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

schubmult-3.0.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+schubmult/__init__.py,sha256=SqufaRbFLZue-oOMqDUpEVJagcTJoAi5XY5Az_YC1bw,2385
+schubmult/perm_lib.py,sha256=2yUV3nquNnGPLpAJJBCg7SFF-y-eP0zcCxC9hy6keDg,10431
+schubmult/poly_lib/__init__.py,sha256=DUA70oCWv64lqhezrpKgA6813Dp5LTM1bkMrpOoqjTU,674
+schubmult/poly_lib/poly_lib.py,sha256=ZgZWY9Q2TBdk5lH2Jtg7LJO-WETtVcYfr8aSpaEKdMU,7839
+schubmult/poly_lib/schub_poly.py,sha256=_GXApXSbmlF0neSZOY9fCFXxSmYJEoHv_PvJJzIhy5E,4586
+schubmult/poly_lib/variables.py,sha256=cnR9Kvzbh7LA0Mvi292h2eMW7d3s2GU9DKvP3M44HNE,6005
+schubmult/rings/__init__.py,sha256=Xaf8JB64C0tjlb_F8WQqHFGp3MM5LteFgkxNETImMiU,630
+schubmult/rings/_quantum_schubert_polynomial_ring.py,sha256=H71XoK96-Bfel-uel5BPQLIL_Kazjjej3StgXeDBAd0,29951
+schubmult/rings/_schubert_polynomial_ring.py,sha256=mokenMrZJq0nrzV8xZ23xrIQJTYpFdbUCCct1vpIbCE,39338
+schubmult/rings/_tensor_schub_ring.py,sha256=-ahCinjsAyK6EvfPD8T4nB4KJ8syISEbtYL-n34q16I,3952
+schubmult/rings/_utils.py,sha256=hCB9sMJfgINLvqbJbpGd5bnGQL3sb6G1nr1Dr5O-qwM,1787
+schubmult/sage/__init__.py,sha256=bgRIEllThsrH0kYJnEAR_cirTGGfdPojOUajbZjJhq4,906
+schubmult/sage/_fast_double_schubert_polynomial_ring.py,sha256=pAan4EWSss0rQA2Pk_QuqGTuy4SoxAGFzaVZGQJAzS0,19936
+schubmult/sage/_fast_schubert_polynomial_ring.py,sha256=dXLX-9rfpk_ueIRqDcGRc83oWx45gaf1SNAbp4ALliY,14371
+schubmult/sage/_indexing.py,sha256=L6ShyDI7ceMSga8jel5mzAWBxfmsXC9uJZYpZ_WrnOI,1932
+schubmult/schub_lib/__init__.py,sha256=kFtT2ghMrgFACzJSraeJYGcvGlb3uXt_GJIl36tmOw8,1118
+schubmult/schub_lib/double.py,sha256=x7l84DJ4e0VW90z7GbdRNpF7FUcKGPXhXWOxBLXBLh0,51663
+schubmult/schub_lib/quantum.py,sha256=RcjpAtyxVndo-kR-H31gjtmjaLNq2PWSglvw6LnKOR0,9998
+schubmult/schub_lib/quantum_double.py,sha256=Ex4Azr-aPGLajFcuOFFNCBKYrDt7fcp7lc_B9SOhGbE,36774
+schubmult/schub_lib/schub_lib.py,sha256=Sca_PAOD0ABEyixpgYpFxPxfCPZnKchFGeKUZIstIyc,22815
+schubmult/schub_lib/single.py,sha256=3ZJzC9dSFc6Ux_DcuSKekwK7D9ZyrCd5OUEiIKW8LZk,5210
+schubmult/schub_lib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schubmult/schub_lib/tests/legacy_perm_lib.py,sha256=fMGkKPv6VtZcTBFC5JZsZQRy1-m9a2uvOGmCiF-eovM,29619
+schubmult/schub_lib/tests/test_vs_old.py,sha256=6X1GDj3dCRg3Hx6rFOUk4trIv7I2Hctq6FlUwGH3gHk,4362
+schubmult/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schubmult/scripts/schubmult_double.py,sha256=DGGH_DQDcovAi5TcJ2_bnA0Slj9-pB3tSVh3pr6SIZM,13010
+schubmult/scripts/schubmult_py.py,sha256=ARQn4Ucl5n8dz_q77gjkrazVSDjUMQHkx5EK7Sx5_Wc,2738
+schubmult/scripts/schubmult_q.py,sha256=ntzcVmFjRbXGKTddkhdNVpxcMTTtK4CeOI4BeIVjePQ,3287
+schubmult/scripts/schubmult_q_double.py,sha256=SANQEvlA5XJUWUh8sd_ObwMOEmct0GLSMbjDAvUTOB4,6086
+schubmult/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schubmult/utils/argparse.py,sha256=ZY85ZR-h8TOUQuzTVlvRfh07QQ032B3c649rLYZHrp8,7205
+schubmult/utils/logging.py,sha256=h-CgHSl7kPscs9VKp0WjJ4fcrtPplnJYDyrL2klPJJ4,503
+schubmult/utils/parsing.py,sha256=ygkkLqZ1KsNQBPeiF6gkEJYMwjmkqkwfGuIP0Wtawnk,599
+schubmult/utils/perm_utils.py,sha256=mf5VOwLREn_UQWMa67lOsmmwHMJClt_rjsVPIE2yE9w,2716
+schubmult/utils/test_utils.py,sha256=vEIuAkb-mFEs1gow9E76JrRbcEDvxvsTDzp4pPUoT5w,1860
+schubmult-3.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+schubmult-3.0.1.dist-info/METADATA,sha256=ZOHi7RDDLffv5Xnq9FUQfua55DxflmWoNB3O6CsjVPk,77074
+schubmult-3.0.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+schubmult-3.0.1.dist-info/entry_points.txt,sha256=9iaFSlTd5xZf52635CKaBqmgJTY_NZLkF6AMnL_T84c,240
+schubmult-3.0.1.dist-info/top_level.txt,sha256=IkujyjRu8lbpoSTdPE8DmMJ9sbyXHpo9L0RHL7nOzM0,10
+schubmult-3.0.1.dist-info/RECORD,,

