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

schubmult/scripts/schubmult_q_double.py

@@ -0,0 +1,207 @@
+import sys
+from functools import cached_property
+
+import sympy
+from symengine import sympify
+
+from schubmult import (
+    GeneratingSet,
+    Permutation,
+    apply_peterson_woodward,
+    div_diff,
+    efficient_subs,
+    nil_hecke,
+    permtrim,
+    q_posify,
+    schubmult_q_double,
+    schubmult_q_double_fast,
+    uncode,
+)
+from schubmult.utils.argparse import schub_argparse
+
+
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+
+    # @cached_property
+    # def fvar(self):
+    #     return 100
+
+    @cached_property
+    def var1(self):
+        return GeneratingSet("x")
+
+    @cached_property
+    def var2(self):
+        return GeneratingSet("y")
+
+    @cached_property
+    def var3(self):
+        return GeneratingSet("z")
+
+    @cached_property
+    def var_r(self):
+        return GeneratingSet("r")
+
+    @cached_property
+    def var_g1(self):
+        return GeneratingSet("y")
+
+    @cached_property
+    def var_g2(self):
+        return GeneratingSet("z")
+
+    @cached_property
+    def q_var(self):
+        return GeneratingSet("q")
+
+
+_vars = _gvars()
+
+q_var = _vars.q_var
+
+zero = sympify(0)
+
+subs_dict2 = {}
+for i in range(1, 100):
+    sm = _vars.var2[1]
+    for j in range(1, i):
+        sm += _vars.var_r[j]
+    subs_dict2[_vars.var2[i]] = sm
+
+
+def _display_full(coeff_dict, args, formatter, var2=_vars.var2, var3=_vars.var3):  # noqa: ARG001
+    ascode = args.ascode
+    Permutation.print_as_code = ascode
+    coeff_perms = list(coeff_dict.keys())
+    coeff_perms.sort(key=lambda x: (x.inv, *x))
+
+    raw_result_dict = {}
+
+    for perm in coeff_perms:
+        val = coeff_dict[perm]
+        if val != 0:
+            raw_result_dict[perm] = val
+            if formatter:
+                print(f"{sympy.sstr(perm)!s}  {formatter(val)}")
+    return raw_result_dict
+
+
+def sv_posify(val):
+    # this has just y's, we want to rearrange
+    # can we do this without an optimization
+    val = sympify(sympy.simplify(efficient_subs(val, subs_dict2)))
+    bingle_dict = {}
+    for i in range(1, len(_vars.var_r) - 1):
+        bingle_dict[_vars.var_r[i]] = _vars.var2[i + 1] - _vars.var2[i]  # sympy.Add(*[_vars.var2[i+1], - _vars.var2[i]],evaluate=False)
+        # oh bay does that bar bangled banber bet bave space buckets of cheese
+    # val = sympy.simplify(val)
+    # return efficient_subs(val, bingle_dict)
+    return val.xreplace(bingle_dict)
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    var2 = _vars.var2
+    var3 = _vars.var3
+    try:
+        sys.setrecursionlimit(1000000)
+
+        args, formatter = schub_argparse(
+            "schubmult_q_double",
+            "Compute coefficients of products of quantum double Schubert polynomials in the same or different sets of coefficient variables",
+            yz=True,
+            quantum=True,
+            argv=argv[1:],
+        )
+        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
+
+        mult = args.mult  # noqa: F841
+        mulstring = args.mulstring  # noqa: F841
+
+        perms = args.perms
+
+        ascode = args.ascode
+        msg = args.msg
+        display_positive = args.display_positive
+        pr = args.pr
+        parabolic_index = []
+        start = 0
+        # 1, 2 | 3
+        for i in range(len(args.parabolic)):
+            end = start + int(args.parabolic[i])
+            parabolic_index += list(range(start + 1, end))
+            # start += int(args.parabolic[i])
+            start = end
+        # [sum(int(args.parabolic[j]) for j in range(i+1)) for i in range(len(args.parabolic))]
+        parabolic = len(parabolic_index) != 0
+        slow = args.slow
+        nil_N = 0
+        nilhecke = False
+        nilhecke_apply = False
+        same = args.same
+        if same:
+            var3 = var2
+
+        if args.nilhecke is not None:
+            nilhecke = True
+            nil_N = args.nilhecke
+        if args.nilhecke_apply is not None:
+            nil_N = args.nilhecke_apply
+            nilhecke_apply = True
+
+        if ascode:
+            for i in range(len(perms)):
+                perms[i] = uncode(perms[i])
+        else:
+            for i in range(len(perms)):
+                if len(perms[i]) < 2 and (len(perms[i]) == 0 or perms[i][0] == 1):
+                    perms[i] = Permutation([1, 2])
+                perms[i] = permtrim(perms[i])
+
+        if nilhecke:
+            coeff_dict = nil_hecke({Permutation([1, 2]): 1}, perms[0], nil_N)
+        elif nilhecke_apply:
+            coeff_dict0 = nil_hecke({Permutation([1, 2]): 1}, perms[0], nil_N, var2, var2)
+            coeff_dict = {Permutation([]): 0}
+            for v in coeff_dict0:
+                coeff_dict[Permutation([])] += coeff_dict0[v] * div_diff(v, perms[1], var2, var3)
+        else:
+            coeff_dict = {perms[0]: 1}
+            for perm in perms[1:]:
+                if not slow:
+                    coeff_dict = schubmult_q_double_fast(coeff_dict, perm, var2, var3)
+                else:
+                    coeff_dict = schubmult_q_double(coeff_dict, perm, var2, var3)
+
+        if parabolic:
+            coeff_dict = apply_peterson_woodward(coeff_dict, parabolic_index)
+
+        if display_positive and not nilhecke and not nilhecke_apply:
+            if same:
+                coeff_dict = {perm: sv_posify(val) for perm, val in coeff_dict.items()}
+            else:
+                coeff_dict = {perm: q_posify(perms[0], perms[1], perm, val, var2, var3, _vars.q_var, msg) for perm, val in coeff_dict.items()}
+
+        raw_result_dict = {}
+
+        if pr or formatter is None:
+            raw_result_dict = _display_full(coeff_dict, args, formatter)
+        if formatter is None:
+            return raw_result_dict
+    except BrokenPipeError:
+        pass
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main(sys.argv))

