schubmult 2.0.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

schubmult/{schubmult_double/_funcs.py → schub_lib/double.py}

@@ -1,51 +1,49 @@
 from bisect import bisect_left
-from functools import cache
+from functools import cache, cached_property
+
+import numpy as np
+import psutil
+import pulp as pu
+import sympy
 from cachetools import cached
 from cachetools.keys import hashkey
-from symengine import sympify, Add, Mul, Pow, expand, Integer, symarray
+from sortedcontainers import SortedList
+from symengine import Add, Integer, Mul, Pow, sympify
+
 from schubmult.perm_lib import (
-    elem_sym_perms,
-    elem_sym_poly,
-    add_perm_dict,
+    Permutation,
+    code,
+    cycle,
     dominates,
-    compute_vpathdicts,
-    inverse,
-    theta,
-    permtrim,
     inv,
-    mulperm,
-    code,
+    one_dominates,
+    phi1,
+    theta,
     uncode,
-    elem_sym_func,
-    elem_sym_perms_op,
+)
+from schubmult.poly_lib.poly_lib import efficient_subs, elem_sym_func, elem_sym_poly, expand
+from schubmult.poly_lib.schub_poly import schubpoly
+from schubmult.poly_lib.variables import CustomGeneratingSet, GeneratingSet, GeneratingSet_base
+from schubmult.schub_lib.schub_lib import (
+    compute_vpathdicts,
     divdiffable,
+    elem_sym_perms,
+    elem_sym_perms_op,
+    is_coeff_irreducible,
+    is_split_two,
     pull_out_var,
-    cycle,
-    will_formula_work,
-    one_dominates,
-    is_reducible,
     reduce_coeff,
     reduce_descents,
     try_reduce_u,
     try_reduce_v,
-    phi1,
-    zero,
+    will_formula_work,
 )
-import numpy as np
-import pulp as pu
-import sympy
-import psutil
-from sortedcontainers import SortedList
-from functools import cached_property
+from schubmult.utils.logging import get_logger
+from schubmult.utils.perm_utils import add_perm_dict
 
-# NO GLOBAL VARS
-# from ._vars import (
-#     n,
-#     var2,
-#     var3,
-#     _vars.var1,
-#     var_y,
-# )
+zero = sympify(0)
+
+logger = get_logger(__name__)
 
 
 class _gvars:
@@ -59,19 +57,28 @@ class _gvars:
 
     @cached_property
     def var1(self):
-        return tuple(symarray("x", self.n).tolist())
+        return GeneratingSet("x")
 
     @cached_property
     def var2(self):
-        return tuple(symarray("y", self.n).tolist())
+        return GeneratingSet("y")
 
     @cached_property
     def var3(self):
-        return tuple(symarray("z", self.n).tolist())
+        return GeneratingSet("z")
 
     @cached_property
     def var_r(self):
-        return symarray("r", 100)
+        return GeneratingSet("r")
+
+    @cached_property
+    def var_g1(self):
+        return GeneratingSet("y")
+
+    @cached_property
+    def var_g2(self):
+        return GeneratingSet("z")
+
 
 
 _vars = _gvars()
@@ -86,8 +93,8 @@ def count_sorted(mn, tp):
     return ct
 
 
-def E(p, k, varl=_vars.var2[1:]):
-    return elem_sym_poly(p, k, _vars.var1[1:], varl)
+# def E(p, k, varl=_vars.var2[1:]):
+#     return elem_sym_poly(p, k, _vars.var1[1:], varl)
 
 
 def single_variable(coeff_dict, varnum, var2=None):
@@ -130,72 +137,82 @@ def single_variable_down(coeff_dict, varnum, var2=_vars.var2):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2):
-    if poly in var_x:
+def mult_poly_double(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2):
+    # try:
+    #     poly = sympify(poly)
+    # except SympifyError:
+    #     poly = sympy.sympify(poly)
+    #     var_x = tuple([sympy.sympify(v) for v in var_x])
+    #     var_y = tuple([sympy.sympify(v) for v in var_y])
+    #     return mult_poly_sympy(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2)
+    if not isinstance(var_x, GeneratingSet_base):
+        var_x = CustomGeneratingSet(var_x)
+    if var_x.index(poly) != -1:
         return single_variable(coeff_dict, var_x.index(poly), var_y)
-    elif isinstance(poly, Mul):
+    if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
-            ret = mult_poly(ret, a, var_x, var_y)
+            ret = mult_poly_double(ret, a, var_x, var_y)
         return ret
-    elif isinstance(poly, Pow):
+    if isinstance(poly, Pow):
         base = poly.args[0]
         exponent = int(poly.args[1])
         ret = coeff_dict
         for i in range(int(exponent)):
-            ret = mult_poly(ret, base, var_x, var_y)
+            ret = mult_poly_double(ret, base, var_x, var_y)
         return ret
-    elif isinstance(poly, Add):
+    if isinstance(poly, Add):
         ret = {}
         for a in poly.args:
-            ret = add_perm_dict(ret, mult_poly(coeff_dict, a, var_x, var_y))
-        return ret
-    else:
-        ret = {}
-        for perm in coeff_dict:
-            ret[perm] = poly * coeff_dict[perm]
+            ret = add_perm_dict(ret, mult_poly_double(coeff_dict, a, var_x, var_y))
         return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
+
+
+# def mult_poly_symy(coeff_dict, poly, var_x=_vars.sympy_var1, var_y=_vars.sympy_var2):
 
 
 def mult_poly_down(coeff_dict, poly):
     if poly in _vars.var1:
         return single_variable_down(coeff_dict, _vars.var1.index(poly))
-    elif isinstance(poly, Mul):
+    if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
             ret = mult_poly_down(ret, a)
         return ret
-    elif isinstance(poly, Pow):
+    if isinstance(poly, Pow):
         base = poly.args[0]
         exponent = int(poly.args[1])
         ret = coeff_dict
         for i in range(int(exponent)):
             ret = mult_poly_down(ret, base)
         return ret
-    elif isinstance(poly, Add):
+    if isinstance(poly, Add):
         ret = {}
         for a in poly.args:
             ret = add_perm_dict(ret, mult_poly_down(coeff_dict, a))
         return ret
-    else:
-        ret = {}
-        for perm in coeff_dict:
-            ret[perm] = poly * coeff_dict[perm]
-        return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
 
 
 def nilhecke_mult(coeff_dict1, coeff_dict2):
     ret = {}
     for w in coeff_dict2:
-        w1 = [*w]
+        w1 = w
         inv_w1 = inv(w1)
         poly = coeff_dict2[w]
         did_mul = mult_poly_down(coeff_dict1, poly)
         for v in did_mul:
             v1 = [*v]
-            addperm = mulperm(v1, w1)
+            addperm = v1 * w1
             if inv(addperm) == inv(v1) + inv_w1:
-                toadd = tuple(permtrim(addperm))
+                toadd = addperm
                 ret[toadd] = ret.get(toadd, 0) + did_mul[v]
     return ret
 
@@ -203,48 +220,63 @@ def nilhecke_mult(coeff_dict1, coeff_dict2):
 def forwardcoeff(u, v, perm, var2=None, var3=None):
     th = theta(v)
     muv = uncode(th)
-    vmun1 = mulperm(inverse([*v]), muv)
+    vmun1 = (~v) * muv
 
-    w = mulperm([*perm], vmun1)
+    w = perm * vmun1
     if inv(w) == inv(vmun1) + inv(perm):
-        coeff_dict = schubmult_one(tuple(permtrim([*u])), tuple(muv), var2, var3)
-        return coeff_dict.get(tuple(permtrim(w)), 0)
+        coeff_dict = schubmult_double_pair(u, muv, var2, var3)
+        # logger.debug(f"{coeff_dict.get(w,0)=} {w=} {perm=} {vmun1=} {v=} {muv=}")
+        return coeff_dict.get(w, 0)
     return 0
 
 
 def dualcoeff(u, v, perm, var2=None, var3=None):
-    if u == (1, 2):
-        vp = mulperm([*v], inverse(perm))
+    if inv(u) == 0:
+        # logger.debug("Recording line number")
+        vp = v * (~perm)
         if inv(vp) == inv(v) - inv(perm):
-            val = schubpoly(vp, var2, var3)
-        else:
-            val = 0
+            return schubpoly(vp, var2, var3)
+    dpret = []
+    ret = 0
+    if dominates(u, perm):
+        dpret = dualpieri(u, v, perm)
     else:
+        # logger.debug("Recording line number")
         dpret = []
