[Up] [Previous] [Next] [Index]

# 2 2d-objects

### Sections

1. Introduction
2. Crossed modules
3. Pre-crossed modules
4. Cat1-groups and pre-cat1-groups
5. Selection of a small cat1-group

## 2.1 Introduction

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 A1).

Crossed modules and cat1-groups are special types of 2-dimensional groups 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 Act(X) of a crossed module X we require representations for the Whitehead group of regular derivations of X and for the group of automorphisms of X. The construction also provides an inner morphism from X to Act(X) whose kernel is the centre of 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:

http://www.maths.bangor.ac.uk/chda/

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 GraphGpd M1, and further work on group groupoids is planned.

## 2.2 Crossed modules

The term crossed module was introduced by J. H. C. Whitehead in W2, W1. Loday, in L1, reformulated the notion of a crossed module as a cat1-group. Norrie N1, N2 and Gilbert G1 have studied derivations, automorphisms of crossed modules and the actor of a crossed module, while Ellis E1 has investigated higher dimensional analogues. Properties of induced crossed modules have been determined by Brown, Higgins and Wensley in BH1, BW1 and BW2. For further references see 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 X = (¶: S ® R ) consists of a group homomorphism ¶, called the boundary of X, with source S and range R. The Group R acts on itself by conjugation, and on S by an action a: R ® Aut(S) such that, for all s,s1,s2 Î S and r Î R,

XMod 1

:

¶(sr) = r-1 (¶s) r = (¶s)r ,

XMod 2

:

s1¶s2 = s2-1s1 s2 = s1s2 ·

The kernel of ¶ 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:

  - 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 ¶: 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 trivial action crossed module ¶: S ® R has sr = s for all s Î S, r Î 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 X1 ×X2 of two crossed modules has source S1 ×S2, range R1 ×R2 and boundary ¶1 ×¶2, with R1, R2 acting trivially on S2, S1 respectively.

- `Source(` X0`) A`
- `Range(` X0`) A`
- `Boundary(` X0`) A`
- `AutoGroup(` X0`) A`
- `XModAction(` X0`) A`

  In this implementation the attributes used in the construction of a crossed module X0 are as follows.

  - `Source(X0)` and `Range(X0)`, the source S and range R of ¶ = `Boundary(X0)`;
  - `XModAction(X0)`, a homomorphism from R to `AutoGroup(X0)`, a group of automorphisms of S.

- `Size(` X0`) A`
- `Name(` X0`) 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.

      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" ]

- `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 S = (d: N ® M) is normal in X = (¶: S ® R) if

  - N,M are normal subgroups of S,R respectively,
  - d is the restriction of ¶,
  - nr Î N for all n Î N, r Î R,
  - s-1 sm Î N for all m Î M, s Î S.

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

  ## 2.3 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 ker(¶) generated by Peiffer commutators

  á s1,s2 ñ = (s1-1)¶s2 s2-1 s1 s2 ·

  Then P = (0 : P ® {1R}) is a normal sub-pre-crossed module of X and X/P = (¶: S/P ® 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.

      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) ])

  ## 2.4 Cat1-groups and pre-cat1-groups

  In this implementation a cat1-group C has attributes:

- `Source(` C`) A`
- `Range(` C`) A`
- `Tail(` C`) A`
- `Head(` C`) A`
- `RangeEmbedding(` C`) A`
- `KernelEmbedding(` C`) A`
- `Boundary(` C`) A`
- `Name(` C`) A`
- `Size(` C`) A`

  In 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 ® G having a common image R and satisfying certain axioms. We find it convenient to define a cat1-group C = (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:

  Cat 1

  :

  te = he = idR ,

  Cat 2

  :

  [kert, kerh] = { 1G } .

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

      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 ]

- `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 X = (¶: S ® R) the group G is defined as the semidirect product G = R \ltimes S using the action from X, with multiplication rule

  (r1,s1) (r2,s2) = (r1 r2, s1r2 s2) .

  The structural morphisms are given by

  t(r,s) = r, h(r,s) = r (¶s), er = (r,1) .

  On the other hand, starting with a cat1-group C = (e;t,h : G ® R), we define S = kert, 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.5 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 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 ¹ h and the associated conjugation crossed module is given by the normal subgroup `c3` of `s3`.

      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]

  [Up] [Previous] [Next] [Index]