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.

`HAPResolution`

datatype in 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 **4**). 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.

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 **3.2-1**) and calculates kernels of the boundary homomorphisms using `KernelOfModuleHomomorphismSplit`

(**4.6-3**) and finds a minimal set of generators for this kernel using `MinimalGeneratorsModuleGF`

(**3.5-9**). The much faster but memory-hungry `ExtendResolutionPrimePowerGroupRadical`

(**HAPprime: ExtendResolutionPrimePowerGroupRadical**) uses `KernelOfModuleHomomorphism`

(**4.6-3**) and `MinimalGeneratorsModuleRadical`

(**3.5-9**) respectively. `ExtendResolutionPrimePowerGroupGF2`

(**HAPprime: ExtendResolutionPrimePowerGroupGF2**) uses `KernelOfModuleHomomorphismGF`

(**4.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.

`> 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.

`> 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`

(**3.5-9**).

`> ResolutionLength` ( R ) | ( method ) |

**Returns: **Integer

Returns the length (i.e. the maximum index k) in the resolution `R`.

`> ResolutionGroup` ( R ) | ( method ) |

**Returns: **Group

Returns the group of the resolution `R`.

`> ResolutionFpGModuleGF` ( R, k ) | ( method ) |

**Returns: **`FpGModuleGF`

Returns the module M_k in the resolution `R`, as a `FpGModuleGF`

(see Chapter **3**), assuming the canonical action.

`> ResolutionModuleRank` ( R, k ) | ( method ) |

**Returns: **Integer

Returns the FG rank of the `k`th module M_k in the resolution.

`> 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`.

`> BoundaryFpGModuleHomomorphismGF` ( R, k ) | ( method ) |

**Returns: **`FpGModuleHomomorphismGF`

Returns the `k`th boundary map in the resolution `R`, as a `FpGModuleHomomorphismGF`

. This represents the linear homomorphism d_k: M_k -> M_k-1.

`> 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.

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.

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 **3.4-11**, **3.5-11**, **3.6-3**, **4.5-7** and **4.6-4** in this reference manual, and also the chapter of **HAPprime: Examples** in the **HAPprime** user guide.

`> 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.

generated by GAPDoc2HTML