schubmult 2.0.0__py3-none-any.whl

schubmult/schubmult_double/_script.py

@@ -0,0 +1,407 @@
+import numpy as np
+import sympy
+import sys
+from ._vars import (
+    var2,
+    var3,
+    var_x,
+    var,
+)
+from ._funcs import (
+    mult_poly,
+    mult_poly_down,
+    schubmult,
+    schubmult_down,
+    compute_positive_rep,
+    posify,
+    split_perms,
+)
+from symengine import symarray, expand, sympify
+from schubmult._base_argparse import schub_argparse
+from schubmult.perm_lib import (
+    add_perm_dict,
+    inverse,
+    theta,
+    permtrim,
+    inv,
+    mulperm,
+    code,
+    uncode,
+    will_formula_work,
+    mu_A,
+    trimcode,
+)
+
+
+def _display(val):
+    print(val)
+
+
+def _display_full(
+    coeff_dict,
+    args,
+    formatter,
+    posified=None,
+    check_coeff_dict=None,
+    kperm=None,
+    var2=var2,
+    var3=var3,
+    N=None,
+):
+    perms = args.perms
+    mult = args.mult
+    ascode = args.ascode
+    coprod = args.coprod
+    check = args.check
+    msg = args.msg
+    down = args.down
+    same = args.same
+    display_positive = args.display_positive
+
+    coeff_perms = list(coeff_dict.keys())
+    if coprod:
+        pos = 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(inverse(perms[0])))
+
+        the_top_perm = tuple(permtrim(mulperm(list(perms[0]), mu_W)))
+
+        muA = uncode(mu_A(code(mu_W), poso))
+        muB = uncode(mu_A(code(mu_W), pos2))
+        subs_dict = {}
+        inv_kperm = inv(kperm)
+        inverse_kperm = inverse(kperm)
+        var2neg = np.array([-var2[i] for i in range(len(var2))])
+        var3neg = np.array([-var3[i] for i in range(len(var3))])
+
+        for i in range(1, 100):
+            if i <= N:
+                subs_dict[var[i]] = var2[i]
+            else:
+                subs_dict[var[i]] = var3[i - N]
+
+        coeff_perms.sort(key=lambda x: (inv(x), *x))
+
+        perm_pairs = []
+
+        for perm in coeff_perms:
+            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))]
+                perm_pairs += [[permtrim(firstperm), permtrim(secondperm)]]
+
+        if ascode:
+            width = max(
+                [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)
+            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(val).subs(subs_dict)
+
+                if val != 0:
+                    if display_positive and not same:
+                        if val != 0:
+                            val2 = posify(
+                                val,
+                                tuple(permtrim(mulperm(firstperm, muA))),
+                                tuple(permtrim(mulperm(secondperm, muB))),
+                                the_top_perm,
+                                tuple(var2neg.tolist()),
+                                tuple(var3neg.tolist()),
+                                msg,
+                                False,
+                            )
+                            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=}"
+                                )
+                                _display(
+                                    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
+                    if val != 0:
+                        if not ascode:
+                            width2 = (
+                                width
+                                - len(str(permtrim(firstperm)))
+                                - len(str(permtrim(secondperm)))
+                            )
+                            _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)}"
+                            )
+    else:
+        if ascode:
+            width = max([len(str(trimcode(perm))) for perm in coeff_dict.keys()])
+        else:
+            width = max([len(str(perm)) for perm in coeff_dict.keys()])
+
+        coeff_perms = list(coeff_dict.keys())
+        coeff_perms.sort(key=lambda x: (inv(x), *x))
+
+        var_r = symarray("r", 100)
+        for perm in coeff_perms:
+            val = coeff_dict[perm]
+            if val != 0:
+                notint = False
+                try:
+                    int(val)
+                except Exception:
+                    notint = True
+                if notint and display_positive:
+                    if same:
+                        subs_dict = {}
+                        for i in range(1, 100):
+                            sm = var2[1]
+                            for j in range(1, i):
+                                sm += var_r[j]
+                            subs_dict[var2[i]] = sm
+                        val = expand(sympify(coeff_dict[perm]).xreplace(subs_dict))
+                    else:
+                        try:
+                            if len(perms) == 2 and not posified and not mult:
+                                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,
+                                    )
+                            elif not posified and not mult:
+                                val = compute_positive_rep(val, var2, var3, msg)
+                            elif not posified:
+                                val = compute_positive_rep(val, var2, var3, msg, do_pos_neg=False)
+                        except Exception:
+                            if mult:
+                                _display(
+                                    "warning; --display-positive is on but result is not positive",
+                                    file=sys.stderr,
+                                )
+                            else:
+                                _display(
+                                    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)=}"
+                            )
+                            exit(1)
+                if val != 0:
+                    if ascode:
+                        _display(f"{str(trimcode(perm)):>{width}}  {formatter(val)}")
+                    else:
+                        _display(f"{str(perm):>{width}}  {formatter(val)}")
+
+
+def main():
+    global var2, var3
+    try:
+        sys.setrecursionlimit(1000000)
+
+        # TEMP
+        sympy.init_printing()
+
+        args, formatter = schub_argparse(
+            "schubmult_double",
+            "Compute coefficients of product of double Schubert polynomials in the same or different sets of coefficient variables",
+            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
+        display_positive = args.display_positive
+        pr = args.pr
+
+        if same:
+            var3 = var2
+
+        posified = False
+        if coprod:
+            if ascode:
+                mperm = tuple(permtrim(uncode(perms[0])))
+            else:
+                mperm = tuple(permtrim(perms[0]))
+
+            perms[0] = mperm
+            pos = perms[1]
+
+            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(kperm): 1}
+            coeff_dict = schubmult(coeff_dict, perms[0], var, var2)
+
+            if pr:
+                _display_full(
+                    coeff_dict,
+                    args,
+                    formatter,
+                    posified=posified,
+                    kperm=kperm,
+                    var2=var2,
+                    var3=var3,
+                    N=N,
+                )
+        else:
+            if ascode:
+                for i in range(len(perms)):
+                    perms[i] = tuple(permtrim(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] = (1, 2)
+                    perms[i] = tuple(permtrim([*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:
+                    globals()[str(v)] = v
+                for v in var3:
+                    globals()[str(v)] = v
+                for v in var_x:
+                    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(check_coeff_dict, perm, var2, var3)
+                if mult:
+                    mul_exp = eval(mulstring)
+                    check_coeff_dict = mult_poly(check_coeff_dict, mul_exp)
+
+            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 = mulperm(inverse(muv), perms[1])
+                coeff_dict2 = {perms[0]: 1}
+                coeff_dict2 = schubmult(coeff_dict2, muv, var2, var3)
+                for perm, val in coeff_dict2.items():
+                    w = mulperm([*perm], muvn1v)
+                    if inv(w) + inv(muvn1v) == inv(perm):
+                        coeff_dict[tuple(permtrim(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(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 pr:
+                _display_full(
+                    coeff_dict,
+                    args,
+                    formatter,
+                    posified=posified,
+                    check_coeff_dict=check_coeff_dict,
+                    var2=var2,
+                    var3=var3,
+                )
+    except BrokenPipeError:
+        pass
+
+
+if __name__ == "__main__":
+    main()

schubmult/schubmult_double/_vars.py

@@ -0,0 +1,16 @@
+from symengine import symarray
+
+n = 100
+fvar = 0
+
+var = tuple(symarray("x", n).tolist())
+var2 = tuple(symarray("y", n).tolist())
+var3 = tuple(symarray("z", n).tolist())
+
+var_x = symarray("x", 100).tolist()
+var_y = var2
+var_z = var3
+
+x = var_x
+y = var_y
+z = var_z

schubmult/schubmult_py/__init__.py

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

schubmult/schubmult_py/__main__.py

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

schubmult/schubmult_py/_funcs.py

@@ -0,0 +1,111 @@
+from ._vars import var_x
+from schubmult.perm_lib import (
+    elem_sym_perms,
+    add_perm_dict,
+    compute_vpathdicts,
+    inverse,
+    theta,
+    permtrim,
+    inv,
+    mulperm,
+    uncode,
+)
+from symengine import Add, Mul, Pow
+
+
+def single_variable(coeff_dict, varnum):
+    ret = {}
+    for u in coeff_dict:
+        new_perms_k = elem_sym_perms(u, 1, varnum)
+        new_perms_km1 = []
+        if varnum > 1:
+            new_perms_km1 = elem_sym_perms(u, 1, varnum - 1)
+        for perm, udiff in new_perms_k:
+            if udiff == 1:
+                ret[perm] = ret.get(perm, 0) + coeff_dict[u]
+        for perm, udiff in new_perms_km1:
+            if udiff == 1:
+                ret[perm] = ret.get(perm, 0) - coeff_dict[u]
+    return ret
+
+
+def mult_poly(coeff_dict, poly, var_x=var_x):
+    if poly in var_x:
+        return single_variable(coeff_dict, var_x.index(poly))
+    elif isinstance(poly, Mul):
+        ret = coeff_dict
+        for a in poly.args:
+            ret = mult_poly(ret, a, var_x)
+        return ret
+    elif 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):
+        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
+
+
+def schubmult(perm_dict, v):
+    vn1 = inverse(v)
+    th = theta(vn1)
+    if th[0] == 0:
+        return perm_dict
+    mu = permtrim(uncode(th))
+    vmu = permtrim(mulperm(list(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
+
+    for u, val in perm_dict.items():
+        inv_u = inv(u)
+        vpathsums = {u: {(1, 2): val}}
+
+        for index in range(len(th)):
+            newpathsums = {}
+            for up in vpathsums:
+                inv_up = inv(up)
+                newperms = elem_sym_perms(
+                    up,
+                    min(mx_th[index], inv_mu - inv_vmu - (inv_up - inv_u)),
+                    th[index],
+                )
+                for vp in vpathsums[up]:
+                    sumval = vpathsums[up][vp]
+                    if sumval == 0:
+                        continue
+                    for v2, vdiff, s in vpathdicts[index][vp]:
+                        addsumval = s * sumval
+                        for up2, udiff in newperms:
+                            if vdiff + udiff == th[index]:
+                                if up2 not in newpathsums:
+                                    newpathsums[up2] = {}
+                                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
+        )
+    return ret_dict

schubmult/schubmult_py/_script.py

@@ -0,0 +1,115 @@
+from ._funcs import (
+    mult_poly,
+    schubmult,
+)
+from symengine import sympify
+from schubmult._base_argparse import schub_argparse
+from schubmult.perm_lib import (
+    inverse,
+    theta,
+    permtrim,
+    inv,
+    mulperm,
+    code,
+    uncode,
+    trimcode,
+)
+
+
+def main():
+    try:
+        args = schub_argparse("schubmult_py", "Compute products of ordinary Schubert polynomials")
+
+        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
+        pr = args.pr
+        coprod = args.coprod
+
+        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)}")
+                            else:
+                                print(
+                                    f"{val} {tuple(permtrim(firstperm))} {tuple(permtrim(secondperm))}"
+                                )
+        else:
+            if ascode:
+                for i in range(len(perms)):
+                    perms[i] = tuple(permtrim(uncode(perms[i])))
+
+            perms.sort(reverse=True, key=lambda x: sum(theta(inverse(x))) - inv(x))
+
+            coeff_dict = {tuple(permtrim([*perms[0]])): 1}
+
+            for perm in perms[1:]:
+                coeff_dict = schubmult(coeff_dict, tuple(permtrim([*perm])))
+            if mult:
+                mul_exp = sympify(mulstring)
+                coeff_dict = mult_poly(coeff_dict, mul_exp)
+
+            if pr:
+                for perm, val in coeff_dict.items():
+                    if val != 0:
+                        if ascode:
+                            print(f"{val}  {trimcode(perm)}")
+                        else:
+                            print(f"{val}  {perm}")
+    except BrokenPipeError:
+        pass
+
+
+if __name__ == "__main__":
+    main()

schubmult/schubmult_py/_vars.py

@@ -0,0 +1,3 @@
+from symengine import symarray
+
+var_x = symarray("x", 100).tolist()

schubmult/schubmult_q/__init__.py

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

schubmult/schubmult_q/__main__.py

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