Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Bib | Ind

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

- 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 partial : S -> R with central kernel, where r in R acts on S by conjugation with partial^-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 in S to the inner automorphism of S by s.

- A trivial action crossed module partial : S -> R has s^r = s for all s in S, ; r in 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 mathcalX_1 times mathcalX_2 of two crossed modules has source S_1 times S_2, range R_1 times R_2 and boundary partial_1 times partial_2, with R_1, R_2 acting trivially on S_2, S_1 respectively.

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

- `Source(X0)` and `Range(X0)` are the source S and range R of partial, the boundary `Boundary(X0)`;

- `AutoGroup(X0)` is a group of automorphisms of S;

- `XModAction(X0)` is a homomorphism from R to `AutoGroup(X0)`.

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

- N,M are normal subgroups of S,R respectively,

- delta is the restriction of partial,

- n^r in N for all n in N,,r in R,

- s^-1,s^m in N for all m in M,,s in S.

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

`> Tail`( C ) | ( attribute )

`> Head`( 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 [L82], 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, &lt;identity&gt; of ..., &lt;identity&gt; 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, &lt;identity&gt; of ..., &lt;identity&gt; of ... ]
    : head homomorphism maps source generators to:
      [ f1, f2, &lt;identity&gt; of ..., &lt;identity&gt; of ... ]
    : range embedding maps range generators to:
      [ f1, f2 ]
    : kernel has generators:
      [ f3, f4 ]
    : boundary homomorphism maps generators of kernel to:
      [ &lt;identity&gt; of ..., &lt;identity&gt; 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:
      [ &lt;identity&gt; of ..., &lt;identity&gt; 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