  
  [1m[4m[31m3. The Functions of the Package[0m
  
  
  [1m[4m[31m3.1 Nilpotent Quotients of Finitely Presented Groups[0m
  
  [1m[4m[31m3.1-1 NilpotentQuotient[0m
  
  [1m[34m> NilpotentQuotient( [0m[22m[34m[output-file,] fp-group[, id-gens][,][c][0m[1m[34m ) ____[0mfunction
  [1m[34m> NilpotentQuotient( [0m[22m[34m[output-file,] input-file[, c][0m[1m[34m ) ______________[0mfunction
  
  The  parameter  [1mfp-group[0m  is  either  a finitely presented group or a record
  specifying  a  presentation  by  expression  trees  (see  section  [1m2.6[0m). The
  parameter  [1minput-file[0m is a string specifying the name of a file containing a
  finite  presentation  in  the  input format (cf. section [1m2.8[0m) of the ANU NQ.
  Such  a  file  can  be  prepared  by  a  text editor or with the help of the
  function [1m[34mNqStringFpGroup[0m ([1m3.3-2[0m).
  
  Let  G  be the group defined by [1mfp-group[0m or the group defined in [1minput-file[0m.
  The  function  computes  a  nilpotent presentation for G/gamma_c+1(G) if the
  optional  parameter  [1mc[0m  is  specified.  If [1mc[0m is not given, then the function
  attempts  to  compute  the  largest  nilpotent  quotient  of  G  and it will
  terminate  only if G has a largest nilpotent quotient. See section [1m3.5[0m for a
  possibility to follow the progress of the computation.
  
  The  optional  argument  [1mid-gens[0m  is  a list of generators of the free group
  underlying  the  finitely  presented  group [1mfp-group[0m. The generators in this
  list are treated as identical generators. Consequently, all relations of the
  [1mfp-group[0m  involving  these generators are treated as identical relations for
  these generators.
  
  In  addition  to  the  arguments  explained  above, the function accepts the
  following options as shown in the first example below:
  
  --    [22m[32mgroup[0m This option can be used instead of the parameter [1mfp-group[0m.
  
  --    [22m[32minput\_string[0m  This option can be used to specify a finitely presented
        group by a string in the input format of the standalone program.
  
  --    [22m[32minput\_file[0m This option specifies a file with input for the standalone
        program.
  
  --    [22m[32moutput\_file[0m  This  option  specifies  a  file  for  the output of the
        standalone.
  
  --    [22m[32midgens[0m This options specifies a list of identical generators.
  
  --    [22m[32mclass[0m  This  option  specifies  the  nilpotency  class up to which the
        nilpotent quotient will be computed.
  
  The following example computes the class-5 quotient of the free group on two
  generators.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup( 2 );[0m
    [22m[35m<free group on the generators [ f1, f2 ]>[0m
    [22m[35mgap> ## Equivalent to:  NilpotentQuotient( : group := F, class := 5 );[0m
    [22m[35mgap> ##                 NilpotentQuotient( F : class := 5 );          [0m
    [22m[35mgap> H := NilpotentQuotient( F, 5 );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ][0m
    [22m[35mgap> lcs := LowerCentralSeries( H );;[0m
    [22m[35mgap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od;[0m
    [22m[35mPcp-group with orders [ 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0 ][0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  Note  that  the  lower  central  series  in  the example is part of the data
  returned by the standalone program. Therefore, the execution of the function
  LowerCentralSeries takes no time.
  
  The  next  example  computes  the  class-4 quotient of the infinite dihedral
  group. The group is soluble but not nilpotent. The first factor of its lower
  central series is a Klein four group and all the other factors are cyclic or
  order 2.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup( 2 );[0m
    [22m[35m<free group on the generators [ f1, f2 ]>[0m
    [22m[35mgap> G := F / [F.1^2, F.2^2];[0m
    [22m[35m<fp group on the generators [ f1, f2 ]>[0m
    [22m[35mgap> H := NilpotentQuotient( G, 4 ); [0m
    [22m[35mPcp-group with orders [ 2, 2, 2, 2, 2 ][0m
    [22m[35mgap> lcs := LowerCentralSeries( H );;[0m
    [22m[35mgap> for i in [1..Length(lcs)-1] do[0m
    [22m[35m>       Print( AbelianInvariants(lcs[i] / lcs[i+1]), "\n" );[0m
    [22m[35m> od;[0m
    [22m[35m[ 2, 2 ][0m
    [22m[35m[ 2 ][0m
    [22m[35m[ 2 ][0m
    [22m[35m[ 2 ][0m
    [22m[35mgap> [0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  In  the  following example identical generators are used in order to express
  the  fact  that  the  group is nilpotent of class 3. A group is nilpotent of
  class  3  if  it  satisfies  the identical relation [x_1,x_2,x_3,x_4]=1 (cf.
  Section  [1m2.5[0m).  The  result  is  the  free nilpotent group of class 3 on two
  generators.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup( "a", "b", "w", "x", "y", "z" );[0m
    [22m[35m<free group on the generators [ a, b, w, x, y, z ]>[0m
    [22m[35mgap> G := F / [ LeftNormedComm( [F.3,F.4,F.5,F.6] ) ];[0m
    [22m[35m<fp group of size infinity on the generators [ a, b, w, x, y, z ]>[0m
    [22m[35mgap> ## The following is equivalent to: [0m
    [22m[35mgap> ##   NilpotentQuotient( G : idgens := [F.3,F.4,F.5,F.6] );[0m
    [22m[35mgap> H := NilpotentQuotient( G, [F.3,F.4,F.5,F.6] );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0 ][0m
    [22m[35mgap> NilpotencyClassOfGroup(H);[0m
    [22m[35m3[0m
    [22m[35mgap> LowerCentralSeries(H);[0m
    [22m[35m[ Pcp-group with orders [ 0, 0, 0, 0, 0 ], Pcp-group with orders [ 0, 0, 0 ], [0m
    [22m[35m  Pcp-group with orders [ 0, 0 ], Pcp-group with orders [  ] ][0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  The  following  example  uses expression trees in order to specify the third
  Engel law for the free group on 3 generators.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> et := ExpressionTrees( 5 );                            [0m
    [22m[35m[ x1, x2, x3, x4, x5 ][0m
    [22m[35mgap> comm := LeftNormedComm( [et[1], et[2], et[2], et[2]] );[0m
    [22m[35mComm( x1, x2, x2, x2 )[0m
    [22m[35mgap> G := rec( generators := et, relations := [comm] );[0m
    [22m[35mrec( generators := [ x1, x2, x3, x4, x5 ], [0m
    [22m[35m  relations := [ Comm( x1, x2, x2, x2 ) ] )[0m
    [22m[35mgap> H := NilpotentQuotient( G : idgens := [et[1],et[2]] );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 2, 2, [0m
    [22m[35m  0, 6, 6, 0, 0, 2, 10, 10, 10 ][0m
    [22m[35mgap> TorsionSubgroup( H );[0m
    [22m[35mPcp-group with orders [ 2, 2, 2, 2, 2, 2, 2, 10, 10, 10 ][0m
    [22m[35mgap> lcs := LowerCentralSeries( H );;[0m
    [22m[35mgap> NilpotencyClassOfGroup( H );[0m
    [22m[35m5[0m
    [22m[35mgap> for i in [1..5] do Print( lcs[i] / lcs[i+1], "\n" ); od;[0m
    [22m[35mPcp-group with orders [ 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 2, 4, 2, 2, 0, 6, 6, 0, 0, 2 ][0m
    [22m[35mPcp-group with orders [ 10, 10, 10 ][0m
    [22m[35mgap> for i in [1..5] do Print( AbelianInvariants(lcs[i]/lcs[i+1]), "\n" ); od;[0m
    [22m[35m[ 0, 0, 0 ][0m
    [22m[35m[ 0, 0, 0 ][0m
    [22m[35m[ 0, 0, 0, 0, 0, 0, 0, 0 ][0m
    [22m[35m[ 2, 2, 2, 2, 2, 2, 2, 0, 0, 0 ][0m
    [22m[35m[ 10, 10, 10 ][0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  The  example  above  also  shows  that  the  relative  orders  of an abelian
  polycyclic group need not be the abelian invariants (elementary divisors) of
  the  group.  Each  zero  corresponds  to  a generator of infinite order. The
  number of zeroes is always correct.
  
  [1m[4m[31m3.1-2 NilpotentEngelQuotient[0m
  
  [1m[34m> NilpotentEngelQuotient( [0m[22m[34m[output-file,] fp-group, n[, id-gens][,][c][0m[1m[34m ) [0mfunction
  [1m[34m> NilpotentEngelQuotient( [0m[22m[34m[output-file,] input-file, n[, c][0m[1m[34m ) ______[0mfunction
  
  This  function  is  a  special  version  of  [1m[34mNilpotentQuotient[0m ([1m3.1-1[0m) which
  enforces  the  n-th  Engel  identity on the nilpotent quotients of the group
  specified  by  [1mfp-group[0m  or  by  [1minput-file[0m.  It accepts the same options as
  [1mNilpotentQuotient[0m.
  
  The  Engel  condition can also be enforced by using identical generators and
  the Engel law and [1m[34mNilpotentQuotient[0m ([1m3.1-1[0m). See the examples there.
  
  The  following example computes the relatively free fifth Engel group on two
  generators,  determines  its  (normal)  torsion  subgroup  and  computes the
  corresponding  quotient  group.  The quotient modulo the torsion subgroup is
  torsion-free.  Therefore,  there  is  a nilpotent presentation without power
  relations.  The  example  computes  a nilpotent presentation for the torsion
  free factor group through the upper central series. The factors of the upper
  central  series  in  a  torsion free group are torsion free. In this way one
  obtains  a  set  of generators of infinite order and the resulting nilpotent
  presentation has no power relations.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> G := NilpotentEngelQuotient( FreeGroup(2), 5 );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, [0m
    [22m[35m  0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, [0m
    [22m[35m  2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ][0m
    [22m[35mgap> NilpotencyClassOfGroup(G);[0m
    [22m[35m9[0m
    [22m[35mgap> T := TorsionSubgroup( G );[0m
    [22m[35mPcp-group with orders [ 3, 3, 2, 2, 3, 3, 2, 9, 3, 5, 2, 3, 2, 10, 5, 2, 3, [0m
    [22m[35m  3, 3, 3, 3, 5, 5, 3, 3 ][0m
    [22m[35mgap> IsAbelian( T );[0m
    [22m[35mtrue[0m
    [22m[35mgap> AbelianInvariants( T );[0m
    [22m[35m[ 3, 3, 3, 3, 3, 3, 3, 3, 30, 30, 30, 180, 180 ][0m
    [22m[35mgap> H := G / T;[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, [0m
    [22m[35m  0, 0, 30, 0, 5, 0, 2, 0, 0, 10, 0, 2, 5, 0 ][0m
    [22m[35mgap> H := PcpGroupBySeries( UpperCentralSeries(H), "snf" );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, [0m
    [22m[35m  0, 0, 0, 0, 0 ][0m
    [22m[35mgap> ucs := UpperCentralSeries( H );;[0m
    [22m[35mgap> for i in [1..NilpotencyClassOfGroup(H)] do[0m
    [22m[35m> 	Print( ucs[i]/ucs[i+1], "\n" );[0m
    [22m[35m> od;[0m
    [22m[35mPcp-group with orders [ 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0 ][0m
    [22m[35mPcp-group with orders [ 0, 0, 0 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m3.1-3 NqEpimorphismNilpotentQuotient[0m
  
  [1m[34m> NqEpimorphismNilpotentQuotient( [0m[22m[34m[output-file,] fp-group[, id-gens][,][c][0m[1m[34m ) [0mfunction
  
  This  function  computes an epimorphism from the group G given by the finite
  presentation  [1mfp-group[0m  onto  G/gamma_c+1(G).  If  [1mc[0m  is not given, then the
  largest  nilpotent  quotient of G is computed and an epimorphism from G onto
  the  largest nilpotent quotient of G. If G does not have a largest nilpotent
  quotient, the function will not terminate if c is not given.
  
  The  optional  argument  [1mid-gens[0m  is  a list of generators of the free group
  underlying  the  finitely  presented  group [1mfp-group[0m. The generators in this
  list are treated as identical generators. Consequently, all relations of the
  [1mfp-group[0m  involving  these generators are treated as identical relations for
  these generators.
  
  If  identical  generators  are specified, then the epimorphism returned maps
  the  group  generated  by  the `non-identical' generators onto the nilpotent
  factor group. See the last example below.
  
  The  function understands the same options as the function [1m[34mNilpotentQuotient[0m
  ([1m3.1-1[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup(3);                              [0m
    [22m[35m<free group on the generators [ f1, f2, f3 ]>[0m
    [22m[35mgap> phi := NqEpimorphismNilpotentQuotient( F, 5 );[0m
    [22m[35m[ f1, f2, f3 ] -> [ g1, g2, g3 ][0m
    [22m[35mgap> Image( phi, LeftNormedComm( [F.3, F.2, F.1] ) );[0m
    [22m[35mg12[0m
    [22m[35mgap> F := FreeGroup( "a", "b" ); [0m
    [22m[35m<free group on the generators [ a, b ]>[0m
    [22m[35mgap> G := F / [ F.1^2, F.2^2 ];     [0m
    [22m[35m<fp group on the generators [ a, b ]>[0m
    [22m[35mgap> phi := NqEpimorphismNilpotentQuotient( G, 4 );   [0m
    [22m[35m[ a, b ] -> [ g1, g2 ][0m
    [22m[35mgap> Image( phi, Comm(G.1,G.2) ); [0m
    [22m[35mg3*g4[0m
    [22m[35mgap> F := FreeGroup( "a", "b", "u", "v", "x" );[0m
    [22m[35m<free group on the generators [ a, b, u, v, x ]>[0m
    [22m[35mgap> a := F.1;; b := F.2;; u := F.3;; v := F.4;; x := F.5;;[0m
    [22m[35mgap> G := F / [ x^5, LeftNormedComm( [u,v,v,v] ) ];[0m
    [22m[35m<fp group of size infinity on the generators [ a, b, u, v, x ]>[0m
    [22m[35mgap> phi := NqEpimorphismNilpotentQuotient( G : idgens:=[u,v,x], class:=5 );[0m
    [22m[35m[ a, b ] -> [ g1, g2 ][0m
    [22m[35mgap> U := Source(phi);                            [0m
    [22m[35mGroup([ a, b ])[0m
    [22m[35mgap> ImageElm( phi, LeftNormedComm( [U.1*U.2, U.2^-1,U.2^-1,U.2^-1,] ) );[0m
    [22m[35mid[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  Note  that the last epimorphism is a map from the group generated by a and b
  onto  the  nilpotent  quotient.  The  identical  generators are used only to
  formulate  the  identical  relator.  They are not generators of the group G.
  Also note that the left-normed commutator above is mapped to the identity as
  G satisfies the specified identical law.
  
  [1m[4m[31m3.1-4 LowerCentralFactors[0m
  
  [1m[34m> LowerCentralFactors( [0m[22m[34m...[0m[1m[34m ) _______________________________________[0mfunction
  
  This  function  accepts  the same arguments and options as [1m[34mNilpotentQuotient[0m
  ([1m3.1-1[0m)  and returns a list containing the abelian invariants of the central
  factors in the lower central series of the specified group.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> LowerCentralFactors( FreeGroup(2), 6 );[0m
    [22m[35m[ [ 0, 0 ], [ 0 ], [ 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0 ], [0m
    [22m[35m  [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m3.2 Expression Trees[0m
  
  [1m[4m[31m3.2-1 ExpressionTrees[0m
  
  [1m[34m> ExpressionTrees( [0m[22m[34mm[, prefix][0m[1m[34m ) ___________________________________[0mfunction
  [1m[34m> ExpressionTrees( [0m[22m[34mstr1, str2, str3, ...[0m[1m[34m ) _________________________[0mfunction
  
  The  argument [1mm[0m must be a positive integer. The function returns a list with
  [1mm[0m  expression  tree  symbols  named x1, x2,... The optional parameter [1mprefix[0m
  must be a string and is used instead of [1mx[0m if present.
  
  Alternatively,  the  function  can  be executed with a list of strings [1mstr1[0m,
  [1mstr2[0m, .... It returns a list of symbols with these strings as names.
  
  The  following  operations are defined for expression trees: multiplication,
  inversion, exponentiation, forming commutators, forming conjugates.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> t := ExpressionTrees( 3 );                      [0m
    [22m[35m[ x1, x2, x3 ][0m
    [22m[35mgap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] );[0m
    [22m[35mComm( x1, x2 )^3/Comm( x1, x2, x3, x1 )[0m
    [22m[35mgap> t := ExpressionTrees( "a", "b", "x" );[0m
    [22m[35m[ a, b, x ][0m
    [22m[35mgap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] );[0m
    [22m[35mComm( a, b )^3/Comm( a, b, x, a )[0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m3.2-2 EvaluateExpTree[0m
  
  [1m[34m> EvaluateExpTree( [0m[22m[34mtree, symbols, values[0m[1m[34m ) _________________________[0mfunction
  
  The  argument  [1mtree[0m  is  an  expression  tree  followed by the list of those
  symbols  [1msymbols[0m  from  which  the expression tree is built up. The argument
  [1mvalues[0m  is  a  list  containing  a  constant  for  each symbol. The function
  substitutes  each  value  for  the  corresponding  symbol  and  computes the
  resulting value for [1mtree[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup( 3 );                               [0m
    [22m[35m<free group on the generators [ f1, f2, f3 ]>[0m
    [22m[35mgap> t := ExpressionTrees( "a", "b", "x" );[0m
    [22m[35m[ a, b, x ][0m
    [22m[35mgap> tree := Comm( t[1], t[2] )^3/LeftNormedComm( [t[1],t[2],t[3],t[1]] );[0m
    [22m[35mComm( a, b )^3/Comm( a, b, x, a )[0m
    [22m[35mgap> EvaluateExpTree( tree, t, GeneratorsOfGroup(F) );[0m
    [22m[35mf1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f2^-1*f1*f2*f1^-1*f3^-1*f2^-1*f1^[0m
    [22m[35m-1*f2*f1*f3*f1^-1*f2^-1*f1*f2*f1*f2^-1*f1^-1*f2*f1*f3^-1*f1^-1*f2^-1*f1*f2*f3[0m
    [22m[35m[0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m3.3 Auxiliary Functions[0m
  
  [1m[4m[31m3.3-1 NqReadOutput[0m
  
  [1m[34m> NqReadOutput( [0m[22m[34mstream[0m[1m[34m ) ___________________________________________[0mfunction
  
  The  only  argument  [1mstream[0m  is an output stream of the ANU NQ. The function
  reads  the  stream and returns a record that has a component for each global
  variable used in the output of the ANU NQ, see [1m[34mNqGlobalVariables[0m ([1m3.4-3[0m).
  
  [1m[4m[31m3.3-2 NqStringFpGroup[0m
  
  [1m[34m> NqStringFpGroup( [0m[22m[34mfp-group[, idgens][0m[1m[34m ) ____________________________[0mfunction
  
  The  function takes a finitely presented group [1mfp-group[0m and returns a string
  in  the  input  format of the ANU NQ. If the list [1midgens[0m is present, then it
  must  contain generators of the free group underlying the finitely presented
  group  [1m[34mFreeGroupOfFpGroup[0m ([1mReference: FreeGroupOfFpGroup[0m). The generators in
  [1midgens[0m are treated as identical generators.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> F := FreeGroup(2);[0m
    [22m[35m<free group on the generators [ f1, f2 ]>[0m
    [22m[35mgap> G := F / [F.1^2, F.2^2, (F.1*F.2)^4];[0m
    [22m[35m<fp group on the generators [ f1, f2 ]>[0m
    [22m[35mgap> NqStringFpGroup( G );[0m
    [22m[35m"< x1, x2 |\n    x1^2,\n    x2^2,\n    x1*x2*x1*x2*x1*x2*x1*x2\n>\n"[0m
    [22m[35mgap> Print( last );[0m
    [22m[35m< x1, x2 |[0m
    [22m[35m    x1^2,[0m
    [22m[35m    x2^2,[0m
    [22m[35m    x1*x2*x1*x2*x1*x2*x1*x2[0m
    [22m[35m>[0m
    [22m[35mgap> PrintTo( "dihedral", last );[0m
    [22m[35mgap> ## The following is equivalent to: [0m
    [22m[35mgap> ##     NilpotentQuotient( : input_file := "dihedral" );[0m
    [22m[35mgap> NilpotentQuotient( "dihedral" );[0m
    [22m[35mPcp-group with orders [ 2, 2, 2 ][0m
    [22m[35mgap> Exec( "rm dihedral" );[0m
    [22m[35mgap> F := FreeGroup(3);[0m
    [22m[35m<free group on the generators [ f1, f2, f3 ]>[0m
    [22m[35mgap> H := F / [ LeftNormedComm( [F.2,F.1,F.1] ),                               [0m
    [22m[35m>               LeftNormedComm( [F.2,F.1,F.2] ), F.3^7 ];[0m
    [22m[35m<fp group on the generators [ f1, f2, f3 ]>[0m
    [22m[35mgap> str := NqStringFpGroup( H, [F.3] );                                  [0m
    [22m[35m"< x1, x2; x3 |\n    x1^-1*x2^-1*x1*x2*x1^-1*x2^-1*x1^-1*x2*x1^2,\n    x1^-1*x\[0m
    [22m[35m2^-1*x1*x2^-1*x1^-1*x2*x1*x2,\n    x3^7\n>\n"[0m
    [22m[35mgap> NilpotentQuotient( : input_string := str );[0m
    [22m[35mPcp-group with orders [ 7, 7, 7 ][0m
    [22m[35m[0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m3.3-3 NqStringExpTrees[0m
  
  [1m[34m> NqStringExpTrees( [0m[22m[34mfp-group[, idgens][0m[1m[34m ) ___________________________[0mfunction
  
  The  function  takes  a  finitely presented group [1mfp-group[0m given in terms of
  expression  trees and returns a string in the input format of the ANU NQ. If
  the list [1midgens[0m is present, then it must contain a sublist of the generators
  of  the  presentation.  The  generators  in  [1midgens[0m are treated as identical
  generators.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x := ExpressionTrees( 2 );[0m
    [22m[35m[ x1, x2 ][0m
    [22m[35mgap> rels := [x[1]^2, x[2]^2, (x[1]*x[2])^5]; [0m
    [22m[35m[ x1^2, x2^2, (x1*x2)^5 ][0m
    [22m[35mgap> NqStringExpTrees( rec( generators := x, relations := rels ) );[0m
    [22m[35m"< x1, x2 |\n    x1^2,\n    x2^2,\n    (x1*x2)^5\n>\n"[0m
    [22m[35mgap> Print( last );         [0m
    [22m[35m< x1, x2 |[0m
    [22m[35m    x1^2,[0m
    [22m[35m    x2^2,[0m
    [22m[35m    (x1*x2)^5[0m
    [22m[35m>[0m
    [22m[35mgap> x := ExpressionTrees( 3 );[0m
    [22m[35m[ x1, x2, x3 ][0m
    [22m[35mgap> rels := [LeftNormedComm( [x[2],x[1],x[1]] ),                              [0m
    [22m[35m>             LeftNormedComm( [x[2],x[1],x[2]] ), x[3]^7 ];[0m
    [22m[35m[ Comm( x2, x1, x1 ), Comm( x2, x1, x2 ), x3^7 ][0m
    [22m[35mgap> NqStringExpTrees( rec( generators := x, relations := rels ) );[0m
    [22m[35m"< x1, x2, x3 |\n    [ x2, x1, x1 ],\n    [ x2, x1, x2 ],\n    x3^7\n>\n"[0m
    [22m[35mgap> Print( last );[0m
    [22m[35m< x1, x2, x3 |[0m
    [22m[35m    [ x2, x1, x1 ],[0m
    [22m[35m    [ x2, x1, x2 ],[0m
    [22m[35m    x3^7[0m
    [22m[35m>[0m
    [22m[35m[0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m3.3-4 NqElementaryDivisors[0m
  
  [1m[34m> NqElementaryDivisors( [0m[22m[34mint-mat[0m[1m[34m ) __________________________________[0mfunction
  
  The  function  [1m[34mElementaryDivisorsMat[0m ([1mReference: ElementaryDivisorsMat[0m) only
  returns the non-zero elementary divisors of an integer matrix. This function
  computes  the elementary divisors of [1mint-mat[0m and adds the appropriate number
  of  zeroes  in  order to make it easier to recognize the isomorphism type of
  the abelian group presented by the integer matrix. At the same time ones are
  stripped from the list of elementary divisors.
  
  
  [1m[4m[31m3.4 Global Variables[0m
  
  [1m[4m[31m3.4-1 NqRuntime[0m
  
  [1m[34m> NqRuntime__________________________________________________[0mglobal variable
  
  This  variable  contains  the  number of milliseconds of runtime of the last
  call of ANU NQ.
  
  [22m[35m-----------------------------  Log  ------------------------------[0m
    [22m[35mgap> NilpotentEngelQuotient( FreeGroup(2), 5 );[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 10, [0m
    [22m[35m  0, 0, 30, 0, 3, 3, 10, 2, 0, 6, 0, 0, 30, 2, 0, 9, 3, 5, 2, 6, 2, 10, 5, 5, [0m
    [22m[35m  2, 0, 3, 3, 3, 3, 3, 5, 5, 3, 3 ][0m
    [22m[35mgap> NqRuntime;[0m
    [22m[35m18200[0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m3.4-2 NqDefaultOptions[0m
  
  [1m[34m> NqDefaultOptions___________________________________________[0mglobal variable
  
  This variable contains a list of strings which are the standard command line
  options  passed  to  the ANU NQ in each call. Modifying this variable can be
  used to pass additional options to the ANU NQ.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> NqDefaultOptions;[0m
    [22m[35m[ "-g", "-p", "-C", "-s" ][0m
    [22m[35m     [0m
  [22m[35m------------------------------------------------------------------[0m
  
  The  option [22m[34m-g[0m causes the ANU NQ to produce output in [1mGAP[0m-format. The option
  [22m[34m-p[0m  prevents  the  ANU  NQ from listing the pc-presentation of the nilpotent
  quotient  at  the  end  of  the  calculation.  The  option  [22m[34m-C[0m  invokes  the
  combinatorial collector. The option [22m[34m-s[0m is effective only in conjunction with
  options  for computing with Engel identities and instructs the ANU NQ to use
  only semigroup words in the generators as instances of an Engel law.
  
  [1m[4m[31m3.4-3 NqGlobalVariables[0m
  
  [1m[34m> NqGlobalVariables__________________________________________[0mglobal variable
  
  This  variable  contains  a  list  of  strings  with the names of the global
  variables that are used in the output stream of the ANU NQ. While the output
  stream  is  read,  these  global variables are assigned new values. To avoid
  overwriting  these  variables in case they contain values, their contents is
  saved before reading the output stream and restored afterwards.
  
  
  [1m[4m[31m3.5 Diagnostic Output[0m
  
  While  the standalone program is running it can be asked to display progress
  information.  This  is  done  by  setting the info class [22m[32mInfoNQ[0m to 1 via the
  function [1m[34mSetInfoLevel[0m ([1mReference: SetInfoLevel[0m).
  
  [22m[35m-----------------------------  Log  ------------------------------[0m
    [22m[35mgap> NilpotentQuotient(FreeGroup(2),5);[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ][0m
    [22m[35mgap> SetInfoLevel( InfoNQ, 1 );[0m
    [22m[35mgap> NilpotentQuotient(FreeGroup(2),5);[0m
    [22m[35m#I  Class 1: 2 generators with relative orders  0 0[0m
    [22m[35m#I  Class 2: 1 generators with relative orders: 0[0m
    [22m[35m#I  Class 3: 2 generators with relative orders: 0 0[0m
    [22m[35m#I  Class 4: 3 generators with relative orders: 0 0 0[0m
    [22m[35m#I  Class 5: 6 generators with relative orders: 0 0 0 0 0 0[0m
    [22m[35mPcp-group with orders [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ][0m
    [22m[35mgap> SetInfoLevel( InfoNQ, 0 );[0m
  [22m[35m------------------------------------------------------------------[0m
  
