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

schubmult/schub_lib/tests/test_vs_old.py

@@ -0,0 +1,109 @@
+import schubmult.poly_lib.variables as schub_vars
+import schubmult.schub_lib.schub_lib as schub_lib
+import schubmult.perm_lib as pl
+import schubmult.schub_lib.tests.legacy_perm_lib as opl
+q_var = schub_vars.GeneratingSet("q")
+
+
+
+def test_double_elem_sym_q():
+    ret_list = {}
+    ret_list_N = {}
+    u= tuple([7,5,1,6,4,2,3])
+    u_N = pl.Permutation(u)
+    p1 = 3
+    p2 = 5
+    k = 6
+
+    perms1 = opl.elem_sym_perms_q(u, p1, k, q_var)
+    perms1_N = schub_lib.elem_sym_perms_q(u_N, p1, k, q_var)
+    iu = opl.inverse(u)
+    iu_N = ~u_N
+    for perm1, udiff1, mul_val1 in perms1:
+        perm1_N = pl.Permutation(perm1)
+        assert (perm1_N, udiff1, mul_val1) in perms1_N, f"Permutation {perm1} not found in new result"
+        perms2 = opl.elem_sym_perms_q(perm1, p2, k, q_var)
+        perms2_N = schub_lib.elem_sym_perms_q(perm1_N, p2, k, q_var)
+        cycles1 = opl.get_cycles(opl.mulperm([*iu],[*perm1]))
+        cycles1_N = (iu_N*perm1_N).get_cycles()
+        assert cycles1 == cycles1_N
+        cycles1_dict = {}
+        for c in cycles1:
+            if c[-1] not in cycles1_dict:
+                cycles1_dict[c[-1]] = []
+            cycles1_dict[c[-1]] += [set(c)]
+        ip1 = opl.inverse(perm1)
+        ip1_N = ~perm1_N
+        assert ip1 == list(ip1_N)
+        for perm2, udiff2, mul_val2 in perms2:
+            perm2_N = pl.Permutation(perm2)
+            assert (perm2_N, udiff2, mul_val2) in perms2_N, f"Permutation {perm2} not found in new result"
+            cycles2 = opl.get_cycles(opl.mulperm([*ip1],[*perm2]))
+            cycles2_N = (ip1_N*perm2_N).get_cycles()
+            assert cycles2 == cycles2_N
+            good = True
+            for i in range(len(cycles2)):
+                c2 = cycles2[i]
+                if c2[-1] not in cycles1_dict:
+                    continue
+                for c1_s in cycles1_dict[c2[-1]]:
+                    for a in range(len(c2) - 2, -1, -1):
+                        if c2[a] in c1_s:
+                            good = False
+                            break
+                    if not good:
+                        break
+                if not good:
+                    break
+
+            if good:
+                if (perm1, udiff1, mul_val1) not in ret_list:
+                    ret_list[(perm1, udiff1, mul_val1)] = []
+                ret_list[(perm1, udiff1, mul_val1)] += [(perm2, udiff2, mul_val2)]
+    return ret_list
+
+
+
+def test_elem_sym_q():
+    # Test the function with a sample permutation
+    old_perm = tuple([5,1,4,2,3])
+    orig_perm = pl.Permutation(old_perm)
+    p = 3
+    k = 5
+    result_old = opl.elem_sym_perms_q(old_perm, p, k)
+    result_new = schub_lib.elem_sym_perms_q(orig_perm, p, k)
+    assert len(result_old) == len(result_new), "Length of results do not match"
+    for i in range(len(result_old)):
+        # print(f"{result_old[i]=} {result_new[i]=}")
+        assert pl.Permutation(result_old[i][0]) == result_new[i][0], f"Permutation mismatch at index {i}"
+        assert result_old[i][2] == result_new[i][2], f"Value mismatch at index {i}"
+    # def double_elem_sym_q(u, p1, p2, k, q_var=q_var):
+    old_perm = tuple([7,5,1,6,4,2,3])
+    orig_perm = pl.Permutation(old_perm)
+    p1 = 3
+    p2 = 5
+    k = 6
+    result_old = opl.double_elem_sym_q(old_perm, p1, p2, k)
+    result_new = schub_lib.double_elem_sym_q(orig_perm, p1, p2, k)
+    assert len(result_old) == len(result_new), "Length of results do not match"
+    print("OLD")
+    print("\n".join([str((str(b),str(result_old[b]))) for b in result_old]))
+    print("NEW")
+    print("\n".join([str((str(b),str(result_new[b]))) for b in result_new]))
+    for k, v in result_old.items():
+        k2 = (pl.Permutation(k[0]),k[1],k[2])
+        assert k2 in result_new, f"Key {k2} not found in new result"
+        v2 = result_new[k2]
+        v = sorted(v)
+        v2 = sorted(v2)
+        assert len(v) == len(v2)
+        for i in range(len(v)):
+            assert pl.Permutation(v[i][0]) == v2[i][0]
+            assert v[i][2] == v2[i][2]
+        
+        #double_elem_sym_q
+        # assert pl.Permutation(result_old[i][1]) == result_new[i][1], f"Value mismatch at index {i}"
+        # assert pl.Permutation(result_old[i][2]) == result_new[i][2], f"Last j mismatch at index {i}"
+    # Print the result
+    # for perm, val, last_j in result:
+    #     # print(f"Permutation: {perm}, Value: {val}, Last j: {last_j}")

