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 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 _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 _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 _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 _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 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 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 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 _semistandard_rpp(cls, max_entry, mu, lam): # noqa ans = set() if mu == lam: ans = {ReversePlanePartition()} elif Partition.contains(mu, lam) and max_entry > 0: for nu, diff in cls._rpp_vertical_strips(mu, lam): for tab in cls._semistandard_rpp(max_entry - 1, nu, lam): for (i, j) in diff: tab = tab.add(i, j, max_entry) ans.add(tab) return ans
def _semistandard(cls, max_entry, mu, lam, setvalued): # noqa ans = set() if mu == lam: ans = {Tableau()} elif Partition.contains(mu, lam) and max_entry > 0: for nu, diff, corners in cls._horizontal_strips(mu, lam): for aug in cls._subsets(diff, corners, setvalued): for tab in cls._semistandard(max_entry - 1, nu, lam, setvalued): for (i, j) in aug: tab = tab.add(i, j, max_entry) ans.add(tab) return ans
def test_dual_inclusion_excluson(k=5): partitions = list(Partition.all(k, strict=True)) for lam in partitions: for nu in partitions: if not Partition.contains(lam, nu): continue ans, queue = Vector(), {nu: 1} while queue: kappa = next(iter(queue)) coeff = queue[kappa] ans += Vector({kappa: coeff}) del queue[kappa] additions = { tuple(kappa[i] + a[i] for i in range(len(a))) for a in zero_one_tuples(len(kappa)) if not all(a[i] == 0 for i in range(len(a))) and all( kappa[i - 1] + a[i - 1] > kappa[i] + a[i] for i in range(1, len(a))) and all( lam[i] >= kappa[i] + a[i] for i in range(len(a))) } for gam in additions: queue[gam] = queue.get(gam, 0) - cols(gam, kappa) * coeff print('lambda =', lam, 'nu =', nu) print() for gam in ans: print(Partition.printable(gam, nu, True)) print() print('coefficient =', ans[gam]) print() print() print(ans) print() print() assert all(ans[g] == 2**overlap(g, nu) for g in ans) assert set(ans) == { g for g in Partition.subpartitions(lam, strict=True) if len(g) == len(nu) and Partition.contains(g, nu) }
def _count_semistandard_rpp(cls, max_entry, mu, lam): # noqa ans = defaultdict(int) if mu == lam: ans[()] = 1 elif Partition.contains(mu, lam) and max_entry > 0: for nu, diff in cls._rpp_vertical_strips(mu, lam): if mu == nu: continue m = len({j for _, j in diff}) for partition, count in cls._count_semistandard_rpp( max_entry - 1, nu, lam).items(): if not (partition and m > partition[-1]): ans[partition + (m, )] += count return ans
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 _semistandard_marked(cls, max_entry, mu, lam, setvalued): # noqa ans = set() if mu == lam: ans = {Tableau()} elif Partition.contains(mu, lam) and max_entry > 0: for nu1, diff1, corners1 in cls._horizontal_strips(mu, lam): for nu2, diff2, corners2 in cls._vertical_strips(nu1, lam): for aug1 in cls._subsets(diff1, corners1, setvalued): for aug2 in cls._subsets(diff2, corners2, setvalued): for tab in cls._semistandard_marked( max_entry - 1, nu2, lam, 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 _semistandard_marked_rpp(cls, max_entry, mu, lam, diagonal_nonprimes): # noqa assert Partition.is_strict_partition(mu) ans = set() if mu == lam: ans = {MarkedReversePlanePartition()} elif Partition.contains(mu, lam) and max_entry > 0: for nu1, diff1 in cls._shifted_rpp_horizontal_strips(mu): for nu2, diff2 in cls._shifted_rpp_vertical_strips(nu1): if diagonal_nonprimes or not any(i == j for i, j in diff1): for tab in cls._semistandard_marked_rpp( max_entry - 1, nu2, lam, diagonal_nonprimes): for (i, j) in diff1: tab = tab.add(i, j, max_entry) for (i, j) in diff2: tab = tab.add(i, j, -max_entry) ans.add(tab) return ans
def _standard_shifted_marked(cls, mu, lam, diagonal_primes): # noqa assert Partition.is_strict_partition(mu) 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), (i + mu[i]) nu = list(mu) nu[i] -= 1 nu = Partition.trim(nu) if Partition.is_strict_partition(nu): for tab in cls._standard_shifted_marked( nu, lam, diagonal_primes): ans.add(tab.add(row, col, n)) if diagonal_primes or row != col: ans.add(tab.add(row, col, -n)) return ans
def _count_semistandard(cls, max_entry, mu, lam, setvalued): # noqa ans = defaultdict(int) if mu == lam: ans[()] = 1 elif Partition.contains(mu, lam) and max_entry > 0: for nu, diff, corners in cls._horizontal_strips(mu, lam): for partition, count in cls._count_semistandard( max_entry - 1, nu, lam, setvalued).items(): for i in range(len(corners) + 1 if setvalued else 1): m = len(diff) + i 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(corners), i) return ans
def _count_semistandard_marked_rpp(cls, max_entry, mu, lam, diagonal_nonprimes): # 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 in cls._shifted_rpp_horizontal_strips(mu): if not diagonal_nonprimes and any(i == j for i, j in diff1): continue for nu2, diff2 in cls._shifted_rpp_vertical_strips(nu1): if mu == nu2: continue m = len({j for _, j in diff1}) + len({i for i, _ in diff2}) for partition, count in cls._count_semistandard_marked_rpp( max_entry - 1, nu2, lam, diagonal_nonprimes).items(): if not (partition and m > partition[-1]): ans[partition + (m, )] += count return ans
def _horizontal_strips(cls, mu, lam): # noqa if not Partition.contains(mu, lam): return [] core = [mu[i + 1] if i + 1 < len(mu) else 0 for i in range(len(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, 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, nu[i]) for i in range(len(nu)) if core[i] < 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] } return ans