[MathJax off]
3 Cat1-algebras
3.1 Definitions and examples
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 a cat\(^{1}\)-group was defined as an algebraic model of \(2\)-types by Loday in [Lod82]. Then Ellis defined cat\(^{1}\)-algebras in [Ell88].
Let \(A\) and \(R\) be \(k\)-algebras, let \(t,h:A\rightarrow R\) be surjections, and let \(e:R\rightarrow 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 \(\mathcal{C} := (e;t,h : A \rightarrow R)\) is called a cat\(^{1}\)-algebra. A system which satisfies the condition \(\mathbf{Cat1Alg1}\) is called a precat\(^{1}\)-algebra. The homomorphisms \(t,h\) and \(e\) are called the tail map, head map and range embedding homomorphisms, respectively.
3.1-1 Cat1Algebra
‣ Cat1Algebra( args ) | ( function ) |
‣ PreCat1AlgebraByEndomorphisms( t, h ) | ( operation ) |
‣ PreCat1AlgebraByTailHeadEmbedding( t, h, e ) | ( operation ) |
‣ PreCat1Algebra( args ) | ( function ) |
‣ IsIdentityCat1Algebra( C ) | ( property ) |
‣ IsCat1Algebra( C ) | ( property ) |
‣ IsPreCat1Algebra( C ) | ( property ) |
The operations PreCat1AlgebraByEndomorphisms and PreCat1AlgebraByTailHeadEmbedding are used with particular choices of algebra homomorphisms. The operations listed above are used for the construction of precat\(^{1}\)- and cat\(^{1}\)-algebras. The functions PreCat1Algebra and Cat1Algebra select the appropriate operation to suit the user's input.
3.1-2 Source
‣ Source( C ) | ( attribute ) |
‣ Range( C ) | ( attribute ) |
‣ TailMap( C ) | ( attribute ) |
‣ HeadMap( C ) | ( attribute ) |
‣ RangeEmbedding( C ) | ( attribute ) |
‣ KernelEmbedding( C ) | ( attribute ) |
‣ Boundary( C ) | ( attribute ) |
‣ Size2d( C ) | ( attribute ) |
‣ Dimension( C ) | ( attribute ) |
These are the nine main attributes of a pre-cat\(^{1}\)-algebra.
In the example we use homomorphisms between A2c6 and I2c6 constructed in section 2.6.
gap> t4 := homAR[8];
[ (Z(2)^0)*(1,6,5,4,3,2) ] -> [ (Z(2)^0)*(7,9,8) ]
gap> e4 := homRA[8];
[ (Z(2)^0)*(7,8,9) ] -> [ (Z(2)^0)*(1,5,3)(2,6,4) ]
gap> C4 := PreCat1AlgebraByTailHeadEmbedding( t4, t4, e4 );
[AlgebraWithOne( GF(2), [ (Z(2)^0)*(1,2,3,4,5,6)
] ) -> AlgebraWithOne( GF(2), [ (Z(2)^0)*(7,8,9) ] )]
gap> IsCat1Algebra( C4 );
true
gap> Size2d( C4 );
[ 64, 8 ]
gap> Dimension( C4 );
[ 6, 3 ]
gap> Display( C4 );
Cat1-algebra [..=>..] :-
: 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)*(7,8,9) ]
: tail homomorphism maps source generators to:
[ (Z(2)^0)*(), (Z(2)^0)*(7,8,9) ]
: head homomorphism maps source generators to:
[ (Z(2)^0)*(), (Z(2)^0)*(7,8,9) ]
: range embedding maps range generators to:
[ (Z(2)^0)*(), (Z(2)^0)*(1,5,3)(2,6,4) ]
: kernel has generators:
[ (Z(2)^0)*()+(Z(2)^0)*(1,4)(2,5)(3,6), (Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*
(1,5,3)(2,6,4), (Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,6,5,4,3,2) ]
: 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)*(1,4)(2,5)(3,6), (Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*
(1,5,3)(2,6,4), (Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,6,5,4,3,2) ]
3.1-3 Cat1AlgebraSelect
‣ Cat1AlgebraSelect( GFnum, gpsize, gpnum, num ) | ( operation ) |
The Cat1Algebra (3.1-1) function may also be used to select certain cat\(^{1}\)-group-algebras from the data file included with this package. Data for these cat\(^{1}\)-structures on commutative group algebras is stored in a list in file cat1algdata.g. This data is read into the list CAT1ALG_LIST only when this function is called.
The function Cat1AlgebraSelect may be used in four ways:
Cat1AlgebraSelect( n ) returns the list of possible group orders when Galois field \(GF(n)\), with \(n \in [2,3,4,5,7]\), is used to form cat\(^1\)-group-algebra structures.
Cat1AlgebraSelect( n, m ) returns the list of available group numbers of size \(m\) with which to form cat\(^1\)-group-algebra structures with given Galois field \(GF(n)\).
Cat1AlgebraSelect( n, m, k ) prints the list of possible cat\(^{1}\)-group-algebra structures with given Galois field \(GF(n)\) and group number \(k\) of size \(m\). The number of these structures is returned.
Cat1AlgebraSelect( n, m, k, j ) (or simply Cat1Algebra( n, m, k, j )) returns the \(j\)-th cat\(^{1}\)-group-algebra structure with these other parameters.
Now, we give examples of the use of this function.
gap> C := Cat1AlgebraSelect( 11 );
|--------------------------------------------------------|
| 11 is invalid value for the Galois Field (GFnum) |
| Available values for GFnum in the data : |
|--------------------------------------------------------|
[ 2, 3, 4, 5, 7 ]
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
fail
gap> C := Cat1AlgebraSelect( 4, 12 );
|--------------------------------------------------------|
| 12 is invalid value for size of group (gpsize) |
| Available values for gpsize with GF(4) in the data: |
|--------------------------------------------------------|
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
gap> C := Cat1AlgebraSelect( 2, 6, 3 );
|--------------------------------------------------------|
| 3 is invalid value for groups of order 6 |
| Available values for gpnum for groups of size 6 : |
|--------------------------------------------------------|
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
[ 1, 2 ]
gap> C := Cat1AlgebraSelect( 2, 6, 2 );
There are 4 cat1-structures for the group 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( GFnum, gpsize, gpnum, num );
Algebra has generators [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3)(4,5) ]
4
The algebra GF(n)_gp has a list of \(n^{|gp|}\) elements. The [2, 10] in the second structure above indicates that the tail map, and also the head map, of the cat\(^1\)-algebra maps the two generators of c6 to the second and tenth elements of this algebra respectively.
gap> C0 := 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> Size2d( C0 );
[ 4096, 1024 ]
gap> Dimension( C0 );
[ 6, 5 ]
gap> Display( C0 );
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) ]
3.1-4 SubCat1Algebra
‣ SubCat1Algebra( alg, src, rng ) | ( operation ) |
‣ SubPreCat1Algebra( alg, src, rng ) | ( operation ) |
‣ IsSubCat1Algebra( alg, sub ) | ( operation ) |
‣ IsSubPreCat1Algebra( alg, sub ) | ( operation ) |
Let \(\mathcal{C} = (e;t,h:A\rightarrow R)\) be a cat\(^{1}\)-algebra, and let \(A^{\prime}\), \(R^{\prime}\) 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 \(\mathbf{Cat1Alg1}\) and \(\mathbf{Cat1Alg2}\) conditions, then the system \(\mathcal{C}^{\prime } = (e^{\prime};t^{\prime},h^{\prime} : A^{\prime} \rightarrow R^{\prime})\) is called a subcat\(^{1}\)-algebra of \(\mathcal{C} = (e;t,h:A\rightarrow R)\).
If the morphisms satisfy only the \(\mathbf{Cat1Alg1}\) condition then \(\mathcal{C}^{\prime }\) is called a sub-precat\(^{1}\)-algebra of \(\mathcal{C}\).
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) ]
3.2 Cat\(^{1}-\)algebra morphisms
Let \(\mathcal{C} = (e;t,h:A\rightarrow R)\), \(\mathcal{C}^{\prime } = (e^{\prime}; t^{\prime }, h^{\prime } : A^{\prime} \rightarrow R^{\prime})\) be cat\(^{1}\)-algebras, and let \(\phi : A\rightarrow A^{\prime}\) and \(\varphi : R \rightarrow R^{\prime}\) 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^{\prime} \circ \phi = \varphi \circ t\), \(h^{\prime} \circ \phi = \varphi \circ h\) and \(e^{\prime } \circ \varphi = \phi \circ e\)), then the pair \((\phi ,\varphi )\) is called a cat\(^{1}\)-algebra morphism.
3.2-1 Cat1AlgebraMorphism
‣ Cat1AlgebraMorphism( arg ) | ( function ) |
‣ PreCat1AlgebraMorphism( arg ) | ( function ) |
‣ IdentityMapping( C ) | ( method ) |
‣ PreCat1AlgebraMorphismByHoms( src, rng, srchom, rnghom ) | ( operation ) |
‣ Cat1AlgebraMorphismByHoms( src, rng, srchom, rnghom ) | ( operation ) |
‣ IsPreCat1AlgebraMorphism( mor ) | ( property ) |
‣ IsCat1AlgebraMorphism( mor ) | ( property ) |
These operations are used for constructing cat\(^{1}\)-algebra morphisms. Details of the implementations can be found in [Oda09].
3.2-2 Source
‣ Source( m ) | ( attribute ) |
‣ Range( m ) | ( attribute ) |
‣ IsSingleValued( m ) | ( method ) |
‣ 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> IsSurjective( m );
false
gap> IsInjective( m );
true
gap> IsBijective( m );
false
3.2-3 ImagesSource2DimensionalMapping
‣ ImagesSource2DimensionalMapping( m ) | ( operation ) |
When \((\theta,\varphi)\) is a homomorphism of cat1-algebras (or crossed modules) this operation returns the image crossed module.
gap> imm := ImagesSource2DimensionalMapping( m );;
gap> Display( imm );
Cat1-algebra [..=>..] :-
: source algebra has generators:
[ (Z(2)^0)*(), (Z(2)^0)*() ]
: range algebra has generators:
[ (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)*() ]
: the kernel is trivial.