Complexes of Modules

Complexes of modules are a fundamental object in homological algebra. Magma supports the type ModCpx representing a complex of modules. Conceptually, a complex is an infinite sequence of modules, indexed by integers, with maps between successive modules such that the composition of any two maps is zero. Complexes are often written

\[\dots \smash{ \mathop{\longrightarrow}\limits^{f_{n+1}}} M_n \smash{ \mathop{\longrightarrow}\limits^{f_{n}}} M_{n-1} \smash{ \mathop{\longrightarrow}\limits^{f_{n-1}}} M_{n-2} \smash{ \mathop{\longrightarrow}\limits^{f_{n-2}}} \dots\]

where the map \(f_n\) has domain \(M_n\) and codomain \(M_{n-1}\). The indices on the modules and maps decrease to the right. In practice, Magma requires all but a finite number of the modules and maps to be zero.

The homomorphism from \(M_n\) to \(M_{n-1}\) in the complex is the \(n^{th}\) boundary map of the complex. The homology of the complex in degree \(n\) is the quotient of the kernel of the \(n^{th}\) boundary map by the image of the boundary map of degree \(n-1\). Magma computes the homology only if both boundary maps are defined. A complex is said to be exact if the image of each map is equal to the kernel of the next.

Currently, there are two types of modules over which complexes are supported:

(a): Modules over a basic algebra \(A\) (see Chapter Basic Algebras);
(b): Modules over a multivariate polynomial ring over a field (see Chapter Modules over Multivariate Rings and in particular the function FreeResolution). Most of the functions in this chapter work for either type of module but exceptions are noted.

Creation

Complex(L, d): List, RngIntElt -> ModCpx: Given a list \(L\) of maps between successive \(A\)-modules create the corresponding complex. The last term of the complex has degree \(d\). This function returns an error if the maps don’t actually form a complex.

Complex(f, d): Map, RngIntElt -> ModCpx: Given a map \(f\) between \(A\)-modules \(M\) and \(N\), form the complex consisting of the two term complex whose only map is \(f\). The term \(N\) is in degree \(d\).

ZeroComplex(A, m, n): AlgBas, RngIntElt, RngIntElt -> ModCpx: Given a basic algebra \(A\) and integers \(m\) and \(n\) such that \(m > n\), create a complex of modules over the basic algebra \(A\), starting with a term of degree \(m\) and ending with a term of degree \(n\), where all the modules and maps are zero.

Dual(C): ModCpx -> ModCpx
Dual(C, n): ModCpx, RngIntElt -> ModCpx: The dual of the complex \(C\) over a basic algebra \(A\) as a complex over the opposite algebra of \(A\). If an integer \(n\) is supplied then the last term of the dual complex is in degree \(n\). Otherwise, the last term of the dual complex is in degree 0.

Subcomplexes and Quotient Complexes

Let \(C\) be a complex of \(A\)-modules, \(M_m, \ldots, M_n\). A subcomplex \(S\) of \(C\) is a complex whose terms are submodules of the terms of \(C\) and whose maps are the restrictions of the maps of \(C\) to the terms of \(S\).

sub< C | Q >: ModCpx, SeqEnum[ModAlg] -> ModCpx, MapChn
sub< C | L >: ModCpx, List -> ModCpx, MapChn: Given a complex \(C\) and a sequence \(Q\) of submodules of the terms of \(C\), returns the smallest subcomplex whose terms contain the modules in \(Q\). The input can also be a list \(L\) of sequences of elements of the successive terms of \(C\). In this case the submodules generated by the elements is computed. The function also returns the chain map giving the inclusion of the subcomplex in \(C\).

RandomSubcomplex(C, Q): ModCpx, SeqEnum -> ModCpx, MapChn: Given a chain complex \(C\) over a basic algebra in degrees \(a\) to \(a-t+1\) and a sequence \(Q = [q_1, \ldots, q_t]\) of natural numbers, the function creates the minimal chain complex whose term in degree \(a-i+1\) is a submodule generated by \(q_i\) random elements of the term in degree \(a-i+1\) of \(C\). The function also returns the chain map that is the inclusion of the subcomplex into \(C\).

quo< C | D >: ModCpx, ModCpx -> ModCpx
quo< C | S >: ModCpx, SeqEnum[ModAlg] -> ModCpx
quo< C | L >: ModCpx, List -> ModCpx: Given a complex \(C\) and a subcomplex \(D\) of \(C\), returns the quotient complex C/D together with the natural quotient map. If given as a sequence \(S\) of submodules of the terms of \(C\) or a list \(L\) of sequences of elements of the terms of \(C\), then the submodule generated by \(S\) or \(L\) is created and the quotient computed. The function also returns the chain map of \(C\) on the quotient.

Access Functions

