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)