Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  47 Finitely Presented Groups
  
  A  finitely  presented  group  (in short: FpGroup) is a group generated by a
  finite  set of abstract generators subject to a finite set of relations that
  these  generators  satisfy.  Every  finite  group  can  be  represented as a
  finitely  presented  group, though in almost all cases it is computationally
  much  more  efficient  to  work  in another representation (even the regular
  permutation representation).
  
  Finitely presented groups are obtained by factoring a free group by a set of
  relators.   Their   elements   know  about  this  presentation  and  compare
  accordingly.
  
  So  to  create  a finitely presented group you first have to generate a free
  group  (see FreeGroup (37.2-1) for details). There are two ways to specify a
  quotient of the free group: either by giving a list of relators or by giving
  a  list  of equations. Relators are just words in the generators of the free
  group.  Equations are represented as pairs of words in the generators of the
  free  group. In either case the generators of the quotient are the images of
  the  free  generators  under  the canonical homomorphism from the free group
  onto the quotient. So for example to create the group
  
  
  ⟨ a, b ∣ a^2, b^3, (a b)^5 ⟩
  
  you can use the following commands:
  
    Example  
    gap> f := FreeGroup( "a", "b" );;
    gap> g := f / [ f.1^2, f.2^3, (f.1*f.2)^5 ];
    <fp group on the generators [ a, b ]>
    gap> h := f / [ [f.1^2, f.1^0], [f.2^3, f.1^0], [(f.1*f.2)^4, f.2^-1*f.1^-1] ];
    <fp group on the generators [ a, b ]>
  
  
  Note that you cannot call the generators by their names. These names are not
  variables,  but  just  display  figures.  So,  if  you  want  to  access the
  generators  by  their  names,  you  first  have  to introduce the respective
  variables and to assign the generators to them.
  
    Example  
    gap> Unbind(a);
    gap> GeneratorsOfGroup( g );
    [ a, b ]
    gap> a;
    Error, Variable: 'a' must have a value
    gap> a := g.1;; b := g.2;; # assign variables
    gap> GeneratorsOfGroup( g );
    [ a, b ]
    gap> a in f;
    false
    gap> a in g;
    true
  
  
  To  relieve  you of the tedium of typing the above assignments, when working
  interactively, there is the function AssignGeneratorVariables (37.2-3).
  
  Note that the generators of the free group are different from the generators
  of  the  FpGroup  (even  though  they are displayed by the same names). That
  means that words in the generators of the free group are not elements of the
  finitely presented group. Vice versa elements of the FpGroup are not words.
  
    Example  
    gap> a*b = b*a;
    false
    gap> (b^2*a*b)^2 = a^0;
    true
  
  
  Such  calculations  comparing  elements of an FpGroup may run into problems:
  There  exist  finitely presented groups for which no algorithm exists (it is
  known  that  no  such  algorithm can exist) that will tell for two arbitrary
  words  in  the  generators whether the corresponding elements in the FpGroup
  are equal.
  
  Therefore  the  methods  used by GAP to compute in finitely presented groups
  may  run  into  warning  errors,  run  out  of memory or run forever. If the
  FpGroup  is  (by theory) known to be finite the algorithms are guaranteed to
  terminate (if there is sufficient memory available), but the time needed for
  the calculation cannot be bounded a priori. See 47.6 and 47.16.
  
    Example  
    gap> (b^2*a*b)^2;
    (b^2*a*b)^2
    gap> a^0;
    <identity ...>
  
  
  A  consequence  of  our  convention  is  that elements of finitely presented
  groups  are  not  printed in a unique way. See also SetReducedMultiplication
  (47.3-4).
  
  
  47.1 IsSubgroupFpGroup and IsFpGroup
  
  47.1-1 IsSubgroupFpGroup
  
  IsSubgroupFpGroup( H )  Category
  
  returns  true if H is a finitely presented group or a subgroup of a finitely
  presented group.
  
  47.1-2 IsFpGroup
  
  IsFpGroup( G )  filter
  
  is a synonym for IsSubgroupFpGroup(G) and IsGroupOfFamily(G).
  
  Free groups are a special case of finitely presented groups, namely finitely
  presented groups with no relators.
  
  Another  special case are groups given by polycyclic presentations. GAP uses
  a  special  representation  for these groups which is created in a different
  way. See chapter 46 for details.
  
    Example  
    gap> g:=FreeGroup(2);
    <free group on the generators [ f1, f2 ]>
    gap> IsFpGroup(g);
    true
    gap> h:=CyclicGroup(2);
    <pc group of size 2 with 1 generators>
    gap> IsFpGroup(h);
    false
  
  
  47.1-3 InfoFpGroup
  
  InfoFpGroup info class
  
  The  info  class  for  functions  dealing  with finitely presented groups is
  InfoFpGroup.
  
  
  47.2 Creating Finitely Presented Groups
  
  47.2-1 \/
  
  \/( F, rels )  method
  \/( F, eqns )  method
  
  creates a finitely presented group given by the presentation ⟨ gens ∣ rels ⟩
  or  ⟨  gens ∣ eqns ⟩, respectively where gens are the free generators of the
  free  group F. Relations can be entered either as words or as pairs of words
  in  the  generators  of F. In the former case we refer to the words given as
  relators, in the latter we refer to the pairs of words as equations. The two
  methods can currently not be mixed.
  
  The same result is obtained with the infix operator /, i.e., as F / rels.
  
    Example  
    gap> f := FreeGroup( 3 );;
    gap> f / [ f.1^4, f.2^3, f.3^5, f.1*f.2*f.3 ];
    <fp group on the generators [ f1, f2, f3 ]>
    gap> f / [ [ f.1^4, f.1^0 ], [ f.2^3, f.1^0 ], [ f.1, f.2^-1*f.3^-1 ] ];
    <fp group on the generators [ f1, f2, f3 ]>
  
  
  47.2-2 FactorGroupFpGroupByRels
  
  FactorGroupFpGroupByRels( G, elts )  function
  
  returns the factor group G/N of G by the normal closure N of elts where elts
  is expected to be a list of elements of G.
  
  47.2-3 ParseRelators
  
  ParseRelators( gens, rels )  function
  
  Will  translate  a  list of relations as given in print, e.g. x y^2 = (x y^3
  x)^2  xy  =  yzx  into relators. gens must be a list of generators of a free
  group,  each being displayed by a single letter. rels is a string that lists
  a sequence of equalities. These must be written in the letters which are the
  names  of  the generators in gens. Change of upper/lower case is interpreted
  to indicate inverses.
  
    Example  
    gap> f:=FreeGroup("x","y","z");;
    gap> AssignGeneratorVariables(f);
    #I  Assigned the global variables [ x, y, z ]
    gap> r:=ParseRelators([x,y,z],
    > "x^2 = y^5 = z^3 = (xyxyxy^4)^2 = (xz)^2 = (y^2z)^2 = 1");
    [ x^2, y^5, z^3, (x*z)^2, (y^2*z)^2, ((x*y)^3*y^3)^2 ]
    gap> g:=f/r;
    <fp group on the generators [ x, y, z ]>
  
  
  47.2-4 StringFactorizationWord
  
  StringFactorizationWord( w )  function
  
  returns  a string that expresses a given word w in compact form written as a
  string.  Inverses  are  expressed  by  changing  the upper/lower case of the
  generators, recurring expressions are written as products.
  
    Example  
    gap> StringFactorizationWord(z^-1*x*y*y*y*x*x*y*y*y*x*y^-1*x);
    "Z(xy3x)2Yx"
  
  
  
  47.3 Comparison of Elements of Finitely Presented Groups
  
  47.3-1 \=
  
  \=( a, b )  method
  
  Two  elements  of  a finitely presented group are equal if they are equal in
  this  group.  Nevertheless they may be represented as different words in the
  generators.   Because   of   the   fundamental  problems  mentioned  in  the
  introduction  to  this  chapter such a test may take very long and cannot be
  guaranteed to finish.
  
  The  method  employed  by  GAP  for such an equality test use the underlying
  finitely  presented group. First (unless this group is known to be infinite)
  GAP  tries  to  find  a  faithful  permutation  representation  by a bounded
  Todd-Coxeter.  If this fails, a Knuth-Bendix (see 52.5) is attempted and the
  words are compared via their normal form.
  
  If  only elements in a subgroup are to be tested for equality it thus can be
  useful  to  translate  the  problem  in  a  new  finitely presented group by
  rewriting (see IsomorphismFpGroup (47.11-1));
  
  The equality test of elements underlies many basic calculations, such as the
  order  of an element, and the same type of problems can arise there. In some
  cases,  working  with rewriting systems can still help to solve the problem.
  The  kbmag  package  provides such functionality, see the package manual for
  further details.
  
  47.3-2 \<
  
  \<( a, b )  method
  
  Compared  with  equality  testing,  problems  get  even worse when trying to
  compute  a  total ordering on the elements of a finitely presented group. As
  any  ordering that is guaranteed to be reproducible in different runs of GAP
  or  even  with  different  groups given by syntactically equal presentations
  would  be  prohibitively expensive to implement, the ordering of elements is
  depending on a method chosen by GAP and not guaranteed to stay the same when
  repeating the construction of an FpGroup. The only guarantee given for the <
  ordering  for  such  elements  is  that it will stay the same for one family
  during its lifetime. The attribute FpElmComparisonMethod (47.3-3) is used to
  obtain a comparison function for a family of FpGroup elements.
  
  47.3-3 FpElmComparisonMethod
  
  FpElmComparisonMethod( fam )  attribute
  
  If  fam  is the elements family of a finitely presented group this attribute
  returns  a  function  smaller(left,  right)  that  will  be  used to compare
  elements in fam.
  
  47.3-4 SetReducedMultiplication
  
  SetReducedMultiplication( obj )  function
  
  For  an FpGroup obj, an element obj of it or the family obj of its elements,
  this function will force immediate reduction when multiplying, keeping words
  short at extra cost per multiplication.
  
  
  47.4 Preimages in the Free Group
  
  47.4-1 FreeGroupOfFpGroup
  
  FreeGroupOfFpGroup( G )  attribute
  
  returns  the  underlying free group for the finitely presented group G. This
  is   the   group   generated   by   the  free  generators  provided  by  the
  FreeGeneratorsOfFpGroup (47.4-2) value of G.
  
  47.4-2 FreeGeneratorsOfFpGroup
  
  FreeGeneratorsOfFpGroup( G )  attribute
  FreeGeneratorsOfWholeGroup( U )  operation
  
  FreeGeneratorsOfFpGroup returns the underlying free generators corresponding
  to  the  generators  of  the finitely presented group G which must be a full
  FpGroup.
  
  FreeGeneratorsOfWholeGroup  also  works  for  subgroups  of  an  FpGroup and
  returns the free generators of the full group that defines the family.
  
  47.4-3 RelatorsOfFpGroup
  
  RelatorsOfFpGroup( G )  attribute
  
  returns  the relators of the finitely presented group G as words in the free
  generators provided by the FreeGeneratorsOfFpGroup (47.4-2) value of G.
  
    Example  
    gap> f := FreeGroup( "a", "b" );;
    gap> g := f / [ f.1^5, f.2^2, f.1^f.2*f.1 ];
    <fp group on the generators [ a, b ]>
    gap> Size( g );
    10
    gap> FreeGroupOfFpGroup( g ) = f;
    true
    gap> FreeGeneratorsOfFpGroup( g );
    [ a, b ]
    gap> RelatorsOfFpGroup( g );
    [ a^5, b^2, b^-1*a*b*a ]
  
  
  Note  that  these  attributes  are  only  available  for  the  full finitely
  presented  group. It is possible (for example by using Subgroup (39.3-1)) to
  construct  a  subgroup of index 1 which is not identical to the whole group.
  The latter one can be obtained in this situation via Parent (31.7-1).
  
  Elements  of  a  finitely presented group are not words, but are represented
  using  a  word  from  the  free  group  as representative. The following two
  commands  obtain  this representative, respectively create an element in the
  finitely presented group.
  
  47.4-4 UnderlyingElement
  
  UnderlyingElement( elm )  operation
  
  Let  elm  be  an  element of a group whose elements are represented as words
  with  further  properties.  Then UnderlyingElement returns the word from the
  free group that is used as a representative for elm.
  
    Example  
    gap> w := g.1*g.2;
    a*b
    gap> IsWord( w );
    false
    gap> ue := UnderlyingElement( w );
    a*b
    gap> IsWord( ue );
    true
  
  
  47.4-5 ElementOfFpGroup
  
  ElementOfFpGroup( fam, word )  operation
  
  If  fam  is  the elements family of a finitely presented group and word is a
  word  in  the free generators underlying this finitely presented group, this
  operation  creates  the  element  with  the  representative word in the free
  group.
  
    Example  
    gap> ge := ElementOfFpGroup( FamilyObj( g.1 ), f.1*f.2 );
    a*b
    gap> ge in f;
    false
    gap> ge in g;
    true
  
  
  
  47.5 Operations for Finitely Presented Groups
  
  Finitely presented groups are groups and so all operations for groups should
  be  applicable  to  them  (though  not  necessarily  efficient  methods  are
  available).  Most  methods  for  finitely  presented  groups  rely  on coset
  enumeration. See 47.6 for details.
  
  The  command  IsomorphismPermGroup (43.3-1) can be used to obtain a faithful
  permutation representation, if such a representation of small degree exists.
  (Otherwise it might run very long or fail.)
  
    Example  
    gap> f := FreeGroup( "a", "b" );
    <free group on the generators [ a, b ]>
    gap> g := f / [ f.1^2, f.2^3, (f.1*f.2)^5 ];
    <fp group on the generators [ a, b ]>
    gap> h := IsomorphismPermGroup( g );
    [ a, b ] -> [ (1,2)(4,5), (2,3,4) ]
    gap> u:=Subgroup(g,[g.1*g.2]);;rt:=RightTransversal(g,u);
    RightTransversal(<fp group of size 60 on the generators 
    [ a, b ]>,Group([ a*b ]))
    gap> Image(ActionHomomorphism(g,rt,OnRight));
    Group([ (1,2)(3,4)(5,7)(6,8)(9,10)(11,12), 
      (1,3,2)(4,5,6)(7,8,9)(10,11,12) ])
  
  
  47.5-1 PseudoRandom
  
  PseudoRandom( F: radius := l )  method
  
  The  default  algorithm  for  PseudoRandom  (30.7-2)  makes little sense for
  finitely  presented  or free groups, as it produces words that are extremely
  long.
  
  By  specifying the option radius, instead elements are taken as words in the
  generators  of F in the ball of radius l with equal distribution in the free
  group.
  
    Example  
    gap> PseudoRandom(g:radius:=20);
    a^3*b^2*a^-2*b^-1*a*b^-4*a*b^-1*a*b^-4
  
  
  
  47.6 Coset Tables and Coset Enumeration
  
  Coset enumeration (see [Neu82] for an explanation) is one of the fundamental
  tools  for  the  examination  of  finitely  presented  groups.  This section
  describes GAP functions that can be used to invoke a coset enumeration.
  
  Note  that  in  addition  to  the built-in coset enumerator there is the GAP
  package  ACE.  Moreover, GAP provides an interactive Todd-Coxeter in the GAP
  package ITC which is based on the XGAP package.
  
  47.6-1 CosetTable
  
  CosetTable( G, H )  operation
  
  returns  the  coset table of the finitely presented group G on the cosets of
  the subgroup H.
  
  Basically  a  coset  table is the permutation representation of the finitely
  presented  group  on the cosets of a subgroup (which need not be faithful if
  the  subgroup  has  a  nontrivial core). Most of the set theoretic and group
  functions  use  the  regular representation of G, i.e., the coset table of G
  over the trivial subgroup.
  
  The  coset table is returned as a list of lists. For each generator of G and
  its  inverse the table contains a generator list. A generator list is simply
  a  list  of  integers. If l is the generator list for the generator g and if
  l[i] = j then generator g takes the coset i to the coset j by multiplication
  from  the right. Thus the permutation representation of G on the cosets of H
  is obtained by applying PermList (42.5-2) to each generator list.
  
  The coset table is standard (see below).
  
  For  finitely  presented groups, a coset table is computed by a Todd-Coxeter
  coset  enumeration.  Note  that  you  may  influence the performance of that
  enumeration    by    changing   the   values   of   the   global   variables
  CosetTableDefaultLimit   (47.6-7)   and  CosetTableDefaultMaxLimit  (47.6-6)
  described     below     and     that    the    options    described    under
  CosetTableFromGensAndRels (47.6-5) are recognized.
  
    Example  
    gap> tab := CosetTable(g, Subgroup(g, [ g.1, g.2*g.1*g.2*g.1*g.2^-1 ]));
    [ [ 1, 4, 5, 2, 3 ], [ 1, 4, 5, 2, 3 ], [ 2, 3, 1, 4, 5 ], 
      [ 3, 1, 2, 4, 5 ] ]
    gap> List( last, PermList );
    [ (2,4)(3,5), (2,4)(3,5), (1,2,3), (1,3,2) ]
    gap> PrintArray( TransposedMat( tab ) );
    [ [  1,  1,  2,  3 ],
      [  4,  4,  3,  1 ],
      [  5,  5,  1,  2 ],
      [  2,  2,  4,  4 ],
      [  3,  3,  5,  5 ] ]
  
  
  The  last  printout in the preceding example provides the coset table in the
  form  in  which it is usually used in hand calculations: The rows correspond
  to  the  cosets, the columns correspond to the generators and their inverses
  in  the  ordering  g_1,  g_1^{-1},  g_2,  g_2^{-1}.  (See section 47.7 for a
  description on the way the numbers are assigned.)
  
  47.6-2 TracedCosetFpGroup
  
  TracedCosetFpGroup( tab, word, pt )  function
  
  Traces  the coset number pt under the word word through the coset table tab.
  (Note:  word must be in the free group, use UnderlyingElement (47.4-4) if in
  doubt.)
  
    Example  
    gap> TracedCosetFpGroup(tab,UnderlyingElement(g.1),2);
    4
  
  
  47.6-3 FactorCosetAction
  
  FactorCosetAction( G, H )  operation
  
  returns the action of G on the cosets of its subgroup H.
  
    Example  
    gap> u := Subgroup( g, [ g.1, g.1^g.2 ] );
    Group([ a, b^-1*a*b ])
    gap> FactorCosetAction( g, u );
    [ a, b ] -> [ (2,4)(5,6), (1,2,3)(4,5,6) ]
  
  
  47.6-4 CosetTableBySubgroup
  
  CosetTableBySubgroup( G, H )  operation
  
  returns a coset table for the action of G on the cosets of H. The columns of
  the table correspond to the GeneratorsOfGroup (39.2-4) value of G.
  
  47.6-5 CosetTableFromGensAndRels
  
  CosetTableFromGensAndRels( fgens, grels, fsgens )  function
  
  is  an  internal  function  which  is  called  by  the  functions CosetTable
  (47.6-1),  CosetTableInWholeGroup  (47.8-1)  and others. It is, in fact, the
  proper  working  horse that performs a Todd-Coxeter coset enumeration. fgens
  must  be  a  set  of  free  generators  and grels a set of relators in these
  generators.  fsgens  are  subgroup  generators  expressed  as words in these
  generators. The function returns a coset table with respect to fgens.
  
  CosetTableFromGensAndRels  will  call TCENUM.CosetTableFromGensAndRels. This
  makes  it possible to replace the built-in coset enumerator with another one
  by assigning TCENUM to another record.
  
  The  library  version  which  is  used by default performs a standard Felsch
  strategy  coset  enumeration.  You  can  call  this  function  explicitly as
  GAPTCENUM.CosetTableFromGensAndRels  even  if  other  coset  enumerators are
  installed.
  
  The expected parameters are
  
  fgens
        generators of the free group F
  
  grels
        relators as words in F
  
  fsgens
        subgroup generators as words in F.
  
  CosetTableFromGensAndRels processes two options (see chapter 8):
  
  max
        The  limit  of  the number of cosets to be defined. If the enumeration
        does not finish with this number of cosets, an error is raised and the
        user  is asked whether she wants to continue. The default value is the
        value  given  in  the  variable CosetTableDefaultMaxLimit. (Due to the
        algorithm  the  actual  limit used can be a bit higher than the number
        given.)
  
  silent
        If  set to true the algorithm will not raise the error mentioned under
        option  max  but  silently  return  fail.  This  can  be  useful if an
        enumeration is only wanted unless it becomes too big.
  
  47.6-6 CosetTableDefaultMaxLimit
  
  CosetTableDefaultMaxLimit global variable
  
  is  the  default  limit  for  the  number  of  cosets  allowed  in  a  coset
  enumeration.
  
  A  coset  enumeration  will  not finish if the subgroup does not have finite
  index, and even if it has it may take many more intermediate cosets than the
  actual  index  of the subgroup is. To avoid a coset enumeration running away
  therefore  GAP  has a safety stop built in. This is controlled by the global
  variable CosetTableDefaultMaxLimit.
  
  If  this  number  of  cosets is reached, GAP will issue an error message and
  prompt  the  user  to  either  continue  the  calculation or to stop it. The
  default value is 4096000.
  
  See  also  the  description  of  the  options  to  CosetTableFromGensAndRels
  (47.6-5).
  
    Example  
    gap> f := FreeGroup( "a", "b" );;
    gap> u := Subgroup( f, [ f.2 ] );
    Group([ b ])
    gap> Index( f, u );
    Error, the coset enumeration has defined more than 4096000 cosets
     called from
    TCENUM.CosetTableFromGensAndRels( fgens, grels, fsgens ) called from
    CosetTableFromGensAndRels( fgens, grels, fsgens ) called from
    TryCosetTableInWholeGroup( H ) called from
    CosetTableInWholeGroup( H ) called from
    IndexInWholeGroup( H ) called from
    ...
    Entering break read-eval-print loop ...
    type 'return;' if you want to continue with a new limit of 8192000 cosets,
    type 'quit;' if you want to quit the coset enumeration,
    type 'maxlimit := 0; return;' in order to continue without a limit
    brk> quit;
  
  
  At  this  point,  a  break-loop (see Section 6.4) has been entered. The line
  beginning  Error  tells you why this occurred. The next seven lines occur if
  OnBreak  (6.4-3)  has its default value Where (6.4-5). They explain, in this
  case,  how  GAP  came  to be doing a coset enumeration. Then you are given a
  number  of  options of how to escape the break-loop: you can either continue
  the  calculation  with  a  larger  number  of  permitted  cosets,  stop  the
  calculation  if  you  don't  expect  the  enumeration to finish (like in the
  example  above),  or  continue  without  a  limit  on  the number of cosets.
  (Choosing  the  first option will, of course, land you back in a break-loop.
  Try it!)
  
  Setting CosetTableDefaultMaxLimit (or the max option value, for any function
  that  invokes a coset enumeration) to infinity (18.2-1) (or to 0) will force
  all coset enumerations to continue until they either get a result or exhaust
  the whole available space. For example, each of the following two inputs
  
  
    gap> CosetTableDefaultMaxLimit := 0;;
    gap> Index( f, u );
  
  
  or
  
  
    gap> Index( f, u : max := 0 );
  
  
  have  essentially  the  same  effect  as  choosing the third option (typing:
  maxlimit := 0; return;) at the brk> prompt above (instead of quit;).
  
  47.6-7 CosetTableDefaultLimit
  
  CosetTableDefaultLimit global variable
  
  is  the  default  number of cosets with which any coset table is initialized
  before doing a coset enumeration.
  
  The function performing this coset enumeration will automatically extend the
  table  whenever  necessary  (as long as the number of cosets does not exceed
  the  value  of CosetTableDefaultMaxLimit (47.6-6)), but this is an expensive
  operation.  Thus,  if  you  change  the value of CosetTableDefaultLimit, you
  should  set  it  to  a number of cosets that you expect to be sufficient for
  your  subsequent  coset  enumerations. On the other hand, if you make it too
  large, your job will unnecessarily waste a lot of space.
  
  The default value of CosetTableDefaultLimit is 1000.
  
  47.6-8 MostFrequentGeneratorFpGroup
  
  MostFrequentGeneratorFpGroup( G )  function
  
  is  an  internal  function which is used in some applications of coset table
  methods.  It  returns  the  first  of those generators of the given finitely
  presented group G which occur most frequently in the relators.
  
  47.6-9 IndicesInvolutaryGenerators
  
  IndicesInvolutaryGenerators( G )  attribute
  
  returns  the  indices  of those generators of the finitely presented group G
  which  are  known  to  be  involutions.  This  knowledge is used by internal
  functions to improve the performance of coset enumerations.
  
  
  47.7 Standardization of coset tables
  
  For  any two coset numbers i and j with i < j the first occurrence of i in a
  coset  table  precedes  the  first occurrence of j with respect to the usual
  row-wise  ordering  of  the table entries. Following the notation of Charles
  Sims'  book  on  computation  with finitely presented groups [Sim94] we call
  such a table a standard coset table.
  
  The table entries which contain the first occurrences of the coset numbers i
  >  1  recursively  provide  for each i a representative of the corresponding
  coset  in form of a unique word w_i in the generators and inverse generators
  of  G.  The  first coset (which is H itself) can be represented by the empty
  word  w_1.  A coset table is standard if and only if the words w_1, w_2, ...
  are  length-plus-lexicographic  ordered  (as defined in [Sim94]), for short:
  lenlex.
  
  This  standardization  of  coset  tables  is different from that used in GAP
  versions  4.2  and  earlier.  Before  that,  we  ignored  the  columns  that
  correspond  to  inverse  generators  and  hence only considered words in the
  generators  of  G. We call this older ordering the semilenlex standard as it
  also  applies  to the case of semigroups where no inverses of the generators
  are known.
  
  We  changed  our default from the semilenlex standard to the lenlex standard
  to  be  consistent  with  [Sim94].  However,  the semilenlex standardisation
  remains  available and the convention used for all implicit standardisations
  can   be   selected   by   setting   the   value   of  the  global  variable
  CosetTableStandard  (47.7-1) to either "lenlex" or "semilenlex". Independent
  of  the current value of CosetTableStandard (47.7-1) you can standardize (or
  restandardize) a coset table at any time using StandardizeTable (47.7-2).
  
  47.7-1 CosetTableStandard
  
  CosetTableStandard global variable
  
  specifies  the  definition  of  a  standard coset table. It is used whenever
  coset  tables  or  augmented  coset  tables  are  created.  Its value may be
  "lenlex"   or   "semilenlex".  If  it  is  "lenlex"  coset  tables  will  be
  standardized  using all their columns as defined in Charles Sims' book (this
  is  the  new  default  standard  of GAP). If it is "semilenlex" they will be
  standardized  using  only their generator columns (this was the original GAP
  standard). The default value of CosetTableStandard is "lenlex".
  
  47.7-2 StandardizeTable
  
  StandardizeTable( table, standard )  function
  
  standardizes  the  given coset table table. The second argument is optional.
  It  defines  the  standard  to  be  used,  its  values  may  be  "lenlex" or
  "semilenlex"  specifying  the new or the old convention, respectively. If no
  value  for  the  parameter  standard  is  provided the function will use the
  global  variable CosetTableStandard (47.7-1) instead. Note that the function
  alters the given table, it does not create a copy.
  
    Example  
    gap> StandardizeTable( tab, "semilenlex" );
    gap> PrintArray( TransposedMat( tab ) );
    [ [  1,  1,  2,  4 ],
      [  3,  3,  4,  1 ],
      [  2,  2,  3,  3 ],
      [  5,  5,  1,  2 ],
      [  4,  4,  5,  5 ] ]
  
  
  
  47.8 Coset tables for subgroups in the whole group
  
  47.8-1 CosetTableInWholeGroup
  
  CosetTableInWholeGroup( H )  attribute
  TryCosetTableInWholeGroup( H )  operation
  
  is  equivalent to CosetTable(G,H) where G is the (unique) finitely presented
  group  such  that  H  is  a  subgroup  of  G.  It  overrides a silent option
  (see CosetTableFromGensAndRels (47.6-5)) with false.
  
  The  variant  TryCosetTableInWholeGroup  does not override the silent option
  with  false  in  case  a coset table is only wanted if not too expensive. It
  will    store    a    result   that   is   not   fail   in   the   attribute
  CosetTableInWholeGroup.
  
  47.8-2 SubgroupOfWholeGroupByCosetTable
  
  SubgroupOfWholeGroupByCosetTable( fpfam, tab )  function
  
  takes  a  family  fpfam of an FpGroup and a standardized coset table tab and
  returns  the  subgroup of fpfam!.wholeGroup defined by this coset table. The
  function  will  not  check  whether  the  coset  table  is standardized. See
  also CosetTableBySubgroup (47.6-4).
  
  
  47.9 Augmented Coset Tables and Rewriting
  
  47.9-1 AugmentedCosetTableInWholeGroup
  
  AugmentedCosetTableInWholeGroup( H[, gens] )  function
  
  For  a  subgroup  H  of a finitely presented group, this function returns an
  augmented  coset  table.  If a generator set gens is given, it is guaranteed
  that  gens will be a subset of the primary and secondary subgroup generators
  of this coset table.
  
  It  is  mutable so we are permitted to add further entries. However existing
  entries  may  not be changed. Any entries added however should correspond to
  the subgroup only and not to a homomorphism.
  
  47.9-2 AugmentedCosetTableMtc
  
  AugmentedCosetTableMtc( G, H, type, string )  function
  
  is  an  internal  function  used  by  the  subgroup  presentation  functions
  described  in  48.2. It applies a Modified Todd-Coxeter coset representative
  enumeration  to  construct an augmented coset table (see 48.2) for the given
  subgroup  H  of  G.  The subgroup generators will be named string1, string2,
  ....
  
  The  function  accepts  the  options  max  and  silent  as described for the
  function CosetTableFromGensAndRels (47.6-5).
  
  47.9-3 AugmentedCosetTableRrs
  
  AugmentedCosetTableRrs( G, table, type, string )  function
  
  is  an  internal  function  used  by  the  subgroup  presentation  functions
  described  in  48.2.  It applies the Reduced Reidemeister-Schreier method to
  construct an augmented coset table for the subgroup of G which is defined by
  the  given  coset  table  table.  The  new subgroup generators will be named
  string1, string2, ....
  
  47.9-4 RewriteWord
  
  RewriteWord( aug, word )  function
  
  RewriteWord rewrites word (which must be a word in the underlying free group
  with  respect  to  which  the  augmented  coset  table  aug is given) in the
  subgroup  generators  given  by  the augmented coset table aug. It returns a
  Tietze-type  word  (i.e. a  list  of integers), referring to the primary and
  secondary generators of aug.
  
  If word is not contained in the subgroup, fail is returned.
  
  
  47.10 Low Index Subgroups
  
  47.10-1 LowIndexSubgroupsFpGroupIterator
  
  LowIndexSubgroupsFpGroupIterator( G[, H], index[, excluded] )  operation
  LowIndexSubgroupsFpGroup( G[, H], index[, excluded] )  operation
  
  These   functions  compute  representatives  of  the  conjugacy  classes  of
  subgroups of the finitely presented group G that contain the subgroup H of G
  and that have index less than or equal to index.
  
  LowIndexSubgroupsFpGroupIterator  returns an iterator (see 30.8) that can be
  used  to  run over these subgroups, and LowIndexSubgroupsFpGroup returns the
  list of these subgroups. If one is interested only in one or a few subgroups
  up to a given index then preferably the iterator should be used.
  
  If the optional argument excluded has been specified, then it is expected to
  be a list of words in the free generators of the underlying free group of G,
  and  LowIndexSubgroupsFpGroup  returns only those subgroups of index at most
  index  that  contain H, but do not contain any conjugate of any of the group
  elements defined by these words.
  
  If not given, H defaults to the trivial subgroup.
  
  The  algorithm  used finds the requested subgroups by systematically running
  through  a  tree  of all potential coset tables of G of length at most index
  (where it skips all branches of that tree for which it knows in advance that
  they  cannot provide new classes of such subgroups). The time required to do
  this  depends,  of  course, on the presentation of G, but in general it will
  grow  exponentially  with  the value of index. So you should be careful with
  the choice of index.
  
    Example  
    gap> li:=LowIndexSubgroupsFpGroup( g, TrivialSubgroup( g ), 10 );
    [ Group(<fp, no generators known>), Group(<fp, no generators known>), 
      Group(<fp, no generators known>), Group(<fp, no generators known>) ]
  
  
  By  default,  the  algorithm  computes no generating sets for the subgroups.
  This can be enforced with GeneratorsOfGroup (39.2-4):
  
    Example  
    gap> GeneratorsOfGroup(li[2]);
    [ a, b*a*b^-1 ]
  
  
  If  we  are interested just in one (proper) subgroup of index at most 10, we
  can  use  the function that returns an iterator. The first subgroup found is
  the  group  itself,  except  if  a list of excluded elements is entered (see
  below), so we look at the second subgroup.
  
    Example  
    gap> iter:= LowIndexSubgroupsFpGroupIterator( g, 10 );;
    gap> s1:= NextIterator( iter );;  Index( g, s1 );
    1
    gap> IsDoneIterator( iter );
    false
    gap> s2:= NextIterator( iter );;  s2 = li[2];
    true
  
  
  As  an  example  for  an  application of the optional parameter excluded, we
  compute  all conjugacy classes of torsion free subgroups of index at most 24
  in  the  group  G = ⟨ x,y,z ∣ x^2, y^4, z^3, (xy)^3, (yz)^2, (xz)^3 ⟩. It is
  know  from  theory that each torsion element of this group is conjugate to a
  power  of  x,  y,  z,  xy, xz, or yz. (Note that this includes conjugates of
  y^2.)
  
    Example  
    gap> F := FreeGroup( "x", "y", "z" );;
    gap> x := F.1;; y := F.2;; z := F.3;;
    gap> G := F / [ x^2, y^4, z^3, (x*y)^3, (y*z)^2, (x*z)^3 ];;
    gap> torsion := [ x, y, y^2, z, x*y, x*z, y*z ];;
    gap> SetInfoLevel( InfoFpGroup, 2 );
    gap> lis := LowIndexSubgroupsFpGroup(G, TrivialSubgroup(G), 24, torsion);;
    #I  LowIndexSubgroupsFpGroup called
    #I   class 1 of index 24 and length 8
    #I   class 2 of index 24 and length 24
    #I   class 3 of index 24 and length 24
    #I   class 4 of index 24 and length 24
    #I   class 5 of index 24 and length 24
    #I  LowIndexSubgroupsFpGroup done. Found 5 classes
    gap> SetInfoLevel( InfoFpGroup, 0 );
  
  
  If  a  particular  image group is desired, the operation GQuotients (40.9-4)
  (see 47.14) can be useful as well.
  
  
  47.11 Converting Groups to Finitely Presented Groups
  
  47.11-1 IsomorphismFpGroup
  
  IsomorphismFpGroup( G )  attribute
  
  returns an isomorphism from the given finite group G to a finitely presented
  group  isomorphic  to G. The function first chooses a set of generators of G
  and then computes a presentation in terms of these generators.
  
    Example  
    gap> g := Group( (2,3,4,5), (1,2,5) );;
    gap> iso := IsomorphismFpGroup( g );
    [ (4,5), (1,2,3,4,5), (1,3,2,4,5) ] -> [ F1, F2, F3 ]
    gap> fp := Image( iso );
    <fp group on the generators [ F1, F2, F3 ]>
    gap> RelatorsOfFpGroup( fp );
    [ F1^2, F1^-1*F2*F1*F2^-1*F3*F2^-2, F1^-1*F3*F1*F2*F3^-1*F2*F3*F2^-1, 
      F2^5*F3^-5, F2^5*(F3^-1*F2^-1)^2, (F2^-2*F3^2)^2 ]
  
  
  47.11-2 IsomorphismFpGroupByGenerators
  
  IsomorphismFpGroupByGenerators( G, gens[, string] )  function
  IsomorphismFpGroupByGeneratorsNC( G, gens, string )  operation
  
  returns an isomorphism from a finite group G to a finitely presented group F
  isomorphic to G. The generators of F correspond to the generators of G given
  in  the  list  gens. If string is given it is used to name the generators of
  the finitely presented group.
  
  The NC version will avoid testing whether the elements in gens generate G.
  
    Example  
    gap> SetInfoLevel( InfoFpGroup, 1 );
    gap> iso := IsomorphismFpGroupByGenerators( g, [ (1,2), (1,2,3,4,5) ] );
    #I  the image group has 2 gens and 4 rels of total length 50
    [ (1,2), (1,2,3,4,5) ] -> [ F1, F2 ]
    gap> fp := Image( iso );
    <fp group of size 120 on the generators [ F1, F2 ]>
    gap> RelatorsOfFpGroup( fp );
    [ F1^2, (F2*F1*F2^-2*F1)^3, 
      F2*F1*F2^-1*(F1*F2)^2*F2^2*(F1*F2^-1)^2*F2^-1*F1, 
      (F2*F1*F2^-1*F1)^2*F2^-1*F1*F2^2*F1*F2^-2*F1*F2*F1 ]
  
  
  The  main  task  of the function IsomorphismFpGroupByGenerators is to find a
  presentation  of  G  in  the  provided  generators  gens.  In  the case of a
  permutation group G it does this by first constructing a stabilizer chain of
  G  and  then  it  works  through  that  chain  from  the  bottom to the top,
  recursively  computing  a presentation for each of the involved stabilizers.
  The   method   used  is  essentially  an  implementation  of  John  Cannon's
  multi-stage  relations-finding  algorithm  as described in [Neu82] (see also
  [Can73]  for a more graph theoretical description). Moreover, it makes heavy
  use  of  Tietze  transformations  in each stage to avoid an explosion of the
  total length of the relators.
  
  Note  that because of the random methods involved in the construction of the
  stabilizer  chain  the  resulting  presentations  of  G  will  in general be
  different for repeated calls with the same arguments.
  
    Example  
    gap> M12 := MathieuGroup( 12 );
    Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6), 
      (1,12)(2,11)(3,6)(4,8)(5,9)(7,10) ])
    gap> gens := GeneratorsOfGroup( M12 );;
    gap> iso := IsomorphismFpGroupByGenerators( M12, gens );;
    #I  the image group has 3 gens and 20 rels of total length 554
    gap> iso := IsomorphismFpGroupByGenerators( M12, gens );;
    #I  the image group has 3 gens and 19 rels of total length 427
  
  
  Also    in   the   case   of   a   permutation   group   G,   the   function
  IsomorphismFpGroupByGenerators  supports  the option method that can be used
  to modify the strategy. The option method may take the following values.
  
  method := "regular"
        This  may  be  specified  for groups of small size, up to 10^5 say. It
        implies  that the function first constructs a regular representation R
        of  G and then a presentation of R. In general, this presentation will
        be  much  more concise than the default one, but the price is the time
        needed for the construction of R.
  
  method := [ "regular", bound ]
        This  is a refinement of the previous possibility. In this case, bound
        should  be  an  integer,  and  if so the method "regular" as described
        above  is applied to the largest stabilizer in the stabilizer chain of
        G  whose size does not exceed the given bound and then the multi-stage
        algorithm  is used to work through the chain from that subgroup to the
        top.
  
  method := "fast"
        This  chooses  an  alternative  method  which essentially is a kind of
        multi-stage  algorithm  for  a stabilizer chain of G but does not make
        any attempt do reduce the number of relators as it is done in Cannon's
        algorithm  or  to  reduce  their  total length. Hence it is often much
        faster  than the default method, but the total length of the resulting
        presentation may be huge.
  
  method := "default"
        This  simply means that the default method shall be used, which is the
        case if the option method is not given a value.
  
    Example  
    gap> iso := IsomorphismFpGroupByGenerators( M12, gens : 
    >                                           method := "regular" );;
    #I  the image group has 3 gens and 11 rels of total length 92
    gap> iso := IsomorphismFpGroupByGenerators( M12, gens : 
    >                                           method := "fast" );;
    #I  the image group has 3 gens and 136 rels of total length 3215
  
  
  Though  the  option  method  :=  "regular"  is only checked in the case of a
  permutation  group  it  also  affects the performance and the results of the
  function  IsomorphismFpGroupByGenerators  for other groups, e. g. for matrix
  groups. This happens because, for these groups, the function first calls the
  function  NiceMonomorphism  (40.5-2)  to get a bijective action homomorphism
  from  G to a suitable permutation group, P say, and then, recursively, calls
  itself for the group P so that now the option becomes relevant.
  
    Example  
    gap> G := ImfMatrixGroup( 5, 1, 3 );
    ImfMatrixGroup(5,1,3)
    gap> gens := GeneratorsOfGroup( G );
    [ [ [ -1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], 
          [ -1, -1, -1, -1, 2 ], [ -1, 0, 0, 0, 1 ] ], 
      [ [ 0, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], 
          [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1 ] ] ]
    gap> iso := IsomorphismFpGroupByGenerators( G, gens );;
    #I  the image group has 2 gens and 10 rels of total length 126
    gap> iso := IsomorphismFpGroupByGenerators( G, gens : 
    >                                           method := "regular");;
    #I  the image group has 2 gens and 6 rels of total length 56
    gap> SetInfoLevel( InfoFpGroup, 0 );
    gap> iso;
    <composed isomorphism:[ [ [ -1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, \
    0, 0, 1, 0 ], [ -1, -1, -1, -1, 2 ], [ -1, 0, 0, 0, 1 ] ], [ [ 0, 1, 0\
    , 0, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 1, 0, 0, 0, 0 ], [ 0\
    , 0, 0, 0, 1 ] ] ]->[ F1, F2 ]>
    gap> ConstituentsCompositionMapping(iso);
    [ <action isomorphism>, 
      [ (2,3,4)(5,6)(8,9,10), (1,2,3,5)(6,7,8,9) ] -> [ F1, F2 ] ]
  
  
  Since  GAP  cannot decompose elements of a matrix group into generators, the
  resulting isomorphism is stored as a composition of a (faithful) permutation
  action  on  vectors  and  a  homomorphism  from the permutation image to the
  finitely  presented  group. In such a situation the constituent mappings can
  be  obtained  via  ConstituentsCompositionMapping  (32.2-8)  as separate GAP
  objects.
  
  
  47.12 New Presentations and Presentations for Subgroups
  
  IsomorphismFpGroup  (47.11-1)  is  also  used  to  compute  a  new  finitely
  presented  group  that  is  isomorphic  to  the given subgroup of a finitely
  presented  group.  (This  is  typically  the  only  method  to  compute with
  subgroups of a finitely presented group.)
  
    Example  
    gap> f:=FreeGroup(2);;
    gap> g:=f/[f.1^2,f.2^3,(f.1*f.2)^5];
    <fp group on the generators [ f1, f2 ]>
    gap> u:=Subgroup(g,[g.1*g.2]);
    Group([ f1*f2 ])
    gap> hom:=IsomorphismFpGroup(u);
    [ <[ [ 1, 1 ] ]|f2^-1*f1^-1> ] -> [ F1 ]
    gap> new:=Range(hom);
    <fp group on the generators [ F1 ]>
    gap> List(GeneratorsOfGroup(new),i->PreImagesRepresentative(hom,i));
    [ <[ [ 1, 1 ] ]|f2^-1*f1^-1> ]
  
  
  When  working  with such homomorphisms, some subgroup elements are expressed
  as  extremely  long  words in the group generators. Therefore the underlying
  words  of  subgroup  generators  stored  in  the isomorphism (as obtained by
  MappingGeneratorsImages  (40.10-2)  and  displayed  when View (6.3-3)ing the
  homomorphism)  as well as preimages under the homomorphism are stored in the
  form  of  straight  line program elements (see 37.9). These will behave like
  ordinary words and no extra treatment should be necessary.
  
    Example  
    gap> r:=Range(hom).1^10;
    F1^10
    gap> p:=PreImagesRepresentative(hom,r);
    <[ [ 1, 10 ] ]|(f2^-1*f1^-1)^10>
  
  
  If  desired,  it  also  is  possible to convert these underlying words using
  EvalStraightLineProgElm (37.9-4):
  
    Example  
    gap> r:=EvalStraightLineProgElm(UnderlyingElement(p));
    (f2^-1*f1^-1)^10
    gap> p:=ElementOfFpGroup(FamilyObj(p),r);
    (f2^-1*f1^-1)^10
  
  
  (If  you are only interested in a finitely presented group isomorphic to the
  given  subgroup  but  not in the isomorphism, you may also use the functions
  PresentationViaCosetTable  (48.1-5)  and  FpGroupPresentation  (48.1-4) (see
  48.1).)
  
  Homomorphisms  can  also  be used to obtain an isomorphic finitely presented
  group with a (hopefully) simpler presentation.
  
  47.12-1 IsomorphismSimplifiedFpGroup
  
  IsomorphismSimplifiedFpGroup( G )  attribute
  
  applies  Tietze  transformations  to a copy of the presentation of the given
  finitely  presented group G in order to reduce it with respect to the number
  of generators, the number of relators, and the relator lengths.
  
  The  operation  returns  an  isomorphism  with  source  G,  range  a group H
  isomorphic  to  G,  so  that the presentation of H has been simplified using
  Tietze transformations.
  
    Example  
    gap> f:=FreeGroup(3);;
    gap> g:=f/[f.1^2,f.2^3,(f.1*f.2)^5,f.1/f.3];
    <fp group on the generators [ f1, f2, f3 ]>
    gap> hom:=IsomorphismSimplifiedFpGroup(g);
    [ f1, f2, f3 ] -> [ f1, f2, f1 ]
    gap> Range(hom);
    <fp group on the generators [ f1, f2 ]>
    gap> RelatorsOfFpGroup(Range(hom));
    [ f1^2, f2^3, (f1*f2)^5 ]
    gap> RelatorsOfFpGroup(g);
    [ f1^2, f2^3, (f1*f2)^5, f1*f3^-1 ]
  
  
  IsomorphismSimplifiedFpGroup  uses  Tietze  transformations  to simplify the
  presentation, see 48.1-6.
  
  
  47.13 Preimages under Homomorphisms from an FpGroup
  
  For  some  subgroups  of  a  finitely presented group the number of subgroup
  generators  increases  with  the  index of the subgroup. However often these
  generators  are  not  needed  at  all  for further calculations, but what is
  needed  is the action of the cosets of the subgroup. This gives the image of
  the  subgroup  in  a finite quotient and this finite quotient can be used to
  calculate normalizers, closures, intersections and so forth [Hul01].
  
  The  same  applies  for  subgroups  that  are  obtained  as  preimages under
  homomorphisms.
  
  47.13-1 SubgroupOfWholeGroupByQuotientSubgroup
  
  SubgroupOfWholeGroupByQuotientSubgroup( fpfam, Q, U )  function
  
  takes  a FpGroup family fpfam, a finitely generated group Q such that the fp
  generators   of  fpfam  can  be  mapped  by  an  epimorphism  phi  onto  the
  GeneratorsOfGroup (39.2-4) value of Q, and a subgroup U of Q. It returns the
  subgroup of fpfam!.wholeGroup which is the full preimage of U under phi.
  
  47.13-2 IsSubgroupOfWholeGroupByQuotientRep
  
  IsSubgroupOfWholeGroupByQuotientRep( G )  Representation
  
  is  the  representation  for  subgroups  of  an FpGroup, given by a quotient
  subgroup.  The  components  G!.quot  and  G!.sub hold quotient, respectively
  subgroup.
  
  47.13-3 AsSubgroupOfWholeGroupByQuotient
  
  AsSubgroupOfWholeGroupByQuotient( U )  attribute
  
  returns      the      same      subgroup      in      the     representation
  AsSubgroupOfWholeGroupByQuotient.
  
  See  also SubgroupOfWholeGroupByCosetTable (47.8-2) and CosetTableBySubgroup
  (47.6-4).
  
  This technique is used by GAP for example to represent the derived subgroup,
  which is obtained from the quotient G/G'.
  
    Example  
    gap> f:=FreeGroup(2);;g:=f/[f.1^6,f.2^6,(f.1*f.2)^6];;
    gap> d:=DerivedSubgroup(g);
    Group(<fp, no generators known>)
    gap> Index(g,d);
    36
  
  
  47.13-4 DefiningQuotientHomomorphism
  
  DefiningQuotientHomomorphism( U )  function
  
  if      U      is      a     subgroup     in     quotient     representation
  (IsSubgroupOfWholeGroupByQuotientRep  (47.13-2)),  this function returns the
  defining homomorphism from the whole group to U!.quot.
  
  
  47.14 Quotient Methods
  
  An  important  class  of  algorithms  for  finitely presented groups are the
  quotient  algorithms  which  compute  quotient  groups  of  a given finitely
  presented  group. There are algorithms for epimorphisms onto abelian groups,
  p-groups     and    solvable    groups.    (The    low    index    algorithm
  –LowIndexSubgroupsFpGroup  (47.10-1)–  can  be  considered  as  well  as  an
  algorithm that produces permutation group quotients.)
  
  MaximalAbelianQuotient (39.18-4), as defined for general groups, returns the
  largest abelian quotient of the given group.
  
    Example  
    gap> f:=FreeGroup(2);;fp:=f/[f.1^6,f.2^6,(f.1*f.2)^12];
    <fp group on the generators [ f1, f2 ]>
    gap> hom:=MaximalAbelianQuotient(fp);
    [ f1, f2 ] -> [ f1, f3 ]
    gap> Size(Image(hom));
    36
  
  
  47.14-1 PQuotient
  
  PQuotient( F, p[, c][, logord][, ctype] )  function
  
  computes  a  factor  p-group  of  a  finitely presented group F in form of a
  quotient  system.  The  quotient system can be converted into an epimorphism
  from  F  onto the p-group computed by the function EpimorphismQuotientSystem
  (47.14-2).
  
  For  a  group G define the exponent-p central series of G inductively by cal
  P_1(G)  =  G and cal P_{i+1}(G) = [cal P_i(G),G]cal P_{i+1}(G)^p. The factor
  groups modulo the terms of the lower exponent-p central series are p-groups.
  The group G has p-class c if cal P_c(G) ≠ cal P_{c+1}(G) = 1.
  
  The  algorithm  computes  successive  quotients  modulo  the  terms  of  the
  exponent-p  central  series  of  F.  If the parameter c is present, then the
  factor  group modulo the (c+1)-th term of the exponent-p central series of F
  is returned. If c is not present, then the algorithm attempts to compute the
  largest  factor  p-group  of  F.  In  case  F does not have a largest factor
  p-group, the algorithm will not terminate.
  
  By  default  the algorithm computes only with factor groups of order at most
  p^256.  If  the  parameter  logord  is  present, it will compute with factor
  groups  of  order at most p^logord. If this parameter is specified, then the
  parameter c must also be given. The present implementation produces an error
  message   if   the   order  of  a  p-quotient  exceeds  p^256  or  p^logord,
  respectively.  Note  that  the  order of intermediate p-groups may be larger
  than the final order of a p-quotient.
  
  The  parameter  ctype  determines  the  type  of  collector that is used for
  computations  within  the  factor  p-group. ctype must either be "single" in
  which  case  a  simple collector from the left is used or "combinatorial" in
  which case a combinatorial collector from the left is used.
  
  47.14-2 EpimorphismQuotientSystem
  
  EpimorphismQuotientSystem( quotsys )  operation
  
  For   a  quotient  system  quotsys  obtained  from  the  function  PQuotient
  (47.14-1),  this  operation  returns  an  epimorphism  F  → P where F is the
  finitely presented group of which quotsys is a quotient system and P is a pc
  group isomorphic to the quotient of F determined by quotsys.
  
  Different  calls to this operation will create different groups P, each with
  its own family.
  
    Example  
    gap> PQuotient( FreeGroup(2), 5, 10, 1024, "combinatorial" );
    <5-quotient system of 5-class 10 with 520 generators>
    gap> phi := EpimorphismQuotientSystem( last );
    [ f1, f2 ] -> [ a1, a2 ]
    gap> Collected( Factors( Size( Image( phi ) ) ) );
    [ [ 5, 520 ] ]
  
  
  47.14-3 EpimorphismPGroup
  
  EpimorphismPGroup( fpgrp, p[, cl] )  operation
  
  computes  an  epimorphism  from  the  finitely  presented group fpgrp to the
  largest  p-group  of  p-class  cl  which  is  a  quotient of fpgrp. If cl is
  omitted,  the  largest  finite  p-group  quotient (of p-class up to 1000) is
  determined.
  
    Example  
    gap> hom:=EpimorphismPGroup(fp,2);
    [ f1, f2 ] -> [ a1, a2 ]
    gap> Size(Image(hom));
    8
    gap> hom:=EpimorphismPGroup(fp,3,7);
    [ f1, f2 ] -> [ a1, a2 ]
    gap> Size(Image(hom));
    6561
  
  
  47.14-4 EpimorphismNilpotentQuotient
  
  EpimorphismNilpotentQuotient( fpgrp[, n] )  function
  
  returns  an  epimorphism  on  the  class  n finite nilpotent quotient of the
  finitely  presented  group  fpgrp.  If  n  is  omitted,  the  largest finite
  nilpotent quotient (of p-class up to 1000) is taken.
  
    Example  
    gap> hom:=EpimorphismNilpotentQuotient(fp,7);
    [ f1, f2 ] -> [ f1*f4, f2*f5 ]
    gap> Size(Image(hom));
    52488
  
  
  A related operation which is also applicable to finitely presented groups is
  GQuotients  (40.9-4),  which  computes  all  epimorphisms  from  a (finitely
  presented) group F onto a given (finite) group G.
  
    Example  
    gap> GQuotients(fp,Group((1,2,3),(1,2)));
    [ [ f1, f2 ] -> [ (1,2), (2,3) ], [ f1, f2 ] -> [ (2,3), (1,2,3) ], 
      [ f1, f2 ] -> [ (1,2,3), (2,3) ] ]
  
  
  47.14-5 SolvableQuotient
  
  SolvableQuotient( F, size )  function
  SolvableQuotient( F, primes )  function
  SolvableQuotient( F, tuples )  function
  SQ( F, ... )  function
  
  This  routine calls the solvable quotient algorithm for a finitely presented
  group  F.  The  quotient to be found can be specified in the following ways:
  Specifying  an  integer  size  finds  a quotient of size up to size (if such
  large  quotients  exist).  Specifying  a  list of primes in primes finds the
  largest  quotient  involving the given primes. Finally tuples can be used to
  prescribe a chief series.
  
  SQ can be used as a synonym for SolvableQuotient.
  
  47.14-6 EpimorphismSolvableQuotient
  
  EpimorphismSolvableQuotient( F, param )  function
  
  computes  an  epimorphism  from  the  finitely  presented group fpgrp to the
  largest  solvable  quotient given by param (specified as in SolvableQuotient
  (47.14-5)).
  
    Example  
    gap> f := FreeGroup( "a", "b", "c", "d" );;
    gap> fp := f / [ f.1^2, f.2^2, f.3^2, f.4^2, f.1*f.2*f.1*f.2*f.1*f.2,
    >  f.2*f.3*f.2*f.3*f.2*f.3*f.2*f.3, f.3*f.4*f.3*f.4*f.3*f.4,
    > f.1^-1*f.3^-1*f.1*f.3, f.1^-1*f.4^-1*f.1*f.4,
    > f.2^-1*f.4^-1*f.2*f.4 ];;
    gap> hom:=EpimorphismSolvableQuotient(fp,300);Size(Image(hom));
    [ a, b, c, d ] -> [ f1*f2, f1*f2, f2*f3, f2 ]
    12
    gap> hom:=EpimorphismSolvableQuotient(fp,[2,3]);Size(Image(hom));
    [ a, b, c, d ] -> [ f1*f2*f4, f1*f2*f6*f8, f2*f3, f2 ]
    1152
  
  
  47.14-7 LargerQuotientBySubgroupAbelianization
  
  LargerQuotientBySubgroupAbelianization( hom, U )  function
  
  Let hom a homomorphism from a finitely presented group G to a finite group H
  and  Ule  H.  This  function will -- if it exists -- return a subgroup SleG,
  such  that  the core of S is properly contained in the kernel of hom as well
  as  in  V', where V is the pre-image of U under hom. Thus S exposes a larger
  quotient of G. If no such subgroup exists, fail is returned.
  
    Example  
    gap> f:=FreeGroup("x","y","z");;
    gap> g:=f/ParseRelators(f,"x^3=y^3=z^5=(xyx^2y^2)^2=(xz)^2=(yz^3)^2=1");
    <fp group on the generators [ x, y, z ]>
    gap> l:=LowIndexSubgroupsFpGroup(g,6);;
    gap> List(l,IndexInWholeGroup);
    [ 1, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 ]
    gap> q:=DefiningQuotientHomomorphism(l[6]);;p:=Image(q);Size(p);
    Group([ (4,5,6), (1,2,3)(4,6,5), (2,4,6,3,5) ])
    360
    gap> s:=LargerQuotientBySubgroupAbelianization(q,SylowSubgroup(p,3)); 
    Group(<fp, no generators known>)
    gap> Size(Image(DefiningQuotientHomomorphism(s))); 
    193273528320
  
  
  
  47.15 Abelian Invariants for Subgroups
  
  Using  variations of coset enumeration it is possible to compute the abelian
  invariants  of  a subgroup of a finitely presented group without computing a
  complete  presentation  for  the subgroup in the first place. Typically, the
  operation  AbelianInvariants  (39.16-1)  when  called  for  subgroups should
  automatically  take  care  of  this,  but  in  case you want to have further
  control about the methods used, the following operations might be of use.
  
  47.15-1 AbelianInvariantsSubgroupFpGroup
  
  AbelianInvariantsSubgroupFpGroup( G, H )  function
  
  AbelianInvariantsSubgroupFpGroup        is        a        synonym       for
  AbelianInvariantsSubgroupFpGroupRrs (47.15-3).
  
  47.15-2 AbelianInvariantsSubgroupFpGroupMtc
  
  AbelianInvariantsSubgroupFpGroupMtc( G, H )  function
  
  uses the Modified Todd-Coxeter method to compute the abelian invariants of a
  subgroup H of a finitely presented group G.
  
  
  47.15-3 AbelianInvariantsSubgroupFpGroupRrs
  
  AbelianInvariantsSubgroupFpGroupRrs( G, H )  function
  AbelianInvariantsSubgroupFpGroupRrs( G, table )  function
  
  uses  the  Reduced  Reidemeister-Schreier  method  to  compute  the  abelian
  invariants of a subgroup H of a finitely presented group G.
  
  Alternatively  to the subgroup H, its coset table table in G may be given as
  second argument.
  
  47.15-4 AbelianInvariantsNormalClosureFpGroup
  
  AbelianInvariantsNormalClosureFpGroup( G, H )  function
  
  AbelianInvariantsNormalClosureFpGroup       is       a      synonym      for
  AbelianInvariantsNormalClosureFpGroupRrs (47.15-5).
  
  47.15-5 AbelianInvariantsNormalClosureFpGroupRrs
  
  AbelianInvariantsNormalClosureFpGroupRrs( G, H )  function
  
  uses  the  Reduced  Reidemeister-Schreier  method  to  compute  the  abelian
  invariants  of  the  normal  closure of a subgroup H of a finitely presented
  group G. See 48.2 for details on the different strategies.
  
  The  following  example  shows a calculation for the Coxeter group B_1. This
  calculation  and  a  similar one for B_0 have been used to prove that B_1' /
  B_1''  ≅  Z_2^9  ×  Z^3  and  B_0'  /  B_0'' ≅ Z_2^91 × Z^27 as stated in in
  [FJNT95, Proposition 5].
  
    Example  
    gap> # Define the Coxeter group E1.
    gap> F := FreeGroup( "x1", "x2", "x3", "x4", "x5" );
    <free group on the generators [ x1, x2, x3, x4, x5 ]>
    gap> x1 := F.1;; x2 := F.2;; x3 := F.3;; x4 := F.4;; x5 := F.5;;
    gap> rels := [ x1^2, x2^2, x3^2, x4^2, x5^2,
    >  (x1 * x3)^2, (x2 * x4)^2, (x1 * x2)^3, (x2 * x3)^3, (x3 * x4)^3,
    >  (x4 * x1)^3, (x1 * x5)^3, (x2 * x5)^2, (x3 * x5)^3, (x4 * x5)^2,
    >  (x1 * x2 * x3 * x4 * x3 * x2)^2 ];;
    gap> E1 := F / rels;
    <fp group on the generators [ x1, x2, x3, x4, x5 ]>
    gap> x1 := E1.1;; x2 := E1.2;; x3 := E1.3;; x4 := E1.4;; x5 := E1.5;;
    gap> # Get normal subgroup generators for B1.
    gap> H := Subgroup( E1, [ x5 * x2^-1, x5 * x4^-1 ] );;
    gap> # Compute the abelian invariants of B1/B1'.
    gap> A := AbelianInvariantsNormalClosureFpGroup( E1, H );
    [ 2, 2, 2, 2, 2, 2, 2, 2 ]
    gap> # Compute a presentation for B1.
    gap> P := PresentationNormalClosure( E1, H );
    <presentation with 18 gens and 46 rels of total length 132>
    gap> SimplifyPresentation( P );
    #I  there are 8 generators and 30 relators of total length 148
    gap> B1 := FpGroupPresentation( P );
    <fp group on the generators [ _x1, _x2, _x3, _x4, _x6, _x7, _x8, _x11 
     ]>
    gap> # Compute normal subgroup generators for B1'.
    gap> gens := GeneratorsOfGroup( B1 );;
    gap> numgens := Length( gens );;
    gap> comms := [ ];;
    gap> for i in [ 1 .. numgens - 1 ] do
    >     for j in [i+1 .. numgens ] do
    >         Add( comms, Comm( gens[i], gens[j] ) );
    >     od;
    > od;
    gap> # Compute the abelian invariants of B1'/B1".
    gap> K := Subgroup( B1, comms );;
    gap> A := AbelianInvariantsNormalClosureFpGroup( B1, K );
    [ 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2 ]
  
  
  
  47.16 Testing Finiteness of Finitely Presented Groups
  
  As  a  consequence  of  the  algorithmic  insolvabilities  mentioned  in the
  introduction  to  this  chapter,  there cannot be a general method that will
  test whether a given finitely presented group is actually finite.
  
  Therefore  testing  the  finiteness  of  a  finitely  presented group can be
  problematic.  What GAP actually does upon a call of IsFinite (30.4-2) (or if
  it is –probably implicitly– asked for a faithful permutation representation)
  is  to test whether it can find (via coset enumeration) a cyclic subgroup of
  finite  index.  If  it  can,  it rewrites the presentation to this subgroup.
  Since  the  subgroup  is  cyclic,  its  size  can be checked easily from the
  resulting  presentation,  the  size of the whole group is the product of the
  index  and the subgroup size. Since however no bound for the index of such a
  subgroup  (if any exist) is known, such a test might continue unsuccessfully
  until memory is exhausted.
  
  On  the other hand, a couple of methods exist, that might prove that a group
  is infinite. Again, none is guaranteed to work in every case:
  
  The  first  method  is  to  find  (for  example via the low index algorithm,
  see LowIndexSubgroupsFpGroup  (47.10-1))  a  subgroup  U such that [U:U'] is
  infinite.    If   U   has   finite   index,   this   can   be   checked   by
  IsInfiniteAbelianizationGroup (47.16-1).
  
  Note   that   this   test  has  been  done  traditionally  by  checking  the
  AbelianInvariants      (39.16-1)      (see      section 47.15)     of     U,
  IsInfiniteAbelianizationGroup (47.16-1) does a similar calculation but stops
  as  soon  as  it  is  known  whether 0 is an invariant without computing the
  actual values. This can be notably faster.
  
  Another  method  is  based on p-group quotients, see NewmanInfinityCriterion
  (47.16-2).
  
  47.16-1 IsInfiniteAbelianizationGroup
  
  IsInfiniteAbelianizationGroup( G )  attribute
  
  returns  true if the commutator factor group G/G' is infinite. This might be
  done without computing the full structure of the commutator factor group.
  
  47.16-2 NewmanInfinityCriterion
  
  NewmanInfinityCriterion( G, p )  function
  
  Let  G be a finitely presented group and p a prime that divides the order of
  the  commutator  factor  group  of  G.  This  function  applies  an infinity
  criterion  due  to M. F. Newman [New90] to G. (See [Joh97, chapter 16] for a
  more  explicit  description.)  It  returns true if the criterion succeeds in
  proving that G is infinite and fail otherwise.
  
  Note  that  the criterion uses the number of generators and relations in the
  presentation  of G. Reduction of the presentation via Tietze transformations
  (IsomorphismSimplifiedFpGroup   (47.12-1))   therefore   might   produce  an
  isomorphic group, for which the criterion will work better.
  
    Example  
    gap> g:=FibonacciGroup(2,9);
    <fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9 ]>
    gap> hom:=EpimorphismNilpotentQuotient(g,2);;
    gap> k:=Kernel(hom);;
    gap> Index(g,k);
    152
    gap> AbelianInvariants(k);
    [ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
    gap> NewmanInfinityCriterion(Kernel(hom),5);
    true
  
  
  This  proves  that  the subgroup k (and thus the whole group g) is infinite.
  (This is the original example from [New90].)