GAP (crime) - Chapter 2: Usage

Goto Chapter: | Top | 1 | 2 | 3 | Bib | Ind

### 2. Usage

All the functions described below taking an argument `n` except `CohomologyRing`, `CohomologyRelators` and `InducedHomomorphismOnCohomology` do whatever the manual says they do until some stage `n`, where `n` is normally the homological degree. These functions are idempotent in the sense that called a second time with the same argument `n`, they do nothing, but called with a bigger `n`, they continue computing from where the previous calculations left off.

#### 2.1 Cohomology Objects

The computation of group cohomology involves several calculations, the results of which are reused in later calculations, and are thus collected in an object of type `CObject`, which is created with the following command.

##### 2.1-1 CohomologyObject

`> CohomologyObject`( G, M ) | ( operation )

`> CohomologyObject`( G ) | ( operation )

Returns: a cohomology object.

This function creates a cohomology object having components the p-group G and the MeatAxe kG-module M. The second invocation creates a cohomology object having components the p-group G and the trivial MeatAxe kG-module where k is the field GF(p).

We emphasize that in the first invocation, `M` can be any MeatAxe module over kG where k is any field of characteristic p. But since the case k=GF(p), and M=k is probably the most common, the second invocation is provided for convenience. At the present, `ProjectiveResolution` works when `M` is an arbitrary MeatAxe module, but all the functions dealing with the ring-structure of H*(G,k) require that `M` be the trivial module.

The cohomology object is used to store, in addition to the items mentioned above, the boundary maps, the Betti numbers, the multiplication table, etc.

#### 2.2 Minimal Projective Resolutions

Given a p-group G, a field k of characteristic p and a kG-module M, the function below computes the first few terms of the minimal projective resolution of M

\[ P_n -> ... P_2 -> P_1 -> P_0 -> M -> 0 \]

where P_i is the direct sum (kG)^(b_i) for certain numbers b_i, the Betti numbers of the resolution. The minimal kG-projective resolution of M is unique up to chain isomorphism. Then the groups Ext^n(M,N) are simply Hom(P_n,N), and if M=N=k is the trivial kG-module, then H^n(G,k)=Ext^n(k,k)=k^(b_n).

##### 2.2-1 ProjectiveResolution

`> ProjectiveResolution`( C, n ) | ( operation )

Returns: a list containing the Betti numbers b_0, b_1,..., b_n.

Given a cohomology object `C` having components G, k, and M, this function computes the first `n`+1 terms of the minimal projective resolution P_* of M of the form P_i=(kG)^(b_i) for i=0,1,...,n, and returns the numbers b_i as a list.

##### 2.2-2 BoundaryMap

`> BoundaryMap`( C, n ) | ( operation )

Returns: the `n`th boundary map.

Given the cohomology object `C`, this function computes a projective resolution to degree `n` if it hasn't been computed already, and returns the `n`th boundary map.

The map returned is a b_n x (b_(n-1)|G|) matrix, having in the ith row the image of the element 1_G from the ith direct summand of P_n.

See the file `doc/example.*` for an example of the usage and interpretation of the result of this function.

#### 2.3 Cohomology Generators and Relators

##### 2.3-1 CohomologyGenerators

`> CohomologyGenerators`( C, n ) | ( operation )

Returns: a list containing the degrees of the generators of the cohomology ring.

Given a cohomology object `C` having components G, k, and M, this function computes the generators of H*(G,k) of degree less than or equal to `n`, and stores them in `C`. The function returns a list of the degrees of these generators.

The actual cohomology generators are represented by maps P_n -> k and are stored in `C` as matrices. Only their degrees are returned.

##### 2.3-2 CohomologyRelators

`> CohomologyRelators`( C, n ) | ( operation )

Returns: a list of generators and a list of relators.

Given a cohomology object `C` having components G, k, and M, this function computes a set of generators of the ideal of relators in H*(G,k), all having multidegree less than or equal to n. Read on for what this means exactly.

The function returns two lists, the first list containing the variables `z`, `y`, `x`, ... corresponding to the generators of H*(G,k) if there are fewer than 12 generators and containing the variables `x_1`, `x_2`, `x_3`, ... otherwise. The second list is a list of polynomials in the variables from the first list.

These two lists should be interpreted as follows. A degree-`n` approximation of the cohomology ring H*(G,k) is given by the polynomial ring over k in the non-commuting variables from the first list, (having degrees given by the list returned by `CohomologyGenerators` above) and subject to the relators in the second list. See 2.6 for more details still.

For example, the following commands

    gap> C:=CohomologyObject(DihedralGroup(8));
    <object>
    gap> CohomologyGenerators(C,10);
    [ 1, 1, 2 ]
    gap> CohomologyRelators(C,10);
    [ [ z, y, x ], [ z*y+y^2 ] ]

tell us that for G=D_8, the cohomology ring H*(G,k) is the graded-commutative polynomial ring in the variables z, y, and x of degrees 1, 1, and 2, subject to the relation zy+y^2. But since H*(G,k) is commutative, k being of characteristic 2, we have H*(G,k)=k[z,y,x]/(zy+y^2). This result can be further improved by taking z=z+y, giving H*(G,k)=k[z,y,x]/(zy).

