def coproduct_on_basis(self, t):
r"""
Return the coproduct of the basis element indexed by ``t``.
EXAMPLES::
sage: FSym = algebras.FSym(QQ)
sage: G = FSym.G()
sage: t = StandardTableau([[1,2,5], [3,4]])
sage: G.coproduct_on_basis(t)
G[] # G[125|34] + G[1] # G[12|34] + G[1] # G[124|3]
+ G[1|2] # G[13|2] + G[12] # G[12|3] + G[12] # G[123]
+ G[12|34] # G[1] + G[123] # G[12] + G[125|34] # G[]
+ G[13|2] # G[1|2] + G[13|2] # G[12] + G[134|2] # G[1]
"""
# we use the duality to compute this
n = t.size()
L = []
dual_basis = self.dual_basis()
for i in range(n + 1):
for t1 in StandardTableaux(i):
for t2 in StandardTableaux(n - i):
coeff = (dual_basis[t1] * dual_basis[t2])[t]
if coeff:
L.append(((t1, t2), coeff))
TT = self.tensor_square()
return TT.sum_of_terms(L)
def basis(self, degree=None):
r"""
The basis elements (optionally: of the specified degree).
OUTPUT: Family
EXAMPLES::
sage: FSym = algebras.FSym(QQ)
sage: TG = FSym.G()
sage: TG.basis()
Lazy family (Term map from Standard tableaux to Hopf algebra of standard tableaux
over the Rational Field in the Fundamental basis(i))_{i in Standard tableaux}
sage: TG.basis().keys()
Standard tableaux
sage: TG.basis(degree=3).keys()
Standard tableaux of size 3
sage: TG.basis(degree=3).list()
[G[123], G[13|2], G[12|3], G[1|2|3]]
"""
from sage.combinat.family import Family
if degree is None:
return Family(self._indices, self.monomial)
else:
return Family(StandardTableaux(degree), self.monomial)
def product_on_basis(self, t1, t2):
r"""
Return the product of basis elements indexed by ``t1`` and ``t2``.
EXAMPLES::
sage: FSym = algebras.FSym(QQ)
sage: G = FSym.G()
sage: t1 = StandardTableau([[1,2], [3]])
sage: t2 = StandardTableau([[1,2,3]])
sage: G.product_on_basis(t1, t2)
G[12456|3] + G[1256|3|4] + G[1256|34] + G[126|35|4]
sage: t1 = StandardTableau([[1],[2]])
sage: t2 = StandardTableau([[1,2]])
sage: G.product_on_basis(t1, t2)
G[134|2] + G[14|2|3]
sage: t1 = StandardTableau([[1,2],[3]])
sage: t2 = StandardTableau([[1],[2]])
sage: G.product_on_basis(t1, t2)
G[12|3|4|5] + G[12|34|5] + G[124|3|5] + G[124|35]
"""
n = t1.size()
m = n + t2.size()
tableaux = []
for t in StandardTableaux(m):
if t.restrict(n) == t1 and standardize(
t.anti_restrict(n).rectify()) == t2:
tableaux.append(t)
return self.sum_of_monomials(tableaux)
def __init__(self, alg, graded=True):
r"""
Initialize ``self``.
EXAMPLES::
sage: G = algebras.FSym(QQ).G()
sage: TestSuite(G).run() # long time
Checks for the antipode::
sage: FSym = algebras.FSym(QQ)
sage: G = FSym.G()
sage: for b in G.basis(degree=3):
....: print("%s : %s" % (b, b.antipode()))
G[123] : -G[1|2|3]
G[13|2] : -G[13|2]
G[12|3] : -G[12|3]
G[1|2|3] : -G[123]
sage: F = FSym.dual().F()
sage: for b in F.basis(degree=3):
....: print("%s : %s" % (b, b.antipode()))
F[123] : -F[1|2|3]
F[13|2] : -F[13|2]
F[12|3] : -F[12|3]
F[1|2|3] : -F[123]
"""
CombinatorialFreeModule.__init__(self,
alg.base_ring(),
StandardTableaux(),
category=FSymBases(alg),
bracket="",
prefix=self._prefix)
def syt_promotion(lam):
r"""
Return the invertible finite discrete dynamical system
consisting of all standard tableaux of shape ``lam`` (a
given partition) and evolving according to promotion.
EXAMPLES::
sage: F = finite_dynamical_systems.syt_promotion([4, 4, 4])
sage: sorted(F.orbit_lengths())
[3, 3, 4, 4, 4, 6, 6, 6, 6, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12]
sage: G = finite_dynamical_systems.syt_promotion([4, 3, 1])
sage: sorted(G.orbit_lengths())
[16, 22, 32]
sage: G.verify_inverse_evolution()
True
"""
from sage.combinat.partition import Partition
lam = Partition(lam)
from sage.combinat.tableau import StandardTableaux
X = StandardTableaux(lam)
return InvertibleFiniteDynamicalSystem(
X, lambda T: T.promotion(), inverse=lambda T: T.promotion_inverse())
def standardize(t):
r"""
Return the standard tableau corresponding to a given
semistandard tableau ``t`` with no repeated entries.
.. NOTE::
This is an optimized version of :meth:`Tableau.standardization`
for computations in `FSym` by using the assumption of no
repeated entries in ``t``.
EXAMPLES::
sage: from sage.combinat.chas.fsym import standardize
sage: t = Tableau([[1,3,5,7],[2,4,8],[9]])
sage: standardize(t)
[[1, 3, 5, 6], [2, 4, 7], [8]]
sage: t = Tableau([[3,8,9,15],[5,10,12],[133]])
sage: standardize(t)
[[1, 3, 4, 7], [2, 5, 6], [8]]
Returns an equal tableau if already standard::
sage: t = Tableau([[1,3,4,5],[2,6,7],[8]])
sage: standardize(t)
[[1, 3, 4, 5], [2, 6, 7], [8]]
sage: standardize(t) == t
True
"""
A = sorted(sum(t, ()))
std = {j: i + 1 for i, j in enumerate(A)}
ST = StandardTableaux()
return ST([[std[i] for i in row] for row in t])
def cardinality(self):
r"""
Return the number of all standard super tableaux of size ``n``.
The standard super tableaux of size `n` are in bijection with the
corresponding standard tableaux (under the alphabet relabeling). Refer
:class:`sage.combinat.tableau.StandardTableaux_size` for more details.
EXAMPLES::
sage: StandardSuperTableaux(3).cardinality()
4
sage: ns = [1,2,3,4,5,6]
sage: sts = [StandardSuperTableaux(n) for n in ns]
sage: all(st.cardinality() == len(st.list()) for st in sts)
True
sage: StandardSuperTableaux(50).cardinality() # long time
27886995605342342839104615869259776
TESTS::
sage: def cardinality_using_hook_formula(n):
....: c = 0
....: for p in Partitions(n):
....: c += StandardSuperTableaux(p).cardinality()
....: return c
sage: all(cardinality_using_hook_formula(i) ==
....: StandardSuperTableaux(i).cardinality()
....: for i in range(10))
True
"""
return StandardTableaux(self.size).cardinality()
def _tableau_dict(self):
r"""
A dictionary pairing the vertices of the underlying Yang-Baxter
graph with standard tableau.
EXAMPLES::
sage: orth = SymmetricGroupRepresentation([3,2], "orthogonal")
sage: orth._tableau_dict
{(0, 2, 1, -1, 0): [[1, 3, 4], [2, 5]], (2, 0, -1, 1, 0): [[1, 2, 5], [3, 4]], (2, 0, 1, -1, 0): [[1, 3, 5], [2, 4]], (0, 2, -1, 1, 0): [[1, 2, 4], [3, 5]], (0, -1, 2, 1, 0): [[1, 2, 3], [4, 5]]}
"""
# construct a dictionary pairing vertices with tableau
t = StandardTableaux(self._partition).last()
tableau_dict = {self._yang_baxter_graph.root():t}
for (u,w,(i,beta)) in self._yang_baxter_graph._edges_in_bfs():
# TODO: improve the following
si = PermutationGroupElement((i,i+1))
tableau_dict[w] = Tableau([map(si, row) for row in tableau_dict[u]])
return tableau_dict
def __iter__(self):
r"""
An iterator for the standard super tableaux associated to the
shape `p` of ``self``.
EXAMPLES::
sage: [t for t in StandardSuperTableaux([2,2])]
[[[1', 2'], [1, 2]], [[1', 1], [2', 2]]]
sage: [t for t in StandardSuperTableaux([3,2])]
[[[1', 2', 3'], [1, 2]],
[[1', 1, 3'], [2', 2]],
[[1', 2', 2], [1, 3']],
[[1', 1, 2], [2', 3']],
[[1', 1, 2'], [2, 3']]]
sage: st = StandardSuperTableaux([2,1])
sage: st[0].parent() is st
True
"""
pi = self.shape
for tableau in StandardTableaux(pi):
yield self.element_class(self, [[PrimedEntry(ZZ(val)/2) for val in row]
for row in tableau])
def cardinality(self):
r"""
Return the number of standard super tableaux of given shape.
The standard super tableaux of a fixed shape `p` are in bijection with
the corresponding standard tableaux (under the alphabet relabeling).
Refer :class:`sage.combinat.tableau.StandardTableaux_shape` for more
details.
EXAMPLES::
sage: StandardSuperTableaux([3,2,1]).cardinality()
16
sage: StandardSuperTableaux([2,2]).cardinality()
2
sage: StandardSuperTableaux([5]).cardinality()
1
sage: StandardSuperTableaux([6,5,5,3]).cardinality()
6651216
sage: StandardSuperTableaux([]).cardinality()
1
"""
pi = self.shape
return StandardTableaux(pi).cardinality()
def s_to_F_on_basis(mu):
return self.sum_of_monomials(StandardTableaux(mu))
def R_to_G_on_basis(alpha):
return self.sum_of_monomials(
ST(t) for t in StandardTableaux(alpha.size())
if descent_composition(t) == alpha)
def f(partition):
n = partition.size()
return (StandardTableaux(partition).cardinality() * t**n /
factorial(n))