schubmult/scripts/schubmult_double.py

@@ -0,0 +1,378 @@
+import sys
+from functools import cached_property
+
+import sympy
+from symengine import expand, sympify
+
+from schubmult import GeneratingSet, Permutation, efficient_subs, mult_poly_double, permtrim, posify, schub_coprod_double, schubmult_double, theta, uncode
+from schubmult.perm_lib import split_perms
+from schubmult.schub_lib.schub_lib import will_formula_work
+from schubmult.utils.argparse import schub_argparse
+from schubmult.utils.logging import get_logger
+from schubmult.utils.perm_utils import (
+    add_perm_dict,
+    mu_A,
+)
+
+logger = get_logger(__name__)
+
+
+class _gvars:
+    @cached_property
+    def n(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")
+
+
+_vars = _gvars()
+
+
+def _display(val):
+    print(val)
+
+
+subs_dict = {}
+for i in range(1, 100):
+    sm = _vars.var2[1]
+    for j in range(1, i):
+        sm += _vars.var_r[j]
+    subs_dict[_vars.var2[i]] = sm
+
+
+def sv_posify(val):
+    # this has just y's, we want to rearrange
+    # can we do this without an optimization
+    val = sympify(sympy.simplify(val.subs(subs_dict)))
+    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 val.xreplace(bingle_dict)
+
+
+def pre_posify(perms, perm, val, check, check_val, same, down, var2, var3, msg):
+    try:
+        return int(val)
+    except Exception:
+        if same:
+            val = sv_posify(val)  # efficient_subs(sympify(val), subs_dict).expand()  # expand(sympify(val).xreplace(subs_dict))
+        else:
+            if not down:
+                val = posify(
+                    val,
+                    perms[0],
+                    perms[1],
+                    perm,
+                    var2,
+                    var3,
+                    msg,
+                )
+            else:
+                val = posify(
+                    val,
+                    perm,
+                    perms[1],
+                    perms[0],
+                    var2,
+                    var3,
+                    msg,
+                )
+            # except Exception:
+            #     _display(
+            #         f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_val=}",
+            #     )
+            #     exit(1)
+            # if check and expand(val - check_coeff_dict.get(perm, 0)) != 0:
+            if check and expand(val - check_val) != 0:
+                _display(
+                    f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=} {check_val=}",
+                )
+                # logger.debug("Yep it's here")
+                exit(1)
+    return val
+
+
+def flip_symbol_signs(val):
+    subs_dict = {}
+    for s in val.free_symbols:
+        if _vars.var2.index(s) != -1 or _vars.var3.index(s) != -1:
+            subs_dict[s] = -s
+    return efficient_subs(val, subs_dict)
+
+
+def _display_full(
+    coeff_dict,
+    args,
+    formatter,
+    var2,
+    var3,
+    check=True,
+):
+    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
+    ascode = args.ascode
+    Permutation.print_as_code = ascode
+    coprod = args.coprod
+    msg = args.msg
+    same = args.same
+    display_positive = args.display_positive
+    perms[0] = Permutation(perms[0])
+    pos = list(perms[1])
+    pos2 = []
+    last_descent = -1
+    poso = []
+    for i in range(len(perms[0]) - 1):
+        if perms[0][i] > perms[0][i + 1]:
+            last_descent = i + 1
+    for i in range(1, last_descent + 1):
+        if i not in pos:
+            pos2 += [i - 1]
+        else:
+            poso += [i - 1]
+
+    mu_W = uncode(theta(~perms[0]))
+
+    the_top_perm = perms[0] * mu_W
+
+    muA = uncode(mu_A(mu_W.code, poso))
+    muB = uncode(mu_A(mu_W.code, pos2))
+
+    coeff_perms = list(coeff_dict.keys())
+    if coprod:
+        perm_pairs = coeff_perms
+        width = max([len(sympy.sstr(perm[0]) + " " + sympy.sstr(perm[1])) for perm in perm_pairs])
+
+        for firstperm, secondperm in perm_pairs:
+            val = coeff_dict[(firstperm, secondperm)]
+            if same and display_positive:
+                val = sv_posify(val)  # efficient_subs(sympify(val), subs_dict2).expand()
+            if val != 0:
+                if display_positive and not same:
+                    if val != 0:
+                        try:
+                            val = int(expand(val))
+                        except Exception as e:  # noqa: F841
+                            val2 = posify(
+                                flip_symbol_signs(val),
+                                firstperm * muA,
+                                secondperm * muB,
+                                the_top_perm,
+                                var2,
+                                var3,
+                                msg,
+                                False,
+                            )
+                            val2 = flip_symbol_signs(val2)
+                            if check and expand(val - val2) != 0:
+                                _display(
+                                    f"error; write to schubmult@gmail.com with the case {perms=}\n{sympy.sstr(firstperm)=} {sympy.sstr(secondperm)=}\n{val2=}\n{val=}",
+                                )
+                                _display(f"{firstperm*muA=} {secondperm*muB=} {the_top_perm=}")
+                                exit(1)
+                            val = val2
+                    else:
+                        val = 0
+                if val != 0:
+                    width2 = width - len(sympy.sstr(permtrim(firstperm))) - len(sympy.sstr(permtrim(secondperm)))
+                    raw_result_dict[(permtrim(firstperm), Permutation(secondperm))] = val
+                    if formatter:
+                        _display(
+                            f"{sympy.sstr(permtrim(firstperm))}{' ':>{width2}}{sympy.sstr(Permutation(secondperm))}  {formatter(val)}",
+                        )
+    else:
+        width = max([len(sympy.sstr(perm)) for perm in coeff_dict.keys()])
+
+        coeff_perms = list(coeff_dict.keys())
+        coeff_perms.sort(key=lambda x: (x.inv, *x))
+
+        for perm in coeff_perms:
+            val = coeff_dict[perm]
+            # if val != 0:
+            if val != 0:
+                raw_result_dict[perm] = val
+                if formatter:
+                    _display(f"{sympy.sstr(perm)!s:>{width}}  {formatter(val)}")
+    return raw_result_dict
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+
+    try:
+        var2 = GeneratingSet("y")
+        var3 = GeneratingSet("z")
+        sys.setrecursionlimit(1000000)
+
+        # TEMP
+        sympy.init_printing()
+
+        args, formatter = schub_argparse(
+            "schubmult_double",
+            "Compute coefficients of products of double Schubert polynomials in the same or different sets of coefficient variables",
+            argv=argv[1:],
+            yz=True,
+        )
+
+        mult = args.mult
+        mulstring = args.mulstring
+
+        perms = args.perms
+
+        ascode = args.ascode
+        coprod = args.coprod
+        same = args.same
+        msg = args.msg
+        down = args.down
+        check = args.check
+        display_positive = args.display_positive
+        pr = args.pr
+        # debug = args.debug
+
+        # logger.log(logging.DEBUG, f"main boing 1 {var2=}{var3=}{same=}")
+        if same:
+            var3 = var2
+        # logger.log(logging.DEBUG, f"main boing 2 {var2=}{var3=}{same=}")
+        posified = False
+        if coprod:
+            if ascode:
+                perms[0] = uncode(perms[0])
+            pos = [*perms[1]]
+            pos.sort()
+            mperm = Permutation(perms[0])
+
+            coeff_dict = schub_coprod_double(mperm, pos, var2, var3)
+
+            if pr or formatter is None:
+                # logger.log(logging.DEBUG, f"main {var2=}{var3=}{same=}")
+                raw_result_dict = _display_full(
+                    coeff_dict,
+                    args,
+                    formatter,
+                    var2=var2,
+                    var3=var3,
+                )
+            if formatter is None:
+                return raw_result_dict
+        else:
+            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([])
+                    perms[i] = Permutation(perms[i])
+
+            size = 0
+            orig_perms = [*perms]
+            while len(perms) != size:
+                size = len(perms)
+                perms = split_perms(perms)
+
+            coeff_dict = {perms[0]: 1}
+            check_coeff_dict = {perms[0]: 1}
+
+            # 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:]:
+            #         check_coeff_dict = schubmult_down(check_coeff_dict, perm, var2, var3)
+            #     if mult:
+            #         mul_exp = eval(mulstring)
+            #         check_coeff_dict = mult_poly_down(check_coeff_dict, mul_exp)
+            # else:
+            for perm in orig_perms[1:]:
+                check_coeff_dict = schubmult_double(check_coeff_dict, perm, var2, var3)
+            # coeff_dict = check_coeff_dict
+            if mult:
+                mul_exp = eval(mulstring)
+                check_coeff_dict = mult_poly_double(check_coeff_dict, mul_exp)
+            # preprocess positivity
+            if display_positive and len(perms) == 2 and will_formula_work(perms[0], perms[1]) and not mult and not down and not same:
+                coeff_dict = {}
+                th = theta(perms[1])
+                muv = uncode(th)
+                muvn1v = (~muv) * perms[1]
+                coeff_dict2 = {perms[0]: 1}
+                coeff_dict2 = schubmult_double(coeff_dict2, muv, var2, var3)
+                for perm, val in coeff_dict2.items():
+                    w = perm * muvn1v
+                    if w.inv + muvn1v.inv == perm.inv:
+                        coeff_dict[Permutation(w)] = val
+                posified = True
+
+            if display_positive and len(perms) > 2 and not mult and not same:
+                coeff_dict2 = dict(coeff_dict)
+                for perm in perms[1:]:
+                    coeff_dict3 = {}
+                    for u in coeff_dict2:
+                        coeff_dict4 = {u: 1}
+                        coeff_dict4 = schubmult_double(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_dict3 = add_perm_dict(coeff_dict4, coeff_dict3)
+                    coeff_dict2 = coeff_dict3
+                coeff_dict = coeff_dict2
+                posified = True
+            elif not posified:
+                coeff_dict = check_coeff_dict
+
+            if not posified and display_positive:
+                # print(f"{coeff_dict=}")
+                coeff_dict = {k: pre_posify(perms, k, v, check, check_coeff_dict.get(k, 0), same, down, var2, var3, msg) for k, v in coeff_dict.items()}
+
+            if pr or formatter is None:
+                raw_result_dict = _display_full(
+                    coeff_dict,
+                    args,
+                    formatter,
+                    var2,
+                    var3,
+                )
+
+            if formatter is None:
+                return raw_result_dict
+    except BrokenPipeError:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

schubmult/scripts/schubmult_py.py

@@ -0,0 +1,84 @@
+import sys
+
+import sympy
+from symengine import sympify
+
+from schubmult import Permutation, mult_poly_py, permtrim, schub_coprod_py, schubmult_py, theta, uncode
+from schubmult.utils.argparse import schub_argparse
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    try:
+        args, formatter = schub_argparse(
+            "schubmult_py",
+            "Compute products of ordinary Schubert polynomials",
+            argv=argv[1:],
+        )
+
+        mult = args.mult
+        mulstring = args.mulstring
+
+        perms = args.perms
+
+        for perm in perms:
+            try:
+                for i in range(len(perm)):
+                    perm[i] = int(perm[i])
+            except Exception as e:
+                print("Permutations must have integer values")
+                raise e
+
+        ascode = args.ascode
+        Permutation.print_as_code = ascode
+        pr = args.pr
+        coprod = args.coprod
+        raw_result_dict = {}
+        if coprod:
+            if ascode:
+                perms[0] = uncode(perms[0])
+            pos = [*perms[1]]
+            pos.sort()
+            mperm = Permutation(perms[0])
+
+            coeff_dict = schub_coprod_py(mperm, pos)
+
+            if pr or formatter is None:
+                for firstperm, secondperm in coeff_dict:
+                    val = coeff_dict[(firstperm, secondperm)]
+                    if val != 0:
+                        if formatter is None:
+                            raw_result_dict[(firstperm, secondperm)] = val
+                        else:
+                            print(f"{val} {sympy.sstr(firstperm)} {sympy.sstr(secondperm)}")
+        else:
+            if ascode:
+                for i in range(len(perms)):
+                    perms[i] = permtrim(uncode(perms[i]))
+            else:
+                perms = [permtrim(perm) for perm in perms]
+            perms.sort(reverse=True, key=lambda x: sum(theta(~x)) - x.inv)
+
+            coeff_dict = {permtrim([*perms[0]]): 1}
+
+            for perm in perms[1:]:
+                coeff_dict = schubmult_py(coeff_dict, Permutation(perm))
+            if mult:
+                mul_exp = sympify(mulstring)
+                coeff_dict = mult_poly_py(coeff_dict, mul_exp)
+
+            if pr or formatter is None:
+                for perm, val in coeff_dict.items():
+                    if val != 0:
+                        raw_result_dict[perm] = val
+                        if formatter:
+                            print(f"{val}  {sympy.sstr(perm)}")
+        if formatter is None:
+            return raw_result_dict
+    except BrokenPipeError:
+        pass
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

schubmult/scripts/schubmult_q.py

@@ -0,0 +1,109 @@
+import sys
+
+import sympy
+from symengine import sympify
+
+from schubmult import GeneratingSet, Permutation, apply_peterson_woodward, schubmult_q, schubmult_q_fast, uncode
+from schubmult.utils.argparse import schub_argparse
+
+q_var = GeneratingSet("q")
+
+
+def _display_full(coeff_dict, args, formatter):
+    raw_result_dict = {}
+    ascode = args.ascode
+    Permutation.print_as_code = ascode
+    parabolic_index = []
+    start = 0
+    for i in range(len(args.parabolic)):
+        end = start + int(args.parabolic[i])
+        parabolic_index += list(range(start + 1, end))
+        start = end
+    parabolic = len(parabolic_index) != 0
+
+    if parabolic:
+        coeff_dict = apply_peterson_woodward(coeff_dict, parabolic_index)
+
+    coeff_perms = list(coeff_dict.keys())
+    coeff_perms.sort(key=lambda x: (x.inv, *x))
+
+    for perm in coeff_perms:
+        val = sympify(coeff_dict[perm]).expand()
+        if val != 0:
+            raw_result_dict[perm] = val
+            if formatter:
+                print(f"{sympy.sstr(perm)!s}  {formatter(val)}")
+    return raw_result_dict
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    try:
+        args, formatter = schub_argparse(
+            "schubmult_q",
+            "Compute products of quantum Schubert polynomials",
+            argv=argv[1:],
+            quantum=True,
+        )
+
+        perms = args.perms
+
+        for perm in perms:
+            try:
+                for i in range(len(perm)):
+                    perm[i] = int(perm[i])
+            except Exception as e:
+                print("Permutations must have integer values")
+                raise e
+
+        ascode = args.ascode
+        pr = args.pr
+        parabolic_index = [int(s) for s in args.parabolic]
+        parabolic = len(parabolic_index) != 0
+        slow = args.slow
+
+        if parabolic and len(perms) != 2:
+            print("Only two permutations supported for parabolic.")
+            exit(1)
+
+        if ascode:
+            for i in range(len(perms)):
+                perms[i] = uncode(perms[i])
+        else:
+            perms = [Permutation(perm) for perm in perms]
+
+        # if parabolic:
+        #     for i in range(len(parabolic_index)):
+        #         index = parabolic_index[i] - 1
+        #         if sg(index, perms[0]) == 1 or sg(index, perms[1]) == 1:
+        #             print(
+        #                 "Parabolic given but elements are not minimal length coset representatives.",
+        #             )
+        #             exit(1)
+
+        coeff_dict = {perms[0]: 1}
+
+        if not slow:
+            for perm in perms[1:]:
+                coeff_dict = schubmult_q_fast(coeff_dict, perm)
+        else:
+            for perm in perms[1:]:
+                coeff_dict = schubmult_q(coeff_dict, perm)
+
+        # if mult:
+        #     mul_exp = sympify(mulstring)
+        #     coeff_dict = mult_poly(coeff_dict, mul_exp)
+
+        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))