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

schubmult/{schubmult_q/_funcs.py → schub_lib/quantum.py}

@@ -1,21 +1,22 @@
 from functools import cached_property
 
-from symengine import Add, Mul, Pow, symarray
+from symengine import Add, Mul, Pow
 
+import schubmult.poly_lib.variables as spl
+import schubmult.schub_lib.schub_lib as sss
 from schubmult.perm_lib import (
-    add_perm_dict,
+    Permutation,
     code,
-    compute_vpathdicts,
-    double_elem_sym_q,
-    elem_sym_perms_q,
     inv,
-    inverse,
     medium_theta,
-    mulperm,
     permtrim,
     strict_theta,
     uncode,
 )
+from schubmult.utils.logging import get_logger
+from schubmult.utils.perm_utils import add_perm_dict
+
+logger = get_logger(__name__)
 
 
 class _gvars:
@@ -25,21 +26,23 @@ class _gvars:
 
     @cached_property
     def var_x(self):
-        return tuple(symarray("x", self.n).tolist())
+        return spl.GeneratingSet("x")
 
     @cached_property
     def q_var(self):
-        return tuple(symarray("q", self.n).tolist())
+        return spl.GeneratingSet("q")
+
 
 _vars = _gvars()
 
+
 def single_variable(coeff_dict, varnum, var_q=_vars.q_var):
     ret = {}
     for u in coeff_dict:
-        new_perms_k = elem_sym_perms_q(u, 1, varnum, var_q)
+        new_perms_k = sss.elem_sym_perms_q(u, 1, varnum, var_q)
         new_perms_km1 = []
         if varnum > 1:
-            new_perms_km1 = elem_sym_perms_q(u, 1, varnum - 1, var_q)
+            new_perms_km1 = sss.elem_sym_perms_q(u, 1, varnum - 1, var_q)
         for perm, udiff, mul_val in new_perms_k:
             if udiff == 1:
                 ret[perm] = ret.get(perm, 0) + coeff_dict[u] * mul_val
@@ -49,41 +52,47 @@ def single_variable(coeff_dict, varnum, var_q=_vars.q_var):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=_vars.var_x, var_q=_vars.q_var):
-    if poly in var_x:
+def mult_poly_q(coeff_dict, poly, var_x=_vars.var_x, var_q=_vars.q_var):
+    if not isinstance(var_x, spl.GeneratingSet_base):
+        var_x = spl.CustomGeneratingSet(var_x)
+    # logger.debug(f"{poly=} {type(poly)=} {list(var_x)}")
+    # logger.debug(f"{[type(v) for v in var_x]}")
+    if var_x.index(poly) != -1:
+        # logger.debug(f"Found {var_x.index(poly)=}")
         return single_variable(coeff_dict, var_x.index(poly), var_q=var_q)
     if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
-            ret = mult_poly(ret, a, var_x, var_q=var_q)
+            ret = mult_poly_q(ret, a, var_x, var_q=var_q)
         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_q=var_q)
+            ret = mult_poly_q(ret, base, var_x, var_q=var_q)
         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_q=var_q))
+            ret = add_perm_dict(ret, mult_poly_q(coeff_dict, a, var_x, var_q=var_q))
         return ret
     ret = {}
     for perm in coeff_dict:
         ret[perm] = poly * coeff_dict[perm]
     return ret
 
-def schubmult_db(perm_dict, v, q_var=_vars.q_var):
-    if v == (1, 2):
+
+def schubmult_q_fast(perm_dict, v, q_var=_vars.q_var):
+    if inv(v) == 0:
         return perm_dict
-    th = medium_theta(inverse(v))
+    th = medium_theta(~v)
     if len(th) == 0:
         return perm_dict
     while th[-1] == 0:
         th.pop()
     mu = permtrim(uncode(th))
-    vmu = permtrim(mulperm([*v], mu))
+    vmu = permtrim(v * mu)
     inv_vmu = inv(vmu)
     inv_mu = inv(mu)
     ret_dict = {}
@@ -91,11 +100,11 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
     thL = len(th)
     # if thL!=2 and len(set(thL))!=1:
     # raise ValueError("Not what I can do")
-    vpathdicts = compute_vpathdicts(th, vmu, True)
+    vpathdicts = sss.compute_vpathdicts(th, vmu, True)
     # print(f"{vpathdicts=}")
     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):
             if index > 0 and th[index - 1] == th[index]:
                 continue
@@ -112,7 +121,7 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
                 for up in vpathsums:
                     newpathsums0 = {}
                     inv_up = inv(up)
