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

schubmult/schubmult_q_double/_funcs.py

@@ -1,37 +1,72 @@
-from ._vars import (
-    var_y,
-    var_x,
-    var2,
-    var3,
-    q_var2,
-)
-from symengine import Add, Mul, Pow, expand
+# from ._vars import (
+#     var_y,
+#     var_x,
+#     var2,
+#     var3,
+#     q_var2,
+# )
+from functools import cached_property
+
+from symengine import Add, Mul, Pow, expand, symarray
+
+import schubmult.schubmult_double as norm_yz
 from schubmult.perm_lib import (
-    elem_sym_perms_q,
     add_perm_dict,
+    call_zvars,
     compute_vpathdicts,
+    double_elem_sym_q,
+    elem_sym_func_q,
+    elem_sym_perms_q,
+    elem_sym_perms_q_op,
+    elem_sym_poly_q,
+    inv,
     inverse,
-    strict_theta,
     medium_theta,
-    permtrim,
-    inv,
     mulperm,
+    permtrim,
+    strict_theta,
     uncode,
-    double_elem_sym_q,
-    elem_sym_poly_q,
-    elem_sym_perms_q_op,
-    elem_sym_func_q,
-    call_zvars,
-    q_var,
 )
-import schubmult.schubmult_double as norm_yz
 
 
-def E(p, k, varl=var_y[1:]):
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+
+    # @cached_property
+    # def fvar(self):
+    #     return 100
+
+    @cached_property
+    def var1(self):
+        return tuple(symarray("x", self.n).tolist())
+
+    @cached_property
+    def var2(self):
+        return tuple(symarray("y", self.n).tolist())
+
+    @cached_property
+    def var3(self):
+        return tuple(symarray("z", self.n).tolist())
+
+    @cached_property
+    def q_var(self):
+        return tuple(symarray("q", self.n).tolist())
+
+    @cached_property
+    def var_r(self):
+        return symarray("r", 100)
+
+
+_vars = _gvars()
+
+
+def E(p, k, varl=_vars.var2[1:], var_x=_vars.var1):
     return elem_sym_poly_q(p, k, var_x[1:], varl)
 
 
-def single_variable(coeff_dict, varnum, var2=var2, q_var=q_var):
+def single_variable(coeff_dict, varnum, var2=_vars.var2, q_var=_vars.q_var):
     ret = {}
     for u in coeff_dict:
         if varnum - 1 < len(u):
@@ -51,34 +86,33 @@ def single_variable(coeff_dict, varnum, var2=var2, q_var=q_var):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=var_x, var_y=var_y, q_var=q_var):
+def mult_poly(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2, q_var=_vars.q_var):
     if poly in var_x:
         return single_variable(coeff_dict, var_x.index(poly), var_y, q_var)
-    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, q_var)
         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, q_var)
         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, q_var))
         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 nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
+def nil_hecke(perm_dict, v, n, var2=_vars.var2, var3=_vars.var3):
     if v == (1, 2):
         return perm_dict
     th = strict_theta(inverse(v))
@@ -96,8 +130,7 @@ def nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
             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_q_op(up, mx_th, th[index], n)
@@ -110,7 +143,8 @@ def nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
                             continue
                         for v2, vdiff, s in vpathdicts[index][v]:
                             newpathsums[up2][v2] = newpathsums[up2].get(
-                                v2, 0
+                                v2,
+                                0,
                             ) + s * sumval * elem_sym_func_q(
                                 th[index],
                                 index + 1,
@@ -129,7 +163,7 @@ def nil_hecke(perm_dict, v, n, var2=var2, var3=var3):
     return ret_dict
 
 
-def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=q_var):
+def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=_vars.q_var):
     newk = k - udiff
     if newk < vdiff:
         return 0
@@ -151,7 +185,7 @@ def elem_sym_func_q_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2, q_var=q_
     return elem_sym_poly_q(newk - vdiff, newk, yvars, zvars, q_var)
 
 
-def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
+def schubpoly_quantum(v, var_x=_vars.var1, var_y=_vars.var2, q_var=_vars.q_var, coeff=1):
     th = strict_theta(inverse(v))
     mu = permtrim(uncode(th))
     vmu = permtrim(mulperm([*v], mu))
@@ -169,13 +203,15 @@ def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
         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_q(
-                up, min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu), th[index], q_var
+                up,
+                min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu),
+                th[index],
+                q_var,
             )
             for up2, udiff, mul_val in newperms:
                 if up2 not in newpathsums:
@@ -186,7 +222,8 @@ def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
                         continue
                     for v2, vdiff, s in vpathdicts[index][v]:
                         newpathsums[up2][v2] = newpathsums[up2].get(
-                            v2, 0
+                            v2,
+                            0,
                         ) + s * sumval * elem_sym_func_q_q(
                             th[index],
                             index + 1,
@@ -206,7 +243,7 @@ def schubpoly_quantum(v, var_x=var_x, var_y=var2, q_var=q_var, coeff=1):
     return ret_dict[(1, 2)]
 
 
-def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
+def schubmult(perm_dict, v, var2=_vars.var2, var3=_vars.var3, q_var=_vars.q_var):
     if v == (1, 2):
         return perm_dict
     th = strict_theta(inverse(v))
@@ -228,8 +265,7 @@ def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
             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)
