schubmult 5.4.0__cp315-cp315-win_amd64.whl

schubmult/__init__.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'schubmult.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+import ast
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Dict, List
+
+# Version is managed by setuptools-scm
+try:
+    from schubmult._version import version as __version__
+except ImportError:
+    __version__ = "5.1.0"
+
+"""
+Top-level schubmult package initializer.
+
+Lazily import and re-export public classes defined in non-experimental submodules.
+Uses deferred AST scanning - only scans files when __dir__() or an unknown
+attribute is accessed for the first time.
+"""
+
+# Commonly exported helpers - only these are in __all__ initially
+_lazy_exports = {
+    # Core Schubert structures
+    "Permutation": "schubmult.combinatorics.permutation",
+    "uncode": "schubmult.combinatorics.permutation",
+    "RCGraph": "schubmult.combinatorics.rc_graph",
+    "WCGraph": "schubmult.combinatorics.wc_graph",
+    "AntiRCGraph": "schubmult.combinatorics.anti_rc_graph",
+    "BoundedRCFactorAlgebra": "schubmult.rings.combinatorial.bounded_rc_factor_algebra",
+    "BoundedWCFactorAlgebra": "schubmult.rings.combinatorial.bounded_wc_factor_algebra",
+    "ThompsonAlgebra": "schubmult.rings.thompson_algebra",
+    "ChuteMoveRing": "schubmult.rings.combinatorial.chute_move_ring",
+    "BPD": "schubmult.combinatorics.bpd",
+    "ForestRCGraphRing": "schubmult.rings.combinatorial.forest_rc_ring",
+    "TileType": "schubmult.combinatorics.bpd",
+    # Rings
+    "Gx": "schubmult.rings.schubert.grothendieck_ring",
+    "DGx": "schubmult.rings.schubert.double_grothendieck_ring",
+    "QDGx": "schubmult.rings.schubert.quantum_double_grothendieck_ring",
+    "QuantumDoubleGrothendieckRing": "schubmult.rings.schubert.quantum_double_grothendieck_ring",
+    "QuantumDoubleGrothendieckElement": "schubmult.rings.schubert.quantum_double_grothendieck_ring",
+    "GrothendieckRing": "schubmult.rings.schubert.grothendieck_ring",
+    "GrothendieckElement": "schubmult.rings.schubert.grothendieck_ring",
+    "Sx": "schubmult.rings.schubert.schubert_ring",
+    "DSx": "schubmult.rings.schubert.schubert_ring",
+    "ASx": "schubmult.rings.free_algebra",
+    "AGx": "schubmult.rings.free_algebra",
+    "ADSx": "schubmult.rings.free_algebra",
+    "FA": "schubmult.rings.free_algebra",
+    "PipeDream": "schubmult.combinatorics.pipe_dream",
+    "IncreasingTableau": "schubmult.combinatorics.increasing_tableau",
+    "SetValuedTableau": "schubmult.combinatorics.set_valued_tableau",
+    "DualRCGraphRing": "schubmult.rings.combinatorial.dual_rc_graph_ring",
+    "ForestDual": "schubmult.rings.free_algebra.forest_basis",
+    "ForestBasis": "schubmult.rings.free_algebra.forest_basis",
+    "DoubleSchubertRing": "schubmult.rings.schubert.schubert_ring",
+    "SingleSchubertRing": "schubmult.rings.schubert.schubert_ring",
+    "DoubleSchubertElement": "schubmult.rings.schubert.schubert_ring",
+    "QSym": "schubmult.rings.quasisymmetric_functions",
+    "QSymElement": "schubmult.rings.quasisymmetric_functions",
+    "RCGraphRing": "schubmult.rings.combinatorial.rc_graph_ring",
+    "GrassRCGraphRing": "schubmult.rings.combinatorial.rc_graph_ring",
+    "GrassTensorAlgebra": "schubmult.rings.combinatorial.grass_tensor_algebra",
+    "GrassTensorAlgebraElement": "schubmult.rings.combinatorial.grass_tensor_algebra",
+    "RCGraphRingElement": "schubmult.rings.combinatorial.rc_graph_ring",
+    "WCGraphRing": "schubmult.rings.combinatorial.wc_graph_ring",
+    "WCGraphRingElement": "schubmult.rings.combinatorial.wc_graph_ring",
+    "EGPlacticRing": "schubmult.rings.combinatorial.eg_plactic_ring",
+    "EGPlacticRingElement": "schubmult.rings.combinatorial.eg_plactic_ring",
+    "BPDRing": "schubmult.rings.combinatorial.bpd_ring",
+    "BPDRingElement": "schubmult.rings.combinatorial.bpd_ring",
+    "CrystalGraphTensor": "schubmult.combinatorics.crystal_graph",
+    "SchubertMonomialRing": "schubmult.rings.combinatorial.schubert_monomial_ring",
+    "SchubertMonomialRingElement": "schubmult.rings.combinatorial.schubert_monomial_ring",
+    "PlacticAlgebra": "schubmult.rings.combinatorial.plactic_algebra",
+    "PlacticAlgebraElement": "schubmult.rings.combinatorial.plactic_algebra",
+    "FreeAlgebra": "schubmult.rings.free_algebra",
+    "NSym": "schubmult.rings.nsym",
+    "NilHeckeRing": "schubmult.rings.schubert.nil_hecke",
+    "PolynomialAlgebra": "schubmult.rings.polynomial_algebra",
+    "TensorRing": "schubmult.rings.tensor_ring",
+    "DirectProductRing": "schubmult.rings.direct_product_ring",
+    "DirectProductRingElement": "schubmult.rings.direct_product_ring",
+    "BaseRing": "schubmult.rings.base_ring",
+    "BaseRingElement": "schubmult.rings.base_ring",
+    # Variables
+    "GeneratingSet": "schubmult.symbolic.poly.variables",
+    "ChangeOfVariables": "schubmult.symbolic.poly.variables",
+    "pull_out_var": "schubmult.utils.schub_lib",
+    # Crystal structures
+    "Plactic": "schubmult.combinatorics.plactic",
+    "NilPlactic": "schubmult.combinatorics.nilplactic",
+    "NilPlacticAlgebra": "schubmult.rings.combinatorial.plactic_algebra",
+    # Free algebra bases
+    "FreeAlgebraBasis": "schubmult.rings.free_algebra",
+    "WordBasis": "schubmult.rings.free_algebra",
+    "JBasis": "schubmult.rings.free_algebra",
+    "JTBasis": "schubmult.rings.free_algebra",
+    "SchubertBasis": "schubmult.rings.free_algebra",
+    "CompositionSchubertBasis": "schubmult.rings.free_algebra",
+    "SchubertSchurBasis": "schubmult.rings.free_algebra",
+    "ElementaryBasis": "schubmult.rings.free_algebra",
+    "NElementaryBasis": "schubmult.rings.free_algebra",
+    "GrothendieckBasis": "schubmult.rings.free_algebra",
+    "ZBasis": "schubmult.rings.free_algebra",
+}
+
+__all__: List[str] = list(_lazy_exports.keys())
+
+# Cache for lazy discovery - populated on first access
+_module_map: Dict[str, str] = {}
+_scanned = False
+_package_root = Path(__file__).resolve().parent
+
+_package_root = Path(__file__).resolve().parent
+
+def _scan_modules():
+    """Deferred AST scan - only called when needed"""
+    global _scanned  # noqa: PLW0603
+    if _scanned:
+        return
+    _scanned = True
+
+    _skipped_dirs = {"__pycache__", "tests", "docs", "scripts", "build", "_scripts"}
+    experimental_root = _package_root / "combinatorics" / "experimental"
+
+    for py in _package_root.rglob("*.py"):
+        if py.samefile(Path(__file__)):
+            continue
+        if experimental_root in py.parents:
+            continue
+        if any(part in _skipped_dirs for part in py.parts):
+            continue
+        if py.stem.startswith("_") and py.stem != "__init__":
+            continue  # private modules (e.g. mult._accel) may deliberately reuse public names
+        try:
+            rel = py.relative_to(_package_root.parent)
+        except Exception:
+            continue
+        modname = ".".join(rel.with_suffix("").parts)
+
+        try:
+            src = py.read_text(encoding="utf8")
+            tree = ast.parse(src)
+        except Exception:
+            continue
+
+        for node in tree.body:
+            if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+                name = node.name
+                if not name.startswith("_") and name not in _module_map:
+                    _module_map[name] = modname
+            elif isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        name = target.id
+                        if not name.startswith("_") and name not in _module_map:
+                            _module_map[name] = modname
+
+def __getattr__(name: str):
+    """
+    Lazy import exported names. This allows `import schubmult` to succeed
+    even if some optional dependencies are missing.
+    """
+    if name in globals():
+        return globals()[name]
+
+    # Known lazy exports - try these first without scanning
+    if name in _lazy_exports:
+        try:
+            mod = importlib.import_module(_lazy_exports[name])
+            val = getattr(mod, name)
+            globals()[name] = val
+            return val
+        except Exception as e:
+            raise AttributeError(f"cannot import {name!r} from {_lazy_exports[name]!r}: {e}") from e
+
+    # Submodules (e.g. ``from schubmult import schubmult_cpp``) must not trigger the slow scan
+    if importlib.util.find_spec(f"{__name__}.{name}") is not None:
+        return importlib.import_module(f"{__name__}.{name}")
+
+    # Not in known exports - scan modules if we haven't yet
+    _scan_modules()
+
+    if name in _module_map:
+        modname = _module_map[name]
+        try:
+            mod = importlib.import_module(modname)
+            val = getattr(mod, name)
+            globals()[name] = val
+            return val
+        except Exception as e:
+            # If the failing module lives under schubmult._scripts, be lenient:
+            # warn the user but return a lightweight proxy that raises a clear
+            # error when used. This lets `import schubmult` succeed while still
+            # giving a helpful message if the script is actually executed.
+            if modname.startswith(__name__ + "._scripts"):
+                def _broken_callable(*_, _name=name, _mod=modname, _err=e, **__):
+                    raise RuntimeError(
+                        f"attempted to use {_name!r} from {_mod!r} but importing the module failed: {_err!r}",
+                    )
+
+                # attach some attributes to help introspection / debugging
+                broken = _broken_callable
+                broken.__name__ = f"broken_{name}"
+                broken.__doc__ = f"Placeholder for {name} from {modname}; import failed: {e!r}"
+                globals()[name] = broken
+                return broken
+
+            # otherwise behave as before
+            raise AttributeError(f"cannot import {name!r} from {_module_map[name]!r}: {e}") from e
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__():
+    """Include lazily-exported names in dir()"""
+    _scan_modules()  # Ensure we have full module map
+    return sorted(set(list(globals().keys()) + list(_lazy_exports.keys()) + list(_module_map.keys())))

