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

schubmult/schubmult_double/_funcs.py

@@ -2,7 +2,7 @@ from bisect import bisect_left
 from functools import cache
 from cachetools import cached
 from cachetools.keys import hashkey
-from symengine import sympify, Add, Mul, Pow, expand, Integer
+from symengine import sympify, Add, Mul, Pow, expand, Integer, symarray
 from schubmult.perm_lib import (
     elem_sym_perms,
     elem_sym_poly,
@@ -36,13 +36,45 @@ import pulp as pu
 import sympy
 import psutil
 from sortedcontainers import SortedList
-from ._vars import (
-    n,
-    var2,
-    var3,
-    var_x,
-    var_y,
-)
+from functools import cached_property
+
+# NO GLOBAL VARS
+# from ._vars import (
+#     n,
+#     var2,
+#     var3,
+#     _vars.var1,
+#     var_y,
+# )
+
+
+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 count_sorted(mn, tp):
@@ -54,11 +86,11 @@ def count_sorted(mn, tp):
     return ct
 
 
-def E(p, k, varl=var_y[1:]):
-    return elem_sym_poly(p, k, var_x[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=var2):
+def single_variable(coeff_dict, varnum, var2=None):
     ret = {}
     for u in coeff_dict:
         if varnum - 1 < len(u):
@@ -78,7 +110,7 @@ def single_variable(coeff_dict, varnum, var2=var2):
     return ret
 
 
-def single_variable_down(coeff_dict, varnum):
+def single_variable_down(coeff_dict, varnum, var2=_vars.var2):
     ret = {}
     for u in coeff_dict:
         if varnum - 1 < len(u):
@@ -98,7 +130,7 @@ def single_variable_down(coeff_dict, varnum):
     return ret
 
 
-def mult_poly(coeff_dict, poly, var_x=var_x, var_y=var2):
+def mult_poly(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2):
     if poly in var_x:
         return single_variable(coeff_dict, var_x.index(poly), var_y)
     elif isinstance(poly, Mul):
@@ -126,8 +158,8 @@ def mult_poly(coeff_dict, poly, var_x=var_x, var_y=var2):
 
 
 def mult_poly_down(coeff_dict, poly):
-    if poly in var_x:
-        return single_variable_down(coeff_dict, var_x.index(poly))
+    if poly in _vars.var1:
+        return single_variable_down(coeff_dict, _vars.var1.index(poly))
     elif isinstance(poly, Mul):
         ret = coeff_dict
         for a in poly.args:
@@ -168,7 +200,7 @@ def nilhecke_mult(coeff_dict1, coeff_dict2):
     return ret
 
 
-def forwardcoeff(u, v, perm, var2=var2, var3=var3):
+def forwardcoeff(u, v, perm, var2=None, var3=None):
     th = theta(v)
     muv = uncode(th)
     vmun1 = mulperm(inverse([*v]), muv)
@@ -180,7 +212,7 @@ def forwardcoeff(u, v, perm, var2=var2, var3=var3):
     return 0
 
 
-def dualcoeff(u, v, perm, var2=var2, var3=var3):
+def dualcoeff(u, v, perm, var2=None, var3=None):
     if u == (1, 2):
         vp = mulperm([*v], inverse(perm))
         if inv(vp) == inv(v) - inv(perm):
@@ -256,11 +288,11 @@ monom_to_vec = {}
 
 
 @cache
-def schubmult_one(perm1, perm2, var2=var2, var3=var3):
+def schubmult_one(perm1, perm2, var2=None, var3=None):
     return schubmult({perm1: 1}, perm2, var2, var3)
 
 
-def schubmult(perm_dict, v, var2=var2, var3=var3):
+def schubmult(perm_dict, v, var2=None, var3=None):
     vn1 = inverse(v)
     th = theta(vn1)
     if len(th) == 0:
@@ -319,7 +351,7 @@ def schubmult(perm_dict, v, var2=var2, var3=var3):
     return ret_dict
 
 
-def schubmult_down(perm_dict, v, var2=var2, var3=var3):
+def schubmult_down(perm_dict, v, var2=None, var3=None):
     vn1 = inverse(v)
     th = theta(vn1)
     if th[0] == 0:
@@ -371,7 +403,7 @@ def schubmult_down(perm_dict, v, var2=var2, var3=var3):
     return ret_dict
 
 
-def poly_to_vec(poly, vec0=None):
+def poly_to_vec(poly, vec0=None, var3=_vars.var3):
     global dimen, monom_to_vec, base_vec
     poly = expand(poly.xreplace({var3[1]: 0}))
 
@@ -396,12 +428,12 @@ def poly_to_vec(poly, vec0=None):
     return vec
 
 
-def shiftsub(pol):
+def shiftsub(pol, var2=_vars.var2, var3=_vars.var3):
     subs_dict = dict([(var2[i], var2[i + 1]) for i in range(99)])
     return sympify(pol).subs(subs_dict)
 
 
-def shiftsubz(pol):
+def shiftsubz(pol, var2=_vars.var2, var3=_vars.var3):
     subs_dict = dict([(var3[i], var3[i + 1]) for i in range(99)])
     return sympify(pol).subs(subs_dict)
 
@@ -449,7 +481,7 @@ def is_flat_term(term):
     return True
 
 
-def flatten_factors(term, var2=var3, var3=var3):
+def flatten_factors(term, var2=_vars.var2, var3=_vars.var3):
     found_one = False
     if is_flat_term(term):
         return term, False
@@ -511,7 +543,7 @@ def fres(v):
         return s
 
 
-def split_mul(arg0, var2=var2, var3=var3):
+def split_mul(arg0, var2=None, var3=None):
     monoms = SortedList()
 
     var2s = {fres(var2[i]): i for i in range(len(var2))}
@@ -705,7 +737,7 @@ def find_base_vectors(monom_list, monom_list_neg, var2, var3, depth):
     return ret, monom_list
 
 
-def compute_positive_rep(val, var2=var2, var3=var3, msg=False, do_pos_neg=True):
+def compute_positive_rep(val, var2=None, var3=None, msg=False, do_pos_neg=True):
     notint = False
     try:
         int(expand(val))
@@ -970,7 +1002,7 @@ def is_hook(cd):
     return False
 
 
-def div_diff(i, poly):
+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]
     )
