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 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 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 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 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 get_types(n): types = defaultdict(list) for nu in Partition.all(n, strict=True): for mu in set(lshapes(nu)) | set(rshapes(nu)): if is_reducible(nu, mu): continue triple = split(nu, mu) types[triple].append((nu, mu)) return types
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 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 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 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 test_gp_pieri(n=4, m=10, l=5): for mu in Partition.all(m, strict=True): if sum(mu) <= 1: continue f = gp(n, mu) for p in range(1, l + 1): g = gp(n, (p,)) actual = f * g expected = 0 pieri = gp_pieri(mu, p) for (lam, c) in pieri.items(): expected += gp(n, lam) * c # print('gp_%s(x_%s)' % (mu, n), '*', 'gp_%s(x_%s)' % (p, n)) # print(' ', actual - expected) # print() assert actual == expected pieri = {k: 2 * v for k, v in pieri.items()} if p >= 2: for (lam, c) in gp_pieri(mu, p - 1).items(): pieri[lam] = pieri.get(lam, 0) + c * beta q = mu[0] if mu else 0 nu = (q + p,) + mu print() print(Partition.printable(nu, mu, shifted=True)) print() print('mu =', mu, 'p =', p, 'q =', q) print() rho1 = (q + p,) + mu[1:] rho2 = (q + p - 1,) + mu[1:] print(pieri) print() for lam in pieri: co = pieri[lam].substitute(0, 1) co = co - 1 if lam in [rho1, rho2] else co klg = Tableau.KLG_counts(nu, lam, q) print(lam, co, klg) assert co == klg print()
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 test_gq_pieri(n=4, m=10, l=5): for mu in Partition.all(m, strict=True): if not mu: continue f = gq(n, mu) for p in range(1, l + 1): g = gq(n, (p,)) actual = f * g expected = 0 pieri = gq_pieri(mu, p) for (lam, c) in pieri.items(): expected += gq(n, lam) * c # print('gq_%s(x_%s)' % (mu, n), '*', 'gq_%s(x_%s)' % (p, n)) # print(' ', actual - expected) # print() assert actual == expected q = mu[0] if mu else 0 nu = (q + p,) + mu print() print(Partition.printable(nu, mu, shifted=True)) print() print('mu =', mu, 'p =', p, 'q =', q) print() rho1 = (q + p,) + mu[1:] rho2 = (q + p - 1,) + mu[1:] for lam in pieri: co = pieri[lam].substitute(0, 1) co = co - 1 if lam in [rho1, rho2] else co kog = Tableau.KOG_counts(nu, lam, q) print(lam, co, kog) assert co == kog print()
def test_inclusion_excluson(k=5): partitions = list(Partition.all(k, strict=True)) for kappa in partitions: ans, queue = Vector(), {kappa: 1} while queue: pop = next(iter(queue)) coeff = queue[pop] ans += Vector({pop: coeff}) del queue[pop] additions = { tuple(pop[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( pop[i - 1] - a[i - 1] > pop[i] - a[i] for i in range(1, len(a))) and all(0 < pop[i] - a[i] for i in range(len(a))) } for nu in additions: queue[nu] = queue.get(nu, 0) - cols(pop, nu) * coeff print('kappa =', kappa) print() for nu in ans: print(Partition.printable(kappa, nu, True)) print() print('coefficient =', ans[nu]) print() print() print(ans) print() print() assert all(ans[nu] == 2**overlap(kappa, nu) for nu in ans) assert set(ans) == { nu for nu in Partition.subpartitions(kappa, strict=True) if len(nu) == len(kappa) }