%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%W  obj2.tex                   XMOD documentation               Chris Wensley
%W                                                                & Murat Alp
%%
%H  $Id: obj2.tex,v 2.006 2004/09/06 gap Exp $
%%
%Y  Copyright (C) 1999,2001 University of St. Andrews, North Haugh,
%Y                          St. Andrews, Fife KY16 9SS, Scotland
%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{2d-objects}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Introduction}

\atindex{2d-object}{@2d-object}
The {\XMod} package provides functions for computation with
finite *crossed modules* and *cat1-groups* and their morphisms.
See the file *notes.pdf* in the *doc* directory 
for an introductory account of these algebraic gadgets.

The package was initially produced while Murat Alp was a Ph.D. student
at Bangor (see \cite{A1}).

Crossed modules and cat1-groups are special types of 
*2-dimensional groups* \cite{B82}
and are implemented as `2dObjects' having a `Source' and a `Range'.

The package divides into four parts, 
all of which have been converted from {\GAP}~3 to the {\GAP}~4.4 release.

The first part is concerned with the standard constructions for 
pre-crossed modules and crossed modules; together with
direct products; normal sub-crossed modules; and quotients.
Operations for constructing pre-cat1-groups and cat1-groups,
and for converting between cat1-groups and crossed modules,
are also included.

The second part is concerned with *morphisms* of (pre-)crossed modules
and (pre-)cat1-groups, together with standard operations for morphisms,
such as composition, image and kernel.

The third part deals with the equivalent notions of
*derivation* for a crossed module and *section* for a cat1-group,
and the monoids which they form under the Whitehead multiplication.

The fourth part deals with actor crossed modules and actor cat1-groups.
These are the automorphism objects in the appropriate categories.
For the actor crossed module ${\rm Act}({\cal X})$ of a
crossed module ${\cal X}$ we require representations
for the Whitehead group of regular derivations of ${\cal X}$
and for the group of automorphisms of ${\cal X}$.
The construction also provides an inner morphism from  ${\cal X}$  
to  ${\rm Act}({\cal X})$  whose kernel is the centre of ${\cal X}$.

The package may be obtained as a compressed file by ftp from one of 
the sites with a {\GAP}~4 archive,
or from the Bangor Mathematics web site:

