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)
}