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

# 4 Derivations and Sections

### Sections

1. Whitehead Multiplication
2. Whitehead Groups and Monoids

## 4.1 Whitehead Multiplication

- `IsUp2dMapping(` map`) P`
- `IsDerivation(` chi`) P`
- `IsSection(` chi`) P`

  The Whitehead monoid Der(X) of X was defined in W2 to be the monoid of all derivations from R to S, that is the set of all maps R ® S, with Whitehead multiplication * (on the right) satisfying:

  Der 1

  :

  c(qr) = (c q)r (c r) ,

  Der 2

  :

  (c1 *c2)(r) = (c2 r)(c1 r)(c2 ¶c1 r) .

  The zero map is the identity for this composition. Invertible elements in the monoid are called regular. The Whitehead group of X is the group of regular derivations in Der(X ). In the next chapter the actor of X is defined as a crossed module whose source and range are permutation representations of the Whitehead group and the automorphism group of X.

  The construction for cat1-groups equivalent to the derivation of a crossed module is the section. The monoid of sections of C = (e;t,h : G ® R) is the set of group homomorphisms x: R ® G, with Whitehead multiplication *, (on the right) satisfying:

  Sect 1

  :

  t x = idR ,

  Sect 2

  :

  (x1 *x2)(r) = (x1 r)(e h x1 r)-1(x2 h x1 r) = (x2 h x1 r)(e h x1 r)-1(x1 r) .

  The embedding e is the identity for this composition, and h(x1 *x2) = (h x1)(h x2). A section is regular when h x is an automorphism, and the group of regular sections is isomorphic to the Whitehead group.

  If e denotes the inclusion of S = ker t in G then ¶ = h e: S ® R and

  x r = (e r)(e c r) = (r, c r)

  determines a section x of C in terms of the corresponding derivation c of X, and conversely.

- `Object2d(` chi`) A`
- `GeneratorImages(` chi`) A`
- `DerivationByImages(` X0`,` ims`) O`

  Derivations are stored like group homomorphisms by specifying the images of a generating set. Images of the remaining elements may then be obtained using axiom Der 1. The function `IsDerivation` is automatically called to check that this procedure is well-defined.

  In the following example a cat1-group `C3` and the associated crossed module `X3` are constructed, where `X3` is isomorphic to the inclusion of the normal cyclic group `c3` in the symmetric group `s3`.

      gap> g18 := Group( (1,2,3), (4,5,6), (2,3)(5,6) );;
      gap> SetName( g18, "g18" );
      gap> gen18 := GeneratorsOfGroup( g18 );;
      gap> g1 := gen18[1];;  g2 := gen18[2];;  g3 := gen18[3];;
      gap> s3 := Subgroup( g18, gen18{[2..3]} );;
      gap> SetName( s3, "s3" );;
      gap> t := GroupHomomorphismByImages( g18, s3, gen18, [g2,g2,g3] );;
      gap> h := GroupHomomorphismByImages( g18, s3, gen18, [(),g2,g3] );;
      gap> e := GroupHomomorphismByImages( s3, g18, [g2,g3], [g2,g3] );;
      gap> C3 := Cat1( t, h, e );
      [g18=>s3]
      gap> SetName( Kernel(t), "c3" );;
      gap> X3 := XModOfCat1( C3 );;
      gap> Display( X3 );
      Crossed module [c3->s3] :-
      : Source group has generators:
        [ ( 1, 2, 3)( 4, 6, 5) ]
      : Range group has generators:
        [ (4,5,6), (2,3)(5,6) ]
      : Boundary homomorphism maps source generators to:
        [ (4,6,5) ]
      : Action homomorphism maps range generators to automorphisms:
        (4,5,6) --> { source gens --> [ (1,2,3)(4,6,5) ] }
        (2,3)(5,6) --> { source gens --> [ (1,3,2)(4,5,6) ] }
        These 2 automorphisms generate the group of automorphisms.
      : associated cat1-group is [g18=>s3]

      gap> imchi := [ (1,2,3)(4,6,5), (1,2,3)(4,6,5) ];;
      gap> chi := DerivationByImages( X3, imchi );
      DerivationByImages( s3, c3, [ (4,5,6), (2,3)(5,6) ],
      [ (1,2,3)(4,6,5), (1,2,3)(4,6,5) ] )

