cokernel(DGModuleMap) -- Cokernel of a DG module map as a DG quotient module of its target

Function: cokernel
Usage:

Q = cokernel f
Inputs:
- f, an instance of the type DGModuleMap, A morphism M -> N of DG modules over a common DG algebra.
Outputs:
- Q, an instance of the type DGQuotientModule, The DG quotient module N / image(f) with the induced differential.

Description

Equivalently, this is dgQuotientModule(target f, image f). The coker spelling is an alias for cokernel and invokes the same method.

A nontrivial example: over R = k[x, y]/(x^2, y^2), multiplication by x on the Koszul DG module KM has cokernel equal to KM / x \cdot KM, which at the natural level is KM \otimes_R R/(x) -- the base change of KM mod x:

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 : Q = cokernel mx

o5 = DGQuotientModule Q = M / S
     Q.natural = cokernel | x |
     Degrees   = {{0, 0}}

o5 : DGQuotientModule

i6 : isWellDefined Q

o6 = true

i7 : ambient Q === KM

o7 = true

i8 : presentation Q.natural

o8 = | x |

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

The induced differential on Q is well-defined because mx commutes with the differential, and it can be realized as an ordinary chain complex via toComplex(DGQuotientModule):

i9 : C = toComplex Q

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

o9 : Complex

i10 : apply(0..(maxDegree Q), n -> prune HH_n C)

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

o10 : Sequence

For a DG submodule inclusion S \hookrightarrow M, the cokernel is exactly the DG quotient module M / S:

i11 : Sfull = dgSubmodule(KM, id_(KM.natural));

i12 : isZero cokernel (inclusion Sfull)

o12 = true

Ways to use this method:

cokernel(DGModuleMap) -- Cokernel of a DG module map as a DG quotient module of its target

The source of this document is in /build/reproducible-path/macaulay2-1.26.05+ds/M2/Macaulay2/packages/DGAlgebras/doc.m2:4119:0.

cokernel(DGModuleMap) -- Cokernel of a DG module map as a DG quotient module of its target

Description

See also

Ways to use this method: