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_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 _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 _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 _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 _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 _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 gq_pieri(mu, p):
ans = {}
shape = Partition.shifted_shape(mu)
corners = {(i, j) for (i, j) in shape if (i + 1, j) not in shape and (i, j + 1) not in shape}
nu = ((mu[0] if mu else 0) + p,) + mu
outer = Partition.shifted_shape(nu, mu)
for a in subsets(corners):
for b in subsets(outer):
c = a + b
if any(i1 < i2 and j1 < j2 for (i1, j1) in c for (i2, j2) in c):
continue
lam = Partition.from_shape(shape | set(c))
if not Partition.is_strict_partition(lam):
continue
if (Partition.shifted_shape(lam) - shape) | set(a) != set(c):
continue
free = len([(i, j) for (i, j) in c if i != j and (i, j - 1) not in c and (i + 1, j) not in c])
if len(c) <= p <= len(c) + free:
diff = p - len(c)
bet = beta**(sum(mu) + p - sum(lam))
coeff = nchoosek(free, diff) * bet * 2**(free - diff)
ans[lam] = ans.get(lam, 0) + coeff
return ans