dwww Home | Show directory contents | Find package

  
  7 Higher level methods for pcp-groups
  
  This  is  a  description  of  some  higher level functions of the Polycyclic
  package  of  GAP 4. Throughout this chapter we let G be a pc-presented group
  and  we consider algorithms for subgroups U and V of G. For background and a
  description of the underlying algorithms we refer to [Eic01a].
  
  
  7.1 Subgroup series in pcp-groups
  
  Many  algorithm  for  pcp-groups work by induction using some series through
  the  group.  In  this  section  we  provide  a  number  of useful series for
  pcp-groups. An efa series is a normal series with elementary or free abelian
  factors.  See  [Eic00]  for  outlines  on  the algorithms of a number of the
  available series.
  
  7.1-1 PcpSeries
  
  PcpSeries( U )  function
  
  returns the polycyclic series of U defined by an igs of U.
  
  7.1-2 EfaSeries
  
  EfaSeries( U )  attribute
  
  returns a normal series of U with elementary or free abelian factors.
  
  7.1-3 SemiSimpleEfaSeries
  
  SemiSimpleEfaSeries( U )  attribute
  
  returns  an  efa  series  of  U  such  that  every  factor  in the series is
  semisimple as a module for U over a finite field or over the rationals.
  
  7.1-4 DerivedSeriesOfGroup
  
  DerivedSeriesOfGroup( U )  method
  
  the derived series of U.
  
  7.1-5 RefinedDerivedSeries
  
  RefinedDerivedSeries( U )  function
  
  the  derived  series of U refined to an efa series such that in each abelian
  factor of the derived series the free abelian factor is at the top.
  
  7.1-6 RefinedDerivedSeriesDown
  
  RefinedDerivedSeriesDown( U )  function
  
  the  derived  series of U refined to an efa series such that in each abelian
  factor of the derived series the free abelian factor is at the bottom.
  
  7.1-7 LowerCentralSeriesOfGroup
  
  LowerCentralSeriesOfGroup( U )  method
  
  the  lower  central  series  of  U.  If  U does not have a largest nilpotent
  quotient group, then this function may not terminate.
  
  7.1-8 UpperCentralSeriesOfGroup
  
  UpperCentralSeriesOfGroup( U )  method
  
  the  upper  central series of U. This function always terminates, but it may
  terminate at a proper subgroup of U.
  
  7.1-9 TorsionByPolyEFSeries
  
  TorsionByPolyEFSeries( U )  function
  
  returns an efa series of U such that all torsion-free factors are at the top
  and  all finite factors are at the bottom. Such a series might not exist for
  U and in this case the function returns fail.
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(5);
    Pcp-group with orders [ 2, 0, 0, 0 ]
    gap> Igs(G);
    [ g1, g2, g3, g4 ]
    
    gap> PcpSeries(G);
    [ Pcp-group with orders [ 2, 0, 0, 0 ],
      Pcp-group with orders [ 0, 0, 0 ],
      Pcp-group with orders [ 0, 0 ],
      Pcp-group with orders [ 0 ],
      Pcp-group with orders [  ] ]
    
    gap> List( PcpSeries(G), Igs );
    [ [ g1, g2, g3, g4 ], [ g2, g3, g4 ], [ g3, g4 ], [ g4 ], [  ] ]
  
  
  Algorithms  for  pcp-groups  often use an efa series of G and work down over
  the  factors  of  this series. Usually, pcp's of the factors are more useful
  than the actual factors. Hence we provide the following.
  
  7.1-10 PcpsBySeries
  
  PcpsBySeries( ser[, flag] )  function
  
  returns  a  list of pcp's corresponding to the factors of the series. If the
  parameter  flag  is  present  and  equals  the  string  snf,  then  each pcp
  corresponds to a decomposition of the abelian groups into direct factors.
  
  7.1-11 PcpsOfEfaSeries
  
  PcpsOfEfaSeries( U )  attribute
  
  returns a list of pcps corresponding to an efa series of U.
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(5);
    Pcp-group with orders [ 2, 0, 0, 0 ]
    
    gap> PcpsBySeries( DerivedSeriesOfGroup(G));
    [ Pcp [ g1, g2, g3, g4 ] with orders [ 2, 2, 2, 2 ],
      Pcp [ g2^-2, g3^-2, g4^2 ] with orders [ 0, 0, 4 ],
      Pcp [ g4^8 ] with orders [ 0 ] ]
    gap> PcpsBySeries( RefinedDerivedSeries(G));
    [ Pcp [ g1, g2, g3 ] with orders [ 2, 2, 2 ],
      Pcp [ g4 ] with orders [ 2 ],
      Pcp [ g2^2, g3^2 ] with orders [ 0, 0 ],
      Pcp [ g4^2 ] with orders [ 2 ],
      Pcp [ g4^4 ] with orders [ 2 ],
      Pcp [ g4^8 ] with orders [ 0 ] ]
    
    gap> PcpsBySeries( DerivedSeriesOfGroup(G), "snf" );
    [ Pcp [ g2, g3, g1 ] with orders [ 2, 2, 4 ],
      Pcp [ g4^2, g3^-2, g2^2*g4^2 ] with orders [ 4, 0, 0 ],
      Pcp [ g4^8 ] with orders [ 0 ] ]
    gap> G.1^4 in DerivedSubgroup( G );
    true
    gap> G.1^2 = G.4;
    true
    
    gap>  PcpsOfEfaSeries( G );
    [ Pcp [ g1 ] with orders [ 2 ],
      Pcp [ g2 ] with orders [ 0 ],
      Pcp [ g3 ] with orders [ 0 ],
      Pcp [ g4 ] with orders [ 0 ] ]
  
  
  
  7.2 Orbit stabilizer methods for pcp-groups
  
  Let  U be a pcp-group which acts on a set [122ΩX. One of the fundamental problems
  in  algorithmic  group theory is the determination of orbits and stabilizers
  of  points  in  [122ΩX  under the action of U. We distinguish two cases: the case
  that  all  considered orbits are finite and the case that there are infinite
  orbits.  In  the latter case, an orbit cannot be listed and a description of
  the orbit and its corresponding stabilizer is much harder to obtain.
  
  If the considered orbits are finite, then the following two functions can be
  applied   to   compute   the   considered  orbits  and  their  corresponding
  stabilizers.
  
  7.2-1 PcpOrbitStabilizer
  
  PcpOrbitStabilizer( point, gens, acts, oper )  function
  PcpOrbitsStabilizers( points, gens, acts, oper )  function
  
  The  input gens can be an igs or a pcp of a pcp-group U. The elements in the
  list  gens act as the elements in the list acts via the function oper on the
  given points; that is, oper( point, acts[i] ) applies the ith generator to a
  given  point.  Thus the group defined by acts must be a homomorphic image of
  the  group  defined  by gens. The first function returns a record containing
  the  orbit  as component 'orbit' and and igs for the stabilizer as component
  'stab'.  The second function returns a list of records, each record contains
  'repr' and 'stab'. Both of these functions run forever on infinite orbits.
  
    Example  
    gap> G := DihedralPcpGroup( 0 );
    Pcp-group with orders [ 2, 0 ]
    gap> mats := [ [[-1,0],[0,1]], [[1,1],[0,1]] ];;
    gap> pcp := Pcp(G);
    Pcp [ g1, g2 ] with orders [ 2, 0 ]
    gap> PcpOrbitStabilizer( [0,1], pcp, mats, OnRight );
    rec( orbit := [ [ 0, 1 ] ],
         stab := [ g1, g2 ],
         word := [ [ [ 1, 1 ] ], [ [ 2, 1 ] ] ] )
  
  
  If the considered orbits are infinite, then it may not always be possible to
  determine  a  description  of  the orbits and their stabilizers. However, as
  shown  in  [EO02]  and  [Eic02], it is possible to determine stabilizers and
  check if two elements are contained in the same orbit if the given action of
  the  polycyclic  group  is a unimodular linear action on a vector space. The
  following functions are available for this case.
  
  7.2-2 StabilizerIntegralAction
  
  StabilizerIntegralAction( U, mats, v )  function
  OrbitIntegralAction( U, mats, v, w )  function
  
  The  first  function  computes the stabilizer in U of the vector v where the
  pcp  group  U acts via mats on an integral space and v and w are elements in
  this  integral  space. The second function checks whether v and w are in the
  same  orbit  and the function returns either false or a record containing an
  element in U mapping v to w and the stabilizer of v.
  
  7.2-3 NormalizerIntegralAction
  
  NormalizerIntegralAction( U, mats, B )  function
  ConjugacyIntegralAction( U, mats, B, C )  function
  
  The  first  function  computes  the  normalizer in U of the lattice with the
  basis B, where the pcp group U acts via mats on an integral space and B is a
  subspace of this integral space. The second functions checks whether the two
  lattices with the bases B and C are contained in the same orbit under U. The
  function  returns either false or a record with an element in U mapping B to
  C and the stabilizer of B.
  
    Example  
    # get a pcp group and a free abelian normal subgroup
    gap> G := ExamplesOfSomePcpGroups(8);
    Pcp-group with orders [ 0, 0, 0, 0, 0 ]
    gap> efa := EfaSeries(G);
    [ Pcp-group with orders [ 0, 0, 0, 0, 0 ],
      Pcp-group with orders [ 0, 0, 0, 0 ],
      Pcp-group with orders [ 0, 0, 0 ],
      Pcp-group with orders [  ] ]
    gap> N := efa[3];
    Pcp-group with orders [ 0, 0, 0 ]
    gap> IsFreeAbelian(N);
    true
    
    # create conjugation action on N
    gap> mats := LinearActionOnPcp(Igs(G), Pcp(N));
    [ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
      [ [ 0, 0, 1 ], [ 1, -1, 1 ], [ 0, 1, 0 ] ],
      [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
      [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
      [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] ]
    
    # take an arbitrary vector and compute its stabilizer
    gap> StabilizerIntegralAction(G,mats, [2,3,4]);
    Pcp-group with orders [ 0, 0, 0, 0 ]
    gap> Igs(last);
    [ g1, g3, g4, g5 ]
    
    # check orbits with some other vectors
    gap> OrbitIntegralAction(G,mats, [2,3,4],[3,1,5]);
    rec( stab := Pcp-group with orders [ 0, 0, 0, 0 ], prei := g2 )
    
    gap> OrbitIntegralAction(G,mats, [2,3,4], [4,6,8]);
    false
    
    # compute the orbit of a subgroup of Z^3 under the action of G
    gap> NormalizerIntegralAction(G, mats, [[1,0,0],[0,1,0]]);
    Pcp-group with orders [ 0, 0, 0, 0, 0 ]
    gap> Igs(last);
    [ g1, g2^2, g3, g4, g5 ]
  
  
  
  7.3 Centralizers, Normalizers and Intersections
  
  In  this  section we list a number of operations for which there are methods
  installed to compute the corresponding features in polycyclic groups.
  
  7.3-1 Centralizer
  
  Centralizer( U, g )  method
  IsConjugate( U, g, h )  method
  
  These  functions  solve the conjugacy problem for elements in pcp-groups and
  they  can  be  used  to  compute  centralizers.  The  first method returns a
  subgroup  of  the  given  group  U,  the  second  method  either  returns  a
  conjugating element or false if no such element exists.
  
  The  methods  are  based  on  the  orbit  stabilizer algorithms described in
  [EO02].  For  nilpotent  groups, an algorithm to solve the conjugacy problem
  for elements is described in [Sim94].
  
  7.3-2 Centralizer
  
  Centralizer( U, V )  method
  Normalizer( U, V )  method
  IsConjugate( U, V, W )  method
  
  These  three functions solve the conjugacy problem for subgroups and compute
  centralizers  and  normalizers  of subgroups. The first two functions return
  subgroups  of  the  input  group U, the third function returns a conjugating
  element or false if no such element exists.
  
  The  methods  are  based  on  the  orbit  stabilizer algorithms described in
  [Eic02].  For nilpotent groups, an algorithm to solve the conjugacy problems
  for subgroups is described in [Lo98b].
  
  7.3-3 Intersection
  
  Intersection( U, N )  function
  
  A  general  method  to  compute intersections of subgroups of a pcp-group is
  described  in  [Eic01a],  but  it  is  not  yet  implemented  here. However,
  intersections  of  subgroups U, N ≤ G can be computed if N is normalising U.
  See [Sim94] for an outline of the algorithm.
  
  
  7.4 Finite subgroups
  
  There  are  various  finite  subgroups of interest in polycyclic groups. See
  [Eic00] for a description of the algorithms underlying the functions in this
  section.
  
  7.4-1 TorsionSubgroup
  
  TorsionSubgroup( U )  attribute
  
  If the set of elements of finite order forms a subgroup, then we call it the
  torsion  subgroup. This function determines the torsion subgroup of U, if it
  exists, and returns fail otherwise. Note that a torsion subgroup does always
  exist if U is nilpotent.
  
  7.4-2 NormalTorsionSubgroup
  
  NormalTorsionSubgroup( U )  attribute
  
  Each  polycyclic  groups  has  a unique largest finite normal subgroup. This
  function computes it for U.
  
  7.4-3 IsTorsionFree
  
  IsTorsionFree( U )  property
  
  This function checks if U is torsion free. It returns true or false.
  
  7.4-4 FiniteSubgroupClasses
  
  FiniteSubgroupClasses( U )  attribute
  
  There  exist  only  finitely many conjugacy classes of finite subgroups in a
  polycyclic  group  U  and  this  function  can  be used to compute them. The
  algorithm  underlying this function proceeds by working down a normal series
  of  U with elementary or free abelian factors. The following function can be
  used to give the algorithm a specific series.
  
  7.4-5 FiniteSubgroupClassesBySeries
  
  FiniteSubgroupClassesBySeries( U, pcps )  function
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(15);
    Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 0 ]
    gap> TorsionSubgroup(G);
    Pcp-group with orders [ 5, 2 ]
    gap> NormalTorsionSubgroup(G);
    Pcp-group with orders [ 5, 2 ]
    gap> IsTorsionFree(G);
    false
    gap> FiniteSubgroupClasses(G);
    [ Pcp-group with orders [ 5, 2 ]^G,
      Pcp-group with orders [ 2 ]^G,
      Pcp-group with orders [ 5 ]^G,
      Pcp-group with orders [  ]^G ]
    
    gap> G := DihedralPcpGroup( 0 );
    Pcp-group with orders [ 2, 0 ]
    gap> TorsionSubgroup(G);
    fail
    gap> NormalTorsionSubgroup(G);
    Pcp-group with orders [  ]
    gap> IsTorsionFree(G);
    false
    gap> FiniteSubgroupClasses(G);
    [ Pcp-group with orders [ 2 ]^G,
      Pcp-group with orders [ 2 ]^G,
      Pcp-group with orders [  ]^G ]
  
  
  
  7.5 Subgroups of finite index and maximal subgroups
  
  Here  we outline functions to determine various types of subgroups of finite
  index  in  polycyclic  groups.  Again,  see [Eic00] for a description of the
  algorithms  underlying  the  functions  in  this  section. Also, we refer to
  [Lo98a] for an alternative approach.
  
  7.5-1 MaximalSubgroupClassesByIndex
  
  MaximalSubgroupClassesByIndex( U, p )  operation
  
  Each  maximal  subgroup  of  a polycyclic group U has p-power index for some
  prime p. This function can be used to determine the conjugacy classes of all
  maximal subgroups of p-power index for a given prime p.
  
  7.5-2 LowIndexSubgroupClasses
  
  LowIndexSubgroupClasses( U, n )  operation
  
  There  are  only  finitely  many  subgroups of a given index in a polycyclic
  group  U. This function computes conjugacy classes of all subgroups of index
  n in U.
  
  7.5-3 LowIndexNormalSubgroups
  
  LowIndexNormalSubgroups( U, n )  operation
  
  This function computes the normal subgroups of index n in U.
  
  7.5-4 NilpotentByAbelianNormalSubgroup
  
  NilpotentByAbelianNormalSubgroup( U )  function
  
  This  function  returns a normal subgroup N of finite index in U such that N
  is  nilpotent-by-abelian.  Such  a subgroup exists in every polycyclic group
  and this function computes such a subgroup using LowIndexNormal. However, we
  note   that   this   function   is  not  very  efficient  and  the  function
  NilpotentByAbelianByFiniteSeries may well be more efficient on this task.
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(2);
    Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ]
    
    gap> MaximalSubgroupClassesByIndex( G, 61 );;
    gap> max := List( last, Representative );;
    gap> List( max, x -> Index( G, x ) );
    [ 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61, 226981 ]
    
    gap> LowIndexSubgroupClasses( G, 61 );;
    gap> low := List( last, Representative );;
    gap> List( low, x -> Index( G, x ) );
    [ 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
      61, 61, 61, 61, 61, 61 ]
  
  
  
  7.6 Further attributes for pcp-groups based on the Fitting subgroup
  
  In  this  section  we  provide a variety of other attributes for pcp-groups.
  Most  of  the  methods below are based or related to the Fitting subgroup of
  the  given  group.  We refer to [Eic01b] for a description of the underlying
  methods.
  
  7.6-1 FittingSubgroup
  
  FittingSubgroup( U )  attribute
  
  returns  the  Fitting  subgroup  of U; that is, the largest nilpotent normal
  subgroup of U.
  
  7.6-2 IsNilpotentByFinite
  
  IsNilpotentByFinite( U )  property
  
  checks whether the Fitting subgroup of U has finite index.
  
  7.6-3 Centre
  
  Centre( U )  method
  
  returns the centre of U.
  
  7.6-4 FCCentre
  
  FCCentre( U )  method
  
  returns  the  FC-centre  of U; that is, the subgroup containing all elements
  having a finite conjugacy class in U.
  
  7.6-5 PolyZNormalSubgroup
  
  PolyZNormalSubgroup( U )  function
  
  returns  a  normal  subgroup  N  of  finite  index  in  U, such that N has a
  polycyclic series with infinite factors only.
  
  7.6-6 NilpotentByAbelianByFiniteSeries
  
  NilpotentByAbelianByFiniteSeries( U )  function
  
  returns  a  normal  series  1  ≤  F ≤ A ≤ U such that F is nilpotent, A/F is
  abelian  and  U/A  is  finite.  This  series  is  computed using the Fitting
  subgroup and the centre of the Fitting factor.
  
  
  7.7 Functions for nilpotent groups
  
  There  are  (very  few)  functions  which are available for nilpotent groups
  only. First, there are the different central series. These are available for
  all  groups,  but  for  nilpotent  groups  they terminate and provide series
  through  the full group. Secondly, the determination of a minimal generating
  set is available for nilpotent groups only.
  
  7.7-1 MinimalGeneratingSet
  
  MinimalGeneratingSet( U )  method
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(14);
    Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 0, 5, 5, 4, 0, 6,
      5, 5, 4, 0, 10, 6 ]
    gap> IsNilpotent(G);
    true
    
    gap> PcpsBySeries( LowerCentralSeriesOfGroup(G));
    [ Pcp [ g1, g2 ] with orders [ 0, 0 ],
      Pcp [ g3 ] with orders [ 0 ],
      Pcp [ g4 ] with orders [ 0 ],
      Pcp [ g5 ] with orders [ 0 ],
      Pcp [ g6, g7 ] with orders [ 0, 0 ],
      Pcp [ g8 ] with orders [ 0 ],
      Pcp [ g9, g10 ] with orders [ 0, 0 ],
      Pcp [ g11, g12, g13 ] with orders [ 5, 4, 0 ],
      Pcp [ g14, g15, g16, g17, g18 ] with orders [ 5, 5, 4, 0, 6 ],
      Pcp [ g19, g20, g21, g22, g23, g24 ] with orders [ 5, 5, 4, 0, 10, 6 ] ]
    
    gap> PcpsBySeries( UpperCentralSeriesOfGroup(G));
    [ Pcp [ g1, g2 ] with orders [ 0, 0 ],
      Pcp [ g3 ] with orders [ 0 ],
      Pcp [ g4 ] with orders [ 0 ],
      Pcp [ g5 ] with orders [ 0 ],
      Pcp [ g6, g7 ] with orders [ 0, 0 ],
      Pcp [ g8 ] with orders [ 0 ],
      Pcp [ g9, g10 ] with orders [ 0, 0 ],
      Pcp [ g11, g12, g13 ] with orders [ 5, 4, 0 ],
      Pcp [ g14, g15, g16, g17, g18 ] with orders [ 5, 5, 4, 0, 6 ],
      Pcp [ g19, g20, g21, g22, g23, g24 ] with orders [ 5, 5, 4, 0, 10, 6 ] ]
    
    gap> MinimalGeneratingSet(G);
    [ g1, g2 ]
  
  
  
  7.8 Random methods for pcp-groups
  
  Below  we  introduce  a function which computes orbit and stabilizer using a
  random  method.  This  function  tries  to  approximate  the  orbit  and the
  stabilizer,  but  the  returned  orbit or stabilizer may be incomplete. This
  function   is  used  in  the  random  methods  to  compute  normalizers  and
  centralizers.  Note  that  deterministic methods for these purposes are also
  available.
  
  7.8-1 RandomCentralizerPcpGroup
  
  RandomCentralizerPcpGroup( U, g )  function
  RandomCentralizerPcpGroup( U, V )  function
  RandomNormalizerPcpGroup( U, V )  function
  
    Example  
    gap> G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap> mats := [[[-1, 0],[0,1]], [[1,1],[0,1]]];
    [ [ [ -1, 0 ], [ 0, 1 ] ], [ [ 1, 1 ], [ 0, 1 ] ] ]
    gap> pcp := Pcp(G);
    Pcp [ g1, g2 ] with orders [ 2, 0 ]
    
    gap> RandomPcpOrbitStabilizer( [1,0], pcp, mats, OnRight ).stab;
    #I  Orbit longer than limit: exiting.
    [  ]
    
    gap> g := Igs(G)[1];
    g1
    gap> RandomCentralizerPcpGroup( G, g );
    #I  Stabilizer not increasing: exiting.
    Pcp-group with orders [ 2 ]
    gap> Igs(last);
    [ g1 ]
  
  
  
  7.9 Non-abelian tensor product and Schur extensions
  
  7.9-1 SchurExtension
  
  SchurExtension( G )  attribute
  
  Let G be a polycyclic group with a polycyclic generating sequence consisting
  of  n  elements. This function computes the largest central extension H of G
  such  that H is generated by n elements. If F/R is the underlying polycyclic
  presentation for G, then H is isomorphic to F/[R,F].
  
    Example  
    gap> G := DihedralPcpGroup( 0 );
    Pcp-group with orders [ 2, 0 ]
    gap> Centre( G );
    Pcp-group with orders [  ]
    gap> H := SchurExtension( G );
    Pcp-group with orders [ 2, 0, 0, 0 ]
    gap> Centre( H );
    Pcp-group with orders [ 0, 0 ]
    gap> H/Centre(H);
    Pcp-group with orders [ 2, 0 ]
    gap> Subgroup( H, [H.1,H.2] ) = H;
    true
  
  
  7.9-2 SchurExtensionEpimorphism
  
  SchurExtensionEpimorphism( G )  attribute
  
  returns  the  projection  from  the Schur extension G^* of G onto G. See the
  function  SchurExtension.  The  kernel  of  this  epimorphism  is the direct
  product  of the Schur multiplicator of G and a direct product of n copies of
  [122ℤX  where n is the number of generators in the polycyclic presentation for G.
  The  Schur  multiplicator  is the intersection of the kernel and the derived
  group of the source. See also the function SchurCover.
  
    Example  
    gap> gl23 := Range( IsomorphismPcpGroup( GL(2,3) ) );
    Pcp-group with orders [ 2, 3, 2, 2, 2 ]
    gap> SchurExtensionEpimorphism( gl23 );
    [ g1, g2, g3, g4, g5, g6, g7, g8, g9, g10 ] -> [ g1, g2, g3, g4, g5,
    id, id, id, id, id ]
    gap> Kernel( last );
    Pcp-group with orders [ 0, 0, 0, 0, 0 ]
    gap> AbelianInvariantsMultiplier( gl23 );
    [  ]
    gap> Intersection( Kernel(epi), DerivedSubgroup( Source(epi) ) );
    [  ]
  
  
  There  is a crossed pairing from G into (G^*)' which can be defined via this
  epimorphism:
  
    Example  
    gap> G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap> epi := SchurExtensionEpimorphism( G );
    [ g1, g2, g3, g4 ] -> [ g1, g2, id, id ]
    gap> PreImagesRepresentative( epi, G.1 );
    g1
    gap> PreImagesRepresentative( epi, G.2 );
    g2
    gap> Comm( last, last2 );
    g2^-2*g4
  
  
  7.9-3 SchurCover
  
  SchurCover( G )  function
  
  computes  a Schur covering group of the polycyclic group G. A Schur covering
  is  a  largest  central  extension  H  of  G  such  that the kernel M of the
  projection of H onto G is contained in the commutator subgroup of H.
  
  If  G is given by a presentation F/R, then M is isomorphic to the subgroup R
  ∩ [F,F] / [R,F]. Let C be a complement to R ∩ [F,F] / [R,F] in R/[R,F]. Then
  F/C is isomorphic to H and R/C is isomorphic to M.
  
    Example  
    gap> G := AbelianPcpGroup( 3,[] );
    Pcp-group with orders [ 0, 0, 0 ]
    gap> ext := SchurCover( G );
    Pcp-group with orders [ 0, 0, 0, 0, 0, 0 ]
    gap> Centre( ext );
    Pcp-group with orders [ 0, 0, 0 ]
    gap> IsSubgroup( DerivedSubgroup( ext ), last );
    true
  
  
  7.9-4 AbelianInvariantsMultiplier
  
  AbelianInvariantsMultiplier( G )  attribute
  
  returns a list of the abelian invariants of the Schur multiplier of G.
  
  Note  that  the  Schur  multiplicator  of  a  polycyclic group is a finitely
  generated abelian group.
  
    Example  
    gap> G := DihedralPcpGroup( 0 );
    Pcp-group with orders [ 2, 0 ]
    gap> DirectProduct( G, AbelianPcpGroup( 2, [] ) );
    Pcp-group with orders [ 0, 0, 2, 0 ]
    gap> AbelianInvariantsMultiplier( last );
    [ 0, 2, 2, 2, 2 ]
  
  
  7.9-5 NonAbelianExteriorSquareEpimorphism
  
  NonAbelianExteriorSquareEpimorphism( G )  function
  
  returns  the  epimorphism of the non-abelian exterior square of a polycyclic
  group  G onto the derived group of G. The non-abelian exterior square can be
  defined  as the derived subgroup of a Schur cover of G. The isomorphism type
  of  the  non-abelian  exterior  square  is  unique despite the fact that the
  isomorphism type of a Schur cover of a polycyclic groups need not be unique.
  The derived group of a Schur cover has a natural projection onto the derived
  group of G which is what the function returns.
  
  The kernel of the epimorphism is isomorphic to the Schur multiplicator of G.
  
    Example  
    gap> G := ExamplesOfSomePcpGroups( 3 );
    Pcp-group with orders [ 0, 0 ]
    gap> G := DirectProduct( G,G );
    Pcp-group with orders [ 0, 0, 0, 0 ]
    gap> AbelianInvariantsMultiplier( G );
    [ [ 0, 1 ], [ 2, 3 ] ]
    gap> epi := NonAbelianExteriorSquareEpimorphism( G );
    [ g2^-2*g5, g4^-2*g10, g6, g7, g8, g9 ] -> [ g2^-2, g4^-2, id, id, id, id ]
    gap> Kernel( epi );
    Pcp-group with orders [ 0, 2, 2, 2 ]
    gap> Collected( AbelianInvariants( last ) );
    [ [ 0, 1 ], [ 2, 3 ] ]
  
  
  7.9-6 NonAbelianExteriorSquare
  
  NonAbelianExteriorSquare( G )  attribute
  
  computes  the  non-abelian  exterior  square of a polycylic group G. See the
  explanation  for NonAbelianExteriorSquareEpimorphism. The natural projection
  of  the non-abelian exterior square onto the derived group of G is stored in
  the component !.epimorphism.
  
  There   is   a   crossed  pairing  from  G  into  G∧  G.  See  the  function
  SchurExtensionEpimorphism  for details. The crossed pairing is stored in the
  component !.crossedPairing. This is the crossed pairing [122λX in [EN08].
  
    Example  
    gap> G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap> GwG := NonAbelianExteriorSquare( G );
    Pcp-group with orders [ 0 ]
    gap> lambda := GwG!.crossedPairing;
    function( g, h ) ... end
    gap> lambda( G.1, G.2 );
    g2^2*g4^-1
  
  
  7.9-7 NonAbelianTensorSquareEpimorphism
  
  NonAbelianTensorSquareEpimorphism( G )  function
  
  returns  for  a  polycyclic group G the projection of the non-abelian tensor
  square  G⊗  G  onto  the non-abelian exterior square G∧ G. The range of that
  epimorphism  has  the  component  !.epimorphism set to the projection of the
  non-abelian  exterior  square  onto  the  derived  group  of G. See also the
  function NonAbelianExteriorSquare.
  
  With  the  result  of  this  function  one  can  compute  the  groups in the
  commutative  diagram at the beginning of the paper [EN08]. The kernel of the
  returned  epimorphism  is  the  group ∇(G). The kernel of the composition of
  this epimorphism and the above mention projection onto G' is the group J(G).
  
    Example  
    gap> G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap> G := DirectProduct(G,G);
    Pcp-group with orders [ 2, 0, 2, 0 ]
    gap> alpha := NonAbelianTensorSquareEpimorphism( G );
    [ g9*g25^-1, g10*g26^-1, g11*g27, g12*g28, g13*g29, g14*g30, g15, g16,
    g17,
      g18, g19, g20, g21, g22, g23, g24 ] -> [ g2^-2*g6, g4^-2*g12, g8,
      g9, g10,
      g11, id, id, id, id, id, id, id, id, id, id ]
    gap> gamma := Range( alpha )!.epimorphism;
    [ g2^-2*g6, g4^-2*g12, g8, g9, g10, g11 ] -> [ g2^-2, g4^-2, id, id,
    id, id ]
    gap> JG := Kernel( alpha * gamma );
    Pcp-group with orders [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ]
    gap> Image( alpha, JG );
    Pcp-group with orders [ 2, 2, 2, 2 ]
    gap> AbelianInvariantsMultiplier( G );
    [ [ 2, 4 ] ]
  
  
  7.9-8 NonAbelianTensorSquare
  
  NonAbelianTensorSquare( G )  attribute
  
  computes for a polycyclic group G the non-abelian tensor square G⊗ G.
  
    Example  
    gap> G := AlternatingGroup( IsPcGroup, 4 );
    <pc group of size 12 with 3 generators>
    gap> PcGroupToPcpGroup( G );
    Pcp-group with orders [ 3, 2, 2 ]
    gap> NonAbelianTensorSquare( last );
    Pcp-group with orders [ 2, 2, 2, 3 ]
    gap> PcpGroupToPcGroup( last );
    <pc group of size 24 with 4 generators>
    gap> DirectFactorsOfGroup( last );
    [ Group([ f1, f2, f3 ]), Group([ f4 ]) ]
    gap> List( last, Size );
    [ 8, 3 ]
    gap> IdGroup( last2[1] );
    [ 8, 4 ]       # the quaternion group of Order 8
    
    gap> G := DihedralPcpGroup( 0 );
    Pcp-group with orders [ 2, 0 ]
    gap> ten := NonAbelianTensorSquare( G );
    Pcp-group with orders [ 0, 2, 2, 2 ]
    gap> IsAbelian( ten );
    true
  
  
  7.9-9 NonAbelianExteriorSquarePlusEmbedding
  
  NonAbelianExteriorSquarePlusEmbedding( G )  function
  
  returns  an  embedding  from  the  non-abelian  exterior square G∧ G into an
  extensions  of G∧ G by G× G. For the significance of the group see the paper
  [EN08]. The range of the epimorphism is the group τ(G) in that paper.
  
  7.9-10 NonAbelianTensorSquarePlusEpimorphism
  
  NonAbelianTensorSquarePlusEpimorphism( G )  function
  
  returns an epimorphisms of ν(G) onto τ(G). The group ν(G) is an extension of
  the  non-abelian  tensor  square  G⊗  G  of  G by G× G. The group τ(G) is an
  extension  of  the non-abelian exterior square G∧ G by G× G. For details see
  [EN08].
  
  7.9-11 NonAbelianTensorSquarePlus
  
  NonAbelianTensorSquarePlus( G )  function
  
  returns the group ν(G) in [EN08].
  
  7.9-12 WhiteheadQuadraticFunctor
  
  WhiteheadQuadraticFunctor( G )  function
  
  returns  Whitehead's  universal  quadratic  functor  of  G, see [EN08] for a
  description.
  
  
  7.10 Schur covers
  
  This  section  contains a function to determine the Schur covers of a finite
  p-group up to isomorphism.
  
  7.10-1 SchurCovers
  
  SchurCovers( G )  function
  
  Let  G  be  a finite p-group defined as a pcp group. This function returns a
  complete  and irredundant set of isomorphism types of Schur covers of G. The
  algorithm implements a method of Nickel's Phd Thesis.

Generated by dwww version 1.15 on Sun Jun 16 09:39:03 CEST 2024.