Associated Graded Algebras To Filtered Algebras - Algebras

Skip to content
Back to top
View this page
Edit this page

# Associated Graded Algebras To Filtered Algebras

AUTHORS:

- Travis Scrimshaw (2014-10-08): Initial version

class sage.algebras.associated_graded.AssociatedGradedAlgebra(A, category=None)

  Bases: `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

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

  Python

      >>> from sage.all import *
      >>> A = Modules(QQ).WithBasis().Filtered().example()
      >>> grA = A.graded_algebra()
      >>> grA.category()
      Category of graded vector spaces with basis over Rational Field
      >>> x = A.basis()[Partition([Integer(3),Integer(2),Integer(1)])]
      >>> grA(x)
      Bbar[[3, 2, 1]]

  Associated graded algebra of a filtered algebra:

  Sage

      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 = [grA.algebra_generators()[s] for s in ['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']

  [Python]

      >>> from sage.all import *
      >>> A = Algebras(QQ).WithBasis().Filtered().example()
      >>> grA = A.graded_algebra()
      >>> grA.category()
      Category of graded algebras with basis over Rational Field
      >>> x,y,z = [grA.algebra_generators()[s] for s in ['x','y','z']]
      >>> x
      bar(U['x'])
      >>> y * x + z
      bar(U['x']*U['y']) + bar(U['z'])
      >>> 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

      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

  Python

      >>> from sage.all import *
      >>> grA(A.an_element())
      bar(U['x']^2*U['y']^2*U['z']^3) + 2*bar(U['x']) + 3*bar(U['y']) + bar(1)
      >>> elt = A.an_element() + A.algebra_generators()['x'] + Integer(2)
      >>> 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)
      >>> 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:

  - Wikipedia article Filtered_algebra#Associated_graded_algebra

  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

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

    Python

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

  degree_on_basis(x)

    Return the degree of the basis element indexed by `x`.

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> A = Algebras(QQ).WithBasis().Filtered().example()
        >>> grA = A.graded_algebra()
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> A = Algebras(QQ).WithBasis().Filtered().example()
        >>> grA = A.graded_algebra()
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> A = Algebras(QQ).WithBasis().Filtered().example()
        >>> grA = A.graded_algebra()
        >>> grA.one_basis()
        1

  product_on_basis(x, y)

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

    EXAMPLES:

    Sage

        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'])

    Python

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