Graded algebras with basis

class sage.categories.graded_algebras_with_basis.GradedAlgebrasWithBasis(base_category)[source]

Bases: GradedModulesCategory

The category of graded algebras with a distinguished basis.

EXAMPLES:

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]

>>> 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[source]

Bases: object

class FiniteDimensional(base_category)[source]

Bases: CategoryWithAxiom_over_base_ring

class ParentMethods[source]

Bases: object

top_degree()[source]

Return the top degree of the finite dimensional graded algebra.

EXAMPLES:

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

>>> 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[source]

Bases: object

completion()[source]

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

EXAMPLES:

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

>>> 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
formal_series_ring()[source]

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

EXAMPLES:

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

>>> 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)[source]

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: # 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)

>>> 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()[source]

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: m = SymmetricFunctions(QQ).m()                                    # needs sage.combinat sage.modules
sage: m.graded_algebra() is m                                           # needs sage.combinat sage.modules
True

>>> 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)[source]

Bases: SignedTensorProductsCategory

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

class ParentMethods[source]

Bases: object

Implement operations on tensor products of super algebras with basis.

one_basis()[source]

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: # 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

>>> 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)[source]

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: # needs sage.combinat sage.modules
sage: A = SteenrodAlgebra(3)
sage: x = A.Q(0)
sage: y = x.coproduct()
sage: y^2
0

>>> 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()[source]

EXAMPLES:

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]

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