GAP (XModAlg) - Chapter 3: Crossed modules

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

[MathJax off]

3 Crossed modules
3.1 Definition and Examples
3.1-1 XModAlgebra
3.1-2 Source
3.1-3 SubXModAlgebra
3.1-4 PreXModAlgebraByBoundaryAndAction
3.2 (Pre-)Crossed Module Morphisms
3.2-1 XModAlgebraMorphism
3.2-2 Kernel
3.2-3 Image
3.2-4 SourceHom

### 3 Crossed modules

In this chapter we will present the notion of crossed modules of commutative algebras and their implementation in this package.

#### 3.1 Definition and Examples

Let k be a fixed commutative ring with \(1 \neq 0\). From now on, all k-algebras will be associative and commutative.

A crossed module is a k-algebra morphism \(\mathcal{X}:=(\partial:S\rightarrow R)\) with an action of \(R\) on \(S\) satisfying

\[ {\bf XModAlg\ 1} ~:~ \partial(r \cdot s) = r(\partial s), \qquad {\bf XModAlg\ 2} ~:~ (\partial s) \cdot s^{\prime} = ss^{\prime}, \]

for all \(s,s^{\prime }\in S, \ r\in R\). The morphism \(\partial\) is called the boundary map of \(\mathcal{X}\)

In this definition we used the left action notation. In the category of commutative algebras the right and the left actions coincide.

We can produce crossed modules by using the following methods.

##### 3.1-1 XModAlgebra

`‣ XModAlgebra`( args ) | ( function )

`‣ XModAlgebraByBoundaryAndAction`( bdy, act ) | ( operation )

`‣ XModAlgebraByIdeal`( A, I ) | ( operation )

`‣ XModAlgebraByModule`( M, R ) | ( operation )

`‣ XModAlgebraByCentralExtension`( f ) | ( operation )

`‣ XModAlgebraByMultipleAlgebra`( A ) | ( operation )

Here are the standard constructions which these operations implement:

- Let \(A\) be an algebra and \(I\) an ideal of \(A\). Then \(\mathcal{X} = (inc:I\rightarrow A)\) is a crossed module with the multiplication action of \(A\) on \(I\). Conversely, given a crossed module \(\mathcal{X} = (\partial : S \rightarrow R)\), it is the case that \({\partial(S)}\) is an ideal of \(R\).

- Let \(M\) be a \(R\)-module. Then \(\mathcal{X} = (0:M\rightarrow R)\) is a crossed module. Conversely, given a crossed module \(\mathcal{X} = (\partial :M\rightarrow R)\), one can get that \(\ker\partial\) is a \((R/\partial M)\)-module.

- Let \(\partial : S\rightarrow R\) be a surjective algebra homomorphism. Define the action of \(R\) on \(S\) by \(r\cdot s = \widetilde{r}s\) where \(\widetilde{r} \in \partial^{-1}(r)\). Then \(\mathcal{X}=(\partial : S\rightarrow R)\) is a crossed module with the defined action.

- Let \(S\) be a k-algebra such that \(Ann(S)=0\) or \(S^{2} = S\). Then \(\partial : S\rightarrow M(S)\) is a crossed module, where \(M(S)\) is the algebra of multipliers of \(S\) and \(\partial \) is the canonical homomorphism, [AE03].

##### 3.1-2 Source

`‣ Source`( X0 ) | ( attribute )

`‣ Range`( X0 ) | ( attribute )

`‣ Boundary`( X0 ) | ( attribute )

`‣ XModAlgebraAction`( X0 ) | ( attribute )

These four attributes are used in the construction of a crossed module \(\mathcal{X}\) where:

- `Source(X)` and `Range(X)` are the source and the range of the boundary map respectively;

- `Boundary(X)` is the boundary map of the crossed module \(\mathcal{X}\);

- `XModAlgebraAction(X)` is the action used in the crossed module.

The following standard GAP operations have special XModAlg implementations:

- `Display(X)` is used to list the components of \(\mathcal{X}\);

- `Size(X)` is used for calculating the order of the crossed module \(\mathcal{X}\);

- `Name(X)` is used for giving a name to the crossed module \(\mathcal{X}\) by associating the names of source and range algebras.