\hfuzz=20pt%
\URL{http://www.maths.bangor.ac.uk/chda/}
% After decompression, instructions for installing the package 
% may be found in the `README' file.

The following constructions were not in the {\GAP}~3 version of the package: 
sub-2dobject functions, functions for pre-crossed modules and the Peiffer 
subgroup of a pre-crossed module, and the associated crossed modules.
The source and range groups in these constructions
are no longer required to be permutation groups.

Future plans include the implementation of *group-graphs*
which will provide examples of pre-crossed modules
(their implementation will require interaction with graph-theoretic
functions in {\GAP}~4)
and *crossed squares* and the equivalent *cat2-groups*, 
structures which arise as $3$-dimensional groups.  
Examples of these are implicitly included in the fourth part, 
namely inclusions of normal sub-crossed modules, 
and the inner morphism from a crossed module to its actor.

The equivalent categories  `XMod'  (crossed modules) and
`Cat1'  (cat1-groups) are also equivalent to  `GpGpd', 
the subcategory of group objects in the category `Gpd' of groupoids.
Finite groupoids have been implemented in Emma Moore's crossed
resolutions package \package{GraphGpd} \cite{M1}, 
and further work on group groupoids is planned.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Crossed modules}

\atindex{crossed module}{@crossed module}

The term crossed module was introduced by J. H. C. Whitehead in 
\cite{W2}, \cite{W1}.
Loday, in \cite{L1}, reformulated the notion of a 
crossed module as a cat1-group.
Norrie \cite{N1}, \cite{N2} and Gilbert \cite{G1} have studied
derivations, automorphisms of crossed modules and the actor 
of a crossed module, while
Ellis \cite{E1} has investigated higher dimensional analogues.
Properties of induced crossed modules have been determined by 
Brown, Higgins and Wensley in \cite{BH1}, \cite{BW1} and \cite{BW2}.
For further references see \cite{AW1} where we discuss some of the
data structures and algorithms used in this package, and also tabulate
isomorphism classes of cat1-groups up to size $30$.

A crossed module  ${\cal X} = (\partial : S \to R )$ 
consists of a group homomorphism $\partial $, 
called the *boundary* of ${\cal X}$, 
with *source* $S$  and *range* $R$. 
The Group $R$ acts on itself by conjugation, and on $S$ by an action 
$\alpha : R \to {\rm Aut}(S)$ such that,  
for all $s,s_1,s_2 \in S$  and  $r \in R$,
$$
\matrix{
{\bf XMod\ 1} ~&:&~      \partial(s^r) ~=~ r^{-1} (\partial s) r
                                       ~=~ (\partial s)^r       ~,\cr
{\bf XMod\ 2} ~&:&~ s_1^{\partial s_2} ~=~ s_2^{-1}s_1 s_2
                                       ~=~ {s_1}^{s_2}   ~.~~~~~~~\cr
}
$$

The kernel of  $\partial$  is abelian.

There are a variety of constructors for crossed modules:

\> XMod( <args> ) F
\> XModByBoundaryAndAction( <bdy, act> ) O
\> XModByTrivialAction( <bdy> ) O
\> XModByNormalSubgroup( <G, N> ) O
\> XModByCentralExtension( <bdy> ) O
\> XModByAutomorphismGroup( <grp> ) O
\> XModByInnerAutomorphismGroup( <grp> ) O
\> XModByGroupOfAutomorphisms( <G, A> ) O
\> XModByAbelianModule( <abgrp> ) O

Here are the standard constructions which these implement:

\beginlist%unordered
\item{$\bullet$} A *conjugation crossed module*
      is an inclusion of a normal subgroup  $S$ \unlhd $~R$,
      where $R$ acts on $S$ by conjugation.
\item{$\bullet$} A *central extension crossed module* has as boundary a surjection
      $\partial : S \to R$ with central kernel,
      where $r \in R$ acts on $S$ by conjugation with $\partial^{-1}r$.
\item{$\bullet$} An *automorphism crossed module* has as range a subgroup $R$
      of the automorphism group  $\Aut(S)$  of  $S$
      which contains the inner automorphism group of $S$.
      The boundary maps $s \in S$  to the inner automorphism of $S$ by $s$.
\item{$\bullet$} A *trivial action crossed module*  $\partial : S \to R$
      has  $s^r = s$  for all  $s \in S, \; r \in R$,  
      the source is abelian
      and the image lies in the centre of the range.
\item{$\bullet$} A *crossed abelian module* has an abelian module as source
      and the zero map as boundary.
\item{$\bullet$} The direct product  ${\cal X}_{1} \times {\cal X}_{2}$
      of two crossed modules has source  $S_1 \times S_2$,
      range  $R_1 \times R_2$  and boundary
      $\partial_1 \times \partial_2$,  with  $R_1,\ R_2$  acting
      trivially on  $S_2,\ S_1$  respectively.
\endlist

\> Source( <X0> )!{of (pre-)crossed module} A
\> Range( <X0> )!{of (pre-)crossed module} A
\> Boundary( <X0> )!{of (pre-)crossed module} A
\> AutoGroup( <X0> )!{of (pre-)crossed module} A
\> XModAction( <X0> ) A

In this implementation the attributes used in the construction of
a crossed module <X0> are as follows.
\beginlist%unordered
\item{$\bullet$} `Source(X0)' and `Range(X0)', 
  the source $S$ and range $R$ of $\partial =$ `Boundary(X0)';
\item{$\bullet$} `XModAction(X0)', a homomorphism from $R$ to 
  `AutoGroup(X0)', a group of automorphisms of $S$. 
\endlist

\> Size( <X0> )!{of (pre-)crossed module} A
\> Name( <X0> )!{of (pre-)crossed module} A

More familiar attributes are `Size' and `Name', the latter 
formed by concatenating the names of the source and range.
An `Enumerator' function has not been implemented.
The `Display' function is used to print details of `2dobjects'.

Here is a simple example of an automorphism crossed module, 
using a cyclic group of size five.

\beginexample
gap> c5 := Group( (5,6,7,8,9) );;
gap> SetName( c5, "c5" );
gap> X1 := XModByAutomorphismGroup( c5 );
[c5 -> PAut(c5)] 
gap> Display( X1 );
Crossed module [c5 -> PAut(c5)] :-
: Source group c5 has generators:
  [ (5,6,7,8,9) ]
: Range group PAut(c5) has generators:
  [ (1,2,4,3) ]
: Boundary homomorphism maps source generators to:
  [ () ]
: Action homomorphism maps range generators to automorphisms:
  (1,2,4,3) --> { source gens --> [ (5,7,9,6,8) ] }
  This automorphism generates the group of automorphisms.
gap> Size( X1 );
[ 5, 4 ]
gap> Print( RepresentationsOfObject(X1), "\n" );
[ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModObj" ]
gap> Print( KnownPropertiesOfObject(X1), "\n" );
[ "Is2dObject", "IsPerm2dObject", "IsPreXMod", "IsXMod",
  "IsTrivialAction2dObject", "IsAutomorphismGroup2dObject" ]
gap> Print( KnownAttributesOfObject(X1), "\n" );
[ "Name", "Size", "Range", "Source", "Boundary", "AutoGroup", "XModAction" ]
\endexample

\> SubXMod( <X0>, <src>, <rng> ) O
\> IdentitySubXMod( <X0> ) A
\> NormalSubXMods( <X0> ) A
\> DirectProduct( <X1>, <X2> ) O

With the standard crossed module constructors listed above as building blocks, 
sub-crossed modules, quotients of normal sub-crossed modules,
and also direct products may be constructed.
A sub-crossed module  ${\cal S} = (\delta : N \to M)$
is *normal* in ${\cal X} = (\partial : S \to R)$  if
\beginlist%unordered
\item{$\bullet$} $N,M$ are normal subgroups of $S,R$ respectively,
\item{$\bullet$} $\delta$ is the restriction of $\partial$,
\item{$\bullet$} $n^r \in N$  for all  $n \in N,\,r \in R$,
\item{$\bullet$} $s^{-1}\,s^m \in N$  for all  $m \in M,\,s \in S$.
\endlist

These conditions ensure that  $M \ltimes N$  is normal in  
the semidirect product $R \ltimes S$.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Pre-crossed modules}

\> PeifferSubgroup( <X0> ) A
\> PreXModByBoundaryAndAction( <bdy, act> ) O
\> PreXModByCentralExtension( <bdy> ) O
\> SubPreXMod( <X0, src, rng> ) O
\> XModByPeifferQuotient( <pre-xmod> ) A

When axiom  *XMod\ 2*  is *not* satisfied, 
the corresponding structure is known as a *pre-crossed module*.
In this case the *Peiffer subgroup*  of  $P$  of  $S$
is the subgroup of  ${\rm ker}(\partial)$
generated by  *Peiffer commutators*
$$
\langle s_1,s_2 \rangle \quad=\quad %
(s_1^{-1})^{\partial s_2}\,s_2^{-1}\,s_1\,s_2~.
$$
Then  ${\cal P} = (0 : P \to \{1_R\})$
is a normal sub-pre-crossed module of  ${\cal X}$
and  ${\cal X}/{\cal P} = (\partial : S/P \to R)$
is a crossed module.

\> IsPermXMod( <X0> ) P
\> IsPcPreXMod( <X0> ) P

When both source and range groups are of the same type,
corresponding properties are assigned to the crossed module.

In the following example the Peiffer subgroup is cyclic of size $4$.

\beginexample
gap> c := (11,12,13,14,15,16,17,18);;  d := (12,18)(13,17)(14,16);;
gap> d16 := Group( c, d );
gap> gend16 := GeneratorsOfGroup( d16 );;
gap> sk4 := Subgroup( d16, [ c^4, d ] );;
gap> gensk4 := GeneratorsOfGroup( sk4 );;
gap> SetName( d16, "d16" );  SetName( sk4, "sk4" );
gap> f16 := GroupHomomorphismByImages( d16, sk4, gend16, gensk4 );;
gap> P16 := PreXModByCentralExtension( f16 );
[d16->sk4]
gap> P := PeifferSubgroup( P16 );
Group( [ (11,17,15,13)(12,18,16,14) ] )
gap> X16 := XModByPeifferQuotient( P16 );
[d16/P->sk4]
gap> Display( X16 );
Crossed module [d16/P->sk4] :-
: Source group has generators:
  [ f1, f2 ]
: Range group has generators:
  [ (11,15)(12,16)(13,17)(14,18), (12,18)(13,17)(14,16) ]
: Boundary homomorphism maps source generators to:
  [ (12,18)(13,17)(14,16), (11,15)(12,16)(13,17)(14,18) ]
  The automorphism group is trivial
gap> iso16 := IsomorphismPermGroup( Source( X16 ) );;
gap> S16 := Image( iso16 );
Group([ (1,3)(2,4), (1,2)(3,4) ])   
\endexample



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Cat1-groups and pre-cat1-groups}

