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

schubmult/{schubmult_py/_funcs.py → schub_lib/single.py}

@@ -1,26 +1,28 @@
+from functools import cached_property
+
+from symengine import Add, Mul, Pow
+
 from schubmult.perm_lib import (
-    elem_sym_perms,
-    add_perm_dict,
-    compute_vpathdicts,
-    inverse,
-    theta,
-    permtrim,
+    Permutation,
     inv,
-    mulperm,
+    permtrim,
+    theta,
     uncode,
 )
-from symengine import Add, Mul, Pow, symarray
-from functools import cached_property
+from schubmult.poly_lib.variables import CustomGeneratingSet, GeneratingSet, GeneratingSet_base
+from schubmult.schub_lib.schub_lib import (
+    compute_vpathdicts,
+    elem_sym_perms,
+)
+from schubmult.utils.perm_utils import (
+    add_perm_dict,
+)
 
 
 class _gvars:
-    @cached_property
-    def n(self):
-        return 100
-
     @cached_property
     def var_x(self):
-        return tuple(symarray("x", self.n).tolist())
+        return GeneratingSet("x")
 
 
 _vars = _gvars()
@@ -42,57 +44,62 @@ def single_variable(coeff_dict, varnum):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=_vars.var_x):
-    if poly in var_x:
+# TODO: if need indexes, CustomGeneratingSet
+def mult_poly_py(coeff_dict, poly, var_x=_vars.var_x):
+    if not isinstance(var_x, GeneratingSet_base):
+        var_x = CustomGeneratingSet(var_x)
+
+    if var_x.index(poly) != -1:
+        # print(f"{poly=} {var_x._symbols_arr=} {var_x._symbols_arr.index(poly)=}")
         return single_variable(coeff_dict, var_x.index(poly))
-    elif isinstance(poly, Mul):
+
+    if isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
-            ret = mult_poly(ret, a, var_x)
+            ret = mult_poly_py(ret, a, var_x)
         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)
+            ret = mult_poly_py(ret, base, var_x)
         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))
-        return ret
-    else:
-        ret = {}
-        for perm in coeff_dict:
-            ret[perm] = poly * coeff_dict[perm]
+            ret = add_perm_dict(ret, mult_poly_py(coeff_dict, a, var_x))
         return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
 
 
-def schubmult(perm_dict, v):
-    vn1 = inverse(v)
+def schubmult_py(perm_dict, v):
+    v = Permutation(v)
+    # print(f"{v=}")
+    vn1 = ~v
     th = theta(vn1)
-    if th[0] == 0:
+    if len(th) == 0 or th[0] == 0:
         return perm_dict
-    mu = permtrim(uncode(th))
-    vmu = permtrim(mulperm(list(v), mu))
+    mu = uncode(th)
+    vmu = v * mu
     inv_vmu = inv(vmu)
     inv_mu = inv(mu)
     ret_dict = {}
     while th[-1] == 0:
         th.pop()
     vpathdicts = compute_vpathdicts(th, vmu)
-
     mx_th = [0 for i in range(len(th))]
     for index in range(len(th)):
         for vp in vpathdicts[index]:
             for v2, vdiff, s in vpathdicts[index][vp]:
-                if th[index] - vdiff > mx_th[index]:
-                    mx_th[index] = th[index] - vdiff
+                mx_th[index] = max(mx_th[index], th[index] - vdiff)
 
     for u, val in perm_dict.items():
         inv_u = inv(u)
-        vpathsums = {u: {(1, 2): val}}
+        vpathsums = {Permutation(u): {Permutation([1, 2]): val}}
 
         for index in range(len(th)):
             newpathsums = {}
@@ -103,7 +110,10 @@ def schubmult(perm_dict, v):
                     min(mx_th[index], inv_mu - inv_vmu - (inv_up - inv_u)),
                     th[index],
                 )
+                # print(f"{up=}")
                 for vp in vpathsums[up]:
+                    # print(f"{vp=} {type(vp)=} {hash(vp)=}")
+                    # print(f"{vpathsums[up]=} {vpathdicts[index]=}")
                     sumval = vpathsums[up][vp]
                     if sumval == 0:
                         continue
@@ -115,13 +125,13 @@ def schubmult(perm_dict, v):
                                     newpathsums[up2] = {}
                                 newpathsums[up2][v2] = newpathsums[up2].get(v2, 0) + addsumval
             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 schub_coprod(perm, indices):
-    mperm = tuple(perm)
+def schub_coprod_py(perm, indices):
+    mperm = perm
     indices = sorted(indices)
     ret_dict = {}
     k = len(indices)
@@ -130,19 +140,19 @@ def schub_coprod(perm, indices):
     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)))
-    coeff_dict = {tuple(kperm): 1}
-    coeff_dict = schubmult(coeff_dict, tuple(mperm))
+    kperm = ~(uncode(kcd2))
+    coeff_dict = {kperm: 1}
+    coeff_dict = schubmult_py(coeff_dict, mperm)
 
     inv_kperm = inv(kperm)
-    inverse_kperm = inverse(kperm)
+    inverse_kperm = ~kperm
     # total_sum = 0
     for perm, val in coeff_dict.items():
         if val == 0:
             continue
-        pperm = [*perm]
-        downperm = mulperm(pperm, inverse_kperm)
-        if inv(downperm) == inv(pperm) - inv_kperm:
+        # pperm = [*perm]
+        downperm = perm * inverse_kperm
+        if inv(downperm) == inv(perm) - inv_kperm:
             flag = True
             for i in range(N):
                 if downperm[i] > N:
@@ -150,7 +160,7 @@ def schub_coprod(perm, indices):
                     break
             if not flag:
                 continue
-            firstperm = tuple(permtrim((list(downperm[0:N]))))
-            secondperm = tuple(permtrim(([downperm[i] - N for i in range(N, len(downperm))])))
+            firstperm = permtrim(list(downperm[0:N]))
+            secondperm = permtrim([downperm[i] - N for i in range(N, len(downperm))])
             ret_dict[(firstperm, secondperm)] = val
     return ret_dict