{schubmult-2.0.4.dist-info → schubmult-3.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.0.2)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

schubmult-3.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+schubmult_double = schubmult.scripts.schubmult_double:main
+schubmult_py = schubmult.scripts.schubmult_py:main
+schubmult_q = schubmult.scripts.schubmult_q:main
+schubmult_q_double = schubmult.scripts.schubmult_q_double:main

schubmult/_tests.py

@@ -1,24 +0,0 @@
-
-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

schubmult/schubmult_double/__init__.py

@@ -1,12 +0,0 @@
-from ._funcs import compute_positive_rep, div_diff, mult_poly, posify, schub_coprod, schubmult, single_variable
-
-__all__ = [
-    "compute_positive_rep",
-    "div_diff",
-    "main",
-    "mult_poly",
-    "posify",
-    "schub_coprod",
-    "schubmult",
-    "single_variable",
-]

schubmult/schubmult_double/__main__.py

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

schubmult/schubmult_double/_script.py

@@ -1,474 +0,0 @@
-import sys
-from functools import cached_property
-
-import numpy as np
-import sympy
-from symengine import expand, symarray, sympify
-
-from schubmult._base_argparse import schub_argparse
-from schubmult.perm_lib import (
-    add_perm_dict,
-    code,
-    inv,
-    inverse,
-    mu_A,
-    mulperm,
-    permtrim,
-    theta,
-    trimcode,
-    uncode,
-    will_formula_work,
-)
-
-# 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)
-
-
-def _display_full(
-    coeff_dict,
-    args,
-    formatter,
-    var2,
-    var3,
-    posified=None,
-    check_coeff_dict=None,
-    kperm=None,
-    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
-    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[_vars.var1[i]] = var2[i]
-            else:
-                subs_dict[_vars.var1[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 same and display_positive:
-                    val = expand(sympify(val).subs(subs_dict2))
-
-                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)))
-                            )
-                            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)))
-                            )
-                            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()])
-        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))
-
-        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 += _vars.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:
-                        raw_result_dict[tuple(trimcode(perm))] = val
-                        if formatter:
-                            _display(f"{trimcode(perm)!s:>{width}}  {formatter(val)}")
-                    else:
-                        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
-
-    try:
-        var2 = tuple(symarray("y", 100).tolist())
-        var3 = tuple(symarray("z", 100).tolist())
-        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",
-            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
-        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:
-                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], _vars.var1, var2)
-
-            if pr or formatter is None:
-                # logger.log(logging.DEBUG, f"main {var2=}{var3=}{same=}")
-                raw_result_dict = _display_full(
-                    coeff_dict,
-                    args,
-                    formatter,
-                    posified=posified,
-                    kperm=kperm,
-                    var2=var2,
-                    var3=var3,
-                    N=N,
-                )
-            if formatter is None:
-                return raw_result_dict
-        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:
-            #         ()[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(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)
-
-            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 or formatter is None:
-                raw_result_dict = _display_full(
-                    coeff_dict,
-                    args,
-                    formatter,
-                    var2,
-                    var3,
-                    posified=posified,
-                    check_coeff_dict=check_coeff_dict,
-                )
-
-            if formatter is None:
-                return raw_result_dict
-    except BrokenPipeError:
-        pass
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

schubmult/schubmult_py/__init__.py

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

schubmult/schubmult_py/__main__.py

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

schubmult/schubmult_py/_script.py

@@ -1,97 +0,0 @@
-import sys
-
-from symengine import sympify
-
-from schubmult._base_argparse import schub_argparse
-from schubmult.perm_lib import (
-    inv,
-    inverse,
-    permtrim,
-    theta,
-    trimcode,
-    uncode,
-)
-from schubmult.schubmult_py._funcs import mult_poly, schub_coprod, schubmult
-
-
-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
-        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 = 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} {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)):
-                    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 or formatter is None:
-                for perm, val in coeff_dict.items():
-                    if val != 0:
-                        if ascode:
-                            raw_result_dict[tuple(trimcode(perm))] = val
-                            if formatter:
-                                print(f"{val}  {trimcode(perm)}")
-                        else:
-                            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__":
-    sys.exit(main(sys.argv))