Chain Maps

A chain map from complex C to complex D is a sequence of homomorphisms between the terms of C and the terms of D such that the maps commute with the boundary homomorphisms on the two complexes. The chain map has degree zero if the map on Cn has it's image in Dn. Otherwise the degree of the chain map expresses the extent to which the degrees of the terms are raised or lowered by the chain map.

Chain maps do not have to be defined in every degree for which either its domain or codomain is defined. On the other hand it must be defined wherever possible, i.e. for any degree i for which the term of the domain is defined and for which the term of the codomain is defined in degree i + n where n is the degree of the chain map.

The freedom of definition can cause problems with constructions such as the kernel or cokernel. That is, the kernel of a chain complex may not be a complex. For this reason we allow the Kernel and Cokernel functions to work only for proper chain maps where "proper" is defined as follows. Suppose C is a chain complex in degrees a to b and D is a complex in degrees u to v. A chain map in degree n from C to D is proper provided u ≥a + n and v ≥b + n.

Contents

Creation

ChainMap(Q, C, D, n) : SeqEnum, ModCpx, ModCpx, RngIntElt -> MapChn
Returns the chain map given by the sequence of maps in Q. Each element in Q is a map from a term of the complex C to a corresponding term of the complex D. The integer n is the degree of the chain map. This means that for any i the term in degree i of C is mapped to the term of degree n + i of D. There should be a map defined for any degree i in the range of degrees of C such that there is a corresponding term in degree n + i for the complex D.
ZeroChainMap(C, D) : ModCpx, ModCpx -> MapChn
Given chain complexes C and D, construct the chain map from C to D all of whose terms are zero.

Access Functions

Degree(f) : MapChn -> RngIntElt
Given a chain map f, returns the degree of f. Note that f: C -> D has degree n if it takes the term in degree i of the complex C to the term in degree i + n of the complex D.

ModuleMap(f, n) : MapChn, RngIntElt -> ModMatRngElt
Given a chain map f:C -> D and an integer n, this function returns the map from the term in degree n of the complex C to the term in degree n + (hbox (Degree))(f) of the complex D.

Kernel(f) : MapChn -> ModCpx, MapChn
Returns the kernel complex of f and the inclusion of the kernel in the domain of f. The function is only defined for proper chain maps. If the chain map is not defined for a certain term of the domain then that term is equal to the term of the kernel complex. That is, if f is not defined on a term then the functions acts as if f were the zero map on that term.

Cokernel(f) : MapChn -> ModCpx, MapChn
Returns the cokernel complex of f and the projection of the cokernel onto the codomain of f. The function is only defined for proper chain maps. If the chain map is not defined for a certain term of the codomain then that term is equal to the term of the cokernel complex. That is, if f is not defined on a term then the function acts as if f were the zero map on that term.
Image(f) : MapChn -> ModCpx, MapChn, MapChn
Returns the image complex of f and the inclusion of the image in the codomain of f and the projection of the domain of f on to the image. The function is only defined for proper chain maps.

Elementary Operations

f + g : MapChn , MapChn -> MapChn
The sum of two chain maps with the same domain and codomain.
a * g : RngElt , MapChn -> MapChn
The product of the chain map g by the scalar a in the base ring of the algebra.
f * g : MapChn , MapChn -> MapChn
The composition of the two chain maps f and g.

Predicates

The following functions return a Boolean value.

IsSurjective(f) : MapChn -> BoolElt
Returns true if the chain map f is a surjection in every degree, false otherwise.
IsInjective(f) : MapChn -> BoolElt
Returns true if the chain map f is an injection in every degree, false otherwise.
IsZero(f) : MapChn -> BoolElt
Returns true if the chain map f is zero in every degree, false otherwise.
IsIsomorphism(f) : MapChn -> BoolElt
Returns true if the chain map f is an isomorphism of chain complexes, false otherwise.
IsShortExactSequence(f, g) : MapChn, MapChn -> BoolElt
Returns true if the sequence of chain complexes, 0 -> Domain(f) -> Domain(g) -> Codomain(g) -> 0, where the internal maps are f and g, is exact.
IsChainMap(L, C, D, n) : List, ModCpx, ModCpx, RngIntElt -> BoolElt
Returns true if the list of maps L from the terms of complex C to the terms of the complex D is a chain map of degree n, i. e. it has the right length and the diagram commutes.
IsChainMap(f) : MapChn -> BoolElt
Returns true if the supposed chain map f really is a chain map, i. e. the diagrams commute.
IsProperChainMap(f) : MapChn -> BoolElt
Returns true if the chain map f is a proper chain map, a necessary condition for taking kernel and cokernel.
HasDefinedModuleMap(C,n) : ModCpx, RngIntElt -> BoolElt
Returns true if the module map in degree n of the complex C is defined.

