In this chapter we will present the notion of crossed modules of commutative algebras and their implementation in this package.
A crossed module is a k-algebra morphism mathcalX:=(∂:S→ R) with a left 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^' ∈ S, r∈ R. The morphism ∂ is called the boundary map of mathcalX
Note that, although in this definition we have used a left action, in the category of commutative algebras left and right actions coincide.
‣ XModAlgebra( args ) | ( function ) |
This global function calls one of the following six operations, depending on the arguments supplied.
‣ XModAlgebraByIdeal( A, I ) | ( operation ) |
Let A be an algebra and I an ideal of A. Then mathcalX = (inc:I→ A) is a crossed module whose action is left multiplication of A on I. Conversely, given a crossed module mathcalX = (∂ : S → R), it is the case that ∂(S) is an ideal of R.
gap> F := GF(5);; gap> one := One(F);; gap> two := Z(5);; gap> z := Zero( F );; gap> l := [ [one,z,z], [z,one,z], [z,z,one] ];; gap> m := [ [z,one,two^3], [z,z,one], [z,z,z] ];; gap> n := [ [z,z,one], [z,z,z], [z,z,z] ];; gap> A := Algebra( F, [l,m] );; gap> SetName( A, "A(l,m)" ); gap> B := Subalgebra( A, [m] );; gap> SetName( B, "A(m)" ); gap> IsIdeal( A, B ); true gap> act := AlgebraActionByMultipliers( A, B );; gap> XAB := XModAlgebraByIdeal( A, B ); [ A(m) -> A(l,m) ] gap> SetName( XAB, "XAB" );
‣ AugmentationXMod( A ) | ( attribute ) |
As a special case of the previous operation, the attribute AugmentationXMod(A) of a group algebra A is the XModAlgebraByIdeal formed using the AugmentationIdeal of the group algebra.
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> Size2d( XIAk4 ); [ 125, 625 ]
‣ XModAlgebraByMultiplierAlgebra( A ) | ( operation ) |
When A is an algebra with multiplier algebra M, then the map A -> M, ~ a ↦ μ_a is the boundary of a crossed module in which the action is the identity map on M.
gap> XA := XModAlgebraByMultiplierAlgebra( A ); [ A(l,m) -> <algebra of dimension 3 over GF(5)> ] gap> XModAlgebraAction( XA ); IdentityMapping( <algebra of dimension 3 over GF(5)> )
‣ XModAlgebraBySurjection( f ) | ( operation ) |
Let ∂ : S→ R be a surjective algebra homomorphism whose kernel lise in the annihilator of S. Define the action of R on S by r⋅ s = widetilders where widetilder ∈ ∂^-1(r), as described in section AlgebraActionBySurjection (2.2-2) Then mathcalX=(∂ : S→ R) is a crossed module with the defined action.
Continuing with the example in that section,
gap> X3 := XModAlgebraBySurjection( nat3 );; gap> Display( X3 ); Crossed module [..->..] :- : Source algebra has generators: [ [ [ 0, 1, 2, 3 ], [ 0, 0, 1, 2 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 0 ] ] ] : Range algebra has generators: [ v.1, v.2 ] : Boundary homomorphism maps source generators to: [ v.1 ]
‣ XModAlgebraByBoundaryAndAction( bdy, act ) | ( operation ) |
‣ PreXModAlgebraByBoundaryAndAction( bdy, act ) | ( operation ) |
‣ IsPreXModAlgebra( X0 ) | ( property ) |
An R-algebra homomorphism mathcalX := (∂ : S → R) which satisfies the condition 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] );; 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 ]
‣ XModAlgebraByModule( M, R ) | ( operation ) |
Let M be a R-module. Then mathcalX = (0:M→ R) is a crossed module. Conversely, given a crossed module mathcalX = (∂ :M→ R), one can get that ker∂ is a (R/∂ M)-module.
gap> ## example needed
‣ Source( X0 ) | ( attribute ) |
‣ Range( X0 ) | ( attribute ) |
‣ Boundary( X0 ) | ( attribute ) |
‣ XModAlgebraAction( X0 ) | ( attribute ) |
These four attributes are used in the construction of a crossed module mathcalX 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 mathcalX;
XModAlgebraAction(X) is the action used in the crossed module. This is an algebra homomorphism from Range(X) to an algebra of endomorphisms of Source(X).
The following standard GAP operations have special XModAlg implementations:
Display(X) is used to list the components of mathcalX;
Size2d(X) is used for calculating the order of the crossed module mathcalX;
Name(X) is used for giving a name to the crossed module mathcalX by associating the names of source and range algebras.
In the following example, we construct a crossed module by using the algebra GF_5D_4 and its augmentation ideal. We also show usage of the attributes listed above.
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", "Range", "Source", "Boundary", "Size2d", "XModAlgebraAction" ]
‣ SubXModAlgebra( X0 ) | ( operation ) |
‣ IsSubXModAlgebra( X0 ) | ( operation ) |
A crossed module mathcalX^' = (∂ ^' :S^'→ R^' ) is a subcrossed module of the crossed module mathcalX = (∂ :S→ R) if S^' ≤ S, R^'≤ R, ∂^' = ∂|_S^' }, and the action of S^' on R^' 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] );; 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
Let mathcalX = (∂:S→ R), mathcalX^' = (∂^' :S^' → R^' ) be (pre)crossed modules and θ :S→ S^', φ : R→ R^' be algebra homomorphisms. If
\varphi \circ \partial = \partial ^{\prime } \circ \theta, \qquad \theta (r\cdot s)=\varphi(r) \cdot \theta (s),
for all r∈ R, s∈ S, then the pair (θ ,φ ) is called a morphism between mathcalX and mathcalX^'
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.
‣ 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> c4 := CyclicGroup( 4 );; gap> Ac4 := GroupRing( GF(2), c4 ); <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> homIAIB := AllHomsOfAlgebras( IAc4, IBk4 );; gap> theta := homIAIB[3];; gap> homAB := AllHomsOfAlgebras( Ac4, Bk4 );; gap> phi := homAB[7];; gap> mor := XModAlgebraMorphism( XIAc4, XIBk4, theta, phi ); [[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 ..., (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^ 0)*f1*f2, (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^ 0)*f1*f2 ] : Range Homomorphism maps range generators to: [ (Z(2)^0)*<identity> of ..., (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2, (Z(2)^0)*<identity> of ... ] gap> IsTotal( mor ); true gap> IsSingleValued( mor ); true
‣ Kernel( X0 ) | ( method ) |
Let (θ,φ) : mathcalX = (∂ : S → R) → mathcalX^' = (∂^' : S^' → R^') be a crossed module homomorphism. Then the crossed module
\ker(\theta,\varphi) = (\partial| : \ker\theta \rightarrow \ker\varphi )
is called the kernel of (θ,φ). Also, ker(θ ,φ ) is an ideal of mathcalX. An example is given below.
gap> Xmor := Kernel( mor ); [ <algebra of dimension 2 over GF(2)> -> <algebra of dimension 2 over GF(2)> ] gap> IsXModAlgebra( Xmor ); true gap> Size2d( Xmor ); [ 4, 4 ] gap> IsSubXModAlgebra( XIAc4, Xmor ); true
‣ Image( X0 ) | ( operation ) |
Let (θ,φ) : mathcalX = (∂ : S → R) → mathcalX^' = (∂^' : S^' → R^') be a crossed module homomorphism. Then the crossed module
\Im(\theta,\varphi) = (\partial^{\prime}| : \Im\theta \rightarrow \Im\varphi)
is called the image of (θ,φ). Further, ℑ(θ,φ) is a subcrossed module of (S^',R^',∂^').
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.
‣ SourceHom( m ) | ( attribute ) |
‣ RangeHom( m ) | ( attribute ) |
‣ IsInjective( m ) | ( property ) |
‣ IsSurjective( m ) | ( property ) |
‣ IsBijjective( m ) | ( property ) |
Let (θ,φ) be a homomorphism of crossed modules. If the homomorphisms θ and φ are injective (surjective) then (θ,φ) is injective (surjective).
The attributes SourceHom and RangeHom store the two algebra homomorphisms θ and φ.
gap> ic4 := One( Ac4 );; gap> e1 := ic4*c4.1 + ic4*c4.2; (Z(2)^0)*f1+(Z(2)^0)*f2 gap> ImageElm( theta, e1 ); (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 gap> e2 := ic4*c4.1; (Z(2)^0)*f1 gap> ImageElm( phi, e2 ); (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 gap> IsInjective( mor ); false gap> IsSurjective( mor ); false gap> immor := ImagesSource2DimensionalMapping( mor );; gap> Display( immor ); Crossed module [..->..] :- : Source algebra has generators: [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 ] : Range algebra has generators: [ (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2, (Z(2)^0)*<identity> of ... ] : Boundary homomorphism maps source generators to: [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2 ]
generated by GAPDoc2HTML