Goto Chapter: Top 1 2 3 Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

3 Cat1-algebras
 3.1 Definitions and examples
 3.2 Cat^1-algebra morphisms
 3.3 Equivalent Categories

3 Cat1-algebras

3.1 Definitions and examples

Algebraic structures which are equivalent to crossed modules of algebras include :

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.

3.1-1 Cat1
‣ 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,

3.1-2 Source
‣ 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) ]

3.1-3 Cat1AlgebraSelect
‣ 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:

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) ]

3.1-4 SubCat1Algebra
‣ 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) ]

3.2 Cat^1-algebra morphisms

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.

3.2-1 Cat1AlgebraMorphism
‣ 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].

3.2-2 Source
‣ 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


3.3 Equivalent Categories

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.

3.3-1 PreCat1ByPreXMod
‣ 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.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 Bib Ind

generated by GAPDoc2HTML