  
  [1m[4m[31m2. General remarks[0m
  
  In this chapter we define notation used throughout this manual and recollect
  basic  facts  about  nilpotent  groups.  We  also  provide  some  background
  information about the functionality implemented in this package.
  
  
  [1m[4m[31m2.1 Commutators and the Lower Central Series[0m
  
  The  [22m[36mcommutator[0m  of  two  elements  h_1  and h_2 of a group G is the element
  h_1^-1h_2^-1h_1h_2  and  is  denoted by [h_1,h_2]. It satisfies the equation
  h_1h_2  = h_2h_1[h_1,h_2] and can be interpreted as the correction term that
  has  to  be  introduced  into  a  word  if  two  elements  of  a  group  are
  interchanged.  Iterated  commutators  are  written  in  [22m[36mleft-normed fashion[0m:
  [h_1,h_2,...,h_n-1,h_n]=[[h_1,h_2,...,h_n-1],h_n].
  
  The  [22m[36mlower  central  series[0m  of  G is defined inductively as gamma_1(G) = G,
  gamma_i(G)  =  [gamma_i-1(G),G]  for  i ge 2. Each term in the lower central
  series  is a normal (even fully invariant) subgroup of G. The factors of the
  lower  central  series are abelian groups. On each factor the induced action
  of G via conjugation is the trivial action.
  
  The   factor   gamma_k(G)/gamma_k+1(G)   is   generated   by   the  elements
  [g,h]gamma_k+1(G),  where  g  runs  through  a  set  of (representatives of)
  generators for G/gamma_2(G) and h runs through a set of (representatives of)
  generators  for gamma_k-1(G)/gamma_k(G). Therefore, each factor of the lower
  central series is finitely generated if G is finitely generated.
  
  If  one  factor  of  the lower central series is finite, then all subsequent
  factors  are  finite. Then the exponent of the k+1-th factor is a divisor of
  the  exponent of the k-th factor of the lower central series. In particular,
  the  exponents of all factors of the lower central series are bounded by the
  exponent of the first finite factor of the lower central series.
  
  
  [1m[4m[31m2.2 Nilpotent groups[0m
  
  A group G is called [22m[36mnilpotent[0m if there is a positive integer c such that all
  (c+1)-fold  commutators  are  trivial  in  G. The smallest integer with this
  property  is called the [22m[36mnilpotency class[0m of G. In terms of the lower central
  series  a  group  G  not= 1 has nilpotency class c if and only if gamma_c(G)
  not= 1 and gamma_c+1(G) = 1.
  
  Examples of nilpotent groups are finite p-groups, the group of unitriangular
  matrices  over  a ring with one and the factor groups of a free group modulo
  the terms of its lower central series.
  
  Finiteness  of  a  nilpotent  group can be decided by the group's commutator
  factor  group.  A  nilpotent  group  is finite if and only if its commutator
  factor  group is finite. A group whose commutator factor group is finite can
  only have finite nilpotent quotient groups.
  
  By refining the lower central series of a finitely generated nilpotent group
  one   can  obtain  a  (sub)normal  series  G_1>G_2>...>G_k+1=1  with  cyclic
  (central)  factors.  Therefore,  every finitely generated nilpotent group is
  [22m[36mpolycyclic[0m.  Such  a [22m[36mpolycyclic series[0m gives rise to a polycyclic generating
  sequence by choosing a generator a_i for each cyclic factor G_i/G_i+1. Let I
  be  the  set  of  indices  such that G_i/G_i+1 is finite. A simple induction
  argument  shows that every element of the group can be written uniquely as a
  [22m[36mnormal word[0m a_1^e_1... a_n^e_n with integers e_i and 0<= e_i<m_i for iin I.
  
  
  [1m[4m[31m2.3 Nilpotent presentations[0m
  
  From   a   polycyclic  generating  sequence  one  can  obtain  a  [22m[36mpolycyclic
  presentation[0m  for  the  group.  The  following  set  of power and commutator
  relations  is  a  defining  set  of  relations.  The [22m[36mpower relations[0m express
  a_i^m_i  in  terms  of  the  generators  a_i+1,...,a_n whenever G_i/G_i+1 is
  finite  with  order m_i. The [22m[36mcommutator relations[0m are obtained by expressing
  [a_j,a_i]  for  j>i  as  a  word  in  the  generators  a_i+1,...,a_n. If the
  polycyclic  series  is obtained from refining the lower central series, then
  [a_j,a_i]  is  even  a  word  in  a_j+1,...,a_n.  In  this  case we obtain a
  nilpotent presentation.
  
  To  be more precise, a [22m[36mnilpotent presentation[0m is given on a finite number of
  generators  a_1,...,a_n.  Let I be the set of indices such that G_i/G_i+1 is
  finite.  Let  m_i  be  the  order  of  G_i/G_i+1 for iin I. Then a nilpotent
  presentation has the form
  
  \[
       \langle a,\ldots,a_n | a_i^{m_i} = w_{ii}(a_{i+1},\ldots,a_n)
       \mbox{ for } i\in I;\; [a_j,a_i] = w_{ij}(a_{j+1},\ldots,a_n)
       \mbox{ for } 1\leq i < j\leq n\rangle
  \]
  
  Here, w_ij(a_k,...,a_n) denotes a group word in the generators a_k,...,a_n.
  
  In  a group given by a polycyclic presentation each element in the group can
  be  written as a [22m[36mnormal word[0m a_1^e_1... a_n^e_n with e_i in Z and 0 <= e_i <
  m_i  for  i  in  I.  A procedure called [22m[36mcollection[0m can be used to convert an
  arbitrary word in the generators into an equivalent normal word. In general,
  the  resulting  normal  word  need not be unique. The result of collecting a
  word  may  depend  on  the  steps  chosen during the collection procedure. A
  polycyclic  presentation  with  the property that two different normal words
  are never equivalent is called [22m[36mconsistent[0m. A polycyclic presentation derived
  from a polycyclic series as above is consistent. The following example shows
  an inconsistent polycyclic presentation
  
  \[
       \langle a,b\mid a^2, b^a = b^2 \rangle
  \]
  
  as  b  =  baa  =  ab^2a = a^2b^4 = b^4 which implies b^3=1. Here we have the
  equivalent  normal  words  b^3  and  the  empty  word. It can be proved that
  consistency  can  be  checked  by collecting a finite number of words in the
  given  generating  set in two essentially different ways and checking if the
  resulting normal forms are the same in both cases. See Chapter 9 of the book
  [C94] for an introduction to polycyclic groups and polycyclic presentations.
  
  For  computations  in a polycyclic group one chooses a consistent polycyclic
  presentation  as  it  offers a simple solution to the word problem: Equality
  between  two  words  is decided by collecting both words to their respective
  normal  forms and comparing the normal forms. Nilpotent groups and nilpotent
  presentations   are  special  cases  of  polycyclic  groups  and  polycyclic
  presentations.  Nilpotent presentations allow specially efficient collection
  methods.   The  package  [1mPolycyclic[0m  provides  algorithms  to  compute  with
  polycyclic groups given by a polycyclic presentation.
  
  However,   inconsistent  nilpotent  presentations  arise  naturally  in  the
  nilpotent  quotient algorithm. There is an algorithm based on the test words
  for   consistency   mentioned  above  to  modify  the  arising  inconsistent
  presentations suitably to obtain a consistent one for the same group.
  
  
  [1m[4m[31m2.4 A sketch of the algorithm[0m
  
  The  input  for  the  ANU NQ in its simplest form is a finite presentation <
  X|R>  for  a group G. The first step of the algorithm determines a nilpotent
  presentation for the commutator quotient of G. This is a presentation of the
  class-1 quotient of G. Call its generators a_1,...,a_d. It also determines a
  homomorphism  of  G  onto  the  commutator  quotient  and  describes  it  by
  specifying the image of each generator in X as a word in the a_i.
  
  For  the  general  step  assume  that the algorithm has computed a nilpotent
  presentation  for  the  class-c  quotient  of G and that a_1,...,a_d are the
  generators introduced in the first step of the algorithm. Furthermore, there
  is  a map from X into the class-c quotient describing the epimorphism from G
  onto G/gamma_c+1(G).
  
  Let  b_1,...b_k  be  the generators from the last step of the algorithm, the
  computation  of gamma_c(G)/gamma_c+1(G). This means that b_1,...b_k generate
  gamma_c(G)/gamma_c+1(G).    Then    the   commutators   [b_j,a_i]   generate
  gamma_c+1(G)/gamma_c+2(G).  The algorithm introduces new, central generators
  c_ij into the presentation, adds the relations [b_j,a_i] = c_ij and modifies
  the  existing  relations  by  appending  suitable  words in the c_ij, called
  [22m[36mtails[0m,  to  the  right hand sides of the power and commutator relations. The
  resulting  presentation  is a nilpotent presentation for the [22m[36mnilpotent cover[0m
  of  G/gamma_c+1(G).  The nilpotent cover is the largest central extension of
  G/gamma_c+1(G)  generated  by d elements. It is is uniquely determined up to
  isomorphism.
  
  The   resulting   presentation   of   the  nilpotent  cover  is  in  general
  inconsistent.  Consistency is achieved by running the consistency test. This
  results  in  relations  among  the  generators  c_ij  which  can  be used to
  eliminate  some of those generators or introduce power relations. After this
  has  been done we have a consistent nilpotent presentation for the nilpotent
  cover of G/gamma_c+1(G).
  
  Furthermore,  the  nilpotent  cover  need not satisfy the relations of G. In
  other  words, the epimorphism from G onto G/gamma_c+1(G) cannot be lifted to
  an  epimorphism  onto  the nilpotent cover. Applying the epimorphism to each
  relator  of  G  and  collecting  the  resulting words of the nilpotent cover
  yields  a set of words in the c_ij. This gives further relations between the
  c_ij  which  leads  to  further  eliminations  or modifications of the power
  relations for the c_ij.
  
  After  this,  the  inductive step of the ANU NQ is complete and a consistent
  nilpotent  presentation  for  G/gamma_c+2(G)  is  obtained  together with an
  epimorphism from G onto the class-(c+1) quotient.
  
  Chapter  11  of  the  book [C94] discusses a nilpotent quotient algorithm. A
  description of the implementation in the ANU NQ is contained in [N96]
  
  
  [1m[4m[31m2.5 Identical Relations[0m
  
  Let  w  be  a  word  in free generators x_1,...,x_n. A group G satisfies the
  relation  w=1  [22m[36midentically[0m if each map from x_1,...,x_n into G maps w to the
  identity  element  of G. We also say that G satisfies the [22m[36midentical relation[0m
  w=1  or  satisfies  the  [22m[36mlaw[0m  w=1.  In slight abuse of notation, we call the
  elements x_1,...,x_n [22m[36midentical[0m generators.
  
  Common  examples  of identical relations are: A group of nilpotency class at
  most  c  satisfies the law [x_1,...,x_c+1]=1. A group that satisfies the law
  [x,y,...,y]=1  where  y  occurs n-times, is called an n-Engel group. A group
  that satisfies the law x^d=1 is a group of exponent d.
  
  To  describe  finitely  presented  groups  that satisfy one or more laws, we
  extend  a  common  notation  for finitely presented groups by specifying the
  identical generators as part of the generator list, separated from the group
  generators by a semicolon: For example
  
  \[
       \langle a,b,c; x,y | x^5, [x,y,y,y]\rangle
  \]
  
  is a group on 3 generators a,b,c of exponent 5 satisfying the 3rd Engel law.
  The  presentation above is equivalent to a presentation on 3 generators with
  an infinite set of relators, where the set of relators consists of all fifth
  powers  of words in the generators and all commutators [x,y,y,y] where x and
  y  run  through  all words in the generators a,b,c. The standalone programme
  accepts  the notation introduced above as a description of its input. In [1mGAP
  4[0m   finitely  presented  groups  are  specified  in  a  different  way,  see
  [1m[34mNilpotentQuotient[0m ([1m3.1-1[0m) for a description.
  
  This  notation  can  also  be  used  in  words  that mix group and identical
  generators as in the following example:
  
  \[
       \langle a,b,c; x | [x,c], [a,x,x,x] \rangle
  \]
  
  The  first  relator  specifies  a  law  which  says that c commutes with all
  elements of the group. The second turns a into a third right Engel element.
  
  An element a is called [22m[36ma right n-th Engel element[0m or [22m[36ma right n-Engel element[0m
  if  it  satisfies  the  commutator  law  [a,x,...,x]=1  where  the identical
  generator  x  occurs  n-times. Likewise, an element b is called an [22m[36mleft n-th
  Engel  element[0m  or  [22m[36mleft  n-Engel element[0m if it satisfies the commutator law
  [x,b,b,...b]=1.
  
  Let  G  be  a  nilpotent  group.  Then G satisfies a given law if the law is
  satisfied  by a certain finite set of instances given by Higman's Lemma, see
  [G59].  The  ANU  NQ uses Higman's Lemma to obtain a finite presentation for
  groups that satisfy one or several identical relations.
  
  
  [1m[4m[31m2.6 Expression Trees[0m
  
  Expressions  involving  commutators play an important role in the context of
  nilpotent  groups.  Expanding  an iterated commutator produces a complicated
  and long expression. For example,
  
  \[
       [x,y,z] = y^{-1}x^{-1}yxz^{-1}x^{-1}y^{-1}xyz.
  \]
  
  Evaluating  a commutator [a,b] is done efficiently by computing the equation
  (ba)^-1ab.   Therefore,   for   each  commutator  we  need  to  perform  two
  multiplications   and   one   inversion.   Evaluating   [x,y,z]  needs  four
  multiplications  and  two  inversions.  Evaluation of an iterated commutator
  with  n  components  takes  2n-1  multiplications  and  n-1  inversions. The
  expression  on  the  right  hand  side  above  needs 9 multiplications and 5
  inversions  which  is  clearly  much  more  expensive  than  evaluating  the
  commutator directly.
  
  Assuming  that no cancellations occur, expanding an iterated commutator with
  n  components  produces  a word with 2^n+1-2^n-1-2 factors half of which are
  inverses.  A similar effect occurs whenever a compact expression is expanded
  into a word in generators and inverses, for example (ab)^49.
  
  Therefore,  it  is  important  not  to  expand  expressions  into  a word in
  generators  and  inverses.  For this purpose we provide a mechanism which we
  call  here [22m[36mexpression trees[0m. An expression tree preserves the structure of a
  given  expression.  It  is a (binary) tree in which each node is assigned an
  operation  and  whose leaves are generators of a free group or integers. For
  example,  the expression [(xy)^2, z] is stored as a tree whose top node is a
  commutator  node.  The right subtree is just a generator node (corresponding
  to z). The left subtree is a power node whose subtrees are a product node on
  the  left  and  an integer node on the right. An expression tree can involve
  products, powers, conjugates and commutators. However, the list of available
  operations can be extended.
  
  Evaluation  of  an  expression tree is done recursively and requires as many
  operations  as  there  are  nodes  in  the  tree.  An expression tree can be
  evaluated in a specific group by the function [1m[34mEvaluateExpTree[0m ([1m3.2-2[0m).
  
  A presentation specified by expression trees is a record with the components
  [1m.generators[0m  and  [1m.relations[0m.  See  section  [1m3.2[0m  for  a  description of the
  functions that produce and manipulate expression trees.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35mgap> RequirePackage( "nq" );[0m
    [22m[35mtrue[0m
    [22m[35mgap> gens := ExpressionTrees( 2 );[0m
    [22m[35m[ x1, x2 ][0m
    [22m[35mgap> r1 := LeftNormedComm( [gens[1],gens[2],gens[2]] );[0m
    [22m[35mComm( x1, x2, x2 )[0m
    [22m[35mgap> r2 := LeftNormedComm( [gens[1],gens[2],gens[2],gens[1]] );[0m
    [22m[35mComm( x1, x2, x2, x1 )[0m
    [22m[35mgap> pres := rec( generators := gens, relations := [r1,r2] );[0m
    [22m[35mrec( generators := [ x1, x2 ], [0m
    [22m[35m  relations := [ Comm( x1, x2, x2 ), Comm( x1, x2, x2, x1 ) ] )[0m
    [22m[35m  [0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m2.7 A word about the implementation[0m
  
  The  ANU  NQ  is  written in C, but not in ANSI C. I hope to make one of the
  next  versions  ANSI compliable. However, it uses a fairly restricted subset
  of the language so that it should be easy to compile it in new environments.
  The  code is 64-bit clean. If you have difficulties with porting it to a new
  environment, let me know and I'll be happy to assist if time permits.
  
  The  program  has  two  collectors:  a  simple  collector  from  the left as
  described in [LS90] and a combinatorial from the left collector as described
  in  [V90].  The  combinatorial  collector  is  always faster than the simple
  collector,  therefore,  it is the collector used by this package by default.
  This  can  be  changed  by  modifying  the  global variable [1m[34mNqDefaultOptions[0m
  ([1m3.4-2[0m).
  
  In  a  polycyclic  group  with  generators that do not have power relations,
  exponents  may  become arbitrarily large. Experience shows that this happens
  rarely  in the computations done by the ANU NQ. Exponents are represented by
  32-bit  integers.  The  collectors  perform  an overflow check and abort the
  computation if an overflow occurred. In a GNU environment the program can be
  compiled  using  the `long long' 64-bit integer type. For this uncomment the
  relevant line in src/Makefile and recompile the program.
  
  As  part  of  the  step  that  enforces consistency and the relations of the
  group,  the  ANU NQ performs computations with integer matrices and converts
  them  to  Hermite Normal Form. The algorithm used here is a variation of the
  Kanan-Bachem  algorithm  based  on the GNU multiple precision package GNU MP
  [xxx].  Experience shows that the integer matrices are usually fairly sparse
  and  Kanan-Bachem  seems  to  be  sufficient  in  this context. However, the
  implementation  might  benefit  from a more efficient strategy for computing
  Hermite Normal Forms. This is a topic for further investigations.
  
  As the program does not compute the Smith Normal Form for each factor of the
  lower  central  series  but the Hermite Normal Form, it does not necessarily
  obtain a minimal generating set for each factor of the lower central series.
  The   following  is  a  simple  example  of  this  behaviour.  We  take  the
  presentation
  
  \[
       \langle x, y | x^2 = y \rangle
  \]
  
  The  group  is  clearly  isomorphic  to  the additive group of the integers.
  Applying  the  ANU  NQ  to  this  presentation gives the following nilpotent
  presentation:
  
  \[
       \langle A,B | A^2 = B, [B,A] \rangle
  \]
  
  A   nilpotent  presentation  on  a  minimal  generating  set  would  be  the
  presentation of the free group on one generator:
  
  \[
       \langle A | \; \rangle
  \]
  
  
  [1m[4m[31m2.8 The input format of the standalone[0m
  
  The  input  format  for  finite  presentations resembles the way many people
  write  down a presentation on paper. Here are some examples of presentations
  that the ANU NQ accepts:
  
  
  
      < a, b | >                       # free group of rank 2
  
      < a, b, c; x, y | 
                  [a,b,c],             # a left normed commutator
                  [b,c,c,c]^6,         # another one raised to a power
                  a^2 = c^-3*a^2*c^3,  # a relation
                  a^(b*c) = a,         # a conjugate relation
                  (a*[b,(a*c)])^6,     # something that looks complicated
                  [x,y,y,y,y],         # an identical relation
                  [c,x,x,x,x,x]        # c is a fifth right Engel element
      >
  
  A presentation starts with '<' followed by a list of generators separated by
  commas.  Generator  names are strings that contain only upper and lower case
  letters,  digits,  dots  and underscores and that do not start with a digit.
  The list of generator names is separated from the list of relators/relations
  by  the  symbol  '|'.  The  list  of generators can be followed by a list of
  identical  generators  separated  by a semicolon. Relators and relations are
  separated by commas and can be mixed arbitrarily. Parentheses can be used in
  order to group subexpressions together. Square brackets can be used in order
  to form left normed commutators. The symbols '*' and '^' can be used to form
  products and powers, respectively. The presentation finishes with the symbol
  '>'.  A  comment  starts  with the symbol '#' and finishes at the end of the
  line.  The  file  src/presentation.c  contains  a  complete  grammar for the
  presentations accepted by the ANU NQ.
  
  Typically,  the  input  for  the  standalone  is  put into a file by using a
  standard  text editor. The file can be passed as an argument to the function
  [1m[34mNilpotentQuotient[0m  ([1m3.1-1[0m). It is also possible to put a presentation in the
  standalone's  input  format into a string and use the string as argument for
  [1m[34mNilpotentQuotient[0m ([1m3.1-1[0m).
  
