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