An algebra is said to be graded commutative if it is endowed with a
grading and its multiplication satisfies the Koszul sign convention:
if
and
are homogeneous of degrees
and
, 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 multi-graded (i.e., graded over a finite rank
free abelian group
); if multi-graded, 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
AUTHORS:
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]
Return the representative of self.
EXAMPLES:
sage: from sage.algebras.commutative_dga import CohomologyClass
sage: x = CohomologyClass(sin)
sage: x.representative() == sin
True
Bases: sage.structure.unique_representation.UniqueRepresentation, sage.categories.morphism.Morphism
Differential of a commutative graded algebra.
INPUT:
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
The n-th coboundary group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
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]
The n-th cocycle group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
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]
The n-th cohomology group of self.
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:
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]
The n-th cohomology group of self.
This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
INPUT:
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
The matrix that gives the differential in degree n.
INPUT:
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
Bases: sage.algebras.commutative_dga.GCAlgebra
A commutative differential graded algebra.
INPUT:
As described in the module-level 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; multi-graded algebras should be constructed using DifferentialGCAlgebra_multigraded instead.
Note that a natural way to construct these is to use the GradedCommutativeAlgebra() function and the GCAlgebra.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.
Bases: sage.algebras.commutative_dga.GCAlgebra.Element
Initialize self.
INPUT:
EXAMPLES:
sage: B.<x,y> = GradedCommutativeAlgebra(QQ, degrees=(2, 2))
sage: a = B({(1,1): -3, (2,5): 1/2})
sage: a
1/2*x^2*y^5 - 3*x*y
sage: TestSuite(a).run()
sage: b = x^2*y^3+2
sage: b
x^2*y^3 + 2
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
Return True if self is a coboundary and False 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
Return True if self is cohomologous to other and False otherwise.
INPUT:
EXAMPLES:
sage: A.<a,b,c,d> = GradedCommutativeAlgebra(QQ, degrees=(1,1,1,1))
sage: B = A.cdg_algebra(differential={a:b*c-c*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*y-y*z).is_cohomologous_to(x*y*z)
True
sage: (x*y*z).is_cohomologous_to(0) # make sure 0 works
True
The n-th coboundary group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
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]
The n-th cocycle group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
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]
The n-th cohomology group of self.
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:
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]
The n-th cohomology group of self.
This is a vector space over the base ring, and it is returned as the quotient cocycles/coboundaries.
INPUT:
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
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
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
Create the quotient of this algebra by a two-sided ideal I.
INPUT:
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
Bases: sage.algebras.commutative_dga.DifferentialGCAlgebra, sage.algebras.commutative_dga.GCAlgebra_multigraded
A commutative differential multi-graded algebras.
INPUT:
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
Bases: sage.algebras.commutative_dga.GCAlgebra_multigraded.Element, sage.algebras.commutative_dga.DifferentialGCAlgebra.Element
Element class of a commutative differential multi-graded algebra.
The n-th coboundary group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
If n is an integer rather than a multi-index, 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]
The n-th cocycle group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
If n is an integer rather than a multi-index, 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]
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:
If n is an integer rather than a multi-index, 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
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:
If n is an integer rather than a multi-index, 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:
[]
Bases: sage.algebras.commutative_dga.Differential
Differential of a commutative multigraded algebra.
The n-th coboundary group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
If n is an integer rather than a multi-index, 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]
The n-th cocycle group of the algebra.
This is a vector space over the base field , and it is
returned as a subspace of the vector space
, where the
n-th homogeneous component has dimension
.
INPUT:
If n is an integer rather than a multi-index, 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]
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:
If n is an integer rather than a multi-index, 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
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:
If n is an integer rather than a multi-index, 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:
[]
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:
If n is an integer rather than a multi-index, 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]
Bases: sage.structure.unique_representation.UniqueRepresentation, sage.rings.quotient_ring.QuotientRing_nc
A graded commutative algebra.
INPUT:
As described in the module-level documentation, these are graded algebras for which oddly graded elements anticommute and evenly graded elements commute.
The arguments R and I are primarily for use by the quotient() method.
These algebras should be graded over the integers; multi-graded 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.
Bases: sage.rings.quotient_ring_element.QuotientRingElement
An element of a graded commutative algebra.
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.
OUTPUT:
A list of integers.
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
The degree of this element.
If the element is not homogeneous, this returns the maximum of the degrees of its monomials.
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: A(0).degree()
Traceback (most recent call last):
...
ValueError: The zero element does not have a well-defined degree
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)]
Return True if self is homogenous and False otherwise.
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 well-defined degree:
sage: A(0).is_homogeneous()
True
Return a basis of the n-th homogeneous component of self.
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]
Construct a differential graded commutative algebra from self by specifying a differential.
INPUT:
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
Construct a differential on self.
INPUT:
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
Create the quotient of this algebra by a two-sided ideal I.
INPUT:
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]
Bases: sage.algebras.commutative_dga.GCAlgebra
A multi-graded commutative algebra.
INPUT:
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 and I are primarily for use by the GCAlgebra.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 the Element.degree() method both accept the boolean keyword total. If True, use the total degree:
sage: A.basis(2, total=True)
[a*b, c]
sage: c.degree(total=True)
2
Bases: sage.algebras.commutative_dga.GCAlgebra.Element
Initialize self.
INPUT:
EXAMPLES:
sage: B.<x,y> = GradedCommutativeAlgebra(QQ, degrees=(2, 2))
sage: a = B({(1,1): -3, (2,5): 1/2})
sage: a
1/2*x^2*y^5 - 3*x*y
sage: TestSuite(a).run()
sage: b = x^2*y^3+2
sage: b
x^2*y^3 + 2
Return the degree of this element.
INPUT:
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 well-defined degree
Basis in degree n.
If n is an integer rather than a multi-index, 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 multi-index, we don’t need to specify total=True:
sage: A.basis(2)
[c, b^2, a*b, a^2]
If total==True, then n 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]
Construct a differential graded commutative algebra from self by specifying a differential.
INPUT:
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
Construct a differential on self.
INPUT:
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
Create the quotient of this algebra by a two-sided ideal I.
INPUT:
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]
A graded commutative algebra.
INPUT:
There are two ways to call this. The first way defines a free graded commutative algebra:
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:
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 default differential:
sage: AQ.differential()
Traceback (most recent call last):
...
TypeError: differential() takes exactly 2 arguments (1 given)
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 can construct multi-graded 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 of C. We can redefine it so that it is instead an element of D in several ways, for instance using gens() 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
TESTS:
We need to specify either name or degrees:
sage: GradedCommutativeAlgebra(QQ)
Traceback (most recent call last):
...
ValueError: You must specify names or degrees
Basis of an exterior algebra in degree n, where the generators are in degrees degrees.
INPUT:
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))
[]
Total degree of deg.
INPUT:
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 of deg.
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