schubmult/{_base_argparse.py → utils/argparse.py}

@@ -1,4 +1,16 @@
-from argparse import ArgumentParser, SUPPRESS, RawDescriptionHelpFormatter
+import sys  # noqa: F401
+from argparse import SUPPRESS, ArgumentParser, RawDescriptionHelpFormatter
+
+import sympy
+
+# from sympy import Indexed, init_printing
+from schubmult.utils.logging import init_logging
+
+# Indexed._sympystr = lambda x, p: f"{p.doprint(x.args[0])}_{x.args[1]}"
+
+
+def _sympy(obj):
+    return obj if not hasattr(obj, "_sympy_") else sympy.sympify(obj)
 
 
 def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
@@ -74,7 +86,10 @@ def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
         )
 
         parser.add_argument(
-            "--down", action="store_true", default=False, help="Reverse multiplication"
+            "--down",
+            action="store_true",
+            default=False,
+            help="Reverse multiplication",
         )
 
         parser.add_argument(
@@ -160,6 +175,13 @@ def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
         help=SUPPRESS,
     )
 
+    parser.add_argument(
+        "-debug",
+        action="store_true",
+        dest="debug",
+        help=SUPPRESS,
+    )
+
     args = parser.parse_args(argv)
     args.mulstring = ""
 
@@ -179,25 +201,32 @@ def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
 
     if args.gen:
         import json
-        import sys
 
         argv.pop(argv.index("-g"))
-        args.__dict__["cmd_line"] = ["script"] + argv
+        args.__dict__["cmd_line"] = [prog_name, *argv]
         del args.__dict__["gen"]
-        json.dump(args.__dict__, sys.stdout, ensure_ascii=False, indent=4)
+        cmd = " ".join(args.cmd_line)
+        cmd = cmd.replace("--", "").replace(" - ", "T").replace(" ", "_")
+        with open(f"{cmd}.json", "w") as js:
+            json.dump(args.__dict__, js, ensure_ascii=False, indent=1)
         exit(0)
 
