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

schubmult/schubmult_double/_script.py

@@ -1,38 +1,65 @@
+import sys
+from functools import cached_property
+
 import numpy as np
 import sympy
-import sys
-from ._vars import (
-    var2,
-    var3,
-    var_x,
-    var,
-    var_r
-)
-from ._funcs import (
-    mult_poly,
-    mult_poly_down,
-    schubmult,
-    schubmult_down,
-    compute_positive_rep,
-    posify,
-    split_perms,
-)
-from symengine import expand, sympify
+from symengine import expand, symarray, sympify
+
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
     add_perm_dict,
-    inverse,
-    theta,
-    permtrim,
+    code,
     inv,
+    inverse,
+    mu_A,
     mulperm,
-    code,
+    permtrim,
+    theta,
+    trimcode,
     uncode,
     will_formula_work,
-    mu_A,
-    trimcode,
 )
 
+# from schubmult.schubmult_double._vars import var_x, var, var_r
+from schubmult.schubmult_double._funcs import (
+    compute_positive_rep,
+    mult_poly,
+    mult_poly_down,
+    posify,
+    schubmult,
+    schubmult_down,
+    split_perms,
+)
+
+
+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 var_r(self):
+        return symarray("r", 100)
+
+
+_vars = _gvars()
+
 
 def _display(val):
     print(val)
@@ -42,13 +69,20 @@ def _display_full(
     coeff_dict,
     args,
     formatter,
+    var2,
+    var3,
     posified=None,
     check_coeff_dict=None,
     kperm=None,
-    var2=var2,
-    var3=var3,
     N=None,
 ):
+    subs_dict2 = {}
+    for i in range(1, 100):
+        sm = var2[1]
+        for j in range(1, i):
+            sm += _vars.var_r[j]
+        subs_dict2[var2[i]] = sm
+    raw_result_dict = {}
     perms = args.perms
     mult = args.mult
     ascode = args.ascode