-        if dominates(u, perm):
-            dpret = dualpieri([*u], [*v], [*perm])
-        else:
-            th = theta(u)
-            muu = uncode(th)
-            umun1 = mulperm(inverse([*u]), muu)
-            w = mulperm([*perm], umun1)
-            if inv(w) == inv(umun1) + inv(perm):
-                dpret = dualpieri(muu, [*v], w)
-        ret = 0
-        for vlist, vp in dpret:
-            toadd = 1
-            for i in range(len(vlist)):
-                for j in range(len(vlist[i])):
-                    toadd *= var2[i + 1] - var3[vlist[i][j]]
-            toadd *= schubpoly(vp, var2, var3, len(vlist) + 1)
-            ret += toadd
-        val = ret
-    return val
+        # logger.debug("Recording line number")
+        th = theta(u)
+        muu = uncode(th)
+        umun1 = (~u) * muu
+        w = perm * umun1
+        # logger.debug("spiggle")
+        # logger.debug(f"{u=} {muu=} {v=} {w=} {perm=}")
+        # logger.debug(f"{w=} {perm=}")
+        if inv(w) == inv(umun1) + inv(perm):
+            dpret = dualpieri(muu, v, w)
+            # logger.debug(f"{muu=} {v=} {w=}")
+            # logger.debug(f"{dpret=}")
+    for vlist, vp in dpret:
+        # logger.debug("Recording line number")
+        toadd = 1
+        for i in range(len(vlist)):
+            for j in range(len(vlist[i])):
+                toadd *= var2[i + 1] - var3[vlist[i][j]]
+        toadd *= schubpoly(vp, var2, var3, len(vlist) + 1)
+        ret += toadd
+    return ret
+    # logger.debug("Recording line number")
+    # schub_val = schubmult_one(u, v, var2, var3)
+    # val_ret = schub_val.get(perm, 0)
+    # if expand(val - val_ret) != 0:
+    #     # logger.debug(f"{schub_val=}")
+    #     # logger.debug(f"{val=} {u=} {v=} {var2[1]=} {var3[1]=}  {perm=} {schub_val.get(perm,0)=}")
+    # logger.debug(f"good to go {ret=}")
 
 
 def dualpieri(mu, v, w):
-    lm = code(inverse(mu))
-    cn1w = code(inverse(w))
+    # logger.debug(f"dualpieri {mu=} {v=} {w=}")
+    lm = code(~mu)
+    cn1w = code(~w)
     while len(lm) > 0 and lm[-1] == 0:
         lm.pop()
     while len(cn1w) > 0 and cn1w[-1] == 0:
@@ -254,33 +286,38 @@ def dualpieri(mu, v, w):
     for i in range(len(lm)):
         if lm[i] > cn1w[i]:
             return []
-    c = [1, 2]
+    c = Permutation([1, 2])
     for i in range(len(lm), len(cn1w)):
-        c = mulperm(cycle(i - len(lm) + 1, cn1w[i]), c)
-    c = permtrim(c)
+        c = cycle(i - len(lm) + 1, cn1w[i]) * c
+    # c = permtrim(c)
+    # logger.debug("Recording line number")
     res = [[[], v]]
+    # logger.debug(f"{v=} {type(v)=}")
     for i in range(len(lm)):
+        # logger.debug(f"{res=}")
         res2 = []
         for vlist, vplist in res:
             vp = vplist
             vpl = divdiffable(vp, cycle(lm[i] + 1, cn1w[i] - lm[i]))
-            if vpl == []:
+            # logger.debug(f"{vpl=} {type(vpl)=}")
+            if len(vpl) == 0:
                 continue
             vl = pull_out_var(lm[i] + 1, vpl)
+            # logger.debug(f"{vl=}")
             for pw, vpl2 in vl:
-                res2 += [[vlist + [pw], vpl2]]
+                res2 += [[[*vlist, pw], vpl2]]
         res = res2
     if len(lm) == len(cn1w):
         return res
-    else:
-        res2 = []
-        for vlist, vplist in res:
-            vp = vplist
-            vpl = divdiffable(vp, c)
-            if vpl == []:
-                continue
-            res2 += [[vlist, vpl]]
-        return res2
+    res2 = []
+    for vlist, vplist in res:
+        vp = vplist
+        vpl = divdiffable(vp, c)
+        if len(vpl) == 0:
+            continue
+        res2 += [[vlist, vpl]]
+    # logger.debug(f"{res2=}")
+    return res2
 
 
 dimen = 0
@@ -288,19 +325,30 @@ monom_to_vec = {}
 
 
 @cache
-def schubmult_one(perm1, perm2, var2=None, var3=None):
-    return schubmult({perm1: 1}, perm2, var2, var3)
+def schubmult_double_pair(perm1, perm2, var2=None, var3=None):
+    return schubmult_double({perm1: 1}, perm2, var2, var3)
 
 
-def schubmult(perm_dict, v, var2=None, var3=None):
-    vn1 = inverse(v)
+@cache
+def schubmult_double_pair_generic(perm1, perm2):
+    return schubmult_double({perm1: 1}, perm2, _vars.var_g1, _vars.var_g2)
+
+
+def schubmult_double(perm_dict, v, var2=None, var3=None):
+    if isinstance(var2, str):
+        var2 = GeneratingSet(var2)
+    if isinstance(var3, str):
+        var3 = GeneratingSet(var3)
+    perm_dict = {Permutation(k): v for k, v in perm_dict.items()}
+    v = Permutation(v)
+    vn1 = ~v
     th = theta(vn1)
     if len(th) == 0:
         return perm_dict
     if th[0] == 0:
         return perm_dict
-    mu = permtrim(uncode(th))
-    vmu = permtrim(mulperm([*v], mu))
+    mu = uncode(th)
+    vmu = v * mu
     inv_vmu = inv(vmu)
     inv_mu = inv(mu)
     ret_dict = {}
@@ -310,18 +358,19 @@ def schubmult(perm_dict, v, var2=None, var3=None):
     vpathdicts = compute_vpathdicts(th, vmu, True)
     for u, val in perm_dict.items():
         inv_u = inv(u)
-        vpathsums = {u: {(1, 2): val}}
+        vpathsums = {u: {Permutation([1, 2]): val}}
         for index in range(thL):
             mx_th = 0
             for vp in vpathdicts[index]:
                 for v2, vdiff, s in vpathdicts[index][vp]:
-                    if th[index] - vdiff > mx_th:
-                        mx_th = th[index] - vdiff
+                    mx_th = max(mx_th, th[index] - vdiff)
             newpathsums = {}
             for up in vpathsums:
                 inv_up = inv(up)
                 newperms = elem_sym_perms(
-                    up, min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu), th[index]
+                    up,
+                    min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu),
+                    th[index],
                 )
                 for up2, udiff in newperms:
                     if up2 not in newpathsums:
@@ -332,7 +381,8 @@ def schubmult(perm_dict, v, var2=None, var3=None):
                             continue
                         for v2, vdiff, s in vpathdicts[index][v]:
                             newpathsums[up2][v2] = newpathsums[up2].get(
-                                v2, zero
+                                v2,
+                                zero,
                             ) + s * sumval * elem_sym_func(
                                 th[index],
                                 index + 1,
@@ -346,18 +396,18 @@ def schubmult(perm_dict, v, var2=None, var3=None):
                                 var3,
                             )
             vpathsums = newpathsums
