Associated Graded Algebras To Filtered Algebras

AUTHORS:

  • Travis Scrimshaw (2014-10-08): Initial version
class sage.algebras.associated_graded.AssociatedGradedAlgebra(A, category=None)

Bases: sage.combinat.free_module.CombinatorialFreeModule

The associated graded algebra/module \operatorname{gr} A of a filtered algebra/module with basis A.

Let A be a filtered module over a commutative ring R. Let (F_i)_{i \in I} be the filtration of A, with I being a totally ordered set. Define

G_i = F_i / \sum_{j < i} F_j

for every i \in I, and then

\operatorname{gr} A = \bigoplus_{i \in I} G_i.

There are canonical projections p_i : F_i \to G_i for every i \in I. Moreover \operatorname{gr} A is naturally a graded R-module with G_i being the i-th graded component. This graded R-module is known as the associated graded module (or, for short, just graded module) of A.

Now, assume that A (endowed with the filtration (F_i)_{i \in I}) is not just a filtered R-module, but also a filtered R-algebra. Let u \in G_i and v \in G_j, and let u' \in F_i and v' \in F_j be lifts of u and v, respectively (so that u = p_i(u') and v = p_j(v')). Then, we define a multiplication * on \operatorname{gr} A (not to be mistaken for the multiplication of the original algebra A) by

u * v = p_{i+j} (u' v').

The associated graded algebra (or, for short, just graded algebra) of A is the graded algebra \operatorname{gr} A (endowed with this multiplication).

Now, assume that A is a filtered R-algebra with basis. Let (b_x)_{x \in X} be the basis of A, and consider the partition X = \bigsqcup_{i \in I} X_i of the set X, which is part of the data of a filtered algebra with basis. We know (see FilteredModulesWithBasis) that A (being a filtered R-module with basis) is canonically (when the basis is considered to be part of the data) isomorphic to \operatorname{gr} A as an R-module. Therefore the k-th graded component G_k can be identified with the span of (b_x)_{x \in X_k}, or equivalently the k-th homogeneous component of A. Suppose that u' v' = \sum_{k \leq i+j} m_k where m_k \in G_k (which has been identified with the k-th homogeneous component of A). Then u * v = m_{i+j}. We also note that the choice of identification of G_k with the k-th homogeneous component of A depends on the given basis.

The basis (b_x)_{x \in X} of A gives rise to a basis of \operatorname{gr} A. This latter basis is still indexed by the elements of X, and consists of the images of the b_x under the R-module isomorphism from A to \operatorname{gr} A. It makes \operatorname{gr} A into a graded R-algebra with basis.

In this class, the R-module isomorphism from A to \operatorname{gr} A is implemented as to_graded_conversion() and also as the default conversion from A to \operatorname{gr} A. Its inverse map is implemented as from_graded_conversion(). The projection p_i : F_i \to G_i is implemented as projection() (i).

INPUT:

  • A – a filtered module (or algebra) with basis

OUTPUT:

The associated graded module of A, if A is just a filtered R-module. The associated graded algebra of A, if A is a filtered R-algebra.

EXAMPLES:

Associated graded module of a filtered module:

sage: A = Modules(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: grA.category()
Category of graded modules with basis over Rational Field
sage: x = A.basis()[Partition([3,2,1])]
sage: grA(x)
Bbar[[3, 2, 1]]

Associated graded algebra of a filtered algebra:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: grA.category()
Category of graded algebras with basis over Rational Field
sage: x,y,z = map(lambda s: grA.algebra_generators()[s], ['x','y','z'])
sage: x
bar(U['x'])
sage: y * x + z
bar(U['x']*U['y']) + bar(U['z'])
sage: A(y) * A(x) + A(z)
U['x']*U['y']

We note that the conversion between A and grA is the canonical QQ-module isomorphism stemming from the fact that the underlying QQ-modules of A and grA are isomorphic:

sage: grA(A.an_element())
bar(U['x']^2*U['y']^2*U['z']^3) + 2*bar(U['x']) + 3*bar(U['y']) + bar(1)
sage: elt = A.an_element() + A.algebra_generators()['x'] + 2
sage: grelt = grA(elt); grelt
bar(U['x']^2*U['y']^2*U['z']^3) + 3*bar(U['x']) + 3*bar(U['y']) + 3*bar(1)
sage: A(grelt) == elt
True

Todo

The algebra A must currently be an instance of (a subclass of) CombinatorialFreeModule. This should work with any filtered algebra with a basis.

Todo

Implement a version of associated graded algebra for filtered algebras without a distinguished basis.

REFERENCES:

algebra_generators()

Return the algebra generators of self.

This assumes that the algebra generators of A provided by its algebra_generators method are homogeneous.

EXAMPLES:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: grA.algebra_generators()
Finite family {'y': bar(U['y']), 'x': bar(U['x']), 'z': bar(U['z'])}
degree_on_basis(x)

Return the degree of the basis element indexed by x.

EXAMPLES:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: all(A.degree_on_basis(x) == grA.degree_on_basis(x)
....:     for g in grA.algebra_generators() for x in g.support())
True
gen(*args, **kwds)

Return a generator of self.

EXAMPLES:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: grA.gen('x')
bar(U['x'])
one_basis()

Return the basis index of the element 1 of \operatorname{gr} A.

This assumes that the unity 1 of A belongs to F_0.

EXAMPLES:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: grA.one_basis()
1
product_on_basis(x, y)

Return the product on basis elements given by the indices x and y.

EXAMPLES:

sage: A = Algebras(QQ).WithBasis().Filtered().example()
sage: grA = A.graded_algebra()
sage: G = grA.algebra_generators()
sage: x,y,z = G['x'], G['y'], G['z']
sage: x * y # indirect doctest
bar(U['x']*U['y'])
sage: y * x
bar(U['x']*U['y'])
sage: z * y * x
bar(U['x']*U['y']*U['z'])