  
  [1X9 Poincaré series[0X
  
  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.
  
  
  [1X9.1 Computing the Poincaré series using spectral sequences[0X
  
  [5XHAPprime[0m  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   [5XHAPprime[0m  function
  [2XPoincareSeriesLHS[0m  ([14XHAPprime:  PoincareSeriesLHS[0m). See the documentation for
  that function in the user guide for more details.
  
  
  [1X9.2 Computing the Poincaré series using a minimal resolution[0X
  
  Given  a  resolution  R  of  length  n  for  a  group  G,  the  [5XHAP[0m function
  [2XPoincareSeries[0m  ([14XHAP:  PoincareSeries[0m)  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      [2XExtendResolutionPrimePowerGroupAutoMem[0m     ([14XHAPprime:
  ExtendResolutionPrimePowerGroupAutoMem[0m)   allows   [5XHAPprime[0m   to  provide  a
  simplified  implementation for calculating Poincaré series in the case where
  n  is  not  specified  (since extending existing resolutions is difficult in
  [5XHAP[0m).  The  [5XHAPprime[0m  function  [2XPoincareSeriesAutoMem[0m  ([14XHAPprime  Datatypes:
  PoincareSeriesAutoMem[0m)  is  a  replacement  for  [5XHAP[0m's  [2XPoincareSeries[0m ([14XHAP:
  PoincareSeries[0m)  in  the  case where G is a p-group and the optimal n is not
  known.
  
  By      using     the     [5XHAPprime[0m     resolution-calculation     functions,
  [2XPoincareSeriesAutoMem[0m   ([14XHAPprime  Datatypes:  PoincareSeriesAutoMem[0m)  saves
  memory when storing resolution, and switches to the [10XGF[0m algorithm when memory
  is  low.  As  a result, it can calculate the Poincaré series for groups that
  would  be  impossible  using  [5XHAP[0m without having about five times the memory
  available to the machine.
  
  [1X9.2-1 PoincareSeriesAutoMem[0m
  
  [2X> PoincareSeriesAutoMem( [0X[3XG[, n][0X[2X ) _________________________________[0Xoperation
  [6XReturns:[0X  Rational function
  
  For  a  finite p-group [3XG[0m, 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 [3Xn[0m 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  [10XPoincareSeries(G,  n)  =
  PoincareSeries(G, n-1) = PoincareSeries(G, n-2)[0m.
  
  This  function uses the [5XHAP[0m function [2XPoincareSeries[0m ([14XHAP: PoincareSeries[0m) to
  calculate    the    Poincaré    series,    but    the    [5XHAPprime[0m   function
  [2XExtendResolutionPrimePowerGroupAutoMem[0m                            ([14XHAPprime:
  ExtendResolutionPrimePowerGroupAutoMem[0m)  to  calculate  and gradually extend
  the  resolution,  so  should  be  both faster and more memory-efficient than
  using [9XPoincareSeries[0m by itself. See Section [14X9.3[0m 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 [2XPoincareSeriesLHS[0m ([14XHAPprime: PoincareSeriesLHS[0m)
  
  
  [1X9.3 Example Poincaré series computations[0X
  
  This example compares the time taken by [2XPoincareSeries[0m ([14XHAP: PoincareSeries[0m)
  and  [2XPoincareSeriesAutoMem[0m  ([14XHAPprime Datatypes: PoincareSeriesAutoMem[0m), and
  shows that the times are roughly comparable:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> G := SmallGroup(64, 210);;[0X
    [4Xgap> # Compute the Poincare series using HAP[0X
    [4Xgap> P1 := PoincareSeries(G);time;[0X
    [4X(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)[0X
    [4X51355[0X
    [4Xgap> # Compute the Poincare series using HAPprime[0X
    [4Xgap> P2 := PoincareSeriesAutoMem(G);time;[0X
    [4X(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)[0X
    [4X39774[0X
    [4Xgap> P1 = P2;[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  The  [5XHAPprime[0m  function [2XPoincareSeriesLHS[0m ([14XHAPprime: PoincareSeriesLHS[0m) 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:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> G := SmallGroup(64, 210);;[0X
    [4Xgap> P3 := PoincareSeriesLHS(G);time;[0X
    [4X(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)[0X
    [4X3564[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X9.4 The Poincaré series of groups of order 64 and 128[0X
  
  Using  [5XHAPprime[0m,  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 [5XGAP[0m, four
  groups  (numbers  4, 60, 242 and 266 from the [5XGAP[0m [9XSmallGroup[0m library) needed
  to    switch    to    using   [2XExtendResolutionPrimePowerGroupGF[0m   ([14XHAPprime:
  ExtendResolutionPrimePowerGroupGF[0m).  Calculating  the Poincaré series of the
  most  difficult  group,  [10XSmallGroup(64,  60)[0m,  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 [5XHAPprime[0m
  website [7Xhttp://www.maths.nuigalway.ie/~pas/CHA/HAPprime/HAPprimeindex.html[0m
  
  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 [5XHAPprime[0m website.
  
