GAP (XModAlg) - Chapter 3: Cat1-algebras

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

[MathJax on]

3 Cat1-algebras
3.1 Definitions and examples
3.1-1 Cat1
3.1-2 Source
3.1-3 Cat1AlgebraSelect
3.1-4 SubCat1Algebra
3.2 Cat^1-algebra morphisms
3.2-1 Cat1AlgebraMorphism
3.2-2 Source
3.3 Equivalent Categories
3.3-1 PreCat1ByPreXMod

### 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 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:

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

##### 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