Graded algebras with basis - Category Framework

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

# Graded algebras with basis

class sage.categories.graded_algebras_with_basis.GradedAlgebrasWithBasis(base_category)

  Bases: `GradedModulesCategory`

  The category of graded algebras with a distinguished basis.

  EXAMPLES:

  Sage

      sage: C = GradedAlgebrasWithBasis(ZZ); C
      Category of graded algebras with basis over Integer Ring
      sage: sorted(C.super_categories(), key=str)
      [Category of filtered algebras with basis over Integer Ring,
       Category of graded algebras over Integer Ring,
       Category of graded modules with basis over Integer Ring]

  Python

      >>> from sage.all import *
      >>> C = GradedAlgebrasWithBasis(ZZ); C
      Category of graded algebras with basis over Integer Ring
      >>> sorted(C.super_categories(), key=str)
      [Category of filtered algebras with basis over Integer Ring,
       Category of graded algebras over Integer Ring,
       Category of graded modules with basis over Integer Ring]

  class ElementMethods

    Bases: `object`

  class FiniteDimensional(base_category)

    Bases: `CategoryWithAxiom_over_base_ring`

    class ParentMethods

      Bases: `object`

      top_degree()

        Return the top degree of the finite dimensional graded algebra.

        EXAMPLES:

        Sage

            sage: ch = matroids.Uniform(4,6).chow_ring(QQ, False)
            sage: ch.top_degree()
            3
            sage: ch = matroids.Wheel(3).chow_ring(QQ, True, 'atom-free')
            sage: ch.top_degree()
            3

        Python

            >>> from sage.all import *
            >>> ch = matroids.Uniform(Integer(4),Integer(6)).chow_ring(QQ, False)
            >>> ch.top_degree()
            3
            >>> ch = matroids.Wheel(Integer(3)).chow_ring(QQ, True, 'atom-free')
            >>> ch.top_degree()
            3

  class ParentMethods

    Bases: `object`

    completion()

      alias of `formal_series_ring()`.

    formal_series_ring()

      Return the completion of all formal linear combinations of `self` with finite linear combinations in each homogeneous degree (computed lazily).

      EXAMPLES:

      Sage

          sage: # needs sage.combinat sage.modules
          sage: NCSF = NonCommutativeSymmetricFunctions(QQ)
          sage: S = NCSF.Complete()
          sage: L = S.formal_series_ring()
          sage: L
          Lazy completion of Non-Commutative Symmetric Functions over
           the Rational Field in the Complete basis

      Python

          >>> from sage.all import *
          >>> # needs sage.combinat sage.modules
          >>> NCSF = NonCommutativeSymmetricFunctions(QQ)
          >>> S = NCSF.Complete()
          >>> L = S.formal_series_ring()
          >>> L
          Lazy completion of Non-Commutative Symmetric Functions over
           the Rational Field in the Complete basis

    free_graded_module(generator_degrees, names=None)

      Create a finitely generated free graded module over `self`.

      INPUT:

      - `generator_degrees` – tuple of integers defining the number of generators of the module and their degrees

      - `names` – (optional) the names of the generators. If `names` is a comma-separated string like `'a, b, c'`, then those will be the names. Otherwise, for example if `names` is `abc`, then the names will be `abc[d,i]`.

      By default, if all generators are in distinct degrees, then the `names` of the generators will have the form `g[d]` where `d` is the degree of the generator. If the degrees are not distinct, then the generators will be called `g[d,i]` where `d` is the degree and `i` is its index in the list of generators in that degree.

      See `sage.modules.fp_graded.free_module` for more examples and details.

      EXAMPLES:

      Sage

          sage: # needs sage.combinat sage.modules
          sage: Q = QuadraticForm(QQ, 3, [1,2,3,4,5,6])
          sage: Cl = CliffordAlgebra(Q)
          sage: M = Cl.free_graded_module((0, 2, 3))
          sage: M.gens()
          (g[0], g[2], g[3])
          sage: N.<xy, z> = Cl.free_graded_module((1, 2))
          sage: N.generators()
          (xy, z)

      Python

          >>> from sage.all import *
          >>> # needs sage.combinat sage.modules
          >>> Q = QuadraticForm(QQ, Integer(3), [Integer(1),Integer(2),Integer(3),Integer(4),Integer(5),Integer(6)])
          >>> Cl = CliffordAlgebra(Q)
          >>> M = Cl.free_graded_module((Integer(0), Integer(2), Integer(3)))
          >>> M.gens()
          (g[0], g[2], g[3])
          >>> N = Cl.free_graded_module((Integer(1), Integer(2)), names=('xy', 'z',)); (xy, z,) = N._first_ngens(2)
          >>> N.generators()
          (xy, z)

    graded_algebra()

      Return the associated graded algebra to `self`.

      This is `self`, because `self` is already graded. See `graded_algebra()` for the general behavior of this method, and see `AssociatedGradedAlgebra` for the definition and properties of associated graded algebras.

      EXAMPLES:

      Sage

          sage: m = SymmetricFunctions(QQ).m()                                    # needs sage.combinat sage.modules
          sage: m.graded_algebra() is m                                           # needs sage.combinat sage.modules
          True

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).m()                                    # needs sage.combinat sage.modules
          >>> m.graded_algebra() is m                                           # needs sage.combinat sage.modules
          True

  class SignedTensorProducts(category, *args)

    Bases: `SignedTensorProductsCategory`

    The category of algebras with basis constructed by signed tensor product of algebras with basis.

    class ParentMethods

      Bases: `object`

      Implement operations on tensor products of super algebras with basis.

      one_basis()

        Return the index of the one of this signed tensor product of algebras, as per `AlgebrasWithBasis.ParentMethods.one_basis`.

        It is the tuple whose operands are the indices of the ones of the operands, as returned by their `one_basis()` methods.

        EXAMPLES:

        Sage

            sage: # needs sage.combinat sage.modules
            sage: A.<x,y> = ExteriorAlgebra(QQ)
            sage: A.one_basis()
            0
            sage: B = tensor((A, A, A))
            sage: B.one_basis()
            (0, 0, 0)
            sage: B.one()
            1 # 1 # 1

        Python

            >>> from sage.all import *
            >>> # needs sage.combinat sage.modules
            >>> A = ExteriorAlgebra(QQ, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
            >>> A.one_basis()
            0
            >>> B = tensor((A, A, A))
            >>> B.one_basis()
            (0, 0, 0)
            >>> B.one()
            1 # 1 # 1

      product_on_basis(t0, t1)

        The product of the algebra on the basis, as per `AlgebrasWithBasis.ParentMethods.product_on_basis`.

        EXAMPLES:

        Test the sign in the super tensor product:

        Sage

            sage: # needs sage.combinat sage.modules
            sage: A = SteenrodAlgebra(3)
            sage: x = A.Q(0)
            sage: y = x.coproduct()
            sage: y^2
            0

        Python

            >>> from sage.all import *
            >>> # needs sage.combinat sage.modules
            >>> A = SteenrodAlgebra(Integer(3))
            >>> x = A.Q(Integer(0))
            >>> y = x.coproduct()
            >>> y**Integer(2)
            0

        TODO: optimize this implementation!

    extra_super_categories()

      EXAMPLES:

      Sage

          sage: Cat = AlgebrasWithBasis(QQ).Graded()
          sage: Cat.SignedTensorProducts().extra_super_categories()
          [Category of graded algebras with basis over Rational Field]
          sage: Cat.SignedTensorProducts().super_categories()
          [Category of graded algebras with basis over Rational Field,
           Category of signed tensor products of graded algebras over Rational Field]

      Python

          >>> from sage.all import *
          >>> Cat = AlgebrasWithBasis(QQ).Graded()
          >>> Cat.SignedTensorProducts().extra_super_categories()
          [Category of graded algebras with basis over Rational Field]
          >>> Cat.SignedTensorProducts().super_categories()
          [Category of graded algebras with basis over Rational Field,
           Category of signed tensor products of graded algebras over Rational Field]