schubmult 5.2.0b2__tar.gz → 5.2.0b3__tar.gz

{schubmult-5.2.0b2 → schubmult-5.2.0b3}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 5.2.0b3
+
+Pre-release of 5.2.0; identical to 5.2.0b2 apart from one bug fix in the manifestly positive
+display of double Schubert structure constants. Pre-releases install with
+`pip install --pre schubmult`; `pip install schubmult` keeps giving 5.1.1 until 5.2.0 is final.
+
+### Fixed
+
+- **`posify` / `q_posify` crashed or returned a wrong expression in the one-dominates recursion**
+  (`schubmult_q_double --mixed-var --display-positive`, `schubmult.mult.positivity.posify`). When
+  $u$ one-dominates $w$, `posify` strips the first row and recurses on $(\phi_1 u, v', \phi_1 w)$
+  over the shifted alphabet $y_2, y_3, \ldots$, passed as a plain tuple. Two bugs met there: the
+  reduced coefficient was still computed in the unshifted alphabet, so any recursion that bottomed
+  out in the integer program returned $c(y_1, y_2, \ldots)$ instead of $c(y_2, y_3, \ldots)$; and
+  `compute_positive_rep` used `tuple.index`, which raises on the $z$ variables where
+  `GeneratingSet.index` returns `-1`. Hit for instance by $u=2431$, $v=1432$, $w=34512$, where
+  `schubmult_q_double 2 4 3 1 - 1 4 3 2 --mixed-var --display-positive` died with a bare
+  `Exception`. The reduced coefficient is now computed in the shifted alphabet and
+  `compute_positive_rep` accepts plain sequences. `posify` and `q_posify` now reconstruct every
+  structure constant on all of $S_4$ (5,558 classical and 11,422 quantum coefficients), and both
+  are covered by direct unit tests.
+
 ## 5.2.0b2
 
 Pre-release of 5.2.0: SageMath integration (`schubmult.sage`), a correctness fix for parabolic

{schubmult-5.2.0b2/src/schubmult.egg-info → schubmult-5.2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schubmult
-Version: 5.2.0b2
+Version: 5.2.0b3
 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>

{schubmult-5.2.0b2 → schubmult-5.2.0b3}/src/schubmult/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.2.0b2'
-__version_tuple__ = version_tuple = (5, 2, 0, 'b2')
+__version__ = version = '5.2.0b3'
+__version_tuple__ = version_tuple = (5, 2, 0, 'b3')
 
-__commit_id__ = commit_id = 'g0e9592688'
+__commit_id__ = commit_id = 'gb2213fbec'

{schubmult-5.2.0b2 → schubmult-5.2.0b3}/src/schubmult/mult/positivity.py

@@ -51,6 +51,18 @@ from .double import schubmult_double, schubmult_double_pair, schubmult_double_pa
 logger = get_logger(__name__)
 
 
+def _var_index(varlist, sym):
+    """Position of ``sym`` in ``varlist`` or ``-1``.
+
+    ``posify`` recurses with ``var2[1:]``, which turns a ``GeneratingSet`` into a plain tuple
+    whose ``.index`` raises instead of returning ``-1`` for foreign symbols.
+    """
+    try:
+        return varlist.index(sym)
+    except ValueError:
+        return -1
+
+
 def cbc_solver(msg=False):
     """PuLP ``COIN_CMD`` using the CBC binary bundled by ``pulp[cbc]``, falling back to ``cbc`` on PATH."""
     import pulp as pu
@@ -96,10 +108,10 @@ def compute_positive_rep(val, var2=None, var3=None, msg=False):
 
     frees = val.free_symbols
 
-    varsimp2 = [m for m in frees if var2.index(m) != -1]
-    varsimp3 = [m for m in frees if var3.index(m) != -1]
-    varsimp2.sort(key=lambda k: var2.index(k))
-    varsimp3.sort(key=lambda k: var3.index(k))
+    varsimp2 = [m for m in frees if _var_index(var2, m) != -1]
+    varsimp3 = [m for m in frees if _var_index(var3, m) != -1]
+    varsimp2.sort(key=lambda k: _var_index(var2, k))
+    varsimp3.sort(key=lambda k: _var_index(var3, k))
 
     var22 = tuple(varsimp2)
     var33 = tuple(varsimp3)
@@ -426,11 +438,14 @@ def posify(
             for arr, v3 in vp:
                 tomul = prod([var2[1] - var3[arr[i]] for i in range(len(arr))])
 
-                val2 = schubmult_double_pair(u3, v3, var2, var3).get(
+                # the reduced coefficient lives in the shifted alphabet var2[1:],
+                # matching the alphabet handed to the recursive posify call below
+                shifted_var2 = var2[1:]
+                val2 = schubmult_double_pair(u3, v3, shifted_var2, var3).get(
                     w3,
                     0,
                 )
-                val2 = posify(val2, u3, v3, w3, var2[1:], var3, msg, optimize=optimize)
+                val2 = posify(val2, u3, v3, w3, shifted_var2, var3, msg, optimize=optimize)
                 val += tomul * val2
 
             return val

{schubmult-5.2.0b2 → schubmult-5.2.0b3/src/schubmult.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schubmult
-Version: 5.2.0b2
+Version: 5.2.0b3
 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>

schubmult-5.2.0b3/src/schubmult.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "5.2.0b3",
+  "distance": 0,
+  "node": "gb2213fbec9918447dad4e7b71e35066a35ccce25",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-12"
+}

{schubmult-5.2.0b2 → schubmult-5.2.0b3}/tests/mult/test_positivity.py

@@ -57,3 +57,37 @@ def test_forwardcoeff_matches_raw_value_when_formula_applies():
                 found += 1
                 assert expand(sp(forwardcoeff(u, v, w, y, z)) - sp(val)) == 0, (u, v, w)
     assert found > 0
+
+
+def _manifestly_positive(expr):
+    # a minus sign is only allowed directly in front of a z-variable term
+    import re
+
+    return re.search(r"-\s*(\d+\*)?[y(]", str(expr)) is None
+
+
+def test_posify_one_dominates_recursion_uses_shifted_alphabet():
+    # Regression: u one-dominates w, so posify recurses on (phi1(u), v3, phi1(w)) over the
+    # shifted alphabet var2[1:] (a plain tuple). Previously the reduced coefficient was computed
+    # in the unshifted alphabet and compute_positive_rep crashed on tuple.index.
+    u, v, w = Permutation([2, 4, 3, 1]), Permutation([1, 4, 3, 2]), Permutation([3, 4, 5, 1, 2])
+    val = schubmult_double({u: 1}, v, y, z)[w]
+    positive = posify(val, u, v, w, y, z)
+    assert expand(sp(positive) - sp(val)) == 0
+    assert _manifestly_positive(positive)
+
+
+def test_compute_positive_rep_accepts_plain_tuple_alphabets():
+    val = (y[2] - z[1]) + 2 * (y[3] - z[2])
+    rep = compute_positive_rep(val, tuple(y[1:5]), tuple(z[1:5]))
+    assert expand(sp(rep) - sp(val)) == 0
+
+
+def test_posify_reconstructs_raw_value_for_s4():
+    S4 = [Permutation(list(p)) for p in itertools.permutations(range(1, 5))]
+    for u in S4:
+        for v in S4:
+            for w, val in schubmult_double({u: 1}, v, y, z).items():
+                positive = posify(val, u, v, w, y, z)
+                assert expand(sp(positive) - sp(val)) == 0, (u, v, w)
+                assert _manifestly_positive(positive), (u, v, w, positive)

{schubmult-5.2.0b2 → schubmult-5.2.0b3}/tests/mult/test_quantum_double.py

@@ -8,7 +8,7 @@ from schubmult import Permutation
 from schubmult.abc import x, y, z
 from schubmult.mult.double import schubmult_double
 from schubmult.mult.quantum import schubmult_q
-from schubmult.mult.quantum_double import factor_out_q, mult_poly_q_double, schubmult_q_double, schubmult_q_double_fast, schubpoly_quantum, single_variable
+from schubmult.mult.quantum_double import factor_out_q, mult_poly_q_double, q_posify, schubmult_q_double, schubmult_q_double_fast, schubpoly_quantum, single_variable
 from schubmult.symbolic import S, sympify_sympy
 from schubmult.symbolic.poly.schub_poly import _vars
 from schubmult.symbolic.poly.variables import ZeroGeneratingSet
@@ -87,3 +87,36 @@ def test_factor_out_q_roundtrip():
     q_dict = factor_out_q(poly)
     total = sum((sp(k) * sp(v) for k, v in q_dict.items()), sympy.Integer(0))
     assert sympy.expand(total - sp(poly)) == 0
+
+
+def _manifestly_positive(expr):
+    # a minus sign is only allowed directly in front of a z-variable term
+    import re
+
+    return re.search(r"-\s*(\d+\*)?[y(]", str(expr)) is None
+
+
+def test_q_posify_regression_one_dominates_cases():
+    # These triples route through posify's one-dominates recursion (shifted alphabet) and
+    # previously either raised or produced an expression not equal to the raw coefficient.
+    cases = [
+        ([2, 4, 3, 1], [1, 4, 3, 2], [3, 4, 5, 1, 2]),
+        ([2, 4, 3, 1], [3, 1, 4, 2], [3, 5, 2, 1, 4]),
+        ([4, 2, 3, 1], [4, 1, 3, 2], [3, 4, 5, 1, 2]),
+    ]
+    for u, v, w in cases:
+        u, v, w = Permutation(u), Permutation(v), Permutation(w)
+        val = schubmult_q_double_fast({u: S.One}, v, y, z)[w]
+        positive = q_posify(u, v, w, val, y, z, q, False)
+        assert sympy.expand(sp(positive) - sp(val)) == 0, (u, v, w)
+        assert _manifestly_positive(positive), (u, v, w, positive)
+
+
+def test_q_posify_reconstructs_raw_value_for_s4():
+    S4 = [Permutation(list(p)) for p in itertools.permutations(range(1, 5))]
+    for u in S4:
+        for v in S4:
+            for w, val in schubmult_q_double_fast({u: S.One}, v, y, z).items():
+                positive = q_posify(u, v, w, val, y, z, q, False)
+                assert sympy.expand(sp(positive) - sp(val)) == 0, (u, v, w)
+                assert _manifestly_positive(positive), (u, v, w, positive)

schubmult-5.2.0b2/src/schubmult.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "5.2.0b2",
-  "distance": 0,
-  "node": "g0e9592688b62d79fb76f04743ab306272b810431",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-09"
-}