2 Resolutions
  
  A free FG-resolution of an FG-module M is a sequence of module homomorphisms
  
  
       ... ---> M_(n+1) ---> M_n ---> M_(n-1) ---> ... ---> M_1 ---> M_0
       --->> M
  
  
  Where  each  M_n  is  a  free FG-module and the image of d_n+1: M_n+1 -> M_n
  equals the kernel of d_n: M_n -> M_n-1 for all n > 0.
  
  
  2.1 The HAPResolution datatype in HAPprime
  
  Both  HAP  and HAPprime use the HAPResolution datatype to store resolutions,
  and  you  should  refer  to  the  HAP documentation for full details of this
  datatype.  With  resolutions computed by HAP, the boundary maps which define
  the  module  homomorphisms  are  stored as lists of ZG-module words, each of
  which  is  an  integer  pair  [i,g].  By  contrast,  when  HAPprime computes
  resolutions it stores the boundary maps as lists of G-generating vectors (as
  used  in  FpGModuleHomomorphismGF,  see Chapter 6). Over small finite fields
  (and in particular in GF(2)), these compressed vectors take far less memory,
  saving  at  least  a  factor of two for long resolutions. The different data
  storage  method  is  entirely  an  internal  change  - as far as the used is
  concerned, both versions behave exactly the same.
  
  
  2.2 Implementation: Constructing resolutions
  
  Given  the definition of a free FG-resolution given above, a resolution of a
  module M can be calculated by construction. If there are k generators for M,
  we  can  set  M_0  equal  to  the  free  FG-module  (FG)^k,  and  the module
  homomorphism  d_0  :  M_0  ->  M  to  be the one that sends the ith standard
  generator  of  (FG)^k  to  the  ith  element  of  M.  We can now recursively
  construct  the  other  modules and module homomorphisms in a similar manner.
  Given  a boundary homomorphism d_n = M_n -> M_n-1, the kernel of this can be
  calculated.  Then  given  a  set  of  generators  (ideally  a small set) for
  ker(d_n),   we   can  set  M_n+1  =  (FG)^|ker(d_n)|,  and  the  new  module
  homomorphism  d_n+1  to  be the one mapping the standard generators of M_n+1
  onto the generators of ker(d_n).
  
  HAPprime  implements  the construction of resolutions using this method. The
  construction  is  divided  into  two  stages.  The  creation  of  the  first
  homomorphism   in  the  resolution  for  M  is  performed  by  the  function
  LengthZeroResolutionPrimePowerGroup  (2.3-2),  or  for  a  resolution of the
  trivial  FG-module  F,  the  first  two  homomorphisms can be stated without
  calculation  using  LengthOneResolutionPrimePowerGroup  (2.3-1).  Once  this
  initial  sequence is created, a longer resolution can be created by repeated
  application   of   one   of   ExtendResolutionPrimePowerGroupGF   (HAPprime:
  ExtendResolutionPrimePowerGroupGF),   ExtendResolutionPrimePowerGroupRadical
  (HAPprime:             ExtendResolutionPrimePowerGroupRadical)            or
  ExtendResolutionPrimePowerGroupGF2                                (HAPprime:
  ExtendResolutionPrimePowerGroupGF2), each of which extends the resolution by
  one  stage  by  constructing  a new module and homomorphism mapping onto the
  minimal  generators  of  the  kernel  of  the last homomorphism of the input
  resolution.  These  extension  functions  differ  in speed and the amount of
  memory      that      they      use.      The     lowest-memory     version,
  ExtendResolutionPrimePowerGroupGF                                 (HAPprime:
  ExtendResolutionPrimePowerGroupGF),  uses  the  block  structure  of  module
  generating  vectors  (see  Section  5.2-1)  and  calculates  kernels  of the
  boundary  homomorphisms  using  KernelOfModuleHomomorphismSplit  (6.6-3) and
  finds    a    minimal    set   of   generators   for   this   kernel   using
  MinimalGeneratorsModuleGF   (5.5-9).   The  much  faster  but  memory-hungry
  ExtendResolutionPrimePowerGroupRadical                            (HAPprime:
  ExtendResolutionPrimePowerGroupRadical)    uses   KernelOfModuleHomomorphism
  (6.6-3)    and    MinimalGeneratorsModuleRadical    (5.5-9)    respectively.
  ExtendResolutionPrimePowerGroupGF2                                (HAPprime:
  ExtendResolutionPrimePowerGroupGF2)     uses    KernelOfModuleHomomorphismGF
  (6.6-3) whic partitions the boundary homomorphism matrix using FG-reduction.
  This  gives  a  small memory saving over the Radical method, but can take as
  long as the GF scheme.
  
  The  construction  of resolutions of length n is wrapped up in the functions
  ResolutionPrimePowerGroupGF,       ResolutionPrimePowerGroupRadical      and
  ResolutionPrimePowerGroupAutoMem, which (as well as the extension functions)
  are fully documented in Section 'HAPprime: ResolutionPrimePowerGroup' of the
  HAPprime user manual.
  
  
  2.3 Resolution construction functions
  
  2.3-1 LengthOneResolutionPrimePowerGroup
  
  > LengthOneResolutionPrimePowerGroup( G ) __________________________function
  Returns:  HAPResolution
  
  Returns  a  free  FG-resolution  of length 1 for group G (which must be of a
  prime power), i.e. the resolution
  
  
       FG^k ---> FG --->> F
  
  
  This  function  requires  very  little  calculation:  the first stage of the
  resolution  can  simply  be stated given a set of minimal generators for the
  group.
  
  2.3-2 LengthZeroResolutionPrimePowerGroup
  
  > LengthZeroResolutionPrimePowerGroup( M ) _________________________function
  Returns:  HAPResolution
  
  Returns  a minimal free FG-resolution of length 0 for the FpGModuleGF module
  M, i.e. the resolution
  
  
       FG^k --->> M
  
  
  This  function  requires little calculation since the the first stage of the
  resolution  can  simply be stated if the module has minimal generators: each
  standard  generator of the zeroth-degree module M_0 maps onto a generator of
  M.  If  M  does  not  have  minimal  generators,  they  are calculated using
  MinimalGeneratorsModuleRadical (5.5-9).
  
  
  2.4 Resolution data access functions
  
  2.4-1 ResolutionLength
  
  > ResolutionLength( R ) ______________________________________________method
  Returns:  Integer
  
  Returns the length (i.e. the maximum index k) in the resolution R.
  
  2.4-2 ResolutionGroup
  
  > ResolutionGroup( R ) _______________________________________________method
  Returns:  Group
  
  Returns the group of the resolution R.
  
  2.4-3 ResolutionFpGModuleGF
  
  > ResolutionFpGModuleGF( R, k ) ______________________________________method
  Returns:  FpGModuleGF
  
  Returns  the  module  M_k in the resolution R, as a FpGModuleGF (see Chapter
  5), assuming the canonical action.
  
  2.4-4 ResolutionModuleRank
  
  > ResolutionModuleRank( R, k ) _______________________________________method
  Returns:  Integer
  
  Returns the FG rank of the kth module M_k in the resolution.
  
  2.4-5 ResolutionModuleRanks
  
  > ResolutionModuleRanks( R ) _________________________________________method
  Returns:  List of integers
  
  Returns  a  list  containg the FG rank of the each of the modules M_k in the
  resolution R.
  
  2.4-6 BoundaryFpGModuleHomomorphismGF
  
  > BoundaryFpGModuleHomomorphismGF( R, k ) ____________________________method
  Returns:  FpGModuleHomomorphismGF
  
  Returns    the    kth   boundary   map   in   the   resolution   R,   as   a
  FpGModuleHomomorphismGF. This represents the linear homomorphism d_k: M_k ->
  M_k-1.
  
  2.4-7 ResolutionsAreEqual
  
  > ResolutionsAreEqual( R, S ) _____________________________________operation
  Returns:  Boolean
  
  Returns  true  if  the resolutions appear to be equal, false otherwise. This
  compares the torsion coefficients of the homology from the two resolutions.
  
  
  2.5 Example: Computing and working with resolutions
  
  In this example we construct a minimal free FG-resolution of length four for
  the group G = D_8 x Q_8 of order 64, which will be the sequence
  
  
       (FG)^22 ---> (FG)^15 ---> (FG)^9 ---> FG --->> F
  
  
  We     first     build     each     stage    explicitly,    starting    with
  LengthOneResolutionPrimePowerGroup (2.3-1) followed by repeated applications
  of             ExtendResolutionPrimePowerGroupRadical             (HAPprime:
  ExtendResolutionPrimePowerGroupRadical).  We  extract  various properties of
  this  resolution.  Finally,  we construct equivalent resolutions for G using
  ResolutionPrimePowerGroupGF   (HAPprime:   ResolutionPrimePowerGroupGF  (for
  group))          and         ResolutionPrimePowerGroupGF2         (HAPprime:
  ResolutionPrimePowerGroupGF2  (for  group))  and  check  that  the three are
  equivalent.
  
  ---------------------------  Example  ----------------------------
    gap> G := DirectProduct(DihedralGroup(8), SmallGroup(8, 4));
    <pc group of size 64 with 6 generators>
    gap> R := LengthOneResolutionPrimePowerGroup(G);
    Resolution of length 1 in characteristic 2 for <pc group of size 64 with
    6 generators> .
    No contracting homotopy available.
    A partial contracting homotopy is available.
    
    gap> R := ExtendResolutionPrimePowerGroupRadical(R);;
    gap> R := ExtendResolutionPrimePowerGroupRadical(R);;
    gap> R := ExtendResolutionPrimePowerGroupRadical(R);
    Resolution of length 4 in characteristic 2 for <pc group of size 64 with
    6 generators> .
    No contracting homotopy available.
    A partial contracting homotopy is available.
    
    gap> #
    gap> ResolutionLength(R);
    4
    gap> ResolutionGroup(R);
    <pc group of size 64 with 6 generators>
    gap> ResolutionModuleRanks(R);
    [ 4, 9, 15, 22 ]
    gap> ResolutionModuleRank(R, 3);
    15
    gap> M2 := ResolutionFpGModuleGF(R, 2);
    Full canonical module FG^9 over the group ring of <pc group of size 64 with
    6 generators> in characteristic 2
    
    gap> d3 := BoundaryFpGModuleHomomorphismGF(R, 3);
    <Module homomorphism>
    
    gap> ImageOfModuleHomomorphism(d3);
    Module over the group ring of <pc group of size 64 with
    6 generators> in characteristic 2 with 15 generators in FG^9.
    
    gap> #
    gap> S := ResolutionPrimePowerGroupGF(G, 4);
    Resolution of length 4 in characteristic 2 for <pc group of size 64 with
    6 generators> .
    No contracting homotopy available.
    A partial contracting homotopy is available.
    
    gap> ResolutionsAreEqual(R, S);
    true
    gap> T := ResolutionPrimePowerGroupGF2(G, 4);
    Resolution of length 4 in characteristic 2 for <pc group of size 64 with
    6 generators> .
    No contracting homotopy available.
    A partial contracting homotopy is available.
    
    gap> ResolutionsAreEqual(R, T);
    true
  ------------------------------------------------------------------
  
  Further  example  of  constructing resolutions and extracting data from them
  are  given  in  Sections  5.4-11,  5.5-11,  5.6-3,  6.5-7  and 6.6-4 in this
  reference  manual,  and  also  the  chapter  of  'HAPprime: Examples' in the
  HAPprime user guide.
  
  
  2.6 Miscellaneous resolution functions
  
  2.6-1 BestCentralSubgroupForResolutionFiniteExtension
  
  > BestCentralSubgroupForResolutionFiniteExtension( G[, n] ) _______operation
  Returns:  Group
  
  Returns the central subgroup of G that is likely to give the smallest module
  ranks   when   using   the   HAP  function  ResolutionFiniteExtension  (HAP:
  ResolutionFiniteExtension).  That function computes a non-minimal resolution
  for G from the twisted tensor product of resolutions for a normal subgroup N
  and the quotient group G/N. The ranks of the modules in the resolution for G
  are  the  products  of the module ranks of the resolutions for these smaller
  groups.  This  function tests n terms of the minimal resolutions for all the
  central  subgroups  of  G  and  the  corresponding  quotients  to  find  the
  subgroup/quotient pair with the smallest module ranks. If n is not provided,
  then n=5 is used.