\atindex{cat1-group}{@cat1-group}
\atindex{pre-cat1-group}{@pre-cat1-group}
In this implementation a cat1-group ${\cal C}$ has attributes:

\> Source( <C> )!{of (pre-)cat1-group} A 
\> Range( <C> )!{of (pre-)cat1-group} A  
\> Tail( <C> ) A     
\> Head( <C> ) A    
\> RangeEmbedding( <C> ) A 
\> KernelEmbedding( <C> ) A
\> Boundary( <C> )!{of (pre-)cat1-group} A       
\> Name( <C> )!{of (pre-)cat1-group} A  
\> Size( <C> )!{of (pre-)cat1-group} A

In \cite{L1}, Loday reformulated the notion of a 
crossed module as a cat1-group, 
namely a group $G$ with a pair of homomorphisms $t,h : G \to G$
having  a common image $R$ and satisfying certain axioms.
We find it convenient to define a cat1-group 
${\cal C} = (e;t,h : G \to R )$  as having source group  $G$,
range group $R$,  and three homomorphisms:  two surjections  
$t,h : G \to R$  and an embedding  $e : R \to G$  satisfying:
$$
\matrix{
{\bf Cat\ 1} ~&:&~ te ~=~ he ~=~ {\rm id}_R~,~\quad\quad\cr
{\bf Cat\ 2} ~&:&~ [\ker t, \ker h] ~=~ \{ 1_G \} ~\.\cr
}
$$
It follows that  $teh = h$, $het = t$, $tet = t$, $heh = h$.