- `SectionByImages(` C, ims`) O`
- `SectionByDerivation(` chi`) O`
- `DerivationBySection(` xi`) O`

  Sections are group homomorphisms, so do not need a special representation. Operations `SectionByDerivation` and `DerivationBySection` convert derivations to sections, and vice-versa, calling `Cat1OfXMod` and `XModOfCat1` automatically.

  Two strategies for calculating derivations and sections are implemented, see AW1. The default method for `AllDerivations` is to search for all possible sets of images using a backtracking procedure, and when all the derivations are found it is not known which are regular. In the GAP 3 version of this package, the default method for `AllSections(` C`)` was to compute all endomorphisms on the range group R of C as possibilities for the composite h x. A backtrack method then found possible images for such a section. In the current version the derivations of the associated crossed module are calculated, and these are all converted to sections using `SectionByDerivation`.

      gap> xi := SectionByDerivation( chi );
      [ (4,5,6), (2,3)(5,6) ] -> [ (1,2,3), (1,2)(4,6) ]

  ## 4.2 Whitehead Groups and Monoids

- `RegularDerivations(` X0`) A`
- `AllDerivations(` X0`) A`
- `RegularSections(` C0`) A`
- `AllSections(` C0`) A`
- `ImagesList(` obj`) A`
- `ImagesTable(` obj`) A`

  There are two functions to determine the elements of the Whitehead group and the Whitehead monoid of X0, namely `RegularDerivations` and `AllDerivations`. (The functions `RegularSections` and `AllSections` perform corresponding tasks for a cat1-group.)

  Using our example `X3` we find that there are just nine derivations, six of them regular, and the associated group is isomorphic to `s3`.

      gap> all3 := AllDerivations( X3 );;
      gap> imall3 := ImagesList( all3 );; Display( imall3 );
      [ [ (), () ],
        [ (), ( 1, 2, 3)( 4, 6, 5) ],
        [ (), ( 1, 3, 2)( 4, 5, 6) ],
        [ ( 1, 2, 3)( 4, 6, 5), () ],
        [ ( 1, 2, 3)( 4, 6, 5), ( 1, 2, 3)( 4, 6, 5) ],
        [ ( 1, 2, 3)( 4, 6, 5), ( 1, 3, 2)( 4, 5, 6) ],
        [ ( 1, 3, 2)( 4, 5, 6), () ],
        [ ( 1, 3, 2)( 4, 5, 6), ( 1, 2, 3)( 4, 6, 5) ],
        [ ( 1, 3, 2)( 4, 5, 6), ( 1, 3, 2)( 4, 5, 6) ]
        ]
      gap> KnownAttributesOfObject( all3 );
      [ "Object2d", "ImagesList", "AllOrRegular", "ImagesTable" ]
      gap> Display( ImagesTable( all3 ) );
      [ [  1,  1,  1,  1,  1,  1 ],
        [  1,  1,  1,  2,  2,  2 ],
        [  1,  1,  1,  3,  3,  3 ],
        [  1,  2,  3,  1,  2,  3 ],
        [  1,  2,  3,  2,  3,  1 ],
        [  1,  2,  3,  3,  1,  2 ],
        [  1,  3,  2,  1,  3,  2 ],
        [  1,  3,  2,  2,  1,  3 ],
        [  1,  3,  2,  3,  2,  1 ] ]

