Coalgebras

class sage.categories.coalgebras.Coalgebras(base, name=None)[source]

Bases: Category_over_base_ring

The category of coalgebras.

EXAMPLES:

sage: Coalgebras(QQ)
Category of coalgebras over Rational Field
sage: Coalgebras(QQ).super_categories()
[Category of vector spaces over Rational Field]

>>> from sage.all import *
>>> Coalgebras(QQ)
Category of coalgebras over Rational Field
>>> Coalgebras(QQ).super_categories()
[Category of vector spaces over Rational Field]
class Cocommutative(base_category)[source]

Bases: CategoryWithAxiom_over_base_ring

Category of cocommutative coalgebras.

class DualObjects(category, *args)[source]

Bases: DualObjectsCategory

extra_super_categories()[source]

Return the dual category.

EXAMPLES:

The category of coalgebras over the Rational Field is dual to the category of algebras over the same field:

sage: C = Coalgebras(QQ)
sage: C.dual()
Category of duals of coalgebras over Rational Field
sage: C.dual().super_categories() # indirect doctest
[Category of algebras over Rational Field,
 Category of duals of vector spaces over Rational Field]

>>> from sage.all import *
>>> C = Coalgebras(QQ)
>>> C.dual()
Category of duals of coalgebras over Rational Field
>>> C.dual().super_categories() # indirect doctest
[Category of algebras over Rational Field,
 Category of duals of vector spaces over Rational Field]

Warning

This is only correct in certain cases (finite dimension, …). See Issue #15647.

class ElementMethods[source]

Bases: object

coproduct()[source]