Example ModCpx_Chainmaps (H61E2)

We from the basic algebra of the direct product of a cyclic group of order 3 with symmetric group on three letters over the field with three elements.
> FA<e1,e2,a,b> := FreeAlgebra(GF(3),4);
> MM:= [e1 +e2 - FA!1, a*b*a, b*a*b];
> BS3 := BasicAlgebra(FA, MM, 2, [<1,2>,<2,1>]);
> gg := CyclicGroup(3);
> BC3 := BasicAlgebra(gg,GF(3));
> A := TensorProduct(BS3,BC3);
> A;
Basic algebra of dimension 18 over GF(3)
Number of projective modules: 2
Number of generators: 6
Now we want the projective resolution of the second simple module as a complex. This we will manipulate and take a somewhat random complex.
> PR := ProjectiveResolution(SimpleModule(A,2),12);
> PR;
Basic algebra complex with terms of degree 12 down to 0
Dimensions of terms: 117 108 99 90 81 72 63 54 45 36 27 18 9
> PR := Prune(PR);
> PR := Prune(PR);
> PR := Prune(PR);
> PR;
Basic algebra complex with terms of degree 12 down to 3
Dimensions of terms: 117 108 99 90 81 72 63 54 45 36
> PR := Prune(PR);
> PR := Prune(PR);
> PR;
Basic algebra complex with terms of degree 12 down to 5
Dimensions of terms: 117 108 99 90 81 72 63 54
> PR := ZeroExtension(PR);
> PR;
Basic algebra complex with terms of degree 13 down to 4
Dimensions of terms: 0 117 108 99 90 81 72 63 54 0
> PR := Shift(PR,-4);
> PR;
Basic algebra complex with terms of degree 9 down to 0
Dimensions of terms: 0 117 108 99 90 81 72 63 54 0
> S := [* *];
> for i := 1 to 10 do
>    S[i] := [Random(Term(PR,10-i)),Random(Term(PR,10-i))];
> end for;
> C,mu := Subcomplex(PR,S);
> C;
Basic algebra complex with terms of degree 9 down to 0
Dimensions of terms: 0 36 67 64 62 63 58 54 51 0
> Homology(C);
[
    AModule of dimension 4 over GF(3),
    AModule of dimension 6 over GF(3),
    AModule of dimension 5 over GF(3),
    AModule of dimension 3 over GF(3),
    AModule of dimension 2 over GF(3),
    AModule of dimension 1 over GF(3),
    AModule of dimension 4 over GF(3),
    AModule of dimension 26 over GF(3)
]
[
    Mapping from: AModule of dimension 4 over GF(3) to AModule of dimension 4
    over GF(3),
    Mapping from: AModule of dimension 38 over GF(3) to AModule of dimension 6
    over GF(3),
    Mapping from: AModule of dimension 34 over GF(3) to AModule of dimension 5
    over GF(3),
    Mapping from: AModule of dimension 33 over GF(3) to AModule of dimension 3
    over GF(3),
    Mapping from: AModule of dimension 31 over GF(3) to AModule of dimension 2
    over GF(3),
    Mapping from: AModule of dimension 33 over GF(3) to AModule of dimension 1
    over GF(3),
    Mapping from: AModule of dimension 29 over GF(3) to AModule of dimension 4
    over GF(3),
    Mapping from: AModule of dimension 51 over GF(3) to AModule of dimension 26
    over GF(3)
]
> D := Cokernel(mu);
> D;
Basic algebra complex with terms of degree 9 down to 0
Dimensions of terms: 0 81 41 35 28 18 14 9 3 0
> Homology(D);
[
    AModule of dimension 64 over GF(3)
    AModule of dimension 5 over GF(3),
    AModule of dimension 3 over GF(3),
    AModule of dimension 2 over GF(3),
    AModule of dimension 1 over GF(3),
    AModule of dimension 4 over GF(3),
    AModule of dimension 3 over GF(3),
    AModule of dimension 3 over GF(3)
]
[
    Mapping from: AModule of dimension 64 over GF(3) to AModule of dimension 64
    over GF(3),
    Mapping from: AModule of dimension 22 over GF(3) to AModule of dimension 5
    over GF(3),
    Mapping from: AModule of dimension 22 over GF(3) to AModule of dimension 3
    over GF(3),
    Mapping from: AModule of dimension 15 over GF(3) to AModule of dimension 2
    over GF(3),
    Mapping from: AModule of dimension 14 over GF(3) to AModule of dimension 1
    over GF(3),
    Mapping from: AModule of dimension 8 over GF(3) to AModule of dimension 4
    over GF(3),
    Mapping from: AModule of dimension 9 over GF(3) to AModule of dimension 3
    over GF(3),
    Mapping from: AModule of dimension 3 over GF(3) to AModule of dimension 3
    over GF(3)
]