Degrees(C): ModCpx -> RngIntElt: Returns the first and last degrees of the defined terms of the complex \(C\).

Algebra(C): ModCpx -> AlgBas: Given a complex \(C\) over a basic algebra \(A\), this function returns the algebra \(A\).

BoundaryMap(C, n): ModCpx, RngIntElt -> ModMatRngElt: Returns the boundary map of the complex \(C\) from the term of degree \(n\) to the term of degree \(n-1\).

BoundaryMaps(C): ModCpx -> List: The list of boundary maps of the complex \(C\).

DimensionsOfHomology(C): ModCpx -> SeqEnum: Returns the list of the dimensions of the homology groups of the complex \(C\).

DimensionOfHomology(C, n): ModCpx, RngIntElt -> RngIntElt: Returns the dimension of the homology group of the complex \(C\) in degree \(n\).

DimensionsOfTerms(C): ModCpx -> SeqEnum: Returns the list of the dimensions of the terms of the complex \(C\).

Term(C, n): ModCpx, RngIntElt -> ModAlg: The module in the complex \(C\) in degree \(n\).

Terms(C): ModCpx -> SeqEnum: The sequence of terms of the complex \(C\).

Elementary Operations

DirectSum(C, D): ModCpx, ModCpx -> ModCpx: Returns the direct sum of the complex \(C\) and the complex \(D\).

Homology(C): ModCpx -> SeqEnum
HomologyOfChainComplex(C): ModCpx -> SeqEnum: The sequence of homology groups of the complex \(C\) as a sequence of modules.

Homology(C, n): ModCpx, RngIntElt -> SeqEnum: Returns the homology group in degree \(n\) of the complex \(C\), as an \(A\)-module.

Prune(C): ModCpx -> ModCpx: Returns the complex that consists of the terms of \(C\) with the right end term (term of lowest degree) removed.

Prune(C, n): ModCpx, RngIntElt -> ModCpx: Returns the complex that consists of the terms of \(C\) with \(n\) terms removed from the right end.

Preprune(C): ModCpx -> ModCpx: Returns the complex that consists of the terms of \(C\) with the left end term (term of highest degree) removed.

Preprune(C, n): ModCpx, RngIntElt -> ModCpx: Returns the complex that consists of the terms of \(C\) with \(n\) terms removed from the left end.

Shift(C, n): ModCpx, RngIntElt -> ModCpx: Given the complex \(C\) in degrees \(r\) to \(s\), returns the complex in shifted degrees \(r+n\) to \(s+n\). The integer \(n\) may be either positive or negative. The maps in the complex are all multiplied by the scalar \((-1)^n\).

ShiftToDegreeZero(C): ModCpx -> ModCpx: Given the complex \(C\), returns the shift of \(C\) so that the last term, the term of lowest degree, is in degree 0.

Splice(C, D): ModCpx, ModCpx -> ModCpx: Given two complexes \(C\) and \(D\) over the same basic algebra, such that the end term of \(C\) coincides with the initial term of \(D\), form the complex that corresponds to the concatenation of \(C\) and \(D\) (as sequences of maps) This function checks that the resulting sequence of maps forms a complex. The degrees of complex \(D\) remain unchanged while the degrees of the terms in complex \(C\) are changed to fit.

Splice(C, D, f): ModCpx, ModCpx, ModMatRngElt -> ModCpx: The splice of the complex \(C\) with the complex \(D\) along the map \(f\) from the last term of \(C\) to the first term of \(D\). The degree of the last term of the splice is the same as the degree of the last term of the complex \(D\).

Extensions

The following are elementary operations related to extending complexes

LeftExactExtension(C): ModCpx -> ModCpx: Given a complex \(C\) of modules over a basic algebra, returns the complex of length one greater that is obtained by adjoining the inclusion map from the kernel of the boundary map in highest degree to the term of highest degree in \(C\).

RightExactExtension(C): ModCpx -> ModCpx: Given a complex \(C\) of modules over a basic algebra, returns the complex of length one greater that is obtained by adjoining the quotient map to the cokernel of the boundary map of lowest degree from the term of lowest degree in \(C\).

ExactExtension(C): ModCpx -> ModCpx: Returns the left and right exact extensions of the complex \(C\).

LeftZeroExtension(C): ModCpx -> ModCpx
LeftZeroExtension(C, n): ModCpx, RngIntElt -> ModCpx: Given a complex \(C\) of modules over a basic algebra, returns the complex of length one greater that is obtained by adjoining the zero map from the zero module to the term of highest degree in the complex. If a natural number \(n\) is included in the input then the operation is performed \(n\) times.

