<!-- ------------------------------------------------------------------- -->
<!--                                                                     -->
<!--  xmod.xml            XModAlg documentation               Z. Arvasi  -->
<!--                                                        & A. Odabas  -->
<!--  Copyright (C) 2014-2025, Z. Arvasi & A. Odabas,                    --> 
<!--  Osmangazi University, Eskisehir, Turkey                            --> 
<!--                                                                     -->
<!-- ------------------------------------------------------------------- -->

<?xml version="1.0" encoding="UTF-8"?>

<Chapter Label="chap-xmod">

<Heading>Crossed modules</Heading>

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

<Section>
<Heading>Definition and Examples</Heading>

<Index>crossed module</Index>
<Index>precrossed module</Index>
<Index>2d-algebra</Index>

A <E>crossed module</E> is a <B>k</B>-algebra morphism 
<M>\mathcal{X}:=(\partial:S\rightarrow R)</M> 
with a left action of <M>R</M> on <M>S</M> satisfying 
<Display>
{\bf XModAlg\ 1} ~:~  \partial(r \cdot s) 
   = r(\partial s),
\qquad
{\bf XModAlg\ 2} ~:~  (\partial s) \cdot s^{\prime} = ss^{\prime}, 
</Display> 
for all <M>s,s^{\prime }\in S, \ r\in R</M>. 
The morphism <M>\partial</M> is called the <E>boundary map</E> 
of <M>\mathcal{X}</M>
<P/>
Note that, although in this definition we have used a left action, 
in the category of commutative algebras left and right actions coincide.
<P/>
When only the first axiom is satisfied, it is a <E>precrossed module</E>
which is constructed.
<P/>
The details of these implementations can be found in <Cite Key="aodabas1"/>.
<P/>

<ManSection>
   <Func Name="XModAlgebra"
         Arg="args" />
   <Func Name="PreXModAlgebra"
         Arg="args" />
   <Prop Name="IsXModAlgebra"
         Arg="X0" />
   <Prop Name="IsPreXModAlgebra"
         Arg="X0" />
<Description> 
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.
</Description>
</ManSection>

<ManSection>
   <Oper Name="XModAlgebraByIdeal"
         Arg="A I" />
<Description> 
Let <M>A</M> be an algebra and <M>I</M> an ideal of <M>A</M>. 
Then <M>\mathcal{X} = (inc:I\rightarrow A)</M> is a 
crossed module whose action is left multiplication of <M>A</M> on <M>I</M>. 
Conversely, given a crossed module 
<M>\mathcal{X} = (\partial : S \rightarrow R)</M>,
it is the case that <M>{\partial(S)}</M> is an ideal of <M>R</M>. 
<P/>
</Description>
</ManSection>

<Example>
<![CDATA[
gap> F5 := GF(5);;
gap> id5 := One( F5 );;
gap> two := Z(5);; 
gap> z5 := Zero( F5 );; 
gap> n0 := [ [id5,z5,z5], [z5,id5,z5], [z5,z5,id5] ];; 
gap> n1 := [ [z5,id5,two^3], [z5,z5,id5], [z5,z5,z5] ];;
gap> n2 := [ [z5,z5,id5], [z5,z5,z5], [z5,z5,z5] ];; 
gap> An := Algebra( F5, [ n0, n1 ] );; 
gap> SetName( An, "An" ); 
gap> Bn := Subalgebra( An, [ n1 ] );; 
gap> SetName( Bn, "Bn" ); 
gap> IsIdeal( An, Bn ); 
true
gap> actn := AlgebraActionByMultipliers( An, Bn, An );; 
gap> Xn := XModAlgebraByIdeal( An, Bn ); 
[ Bn -> An ]
gap> SetName( Xn, "Xn" ); 
]]>
</Example>

<ManSection>
   <Attr Name="AugmentationXMod"
         Arg="A" />
<Description> 
As a special case of the previous operation, the attribute 
<C>AugmentationXMod(A)</C> of a group algebra <M>A</M> 
is the <C>XModAlgebraByIdeal</C> formed using the 
<C>AugmentationIdeal</C> of the group algebra. 
<P/>
</Description>
</ManSection>

<Example>
<![CDATA[
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 ]
]]>
</Example>

<ManSection>
   <Attr Name="Source" Label="for crossed modules of commutative algebras"
         Arg="X0" />
   <Attr Name="Range" Label="for crossed modules of commutative algebras" 
         Arg="X0" />
   <Attr Name="Boundary" Label="for crossed modules of commutative algebras"
         Arg="X0" />
   <Attr Name="XModAlgebraAction"
         Arg="X0" />
<Description>
These four attributes are used in the construction of a crossed module 
<M>\mathcal{X}</M> where: 
<List>
<Item>
<C>Source(X)</C> and <C>Range(X)</C> are the <E>source</E> and the <E>range</E>
of the boundary map respectively; 
</Item>
<Item>
<C>Boundary(X)</C> is the boundary map of the crossed module <M>\mathcal{X}</M>; 
</Item>
<Item>
<C>XModAlgebraAction(X)</C> is the action used in the crossed module. 
This is an algebra homomorphism from <C>Range(X)</C> to an algebra of 
endomorphisms of <C>Source(X)</C>. 
</Item>
</List> 

