def __init__(self, R, names=None):
"""
Initialize ``self``.
TESTS::
sage: A = algebras.FreeDendriform(QQ, '@'); A
Free Dendriform algebra on one generator ['@'] over Rational Field
sage: TestSuite(A).run() # long time (3s)
sage: F = algebras.FreeDendriform(QQ, 'xy')
sage: TestSuite(F).run() # long time (3s)
"""
if names is None:
Trees = BinaryTrees()
key = BinaryTree._sort_key
self._alphabet = Alphabet(['o'])
else:
Trees = LabelledBinaryTrees()
key = LabelledBinaryTree._sort_key
self._alphabet = names
# Here one would need LabelledBinaryTrees(names)
# so that one can restrict the labels to some fixed set
cat = HopfAlgebras(R).WithBasis().Graded().Connected()
CombinatorialFreeModule.__init__(self,
R,
Trees,
latex_prefix="",
sorting_key=key,
category=cat)
def __init__(self, base_ring):
r"""
TESTS::
sage: FSym = algebras.FSym(QQ)
sage: TestSuite(FSym).run()
"""
cat = HopfAlgebras(base_ring).Graded().Connected()
Parent.__init__(self, base=base_ring, category=cat.WithRealizations())
def super_categories(self):
"""
The super categories of ``self``.
EXAMPLES::
sage: from sage.combinat.chas.fsym import FSymBases
sage: FSym = algebras.FSym(ZZ)
sage: bases = FSymBases(FSym)
sage: bases.super_categories()
[Category of realizations of Hopf algebra of standard tableaux over the Integer Ring,
Join of Category of realizations of hopf algebras over Integer Ring
and Category of graded algebras over Integer Ring
and Category of graded coalgebras over Integer Ring,
Category of graded connected hopf algebras with basis over Integer Ring]
"""
R = self.base().base_ring()
return [self.base().Realizations(),
HopfAlgebras(R).Graded().Realizations(),
HopfAlgebras(R).Graded().WithBasis().Graded().Connected()]
def super_categories(self):
"""
EXAMPLES::
sage: HopfAlgebrasWithBasis(QQ).Filtered().WithRealizations().super_categories()
[Join of Category of hopf algebras over Rational Field
and Category of filtered algebras over Rational Field]
TESTS::
sage: TestSuite(HopfAlgebrasWithBasis(QQ).Filtered().WithRealizations()).run()
"""
from sage.categories.hopf_algebras import HopfAlgebras
R = self.base_category().base_ring()
return [HopfAlgebras(R).Filtered()]
def extra_super_categories(self):
"""
Implement the fact that the algebra of a group is a Hopf
algebra.
EXAMPLES::
sage: C = Groups().Algebras(QQ)
sage: C.extra_super_categories()
[Category of hopf algebras over Rational Field]
sage: sorted(C.super_categories(), key=str)
[Category of hopf algebras with basis over Rational Field,
Category of monoid algebras over Rational Field]
"""
from sage.categories.hopf_algebras import HopfAlgebras
return [HopfAlgebras(self.base_ring())]
def __init__(self, R):
"""
Initialize ``self``.
TESTS::
sage: A = algebras.FQSym(QQ); A
Free Quasi-symmetric functions over Rational Field
sage: TestSuite(A).run() # long time (3s)
sage: F = algebras.FQSym(QQ)
sage: TestSuite(F).run() # long time (3s)
"""
self._category = HopfAlgebras(R).Graded().Connected()
Parent.__init__(self,
base=R,
category=self._category.WithRealizations())
def __init__(self, R, names=None):
"""
Initialize ``self``.
TESTS::
sage: A = algebras.GrossmanLarson(QQ, '@'); A
Grossman-Larson Hopf algebra on one generator ['@']
over Rational Field
sage: TestSuite(A).run() # long time
sage: F = algebras.GrossmanLarson(QQ, 'xy')
sage: TestSuite(F).run() # long time
sage: A = algebras.GrossmanLarson(QQ, None); A
Grossman-Larson Hopf algebra on one generator ['o'] over
Rational Field
sage: F = algebras.GrossmanLarson(QQ, ['x','y']); F
Grossman-Larson Hopf algebra on 2 generators ['x', 'y']
over Rational Field
sage: A = algebras.GrossmanLarson(QQ, []); A
Grossman-Larson Hopf algebra on 0 generators [] over
Rational Field
"""
if names is None:
Trees = RootedTrees()
key = RootedTree.sort_key
self._alphabet = Alphabet(['o'])
else:
Trees = LabelledRootedTrees()
key = LabelledRootedTree.sort_key
self._alphabet = names
# Here one would need LabelledRootedTrees(names)
# so that one can restrict the labels to some fixed set
cat = HopfAlgebras(R).WithBasis().Graded()
CombinatorialFreeModule.__init__(self,
R,
Trees,
latex_prefix="",
sorting_key=key,
category=cat)
def __init__(self, n, q, bar, R):
"""
Initialize ``self``.
TESTS::
sage: O = algebras.QuantumGL(2)
sage: elts = list(O.algebra_generators())
sage: elts += [O.quantum_determinant(), O.an_element()]
sage: TestSuite(O).run(elements=elts) # long time
"""
# Set the names
gp_indices = [(i, j) for i in range(1, n + 1) for j in range(1, n + 1)]
gp_indices.append('c')
cat = HopfAlgebras(R.category()).WithBasis()
QuantumMatrixCoordinateAlgebra_abstract.__init__(
self, gp_indices, n, q, bar, R, cat, indices_key=_generator_key)
names = ['x{}{}'.format(*k) for k in gp_indices[:-1]]
names.append('c')
self._assign_names(names)