Algebraic structures which are equivalent to crossed modules of algebras include :
cat^1-algebras. (Ellis, [Ell88]);
simplicial algebras with Moore complex of length 1 (Z. Arvasi and T.Porter, [AP96]);
algebra-algebroids (Gaffar Musa's Ph.D. thesis, [Mos86]).
In this section we describe an implementation of cat^1-algebras and their morphisms.
The notion of cat^1-groups was defined as an algebraic model of 2-types by Loday in [Lod82]. Then Ellis defined the cat^1-algebras in [Ell88].
Let A and R be k-algebras, let t,h:A→ R be surjections, and let e:R→ A be an inclusion.
\xymatrix@R=50pt@C=50pt{ A \ar@{->}@<-1.5pt>[d]_{t} \ar@{->}@<1.5pt>[d]^{h} \\ R \ar@/^1.5pc/[u]^{e} }
If the conditions,
\mathbf{Cat1Alg1:} \quad te = id_{R} = he, \qquad \mathbf{Cat1Alg2:} \quad (\ker t)(\ker h) = \{0_{A}\}
are satisfied, then the algebraic system mathcalC := (e;t,h : A → R) is called a cat^1-algebra. The system which satisfy the condition mathbfCat1Alg1 is called a precat^1-algebra. The homomorphisms t,h and e are called the tail, head and embedding homomorphisms, respectively.
‣ Cat1( args ) | ( function ) |
‣ PreCat1ByTailHeadEmbedding( t, h, e ) | ( operation ) |
‣ PreCat1ByEndomorphisms( t, h ) | ( operation ) |
‣ PreCat1AlgebraObj( C ) | ( operation ) |
‣ PreCat1Algebra( C ) | ( operation ) |
‣ IsIdentityCat1Algebra( C ) | ( property ) |
‣ IsCat1Algebra( C ) | ( property ) |
‣ IsPreCat1Algebra( C ) | ( property ) |
The operations listed above are used for construction of precat^1 and cat^1-algebra structures. The function Cat1Algebra selects the operation from the above implementations up to user's input. The operation PreCat1AlgebraObj is used for preserving the implementations,
‣ Source( C ) | ( attribute ) |
‣ Range( C ) | ( attribute ) |
‣ Tail( C ) | ( attribute ) |
‣ Head( C ) | ( attribute ) |
‣ Embedding( C ) | ( attribute ) |
‣ Kernel( C ) | ( attribute ) |
‣ Boundary( C ) | ( attribute ) |
These are the seven main attributes of a pre-cat^1-algebra.
gap> A := GroupRing(GF(2),Group((1,2,3)(4,5))); <algebra-with-one over GF(2), with 1 generators> gap> R := GroupRing(GF(2),Group((1,2,3))); <algebra-with-one over GF(2), with 1 generators> gap> f := AllHomsOfAlgebras(A,R); [ [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ <zero> of ... ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*() ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3) ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*(1,2,3) ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,3,2)(4,5) ] -> [ (Z(2)^0)*(1,3,2) ] ] gap> g := AllHomsOfAlgebras(R,A); [ [ (Z(2)^0)*(1,2,3) ] -> [ <zero> of ... ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*() ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3) ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*()+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*(1,2,3) ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2) ], [ (Z(2)^0)*(1,2,3) ] -> [ (Z(2)^0)*(1,3,2) ] ] gap> C4 := PreCat1ByTailHeadEmbedding(f[6],f[6],g[8]); [AlgebraWithOne( GF(2), [ (Z(2)^0)*(1,2,3)(4,5) ] ) -> AlgebraWithOne( GF(2), [ (Z(2)^0)*(1,2,3) ] )] gap> IsCat1Algebra(C4); true gap> Size(C4); [ 64, 8 ] gap> Display(C4); Cat1-algebra [..=>..] :- : source algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3)(4,5) ] : range algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3) ] : tail homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*(1,3,2) ] : head homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*(1,3,2) ] : range embedding maps range generators to: [ (Z(2)^0)*(), (Z(2)^0)*(1,3,2) ] : kernel has generators: [ (Z(2)^0)*()+(Z(2)^0)*(4,5), (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,2,3)(4,5), (Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3,2)(4,5) ] : boundary homomorphism maps generators of kernel to: [ <zero> of ..., <zero> of ..., <zero> of ... ] : kernel embedding maps generators of kernel to: [ (Z(2)^0)*()+(Z(2)^0)*(4,5), (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,2,3)(4,5), (Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3,2)(4,5) ]
‣ Cat1AlgebraSelect( gf, gpsize, gpnum, num ) | ( operation ) |
The Cat1Algebra function may also be used to select a cat^1-algebra from a data file. All cat^1-structures on commutative algebras are stored in a list in file cat1algdata.g. The data is read into the list CAT1ALG_LIST only when this function is called. The function Cat1AlgebraSelect may be used in four ways:
Cat1AlgebraSelect( gf ) returns the list of possible size of Galois field or the list of possible size of groups with given Galois field.
Cat1AlgebraSelect( gf, gpsize ) returns the list of possible size of group with given Galois fields or the list of possible number of groups with given Galois field and size of group.
Cat1AlgebraSelect( gf, gpsize, gpnum ) returns the list of possible number of group with given Galois field and size of group or the list of possible cat^1-structures with given Galois field and group.
Cat1AlgebraSelect( gf, gpsize, gpnum, num ) (or just Cat1Algebra( gf, gpsize, gpnum, num )) returns the chosen cat^1-algebra.
Now, we will give an example for the usage of this function.
gap> C := Cat1AlgebraSelect(11); |--------------------------------------------------------| | 11 is invalid number for Galois Field (gf) | | Possible numbers for the gf in the Data : | |--------------------------------------------------------| [ 2, 3, 4, 5, 7 ] Usage: Cat1Algebra( gf, gpsize, gpnum, num ); fail gap> C := Cat1AlgebraSelect(4,12); |--------------------------------------------------------| | 12 is invalid number for size of group (gpsize) | | Possible numbers for the gpsize for GF(4) in the Data: | |--------------------------------------------------------| [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] Usage: Cat1Algebra( gf, gpsize, gpnum, num ); fail gap> C := Cat1AlgebraSelect(2,6,3); |--------------------------------------------------------| | 3 is invalid number for group of order 6 | | Possible numbers for the gpnum in the Data : | |--------------------------------------------------------| [ 1, 2 ] Usage: Cat1Algebra( gf, gpsize, gpnum, num ); fail gap> C := Cat1AlgebraSelect(2,6,2); There are 4 cat1-structures for the algebra GF(2)_c6. Range Alg Tail Head |--------------------------------------------------------| | GF(2)_c6 identity map identity map | | ----- [ 2, 10 ] [ 2, 10 ] | | ----- [ 2, 14 ] [ 2, 14 ] | | ----- [ 2, 50 ] [ 2, 50 ] | |--------------------------------------------------------| Usage: Cat1Algebra( gf, gpsize, gpnum, num ); Algebra has generators [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3)(4,5) ] 4 gap> C2 := Cat1AlgebraSelect( 4, 6, 2, 2 ); [GF(2^2)_c6 -> Algebra( GF(2^2), [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)(3,6)+( Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] )] gap> Size( C2 ); [ 4096, 1024 ] gap> Display( C2 ); Cat1-algebra [GF(2^2)_c6=>..] :- : source algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3,4,5,6) ] : range algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5) (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] : tail homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5) (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] : head homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5) (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] : range embedding maps range generators to: [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5) (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] : kernel has generators: [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4) (2,5)(3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] : boundary homomorphism maps generators of kernel to: [ <zero> of ... ] : kernel embedding maps generators of kernel to: [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4) (2,5)(3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
‣ SubCat1Algebra( arg ) | ( operation ) |
‣ SubPreCat1Algebra( arg ) | ( operation ) |
‣ IsSubCat1Algebra( arg ) | ( property ) |
‣ IsSubPreCat1Algebra( arg ) | ( property ) |
Let mathcalC = (e;t,h:A→ R) be a cat^1-algebra, and let A^', R^' be subalgebras of A and R respectively. If the restriction morphisms
t^{\prime} = t|_{A^{\prime}} : A^{\prime}\rightarrow R^{\prime}, \qquad h^{\prime} = h|_{A^{\prime}} : A^{\prime}\rightarrow R^{\prime}, \qquad e^{\prime} = e|_{R^{\prime}} : R^{\prime}\rightarrow A^{\prime}
satisfy the mathbfCat1Alg1 and mathbfCat1Alg2 conditions, then the system mathcalC^' = (e^';t^',h^' : A^' → R^') is called a subcat^1-algebra of mathcalC = (e;t,h:A→ R).
If the morphisms satisfy only the mathbfCat1Alg1 condition then mathcalC^' is called a sub-precat^1-algebra of mathcalC.
The operations in this subsection are used for constructing subcat^1-algebras of a given cat^1-algebra.
gap> C3 := Cat1AlgebraSelect( 2, 6, 2, 4 );; gap> A3 := Source( C3 ); GF(2)_c6 gap> B3 := Range( C3 ); GF(2)_c3 gap> eA3 := Elements( A3 );; gap> eB3 := Elements( B3 );; gap> AA3 := Subalgebra( A3, [ eA3[1], eA3[2], eA3[3] ] ); <algebra over GF(2), with 3 generators> gap> [ Size(A3), Size(AA3) ]; [ 64, 4 ] gap> BB3 := Subalgebra( B3, [ eB3[1], eB3[2] ] ); <algebra over GF(2), with 2 generators> gap> [ Size(B3), Size(BB3) ]; [ 8, 2 ] gap> CC3 := SubCat1Algebra( C3, AA3, BB3 ); [Algebra( GF(2), [ <zero> of ..., (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(4,5) ] ) -> Algebra( GF(2), [ <zero> of ..., (Z(2)^0)*() ] )] gap> Display( CC3 ); Cat1-algebra [..=>..] :- : source algebra has generators: [ <zero> of ..., (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(4,5) ] : range algebra has generators: [ <zero> of ..., (Z(2)^0)*() ] : tail homomorphism maps source generators to: [ <zero> of ..., (Z(2)^0)*(), <zero> of ... ] : head homomorphism maps source generators to: [ <zero> of ..., (Z(2)^0)*(), <zero> of ... ] : range embedding maps range generators to: [ <zero> of ..., (Z(2)^0)*() ] : kernel has generators: [ <zero> of ..., (Z(2)^0)*()+(Z(2)^0)*(4,5) ] : boundary homomorphism maps generators of kernel to: [ <zero> of ..., <zero> of ... ] : kernel embedding maps generators of kernel to: [ <zero> of ..., (Z(2)^0)*()+(Z(2)^0)*(4,5) ]
Let mathcalC = (e;t,h:A→ R), mathcalC^' = (e^'; t^' , h^' : A^' → R^') be cat^1-algebras, and let ϕ : A→ A^' and φ : R → R^' be algebra homomorphisms. If the diagram
\xymatrix@R=50pt@C=50pt{ A \ar@{->}@<-1.5pt>[d]_{t} \ar@{->}@<1.5pt>[d]^{h} \ar@{->}[r]^{\phi} & A' \ar@{->}@<-1.5pt>[d]_{t'} \ar@{->}@<1.5pt>[d]^{h'} \\ R \ar@/^1.5pc/[u]^{e} \ar@{->}[r]_{\varphi} & R' \ar@/_1.5pc/[u]_{e'} }
commutes, (i.e t^' ∘ ϕ = φ ∘ t, h^' ∘ ϕ = φ ∘ h and e^' ∘ φ = ϕ ∘ e), then the pair (ϕ ,φ )is called a cat^1-algebra morphism.
‣ Cat1AlgebraMorphism( arg ) | ( operation ) |
‣ IdentityMapping( C ) | ( operation ) |
‣ PreCat1AlgebraMorphismByHoms( f, g ) | ( operation ) |
‣ Cat1AlgebraMorphismByHoms( f, g ) | ( operation ) |
‣ IsPreCat1AlgebraMorphism( C ) | ( property ) |
‣ IsCat1AlgebraMorphism( arg ) | ( property ) |
These operations are used for constructing cat^1-algebra morphisms. Details of the implementations can be found in [Oda09].
‣ Source( m ) | ( attribute ) |
‣ Range( m ) | ( attribute ) |
‣ IsTotal( m ) | ( attribute ) |
‣ IsSingleValued( m ) | ( property ) |
‣ Name( m ) | ( attribute ) |
‣ Boundary( m ) | ( attribute ) |
These are the six main attributes of a cat^1-algebra morphism.
gap> C1:=Cat1Algebra(2,1,1,1); [GF(2)_triv -> GF(2)_triv] gap> Display(C1); Cat1-algebra [GF(2)_triv=>GF(2)_triv] :- : source algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*() ] : range algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*() ] : tail homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : head homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : range embedding maps range generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : the kernel is trivial. gap> C2:=Cat1Algebra(2,2,1,2); [GF(2)_c2 -> GF(2)_triv] gap> Display(C2); Cat1-algebra [GF(2)_c2=>GF(2)_triv] :- : source algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*(1,2) ] : range algebra has generators: [ (Z(2)^0)*(), (Z(2)^0)*() ] : tail homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : head homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : range embedding maps range generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : kernel has generators: [ (Z(2)^0)*()+(Z(2)^0)*(1,2) ] : boundary homomorphism maps generators of kernel to: [ <zero> of ... ] : kernel embedding maps generators of kernel to: [ (Z(2)^0)*()+(Z(2)^0)*(1,2) ] gap> C1=C2; false gap> R1:=Source(C1);; gap> R2:=Source(C2);; gap> S1:=Range(C1);; gap> S2:=Range(C2);; gap> gR1:=GeneratorsOfAlgebra(R1); [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> gR2:=GeneratorsOfAlgebra(R2); [ (Z(2)^0)*(), (Z(2)^0)*(1,2) ] gap> gS1:=GeneratorsOfAlgebra(S1); [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> gS2:=GeneratorsOfAlgebra(S2); [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> im1:=[gR2[1],gR2[1]]; [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> f1:=AlgebraHomomorphismByImages(R1,R2,gR1,im1); [ (Z(2)^0)*(), (Z(2)^0)*() ] -> [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> im2:=[gS2[1],gS2[1]]; [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> f2:=AlgebraHomomorphismByImages(S1,S2,gS1,im2); [ (Z(2)^0)*(), (Z(2)^0)*() ] -> [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> m:=Cat1AlgebraMorphism(C1,C2,f1,f2); [[GF(2)_triv=>GF(2)_triv] => [GF(2)_c2=>GF(2)_triv]] gap> Display(m); Morphism of cat1-algebras :- : Source = [GF(2)_triv=>GF(2)_triv] with generating sets: [ (Z(2)^0)*(), (Z(2)^0)*() ] [ (Z(2)^0)*(), (Z(2)^0)*() ] : Range = [GF(2)_c2=>GF(2)_triv] with generating sets: [ (Z(2)^0)*(), (Z(2)^0)*(1,2) ] [ (Z(2)^0)*(), (Z(2)^0)*() ] : Source Homomorphism maps source generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] : Range Homomorphism maps range generators to: [ (Z(2)^0)*(), (Z(2)^0)*() ] gap> Image2dAlgMapping(m); [GF(3)_c2^3=>GF(3)_c2^3] gap> IsSurjective(m); false gap> IsInjective(m); true gap> IsBijective(m); false
The categories mathbfCat1Alg (cat^1-algebras) and mathbfXModAlg (crossed modules) are naturally equivalent [Ell88]. This equivalence is outlined in what follows. For a given crossed module (∂ : A → R) we can construct the semidirect product R⋉ A thanks to the action of R on A. If we define t,h : R⋉ A → R and e : R → R ⋉ A by
t(r,a) = r, \qquad h(r,a) = r+\partial(a), \qquad e(r) = (r,0),
respectively, then mathcalC = (e;t,h : R ⋉ A → R) is a cat^1-algebra.
Conversely, for a given cat^1-algebra mathcalC=(e;t,h : A → R), the map ∂ : ker t → R is a crossed module, where the action is multiplication action and ∂ is the restriction of h to ker t.
‣ PreCat1ByPreXMod( X0 ) | ( operation ) |
‣ PreXModAlgebraByPreCat1Algebra( C ) | ( operation ) |
‣ Cat1AlgebraByXModAlgebra( X0 ) | ( operation ) |
‣ XModAlgebraByCat1Algebra( C ) | ( operation ) |
These operations are used for constructing a cat^1-algebra from a given crossed module, and conversely.
gap> CXM := Cat1AlgebraByXModAlgebra( XM ); [GF(2^2)[k4] IX <e5> -> GF(2^2)[k4]] gap> X3 := XModAlgebraByCat1Algebra( C3 ); [Algebra( GF(2), [ <zero> of ..., <zero> of ..., <zero> of ... ] )->Algebra( GF(2), [ (Z(2)^0)*()+(Z(2)^0)*(4,5), (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,2,3)(4,5), (Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3,2)(4,5) ] )] gap> Display( X3 ); Crossed module [..->..] :- : Source algebra has generators: [ <zero> of ..., <zero> of ..., <zero> of ... ] : Range algebra has generators: [ (Z(2)^0)*()+(Z(2)^0)*(4,5), (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,2,3)(4,5), (Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3,2)(4,5) ] : Boundary homomorphism maps source generators to: [ <zero> of ..., <zero> of ..., <zero> of ... ]
Since all these operations are linked to the functions Cat1Algebra and XModAlgebra, all of them can be done by using these two functions. We may also use the function Cat1Algebra instead of the operation Cat1AlgebraSelect.
generated by GAPDoc2HTML