setDiff -- Install or replace the differential on a DG algebra

Usage:

A = setDiff(A, diffList)

A = setDiff(A, diffList, InitializeComplex => false)
Inputs:
- A, an instance of the type DGAlgebra,
- diffList, a list, A list of elements of A.natural, one per algebra generator, given in the same order as gens A.natural (which is the order of A.Degrees). The i-th entry becomes d((gens A.natural)_i) and is extended to all of A.natural by R-linearity and the Leibniz rule. Each entry must have homological degree one less than its generator.
Optional inputs:
- InitializeComplex => a Boolean value, default value true, Whether to eagerly compute all differential matrices up to maxDegree A. Defaults to true; set to false to skip the precomputation when only a low-degree fragment is needed.
- InitializeDegreeZeroHomology => a Boolean value, default value true, Whether to compute the quotient ring H_0(A) (needed by homologyAlgebra). Defaults to true; set to false to skip the Grobner-basis computation when not needed.
Outputs:
- A, an instance of the type DGAlgebra, The same A, now with its diff field populated; returned for convenience in a chained call.

Description

Because the ring A.natural does not exist until after freeDGAlgebra runs, the differential cannot be passed to the constructor and must be set afterwards with setDiff. The list diffList supplies the image of each algebra generator; Leibniz and R-linearity extend this to every element of A.natural.

i1 : R = ZZ/101[x, y, z]

o1 = R

o1 : PolynomialRing

i2 : A = freeDGAlgebra(R, {{1}, {1}, {1}, {3}})

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

o2 : DGAlgebra

i3 : gens A.natural

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

o3 : List

i4 : setDiff(A, {x, y, z, x*T_(1,2)*T_(1,3) - y*T_(1,1)*T_(1,3) + z*T_(1,1)*T_(1,2)})

o4 = {Ring => R                                                      }
      Underlying algebra => R[T   ..T   , T   ]
                               1,1   1,3   3,1
      Differential => {x, y, z, z*T   T    - y*T   T    + x*T   T   }
                                   1,1 1,2      1,1 1,3      1,2 1,3

o4 : DGAlgebra

i5 : flatten entries matrix A.diff

o5 = {x, y, z, z*T   T    - y*T   T    + x*T   T   , x, y, z}
                  1,1 1,2      1,1 1,3      1,2 1,3

o5 : List

Here d(T_(1,i)) = x_i (so the Koszul piece on T_(1,*) is installed) and d(T_(3,1)) is the Koszul-relation 2-cycle x T_(1,2) T_(1,3) - y T_(1,1) T_(1,3) + z T_(1,1) T_(1,2), turning A into a Tate-resolution fragment for R/(x, y, z). Converting to a Complex shows the installed differentials:

i6 : Acomplex = toComplex A

      1      3      3      2      3      3      1
o6 = R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R
                                                
     0      1      2      3      4      5      6

o6 : Complex

i7 : Acomplex.dd_1

o7 = | x y z |

             1      3
o7 : Matrix R  <-- R

i8 : Acomplex.dd_2

o8 = | -y -z 0  |
     | x  0  -z |
     | 0  x  y  |

             3      3
o8 : Matrix R  <-- R

Validity. The package does not check that the installed differential squares to zero; a user-supplied diffList that violates d^2 = 0 yields a malformed DG algebra with silently wrong downstream behavior. The chain-map conditions can be checked after the fact via isWellDefined(DGAlgebra).

Options. InitializeComplex controls whether setDiff eagerly builds all differential matrices up to maxDegree A (the sum of the hom-degrees of the odd-hom-degree generators). Set it to false to defer this computation when only low-degree information is needed:

i9 : Abig = freeDGAlgebra(R, {{1}, {1}, {1}, {3}})

o9 = {Ring => R                                }
      Underlying algebra => R[T   ..T   , T   ]
                               1,1   1,3   3,1
      Differential => null

o9 : DGAlgebra

i10 : setDiff(Abig, {x, y, z, x*T_(1,2)*T_(1,3) - y*T_(1,1)*T_(1,3) + z*T_(1,1)*T_(1,2)}, InitializeComplex => false)

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

o10 : DGAlgebra

InitializeDegreeZeroHomology controls whether the quotient ring H_0(A) = A_0 / image(d_1) is computed on the spot (a Grobner-basis computation, deferred to homologyAlgebra if turned off). Default: true. Turn it off if you have many hom-degree-1 generators and are not about to compute HH A as a DG algebra.

Caveat

The order of entries in diffList must match the order of generators in gens A.natural (equivalently, of A.Degrees). For constructors that adjoin generators incrementally (adjoinVariables, acyclicClosure, killCycles), the new generators come after all existing ones in this ordering.

Ways to use setDiff:

setDiff(DGAlgebra,List)
setDiff(DGModule,List) -- Install the list of generator differentials on a free DG module

For the programmer

The object setDiff 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:1137:0.

setDiff -- Install or replace the differential on a DG algebra

Description

Caveat

See also

Ways to use setDiff:

For the programmer