Commutative Differential Graded Algebras¶
An algebra is said to be graded commutative if it is endowed with a grading and its multiplication satisfies the Koszul sign convention: \(yx = (1)^{ij} xy\) if \(x\) and \(y\) are homogeneous of degrees \(i\) and \(j\), respectively. Thus the multiplication is anticommutative for odd degree elements, commutative otherwise. Commutative differential graded algebras are graded commutative algebras endowed with a graded differential of degree 1. These algebras can be graded over the integers or they can be multigraded (i.e., graded over a finite rank free abelian group \(\ZZ^n\)); if multigraded, the total degree is used in the Koszul sign convention, and the differential must have total degree 1.
EXAMPLES:
All of these algebras may be constructed with the function
GradedCommutativeAlgebra()
. For most users, that will be the
main function of interest. See its documentation for many more
examples.
We start by constructing some graded commutative algebras. Generators have degree 1 by default:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ)
sage: x.degree()
1
sage: x^2
0
sage: y*x
x*y
sage: B.<a,b> = GradedCommutativeAlgebra(QQ, degrees = (2,3))
sage: a.degree()
2
sage: b.degree()
3
Once we have defined a graded commutative algebra, it is easy to
define a differential on it using the GCAlgebra.cdg_algebra()
method:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2))
sage: B = A.cdg_algebra({x: x*y, y: x*y})
sage: B
Commutative Differential Graded Algebra with generators ('x', 'y', 'z') in degrees (1, 1, 2) over Rational Field with differential:
x > x*y
y > x*y
z > 0
sage: B.cohomology(3)
Free module generated by {[x*z + y*z]} over Rational Field
sage: B.cohomology(4)
Free module generated by {[z^2]} over Rational Field
We can also compute algebra generators for the cohomology in a range of degrees, and in this case we compute up to degree 10:
sage: B.cohomology_generators(10)
{1: [x + y], 2: [z]}
AUTHORS:
 Miguel Marco, John Palmieri (201407): initial version

class
sage.algebras.commutative_dga.
CohomologyClass
(x)¶ Bases:
sage.structure.sage_object.SageObject
A class for representing cohomology classes.
This just has
_repr_
and_latex_
methods which put brackets around the object’s name.EXAMPLES:
sage: from sage.algebras.commutative_dga import CohomologyClass sage: CohomologyClass(3) [3] sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees = (2,3,3,1)) sage: CohomologyClass(x^2+2*y*z) [2*y*z + x^2]

representative
()¶ Return the representative of
self
.EXAMPLES:
sage: from sage.algebras.commutative_dga import CohomologyClass sage: x = CohomologyClass(sin) sage: x.representative() == sin True


class
sage.algebras.commutative_dga.
Differential
(A, im_gens)¶ Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.categories.morphism.Morphism
Differential of a commutative graded algebra.
INPUT:
A
– algebra where the differential is definedim_gens
– tuple containing the image of each generator
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2,3)) sage: B = A.cdg_algebra({x: x*y, y: x*y , z: t}) sage: B Commutative Differential Graded Algebra with generators ('x', 'y', 'z', 't') in degrees (1, 1, 2, 3) over Rational Field with differential: x > x*y y > x*y z > t t > 0 sage: B.differential()(x) x*y

coboundaries
(n)¶ The
n
th coboundary group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2)) sage: d = A.differential({z: x*z}) sage: d.coboundaries(2) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] sage: d.coboundaries(3) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [0 1] sage: d.coboundaries(1) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: []

cocycles
(n)¶ The
n
th cocycle group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2)) sage: d = A.differential({z: x*z}) sage: d.cocycles(2) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0]

cohomology
(n)¶ The
n
th cohomology group ofself
.This is a vector space over the base ring, defined as the quotient cocycles/coboundaries. The elements of the quotient are lifted to the vector space of cocycles, and this is described in terms of those lifts.
INPUT:
n
– degree
See also
EXAMPLES:
sage: A.<a,b,c,d,e> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1,1,1)) sage: d = A.differential({d: a*b, e: b*c}) sage: d.cohomology(2) Free module generated by {[c*e], [c*d  a*e], [b*e], [b*d], [a*d], [a*c]} over Rational Field
Compare to
cohomology_raw()
:sage: d.cohomology_raw(2) Vector space quotient V/W of dimension 6 over Rational Field where V: Vector space of degree 10 and dimension 8 over Rational Field Basis matrix: [ 0 1 0 0 0 0 0 0 0 0] [ 0 0 1 0 0 0 1 0 0 0] [ 0 0 0 1 0 0 0 0 0 0] [ 0 0 0 0 1 0 0 0 0 0] [ 0 0 0 0 0 1 0 0 0 0] [ 0 0 0 0 0 0 0 1 0 0] [ 0 0 0 0 0 0 0 0 1 0] [ 0 0 0 0 0 0 0 0 0 1] W: Vector space of degree 10 and dimension 2 over Rational Field Basis matrix: [0 0 0 0 0 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1]

cohomology_raw
(n)¶ The
n
th cohomology group ofself
.This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
INPUT:
n
– degree
See also
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(2,3,2,4)) sage: d = A.differential({t: x*y, x: y, z: y}) sage: d.cohomology_raw(4) Vector space quotient V/W of dimension 2 over Rational Field where V: Vector space of degree 4 and dimension 2 over Rational Field Basis matrix: [ 1 0 0 1/2] [ 0 1 2 1] W: Vector space of degree 4 and dimension 0 over Rational Field Basis matrix: []
Compare to
cohomology()
:sage: d.cohomology(4) Free module generated by {[1/2*x^2 + t], [x^2  2*x*z + z^2]} over Rational Field

differential_matrix
(n)¶ The matrix that gives the differential in degree
n
.INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(GF(5), degrees=(2, 3, 2, 4)) sage: d = A.differential({t: x*y, x: y, z: y}) sage: d.differential_matrix(4) [0 1] [2 0] [1 1] [0 2] sage: A.inject_variables() Defining x, y, z, t sage: d(t) x*y sage: d(z^2) 2*y*z sage: d(x*z) x*y + y*z sage: d(x^2) 2*x*y