schubmult/_scripts/__init__.py

@@ -0,0 +1,7 @@
+"""Console and helper scripts shipped with schubmult."""
+
+import os
+
+# The CLI never does BLAS work; spinning up numpy's thread pool at import costs ~80 ms wall.
+for _var in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
+    os.environ.setdefault(_var, "1")

schubmult/_scripts/grothmult_double.py

@@ -0,0 +1,396 @@
+"""``grothmult_double`` console script: products of double Grothendieck polynomials.
+
+Example:
+    grothmult_double 3 1 2 - 2 1 3 --display-positive
+    grothmult_double --code 2 0 - 1 0 --mixed-var
+"""
+
+import sys
+
+from schubmult import Gx, Permutation, uncode
+from schubmult.abc import beta
+from schubmult.mult.groth_double import grothmult_double, mult_poly_groth_double, normalize_coeff
+from schubmult.symbolic import S, sympify, sympify_sympy, expand
+from schubmult.utils.argparse import grothendieck_cli_variables, schub_argparse
+from schubmult.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+_posify_cache = {}
+
+# graceful failure ceiling: candidate enumeration and the LP grow combinatorially,
+# and unbounded growth has OOM-killed the whole machine before
+_MAX_CANDIDATES = 1_000_000
+
+
+def _limit_memory():
+    """Cap this process's address space so runaway cases die with MemoryError
+    instead of taking down the host (WSL is especially fragile under OOM).
+    No-op where ``resource`` is unavailable (Windows)."""
+    try:
+        import resource
+
+        import psutil
+
+        cap = max(int(psutil.virtual_memory().available * 0.7), 1024**3)
+        soft, hard = resource.getrlimit(resource.RLIMIT_AS)
+        if soft == resource.RLIM_INFINITY or soft > cap:
+            resource.setrlimit(resource.RLIMIT_AS, (cap, hard))
+    except Exception:  # noqa: BLE001
+        logger.debug("could not set memory limit", exc_info=True)
+
+
+def _solver(msg):
+    import pulp as pu
+
+    if pu.HiGHS_CMD().available():
+        return pu.HiGHS_CMD(msg=msg)
+    from schubmult.mult.positivity import cbc_solver
+
+    return cbc_solver(msg)
+
+
+def _is_optimal(status):
+    """``LpProblem.solve`` returns an int status in PuLP < 4 and an ``LpSolveStats`` object in PuLP >= 4."""
+    if status is None:
+        return False
+    return int(getattr(status, "status", status)) == 1
+
+
+def _denominator_budget(den, var2):
+    """Atom multiplicities ``{y_symbol: exp}`` of a denominator ``prod (1 + beta*y_i)**e``.
+
+    Keys are symengine symbols (consistent with GeneratingSet identity).
+    """
+    from sympy import factor_list
+
+    bs = sympify_sympy(beta)
+    budget = {}
+    _, factors = factor_list(sympify_sympy(den))
+    for fac, mult in factors:
+        syms = [s for s in fac.free_symbols if s != bs]
+        if len(syms) != 1 or var2.index(syms[0]) == -1:
+            raise ValueError(f"unexpected denominator factor {fac}")
+        key = sympify(syms[0])
+        budget[key] = budget.get(key, 0) + int(mult)
+    return budget
+
+
+def groth_posify(val, var2, var3, msg):
+    """Positive FGL form of a coefficient, at ``beta = 1``.
+
+    Basis: all products of ``z_i - y_j``, ``(1 + y_j)^{-1}``, ``(1 + z_i)^{-1}``.
+    Substituting ``u_j = 1 + y_j``, ``v_i = 1 + z_i`` (so ``y = u - 1``,
+    ``z = v - 1``) turns the value into a Laurent polynomial in ``u, v``; clearing
+    the monomial denominator makes everything polynomial.  Candidates are
+    difference products times leftover clearing monomials, expanded once, with
+    ``as_coefficients_dict`` terms used as opaque basis vectors for an integer
+    LP.  ``beta`` is restored as ``beta**(#diffs - d)`` with the Laurent atoms
+    ``(1 + beta*y)`` degree 0 by construction.
+    """
+    import itertools
+
+    import pulp as pu
+    from symengine import Symbol as SySymbol
+
+    from schubmult.symbolic import efficient_subs
+
+    try:
+        return int(val)
+    except Exception:
+        pass
+    bs = sympify(beta)
+    e = sympify(val)
+
+    # homogeneous degree: yz-degree minus beta-degree is constant across terms
+    num0 = expand(sympify(sympify_sympy(e).as_numer_denom()[0]))
+    t0 = next(mono for mono, c in num0.as_coefficients_dict().items() if c != 0)
+    t0d = t0.as_powers_dict()
+    d = sum(int(p) for g, p in t0d.items() if g.is_Symbol and sympify(g) != bs) - int(t0d.get(bs, 0))
+
+    e1 = expand(efficient_subs(e, {bs: S.One}))
+    frees = e1.free_symbols
+    ysyms = sorted([s for s in frees if var2.index(s) != -1], key=lambda s: var2.index(s))
+    zsyms = sorted([s for s in frees if var3.index(s) != -1], key=lambda s: var3.index(s))
+
+    uu = {ys: SySymbol(f"u_{var2.index(ys)}") for ys in ysyms}
+    vv = {zs: SySymbol(f"v_{var3.index(zs)}") for zs in zsyms}
+    back = {u: S.One + bs * sympify(ys) for ys, u in uu.items()}
+    back.update({v: S.One + bs * sympify(zs) for zs, v in vv.items()})
+
+    fwd = {sympify(ys): uu[ys] - S.One for ys in ysyms}
+    fwd.update({sympify(zs): vv[zs] - S.One for zs in zsyms})
+    laurent = expand(e1.subs(fwd))
+
+    # clear the (monomial) denominator structurally; everything is a polynomial
+    # in u, v from here on and terms are opaque basis vectors
+    num_l, den_l = laurent.as_numer_denom()
+    num_l = expand(num_l)
+    caps = {g: int(p) for g, p in den_l.as_powers_dict().items() if g != S.One and int(p) != 0}
+
+    # packed-int monomial representation over the u, v generators: PBITS bits
+    # of exponent per generator, so monomial products are plain integer sums
+    PBITS = 10
+    gens = [*[uu[ys] for ys in ysyms], *[vv[zs] for zs in zsyms]]
+    gshift = {g: PBITS * i for i, g in enumerate(gens)}
+
+    def to_vec(expr):
+        vec = {}
+        degs = {}
+        for mono, c in expr.as_coefficients_dict().items():
+            if c == 0:
+                continue
+            key = 0
+            deg = 0
+            for g, p in mono.as_powers_dict().items():
+                if g in gshift:
+                    key += int(p) << gshift[g]
+                    deg += int(p)
+                elif g != S.One:
+                    raise ValueError(f"unexpected generator {g}")
+            vec[key] = vec.get(key, 0) + int(c)
+            degs[key] = deg
+        return vec, degs
+
+    def dict_mul(a, b):
+        out = {}
+        for m1, c1 in a.items():
+            for m2, c2 in b.items():
+                k = m1 + m2
+                cc = out.get(k, 0) + c1 * c2
+                if cc:
+                    out[k] = cc
+                elif k in out:
+                    del out[k]
+        return out
+
+    vec0, deg0 = to_vec(num_l)
+    max_m = max(deg0.values(), default=0)
+    # candidates are homogeneous of total degree #pairs + clearing-shift degree,
+    # so degrees absent from the target can be pruned losslessly
+    target_degs = frozenset(deg0.values())
+
+    # construction state is shared across coefficients: difference products
+    # depend only on the generators, levels also on caps and target degrees;
+    # both are built lazily on demand
+    gens_key = (tuple(str(s) for s in ysyms), tuple(str(s) for s in zsyms))
+    prods_state = _posify_cache.get(gens_key)
+    if prods_state is None:
+        # difference products built incrementally: each level multiplies by one
+        # 2-term pair vector (integer convolution, no symbolic expand)
+        pair_vecs = [({1 << gshift[vv[zs]]: 1, 1 << gshift[uu[ys]]: -1}, (ys, zs)) for ys in ysyms for zs in zsyms]
+        prods_state = {"pair_vecs": pair_vecs, "prods": [[({0: 1}, (), 0)]]}
+        _posify_cache[gens_key] = prods_state
+
+    cache_key = (gens_key, tuple(sorted((str(g), p) for g, p in caps.items())), target_degs)
+    state = _posify_cache.get(cache_key)
+    if state is None:
+        # clearing monomials as precomputed packed shifts with their degrees
+        usage_shifts = []
+        for usage in itertools.product(*[range(caps[g] + 1) for g in caps]):
+            shift = 0
+            sdeg = 0
+            for g, a in zip(caps, usage):
+                shift += (caps[g] - a) << gshift[g]
+                sdeg += caps[g] - a
+            usage_shifts.append((shift, dict(zip(caps, usage)), sdeg))
+        state = {"usage_shifts": usage_shifts, "levels": {}}
+        _posify_cache[cache_key] = state
+
+    def get_level(m):
+        if m in state["levels"]:
+            return state["levels"][m]
+        prods = prods_state["prods"]
+        pair_vecs = prods_state["pair_vecs"]
+        shifts = [(shift, usage) for shift, usage, sdeg in state["usage_shifts"] if m + sdeg in target_degs]
+        lev = []
+        if shifts:
+            while len(prods) <= m:
+                cur = []
+                for vec, combo, start in prods[-1]:
+                    for idx in range(start, len(pair_vecs)):
+                        pv, pair = pair_vecs[idx]
+                        cur.append((dict_mul(vec, pv), (*combo, pair), idx))
+                prods.append(cur)
+            for vec, combo, _ in prods[m]:
+                for shift, usage in shifts:
+                    lev.append(({k + shift: c for k, c in vec.items()}, combo, usage, m))
+        state["levels"][m] = lev
+        return lev
+
+    def solve(candidates):
+        lp_prob = pu.LpProblem("Problem", pu.LpMinimize)
+        vrs = [lp_prob.add_variable(f"a{i}", lowBound=0, cat="Integer") for i in range(len(candidates))]
+        lp_prob += 0
+        eqs = {}
+        for i, (svec, _, _, _) in enumerate(candidates):
+            for k, c in svec.items():
+                eqs.setdefault(k, {})[vrs[i]] = c
+        for k in set(eqs) | set(vec0):
+            # lpSum rather than LpAffineExpression(dict): the latter cannot form constraints in PuLP >= 4
+            lp_prob += pu.lpSum(c * v for v, c in eqs.get(k, {}).items()) == vec0.get(k, 0)
+        try:
+            status = lp_prob.solve(_solver(msg))
+        except KeyboardInterrupt:
+            import psutil
+
+            current_process = psutil.Process()
+            for child in current_process.children(recursive=True):
+                child_process = psutil.Process(child.pid)
+                child_process.terminate()
+                child_process.kill()
+            raise
+        # read values here: in PuLP >= 4 variables become unusable once lp_prob is garbage collected
+        return status, [v.value() for v in vrs]
+
+    # escalate the factor-count ceiling: small LPs solve fast and usually suffice
+    candidates = []
+    status = None
+    for m in range(max(d, 0), max_m + 1):
+        lev = get_level(m)
+        if not lev:
+            continue
+        candidates = [*candidates, *lev]
+        if len(candidates) > _MAX_CANDIDATES:
+            raise ValueError(f"candidate set too large ({len(candidates)}) for {val}")
+        print(f"  solving level m={m}: {len(candidates)} candidates", file=sys.stderr)
+        status, values = solve(candidates)
+        if _is_optimal(status):
+            break
+    if not _is_optimal(status):
+        raise ValueError(f"no positive representation found for {val}")
+
+    result = S.Zero
+    for i, (_, combo, usage, m) in enumerate(candidates):
+        x = values[i]
+        # round, don't truncate: solvers return near-integers like 0.9999999999996
+        xi = 0 if x is None else round(x)
+        if xi != 0:
+            term = S.One
+            for ys, zs in combo:
+                term = term * (sympify(zs) - sympify(ys))
+            for g, a in usage.items():
+                if a:
+                    term = term / back[g] ** a
+            result += xi * bs ** (m - d) * term
+    # exact symbolic verification: structural numerator of the difference
+    diff_num, _ = sympify_sympy(result - e).as_numer_denom()
+    if expand(sympify(diff_num)) != S.Zero:
+        raise ValueError(f"positive representation check failed for {val}: got {result}")
+    return result
+
+
+def main(argv=None):
+    """Entry point for the ``grothmult_double`` console script.
+
+    Parses permutations (or, with ``--code``, Lehmer codes) from ``argv``, multiplies
+    their double Grothendieck polynomials via `schubmult.mult.groth_double.grothmult_double`,
+    and prints the resulting coefficient dictionary ``{Permutation: coefficient}`` in the
+    ``y``/``z`` coefficient variables and the K-theory parameter ``beta``. With
+    ``--multiplicative-variables``, use ``beta=-1`` and ``1-1/y_i`` coefficient
+    coordinates (also ``1-1/z_i`` for mixed variables). With
+    ``--display-positive`` (only supported together with ``--mixed-var``), coefficients
+    are rewritten in the positive FGL basis of ``z_i - y_j``, ``(1 + y_j)^{-1}``, and
+    ``(1 + z_i)^{-1}`` via an integer program (see `groth_posify`). Returns the raw
+    result dict when the caller passes a ``None`` formatter (e.g. from tests); otherwise
+    prints and returns ``None``.
+    """
+    if argv is None:
+        argv = sys.argv
+
+    try:
+        sys.setrecursionlimit(1000000)
+
+        args, formatter = schub_argparse(
+            "grothmult_double",
+            "Compute coefficients of products of double Grothendieck polynomials in the same or different sets of coefficient variables",
+            argv=argv[1:],
+            yz=True,
+            coprod=False,
+        )
+
+        if args.display_positive and args.same:
+            print("--display-positive is only supported with --mixed-var for grothmult_double")
+            return 1
+
+        if args.display_positive:
+            _limit_memory()
+
+        mult = args.mult
+        mulstring = args.mulstring
+
+        perms = args.perms
+
+        ascode = args.ascode
+        Permutation.print_as_code = ascode
+        pr = args.pr
+        beta_value = sympify(args.beta) if args.beta is not None else Gx._beta
+
+        var2, var3 = grothendieck_cli_variables(args)
+
+        if ascode:
+            perms = [uncode(perm) for perm in perms]
+        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])
+
+        coeff_dict = {perms[0]: 1}
+
+        for perm in perms[1:]:
+            coeff_dict = grothmult_double(coeff_dict, perm, var2, var3, beta=beta_value)
+
+        if mult:
+            mul_exp = sympify(mulstring)
+            coeff_dict = mult_poly_groth_double(coeff_dict, mul_exp, var2, var3, beta=beta_value)
+
+        if args.simplify and not args.display_positive:
+            if args.multiplicative_variables:
+                coeff_dict = {perm: sympify(sympify_sympy(val).cancel()) for perm, val in coeff_dict.items()}
+            else:
+                coeff_dict = {perm: normalize_coeff(val, var2, beta=beta_value) if beta_value != 0 else expand(val) for perm, val in coeff_dict.items()}
+
+        positive_coeff_dict = coeff_dict
+        if args.display_positive and args.beta is not None:
+            # The positivity solver needs the symbolic beta grading before specialization.
+            positive_coeff_dict = {perms[0]: 1}
+            for perm in perms[1:]:
+                positive_coeff_dict = grothmult_double(positive_coeff_dict, perm, var2, var3, beta=Gx._beta)
+            if mult:
+                positive_coeff_dict = mult_poly_groth_double(positive_coeff_dict, mul_exp, var2, var3, beta=Gx._beta)
+
+        # sort/filter up front so posified coefficients can stream out as each
+        # one finishes (the LPs can take a long time); structural zero test only
+        coeff_perms = [perm for perm, val in coeff_dict.items() if val != S.Zero]
+        coeff_perms.sort(key=lambda x: (-abs(perms[0].inv + perms[1].inv - x.inv), *x))
+        width = max([len(str(perm)) for perm in coeff_perms]) if coeff_perms else 0
+
+        raw_result_dict = {}
+        for i, perm in enumerate(coeff_perms):
+            val = coeff_dict[perm]
+            if args.display_positive:
+                print(f"posify {i + 1}/{len(coeff_perms)}: {str(perm)}", file=sys.stderr)
+                try:
+                    # groth_posify verifies its own output exactly
+                    val = groth_posify(positive_coeff_dict[perm], var2, var3, args.msg)
+                    if args.beta is not None:
+                        val = sympify(val).subs(Gx._beta, beta_value)
+                except Exception:
+                    import traceback
+
+                    traceback.print_exc()
+                    print(f"error; write to schubmult@gmail.com with the case {perms=} {perm=} {val=}")
+                    return 1
+            raw_result_dict[perm] = val
+            if pr and formatter:
+                print(f"{str(perm)!s:>{width}}  {formatter(val)}", flush=True)
+
+        if formatter is None:
+            return raw_result_dict
+    except BrokenPipeError:
+        pass
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))