def __classcall_private__(cls, w, factors, excess):
"""
Classcall to mend the input.
EXAMPLES::
sage: from sage.combinat.crystals.fully_commutative_stable_grothendieck import DecreasingHeckeFactorizations
sage: S = SymmetricGroup(3+1)
sage: w = S.from_reduced_word([1, 2 ,1])
sage: F = DecreasingHeckeFactorizations(w, 4, 1); F
Decreasing Hecke factorizations with 4 factors associated to [1, 2, 1] with excess 1
sage: from sage.monoids.hecke_monoid import HeckeMonoid
sage: H = HeckeMonoid(SymmetricGroup(3+1))
sage: w = H.from_reduced_word([1, 2 ,1])
sage: G = DecreasingHeckeFactorizations(w, 4, 1); G
Decreasing Hecke factorizations with 4 factors associated to [1, 2, 1] with excess 1
sage: F is G
True
"""
from sage.monoids.hecke_monoid import HeckeMonoid
if isinstance(w.parent(), SymmetricGroup):
H = HeckeMonoid(w.parent())
w = H.from_reduced_word(w.reduced_word())
if (not w.reduced_word()) and excess != 0:
raise ValueError("excess must be 0 for the empty word")
return super(DecreasingHeckeFactorizations,
cls).__classcall__(cls, w, factors, excess)
def __classcall_private__(self, t, max_value=None, parent=None):
"""
Assign the correct parent for ``t`` and call ``t`` as an element of that parent
EXAMPLES::
sage: from sage.combinat.crystals.fully_commutative_stable_grothendieck import DecreasingHeckeFactorization
sage: h1 = DecreasingHeckeFactorization([[3, 1], [], [3, 2]])
sage: h1.parent()
Fully commutative stable Grothendieck crystal of type A_2 associated to [1, 3, 2] with excess 1
sage: h2 = DecreasingHeckeFactorization(h1)
sage: h1 == h2
True
sage: h1 = DecreasingHeckeFactorization([[3, 1], [2, 1], [2, 1]])
sage: F = h1.parent(); F
Decreasing Hecke factorizations with 3 factors associated to [1, 3, 2, 1] with excess 2
sage: h2 = F(h1)
sage: h1 == h2
True
TESTS::
sage: DecreasingHeckeFactorization([[]])
()
"""
_check_decreasing_hecke_factorization(t)
if isinstance(t, DecreasingHeckeFactorization):
u = t.value
if parent is None:
parent = t.parent()
else:
u = t
if parent is None:
if max_value is None:
letters = [x for factor in t for x in factor]
max_value = max(letters) if letters else 1
from sage.monoids.hecke_monoid import HeckeMonoid
S = SymmetricGroup(max_value + 1)
H = HeckeMonoid(S)
word = H.from_reduced_word(x for factor in t
for x in factor).reduced_word()
factors = len(t)
excess = sum(len(l) for l in t) - len(word)
p = permutation.from_reduced_word(word)
if p.has_pattern([3, 2, 1]):
word = S.from_reduced_word(word)
parent = DecreasingHeckeFactorizations(
word, factors, excess)
else:
word = S.from_reduced_word(word)
parent = FullyCommutativeStableGrothendieckCrystal(
word, factors, excess)
return parent.element_class(parent, u)
def _check_containment(t, parent):
"""
Check if ``t`` is an element of ``parent``.
EXAMPLES::
sage: S = SymmetricGroup(3+1)
sage: w = S.from_reduced_word([1, 3, 2])
sage: B = crystals.FullyCommutativeStableGrothendieck(w, 3, 2)
sage: from sage.combinat.crystals.fully_commutative_stable_grothendieck import DecreasingHeckeFactorization, _check_containment
sage: h1 = DecreasingHeckeFactorization([[3, 1], [3], [3, 2]], 4)
sage: _check_containment(h1, B)
sage: h2 = DecreasingHeckeFactorization([[3, 1], [3], [], [3, 2]])
sage: _check_containment(h2, B)
Traceback (most recent call last):
...
ValueError: number of factors do not match
sage: h3 = [[3, 1], [2], [3, 2]]
sage: _check_containment(h3, B)
Traceback (most recent call last):
...
ValueError: self and parent must be specified based on equivalent words
sage: h4 = DecreasingHeckeFactorization([[3, 1], [3, 1], [3, 2]], 3)
sage: _check_containment(h4, B)
Traceback (most recent call last):
...
ValueError: number of excess letters do not match
"""
if isinstance(t, DecreasingHeckeFactorization):
factors = t.factors
w = t.w
excess = t.excess
else:
factors = len(t)
max_value = parent.max_value
from sage.monoids.hecke_monoid import HeckeMonoid
H = HeckeMonoid(SymmetricGroup(max_value + 1))
w = tuple(
H.from_reduced_word(x for factor in t
for x in factor).reduced_word())
excess = sum(len(l) for l in t) - len(w)
if factors != parent.factors:
raise ValueError("number of factors do not match")
if w != parent.w:
raise ValueError(
"self and parent must be specified based on equivalent words")
if excess != parent.excess:
raise ValueError("number of excess letters do not match")
def __classcall_private__(cls, w, factors, excess, shape=False):
"""
Classcall to mend the input.
EXAMPLES::
sage: A = crystals.FullyCommutativeStableGrothendieck([[3, 3], [2, 1]], 4, 1, shape=True); A
Fully commutative stable Grothendieck crystal of type A_3 associated to [3, 2, 4] with excess 1
sage: B = crystals.FullyCommutativeStableGrothendieck(SkewPartition([[3, 3], [2, 1]]), 4, 1, shape=True)
sage: A is B
True
sage: C = crystals.FullyCommutativeStableGrothendieck((2, 1), 3, 2, shape=True); C
Fully commutative stable Grothendieck crystal of type A_2 associated to [1, 3, 2] with excess 2
sage: D = crystals.FullyCommutativeStableGrothendieck(Partition([2, 1]), 3, 2, shape=True)
sage: C is D
True
"""
from sage.monoids.hecke_monoid import HeckeMonoid
if shape:
from sage.combinat.partition import _Partitions
from sage.combinat.skew_partition import SkewPartition
cond1 = isinstance(w, (tuple, list)) and len(
w) == 2 and w[0] in _Partitions and w[1] in _Partitions
cond2 = isinstance(w, SkewPartition)
if cond1 or cond2:
sh = SkewPartition([w[0], w[1]])
elif w in _Partitions:
sh = SkewPartition([w, []])
else:
raise ValueError("w needs to be a (skew) partition")
word = _to_reduced_word(sh)
max_value = max(word) if word else 1
H = HeckeMonoid(SymmetricGroup(max_value + 1))
w = H.from_reduced_word(word)
else:
if isinstance(w.parent(), SymmetricGroup):
H = HeckeMonoid(w.parent())
w = H.from_reduced_word(w.reduced_word())
if (not w.reduced_word()) and excess != 0:
raise ValueError("excess must be 0 for the empty word")
return super(FullyCommutativeStableGrothendieckCrystal,
cls).__classcall__(cls, w, factors, excess)