# Coalgebras with basis#

class sage.categories.coalgebras_with_basis.CoalgebrasWithBasis(base_category)[source]#

The category of coalgebras with a distinguished basis.

EXAMPLES:

sage: CoalgebrasWithBasis(ZZ)
Category of coalgebras with basis over Integer Ring
sage: sorted(CoalgebrasWithBasis(ZZ).super_categories(), key=str)
[Category of coalgebras over Integer Ring,
Category of modules with basis over Integer Ring]

>>> from sage.all import *
>>> CoalgebrasWithBasis(ZZ)
Category of coalgebras with basis over Integer Ring
>>> sorted(CoalgebrasWithBasis(ZZ).super_categories(), key=str)
[Category of coalgebras over Integer Ring,
Category of modules with basis over Integer Ring]

class ElementMethods[source]#

Bases: object

coproduct_iterated(n=1)[source]#

Apply n coproducts to self.

Todo

Remove dependency on modules_with_basis methods.

EXAMPLES:

sage: Psi = NonCommutativeSymmetricFunctions(QQ).Psi()                  # needs sage.combinat sage.modules
sage: Psi[2,2].coproduct_iterated(0)                                    # needs sage.combinat sage.modules
Psi[2, 2]
sage: Psi[2,2].coproduct_iterated(2)                                    # needs sage.combinat sage.modules
Psi[] # Psi[] # Psi[2, 2] + 2*Psi[] # Psi[2] # Psi[2]
+ Psi[] # Psi[2, 2] # Psi[] + 2*Psi[2] # Psi[] # Psi[2]
+ 2*Psi[2] # Psi[2] # Psi[] + Psi[2, 2] # Psi[] # Psi[]

>>> from sage.all import *
>>> Psi = NonCommutativeSymmetricFunctions(QQ).Psi()                  # needs sage.combinat sage.modules
>>> Psi[Integer(2),Integer(2)].coproduct_iterated(Integer(0))                                    # needs sage.combinat sage.modules
Psi[2, 2]
>>> Psi[Integer(2),Integer(2)].coproduct_iterated(Integer(2))                                    # needs sage.combinat sage.modules
Psi[] # Psi[] # Psi[2, 2] + 2*Psi[] # Psi[2] # Psi[2]
+ Psi[] # Psi[2, 2] # Psi[] + 2*Psi[2] # Psi[] # Psi[2]
+ 2*Psi[2] # Psi[2] # Psi[] + Psi[2, 2] # Psi[] # Psi[]

class Filtered(base_category)[source]#

Category of filtered coalgebras.

class ParentMethods[source]#

Bases: object

coproduct()[source]#

If coproduct_on_basis() is available, construct the coproduct morphism from self to self $$\otimes$$ self by extending it by linearity. Otherwise, use coproduct_by_coercion(), if available.

EXAMPLES:

sage: # needs sage.groups sage.modules
sage: A = HopfAlgebrasWithBasis(QQ).example(); A
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
sage: a, b = A.algebra_generators()
sage: a, A.coproduct(a)
(B[(1,2,3)], B[(1,2,3)] # B[(1,2,3)])
sage: b, A.coproduct(b)
(B[(1,3)], B[(1,3)] # B[(1,3)])

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> A = HopfAlgebrasWithBasis(QQ).example(); A
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
>>> a, b = A.algebra_generators()
>>> a, A.coproduct(a)
(B[(1,2,3)], B[(1,2,3)] # B[(1,2,3)])
>>> b, A.coproduct(b)
(B[(1,3)], B[(1,3)] # B[(1,3)])

coproduct_on_basis(i)[source]#

The coproduct of the algebra on the basis (optional).

INPUT:

• i – the indices of an element of the basis of self

Returns the coproduct of the corresponding basis elements If implemented, the coproduct of the algebra is defined from it by linearity.

EXAMPLES:

sage: A = HopfAlgebrasWithBasis(QQ).example(); A                        # needs sage.groups sage.modules
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
sage: (a, b) = A._group.gens()                                          # needs sage.groups sage.modules
sage: A.coproduct_on_basis(a)                                           # needs sage.groups sage.modules
B[(1,2,3)] # B[(1,2,3)]

>>> from sage.all import *
>>> A = HopfAlgebrasWithBasis(QQ).example(); A                        # needs sage.groups sage.modules
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
>>> (a, b) = A._group.gens()                                          # needs sage.groups sage.modules
>>> A.coproduct_on_basis(a)                                           # needs sage.groups sage.modules
B[(1,2,3)] # B[(1,2,3)]

counit()[source]#

If counit_on_basis() is available, construct the counit morphism from self to self $$\otimes$$ self by extending it by linearity

EXAMPLES:

sage: # needs sage.groups sage.modules
sage: A = HopfAlgebrasWithBasis(QQ).example(); A
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
sage: a, b = A.algebra_generators()
sage: a, A.counit(a)
(B[(1,2,3)], 1)
sage: b, A.counit(b)
(B[(1,3)], 1)

>>> from sage.all import *
>>> # needs sage.groups sage.modules
>>> A = HopfAlgebrasWithBasis(QQ).example(); A
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
>>> a, b = A.algebra_generators()
>>> a, A.counit(a)
(B[(1,2,3)], 1)
>>> b, A.counit(b)
(B[(1,3)], 1)

counit_on_basis(i)[source]#

The counit of the algebra on the basis (optional).

INPUT:

• i – the indices of an element of the basis of self

Returns the counit of the corresponding basis elements If implemented, the counit of the algebra is defined from it by linearity.

EXAMPLES:

sage: A = HopfAlgebrasWithBasis(QQ).example(); A                        # needs sage.groups sage.modules
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
sage: (a, b) = A._group.gens()                                          # needs sage.groups sage.modules
sage: A.counit_on_basis(a)                                              # needs sage.groups sage.modules
1

>>> from sage.all import *
>>> A = HopfAlgebrasWithBasis(QQ).example(); A                        # needs sage.groups sage.modules
An example of Hopf algebra with basis:
the group algebra of the Dihedral group of order 6
as a permutation group over Rational Field
>>> (a, b) = A._group.gens()                                          # needs sage.groups sage.modules
>>> A.counit_on_basis(a)                                              # needs sage.groups sage.modules
1

class Super(base_category)[source]#
extra_super_categories()[source]#

EXAMPLES:

sage: C = Coalgebras(ZZ).WithBasis().Super()
sage: sorted(C.super_categories(), key=str)  # indirect doctest
[Category of graded coalgebras with basis over Integer Ring,
Category of super coalgebras over Integer Ring,
Category of super modules with basis over Integer Ring]

>>> from sage.all import *
>>> C = Coalgebras(ZZ).WithBasis().Super()
>>> sorted(C.super_categories(), key=str)  # indirect doctest
[Category of graded coalgebras with basis over Integer Ring,
Category of super coalgebras over Integer Ring,
Category of super modules with basis over Integer Ring]