Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  45 Polycyclic Groups
  
  A  group  G is polycyclic if there exists a subnormal series G = C_1 > C_2 >
  ...  > C_n > C_{n+1} = { 1 } with cyclic factors. Such a series is called pc
  series of G.
  
  Every  polycyclic  group  is  solvable  and  every  finite solvable group is
  polycyclic.  However,  there  are  infinite  solvable  groups  which are not
  polycyclic.
  
  In  GAP  there  exists a large number of methods for polycyclic groups which
  are  based  upon the polycyclic structure of these groups. These methods are
  usually  very  efficient,  especially  for  groups  which  are  given  by  a
  pc-presentation  (see  chapter  46),  and  can  be  applied to many types of
  groups.  Hence  GAP  tries  to  use them whenever possible, for example, for
  permutation groups and matrix groups over finite fields that are known to be
  polycyclic  (the  only exception is the representation as finitely presented
  group for which the polycyclic methods cannot be used in general).
  
  At  the current state of implementations the GAP library contains methods to
  compute  with  finite polycyclic groups, while the GAP package Polycyclic by
  Bettina  Eick  and  Werner  Nickel  allows  also  computations with infinite
  polycyclic groups which are given by a pc-presentation.
  
  
  45.1 Polycyclic Generating Systems
  
  Let  G  be  a  polycyclic  group  with  a  pc  series as above. A polycyclic
  generating sequence (pcgs for short) of G is a sequence P := (g_1, ..., g_n)
  of  elements  of G such that C_i = ⟨ C_{i+1}, g_i ⟩ for 1 ≤ i ≤ n. Note that
  each  polycyclic  group has a pcgs, but except for very small groups, a pcgs
  is not unique.
  
  For each index i the subsequence of elements (g_i, ..., g_n) forms a pcgs of
  the  subgroup  C_i. In particular, these tails generate the subgroups of the
  pc series and hence we say that the pc series is determined by P.
  
  Let  r_i  be  the  index of C_{i+1} in C_i which is either a finite positive
  number  or  infinity.  Then  r_i is the order of g_i C_{i+1} and we call the
  resulting list of indices the relative orders of the pcgs P.
  
  Moreover,  with  respect to a given pcgs (g_1, ..., g_n) each element g of G
  can  be represented in a unique way as a product g = g_1^{e_1} ⋅ g_2^{e_2} ⋯
  g_n^{e_n}  with exponents e_i ∈ {0, ..., r_i-1}, if r_i is finite, and e_i ∈
  ℤ  otherwise.  Words of this form are called normal words or words in normal
  form.  Then  the  integer  vector  [  e_1, ..., e_n ] is called the exponent
  vector of the element g. Furthermore, the smallest index k such that e_k ≠ 0
  is called the depth of g and e_k is the leading exponent of g.
  
  For many applications we have to assume that each of the relative orders r_i
  is  either  a prime or infinity. This is equivalent to saying that there are
  no  trivial factors in the pc series and the finite factors of the pc series
  are  maximal  refined. Then we obtain that r_i is the order of g C_{i+1} for
  all  elements  g  in C_i ∖ C_{i+1} and we call r_i the relative order of the
  element g.
  
  
  45.2 Computing a Pcgs
  
  Suppose  a  group  G is given; for example, let G be a permutation or matrix
  group.  Then  we  can  ask  GAP to compute a pcgs of this group. If G is not
  polycyclic, the result will be fail.
  
  Note  that  these  methods can only be applied if G is not given as finitely
  presented group. For finitely presented groups one can try to compute a pcgs
  via the polycyclic quotient methods, see 47.14.
  
  Note also that a pcgs behaves like a list.
  
  45.2-1 Pcgs
  
  Pcgs( G )  attribute
  
  returns a pcgs for the group G. If grp is not polycyclic it returns fail and
  this result is not stored as attribute value, in particular in this case the
  filter HasPcgs is not set for G!
  
  45.2-2 IsPcgs
  
  IsPcgs( obj )  Category
  
  The category of pcgs.
  
    Example  
    gap> G := Group((1,2,3,4),(1,2));;
    gap> p := Pcgs(G);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> IsPcgs( p );
    true
    gap> p[1];
    (3,4)
    gap> G := Group((1,2,3,4,5),(1,2));;
    gap> Pcgs(G);
    fail
  
  
  45.2-3 CanEasilyComputePcgs
  
  CanEasilyComputePcgs( grp )  filter
  
  This  filter  indicates  whether  it  is  possible to compute a pcgs for grp
  cheaply.  Clearly,  grp  must  be  polycyclic in this case. However, not for
  every  polycyclic  group  there  is a method to compute a pcgs at low costs.
  This  filter  is  used in the method selection mainly. Note that this filter
  may change its value from false to true.
  
    Example  
    gap> G := Group( (1,2,3,4),(1,2) );
    Group([ (1,2,3,4), (1,2) ])
    gap> CanEasilyComputePcgs(G);
    false
    gap> Pcgs(G);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> CanEasilyComputePcgs(G);
    true
  
  
  
  45.3 Defining a Pcgs Yourself
  
  In a number of situations it might be useful to supply a pcgs to a group.
  
  Note  that  the  elementary  operations  for  such  a  pcgs  might be rather
  inefficient,  since GAP has to use generic methods in this case. It might be
  helpful  to  supply  the relative orders of the self-defined pcgs as well by
  SetRelativeOrder. See also IsPrimeOrdersPcgs (45.4-3).
  
  45.3-1 PcgsByPcSequence
  
  PcgsByPcSequence( fam, pcs )  operation
  PcgsByPcSequenceNC( fam, pcs )  operation
  
  constructs  a pcgs for the elements family fam from the elements in the list
  pcs.  The  elements  must lie in the family fam. PcgsByPcSequence and its NC
  variant will always create a new pcgs which is not induced by any other pcgs
  (cf. InducedPcgsByPcSequence (45.7-2)).
  
    Example  
    gap> fam := FamilyObj( (1,2) );; # the family of permutations
    gap> p := PcgsByPcSequence( fam, [(1,2),(1,2,3)] );
    Pcgs([ (1,2), (1,2,3) ])
    gap> RelativeOrders(p);
    [ 2, 3 ]
    gap> ExponentsOfPcElement( p, (1,3,2) );
    [ 0, 2 ]
  
  
  
  45.4 Elementary Operations for a Pcgs
  
  45.4-1 RelativeOrders
  
  RelativeOrders( pcgs )  attribute
  
  returns the list of relative orders of the pcgs pcgs.
  
  45.4-2 IsFiniteOrdersPcgs
  
  IsFiniteOrdersPcgs( pcgs )  property
  
  tests whether the relative orders of pcgs are all finite.
  
  45.4-3 IsPrimeOrdersPcgs
  
  IsPrimeOrdersPcgs( pcgs )  property
  
  tests whether the relative orders of pcgs are prime numbers. Many algorithms
  require      a      pcgs      to      have      this      property.      The
  operation IsomorphismRefinedPcGroup (46.4-8) can be of help here.
  
  45.4-4 PcSeries
  
  PcSeries( pcgs )  attribute
  
  returns the subnormal series determined by pcgs.
  
  45.4-5 GroupOfPcgs
  
  GroupOfPcgs( pcgs )  attribute
  
  The group generated by pcgs.
  
  45.4-6 OneOfPcgs
  
  OneOfPcgs( pcgs )  attribute
  
  The identity of the group generated by pcgs.
  
    Example  
    gap> G := Group( (1,2,3,4),(1,2) );; p := Pcgs(G);;
    gap> RelativeOrders(p);
    [ 2, 3, 2, 2 ]
    gap> IsFiniteOrdersPcgs(p);
    true
    gap> IsPrimeOrdersPcgs(p);
    true
    gap> PcSeries(p);
    [ Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
      Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
      Group([ (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) 
     ]
  
  
  
  45.5 Elementary Operations for a Pcgs and an Element
  
  45.5-1 RelativeOrderOfPcElement
  
  RelativeOrderOfPcElement( pcgs, elm )  operation
  
  The relative order of elm with respect to the prime order pcgs pcgs.
  
  45.5-2 ExponentOfPcElement
  
  ExponentOfPcElement( pcgs, elm, pos )  operation
  
  returns the pos-th exponent of elm with respect to pcgs.
  
  45.5-3 ExponentsOfPcElement
  
  ExponentsOfPcElement( pcgs, elm[, posran] )  operation
  
  returns  the  exponents  of  elm  with  respect  to pcgs. The three argument
  version returns the exponents in the positions given in posran.
  
  45.5-4 DepthOfPcElement
  
  DepthOfPcElement( pcgs, elm )  operation
  
  returns the depth of the element elm with respect to pcgs.
  
  45.5-5 LeadingExponentOfPcElement
  
  LeadingExponentOfPcElement( pcgs, elm )  operation
  
  returns the leading exponent of elm with respect to pcgs.
  
  45.5-6 PcElementByExponents
  
  PcElementByExponents( pcgs, list )  function
  PcElementByExponentsNC( pcgs[, basisind], list )  operation
  
  returns  the  element corresponding to the exponent vector list with respect
  to pcgs. The exponents in list must be in the range of permissible exponents
  for  pcgs.  It  is  not guaranteed that PcElementByExponents will reduce the
  exponents  modulo  the  relative  orders.  (You  should  use  the  operation
  LinearCombinationPcgs  (45.5-7)  for  this purpose.) The NC version does not
  check  that  the  lengths  of  the lists fit together and does not check the
  exponent range.
  
  The  three  argument  version  gives exponents only w.r.t. the generators in
  pcgs indexed by basisind.
  
  45.5-7 LinearCombinationPcgs
  
  LinearCombinationPcgs( pcgs, list[, one] )  function
  
  returns    the    product    ∏_i    pcgs[i]^{list[i]}.    In   contrast   to
  PcElementByExponents (45.5-6) this permits negative exponents. pcgs might be
  a  list of group elements. In this case, an appropriate identity element one
  must be given. list can be empty.
  
    Example  
    gap> G := Group( (1,2,3,4),(1,2) );; P := Pcgs(G);;
    gap> g := PcElementByExponents(P, [0,1,1,1]);
    (1,2,3)
    gap> ExponentsOfPcElement(P, g);
    [ 0, 1, 1, 1 ]
  
  
  45.5-8 SiftedPcElement
  
  SiftedPcElement( pcgs, elm )  operation
  
  sifts elm through pcgs, reducing it if the depth is the same as the depth of
  one  of the generators in pcgs. Thus the identity is returned if elm lies in
  the group generated by pcgs. pcgs must be an induced pcgs (see section 45.7)
  and elm must lie in the span of the parent of pcgs.
  
  45.5-9 CanonicalPcElement
  
  CanonicalPcElement( ipcgs, elm )  operation
  
  reduces elm at the induces pcgs ipcgs such that the exponents of the reduced
  result  r  are  zero  at the depths for which there are generators in ipcgs.
  Elements, whose quotient lies in the group generated by ipcgs yield the same
  canonical element.
  
  45.5-10 ReducedPcElement
  
  ReducedPcElement( pcgs, x, y )  operation
  
  reduces the element x by dividing off (from the left) a power of y such that
  the leading coefficient of the result with respect to pcgs becomes zero. The
  elements x and y therefore have to have the same depth.
  
  45.5-11 CleanedTailPcElement
  
  CleanedTailPcElement( pcgs, elm, dep )  operation
  
  returns  an  element  in  the  span of pcgs whose exponents for indices 1 to
  dep-1  with  respect  to  pcgs  are  the same as those of elm, the remaining
  exponents  are undefined. This can be used to obtain more simple elements if
  only representatives in a factor are required, see 45.9.
  
  The  difference  to HeadPcElementByNumber (45.5-12) is that this function is
  guaranteed to zero out trailing coefficients while CleanedTailPcElement will
  only do this if it can be done cheaply.
  
  45.5-12 HeadPcElementByNumber
  
  HeadPcElementByNumber( pcgs, elm, dep )  operation
  
  returns  an  element  in  the  span of pcgs whose exponents for indices 1 to
  dep-1  with  respect  to  pcgs  are  the same as those of elm, the remaining
  exponents  are zero. This can be used to obtain more simple elements if only
  representatives in a factor are required.
  
  
  45.6 Exponents of Special Products
  
  There are certain products of elements whose exponents are used often within
  algorithms,  and  which  might be obtained more easily than by computing the
  product first and to obtain its exponents afterwards. The operations in this
  section provide a way to obtain such exponent vectors directly.
  
  (The  circumstances  under which these operations give a speedup depend very
  much  on  the  pcgs  and the representation of elements that is used. So the
  following  operations  are  not  guaranteed to give a speedup in every case,
  however  the default methods are not slower than to compute the exponents of
  a product and thus these operations should always be used if applicable.)
  
  The  second  class are exponents of products of the generators which make up
  the  pcgs.  If the pcgs used is a family pcgs (see FamilyPcgs (46.1-1)) then
  these exponents can be looked up and do not need to be computed.
  
  45.6-1 ExponentsConjugateLayer
  
  ExponentsConjugateLayer( mpcgs, elm, e )  operation
  
  Computes  the  exponents  of elm^e with respect to mpcgs; elm must be in the
  span  of  mpcgs,  e a pc element in the span of the parent pcgs of mpcgs and
  mpcgs  must be the modulo pcgs for an abelian layer. (This is the usual case
  when  acting  on  a  chief  factor). In this case if mpcgs is induced by the
  family  pcgs  (see  section 45.7), the exponents can be computed directly by
  looking  up  exponents  without having to compute in the group and having to
  collect a potential tail.
  
  45.6-2 ExponentsOfRelativePower
  
  ExponentsOfRelativePower( pcgs, i )  operation
  
  For  p  =  pcgs[i] this function returns the exponent vector with respect to
  pcgs  of the element p^e where e is the relative order of p in pcgs. For the
  family  pcgs  or pcgs induced by it (see section 45.7), this might be faster
  than computing the element and computing its exponent vector.
  
  45.6-3 ExponentsOfConjugate
  
  ExponentsOfConjugate( pcgs, i, j )  operation
  
  returns  the  exponents  of  pcgs[i]^pcgs[j]  with  respect to pcgs. For the
  family  pcgs  or pcgs induced by it (see section 45.7), this might be faster
  than computing the element and computing its exponent vector.
  
  45.6-4 ExponentsOfCommutator
  
  ExponentsOfCommutator( pcgs, i, j )  operation
  
  returns  the  exponents  of  the  commutator  Comm(  pcgs[i], pcgs[j] ) with
  respect  to  pcgs.  For  the family pcgs or pcgs induced by it, (see section
  45.7),  this  might  be  faster than computing the element and computing its
  exponent vector.
  
  
  45.7 Subgroups of Polycyclic Groups - Induced Pcgs
  
  Let  U  be  a  subgroup  of  G and let P be a pcgs of G as above such that P
  determines  the  subnormal  series G = C_1 > ... > C_{n+1} = { 1 }. Then the
  series  of  subgroups  U  ∩  C_i  is  a subnormal series of U with cyclic or
  trivial factors. Hence, if we choose an element u_{i_j} ∈ (U ∩ C_{i_j}) ∖ (U
  ∩  C_{i_j+1}) whenever this factor is non-trivial, then we obtain a pcgs Q =
  (u_{i_1},  ..., u_{i_m}) of U. We say that Q is an induced pcgs with respect
  to P. The pcgs P is the parent pcgs to the induced pcgs Q.
  
  Note  that the pcgs Q is induced with respect to P if and only if the matrix
  of  exponent  vectors  of the elements u_{i_j} with respect to P is in upper
  triangular form. Thus Q is not unique in general.
  
  In  particular,  the  elements  of  an  induced pcgs do not necessarily have
  leading   coefficient  1  relative  to  the  inducing  pcgs.  The  attribute
  LeadCoeffsIGS  (45.7-7)  holds the leading coefficients in case they have to
  be renormed in an algorithm.
  
  Each  induced  pcgs is a pcgs and hence allows all elementary operations for
  pcgs.  On the other hand each pcgs could be transformed into an induced pcgs
  for  the  group  defined  by the pcgs, but note that an arbitrary pcgs is in
  general not an induced pcgs for technical reasons.
  
  An induced pcgs is compatible with its parent, see ParentPcgs (45.7-3).
  
  In  [LNS84]  a  non-commutative  Gauss  algorithm is described to compute an
  induced pcgs of a subgroup U from a generating set of U. For calling this in
  GAP, see 45.7-4 to 45.7-8.
  
  To create a subgroup generated by an induced pcgs such that the induced pcgs
  gets stored automatically, use SubgroupByPcgs (45.7-9).
  
  45.7-1 IsInducedPcgs
  
  IsInducedPcgs( pcgs )  Category
  
  The category of induced pcgs. This a subcategory of pcgs.
  
  45.7-2 InducedPcgsByPcSequence
  
  InducedPcgsByPcSequence( pcgs, pcs )  operation
  InducedPcgsByPcSequenceNC( pcgs, pcs[, depths] )  operation
  
  If  pcs is a list of elements that form an induced pcgs with respect to pcgs
  this operation returns an induced pcgs with these elements.
  
  In  the  third  version, the depths of pcs with respect to pcgs can be given
  (they are computed anew otherwise).
  
  45.7-3 ParentPcgs
  
  ParentPcgs( pcgs )  attribute
  
  returns  the  pcgs  by  which  pcgs was induced. If pcgs was not induced, it
  simply returns pcgs.
  
    Example  
    gap> G := Group( (1,2,3,4),(1,2) );;
    gap> P := Pcgs(G);;
    gap> K := InducedPcgsByPcSequence( P, [(1,2,3,4),(1,3)(2,4)] );
    Pcgs([ (1,2,3,4), (1,3)(2,4) ])
    gap> ParentPcgs( K );
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> IsInducedPcgs( K );
    true
  
  
  45.7-4 InducedPcgs
  
  InducedPcgs( pcgs, grp )  operation
  
  computes a pcgs for grp which is induced by pcgs. If pcgs has a parent pcgs,
  then the result is induced with respect to this parent pcgs.
  
  InducedPcgs  is  a  wrapper  function only. Therefore, methods for computing
  computing   an   induced   pcgs   should  be  installed  for  the  operation
  InducedPcgsOp.
  
  45.7-5 InducedPcgsByGenerators
  
  InducedPcgsByGenerators( pcgs, gens )  operation
  InducedPcgsByGeneratorsNC( pcgs, gens )  operation
  
  returns  an  induced pcgs with respect to pcgs for the subgroup generated by
  gens.
  
  45.7-6 InducedPcgsByPcSequenceAndGenerators
  
  InducedPcgsByPcSequenceAndGenerators( pcgs, ind, gens )  operation
  
  returns  an  induced  pcgs with respect to pcgs of the subgroup generated by
  ind  and  gens.  Here ind must be an induced pcgs with respect to pcgs (or a
  list of group elements that form such an igs) and it will be used as initial
  sequence for the computation.
  
    Example  
    gap> G := Group( (1,2,3,4),(1,2) );;  P := Pcgs(G);;
    gap> I := InducedPcgsByGenerators( P, [(1,2,3,4)] );
    Pcgs([ (1,2,3,4), (1,3)(2,4) ])
    gap> J := InducedPcgsByPcSequenceAndGenerators( P, I, [(1,2)] );
    Pcgs([ (1,2,3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
  
  
  45.7-7 LeadCoeffsIGS
  
  LeadCoeffsIGS( igs )  attribute
  
  This  attribute  is  used  to store leading coefficients with respect to the
  parent  pcgs.  the  i-th  entry  –if  bound–  is the leading exponent of the
  element  of  igs that has depth i in the parent. (It cannot be assigned to a
  component in the object created by InducedPcgsByPcSequenceNC (45.7-2) as the
  permutation  group  methods  call  it from within the postprocessing, before
  this postprocessing however no coefficients may be computed.)
  
  45.7-8 ExtendedPcgs
  
  ExtendedPcgs( N, gens )  operation
  
  extends the pcgs N (induced w.r.t. home) to a new induced pcgs by prepending
  gens. No checks are performed that this really yields an induced pcgs.
  
  45.7-9 SubgroupByPcgs
  
  SubgroupByPcgs( G, pcgs )  operation
  
  returns a subgroup of G generated by the elements of pcgs.
  
  
  45.8 Subgroups of Polycyclic Groups – Canonical Pcgs
  
  The  induced  pcgs  Q  of  U  is  called canonical if the matrix of exponent
  vectors  contains  normed  vectors  only and above each leading entry in the
  matrix  there  are  0's  only.  The canonical pcgs of U with respect to P is
  unique and hence such pcgs can be used to compare subgroups.
  
  45.8-1 IsCanonicalPcgs
  
  IsCanonicalPcgs( pcgs )  property
  
  An  induced  pcgs  is canonical if the matrix of the exponent vectors of the
  elements of pcgs with respect to the ParentPcgs (45.7-3) value of pcgs is in
  Hermite normal form (see [LNS84]). While a subgroup can have various induced
  pcgs with respect to a parent pcgs a canonical pcgs is unique.
  
  45.8-2 CanonicalPcgs
  
  CanonicalPcgs( pcgs )  attribute
  
  returns the canonical pcgs corresponding to the induced pcgs pcgs.
  
    Example  
    gap> G := Group((1,2,3,4),(5,6,7));
    Group([ (1,2,3,4), (5,6,7) ])
    gap> P := Pcgs(G);
    Pcgs([ (5,6,7), (1,2,3,4), (1,3)(2,4) ])
    gap> I := InducedPcgsByPcSequence(P, [(5,6,7)*(1,3)(2,4),(1,3)(2,4)] );
    Pcgs([ (1,3)(2,4)(5,6,7), (1,3)(2,4) ])
    gap> CanonicalPcgs(I);
    Pcgs([ (5,6,7), (1,3)(2,4) ])
  
  
  
  45.9 Factor Groups of Polycyclic Groups – Modulo Pcgs
  
  Let  N  be a normal subgroup of G such that G/N is polycyclic with pcgs (h_1
  N,  ...,  h_r  N).  Then  we call the sequence of preimages (h_1, ... h_r) a
  modulo  pcgs  of  G/N. G is called the numerator of the modulo pcgs and N is
  the denominator of the modulo pcgs.
  
  Modulo  pcgs are often used to facilitate efficient computations with factor
  groups,  since  they  allow computations with factor groups without formally
  defining the factor group at all.
  
  All  elementary  operations  of  pcgs,  see Sections 45.4 and 45.5, apply to
  modulo  pcgs  as  well.  However,  it  is in general not possible to compute
  induced pcgs with respect to a modulo pcgs.
  
  Two  more  elementary  operations  for modulo pcgs are NumeratorOfModuloPcgs
  (45.9-3) and DenominatorOfModuloPcgs (45.9-4).
  
  45.9-1 ModuloPcgs
  
  ModuloPcgs( G, N )  operation
  
  returns a modulo pcgs for the factor G/N which must be solvable, while N may
  be  non-solvable.  ModuloPcgs will return a pcgs for the factor, there is no
  guarantee  that  it  will  be  compatible  with  any  other pcgs. If this is
  required, the mod operator must be used on induced pcgs, see \mod (45.9-5).
  
  45.9-2 IsModuloPcgs
  
  IsModuloPcgs( obj )  Category
  
  The  category  of  modulo pcgs. Note that each pcgs is a modulo pcgs for the
  trivial subgroup.
  
  45.9-3 NumeratorOfModuloPcgs
  
  NumeratorOfModuloPcgs( pcgs )  attribute
  
  returns a generating set for the numerator of the modulo pcgs pcgs.
  
  45.9-4 DenominatorOfModuloPcgs
  
  DenominatorOfModuloPcgs( pcgs )  attribute
  
  returns a generating set for the denominator of the modulo pcgs pcgs.
  
    Example  
    gap> G := Group( (1,2,3,4,5),(1,2) );
    Group([ (1,2,3,4,5), (1,2) ])
    gap> P := ModuloPcgs(G, DerivedSubgroup(G) );
    Pcgs([ (4,5) ])
    gap> NumeratorOfModuloPcgs(P);
    [ (1,2,3,4,5), (1,2) ]
    gap> DenominatorOfModuloPcgs(P);
    [ (1,3,2), (1,4,3), (2,5,4) ]
    gap> RelativeOrders(P);
    [ 2 ]
    gap> ExponentsOfPcElement( P, (1,2,3,4,5) );
    [ 0 ]
    gap> ExponentsOfPcElement( P, (4,5) );
    [ 1 ]
  
  
  45.9-5 \mod
  
  \mod( P, I )  method
  
  Modulo Pcgs can also be built from compatible induced pcgs. Let G be a group
  with  pcgs  P  and  let  I  be  an induced pcgs of a normal subgroup N of G.
  (Respectively: P and I are both induced with respect to the same Pcgs.) Then
  we can compute a modulo pcgs of G mod N by
  
  P mod I
  
  Note  that  in  this  case  we  obtain  the  advantage  that  the  values of
  NumeratorOfModuloPcgs (45.9-3) and DenominatorOfModuloPcgs (45.9-4) are just
  P and I, respectively, and hence are unique.
  
  The  resulting  modulo  pcgs  will  consist  of  a  subset  of P and will be
  compatible with P (or its parent).
  
    Example  
    gap> G := Group((1,2,3,4));;
    gap> P := Pcgs(G);
    Pcgs([ (1,2,3,4), (1,3)(2,4) ])
    gap> I := InducedPcgsByGenerators(P, [(1,3)(2,4)]);
    Pcgs([ (1,3)(2,4) ])
    gap> M := P mod I;
    [ (1,2,3,4) ]
    gap> NumeratorOfModuloPcgs(M);
    Pcgs([ (1,2,3,4), (1,3)(2,4) ])
    gap> DenominatorOfModuloPcgs(M);
    Pcgs([ (1,3)(2,4) ])
  
  
  45.9-6 CorrespondingGeneratorsByModuloPcgs
  
  CorrespondingGeneratorsByModuloPcgs( mpcgs, imgs )  function
  
  Let mpcgs be a modulo pcgs for a factor of a group G and let U be a subgroup
  of  G  generated  by imgs such that U covers the factor for the modulo pcgs.
  Then this function computes elements in U corresponding to the generators of
  the modulo pcgs.
  
  Note  that  the  computation  of induced generating sets is not possible for
  some modulo pcgs.
  
  45.9-7 CanonicalPcgsByGeneratorsWithImages
  
  CanonicalPcgsByGeneratorsWithImages( pcgs, gens, imgs )  operation
  
  computes   a   canonical,  pcgs-induced  pcgs  for  the  span  of  gens  and
  simultaneously  does  the  same  transformations  on imgs, preserving thus a
  correspondence  between  gens  and imgs. This operation is used to represent
  homomorphisms from a pc group.
  
  
  45.10 Factor Groups of Polycyclic Groups in their Own Representation
  
  If  substantial calculations are done in a factor it might be worth still to
  construct the factor group in its own representation (for example by calling
  PcGroupWithPcgs (46.5-1) on a modulo pcgs.
  
  The following functions are intended for working with factor groups obtained
  by  factoring  out the tail of a pcgs. They provide a way to map elements or
  induced  pcgs quickly in the factor (respectively to take preimages) without
  the need to construct a homomorphism.
  
  The  setup is always a pcgs pcgs of G and a pcgs fpcgs of a factor group H =
  G/N which corresponds to a head of pcgs.
  
  No tests for validity of the input are performed.
  
  45.10-1 ProjectedPcElement
  
  ProjectedPcElement( pcgs, fpcgs, elm )  function
  
  returns the image in H of an element elm of G.
  
  45.10-2 ProjectedInducedPcgs
  
  ProjectedInducedPcgs( pcgs, fpcgs, ipcgs )  function
  
  ipcgs  must  be an induced pcgs with respect to pcgs. This operation returns
  an induced pcgs with respect to fpcgs consisting of the nontrivial images of
  ipcgs.
  
  45.10-3 LiftedPcElement
  
  LiftedPcElement( pcgs, fpcgs, elm )  function
  
  returns a preimage in G of an element elm of H.
  
  45.10-4 LiftedInducedPcgs
  
  LiftedInducedPcgs( pcgs, fpcgs, ipcgs, ker )  function
  
  ipcgs  must be an induced pcgs with respect to fpcgs. This operation returns
  an  induced  pcgs with respect to pcgs consisting of the preimages of ipcgs,
  appended  by  the elements in ker (assuming there is a bijection of pcgs mod
  ker to fpcgs). ker might be a simple element list.
  
  
  45.11 Pcgs and Normal Series
  
  By  definition,  a  pcgs  determines  a  pc  series of its underlying group.
  However,  in  many  applications  it  will  be necessary that this pc series
  refines  a  normal  series  with  certain  properties; for example, a normal
  series with abelian factors.
  
  There  are  functions  in GAP to compute a pcgs through a normal series with
  elementary  abelian factors, a central series or the lower p-central series.
  See also Section 45.13 for a more explicit possibility.
  
  45.11-1 IsPcgsElementaryAbelianSeries
  
  IsPcgsElementaryAbelianSeries( pcgs )  property
  
  returns  true  if  the  pcgs  pcgs  refines  an  elementary  abelian series.
  IndicesEANormalSteps  (45.11-3) then gives the indices in the Pcgs, at which
  the subgroups of this series start.
  
  45.11-2 PcgsElementaryAbelianSeries
  
  PcgsElementaryAbelianSeries( G )  attribute
  PcgsElementaryAbelianSeries( list )  attribute
  
  computes   a   pcgs  for  G  that  refines  an  elementary  abelian  series.
  IndicesEANormalSteps  (45.11-3)  gives the indices in the pcgs, at which the
  normal  subgroups  of  this  series start. The second variant returns a pcgs
  that runs through the normal subgroups in the list list.
  
  45.11-3 IndicesEANormalSteps
  
  IndicesEANormalSteps( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with    elementary    abelian    factors    (for    example   from   calling
  PcgsElementaryAbelianSeries  (45.11-2))  Then IndicesEANormalSteps returns a
  sorted  list  of integers, indicating the tails of pcgs which generate these
  normal  subgroup of G. If i is an element of this list, (g_i, ..., g_n) is a
  normal  subgroup  of  G.  The  list  always starts with 1 and ends with n+1.
  (These  indices  form  one  series  with  elementary abelian subfactors, not
  necessarily the most refined one.)
  
  The  attribute  EANormalSeriesByPcgs  (45.11-4) returns the actual series of
  subgroups.
  
  For  arbitrary pcgs not obtained as belonging to a special series such a set
  of   indices   not  necessarily  exists,  and  IndicesEANormalSteps  is  not
  guaranteed to work in this situation.
  
  Typically,   IndicesEANormalSteps   is  set  by  PcgsElementaryAbelianSeries
  (45.11-2).
  
  45.11-4 EANormalSeriesByPcgs
  
  EANormalSeriesByPcgs( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with    elementary    abelian    factors    (for    example   from   calling
  PcgsElementaryAbelianSeries  (45.11-2)).  This  attribute returns the actual
  series of normal subgroups, corresponding to IndicesEANormalSteps (45.11-3).
  
  45.11-5 IsPcgsCentralSeries
  
  IsPcgsCentralSeries( pcgs )  property
  
  returns  true if the pcgs pcgs refines an central elementary abelian series.
  IndicesCentralNormalSteps  (45.11-7)  then gives the indices in the pcgs, at
  which the subgroups of this series start.
  
  45.11-6 PcgsCentralSeries
  
  PcgsCentralSeries( G )  attribute
  
  computes  a  pcgs  for  G  that refines a central elementary abelian series.
  IndicesCentralNormalSteps  (45.11-7) gives the indices in the pcgs, at which
  the normal subgroups of this series start.
  
  45.11-7 IndicesCentralNormalSteps
  
  IndicesCentralNormalSteps( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with   central   elementary   abelian  factors  (for  example  from  calling
  PcgsCentralSeries   (45.11-6)).  Then  IndicesCentralNormalSteps  returns  a
  sorted  list  of integers, indicating the tails of pcgs which generate these
  normal subgroups of G. If i is an element of this list, (g_i, ..., g_n) is a
  normal  subgroup  of  G.  The  list  always starts with 1 and ends with n+1.
  (These  indices  form one series with central elementary abelian subfactors,
  not necessarily the most refined one.)
  
  The  attribute CentralNormalSeriesByPcgs (45.11-8) returns the actual series
  of subgroups.
  
  For  arbitrary pcgs not obtained as belonging to a special series such a set
  of  indices  not  necessarily  exists,  and IndicesCentralNormalSteps is not
  guaranteed to work in this situation.
  
  Typically, IndicesCentralNormalSteps is set by PcgsCentralSeries (45.11-6).
  
  45.11-8 CentralNormalSeriesByPcgs
  
  CentralNormalSeriesByPcgs( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with   central   elementary   abelian  factors  (for  example  from  calling
  PcgsCentralSeries  (45.11-6)).  This  attribute returns the actual series of
  normal subgroups, corresponding to IndicesCentralNormalSteps (45.11-7).
  
  45.11-9 IsPcgsPCentralSeriesPGroup
  
  IsPcgsPCentralSeriesPGroup( pcgs )  property
  
  returns  true if the pcgs pcgs refines a p-central elementary abelian series
  for  a  p-group.  IndicesPCentralNormalStepsPGroup (45.11-11) then gives the
  indices in the pcgs, at which the subgroups of this series start.
  
  45.11-10 PcgsPCentralSeriesPGroup
  
  PcgsPCentralSeriesPGroup( G )  attribute
  
  computes  a  pcgs  for  the  p-group  G  that refines a p-central elementary
  abelian   series.   IndicesPCentralNormalStepsPGroup  (45.11-11)  gives  the
  indices in the pcgs, at which the normal subgroups of this series start.
  
  45.11-11 IndicesPCentralNormalStepsPGroup
  
  IndicesPCentralNormalStepsPGroup( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with   p-central  elementary  abelian  factors  (for  example  from  calling
  PcgsPCentralSeriesPGroup  (45.11-10)). Then IndicesPCentralNormalStepsPGroup
  returns  a  sorted  list  of  integers,  indicating  the tails of pcgs which
  generate these normal subgroups of G. If i is an element of this list, (g_i,
  ...,  g_n) is a normal subgroup of G. The list always starts with 1 and ends
  with  n+1.  (These  indices  form one series with central elementary abelian
  subfactors, not necessarily the most refined one.)
  
  The attribute PCentralNormalSeriesByPcgsPGroup (45.11-12) returns the actual
  series of subgroups.
  
  For  arbitrary pcgs not obtained as belonging to a special series such a set
  of  indices  not necessarily exists, and IndicesPCentralNormalStepsPGroup is
  not guaranteed to work in this situation.
  
  Typically,       IndicesPCentralNormalStepsPGroup       is       set      by
  PcgsPCentralSeriesPGroup (45.11-10).
  
  45.11-12 PCentralNormalSeriesByPcgsPGroup
  
  PCentralNormalSeriesByPcgsPGroup( pcgs )  attribute
  
  Let pcgs be a pcgs obtained as corresponding to a series of normal subgroups
  with   p-central  elementary  abelian  factors  (for  example  from  calling
  PcgsPCentralSeriesPGroup  (45.11-10)).  This  attribute  returns  the actual
  series        of        normal       subgroups,       corresponding       to
  IndicesPCentralNormalStepsPGroup (45.11-11).
  
  45.11-13 IsPcgsChiefSeries
  
  IsPcgsChiefSeries( pcgs )  property
  
  returns    true    if    the    pcgs    pcgs   refines   a   chief   series.
  IndicesChiefNormalSteps  (45.11-15)  then  gives the indices in the pcgs, at
  which the subgroups of this series start.
  
  45.11-14 PcgsChiefSeries
  
  PcgsChiefSeries( G )  attribute
  
  computes  a  pcgs for G that refines a chief series. IndicesChiefNormalSteps
  (45.11-15)  gives  the indices in the pcgs, at which the normal subgroups of
  this series start.
  
  45.11-15 IndicesChiefNormalSteps
  
  IndicesChiefNormalSteps( pcgs )  attribute
  
  Let  pcgs  be a pcgs obtained as corresponding to a chief series for example
  from   calling  PcgsChiefSeries  (45.11-14)).  Then  IndicesChiefNormalSteps
  returns  a  sorted  list  of  integers,  indicating  the tails of pcgs which
  generate these normal subgroups of G. If i is an element of this list, (g_i,
  ...,  g_n) is a normal subgroup of G. The list always starts with 1 and ends
  with n+1. (These indices form one series with elementary abelian subfactors,
  not necessarily the most refined one.)
  
  The  attribute  ChiefNormalSeriesByPcgs (45.11-16) returns the actual series
  of subgroups.
  
  For  arbitrary pcgs not obtained as belonging to a special series such a set
  of  indices  not  necessarily  exists,  and  IndicesChiefNormalSteps  is not
  guaranteed to work in this situation.
  
  Typically, IndicesChiefNormalSteps is set by PcgsChiefSeries (45.11-14).
  
  45.11-16 ChiefNormalSeriesByPcgs
  
  ChiefNormalSeriesByPcgs( pcgs )  attribute
  
  Let  pcgs be a pcgs obtained as corresponding to a chief series (for example
  from  calling PcgsChiefSeries (45.11-14)). This attribute returns the actual
  series   of   normal  subgroups,  corresponding  to  IndicesChiefNormalSteps
  (45.11-15).
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> p:=PcgsElementaryAbelianSeries(g);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> IndicesEANormalSteps(p);
    [ 1, 2, 3, 5 ]
    gap> g:=Group((1,2,3,4),(1,5)(2,6)(3,7)(4,8));;
    gap> p:=PcgsCentralSeries(g);
    Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8), 
      (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ])
    gap> IndicesCentralNormalSteps(p);
    [ 1, 2, 4, 5, 6 ]
    gap> q:=PcgsPCentralSeriesPGroup(g);
    Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8), 
      (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ])
    gap> IndicesPCentralNormalStepsPGroup(q);
    [ 1, 3, 5, 6 ]
  
  
  45.11-17 IndicesNormalSteps
  
  IndicesNormalSteps( pcgs )  attribute
  
  returns  the  indices of all steps in the pc series, which are normal in the
  group defined by the pcgs.
  
  (In  general,  this  function  yields  a  slower  performance  than the more
  specialized index functions for elementary abelian series etc.)
  
  45.11-18 NormalSeriesByPcgs
  
  NormalSeriesByPcgs( pcgs )  attribute
  
  returns  the  subgroups the pc series, which are normal in the group defined
  by the pcgs.
  
  (In  general,  this  function  yields  a  slower  performance  than the more
  specialized index functions for elementary abelian series etc.)
  
  
  45.12 Sum and Intersection of Pcgs
  
  45.12-1 SumFactorizationFunctionPcgs
  
  SumFactorizationFunctionPcgs( parentpcgs, n, u, kerpcgs )  operation
  
  computes  the  sum and intersection of the lists n and u whose elements form
  modulo pcgs induced by parentpcgs for two subgroups modulo a kernel given by
  kerpcgs.  If  kerpcgs  is a tail if the parent-pcgs it is sufficient to give
  the starting depth, this can be more efficient than to construct an explicit
  pcgs.  The  factor  group  modulo  kerpcgs generated by n must be elementary
  abelian and normal under u.
  
  The function returns a record with components
  
  sum
        elements that form a modulo pcgs for the span of both subgroups.
  
  intersection
        elements  that  form  a  modulo  pcgs  for  the  intersection  of both
        subgroups.
  
  factorization
        a  function  that returns for an element x in the span of sum a record
        with components u and n that give its decomposition.
  
  The record components sum and intersection are not pcgs but only lists of pc
  elements (to avoid unnecessary creation of induced pcgs).
  
  
  45.13 Special Pcgs
  
  In  short,  a special pcgs is a pcgs which has particularly nice properties,
  for  example it always refines an elementary abelian series, for p-groups it
  even  refines  a  central  series. These nice properties permit particularly
  efficient algorithms.
  
  Let  G  be a finite polycyclic group. A special pcgs of G is a pcgs which is
  closely  related to a Hall system and the maximal subgroups of G. These pcgs
  have  been  introduced  by C. R. Leedham-Green who also gave an algorithm to
  compute  them. Improvements to this algorithm are due to Bettina Eick. For a
  more detailed account of their definition the reader is referred to [Eic97]
  
  To  introduce  the  definition  of  special pcgs we first need to define the
  LG-series and head complements of a finite polycyclic group G. Let G = G_1 >
  G_2 > ... G_m > G_{m+1} = { 1 } be the lower nilpotent series of G; that is,
  G_i  is  the  smallest  normal subgroup of G_{i-1} with nilpotent factor. To
  obtain  the  LG-series  of  G we need to refine this series. Thus consider a
  factor  F_i  := G_i / G_{i+1}. Since F_i is finite nilpotent, it is a direct
  product  of  its  Sylow  subgroups,  say F_i = P_{i,1} ⋯ P_{i,r_i}. For each
  Sylow  p_j-subgroup P_{i,j} we can consider its lower p_j-central series. To
  obtain  a  characteristic  central series with elementary abelian factors of
  F_i  we loop over its Sylow subgroups. Each time we consider P_{i,j} in this
  process  we  take  the  next  step  of its lower p_j-central series into the
  series of F_i. If there is no next step, then we just skip the consideration
  of  P_{i,j}.  Note  that  the second term of the lower p-central series of a
  p-group  is in fact its Frattini subgroup. Thus the Frattini subgroup of F_i
  is  contained  in  the computed series of this group. We denote the Frattini
  subgroup of F_i = G_i / G_{i+1} by G_i^* / G_{i+1}.
  
  The  factors  G_i  /  G_i^*  are  called the heads of G, while the (possibly
  trivial)  factors G_i^* / G_{i+1} are the tails of G. A head complement of G
  is  a  subgroup U of G such that U / G_i^* is a complement to the head G_i /
  G_i^* in G / G_i^* for some i.
  
  Now  we are able to define a special pcgs of G. It is a pcgs of G with three
  additional  properties.  First, the pc series determined by the pcgs refines
  the  LG-series  of  G.  Second, a special pcgs exhibits a Hall system of the
  group  G;  that  is,  for each set of primes π the elements of the pcgs with
  relative  order in π form a pcgs of a Hall π-subgroup in a Hall system of G.
  Third, a special pcgs exhibits a head complement for each head of G.
  
  To  record  information  about the LG-series with the special pcgs we define
  the LGWeights of the special pcgs. These weights are a list which contains a
  weight w for each elements g of the special pcgs. Such a weight w represents
  the smallest subgroup of the LG-series containing g.
  
  Since the LG-series is defined in terms of the lower nilpotent series, Sylow
  subgroups  of  the factors and lower p-central series of the Sylow subgroup,
  the  weight w is a triple. More precisely, g is contained in the w[1]th term
  U  of  the  lower  nilpotent series of G, but not in the next smaller one V.
  Then  w[3]  is a prime such that g V is contained in the Sylow w[3]-subgroup
  P/V  of  U/V.  Moreover,  gV  is  contained  in the w[2]th term of the lower
  p-central series of P/V.
  
  There are two more attributes of a special pcgs containing information about
  the  LG-series:  the  list LGLayers and the list LGFirst. The list of layers
  corresponds to the elements of the special pcgs and denotes the layer of the
  LG-series  in  which  an  element  lies. The list LGFirst corresponds to the
  LG-series  and  gives the number of the first element in the special pcgs of
  the corresponding subgroup.
  
  45.13-1 IsSpecialPcgs
  
  IsSpecialPcgs( obj )  property
  
  tests whether obj is a special pcgs.
  
  
  45.13-2 SpecialPcgs
  
  SpecialPcgs( pcgs )  attribute
  SpecialPcgs( G )  attribute
  
  computes a special pcgs for the group defined by pcgs or for G.
  
  45.13-3 LGWeights
  
  LGWeights( pcgs )  attribute
  
  returns the LGWeights of the special pcgs pcgs.
  
  45.13-4 LGLayers
  
  LGLayers( pcgs )  attribute
  
  returns the layers of the special pcgs pcgs.
  
  45.13-5 LGFirst
  
  LGFirst( pcgs )  attribute
  
  returns the first indices for each layer of the special pcgs pcgs.
  
  45.13-6 LGLength
  
  LGLength( G )  attribute
  
  returns  the  length  of the LG-series of the group G, if G is solvable, and
  fail otherwise.
  
    Example  
    gap> G := SmallGroup( 96, 220 );
    <pc group of size 96 with 6 generators>
    gap> spec := SpecialPcgs( G );
    Pcgs([ f1, f2, f3, f4, f5, f6 ])
    gap> LGWeights(spec);
    [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 3 ], 
      [ 1, 2, 2 ] ]
    gap> LGLayers(spec);
    [ 1, 1, 1, 1, 2, 3 ]
    gap> LGFirst(spec);
    [ 1, 5, 6, 7 ]
    gap> LGLength( G );
    3
    gap> p := SpecialPcgs( Pcgs( SmallGroup( 96, 120 ) ) );
    Pcgs([ f1, f2, f3, f4, f5, f6 ])
    gap> LGWeights(p);
    [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 2, 2 ], [ 1, 3, 2 ], 
      [ 2, 1, 3 ] ]
  
  
  Thus  the  first group, SmallGroup(96, 220), has a lower nilpotent series of
  length  1;  that  is,  the group is nilpotent. It is a direct product of its
  Sylow  subgroups. Moreover the Sylow 2-subgroup is generated by the elements
  f1,  f2,  f3, f4, f6, and the Sylow 3-subgroup is generated by f5. The lower
  2-central  series  of  the  Sylow  2-subgroup  has  length  2 and the second
  subgroup in this series is generated by f6.
  
  The  second  group,  SmallGroup(96,  120),  has  a lower nilpotent series of
  length  2  and hence is not nilpotent. The second subgroup in this series is
  just  the Sylow 3-subgroup and it is generated by f6. The subgroup generated
  by f1, ..., f5 is a Sylow 2-subgroup of the group and also a head complement
  to the second head of the group. Its lower 2-central series has length 2.
  
  In  this  example  the  FamilyPcgs  (46.1-1)  value of the groups used was a
  special  pcgs, but this is not necessarily the case. For performance reasons
  it can be worth to enforce this, see IsomorphismSpecialPcGroup (46.5-3).
  
  45.13-7 IsInducedPcgsWrtSpecialPcgs
  
  IsInducedPcgsWrtSpecialPcgs( pcgs )  property
  
  tests whether pcgs is induced with respect to a special pcgs.
  
  45.13-8 InducedPcgsWrtSpecialPcgs
  
  InducedPcgsWrtSpecialPcgs( G )  attribute
  
  computes  an  induced pcgs with respect to the special pcgs of the parent of
  G.
  
  InducedPcgsWrtSpecialPcgs  will  return  a  pcgs  induced  by a special pcgs
  (which  might  differ  from the one you had in mind). If you need an induced
  pcgs  compatible with a given special pcgs use InducedPcgs (45.7-4) for this
  special pcgs.
  
  
  45.14 Action on Subfactors Defined by a Pcgs
  
  When  working  with  a  polycyclic  group, one often needs to compute matrix
  operations of the group on a factor of the group. For this purpose there are
  the functions described in 45.14-1 to 45.14-3.
  
  In  certain  situations,  for  example  within  the computation of conjugacy
  classes  of  finite soluble groups as described in [MN89], affine actions of
  groups   are   required.   For  this  purpose  we  introduce  the  functions
  AffineAction (45.14-4) and AffineActionLayer (45.14-5).
  
  45.14-1 VectorSpaceByPcgsOfElementaryAbelianGroup
  
  VectorSpaceByPcgsOfElementaryAbelianGroup( mpcgs, fld )  function
  
  returns  the  vector  space over fld corresponding to the modulo pcgs mpcgs.
  Note  that  mpcgs has to define an elementary abelian p-group where p is the
  characteristic of fld.
  
  45.14-2 LinearAction
  
  LinearAction( gens, basisvectors, linear )  operation
  LinearOperation( gens, basisvectors, linear )  operation
  
  returns  a list of matrices, one for each element of gens, which corresponds
  to  the  matrix action of the elements in gens on the basis basisvectors via
  linear.
  
  45.14-3 LinearActionLayer
  
  LinearActionLayer( G, gens, pcgs )  function
  LinearOperationLayer( G, gens, pcgs )  function
  
  returns  a list of matrices, one for each element of gens, which corresponds
  to  the  matrix  action of G on the vector space corresponding to the modulo
  pcgs pcgs.
  
  45.14-4 AffineAction
  
  AffineAction( gens, basisvectors, linear, transl )  operation
  
  return  a  list of matrices, one for each element of gens, which corresponds
  to  the  affine action of the elements in gens on the basis basisvectors via
  linear with translation transl.
  
  45.14-5 AffineActionLayer
  
  AffineActionLayer( G, gens, pcgs, transl )  function
  
  returns  a list of matrices, one for each element of gens, which corresponds
  to  the  affine  action of G on the vector space corresponding to the modulo
  pcgs pcgs with translation transl.
  
    Example  
    gap> G := SmallGroup( 96, 51 );
    <pc group of size 96 with 6 generators>
    gap> spec := SpecialPcgs( G );
    Pcgs([ f1, f2, f3, f4, f5, f6 ])
    gap> LGWeights( spec );
    [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 3 ], [ 1, 2, 2 ], [ 1, 2, 2 ], 
      [ 1, 3, 2 ] ]
    gap> mpcgs := InducedPcgsByPcSequence( spec, spec{[4,5,6]} );
    Pcgs([ f4, f5, f6 ])
    gap> npcgs := InducedPcgsByPcSequence( spec, spec{[6]} );
    Pcgs([ f6 ])
    gap> modu := mpcgs mod npcgs;
    [ f4, f5 ]
    gap> mat:=LinearActionLayer( G, spec{[1,2,3]}, modu );
    [ <an immutable 2x2 matrix over GF2>, 
      <an immutable 2x2 matrix over GF2>, 
      <an immutable 2x2 matrix over GF2> ]
    gap> Print( mat, "\n" );
    [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ], 
      [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ], 
      [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ]
  
  
  
  45.15 Orbit Stabilizer Methods for Polycyclic Groups
  
  If  a  pcgs  pcgs is known for a group G, then orbits and stabilizers can be
  computed  by  a  special  method  which is particularly efficient. Note that
  within  this  function  only the elements in pcgs and the relative orders of
  pcgs  are  needed.  Hence  this  function  works  effectively  even  if  the
  elementary operations for pcgs are slow.
  
  45.15-1 StabilizerPcgs
  
  StabilizerPcgs( pcgs, pnt[, acts][, act] )  function
  
  computes  the stabilizer in the group generated by pcgs of the point pnt. If
  given,  acts  are  elements  by which pcgs acts, act is the acting function.
  This  function  returns  a  pcgs  for the stabilizer which is induced by the
  ParentPcgs of pcgs, that is it is compatible with pcgs.
  
  45.15-2 Pcgs_OrbitStabilizer
  
  Pcgs_OrbitStabilizer( pcgs, domain, pnt, oprs, opr )  function
  
  runs a solvable group orbit-stabilizer algorithm on pnt with pcgs acting via
  the  images  oprs  and  the operation function opr. The domain domain can be
  used to speed up search, if it is not known, false can be given instead. The
  function  returns  a record with components orbit, stabpcgs and lengths, the
  latter  indicating  the  lengths of the orbit whenever it got extended. This
  can  be used to recompute transversal elements. This function should be used
  only inside algorithms when speed is essential.
  
  
  45.16 Operations which have Special Methods for Groups with Pcgs
  
  For  the following operations there are special methods for groups with pcgs
  installed:
  
  IsNilpotentGroup  (39.15-3),  IsSupersolvableGroup (39.15-8), Size (30.4-6),
  CompositionSeries   (39.17-5),   ConjugacyClasses   (39.10-2),   Centralizer
  (35.4-4),   FrattiniSubgroup   (39.12-6),   PrefrattiniSubgroup   (39.12-7),
  MaximalSubgroups  (39.19-8) and related operations, HallSystem (39.13-6) and
  related   operations,   MinimalGeneratingSet   (39.22-3),  Centre  (35.4-5),
  Intersection   (30.5-2),   AutomorphismGroup   (40.7-1),  IrreducibleModules
  (71.15-1).
  
  
  45.17 Conjugacy Classes in Solvable Groups
  
  There  are  a  variety  of  algorithms  to  compute  conjugacy  classes  and
  centralizers  in  solvable  groups  via  epimorphic  images ([FN79], [MN89],
  [The93]).  Usually  these are only invoked as methods, but it is possible to
  access the algorithm directly.
  
  45.17-1 ClassesSolvableGroup
  
  ClassesSolvableGroup( G, mode[, opt] )  function
  
  computes  conjugacy  classes  and  centralizers in solvable groups. G is the
  acting group. mode indicates the type of the calculation:
  
  0 Conjugacy classes
  
  4 Conjugacy test for the two elements in opt.candidates
  
  In  mode  0  the  function  returns  a list of records containing components
  representative and centralizer. In mode 4 it returns a conjugating element.
  
  The  optional  record  opt  may  contain  the following components that will
  affect the algorithm's behaviour:
  
  pcgs
        is  a  pcgs  that  will  be  used  for  the calculation. The attribute
        EANormalSeriesByPcgs  (45.11-4)  must  return an appropriate series of
        normal  subgroups  with  elementary  abelian  factors  among them. The
        algorithm  will  step down this series. In the case of the calculation
        of rational classes, it must be a pcgs refining a central series.
  
  candidates
        is  a  list  of elements for which canonical representatives are to be
        computed  or  for  which  a conjugacy test is performed. Both elements
        must  lie  in G, but this is not tested. In mode 4 these elements must
        be  given.  In mode 0 a list of classes corresponding to candidates is
        returned  (which  may  contain duplicates). The representatives chosen
        are  canonical with respect to pcgs. The records returned also contain
        components operator such that candidate ^ operator = representative.
  
  consider
        is a function consider( fhome, rep, cenp, K, L ). Here fhome is a home
        pcgs  for  the factor group F in which the calculation currently takes
        place,  rep  is  an  element  of the factor and cenp is a pcgs for the
        centralizer  of  rep modulo K. In mode 0, when lifting from F/K to F/L
        (note: for efficiency reasons, F can be different from G or L might be
        not  trivial)  this  function  is  called before performing the actual
        lifting  and  only those representatives for which it returns true are
        passed  to the next level. This permits for example the calculation of
        only  those  classes  with small centralizers or classes of restricted
        orders.
  
  45.17-2 CentralizerSizeLimitConsiderFunction
  
  CentralizerSizeLimitConsiderFunction( sz )  function
  
  returns  a  function (with arguments fhome, rep, cen, K, L) that can be used
  in  ClassesSolvableGroup  (45.17-1) as the consider component of the options
  record. It will restrict the lifting to those classes, for which the size of
  the centralizer (in the factor) is at most sz.
  
  See also SubgroupsSolvableGroup (39.21-3).