Maps on Homology

InducedMapOnHomology(f, n) : MapChn, RngIntElt -> ModTupFldElt
The homomorphism induced on homology by the chain map f in degree n.
ConnectingHomomorphism(f, g, n) : MapChn, MapChn, RngIntElt -> ModMatRngElt
The connecting homomorphism in degree n of the short exact sequence of chain complexes given by the chain maps f and g.
LongExactSequenceOnHomology(f, g) : MapChn, MapChn -> ModCpx
The long exact sequence on homology for the exact sequence of complexes given by the chain maps f and g as a chain complex with the homology group in degree i for the Cokernel of the complex C appearing in degree 3i.

Example ModCpx_LongExactSequence (H61E3)

We create a basic algebra with two simple modules and four nonidempotent generators. The relations are given in the sequence rrr.
> ff := GF(3);
> p := Characteristic(ff);
> FA<e1, e2, y, x, a, b> := FreeAlgebra(ff,6);
> rrr := [y^p,x^p,x*y+y*x,x*a*b-a*b*x,y*a*b-a*b*y,(b*a)^2,(b*a)^2];
> A := BasicAlgebra(FA,rrr,2,[<1,1>,<1,1>,<1,2>,<2,1>]);
> A;
Basic algebra of dimension 81 over GF(3)
Number of projective modules: 2
Number of generators: 6
> DimensionsOfProjectiveModules(A);
[ 45, 36 ]
Now we generate the simple modules and their projective covers. We want a module PP that is the direct sum of two copies of each of the projective indecomposable module.
> S1 := SimpleModule(A,1);
> PP := ProjectiveModule(A,[2,2]);
Now we are going to create a complex all of whose terms are isomorphic to PP. To make it interesting we will insist that the first homomorphism have its image in the second radical layer of PP.
> J1 := JacobsonRadical(PP);
> theta1 := Morphism(J1,PP);
> J2 := JacobsonRadical(J1);
> theta2 := Morphism(J2,J1);
> theta := theta2*theta1;
> HomPJ := AHom(PP, J2);
> HomPJ;
KMatrixSpace of 162 by 150 matrices and dimension 300 over GF(3)
> gamma := Random(HomPJ)*theta;
> LL := [* gamma *];
So we now have the first boundary map of the complex. The other boundary maps are generated randomly.
> for i := 1 to 15 do
>     K, phi := Kernel(gamma);
>     HomPK := AHom(PP,K);
>     gamma := Random(HomPK)*MapToMatrix(phi);
>     LL := [* gamma *] cat LL;
> end for;
Now we make the list into a chain complex.
> C := Complex(LL,0);
> C;
Basic algebra complex with terms of degree 16 down to 0
Dimensions of terms: 162 162 162 162 162 162 162 162 162 162 162 162 162 162
162 162 162
> DimensionsOfHomology(C);
[ 30, 23, 34, 32, 35, 32, 35, 42, 30, 34, 32, 33, 29, 42, 21 ]
Now we will get a random subcomplex.
> a,b := Degrees(C);
> S, mu := RandomSubcomplex(C,[2: i in [1 .. a-b+1]]);
> S;
Basic algebra complex with terms of degree 16 down to 0
Dimensions of terms: 162 155 162 162 162 154 142 162 162 148 154 162 162 152
155 152 162
> DimensionsOfHomology(S);
[ 27, 27, 34, 32, 35, 33, 48, 42, 28, 44, 38, 33, 29, 48, 24 ]
Now take the quotient.
> Q,nu := quo<C|S>;
> Q;
Basic algebra complex with terms of degree 16 down to 0
Dimensions of terms: 0 7 0 0 0 8 20 0 0 14 8 0 0 10 7 10 0
> DimensionsOfHomology(Q);
[ 7, 0, 0, 0, 6, 18, 0, 0, 12, 6, 0, 0, 8, 5, 10 ]
Now we check to see if this is a short exact sequence of chain maps.
> IsShortExactSequence(mu,nu);
true
> lll := LongExactSequenceOnHomology(mu,nu);
Basic algebra complex with terms of degree 47 down to 3
Dimensions of terms: 27 30 7 27 23 0 34 34 0 32 32 0 35 35 6 33 32 18 48 35 0
42 42 0 28 30 12 44 34 6 38 32 0 33 33 0 29 29 8 48 42 5 24 21 10
> IsExact(lll);
true
V2.28, 13 July 2023