Coverage for local/lib/python2.7/site-packages/sage/categories/hopf_algebras_with

An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Univariate Polynomial Ring in x over Rational Field

An other group can be specified as optional argument::

sage: HopfAlgebrasWithBasis(QQ).example(SymmetricGroup(4))

An example of Hopf algebra with basis: the group algebra of the Symmetric group of order 4! as a permutation group over Rational Field

"""

from sage.categories.examples.hopf_algebras_with_basis import MyGroupAlgebra

from sage.groups.perm_gps.permgroup_named import DihedralGroup

if G is None:

G = DihedralGroup(3)

return MyGroupAlgebra(self.base_ring(), G)

# This is only correct in the finite dimensional / graded case

# def dual(self):

# """

# Returns the dual category

# EXAMPLES:

# The category of Hopf algebras over any field is self dual::

# sage: C = HopfAlgebrasWithBasis(QQ)

# sage: C.dual()

# Category of hopf algebras with basis over Rational Field

# """

# return self

FiniteDimensional = LazyImport('sage.categories.finite_dimensional_hopf_algebras_with_basis',

'FiniteDimensionalHopfAlgebrasWithBasis')

Filtered = LazyImport('sage.categories.filtered_hopf_algebras_with_basis',

'FilteredHopfAlgebrasWithBasis')

Graded = LazyImport('sage.categories.graded_hopf_algebras_with_basis',

'GradedHopfAlgebrasWithBasis')

Super = LazyImport('sage.categories.super_hopf_algebras_with_basis',

'SuperHopfAlgebrasWithBasis')

class ParentMethods:

@abstract_method(optional=True)

def antipode_on_basis(self, x):

"""

The antipode of the Hopf algebra on the basis (optional)

INPUT:

- ``x`` -- an index of an element of the basis of ``self``

Returns the antipode of the basis element indexed by ``x``.

If this method is implemented, then :meth:`antipode` is defined

from this by linearity.

EXAMPLES::

sage: A = HopfAlgebrasWithBasis(QQ).example()

sage: W = A.basis().keys(); W

Dihedral group of order 6 as a permutation group

sage: w = W.an_element(); w

(1,2,3)

sage: A.antipode_on_basis(w)

B[(1,3,2)]

"""

@lazy_attribute

def antipode(self):

"""

The antipode of this Hopf algebra.

If :meth:`.antipode_basis` is available, this constructs the

antipode morphism from ``self`` to ``self`` by extending it by

linearity. Otherwise, :meth:`self.antipode_by_coercion` is used, if

available.

EXAMPLES::

sage: A = HopfAlgebrasWithBasis(ZZ).example(); A

An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Integer Ring

sage: A = HopfAlgebrasWithBasis(QQ).example()

sage: [a,b] = A.algebra_generators()

sage: a, A.antipode(a)

(B[(1,2,3)], B[(1,3,2)])

sage: b, A.antipode(b)

(B[(1,3)], B[(1,3)])

TESTS::

sage: all(A.antipode(x) * x == A.one() for x in A.basis())

True

"""

if self.antipode_on_basis is not NotImplemented:

# Should give the information that this is an anti-morphism of algebra

return self._module_morphism(self.antipode_on_basis, codomain = self)

elif hasattr(self, "antipode_by_coercion"):

return self.antipode_by_coercion

def _test_antipode(self, **options):

r"""

Test the antipode.

An *antipode* `S` of a Hopf algebra is a linear endomorphism of the

Hopf algebra that satisfies the following conditions (see

:wikipedia:`HopfAlgebra`).

- If `\mu` and `\Delta` denote the product and coproduct of the

Hopf algebra, respectively, then `S` satisfies

.. MATH::

\mu \circ (S \tensor 1) \circ \Delta = unit \circ counit

\mu \circ (1 \tensor S) \circ \Delta = unit \circ counit

- `S` is an *anti*-homomorphism

These properties are tested on :meth:`some_elements`.

TESTS::

sage: R = NonCommutativeSymmetricFunctions(QQ).ribbon()

sage: R._test_antipode()

sage: s = SymmetricFunctions(QQ).schur()

sage: s._test_antipode()

"""

tester = self._tester(**options)

S = self.antipode

IS = lambda x: self.sum(c * self.monomial(t1) * S(self.monomial(t2))

for ((t1, t2), c) in x.coproduct())

SI = lambda x: self.sum(c * S(self.monomial(t1)) * self.monomial(t2)

for ((t1, t2), c) in x.coproduct())

for x in tester.some_elements():

# antipode is an anti-homomorphism

for y in tester.some_elements():

tester.assertTrue(S(x) * S(y) == S(y * x))

# mu * (S # I) * delta == counit * unit

tester.assertTrue(SI(x) == self.counit(x) * self.one())

# mu * (I # S) * delta == counit * unit

tester.assertTrue(IS(x) == self.counit(x) * self.one())

class ElementMethods:

pass

class TensorProducts(TensorProductsCategory):

"""

The category of hopf algebras with basis constructed by tensor product of hopf algebras with basis

"""

@cached_method

def extra_super_categories(self):

"""

EXAMPLES::

sage: C = HopfAlgebrasWithBasis(QQ).TensorProducts()

sage: C.extra_super_categories()

[Category of hopf algebras with basis over Rational Field]

sage: sorted(C.super_categories(), key=str)

[Category of hopf algebras with basis over Rational Field,

Category of tensor products of algebras with basis over Rational Field,

Category of tensor products of hopf algebras over Rational Field]

"""

return [self.base_category()]

class ParentMethods:

# todo: antipode

pass

class ElementMethods:

pass

Coverage for local/lib/python2.7/site-packages/sage/categories/hopf_algebras_with_basis.py : 44%

43 statements 19 run 24 missing 0 excluded