Observe that in this case, we knew in advance that there was a set of generators for H*(G,k) all having degree less than 10, and that there was a set of generators of the ideal of relators all having multidegree less than 10. See see 2.6 for details.

While this isn't likely to occur, we point out that if there are 12 or more generators and some of the indeterminates `x_1`, `x_2`, `x_3`, ... have already been named, say by a previous call to `CohomologyRelators`, then these variables will retain their old names. If this is confusing, restart GAP and do it again.

#### 2.4 Tests for Completion

A test or series of tests for completion of the calculation will hopefully be implemented soon. See [CT+03] for the details.

#### 2.5 Cohomology Rings

See [CT+03] for the details of the calculation of cohomology products using composition of chain maps. See also the file `doc/explanation.*` for an explanation of the implementation.

##### 2.5-1 CohomologyRing

`> CohomologyRing`( C, n ) | ( operation )

`> CohomologyRing`( G, n ) | ( operation )

Returns: the cohomology ring of G.

Given a cohomology object `C` having module component the trivial kG-module and possibly having a projective resolution already computed, this function returns the degree-`n` truncation of the cohomology ring H*(G,k). See 2.6 for what this means exactly. The object returned is a structure constant algebra.

Users interested only in working with the cohomology ring of a group as a GAP object, and not in calculating generators, relators, induced maps, etc, can use the second invocation of this function, which returns the cohomology ring of the group `G` immediately, throwing away all intermediate calculations.

Observe that the object returned is a degree `n` truncation of the infinite-dimensional cohomology ring. A consequence of this is that multiplying two elements whose product has degree greater than `n` results in zero, whether or not the product is really zero.

Observe also that calling `CohomologyRing` a second time with a bigger `n` does not extend the previous ring, but rather, recalculates the entire ring from the beginning. Extending the previous ring appears not to be worth the effort for technical reasons, since almost everything would need to be recalculated again anyway.

##### 2.5-2 IsHomogeneous

`> IsHomogeneous`( e ) | ( operation )

Returns: `true` or `false`.

Given an element `e` of some cohomology ring A, this operation determines whether or not `e` is homogeneous, that is, whether or not `e` is contained in some `hom_component` of A.

##### 2.5-3 Degree

`> Degree`( e ) | ( method )

Returns: the degree of `e`.

This function is intended to return the degree of the possibly non-homogeneous element `e` of some cohomology ring A, but in principle, works for any element of any graded `SCAlgebra`. Specifically, if A = A_0 + A_1 + A_2 + ... where A_i are the `hom_components` of A, then this function returns the minimum n such that `e` is in A_0 + A_1 + ... + A_n.

    gap> A:=CohomologyRing(DihedralGroup(8),10);
    <algebra of dimension 66 over GF(2)>
    gap> b:=Basis(A);
    CanonicalBasis( <algebra of dimension 66 over GF(2)> )
    gap> x:=b[2]+b[4];
    v.2+v.4
    gap> IsHomogeneous(x);
    false
    gap> Degree(x);
    2

##### 2.5-4 LocateGeneratorsInCohomologyRing

`> LocateGeneratorsInCohomologyRing`( C ) | ( function )

Returns: a list containing the cohomology generators.

Having already called `CohomologyRing` (see 2.5-1), this function returns a list of elements of the cohomology ring which together with the identity element generate the cohomology ring.

This function is a wrapper for `CohomologyGenerators` (see 2.3-1), indicating which elements of the cohomology ring correspond with the generators found by `CohomologyGenerators`.

    gap> C:=CohomologyObject(SmallGroup(8,4));
    <object>
    gap> A:=CohomologyRing(C,10);
    <algebra of dimension 17 over GF(2)>
    gap> L:=LocateGeneratorsInCohomologyRing(C);
    [ v.2, v.3, v.7 ]
    gap> A=Subalgebra(A,Concatenation(L,[One(A)]));
    true

#### 2.6 What Happens if `n` Isn't Big Enough?

Since P_* is a minimal resolution, the cohomology group H^i(G,k) is the dual of P_n, so that H^i(G,k) has a natural basis consisting of the maps sending the element 1_G of the jth direct summand of P_i to 1_k and all other direct summands to 0_k for j=1,2,...,b_i.

The command `CohomologyRing(C,n)` concatenates these bases for i=1,2,...,n and computes all products of basis elements x and y for which deg x+deg y <= n. Thinking of H*(G,k) in terms of it's multiplication table, then this means that the function computes the upper left-hand corner of the multiplication table. If deg x + deg y > n then the product xy is taken to be zero. Therefore, the ring returned by `CohomologyGenerators` is H*(G,k)/J where J is the ideal of all elements of degree >n.

