### Navigation

- index
- modules |
- next |
- previous |
- Category Theory »

# Coalgebras

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

  Bases: `sage.categories.category_types.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]

  TESTS:

      sage: TestSuite(Coalgebras(ZZ)).run()

  class `DualObjects`(category, *args)

    Bases: `sage.categories.dual.DualObjectsCategory`

    TESTS:

        sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
        sage: class FooBars(CovariantConstructionCategory):
        ...       _functor_category = "FooBars"
        sage: Category.FooBars = lambda self: FooBars.category_of(self)
        sage: C = FooBars(ModulesWithBasis(ZZ))
        sage: C
        Category of foo bars of modules with basis over Integer Ring
        sage: C.base_category()
        Category of modules with basis over Integer Ring
        sage: latex(C)
        \mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
        sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
        sage: TestSuite(C).run()

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

      Warning

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

  class `Coalgebras.``ElementMethods`
    `coproduct`()

      Returns the coproduct of `self`

      EXAMPLES:

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

    `counit`()

      Returns the counit of `self`

      EXAMPLES:

          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)

  class `Coalgebras.``ParentMethods`
    `coproduct`(x)

      Returns the coproduct of x.

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

      EXAMPLES:

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

    `counit`(x)

      Returns the counit of x.

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

      EXAMPLES:

          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)

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

    `tensor_square`()

      Returns the tensor square of `self`

      EXAMPLES:

          sage: A = HopfAlgebrasWithBasis(QQ).example()
          sage: A.tensor_square()
          An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Rational Field # An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Rational Field

  class `Coalgebras.``Realizations`(category, *args)

    Bases: `sage.categories.realizations.RealizationsCategory`

    TESTS:

        sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
        sage: class FooBars(CovariantConstructionCategory):
        ...       _functor_category = "FooBars"
        sage: Category.FooBars = lambda self: FooBars.category_of(self)
        sage: C = FooBars(ModulesWithBasis(ZZ))
        sage: C
        Category of foo bars of modules with basis over Integer Ring
        sage: C.base_category()
        Category of modules with basis over Integer Ring
        sage: latex(C)
        \mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
        sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
        sage: TestSuite(C).run()

    class `ParentMethods`
      `coproduct_by_coercion`(x)

        Returns the coproduct by coercion if coproduct_by_basis is not implemented.

        EXAMPLES:

            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()
            m[] # m[2, 1] + m[1] # m[2] + m[2] # m[1] + m[2, 1] # m[]

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

  class `Coalgebras.``TensorProducts`(category, *args)

    Bases: `sage.categories.tensor.TensorProductsCategory`

    TESTS:

        sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
        sage: class FooBars(CovariantConstructionCategory):
        ...       _functor_category = "FooBars"
        sage: Category.FooBars = lambda self: FooBars.category_of(self)
        sage: C = FooBars(ModulesWithBasis(ZZ))
        sage: C
        Category of foo bars of modules with basis over Integer Ring
        sage: C.base_category()
        Category of modules with basis over Integer Ring
        sage: latex(C)
        \mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
        sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
        sage: TestSuite(C).run()

    class `ElementMethods`
    class `Coalgebras.TensorProducts.``ParentMethods`
    `Coalgebras.TensorProducts.``extra_super_categories`()

      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]

      Meaning: a tensor product of coalgebras is a coalgebra

  `Coalgebras.``WithBasis`

    alias of `CoalgebrasWithBasis`

  class `Coalgebras.``WithRealizations`(category, *args)

    Bases: `sage.categories.with_realizations.WithRealizationsCategory`

    TESTS:

        sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
        sage: class FooBars(CovariantConstructionCategory):
        ...       _functor_category = "FooBars"
        sage: Category.FooBars = lambda self: FooBars.category_of(self)
        sage: C = FooBars(ModulesWithBasis(ZZ))
        sage: C
        Category of foo bars of modules with basis over Integer Ring
        sage: C.base_category()
        Category of modules with basis over Integer Ring
        sage: latex(C)
        \mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
        sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
        sage: TestSuite(C).run()

    class `ParentMethods`
      `coproduct`(x)

        Returns the coproduct of `x`.

        EXAMPLES:

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

      `counit`(x)

        Returns the counit of `x`.

        EXAMPLES:

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

            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

  `Coalgebras.``super_categories`()

    EXAMPLES:

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

### Navigation

- index
- modules |
- next |
- previous |
- Category Theory »