@@ -1007,13 +1039,15 @@ def skew_div_diff(u, w, poly):
     u2,
     v2,
     w2,
-    var2=var2,
-    var3=var3,
+    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),
 )
-def posify(val, u2, v2, w2, var2=var2, var3=var3, msg=False, do_pos_neg=True, sign_only=False):
+def posify(
+    val, u2, v2, w2, var2=None, var3=None, msg=False, do_pos_neg=True, sign_only=False, n=_vars.n
+):
     if inv(u2) + inv(v2) - inv(w2) == 0:
         return val
     cdv = code(v2)
@@ -1567,7 +1601,7 @@ def split_perms(perms):
     return perms2
 
 
-def schubpoly(v, var2=var2, var3=var3, start_var=1):
+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]:
@@ -1585,6 +1619,52 @@ def schubpoly(v, var2=var2, var3=var3, start_var=1):
     return ret
 
 
-def permy(val, i):
+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):
+    indices = sorted(indices)
+    subs_dict_coprod = {}
+    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)))
+    inv_kperm = inv(kperm)
+    vn = symarray("soible", 100)
+
+    for i in range(1, N * 2 + 1):
+        if i <= N:
+            subs_dict_coprod[vn[i]] = var2[i]
+        else:
+            subs_dict_coprod[vn[i]] = var3[i - N]
+
+    coeff_dict = {tuple(kperm): 1}
+    coeff_dict = schubmult(coeff_dict, mperm, vn, var2)
+
+    inverse_kperm = inverse(kperm)
+
+    ret_dict = {}
+    for perm in coeff_dict:
+        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))]
+
+            val = sympify(coeff_dict[perm]).subs(subs_dict_coprod)
+
+            key = (tuple(permtrim(firstperm)), tuple(permtrim(secondperm)))
+            ret_dict[key] = val
+
+    return ret_dict