@@ -88,9 +122,9 @@ def _display_full(
 
         for i in range(1, 100):
             if i <= N:
-                subs_dict[var[i]] = var2[i]
+                subs_dict[_vars.var1[i]] = var2[i]
             else:
-                subs_dict[var[i]] = var3[i - N]
+                subs_dict[_vars.var1[i]] = var3[i - N]
 
         coeff_perms.sort(key=lambda x: (inv(x), *x))
 
@@ -112,11 +146,12 @@ def _display_full(
 
         if ascode:
             width = max(
-                [len(str(trimcode(perm[0])) + " " + str(trimcode(perm[1]))) for perm in perm_pairs]
+                [len(str(trimcode(perm[0])) + " " + str(trimcode(perm[1]))) for perm in perm_pairs],
             )
         else:
             width = max([len(str(perm[0]) + " " + str(perm[1])) for perm in perm_pairs])
 
+
         for perm in coeff_perms:
             val = coeff_dict[perm]
             downperm = mulperm(list(perm), inverse_kperm)
@@ -133,13 +168,7 @@ def _display_full(
                 val = sympify(val).subs(subs_dict)
 
                 if same and display_positive:
-                    subs_dict2 = {}
-                    for i in range(1, 100):
-                        sm = var2[1]
-                        for j in range(1, i):
-                            sm += var_r[j]
-                        subs_dict2[var2[i]] = sm
-                    val = expand(sympify(val).xreplace(subs_dict2))
+                    val = expand(sympify(val).subs(subs_dict2))
 
                 if val != 0:
                     if display_positive and not same:
@@ -156,15 +185,15 @@ def _display_full(
                             )
                             if expand(val - val2) != 0:
                                 _display(
-                                    f"error; write to schubmult@gmail.com with the case {perms=}\n{code(firstperm)=} {code(secondperm)=}\n{val2=}\n{val=}"
+                                    f"error; write to schubmult@gmail.com with the case {perms=}\n{code(firstperm)=} {code(secondperm)=}\n{val2=}\n{val=}",
                                 )
                                 _display(
-                                    f"{code(tuple(permtrim(mulperm(firstperm,muA))))=},{code(tuple(permtrim(mulperm(secondperm,muB))))=},{code(the_top_perm)=}\n{expand(val-val2)=}"
+                                    f"{code(tuple(permtrim(mulperm(firstperm,muA))))=},{code(tuple(permtrim(mulperm(secondperm,muB))))=},{code(the_top_perm)=}\n{expand(val-val2)=}",
                                 )
                                 exit(1)
                             val = val2
                         else:
-                            val = 0                    
+                            val = 0
                     if val != 0:
                         if not ascode:
                             width2 = (
@@ -172,18 +201,26 @@ def _display_full(
                                 - len(str(permtrim(firstperm)))
                                 - len(str(permtrim(secondperm)))
                             )
-                            _display(
-                                f"{tuple(permtrim(firstperm))}{' ':>{width2}}{tuple(permtrim(secondperm))}  {formatter(val)}"
-                            )
+                            raw_result_dict[
+                                (tuple(permtrim(firstperm)), tuple(permtrim(secondperm)))
+                            ] = val
+                            if formatter:
+                                _display(
+                                    f"{tuple(permtrim(firstperm))}{' ':>{width2}}{tuple(permtrim(secondperm))}  {formatter(val)}",
+                                )
                         else:
                             width2 = (
                                 width
                                 - len(str(trimcode(firstperm)))
                                 - len(str(trimcode(secondperm)))
                             )
-                            _display(
-                                f"{trimcode(firstperm)}{' ':>{width2}}{trimcode(secondperm)}  {formatter(val)}"
-                            )
+                            raw_result_dict[
+                                (tuple(trimcode(firstperm)), tuple(trimcode(secondperm)))
+                            ] = val
+                            if formatter:
+                                _display(
+                                    f"{trimcode(firstperm)}{' ':>{width2}}{trimcode(secondperm)}  {formatter(val)}",
+                                )
     else:
         if ascode:
             width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys()])
@@ -192,7 +229,7 @@ def _display_full(
 
         coeff_perms = list(coeff_dict.keys())
         coeff_perms.sort(key=lambda x: (inv(x), *x))
-        
+
         for perm in coeff_perms:
             val = coeff_dict[perm]
             if val != 0:
@@ -207,7 +244,7 @@ def _display_full(
                         for i in range(1, 100):
                             sm = var2[1]
                             for j in range(1, i):
-                                sm += var_r[j]
+                                sm += _vars.var_r[j]
                             subs_dict[var2[i]] = sm
                         val = expand(sympify(coeff_dict[perm]).xreplace(subs_dict))
                     else:
@@ -245,24 +282,33 @@ def _display_full(
                                 )
                             else:
                                 _display(
-                                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}"
+                                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}",
                                 )
                                 exit(1)
                         if check and expand(val - check_coeff_dict.get(perm, 0)) != 0:
                             _display(
-                                f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}"
+                                f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_coeff_dict.get(perm,0)=}",
                             )
                             exit(1)
                 if val != 0:
                     if ascode:
-                        _display(f"{str(trimcode(perm)):>{width}}  {formatter(val)}")
+                        raw_result_dict[tuple(trimcode(perm))] = val
+                        if formatter:
+                            _display(f"{trimcode(perm)!s:>{width}}  {formatter(val)}")
                     else:
-                        _display(f"{str(perm):>{width}}  {formatter(val)}")
+                        raw_result_dict[tuple(perm)] = val
+                        if formatter:
+                            _display(f"{perm!s:>{width}}  {formatter(val)}")
+    return raw_result_dict
+
 
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
 
-def main():
-    global var2, var3
     try:
+        var2 = tuple(symarray("y", 100).tolist())
+        var3 = tuple(symarray("z", 100).tolist())
         sys.setrecursionlimit(1000000)
 
         # TEMP
