def deep_dive(nu=(6, 5, 3, 2, 1), mu=(4, 3, 2, 1)):
split_nu, split_mu, diagonal = split(nu, mu)
print()
print('TYPE:')
print()
print(split_nu, split_mu, diagonal)
print()
print(Partition.printable(split_nu, split_mu, shifted=False))
print()
print('nu =', nu, 'mu =', mu)
print()
print(Partition.printable(nu, mu, shifted=True))
print()
m = sum(nu) - sum(mu) + 2
target = lvector(nu, mu, m)
nu1, mu1 = Partition.decrement_one(nu), mu
nu2, mu2 = Partition.decrement_one(Partition.decrement_one(nu)), mu
nu3, mu3 = Partition.decrement_one(
Partition.decrement_one(
Partition.decrement_one(nu))), Partition.decrement_one(mu)
nu4, mu4 = Partition.trim(nu[1:]), Partition.trim(mu[1:])
nu5, mu5 = Partition.trim(nu[2:]), Partition.trim(mu[2:])
nu6, mu6 = tuple(i - 1 for i in nu), tuple(i - 1 for i in mu)
print(Partition.printable(nu1, mu1, shifted=True), '\n')
print(Partition.printable(nu2, mu2, shifted=True), '\n')
print(Partition.printable(nu3, mu3, shifted=True), '\n')
print(Partition.printable(nu4, mu4, shifted=True), '\n')
print(Partition.printable(nu5, mu5, shifted=True), '\n')
m = sum(nu) - sum(mu) + 2
print('nu =', nu, '; mu =', mu)
print()
print(Partition.printable(nu, mu, shifted=True))
print()
v = [
lvector(nu1, mu1, m),
lvector(nu1, mu1, m) >> 1,
lvector(nu2, mu2, m),
lvector(nu2, mu2, m) >> 1,
lvector(nu3, mu3, m),
lvector(nu3, mu3, m) >> 1,
lvector(nu4, mu4, m),
lvector(nu4, mu4, m) >> 1,
lvector(nu5, mu5, m),
lvector(nu5, mu5, m) >> 1,
lvector(nu5, mu5, m) >> 2,
]
print('target =')
print(target)
print()
RowVector.print_matrix(v)
print()
print('partial solutions =', RowVector.solve(v, target, integral=False))
print()
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)
}
def test_all(n=6):
def inspect(w, target, good, unique=None):
ans = []
sort = sorted(good, key=lambda x: -unique[x]) if unique else good
for g in sort:
a = w[0] * g[0]
for i in range(1, len(g)):
a += w[i] * g[i]
if target == a:
ans.append(g)
return ans
types = get_types(n)
success = [0, 0]
unique = {}
refined_unique = defaultdict(list)
good = set()
for (split_nu, split_mu, diagonal) in types:
# if (split_nu, split_mu) != ((3, 1, 1, 1), ()):
# continue
target = RowVector()
w = [RowVector() for i in range(9)]
# print(10 * '\n')
domain = types[(split_nu, split_mu, diagonal)]
# if len(domain) <= 2:
# continue
for (nu, mu) in domain:
nu1, mu1 = Partition.decrement_one(nu), mu
# nu2, mu2 = Partition.decrement_one(Partition.decrement_one(nu)), mu
# nu3, mu3 = Partition.decrement_one(Partition.decrement_one(nu)), Partition.decrement_one(mu)
nu4, mu4 = Partition.trim(nu[1:]), Partition.trim(mu[1:])
nu5, mu5 = Partition.trim(nu[2:]), Partition.trim(mu[2:])
nu6, mu6 = Partition.trim(nu[3:]), Partition.trim(mu[3:])
m = sum(nu) - sum(mu) + 2
v = lvector(nu, mu, m)
target |= v
w[0] |= lvector(nu4, mu4, m)
w[1] |= lvector(nu4, mu4, m) >> 1
w[2] |= lvector(nu4, mu4, m) >> 2
w[3] |= lvector(nu5, mu5, m)
w[4] |= lvector(nu5, mu5, m) >> 1
w[5] |= lvector(nu5, mu5, m) >> 2
w[6] |= lvector(nu1, mu1, m)
w[7] |= lvector(nu1, mu1, m) >> 1
w[8] |= lvector(nu1, mu1, m) >> 2
# v = RowVector.elementary(1, len(v))
# w[9] |= v
# w[9] |= lvector(nu6, mu6, m)
# w[10] |= lvector(nu6, mu6, m) >> 1
# w[11] |= lvector(nu6, mu6, m) >> 2
# w[8] |= lvector(nu2, mu2, m)
# w[9] |= lvector(nu2, mu2, m) >> 1
# w[10] |= lvector(nu3, mu3, m)
# w[11] |= lvector(nu3, mu3, m) >> 1
# w[12] |= lvector(nu6, mu6, m)
# w[13] |= lvector(nu6, mu6, m) >> 1
try:
assert lvector(nu, mu, m) == rvector(nu, mu, m)
except:
print(Partition.printable(nu, mu, shifted=True), '\n')
print(lvector(nu, mu, m), '==', rvector(nu, mu, m))
input('')
k = 1
solved = inspect(w, k * target, good, unique)
if not solved:
solved = [k * x for x in RowVector.solve(w, target)]
if solved:
integral = [RowVector([int(a) for a in solved[0]])]
if inspect(w, k * target, integral):
solved = integral
if solved: # and all(type(t) == int for t in solved[0]):
solved = solved[0]
success[0] += 1
unique[solved] = unique.get(solved, 0) + 1
for (nu, mu) in domain:
x = sum(nu) - sum(mu)
refined_unique[solved].append(
(split_nu, split_mu, diagonal, domain, w, target))
# if len(domain) > 1:
# print(len(domain), ':', solved, diagonal)
if all(type(i) == int for i in solved):
good.add(solved)
if solved[-1] == 0:
continue
else:
success[1] += 1
for (nu, mu) in domain:
# if mu == ():
# continue
nu1, mu1 = Partition.decrement_one(nu), mu
# nu2, mu2 = Partition.decrement_one(Partition.decrement_one(nu)), mu
# nu3, mu3 = Partition.decrement_one(Partition.decrement_one(nu)), Partition.decrement_one(mu)
nu4, mu4 = Partition.trim(nu[1:]), Partition.trim(mu[1:])
nu5, mu5 = Partition.trim(nu[2:]), Partition.trim(mu[2:])
# nu6, mu6 = Partition.decrement_one(Partition.decrement_one(nu)), mu
m = sum(nu) - sum(mu) + 2
print('nu =', nu, '; mu =', mu)
print()
print(Partition.printable(nu, mu, shifted=True))
print()
# print(Partition.printable(nu1, mu1, shifted=True), '\n')
# print(Partition.printable(nu2, mu2, shifted=True), '\n')
# print(Partition.printable(nu3, mu3, shifted=True), '\n')
# print(Partition.printable(nu4, mu4, shifted=True), '\n')
# print(Partition.printable(nu5, mu5, shifted=True), '\n')
# print(Partition.printable(nu6, mu6, shifted=True), '\n')
v = [
lvector(nu4, mu4, m),
lvector(nu4, mu4, m) >> 1,
lvector(nu4, mu4, m) >> 2,
lvector(nu5, mu5, m),
lvector(nu5, mu5, m) >> 1,
lvector(nu5, mu5, m) >> 2,
lvector(nu1, mu1, m),
lvector(nu1, mu1, m) >> 1,
lvector(nu1, mu1, m) >> 2,
# lvector(nu2, mu2, m),
# lvector(nu2, mu2, m) >> 1,
# lvector(nu3, mu3, m),
# lvector(nu3, mu3, m) >> 1,
# lvector(nu6, mu6, m),
# lvector(nu6, mu6, m) >> 1,
]
print('target =')
print(lvector(nu, mu, m))
print()
RowVector.print_matrix(v)
print()
print('partial solutions =',
RowVector.solve(v, lvector(nu, mu, m), integral=False))
print()
# print('solutions so far:')
# for u in unique:
# print('*', u)
RowVector.print_matrix(w)
RowVector.print_matrix([target])
print(Partition.printable(nu, mu, shifted=True), '\n')
print(Partition.printable(nu1, mu1, shifted=True), '\n')
print()
print('TYPE:')
print()
print(split_nu, split_mu, diagonal)
print()
print(Partition.printable(split_nu, split_mu, shifted=False))
print()
print()
print(solved)
print()
# input('')
print(10 * '\n')
print()
for u in sorted(unique, key=lambda x: -unique[x]):
print(u, ':', unique[u])
for (split_nu, split_mu, diagonal, domain, w,
target) in refined_unique[u][:10]:
RowVector.print_matrix(w)
RowVector.print_matrix([target])
print()
print('type:', split_nu, split_mu, diagonal)
print()
print(Partition.printable(split_nu, split_mu, shifted=False))
print()
# i = 1
# for nu, mu in domain:
# print(i, 'of', len(domain), '\n')
# print(Partition.printable(nu, mu, shifted=True))
# print()
# i += 1
print()
print('{')
for u in sorted(unique, key=lambda x: unique[x]):
print(u, ':', unique[u], ',') # , unique[u], set(refined_unique[u]))
print('}')
print()
print('unique:', len(unique))
print()
print(success)