RightZeroExtension(C): ModCpx -> ModCpx
RightZeroExtension(C, n): ModCpx, RngIntElt -> ModCpx: Given a complex \(C\) of modules over a basic algebra, returns the complex of length one greater that is obtained by adjoining the zero map to the zero module from the term of lowest degree in the complex. If a natural number \(n\) is included in the input then the operation is performed \(n\) times.

ZeroExtension(C): ModCpx -> ModCpx: Returns the left and right zero extensions of the complex \(C\).

EqualizeDegrees(C, D): ModCpx, ModCpx -> ModCpx, ModCpx
EqualizeDegrees(Q): SeqEnum -> SeqEnum: Given complexes \(C\) and \(D\) over the same algebra, the function returns the complexes obtained by taking zero extensions of \(C\) and \(D\), if necessary, so that both complexes have the same degrees. The input can also be given as a sequence \(Q\) of complexes, in which case the function returns the sequence of complexes obtained by taking zero extensions of the elements of \(Q\), if necessary, until all of the elements of the sequence have the same degrees.

EqualizeDegrees(C, D, n): ModCpx, ModCpx, RngIntElt -> ModCpx, ModCpx: The two complexes, \(C\) and \(D\), with zero extension sufficient that the first and the shift by degree \(n\) of the second have the same degrees.

Predicates

The following functions return a Boolean value.

IsExact(C): ModComplex -> BoolElt: Returns true if and only if the complex \(C\) is an exact sequence, i.e. the image of each map in \(C\) is equal to the kernel of the succeeding map (with the obvious exceptions of the first and last maps of the complex). If the complex has only two terms then this is true trivially.

IsShortExactSequence(C): ModCpx -> BoolElt, RngIntElt: Returns true if the complex \(C\) consists of a short exact sequence together with other terms that are zero. The function returns also the degrees of the complex of nonzero terms.

IsExact(C, n): ModCpx, RngIntElt -> BoolElt: Returns true if and only if the complex \(C\) is an exact sequence in degree \(n\), i.e. the image of the map in \(C\) into the term of degree \(n\) is equal to the kernel of the succeeding map.

IsZeroComplex(C): ModCpx -> BoolElt: Returns true if and only if the complex \(C\) is composed entirely of zero modules and maps.

IsZeroMap(C, n): ModCpx, RngIntElt -> BoolElt: Returns true if and only if the boundary map in degree \(n\) of the complex \(C\) is the zero map.

IsZeroTerm(C, n): ModCpx, RngIntElt -> BoolElt: Returns true if and only if the term in degree \(n\) of the complex \(C\) is the zero object.

Example: Complexes over a Quiver Algebra (ex-bb43ae)

Run in calculator (opens in a new tab)

We construct the quiver algebra of a quiver with three nodes and three arrows going from node 1 to node 2, from 2 to 1, and 2 to 3. The relation is that \((ab)^3a =0\) where \(a\) is the first arrow and \(b\) is the second. Then we construct projective and injective resolutions of the first simple module.

> ff := GF(8);
> FA<e1,e2,e3,a,b,c> := FreeAlgebra(ff,6);
> rrr := [a*b*a*b*a*b*a];
> D := BasicAlgebra(FA,rrr,3,[<1,2>,<2,1>,<2,3>]);
> D;
Basic algebra of dimension 23 over GF(2^3)
Number of projective modules: 3
Number of generators: 6
> DimensionsOfProjectiveModules(D);
[ 10, 12, 1 ]
> DimensionsOfInjectiveModules(D);
[ 8, 7, 8 ]

Here is the opposite algebra:

> OD := OppositeAlgebra(D);
reverse trees
> OD;
Basic algebra of dimension 23 over GF(2^3)
Number of projective modules: 3
Number of generators: 6
> s1 := SimpleModule(D,1);
> P,mu := ProjectiveResolution(s1,7);
> P;
Basic algebra complex with terms of degree 7 down to 0
Dimensions of terms: 12 12 12 12 12 12 12 10
> Q,nu := InjectiveResolution(s1,7);
> Q;
Basic algebra complex with terms of degree 0 down to -7
Dimensions of terms: 8 7 0 0 0 0 0 0

Note that the projective and injective resolutions are complexes with the appropriate augmentation and coaugmentation maps. First we form the two term complex whose boundary map is the composition of the augmentation and coaugmentation maps.

> theta := MapToMatrix(hom<Term(P,0)-> Term(Q,0)|mu*nu>);
> E := Complex(theta,0);

Then we splice all of this together.

> R := Splice(P,E);
> S := Splice(R,Q);
> S;
Basic algebra complex with terms of degree 8 down to -7
Dimensions of terms: 12 12 12 12 12 12 12 10 8 7 0 0 0 0 0 0

Run in calculator (opens in a new tab)

Complexes of Modules#

Creation#

Subcomplexes and Quotient Complexes#

Access Functions#

Elementary Operations#

Extensions#

Predicates#