-    import sympy
+    sympy.init_printing()
 
     if args.disp_mode == "latex":
         formatter = (  # noqa: E731
-            lambda bob: sympy.latex(sympy.sympify(bob)).replace("\\left", "").replace("\\right", "")
-        )  # noqa: E731
+            lambda bob, width=None: sympy.latex(_sympy(bob)).replace("\\left", "").replace("\\right", "")
+        )
     elif args.disp_mode == "pretty":
-        formatter = lambda bob: sympy.pretty(sympy.sympify(bob))  # noqa: E731
+        # pretty we need to keep centered
+        formatter = (  # noqa: E731
+            lambda bob, width=None: sympy.pretty(_sympy(bob))
+            if width is None
+            else sympy.pretty(_sympy(bob), order="rev-lex" if args.same else "none", use_unicode=False).replace("\n", "\n" + " ".join(["" for i in range(width)]))
+        )
     elif args.disp_mode == "basic":
-        formatter = lambda bob: str(bob)  # noqa: E731
+        formatter = lambda bob, width=None: sympy.sstr(_sympy(bob))  # , order="rev-lex" if args.same else "none")  # noqa: E731
     elif args.disp_mode == "raw":
         formatter = None
-
+    init_logging(debug=args.debug)
     return args, formatter

schubmult/utils/logging.py

@@ -0,0 +1,16 @@
+import logging
+
+
+def init_logging(debug=False):
+    if debug:
+        logging.basicConfig(format='%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
+            datefmt='%Y-%m-%d:%H:%M:%S',
+            level=logging.DEBUG)
+    else:
+        logging.basicConfig(format='%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
+        datefmt='%Y-%m-%d:%H:%M:%S',
+        level=logging.ERROR)
+
+
+def get_logger(name):
+    return logging.getLogger(name)

schubmult/utils/parsing.py

@@ -0,0 +1,20 @@
+import symengine
+from latex2sympy2_extended import latex2sympy  # noqa: F401
+from sympy.parsing.sympy_parser import parse_expr  # noqa: F401
+
+from schubmult.poly_lib.variables import GeneratingSet
+
+
+def parse_coeff(coeff_str, latex=False):
+    if not latex:
+        result = symengine.sympify(coeff_str)
+        subs_dict = {}
+        for s in result.free_symbols:
+            if s.name.find("_") != -1:
+                base, index = s.name.split("_")
+                gset = GeneratingSet(base)
+                subs_dict[s] = gset[int(index)]
+        return result.subs(subs_dict)
+    return None
+
+

schubmult/utils/perm_utils.py