In the following example, we construct a crossed module by using the algebra \(GF_{5}D_{4}\) and its augmentation ideal. We also show usage of the attributes listed above.

    gap> Ak4 := GroupRing( GF(5), DihedralGroup(4) );
    <algebra-with-one over GF(5), with 2 generators>
    gap> Size( Ak4 );
    625
    gap> SetName( Ak4, "GF5[k4]" );
    gap> IAk4 := AugmentationIdeal( Ak4 );
    <two-sided ideal in GF5[k4], (2 generators)>
    gap> Size( IAk4 );
    125
    gap> SetName( IAk4, "I(GF5[k4])" );
    gap> XIAk4 := XModAlgebraByIdeal( Ak4, IAk4 );
    [ I(GF5[k4]) -> GF5[k4] ]
    gap> Display( XIAk4 );

    Crossed module [I(GF5[k4])->GF5[k4]] :-
    : Source algebra I(GF5[k4]) has generators:
      [ (Z(5)^2)*<identity> of ...+(Z(5)^0)*f1, (Z(5)^2)*<identity> of ...+(Z(5)^
        0)*f2 ]
    : Range algebra GF5[k4] has generators:
      [ (Z(5)^0)*<identity> of ..., (Z(5)^0)*f1, (Z(5)^0)*f2 ]
    : Boundary homomorphism maps source generators to:
      [ (Z(5)^2)*<identity> of ...+(Z(5)^0)*f1, (Z(5)^2)*<identity> of ...+(Z(5)^
        0)*f2 ]

    gap> Size( XIAk4 );
    [ 125, 625 ]
    gap> f := Boundary( XIAk4 );
    MappingByFunction( I(GF5[k4]), GF5[k4], function( i ) ... end )
    gap> Print( RepresentationsOfObject(XIAk4), "\n" );
    [ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModAlgebraObj" ]
    gap> props := [ "CanEasilyCompareElements", "CanEasilySortElements",
    >  "IsDuplicateFree", "IsLeftActedOnByDivisionRing", "IsAdditivelyCommutative",
    >  "IsLDistributive", "IsRDistributive", "IsPreXModDomain", "Is2dAlgebraObject",
    >  "IsPreXModAlgebra", "IsXModAlgebra" ];;
    gap> known := KnownPropertiesOfObject( XIAk4 );;
    gap> ForAll( props, p -> (p in known) );
    true
    gap> Print( KnownAttributesOfObject(XIAk4), "\n" );
    [ "Name", "Size", "Range", "Source", "Boundary", "XModAlgebraAction" ]

##### 3.1-3 SubXModAlgebra

`‣ SubXModAlgebra`( X0 ) | ( operation )

`‣ IsSubXModAlgebra`( X0 ) | ( operation )

A crossed module \(\mathcal{X}^{\prime } = (\partial ^{\prime }:S^{\prime}\rightarrow R^{\prime })\) is a subcrossed module of the crossed module \(\mathcal{X} = (\partial :S\rightarrow R)\) if \(S^{\prime }\leq S\), \(R^{\prime}\leq R\), \(\partial^{\prime } = \partial|_{S^{\prime }}\), and the action of \(S^{\prime }\) on \(R^{\prime }\) is induced by the action of \(R\) on \(S\). The operation `SubXModAlgebra` is used to construct a subcrossed module of a given crossed module.

    gap> e4 := Elements( IAk4 )[4];
    (Z(5)^0)*<identity> of ...+(Z(5)^0)*f1+(Z(5)^2)*f2+(Z(5)^2)*f1*f2
    gap> Je4 := Ideal( IAk4, [e4] );
    <two-sided ideal in I(GF5[k4]), (1 generators)>
    gap> Size( Je4 );
    5
    gap> SetName( Je4, "<e4>" );
    gap> XJe4 := XModAlgebraByIdeal( Ak4, Je4 );
    [ <e4> -> GF5[k4] ]
    gap> Display( XJe4 );

    Crossed module [<e4>->GF5[k4]] :-
    : Source algebra <e4> has generators:
      [ (Z(5)^0)*<identity> of ...+(Z(5)^0)*f1+(Z(5)^2)*f2+(Z(5)^2)*f1*f2 ]
    : Range algebra GF5[k4] has generators:
      [ (Z(5)^0)*<identity> of ..., (Z(5)^0)*f1, (Z(5)^0)*f2 ]
    : Boundary homomorphism maps source generators to:
      [ (Z(5)^0)*<identity> of ...+(Z(5)^0)*f1+(Z(5)^2)*f2+(Z(5)^2)*f1*f2 ]

    gap> IsSubXModAlgebra( XIAk4, XJe4 );
    true

##### 3.1-4 PreXModAlgebraByBoundaryAndAction

`‣ PreXModAlgebraByBoundaryAndAction`( bdy, act ) | ( operation )

`‣ IsPreXModAlgebra`( X0 ) | ( property )

An \(R\)-algebra homomorphism \(\mathcal{X} := (\partial : S \rightarrow R)\) which satisfies the condition \({\bf XModAlg\ 1}\) is called a precrossed module. The details of these implementations can be found in [Oda09].

    gap> G := SmallGroup( 4, 2 );
    <pc group of size 4 with 2 generators>
    gap> F := GaloisField( 4 );
    GF(2^2)
    gap> R := GroupRing( F, G );
    <algebra-with-one over GF(2^2), with 2 generators>
    gap> Size( R );
    256
    gap> SetName( R, "GF(2^2)[k4]" );
    gap> e5 := Elements( R )[5];
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> S := Subalgebra( R, [e5] );
    <algebra over GF(2^2), with 1 generators>
    gap> SetName( S, "<e5>" );
    gap> RS := Cartesian( R, S );;
    gap> SetName( RS, "GF(2^2)[k4] x <e5>" );
    gap> act := AlgebraAction( R, RS, S );;
    gap> bdy := AlgebraHomomorphismByFunction( S, R, r->r );
    MappingByFunction( <e5>, GF(2^2)[k4], function( r ) ... end )
    gap> IsAlgebraAction( act );
    true
    gap> IsAlgebraHomomorphism( bdy );
    true
    gap> XM := PreXModAlgebraByBoundaryAndAction( bdy, act );
    [<e5>->GF(2^2)[k4]]
    gap> IsXModAlgebra( XM );
    true
    gap> Display( XM );

    Crossed module [<e5>->GF(2^2)[k4]] :-
    : Source algebra has generators:
      [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 ]
    : Range algebra GF(2^2)[k4] has generators:
      [ (Z(2)^0)*<identity> of ..., (Z(2)^0)*f1, (Z(2)^0)*f2 ]
    : Boundary homomorphism maps source generators to:
      [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 ]

#### 3.2 (Pre-)Crossed Module Morphisms

Let \(\mathcal{X} = (\partial:S\rightarrow R)\), \(\mathcal{X}^{\prime} = (\partial^{\prime }:S^{\prime }\rightarrow R^{\prime })\) be (pre)crossed modules and \(\theta :S\rightarrow S^{\prime }\), \(\varphi : R\rightarrow R^{\prime }\) be algebra homomorphisms. If

\[ \varphi \circ \partial = \partial ^{\prime } \circ \theta, \qquad \theta (r\cdot s)=\varphi(r) \cdot \theta (s), \]

for all \(r\in R\), \(s\in S,\) then the pair \((\theta ,\varphi )\) is called a morphism between \(\mathcal{X}\) and \(\mathcal{X}^{\prime } \)

The conditions can be thought as the commutativity of the following diagrams:

\[ \xymatrix@R=40pt@C=40pt{ S \ar[d]_{\partial} \ar[r]^{\theta} & S^{\prime } \ar[d]^{\partial^{\prime }} \\ R \ar[r]_{\varphi} & R^{\prime } } \ \ \ \ \xymatrix@R=40pt@C=40pt{ R \times S \ar[d] \ar[r]^{ \varphi \times \theta } & R^{\prime } \times S^{\prime } \ar[d] \\ S \ar[r]_{ \theta } & S^{\prime }. } \]

In GAP we define the morphisms between algebraic structures such as cat\(^{1}\)-algebras and crossed modules and they are investigated by the function `Make2dAlgebraMorphism`.

##### 3.2-1 XModAlgebraMorphism

`‣ XModAlgebraMorphism`( arg ) | ( function )

`‣ IdentityMapping`( X0 ) | ( method )

`‣ PreXModAlgebraMorphismByHoms`( f, g ) | ( operation )

`‣ XModAlgebraMorphismByHoms`( f, g ) | ( operation )

`‣ IsPreXModAlgebraMorphism`( f ) | ( property )

`‣ IsXModAlgebraMorphism`( f ) | ( property )

`‣ Source`( m ) | ( attribute )

`‣ Range`( m ) | ( attribute )

`‣ IsTotal`( m ) | ( method )

`‣ IsSingleValued`( m ) | ( method )

`‣ Name`( m ) | ( method )

These operations construct crossed module homomorphisms, which may have the attributes listed.

    gap> Ac4 := GroupRing( GF(2), CyclicGroup(4) );
    <algebra-with-one over GF(2), with 2 generators>
    gap> SetName( Ac4, "GF2[c4]" );
    gap> IAc4 := AugmentationIdeal( Ac4 );
    <two-sided ideal in GF2[c4], (dimension 3)>
    gap> SetName( IAc4, "I(GF2[c4])" );
    gap> XIAc4 := XModAlgebra( Ac4, IAc4 );
    [ I(GF2[c4]) -> GF2[c4] ]
    gap> Bk4 := GroupRing( GF(2), SmallGroup( 4, 2 ) );
    <algebra-with-one over GF(2), with 2 generators>
    gap> SetName( Bk4, "GF2[k4]" );
    gap> IBk4 := AugmentationIdeal( Bk4 );
    <two-sided ideal in GF2[k4], (dimension 3)>
    gap> SetName( IBk4, "I(GF2[k4])" );
    gap> XIBk4 := XModAlgebra( Bk4, IBk4 );
    [ I(GF2[k4]) -> GF2[k4] ]
    gap> IAc4 = IBk4;
    false
    gap> homAB := AllHomsOfAlgebras( Ac4, Bk4 );;
    gap> homIAIB := AllHomsOfAlgebras( IAc4, IBk4 );;
    gap> mor := XModAlgebraMorphism( XIAc4, XIBk4, homIAIB[1], homAB[2] );
    [[I(GF2[c4])->GF2[c4]] => [I(GF2[k4])->GF2[k4]]]
    gap> Display( mor );

    Morphism of crossed modules :-
    : Source = [I(GF2[c4])->GF2[c4]]
    :  Range = [I(GF2[k4])->GF2[k4]]
    : Source Homomorphism maps source generators to:
      [ <zero> of ..., <zero> of ..., <zero> of ... ]
    : Range Homomorphism maps range generators to:
      [ (Z(2)^0)*<identity> of ..., (Z(2)^0)*<identity> of ...,
      (Z(2)^0)*<identity> of ... ]

    gap> IsTotal( mor );
    true
    gap> IsSingleValued( mor );
    true

##### 3.2-2 Kernel

`‣ Kernel`( X0 ) | ( method )

Let \((\theta,\varphi) : \mathcal{X} = (\partial : S \rightarrow R) \rightarrow \mathcal{X}^{\prime} = (\partial^{\prime} : S^{\prime} \rightarrow R^{\prime})\) be a crossed module homomorphism. Then the crossed module

\[ \ker(\theta,\varphi) = (\partial| : \ker\theta \rightarrow \ker\varphi ) \]

is called the kernel of \((\theta,\varphi)\). Also, \(\ker(\theta ,\varphi )\) is an ideal of \(\mathcal{X}\). An example is given below.

    gap> Xmor := Kernel( mor );
    [ <algebra of dimension 3 over GF(2)> -> <algebra of dimension 3 over GF(2)> ]
    gap> IsXModAlgebra( Xmor );
    true
    gap> Size( Xmor );
    [ 8, 8 ]
    gap> IsSubXModAlgebra( XIAc4, Xmor );
    true

##### 3.2-3 Image

`‣ Image`( X0 ) | ( operation )

Let \((\theta,\varphi) : \mathcal{X} = (\partial : S \rightarrow R) \rightarrow \mathcal{X}^{\prime} = (\partial^{\prime} : S^{\prime} \rightarrow R^{\prime})\) be a crossed module homomorphism. Then the crossed module

\[ \Im(\theta,\varphi) = (\partial^{\prime}| : \Im\theta \rightarrow \Im\varphi) \]

is called the image of \((\theta,\varphi)\). Further, \(\Im(\theta,\varphi)\) is a subcrossed module of \((S^{\prime},R^{\prime},\partial^{\prime})\).

In this package, the image of a crossed module homomorphism can be obtained by the command `ImagesSource`. The operation `Sub2dAlgObject` is effectively used for finding the kernel and image crossed modules induced from a given crossed module homomorphism.

##### 3.2-4 SourceHom

`‣ SourceHom`( m ) | ( attribute )

`‣ RangeHom`( m ) | ( attribute )

`‣ IsInjective`( m ) | ( property )

`‣ IsSurjective`( m ) | ( property )

`‣ IsBijjective`( m ) | ( property )

Let \((\theta,\varphi)\) be a homomorphism of crossed modules. If the homomorphisms \(\theta\) and \(\varphi\) are injective (surjective) then \((\theta,\varphi)\) is injective (surjective).

The attributes `SourceHom` and `RangeHom` store the two algebra homomorphisms \(\theta\) and \(\varphi\).

    gap> ic4 := One( Ac4 );;
    gap> theta := SourceHom( mor );;
    gap> e1 := ic4*c4.1 + ic4*c4.2;
    (Z(2)^0)*f1+(Z(2)^0)*f2
    gap> ImageElm( theta, e1 );
    <zero> of ...
    gap> phi := RangeHom( mor );;
    gap> e2 := ic4*c4.1;
    (Z(2)^0)*f1
    gap> ImageElm( phi, e2 );
    (Z(2)^0)*<identity> of ...
    gap> IsInjective( mor );
    false
    gap> IsSurjective( mor );
    false

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

generated by GAPDoc2HTML