@@ -248,7 +284,8 @@ def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
                             continue
                         for v2, vdiff, s in vpathdicts[index][v]:
                             newpathsums[up2][v2] = newpathsums[up2].get(
-                                v2, 0
+                                v2,
+                                0,
                             ) + s * sumval * elem_sym_func_q(
                                 th[index],
                                 index + 1,
@@ -267,7 +304,7 @@ def schubmult(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
     return ret_dict
 
 
-def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
+def schubmult_db(perm_dict, v, var2=_vars.var2, var3=_vars.var3, q_var=_vars.q_var):
     if v == (1, 2):
         return perm_dict
     th = medium_theta(inverse(v))
@@ -292,14 +329,12 @@ def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
             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)
             if index < len(th) - 1 and th[index] == th[index + 1]:
                 mx_th1 = 0
                 for vp in vpathdicts[index + 1]:
                     for v2, vdiff, s in vpathdicts[index + 1][vp]:
-                        if th[index + 1] - vdiff > mx_th1:
-                            mx_th1 = th[index + 1] - vdiff
+                        mx_th1 = max(mx_th1, th[index + 1] - vdiff)
                 newpathsums = {}
                 for up in vpathsums:
                     newpathsums0 = {}
@@ -331,9 +366,7 @@ def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
                                 if (up1, udiff1, mul_val1) not in newpathsums0:
                                     newpathsums0[(up1, udiff1, mul_val1)] = {}
                                 # newpathsums0[(up1, udiff1, mul_val1
-                                newpathsums0[(up1, udiff1, mul_val1)][v2] = (
-                                    newpathsums0[(up1, udiff1, mul_val1)].get(v2, 0) + mulfac
-                                )
+                                newpathsums0[(up1, udiff1, mul_val1)][v2] = newpathsums0[(up1, udiff1, mul_val1)].get(v2, 0) + mulfac
 
                     for up1, udiff1, mul_val1 in newpathsums0:
                         for v in vpathdicts[index + 1]:
@@ -381,7 +414,8 @@ def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
                                 continue
                             for v2, vdiff, s in vpathdicts[index][v]:
                                 newpathsums[up2][v2] = newpathsums[up2].get(
-                                    v2, 0
+                                    v2,
+                                    0,
                                 ) + s * sumval * elem_sym_func_q(
                                     th[index],
                                     index + 1,
@@ -400,7 +434,7 @@ def schubmult_db(perm_dict, v, var2=var2, var3=var3, q_var=q_var):
     return ret_dict
 
 
-def div_diff(v, w, var2=var2, var3=var3):
+def div_diff(v, w, var2=_vars.var2, var3=_vars.var3):
     coeff_dict = {v: 1}
     coeff_dict = norm_yz.schubmult_down(coeff_dict, w, var2, var3)
     return coeff_dict.get((1, 2), 0)
@@ -427,28 +461,28 @@ def factor_out_q_keep_factored(poly):
     if str(poly).find("q") == -1:
         ret[1] = poly
         return ret
-    elif poly in q_var2:
+    if poly in _vars.q_var:
         ret[poly] = 1
         return ret
-    elif isinstance(poly, Add):
+    if isinstance(poly, Add):
         ag = poly.args
         ret = factor_out_q_keep_factored(ag[0])
         for i in range(1, len(ag)):
             ret = sum_q_dict(ret, factor_out_q_keep_factored(ag[i]))
         return ret
-    elif isinstance(poly, Mul):
+    if isinstance(poly, Mul):
         ag = poly.args
         ret = factor_out_q_keep_factored(ag[0])
         for i in range(1, len(ag)):
             ret = mul_q_dict(ret, factor_out_q_keep_factored(ag[i]))
         return ret
-    elif isinstance(poly, Pow):
+    if isinstance(poly, Pow):
         base = poly.args[0]
         exponent = int(poly.args[1])
 
         ret = factor_out_q_keep_factored(base)
         ret0 = dict(ret)
-        for i in range(exponent - 1):
+        for _ in range(exponent - 1):
             ret = mul_q_dict(ret, ret0)
 
         # print(f"exponent {exponent}")
@@ -481,27 +515,26 @@ def factor_out_q(poly):
             for var_maybe_pow in key.args:
                 if isinstance(var_maybe_pow, Pow):
                     real_var = var_maybe_pow.args[0]
-                    if real_var in q_var2:
+                    if real_var in _vars.q_var:
                         q_part *= var_maybe_pow
                     else:
                         yz_part *= var_maybe_pow
                 else:
                     real_var = var_maybe_pow
-                    if real_var in q_var2:
+                    if real_var in _vars.q_var:
                         q_part *= var_maybe_pow
                     else:
                         yz_part *= var_maybe_pow
         elif isinstance(key, Pow):
             real_var = key.args[0]
-            if real_var in q_var2:
+            if real_var in _vars.q_var:
                 q_part *= key
             else:
                 yz_part *= key
+        elif key in _vars.q_var:
+            q_part *= key
         else:
-            if key in q_var2:
-                q_part *= key
-            else:
-                yz_part *= key
+            yz_part *= key
 
         ret[q_part] = ret.get(q_part, 0) + yz_part
     return ret