The maps  $t,h$  are often referred to as the *source* and *target*,
but we choose to call them the
*tail* and *head* of  ${\cal C}$, 
because *source* is the {\GAP} term for the domain of a function.
The `RangeEmbedding' is the embedding of <R> in <G>,
the `KernelEmbedding' is the inclusion of the kernel of <t> in <G>,
and the `Boundary' is the restriction of <h> to the kernel of <t>.

Here are some of the constructors for pre-cat1-groups and cat1-groups:

\> Cat1( <args> ) F
\> PreCat1ByTailHeadEmbedding( <t>, <h>, <e> ) O
\> PreCat1ByEndomorphisms( <t>, <h> ) O
\> PreCat1ByNormalSubgroup( <G>, <N> ) O
\> Cat1ByPeifferQuotient( <P> ) O
\> Reverse( <C0> ) A

The following listing shows an example of a cat1-group of pc-groups:

\beginexample
gap> s3 := SymmetricGroup(IsPcGroup,3);;   
gap> gens3 := GeneratorsOfGroup(s3);
[ f1, f2 ]
gap> pc4 := CyclicGroup(4);; 
gap> SetName(s3,"s3");  SetName( pc4, "pc4" );
gap> s3c4 := DirectProduct( s3, pc4 );; 
gap> SetName( s3c4, "s3c4" );  
gap> gens3c4 := GeneratorsOfGroup( s3c4 );
[ f1, f2, f3, f4 ]
gap> a := gens3[1];;  b := gens3[2];;  one := One(s3);;
gap> t2 := GroupHomomorphismByImages( s3c4, s3, gens3c4, [a,b,one,one] );
[ f1, f2, f3, f4 ] -> [ f1, f2, <identity> of ..., <identity> of ... ]
gap> e2 := Embedding( s3c4, 1 );
[ f1, f2 ] -> [ f1, f2 ]
gap> C2 := Cat1( t2, t2, e2 );
[s3c4=>s3]
gap> Display( C2 );
Cat1-group [s3c4=>s3] :-
: source group has generators:
  [ f1, f2, f3, f4 ]
:  range group has generators:
  [ f1, f2 ]
: tail homomorphism maps source generators to:
  [ f1, f2, <identity> of ..., <identity> of ... ]
: head homomorphism maps source generators to:
  [ f1, f2, <identity> of ..., <identity> of ... ]
: range embedding maps range generators to:
  [ f1, f2 ]
: kernel has generators:
  [ f3, f4 ]
: boundary homomorphism maps generators of kernel to:
  [ <identity> of ..., <identity> of ... ]
: kernel embedding maps generators of kernel to:
  [ f3, f4 ]
gap> IsPcCat1( C2 );
true
gap> Size( C2 );
[ 24, 6 ]
\endexample


\> Cat1OfXMod( <X0> ) A
\> XModOfCat1( <C0> ) A
\> PreCat1OfPreXMod( <P0> ) A
\> PreXModOfPreCat1( <P0> ) A

The category of crossed modules is equivalent to the category of cat1-groups,
and the functors between these two categories may be described as follows.

Starting with the crossed module 
${\cal X} = (\partial : S \to R)$ the group $ G $ is defined 
as the semidirect product $ G = R \ltimes S$
using the action from  ${\cal X}$,
with multiplication rule
$$
(r_1,s_1)\,(r_2,s_2) ~=~ (r_1\,r_2,\,s_1^{r_2}\,s_2) ~\.
$$
The structural morphisms are given by
$$
t(r,s) = r, ~~ h(r,s) = r (\partial s), ~~ er = (r,1) ~\.
$$
On the other hand, starting with a cat1-group 
$ {\cal C} = (e;t,h : G \to R)$,  we define 
$ S = \ker t$, the range $R$ remains unchanged, and 
$ \partial = h\!\mid_S $.
The action of  $R$  on  $S$  is conjugation in  $G$  via the embedding
of  $R$  in  $G$.

\beginexample
gap> SetName( Kernel(t2), "ker(t2)" );;
gap> X2 := XModOfCat1( C2 );
[Group( [ f3, f4 ] )->s3]
gap> Display( X2 );
Crossed module [ker(t2)->s3] :-
: Source group has generators:
  [ f3, f4 ]
: Range group s3 has generators:
  [ f1, f2 ]
: Boundary homomorphism maps source generators to:
  [ <identity> of ..., <identity> of ... ]
  The automorphism group is trivial
: associated cat1-group is [s3c4=>s3]

\endexample


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Selection of a small cat1-group}

\atindex{cat1-group selection}{@cat1-group selection}

The `Cat1' function may also be used to select a cat1-group from a data file.
All cat1-structures on groups of size up to $47$ are stored in a list
in file `cat1data.g'.
Global variables `CAT1_LIST_MAX_SIZE := 47' and
`CAT1_LIST_CLASS_SIZES' are also stored.
The {\XMod2} version of the database orders the groups of size up to $47$
according to the {\GAP4} numbering of small groups.
The data is read into the list `CAT1_LIST' only when this function is called.

