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 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 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_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_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_shifted_schur_relations(n=4):
def tag(args):
if len(args) == 0:
return 'id'
if args == ZERO:
return '0'
s = ''
for a in args:
s += '%s_{%i} ' % a
return s.strip()
delta = tuple(range(n + 1, 0, -1))
partitions = list(Partition.subpartitions(delta, strict=True))
small = {k: v for k, v in small_q_schur_expressions(n)}
def equals(k1, k2):
op1, op2 = small[k1], small[k2]
return all(op1(mu) == op2(mu) for mu in partitions)
expected = [{(('u', i), ('u', i + 1), ('u', i)), ZERO}
for i in range(1, n)] + [{
(('d', i), ('d', i + 1), ('d', i)), ZERO
} for i in range(1, n)] + [{(
('u', i), ('u', i)), ZERO} for i in range(0, n + 1)] + [{
(('u', i + 1), ('u', i), ('u', i + 1)), ZERO
} for i in range(0, n)] + [{
(('d', i), ('d', i)), ZERO
} for i in range(0, n + 1)] + [{
(('d', i + 1), ('d', i), ('d', i + 1)), ZERO
} for i in range(0, n)] + [{
(('u', i + 1), ('d', i)), ZERO
} for i in range(0, n)] + [{
(('d', i), ('u', i + 1)), ZERO
} for i in range(0, n)] + [{(
('d', i + 1),
('u', i)), ZERO} for i in range(0, n)] + [{
(('u', i), ('d', i + 1)), ZERO
} for i in range(0, n)] + [
{(('u', i), ('u', j)), (('u', j), ('u', i))}
for i in range(0, n + 1)
for j in range(0, n + 1) if i + 1 < j
] + [{(('d', i), ('d', j)), (('d', j), ('d', i))}
for i in range(0, n + 1)
for j in range(0, n + 1) if i + 1 < j
] + [{(('u', i), ('d', j)), (('d', j), ('u', i))}
for i in range(0, n + 1)
for j in range(0, n + 1) if abs(i - j) > 1]
span = get_span(get_dict(expected), small)
print('\n.\n')
def check_expected_identities(k1, k2, do_check=True):
if {k1, k2} in expected:
if do_check:
try:
assert equals(k1, k2)
except:
print()
print('** failure: ', tag(k1), '!=', tag(k2))
# for mu in partitions:
# op1 = small[k1]
# op2 = small[k2]
# if op1(mu) != op2(mu):
# print(' ', mu, ':', op1(mu), '!=', op2(mu))
# print()
raise Exception
return True
return False
relations = set()
for k1 in sorted(small):
for k2 in sorted(small):
if k1 < k2:
if check_expected_identities(k1, k2):
relations.add((k1, k2))
# print()
# print('* expected: ', tag(k1), '=', tag(k2))
continue
if span[k1] & span[k2]:
continue
# if all(small[k1](mu).is_zero() for mu in partitions) and k2 != ZERO:
# continue
if equals(k1, k2):
relations.add((k1, k2))
print()
print('unexpected:', tag(k1), '=', tag(k2))
raise Exception
print()
return relations
def test_schur_relations(n=4):
def tag(args):
if len(args) == 0:
return 'id'
s = ''
for a in args:
if a > 0:
s += 'u_%i ' % a
else:
s += 'd_%i ' % -a
return s.strip()
square = (n + 1) * (n + 1, )
partitions = list(Partition.subpartitions(square))
small = {k: v for k, v in small_schur_expressions(n)}
def equals(k1, k2):
op1, op2 = small[k1], small[k2]
return all(op1(mu) == op2(mu) for mu in partitions)
expected = [
{(), (-1, 1)},
] + [{(i, j), (j, i)} for i in range(1, n + 1)
for j in range(1, n + 1) if i + 1 < j] + [{
(-i, -j), (-j, -i)
} for i in range(1, n + 1) for j in range(1, n + 1) if i + 1 < j] + [
{(-i, j), (j, -i)} for i in range(1, n + 1)
for j in range(1, n + 1) if i != j
] + [{(-i - 1, i + 1), (i, -i)} for i in range(1, n)
] + [{(i + 1, i, i), (i, i + 1, i)} for i in range(1, n)] + [{
(i + 1, i, i + 1), (i + 1, i + 1, i)
} for i in range(1, n)] + [{(-i, -i - 1, -i), (-i, -i, -i - 1)}
for i in range(1, n)
] + [{(-i, -i - 1, -i - 1),
(-i - 1, -i, -i - 1)}
for i in range(1, n)]
dictionary = get_dict(expected)
span = get_span(dictionary, small)
def check_expected_identities(k1, k2, do_check=True):
if {k1, k2} in expected:
if do_check:
try:
assert equals(k1, k2)
except:
print()
print('** failure: ', tag(k1), '!=', tag(k2))
raise Exception
return True
return False
relations = set()
for k1 in small:
for k2 in small:
if k1 < k2:
if check_expected_identities(k1, k2):
relations.add((k1, k2))
print()
print('* expected: ', tag(k1), '=', tag(k2))
continue
if span[k1] & span[k2]:
continue
if equals(k1, k2):
relations.add((k1, k2))
print()
print('unexpected:', tag(k1), '=', tag(k2))
raise Exception
print()
return relations