@@ -271,6 +317,7 @@ def main():
         args, formatter = schub_argparse(
             "schubmult_double",
             "Compute coefficients of product of double Schubert polynomials in the same or different sets of coefficient variables",
+            argv=argv[1:],
             yz=True,
         )
 
@@ -287,9 +334,11 @@ def main():
         display_positive = args.display_positive
         pr = args.pr
 
+        # logger.log(logging.DEBUG, f"main boing 1 {var2=}{var3=}{same=}")
         if same:
+            # logger.log(logging.DEBUG, f"main OOO {same=}")
             var3 = var2
-
+        # logger.log(logging.DEBUG, f"main boing 2 {var2=}{var3=}{same=}")
         posified = False
         if coprod:
             if ascode:
@@ -307,10 +356,11 @@ def main():
 
             kperm = inverse(uncode(kcd))
             coeff_dict = {tuple(kperm): 1}
-            coeff_dict = schubmult(coeff_dict, perms[0], var, var2)
+            coeff_dict = schubmult(coeff_dict, perms[0], _vars.var1, var2)
 
-            if pr:
-                _display_full(
+            if pr or formatter is None:
+                # logger.log(logging.DEBUG, f"main {var2=}{var3=}{same=}")
+                raw_result_dict = _display_full(
                     coeff_dict,
                     args,
                     formatter,
@@ -320,6 +370,8 @@ def main():
                     var3=var3,
                     N=N,
                 )
+            if formatter is None:
+                return raw_result_dict
         else:
             if ascode:
                 for i in range(len(perms)):
@@ -339,13 +391,13 @@ def main():
             coeff_dict = {perms[0]: 1}
             check_coeff_dict = {perms[0]: 1}
 
-            if mult:
-                for v in var2:
-                    globals()[str(v)] = v
-                for v in var3:
-                    globals()[str(v)] = v
-                for v in var_x:
-                    globals()[str(v)] = v
+            # if mult:
+            #     for v in var2:
+            #         ()[str(v)] = v
+            #     for v in var3:
+            #         globals()[str(v)] = v
+            #     for v in _vars.var1:
+            #         globals()[str(v)] = v
 
             if down:
                 for perm in orig_perms[1:]:
@@ -356,6 +408,7 @@ def main():
             else:
                 for perm in orig_perms[1:]:
                     check_coeff_dict = schubmult(check_coeff_dict, perm, var2, var3)
+                # coeff_dict = check_coeff_dict
                 if mult:
                     mul_exp = eval(mulstring)
                     check_coeff_dict = mult_poly(check_coeff_dict, mul_exp)
@@ -389,7 +442,7 @@ def main():
                         coeff_dict4 = schubmult(coeff_dict4, perm, var2, var3)
                         for w in coeff_dict4:
                             coeff_dict4[w] = coeff_dict2[u] * posify(
-                                coeff_dict4[w], u, perm, w, var2, var3, msg
+                                coeff_dict4[w], u, perm, w, var2, var3, msg,
                             )
                         coeff_dict3 = add_perm_dict(coeff_dict4, coeff_dict3)
                     coeff_dict2 = coeff_dict3
@@ -398,19 +451,24 @@ def main():
             elif not posified:
                 coeff_dict = check_coeff_dict
 
-            if pr:
-                _display_full(
+
+            if pr or formatter is None:
+                raw_result_dict = _display_full(
                     coeff_dict,
                     args,
                     formatter,
+                    var2,
+                    var3,
                     posified=posified,
                     check_coeff_dict=check_coeff_dict,
-                    var2=var2,
-                    var3=var3,
                 )
+
+            if formatter is None:
+                return raw_result_dict
     except BrokenPipeError:
         pass
+    return 0
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main(sys.argv))

schubmult/schubmult_py/__init__.py

@@ -1,10 +1,12 @@
 from ._funcs import (
+    mult_poly,
+    schub_coprod,
     schubmult,
-    mult_poly
 )
 
-
 __all__ = [
+    "mult_poly",
+    "schub_coprod",
     "schubmult",
-    "mult_poly"
 ]
+

schubmult/schubmult_py/__main__.py

@@ -1,5 +1,6 @@
 import sys
+
 from ._script import main
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main(sys.argv))

