2 2d-objects
  
  
  2.1 Constructions for crossed modules
  
  A  crossed  module  mathcalX  =  (partial  :  S  ->  R ) consists of a group
  homomorphism  partial,  called  the  boundary of mathcalX, with source S and
  range  R.  The  Group R acts on itself by conjugation, and on S by an action
  alpha : R -> Aut(S) such that, for all s,s_1,s_2 in S and r in R,
  
  
       {\bf XMod\ 1} ~:~ \partial(s^r) = r^{-1} (\partial s) r =
       (\partial s)^r, \qquad {\bf XMod\ 2} ~:~ s_1^{\partial s_2} =
       s_2^{-1}s_1 s_2 = {s_1}^{s_2}.
  
  
  The kernel of partial is abelian.
  
  There are a variety of constructors for crossed modules:
  
  2.1-1 XMod
  
  > XMod( args ) _____________________________________________________function
  > XModByBoundaryAndAction( bdy, act ) _____________________________operation
  > XModByTrivialAction( bdy ) ______________________________________operation
  > XModByNormalSubgroup( G, N ) ____________________________________operation
  > XModByCentralExtension( bdy ) ___________________________________operation
  > XModByAutomorphismGroup( grp ) __________________________________operation
  > XModByInnerAutomorphismGroup( grp ) _____________________________operation
  > XModByGroupOfAutomorphisms( G, A ) ______________________________operation
  > XModByAbelianModule( abgrp ) ____________________________________operation
  > DirectProduct( X1, X2 ) _________________________________________operation
  
  Here are the standard constructions which these implement:
  
  --    A  conjugation  crossed  module is an inclusion of a normal subgroup S
        unlhd R, where R acts on S by conjugation.
  
  --    A  central  extension  crossed  module  has  as  boundary a surjection
        partial  :  S  ->  R  with  central  kernel, where r in R acts on S by
        conjugation with partial^-1r.
  
  --    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.
  
  --    A trivial action crossed module partial : S -> 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.
  
  --    A  crossed abelian module has an abelian module as source and the zero
        map as boundary.
  
  --    The  direct product mathcalX_1 x mathcalX_2 of two crossed modules has
        source  S_1 x S_2, range R_1 x R_2 and boundary partial_1 x partial_2,
        with R_1, R_2 acting trivially on S_2, S_1 respectively.
  
  2.1-2 Source
  
  > Source( X0 ) ____________________________________________________attribute
  > Range( X0 ) _____________________________________________________attribute
  > Boundary( X0 ) __________________________________________________attribute
  > AutoGroup( X0 ) _________________________________________________attribute
  > XModAction( X0 ) ________________________________________________attribute
  
  In  this implementation the attributes used in the construction of a crossed
  module X0 are as follows.
  
  --    Source(X0)  and Range(X0) are the source S and range R of partial, the
        boundary Boundary(X0);
  
  --    AutoGroup(X0) is a group of automorphisms of S;
  
  --    XModAction(X0) is a homomorphism from R to AutoGroup(X0).
  
  2.1-3 Size
  
  > Size( X0 ) ______________________________________________________attribute
  > Name( X0 ) ______________________________________________________attribute
  
  More   familiar   attributes  are  Size  and  Name,  the  latter  formed  by
  concatenating  the  names  of  the  source  and  range  (if these exist). An
  Enumerator  function  has not been implemented. The Display function is used
  to print details of 2d-objects.
  
  Here  is  a simple example of an automorphism crossed module, using a cyclic
  group of size five.
  
  ---------------------------  Example  ----------------------------
    
    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" ]
    
  ------------------------------------------------------------------
  
  2.1-4 SubXMod
  
  > SubXMod( X0, src, rng ) _________________________________________operation
  > IdentitySubXMod( X0 ) ___________________________________________attribute
  > NormalSubXMods( X0 ) ____________________________________________attribute
  
  With  the  standard  crossed  module  constructors  listed above as building
  blocks,   sub-crossed  modules,  normal  sub-crossed  modules  mathcalN  lhd
  mathcalX,  and  also  quotients  mathcalX/mathcalN  may  be  constructed.  A
  sub-crossed  module  mathcalS  =  (delta  :  N -> M) is normal in mathcalX =
  (partial : S -> R) if
  
  --    N,M are normal subgroups of S,R respectively,
  
  --    delta is the restriction of partial,
  
  --    n^r in N for all n in N,~r in R,
  
  --    s^-1s^m in N for all m in M,~s in S.
  
  These  conditions ensure that M ltimes N is normal in the semidirect product
  R ltimes S.
  
  
  2.2 Pre-crossed modules
  
  2.2-1 PreXModByBoundaryAndAction
  
  > PreXModByBoundaryAndAction( bdy, act ) __________________________operation
  > SubPreXMod( X0, src, rng ) ______________________________________operation
  
  When  axiom  {\bf  XMod\ 2} is not satisfied, the corresponding structure is
  known as a pre-crossed module.
  
  ---------------------------  Example  ----------------------------
    
    gap> c := (11,12,13,14,15,16,17,18);;  d := (12,18)(13,17)(14,16);;
    gap> d16 := Group( c, d );;
    gap> sk4 := Subgroup( d16, [ c^4, d ] );;
    gap> SetName( d16, "d16" );  SetName( sk4, "sk4" );
    gap> bdy16 := GroupHomomorphismByImages( d16, sk4, [c,d], [c^4,d] );;
    gap> h1 := GroupHomomorphismByImages( d16, d16, [c,d], [c^5,d] );;
    gap> h2 := GroupHomomorphismByImages( d16, d16, [c,d], [c,c^4*d] );;
    gap> aut16 := Group( [ h1, h2 ] );;
    gap> act16 := GroupHomomorphismByImages( sk4, aut16, [c^4,d], [h1,h2] );;
    gap> P16 := PreXModByBoundaryAndAction( bdy16 );
    [d16->sk4]
    
  ------------------------------------------------------------------
  
  2.2-2 PeifferSubgroup
  
  > PeifferSubgroup( X0 ) ___________________________________________attribute
  > XModByPeifferQuotient( prexmod ) ________________________________attribute
  
  The  Peiffer  subgroup  of  a  pre-crossed  module P of S is the subgroup of
  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  mathcalP  =  (0  :  P  -> {1_R}) is a normal sub-pre-crossed module of
  mathcalX and mathcalX/mathcalP = (partial : S/P -> R) is a crossed module.
  
  In the following example the Peiffer subgroup is cyclic of size 4.
  
  ---------------------------  Example  ----------------------------
    
    gap> P := PeifferSubgroup( P16 );
    Group( [ (11,15)(12,16)(13,17)(14,18), (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) ])   
    
  ------------------------------------------------------------------
  
  2.2-3 IsPermXMod
  
  > IsPermXMod( X0 ) _________________________________________________property
  > IsPcPreXMod( X0 ) ________________________________________________property
  
  When  both  source  and  range  groups  are  of the same type, corresponding
  properties are assigned to the crossed module.
  
  
  2.3 Cat1-groups and pre-cat1-groups
  
  2.3-1 Source
  
  > Source( C ) _____________________________________________________attribute
  > Range( C ) ______________________________________________________attribute
  > TailMap( C ) ____________________________________________________attribute
  > HeadMap( C ) ____________________________________________________attribute
  > RangeEmbedding( C ) _____________________________________________attribute
  > KernelEmbedding( C ) ____________________________________________attribute
  > Boundary( C ) ___________________________________________________attribute
  > Name( C ) _______________________________________________________attribute
  > Size( C ) _______________________________________________________attribute
  
  These are the attributes of a cat1-group mathcalC in this implementation.
  
  In  [Lod82],  Loday  reformulated  the  notion  of  a  crossed  module  as a
  cat1-group,  namely  a  group  G  with  a pair of homomorphisms t,h : G -> G
  having a common image R and satisfying certain axioms. We find it convenient
  to  define  a cat1-group mathcalC = (e;t,h : G -> R ) as having source group
  G,  range group R, and three homomorphisms: two surjections t,h : G -> R and
  an embedding e : R -> G satisfying:
  
  
       {\bf Cat\ 1} ~:~ te = he = {\rm id}_R, \qquad {\bf Cat\ 2} ~:~
       [\ker t, \ker h] = \{ 1_G \}.
  
  
  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 mathcalC, 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.
  
  2.3-2 Cat1
  
  > Cat1( args ) ____________________________________________________attribute
  > PreCat1ByTailHeadEmbedding( t, h, e ) ___________________________attribute
  > PreCat1ByEndomorphisms( t, h ) __________________________________attribute
  > PreCat1ByNormalSubgroup( G, N ) _________________________________attribute
  > Cat1ByPeifferQuotient( P ) ______________________________________attribute
  > Reverse( C0 ) ___________________________________________________attribute
  
  These are some of the constructors for pre-cat1-groups and cat1-groups.
  
  The following listing shows an example of a cat1-group of pc-groups:
  
  ---------------------------  Example  ----------------------------
    
    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 ]
    
  ------------------------------------------------------------------
  
  2.3-3 Cat1OfXMod
  
  > Cat1OfXMod( X0 ) ________________________________________________attribute
  > XModOfCat1( C0 ) ________________________________________________attribute
  > PreCat1OfPreXMod( P0 ) __________________________________________attribute
  > PreXModOfPreCat1( P0 ) __________________________________________attribute
  
  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 mathcalX = (partial : S -> R)
  the  group  G  is defined as the semidirect product G = R ltimes S using the
  action from mathcalX, with multiplication rule
  
  
       (r_1,s_1)(r_2,s_2) ~=~ (r_1r_2,{s_1}^{r_2}s_2).
  
  
  The structural morphisms are given by
  
  
       t(r,s) = r, \quad h(r,s) = r (\partial s), \quad er = (r,1).
  
  
  On  the  other hand, starting with a cat1-group mathcalC = (e;t,h : G -> R),
  we  define S = ker t, the range R remains unchanged, and partial = h|_S. The
  action of R on S is conjugation in G via the embedding of R in G.
  
  ---------------------------  Example  ----------------------------
    
    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]
    
  ------------------------------------------------------------------
  
  
  2.4 Selection of a small cat1-group
  
  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 XMod~2 version of the database
  orders the groups of size up to 47 according to the GAP~4 numbering of small
  groups.  The data is read into the list CAT1_LIST only when this function is
  called.
  
  2.4-1 Cat1Select
  
  > Cat1Select( size, gpnum, num ) __________________________________attribute
  
  This  function  may  be  used  in three ways. Cat1Select( size ) returns the
  names  of the groups with this size. Cat1Select( size, gpnum ) prints a list
  of cat1-structures for this chosen group. Cat1Select( size, gpnum, num ) (or
  just Cat1( size, gpnum, num )) returns the chosen cat1-group.
  
  The  example  below  is  the  first  case in which t <> h and the associated
  conjugation crossed module is given by the normal subgroup c3 of s3.
  
  ---------------------------  Example  ----------------------------
    
    gap> L18 := Cat1Select( 18 );
    #I  Loading cat1-group data into CAT1_LIST
    Usage:  Cat1( size, gpnum, num )
    [ "d18", "c18", "s3c3", "c3^2|Xc2", "c6c3" ]
    gap> Cat1Select( 18, 4 );
    There are 4 cat1-structures for the group c3^2|Xc2.
    [ [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) ]
    4
    gap> C4 := Cat1( 18, 4, 4 );
    [c3^2|Xc2=>s3]
    gap> Display( C4 );
    Cat1-group [c3^2|Xc2=>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]
    
  ------------------------------------------------------------------