Unless otherwise specified, all the functions described below taking an argument n do whatever the manual says they do up to homological degree n. 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 finished.
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.
‣ CohomologyObject( G, M ) | ( operation ) |
‣ CohomologyObject( G ) | ( operation ) |
Returns: a CObject.
This function creates a CObject having components the \(p\)-group G and the MeatAxe module M, which should be a \(kG\)-module where \(G\) the group G and \(k\) a field of characteristic \(p\). Note that MeatAxe modules know what \(k\) is, but not what \(G\) is, which is why this operation requires the user to specify \(G\) but not \(k\).
Fortunately, most users don't need to know anything about MeatAxe modules, being interested primarily in the case where \(k=GF(p)\) and \(M=k\) is the trivial \(kG\)-module. In this situation, the second invocation creates a cohomology object having components the \(p\)-group \(G\) and the trivial MeatAxe \(kG\)-module \(k=GF(p)\).
We emphasize that in the first invocation, \(k\) can be any field of characteristic \(p\) and M can be any MeatAxe module over \(kG\), and that ProjectiveResolution works when M is an arbitrary MeatAxe module, but that 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.
Given a \(p\)-group \(G\), a field \(k\) of characteristic \(p\), and a \(kG\)-module \(M\), the function below computes the beginning 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. Because of the minimality of \(P\) the groups \(Ext^i(M,N)\) are simply \(Hom(P_i,N)\), and if \(M\) and \(N\) are both the trivial \(kG\)-module \(k\), then \(H^i(G,k)=Ext^i(k,k)=k^(b_i)\).
‣ ProjectiveResolution( C, n ) | ( operation ) |
Returns: a list containing the Betti numbers \(b_0, b_1,\ldots, b_n\).
Given a cohomology object C having components \(G\) 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.
‣ BoundaryMap( C, n ) | ( operation ) |
Returns: the nth 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 nth boundary map \(P_n \rightarrow P_{n-1}\).
The map returned is a \(b_n x b_{n-1}|G|\) matrix, having in the \(i\)th row the image of the element \(1_G\) from the \(i\)th direct summand of \(P_n\).
See the file doc/example.* for an example of the usage and interpretation of the result of this function.
See [2] 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.
‣ CohomologyGenerators( C, n ) | ( operation ) |
Returns: a list containing the degrees of the elements of a set of generators of the cohomology ring.
Given a cohomology object C having group component \(G\) and module component the trivial \(kG\)-module, this function computes a set of generators of \(H*(G,k)\) having degree n or less, 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_i \rightarrow k\) for \(0\le i\le n\) and are stored in C as matrices. Only their degrees are returned.
‣ CohomologyRelators( C, n ) | ( operation ) |
Returns: a list of generators and a list of relators.
Given a cohomology object C having group component \(G\) and module component \(k\), this function computes a set of generators of the ideal of relators in \(H*(G,k),\) all having degree \(n\) or less.
More specifically, the function returns two lists, the first list containing the variables z, y, x, \(\ldots\) 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, \(\ldots\) 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 in section 2.3-1 ) and subject to the relators in the second list. See section 2.6 for more details still.
For example, consider 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 ] ]
This tells us that for \(G=D_8\) and \(k=GF(p)\) the cohomology ring \(H*(G,k)\) is the graded-commutative polynomial ring in the variables \(z\), \(y\), \(x\) of degrees 1, 1, 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 degree less than 10. See see section 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, \(\ldots\) have already been named, say by a previous call to CohomologyRelators, then these variables will retain their old names. If this is confusing, you could restart GAP and do it again.
Finally, CohomologyRelators is not idempotent for efficiency reasons, so sadly, if you don't uncover all the relators the first time, you will have to start all over from the beginning.
A test or series of tests for completion of the calculation will hopefully be implemented soon. See [2] for the details.
Whereas the operations in sections 2.3-1 and 2.3-2 calculate a presentation for the cohomology ring, the operation below creates the ring in GAP as a structure constant algebra.
See [2] 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.
‣ CohomologyRing( C, n ) | ( operation ) |
‣ CohomologyRing( G, n ) | ( operation ) |
Returns: the cohomology ring of \(G\).
Given a cohomology object C with group component \(G\) and module component the trivial \(kG\)-module, 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.
Recall that \(H*(G,k)\) is a graded algebra, the components being the cohomology groups \(H^i(G,k)\). The following functions were intended to be used for cohomology rings, but in principle, they work for any graded structure constant algebra.
‣ IsHomogeneous( e ) | ( operation ) |
Returns: true or false.
Given an element e of a cohomology ring \(H*(G,k)\), this operation determines whether or not e is homogeneous, that is, whether e is contained in \(H^i(G,k)\) for some i.
‣ Degree( e ) | ( method ) |
Returns: the degree of e.
This function returns the degree of the possibly non-homogeneous element e of a cohomology ring \(H*(G,k)\). Specifically, if \(H*(G,k) = A_0 + A_1 + A_2 + \ldots\) where \(A_i = H^i(G,k)\) then this function returns the minimum \(n\) such that e is in \(A_0 + A_1 + \ldots + 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
‣ 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). It points out 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
n Isn't
Big Enough?Since \(P\) is a minimal projective resolution, we have \(H^i(G,k) = Hom_{{kG}}(P_i,k)\) where \(P_i = \left(kG\right)^{b_i}\) so that \(H^i\left(G,k\right)\) has a natural basis consisting of the maps sending the element \(1_G\) of the \(j\)th direct summand of \(P_i\) to \(1_k\) and all other direct summands to \(0\), for \(j=1,2,\ldots,b_i\), where \(b_i\) is the \(kG\)-rank of \(P_i\).
The command CohomologyRing(C,n) forms the vector space whose basis is the concatenation of the natural bases of \(H^i\left(G,k\right)\) for \(i=1,2,\ldots,n\) and computes all products of basis elements \(x\) and \(y\) for which \(\deg x+\deg y \leq n\). Thinking of \(H*(G,k)\) in terms of it's multiplication table, this means that the function computes the upper left-hand corner of the multiplication table. If \(\deg x + \deg y > n\), the product \(xy\) is taken to be zero. Therefore, the ring returned by CohomologyRing 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 natural basis elements of \(H^1\left(G,k\right)\) as generators, and for \(i=2\ldots n\), taking all natural basis elements of \(H^i\left(G,k\right)\) which are not products of lower-degree elements as generators. Therefore, unless you know that there is an \(n\) for which there exists a generating set of \(H*(G,k)\) consisting of elements of degree \(n\) or less, then you are not guaranteed that the elements returned by the CohomologyGenerators generate \(H*(G,k)\) as a ring. The knowledge of such an \(n\) is the subject of section 2.4.
Similarly, CohomologyRelators proceeds inductively until degree \(n\), returning a list of polynomials which generate the ideal of relators of degree \(n\) or less. Again, you have to already know how big \(n\) should be.
The result of the preceding information is that there is a homomorphism \(k\left\langle x_1,x_2,\ldots, x_m \right\rangle/ I \to H*(G,k)\), where \(k\left\langle x_1,x_2,\ldots,x_m \right\rangle\) is the graded polynomial ring over \(k\) in the non-commuting variables \(x_1,x_2,\ldots,x_m\), having degrees the numbers in the list returned by CohomologyGenerators, and \(I\) is the ideal in \(k\left\langle x_1,x_2,\ldots, x_m \right\rangle\) generated by the elements returned by CohomologyRelators(C,n).
Therefore, if there is a generator of degree greater than \(n\), then \(f\) won't be surjective. Similarly, if there is a relator of degree greater than \(n\) which is not a consequence of lower degree relators, then \(f\) won't be injective. See section 2.4 for a discussion on how big \(n\) needs to be to ensure that \(f\) will be an isomorphism.
Let \(f: H \rightarrow G\) be a group homomorphism. Then \(f\) induces a homomorphism on cohomology \(H\ast(G,k) \rightarrow H\ast(H,k)\) which is returned by the following function.
‣ InducedHomomorphismOnCohomology( C, D, f, n ) | ( function ) |
Returns: the induced homomorphism on cohomology.
This function returns the induced homomorphism \(H\ast(G,k) \rightarrow H\ast(H,k)\) where the groups \(H\) and \(G\) are the components of the cohomology objects C and D and \(f: H \rightarrow 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).
‣ SubgroupInclusion( H, G ) | ( function ) |
Returns: the inclusion \(H\rightarrow G\)
This function returns the group homomorphism \(H\rightarrow 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\ast(G,k) \rightarrow H\ast(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:=SubgroupInclusion(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
See [3] for the definitions and [1] for the details of the calculation using the Yoneda cocomplex. See also the file doc/explanation.* for an explanation of the implementation.
‣ MasseyProduct( x1, x2, ..., xn ) | ( function ) |
Returns: the Massey product \(\left\langle x1, x2, ... , xn\right\rangle\).
Given elements \(x1, x2, \ldots , xn\) of the ring returned by CohomologyRing (see 2.5) this function computes the \(n\)-fold Massey product \(\left\langle x1, x2, \ldots , xn \right\rangle\) provided that the lower-degree Massey products \(\left\langle xi, x{{i+1}}, \ldots , xj \right\rangle\) vanish for all \(1 \leq i < j \leq n\) and returns fail otherwise.
As an example, recall that the cohomology rings of the cyclic groups \(C_3\) and \(C_9\) of sizes 3 and 9 over \(k=GF(3)\) are both given by \(k\left\langle z,y \right\rangle/\left(z^2\right)\), so they are isomorphic as rings. However, the following example shows that \(\left\langle z, z, z \right\rangle\) 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
generated by GAPDoc2HTML