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

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

@@ -8,45 +8,42 @@ import sympy
 from cachetools import cached
 from cachetools.keys import hashkey
 from sortedcontainers import SortedList
-from symengine import Add, Integer, Mul, Pow, expand, symarray, sympify
+from symengine import Add, Integer, Mul, Pow, sympify
 
 from schubmult.perm_lib import (
-    add_perm_dict,
+    Permutation,
     code,
-    compute_vpathdicts,
     cycle,
-    divdiffable,
     dominates,
-    elem_sym_func,
-    elem_sym_perms,
-    elem_sym_perms_op,
-    elem_sym_poly,
     inv,
-    inverse,
-    is_reducible,
-    mulperm,
     one_dominates,
-    permtrim,
     phi1,
+    theta,
+    uncode,
+)
+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,
     reduce_coeff,
     reduce_descents,
-    theta,
     try_reduce_u,
     try_reduce_v,
-    uncode,
     will_formula_work,
-    zero,
 )
+from schubmult.utils.logging import get_logger
+from schubmult.utils.perm_utils import add_perm_dict
+
+zero = sympify(0)
 
-# NO GLOBAL VARS
-# from ._vars import (
-#     n,
-#     var2,
-#     var3,
-#     _vars.var1,
-#     var_y,
-# )
+logger = get_logger(__name__)
 
 
 class _gvars:
@@ -60,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()
@@ -87,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):
@@ -131,25 +137,34 @@ 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)
     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
     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
     if isinstance(poly, Add):
         ret = {}
         for a in poly.args:
-            ret = add_perm_dict(ret, mult_poly(coeff_dict, a, var_x, var_y))
+            ret = add_perm_dict(ret, mult_poly_double(coeff_dict, a, var_x, var_y))
         return ret
     ret = {}
     for perm in coeff_dict:
@@ -157,6 +172,9 @@ def mult_poly(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2):
     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))
@@ -186,15 +204,15 @@ def mult_poly_down(coeff_dict, poly):
 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
 
@@ -202,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:
@@ -253,19 +286,24 @@ 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]]
         res = res2
@@ -275,9 +313,10 @@ def dualpieri(mu, v, w):
     for vlist, vplist in res:
         vp = vplist
         vpl = divdiffable(vp, c)
-        if vpl == []:
+        if len(vpl) == 0:
             continue
         res2 += [[vlist, vpl]]
+    # logger.debug(f"{res2=}")
     return res2
 
 
@@ -286,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 = {}
@@ -308,7 +358,7 @@ 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]:
@@ -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,7 +415,7 @@ 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]:
@@ -398,13 +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):
-    poly = expand(poly.xreplace({var3[1]: 0}))
+    poly = expand(sympify(poly).xreplace({var3[1]: 0}))
 
     dc = poly.as_coefficients_dict()
 
@@ -429,12 +479,12 @@ def poly_to_vec(poly, vec0=None, var3=_vars.var3):
 
 def shiftsub(pol, var2=_vars.var2):
     subs_dict = {var2[i]: var2[i + 1] for i in range(99)}
-    return sympify(pol).subs(subs_dict)
+    return efficient_subs(sympify(pol), subs_dict)
 
 
 def shiftsubz(pol, var3=_vars.var3):
     subs_dict = {var3[i]: var3[i + 1] for i in range(99)}
-    return sympify(pol).subs(subs_dict)
+    return efficient_subs(sympify(pol), subs_dict)
 
 
 def init_basevec(dc):
@@ -624,12 +674,12 @@ 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
 
 
@@ -641,32 +691,15 @@ def find_base_vectors(monom_list, var2, var3, depth):
     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:
@@ -691,8 +724,7 @@ def find_base_vectors(monom_list, 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])
@@ -707,19 +739,9 @@ def find_base_vectors(monom_list, 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)
@@ -736,41 +758,34 @@ def find_base_vectors(monom_list, 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 = []
@@ -858,12 +873,14 @@ 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:
@@ -874,6 +891,7 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
                     lookup[key] += [mm0]
                 if mm0n1 == L1:
                     mn1L += [mm0]
+            # logger.debug("this")
             for mn1 in mn1L:
                 comblistmn1 = [1]
                 for i in range(n1, len(mn1)):
@@ -908,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:
@@ -933,96 +953,28 @@ 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):  # noqa: ARG001
-    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 = {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
-    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))
-    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, 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),
+    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,
@@ -1032,44 +984,43 @@ def posify(
     var2=None,
     var3=None,
     msg=False,
-    do_pos_neg=True,
+    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:
-        return val
-    cdv = code(v2)
-    if set(cdv) == {0, 1} and do_pos_neg:
+        # logger.debug(f"Hmm this is probably not or val inty true {val=}")
         return val
 
     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):
@@ -1079,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)
@@ -1094,17 +1046,27 @@ def posify(
         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(
+        # 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
@@ -1128,16 +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]]
             arr = arr2
         val = 0
         for L in arr:
-            v3 = [*L[-1]]
+            v3 = L[-1]
             if v3[0] < v3[1]:
                 continue
-            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]:
@@ -1156,359 +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
-                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
-                    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
-            if (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
-                    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)
-    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):
-            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]:
+        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
-            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)),
+                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 not sign_only:
+            # 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:
                 val2 = compute_positive_rep(val, var2, var3, msg, do_pos_neg)
             if val2 is not None:
                 val = val2
-        else:
-            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
-                    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):
+            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)
@@ -1517,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:
@@ -1527,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):
@@ -1543,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