The example below is the first case in which $t \neq h$
and the associated conjugation crossed module
is given by the normal subgroup `c3' of `s3'.

\beginexample
gap> CAT1_LIST_CLASS_SIZES[ 18 ];
5
gap> Cat1( 18 );
#I  Loading cat1-group data into CAT1_LIST
Usage:  Cat1( size, gpnum, num )
[ "d18", "c18", "s3c3", "c3^2Xc2", "c6c3" ]
gap> Cat1( 18, 4 );
There are 4 cat1-structures for the group c3^2 X c2.
[ [range gens], source & range names, [tail genimages], [head genimages] ] :-
[ [ (1,2,3), (4,5,6), (2,3)(5,6) ],  tail = head = identity mapping ]
[ [ (2,3)(5,6) ], "c3^2", "c2", [ (), (), (2,3)(5,6) ],
  [ (), (), (2,3)(5,6) ] ]
[ [ (4,5,6), (2,3)(5,6) ], "c3", "s3", [ (), (4,5,6), (2,3)(5,6) ],
  [ (), (4,5,6), (2,3)(5,6) ] ]
[ [ (4,5,6), (2,3)(5,6) ], "c3", "s3", [ (4,5,6), (4,5,6), (2,3)(5,6) ],
  [ (), (4,5,6), (2,3)(5,6) ] ]
Usage:  Cat1( size, gpnum, num )
Group has generators [ (1,2,3), (4,5,6), (2,3)(5,6) ]

gap> C4 := Cat1( 18, 4, 4 );
[c3^2 X c2=>s3]
gap> Display( C4 );
Cat1-group [c3^2 X c2=>s3] :-
: source group has generators:
  [ (1,2,3), (4,5,6), (2,3)(5,6) ]
:  range group has generators:
  [ (4,5,6), (4,5,6), (2,3)(5,6) ]
: tail homomorphism maps source generators to:
  [ (4,5,6), (4,5,6), (2,3)(5,6) ]
: head homomorphism maps source generators to:
  [ (), (4,5,6), (2,3)(5,6) ]
: range embedding maps range generators to:
  [ (4,5,6), (4,5,6), (2,3)(5,6) ]
: kernel has generators:
  [ ( 1, 2, 3)( 4, 6, 5) ]
: boundary homomorphism maps generators of kernel to:
  [ (4,6,5) ]
: kernel embedding maps generators of kernel to:
  [ (1,2,3)(4,6,5) ]

gap> XC4 := XModOfCat1( C4 );
[Group( [ ( 1, 2, 3)( 4, 6, 5) ] )->s3]
\endexample

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%E
