freeDGAlgebra -- Construct a free DG algebra with given generator degrees

Usage:

A = freeDGAlgebra(R, degreeList)

A = freeDGAlgebra(R, degreeList, Variable => "U")
Inputs:
- R, a ring, The base ring over which the DG algebra is defined.
- degreeList, a list, One degree per algebra generator. Each degree is itself a List of integers; the first entry is interpreted as the homological degree, and any remaining entries are internal gradings carried through to the underlying algebra.
Optional inputs:
- Variable => a string, default value "T", Either a base name (String or Symbol) or an explicit list of symbols. Defaults to "T". See below.
Outputs:
- A, an instance of the type DGAlgebra, A DG algebra over R whose A.natural is a graded-commutative polynomial ring on #degreeList generators. The differential is not set by this constructor; call setDiff on the result to install it.

Description

The output is a DGAlgebra whose underlying ring is a polynomial ring in graded-commutative generators: generators of odd homological degree are skew-commutative and square to zero (i.e.\ exterior), while generators of even homological degree are fully commutative. The resulting algebra is always free as a graded R-algebra; the current version of the package does not handle quotient DG algebras whose underlying ring is a non-polynomial quotient.

Variable-naming convention. Generators are named base_(i, j), where i is the homological degree (the first entry of the degree vector) and j is a 1-indexed counter among generators at that hom-degree. So freeDGAlgebra(R, {{1}, {1}, {1}, {3}}) produces four generators T_(1,1), T_(1,2), T_(1,3), T_(3,1). The Variable option changes the base name:

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

o1 = R

o1 : PolynomialRing

i2 : A = freeDGAlgebra(R, {{1}, {1}, {1}, {3}}, Variable => "U")

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

o2 : DGAlgebra

i3 : gens A.natural

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

o3 : List

Passing a List of symbols for Variable overrides the doubly-indexed naming entirely and uses the given names verbatim. The list length must match #degreeList:

i4 : B = freeDGAlgebra(R, {{1}, {1}, {1}}, Variable => {getSymbol "P", getSymbol "Q", getSymbol "RR"})

o4 = {Ring => R                        }
      Underlying algebra => R[P..Q, RR]
      Differential => null

o4 : DGAlgebra

i5 : gens B.natural

o5 = {P, Q, RR}

o5 : List

This is the mode used internally by adjoinVariables and acyclicClosure to preserve the identities of existing generators when extending a DG algebra.

Multi-grading. Any degree entries beyond the first are carried through as additional gradings of the underlying ring A.natural. To make the differential homogeneous with respect to both the homological and internal gradings, pair each hom-degree with the matching internal-degree of its image under setDiff. Here, T_(1,i) has degree (1,1) (hom-degree 1, internal-degree 1) matching x, y, z, and T_(3,1) has degree (3,3) matching its cubic-monomial differential:

i6 : Bmulti = freeDGAlgebra(R, {{1, 1}, {1, 1}, {1, 1}, {3, 3}})

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

o6 : DGAlgebra

i7 : degrees Bmulti.natural

o7 = {{1, 1}, {1, 1}, {1, 1}, {3, 3}}

o7 : List

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

o8 = {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

o8 : DGAlgebra

i9 : isHomogeneous Bmulti

o9 = true

Dropping the internal grading (hom-degree only) breaks homogeneity because the differential mixes different internal polynomial degrees of R:

i10 : Bhomo = freeDGAlgebra(R, {{1}, {1}, {1}, {3}})

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

o10 : DGAlgebra

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

o11 = {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

o11 : DGAlgebra

i12 : isHomogeneous Bhomo

o12 = false

The differential is set after construction (via setDiff) rather than passed to freeDGAlgebra directly: the differential's ring is A.natural, which does not exist until after the constructor runs. For common DG algebras arising in commutative algebra (Koszul complex, Tate resolution, acyclic closure, etc.) dedicated constructors are available; see koszulComplexDGA, acyclicClosure, minimalModel.

Caveat

There is currently a bug handling DG algebras that have no generators in some homological degree but some in a later homological degree; for example freeDGAlgebra(R, {{1}, {5}}) may produce incorrect behavior if no hom-degree 3 generators are adjoined first. The safer workflow is freeDGAlgebra with hom-degrees only up to what is needed, followed by adjoinVariables to extend incrementally.

Ways to use freeDGAlgebra:

freeDGAlgebra(Ring,List)

For the programmer

The object freeDGAlgebra 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:851:0.

freeDGAlgebra -- Construct a free DG algebra with given generator degrees

Description

Caveat

See also

Ways to use freeDGAlgebra:

For the programmer