-                    newperms = double_elem_sym_q(up, mx_th, mx_th1, th[index], q_var)
+                    newperms = sss.double_elem_sym_q(up, mx_th, mx_th1, th[index], q_var)
                     for v in vpathdicts[index]:
                         sumval = vpathsums[up].get(v, 0)
                         if sumval == 0:
@@ -124,7 +133,8 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
                                 if udiff1 + vdiff2 == th[index]:
                                     newpathsums0[(up1, udiff1, mul_val1)][v2] = (
                                         newpathsums0[(up1, udiff1, mul_val1)].get(
-                                            v2, 0,
+                                            v2,
+                                            0,
                                         )
                                         + s2 * sumval * mul_val1
                                     )
@@ -135,21 +145,16 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
                             if sumval == 0:
                                 continue
                             for v2, vdiff2, s2 in vpathdicts[index + 1][v]:
-                                for up2, udiff2, mul_val2 in newperms[
-                                    (up1, udiff1, mul_val1)
-                                ]:
+                                for up2, udiff2, mul_val2 in newperms[(up1, udiff1, mul_val1)]:
                                     if up2 not in newpathsums:
                                         newpathsums[up2] = {}
                                     if udiff2 + vdiff2 == th[index + 1]:
-                                        newpathsums[up2][v2] = (
-                                            newpathsums[up2].get(v2, 0)
-                                            + s2 * sumval * mul_val2
-                                        )
+                                        newpathsums[up2][v2] = newpathsums[up2].get(v2, 0) + s2 * sumval * mul_val2
             else:
                 newpathsums = {}
                 for up in vpathsums:
                     inv_up = inv(up)
-                    newperms = elem_sym_perms_q(
+                    newperms = sss.elem_sym_perms_q(
                         up,
                         min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu),
                         th[index],
@@ -164,22 +169,20 @@ def schubmult_db(perm_dict, v, q_var=_vars.q_var):
                                 continue
                             for v2, vdiff, s in vpathdicts[index][v]:
                                 if udiff + vdiff == th[index]:
-                                    newpathsums[up2][v2] = (
-                                        newpathsums[up2].get(v2, 0)
-                                        + s * sumval * mul_val
-                                    )
+                                    newpathsums[up2][v2] = newpathsums[up2].get(v2, 0) + s * sumval * mul_val
             vpathsums = newpathsums
-        toget = tuple(vmu)
+        toget = vmu
         ret_dict = add_perm_dict(
-            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict,
+            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums},
+            ret_dict,
         )
     return ret_dict
 
 
-def schubmult(perm_dict, v):
-    th = strict_theta(inverse(v))
+def schubmult_q(perm_dict, v):
+    th = strict_theta(~v)
     mu = permtrim(uncode(th))
-    vmu = permtrim(mulperm([*v], mu))
+    vmu = v * mu
     inv_vmu = inv(vmu)
     inv_mu = inv(mu)
     ret_dict = {}
@@ -188,10 +191,10 @@ def schubmult(perm_dict, v):
     while th[-1] == 0:
         th.pop()
     thL = len(th)
-    vpathdicts = compute_vpathdicts(th, vmu, True)
+    vpathdicts = sss.compute_vpathdicts(th, vmu, True)
     for u, val in perm_dict.items():
         inv_u = inv(u)
-        vpathsums = {u: {(1, 2): val}}
+        vpathsums = {u: {Permutation([]): val}}
         for index in range(thL):
             mx_th = 0
             for vp in vpathdicts[index]:
@@ -200,8 +203,10 @@ def schubmult(perm_dict, v):
             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],
+                newperms = sss.elem_sym_perms_q(
+                    up,
+                    min(mx_th, (inv_mu - (inv_up - inv_u)) - inv_vmu),
+                    th[index],
                 )
                 for up2, udiff, mul_val in newperms:
                     if up2 not in newpathsums:
@@ -212,20 +217,16 @@ def schubmult(perm_dict, v):
                             continue
                         for v2, vdiff, s in vpathdicts[index][v]:
                             if udiff + vdiff == th[index]:
-                                newpathsums[up2][v2] = (
-                                    newpathsums[up2].get(v2, 0)
-                                    + s * sumval * mul_val
-                                )
+                                newpathsums[up2][v2] = newpathsums[up2].get(v2, 0) + s * sumval * mul_val
             vpathsums = newpathsums
-        toget = tuple(vmu)
+        toget = vmu
         ret_dict = add_perm_dict(
-            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict,
+            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums},
+            ret_dict,
         )
     return ret_dict
 
 
-
-
 def grass_q_replace(perm, k, d, n):
     if k - d < 0:
         return None