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 *
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 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
```

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)
```

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

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

class ParentMethods[source]#

Bases: `object`

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

```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 *