Return the coproduct of self.

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()
(B[(1,2,3)], B[(1,2,3)] # B[(1,2,3)])
sage: b, b.coproduct()
(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()
(B[(1,2,3)], B[(1,2,3)] # B[(1,2,3)])
>>> b, b.coproduct()
(B[(1,3)], B[(1,3)] # B[(1,3)])
counit()[source]

Return the counit of self.

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()
(B[(1,2,3)], 1)
sage: b, b.counit()
(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()
(B[(1,2,3)], 1)
>>> b, b.counit()
(B[(1,3)], 1)
class Filtered(base_category)[source]

Bases: FilteredModulesCategory

Category of filtered coalgebras.

Graded[source]

alias of GradedCoalgebras

class ParentMethods[source]

Bases: object

coproduct(x)[source]

Return the coproduct of x.

Eventually, there will be a default implementation, delegating to the overloading mechanism and forcing the conversion back

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

Return the counit of x.

Eventually, there will be a default implementation, delegating to the overloading mechanism and forcing the conversion back

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)

TODO: implement some tests of the axioms of coalgebras, bialgebras and Hopf algebras using the counit.

class Realizations(category, *args)[source]

Bases: RealizationsCategory

class ParentMethods[source]

Bases: object

coproduct_by_coercion(x)[source]

Return the coproduct by coercion if coproduct_by_basis is not implemented.

EXAMPLES:

sage: # needs sage.modules
sage: Sym = SymmetricFunctions(QQ)
sage: m = Sym.monomial()
sage: f = m[2,1]
sage: f.coproduct.__module__
'sage.categories.coalgebras'
sage: m.coproduct_on_basis
NotImplemented
sage: m.coproduct == m.coproduct_by_coercion
True
sage: f.coproduct()                                                 # needs lrcalc_python
m[] # m[2, 1] + m[1] # m[2] + m[2] # m[1] + m[2, 1] # m[]

>>> from sage.all import *
>>> # needs sage.modules
>>> Sym = SymmetricFunctions(QQ)
>>> m = Sym.monomial()
>>> f = m[Integer(2),Integer(1)]
>>> f.coproduct.__module__
'sage.categories.coalgebras'
>>> m.coproduct_on_basis
NotImplemented
>>> m.coproduct == m.coproduct_by_coercion
True
>>> f.coproduct()                                                 # needs lrcalc_python
m[] # m[2, 1] + m[1] # m[2] + m[2] # m[1] + m[2, 1] # m[]


sage: # needs sage.modules
sage: N = NonCommutativeSymmetricFunctions(QQ)
sage: R = N.ribbon()
sage: R.coproduct_by_coercion.__module__
'sage.categories.coalgebras'
sage: R.coproduct_on_basis
NotImplemented
sage: R.coproduct == R.coproduct_by_coercion
True
sage: R[1].coproduct()
R[] # R[1] + R[1] # R[]

>>> from sage.all import *
>>> # needs sage.modules
>>> N = NonCommutativeSymmetricFunctions(QQ)
>>> R = N.ribbon()
>>> R.coproduct_by_coercion.__module__
'sage.categories.coalgebras'
>>> R.coproduct_on_basis
NotImplemented
>>> R.coproduct == R.coproduct_by_coercion
True
>>> R[Integer(1)].coproduct()
R[] # R[1] + R[1] # R[]
counit_by_coercion(x)[source]

Return the counit of x if counit_by_basis is not implemented.

EXAMPLES:

sage: # needs lrcalc_python sage.modules
sage: sp = SymmetricFunctions(QQ).sp()
sage: sp.an_element()
2*sp[] + 2*sp[1] + 3*sp[2]
sage: sp.counit(sp.an_element())
2
sage: o = SymmetricFunctions(QQ).o()
sage: o.an_element()
2*o[] + 2*o[1] + 3*o[2]
sage: o.counit(o.an_element())
-1

>>> from sage.all import *
>>> # needs lrcalc_python sage.modules
>>> sp = SymmetricFunctions(QQ).sp()
>>> sp.an_element()
2*sp[] + 2*sp[1] + 3*sp[2]
>>> sp.counit(sp.an_element())
2
>>> o = SymmetricFunctions(QQ).o()
>>> o.an_element()
2*o[] + 2*o[1] + 3*o[2]
>>> o.counit(o.an_element())
-1
class SubcategoryMethods[source]

Bases: object

Cocommutative()[source]

Return the full subcategory of the cocommutative objects of self.

A coalgebra \(C\) is said to be cocommutative if

\[\Delta(c) = \sum_{(c)} c_{(1)} \otimes c_{(2)} = \sum_{(c)} c_{(2)} \otimes c_{(1)}\]

in Sweedler’s notation for all \(c \in C\).

EXAMPLES:

sage: C1 = Coalgebras(ZZ).Cocommutative().WithBasis(); C1
Category of cocommutative coalgebras with basis over Integer Ring
sage: C2 = Coalgebras(ZZ).WithBasis().Cocommutative()
sage: C1 is C2
True
sage: BialgebrasWithBasis(QQ).Cocommutative()
Category of cocommutative bialgebras with basis over Rational Field

>>> from sage.all import *
>>> C1 = Coalgebras(ZZ).Cocommutative().WithBasis(); C1
Category of cocommutative coalgebras with basis over Integer Ring
>>> C2 = Coalgebras(ZZ).WithBasis().Cocommutative()
>>> C1 is C2
True
>>> BialgebrasWithBasis(QQ).Cocommutative()
Category of cocommutative bialgebras with basis over Rational Field
class Super(base_category)[source]

Bases: SuperModulesCategory

class SubcategoryMethods[source]

Bases: object

Supercocommutative()[source]

Return the full subcategory of the supercocommutative objects of self.

EXAMPLES:

sage: Coalgebras(ZZ).WithBasis().Super().Supercocommutative()
Category of supercocommutative super coalgebras with basis over Integer Ring
sage: BialgebrasWithBasis(QQ).Super().Supercocommutative()
Join of Category of super algebras with basis over Rational Field
 and Category of super bialgebras over Rational Field
 and Category of super coalgebras with basis over Rational Field
 and Category of supercocommutative super coalgebras over Rational Field

>>> from sage.all import *
>>> Coalgebras(ZZ).WithBasis().Super().Supercocommutative()
Category of supercocommutative super coalgebras with basis over Integer Ring
>>> BialgebrasWithBasis(QQ).Super().Supercocommutative()
Join of Category of super algebras with basis over Rational Field
 and Category of super bialgebras over Rational Field
 and Category of super coalgebras with basis over Rational Field
 and Category of supercocommutative super coalgebras over Rational Field
class Supercocommutative(base_category)[source]

Bases: CategoryWithAxiom_over_base_ring

Category of supercocommutative coalgebras.

extra_super_categories()[source]

EXAMPLES:

sage: Coalgebras(ZZ).Super().extra_super_categories()
[Category of graded coalgebras over Integer Ring]
sage: Coalgebras(ZZ).Super().super_categories()
[Category of graded coalgebras over Integer Ring,
 Category of super modules over Integer Ring]

>>> from sage.all import *
>>> Coalgebras(ZZ).Super().extra_super_categories()
[Category of graded coalgebras over Integer Ring]
>>> Coalgebras(ZZ).Super().super_categories()
[Category of graded coalgebras over Integer Ring,
 Category of super modules over Integer Ring]

Compare this with the situation for bialgebras:

sage: Bialgebras(ZZ).Super().extra_super_categories()
[]
sage: Bialgebras(ZZ).Super().super_categories()
[Category of super algebras over Integer Ring,
 Category of super coalgebras over Integer Ring]

>>> from sage.all import *
>>> Bialgebras(ZZ).Super().extra_super_categories()
[]
>>> Bialgebras(ZZ).Super().super_categories()
[Category of super algebras over Integer Ring,
 Category of super coalgebras over Integer Ring]

The category of bialgebras does not occur in these results, since super bialgebras are not bialgebras.

class TensorProducts(category, *args)[source]

Bases: TensorProductsCategory

class ElementMethods[source]

Bases: object

class ParentMethods[source]

Bases: object

extra_super_categories()[source]

EXAMPLES:

sage: Coalgebras(QQ).TensorProducts().extra_super_categories()
[Category of coalgebras over Rational Field]
sage: Coalgebras(QQ).TensorProducts().super_categories()
[Category of tensor products of vector spaces over Rational Field,
 Category of coalgebras over Rational Field]

>>> from sage.all import *
>>> Coalgebras(QQ).TensorProducts().extra_super_categories()
[Category of coalgebras over Rational Field]
>>> Coalgebras(QQ).TensorProducts().super_categories()
[Category of tensor products of vector spaces over Rational Field,
 Category of coalgebras over Rational Field]

Meaning: a tensor product of coalgebras is a coalgebra

WithBasis[source]

alias of CoalgebrasWithBasis

class WithRealizations(category, *args)[source]

Bases: WithRealizationsCategory

class ParentMethods[source]

Bases: object

coproduct(x)[source]

Return the coproduct of x.

EXAMPLES:

sage: # needs sage.modules
sage: N = NonCommutativeSymmetricFunctions(QQ)
sage: S = N.complete()
sage: N.coproduct.__module__
'sage.categories.coalgebras'
sage: N.coproduct(S[2])
S[] # S[2] + S[1] # S[1] + S[2] # S[]

>>> from sage.all import *
>>> # needs sage.modules
>>> N = NonCommutativeSymmetricFunctions(QQ)
>>> S = N.complete()
>>> N.coproduct.__module__
'sage.categories.coalgebras'
>>> N.coproduct(S[Integer(2)])
S[] # S[2] + S[1] # S[1] + S[2] # S[]
counit(x)[source]

Return the counit of x.

EXAMPLES:

sage: # needs sage.modules
sage: Sym = SymmetricFunctions(QQ)
sage: s = Sym.schur()
sage: f = s[2,1]
sage: f.counit.__module__
'sage.categories.coalgebras'
sage: f.counit()
0

>>> from sage.all import *
>>> # needs sage.modules
>>> Sym = SymmetricFunctions(QQ)
>>> s = Sym.schur()
>>> f = s[Integer(2),Integer(1)]
>>> f.counit.__module__
'sage.categories.coalgebras'
>>> f.counit()
0


sage: # needs sage.modules
sage: N = NonCommutativeSymmetricFunctions(QQ)
sage: N.counit.__module__
'sage.categories.coalgebras'
sage: N.counit(N.one())
1
sage: x = N.an_element(); x
2*S[] + 2*S[1] + 3*S[1, 1]
sage: N.counit(x)
2

>>> from sage.all import *
>>> # needs sage.modules
>>> N = NonCommutativeSymmetricFunctions(QQ)
>>> N.counit.__module__
'sage.categories.coalgebras'
>>> N.counit(N.one())
1
>>> x = N.an_element(); x
2*S[] + 2*S[1] + 3*S[1, 1]
>>> N.counit(x)
2
super_categories()[source]

EXAMPLES:

sage: Coalgebras(QQ).super_categories()
[Category of vector spaces over Rational Field]

>>> from sage.all import *
>>> Coalgebras(QQ).super_categories()
[Category of vector spaces over Rational Field]