class
sage.algebras.commutative_dga.
DifferentialGCAlgebra
(A, differential)¶ Bases:
sage.algebras.commutative_dga.GCAlgebra
A commutative differential graded algebra.
INPUT:
A
– a graded commutative algebra; that is, an instance ofGCAlgebra
differential
– a differential
As described in the modulelevel documentation, these are graded algebras for which oddly graded elements anticommute and evenly graded elements commute, and on which there is a graded differential of degree 1.
These algebras should be graded over the integers; multigraded algebras should be constructed using
DifferentialGCAlgebra_multigraded
instead.Note that a natural way to construct these is to use the
GradedCommutativeAlgebra()
function and theGCAlgebra.cdg_algebra()
method.EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(3, 2, 2, 3)) sage: A.cdg_algebra({x: y*z}) Commutative Differential Graded Algebra with generators ('x', 'y', 'z', 't') in degrees (3, 2, 2, 3) over Rational Field with differential: x > y*z y > 0 z > 0 t > 0
Alternatively, starting with
GradedCommutativeAlgebra()
:sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(3, 2, 2, 3)) sage: A.cdg_algebra(differential={x: y*z}) Commutative Differential Graded Algebra with generators ('x', 'y', 'z', 't') in degrees (3, 2, 2, 3) over Rational Field with differential: x > y*z y > 0 z > 0 t > 0
See the function
GradedCommutativeAlgebra()
for more examples.
class
Element
(A, rep)¶ Bases:
sage.algebras.commutative_dga.GCAlgebra.Element

differential
()¶ The differential on this element.
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees = (2, 3, 2, 4)) sage: B = A.cdg_algebra({t: x*y, x: y, z: y}) sage: B.inject_variables() Defining x, y, z, t sage: x.differential() y sage: (1/2 * x^2 + t).differential() 0

is_coboundary
()¶ Return
True
ifself
is a coboundary andFalse
otherwise.This raises an error if the element is not homogeneous.
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=(1,2,2)) sage: B = A.cdg_algebra(differential={b: a*c}) sage: x,y,z = B.gens() sage: x.is_coboundary() False sage: (x*z).is_coboundary() True sage: (x*z+x*y).is_coboundary() False sage: (x*z+y**2).is_coboundary() Traceback (most recent call last): ... ValueError: This element is not homogeneous

is_cohomologous_to
(other)¶ Return
True
ifself
is cohomologous toother
andFalse
otherwise.INPUT:
other
– another element of this algebra
EXAMPLES:
sage: A.<a,b,c,d> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1,1)) sage: B = A.cdg_algebra(differential={a:b*cc*d}) sage: w, x, y, z = B.gens() sage: (x*y).is_cohomologous_to(y*z) True sage: (x*y).is_cohomologous_to(x*z) False sage: (x*y).is_cohomologous_to(x*y) True
Two elements whose difference is not homogeneous are cohomologous if and only if they are both coboundaries:
sage: w.is_cohomologous_to(y*z) False sage: (x*yy*z).is_cohomologous_to(x*y*z) True sage: (x*y*z).is_cohomologous_to(0) # make sure 0 works True


coboundaries
(n)¶ The
n
th coboundary group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2)) sage: B = A.cdg_algebra(differential={z: x*z}) sage: B.coboundaries(2) Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: [] sage: B.coboundaries(3) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [0 1] sage: B.basis(3) [y*z, x*z]

cocycles
(n)¶ The
n
th cocycle group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2)) sage: B = A.cdg_algebra(differential={z: x*z}) sage: B.cocycles(2) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0] sage: B.basis(2) [x*y, z]

cohomology
(n)¶ The
n
th cohomology group ofself
.This is a vector space over the base ring, defined as the quotient cocycles/coboundaries. The elements of the quotient are lifted to the vector space of cocycles, and this is described in terms of those lifts.
INPUT:
n
– degree
EXAMPLES:
sage: A.<a,b,c,d,e> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1,1,1)) sage: B = A.cdg_algebra({d: a*b, e: b*c}) sage: B.cohomology(2) Free module generated by {[c*e], [c*d  a*e], [b*e], [b*d], [a*d], [a*c]} over Rational Field
Compare to
cohomology_raw()
:sage: B.cohomology_raw(2) Vector space quotient V/W of dimension 6 over Rational Field where V: Vector space of degree 10 and dimension 8 over Rational Field Basis matrix: [ 0 1 0 0 0 0 0 0 0 0] [ 0 0 1 0 0 0 1 0 0 0] [ 0 0 0 1 0 0 0 0 0 0] [ 0 0 0 0 1 0 0 0 0 0] [ 0 0 0 0 0 1 0 0 0 0] [ 0 0 0 0 0 0 0 1 0 0] [ 0 0 0 0 0 0 0 0 1 0] [ 0 0 0 0 0 0 0 0 0 1] W: Vector space of degree 10 and dimension 2 over Rational Field Basis matrix: [0 0 0 0 0 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1]

cohomology_algebra
(max_degree=3)¶ Compute a CDGA with trivial differential, that is isomorphic to the cohomology of self up to``max_degree``
INPUT:
max_degree
– integer (default: \(3\)); degree to which the result is required to be isomorphic to self’s cohomology.
EXAMPLES:
sage: A.<e1,e2,e3,e4,e5,e6,e7> = GradedCommutativeAlgebra(QQ) sage: d = A.differential({e1:e1*e6,e2:e2*e6,e3:e3*e6,e4:e5*e6,e5:e4*e6}) sage: B = A.cdg_algebra(d) sage: M = B.cohomology_algebra() sage: M Commutative Differential Graded Algebra with generators ('x0', 'x1', 'x2') in degrees (1, 1, 2) over Rational Field with differential: x0 > 0 x1 > 0 x2 > 0 sage: M.cohomology(1) Free module generated by {[x1], [x0]} over Rational Field sage: B.cohomology(1) Free module generated by {[e7], [e6]} over Rational Field sage: M.cohomology(2) Free module generated by {[x0*x1], [x2]} over Rational Field sage: B.cohomology(2) Free module generated by {[e6*e7], [e4*e5]} over Rational Field sage: M.cohomology(3) Free module generated by {[x1*x2], [x0*x2]} over Rational Field sage: B.cohomology(3) Free module generated by {[e4*e5*e7], [e4*e5*e6]} over Rational Field