The ring determined by `CohomologyGenerators` and `CohomologyRelators` is somewhat different. `CohomologyGenerators` proceeds inductively, taking all standard basis elements of H^1(G,k) as generators, and for i=2... n, taking all standard basis elements of H^i(G,k) which are not products of lower-degree elements as generators. Therefore, unless you have some reason to believe that there exists a generating set for H*(G,k) consisting of elements of degree <= n, then you are not guaranteed that the elements returned by the `CohomologyGenerators` generate H*(G,k) as a ring.

Similarly, `CohomologyRelators` proceeds inductively until degree n, returning a list of polynomials of multidegree <= n.

The impact of the preceeding information is that there is a homomorphism k< x_1,x_2,..., x_m >/ I -> H*(G,k) where x_1,x_2,...,x_m represent the elements returned by `CohomologyGenerators(C,n)`, k< x_1,x_2,... x_m > is the polynomial ring over k in the non-commuting variables x_1,x_2,...,x_m, and I is the ideal in k< x_1,x_2,..., x_m > generated by the elements returned by `CohomologyRelators(C,n)`.

Therefore, if there is a generator of degree >n, then f won't be surjective. If there is a relator of multidegree >n which is not a consequence of lower degree relators, then f won't be injective. See 2.4 for how big n needs to be to ensure that f be an isomorphism.

#### 2.7 Induced Maps

Let f: H -> G be a group homomorphism. Then f induces a homomorphism on cohomology H*(G,k) -> H*(H,k) which is returned by the following function.

##### 2.7-1 InducedHomomorphismOnCohomology

`> InducedHomomorphismOnCohomology`( C, D, f, n ) | ( function )

Returns: the induced homomorphism on cohomology rings.

This function returns the induced homomorphism on cohomology H*(G,k) -> H*(H,k) where the groups H and G are the components of the cohomology objects `C` and `D` and f: H -> G is a group homomorphism. If the cohomology rings have not yet been calculated, they will be computed to degree n, and in this case, they can then be accessed by calling `CohomologyRing` (see 2.5-1).

##### 2.7-2 Inclusion

`> Inclusion`( H, G ) | ( function )

Returns: the inclusion H-> G

This function returns the group homomorphism H-> G when H is a subgroup of G. The returned map can be used as the `f` argument of `InducedHomomorphismOnCohomology`, in which case the induced homomorphism is the restriction map Res: H*(G,k) -> H*(H,k).

The following example calculates the homomorphism on cohomology induced by the inclusion of the cyclic group of size 4 into the dihedral group of size 8.

    gap> G:=DihedralGroup(8);H:=Subgroup(G,[G.2]);
    <pc group of size 8 with 3 generators>
    Group([ f2 ])
    gap> C:=CohomologyObject(H);D:=CohomologyObject(G);
    <object>
    <object>
    gap> i:=Inclusion(H,G);
    [ f2 ] -> [ f2 ]
    gap> Res:=InducedHomomorphismOnCohomology(C,D,i,10);;
    gap> A:=CohomologyRing(D,10);
    <algebra of dimension 66 over GF(2)>
    gap> LocateGeneratorsInCohomologyRing(D);
    [ v.2, v.3, v.6 ]
    gap> A.1^Res; A.2^Res; A.3^Res; A.6^Res;
    v.1
    0*v.1
    v.2
    v.3

#### 2.8 Massey Products

See [K66] for the definitions and [B01] for the details of the calculation using the Yoneda cocomplex. See also the file `doc/explanation.*` for an explanation of the implementation.

##### 2.8-1 MasseyProduct

`> MasseyProduct`( x1, x2, ..., xn ) | ( function )

Returns: the Massey product < x1, x2, ... , xn>.

Given elements x1, x2, ... , xn of a cohomology ring returned by `CohomologyRing` (see 2.5), this function computes the n-fold Massey product < x1, x2, ... , xn > provided that the lower-degree Massey products < x_i ,x_{i+1}, ... , x_j > vanish for all 1 <= i < j <= n, and returns `fail` otherwise.

As an example, recall that the cohomology rings of the cyclic groups C_3 and C_9 of size 3 and 9 over k=GF(3) are both given by k< z,y >/(z^2), that is, they are isomorphic as rings. However, the following example shows that < z, z, z > is non-zero in H*(C_3,k) but is zero in H*(C_9,k).

    gap> A:=CohomologyRing(CyclicGroup(3),10);
    <algebra of dimension 11 over GF(3)>
    gap> z:=Basis(A)[2];
    v.2
    gap> MasseyProduct(z,z);
    0*v.1
    gap> MasseyProduct(z,z,z);
    v.3
    gap> A:=CohomologyRing(CyclicGroup(9),10);
    <algebra of dimension 11 over GF(3)>
    gap> z:=Basis(A)[2];
    v.2
    gap> MasseyProduct(z,z);
    0*v.1
    gap> MasseyProduct(z,z,z);
    0*v.1
    gap> MasseyProduct(z,z,z,z,z,z,z,z,z);
    v.3

Top of Book | Previous Chapter | Next Chapter

Goto Chapter: | Top | 1 | 2 | 3 | Bib | Ind

generated by GAPDoc2HTML