def _slow_transposed_dual_stable_grothendieck_q(cls,
num_variables,
mu,
nu=()):
p = 0
for tab in Tableau.semistandard_shifted_marked(num_variables, mu, nu):
m = 1
for i in range(1, num_variables + 1):
r = len({x for x, y, v in tab if v[0] == i})
c = len({y for x, y, v in tab if v[0] == -i})
a = len({(x, y) for x, y, v in tab if abs(v[0]) == i})
x = Polynomial.x(i)
m *= x**(r + c) * (x + 1)**(a - r - c)
p += m
dictionary = {}
for e in p:
tup = num_variables * [0]
for i in e:
tup[i - 1] = e[i]
dictionary[tuple(tup)] = p[e]
return SymmetricPolynomial({
SymmetricMonomial(num_variables, alpha): coeff *
(-BETA**-1)**(sum(alpha))
for alpha, coeff in dictionary.items()
if Partition.is_partition(alpha)
}) * (-BETA)**(sum(mu) - sum(nu))
def _slow_vectorize(cls, n, tableaux, signs=None, check=True):
dictionary = defaultdict(int)
for tab in tableaux:
dictionary[tab.weight(n)] += 1
if check:
assert all(dictionary[Partition.sort(alpha)] == dictionary[alpha]
for alpha in dictionary)
return SymmetricPolynomial({
SymmetricMonomial(n, alpha):
coeff * (signs if signs else 1)**sum(alpha)
for alpha, coeff in dictionary.items()
if Partition.is_partition(alpha)
})
def _multiply(cls, f, g):
assert type(f) == type(g) == SymmetricMonomial
assert f.order() == g.order()
mu = f.mu
nu = g.mu
n = min(f.order(), len(mu) + len(nu))
if (mu, nu, n) not in MONOMIAL_PRODUCT_CACHE:
ans = defaultdict(int)
for alpha in cls._destandardize(n, mu):
for blpha in cls._destandardize(n, nu):
gamma = tuple(alpha[i] + blpha[i] for i in range(n))
if Partition.is_partition(gamma):
while gamma and gamma[-1] == 0:
gamma = gamma[:-1]
ans[gamma] += 1
MONOMIAL_PRODUCT_CACHE[(mu, nu, n)] = ans
return MONOMIAL_PRODUCT_CACHE[(mu, nu, n)]