cohomology_generators
(max_degree)¶ Return lifts of algebra generators for cohomology in degrees at most
max_degree
.INPUT:
max_degree
– integer
OUTPUT:
A dictionary keyed by degree, where the corresponding value is a list of cohomology generators in that degree. Actually, the elements are lifts of cohomology generators, which means that they lie in this differential graded algebra. It also means that they are only welldefined up to cohomology, not on the nose.
ALGORITHM:
Reduce a basis of the \(n\)’th cohomology modulo all the degree n products of the lower degrees cohomologys.
EXAMPLES:
sage: A.<a,x,y> = GradedCommutativeAlgebra(QQ, degrees=(1,2,2)) sage: B = A.cdg_algebra(differential={y: a*x}) sage: B.cohomology_generators(3) {1: [a], 2: [x], 3: [a*y]}
The previous example has infinitely generated cohomology: \(a y^n\) is a cohomology generator for each \(n\):
sage: B.cohomology_generators(10) {1: [a], 2: [x], 3: [a*y], 5: [a*y^2], 7: [a*y^3], 9: [a*y^4]}
In contrast, the corresponding algebra in characteristic \(p\) has finitely generated cohomology:
sage: A3.<a,x,y> = GradedCommutativeAlgebra(GF(3), degrees=(1,2,2)) sage: B3 = A3.cdg_algebra(differential={y: a*x}) sage: B3.cohomology_generators(20) {1: [a], 2: [x], 3: [a*y], 5: [a*y^2], 6: [y^3]}
This method works with both singly graded and multigraded algebras:
sage: Cs.<a,b,c,d> = GradedCommutativeAlgebra(GF(2), degrees=(1,2,2,3)) sage: Ds = Cs.cdg_algebra({a:c, b:d}) sage: Ds.cohomology_generators(10) {2: [a^2], 4: [b^2]} sage: Cm.<a,b,c,d> = GradedCommutativeAlgebra(GF(2), degrees=((1,0), (1,1), (0,2), (0,3))) sage: Dm = Cm.cdg_algebra({a:c, b:d}) sage: Dm.cohomology_generators(10) {2: [a^2], 4: [b^2]}

cohomology_raw
(n)¶ The
n
th cohomology group ofself
.This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
INPUT:
n
– degree
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees = (2,3,2,4)) sage: B = A.cdg_algebra({t: x*y, x: y, z: y}) sage: B.cohomology_raw(4) Vector space quotient V/W of dimension 2 over Rational Field where V: Vector space of degree 4 and dimension 2 over Rational Field Basis matrix: [ 1 0 0 1/2] [ 0 1 2 1] W: Vector space of degree 4 and dimension 0 over Rational Field Basis matrix: []
Compare to
cohomology()
:sage: B.cohomology(4) Free module generated by {[1/2*x^2 + t], [x^2  2*x*z + z^2]} over Rational Field

differential
(x=None)¶ The differential of
self
.This returns a map, and so it may be evaluated on elements of this algebra.
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2,1,1)) sage: B = A.cdg_algebra({y:y*z, z: y*z}) sage: d = B.differential(); d Differential of Commutative Differential Graded Algebra with generators ('x', 'y', 'z') in degrees (2, 1, 1) over Rational Field Defn: x > 0 y > y*z z > y*z sage: d(y) y*z

graded_commutative_algebra
()¶ Return the base graded commutative algebra of
self
.EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(3, 2, 2, 3)) sage: D = A.cdg_algebra({x: y*z}) sage: D.graded_commutative_algebra() == A True

minimal_model
(i=3, max_iterations=3)¶ Try to compute a map from a
i
minimal gcda that is ai
quasiisomorphism up to degreemax_degree
.INPUT:
i
– integer (default: \(3\)); degree to which the result is required to induce an isomorphism in cohomology, and the domain is required to be minimal.max_iterations
– integer (default: \(3\)); the number of iterations of the method at each degree. If the algorithm does not finish in this many iterations at each degree, an error is raised.
OUTPUT:
A morphism from a minimal Sullivan (up to degree
i
) CDGA’s to self, that induces an isomorphism in cohomology up to degreei
, and a monomorphism in degreei+1
.EXAMPLES:
sage: S.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees = (1,1,2)) sage: d = S.differential({x:x*y,y:x*y}) sage: R = S.cdg_algebra(d) sage: p = R.minimal_model() sage: T = p.domain() sage: p Commutative Differential Graded Algebra morphism: From: Commutative Differential Graded Algebra with generators ('x1_0', 'x2_0') in degrees (1, 2) over Rational Field with differential: x1_0 > 0 x2_0 > 0 To: Commutative Differential Graded Algebra with generators ('x', 'y', 'z') in degrees (1, 1, 2) over Rational Field with differential: x > x*y y > x*y z > 0 Defn: (x1_0, x2_0) > (x + y, z) sage: R.cohomology(1) Free module generated by {[x + y]} over Rational Field sage: T.cohomology(1) Free module generated by {[x1_0]} over Rational Field sage: [p(g.representative()) for g in T.cohomology(1).basis().keys()] [x + y] sage: R.cohomology(2) Free module generated by {[z]} over Rational Field sage: T.cohomology(2) Free module generated by {[x2_0]} over Rational Field sage: [p(g.representative()) for g in T.cohomology(2).basis().keys()] [z] sage: A.<e1,e2,e3,e4,e5,e6,e7> = GradedCommutativeAlgebra(QQ) sage: d = A.differential({e1:e1*e7,e2:e2*e7,e3:e3*e7, e4:e4*e7}) sage: B = A.cdg_algebra(d) sage: phi = B.minimal_model(i=3) sage: M = phi.domain() sage: M Commutative Differential Graded Algebra with generators ('x1_0', 'x1_1', 'x1_2', 'x2_0', 'x2_1', 'x2_2', 'x2_3', 'y3_0', 'y3_1', 'y3_2', 'y3_3', 'y3_4', 'y3_5', 'y3_6', 'y3_7', 'y3_8') in degrees (1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3) over Rational Field with differential: x1_0 > 0 x1_1 > 0 x1_2 > 0 x2_0 > 0 x2_1 > 0 x2_2 > 0 x2_3 > 0 y3_0 > x2_3^2 y3_1 > x2_2*x2_3 y3_2 > x2_1*x2_3 y3_3 > x2_1*x2_2 + x2_0*x2_3 y3_4 > x2_2^2 y3_5 > x2_0*x2_2 y3_6 > x2_1^2 y3_7 > x2_0*x2_1 y3_8 > x2_0^2 sage: phi Commutative Differential Graded Algebra morphism: From: Commutative Differential Graded Algebra with generators ('x1_0', 'x1_1', 'x1_2', 'x2_0', 'x2_1', 'x2_2', 'x2_3', 'y3_0', 'y3_1', 'y3_2', 'y3_3', 'y3_4', 'y3_5', 'y3_6', 'y3_7', 'y3_8') in degrees (1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3) over Rational Field with differential: x1_0 > 0 x1_1 > 0 x1_2 > 0 x2_0 > 0 x2_1 > 0 x2_2 > 0 x2_3 > 0 y3_0 > x2_3^2 y3_1 > x2_2*x2_3 y3_2 > x2_1*x2_3 y3_3 > x2_1*x2_2 + x2_0*x2_3 y3_4 > x2_2^2 y3_5 > x2_0*x2_2 y3_6 > x2_1^2 y3_7 > x2_0*x2_1 y3_8 > x2_0^2 To: Commutative Differential Graded Algebra with generators ('e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7') in degrees (1, 1, 1, 1, 1, 1, 1) over Rational Field with differential: e1 > e1*e7 e2 > e2*e7 e3 > e3*e7 e4 > e4*e7 e5 > 0 e6 > 0 e7 > 0 Defn: (x1_0, x1_1, x1_2, x2_0, x2_1, x2_2, x2_3, y3_0, y3_1, y3_2, y3_3, y3_4, y3_5, y3_6, y3_7, y3_8) > (e7, e6, e5, e2*e4, e2*e3, e1*e4, e1*e3, 0, 0, 0, 0, 0, 0, 0, 0, 0) sage: [B.cohomology(i).dimension() for i in [1..3]] [3, 7, 13] sage: [M.cohomology(i).dimension() for i in [1..3]] [3, 7, 13]
ALGORITHM:
Construct the minimal Sullivan algebra
S
by iteratively adding generators to it. Start with one closed generator of degree 1 for each element in the basis of the first cohomology of the algebra. Then proceed degree by degree. At each degree \(d\), we keep adding generators of degree \(d1\) whose differential kills the elements in the kernel of the map \(H^d(S) o H^d(self)\). Once this map is made injective, we add the needed closed generators in degree \(d\) to make it surjective.Warning
The method is not granted to finish (it can’t, since the minimal model could be infinitely generated in some degrees). The parameter
max_iterations
controls how many iterations of the method are attempted at each degree. In case they are not enough, an exception is raised. If you think that the result will be finitely generated, you can try to run it again with a higher value formax_iterations
.