The following standard &GAP; operations have special &XModAlg; implementations: 
<List>
<Item>
<C>Display(X)</C> is used to list the components of <M>\mathcal{X}</M>; 
</Item> 
<Item>
<C>Size2d(X)</C> for a crossed module <M>\mathcal{X}</M> 
returns a <M>2</M>-element list, the sizes of the source and range, 
</Item>
<Item>
<C>Dimension(X)</C> for a crossed module <M>\mathcal{X}</M> 
returns a <M>2</M>-element list, the dimensions of the source and range,
</Item>
<Item>
<C>Name(X)</C> is used for giving a name to the crossed module 
<M>\mathcal{X}</M> by associating the names of source and range algebras. 
</Item> 
</List> 

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

</Description>
</ManSection>

<Example>
<![CDATA[
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" ]
]]>
</Example>

<ManSection>
   <Oper Name="XModAlgebraByMultiplierAlgebra"
         Arg="A" />
<Description> 
When <M>A</M> is an algebra with multiplier algebra <M>M</M>, 
then the map <M>A \to M, ~ a \mapsto \mu_a</M> is the boundary 
of a crossed module in which the action is the identity map on <M>M</M>. 
<P/>
</Description>
</ManSection>

<Example>
<![CDATA[
gap> XAn := XModAlgebraByMultiplierAlgebra( An );
[ An -> <algebra of dimension 3 over GF(5)> ]
gap> XModAlgebraAction( XAn );
IdentityMapping( <algebra of dimension 3 over GF(5)> )
]]>
</Example>

<ManSection>
   <Oper Name="XModAlgebraBySurjection"
         Arg="f" />
<Description> 
Let <M>\partial : S\rightarrow R</M> be a surjective algebra homomorphism 
whose kernel lies in the annihilator of <M>S</M>. 
Define the action of <M>R</M> on <M>S</M> by <M>r\cdot s = \widetilde{r}s</M>
where <M>\widetilde{r} \in \partial^{-1}(r)</M>, 
as described in section <Ref Oper="AlgebraActionBySurjection"/>.
Then <M>\mathcal{X}=(\partial : S\rightarrow R)</M> 
is a crossed module with the defined action.
<P/> 
Continuing with the example in that section, 
<P/>
</Description>
</ManSection>

<Example>
<![CDATA[
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 ]
]]>
</Example>

<#Include Label="XModAlgebraByBoundaryAndAction">

<#Include Label="XModAlgebraByModule">


<ManSection>
   <Oper Name="SubXModAlgebra"
         Arg="alg src rng" />
   <Oper Name="IsSubXModAlgebra"
         Arg="alg sub" />
<Description>
A crossed module <M>\mathcal{X}^{\prime } 
= (\partial ^{\prime }:S^{\prime}\rightarrow R^{\prime })</M> 
is a  subcrossed module of the crossed module 
<M>\mathcal{X} = (\partial :S\rightarrow R)</M> if 
<M>S^{\prime }\leq S</M>, <M>R^{\prime}\leq R</M>,  
<M>\partial^{\prime } = \partial|_{S^{\prime }}</M>,  
and the action of <M>S^{\prime }</M> on <M>R^{\prime }</M> 
is induced by the action of <M>R</M> on <M>S</M>. 
The operation <C>SubXModAlgebra</C> is used to construct a subcrossed module 
of a given crossed module. 

</Description>
</ManSection>

<Example>
<![CDATA[
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> SetName( Je4, "<e4>" );
gap> Ke4 := Subalgebra( Ak4, [e4] );;
gap> [ Size( Je4 ), Size( Ke4 ) ];
[ 5, 5 ]
gap> Se4 := SubXModAlgebra( XIAk4, Je4, Ke4 );
[ <e4> -> <algebra of dimension 1 over GF(5)> ]
gap> IsSubXModAlgebra( XIAk4, Se4 ); 
true
gap> Display( Se4 );
Crossed module [<e4> -> ..] :- 
: 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 has generators:  
[ (Z(5)^0)*<identity> of ...+(Z(5)^0)*f1+(Z(5)^2)*f2+(Z(5)^2)*f1*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 ]
]]>
</Example>

</Section>


<Section><Heading>(Pre-)Crossed Module Morphisms</Heading>

Let <M>\mathcal{X} = (\partial:S\rightarrow R)</M> and 
<M>\mathcal{X}^{\prime} = 
(\partial^{\prime }:S^{\prime }\rightarrow R^{\prime })</M> 
be (pre)crossed modules and let <M>\theta :S\rightarrow S^{\prime }</M>, 
<M>\varphi : R\rightarrow R^{\prime }</M> be algebra homomorphisms. 
Then if
<Display>
\varphi \circ \partial = \partial ^{\prime } \circ \theta, 
\qquad 
\theta (r\cdot s)=\varphi(r) \cdot \theta (s), 
</Display>
for all <M>r\in R</M>, <M>s\in S,</M> 
the pair <M>(\theta ,\varphi )</M> is called a morphism between 
<M>\mathcal{X}</M> and <M>\mathcal{X}^{\prime } </M>
<P/>
The conditions can be thought as the commutativity of the following diagrams: 

