def _setup_tableaux(self):
if self.is_symplectic:
z = Permutation.get_fpf_grassmannian(*self.mu)
ell = z.fpf_involution_length + self.excess
words = [
w for w in z.get_symplectic_hecke_words(length_bound=ell)
if len(w) == ell
]
else:
z = Permutation.get_inv_grassmannian(*self.mu)
ell = z.involution_length + self.excess
words = [
w for w in z.get_involution_hecke_words(length_bound=ell)
if len(w) == ell
]
self.tableaux = []
self.arrays = []
for word in words:
for f in WordCrystalGenerator.get_increasing_factorizations(
word, self.rank, not self.multisetvalued):
w, i = WordCrystalGenerator.factorization_tuple_to_array(f)
p, q = self.forward(w, i)
assert self.insertion_tableau is None or self.insertion_tableau == p
self.insertion_tableau = p
self.tableaux.append(q)
#
a = Tableau()
for j in range(len(w)):
a = a.add(2, j + 1, w[j])
a = a.add(1, j + 1, i[j])
self.arrays.append(a)
def test_next_f_c1():
# transition (C1)
t = Tableau({
(1, 1): 5,
(1, 2): 5,
(1, 3): 5,
(1, 4): 4,
(2, 2): 4,
(4, 3): 6
})
state = FState(t, (4, 3))
state, box = state.next()
i, j = box
t = Tableau({
(1, 1): 5,
(1, 2): 5,
(1, 3): 5,
(1, 4): 4,
(2, 2): 4,
(2, 3): 6
})
assert state == FState(t)
assert i == 2
assert j == 3
def insertion_tableaux(cls, *args, **kwargs):
if len(args) == 1 and type(args[0]) != int:
args = args[0]
p = kwargs.get('p', Tableau())
q = kwargs.get('q', Tableau())
offset = abs(q.last())
state = FState(p)
for index, a in enumerate(args):
state, path = state.insert(a)
i, j = path[-1]
r = index + 1 + offset
if any(b[0] == b[1] for b in path[:-1]) or ((i, j) not in state and i == j):
r = -r
if (i, j) not in state and r > 0:
a = max([a for (a, b) in state.boxes if b == j - 1])
i, j = a, j - 1
elif (i, j) not in state:
b = max([b for (a, b) in state.boxes if i - 1 == a])
i, j = i - 1, b
q = q.add(i, j, r)
p = state.tableau
return p, q
def test_next_f_c3():
# transition (C3)
t = Tableau({
(1, 1): 2,
(1, 2): 3,
(1, 3): 5,
(1, 4): 6,
(2, 2): 4,
(2, 3): 6,
(2, 4): 7,
(3, 3): 8,
(5, 3): 5
})
state = FState(t, (5, 3))
state, box = state.next()
i, j = box
t = Tableau({
(1, 1): 2,
(1, 2): 3,
(1, 3): 5,
(1, 4): 6,
(2, 2): 4,
(2, 3): 6,
(2, 4): 7,
(3, 3): 8,
(5, 4): 6
})
assert state == FState(t, (5, 4))
assert i == 2
assert j == 3
def test_orthogonal_hecke_insertion():
w = (4, 5, 1, 1, 3, 2)
i = (1, 1, 3, 4, 4, 6)
insertion, recording = InsertionAlgorithm.orthogonal_hecke(w)
p = Tableau({(1, 1): 1, (1, 2): 2, (1, 3): 4, (1, 4): 5, (2, 2): 3})
q = Tableau({
(1, 1): 1,
(1, 2): 2,
(1, 3): (-3, -4),
(1, 4): -6,
(2, 2): 5
})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_orthogonal_hecke(p, q) == (w, (1, 2, 3,
4, 5, 6))
insertion, recording = InsertionAlgorithm.orthogonal_hecke(w, i)
q = Tableau({
(1, 1): 1,
(1, 2): 1,
(1, 3): (-3, -4),
(1, 4): -6,
(2, 2): 4
})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_orthogonal_hecke(p, q) == (w, i)
def test_next_f_d1():
# transition (D1)
t = Tableau({
(1, 1): 2,
(1, 2): 3,
(1, 3): 4,
(1, 4): 5,
(2, 2): 6,
(2, 3): 7,
(2, 4): 8,
(2, 6): 4
})
state = FState(t, (2, 6))
state, box = state.next()
i, j = box
t = Tableau({
(1, 1): 2,
(1, 2): 3,
(1, 3): 4,
(1, 4): 5,
(2, 2): 4,
(2, 3): 7,
(2, 4): 8,
(4, 3): 6
})
assert state == FState(t, (4, 3))
assert i == 2
assert j == 2
def test_shifted_rpp_vertical_strips():
mu = ()
assert Tableau._shifted_rpp_vertical_strips(mu) == [((), set())]
mu = (1, )
assert Tableau._shifted_rpp_vertical_strips(mu) == [((), {(1, 1)}),
((1, ), set())]
mu = (2, 1)
assert {nu
for nu, _ in Tableau._shifted_rpp_vertical_strips(mu)} == {
(2, 1),
(2, ),
(1, ),
(),
}
mu = (3, 1)
assert {nu
for nu, _ in Tableau._shifted_rpp_vertical_strips(mu)} == {
(3, 1),
(3, ),
(2, ),
(1, ),
(),
(2, 1),
}
def __init__(self, mu, rank, excess):
super(URTShiftedCrystalGenerator,
self).__init__(mu, rank, excess, False, False)
t = Tableau()
for i in range(len(mu)):
for j in range(mu[i]):
t = t.add(i + 1, i + j + 1, len(t) + 1)
self.insertion_tableau = t
def test_symplectic_hecke_insertion():
w = (4, 2, 6, 1, 7, 5, 3, 4, 2, 1, 3, 2)
i = (1, 2, 2, 3, 3, 4, 5, 5, 6, 8, 8, 9)
insertion, recording = InsertionAlgorithm.symplectic_hecke(w)
p = Tableau({
(1, 1): 2,
(1, 2): 3,
(1, 3): 4,
(1, 4): 5,
(1, 5): 6,
(1, 6): 7,
(2, 2): 4,
(2, 3): 5,
(2, 4): 6,
(2, 5): 7,
(3, 3): 6,
(3, 4): 7,
})
q = Tableau({
(1, 1): 1,
(1, 2): -2,
(1, 3): 3,
(1, 4): -4,
(1, 5): 5,
(1, 6): -10,
(2, 2): 6,
(2, 3): -7,
(2, 4): -9,
(2, 5): -12,
(3, 3): 8,
(3, 4): -11,
})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(
p, q) == (w, tuple(range(1, 13)))
insertion, recording = InsertionAlgorithm.symplectic_hecke(w, i)
q = Tableau({
(1, 1): 1,
(1, 2): -2,
(1, 3): 2,
(1, 4): -3,
(1, 5): 3,
(1, 6): -8,
(2, 2): 4,
(2, 3): -5,
(2, 4): -6,
(2, 5): -9,
(3, 3): 5,
(3, 4): -8,
})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p, q) == (w, i)
def test_row_reading_word():
t = Tableau()
assert t.row_reading_word() == tuple()
assert t == Tableau.from_row_reading_word(t.row_reading_word())
t = Tableau({(1, 1): 1, (1, 2): 3, (1, 3): 4, (2, 1): 2})
assert t.row_reading_word() == (2, 1, 3, 4)
u = Tableau.from_row_reading_word(t.row_reading_word())
assert t == u
def insertion_tableaux(cls, *args, **kwargs):
if len(args) == 1 and type(args[0]) != int:
args = args[0]
p = kwargs.get('p', Tableau())
q = kwargs.get('q', Tableau())
args = tuple(args)
for a in args:
p, q = cls.push(p, q, a)
return p, q
def test_from_string(m=4):
for n in range(m):
for mu in Partition.generate(n, strict=True):
for t in Tableau.semistandard_shifted_marked(n, mu):
u = Tableau(str(t))
if u != t:
print(t)
print(u)
print(t.boxes, u.boxes)
print()
assert Tableau(str(t)) == t
def test_fast_KOG(): # noqa
for mu in Partition.all(7, strict=True):
for p in range(7):
counts = Tableau.KOG_counts_by_shape(p, mu)
tabs = Tableau.KOG_by_shape(p, mu)
print(mu, p)
print(counts)
print(tabs)
print()
assert set(counts) == set(tabs)
for nu in counts:
assert counts[nu] == len(tabs[nu])
def test_next_f_r1():
# transition (R1)
state = FState().add(1)
t = Tableau().add(1, 2, 1)
assert state == FState(t, (1, 2))
state, box = state.next()
i, j = box
t = Tableau().add(1, 1, 1)
assert state == FState(t)
assert i == 1
assert j == 1
def test_row_bump():
p = Tableau("""
1 1,2 2 3,4 4 6
2,3 3 3,4 5 6 8
3 4 5 6 7
4 6 7 8
6 """) # noqa
q = Tableau("""
1 1,2 2 3,4 4 6
2,3 3 3 5 6 8
3 4 4 6 7
4 5 7 8
6 6 """) # noqa
assert row_extract_and_bump(p) == (q, 5)
assert reverse_row_extract_and_bump(q, 5, 2) == (p, 3)
def irsk(pi, n=None):
if n is None:
n = pi.rank
cycles = sorted([(pi(i), i) for i in range(1, n + 1) if i <= pi(i)])
tab = Tableau()
for b, a in cycles:
if a == b:
tab = tab.add(1, tab.max_column() + 1, a)
else:
p, q = InsertionAlgorithm.hecke(tab.row_reading_word() + (a, ))
i, j = q.find(len(q))[0]
while j > 1 and (i + 1, j - 1) not in p:
j = j - 1
tab = p.add(i + 1, j, b)
return tab
def print_tableau_operation(n=6):
mapping = {}
for mu in Partition.generate(n):
for tab in Tableau.standard(mu):
w = irsk_inverse(tab)
ntab = dual_irsk(w, sum(mu)).transpose()
mapping[tab] = ntab
print(tab)
print('w =', w)
print(ntab)
#lines = str(tab).split('\n')
#nlines = str(ntab).split('\n')
#assert len(lines) == len(nlines)
#print('\n'.join([lines[i] + ' -> ' + nlines[i] for i in range(len(lines))]))
print()
print()
print()
print()
orders = {}
for tab in mapping:
o = 1
x = mapping[tab]
while x != tab:
o += 1
x = mapping[x]
orders[tab] = o
return orders, mapping
def _slow_transposed_dual_stable_grothendieck_q(cls,
num_variables,
mu,
nu=()):
p = 0
for tab in Tableau.semistandard_shifted_marked(num_variables, mu, nu):
m = 1
for i in range(1, num_variables + 1):
r = len({x for x, y, v in tab if v[0] == i})
c = len({y for x, y, v in tab if v[0] == -i})
a = len({(x, y) for x, y, v in tab if abs(v[0]) == i})
x = Polynomial.x(i)
m *= x**(r + c) * (x + 1)**(a - r - c)
p += m
dictionary = {}
for e in p:
tup = num_variables * [0]
for i in e:
tup[i - 1] = e[i]
dictionary[tuple(tup)] = p[e]
return SymmetricPolynomial({
SymmetricMonomial(num_variables, alpha): coeff *
(-BETA**-1)**(sum(alpha))
for alpha, coeff in dictionary.items()
if Partition.is_partition(alpha)
}) * (-BETA)**(sum(mu) - sum(nu))
def print_mn_operators(n=8):
def wstr(w):
return ' $\\barr{c}' + str(
w) + ' \\\\ ' + w.oneline_repr() + ' \\earr$ '
ans = []
for n in range(2, n + 1, 2):
for mu in Partition.generate(n):
s = []
i = 0
for t in Tableau.standard(mu):
u = dual_irsk(irsk_inverse(t), n).transpose()
s += ['\n&\n'.join([t.tex(), u.tex()])]
i += 1
if i * t.max_row() >= 24:
s += [
'\n\\end{tabular} \\newpage \\begin{tabular}{ccccc} Tableau & Tableau \\\\ \\hline '
]
i = 0
s = '\n \\\\ \\\\ \n'.join(s)
ans += [
'\\begin{tabular}{ccccc} Tableau & Tableau \\\\ \\hline \\\\ \\\\ \n'
+ s + '\n\\end{tabular}'
]
ans = '\n\n\\newpage\n\n'.join(ans + [''])
with open(
'/Users/emarberg/Dropbox/projects/affine-transitions/notes/eric_notes/examples.tex',
'w') as f:
f.write(ans)
f.close()
def test_unprime(n=3, mu=(4, 2)):
u = list(
Tableau.semistandard_shifted_marked_setvalued(n,
mu,
diagonal_primes=True))
mapping = {}
for t in u:
tt = unprime(t)
if tt in mapping:
print('target:')
print(tt)
print('t =', t.boxes)
nu = tt.shape()
assert t.shape() == mu
assert len(nu) == len(mu)
assert all(nu[i] in [mu[i], mu[i] + 1] for i in range(len(mu)))
assert t.is_semistandard(diagonal_primes=True)
assert tt.is_semistandard(diagonal_primes=True)
mapping[tt].append(t)
for x in mapping[tt]:
print(x)
print(x.boxes)
print()
print()
print()
else:
mapping[tt] = [t]
def _slow_schur_p(cls, num_variables, mu, nu=()):
return cls._slow_vectorize(
num_variables,
Tableau.semistandard_shifted_marked(num_variables,
mu,
nu,
diagonal_primes=False))
def test_descents():
t = Tableau({
(1, 1): 1,
(1, 2): -2,
(1, 3): 3,
(1, 4): -4,
(1, 5): 5,
(1, 6): -10,
(2, 2): 6,
(2, 3): -7,
(2, 4): -9,
(2, 5): -12,
(3, 3): 8,
(3, 4): -11,
})
assert t.descent_set() == {1, 3, 5, 6, 8, 9, 11}
def tableaux(self):
if self._tableaux is None:
self._tableaux = [
t for t in Tableau.semistandard_shifted_marked_setvalued(
self.rank, self.mu, diagonal_primes=False)
if len(t) == sum(self.mu) + self.excess
]
return self._tableaux
def test_semistandard_marked_rpp():
mu = (1, )
print(Tableau.semistandard_marked_rpp(1, mu, diagonal_nonprimes=True))
print()
assert Tableau.semistandard_marked_rpp(1, mu, diagonal_nonprimes=True) == {
MarkedReversePlanePartition({(1, 1): 1}),
MarkedReversePlanePartition({(1, 1): -1}),
}
print(Tableau.semistandard_marked_rpp(1, mu, diagonal_nonprimes=False))
print()
assert Tableau.semistandard_marked_rpp(1, mu,
diagonal_nonprimes=False) == {
MarkedReversePlanePartition({
(1, 1):
-1
}),
}
def test_slide():
p = Tableau("""
1 1 2 4 5 5
1 2 3 4 4 6
2 2 6 6 7
3 4 7 9
5 """)
x = p.remove(2, 2)
q = Tableau("""
1 1 2 4 5 5
1 2 3 4 4 6
2 4 6 6 7
3 7 9
5 """)
assert slide(x, 2, 2) == (q, 4, 4)
assert extract_and_slide(p) == (q, 4, 4)
assert reverse_slide(q, 4, 2) == (x, 2)
def test_GQ_pieri_slow(): # noqa
for mu in Partition.all(10, strict=True):
for p in [1, 2, 3]:
ans = Vector()
for nu, tabs in Tableau.KLG_by_shape(p, mu).items():
ans += Vector(
{nu: utils.beta**(sum(nu) - sum(mu) - p) * len(tabs)})
f = utils.GQ(len(mu) + 1, mu) * utils.GQ(len(mu) + 1, (p, ))
assert ans == utils.GQ_expansion(f)
def __init__(self, mu, max_entry, multisetvalued=False, setvalued=True):
assert not multisetvalued
self.mu = mu
self.max_entry = max_entry
self.tableaux = list(
Tableau.semistandard(max_entry, mu, setvalued=setvalued))
self._edges = None
self._components = None
self.multisetvalued = multisetvalued
def test_instance():
tabs = [
Tableau({
(1, 2): (1, ),
(1, 3): (1, ),
(1, 1): (1, ),
(2, 3): (-3, 2),
(1, 4): (-3, -2, 2),
(2, 2): (-2, 2),
(1, 5): (3, ),
(1, 6): (3, ),
(2, 4): (3, ),
(3, 3): (-3, )
}),
Tableau({
(1, 2): (1, ),
(1, 3): (1, ),
(1, 1): (1, ),
(2, 3): (2, 3),
(1, 4): (2, 3),
(2, 2): (-2, 2),
(1, 5): (3, ),
(1, 6): (3, ),
(2, 4): (4, ),
(3, 3): (4, )
}),
Tableau({
(1, 1): (-2, -1, 1),
(1, 2): (2, ),
(2, 2): (3, ),
(1, 3): (-3, )
}),
]
for t in tabs:
tt = unprime(t)
print(t)
print(tt)
mu = t.shape()
nu = tt.shape()
assert len(nu) == len(mu)
assert all(nu[i] in [mu[i], mu[i] + 1] for i in range(len(mu)))
assert t.is_semistandard(diagonal_primes=True)
assert tt.is_semistandard(diagonal_primes=True)
def test_slow_dual_stable_grothendieck_pq():
n = 3
mu = (1, )
g = SymmetricPolynomial._slow_dual_stable_grothendieck_p(n, mu)
h = SymmetricPolynomial._slow_dual_stable_grothendieck_q(n, mu)
print(g)
print(h)
print()
assert g == SymmetricMonomial(n, (1, ))
assert h == 2 * SymmetricMonomial(n, (1, ))
n = 3
mu = (2, )
for t in Tableau.semistandard_marked_rpp(3, mu, diagonal_nonprimes=False):
print(t)
g = SymmetricPolynomial._slow_dual_stable_grothendieck_p(n, mu)
print(g)
assert g == \
SymmetricPolynomial._slow_dual_stable_grothendieck(n, (1, 1)) + \
SymmetricPolynomial._slow_dual_stable_grothendieck(n, (2,))
n = 3
mu = (2, 1)
for t in Tableau.semistandard_marked_rpp(n, mu):
print(t)
g = SymmetricPolynomial._slow_dual_stable_grothendieck_p(n, mu)
h = SymmetricPolynomial._slow_dual_stable_grothendieck_q(n, mu)
print(g)
print(h)
print()
assert g == -BETA * SymmetricMonomial(
n,
(1, 1)) + -BETA * SymmetricMonomial(n, (2, )) + 2 * SymmetricMonomial(
n, (1, 1, 1)) + SymmetricMonomial(n, (2, 1))
n = 5
mu = (3, 2)
g = SymmetricPolynomial._slow_dual_stable_grothendieck_p(n, mu)
h = SymmetricPolynomial._slow_dual_stable_grothendieck_q(n, mu)
n = 6
mu = (3, 2, 1)
assert SymmetricPolynomial._slow_dual_stable_grothendieck_p(n, mu) == \
SymmetricPolynomial._slow_dual_stable_grothendieck(n, mu)
def test_symplectic_hecke_insertion_setvalued():
w = (2, 2, 4, 3)
i = (1, 1, 1, 4)
insertion, recording = InsertionAlgorithm.symplectic_hecke(w)
p = Tableau({(1, 1): 2, (1, 2): 3, (2, 2): 4})
q = Tableau({(1, 1): (1, 2), (1, 2): 3, (2, 2): 4})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p,
q) == (w, (1, 2, 3, 4))
insertion, recording = InsertionAlgorithm.symplectic_hecke(w, i)
q = Tableau({(1, 1): (1, 1), (1, 2): 1, (2, 2): 4})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p, q) == (w, i)
i = (1, 2, 3, 3)
insertion, recording = InsertionAlgorithm.symplectic_hecke(w, i, False)
q = Tableau({(1, 1): (1, 2), (1, 2): -3, (2, 2): 3})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p, q, False) == (w, i)
w = (4, 2, 2, 3)
i = (2, 4, 4, 4)
insertion, recording = InsertionAlgorithm.symplectic_hecke(w)
p = Tableau({(1, 1): 2, (1, 2): 3, (2, 2): 4})
q = Tableau({(1, 1): 1, (1, 2): (-3, -2), (2, 2): 4})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p,
q) == (w, (1, 2, 3, 4))
insertion, recording = InsertionAlgorithm.symplectic_hecke(w, i)
q = Tableau({(1, 1): 2, (1, 2): (-4, -4), (2, 2): 4})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p, q) == (w, i)
i = (1, 1, 2, 3)
insertion, recording = InsertionAlgorithm.symplectic_hecke(w, i, False)
q = Tableau({(1, 1): 1, (1, 2): (1, 2), (2, 2): 3})
assert insertion == p
assert recording == q
assert InsertionAlgorithm.inverse_symplectic_hecke(p, q, False) == (w, i)