quotient
(I, check=True)¶ Create the quotient of this algebra by a twosided ideal
I
.INPUT:
I
– a twosided homogeneous ideal of this algebracheck
– (default:True
) ifTrue
, check whetherI
is generated by homogeneous elements
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2,1,1)) sage: B = A.cdg_algebra({y:y*z, z: y*z}) sage: B.inject_variables() Defining x, y, z sage: I = B.ideal([x*y]) sage: C = B.quotient(I) sage: (x*y).differential() x*y*z sage: C((x*y).differential()) 0 sage: C(x*y) 0
It is checked that the differential maps the ideal into itself, to make sure that the quotient inherits a differential structure:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2,2,1)) sage: B = A.cdg_algebra({z:y}) sage: B.quotient(B.ideal(y*z)) Traceback (most recent call last): ... ValueError: The differential does not preserve the ideal sage: B.quotient(B.ideal(z)) Traceback (most recent call last): ... ValueError: The differential does not preserve the ideal

class
sage.algebras.commutative_dga.
DifferentialGCAlgebra_multigraded
(A, differential)¶ Bases:
sage.algebras.commutative_dga.DifferentialGCAlgebra
,sage.algebras.commutative_dga.GCAlgebra_multigraded
A commutative differential multigraded algebras.
INPUT:
A
– a commutative multigraded algebradifferential
– a differential
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: B = A.cdg_algebra(differential={a: c}) sage: B.basis((1,0)) [a] sage: B.basis(1, total=True) [b, a] sage: B.cohomology((1, 0)) Free module generated by {} over Rational Field sage: B.cohomology(1, total=True) Free module generated by {[b]} over Rational Field

class
Element
(A, rep)¶ Bases:
sage.algebras.commutative_dga.GCAlgebra_multigraded.Element
,sage.algebras.commutative_dga.DifferentialGCAlgebra.Element
Element class of a commutative differential multigraded algebra.

coboundaries
(n, total=False)¶ The
n
th coboundary group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degreetotal
(defaultFalse
) – ifTrue
, return the coboundaries in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: B = A.cdg_algebra(differential={a: c}) sage: B.coboundaries((0,2)) Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: B.coboundaries(2) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [0 1]

cocycles
(n, total=False)¶ The
n
th cocycle group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cocycles in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: B = A.cdg_algebra(differential={a: c}) sage: B.cocycles((0,1)) Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: B.cocycles((0,1), total=True) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0]

cohomology
(n, total=False)¶ The
n
th cohomology group of the algebra.This is a vector space over the base ring, defined as the quotient cocycles/coboundaries. The elements of the quotient are lifted to the vector space of cocycles, and this is described in terms of those lifts.
Compare to
cohomology_raw()
.INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cohomology in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: B = A.cdg_algebra(differential={a: c}) sage: B.cohomology((0,2)) Free module generated by {} over Rational Field sage: B.cohomology(1) Free module generated by {[b]} over Rational Field

cohomology_raw
(n, total=False)¶ The
n
th cohomology group of the algebra.This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
Compare to
cohomology()
.INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cohomology in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: B = A.cdg_algebra(differential={a: c}) sage: B.cohomology_raw((0,2)) Vector space quotient V/W of dimension 0 over Rational Field where V: Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] W: Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: B.cohomology_raw(1) Vector space quotient V/W of dimension 1 over Rational Field where V: Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0] W: Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: []

class
sage.algebras.commutative_dga.
Differential_multigraded
(A, im_gens)¶ Bases:
sage.algebras.commutative_dga.Differential
Differential of a commutative multigraded algebra.

coboundaries
(n, total=False)¶ The
n
th coboundary group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degreetotal
(defaultFalse
) – ifTrue
, return the coboundaries in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: d = A.differential({a: c}) sage: d.coboundaries((0,2)) Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: d.coboundaries(2) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [0 1]

