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

schubmult-3.0.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+schubmult/__init__.py,sha256=XOa382I_9HvYUwbuz8dEAoDptLnzbLzZcL5A2TiCIos,2363
+schubmult/perm_lib.py,sha256=h_phdUoIMZn66C4CIWSqalHWC0t7ofgPswDrKzd2Sho,9509
+schubmult/poly_lib/__init__.py,sha256=DUA70oCWv64lqhezrpKgA6813Dp5LTM1bkMrpOoqjTU,674
+schubmult/poly_lib/poly_lib.py,sha256=ymFvBNu7rxDMvaAo2_ts4ikixzykAilUbbyJZbTuYB8,6946
+schubmult/poly_lib/schub_poly.py,sha256=_GXApXSbmlF0neSZOY9fCFXxSmYJEoHv_PvJJzIhy5E,4586
+schubmult/poly_lib/variables.py,sha256=cnR9Kvzbh7LA0Mvi292h2eMW7d3s2GU9DKvP3M44HNE,6005
+schubmult/rings/__init__.py,sha256=vRaxEBgeT7OtvOOzOTvZffHBRdopVkouTVyklAOg8l0,612
+schubmult/rings/_quantum_schubert_polynomial_ring.py,sha256=Gy11WD4v9V5lcYhYsoU4lf-wPS-UZ3kyfyxjKLt7X4I,28031
+schubmult/rings/_schubert_polynomial_ring.py,sha256=D0Uo8J2BJGZrDWaXHbrC02FAbuYtssVofNkWoMMCYdU,37969
+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=Up9wSqZ6A5u5Ze3sznp3vEA8uktepVSpSdVjw5X_RZE,36770
+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=35jg_AtQuue9HuJB7RN_D7YwMOzrcJkrriNAHKiNJh8,7175
+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.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+schubmult-3.0.0.dist-info/METADATA,sha256=f9ofBquNwvAKOQ8zCIN1-y-Hj8EErdBgKAGBnoF7Gfg,77074
+schubmult-3.0.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+schubmult-3.0.0.dist-info/entry_points.txt,sha256=9iaFSlTd5xZf52635CKaBqmgJTY_NZLkF6AMnL_T84c,240
+schubmult-3.0.0.dist-info/top_level.txt,sha256=IkujyjRu8lbpoSTdPE8DmMJ9sbyXHpo9L0RHL7nOzM0,10
+schubmult-3.0.0.dist-info/RECORD,,

{schubmult-2.0.3.dist-info → schubmult-3.0.0.dist-info}/WHEEL

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

schubmult-3.0.0.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,9 +0,0 @@
-def get_json(file: str):
-    import os
-    import json
-
-    script_dir = os.path.dirname(__file__)
-    rel_path = f"../tests/{file}.json"
-    abs_file_path = os.path.join(script_dir, rel_path)
-    with open(abs_file_path, "r") as f:
-        return json.load(f)

schubmult/sage_integration/_indexing.py

@@ -1,51 +0,0 @@
-from sage.combinat.permutation import Permutation
-
-from sage.combinat.composition import Composition
-
-from schubmult.perm_lib import uncode, trimcode, permtrim
-
-
-def _coerce_index(indexed_obj, is_comp, should_be_comp):
-    if is_comp == should_be_comp:
-        if isinstance(indexed_obj, list) or isinstance(indexed_obj, tuple):
-            if is_comp:
-                return Composition(trimcode(permtrim(uncode(list(indexed_obj)))))
-            else:
-                return Permutation(permtrim(list(indexed_obj))).remove_extra_fixed_points()
-        else:
-            if not is_comp:
-                if isinstance(indexed_obj, Permutation):
-                    return indexed_obj.remove_extra_fixed_points()
-                elif isinstance(indexed_obj, dict):
-                    {
-                    Permutation(permtrim(list(k))).remove_extra_fixed_points(): v
-                    for k, v in indexed_obj.items()
-                }
-    else:
-        if is_comp:
-            if (
-                isinstance(indexed_obj, list)
-                or isinstance(indexed_obj, tuple)
-                or isinstance(indexed_obj, Composition)
-            ):
-                return Permutation(permtrim(uncode(list(indexed_obj)))).remove_extra_fixed_points()
-
-            if isinstance(indexed_obj, dict):  # keys are comps
-                return {
-                    Permutation(permtrim(uncode(list(k)))).remove_extra_fixed_points(): v
-                    for k, v in indexed_obj.items()
-                }
-        else:
-            if (
-                isinstance(indexed_obj, list)
-                or isinstance(indexed_obj, tuple)
-                or isinstance(indexed_obj, Permutation)
-            ):
-                return Composition(trimcode(list(indexed_obj)))
-
-            if isinstance(indexed_obj, dict):  # keys are comps
-                return {
-                    Composition(trimcode(permtrim(list(k)))): v
-                    for k, v in indexed_obj.items()
-                }
-    raise TypeError

schubmult/schubmult_double/__init__.py

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

schubmult/schubmult_double/__main__.py

@@ -1,5 +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 numpy as np
-import sympy
-import sys
-
-# from schubmult.schubmult_double._vars import var_x, var, var_r
-from schubmult.schubmult_double._funcs import (
-    mult_poly,
-    mult_poly_down,
-    schubmult,
-    schubmult_down,
-    compute_positive_rep,
-    posify,
-    split_perms,
-)
-from symengine import expand, sympify, symarray
-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,
-)
-
-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)
-
-
-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])
-
-        subs_dict2 = {}        
-        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).xreplace(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"{str(trimcode(perm)):>{width}}  {formatter(val)}")
-                    else:
-                        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
-        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=}")
-                return _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:
-            #         ()[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
-
-
-if __name__ == "__main__":
-    main(sys.argv)

schubmult/schubmult_py/__init__.py

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

schubmult/schubmult_py/__main__.py

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