schubmult 4.2.0__tar.gz → 5.0.0__tar.gz

{schubmult-4.2.0 → schubmult-5.0.0}/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 5.0.0
+
+The multiplication kernels are now compiled C++. This release consolidates the
+5.0.0b1 and 5.0.0b2 pre-releases.
+
+### Changed
+
+- **The Schubert multiplication kernels run in a C++ extension (`schubmult.schubmult_cpp`).**
+  `schubmult_py`, `schubmult_double`, `schubmult_q_fast`, `schubmult_q_double_fast`,
+  `schubmult_double_from_elems` and `schubmult_double_alt_from_elems` — and therefore
+  every ring product built on them — dispatch to ports of the same algorithms in `cpp/`.
+  Results are identical to the Python kernels (coefficients are still unexpanded symengine
+  expressions); typical products are one to two orders of magnitude faster. The Python
+  kernels remain as the fallback for permutations beyond the compiled size limit
+  (`MAXN`, default 32). `SCHUBMULT_NO_CPP=1` forces the Python kernels.
+- **Binary wheels for Linux, macOS and Windows** (CPython 3.10–3.14). The extension uses
+  only the Python C API — coefficients are handled as `symengine` Python objects — so it
+  has no SymEngine C++ dependency and builds from source with any C++17 compiler.
+- Ring products no longer re-scan every coefficient's `free_symbols` when assembling the
+  result, and products are computed directly in the ring's variables instead of in generic
+  variables followed by a substitution pass.
+- `requires-python` is now `>=3.10` (3.9 was declared but never supported).
+- The PuLP requirement is `PuLP>=2.7.0,<4`. The PuLP 4 pre-releases are a rewrite with an
+  incompatible API (no `LpVariable(name=...)`, no bundled CBC) and broke `--display-positive`.
+
+### Added
+
+- Standalone C++ command-line tools in `cpp/` (`schubmult_core`, `schubmult_double_core`,
+  `schubmult_q_core`, `schubmult_q_double_core`) mirroring the CLI scripts, including
+  `--display-positive` for the double kernel (MILP via `cbc`). These are development tools
+  built with `make`; they need the SymEngine C++ headers.
+
+### Fixed
+
+- The script test fixtures are located relative to the test modules, so the test suite
+  runs against a non-editable install.
+
 ## 4.2.0
 
 ### Fixed

