Macaulay2 » Documentation
Packages » DGAlgebras :: acyclicClosure
next | previous | forward | backward | up | index | toc

acyclicClosure -- Tate's construction of a semifree acyclic DG algebra extension

Description

Tate's construction. Starting from A, acyclicClosure iterates killCycles from StartDegree up through EndDegree. At each step n, a minimal set of cycle representatives of H_n(A) is computed and a new DG algebra generator is adjoined for each, placed in hom-degree n + 1 and whose differential is the chosen cycle. Adjoining follows the graded-commutative convention: generators of odd hom-degree are exterior (skew-commutative, square-zero) while generators of even hom-degree are polynomial, so the result is a free DG algebra in the sense of Tate/Gulliksen. If A is the Koszul complex on a regular sequence, no homology exists to kill and acyclicClosure returns A unchanged; otherwise new generators appear, recording the deviations of A.

Variable-naming convention. Both the existing generators of A and the newly adjoined generators use a doubly-indexed naming scheme base_(i, j), where i is the homological degree (the first entry of the multi-degree) and j is a 1-indexed counter among generators at that hom-degree. Counters continue past those already present in A. For example, if A already has three generators T_(1,1), T_(1,2), T_(1,3) in hom-degree 1 and two new hom-degree-2 cycles need killing, the output has new generators T_(2,1) and T_(2,2). The Variable option only affects the base symbol for new generators; existing names are preserved.

Over a complete intersection R = k[a, b, c]/(a^3, b^3, c^3), the Koszul complex has three nonzero hom-degree-2 cycles (one per relation) which must be killed, introducing three new polynomial generators T_(2,1), T_(2,2), T_(2,3):

i1 : R = ZZ/101[a, b, c] / ideal(a^3, b^3, c^3)

o1 = R

o1 : QuotientRing
i2 : A = koszulComplexDGA R

o2 = {Ring => R                          }
      Underlying algebra => R[T   ..T   ]
                               1,1   1,3
      Differential => {a, b, c}

o2 : DGAlgebra
i3 : gens A.natural

o3 = {T   , T   , T   }
       1,1   1,2   1,3

o3 : List
i4 : B = acyclicClosure(A, EndDegree => 2)

o4 = {Ring => R                                        }
      Underlying algebra => R[T   ..T   ]
                               1,1   2,3
                                 2       2       2
      Differential => {a, b, c, a T   , b T   , c T   }
                                   1,1     1,2     1,3

o4 : DGAlgebra
i5 : gens B.natural

o5 = {T   , T   , T   , T   , T   , T   }
       1,1   1,2   1,3   2,1   2,2   2,3

o5 : List
i6 : take(flatten entries matrix B.diff, 6)

                2       2       2
o6 = {a, b, c, a T   , b T   , c T   }
                  1,1     1,2     1,3

o6 : List

Here the new generators satisfy d(T_(2,i)) = a_i^2 T_(1,i), the cycle representatives of H_2 for each element of the regular sequence. The result is quasi-isomorphic to R/(a,b,c) in hom-degrees <= 2.

For larger EndDegree, the construction keeps going; over a c.i. no further generators appear because the Koszul-plus-polynomial DG algebra is already a resolution of the residue field (this is Tate's theorem):

i7 : B2 = acyclicClosure(A, EndDegree => 4)

o7 = {Ring => R                                        }
      Underlying algebra => R[T   ..T   ]
                               1,1   2,3
                                 2       2       2
      Differential => {a, b, c, a T   , b T   , c T   }
                                   1,1     1,2     1,3

o7 : DGAlgebra
i8 : numgens B2.natural == numgens B.natural

o8 = true

Over a non-c.i., higher deviations are nontrivial and acyclicClosure adjoins further generators at each stage. Tallying by hom-degree gives the deviation sequence of the ring (excluding hom-degree 0, where the ring itself sits):

i9 : S = QQ[x, y] / ideal(x^2, x*y, y^2)

o9 = S

o9 : QuotientRing
i10 : C = acyclicClosure(koszulComplexDGA S, EndDegree => 3)

o10 = {Ring => S                                                                                                      }
       Underlying algebra => S[T   ..T   , T   ..T   , T   ..T   , T   ..T   ]
                                1,1   1,2   2,1   2,3   3,1   3,2   4,1   4,3
       Differential => {x, y, x*T   , y*T   , y*T   , -x*T   T   , -y*T   T   , -y*T   T   , -y*T   T   , -y*T   T   }
                                 1,1     1,2     1,1      1,1 1,2      1,1 1,2      1,2 2,1      1,1 2,1      1,1 2,2

o10 : DGAlgebra
i11 : tally apply(C.Degrees, d -> first d)

o11 = Tally{1 => 2}
            2 => 3
            3 => 2
            4 => 3

o11 : Tally

The hom-degree-1 count of 2 comes from the two Koszul exterior generators (one per variable of S); hom-degree 2 has three polynomial generators killing the three relations; and hom-degrees 3 and beyond have nontrivial deviations, signaling that S is not a complete intersection. Over a complete intersection, all hom-degrees >= 3 would be empty.

To choose a different base symbol for the newly adjoined generators, use the Variable option. Existing generators of A keep their names:

i12 : D = acyclicClosure(A, EndDegree => 2, Variable => "U")

o12 = {Ring => R                                        }
       Underlying algebra => R[T   ..T   , U   ..U   ]
                                1,1   1,3   2,1   2,3
                                  2       2       2
       Differential => {a, b, c, a T   , b T   , c T   }
                                    1,1     1,2     1,3

o12 : DGAlgebra
i13 : gens D.natural

o13 = {T   , T   , T   , U   , U   , U   }
        1,1   1,2   1,3   2,1   2,2   2,3

o13 : List

Caveat

For a DG algebra A whose degree-zero part already has inhomogeneous structure (e.g. one built via freeDGAlgebra with a hand-written differential that is not square-zero), the package assumes d^2 = 0 without checking; the resulting acyclicClosure is only meaningful when this holds.

See also

Ways to use acyclicClosure:

  • acyclicClosure(DGAlgebra)
  • acyclicClosure(Ring) -- Tate's acyclic closure of the residue field, starting from the Koszul complex

For the programmer

The object acyclicClosure is a method function with options.


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