schubmult/schubmult_py/_funcs.py

@@ -1,16 +1,31 @@
-from ._vars import var_x
+from functools import cached_property
+
+from symengine import Add, Mul, Pow, symarray
+
 from schubmult.perm_lib import (
-    elem_sym_perms,
     add_perm_dict,
     compute_vpathdicts,
-    inverse,
-    theta,
-    permtrim,
+    elem_sym_perms,
     inv,
+    inverse,
     mulperm,
+    permtrim,
+    theta,
     uncode,
 )
-from symengine import Add, Mul, Pow
+
+
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+
+    @cached_property
+    def var_x(self):
+        return tuple(symarray("x", self.n).tolist())
+
+
+_vars = _gvars()
 
 
 def single_variable(coeff_dict, varnum):
@@ -29,31 +44,30 @@ def single_variable(coeff_dict, varnum):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=var_x):
+def mult_poly(coeff_dict, poly, var_x=_vars.var_x):
     if poly in var_x:
         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)
         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)
         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]
-        return ret
+    ret = {}
+    for perm in coeff_dict:
+        ret[perm] = poly * coeff_dict[perm]
+    return ret
 
 
 def schubmult(perm_dict, v):
@@ -74,8 +88,7 @@ def schubmult(perm_dict, v):
     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)
@@ -100,12 +113,44 @@ def schubmult(perm_dict, v):
                             if vdiff + udiff == th[index]:
                                 if up2 not in newpathsums:
                                     newpathsums[up2] = {}
-                                newpathsums[up2][v2] = (
-                                    newpathsums[up2].get(v2, 0) + addsumval
-                                )
+                                newpathsums[up2][v2] = newpathsums[up2].get(v2, 0) + addsumval
             vpathsums = newpathsums
         toget = tuple(vmu)
-        ret_dict = add_perm_dict(
-            {ep: vpathsums[ep].get(toget, 0) for ep in vpathsums}, ret_dict
-        )
+        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)
+    indices = sorted(indices)
+    ret_dict = {}
+    k = len(indices)
+    n = len(mperm)
+    kcd = [indices[i] - i - 1 for i in range(len(indices))] + [n + 1 - k for i in range(k, n)]
+    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))
+
+    inv_kperm = inv(kperm)
+    inverse_kperm = inverse(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:
+            flag = True
+            for i in range(N):
+                if downperm[i] > N:
+                    flag = False
+                    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))]))
+            ret_dict[(firstperm, secondperm)] = val
     return ret_dict

schubmult/schubmult_py/_script.py

@@ -1,24 +1,26 @@
-from ._funcs import (
-    mult_poly,
-    schubmult,
-)
+import sys
+
 from symengine import sympify
+
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
+    inv,
     inverse,
-    theta,
     permtrim,
-    inv,
-    mulperm,
-    code,
-    uncode,
+    theta,
     trimcode,
+    uncode,
 )
+from schubmult.schubmult_py._funcs import mult_poly, schub_coprod, schubmult
 
 
-def main():
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
     try:
-        args, formatter = schub_argparse("schubmult_py", "Compute products of ordinary Schubert polynomials")
+        args, formatter = schub_argparse(
+            "schubmult_py", "Compute products of ordinary Schubert polynomials", argv=argv[1:],
+        )
 
         mult = args.mult
         mulstring = args.mulstring
@@ -36,55 +38,29 @@ def main():
         ascode = args.ascode
         pr = args.pr
         coprod = args.coprod
