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 __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, 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 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, 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)
class FreeQuasisymmetricFunctions(UniqueRepresentation, Parent):
r"""
The free quasi-symmetric functions.
The Hopf algebra `FQSym` of free quasi-symmetric functions
over a commutative ring `R` is the free `R`-module with basis
indexed by all permutations (i.e., the indexing set is
the disjoint union of all symmetric groups).
Its product is determined by the shifted shuffles of two
permutations, whereas its coproduct is given by splitting
a permutation (regarded as a word) into two (at every
possible point) and standardizing the two pieces.
This Hopf algebra was introduced in [MR]_.
See [GriRei16]_ (Chapter 8) for a treatment using modern
notations.
In more detail:
For each `n \geq 0`, consider the symmetric group `S_n`.
Let `S` be the disjoint union of the `S_n` over all
`n \geq 0`.
Then, `FQSym` is the free `R`-module with basis
`(F_w)_{w \in S}`.
This `R`-module is graded, with the `n`-th graded
component being spanned by all `F_w` for `w \in S_n`.
A multiplication is defined on `FQSym` as follows:
For any two permutations `u \in S_k` and `v \in S_l`,
we set
.. MATH::
F_u F_v = \sum F_w ,
where the sum is over all shuffles of `u` with `v[k]`.
Here, the permutations `u` and `v` are regarded as words
(by writing them in one-line notation), and `v[k]` means
the word obtained from `v` by increasing each letter by
`k` (for example, `(1,4,2,3)[5] = (6,9,7,8)`); and the
shuffles `w` are translated back into permutations.
This defines an associative multiplication on `FQSym`;
its unity is `F_e`, where `e` is the identity
permutation in `S_0`.
As an associative algebra, `FQSym` has the richer structure
of a dendriform algebra. This means that the associative
product ``*`` is decomposed as a sum of two binary operations
.. MATH::
x y = x \succ y + x \prec y
that satisfy the axioms:
.. MATH::
(x \succ y) \prec z = x \succ (y \prec z),
.. MATH::
(x \prec y) \prec z = x \prec (y z),
.. MATH::
(x y) \succ z = x \succ (y \succ z).
These two binary operations are defined similarly to the
(associative) product above: We set
.. MATH::
F_u \prec F_v = \sum F_w ,
where the sum is now over all shuffles of `u` with `v[k]`
whose first letter is taken from `u` (rather than from
`v[k]`). Similarly,
.. MATH::
F_u \succ F_v = \sum F_w ,
where the sum is over all remaining shuffles of `u` with
`v[k]`.
.. TODO::
Explain what `1 \prec 1` and `1 \succ 1` are.
.. TODO::
Doctest all 6 possibilities involving `1` on one
side of a `\prec` or `\succ`.
.. NOTE::
The usual binary operator ``*`` is used for the
associative product.
EXAMPLES::
sage: F = algebras.FQSym(ZZ).F()
sage: x,y,z = F([1]), F([1,2]), F([1,3,2])
sage: (x * y) * z
F[1, 2, 3, 4, 6, 5] + ...
The product of `FQSym` is associative::
sage: x * (y * z) == (x * y) * z
True
The associative product decomposes into two parts::
sage: x * y == F.prec(x, y) + F.succ(x, y)
True
The axioms of dendriform algebra hold::
sage: F.prec(F.succ(x, y), z) == F.succ(x, F.prec(y, z))
True
sage: F.prec(F.prec(x, y), z) == F.prec(x, y * z)
True
sage: F.succ(x * y, z) == F.succ(x, F.succ(y, z))
True
`FQSym` is also known as the Malvenuto-Reutenauer algebra::
sage: algebras.MalvenutoReutenauer(ZZ)
Free Quasi-symmetric functions over Integer Ring
REFERENCES:
- [MR]_
- [LodayRonco]_
- [GriRei16]_
"""
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 _repr_(self):
"""
Return the string representation of ``self``.
EXAMPLES::
sage: algebras.FQSym(QQ) # indirect doctest
Free Quasi-symmetric functions over Rational Field
"""
s = "Free Quasi-symmetric functions over {}"
return s.format(self.base_ring())
def a_realization(self):
r"""
Return a particular realization of ``self`` (the F-basis).
EXAMPLES::
sage: FQSym = algebras.FQSym(QQ)
sage: FQSym.a_realization()
Free Quasi-symmetric functions over Rational Field in the F basis
"""
return self.F()
class F(FQSymBasis_abstract):
"""
The F-basis of `FQSym`.
This is the basis `(F_w)`, with `w` ranging over all
permutations. See the documentation of :class:`FQSym`
for details.
EXAMPLES::
sage: FQSym = algebras.FQSym(QQ)
sage: FQSym.F()
Free Quasi-symmetric functions over Rational Field in the F basis
"""
_prefix = "F"
_basis_name = "F"
def _element_constructor_(self, x):
r"""
Convert ``x`` into ``self``.
EXAMPLES::
sage: R = algebras.FQSym(QQ).F()
sage: x, y, z = R([1]), R([2,1]), R([3,2,1])
sage: R(x)
F[1]
sage: R(x+4*y)
F[1] + 4*F[2, 1]
sage: R(1)
F[]
sage: D = algebras.FQSym(ZZ).F()
sage: X, Y, Z = D([1]), D([2,1]), D([3,2,1])
sage: R(X-Y).parent()
Free Quasi-symmetric functions over Rational Field in the F basis
sage: R([1, 3, 2])
F[1, 3, 2]
sage: R(Permutation([1, 3, 2]))
F[1, 3, 2]
sage: R(SymmetricGroup(4)(Permutation([1,3,4,2])))
F[1, 3, 4, 2]
"""
if isinstance(x, (list, tuple, PermutationGroupElement)):
x = Permutation(x)
try:
P = x.parent()
if isinstance(P, FreeQuasisymmetricFunctions.F):
if P is self:
return x
return self.element_class(self, x.monomial_coefficients())
except AttributeError:
pass
return CombinatorialFreeModule._element_constructor_(self, x)
def degree_on_basis(self, t):
"""
Return the degree of a permutation in
the algebra of free quasi-symmetric functions.
This is the size of the permutation (i.e., the `n`
for which the permutation belongs to `S_n`).
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: u = Permutation([2,1])
sage: A.degree_on_basis(u)
2
"""
return len(t)
@cached_method
def an_element(self):
"""
Return an element of ``self``.
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: A.an_element()
F[1] + 2*F[1, 2] + 2*F[2, 1]
"""
o = self([1])
return o + 2 * o * o
def some_elements(self):
"""
Return some elements of the free quasi-symmetric functions.
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: A.some_elements()
[F[], F[1], F[1, 2] + F[2, 1],
F[] + F[1, 2] + F[2, 1]]
"""
u = self.one()
o = self([1])
x = o * o
y = u + x
return [u, o, x, y]
def one_basis(self):
"""
Return the index of the unit.
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: A.one_basis()
[]
"""
Perm = self.basis().keys()
return Perm([])
def product_on_basis(self, x, y):
r"""
Return the `*` associative product of two permutations.
This is the shifted shuffle of `x` and `y`.
.. SEEALSO::
:meth:`succ_product_on_basis`, :meth:`prec_product_on_basis`
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: x = Permutation([1])
sage: A.product_on_basis(x, x)
F[1, 2] + F[2, 1]
"""
n = len(x)
basis = self.basis()
return self.sum(basis[u] for u in x.shifted_shuffle(y))
def succ_product_on_basis(self, x, y):
r"""
Return the `\succ` product of two permutations.
This is the shifted shuffle of `x` and `y` with the additional
condition that the first letter of the result comes from `y`.
The usual symbol for this operation is `\succ`.
.. SEEALSO::
- :meth:`product_on_basis`, :meth:`prec_product_on_basis`
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: x = Permutation([1,2])
sage: A.succ_product_on_basis(x, x)
F[3, 1, 2, 4] + F[3, 1, 4, 2] + F[3, 4, 1, 2]
sage: y = Permutation([])
sage: A.succ_product_on_basis(x, y) == 0
True
sage: A.succ_product_on_basis(y, x) == A(x)
True
TESTS::
sage: u = A.one().support()[0]
sage: A.succ_product_on_basis(u, u)
Traceback (most recent call last):
...
ValueError: products | < | and | > | are not defined
"""
if not y:
if not x:
raise ValueError(
"products | < | and | > | are not defined")
else:
return self.zero()
basis = self.basis()
if not x:
return basis[y]
K = basis.keys()
n = len(x)
shy = Word([a + n for a in y])
shy0 = shy[0]
return self.sum(basis[K([shy0] + list(u))]
for u in Word(x).shuffle(Word(shy[1:])))
def prec_product_on_basis(self, x, y):
r"""
Return the `\prec` product of two permutations.
This is the shifted shuffle of `x` and `y` with the additional
condition that the first letter of the result comes from `x`.
The usual symbol for this operation is `\prec`.
.. SEEALSO::
:meth:`product_on_basis`, :meth:`succ_product_on_basis`
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: x = Permutation([1,2])
sage: A.prec_product_on_basis(x, x)
F[1, 2, 3, 4] + F[1, 3, 2, 4] + F[1, 3, 4, 2]
sage: y = Permutation([])
sage: A.prec_product_on_basis(x, y) == A(x)
True
sage: A.prec_product_on_basis(y, x) == 0
True
TESTS::
sage: u = A.one().support()[0]
sage: A.prec_product_on_basis(u, u)
Traceback (most recent call last):
...
ValueError: products | < | and | > | are not defined
"""
if not x and not y:
raise ValueError("products | < | and | > | are not defined")
if not x:
return self.zero()
basis = self.basis()
if not y:
return basis[x]
K = basis.keys()
n = len(x)
shy = Word([a + n for a in y])
x0 = x[0]
return self.sum(basis[K([x0] + list(u))]
for u in Word(x[1:]).shuffle(shy))
def coproduct_on_basis(self, x):
r"""
Return the coproduct of `F_{\sigma}` for `\sigma` a permutation.
EXAMPLES::
sage: A = algebras.FQSym(QQ).F()
sage: x = A([1])
sage: ascii_art(A.coproduct(A.one())) # indirect doctest
1 # 1
sage: ascii_art(A.coproduct(x)) # indirect doctest
1 # F + F # 1
[1] [1]
sage: A = algebras.FQSym(QQ).F()
sage: x, y, z = A([1]), A([2,1]), A([3,2,1])
sage: A.coproduct(z)
F[] # F[3, 2, 1] + F[1] # F[2, 1] + F[2, 1] # F[1]
+ F[3, 2, 1] # F[]
"""
if not len(x):
return self.one().tensor(self.one())
return sum(
self(Word(x[:i]).standard_permutation()).tensor(
self(Word(x[i:]).standard_permutation()))
for i in range(len(x) + 1))