cocycles
(n, total=False)¶ The
n
th cocycle group of the algebra.This is a vector space over the base field \(F\), and it is returned as a subspace of the vector space \(F^d\), where the
n
th homogeneous component has dimension \(d\).INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cocycles in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: d = A.differential({a: c}) sage: d.cocycles((0,1)) Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: d.cocycles((0,1), total=True) Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0]

cohomology
(n, total=False)¶ The
n
th cohomology group of the algebra.This is a vector space over the base ring, defined as the quotient cocycles/coboundaries. The elements of the quotient are lifted to the vector space of cocycles, and this is described in terms of those lifts.
INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cohomology in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.See also
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: d = A.differential({a: c}) sage: d.cohomology((0,2)) Free module generated by {} over Rational Field sage: d.cohomology(1) Free module generated by {[b]} over Rational Field

cohomology_raw
(n, total=False)¶ The
n
th cohomology group of the algebra.This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the cohomology in total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.See also
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: d = A.differential({a: c}) sage: d.cohomology_raw((0,2)) Vector space quotient V/W of dimension 0 over Rational Field where V: Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] W: Vector space of degree 1 and dimension 1 over Rational Field Basis matrix: [1] sage: d.cohomology_raw(1) Vector space quotient V/W of dimension 1 over Rational Field where V: Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0] W: Vector space of degree 2 and dimension 0 over Rational Field Basis matrix: []

differential_matrix_multigraded
(n, total=False)¶ The matrix that gives the differential in degree
n
.Todo
Rename this to
differential_matrix
once inheritance, overriding, and cached methods work together better. See trac ticket #17201.INPUT:
n
– degreetotal
– (default:False
) ifTrue
, return the matrix corresponding to total degreen
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: d = A.differential({a: c}) sage: d.differential_matrix_multigraded((1,0)) [1] sage: d.differential_matrix_multigraded(1, total=True) [0 0] [0 1] sage: d.differential_matrix_multigraded((1,0), total=True) [0 0] [0 1] sage: d.differential_matrix_multigraded(1) [0 0] [0 1]


class
sage.algebras.commutative_dga.
GCAlgebra
(base, R=None, I=None, names=None, degrees=None)¶ Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.rings.quotient_ring.QuotientRing_nc
A graded commutative algebra.
INPUT:
base
– the base fieldnames
– (optional) names of the generators: a list of strings or a single string with the names separated by commas. If not specified, the generators are named “x0”, “x1”, …degrees
– (optional) a tuple or list specifying the degrees of the generators; if omitted, each generator is given degree 1, and if bothnames
anddegrees
are omitted, an error is raised.R
(optional, default None) – the ring over which the algebra is defined: if this is specified, the algebra is defined to beR/I
.I
(optional, default None) – an ideal inR
. It is should include, among other relations, the squares of the generators of odd degree
As described in the modulelevel documentation, these are graded algebras for which oddly graded elements anticommute and evenly graded elements commute.
The arguments
R
andI
are primarily for use by thequotient()
method.These algebras should be graded over the integers; multigraded algebras should be constructed using
GCAlgebra_multigraded
instead.EXAMPLES:
sage: A.<a,b> = GradedCommutativeAlgebra(QQ, degrees = (2,3)) sage: a.degree() 2 sage: B = A.quotient(A.ideal(a**2*b)) sage: B Graded Commutative Algebra with generators ('a', 'b') in degrees (2, 3) with relations [a^2*b] over Rational Field sage: A.basis(7) [a^2*b] sage: B.basis(7) []
Note that the function
GradedCommutativeAlgebra()
can also be used to construct these algebras.
class
Element
(A, rep)¶ Bases:
sage.rings.quotient_ring_element.QuotientRingElement
An element of a graded commutative algebra.

basis_coefficients
(total=False)¶ Return the coefficients of this homogeneous element with respect to the basis in its degree.
For example, if this is the sum of the 0th and 2nd basis elements, return the list
[1, 0, 1]
.Raise an error if the element is not homogeneous.
INPUT:
total
– boolean (defaultFalse
); this is only used in the multigraded case, in which case ifTrue
, it returns the coefficients with respect to the basis for the total degree of this element
OUTPUT:
A list of elements of the base field.
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(1, 2, 2, 3)) sage: A.basis(3) [t, x*z, x*y] sage: (t + 3*x*y).basis_coefficients() [1, 0, 3] sage: (t + x).basis_coefficients() Traceback (most recent call last): ... ValueError: This element is not homogeneous sage: B.<c,d> = GradedCommutativeAlgebra(QQ, degrees=((2,0), (0,4))) sage: B.basis(4) [d, c^2] sage: (c^2  1/2 * d).basis_coefficients(total=True) [1/2, 1] sage: (c^2  1/2 * d).basis_coefficients() Traceback (most recent call last): ... ValueError: This element is not homogeneous

degree
(total=False)¶ The degree of this element.
If the element is not homogeneous, this returns the maximum of the degrees of its monomials.
INPUT:
total
– ignored, present for compatibility with the multigraded case
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(2,3,3,1)) sage: el = y*z+2*x*tx^2*y sage: el.degree() 7 sage: el.monomials() [x^2*y, y*z, x*t] sage: [i.degree() for i in el.monomials()] [7, 6, 3] sage: A(0).degree() Traceback (most recent call last): ... ValueError: The zero element does not have a welldefined degree

dict
()¶ A dictionary that determines the element.
The keys of this dictionary are the tuples of exponents of each monomial, and the values are the corresponding coefficients.
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(1, 2, 2, 3)) sage: dic = (x*y  5*y*z + 7*x*y^2*z^3*t).dict() sage: sorted(dic.items()) [((0, 1, 1, 0), 5), ((1, 1, 0, 0), 1), ((1, 2, 3, 1), 7)]

is_homogeneous
(total=False)¶ Return
True
ifself
is homogeneous andFalse
otherwise.INPUT:
total
– boolean (defaultFalse
); only used in the multigraded case, in which case ifTrue
, check to see ifself
is homogeneous with respect to total degree
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(2,3,3,1)) sage: el = y*z + 2*x*t  x^2*y sage: el.degree() 7 sage: el.monomials() [x^2*y, y*z, x*t] sage: [i.degree() for i in el.monomials()] [7, 6, 3] sage: el.is_homogeneous() False sage: em = x^3  5*y*z + 3/2*x*z*t sage: em.is_homogeneous() True sage: em.monomials() [x^3, y*z, x*z*t] sage: [i.degree() for i in em.monomials()] [6, 6, 6]
The element 0 is homogeneous, even though it doesn’t have a welldefined degree:
sage: A(0).is_homogeneous() True
A multigraded example:
sage: B.<c,d> = GradedCommutativeAlgebra(QQ, degrees=((2,0), (0,4))) sage: (c^2  1/2 * d).is_homogeneous() False sage: (c^2  1/2 * d).is_homogeneous(total=True) True