- `CompositeDerivation(` chi1`,` chi2`) O`
- `ImagePositions(` chi`) A`

  The Whitehead multiplication c1 *c2 is implemented as `CompositeDerivation(` chi1`,` chi2`)`.

      gap> reg3 := RegularDerivations( X3 );;
      gap> imder3 := ImagesList( reg3 );;
      gap> chi4 := DerivationByImages( X3, imder3[4] );
      DerivationByImages( s3, c3, [ (4,5,6), (2,3)(5,6) ],
      [ ( 1, 3, 2)( 4, 5, 6), () ] )
      gap> chi5 := DerivationByImages( X3, imder3[5] );
      DerivationByImages( s3, c3, [ (4,5,6), (2,3)(5,6) ],
      [ ( 1, 3, 2)( 4, 5, 6), ( 1, 2, 3)( 4, 6, 5) ] )
      gap> im4 := ImagePositions( chi4 );
      [ 1, 3, 2, 1, 3, 2 ]
      gap> im5 := ImagePositions( chi5 );
      [ 1, 3, 2, 2, 1, 3 ]
      gap> chi45 := chi4 * chi5;
      DerivationByImages( s3, c3, [ (4,5,6), (2,3)(5,6) ],
      [ (), ( 1, 2, 3)( 4, 6, 5) ] )
      gap> im45 := ImagePositions( chi45 );
      [ 1, 1, 1, 2, 2, 2 ]
      gap> pos := Position( imder3, GeneratorImages( chi45 ) );
      2

- `WhiteheadGroupTable(` X0`) A`
- `WhiteheadMonoidTable(` X0`) A`
- `WhiteheadPermGroup(` X0`) A`
- `WhiteheadTransMonoid(` X0`) A`

  Multiplication tables for the Whitehead group or monoid enable the construction of permutation or transformation representations.

      gap> wgt3 := WhiteheadGroupTable( X3 );; Display( wgt3 );
      [ [  1,  2,  3,  4,  5,  6 ],
        [  2,  3,  1,  5,  6,  4 ],
        [  3,  1,  2,  6,  4,  5 ],
        [  4,  6,  5,  1,  3,  2 ],
        [  5,  4,  6,  2,  1,  3 ],
        [  6,  5,  4,  3,  2,  1 ] ]
      gap> wpg3 := WhiteheadPermGroup( X3 );
      Group([ (1,2,3)(4,5,6), (1,4)(2,6)(3,5) ])
      gap> wmt3 := WhiteheadMonoidTable( X3 );; Display( wmt3 );
      [ [  1,  2,  3,  4,  5,  6,  7,  8,  9 ],
        [  2,  3,  1,  5,  6,  4,  8,  9,  7 ],
        [  3,  1,  2,  6,  4,  5,  9,  7,  8 ],
        [  4,  4,  4,  4,  4,  4,  4,  4,  4 ],
        [  5,  5,  5,  5,  5,  5,  5,  5,  5 ],
        [  6,  6,  6,  6,  6,  6,  6,  6,  6 ],
        [  7,  9,  8,  4,  6,  5,  1,  3,  2 ],
        [  8,  7,  9,  5,  4,  6,  2,  1,  3 ],
        [  9,  8,  7,  6,  5,  4,  3,  2,  1 ] ]
      gap> wtm3 := WhiteheadTransMonoid( X3 );
      Monoid( [ Transformation( [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ),
        Transformation( [ 2, 3, 1, 5, 6, 4, 8, 9, 7 ] ),
        Transformation( [ 3, 1, 2, 6, 4, 5, 9, 7, 8 ] ),
        Transformation( [ 4, 4, 4, 4, 4, 4, 4, 4, 4 ] ),
        Transformation( [ 5, 5, 5, 5, 5, 5, 5, 5, 5 ] ),
        Transformation( [ 6, 6, 6, 6, 6, 6, 6, 6, 6 ] ),
        Transformation( [ 7, 9, 8, 4, 6, 5, 1, 3, 2 ] ),
        Transformation( [ 8, 7, 9, 5, 4, 6, 2, 1, 3 ] ),
        Transformation( [ 9, 8, 7, 6, 5, 4, 3, 2, 1 ] ) ], ... )

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