Coalgebras - Category Framework

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

# Coalgebras

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

  Bases: `Category_over_base_ring`

  The category of coalgebras.

  EXAMPLES:

  Sage

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

  Python

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

    Bases: `CategoryWithAxiom_over_base_ring`

    Category of cocommutative coalgebras.

  class DualObjects(category, *args)

    Bases: `DualObjectsCategory`

    extra_super_categories()

      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

          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]

      Python

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

    Bases: `object`

    coproduct()

      Return the coproduct of `self`.

      EXAMPLES:

      Sage

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

      Python

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

      Return the counit of `self`.

      EXAMPLES:

      Sage

          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)

      Python

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

    Bases: `FilteredModulesCategory`

    Category of filtered coalgebras.

  Graded

    alias of `GradedCoalgebras`

  class ParentMethods

    Bases: `object`

    coproduct(x)

      Return the coproduct of `x`.

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

      EXAMPLES:

      Sage

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

      Python

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

      Return the counit of `x`.

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

      EXAMPLES:

      Sage

          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)

      Python

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

    Bases: `RealizationsCategory`

    class ParentMethods

      Bases: `object`

      coproduct_by_coercion(x)

        Return the coproduct by coercion if `coproduct_by_basis` is not implemented.

        EXAMPLES:

        Sage

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

        Python

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

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

        [Python]

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

        Return the counit of `x` if `counit_by_basis` is not implemented.

        EXAMPLES:

        Sage

            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

        Python

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

    Bases: `object`

    Cocommutative()

      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

          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

      Python

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

    Bases: `SuperModulesCategory`

    class SubcategoryMethods

      Bases: `object`

      Supercocommutative()

        Return the full subcategory of the supercocommutative objects of `self`.

        EXAMPLES:

        Sage

            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

        Python

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

      Bases: `CategoryWithAxiom_over_base_ring`

      Category of supercocommutative coalgebras.

    extra_super_categories()

      EXAMPLES:

      Sage

          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]

      Python

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

          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]

      [Python]

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

    Bases: `TensorProductsCategory`

    class ElementMethods

      Bases: `object`

    class ParentMethods

      Bases: `object`

    extra_super_categories()

      EXAMPLES:

      Sage

          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]

      Python

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

    alias of `CoalgebrasWithBasis`

  class WithRealizations(category, *args)

    Bases: `WithRealizationsCategory`

    class ParentMethods

      Bases: `object`

      coproduct(x)

        Return the coproduct of `x`.

        EXAMPLES:

        Sage

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

        Python

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

        Return the counit of `x`.

        EXAMPLES:

        Sage

            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

        Python

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

            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

        [Python]

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

    EXAMPLES:

    Sage

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

    Python

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