@@ -0,0 +1,135 @@
+from bisect import bisect_left
+
+
+def getpermval(perm, index):
+    if index < len(perm):
+        return perm[index]
+    return index + 1
+
+
+def permtrim_list(perm):
+    L = len(perm)
+    while L > 0 and perm[-1] == L:
+        L = perm.pop() - 1
+    return perm
+
+
+def has_bruhat_descent(perm, i, j):
+    if perm[i] < perm[j]:
+        return False
+    for p in range(i + 1, j):
+        if perm[i] > perm[p] and perm[p] > perm[j]:
+            return False
+    return True
+
+
+def count_bruhat(perm, i, j):
+    up_amount = 0
+    if perm[i] < perm[j]:
+        up_amount = 1
+    else:
+        up_amount = -1
+    for k in range(i + 1, j):
+        if perm[i] < perm[k] and perm[k] < perm[j]:
+            up_amount += 2
+        elif perm[i] > perm[k] and perm[k] > perm[j]:
+            up_amount -= 2
+    return up_amount
+
+
+def has_bruhat_ascent(perm, i, j):
+    if perm[i] > perm[j]:
+        return False
+    for p in range(i + 1, j):
+        if perm[i] < perm[p] and perm[p] < perm[j]:
+            return False
+    return True
+
+
+def omega(i, qv):
+    i = i - 1
+    if len(qv) == 0 or i > len(qv):
+        return 0
+    if i == 0:
+        if len(qv) == 1:
+            return 2 * qv[0]
+        return 2 * qv[0] - qv[1]
+    if i == len(qv):
+        return -qv[-1]
+    if i == len(qv) - 1:
+        return 2 * qv[-1] - qv[-2]
+    return 2 * qv[i] - qv[i - 1] - qv[i + 1]
+
+
+def sg(i, w):
+    if i >= len(w) - 1 or w[i] < w[i + 1]:
+        return 0
+    return 1
+
+
+def count_less_than(arr, val):
+    ct = 0
+    i = 0
+    while i < len(arr) and arr[i] < val:
+        i += 1
+        ct += 1
+    return ct
+
+
+def is_parabolic(w, parabolic_index):
+    for i in parabolic_index:
+        if sg(i - 1, w) == 1:
+            return False
+    return True
+
+
+def add_perm_dict(d1, d2):
+    d_ret = {**d1}
+    for k, v in d2.items():
+        d_ret[k] = d_ret.get(k, 0) + v
+    return d_ret
+
+
+def p_trans(part):
+    newpart = []
+    if len(part) == 0 or part[0] == 0:
+        return [0]
+    for i in range(1, part[0] + 1):
+        cnt = 0
+        for j in range(len(part)):
+            if part[j] >= i:
+                cnt += 1
+        if cnt == 0:
+            break
+        newpart += [cnt]
+    return newpart
+
+
+def mu_A(mu, A):
+    mu_t = p_trans(mu)
+    mu_A_t = []
+    for i in range(len(A)):
+        if A[i] < len(mu_t):
+            mu_A_t += [mu_t[A[i]]]
+    return p_trans(mu_A_t)
+
+
+def get_cycles(perm):
+    return perm.get_cycles()
+
+
+def old_code(perm):
+    L = len(perm)
+    ret = []
+    v = list(range(1, L + 1))
+    for i in range(L - 1):
+        itr = bisect_left(v, perm[i])
+        ret += [itr]
+        v = v[:itr] + v[itr + 1 :]
+    return ret
+
+
+def cyclic_sort(L):
+    m = max(L)
+    i = L.index(m)
+    return L[i + 1 :] + L[: i + 1]

schubmult/utils/test_utils.py

@@ -0,0 +1,65 @@
+import symengine
+
+
+def generate_all(module, filename):
+    D = dir(module)
+    print(f"{D=}")
+    file_data = ""
+    with open(filename) as f:
+        file_data = str(f.read())
+    print(f"{file_data}")
+    real_d = [d for d in D if (file_data.find(f"def {d}")!=-1 or file_data.find(f"class {d}")!=-1) and d[0]!="_"]
+    print("from bob import (")
+    print("    ",end="")
+    print(",\n    ".join(real_d))
+    print(",")
+    print(")")
+
+    print("__all__ =")
+    print("[")
+    print("    ",end="")
+    print("',\n    '".join(real_d))
+    print(",")
+    print("]")
+
+def get_json(file: str):
+    import json
+    import os
+
+    script_dir = os.path.dirname(__file__)
+    rel_path = f"../../tests/script_tests/data/{file}.json"
+    abs_file_path = os.path.join(script_dir, rel_path)
+    with open(abs_file_path) as f:
+        return json.load(f)
+
+
+def load_json_test_names(this_dir):
+    import os
+    script_dir = os.path.dirname(__file__)
+    rel_path = f"../../tests/script_tests/data/{this_dir}"
+    abs_path = os.path.join(script_dir, rel_path)
+    files = os.listdir(abs_path)
+    ret = []
+    for file in files:
+        index = file.rfind(".json")
+        filename = file[:index]
+        ret += [filename]
+    return ret
+
+def print_args(poly):
+    def _pr(ag):
+        if hasattr(ag, "__sympy__") and not ag.is_Atom:
+            return f"({type(ag)},{print_args(ag)})"
+        return str(type(ag))
+    return "["+",".join([_pr(arg) for arg in poly.args])+"]"
+
+def sympify_args(poly):
+    try:
+        return symengine.sympify(poly)
+    except Exception:
+        if poly.is_Mul:
+            return symengine.Mul(*[sympify_args(arg) for arg in poly.args])
+        if poly.is_Pow:
+            return symengine.Pow(*[sympify_args(arg) for arg in poly.args])
+        if poly.is_Add:
+            return symengine.Add(*[sympify_args(arg) for arg in poly.args])