basis
(n)¶ Return a basis of the
n
th homogeneous component ofself
.EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, degrees=(1, 2, 2, 3)) sage: A.basis(2) [z, y] sage: A.basis(3) [t, x*z, x*y] sage: A.basis(4) [x*t, z^2, y*z, y^2] sage: A.basis(5) [z*t, y*t, x*z^2, x*y*z, x*y^2] sage: A.basis(6) [x*z*t, x*y*t, z^3, y*z^2, y^2*z, y^3]

cdg_algebra
(differential)¶ Construct a differential graded commutative algebra from
self
by specifying a differential.INPUT:
differential
– a dictionary defining a differential or a map defining a valid differential
The keys of the dictionary are generators of the algebra, and the associated values are their targets under the differential. Any generators which are not specified are assumed to have zero differential. Alternatively, the differential can be defined using the
differential()
method; see below for an example.See also
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1)) sage: B = A.cdg_algebra({a: b*c, b: a*c}) sage: B Commutative Differential Graded Algebra with generators ('a', 'b', 'c') in degrees (1, 1, 1) over Rational Field with differential: a > b*c b > a*c c > 0
Note that
differential
can also be a map:sage: d = A.differential({a: b*c, b: a*c}) sage: d Differential of Graded Commutative Algebra with generators ('a', 'b', 'c') in degrees (1, 1, 1) over Rational Field Defn: a > b*c b > a*c c > 0 sage: A.cdg_algebra(d) is B True

differential
(diff)¶ Construct a differential on
self
.INPUT:
diff
– a dictionary defining a differential
The keys of the dictionary are generators of the algebra, and the associated values are their targets under the differential. Any generators which are not specified are assumed to have zero differential.
EXAMPLES:
sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2,1,1)) sage: A.differential({y:y*z, z: y*z}) Differential of Graded Commutative Algebra with generators ('x', 'y', 'z') in degrees (2, 1, 1) over Rational Field Defn: x > 0 y > y*z z > y*z sage: B.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=(1,2,2)) sage: d = B.differential({b:a*c, c:a*c}) sage: d(b*c) a*b*c + a*c^2

quotient
(I, check=True)¶ Create the quotient of this algebra by a twosided ideal
I
.INPUT:
I
– a twosided homogeneous ideal of this algebracheck
– (default:True
) ifTrue
, check whetherI
is generated by homogeneous elements
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(GF(5), degrees=(2, 3, 2, 4)) sage: I = A.ideal([x*t+y^2, x*z  t]) sage: B = A.quotient(I) sage: B Graded Commutative Algebra with generators ('x', 'y', 'z', 't') in degrees (2, 3, 2, 4) with relations [x*t, x*z  t] over Finite Field of size 5 sage: B(x*t) 0 sage: B(x*z) t sage: A.basis(7) [y*t, y*z^2, x*y*z, x^2*y] sage: B.basis(7) [y*t, y*z^2, x^2*y]

class
sage.algebras.commutative_dga.
GCAlgebraHomset
(R, S, category=None)¶ Bases:
sage.rings.homset.RingHomset_generic
Set of morphisms between two graded commutative algebras.
Note
Homsets (and thus morphisms) have only been implemented when the base fields are the same for the domain and codomain.
EXAMPLES:
sage: A.<x,y> = GradedCommutativeAlgebra(QQ, degrees=(1,2)) sage: H = Hom(A,A) sage: H([x,y]) == H.identity() True sage: H([x,x]) == H.identity() False sage: A.<w,x> = GradedCommutativeAlgebra(QQ, degrees=(1,2)) sage: B.<y,z> = GradedCommutativeAlgebra(QQ, degrees=(1,1)) sage: H = Hom(A,B) sage: H([y,0]) Graded Commutative Algebra morphism: From: Graded Commutative Algebra with generators ('w', 'x') in degrees (1, 2) over Rational Field To: Graded Commutative Algebra with generators ('y', 'z') in degrees (1, 1) over Rational Field Defn: (w, x) > (y, 0) sage: H([y,y*z]) Graded Commutative Algebra morphism: From: Graded Commutative Algebra with generators ('w', 'x') in degrees (1, 2) over Rational Field To: Graded Commutative Algebra with generators ('y', 'z') in degrees (1, 1) over Rational Field Defn: (w, x) > (y, y*z)

identity
()¶ Construct the identity morphism of this homset.
EXAMPLES:
sage: A.<x,y> = GradedCommutativeAlgebra(QQ, degrees=(1,2)) sage: H = Hom(A,A) sage: H([x,y]) == H.identity() True sage: H([x,x]) == H.identity() False

zero
()¶ Construct the “zero” morphism of this homset: the map sending each generator to zero.
EXAMPLES:
sage: A.<x,y> = GradedCommutativeAlgebra(QQ, degrees=(1,2)) sage: B.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1)) sage: zero = Hom(A,B).zero() sage: zero(x) == zero(y) == 0 True


class
sage.algebras.commutative_dga.
GCAlgebraMorphism
(parent, im_gens, check=True)¶ Bases:
sage.rings.morphism.RingHomomorphism_im_gens
Create a morphism between two
graded commutative algebras
.INPUT:
parent
– the parent homsetim_gens
– the images, in the codomain, of the generators of the domaincheck
– boolean (default:True
); check whether the proposed map is actually an algebra map; if the domain and codomain have differentials, also check that the map respects those.
EXAMPLES:
sage: A.<x,y> = GradedCommutativeAlgebra(QQ) sage: H = Hom(A,A) sage: f = H([y,x]) sage: f Graded Commutative Algebra endomorphism of Graded Commutative Algebra with generators ('x', 'y') in degrees (1, 1) over Rational Field Defn: (x, y) > (y, x) sage: f(x*y) x*y

