9 Poincaré series
  
  The  Poincaré series for the mod-p cohomology ring H^*(G, F) is the infinite
  series
  
  
       a_0 + a_1x + a_2x^2 + a_3x^3 + ...
  
  
  where  a_k  is  the  dimension  of  the vector space H^k(G, F). The Poincaré
  function  is  a  rational  function P(x)/Q(x) which is equal to the Poincaré
  series.
  
  
  9.1 Computing the Poincaré series using spectral sequences
  
  HAPprime  can  calculate  a  provably-correct  Poincaré series for the mod-p
  cohomology  ring of a small p-group using spectral sequences, without having
  to   compute   the   actual   cohomology  ring.  The  limiting  sheet  of  a
  Lyndon-Hochschild-Serre  spectral sequence for a group G will be a ring with
  the  same additive structure as the cohomology ring for G, and thus the same
  Poincaré   series.   This   is   implemented   in   the   HAPprime  function
  PoincareSeriesLHS  (HAPprime:  PoincareSeriesLHS). See the documentation for
  that function in the user guide for more details.
  
  
  9.2 Computing the Poincaré series using a minimal resolution
  
  Given  a  resolution  R  of  length  n  for  a  group  G,  the  HAP function
  PoincareSeries  (HAP:  PoincareSeries)  calculates a quotient of polynomials
  such that the coefficient of x^k equals the dimension of H^k(G, F) for k = 1
  to k = n. Given a sufficiently long resolution R, this quotient should equal
  the  true  Poincaré  series.  The  function  can  also  automatically find a
  suitable  value  for  n  by  trying resolutions of increasing length until a
  consistent  estimate  is found for the Poincaré series. This is likely to be
  correct, but we have no proof that this will always be the case.
  
  The      function      ExtendResolutionPrimePowerGroupAutoMem     (HAPprime:
  ExtendResolutionPrimePowerGroupAutoMem)   allows   HAPprime   to  provide  a
  simplified  implementation for calculating Poincaré series in the case where
  n  is  not  specified  (since extending existing resolutions is difficult in
  HAP).  The  HAPprime  function  PoincareSeriesAutoMem  (HAPprime  Datatypes:
  PoincareSeriesAutoMem)  is  a  replacement  for  HAP's  PoincareSeries (HAP:
  PoincareSeries)  in  the  case where G is a p-group and the optimal n is not
  known.
  
  By      using     the     HAPprime     resolution-calculation     functions,
  PoincareSeriesAutoMem   (HAPprime  Datatypes:  PoincareSeriesAutoMem)  saves
  memory when storing resolution, and switches to the GF algorithm when memory
  is  low.  As  a result, it can calculate the Poincaré series for groups that
  would  be  impossible  using  HAP without having about five times the memory
  available to the machine.
  
  9.2-1 PoincareSeriesAutoMem
  
  > PoincareSeriesAutoMem( G[, n] ) _________________________________operation
  Returns:  Rational function
  
  For  a  finite p-group G, this function calculates and returns a quotient of
  polynomials f(x) = P(x)/Q(x) (i.e. the Poincaré series) whose coefficient of
  x^k  equals  the rank of the vector space H_k(G, F_p) for all k in the range
  k=1 to k=n. If no value is given for n then increasing values of n are tried
  to  find the minimum value which gives a consistent Poincaré series, defined
  as   a   the  minimum  value  n  >  10  such  that  PoincareSeries(G,  n)  =
  PoincareSeries(G, n-1) = PoincareSeries(G, n-2).
  
  This  function uses the HAP function PoincareSeries (HAP: PoincareSeries) to
  calculate    the    Poincaré    series,    but    the    HAPprime   function
  ExtendResolutionPrimePowerGroupAutoMem                            (HAPprime:
  ExtendResolutionPrimePowerGroupAutoMem)  to  calculate  and gradually extend
  the  resolution,  so  should  be  both faster and more memory-efficient than
  using PoincareSeries by itself. See Section 9.3 for an example.
  
  The  Poincaré series calculated using this function is likely to be correct,
  but  we  have  no  proof  that  this will be the case. If a correct Poincaré
  series is required, use PoincareSeriesLHS (HAPprime: PoincareSeriesLHS)
  
  
  9.3 Example Poincaré series computations
  
  This example compares the time taken by PoincareSeries (HAP: PoincareSeries)
  and  PoincareSeriesAutoMem  (HAPprime Datatypes: PoincareSeriesAutoMem), and
  shows that the times are roughly comparable:
  
  ---------------------------  Example  ----------------------------
    gap> G := SmallGroup(64, 210);;
    gap> # Compute the Poincare series using HAP
    gap> P1 := PoincareSeries(G);time;
    (x_1^4+x_1^2+x_1+1)/(-x_1^7+3*x_1^6-5*x_1^5+7*x_1^4-7*x_1^3+5*x_1^2-3*x_1+1)
    51355
    gap> # Compute the Poincare series using HAPprime
    gap> P2 := PoincareSeriesAutoMem(G);time;
    (x_1^4+x_1^2+x_1+1)/(-x_1^7+3*x_1^6-5*x_1^5+7*x_1^4-7*x_1^3+5*x_1^2-3*x_1+1)
    39774
    gap> P1 = P2;
    true
  ------------------------------------------------------------------
  
  The  HAPprime  function PoincareSeriesLHS (HAPprime: PoincareSeriesLHS) uses
  an  alternative  approach to compute Poincaré series which are guaranteed to
  be  correct.  In  many  cases it is also faster, as we see if we compute the
  Poincaré series for the same group using this function:
  
  ---------------------------  Example  ----------------------------
    gap> G := SmallGroup(64, 210);;
    gap> P3 := PoincareSeriesLHS(G);time;
    (x_1^4+x_1^2+x_1+1)/(-x_1^7+3*x_1^6-5*x_1^5+7*x_1^4-7*x_1^3+5*x_1^2-3*x_1+1)
    3564
  ------------------------------------------------------------------
  
  
  9.4 The Poincaré series of groups of order 64 and 128
  
  Using  HAPprime,  on  a  dual-processor  AMD  Opteron  250  machine, we have
  calculated  the  Poincaré series for all of the groups of order 64 using the
  resolution-based  technique. Most computed within a few seconds using only a
  few  Mb  of  memory.  With a maximum of 1Gb of memory available to GAP, four
  groups  (numbers  4, 60, 242 and 266 from the GAP SmallGroup library) needed
  to    switch    to    using   ExtendResolutionPrimePowerGroupGF   (HAPprime:
  ExtendResolutionPrimePowerGroupGF).  Calculating  the Poincaré series of the
  most  difficult  group,  SmallGroup(64,  60),  took  24  days,  computing  a
  resolution  whose  last  term was M_16 = (FG)^2445. The complete list of the
  Poincaré  series  for  all  groups  of order 64 is available on the HAPprime
  website http://www.maths.nuigalway.ie/~pas/CHA/HAPprime/HAPprimeindex.html
  
  There  is  an  on-going programme of calculating the Poincaré series for the
  groups  of  order 128. To date, using the same constraints as for the groups
  of  order  64  above, we have computed the Poincaré series for about half of
  them. For latest details, again please see the HAPprime website.