A-infinity Algebra Structures on Group Cohomology

As described in [Kel01], [Kel02], an A∞-algebra structure can be induced on H * A for any differential graded algebra A. Consider Ext * R(S, S), for R a quiver algebra quotient and S the direct sum of all simple R-modules. Regarded as the homology of the endomorphism algebra of a projective resolution of S, Keller further demonstrates how this additional algebraic structure allows recovery of R from Ext * R(S, S).

An A∞-algebra structure on a vector space V consists of higher structural operations m1, ... defined as mi:V tensor ito V fulfilling the Stasheff axioms for all n:

i + j - 1=n, 0≤k≤n - j∓ mi(a1, ..., ak - 1, mj(ak, ..., ak + j), ak + j + 1, ..., an) = 0

An A∞-algebra homomorphism from an A∞-algebra A to an A∞-algebra B is a family fi of maps A tensor ito B such that the homomorphism axioms hold for all n:

i + j - 1=n, 0≤k≤n - j ∓ fi(a1, ..., ak - 1, mj(ak, ..., ak + j), ak + j + 1, ..., an) = ∑i1 + ... + ir=n ∓ mr(fi1(a1, ..., ai1), ..., fir(an - ir + 1, ..., an))

According to a theorem fundamental to the algebraic uses of A∞-techniques, for a differential graded algebra A, there is an A∞-structure on H * A and an A∞-algebra homomorphism f:H * A to A such that f1 is a quasiisomorphism of differential graded algebras, and induced by the identity map on H * A.

A blackbox method of calculation can be based on Kadeishvilis' proof of this statement, using the homomorphism axioms to recursively calculate any specific values that are needed, and choosing the mi and fi in such a way as not to violate the axioms. The following package implements this method for the special case of Ext * kG(k, k) for G a p-group, k a prime field of characteristic p and also the one-dimensional unique simple kG-module.

Contents

AInfinityRecord(G,n) : Grp, RngIntElt -> Rec
Constructs a record carrying all relevant information to calculate A∞-operations on a group cohomology ring. Among the data carried can be found the cohomology ring in R, the cohomology ring quotient in S, the projective resolution used in P, the simple module resolved in k and the basic algebra in A.
MasseyProduct(Aoo,terms) : Rec, SeqEnum[RngElt] -> RngElt
HighProduct(Aoo,terms) : Rec, SeqEnum[RngElt] -> RngElt
Given an A∞ object Aoo corresponding to a group cohomology ring, this intrinsic calculates the structure map mi(t1 tensor ... tensor ti), where the i give the length of terms, and t1, ..., ti are the elements of terms.
HighMap(Aoo,terms) : Rec, SeqEnum[RngElt] -> MapChn
Given an A∞ object Aoo corresponding to a group cohomology ring, this intrinsic calculates the value of an A∞-quasiisomorphism f at the point t1 tensor ... tensor ti, where the i gives the length of terms, and t1, ..., ti are the elements of terms.

Example AlgBas_A-infinity mod 2 (H92E24)

The A∞-structures on the cohomology rings of cyclic p-groups are well known examples in the literature: the A∞-structure on H * (Cn, F2) has one single higher structure nontrivial operation, namely mn, which takes any n-tuple of odd coclasses to the even coclass of appropriate degree.

In order to verify this for a specific example, we start by constructing an A∞ record that contains all relevant information for the cohomology ring.

> Aoo := AInfinityRecord(CyclicGroup(4),10);
> S<x,y> := Aoo`S;
> HighProduct(Aoo,[x,x,x,x]);
y
> HighMap(Aoo,[x,x,x,x]);
Basic algebra chain map of degree -1

Example AlgBas_A-infinity mod 3 (H92E25)

The code as written handles odd characteristics well, with the sign choices featured in Kadeishvilis article [Kad80] embedded in the code.

> Aoo := AInfinityRecord(CyclicGroup(3),10);
> S<x,y> := Aoo`S;
> HighProduct(Aoo,[x,x,x]);
y
> HighMap(Aoo,[x,x,x]);
Basic algebra chain map of degree -1

Homological Algebra Toolkit

For the computation of A∞-structures, several methods are used that would invite a wider use in a generic homological algebra toolkit.

ActionMatrix(A,x) : AlgBas, Mtrx -> ModMatFldElt
Produces a matrix of the right action of the Basic algebra element described by x in the Basic algebra A.
CohomologyRingQuotient(CR) : Rec -> Rng,Map
Computes the actual cohomology ring as a quotient ring of a multivariate polynomial ring from a cohomology ring record.
LiftToChainmap(P,f,d) : ModCpx, Mtrx, RngIntElt -> MapChn
Lifts the function described by f to a chain map from P to P of degree d.
NullHomotopy(f) : MapChn -> MapChn
Constructs a null homotopy of the null homotopic chain map f. If f is not null homotopic, the function will throw an error message, since in that case some of the equations encountered on the way are not solvable.
IsNullHomotopy(f,H) : MapChn, MapChn -> BoolElt
Confirms that H is a null homotopy of f, in other words that f=dH - Hd, with d the differential of the corresponding chain complexes.
ChainmapToCohomology(f,CR) : MapChn, Rec -> RngElt
Takes a chain map f and returns the element in the cohomology quotient ring to which the chain map corresponds.
CohomologyToChainmap(xi,CR,P) : RngElt, Rec, ModCpx -> MapChn
Takes an element xi of a cohomology quotient ring of the cohomology ring record CR and a projective resolution corresponding to that cohomology ring, and returns a chain map in the coclass represented by xi.

Example AlgBas_Nullhomotopy (H92E26)

To illustrate the code that generates null homotopies, we consider the cohomology ring of a cyclic group, and pick out chain map representatives for the degree 1 coclass. Although this squares to zero, the corresponding chainmaps do not compose to the zero chainmap.
> A := BasicAlgebra(CyclicGroup(4));
> k := SimpleModule(A,1);
> P := ProjectiveResolution(k,5);
> R := CohomologyRing(k,5);
> S<x,y> := CohomologyRingQuotient(R);
> xi := CohomologyToChainmap(x,R,P);
> x*x;
0
> IsZero(xi*xi);
false
> ModuleMaps(xi*xi);
[*
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0]
    [0 0 0 0],
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0]
    [0 0 0 0],
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0]
    [0 0 0 0],
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0]
    [0 0 0 0]
*]
> H := NullHomotopy(xi*xi);
> ModuleMaps(H);
[*
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0],
    [0 1 0 0]
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0],
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0],
    [0 1 0 0]
    [0 0 1 0]
    [0 0 0 1]
    [0 0 0 0],
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0]
    [0 0 0 0]
*]
> IsNullHomotopy(xi*xi,H);
true
V2.28, 13 July 2023