{schubmult-4.2.0 → schubmult-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schubmult
-Version: 4.2.0
+Version: 5.0.0
 Summary: Package for algebraic computation with single, double, and quantum Schubert polynomials
 Author-email: Matt Samuel <schubmult@gmail.com>
 Maintainer-email: Matt Samuel <schubmult@gmail.com>
@@ -683,13 +683,21 @@ Project-URL: Homepage, http://schubmult.org
 Project-URL: Repository, https://github.com/matthematics/schubmult
 Keywords: Schubert,polynomial,double,algebra
 Classifier: Programming Language :: Python
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: joblib
 Requires-Dist: latex2sympy2_extended
-Requires-Dist: PuLP>=2.7.0
+Requires-Dist: PuLP<4,>=2.7.0
 Requires-Dist: symengine>=0.14.1
 Requires-Dist: sympy>=1.14.0
 Requires-Dist: psutil

schubmult-5.0.0/cpp/Makefile

@@ -0,0 +1,37 @@
+CXX ?= g++
+CXXFLAGS ?= -O3 -march=native -std=c++17 -Wall -Wextra
+MAXN ?= 32
+BUILD ?= build
+
+# SymEngine C++ (for schubmult_double_core); defaults to the active conda env
+SYMENGINE_PREFIX ?= $(CONDA_PREFIX)
+SE_CXXFLAGS = -isystem $(SYMENGINE_PREFIX)/include
+SE_LDFLAGS = -L$(SYMENGINE_PREFIX)/lib -lsymengine -lflint -lgmp -Wl,-rpath,$(SYMENGINE_PREFIX)/lib
+
+BINS = $(BUILD)/schubmult_core $(BUILD)/schubmult_q_core $(BUILD)/schubmult_double_core $(BUILD)/schubmult_q_double_core
+
+all: $(BINS)
+
+$(BUILD):
+	mkdir -p $(BUILD)
+
+$(BUILD)/schubmult_core: schubmult_core.cpp schub_common.h | $(BUILD)
+	$(CXX) $(CXXFLAGS) -DMAXN=$(MAXN) -o $@ $<
+
+$(BUILD)/schubmult_q_core: schubmult_q_core.cpp schub_common.h schub_quantum.h | $(BUILD)
+	$(CXX) $(CXXFLAGS) -DMAXN=$(MAXN) -o $@ $<
+
+$(BUILD)/schubmult_double_core: schubmult_double_core.cpp schub_common.h schub_symbolic.h positivity.h | $(BUILD)
+	$(CXX) $(CXXFLAGS) -DMAXN=$(MAXN) $(SE_CXXFLAGS) -o $@ $< $(SE_LDFLAGS)
+
+$(BUILD)/schubmult_q_double_core: schubmult_q_double_core.cpp schub_common.h schub_quantum.h schub_symbolic.h | $(BUILD)
+	$(CXX) $(CXXFLAGS) -DMAXN=$(MAXN) $(SE_CXXFLAGS) -o $@ $< $(SE_LDFLAGS)
+
+clean:
+	rm -rf $(BUILD) ../build ../src/schubmult/schubmult_cpp*.so ../src/schubmult/schubmult_cpp*.pyd
+
+# Python extension: built by the package's setup.py (plain Python C API, no SymEngine C++ needed).
+python:
+	cd .. && pip install --no-build-isolation -e .
+
+.PHONY: all clean python

schubmult-5.0.0/cpp/compare.py

@@ -0,0 +1,71 @@
+"""Cross-check cpp/schubmult_core against schubmult.mult.single.schubmult_py.
+
+usage: python compare.py [n] [num_random] [seed]
+Runs all pairs in S_n for n <= 5 (else random pairs), reports mismatches and timing.
+"""
+
+import itertools
+import random
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from schubmult import Permutation, schubmult_py
+
+BIN = Path(__file__).with_name("build") / "schubmult_core"
+
+
+def run_cpp(u, v):
+    args = [str(BIN), *map(str, u), "-", *map(str, v)]
+    out = subprocess.run(args, capture_output=True, text=True, check=True).stdout
+    res = {}
+    for line in out.splitlines():
+        val, perm = line.split("  ", 1)
+        res[Permutation(eval(perm))] = int(val)
+    return res
+
+
+def run_py(u, v):
+    perms = sorted([Permutation(u), Permutation(v)], reverse=True, key=lambda x: sum((~x).theta()) - x.inv)
+    d = schubmult_py({perms[0]: 1}, perms[1])
+    return {k: val for k, val in d.items() if val != 0}
+
+
+def main():
+    n = int(sys.argv[1]) if len(sys.argv) > 1 else 5
+    num_random = int(sys.argv[2]) if len(sys.argv) > 2 else 50
+    seed = int(sys.argv[3]) if len(sys.argv) > 3 else 0
+    rng = random.Random(seed)
+    if n <= 5:
+        allp = [list(p) for p in itertools.permutations(range(1, n + 1))]
+        pairs = [(u, v) for u in allp for v in allp]
+    else:
+        pairs = []
+        for _ in range(num_random):
+            u = list(range(1, n + 1))
+            v = list(range(1, n + 1))
+            rng.shuffle(u)
+            rng.shuffle(v)
+            pairs.append((u, v))
+    bad = 0
+    t_cpp = t_py = 0.0
+    for u, v in pairs:
+        t0 = time.perf_counter()
+        a = run_cpp(u, v)
+        t1 = time.perf_counter()
+        b = run_py(u, v)
+        t2 = time.perf_counter()
+        t_cpp += t1 - t0
+        t_py += t2 - t1
+        if a != b:
+            bad += 1
+            print(f"MISMATCH u={u} v={v}")
+            for k in set(a) | set(b):
+                if a.get(k) != b.get(k):
+                    print(f"   {k}: cpp={a.get(k)} py={b.get(k)}")
+    print(f"{len(pairs)} pairs, {bad} mismatches; cpp {t_cpp:.2f}s (incl. process spawn), py {t_py:.2f}s")
+
+
+if __name__ == "__main__":
+    main()

schubmult-5.0.0/cpp/expr.h

@@ -0,0 +1,164 @@
+// expr.h: the symbolic-coefficient type used by the double / quantum-double kernels, with two
+// interchangeable backends selected at compile time:
+//
+//   default        SymEngine C++ (RCP<const Basic>) — for the standalone CLI tools.
+//   SCHUB_PYEXPR   Python objects (PyObject*) driven through the Python C API — for the
+//                  schubmult_cpp extension. Coefficients are then whatever the `symengine`
+//                  Python package hands back, so the extension needs no SymEngine C++ headers
+//                  or library and links against nothing but Python. Any Python exception is
+//                  carried as a C++ exception (PyErrorSet) to the module boundary.
+//
+// The kernels only use the small ex_* vocabulary below.
+
+#pragma once
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#ifdef SCHUB_PYEXPR
+// ---------------------------------------------------------------------------
+// Python-object backend
+// ---------------------------------------------------------------------------
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+#include <Python.h>
+
+struct PyErrorSet : std::runtime_error {
+    PyErrorSet() : std::runtime_error("Python exception") {}
+};
+
+// Owning reference to a Python object (null allowed).
+class Expr {
+    PyObject* p_ = nullptr;
+
+public:
+    Expr() = default;
+    explicit Expr(PyObject* p, bool steal = true) : p_(p) {
+        if (p_ && !steal) Py_INCREF(p_);
+    }
+    Expr(const Expr& o) : p_(o.p_) {
+        if (p_) Py_INCREF(p_);
+    }
+    Expr(Expr&& o) noexcept : p_(o.p_) { o.p_ = nullptr; }
+    Expr& operator=(Expr o) noexcept {
+        std::swap(p_, o.p_);
+        return *this;
+    }
+    ~Expr() {
+        if (p_) Py_DECREF(p_);
+    }
+    bool is_null() const { return p_ == nullptr; }
+    PyObject* get() const { return p_; }
+    PyObject* release() {
+        PyObject* r = p_;
+        p_ = nullptr;
+        return r;
+    }
+};
+
+typedef std::vector<Expr> ExprVec;
+
+namespace pyexpr_detail {
+// Result of a Python call; throws if the call failed.
+inline Expr checked(PyObject* r) {
+    if (!r) throw PyErrorSet();
+    return Expr(r);
+}
+
+struct Syms {
+    Expr add, mul, integer, symbol, sympify, zero, one;
+    Syms() {
+        Expr mod = checked(PyImport_ImportModule("symengine"));
+        add = checked(PyObject_GetAttrString(mod.get(), "Add"));
+        mul = checked(PyObject_GetAttrString(mod.get(), "Mul"));
+        integer = checked(PyObject_GetAttrString(mod.get(), "Integer"));
+        symbol = checked(PyObject_GetAttrString(mod.get(), "Symbol"));
+        sympify = checked(PyObject_GetAttrString(mod.get(), "sympify"));
+        zero = checked(PyObject_CallFunction(integer.get(), "i", 0));
+        one = checked(PyObject_CallFunction(integer.get(), "i", 1));
+    }
+};
+// Heap-allocated and never freed: a static object's destructor would Py_DECREF after the
+// interpreter has finalized.
+inline Syms& syms() {
+    static Syms* s = new Syms();
+    return *s;
+}
+
+inline Expr call_star(const Expr& f, const ExprVec& args) {
+    Expr tup = checked(PyTuple_New((Py_ssize_t)args.size()));
+    for (size_t i = 0; i < args.size(); ++i) {
+        Py_INCREF(args[i].get());
+        PyTuple_SET_ITEM(tup.get(), (Py_ssize_t)i, args[i].get());
+    }
+    return checked(PyObject_CallObject(f.get(), tup.get()));
+}
+}  // namespace pyexpr_detail
+
+inline Expr ex_zero() { return pyexpr_detail::syms().zero; }
+inline Expr ex_one() { return pyexpr_detail::syms().one; }
+inline Expr ex_integer(long n) { return pyexpr_detail::checked(PyObject_CallFunction(pyexpr_detail::syms().integer.get(), "l", n)); }
+inline Expr ex_symbol(const std::string& name) { return pyexpr_detail::checked(PyObject_CallFunction(pyexpr_detail::syms().symbol.get(), "s", name.c_str())); }
+inline Expr ex_add(const Expr& a, const Expr& b) { return pyexpr_detail::checked(PyNumber_Add(a.get(), b.get())); }
+inline Expr ex_sub(const Expr& a, const Expr& b) { return pyexpr_detail::checked(PyNumber_Subtract(a.get(), b.get())); }
+inline Expr ex_mul(const Expr& a, const Expr& b) { return pyexpr_detail::checked(PyNumber_Multiply(a.get(), b.get())); }
+inline Expr ex_neg(const Expr& a) { return pyexpr_detail::checked(PyNumber_Negative(a.get())); }
+inline Expr ex_pow(const Expr& a, int n) {
+    Expr e = ex_integer(n);
+    return pyexpr_detail::checked(PyNumber_Power(a.get(), e.get(), Py_None));
+}
+inline Expr ex_add(const ExprVec& v) {
+    if (v.empty()) return ex_zero();
+    if (v.size() == 1) return v[0];
+    return pyexpr_detail::call_star(pyexpr_detail::syms().add, v);
+}
+inline Expr ex_mul(const ExprVec& v) {
+    if (v.empty()) return ex_one();
+    if (v.size() == 1) return v[0];
+    return pyexpr_detail::call_star(pyexpr_detail::syms().mul, v);
+}
+inline bool ex_is_zero(const Expr& e) {
+    int r = PyObject_RichCompareBool(e.get(), pyexpr_detail::syms().zero.get(), Py_EQ);
+    if (r < 0) throw PyErrorSet();
+    return r == 1;
+}
+inline Expr ex_sympify(const Expr& e) { return pyexpr_detail::checked(PyObject_CallFunctionObjArgs(pyexpr_detail::syms().sympify.get(), e.get(), nullptr)); }
+inline std::string ex_str(const Expr& e) {
+    Expr s = pyexpr_detail::checked(PyObject_Str(e.get()));
+    const char* c = PyUnicode_AsUTF8(s.get());
+    if (!c) throw PyErrorSet();
+    return c;
+}
+
+#else
+// ---------------------------------------------------------------------------
+// SymEngine C++ backend
+// ---------------------------------------------------------------------------
+#include <symengine/add.h>
+#include <symengine/basic.h>
+#include <symengine/constants.h>
+#include <symengine/integer.h>
+#include <symengine/mul.h>
+#include <symengine/pow.h>
+#include <symengine/printers.h>
+#include <symengine/symbol.h>
+
+typedef SymEngine::RCP<const SymEngine::Basic> Expr;
+typedef SymEngine::vec_basic ExprVec;
+
+inline Expr ex_zero() { return SymEngine::zero; }
+inline Expr ex_one() { return SymEngine::one; }
+inline Expr ex_integer(long n) { return SymEngine::integer(n); }
+inline Expr ex_symbol(const std::string& name) { return SymEngine::symbol(name); }
+inline Expr ex_add(const Expr& a, const Expr& b) { return SymEngine::add(a, b); }
+inline Expr ex_sub(const Expr& a, const Expr& b) { return SymEngine::sub(a, b); }
+inline Expr ex_mul(const Expr& a, const Expr& b) { return SymEngine::mul(a, b); }
+inline Expr ex_neg(const Expr& a) { return SymEngine::neg(a); }
+inline Expr ex_pow(const Expr& a, int n) { return SymEngine::pow(a, SymEngine::integer(n)); }
+inline Expr ex_add(const ExprVec& v) { return SymEngine::add(v); }
+inline Expr ex_mul(const ExprVec& v) { return SymEngine::mul(v); }
+inline bool ex_is_zero(const Expr& e) { return SymEngine::eq(*e, *SymEngine::zero); }
+inline std::string ex_str(const Expr& e) { return e->__str__(); }
+#endif

schubmult-5.0.0/cpp/kernel_double.h

@@ -0,0 +1,131 @@
+// kernel_double.h: C++ port of schubmult_double (library form; the CLI lives in schubmult_double_core.cpp).
+
+#pragma once
+
+#include "schub_symbolic.h"
+
+// ---------------------------------------------------------------------------
+// schubmult_double
+// ---------------------------------------------------------------------------
+
+#ifndef SCHUB_EXPRDICT
+#define SCHUB_EXPRDICT
+typedef std::vector<std::pair<Perm, Expr>> ExprDict;
+#endif
+
+static ExprDict schubmult_double(const ExprDict& perm_dict, const Perm& v, int n, ElemSymCache& esc) {
+    MultSetup S = mult_setup(v);
+    if (S.trivial) return perm_dict;
+    const VPaths& vp = S.vp;
+    const std::vector<int>& th = S.th;
+    int thL = (int)th.size();
+    if (vp.id_start == UINT32_MAX) return {};
+    uint32_t id_vmu = 0;  // level[thL] == {vmu}
+
+    ZIdx zidx = compute_zidx(vp);
+
+    // Each sum entry holds the pending terms; at the end of a level they are summed
+    // (SymEngine's Add merges like terms at the top level, as Python's + does) and
+    // structurally zero entries are dropped. Nothing is ever expanded.
+    typedef PermTable<ExprVec> Table;
+    typedef Table::VSum VSum;
+    std::unordered_map<Perm, ExprVec, PermHash> result;
+
+    Table tabA, tabB;
+    Table* A = &tabA;
+    Table* B = &tabB;
+
+    std::vector<std::pair<Perm, int>> newperms;
+    std::vector<int> yidx;
+
+    for (const auto& kv : perm_dict) {
+        const Perm& u = kv.first;
+        if (is_zero(kv.second)) continue;
+        int inv_u = perm_inv(u, n);
+
+        A->reset();
+        A->sums[A->intern(u, inv_u)].push_back({vp.id_start, ExprVec{kv.second}});
+
+        for (int index = 0; index < thL; ++index) {
+            int k = th[index];
+            const auto& trans = vp.trans[index];
+#ifdef STATS
+            double t0 = now_s();
+            size_t n_terms = 0;
+#endif
+            B->reset();
+
+            for (uint32_t sid = 0; sid < A->count; ++sid) {
+                const std::vector<VSum>& sums = A->sums[sid];
+                if (sums.empty()) continue;
+                const Perm& up = A->perms[sid];
+                int inv_up = A->inv[sid];
+                int p = std::min(vp.mx_th[index], S.inv_mu - S.inv_vmu - (inv_up - inv_u));
+                if (p < 0) p = 0;
+                elem_sym_perms(up, p, k, n, newperms);
+
+                for (const auto& npd : newperms) {
+                    const Perm& up2 = npd.first;
+                    int udiff = npd.second, newk = k - udiff;
+                    yvars_of(up, up2, k, yidx);
+                    long id = -1;
+                    for (const VSum& sv : sums) {
+                        const Expr& sumval = sv.second[0];
+                        const auto& trs = trans[sv.first];
+                        for (size_t t = 0; t < trs.size(); ++t) {
+                            const Trans& tr = trs[t];
+                            if (newk < tr.vdiff) continue;  // elem_sym_func == 0
+                            Expr term;
+                            if (newk == tr.vdiff) {
+                                term = sumval;  // elem_sym_func == 1
+                            } else {
+                                const Expr& esf = esc.get(newk - tr.vdiff, newk, yidx, zidx[index][sv.first][t]);
+                                if (is_zero(esf)) continue;
+                                term = ex_mul(sumval, esf);
+                            }
+                            if (tr.s < 0) term = ex_neg(term);
+                            if (id < 0) id = B->intern(up2, inv_up + udiff);
+                            B->get_or_insert((uint32_t)id, tr.v2).push_back(term);
+#ifdef STATS
+                            ++n_terms;
+#endif
+                        }
+                    }
+                }
+            }
+
+            // sum each entry's pending terms; drop the zeros
+            size_t alive = 0, live_sums = 0;
+            for (auto& vec : B->sums) {
+                for (VSum& e : vec) {
+                    Expr s = ex_add(e.second);
+                    e.second.clear();
+                    if (!is_zero(s)) e.second.push_back(s);
+                }
+                vec.erase(std::remove_if(vec.begin(), vec.end(), [](const VSum& e) { return e.second.empty(); }), vec.end());
+                if (!vec.empty()) {
+                    ++alive;
+                    live_sums += vec.size();
+                }
+            }
+            std::swap(A, B);
+#ifdef STATS
+            std::fprintf(stderr, "idx %2d k=%2d terms=%10zu targets=%8u states_out=%8zu sums_out=%10zu esf_cache=%zu  %.3fs\n", index, k, n_terms, A->count, alive, live_sums, esc.memo.size(),
+                         now_s() - t0);
+#endif
+        }
+
+        for (uint32_t sid = 0; sid < A->count; ++sid)
+            if (ExprVec* c = A->find(sid, id_vmu)) result[A->perms[sid]].push_back((*c)[0]);
+    }
+
+    ExprDict out;
+    out.reserve(result.size());
+    for (auto& kv : result) {
+        Expr s = ex_add(kv.second);
+        if (!is_zero(s)) out.push_back({kv.first, s});
+    }
+    std::sort(out.begin(), out.end(), [](const std::pair<Perm, Expr>& x, const std::pair<Perm, Expr>& y) { return x.first < y.first; });
+    return out;
+}
+

schubmult-5.0.0/cpp/kernel_double_alt.h

@@ -0,0 +1,189 @@
+// kernel_double_alt.h: C++ port of schubmult.mult.double.schubmult_double_alt_from_elems_backwards
+// (= schubmult_double_alt_from_elems), the pull-out-variable recursion used for positivity,
+// together with schub_lib.pull_out_var and elem_sym_positional_perms.
+//
+// The elementary symmetric objects come from esc.builder, so this reproduces the Python
+// exactly for any elem_func (FactorialElemSym, elem_sym_poly, ...).
+
+#pragma once
+
+#include "schub_symbolic.h"
+
+#include <map>
+
+// Python's len() of a trimmed Permutation: max(trimmed length, 2). Only used where the
+// Python algorithm's loop bounds depend on it; the representation stays fixed-size.
+static int py_len(const Perm& a) {
+    int L = MAXN;
+    while (L > 0 && a.p[L - 1] == L) --L;
+    return std::max(L, 2);
+}
+
+static int perm_inv_full(const Perm& a) { return perm_inv(a, MAXN); }
+
+struct PullOut {
+    std::vector<int> index_list;  // 1-based values of v at the retained positions
+    Perm vp;
+    bool operator<(const PullOut& o) const {
+        if (vp != o.vp) return vp < o.vp;
+        return index_list < o.index_list;
+    }
+    bool operator==(const PullOut& o) const { return vp == o.vp && index_list == o.index_list; }
+};
+
+// schub_lib.pull_out_var(vnum, v): the set of (index_list, vp).
+static std::vector<PullOut> pull_out_var(int vnum, const Perm& v) {
+    int L = py_len(v);
+    std::vector<PullOut> ret;
+    if (vnum >= L) {
+        ret.push_back({{}, v});
+        return ret;
+    }
+    if (L + 2 > MAXN) die("pull_out_var: permutation too long for MAXN");
+    auto add_result = [&](const Perm& vpm) {
+        // vpm with position vnum-1 (holding L+1) removed, values above L+1 shifted down
+        Perm vp = identity_perm();
+        int out = 0;
+        int lenv = py_len(vpm);
+        for (int i = 0; i < lenv; ++i) {
+            if (i == vnum - 1) continue;
+            int x = vpm.p[i];
+            vp.p[out++] = (uint8_t)(x > L + 1 ? x - 1 : x);
+        }
+        int lvp = py_len(vp);
+        PullOut po;
+        po.vp = vp;
+        for (int i = vnum; i < L; ++i)
+            if ((i > lvp && v.p[i] == i) || (i <= lvp && v.p[i] == vp.p[i - 1])) po.index_list.push_back(v.p[i]);
+        ret.push_back(std::move(po));
+    };
+    std::vector<std::pair<Perm, int>> cur, nxt;
+    cur.push_back({v, 0});
+    for (int p = 0; p < L + 1 - vnum; ++p) {
+        nxt.clear();
+        for (const auto& e : cur) {
+            const Perm& vpm = e.first;
+            int b = e.second;
+            if (vpm.p[vnum - 1] == L + 1) add_result(vpm);
+            for (int j = vnum; j < L + 2; ++j) {
+                if (vpm.p[j] <= b) continue;
+                for (int i = 0; i < vnum; ++i)
+                    if (bruhat_ascent(vpm, i, j)) nxt.push_back({swapped(vpm, i, j), vpm.p[j]});
+            }
+        }
+        std::swap(cur, nxt);
+    }
+    for (const auto& e : cur)
+        if (e.first.p[vnum - 1] == L + 1) add_result(e.first);
+    std::sort(ret.begin(), ret.end());
+    ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
+    return ret;
+}
+
+struct PosUp {
+    Perm perm;
+    int udiff;
+    int sign;
+    bool operator<(const PosUp& o) const {
+        if (perm != o.perm) return perm < o.perm;
+        if (udiff != o.udiff) return udiff < o.udiff;
+        return sign < o.sign;
+    }
+    bool operator==(const PosUp& o) const { return perm == o.perm && udiff == o.udiff && sign == o.sign; }
+};
+
+// schub_lib.elem_sym_positional_perms(orig, p, *k) with k given 0-based; returns the set of
+// (perm, udiff, sign).
+static std::vector<PosUp> elem_sym_positional_perms(const Perm& orig, int p, const std::vector<int>& kpos) {
+    std::vector<PosUp> total{{orig, 0, 1}};
+    std::vector<std::pair<Perm, int>> cur{{orig, 1}}, nxt;
+    int maxk = 0;
+    for (int q : kpos) maxk = std::max(maxk, q);
+    bool ink[MAXN] = {false};
+    for (int q : kpos) ink[q] = true;
+    for (int pp = 0; pp < p; ++pp) {
+        nxt.clear();
+        for (const auto& e : cur) {
+            const Perm& up = e.first;
+            int sign = e.second;
+            int bound = py_len(up) + maxk + 1;
+            if (bound > MAXN) die("elem_sym_positional_perms: permutation too long for MAXN");
+            for (int i : kpos) {
+                if (up.p[i] != orig.p[i]) continue;
+                for (int j = 0; j < bound; ++j) {
+                    if (ink[j]) continue;
+                    int a = std::min(i, j), b = std::max(i, j);
+                    if (!bruhat_ascent(up, a, b)) continue;
+                    Perm np = swapped(up, a, b);
+                    int ns = i < j ? sign : -sign;
+                    nxt.push_back({np, ns});
+                    total.push_back({np, pp + 1, ns});
+                }
+            }
+        }
+        std::sort(nxt.begin(), nxt.end());
+        nxt.erase(std::unique(nxt.begin(), nxt.end()), nxt.end());
+        std::swap(cur, nxt);
+    }
+    std::sort(total.begin(), total.end());
+    total.erase(std::unique(total.begin(), total.end()), total.end());
+    return total;
+}
+
+#ifndef SCHUB_EXPRDICT
+#define SCHUB_EXPRDICT
+typedef std::vector<std::pair<Perm, Expr>> ExprDict;
+#endif
+
+typedef std::unordered_map<Perm, ExprVec, PermHash> TermMap;
+
+static TermMap alt_backwards_rec(const TermMap& perm_dict, const Perm& v, ElemSymCache& esc) {
+    if (perm_inv_full(v) == 0) return perm_dict;
+    Perm vinv = inverse(v, MAXN);
+    int index = 0;  // max descent of ~v, 1-based
+    for (int i = 0; i + 1 < MAXN; ++i)
+        if (vinv.p[i] > vinv.p[i + 1]) index = i + 1;
+    std::vector<PullOut> L = pull_out_var(index, vinv);
+
+    TermMap ret;
+    std::map<Perm, TermMap> cache;  // by new_v, as the Python
+    std::vector<int> kpos, yidx;
+    for (const PullOut& po : L) {
+        auto it = cache.find(po.vp);
+        if (it == cache.end()) it = cache.emplace(po.vp, alt_backwards_rec(perm_dict, inverse(po.vp, MAXN), esc)).first;
+        const TermMap& start = it->second;
+        int m = (int)po.index_list.size();
+        kpos.clear();
+        for (int i : po.index_list) kpos.push_back(i - 1);
+        for (const auto& kv : start) {
+            const Perm& u = kv.first;
+            Expr val = ex_add(kv.second);
+            if (is_zero(val)) continue;
+            for (const PosUp& e : elem_sym_positional_perms(u, m, kpos)) {
+                yidx.clear();
+                for (int i : po.index_list)
+                    if (e.perm.p[i - 1] == u.p[i - 1]) yidx.push_back(e.perm.p[i - 1]);
+                const Expr& ef = esc.get(m - e.udiff, m - e.udiff, yidx, std::vector<int>{index});
+                if (is_zero(ef)) continue;
+                Expr term = ex_mul(val, ef);
+                if (e.sign < 0) term = ex_neg(term);
+                ret[e.perm].push_back(term);
+            }
+        }
+    }
+    return ret;
+}
+
+// schubmult_double_alt_from_elems_backwards(perm_dict, v, var2, var3, elem_func)
+static ExprDict schubmult_double_alt_from_elems_backwards(const ExprDict& perm_dict, const Perm& v, ElemSymCache& esc) {
+    TermMap in;
+    for (const auto& kv : perm_dict) in[kv.first].push_back(kv.second);
+    TermMap out = alt_backwards_rec(in, v, esc);
+    ExprDict r;
+    for (auto& kv : out) {
+        Expr s = ex_add(kv.second);
+        if (!is_zero(s)) r.push_back({kv.first, s});
+    }
+    std::sort(r.begin(), r.end(), [](const std::pair<Perm, Expr>& x, const std::pair<Perm, Expr>& y) { return x.first < y.first; });
+    return r;
+}