-        toget = tuple(vmu)
-        ret_dict = add_perm_dict({ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict)
+        toget = vmu
+        ret_dict = add_perm_dict({Permutation(ep): vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict)
     return ret_dict
 
 
 def schubmult_down(perm_dict, v, var2=None, var3=None):
-    vn1 = inverse(v)
+    vn1 = ~v
     th = theta(vn1)
     if th[0] == 0:
         return perm_dict
-    mu = permtrim(uncode(th))
-    vmu = permtrim(mulperm([*v], mu))
+    mu = uncode(th)
+    vmu = v * mu
     ret_dict = {}
 
     while th[-1] == 0:
@@ -365,13 +415,12 @@ def schubmult_down(perm_dict, v, var2=None, var3=None):
     thL = len(th)
     vpathdicts = compute_vpathdicts(th, vmu, True)
     for u, val in perm_dict.items():
-        vpathsums = {u: {(1, 2): val}}
+        vpathsums = {u: {Permutation([1, 2]): val}}
         for index in range(thL):
             mx_th = 0
             for vp in vpathdicts[index]:
                 for v2, vdiff, s in vpathdicts[index][vp]:
-                    if th[index] - vdiff > mx_th:
-                        mx_th = th[index] - vdiff
+                    mx_th = max(mx_th, th[index] - vdiff)
             newpathsums = {}
             for up in vpathsums:
                 newperms = elem_sym_perms_op(up, mx_th, th[index])
@@ -384,7 +433,8 @@ def schubmult_down(perm_dict, v, var2=None, var3=None):
                             continue
                         for v2, vdiff, s in vpathdicts[index][v]:
                             newpathsums[up2][v2] = newpathsums[up2].get(
-                                v2, zero
+                                v2,
+                                zero,
                             ) + s * sumval * elem_sym_func(
                                 th[index],
                                 index + 1,
@@ -398,14 +448,13 @@ def schubmult_down(perm_dict, v, var2=None, var3=None):
                                 var3,
                             )
             vpathsums = newpathsums
-        toget = tuple(vmu)
+        toget = vmu
         ret_dict = add_perm_dict({ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict)
     return ret_dict
 
 
 def poly_to_vec(poly, vec0=None, var3=_vars.var3):
-    global dimen, monom_to_vec, base_vec
-    poly = expand(poly.xreplace({var3[1]: 0}))
+    poly = expand(sympify(poly).xreplace({var3[1]: 0}))
 
     dc = poly.as_coefficients_dict()
 
@@ -428,18 +477,18 @@ def poly_to_vec(poly, vec0=None, var3=_vars.var3):
     return vec
 
 
-def shiftsub(pol, var2=_vars.var2, var3=_vars.var3):
-    subs_dict = dict([(var2[i], var2[i + 1]) for i in range(99)])
-    return sympify(pol).subs(subs_dict)
+def shiftsub(pol, var2=_vars.var2):
+    subs_dict = {var2[i]: var2[i + 1] for i in range(99)}
+    return efficient_subs(sympify(pol), subs_dict)
 
 
-def shiftsubz(pol, var2=_vars.var2, var3=_vars.var3):
-    subs_dict = dict([(var3[i], var3[i + 1]) for i in range(99)])
-    return sympify(pol).subs(subs_dict)
+def shiftsubz(pol, var3=_vars.var3):
+    subs_dict = {var3[i]: var3[i + 1] for i in range(99)}
+    return efficient_subs(sympify(pol), subs_dict)
 
 
 def init_basevec(dc):
-    global dimen, monom_to_vec, base_vec
+    global dimen, monom_to_vec, base_vec  # noqa: PLW0603
     monom_to_vec = {}
     index = 0
     for mn in dc:
@@ -462,12 +511,11 @@ def split_flat_term(arg):
                     ys += [arg2.args[1]]
             else:
                 ys += [arg2]
+        elif isinstance(arg2, Mul):
+            for i in range(abs(int(arg2.args[0]))):
+                zs += [-arg2.args[1]]
         else:
-            if isinstance(arg2, Mul):
-                for i in range(abs(int(arg2.args[0]))):
-                    zs += [-arg2.args[1]]
-            else:
-                zs += [arg2]
+            zs += [arg2]
     return ys, zs
 
 
@@ -481,11 +529,11 @@ def is_flat_term(term):
     return True
 
 
-def flatten_factors(term, var2=_vars.var2, var3=_vars.var3):
+def flatten_factors(term):
     found_one = False
     if is_flat_term(term):
         return term, False
-    elif isinstance(term, Pow):
+    if isinstance(term, Pow):
         if is_flat_term(term.args[0]) and len(term.args[0].args) > 2:
             ys, zs = split_flat_term(term.args[0])
             terms = [1]
@@ -496,11 +544,10 @@ def flatten_factors(term, var2=_vars.var2, var3=_vars.var3):
                         terms2 += [t * (ys[i] + zs[i])]
                 terms = terms2
             return Add(*terms)
-        elif is_flat_term(term.args[0]):
+        if is_flat_term(term.args[0]):
             return term, False
-        else:
-            return flatten_factors(term.args[0]) ** term.args[1], True
-    elif isinstance(term, Mul):
+        return flatten_factors(term.args[0]) ** term.args[1], True
+    if isinstance(term, Mul):
         terms = [1]
         for arg in term.args:
             terms2 = []
@@ -528,7 +575,7 @@ def flatten_factors(term, var2=_vars.var2, var3=_vars.var3):
         else:
             term = Add(*terms)
         return term, found_one
-    elif isinstance(term, Add):
+    if isinstance(term, Add):
         res = 0
         for arg in term.args:
             flat, found = flatten_factors(arg)
@@ -536,11 +583,13 @@ def flatten_factors(term, var2=_vars.var2, var3=_vars.var3):
                 found_one = True
             res += flat
         return res, found_one
+    return None
 
 
 def fres(v):
     for s in v.free_symbols:
         return s
+    return None
 
 
 def split_mul(arg0, var2=None, var3=None):
@@ -614,7 +663,7 @@ def is_negative(term):
     sign = 1
     if isinstance(term, Integer) or isinstance(term, int):
         return term < 0
-    elif isinstance(term, Mul):
+    if isinstance(term, Mul):
         for arg in term.args:
             if isinstance(arg, Integer):
                 sign *= arg
@@ -625,49 +674,32 @@ def is_negative(term):
                 mulsign = 1
                 if str(arg.args[0]).find("-y") != -1:
                     mulsign = -1
-                sign *= mulsign ** term.args[1]
+                sign *= mulsign**term.index
     elif isinstance(term, Pow):
         mulsign = 1
         if str(term.args[0]).find("-y") != -1:
             mulsign = -1
-        sign *= mulsign ** term.args[1]
+        sign *= mulsign**term.index
     return sign < 0
 
 
-def find_base_vectors(monom_list, monom_list_neg, var2, var3, depth):
+def find_base_vectors(monom_list, var2, var3, depth):
     size = 0
     mn_fullcount = {}
     # pairs_checked = set()
-    monom_list = set([tuple(mn) for mn in monom_list])
+    monom_list = {tuple(mn) for mn in monom_list}
     ct = 0
     while ct < depth and size != len(monom_list):
         size = len(monom_list)
-        # found = False
-        # for mn in mons2:
-        # if mn not in monom_list:
-        # found = True
-        # break
-        # if not found:
-        # print("Breaking")
-        # break
-
         monom_list2 = set(monom_list)
         additional_set2 = set()
         for mn in monom_list:
-            # res = 1
-            # for tp in mn:
-            # res *= var2[tp[0]] - var3[tp[1]]
-            # if poly_to_vec(res,vec) is None:
-            # continue
-
             mncount = mn_fullcount.get(mn, {})
             if mncount == {}:
                 for tp in mn:
                     mncount[tp] = mncount.get(tp, 0) + 1
                 mn_fullcount[mn] = mncount
             for mn2 in monom_list:
-                # if (mn,mn2) in pairs_checked:
-                # continue
                 mn2count = mn_fullcount.get(mn2, {})
                 if mn2count == {}:
                     for tp in mn2:
@@ -692,8 +724,7 @@ def find_base_vectors(monom_list, monom_list_neg, var2, var3, depth):
                             break
                     # print(f"{mn,mn2}")
                     if diff_term1 is None or diff_term2 is None:
-                        print(f"{mn=} {mn2=}")
-                        exit(1)
+                        raise Exception(f"{mn=} {mn2=}")
                     if diff_term2[1] == diff_term1[1]:
                         continue
                     new_term1 = (diff_term1[0], diff_term2[1])
@@ -708,19 +739,9 @@ def find_base_vectors(monom_list, monom_list_neg, var2, var3, depth):
                     mn4 = list(mn2[:index2]) + list(mn2[index2 + 1 :])
                     index2 = bisect_left(mn4, new_term2)
                     mn4_t = tuple(mn4[:index2] + [new_term2] + mn4[index2:])
-                    # res = 1
-                    # for tp in mn3_t:
-                    # res *= var2[tp[0]] - var3[tp[1]]
-                    # if poly_to_vec(res,vec) is not None:
                     if mn3_t not in monom_list2:
                         additional_set2.add(mn3_t)
                     monom_list2.add(mn3_t)
-                    # res = 1
-                    # for tp in mn4_t:
-                    # res *= var2[tp[0]] - var3[tp[1]]
-                    ##
-                    ##	additional_set2.add(mn3_t)
-                    # if poly_to_vec(res,vec) is not None:
                     if mn4_t not in monom_list2:
                         additional_set2.add(mn4_t)
                     monom_list2.add(mn4_t)
@@ -737,41 +758,34 @@ def find_base_vectors(monom_list, monom_list_neg, var2, var3, depth):
     return ret, monom_list
 
 
-def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
+def compute_positive_rep(val, var2=GeneratingSet("y"), var3=GeneratingSet("z"), msg=False, do_pos_neg=True):
+    do_pos_neg = False
     notint = False
     try:
-        int(expand(val))
-        val2 = expand(val)
+        val2 = int(expand(val))
+        # val2 = expand(val)
     except Exception:
         notint = True
     if notint:
         frees = val.free_symbols
-        var2list = [*var2]
-        var3list = [*var3]
-
-        for i in range(len(var2list)):
-            symset = var2list[i].free_symbols
-            for sym in symset:
-                var2list[i] = sym
-
-        for i in range(len(var3list)):
-            symset = var3list[i].free_symbols
-            for sym in symset:
-                var3list[i] = sym
-
-        varsimp2 = [m for m in frees if m in var2list]
-        varsimp3 = [m for m in frees if m in var3list]
-        varsimp2.sort(key=lambda k: var2list.index(k))
-        varsimp3.sort(key=lambda k: var3list.index(k))
-
-        var22 = [sympy.sympify(m) for m in varsimp2]
-        var33 = [sympy.sympify(m) for m in varsimp3]
+        # logger.debug(f"{frees=}")
+        # logger.debug(f"{[type(s) for s in frees]=}")
+        varsimp2 = [m for m in frees if var2.index(m) != -1]
+        varsimp3 = [m for m in frees if var3.index(m) != -1]
+        varsimp2.sort(key=lambda k: var2.index(k))
+        varsimp3.sort(key=lambda k: var3.index(k))
+        # logger.debug(f"{varsimp2=}")
+        # logger.debug(f"{varsimp3=}")
+        var22 = [sympy.sympify(v) for v in varsimp2]
+        var33 = [sympy.sympify(v) for v in varsimp3]
+        # var22 = [sympy.sympify(m) for m in varsimp2]
+        # var33 = [sympy.sympify(m) for m in varsimp3]
         n1 = len(varsimp2)
 
-        for i in range(len(varsimp2)):
-            varsimp2[i] = var2[var2list.index(varsimp2[i])]
-        for i in range(len(varsimp3)):
-            varsimp3[i] = var3[var3list.index(varsimp3[i])]
+        # for i in range(len(varsimp2)):
+        #     varsimp2[i] = var2[var2list.index(varsimp2[i])]
+        # for i in range(len(varsimp3)):
+        #     varsimp3[i] = var3[var3list.index(varsimp3[i])]
 
         base_vectors = []
         base_monoms = []
@@ -798,9 +812,9 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
             depth = 1
 
             mons = split_monoms(pos_part, varsimp2, varsimp3)
-            mons = set([tuple(mn) for mn in mons])
+            mons = {tuple(mn) for mn in mons}
             mons2 = split_monoms(neg_part, varsimp2, varsimp3)
-            mons2 = set([tuple(mn2) for mn2 in mons2])
+            mons2 = {tuple(mn2) for mn2 in mons2}
 
             # mons2 = split_monoms(neg_part)
             # for mn in mons2:
@@ -827,12 +841,9 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
                 for j in range(len(bad_vectors) - 1, -1, -1):
                     base_monoms.pop(bad_vectors[j])
 
-                vrs = [
-                    pu.LpVariable(name=f"a{i}", lowBound=0, cat="Integer")
-                    for i in range(len(base_vectors))
-                ]
+                vrs = [pu.LpVariable(name=f"a{i}", lowBound=0, cat="Integer") for i in range(len(base_vectors))]
                 lp_prob = pu.LpProblem("Problem", pu.LpMinimize)
-                lp_prob += int(0)
+                lp_prob += 0
                 eqs = [*base_vec]
                 for j in range(len(base_vectors)):
                     for i in base_vectors[j]:
@@ -862,38 +873,37 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
                     raise KeyboardInterrupt()
                 status = lp_prob.status
         else:
+            # logger.debug("this")
             val_poly = sympy.poly(expand(val), *var22, *var33)
             vec = poly_to_vec(val)
             mn = val_poly.monoms()
             L1 = tuple([0 for i in range(n1)])
             mn1L = []
             lookup = {}
+            # logger.debug("this")
             for mm0 in mn:
                 key = mm0[n1:]
                 if key not in lookup:
                     lookup[key] = []
                 mm0n1 = mm0[:n1]
                 st = set(mm0n1)
-                if len(st.intersection(set([0, 1]))) == len(st) and 1 in st:
+                if len(st.intersection({0, 1})) == len(st) and 1 in st:
                     lookup[key] += [mm0]
                 if mm0n1 == L1:
                     mn1L += [mm0]
+            # logger.debug("this")
             for mn1 in mn1L:
                 comblistmn1 = [1]
                 for i in range(n1, len(mn1)):
                     if mn1[i] != 0:
                         arr = np.array(comblistmn1)
                         comblistmn12 = []
-                        mn1_2 = tuple([*mn1[n1:i]] + [0] + [*mn1[i + 1 :]])
+                        mn1_2 = (*mn1[n1:i], 0, *mn1[i + 1 :])
                         for mm0 in lookup[mn1_2]:
                             comblistmn12 += (
                                 arr
                                 * np.prod(
-                                    [
-                                        varsimp2[k] - varsimp3[i - n1]
-                                        for k in range(n1)
-                                        if mm0[k] == 1
-                                    ]
+                                    [varsimp2[k] - varsimp3[i - n1] for k in range(n1) if mm0[k] == 1],
                                 )
                             ).tolist()
                         comblistmn1 = comblistmn12
@@ -903,12 +913,9 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
                     if vec0 is not None:
                         base_vectors += [vec0]
                         base_monoms += [b1]
-            vrs = [
-                pu.LpVariable(name=f"a{i}", lowBound=0, cat="Integer")
-                for i in range(len(base_vectors))
-            ]
+            vrs = [pu.LpVariable(name=f"a{i}", lowBound=0, cat="Integer") for i in range(len(base_vectors))]
             lp_prob = pu.LpProblem("Problem", pu.LpMinimize)
-            lp_prob += int(0)
+            lp_prob += 0
             eqs = [*base_vec]
             for j in range(len(base_vectors)):
                 for i in base_vectors[j]:
@@ -919,7 +926,9 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
                         eqs[i] += bvi * vrs[j]
             for i in range(dimen):
                 lp_prob += eqs[i] == vec[i]
+            # logger.debug("I IS SOLVING")
             try:
+                # logger.debug("I IS SOLVING BOLVING")
                 solver = pu.PULP_CBC_CMD(msg=msg)
                 status = lp_prob.solve(solver)
             except KeyboardInterrupt:
@@ -944,145 +953,74 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
             b1 = base_monoms[k]
             if x != 0 and x is not None:
                 val2 += int(x) * b1
+    # logger.debug(f"{val2=}")
     return val2
 
 
-def is_split_two(u, v, w):
-    if inv(w) - inv(u) != 2:
-        return False, []
-    diff_perm = mulperm(inverse([*u]), [*w])
-    identity = [i + 1 for i in range(len(diff_perm))]
-    cycles = []
-    for i in range(len(identity)):
-        if diff_perm[i] != identity[i]:
-            cycle0 = set()
-            cycle = set([i + 1])
-            last = i
-            while len(cycle0) != len(cycle):
-                cycle0 = cycle
-                last = diff_perm[last] - 1
-                cycle.add(last + 1)
-            if len(cycle) > 1 and cycle not in cycles:
-                cycles += [cycle]
-            if len(cycles) > 2:
-                break
-    if len(cycles) == 2:
-        return True, cycles
-    else:
-        return False, []
-
-
-def is_coeff_irreducible(u, v, w):
-    return (
-        not will_formula_work(u, v)
-        and not will_formula_work(v, u)
-        and not one_dominates(u, w)
-        and not is_reducible(v)
-        and inv(w) - inv(u) > 1
-        and not is_split_two(u, v, w)[0]
-        and len([i for i in code(v) if i != 0]) > 1
-    )
-
-
-def is_hook(cd):
-    started = False
-    done = False
-    found_zero_after = False
-    for i in range(len(cd)):
-        if (done or found_zero_after) and cd[i] != 0:
-            return False
-        if cd[i] == 1 and not started:
-            started = True
-        if cd[i] > 1:
-            done = True
-        if started and cd[i] == 0:
-            found_zero_after = True
-    if started or done:
-        return True
-    return False
-
-
-def div_diff(i, poly, var2=_vars.var2):
-    return sympify(
-        sympy.div(sympy.sympify(poly - permy(poly, i)), sympy.sympify(var2[i] - var2[i + 1]))[0]
-    )
-
-
-def skew_div_diff(u, w, poly):
-    d = -1
-    for i in range(len(w) - 1):
-        if w[i] > w[i + 1]:
-            d = i
-            break
-    d2 = -1
-    for i in range(len(u) - 1):
-        if u[i] > u[i + 1]:
-            d2 = i
-            break
-    if d == -1:
-        if d2 == -1:
-            return poly
-        return 0
-    w2 = [*w]
-    w2[d], w2[d + 1] = w2[d + 1], w2[d]
-    if d < len(u) - 1 and u[d] > u[d + 1]:
-        u2 = [*u]
-        u2[d], u2[d + 1] = u2[d + 1], u2[d]
-        return skew_div_diff(u2, w2, permy(poly, d + 1))
-    else:
-        return skew_div_diff(u, w2, div_diff(d + 1, poly))
+def posify_generic_partial(val, u2, v2, w2):
+    val2 = val
+    val = posify(val, u2, v2, w2, var2=_vars.var_g1, var3=_vars.var_g2, msg=True, do_pos_neg=False, sign_only=False, optimize=False)
+    if expand(val - val2) != 0:
+        # logger.debug("Warning, failed on a case")
+        raise Exception(f"{val=} {val2=} {u2=} {v2=} {w2=}")
+    # print("FROFL")
+    return val
+
+
+@cache
+def schubmult_generic_partial_posify(u2, v2):
+    return {w2: posify_generic_partial(val, u2, v2, w2) for w2, val in schubmult_double_pair_generic(u2, v2).items()}
 
 
 @cached(
     cache={},
-    key=lambda val,
+    key=lambda val, u2, v2, w2, var2=None, var3=None, msg=False, do_pos_neg=False, sign_only=False, optimize=True: hashkey(val, u2, v2, w2, var2, var3, msg, do_pos_neg, sign_only, optimize),
+)
+def posify(
+    val,
     u2,
     v2,
     w2,
     var2=None,
     var3=None,
     msg=False,
-    do_pos_neg=True,
-    sign_only=False: hashkey(u2, v2, w2, var2, var3, msg, do_pos_neg, sign_only),
-)
-def posify(
-    val, u2, v2, w2, var2=None, var3=None, msg=False, do_pos_neg=True, sign_only=False, n=_vars.n
+    do_pos_neg=False,
+    sign_only=False,
+    optimize=True,
+    n=_vars.n,
 ):
+    # logger.debug(f"NEW {val=} {u2=} {v2=} {w2=}")
+    oldval = val
     if inv(u2) + inv(v2) - inv(w2) == 0:
+        # logger.debug(f"Hmm this is probably not or val inty true {val=}")
         return val
-    cdv = code(v2)
-    if set(cdv) == set([0, 1]) and do_pos_neg:
-        return val
-    # if is_hook(cdv):
-    # print(f"Could've {cdv}")
+
     if not sign_only and expand(val) == 0:
+        # logger.debug(f"Hmm this is probably not true {u2=} {v2=} {w2=} {val=}")
         return 0
-
-    u, v, w = try_reduce_v(u2, v2, w2)
-    if is_coeff_irreducible(u, v, w):
+    # logger.debug("proceeding")
+    u, v, w = u2, v2, w2
+    # u, v, w = try_reduce_v(u2, v2, w2)
+    if is_coeff_irreducible(u2, v2, w2):
         u, v, w = try_reduce_u(u2, v2, w2)
         if is_coeff_irreducible(u, v, w):
-            u, v, w = [*u2], [*v2], [*w2]
+            u, v, w = u2, v2, w2
             if is_coeff_irreducible(u, v, w):
-                w0 = [*w]
+                w0 = w
                 u, v, w = reduce_descents(u, v, w)
                 if is_coeff_irreducible(u, v, w):
                     u, v, w = reduce_coeff(u, v, w)
                     if is_coeff_irreducible(u, v, w):
-                        while is_coeff_irreducible(u, v, w) and tuple(permtrim(w0)) != tuple(
-                            permtrim([*w])
-                        ):
+                        while is_coeff_irreducible(u, v, w) and w0 != w:
                             w0 = w
                             u, v, w = reduce_descents(u, v, w)
                             if is_coeff_irreducible(u, v, w):
                                 u, v, w = reduce_coeff(u, v, w)
-    u = tuple(u)
-    v = tuple(v)
-    w = tuple(w)
 
     if w != w2 and sign_only:
+        # logger.debug(f"Return 0 ")
         return 0
-
+    # logger.debug(f"Reduced to {u2=} {v2=} {w2=} {val=}")
     if is_coeff_irreducible(u, v, w):
         u3, v3, w3 = try_reduce_v(u, v, w)
         if not is_coeff_irreducible(u3, v3, w3):
@@ -1092,8 +1030,9 @@ def posify(
             if not is_coeff_irreducible(u3, v3, w3):
                 u, v, w = u3, v3, w3
     split_two_b, split_two = is_split_two(u, v, w)
-
+    # logger.debug("Recording line number")
     if len([i for i in code(v) if i != 0]) == 1:
+        # logger.debug("Recording line number")
         if sign_only:
             return 0
         cv = code(v)
@@ -1106,32 +1045,35 @@ def posify(
         r = inv(w) - inv_u
         val = 0
         w2 = w
-        hvarset = (
-            [w2[i] for i in range(min(len(w2), k))]
-            + [i + 1 for i in range(len(w2), k)]
-            + [w2[b] for b in range(k, len(u)) if u[b] != w2[b]]
-            + [w2[b] for b in range(len(u), len(w2))]
-        )
-        val = elem_sym_poly(
+        hvarset = [w2[i] for i in range(min(len(w2), k))] + [i + 1 for i in range(len(w2), k)] + [w2[b] for b in range(k, len(u)) if u[b] != w2[b]] + [w2[b] for b in range(len(u), len(w2))]
+        # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+        return elem_sym_poly(
             p - r,
             k + p - 1,
             [-var3[i] for i in range(1, n)],
             [-var2[i] for i in hvarset],
         )
-    elif will_formula_work(v, u) or dominates(u, w):
+        # if expand(val - oldval) != 0:
+        #     # logger.debug("This is bad")
+        #     # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=}")
+    if will_formula_work(v, u) or dominates(u, w):
+        # logger.debug("Recording line number")
         if sign_only:
             return 0
-        val = dualcoeff(u, v, w, var2, var3)
-    elif inv(w) - inv(u) == 1:
+        return dualcoeff(u, v, w, var2, var3)
+        # if expand(val - oldval) != 0:
+        # logger.debug("This is bad")
+        # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=} {will_formula_work(v,u)=} {dominates(u,w)=}")
+        # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+    if inv(w) - inv(u) == 1:
+        # logger.debug("Recording line number")
         if sign_only:
             return 0
         a, b = -1, -1
         for i in range(len(w)):
             if a == -1 and u[i] != w[i]:
                 a = i
-            elif i >= len(u) and w[i] != i + 1:
-                b = i
-            elif b == -1 and u[i] != w[i]:
+            elif (i >= len(u) and w[i] != i + 1) or (b == -1 and u[i] != w[i]):
                 b = i
         arr = [[[], v]]
         d = -1
@@ -1148,17 +1090,16 @@ def posify(
             elif i > a:
                 i2 += 1
             for vr, v2 in arr:
-                dpret = pull_out_var(i2, [*v2])
+                dpret = pull_out_var(i2, v2)
                 for v3r, v3 in dpret:
-                    arr2 += [[vr + [v3r], v3]]
+                    arr2 += [[[*vr, v3r], v3]]
             arr = arr2
         val = 0
         for L in arr:
-            v3 = [*L[-1]]
+            v3 = L[-1]
             if v3[0] < v3[1]:
                 continue
-            else:
-                v3[0], v3[1] = v3[1], v3[0]
+            v3 = v3.swap(0, 1)
             toadd = 1
             for i in range(d):
                 if i in [a, b]:
@@ -1177,454 +1118,333 @@ def posify(
                     toadd *= var2[yv] - var3[oaf[j]]
             toadd *= schubpoly(v3, [0, var2[w[a]], var2[w[b]]], var3)
             val += toadd
-    elif split_two_b:
+        # if expand(val - oldval) != 0:
+        # logger.debug("This is bad")
+        # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=}")
+        # logger.debug(f"good to go {u2=} {v2=} {w2=}")
+        return val
+    # if split_two_b:
+    #     # logger.debug("Recording line number")
+    #     if sign_only:
+    #         return 0
+    #     cycles = split_two
+    #     a1, b1 = cycles[0]
+    #     a2, b2 = cycles[1]
+    #     a1 -= 1
+    #     b1 -= 1
+    #     a2 -= 1
+    #     b2 -= 1
+    #     spo = sorted([a1, b1, a2, b2])
+    #     real_a1 = min(spo.index(a1), spo.index(b1))
+    #     real_a2 = min(spo.index(a2), spo.index(b2))
+    #     real_b1 = max(spo.index(a1), spo.index(b1))
+    #     real_b2 = max(spo.index(a2), spo.index(b2))
+
+    #     good1 = False
+    #     good2 = False
+    #     if real_b1 - real_a1 == 1:
+    #         good1 = True
+    #     if real_b2 - real_a2 == 1:
+    #         good2 = True
+    #     a, b = -1, -1
+    #     if good1 and not good2:
+    #         a, b = min(a2, b2), max(a2, b2)
+    #     if good2 and not good1:
+    #         a, b = min(a1, b1), max(a1, b1)
+    #     arr = [[[], v]]
+    #     d = -1
+    #     for i in range(len(v) - 1):
+    #         if v[i] > v[i + 1]:
+    #             d = i + 1
+    #     for i in range(d):
+    #         arr2 = []
+
+    #         if i in [a1, b1, a2, b2]:
+    #             continue
+    #         i2 = 1
+    #         i2 += len([aa for aa in [a1, b1, a2, b2] if i > aa])
+    #         for vr, v2 in arr:
+    #             dpret = pull_out_var(i2, v2)
+    #             for v3r, v3 in dpret:
+    #                 arr2 += [[[*vr, (v3r, i + 1)], v3]]
+    #         arr = arr2
+    #     val = 0
+
+    #     if good1:
+    #         arr2 = []
+    #         for L in arr:
+    #             v3 = L[-1]
+    #             if v3[real_a1] < v3[real_b1]:
+    #                 continue
+    #             v3 = v3.swap(real_a1, real_b1)
+    #             arr2 += [[L[0], v3]]
+    #         arr = arr2
+    #         if not good2:
+    #             for i in range(4):
+    #                 arr2 = []
+
+    #                 if i in [real_a2, real_b2]:
+    #                     continue
+    #                 if i == real_a1:
+    #                     var_index = min(a1, b1) + 1
+    #                 elif i == real_b1:
+    #                     var_index = max(a1, b1) + 1
+    #                 i2 = 1
+    #                 i2 += len([aa for aa in [real_a2, real_b2] if i > aa])
+    #                 for vr, v2 in arr:
+    #                     dpret = pull_out_var(i2, v2)
+    #                     for v3r, v3 in dpret:
+    #                         arr2 += [[[*vr, (v3r, var_index)], v3]]
+    #                 arr = arr2
+    #     if good2:
+    #         arr2 = []
+    #         for L in arr:
+    #             v3 = L[-1]
+    #             try:
+    #                 if v3[real_a2] < v3[real_b2]:
+    #                     continue
+    #                 v3 = v3.swap(real_a2, real_b2)
+    #             except IndexError:
+    #                 continue
+    #             arr2 += [[L[0], v3]]
+    #         arr = arr2
+    #         if not good1:
+    #             for i in range(4):
+    #                 arr2 = []
+
+    #                 if i in [real_a1, real_b1]:
+    #                     continue
+    #                 i2 = 1
+    #                 i2 += len([aa for aa in [real_a1, real_b1] if i > aa])
+    #                 if i == real_a2:
+    #                     var_index = min(a2, b2) + 1
+    #                 elif i == real_b2:
+    #                     var_index = max(a2, b2) + 1
+    #                 for vr, v2 in arr:
+    #                     dpret = pull_out_var(i2, v2)
+    #                     for v3r, v3 in dpret:
+    #                         arr2 += [[[*vr, (v3r, var_index)], v3]]
+    #                 arr = arr2
+
+    #         for L in arr:
+    #             v3 = L[-1]
+    #             tomul = 1
+    #             doschubpoly = True
+    #             if (not good1 or not good2) and v3[0] < v3[1] and (good1 or good2):
+    #                 continue
+    #             if (good1 or good2) and (not good1 or not good2):
+    #                 v3 = v3.swap(0, 1)
+    #             elif not good1 and not good2:
+    #                 doschubpoly = False
+    #                 if v3[0] < v3[1]:
+    #                     dual_u = uncode([2, 0])
+    #                     dual_w = Permutation([4, 2, 1, 3])
+    #                     coeff = perm_act(dualcoeff(dual_u, v3, dual_w, var2, var3), 2, var2)
+
+    #                 elif len(v3) < 3 or v3[1] < v3[2]:
+    #                     if len(v3) <= 3 or v3[2] < v3[3]:
+    #                         coeff = 0
+    #                         continue
+    #                     v3 = v3.swap(0, 1).swap(2, 3)
+    #                     coeff = perm_act(schubpoly(v3, var2, var3), 2, var2)
+    #                 elif len(v3) <= 3 or v3[2] < v3[3]:
+    #                     if len(v3) <= 3:
+    #                         v3 += [4]
+    #                     v3 = v3.swap(2, 3)
+    #                     coeff = perm_act(
+    #                         posify(
+    #                             schubmult_one(Permutation([1, 3, 2]), v3, var2, var3).get(
+    #                                 Permutation([2, 4, 3, 1]),
+    #                                 0,
+    #                             ),
+    #                             Permutation([1, 3, 2]),
+    #                             v3,
+    #                             Permutation([2, 4, 3, 1]),
+    #                             var2,
+    #                             var3,
+    #                             msg,
+    #                             do_pos_neg,
+    #                             optimize=optimize,
+    #                         ),
+    #                         2,
+    #                         var2,
+    #                     )
+    #                     # logger.debug(f"{coeff=}")
+    #                 else:
+    #                     coeff = perm_act(
+    #                         schubmult_one(Permutation([1, 3, 2]), v3, var2, var3).get(
+    #                             Permutation([2, 4, 1, 3]),
+    #                             0,
+    #                         ),
+    #                         2,
+    #                         var2,
+    #                     )
+    #                 # logger.debug(f"{coeff=}")
+    #                 # if expand(coeff) == 0:
+    #                 #     # logger.debug("coeff 0 oh no")
+    #                 tomul = sympify(coeff)
+    #             toadd = 1
+    #             for i in range(len(L[0])):
+    #                 var_index = L[0][i][1]
+    #                 oaf = L[0][i][0]
+    #                 if var_index - 1 >= len(w):
+    #                     yv = var_index
+    #                 else:
+    #                     yv = w[var_index - 1]
+    #                 for j in range(len(oaf)):
+    #                     toadd *= var2[yv] - var3[oaf[j]]
+    #             if (not good1 or not good2) and (good1 or good2):
+    #                 varo = [0, var2[w[a]], var2[w[b]]]
+    #             else:
+    #                 varo = [0, *[var2[w[spo[k]]] for k in range(4)]]
+    #             if doschubpoly:
+    #                 toadd *= schubpoly(v3, varo, var3)
+    #             else:
+    #                 subs_dict3 = {var2[i]: varo[i] for i in range(len(varo))}
+    #                 toadd *= efficient_subs(tomul, subs_dict3)
+    #             val += toadd
+    #             # logger.debug(f"accum {val=}")
+    #         #logger.debug(f"{expand(val-oldval)=}")
+    #         # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+    #         return val
+    if will_formula_work(u, v):
+        # logger.debug("Recording line number")
         if sign_only:
             return 0
-        cycles = split_two
-        a1, b1 = cycles[0]
-        a2, b2 = cycles[1]
-        a1 -= 1
-        b1 -= 1
-        a2 -= 1
-        b2 -= 1
-        spo = sorted([a1, b1, a2, b2])
-        real_a1 = min(spo.index(a1), spo.index(b1))
-        real_a2 = min(spo.index(a2), spo.index(b2))
-        real_b1 = max(spo.index(a1), spo.index(b1))
-        real_b2 = max(spo.index(a2), spo.index(b2))
-
-        good1 = False
-        good2 = False
-        if real_b1 - real_a1 == 1:
-            good1 = True
-        if real_b2 - real_a2 == 1:
-            good2 = True
-        a, b = -1, -1
-        if good1 and not good2:
-            a, b = min(a2, b2), max(a2, b2)
-        if good2 and not good1:
-            a, b = min(a1, b1), max(a1, b1)
-        arr = [[[], v]]
-        d = -1
-        for i in range(len(v) - 1):
-            if v[i] > v[i + 1]:
-                d = i + 1
-        for i in range(d):
-            arr2 = []
-
-            if i in [a1, b1, a2, b2]:
-                continue
-            i2 = 1
-            i2 += len([aa for aa in [a1, b1, a2, b2] if i > aa])
-            for vr, v2 in arr:
-                dpret = pull_out_var(i2, [*v2])
-                for v3r, v3 in dpret:
-                    arr2 += [[vr + [(v3r, i + 1)], v3]]
-            arr = arr2
-        val = 0
-
-        if good1:
-            arr2 = []
-            for L in arr:
-                v3 = [*L[-1]]
-                if v3[real_a1] < v3[real_b1]:
-                    continue
-                else:
-                    v3[real_a1], v3[real_b1] = v3[real_b1], v3[real_a1]
-                arr2 += [[L[0], v3]]
-            arr = arr2
-            if not good2:
-                for i in range(4):
-                    arr2 = []
-
-                    if i in [real_a2, real_b2]:
-                        continue
-                    if i == real_a1:
-                        var_index = min(a1, b1) + 1
-                    elif i == real_b1:
-                        var_index = max(a1, b1) + 1
-                    i2 = 1
-                    i2 += len([aa for aa in [real_a2, real_b2] if i > aa])
-                    for vr, v2 in arr:
-                        dpret = pull_out_var(i2, [*v2])
-                        for v3r, v3 in dpret:
-                            arr2 += [[vr + [(v3r, var_index)], v3]]
-                    arr = arr2
-        if good2:
-            arr2 = []
-            for L in arr:
-                v3 = [*L[-1]]
-                try:
-                    if v3[real_a2] < v3[real_b2]:
-                        continue
-                    else:
-                        v3[real_a2], v3[real_b2] = v3[real_b2], v3[real_a2]
-                except IndexError:
-                    continue
-                arr2 += [[L[0], v3]]
-            arr = arr2
-            if not good1:
-                for i in range(4):
-                    arr2 = []
-
-                    if i in [real_a1, real_b1]:
-                        continue
-                    i2 = 1
-                    i2 += len([aa for aa in [real_a1, real_b1] if i > aa])
-                    if i == real_a2:
-                        var_index = min(a2, b2) + 1
-                    elif i == real_b2:
-                        var_index = max(a2, b2) + 1
-                    for vr, v2 in arr:
-                        dpret = pull_out_var(i2, [*v2])
-                        for v3r, v3 in dpret:
-                            arr2 += [[vr + [(v3r, var_index)], v3]]
-                    arr = arr2
-
-        for L in arr:
-            v3 = [*L[-1]]
-            tomul = 1
-            doschubpoly = True
-            if (not good1 or not good2) and v3[0] < v3[1] and (good1 or good2):
-                continue
-            elif (good1 or good2) and (not good1 or not good2):
-                v3[0], v3[1] = v3[1], v3[0]
-            elif not good1 and not good2:
-                doschubpoly = False
-                if v3[0] < v3[1]:
-                    dual_u = uncode([2, 0])
-                    dual_w = [4, 2, 1, 3]
-                    coeff = permy(dualcoeff(dual_u, v3, dual_w, var2, var3), 2)
-
-                elif len(v3) < 3 or v3[1] < v3[2]:
-                    if len(v3) <= 3 or v3[2] < v3[3]:
-                        coeff = 0
-                        continue
-                    else:
-                        v3[0], v3[1] = v3[1], v3[0]
-                        v3[2], v3[3] = v3[3], v3[2]
-                        coeff = permy(schubpoly(v3, var2, var3), 2)
-                elif len(v3) <= 3 or v3[2] < v3[3]:
-                    if len(v3) <= 3:
-                        v3 += [4]
-                    v3[2], v3[3] = v3[3], v3[2]
-                    coeff = permy(
-                        posify(
-                            schubmult_one((1, 3, 2), tuple(permtrim([*v3])), var2, var3).get(
-                                (2, 4, 3, 1), 0
-                            ),
-                            (1, 3, 2),
-                            tuple(permtrim([*v3])),
-                            (2, 4, 3, 1),
-                            var2,
-                            var3,
-                            msg,
-                            do_pos_neg,
-                        ),
-                        2,
-                    )
-                else:
-                    coeff = permy(
-                        schubmult_one((1, 3, 2), tuple(permtrim([*v3])), var2, var3).get(
-                            (2, 4, 1, 3), 0
-                        ),
-                        2,
-                    )
-                tomul = sympify(coeff)
-            toadd = 1
-            for i in range(len(L[0])):
-                var_index = L[0][i][1]
-                oaf = L[0][i][0]
-                if var_index - 1 >= len(w):
-                    yv = var_index
-                else:
-                    yv = w[var_index - 1]
-                for j in range(len(oaf)):
-                    toadd *= var2[yv] - var3[oaf[j]]
-            if (not good1 or not good2) and (good1 or good2):
-                varo = [0, var2[w[a]], var2[w[b]]]
-            else:
-                varo = [0, *[var2[w[spo[k]]] for k in range(4)]]
-            if doschubpoly:
-                toadd *= schubpoly(v3, varo, var3)
-            else:
-                subs_dict3 = {var2[i]: varo[i] for i in range(len(varo))}
-                toadd *= tomul.subs(subs_dict3)
-            val += toadd
-    elif will_formula_work(u, v):
+        # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+        return forwardcoeff(u, v, w, var2, var3)
+        # if expand(val - oldval) != 0:
+        #     # logger.debug("This is bad")
+        #     # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=}")
+    # logger.debug("Recording line number")
+    # c01 = code(u)
+    # c02 = code(w)
+    # c03 = code(v)
+
+    c1 = code(~u)
+    c2 = code(~w)
+
+    if one_dominates(u, w):
         if sign_only:
             return 0
-        val = forwardcoeff(u, v, w, var2, var3)
-    # elif inv(w) - inv(u) == 2:
-    # indices = []
-    # for i in range(len(w)):
-    # if i>=len(u) or u[i]!=w[i]:
-    # indices += [i+1]
-    # arr = [[[],v]]
-    # d = -1
-    # for i in range(len(v)-1):
-    # if v[i]>v[i+1]:
-    # d = i + 1
-    # for i in range(d):
-    # arr2 = []
-    #
-    # if i+1 in indices:
-    # continue
-    # i2 = 1
-    # i2 += len([aa for aa in indices if i+1>aa])
-    # for vr, v2 in arr:
-    # dpret = pull_out_var(i2,[*v2])
-    # for v3r, v3 in dpret:
-    # arr2 += [[vr + [(v3r,i+1)],v3]]
-    # arr = arr2
-    # val = 0
-    #
-    # for L in arr:
-    # v3 = [*L[-1]]
-    # tomul = 1
-    # pooly = skew_div_diff(u,w,schubpoly(v3,[0,*[var2[a] for a in indices]],var3))
-    # coeff = compute_positive_rep(pooly,var2,var3,msg,False)
-    # if coeff == -1:
-    # return -1
-    # tomul = sympify(coeff)
-    # toadd = 1
-    # for i in range(len(L[0])):
-    # var_index = L[0][i][1]
-    # oaf = L[0][i][0]
-    # if var_index-1>=len(w):
-    # yv = var_index
-    # else:
-    # yv = w[var_index-1]
-    # for j in range(len(oaf)):
-    # toadd*= var2[yv] - var3[oaf[j]]
-    # toadd*=tomul#.subs(subs_dict3)
-    # val += toadd
-    else:
-        c01 = code(u)
-        c02 = code(w)
-        c03 = code(v)
-
-        c1 = code(inverse(u))
-        c2 = code(inverse(w))
-
-        if one_dominates(u, w):
-            if sign_only:
-                return 0
-            while c1[0] != c2[0]:
-                w = [*w]
-                v = [*v]
-                w[c2[0] - 1], w[c2[0]] = w[c2[0]], w[c2[0] - 1]
-                v[c2[0] - 1], v[c2[0]] = v[c2[0]], v[c2[0] - 1]
-                w = tuple(w)
-                v = tuple(v)
-                c2 = code(inverse(w))
-                c03 = code(v)
-                c01 = code(u)
-                c02 = code(w)
-
-        if is_reducible(v):
+        while c1[0] != c2[0]:
+            w = w.swap(c2[0] - 1, c2[0])
+            v = v.swap(c2[0] - 1, c2[0])
+            # w[c2[0] - 1], w[c2[0]] = w[c2[0]], w[c2[0] - 1]
+            # v[c2[0] - 1], v[c2[0]] = v[c2[0]], v[c2[0] - 1]
+            # w = tuple(w)
+            # v = tuple(v)
+            c2 = code(~w)
+            # c03 = code(v)
+            # c01 = code(u)
+            # c02 = code(w)
+        # if is_reducible(v):
+        #     # logger.debug("Recording line number")
+        #     if sign_only:
+        #         return 0
+        #     newc = []
+        #     elemc = []
+        #     for i in range(len(c03)):
+        #         if c03[i] > 0:
+        #             newc += [c03[i] - 1]
+        #             elemc += [1]
+        #         else:
+        #             break
+        #     v3 = uncode(newc)
+        #     coeff_dict = schubmult_one(
+        #         u,
+        #         uncode(elemc),
+        #         var2,
+        #         var3,
+        #     )
+        #     val = 0
+        #     for new_w in coeff_dict:
+        #         tomul = coeff_dict[new_w]
+        #         newval = schubmult_one(new_w, uncode(newc), var2, var3).get(
+        #             w,
+        #             0,
+        #         )
+        #         # logger.debug(f"Calling posify on {newval=} {new_w=} {uncode(newc)=} {w=}")
+        #         newval = posify(newval, new_w, uncode(newc), w, var2, var3, msg, do_pos_neg, optimize=optimize)
+        #         val += tomul * shiftsubz(newval)
+        #     # if expand(val - oldval) != 0:
+        #     #     # logger.debug("This is bad")
+        #     #     # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=}")
+        #         # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+        #     return val
+        # removed, iffy (hard to implement)
+        # if c01[0] == c02[0] and c01[0] != 0:
+        #     # logger.debug("Recording line number")
+        #     if sign_only:
+        #         return 0
+        #     varl = c01[0]
+        #     u3 = uncode([0] + c01[1:])
+        #     w3 = uncode([0] + c02[1:])
+        #     val = 0
+        #     val = schubmult_one(u3, v, var2, var3).get(
+        #         w3,
+        #         0,
+        #     )
+        #     # logger.debug(f"Calling posify on {val=} {u3=} {v=} {w3=}")
+        #     val = posify(val, u3, v, w3, var2, var3, msg, do_pos_neg, optimize=optimize)
+        #     for i in range(varl):
+        #         val = perm_act(val, i + 1, var2)
+        #     # if expand(val - oldval) != 0:
+        #     #     # logger.debug("This is bad")
+        #     #     # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=}")
+        #     # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+        #     return val
+        if c1[0] == c2[0]:
+            # logger.debug("Recording line number")
             if sign_only:
                 return 0
-            newc = []
-            elemc = []
-            for i in range(len(c03)):
-                if c03[i] > 0:
-                    newc += [c03[i] - 1]
-                    elemc += [1]
-                else:
-                    break
-            v3 = uncode(newc)
-            coeff_dict = schubmult_one(
-                tuple(permtrim([*u])), tuple(permtrim(uncode(elemc))), var2, var3
-            )
-            val = 0
-            for new_w in coeff_dict:
-                tomul = coeff_dict[new_w]
-                newval = schubmult_one(new_w, tuple(permtrim(uncode(newc))), var2, var3).get(
-                    tuple(permtrim([*w])), 0
-                )
-                newval = posify(
-                    newval,
-                    new_w,
-                    tuple(permtrim(uncode(newc))),
-                    w,
-                    var2,
-                    var3,
-                    msg,
-                    do_pos_neg,
-                )
-                val += tomul * shiftsubz(newval)
-        elif c01[0] == c02[0] and c01[0] != 0:
-            if sign_only:
-                return 0
-            varl = c01[0]
-            u3 = uncode([0] + c01[1:])
-            w3 = uncode([0] + c02[1:])
-            val = 0
-            val = schubmult_one(tuple(permtrim(u3)), tuple(permtrim([*v])), var2, var3).get(
-                tuple(permtrim(w3)), 0
-            )
-            val = posify(
-                val,
-                tuple(permtrim(u3)),
-                tuple(permtrim([*v])),
-                tuple(permtrim(w3)),
-                var2,
-                var3,
-                msg,
-                do_pos_neg,
-            )
-            for i in range(varl):
-                val = permy(val, i + 1)
-        elif c1[0] == c2[0]:
-            if sign_only:
-                return 0
-            vp = pull_out_var(c1[0] + 1, [*v])
-            u3 = tuple(permtrim(phi1(u)))
-            w3 = tuple(permtrim(phi1(w)))
+            vp = pull_out_var(c1[0] + 1, v)
+            u3 = phi1(u)
+            w3 = phi1(w)
             val = 0
             for arr, v3 in vp:
                 tomul = 1
                 for i in range(len(arr)):
                     tomul *= var2[1] - var3[arr[i]]
 
-                val2 = schubmult_one(tuple(permtrim(u3)), tuple(permtrim(v3)), var2, var3).get(
-                    tuple(permtrim(w3)), 0
+                val2 = schubmult_double_pair(u3, v3, var2, var3).get(
+                    w3,
+                    0,
                 )
-                val2 = posify(val2, u3, tuple(permtrim(v3)), w3, var2, var3, msg, do_pos_neg)
+                val2 = posify(val2, u3, v3, w3, var2, var3, msg, do_pos_neg, optimize=optimize)
                 val += tomul * shiftsub(val2)
-        # elif inv(w)-inv(u)==2 and len(trimcode(u)) == len(trimcode(w)):
-        # indices = []
-        # for i in range(len(w)):
-        # if i>=len(u) or u[i]!=w[i]:
-        # indices += [i+1]
-        # arr = [[[],v]]
-        # d = -1
-        # for i in range(len(v)-1):
-        # if v[i]>v[i+1]:
-        # d = i + 1
-        # for i in range(d):
-        # arr2 = []
-        #
-        # if i+1 in indices:
-        # continue
-        # i2 = 1
-        # i2 += len([aa for aa in indices if i+1>aa])
-        # for vr, v2 in arr:
-        # dpret = pull_out_var(i2,[*v2])
-        # for v3r, v3 in dpret:
-        # arr2 += [[vr + [(v3r,i+1)],v3]]
-        # arr = arr2
-        # val = 0
-        #
-        # for L in arr:
-        # v3 = [*L[-1]]
-        # tomul = 1
-        # toadd = 1
-        # for i in range(len(L[0])):
-        # var_index = L[0][i][1]
-        # oaf = L[0][i][0]
-        # if var_index-1>=len(w):
-        # yv = var_index
-        # else:
-        # yv = w[var_index-1]
-        # for j in range(len(oaf)):
-        # toadd*= var2[yv] - var3[oaf[j]]
-        # pooly = skew_div_diff(u,w,schubpoly(v3,[0,*[var2[a] for a in indices]],var3))
-        # if toadd == 0:
-        # continue
-        # if pooly !=0:
-        # coeff = compute_positive_rep(pooly,var2,var3,msg,False)
-        # else:
-        # coeff = 0
-        # if coeff == -1:
-        # return -1
-        # tomul = sympify(coeff)
-        # toadd*=tomul#.subs(subs_dict3)
-        # val += toadd
-        else:
-            if not sign_only:
-                if inv(u) + inv(v) - inv(w) == 1:
-                    val2 = compute_positive_rep(val, var2, var3, msg, False)
-                else:
-                    val2 = compute_positive_rep(val, var2, var3, msg, do_pos_neg)
-                if val2 is not None:
-                    val = val2
+            # if expand(val - oldval) != 0:
+            #     # logger.debug("This is bad")
+            #     # logger.debug(f"{u2=} {v2=} {w2=} {val=} {oldval=")
+            # logger.debug(f"Returning {u2=} {v2=} {w2=} {val=}")
+            return val
+    # logger.debug("Fell all the way through. Cleverness did not save us")
+    if not sign_only:
+        # logger.debug("Recording line number")
+        if optimize:
+            if inv(u) + inv(v) - inv(w) == 1:
+                val2 = compute_positive_rep(val, var2, var3, msg, False)
             else:
-                # st = str(expand(val))
-                # if st.find("-")!=-1:
-                # return -1
-                # else:
-                # return val
-                d = expand(val).as_coefficients_dict()
-                for v in d.values():
-                    if v < 0:
-                        return -1
-                return 1
-    return val
-
-
-def split_perms(perms):
-    perms2 = [perms[0]]
-    for perm in perms[1:]:
-        cd = code(perm)
-        index = -1
-        not_zero = False
-        did = False
-        for i in range(len(cd)):
-            if cd[i] != 0:
-                not_zero = True
-            elif not_zero and cd[i] == 0:
-                not_zero = False
-                index = i
-                num_zeros_to_miss = 0
-                for j in range(index):
-                    if cd[j] != 0:
-                        num_zeros_to_miss = max(num_zeros_to_miss, cd[j] - (index - 1 - j))
-                num_zeros = 0
-                for j in range(index, len(cd)):
-                    if cd[j] != 0:
-                        break
-                    else:
-                        num_zeros += 1
-                if num_zeros >= num_zeros_to_miss:
-                    cd1 = cd[:index]
-                    cd2 = [0 for i in range(index)] + cd[index:]
-                    perms2 += [
-                        tuple(permtrim(uncode(cd1))),
-                        tuple(permtrim(uncode(cd2))),
-                    ]
-                    did = True
-                    break
-        if not did:
-            perms2 += [perm]
-    return perms2
-
-
-def schubpoly(v, var2=None, var3=None, start_var=1):
-    n = 0
-    for j in range(len(v) - 2, -1, -1):
-        if v[j] > v[j + 1]:
-            n = j + 1
-            break
-    if n == 0:
-        return 1
-    lst = pull_out_var(n, v)
-    ret = 0
-    for pw, vp in lst:
-        tomul = 1
-        for p in pw:
-            tomul *= var2[start_var + n - 1] - var3[p]
-        ret += tomul * schubpoly(vp, var2, var3, start_var)
-    return ret
-
-
-def permy(val, i, var2=_vars.var2):
-    subsdict = {var2[i]: var2[i + 1], var2[i + 1]: var2[i]}
-    return sympify(val).subs(subsdict)
-
-
-def schub_coprod(mperm, indices, var2=_vars.var2, var3=_vars.var3):
+                val2 = compute_positive_rep(val, var2, var3, msg, do_pos_neg)
+            if val2 is not None:
+                val = val2
+            return val
+        # logger.debug("RETURNINGOLDVAL")
+        return oldval
+    # logger.debug("Recording line number")
+    d = expand(val).as_coefficients_dict()
+    for v in d.values():
+        if v < 0:
+            return -1
+    return 1
+
+    #     if expand(val - oldval) !=0:
+    #         # logger.debug("NONONOONOO")
+    #         raise Exception
+    # return val
+
+
+def schub_coprod_double(mperm, indices, var2=_vars.var2, var3=_vars.var3):
     indices = sorted(indices)
     subs_dict_coprod = {}
     k = len(indices)
@@ -1633,9 +1453,9 @@ def schub_coprod(mperm, indices, var2=_vars.var2, var3=_vars.var3):
     max_required = max([kcd[i] + i for i in range(len(kcd))])
     kcd2 = kcd + [0 for i in range(len(kcd), max_required)] + [0]
     N = len(kcd)
-    kperm = permtrim(inverse(uncode(kcd2)))
+    kperm = ~uncode(kcd2)
     inv_kperm = inv(kperm)
-    vn = symarray("soible", 100)
+    vn = GeneratingSet("soible")
 
     for i in range(1, N * 2 + 1):
         if i <= N:
@@ -1643,14 +1463,14 @@ def schub_coprod(mperm, indices, var2=_vars.var2, var3=_vars.var3):
         else:
             subs_dict_coprod[vn[i]] = var3[i - N]
 
-    coeff_dict = {tuple(kperm): 1}
-    coeff_dict = schubmult(coeff_dict, mperm, vn, var2)
+    coeff_dict = {kperm: 1}
+    coeff_dict = schubmult_double(coeff_dict, mperm, vn, var2)
 
-    inverse_kperm = inverse(kperm)
+    inverse_kperm = ~kperm
 
     ret_dict = {}
     for perm in coeff_dict:
-        downperm = mulperm(list(perm), inverse_kperm)
+        downperm = perm * inverse_kperm
         if inv(downperm) == inv(perm) - inv_kperm:
             flag = True
             for i in range(N):
@@ -1659,12 +1479,12 @@ def schub_coprod(mperm, indices, var2=_vars.var2, var3=_vars.var3):
                     break
             if not flag:
                 continue
-            firstperm = downperm[0:N]
-            secondperm = [downperm[i] - N for i in range(N, len(downperm))]
+            firstperm = Permutation(downperm[0:N])
+            secondperm = Permutation([downperm[i] - N for i in range(N, len(downperm))])
 
-            val = sympify(coeff_dict[perm]).subs(subs_dict_coprod)
+            val = efficient_subs(sympify(coeff_dict[perm]), subs_dict_coprod)
 
-            key = (tuple(permtrim(firstperm)), tuple(permtrim(secondperm)))
+            key = (firstperm, secondperm)
             ret_dict[key] = val
 
     return ret_dict