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

Function: acyclicClosure
Usage:

A = acyclicClosure R

A = acyclicClosure(R, EndDegree => n)
Inputs:
- R, a ring, A local or graded ring (in practice, a quotient of a polynomial ring by a homogeneous ideal).
Optional inputs:
- EndDegree => ..., default value 3, Option to specify the degree to stop computing the acyclic closure
- StartDegree => ..., default value 1, Option to specify the degree to start computing the acyclic closure.
- Variable => ..., default value null, Option to name the DG algebra generators adjoined during acyclic closure
Outputs:
- A, an instance of the type DGAlgebra, A semifree DG algebra over R whose degree-zero homology is R/m = R_0 (the residue field, or more generally R/ ideal(Ring) R) and whose positive homology is killed through hom-degree EndDegree.

Description

This form is shorthand for acyclicClosure(koszulComplexDGA R, ...): the Koszul complex on a chosen generating set of the maximal/irrelevant ideal is used as the starting DG algebra, and acyclicClosure(DGAlgebra) iteratively adjoins new generators to kill homology up to EndDegree. The output is a truncation of Avramov's acyclic closure of R over itself -- equivalently, a free DG algebra resolution of the residue field in hom-degrees 0 through EndDegree.

Variable convention. The hom-degree-1 exterior generators come from koszulComplexDGA and are named T_(1,j), one for each generator of the maximal/irrelevant ideal. Higher generators (adjoined by killCycles at each stage) are named T_(n,j), with n the homological degree and j a 1-indexed counter. Generators of odd hom-degree are exterior; generators of even hom-degree are polynomial. Pass Variable => "S" (or any string/symbol) to rename the base.

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

o1 = R

o1 : QuotientRing

i2 : A = acyclicClosure(R, EndDegree => 3)

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

o2 : DGAlgebra

i3 : tally apply(A.Degrees, d -> first d)

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

o3 : Tally

i4 : take(flatten entries matrix A.diff, numgens A.natural)

                   2       2       3        2
o4 = {a, b, c, d, a T   , b T   , c T    - d T   }
                     1,1     1,2     1,3      1,4

o4 : List

Four hom-degree-1 exterior generators T_(1,1), ..., T_(1,4) (one per variable of R) and three hom-degree-2 polynomial generators (one for each defining relation, since R is a complete intersection of codimension 3). In the resulting DG algebra the residue field has been resolved through hom-degree 3.

For a complete intersection, the Koszul complex already has zero higher homology beyond what the Tate polynomial closure kills at hom-degree 2, so the number of generators stabilizes quickly:

i5 : S = QQ[x, y, z] / ideal(x^2, y^2, z^2)

o5 = S

o5 : QuotientRing

i6 : C = acyclicClosure(S, EndDegree => 4)

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

o6 : DGAlgebra

i7 : tally apply(C.Degrees, d -> first d)

o7 = Tally{1 => 3}
           2 => 3

o7 : Tally

For a non-c.i., further deviations appear:

i8 : T = QQ[x, y] / ideal(x^2, x*y, y^2)

o8 = T

o8 : QuotientRing

i9 : D = acyclicClosure(T, EndDegree => 3)
warning: clearing value of symbol T to allow access to subscripted variables based on it
       : debug with expression   debug 6944   or with command line option   --debug 6944

o9 = {Ring => T                                                                                                      }
      Underlying algebra => T[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

o9 : DGAlgebra

i10 : tally apply(D.Degrees, d -> first d)

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

o10 : Tally

Ways to use this method:

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

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

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

Description

See also

Ways to use this method: