chap2.txt

  
  2 2d-groups : crossed modules and cat1-groups
  
  The term 2d-group refers to a set of equivalent categories of which the most
  common   are   the   categories   of   crossed   modules;  cat1-groups;  and
  group-groupoids, all of which involve a pair of groups.
  
  
  2.1 Constructions for crossed modules
  
  A  crossed  module  (of groups) mathcalX = (∂ : S -> R ) consists of a group
  homomorphism  ∂, 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 α : R ->
  Aut(S) such that, for all s,s_1,s_2 ∈ S and r ∈ 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}.
  
  
  
  When only the first of these axioms is satisfied, the resulting structure is
  a  pre-crossed  module (see section 2.3). (Much of the literature on crossed
  modules  uses  left actions, but we have chosen to use right actions in this
  package since that is the standard choice for group actions in GAP.)
  
  The kernel of ∂ 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( abmod )  operation
  DirectProductOp( L, X1 )  operation
  
  The   global   function  XMod  implements  one  of  the  following  standard
  constructions:
  
      A  trivial  action crossed module (∂ : S -> R) has s^r = s for all s ∈
        S,  r  ∈  R, the source is abelian and the image lies in the centre of
        the range.
  
      A conjugation crossed module is the inclusion of a normal subgroup S ⊴
        R, where R acts on S by conjugation.
  
      A  central extension crossed module has as boundary a surjection ∂ : S
        ->  R,  with central kernel, where r ∈ R acts on S by conjugation with
        ∂^-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 ∈ S to the inner automorphism of S by
        s.
  
      A  crossed abelian module has an abelian module as source and the zero
        map as boundary.
  
      The  direct product mathcalX_1 × mathcalX_2 of two crossed modules has
        source  S_1  ×  S_2, range R_1 × R_2 and boundary ∂_1 × ∂_2, with R_1,
        R_2 acting trivially on S_2, S_1 respectively.
  
        Since DirectProduct is a global function which only accepts groups, it
        is   necessary   to   provide   an   "other   method"   for  operation
        DirectProductOp which, as usual, takes as parameters a list of crossed
        modules, followed by the first of these: DirectProductOp([X1,X2],X1);
  
  2.1-2 Source
  
  Source( X0 )  attribute
  Range( X0 )  attribute
  Boundary( X0 )  attribute
  XModAction( X0 )  attribute
  
  The  following  attributes  are used in the construction of a crossed module
  X0.
  
      Source(X0)  and  Range(X0)  are  the  source  S  and range R of ∂, the
        boundary Boundary(X0);
  
      XModAction(X0) is a homomorphism from R to a group of automorphisms of
        X0.
  
  (Up  until  version  2.63  there  was an additional attribute AutoGroup, the
  range of XModAction(X0).)
  
  2.1-3 ImageElmXModAction
  
  ImageElmXModAction( X0, s, r )  operation
  
  This function returns the element s^r given by XModAction(X0).
  
  2.1-4 Size
  
  Size( X0 )  attribute
  Name( X0 )  attribute
  IdGroup( X0 )  attribute
  ExternalSetXMod( X0 )  attribute
  
  More  familiar  attributes are Name, Size and IdGroup. The name is formed by
  concatenating  the  names of the source and range (if these exist). Size and
  IdGroup return two-element lists.
  
  The ExternalSetXMod for a crossed module is the source group considered as a
  G-set of the range group using the crossed module action.
  
  The Display function is used to print details of 2d-groups.
  
  In  the  simple example below, X1 is an automorphism crossed module, using a
  cyclic  group  of  size  five.  The Print statements at the end list the GAP
  representations, properties and attributes of X1.
  
    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,3,4) ]
    : Boundary homomorphism maps source generators to:
      [ () ]
    : Action homomorphism maps range generators to automorphisms:
      (1,2,3,4) --> { source gens --> [ (5,7,9,6,8) ] }
      This automorphism generates the group of automorphisms.
    gap> Size( X1 );  IdGroup( X1 ); 
    [ 5, 4 ]
    [ [ 5, 1 ], [ 4, 1 ] ]
    gap> ext := ExternalSetXMod( X1 ); 
    <xset:[ (), (5,6,7,8,9), (5,7,9,6,8), (5,8,6,9,7), (5,9,8,7,6) ]>
    gap> Orbits( ext );
    [ [ () ], [ (5,6,7,8,9), (5,7,9,6,8), (5,9,8,7,6), (5,8,6,9,7) ] ]
    gap> ImageElmXModAction( X1, (5,6,7,8,9), (1,2,3,4) );
    (5,7,9,6,8)
    gap> RepresentationsOfObject( X1 );
    [ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModObj" ]
    gap> KnownAttributesOfObject( X1);
    [ "Name", "Size", "Range", "Source", "IdGroup", "Boundary", "XModAction", 
      "ExternalSetXMod" ]
    
  
  
  
  2.2 Properties of crossed modules
  
  The  underlying  category  structures  for  the  objects constructed in this
  chapter   follow  the  sequence  Is2DimensionalDomain;  Is2DimensionalMagma;
  Is2DimensionalMagmaWithOne;  Is2DimensionalMagmaWithInverses,  mirroring the
  situation   for   (one-dimensional)   groups.   From   these   we  construct
  Is2DimensionalSemigroup, Is2DimensionalMonoid and Is2DimensionalGroup.
  
  There  are  then  a  variety  of properties associated with crossed modules,
  starting with IsPreXMod and IsXMod.
  
  2.2-1 IsXMod
  
  IsXMod( X0 )  property
  IsPreXMod( X0 )  property
  IsPerm2DimensionalGroup( X0 )  property
  IsPc2DimensionalGroup( X0 )  property
  IsFp2DimensionalGroup( X0 )  property
  
  A  structure  which  has IsPerm2DimensionalGroup is a precrossed module or a
  pre-cat1-group (see section 2.4) whose source and range are both permutation
  groups.  The  properties  IsPc2DimensionalGroup,  IsFp2DimensionalGroup  are
  defined similarly. In the example below we see that X1 has IsPreXMod, IsXMod
  and  IsPerm2DimensionalGroup. There are also properties corresponding to the
  various      construction     methods     listed     in     section     2.1:
  IsTrivialAction2DimensionalGroup;         IsNormalSubgroup2DimensionalGroup;
  IsCentralExtension2DimensionalGroup;   IsAutomorphismGroup2DimensionalGroup;
  IsAbelianModule2DimensionalGroup.
  
    Example  
    
    gap> KnownPropertiesOfObject( X1 );
    [ "IsEmpty", "IsTrivial", "IsNonTrivial", "IsFinite", 
      "CanEasilyCompareElements", "CanEasilySortElements", "IsDuplicateFree", 
      "IsGeneratorsOfSemigroup", "IsPreXModDomain", "IsPerm2DimensionalGroup", 
      "IsPreXMod", "IsXMod", "IsAutomorphismGroup2DimensionalGroup" ]
    
  
  
  2.2-2 SubXMod
  
  SubXMod( X0, src, rng )  operation
  TrivialSubXMod( X0 )  attribute
  NormalSubXMods( X0 )  attribute
  
  With  the  standard  crossed  module  constructors  listed above as building
  blocks, sub-crossed modules, normal sub-crossed modules mathcalN ⊲ mathcalX,
  and  also  quotients  mathcalX/mathcalN  may  be  constructed. A sub-crossed
  module mathcalS = (δ : N -> M) is normal in mathcalX = (∂ : S -> R) if
  
      N,M are normal subgroups of S,R respectively,
  
      δ is the restriction of ∂,
  
      n^r ∈ N for all n ∈ N,~r ∈ R,
  
      (s^-1)^ms ∈ N for all m ∈ M,~s ∈ S.
  
  These  conditions  ensure that M ⋉ N is normal in the semidirect product R ⋉
  S.  (Note  that  ⟨  s,m  ⟩  =  (s^-1)^ms is a displacement: see Displacement
  (4.1-3).)
  
  A  method  for  IsNormal for precrossed modules is provided. See section 4.1
  for factor crossed modules and their natural morphisms.
  
  The  five normal subcrossed modules of X4 found in the following example are
  [id,id], [k4,k4], [k4,a4], [a4,a4] and X4 itself.
  
    Example  
    
    gap> s4 := Group( (1,2), (2,3), (3,4) );; 
    gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );; 
    gap> k4 := Subgroup( a4, [ (1,2)(3,4), (1,3)(2,4) ] );; 
    gap> SetName(s4,"s4");  SetName(a4,"a4");  SetName(k4,"k4"); 
    gap> X4 := XModByNormalSubgroup( s4, a4 );
    [a4->s4]
    gap> Y4 := SubXMod( X4, k4, a4 ); 
    [k4->a4]
    gap> IsNormal(X4,Y4);
    true
    gap> NX4 := NormalSubXMods( X4 );;
    gap> Length( NX4 ); 
    5
    
  
  
  
  2.3 Pre-crossed modules
  
  2.3-1 PreXModByBoundaryAndAction
  
  PreXModByBoundaryAndAction( bdy, act )  operation
  SubPreXMod( X0, src, rng )  operation
  
  If  axiom XMod 2 is not satisfied, the corresponding structure is known as a
  pre-crossed module.
  
    Example  
    
    gap> b1 := (11,12,13,14,15,16,17,18);;  b2 := (12,18)(13,17)(14,16);;
    gap> d16 := Group( b1, b2 );;
    gap> sk4 := Subgroup( d16, [ b1^4, b2 ] );;
    gap> SetName( d16, "d16" );  SetName( sk4, "sk4" );
    gap> bdy16 := GroupHomomorphismByImages( d16, sk4, [b1,b2], [b1^4,b2] );;
    gap> aut1 := GroupHomomorphismByImages( d16, d16, [b1,b2], [b1^5,b2] );;
    gap> aut2 := GroupHomomorphismByImages( d16, d16, [b1,b2], [b1,b2^4*b2] );;
    gap> aut16 := Group( [ aut1, aut2 ] );;
    gap> act16 := GroupHomomorphismByImages( sk4, aut16, [b1^4,b2], [aut1,aut2] );;
    gap> P16 := PreXModByBoundaryAndAction( bdy16, act16 );
    [d16->sk4]
    gap> IsXMod(P16);
    false
    
  
  
  2.3-2 PeifferSubgroup
  
  PeifferSubgroup( X0 )  attribute
  XModByPeifferQuotient( prexmod )  attribute
  
  The  Peiffer subgroup P of a pre-crossed module mathcal X is the subgroup of
  ker(∂) generated by Peiffer commutators
  
  
  \lfloor  s_1,s_2  \rfloor ~=~ (s_1^{-1})^{\partial s_2}~s_2^{-1}~s_1~s_2 ~=~
  \langle \partial s_2, s_1 \rangle\ [s_1,s_2]~.
  
  
  
  Then  mathcalP  =  (0  :  P  -> {1_R}) is a normal sub-pre-crossed module of
  mathcalX and mathcalX/mathcalP = (∂ : 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 );
    Peiffer([d16->sk4])
    gap> Display( X16 );
    Crossed module Peiffer([d16->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,2), (3,4) ])   
    
  
  
  
  2.4 Cat1-groups and pre-cat1-groups
  
  In  [Lod82],  Loday  reformulated  the  notion  of  a  crossed  module  as a
  cat1-group,  namely  a  group  G  with  a pair of endomorphisms t,h : G -> G
  having  a  common  image  R  and  satisfying  certain  axioms.  We  find  it
  computationally 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} : ~t \circ e ~=~ h \circ e = {\rm id}_R, \qquad {\bf Cat\ 2} :
  ~[\ker t, \ker h] ~=~ \{ 1_G \}.
  
  
  
  It  follows that t ∘ e ∘ h = h,~ h ∘ e ∘ t = t,~ t ∘ e ∘ t = t~ and ~h ∘ e ∘
  h = h. (See section 2.5 for the case when t,h are endomorphisms.)
  
  2.4-1 Cat1Group
  
  Cat1Group( args )  function
  PreCat1Group( args )  function
  PreCat1GroupByTailHeadEmbedding( t, h, e )  operation
  PreCat1GroupByEndomorphisms( t, h )  operation
  
  The  global  functions  Cat1Group  and PreCat1Group can be called in various
  ways.
  
      as  Cat1Group(t,h,e);  when  t,h,e  are  three homomorphisms, which is
        equivalent to PreCat1GroupByTailHeadEmbedding(t,h,e);
  
      as Cat1Group(t,h); when t,h are two endomorphisms, which is equivalent
        to PreCat1GroupByEndomorphisms(t,h);
  
      as  Cat1Group(t);  when t=h is an endomorphism, which is equivalent to
        PreCat1GroupByEndomorphisms(t,t);
  
      as  Cat1Group(t,e);  when  t=h  and  e  are  homomorphisms,  which  is
        equivalent to PreCat1GroupByTailHeadEmbedding(t,t,e);
  
      as  Cat1Group(i,j,k);  when i,j,k are integers, which is equivalent to
        Cat1Select(i,j,k); as described in section 2.6.
  
    Example  
    
    gap> g18gens := [ (1,2,3), (4,5,6), (2,3)(5,6) ];;     
    gap> s3agens := [ (7,8,9), (8,9) ];;                
    gap> g18 := Group( g18gens );;  SetName( g18, "g18" ); 
    gap> s3a := Group( s3agens );;  SetName( s3a, "s3a" );
    gap> t1 := GroupHomomorphismByImages(g18,s3a,g18gens,[(7,8,9),(),(8,9)]);     
    [ (1,2,3), (4,5,6), (2,3)(5,6) ] -> [ (7,8,9), (), (8,9) ]
    gap> h1 := GroupHomomorphismByImages(g18,s3a,g18gens,[(7,8,9),(7,8,9),(8,9)]);
    [ (1,2,3), (4,5,6), (2,3)(5,6) ] -> [ (7,8,9), (7,8,9), (8,9) ]
    gap> e1 := GroupHomomorphismByImages(s3a,g18,s3agens,[(1,2,3),(2,3)(5,6)]);   
    [ (7,8,9), (8,9) ] -> [ (1,2,3), (2,3)(5,6) ]
    gap> C18 := Cat1Group( t1, h1, e1 );
    [g18=>s3a]
    
  
  
  2.4-2 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.
  
  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. It is frequently the
  case that t=h, but not in the example C18 above.
  
    Example  
    
    gap> Source( C18 );
    g18
    gap> Range( C18 );
    s3a
    gap> TailMap( C18 );
    [ (1,2,3), (4,5,6), (2,3)(5,6) ] -> [ (7,8,9), (), (8,9) ]
    gap> HeadMap( C18 );
    [ (1,2,3), (4,5,6), (2,3)(5,6) ] -> [ (7,8,9), (7,8,9), (8,9) ]
    gap> RangeEmbedding( C18 );
    [ (7,8,9), (8,9) ] -> [ (1,2,3), (2,3)(5,6) ]
    gap> Kernel( C18 );
    Group([ (4,5,6) ])
    gap> KernelEmbedding( C18 );
    [ (4,5,6) ] -> [ (4,5,6) ]
    gap> Name( C18 );
    "[g18=>s3a]"
    gap> Size( C18 );
    [ 18, 6 ]
    gap> StructureDescription( C18 );
    [ "(C3 x C3) : C2", "S3" ]
    
  
  
  2.4-3 DiagonalCat1Group
  
  DiagonalCat1Group( gen1 )  operation
  PreCat1GroupByNormalSubgroup( G, N )  operation
  Cat1GroupByPeifferQuotient( P )  operation
  ReverseCat1Group( C0 )  attribute
  
  These  are  some  more  constructors  for cat1-groups. The following listing
  shows  an  example  of a permutation cat1-group of size [576,24] with source
  group  S_4  × S_4, range group a third S_4, and t ≠ h. A similar example may
  be reproduced using the command C := DiagonalCat1Group([(1,2,3,4),(3,4)]);.
  
    Example  
    
    gap> G4 := Group( (1,2,3,4), (3,4), (5,6,7,8), (7,8) );; 
    gap> R4 := Group( (9,10,11,12), (11,12) );;
    gap> SetName( G4, "s4s4" );  SetName( R4, "s4d" ); 
    gap> G4gens := GeneratorsOfGroup( G4 );; 
    gap> R4gens := GeneratorsOfGroup( R4 );; 
    gap> t := GroupHomomorphismByImages( G4, R4, G4gens, 
    >            Concatenation( R4gens, [ (), () ] ) );; 
    gap> h := GroupHomomorphismByImages( G4, R4, G4gens,  
    >            Concatenation( [ (), () ], R4gens ) );; 
    gap> e := GroupHomomorphismByImages( R4, G4, R4gens, 
    >            [ (1,2,3,4)(5,6,7,8), (3,4)(7,8) ] );; 
    gap> C4 := PreCat1GroupByTailHeadEmbedding( t, h, e );; 
    gap> Display(C4);
    Cat1-group [s4s4=>s4d] :- 
    : Source group s4s4 has generators:
      [ (1,2,3,4), (3,4), (5,6,7,8), (7,8) ]
    : Range group s4d has generators:
      [ ( 9,10,11,12), (11,12) ]
    : tail homomorphism maps source generators to:
      [ ( 9,10,11,12), (11,12), (), () ]
    : head homomorphism maps source generators to:
      [ (), (), ( 9,10,11,12), (11,12) ]
    : range embedding maps range generators to:
      [ (1,2,3,4)(5,6,7,8), (3,4)(7,8) ]
    : kernel has generators:
      [ (5,6,7,8), (7,8) ]
    : boundary homomorphism maps generators of kernel to:
      [ ( 9,10,11,12), (11,12) ]
    : kernel embedding maps generators of kernel to:
      [ (5,6,7,8), (7,8) ]
    
  
  
  
  2.5 Properties of cat1-groups and pre-cat1-groups
  
  Many of the properties listed in section 2.2 apply to pre-cat1-groups and to
  cat1-groups  since  these  are  also 2d-groups. There are also more specific
  properties.
  
  2.5-1 IsCat1Group
  
  IsCat1Group( C0 )  property
  IsPreXCat1Group( C0 )  property
  IsIdentityCat1Group( C0 )  property
  IsEndomorphismPreCat1Group( C0 )  property
  EndomorphismPreCat1Group( C0 )  attribute
  
  IsIdentityCat1Group(C0)  is  true  when  the  head  and  tail maps of C0 are
  identity  mappings. IsEndomorphismPreCat1Group(C0) is true when the range of
  C0  is  a subgroup of the source. When this is not the case, replacing t,h,e
  by  t*e,h*e  and the inclusion mapping of the image of e gives an isomorphic
  cat1-group for which IsEndomorphismPreCat1Group is true.
  
    Example  
    
    gap> G2 := SmallGroup( 288, 956 );  SetName( G2, "G2" );
    <pc group of size 288 with 7 generators>
    gap> d12 := DihedralGroup( 12 );  SetName( d12, "d12" );
    <pc group of size 12 with 3 generators>
    gap> a1 := d12.1;;  a2 := d12.2;;  a3 := d12.3;;  a0 := One( d12 );;
    gap> gensG2 := GeneratorsOfGroup( G2 );;
    gap> t2 := GroupHomomorphismByImages( G2, d12, gensG2,
    >           [ a0, a1*a3, a2*a3, a0, a0, a3, a0 ] );;
    gap> h2 := GroupHomomorphismByImages( G2, d12, gensG2,
    >           [ a1*a2*a3, a0, a0, a2*a3, a0, a0, a3^2 ] );;                   
    gap> e2 := GroupHomomorphismByImages( d12, G2, [a1,a2,a3],
    >        [ G2.1*G2.2*G2.4*G2.6^2, G2.3*G2.4*G2.6^2*G2.7, G2.6*G2.7^2 ] );
    [ f1, f2, f3 ] -> [ f1*f2*f4*f6^2, f3*f4*f6^2*f7, f6*f7^2 ]
    gap> C2 := PreCat1GroupByTailHeadEmbedding( t2, h2, e2 );
    [G2=>d12]
    gap> IsCat1Group( C2 );
    true
    gap> KnownPropertiesOfObject( C2 );
    [ "CanEasilyCompareElements", "CanEasilySortElements", "IsDuplicateFree", 
      "IsGeneratorsOfSemigroup", "IsPreCat1Domain", "IsPerm2DimensionalGroup", 
      "IsPreCat1Group", "IsCat1Group", "IsEndomorphismPreCat1Group" ]
    gap> IsEndomorphismPreCat1Group( C2 );
    false
    gap> EC4 := EndomorphismPreCat1Group( C4 );
    [s4s4=>Group( [ (1,2,3,4)(5,6,7,8), (3,4)(7,8), (), () ] )]
    
  
  
  2.5-2 Cat1GroupOfXMod
  
  Cat1GroupOfXMod( X0 )  attribute
  XModOfCat1Group( C0 )  attribute
  PreCat1GroupOfPreXMod( P0 )  attribute
  PreXModOfPreCat1Group( 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 = (∂ : S -> R) the
  group G is defined as the semidirect product G = R ⋉ 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 is unchanged, and ∂ = h∣_S. The action of R
  on S is conjugation in G via the embedding of R in G.
  
    Example  
    
    gap> X2 := XModOfCat1Group( C2 );;
    gap> Display( X2 );
    
    Crossed module X([G2=>d12]) :- 
    : Source group has generators:
      [ f1, f4, f5, f7 ]
    : Range group d12 has generators:
      [ f1, f2, f3 ]
    : Boundary homomorphism maps source generators to:
      [ f1*f2*f3, f2*f3, <identity> of ..., f3^2 ]
    : Action homomorphism maps range generators to automorphisms:
      f1 --> { source gens --> [ f1*f5, f4*f5, f5, f7^2 ] }
      f2 --> { source gens --> [ f1*f5*f7^2, f4, f5, f7 ] }
      f3 --> { source gens --> [ f1*f7, f4, f5, f7 ] }
      These 3 automorphisms generate the group of automorphisms.
    : associated cat1-group is [G2=>d12]
    
    gap> StructureDescription(X2);
    [ "D24", "D12" ]
    
    
  
  
  
  2.6 Selection of a small cat1-group
  
  The  Cat1Group  function may also be used to select a cat1-group from a data
  file.  All  cat1-structures on groups of size up to 70 (ordered according to
  the  GAP  4  numbering  of  small  groups)  are  stored  in  a  list in file
  cat1data.g.     Global    variables    CAT1_LIST_MAX_SIZE    :=    70    and
  CAT1_LIST_CLASS_SIZES  are  also  stored.  The  data  is  read into the list
  CAT1_LIST only when this function is called.
  
  2.6-1 Cat1Select
  
  Cat1Select( size, gpnum, num )  attribute
  
  The  function  Cat1Select  may  be  used  in  three ways. Cat1Select( size )
  returns  the  names  of  the  groups with this size, while Cat1Select( size,
  gpnum  ) prints a list of cat1-structures for this chosen group. Cat1Select(
  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> ## check the number of groups of size 18
    gap> L18 := Cat1Select( 18 ); 
    Usage:  Cat1Select( size, gpnum, num );
    [ "D18", "C18", "C3 x S3", "(C3 x C3) : C2", "C6 x C3" ]
    gap> ## check the number of cat1-structures on the fourth of these
    gap> Cat1Select( 18, 4 );
    Usage:  Cat1Select( size, gpnum, num );
    There are 4 cat1-structures for the group (C3 x C3) : C2.
    Using small generating set [ f1, f2, f2*f3 ] for source of homs.
    [ [range gens], [tail genimages], [head genimages] ] :-
    (1)  [ [ f1 ], [ f1, <identity> of ..., <identity> of ... ], 
      [ f1, <identity> of ..., <identity> of ... ] ]
    (2)  [ [ f1, f3 ], [ f1, <identity> of ..., f3 ], 
      [ f1, <identity> of ..., f3 ] ]
    (3)  [ [ f1, f3 ], [ f1, <identity> of ..., f3 ], 
      [ f1, f3^2, <identity> of ... ] ]
    (4)  [ [ f1, f2, f2*f3 ],  tail = head = identity mapping ]
    4
    gap> ## select the third of these cat1-structures 
    gap> C18 := Cat1Group( 18, 4, 3 );
    [(C3 x C3) : C2=>Group( [ f1, <identity> of ..., f3 ] )]
    gap> ## convert from a pc-cat1-group to a permutation cat1-group
    gap> iso18 := IsomorphismPermObject( C18 );;
    gap> PC18 := Image( iso18 );;
    gap> Display( PC18 );
    Cat1-group :- 
    : Source group has generators:
      [ (2,3)(5,6), (4,5,6), (1,2,3) ]
    : Range group has generators:
      [ (2,3), (), (1,2,3) ]
    : tail homomorphism maps source generators to:
      [ (2,3), (), (1,2,3) ]
    : head homomorphism maps source generators to:
      [ (2,3), (1,3,2), (1,2,3) ]
    : range embedding maps range generators to:
      [ (2,3)(5,6), (), (1,2,3) ]
    : kernel has generators:
      [ (4,5,6) ]
    : boundary homomorphism maps generators of kernel to:
      [ (1,3,2) ]
    : kernel embedding maps generators of kernel to:
      [ (4,5,6) ]
    gap> convert the result to the associated permutation crossed module 
    gap> X18 := XModOfCat1Group( PC18 );; 
    gap> Display( X18 ); 
    Crossed module:- 
    : Source group has generators:
      [ (4,5,6) ]
    : Range group has generators:
      [ (2,3), (), (1,2,3) ]
    : Boundary homomorphism maps source generators to:
      [ (1,3,2) ]
    : Action homomorphism maps range generators to automorphisms:
      (2,3) --> { source gens --> [ (4,6,5) ] }
      () --> { source gens --> [ (4,5,6) ] }
      (1,2,3) --> { source gens --> [ (4,5,6) ] }
      These 3 automorphisms generate the group of automorphisms.
    : associated cat1-group is [..=>..]
    
  
  
  2.6-2 AllCat1DataGroupsBasic
  
  AllCat1DataGroupsBasic( gp )  operation
  
  For  a  group  G of size greater than 70 which is reasonably straightforward
  this  function  may be used to construct a list of all cat1-group structures
  on  G.  The  operation also attempts to write output to a file in the folder
  xmod/lib.  (Other  operations in the file cat1data.gi have been used to deal
  with  the  more  complicated  groups  of  size  up  to 70, but these are not
  described here.)
  
  Van Luyen Le has a more efficient algorithm, extending the data up to groups
  of size 171, which is expected to appear in a future release of HAP.
  
    Example  
    
    gap> gp := SmallGroup( 102, 2 ); 
    <pc group of size 102 with 3 generators>
    gap> StructureDescription( gp ); 
    "C3 x D34"
    gap> all := AllCat1DataGroupsBasic( gp );
    #I Edit last line of .../xmod/lib/nn.kk.out to end with ] ] ] ] ]
    [ [Group( [ f1, f2, f3 ] )=>Group( [ f1, <identity> of ..., <identity> of ... 
         ] )], [Group( [ f1, f2, f3 ] )=>Group( [ f1, f2, <identity> of ... ] )], 
      [Group( [ f1, f2, f3 ] )=>Group( [ f1, <identity> of ..., f3 ] )], 
      [Group( [ f1, f2, f3 ] )=>Group( [ f1, f2, f3 ] )] ]
    
  
  
  
  2.7 More functions for crossed modules and cat1-groups
  
  Chapter  4  contains  functions  for  quotient  crossed modules; centre of a
  crossed module; commutator and derived subcrossed modules; etc.
  
  Here  we  mention  two  functions for groups which have been extended to the
  two-dimensional case.
  
  2.7-1 IdGroup
  
  IdGroup( 2DimensionalGroup )  operation
  StructureDescription( 2DimensionalGroup )  operation
  
  These  functions return two-element lists formed by applying the function to
  the source and range of the 2d-group.
  
    Example  
    
    gap> IdGroup( X2 );
    [ [ 24, 6 ], [ 12, 4 ] ]
    gap> StructureDescription( C2 );
    [ "(S3 x D24) : C2", "D12" ]