chap5.txt

  
  5 Derivations and Sections
  
  
  5.1 Whitehead Multiplication
  
  5.1-1 IsDerivation
  
  IsDerivation( map )  property
  IsSection( map )  property
  IsUp2DimensionalMapping( map )  property
  
  The  Whitehead monoid Der(mathcalX) of mathcalX was defined in [Whi48] 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:
  
  
  {\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).
  
  
  
  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 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 ξ : R -> G, with Whitehead multiplication
  ⋆ (on the right) satisfying:
  
  
  {\bf Sect\ 1}: t \circ \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(ξ_1 ⋆ ξ_2) = (h
  ξ_1)(h ξ_2). A section is regular when h ξ is an automorphism, and the group
  of regular sections is isomorphic to the Whitehead group.
  
  If ϵ denotes the inclusion of S = ker t in G then ∂ = h ϵ : S -> R and
  
  
  \xi r ~=~ (e r)(e \chi r), \quad\mbox{which equals}\quad (r, \chi r) ~\in~ R
  \ltimes S,
  
  
  
  determines  a section ξ of mathcalC in terms of the corresponding derivation
  χ of mathcalX, and conversely.
  
  5.1-2 DerivationByImages
  
  DerivationByImages( X0, ims )  operation
  
  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.
  
    Example  
    
    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) ] )
    
  
  
  5.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
  [AW00].  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 early versions 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
  ξ.  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.
  
    Example  
    
    gap> xi := SectionByDerivation( chi );
    SectionByImages( s3, g18, [ (4,5,6), (2,3)(5,6) ], [ (1,2,3), (1,2)(4,6) ] )
    
  
  
  
  5.2 Whitehead Groups and Monoids
  
  5.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  a  crossed module, 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. (In fact,
  six  of  them  regular,  as we shall see in the next section. The associated
  group is isomorphic to the symmetric group s3.)
  
    Example  
    
    gap> all3 := AllDerivations( X3 );;
    gap> imall3 := ImagesList( all3 );; 
    gap> PrintListOneItemPerLine( imall3 );
    [ [ (), () ],
      [ (), (1,3,2)(4,5,6) ],
      [ (), (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,3,2)(4,5,6), (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,2,3)(4,6,5), (1,2,3)(4,6,5) ]
      ]
    gap> KnownAttributesOfObject( all3 );
    [ "Object2d", "ImagesList", "AllOrRegular", "ImagesTable" ]
    gap> PrintListOneItemPerLine( ImagesTable( all3 ) );
    [ [ 1, 1, 1, 1, 1, 1 ],
      [ 1, 1, 1, 3, 3, 3 ],
      [ 1, 1, 1, 2, 2, 2 ],
      [ 1, 3, 2, 1, 3, 2 ],
      [ 1, 3, 2, 3, 2, 1 ],
      [ 1, 3, 2, 2, 1, 3 ],
      [ 1, 2, 3, 1, 2, 3 ],
      [ 1, 2, 3, 3, 1, 2 ],
      [ 1, 2, 3, 2, 3, 1 ]
      ]
    
  
  
  5.2-2 CompositeDerivation
  
  CompositeDerivation( chi1, chi2 )  operation
  UpImagePositions( chi )  attribute
  UpGeneratorImages( chi )  attribute
  CompositeSection( xi1, xi2 )  operation
  
  The     Whitehead     product     χ_1    ⋆    χ_2    is    implemented    as
  CompositeDerivation(<chi1>,<chi2>).  The  composite  of two sections is just
  the composite of homomorphisms.
  
    Example  
    
    gap> reg3 := RegularDerivations( X3 );;
    gap> imder3 := ImagesList( reg3 );;  Length( imder3 );
    6
    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,3,2)(4,5,6) ] )
    gap> im4 := UpImagePositions( chi4 );
    [ 1, 3, 2, 1, 3, 2 ]
    gap> im5 := UpImagePositions( chi5 );
    [ 1, 3, 2, 3, 2, 1 ]
    gap> chi45 := chi4 * chi5;
    DerivationByImages( s3, c3, [ (4,5,6), (2,3)(5,6) ], [ (), (1,3,2)(4,5,6) ] )
    gap> im45 := UpImagePositions( chi45 );
    [ 1, 1, 1, 3, 3, 3 ]
    gap> Position( imder3, UpGeneratorImages( chi45 ) );
    2
    
  
  
  5.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.
  
    Example  
    
    gap> wgt3 := WhiteheadGroupTable( X3 );; 
    gap> PrintListOneItemPerLine( 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 );; 
    gap> PrintListOneItemPerLine( 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, 6, 5, 1, 3, 2, 7, 9, 8 ],
      [ 5, 4, 6, 2, 1, 3, 8, 7, 9 ],
      [ 6, 5, 4, 3, 2, 1, 9, 8, 7 ],
      [ 7, 7, 7, 7, 7, 7, 7, 7, 7 ],
      [ 8, 8, 8, 8, 8, 8, 8, 8, 8 ],
      [ 9, 9, 9, 9, 9, 9, 9, 9, 9 ]
      ]
    gap> wtm3 := WhiteheadTransMonoid( X3 );
    <transformation monoid on 9 pts with 3 generators>
    gap> GeneratorsOfMonoid( wtm3 ); 
    [ Transformation( [ 2, 3, 1, 5, 6, 4, 8, 9, 7 ] ), 
      Transformation( [ 4, 6, 5, 1, 3, 2, 7, 9, 8 ] ), 
      Transformation( [ 7, 7, 7, 7, 7, 7, 7, 7, 7 ] ) ]