Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

2 2d-groups : crossed modules and cat1-groups
 2.1 Constructions for crossed modules
 2.2 Pre-crossed modules
 2.3 Cat1-groups and pre-cat1-groups
 2.4 Selection of a small cat1-group

2 2d-groups : crossed modules and cat1-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}.

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( abgrp )( operation )
‣ DirectProduct( X1, X2 )( operation )

Here are the standard constructions which these implement:

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.

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-groups.

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


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 );
[ 5, 4 ]
gap> Print( RepresentationsOfObject(X1), "\n" );
[ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPreXModObj" ]
gap> Print( KnownPropertiesOfObject(X1), "\n" );
[ "IsEmpty", "IsTrivial", "IsNonTrivial", "IsFinite", 
  "CanEasilyCompareElements", "CanEasilySortElements", "IsDuplicateFree", 
  "IsPerm2dDomain", "IsPreXMod", "IsXMod", "IsAutomorphismGroup2dDomain" ]
gap> Print( KnownAttributesOfObject(X1), "\n" );
[ "Name", "Size", "Range", "Source", "Boundary", "AutoGroup", "XModAction" ]

2.1-4 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

These conditions ensure that M ⋉ N is normal in the semidirect product R ⋉ 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.


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(∂) 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 = (∂ : S/P -> R) is a crossed module.

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


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,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:


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 s3c4 has generators:
  [ f1, f2, f3, f4 ]
: Range group s3 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 ]
: associated crossed module is [ker(t2)->s3]
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 = (∂ : 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 remains unchanged, and ∂ = h∣_S. The action of R on S is conjugation in G via the embedding of R in G.


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 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.4-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 ) (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.


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-structrues 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.
[ [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 := Cat1( 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 := XModByCat1( PC18 );; 
gap> Display( X18 ); 

Crossed module X([..=>..]) :- 
: 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.4-2 AllCat1sBasic
‣ AllCat1sBasic( 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.


gap> gp := SmallGroup( 102, 2 ); 
<pc group of size 102 with 3 generators>
gap> StructureDescription( gp ); 
"C3 x D34"
gap> all := AllCat1sBasic( 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 ] )] ]
gap> Display( all[3] ); 

Cat1-group [..=>..] :- 
: Source group has generators:
  [ f1, f2, f3 ]
: Range group has generators:
  [ f1, <identity> of ..., f3 ]
: tail homomorphism maps source generators to:
  [ f1, <identity> of ..., f3 ]
: head homomorphism maps source generators to:
  [ f1, <identity> of ..., f3 ]
: range embedding maps range generators to:
  [ f1, <identity> of ..., f3 ]
: kernel has generators:
  [ f2 ]
: boundary homomorphism maps generators of kernel to:
  [ <identity> of ... ]
: kernel embedding maps generators of kernel to:
  [ f2 ]


 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 Bib Ind

generated by GAPDoc2HTML