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)]