is_graded
(total=False)¶ Return
True
if this morphism is graded.That is, return
True
if \(f(x)\) is zero, or if \(f(x)\) is homogeneous and has the same degree as \(x\), for each generator \(x\).INPUT:
total
(optional, defaultFalse
) – ifTrue
, use the total degree to determine whether the morphism is graded (relevant only in the multigraded case)
EXAMPLES:
sage: C.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=(1,1,2)) sage: H = Hom(C,C) sage: H([a, b, a*b + 2*a]).is_graded() False sage: H([a, b, a*b]).is_graded() True sage: A.<w,x> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (1,0))) sage: B.<y,z> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0,1))) sage: H = Hom(A,B) sage: H([y,0]).is_graded() True sage: H([z,z]).is_graded() False sage: H([z,z]).is_graded(total=True) True

class
sage.algebras.commutative_dga.
GCAlgebra_multigraded
(base, degrees, names=None, R=None, I=None)¶ Bases:
sage.algebras.commutative_dga.GCAlgebra
A multigraded commutative algebra.
INPUT:
base
– the base fielddegrees
– a tuple or list specifying the degrees of the generatorsnames
– (optional) names of the generators: a list of strings or a single string with the names separated by commas; if not specified, the generators are namedx0
,x1
, …R
– (optional) the ring over which the algebra is definedI
– (optional) an ideal inR
; it should include, among other relations, the squares of the generators of odd degree
When defining such an algebra, each entry of
degrees
should be a list, tuple, or element of an additive (free) abelian group. Regardless of how the user specifies the degrees, Sage converts them to group elements.The arguments
R
andI
are primarily for use by theGCAlgebra.quotient()
method.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0,1), (1,1))) sage: A Graded Commutative Algebra with generators ('a', 'b', 'c') in degrees ((1, 0), (0, 1), (1, 1)) over Rational Field sage: a**2 0 sage: c.degree(total=True) 2 sage: c**2 c^2 sage: c.degree() (1, 1)
Although the degree of
c
was defined using a Python tuple, it is returned as an element of an additive abelian group, and so it can be manipulated via arithmetic operations:sage: type(c.degree()) <class 'sage.groups.additive_abelian.additive_abelian_group.AdditiveAbelianGroup_fixed_gens_with_category.element_class'> sage: 2 * c.degree() (2, 2) sage: (a*b).degree() == a.degree() + b.degree() True
The
basis()
method and theElement.degree()
method both accept the boolean keywordtotal
. IfTrue
, use the total degree:sage: A.basis(2, total=True) [a*b, c] sage: c.degree(total=True) 2

class
Element
(A, rep)¶ Bases:
sage.algebras.commutative_dga.GCAlgebra.Element

degree
(total=False)¶ Return the degree of this element.
INPUT:
total
– ifTrue
, return the total degree, an integer; otherwise, return the degree as an element of an additive free abelian group
If not requesting the total degree, raise an error if the element is not homogeneous.
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(GF(2), degrees=((1,0), (0,1), (1,1))) sage: (a**2*b).degree() (2, 1) sage: (a**2*b).degree(total=True) 3 sage: (a**2*b + c).degree() Traceback (most recent call last): ... ValueError: This element is not homogeneous sage: (a**2*b + c).degree(total=True) 3 sage: A(0).degree() Traceback (most recent call last): ... ValueError: The zero element does not have a welldefined degree


basis
(n, total=False)¶ Basis in degree
n
.n
– degree or integertotal
(optional, default False) – if True, return the basis in total degreen
.
If
n
is an integer rather than a multiindex, then the total degree is used in that case as well.EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(GF(2), degrees=((1,0), (0,1), (1,1))) sage: A.basis((1,1)) [c, a*b] sage: A.basis(2, total=True) [c, b^2, a*b, a^2]
Since 2 is a not a multiindex, we don’t need to specify
total=True
:sage: A.basis(2) [c, b^2, a*b, a^2]
If
total==True
, thenn
can still be a tuple, list, etc., and its total degree is used instead:sage: A.basis((1,1), total=True) [c, b^2, a*b, a^2]

cdg_algebra
(differential)¶ Construct a differential graded commutative algebra from
self
by specifying a differential.INPUT:
differential
– a dictionary defining a differential or a map defining a valid differential
The keys of the dictionary are generators of the algebra, and the associated values are their targets under the differential. Any generators which are not specified are assumed to have zero differential. Alternatively, the differential can be defined using the
differential()
method; see below for an example.See also
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: A.cdg_algebra({a: c}) Commutative Differential Graded Algebra with generators ('a', 'b', 'c') in degrees ((1, 0), (0, 1), (0, 2)) over Rational Field with differential: a > c b > 0 c > 0 sage: d = A.differential({a: c}) sage: A.cdg_algebra(d) Commutative Differential Graded Algebra with generators ('a', 'b', 'c') in degrees ((1, 0), (0, 1), (0, 2)) over Rational Field with differential: a > c b > 0 c > 0

differential
(diff)¶ Construct a differential on
self
.INPUT:
diff
– a dictionary defining a differential
The keys of the dictionary are generators of the algebra, and the associated values are their targets under the differential. Any generators which are not specified are assumed to have zero differential.
EXAMPLES:
sage: A.<a,b,c> = GradedCommutativeAlgebra(QQ, degrees=((1,0), (0, 1), (0,2))) sage: A.differential({a: c}) Differential of Graded Commutative Algebra with generators ('a', 'b', 'c') in degrees ((1, 0), (0, 1), (0, 2)) over Rational Field Defn: a > c b > 0 c > 0

quotient
(I, check=True)¶ Create the quotient of this algebra by a twosided ideal
I
.INPUT:
I
– a twosided homogeneous ideal of this algebracheck
– (default:True
) ifTrue
, check whetherI
is generated by homogeneous elements
EXAMPLES:
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(GF(5), degrees=(2, 3, 2, 4)) sage: I = A.ideal([x*t+y^2, x*z  t]) sage: B = A.quotient(I) sage: B Graded Commutative Algebra with generators ('x', 'y', 'z', 't') in degrees (2, 3, 2, 4) with relations [x*t, x*z  t] over Finite Field of size 5 sage: B(x*t) 0 sage: B(x*z) t sage: A.basis(7) [y*t, y*z^2, x*y*z, x^2*y] sage: B.basis(7) [y*t, y*z^2, x^2*y]

