Image, kernel, and cokernel of DG module maps -- Building DG submodules and DG quotient modules from a DG module map

For a DG module map f : M -> N of DG modules over a common DG algebra A, the package provides three chain-level constructions:

image(DGModuleMap) — the image of f, built as a DGSubmodule of the target N. A chain map sends cycles to cycles and boundaries to boundaries, so the column span of f.natural is automatically d-closed in N.natural; no d-saturation is needed.

kernel(DGModuleMap) — the kernel of f, built as a DGSubmodule of the source M. Again chain-map-ness gives d-closure for free.

cokernel(DGModuleMap) — the cokernel of f, built as a DGQuotientModule equal to target f / image f.

These three operations fit together in the usual short exact sequence: for any f, we have rank(source f) == numgens(kernel f) + numgens(image f) and rank(target f) == numgens(image f) + numgens(cokernel f) whenever the natural modules are free.

A genuinely informative example: let R = k[x, y]/(x^2, y^2) and let KM = koszulComplexDGM R^1 be its Koszul DG module. Multiplication by x is a degree-0 endomorphism of KM because x is central in the underlying ring:

i1 : R = ZZ/101[x, y] / ideal(x^2, y^2)

o1 = R

o1 : QuotientRing

i2 : A = koszulComplexDGA R

o2 = {Ring => R                          }
      Underlying algebra => R[T   ..T   ]
                               1,1   1,2
      Differential => {x, y}

o2 : DGAlgebra

i3 : KM = koszulComplexDGM R^1

o3 = {Base ring => R                    }
      DG algebra => R[T   ..T   ]
                       1,1   1,2
                                       1
      Natural module => (R[T   ..T   ])
                            1,1   1,2
      Generator degrees => {{0, 0}}
      Differentials on gens => {0}

o3 : DGModule

i4 : mx = dgModuleMap(KM, KM, x * id_(KM.natural))

                               1
o4 = {Source => (R[T   ..T   ]) }
                    1,1   1,2
                               1
      Target => (R[T   ..T   ])
                    1,1   1,2
      Natural => | x |

o4 : DGModuleMap

i5 : isWellDefined mx

o5 = true

Since x^2 = 0 in R, the composition mx o mx is the zero map, which chain-level is the statement image mx \subseteq kernel mx. The three constructions expose this directly:

i6 : imgMx = image mx;

i7 : kerMx = kernel mx;

i8 : cokMx = cokernel mx;

i9 : all({imgMx, kerMx, cokMx}, isWellDefined)

o9 = true

i10 : numcols (inclusion imgMx).natural

o10 = 1

i11 : numcols (inclusion kerMx).natural

o11 = 1

i12 : isSubset(imgMx, kerMx)

o12 = true

The cokernel is the quotient DG module KM / x \cdot KM; at the natural level it is KM \otimes_R R/(x) = k[y]/(y^2) \otimes_k \Lambda(T_1, T_2), presented by the 1 x 1 matrix [x] per generator:

i13 : presentation cokMx.natural

o13 = | x |

                            1                    1
o13 : Matrix (R[T   ..T   ])  <-- (R[T   ..T   ])
                 1,1   1,2            1,1   1,2

The three operations are used throughout the package -- notably by homology at degree n, which computes kernel(d_n) / image(d_{n+1}) via these primitives.

Finally, each of image mx, kernel mx, cokernel mx is itself a DG module, so toComplex(DGModule) (or its DGSubmodule / DGQuotientModule variants) converts them into ordinary chain complexes one can hand to Complexes. For the cokernel in particular, the underlying complex is KM / x \cdot KM and its homology picks up the classes that become new cycles when the x-direction is killed:

i14 : CcokMx = toComplex cokMx

o14 = cokernel | x | <-- cokernel {1} | x 0 | <-- cokernel {2} | x |
                                  {1} | 0 x |      
      0                                           2
                         1

o14 : Complex

i15 : apply(0..(maxDegree cokMx), n -> prune HH_n CcokMx)

o15 = (cokernel | y x |, cokernel | y x 0 0 |, cokernel | y x |)
                                  | 0 0 y x |

o15 : Sequence

Image, kernel, and cokernel of DG module maps -- Building DG submodules and DG quotient modules from a DG module map

See also

Menu