dgComplex -- Package a DG algebra or DG module as a Complex of free base-ring modules

Usage:

C = dgComplex A

C = dgComplex M
Inputs:
- A, an instance of the type DGAlgebra,
- M, an instance of the type DGModule,
Outputs:
- C, a complex, A Complex of free A.ring-modules whose i-th module is A_i (resp.\ M_i) and whose differential is polyDifferential (resp.\ moduleDifferential).

Description

dgComplex assembles the per-degree differentials of a DG algebra or DG module into a single Complex object. The result is cached on the input; calling dgComplex again returns exactly the same complex, and invalidateDGAlgebraCache clears the cache so that the next call rebuilds the complex.

i1 : R = QQ[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 : C1 = dgComplex A

      1      2      1
o3 = R  <-- R  <-- R
                    
     0      1      2

o3 : Complex

i4 : C2 = dgComplex A

      1      2      1
o4 = R  <-- R  <-- R
                    
     0      1      2

o4 : Complex

i5 : assert(C1 === C2)

i6 : invalidateDGAlgebraCache A

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

o6 : DGAlgebra

i7 : assert(not A.cache#?(symbol dgComplex))

i8 : C3 = dgComplex A

      1      2      1
o8 = R  <-- R  <-- R
                    
     0      1      2

o8 : Complex

i9 : assert(instance(C3, Complex))

When maxDegree is infinite -- for example on the acyclic closure of a non-regular ring -- dgComplex truncates at a canonical finite bound so that a Complex is always produced.

i10 : R = QQ[x, y] / ideal(x^2, y^2)

o10 = R

o10 : QuotientRing

i11 : A = acyclicClosure(R, EndDegree => 2)

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

o11 : DGAlgebra

i12 : assert(instance(dgComplex A, Complex))

The DG module form is parallel: it builds the complex whose terms are M_i and whose differentials are the maps returned by moduleDifferential.

i13 : R = QQ[x, y] / ideal(x^2, y^2)

o13 = R

o13 : QuotientRing

i14 : KM = koszulComplexDGM R^1

o14 = {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}

o14 : DGModule

i15 : D1 = dgComplex KM

       1      2      1
o15 = R  <-- R  <-- R
                     
      0      1      2

o15 : Complex

i16 : D2 = dgComplex KM

       1      2      1
o16 = R  <-- R  <-- R
                     
      0      1      2

o16 : Complex

i17 : assert(D1 === D2)

Ways to use dgComplex:

dgComplex(DGAlgebra)
dgComplex(DGModule)

For the programmer

The object dgComplex is a method function.

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

dgComplex -- Package a DG algebra or DG module as a Complex of free base-ring modules

Description

See also

Ways to use dgComplex:

For the programmer