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.
When only the first axiom is satisfied, it is a precrossed module which is constructed.
The details of these implementations can be found in [Oda09].
‣ XModAlgebra( args ) | ( function ) |
‣ PreXModAlgebra( args ) | ( function ) |
‣ IsXModAlgebra( X0 ) | ( property ) |
‣ IsPreXModAlgebra( X0 ) | ( property ) |
These two global function call one of the following six operations, depending on the arguments supplied. The two properties listed are assigned as appropriate to the resulting structures.
‣ 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, A );; 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 ]
‣ 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) for a crossed module mathcalX returns a 2-element list, the sizes of the source and range,
Dimension(X) for a crossed module mathcalX returns a 2-element list, the dimensions of the source and range,
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 ); [ (Z(5)^2)*<identity> of ...+(Z(5)^0)*f1, (Z(5)^2)*<identity> of ...\ +(Z(5)^ 0)*f2 ] -> [ (Z(5)^2)*<identity> of ...+(Z(5)^0)*f1, (Z(5)^2)*<identity> of ...+(Z(5)^0)*f2 ] gap> RepresentationsOfObject( XIAk4 ); [ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModAlgebraObj" ] gap> KnownPropertiesOfObject( XIAk4 ); [ "CanEasilyCompareElements", "CanEasilySortElements", "IsDuplicateFree", "IsLeftActedOnByDivisionRing", "IsAdditivelyCommutative", "IsLDistributive", "IsRDistributive", "IsPreXModDomain", "Is2dAlgebraObject", "IsPreXModAlgebra", "IsXModAlgebra" ] gap> KnownAttributesOfObject( XIAk4 ); [ "Name", "LeftActingDomain", "Range", "Source", "Boundary", "Size2d", "XModAlgebraAction" ]
‣ 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 lies 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-3). Then mathcalX=(∂ : S→ R) is a crossed module with the defined action.
Continuing with the example in that section,
gap> X2 := XModAlgebraBySurjection( nat2 );; gap> Display( X2 ); Crossed module [A2->Q2] :- : Source algebra A2 has generators: [ [ [ 0, 1, 2, 3 ], [ 0, 0, 1, 2 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 0 ] ] ] : Range algebra Q2 has generators: [ v.1, v.2 ] : Boundary homomorphism maps source generators to: [ v.1 ]
‣ XModAlgebraByBoundaryAndAction( bdy, act ) | ( operation ) |
‣ PreXModAlgebraByBoundaryAndAction( bdy, act ) | ( operation ) |
When a suitable pair of algebra homomorphisms are available, these operations may be used. The example uses the algebra action created in section 2.3-4.
gap> bdy3 := AlgebraHomomorphismByImages( A3, MB3, [ m3 ], [ mg3 ] ); [ [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ] -> [ [ (1)*(), (1)*(1,2,3), (1)*(1,3,2) ] -> [ (1)*(1,2,3), (1)*(1,3,2), (1)*() ] ] gap> bdy3 := AlgebraHomomorphismByImages( B3, A3, [ g3 ], [ m3 ] ); [ (1)*(1,2,3) ] -> [ [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ] gap> X3 := XModAlgebraByBoundaryAndAction( bdy3, act3 ); [ GR(G) -> A3 ] gap> Display( X3 ); Crossed module [GR(G) -> A3] :- : Source algebra GR(G) has generators: [ (1)*(), (1)*(1,2,3) ] : Range algebra A3 has generators: [ [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ] : Boundary homomorphism maps source generators to: [ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ]
‣ XModAlgebraByModule( alg, leftmod ) | ( operation ) |
Let M be an A-module. Then mathcalX = (0 : A(M) → A) is a crossed module, where A(M) is M considered as an algebra with zero products (see section 2.3-1). The example uses the action act3 constructed in section 2.3-4.
Conversely, given a crossed module mathcalX = (∂ :M→ R), one can get that ker∂ is a (R/∂ M)-module.
gap> X4 := XModAlgebraByModule( A4, M4 ); [ A(M4) -> A4 ] gap> Display( X4 ); Crossed module [A(M4)->A4] :- : Source algebra A(M4) has generators: [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] : Range algebra A4 has generators: [4[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ] : Boundary homomorphism maps source generators to: [ [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ] ]
‣ DirectSumOfXModAlgebras( X1, X2 ) | ( operation ) |
In Sections 2.4-3 and 2.4-5 we constructed direct sums of algebra homomorphisms and algebra actions. So, given two crossed modules of algebras X_1, X_2, we can form the direct sums of their boundaries and actions to form a direct sum X_1 ⊕ X_2 of crossed modules.
gap> DirectSumOfXModAlgebras( X3, X4 ); [ GR(G)(+)A(M4) -> A3(+)A4 ]
‣ SubXModAlgebra( alg, src, rng ) | ( operation ) |
‣ IsSubXModAlgebra( alg, sub ) | ( 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) and mathcalX^' = (∂^' :S^' → R^' ) be (pre)crossed modules and let θ :S→ S^', φ : R→ R^' be algebra homomorphisms. Then if
\varphi \circ \partial = \partial ^{\prime } \circ \theta, \qquad \theta (r\cdot s)=\varphi(r) \cdot \theta (s),
for all r∈ R, s∈ S, 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( Xalg ) | ( method ) |
‣ PreXModAlgebraMorphismByHoms( src, rng, srchom, rnghom ) | ( operation ) |
‣ XModAlgebraMorphismByHoms( src, rng, srchom, rnghom ) | ( operation ) |
‣ IsPreXModAlgebraMorphism( mor ) | ( property ) |
‣ IsXModAlgebraMorphism( mor ) | ( property ) |
‣ Source( mor ) | ( attribute ) |
‣ Range( mor ) | ( attribute ) |
‣ IsTotal( mor ) | ( method ) |
‣ IsSingleValued( m0r ) | ( method ) |
‣ Name( mor ) | ( 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( mor ) | ( 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( mor ) | ( 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( mor ) | ( attribute ) |
‣ RangeHom( mor ) | ( attribute ) |
‣ IsInjective( mor ) | ( property ) |
‣ IsSurjective( mor ) | ( property ) |
‣ IsBijjective( mor ) | ( 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