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

# 2 2d-objects

### Sections

1. Introduction
2. Crossed modules
3. Pre-crossed modules
4. Cat1-groups and pre-cat1-groups

## 2.1 Introduction

The XMod package provides functions for computation with finite crossed modules and cat1-groups and their morphisms.

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, three of which have so far been converted from GAP 3 to GAP 4.

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.

The following constructions are new in this version of the package. Firstly, sub-2d-object functions have been included. Secondly, functions for pre-crossed modules, the Peiffer subgroup of a pre-crossed module, and the associated crossed modules, have been added. 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 XRes M01, 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. In L1, Loday 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, together with an action a: R ® Aut(S) satisfying, for all s,s1,s2 Î S and r Î R,

XMod 1
:
¶(sr) = r-1 (¶s) r ,
XMod 2
:
s1¶s2 = s2-1s1 s2 .

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`
- `XModByRModule(` 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.
  - An R-Module crossed module has an R-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.

  In this implementation the attributes used in the construction of a crossed module X0 are:

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

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

  More familiar attributes are `Size` and `Name`, formed by concatenating the names of the source and range. An `Enumerator` function has not yet been implemented.

- `Size(` X0`) A`
- `Name(` X0`) A`

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

      gap> c5 := Group( (1,2,3,4,5) );;
      gap> SetName( c5, "c5" );
      gap> X1 := XModByAutomorphismGroup( c5 );
      [c5 -> PermAut(c5)]
      gap> Display( X1 );
      Crossed module [c5 -> PermAut(c5)] :-
      : Source group c5 has generators:
        [ (1,2,3,4,5) ]
      : Range group PermAut(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 --> [ (1,3,5,2,4) ] }
        This automorphism generates the group of automorphisms.
      gap> Size( X1 );
      [ 5, 4 ]

- `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 ios cyclic of size 4.

      gap> d16 := Group( (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) );;
      gap> SetName( d16, "d16" );
      gap> gend16 := GeneratorsOfGroup( d16 );;
      gap> sk4 := Subgroup( d16, [ (1,5)(3,7)(2,6)(4,8), (2,8)(3,7)(4,6) ] );;
      gap> gensk4 := GeneratorsOfGroup( sk4 );;
      gap> SetName( sk4, "sk4" );
      gap> f16 := GroupHomomorphismByImages( d16, sk4, gend16, gensk4 );;
      gap> P16 := PreXModByCentralExtension( f16 );;
      gap> Display(P16);
      Pre-crossed module [d16 -> sk4] :-
      : Source group d16 has generators:
        [ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ]
      : Range group has generators:
        [ (1,5)(2,6)(3,7)(4,8), (2,8)(3,7)(4,6) ]
      : Boundary homomorphism maps source generators to:
        [ (1,5)(2,6)(3,7)(4,8), (2,8)(3,7)(4,6) ]
      : Action homomorphism maps range generators to automorphisms:
        (1,5)(2,6)(3,7)(4,8) --> { source gens -->
      [ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ] }
        (2,8)(3,7)(4,6) --> { source gens --> [ (1,8,7,6,5,4,3,2), (2,8)(3,7)(4,6) ] }
        These 2 automorphisms generate the group of automorphisms.

      gap> P := PeifferSubgroup( P16 );
      Group([ (1,7,5,3)(2,8,6,4) ])
      gap> X16 := XModByPeifferQuotient( P16 );;
      gap> Display( X16 );
      Crossed module [? -> sk4] :-
      : Source group has generators:
        [ f1, f2 ]
      : Range group has generators:
        [ (1,5)(2,6)(3,7)(4,8), (2,8)(3,7)(4,6) ]
      : Boundary homomorphism maps source generators to:
        [ (2,8)(3,7)(4,6), (1,5)(2,6)(3,7)(4,8) ]
        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 constructors for pre-cat1-groups and cat1-groups:

- `Cat1(` args`) F`
- `PreCat1ByTailHeadEmbedding(` t`,` h`,` e`) O`
- `PreCat1ByEndomorphisms(` t`,` h`) O`
- `PreCat1ByNormalSubgroup(` G`,` N`) O`
- `PreCat1OfPreXMod(` P`) A`

  The following listing shows an example of a cat1-group of pc-groups:

      gap> s3 := SymmetricGroup(IsPcGroup,3);;   SetName(s3,"s3");
      gap> gens3 := GeneratorsOfGroup(s3);
      [ f1, f2 ]
      gap> c4 := CyclicGroup(4);;  SetName( c4, "c4" );
      gap> s3c4 := DirectProduct( s3, c4 );;  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 );
      Pcgs([ 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(` C`) 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 S via the embedding of R in G.

      gap> X2 := XModOfCat1( C2 );
      [Group( [ f3, f4 ] )->s3]
      gap> Display( X2 );
      Crossed module [..->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

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