sage.algebras.commutative_dga.
GradedCommutativeAlgebra
(ring, names=None, degrees=None, relations=None)¶ A graded commutative algebra.
INPUT:
There are two ways to call this. The first way defines a free graded commutative algebra:
ring
– the base field over which to worknames
– names of the generators. You may also use Sage’sA.<x,y,...> = ...
syntax to define the names. If no names are specified, the generators are namedx0
,x1
, …degrees
– degrees of the generators; if this is omitted, the degree of each generator is 1, and if bothnames
anddegrees
are omitted, an error is raised
Once such an algebra has been defined, one can use its associated methods to take a quotient, impose a differential, etc. See the examples below.
The second way takes a graded commutative algebra and imposes relations:
ring
– a graded commutative algebrarelations
– a list or tuple of elements ofring
EXAMPLES:
Defining a graded commutative algebra:
sage: GradedCommutativeAlgebra(QQ, 'x, y, z') Graded Commutative Algebra with generators ('x', 'y', 'z') in degrees (1, 1, 1) over Rational Field sage: GradedCommutativeAlgebra(QQ, degrees=(2, 3, 4)) Graded Commutative Algebra with generators ('x0', 'x1', 'x2') in degrees (2, 3, 4) over Rational Field
As usual in Sage, the
A.<...>
notation defines both the algebra and the generator names:sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(1, 2, 1)) sage: x^2 0 sage: z*x # Odd classes anticommute. x*z sage: z*y # y is central since it is in degree 2. y*z sage: (x*y**3*z).degree() 8 sage: A.basis(3) # basis of homogeneous degree 3 elements [y*z, x*y]
Defining a quotient:
sage: I = A.ideal(x*y) sage: AQ = A.quotient(I) sage: AQ Graded Commutative Algebra with generators ('x', 'y', 'z') in degrees (1, 2, 1) with relations [x*y] over Rational Field sage: AQ.basis(3) [y*z]
Note that
AQ
has no specified differential. This is reflected in its print representation:AQ
is described as a “graded commutative algebra” – the word “differential” is missing. Also, it has no defaultdifferential
:sage: AQ.differential() # py2 Traceback (most recent call last): ... TypeError: differential() takes exactly 2 arguments (1 given) sage: AQ.differential() # py3 Traceback (most recent call last): ... TypeError: differential() missing 1 required positional argument: 'diff'
Now we add a differential to
AQ
:sage: B = AQ.cdg_algebra({y:y*z}) sage: B Commutative Differential Graded Algebra with generators ('x', 'y', 'z') in degrees (1, 2, 1) with relations [x*y] over Rational Field with differential: x > 0 y > y*z z > 0 sage: B.differential() Differential of Commutative Differential Graded Algebra with generators ('x', 'y', 'z') in degrees (1, 2, 1) with relations [x*y] over Rational Field Defn: x > 0 y > y*z z > 0 sage: B.cohomology(1) Free module generated by {[z], [x]} over Rational Field sage: B.cohomology(2) Free module generated by {[x*z]} over Rational Field
We compute algebra generators for cohomology in a range of degrees. This cohomology algebra appears to be finitely generated:
sage: B.cohomology_generators(15) {1: [z, x]}
We can construct multigraded rings as well. We work in characteristic 2 for a change, so the algebras here are honestly commutative:
sage: C.<a,b,c,d> = GradedCommutativeAlgebra(GF(2), degrees=((1,0), (1,1), (0,2), (0,3))) sage: D = C.cdg_algebra(differential={a:c, b:d}) sage: D Commutative Differential Graded Algebra with generators ('a', 'b', 'c', 'd') in degrees ((1, 0), (1, 1), (0, 2), (0, 3)) over Finite Field of size 2 with differential: a > c b > d c > 0 d > 0
We can examine
D
using both total degrees and multidegrees. Use tuples, lists, vectors, or elements of additive abelian groups to specify degrees:sage: D.basis(3) # basis in total degree 3 [d, a*c, a*b, a^3] sage: D.basis((1,2)) # basis in degree (1,2) [a*c] sage: D.basis([1,2]) [a*c] sage: D.basis(vector([1,2])) [a*c] sage: G = AdditiveAbelianGroup([0,0]); G Additive abelian group isomorphic to Z + Z sage: D.basis(G(vector([1,2]))) [a*c]
At this point,
a
, for example, is an element ofC
. We can redefine it so that it is instead an element ofD
in several ways, for instance usinggens()
method:sage: a, b, c, d = D.gens() sage: a.differential() c
Or the
inject_variables()
method:sage: D.inject_variables() Defining a, b, c, d sage: (a*b).differential() b*c + a*d sage: (a*b*c**2).degree() (2, 5)
Degrees are returned as elements of additive abelian groups:
sage: (a*b*c**2).degree() in G True sage: (a*b*c**2).degree(total=True) # total degree 7 sage: D.cohomology(4) Free module generated by {[b^2], [a^4]} over Finite Field of size 2 sage: D.cohomology((2,2)) Free module generated by {[b^2]} over Finite Field of size 2

sage.algebras.commutative_dga.
exterior_algebra_basis
(n, degrees)¶ Basis of an exterior algebra in degree
n
, where the generators are in degreesdegrees
.INPUT:
n
 integerdegrees
 iterable of integers
Return list of lists, each list representing exponents for the corresponding generators. (So each list consists of 0’s and 1’s.)
EXAMPLES:
sage: from sage.algebras.commutative_dga import exterior_algebra_basis sage: exterior_algebra_basis(1, (1,3,1)) [[0, 0, 1], [1, 0, 0]] sage: exterior_algebra_basis(4, (1,3,1)) [[0, 1, 1], [1, 1, 0]] sage: exterior_algebra_basis(10, (1,5,1,1)) []

sage.algebras.commutative_dga.
total_degree
(deg)¶ Total degree of
deg
.INPUT:
deg
 an element of a free abelian group.
In fact,
deg
could be an integer, a Python int, a list, a tuple, a vector, etc. This function returns the sum of the components ofdeg
.EXAMPLES:
sage: from sage.algebras.commutative_dga import total_degree sage: total_degree(12) 12 sage: total_degree(range(5)) 10 sage: total_degree(vector(range(5))) 10 sage: G = AdditiveAbelianGroup((0,0)) sage: x = G.gen(0); y = G.gen(1) sage: 3*x+4*y (3, 4) sage: total_degree(3*x+4*y) 7