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

### 4. Derivations and Sections

#### 4.1 Whitehead Multiplication

##### 4.1-1 IsDerivation

`> IsDerivation`( map ) | ( property )

`> IsSection`( map ) | ( property )

`> IsUp2dMapping`( map ) | ( property )

The Whitehead monoid rm Der(mathcalX) of mathcalX was defined in [J48] to be the monoid of all derivations from R to S, that is the set of all maps chi : R -> S, with Whitehead multiplication star (on the right) satisfying:

\[ {\bf Der\ 1}: \chi(qr) ~=~ (\chi q)^{r} \; (\chi r), \qquad {\bf Der\ 2}: (\chi_1 \star \chi_2)(r) ~=~ (\chi_2 r)(\chi_1 r)(\chi_2 \partial \chi_1 r). \end{eqnarray*} \]

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

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

\[ {\bf Sect\ 1}: t \xi ~=~ {\rm id}_R, \quad {\bf Sect\ 2}: (\xi_1 \star \xi_2)(r) ~=~ (\xi_1 r)(e h \xi_1 r)^{-1}(\xi_2 h \xi_1 r) ~=~ (\xi_2 h \xi_1 r)(e h \xi_1 r)^{-1}(\xi_1 r). \]

The embedding e is the identity for this composition, and h(xi_1 star xi_2) = (h xi_1)(h xi_2). A section is regular when h xi is an automorphism, and the group of regular sections is isomorphic to the Whitehead group.

If epsilon denotes the inclusion of S = rm ker t in G then partial = h epsilon : S -> R and

\[ \xi r ~=~ (e r)(e \chi r) ~=~ (r, \chi r) \]

determines a section xi of mathcalC in terms of the corresponding derivation chi of mathcalX, and conversely.

##### 4.1-2 DerivationByImages

`> DerivationByImages`( X0, ims ) | ( operation )

`> Object2d`( chi ) | ( attribute )

`> GeneratorImages`( chi ) | ( attribute )

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 {\bf 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) ] )

##### 4.1-3 SectionByImages

`> SectionByImages`( C, ims ) | ( operation )

`> SectionByDerivation`( chi ) | ( operation )

`> DerivationBySection`( xi ) | ( operation )

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 [MC00]. 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 GAP3 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 xi. 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

##### 4.2-1 RegularDerivations

`> RegularDerivations`( X0 ) | ( attribute )

`> AllDerivations`( X0 ) | ( attribute )

`> RegularSections`( C0 ) | ( attribute )

`> AllSections`( C0 ) | ( attribute )

`> ImagesList`( obj ) | ( attribute )

`> ImagesTable`( obj ) | ( attribute )

There are two functions to determine the elements of the Whitehead group and the Whitehead monoid of mathcalX0, 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 ] ]

##### 4.2-2 CompositeDerivation

`> CompositeDerivation`( chi1, chi2 ) | ( operation )

`> ImagePositions`( chi ) | ( attribute )

`> CompositeSection`( xi1, xi2 ) | ( operation )

The Whitehead product chi_1 star chi_2 is implemented as `CompositeDerivation( <chi1>, <chi2> )`. The composite of two sections is just the composite of homomorphisms.

    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

##### 4.2-3 WhiteheadGroupTable

`> WhiteheadGroupTable`( X0 ) | ( attribute )

`> WhiteheadMonoidTable`( X0 ) | ( attribute )

`> WhiteheadPermGroup`( X0 ) | ( attribute )

`> WhiteheadTransMonoid`( X0 ) | ( attribute )

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

Top of Book | Previous Chapter | Next Chapter

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

generated by GAPDoc2HTML