def test_star(n=8): for nu in Partition.generate(n, even_parts=True): mu = Partition.transpose(nu) lu = Partition.transpose(tuple(2 * mu[i] for i in range(0, len(mu), 2))) assert mu == Partition.transpose( tuple(2 * lu[i] for i in range(0, len(lu), 2)))
def test_molecular_correspondence(n=8): for mu in Partition.generate(n, even_parts=True): mu = Partition.transpose(mu) mapping = construct_molecular_correspondence(mu) for v in mapping: w = mapping[v] assert irsk(v).transpose() == dual_irsk(w)
def test_other_dual(n=5, k=5): partitions = list(Partition.all(k, strict=True)) for lam in partitions: for kappa in partitions: if Partition.contains(lam, kappa): lhs = 2**sum(lam) * gp(n, lam, kappa) rhs = 0 expected = { tuple(lam[i] - a[i] for i in range(len(a))) for a in zero_one_tuples(len(lam)) if all(lam[i] - a[i] > 0 for i in range(len(a))) and all( lam[i - 1] - a[i - 1] > lam[i] - a[i] for i in range(1, len(a))) } for mu in expected: for nu in Partition.subpartitions(mu, strict=True): if len(nu) == len(kappa) and Partition.contains( nu, kappa): rhs += 2**(len(nu) - len(mu) + overlap(lam, mu) + sum(kappa) + sum(mu) - sum(nu)) * cols( nu, kappa) * (-beta)**( sum(lam) - sum(mu) + sum(nu) - sum(kappa)) * gq(n, mu, nu) print('n =', n, 'lambda =', lam, 'kappa =', kappa) if lhs != rhs: print() print(lhs) print(rhs) print() assert lhs == rhs
def _rpp_horizontal_strips(cls, mu, lam): # noqa if mu == lam: return [(mu, set())] if not Partition.contains(mu, lam): return [] def remove_box(nu, i): if i < len(nu) and nu[i] > 0: nu = nu[:i] + (nu[i] - 1, ) + nu[i + 1:] while nu and nu[-1] == 0: nu = nu[:-1] if all(nu[j] >= nu[j + 1] for j in range(len(nu) - 1)): if Partition.contains(nu, lam): yield nu def remove_all_boxes(nu, i): queue = [nu] while queue: nu, queue = queue[0], queue[1:] yield nu for x in remove_box(nu, i): queue.append(x) ans = set() queue = [(mu, len(mu) - 1)] while queue: nu, i = queue[0] queue = queue[1:] if i >= 0: for nu in remove_all_boxes(nu, i): ans.add(nu) queue.append((nu, i - 1)) return [(nu, Partition.skew(mu, nu)) for nu in ans]
def _semistandard_shifted_marked(cls, max_entry, mu, lam, diagonal_primes, setvalued): # noqa assert Partition.is_strict_partition(mu) ans = set() if mu == lam: ans = {Tableau()} elif Partition.contains(mu, lam) and max_entry > 0: for nu1, diff1, corners1 in cls._shifted_horizontal_strips( mu, lam): for nu2, diff2, corners2 in cls._shifted_vertical_strips( nu1, lam): if not diagonal_primes: if any(i == j for (i, j) in diff2): continue corners2 = [(i, j) for (i, j) in corners2 if i != j] for aug1 in cls._subsets(diff1, corners1, setvalued): for aug2 in cls._subsets(diff2, corners2, setvalued): for tab in cls._semistandard_shifted_marked( max_entry - 1, nu2, lam, diagonal_primes, setvalued): for (i, j) in aug1: tab = tab.add(i, j, max_entry) for (i, j) in aug2: tab = tab.add(i, j, -max_entry) ans.add(tab) return ans
def get_molecules_n(n, verbose=False): ans = {} for mu in Partition.generate(n, even_parts=True): mu = Partition.transpose(mu) molecule = molecule_n(mu) ans[mu] = molecule return ans
def _shifted_vertical_strips(cls, mu, lam): # noqa assert Partition.is_strict_partition(mu) if not Partition.contains(mu, lam): return [] core = [a - 1 for a in mu] for i in range(len(lam)): core[i] = max(core[i], lam[i]) core = tuple(core) ans = [] level = {core} while level: for nu in level: diff = {(i + 1, i + j + 1) for i in range(len(mu)) for j in range(nu[i], mu[i])} nu = nu if nu and nu[-1] > 0 else nu[:-1] corners = [(i + 1, i + nu[i]) for i in range(len(nu)) if core[i] < nu[i] and (i == len(nu) - 1 or 1 + nu[i + 1] < nu[i])] ans.append((nu, diff, corners)) level = { nu[:i] + (nu[i] + 1, ) + nu[i + 1:] for i in range(len(mu)) for nu in level if nu[i] < mu[i] and (i == 0 or 1 + nu[i] < nu[i - 1]) } return ans
def _shifted_rpp_vertical_strips(cls, mu): # noqa assert Partition.is_strict_partition(mu) if mu == (): return [(mu, set())] def remove_box(nu, i): for j in range(len(nu) - 1, -1, -1): if j + nu[j] == i + 1: nu = nu[:j] + (nu[j] - 1, ) + nu[j + 1:] while nu and nu[-1] == 0: nu = nu[:-1] yield nu return def remove_all_boxes(nu, i): queue = [nu] while queue: nu, queue = queue[0], queue[1:] yield nu for x in remove_box(nu, i): queue.append(x) ans = set() queue = [(mu, (mu[0] if mu else 0) - 1)] while queue: nu, i = queue[0] queue = queue[1:] if i >= 0: for nu in remove_all_boxes(nu, i): ans.add(nu) queue.append((nu, i - 1)) return [(nu, Partition.skew(mu, nu, shifted=True)) for nu in ans]
def get_target(domain): target = RowVector() w = [RowVector() for i in range(9)] for (nu, mu) in domain: nu1, mu1 = Partition.trim(nu[1:]), Partition.trim(mu[1:]) nu2, mu2 = Partition.trim(nu[2:]), Partition.trim(mu[2:]) nu3, mu3 = Partition.decrement_one(nu), mu m = sum(nu) - sum(mu) + 2 v = lvector(nu, mu, m) target |= v w[0] |= lvector(nu1, mu1, m) w[1] |= lvector(nu1, mu1, m) >> 1 w[2] |= lvector(nu1, mu1, m) >> 2 w[3] |= lvector(nu2, mu2, m) w[4] |= lvector(nu2, mu2, m) >> 1 w[5] |= lvector(nu2, mu2, m) >> 2 w[6] |= lvector(nu3, mu3, m) w[7] |= lvector(nu3, mu3, m) >> 1 w[8] |= lvector(nu3, mu3, m) >> 2 assert lvector(nu, mu, m) == rvector(nu, mu, m) return target, w
def _count_semistandard_shifted_marked(cls, max_entry, mu, lam, diagonal_primes, setvalued): # noqa assert Partition.is_strict_partition(mu) ans = defaultdict(int) if mu == lam: ans[()] = 1 elif Partition.contains(mu, lam) and max_entry > 0: for nu1, diff1, corners1 in cls._shifted_horizontal_strips( mu, lam): for nu2, diff2, corners2 in cls._shifted_vertical_strips( nu1, lam): if not diagonal_primes: if any(i == j for (i, j) in diff2): continue corners2 = [(i, j) for (i, j) in corners2 if i != j] for partition, count in cls._count_semistandard_shifted_marked( max_entry - 1, nu2, lam, diagonal_primes, setvalued).items(): for i in range(len(corners1) + 1 if setvalued else 1): for j in range( len(corners2) + 1 if setvalued else 1): m = len(diff1) + len(diff2) + i + j if m == 0: ans[partition] += count elif len(partition) < max_entry - 1 or ( partition and m > partition[-1]): break else: updated_partition = partition + (m, ) ans[updated_partition] += count * nchoosek( len(corners1), i) * nchoosek( len(corners2), j) return ans
def _shifted_rpp_horizontal_strips(cls, mu): # noqa assert Partition.is_strict_partition(mu) if mu == (): return [(mu, set())] def remove_box(nu, i): if i < len(nu) and nu[i] > 0: nu = nu[:i] + (nu[i] - 1, ) + nu[i + 1:] while nu and nu[-1] == 0: nu = nu[:-1] if all(nu[j] > nu[j + 1] for j in range(len(nu) - 1)): yield nu def remove_all_boxes(nu, i): queue = [nu] while queue: nu, queue = queue[0], queue[1:] yield nu for x in remove_box(nu, i): queue.append(x) ans = set() queue = [(mu, len(mu) - 1)] while queue: nu, i = queue[0] queue = queue[1:] if i >= 0: for nu in remove_all_boxes(nu, i): ans.add(nu) queue.append((nu, i - 1)) return [(nu, Partition.skew(mu, nu, shifted=True)) for nu in ans]
def test(n=5, k=5): partitions = list(Partition.all(k, strict=True)) for mu in partitions: for kappa in partitions: rhs = 0 expected = { tuple(mu[i] + a[i] for i in range(len(a))) for a in zero_one_tuples(len(mu)) if all(mu[i - 1] + a[i - 1] > mu[i] + a[i] for i in range(1, len(a))) } for lam in expected: rhs += 2**(len(mu) - sum(lam) + sum(mu)) * cols(lam, mu) * ( -beta)**(sum(lam) - sum(mu)) * GP_doublebar(n, lam, kappa) lhs = 0 expected = { tuple(kappa[i] - a[i] for i in range(len(a))) for a in zero_one_tuples(len(kappa)) if all(kappa[i - 1] - a[i - 1] > kappa[i] - a[i] for i in range(1, len(a))) and all( 0 < kappa[i] - a[i] <= (mu[i] if i < len(mu) else 0) for i in range(len(a))) } for nu in expected: lhs += 2**(len(kappa) - sum(kappa) + sum(nu)) * cols( kappa, nu) * (-beta)**(sum(kappa) - sum(nu)) * GQ_doublebar(n, mu, nu) if lhs != 0 or rhs != 0: print('n =', n, 'mu =', mu, 'kappa =', kappa) # print() # print(lhs) # print() assert lhs == rhs if Partition.contains(mu, kappa): lhs = 2**(sum(kappa) + len(kappa)) * GQ_doublebar(n, mu, kappa) rhs = 0 expected = { tuple(mu[i] + a[i] for i in range(len(a))) for a in zero_one_tuples(len(mu)) if all(mu[i - 1] + a[i - 1] > mu[i] + a[i] for i in range(1, len(a))) } for nu in Partition.subpartitions(kappa, strict=True): if len(nu) == len(kappa): for lam in expected: rhs += 2**(len(mu) + overlap(kappa, nu) + sum(nu) - sum(lam) + sum(mu)) * cols(lam, mu) * (-beta)**( sum(lam) - sum(mu) + sum(kappa) - sum(nu)) * GP_doublebar(n, lam, nu) print('n =', n, 'mu =', mu, 'kappa =', kappa) print() print(lhs) print(rhs) print() assert lhs == rhs
def test_rims(): assert set(Partition.rims((), 0)) == {()} assert set(Partition.rims((), 1)) == {(), ((1, 1), )} assert set(Partition.rims((), 2)) == {(), ((1, 1), ), ((1, 1), (1, 2))} assert set(Partition.rims((1, ), 1)) == {(), ((1, 2), ), ((1, 2), (2, 2))} assert set(Partition.rims( (3, 2))) == {(), ((1, 4), ), ((1, 4), (2, 4)), ((3, 3), ), ((1, 4), (3, 3)), ((1, 4), (2, 4), (3, 3)), ((1, 4), (2, 4), (3, 3), (3, 4))} # noqa
def _vertical_strips(cls, mu, lam): ans = [] strips = cls._horizontal_strips(Partition.transpose(mu), Partition.transpose(lam)) for nu, diff, corners in strips: nu = Partition.transpose(nu) diff = {(j, i) for (i, j) in diff} corners = [(j, i) for (i, j) in corners] ans.append((nu, diff, corners)) return ans
def test_anti_representatives(n=8): for nu in Partition.generate(n, even_parts=True): mu = Partition.transpose(nu) lu = Partition.transpose(tuple(2 * mu[i] for i in range(0, len(mu), 2))) print(mu) print(lu) print() assert representative_m(lu) == anti_representative_n(mu)
def search(n, k): partitions = list(Partition.all(k, strict=True)) for mu in partitions: for nu in partitions: if Partition.contains( mu, nu) and len(nu) > 0 and nu[0] != mu[0] and not any( nu[i] > mu[i + 1] for i in range(min(len(nu), len(mu) - 1))): target = gp_expand(GQ, n, mu, nu) print('\ntarget:', target, ' ', mu, nu) print() seen = set() s = [] for aa in Partition.successors(mu, strict=True): for a in Partition.successors(aa, strict=True): for bb in Partition.successors(nu, strict=True): for b in Partition.successors(bb, strict=True): if Partition.contains( a, b) and Partition.skew_key( a, b, True) not in seen: s += [(gp_expand(GP, n, a, b), a, b)] seen.add(Partition.skew_key(a, b, True)) display = [(str(x), a, b) for (x, a, b) in s] width = 48 display = [(x if len(x) < width else x[:width] + '...', a, b) for (x, a, b) in display] m = max([len(x) for x, _, _ in display]) for i, (x, a, b) in enumerate(display): print(' ', x, ' ' * (m - len(x)), ' ', a, b, ':', i + 1) assert target.is_expressable(*[x[0] for x in s])
def op(vector): ans = 0 for mu, coefficient in vector.items(): row = Partition.find_shifted_inner_corner(mu, abs(index)) if row is not None: ans += Vector({mu: beta * coefficient}) continue row = Partition.find_shifted_outer_corner(mu, abs(index)) if row is not None: nu = Partition.add(mu, row) ans += Vector({nu: coefficient}) return ans
def test_q(n=4): lam = tuple([n - i for i in range(n)]) for mu in Partition.subpartitions(lam, strict=True): for nu in Partition.subpartitions(mu, strict=True): f = SymmetricPolynomial._slow_transposed_dual_stable_grothendieck_q(n, mu, nu) g = SymmetricPolynomial.dual_stable_grothendieck_q(n, mu, nu) ef, eg = f.omega_schur_expansion(f), g.schur_expansion(g) print('n =', n, 'mu =', mu) print(ef) print(eg) print() assert ef == eg
def op(vector): ans = 0 for mu, coefficient in vector.items(): e = 0 i = abs(index) row = Partition.find_shifted_inner_corner(mu, i) while row is not None: i = i + 1 mu = Partition.remove_inner_corner(mu, row) ans += Vector({mu: (-beta)**e}) row = Partition.find_shifted_inner_corner(mu, i) e += 1 return ans
def rshapes(nu, mu=None): if nu not in RSHAPES: RSHAPES[nu] = {} for lam in Partition.decompose_shifted_shape_by_vertical_strips(nu): if len(lam) == len(nu): for x in Partition.decompose_shifted_shape_by_rims(lam): if x not in RSHAPES[nu]: RSHAPES[nu][x] = [] RSHAPES[nu][x].append(lam) if mu is None: return RSHAPES[nu] else: return RSHAPES[nu].get(mu, [])
def expand_search(n, k): if n not in gp_skew: gp_skew[n] = {} if n not in gq_skew: gq_skew[n] = {} partitions = list(Partition.all(k, strict=True)) for mu in partitions: for kappa in partitions: if Partition.contains(mu, nu) and not (nu and nu[0] == mu[0]): key = (nu, mu) gp_skew[n][key] = substitute( SymmetricPolynomial.GP_expansion(GP(n, mu, nu)), None) gq_skew[n][key] = substitute( SymmetricPolynomial.GQ_expansion(GQ(n, mu, nu)), None)
def _standard(cls, mu, lam): # noqa ans = set() if mu == lam: ans = {Tableau()} elif Partition.contains(mu, lam): n = sum(mu) - sum(lam) for i in range(len(mu)): row, col = (i + 1), mu[i] nu = list(mu) nu[i] -= 1 nu = Partition.trim(nu) if Partition.is_partition(nu): for tab in cls._standard(nu, lam): ans.add(tab.add(row, col, n)) return ans
def _KOG_count_helper(cls, p, rim): # noqa if len(rim) == 0: return 1 if p == 0 else 0 if p <= 0: return 0 term = Partition.rim_terminal_part(rim) if len(term) == 2 and p == 1: return 0 elif len(term) == 2: left = tuple(a for a in rim if a not in term) x = cls._KOG_count_helper(p, left) y = cls._KOG_count_helper(p - 1, left) z = cls._KOG_count_helper(p - 2, left) c = 2 if p > 2 else 1 return x + (1 + c) * y + c * z else: left = tuple(a for a in rim if a != term[-1]) x = cls._KOG_count_helper(p, left) y = cls._KOG_count_helper(p - 1, left) c = 2 if p > 1 else 1 if len(term) == 1: return c * (x + y) if len(term) == 3 and term[0][0] != term[-1][0] and term[0][ 1] != term[-1][1]: return x + y if len(term) == 3: return y
def is_reducible(nu, mu): if len(nu) == 0: return True if any(nu[i] == mu[i] for i in range(len(mu))): return True if sum(nu) - sum(mu) <= 3: return True # if any(nu[i] + 1 < mu[i - 1] for i in range(1, len(nu))): # return True # if nu == mu: # return True # if Partition.get(nu, 1) <= Partition.get(mu, 1) + 1: # return True skew = Partition.skew(nu, mu, shifted=True) (i, j) = min(skew, key=lambda ij: (-ij[0], ij[1])) while True: if (i - 1, j) in skew: (i, j) = (i - 1, j) elif (i, j + 1) in skew: (i, j) = (i, j + 1) else: break if (i, j) != max(skew, key=lambda ij: (-ij[0], ij[1])): return True
def compare(max_size_of_partitions, number_of_values_of_n, op1, op2): for mu in Partition.all(max_size_of_partitions, strict=True): s = mu[0] if mu else 0 coefficients = defaultdict(dict) differences = defaultdict(list) for n in range(s, number_of_values_of_n + s): lhs = op1(n)(op2(n)(mu)) rhs = op2(n)(op1(n)(mu)) _extract(rhs - lhs, n, coefficients, differences) if coefficients: print() print('mu =', mu) print() for nu in sorted(coefficients, reverse=True): k = max(mu[0] if mu else 0, nu[0] if nu else 0) if k >= number_of_values_of_n + s: continue print(' mu =', mu, '--> nu =', nu, ': coefficient of nu in op2(op1(mu)) - op1(op2(mu)) is') print() for n in range(k, number_of_values_of_n + s): c = coefficients[nu].get(n, 0) print(' n =', n, ':', c) print() print() input('continue (press any key)')
def compare_AL_R_versus_R_AL(max_size_of_partitions, number_of_values_of_n): sb = 'x / (1 + %s)' % str(beta) for mu in Partition.all(max_size_of_partitions, strict=True): print() print('mu =', mu) print() s = mu[0] if mu else 0 coefficients = defaultdict(dict) differences = defaultdict(list) for n in range(s, number_of_values_of_n + s): op_AL = operator_AL(n) # noqa op_R = operator_R(n) # noqa lhs = op_AL(op_R(mu)) rhs = op_R(op_AL(mu)) _extract(rhs - lhs, n, coefficients, differences) for nu in sorted(coefficients): k = max(mu[0] if mu else 0, nu[0] if nu else 0) print(' mu =', mu, '--> nu =', nu, ': coefficient of nu in R_n(AL_n(mu)) - AL_n(R_n(mu)) is') print() n = number_of_values_of_n + s - 1 f = sum([(-beta)**i for i in range(n + 1 - k)]) * X() c = coefficients[nu].get(n, 0) e = (c - f) if e: print(' ', e, '+', sb) else: print(' ', sb) print() print() input('continue (press any key)')
def overlap(bigger, smaller): ans = 0 skew = Partition.shifted_shape(bigger, smaller) for (i, j) in skew: if (i + 1, j) in skew: ans += 1 return ans
def from_shifted_growth_diagram(cls, growth, edges, corners): def shdiff(nu, lam): return next(iter(Partition.skew(nu, lam, shifted=True))) p, q = Tableau(), Tableau() n, m = len(growth) - 1, len(growth[0]) - 1 if growth else 0 for i in range(1, n + 1): mu, nu = growth[i][m], growth[i - 1][m] for a, b in Partition.skew(mu, nu, shifted=True): p = p.add(a, b, i) for i in range(1, m + 1): mu, nu = growth[n][i], growth[n][i - 1] v = -i if edges[n][i] else i j = corners[n][i] if mu != nu: a, b = shdiff(mu, nu) q = q.add(a, b, v) elif v < 0: x = q.last_box_in_column(j) q = q.add(x, j, v) else: x = q.last_box_in_row(j) q = q.add(j, x, v) return p, q
def test_undo_doublebar(n=5, k=5): partitions = list(Partition.all(k, strict=True)) for lam in partitions: for mu in partitions: if not Partition.contains(lam, mu): continue lhs = GP(n, lam, mu) rhs = sum([(-beta)**(sum(mu) - sum(nu)) * GP_doublebar(n, lam, nu) for nu in partitions if Partition.contains(mu, nu)]) print('GP:', n, lam, mu) assert lhs == rhs lhs = GQ(n, lam, mu) rhs = sum([(-beta)**(sum(mu) - sum(nu)) * GQ_doublebar(n, lam, nu) for nu in partitions if Partition.contains(mu, nu)]) print('GQ:', n, lam, mu) assert lhs == rhs
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()