schubmult/schubmult_double/_script.py

@@ -1,14 +1,9 @@
 import numpy as np
 import sympy
 import sys
-from ._vars import (
-    var2,
-    var3,
-    var_x,
-    var,
-    var_r
-)
-from ._funcs import (
+
+# from schubmult.schubmult_double._vars import var_x, var, var_r
+from schubmult.schubmult_double._funcs import (
     mult_poly,
     mult_poly_down,
     schubmult,
@@ -17,7 +12,7 @@ from ._funcs import (
     posify,
     split_perms,
 )
-from symengine import expand, sympify
+from symengine import expand, sympify, symarray
 from schubmult._base_argparse import schub_argparse
 from schubmult.perm_lib import (
     add_perm_dict,
@@ -33,6 +28,37 @@ from schubmult.perm_lib import (
     trimcode,
 )
 
+from functools import cached_property
+
+
+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 +68,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 +121,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))
 
@@ -117,6 +150,7 @@ def _display_full(
         else:
             width = max([len(str(perm[0]) + " " + str(perm[1])) for perm in perm_pairs])
 
+        subs_dict2 = {}        
         for perm in coeff_perms:
             val = coeff_dict[perm]
             downperm = mulperm(list(perm), inverse_kperm)
@@ -132,13 +166,7 @@ def _display_full(
                 secondperm = [downperm[i] - N for i in range(N, len(downperm))]
                 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
+                if same and display_positive:                    
                     val = expand(sympify(val).xreplace(subs_dict2))
 
                 if val != 0:
@@ -164,7 +192,7 @@ def _display_full(
                                 exit(1)
                             val = val2
                         else:
-                            val = 0                    
+                            val = 0
                     if val != 0:
                         if not ascode:
                             width2 = (
@@ -172,18 +200,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 +228,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 +243,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:
@@ -255,14 +291,29 @@ def _display_full(
                             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"{str(trimcode(perm)):>{width}}  {formatter(val)}")
                     else:
-                        _display(f"{str(perm):>{width}}  {formatter(val)}")
-
-
-def main():
-    global var2, var3
+                        raw_result_dict[tuple(perm)] = val
+                        if formatter:
+                            _display(f"{str(perm):>{width}}  {formatter(val)}")
+    return raw_result_dict
+
+
+def main(argv=None):
+    import logging
+
+    logging.basicConfig(
+        level=logging.ERROR, format="%(asctime)s %(levelname)s %(message) %(module) s"
+    )
+    logger = logging.getLogger(__name__)
+    logger.log(logging.DEBUG, f"main {argv=}")
+    if argv is None:
+        argv = sys.argv
     try:
+        var2 = tuple(symarray("y", 100).tolist())
+        var3 = tuple(symarray("z", 100).tolist())
         sys.setrecursionlimit(1000000)
 
         # TEMP
@@ -271,6 +322,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 +339,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 +361,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=}")
+                return _display_full(
                     coeff_dict,
                     args,
                     formatter,
@@ -339,13 +394,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 +411,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)
@@ -398,19 +454,21 @@ 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
 
 
 if __name__ == "__main__":
-    main()
+    main(sys.argv)

schubmult/schubmult_py/__init__.py

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

schubmult/schubmult_py/__main__.py

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

schubmult/schubmult_py/_funcs.py

@@ -1,4 +1,3 @@
-from ._vars import var_x
 from schubmult.perm_lib import (
     elem_sym_perms,
     add_perm_dict,
@@ -10,7 +9,21 @@ from schubmult.perm_lib import (
     mulperm,
     uncode,
 )
-from symengine import Add, Mul, Pow
+from symengine import Add, Mul, Pow, symarray
+from functools import cached_property
+
+
+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,7 +42,7 @@ 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):
@@ -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