def test_star(n=8):
for nu in Partition.generate(n, even_parts=True):
mu = Partition.transpose(nu)
lu = Partition.transpose(tuple(2 * mu[i]
for i in range(0, len(mu), 2)))
assert mu == Partition.transpose(
tuple(2 * lu[i] for i in range(0, len(lu), 2)))
def test_molecular_correspondence(n=8):
for mu in Partition.generate(n, even_parts=True):
mu = Partition.transpose(mu)
mapping = construct_molecular_correspondence(mu)
for v in mapping:
w = mapping[v]
assert irsk(v).transpose() == dual_irsk(w)
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 _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 _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 get_molecules_n(n, verbose=False):
ans = {}
for mu in Partition.generate(n, even_parts=True):
mu = Partition.transpose(mu)
molecule = molecule_n(mu)
ans[mu] = molecule
return 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 _shifted_rpp_vertical_strips(cls, mu): # noqa
assert Partition.is_strict_partition(mu)
if mu == ():
return [(mu, set())]
def remove_box(nu, i):
for j in range(len(nu) - 1, -1, -1):
if j + nu[j] == i + 1:
nu = nu[:j] + (nu[j] - 1, ) + nu[j + 1:]
while nu and nu[-1] == 0:
nu = nu[:-1]
yield nu
return
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, (mu[0] if mu else 0) - 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, shifted=True)) for nu in ans]
def get_target(domain):
target = RowVector()
w = [RowVector() for i in range(9)]
for (nu, mu) in domain:
nu1, mu1 = Partition.trim(nu[1:]), Partition.trim(mu[1:])
nu2, mu2 = Partition.trim(nu[2:]), Partition.trim(mu[2:])
nu3, mu3 = Partition.decrement_one(nu), mu
m = sum(nu) - sum(mu) + 2
v = lvector(nu, mu, m)
target |= v
w[0] |= lvector(nu1, mu1, m)
w[1] |= lvector(nu1, mu1, m) >> 1
w[2] |= lvector(nu1, mu1, m) >> 2
w[3] |= lvector(nu2, mu2, m)
w[4] |= lvector(nu2, mu2, m) >> 1
w[5] |= lvector(nu2, mu2, m) >> 2
w[6] |= lvector(nu3, mu3, m)
w[7] |= lvector(nu3, mu3, m) >> 1
w[8] |= lvector(nu3, mu3, m) >> 2
assert lvector(nu, mu, m) == rvector(nu, mu, m)
return target, w
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 _shifted_rpp_horizontal_strips(cls, mu): # noqa
assert Partition.is_strict_partition(mu)
if mu == ():
return [(mu, set())]
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)):
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, shifted=True)) for nu in ans]
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 test_rims():
assert set(Partition.rims((), 0)) == {()}
assert set(Partition.rims((), 1)) == {(), ((1, 1), )}
assert set(Partition.rims((), 2)) == {(), ((1, 1), ), ((1, 1), (1, 2))}
assert set(Partition.rims((1, ), 1)) == {(), ((1, 2), ), ((1, 2), (2, 2))}
assert set(Partition.rims(
(3, 2))) == {(), ((1, 4), ), ((1, 4), (2, 4)), ((3, 3), ),
((1, 4), (3, 3)), ((1, 4), (2, 4), (3, 3)),
((1, 4), (2, 4), (3, 3), (3, 4))} # noqa
def _vertical_strips(cls, mu, lam):
ans = []
strips = cls._horizontal_strips(Partition.transpose(mu),
Partition.transpose(lam))
for nu, diff, corners in strips:
nu = Partition.transpose(nu)
diff = {(j, i) for (i, j) in diff}
corners = [(j, i) for (i, j) in corners]
ans.append((nu, diff, corners))
return ans
def test_anti_representatives(n=8):
for nu in Partition.generate(n, even_parts=True):
mu = Partition.transpose(nu)
lu = Partition.transpose(tuple(2 * mu[i]
for i in range(0, len(mu), 2)))
print(mu)
print(lu)
print()
assert representative_m(lu) == anti_representative_n(mu)
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 op(vector):
ans = 0
for mu, coefficient in vector.items():
row = Partition.find_shifted_inner_corner(mu, abs(index))
if row is not None:
ans += Vector({mu: beta * coefficient})
continue
row = Partition.find_shifted_outer_corner(mu, abs(index))
if row is not None:
nu = Partition.add(mu, row)
ans += Vector({nu: coefficient})
return ans
def test_q(n=4):
lam = tuple([n - i for i in range(n)])
for mu in Partition.subpartitions(lam, strict=True):
for nu in Partition.subpartitions(mu, strict=True):
f = SymmetricPolynomial._slow_transposed_dual_stable_grothendieck_q(n, mu, nu)
g = SymmetricPolynomial.dual_stable_grothendieck_q(n, mu, nu)
ef, eg = f.omega_schur_expansion(f), g.schur_expansion(g)
print('n =', n, 'mu =', mu)
print(ef)
print(eg)
print()
assert ef == eg
def op(vector):
ans = 0
for mu, coefficient in vector.items():
e = 0
i = abs(index)
row = Partition.find_shifted_inner_corner(mu, i)
while row is not None:
i = i + 1
mu = Partition.remove_inner_corner(mu, row)
ans += Vector({mu: (-beta)**e})
row = Partition.find_shifted_inner_corner(mu, i)
e += 1
return ans
def rshapes(nu, mu=None):
if nu not in RSHAPES:
RSHAPES[nu] = {}
for lam in Partition.decompose_shifted_shape_by_vertical_strips(nu):
if len(lam) == len(nu):
for x in Partition.decompose_shifted_shape_by_rims(lam):
if x not in RSHAPES[nu]:
RSHAPES[nu][x] = []
RSHAPES[nu][x].append(lam)
if mu is None:
return RSHAPES[nu]
else:
return RSHAPES[nu].get(mu, [])
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 _KOG_count_helper(cls, p, rim): # noqa
if len(rim) == 0:
return 1 if p == 0 else 0
if p <= 0:
return 0
term = Partition.rim_terminal_part(rim)
if len(term) == 2 and p == 1:
return 0
elif len(term) == 2:
left = tuple(a for a in rim if a not in term)
x = cls._KOG_count_helper(p, left)
y = cls._KOG_count_helper(p - 1, left)
z = cls._KOG_count_helper(p - 2, left)
c = 2 if p > 2 else 1
return x + (1 + c) * y + c * z
else:
left = tuple(a for a in rim if a != term[-1])
x = cls._KOG_count_helper(p, left)
y = cls._KOG_count_helper(p - 1, left)
c = 2 if p > 1 else 1
if len(term) == 1:
return c * (x + y)
if len(term) == 3 and term[0][0] != term[-1][0] and term[0][
1] != term[-1][1]:
return x + y
if len(term) == 3:
return y
def is_reducible(nu, mu):
if len(nu) == 0:
return True
if any(nu[i] == mu[i] for i in range(len(mu))):
return True
if sum(nu) - sum(mu) <= 3:
return True
# if any(nu[i] + 1 < mu[i - 1] for i in range(1, len(nu))):
# return True
# if nu == mu:
# return True
# if Partition.get(nu, 1) <= Partition.get(mu, 1) + 1:
# return True
skew = Partition.skew(nu, mu, shifted=True)
(i, j) = min(skew, key=lambda ij: (-ij[0], ij[1]))
while True:
if (i - 1, j) in skew:
(i, j) = (i - 1, j)
elif (i, j + 1) in skew:
(i, j) = (i, j + 1)
else:
break
if (i, j) != max(skew, key=lambda ij: (-ij[0], ij[1])):
return True
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 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 overlap(bigger, smaller):
ans = 0
skew = Partition.shifted_shape(bigger, smaller)
for (i, j) in skew:
if (i + 1, j) in skew:
ans += 1
return ans
def from_shifted_growth_diagram(cls, growth, edges, corners):
def shdiff(nu, lam):
return next(iter(Partition.skew(nu, lam, shifted=True)))
p, q = Tableau(), Tableau()
n, m = len(growth) - 1, len(growth[0]) - 1 if growth else 0
for i in range(1, n + 1):
mu, nu = growth[i][m], growth[i - 1][m]
for a, b in Partition.skew(mu, nu, shifted=True):
p = p.add(a, b, i)
for i in range(1, m + 1):
mu, nu = growth[n][i], growth[n][i - 1]
v = -i if edges[n][i] else i
j = corners[n][i]
if mu != nu:
a, b = shdiff(mu, nu)
q = q.add(a, b, v)
elif v < 0:
x = q.last_box_in_column(j)
q = q.add(x, j, v)
else:
x = q.last_box_in_row(j)
q = q.add(j, x, v)
return p, q
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 print_mn_operators(n=8):
def wstr(w):
return ' $\\barr{c}' + str(
w) + ' \\\\ ' + w.oneline_repr() + ' \\earr$ '
ans = []
for n in range(2, n + 1, 2):
for mu in Partition.generate(n):
s = []
i = 0
for t in Tableau.standard(mu):
u = dual_irsk(irsk_inverse(t), n).transpose()
s += ['\n&\n'.join([t.tex(), u.tex()])]
i += 1
if i * t.max_row() >= 24:
s += [
'\n\\end{tabular} \\newpage \\begin{tabular}{ccccc} Tableau & Tableau \\\\ \\hline '
]
i = 0
s = '\n \\\\ \\\\ \n'.join(s)
ans += [
'\\begin{tabular}{ccccc} Tableau & Tableau \\\\ \\hline \\\\ \\\\ \n'
+ s + '\n\\end{tabular}'
]
ans = '\n\n\\newpage\n\n'.join(ans + [''])
with open(
'/Users/emarberg/Dropbox/projects/affine-transitions/notes/eric_notes/examples.tex',
'w') as f:
f.write(ans)
f.close()