-
+        raw_result_dict = {}
         if coprod:
             if ascode:
                 perms[0] = tuple(permtrim(uncode(perms[0])))
             pos = [*perms[1]]
             pos.sort()
-            mperm = perms[0]
-
-            cd = code(mperm)
-            perms[0] = mperm
-
-            while cd[-1] == 0:
-                cd.pop()
-            k = len(pos)
-            n = len(perms[0])
-            kcd = [pos[i] - i - 1 for i in range(len(pos))] + [n + 1 - k for i in range(k, n)]
-            N = len(kcd)
-            kperm = inverse(uncode(kcd))
-            coeff_dict = {tuple(permtrim(kperm)): 1}
-            coeff_dict = schubmult(coeff_dict, tuple(permtrim([*perms[0]])))
-
-            inv_kperm = inv(kperm)
-            inverse_kperm = inverse(kperm)
-            if pr:
-                for perm, val in coeff_dict.items():
-                    downperm = mulperm(list(perm), inverse_kperm)
-                    if inv(downperm) == inv(perm) - inv_kperm:
-                        flag = True
-                        for i in range(N):
-                            if downperm[i] > N:
-                                flag = False
-                                break
-                        if not flag:
-                            continue
-                        firstperm = downperm[0:N]
-                        secondperm = [downperm[i] - N for i in range(N, len(downperm))]
-                        if val != 0:
-                            # firstcode = code(firstperm)
-                            # while len(firstcode)>0 and firstcode[-1] == 0:
-                            # firstcode.pop()
-                            # secondcode = code(secondperm)
-                            # while len(secondcode)>0 and secondcode[-1] == 0:
-                            # secondcode.pop()
-                            if ascode:
-                                print(f"{val} {trimcode(firstperm)} {trimcode(secondperm)}")
+            mperm = tuple(permtrim(perms[0]))
+
+            coeff_dict = schub_coprod(mperm, pos)
+
+            if pr or formatter is None:
+                for firstperm, secondperm in coeff_dict:
+                    val = coeff_dict[(firstperm, secondperm)]
+                    if val != 0:
+                        if ascode:
+                            if formatter is None:
+                                raw_result_dict[(tuple(trimcode(firstperm)), tuple(trimcode(secondperm)))] = val
                             else:
-                                print(
-                                    f"{val} {tuple(permtrim(firstperm))} {tuple(permtrim(secondperm))}"
-                                )
+                                print(f"{val} {trimcode(firstperm)} {trimcode(secondperm)}")
+                        elif formatter is None:
+                            raw_result_dict[(firstperm, secondperm)] = val
+                        else:
+                            print(f"{val} {firstperm} {secondperm}")
         else:
             if ascode:
                 for i in range(len(perms)):
@@ -100,16 +76,22 @@ def main():
                 mul_exp = sympify(mulstring)
                 coeff_dict = mult_poly(coeff_dict, mul_exp)
 
-            if pr:
+            if pr or formatter is None:
                 for perm, val in coeff_dict.items():
                     if val != 0:
                         if ascode:
-                            print(f"{val}  {trimcode(perm)}")
+                            raw_result_dict[tuple(trimcode(perm))] = val
+                            if formatter:
+                                print(f"{val}  {trimcode(perm)}")
                         else:
-                            print(f"{val}  {perm}")
+                            raw_result_dict[tuple(perm)] = val
+                            if formatter:
+                                print(f"{val}  {perm}")
+        if formatter is None:
+            return raw_result_dict
     except BrokenPipeError:
         pass
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main(sys.argv))

schubmult/schubmult_q/__init__.py

@@ -1,12 +1,8 @@
-from ._funcs import (
-    schubmult,
-    schubmult_db,
-    mult_poly
-)
-
+from ._funcs import mult_poly, schubmult, schubmult_db
 
 __all__ = [
+    "mult_poly",
     "schubmult",
     "schubmult_db",
-    "mult_poly"
 ]
+