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

2 2d-objects
 2.1 Constructions for crossed modules
  2.1-1 XMod

  2.1-2 Source

  2.1-3 Size

  2.1-4 SubXMod
 2.2 Pre-crossed modules
  2.2-1 PreXModByBoundaryAndAction

  2.2-2 PeifferSubgroup

  2.2-3 IsPermXMod
 2.3 Cat1-groups and pre-cat1-groups
  2.3-1 Source

  2.3-2 Cat1

  2.3-3 Cat1OfXMod
 2.4 Selection of a small cat1-group
  2.4-1 Cat1Select

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:

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

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

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.


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.


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:


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.


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.


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]

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

generated by GAPDoc2HTML