adjoinVariables -- Extend a DG algebra by a user-chosen list of cycles to be killed

Usage:

B = adjoinVariables(A, cycleList)

B = adjoinVariables(A, cycleList, Variable => "U")
Inputs:
- A, an instance of the type DGAlgebra,
- cycleList, a list, Homogeneous cycles of A, i.e.\ elements z in A.natural with (A.diff)(z) = 0 (no check is performed). Each cycle must have the same multi-degree shape as A.Degrees.
Optional inputs:
- Variable => a string, default value null, Base name for the newly adjoined generators. Defaults to the base symbol already used by A, or "T" if A has no generators.
Outputs:
- B, an instance of the type DGAlgebra, A semifree extension of A with one new generator per entry of cycleList. The new generator for a cycle z of hom-degree n has hom-degree n + 1 and differential z.

Description

Whereas killCycles chooses representatives of a basis of the first nonzero homology of A automatically, adjoinVariables lets the user specify exactly which cycles become boundaries. This is the primitive used by acyclicClosure, killCycles, and minimalModel, but can also be called directly to build DG algebra resolutions by hand.

Variable convention. The new generators extend the existing doubly-indexed naming scheme base_(i, j): for each adjoined cycle of hom-degree n, a new generator named base_(n+1, k) is created, where k continues the 1-indexed counter already in use at hom-degree n + 1 in A. Existing generator names are preserved verbatim. Passing Variable => "U" switches the base symbol for the new generators only:

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 : z = a^2 * (gens A.natural)_0

      2
o3 = a T
        1,1

o3 : R[T   ..T   ]
        1,1   1,3

i4 : polyDifferential(A, z) == 0

o4 = true

i5 : B = adjoinVariables(A, {z})

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

o5 : DGAlgebra

i6 : gens B.natural

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

o6 : List

i7 : B' = adjoinVariables(A, {z}, Variable => "U")

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

o7 : DGAlgebra

i8 : gens B'.natural

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

o8 : List

Killing a single cycle lowers the size of the corresponding homology:

i9 : apply(3, i -> numgens prune homology(i, A))

o9 = {1, 3, 3}

o9 : List

i10 : apply(3, i -> numgens prune homology(i, B))

o10 = {1, 2, 1}

o10 : List

Over a non-c.i.\ example with a non-regular relation, one can inspect the first homology, pick a representative, and kill just that class (leaving other H_1 classes intact):

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

o11 = S

o11 : QuotientRing

i12 : AS = koszulComplexDGA S

o12 = {Ring => S                          }
       Underlying algebra => S[T   ..T   ]
                                1,1   1,4
       Differential => {a, b, c, d}

o12 : DGAlgebra

i13 : prune homology(1, AS)

o13 = cokernel | d c b a 0 0 0 0 0 0 0 0 |
               | 0 0 0 0 d c b a 0 0 0 0 |
               | 0 0 0 0 0 0 0 0 d c b a |

                             3
o13 : S-module, quotient of S

i14 : BS = adjoinVariables(AS, {a^2 * (gens AS.natural)_0})

o14 = {Ring => S                                }
       Underlying algebra => S[T   ..T   , T   ]
                                1,1   1,4   2,1
                                     2
       Differential => {a, b, c, d, a T   }
                                       1,1

o14 : DGAlgebra

i15 : prune homology(1, BS)

o15 = cokernel | d c b a 0 0 0 0 |
               | 0 0 0 0 d c b a |

                             2
o15 : S-module, quotient of S

Caveat

The package does not verify that the supplied elements are actually cycles; passing a non-cycle produces a malformed DG algebra. Use polyDifferential(A, z) == 0 to check before calling (the shorthand (A.diff)(z) applies A.diff as a ring map, which only agrees with the differential on monomials that contain at most one algebra generator and hence is not a valid cycle check for products).

Ways to use adjoinVariables:

adjoinVariables(DGAlgebra,List)

For the programmer

The object adjoinVariables 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:8086:0.

adjoinVariables -- Extend a DG algebra by a user-chosen list of cycles to be killed

Description

Caveat

See also

Ways to use adjoinVariables:

For the programmer