<Display>
\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 }.       }
</Display> 
<!-- \begin{equation*} --> 
<!-- \text{\input{140.tex}} --> 
<!-- \end{equation*} --> 

<P/> 
In &GAP; we define the morphisms between algebraic structures such as 
cat<M>^{1}</M>-algebras and crossed modules and they are investigated 
by the function <C>Make2dAlgebraMorphism</C>.

<ManSection>
   <Func Name="XModAlgebraMorphism"
         Arg="arg" />
   <Meth Name="IdentityMapping" Label="for crossed modules of algebras"
         Arg="Xalg" />
   <Oper Name="PreXModAlgebraMorphismByHoms"
         Arg="src rng srchom rnghom" />
   <Oper Name="XModAlgebraMorphismByHoms"
         Arg="src rng srchom rnghom" />
   <Prop Name="IsPreXModAlgebraMorphism"
         Arg="mor" />
   <Prop Name="IsXModAlgebraMorphism"
         Arg="mor" />
   <Attr Name="Source" Label="for morphisms of crossed modules of algebras"
         Arg="mor" />
   <Attr Name="Range" Label="for morphisms of crossed modules of algebras"
         Arg="mor" />
   <Meth Name="IsTotal" Label="for morphisms of crossed modules of algebras"
         Arg="mor" />
   <Meth Name="IsSingleValued" 
         Label="for morphisms of crossed modules of algebras"
         Arg="m0r" />
   <Meth Name="Name" Label="for morphisms of crossed modules of algebras"
         Arg="mor" />

<Description>
These operations construct crossed module homomorphisms, 
which may have the attributes listed. 
</Description>
</ManSection>

<Example>
<![CDATA[
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 := AllAlgebraHomomorphisms( IAc4, IBk4 );; 
gap> theta := homIAIB[3];; 
gap> homAB := AllAlgebraHomomorphisms( 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
]]>
</Example>


<ManSection>
   <Meth Name="Kernel" Label="for morphisms of crossed modules of algebras" 
         Arg="mor" />
<Description>
Let <M>(\theta,\varphi) : \mathcal{X} = (\partial : S \rightarrow R) 
       \rightarrow \mathcal{X}^{\prime} = (\partial^{\prime} 
       : S^{\prime} \rightarrow R^{\prime})</M>
be a crossed module homomorphism. 
Then the crossed module 
<Display>
\ker(\theta,\varphi) = (\partial| : \ker\theta \rightarrow \ker\varphi )
</Display>
is called the <E>kernel</E> of <M>(\theta,\varphi)</M>. 
Also, <M>\ker(\theta ,\varphi )</M> is an ideal of <M>\mathcal{X}</M>. 
An example is given below. 
</Description>
</ManSection>

<Example>
<![CDATA[
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
]]>
</Example>

<ManSection>
   <Oper Name="Image"
         Arg="mor" />
<Description>
Let <M>(\theta,\varphi) : \mathcal{X} = (\partial : S \rightarrow R) 
        \rightarrow \mathcal{X}^{\prime} = (\partial^{\prime} : S^{\prime} 
        \rightarrow R^{\prime})</M> 
be a crossed module homomorphism. 
Then the crossed module 
<Display> 
\Im(\theta,\varphi) = (\partial^{\prime}| : 
\Im\theta \rightarrow \Im\varphi)
</Display>
is called the image of <M>(\theta,\varphi)</M>. 
Further, <M>\Im(\theta,\varphi)</M> is a subcrossed module of 
<M>(S^{\prime},R^{\prime},\partial^{\prime})</M>. 
<P/> 
In this package, the image of a crossed module homomorphism 
can be obtained by the command <C>ImagesSource</C>. 
The operation <C>Sub2dAlgObject</C> is effectively used 
for finding the kernel and image crossed modules
induced from a given crossed module homomorphism.

</Description>
</ManSection>

<ManSection>
   <Attr Name="SourceHom"
         Arg="mor" />
   <Attr Name="RangeHom"
         Arg="mor" />
   <Prop Name="IsInjective"
         Arg="mor" />
   <Prop Name="IsSurjective"
         Arg="mor" />
   <Prop Name="IsBijjective"
         Arg="mor" />
<Description>
Let <M>(\theta,\varphi)</M> be a homomorphism of crossed modules. 
If the homomorphisms <M>\theta</M> and <M>\varphi</M> 
are injective (surjective) then <M>(\theta,\varphi)</M> 
is injective (surjective).
<P/> 
The attributes <C>SourceHom</C> and <C>RangeHom</C> 
store the two algebra homomorphisms <M>\theta</M> and <M>\varphi</M>. 

</Description>
</ManSection>

<Example>
<![CDATA[
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 ]

]]>
</Example>

</Section>

</Chapter>