baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/test_modern_repairs.py

@@ -0,0 +1,111 @@
+"""The objection that the comparison stopped at 1973, and what it settled.
+
+Two things came out of running it, and they scope the claim exactly:
+
+  the credit projection is the best repair known for the false-position
+  family - better than 1971, 1972, 1973, 1995 and 2011 on evaluations,
+  solved count and worst case at once, and the only one that reaches the
+  193-of-199 ceiling;
+
+  and it is NOT better than a purpose-built acceptance test: swapped into
+  Chandrupatla's own interpolation it costs 7627 where his test costs 5209.
+
+So the safeguard is a good DEFAULT for a rule that has none, not a
+replacement for one that has a good one.  Both halves are pinned.
+"""
+from __future__ import annotations
+
+import math
+import os
+import sys
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from simroot.baselines import chandrupatla
+from stage18_bulletproof import falsi_driver, load_roots
+from stage19_modern import chandrupatla_guard, falsi_modern, score
+
+PROBS = load_roots()
+XTOL, MAXFEV = 1e-12, 200
+
+
+def falsi(repair):
+    return score(lambda f, a, b, xt, mx: falsi_driver(f, a, b, xt, mx, repair),
+                 PROBS)
+
+
+def modern(variant):
+    return score(lambda f, a, b, xt, mx: falsi_modern(f, a, b, xt, mx, variant),
+                 PROBS)
+
+
+# --------------------------------------------------------------------------
+# the half that holds
+# --------------------------------------------------------------------------
+@pytest.mark.parametrize("name,getter", [
+    ("illinois-1971", lambda: falsi("illinois")),
+    ("pegasus-1972", lambda: falsi("pegasus")),
+    ("anderson-1973", lambda: falsi("anderson")),
+    ("ford-1995", lambda: modern("ford")),
+    ("galdino-2011", lambda: modern("galdino")),
+])
+def test_credit_beats_every_published_repair_on_all_three_axes(name, getter):
+    c_t, c_s, c_w = falsi("credit")
+    t, s, w = getter()
+    assert c_t < t, (name, c_t, t)
+    assert c_s > s, (name, c_s, s)
+    assert c_w < w, (name, c_w, w)
+
+
+def test_no_published_repair_reaches_the_ceiling():
+    """193 of 199 is what bisection, Chandrupatla and TOMS 748 reach.  Fifty
+    years of repairs of the false-position family stop at 176."""
+    assert falsi("credit")[1] == 193
+    for g in (lambda: falsi("illinois"), lambda: falsi("pegasus"),
+              lambda: falsi("anderson"), lambda: modern("ford"),
+              lambda: modern("galdino")):
+        assert g()[1] <= 176
+
+
+# --------------------------------------------------------------------------
+# the half that does not - pinned so the claim is never overstated
+# --------------------------------------------------------------------------
+def test_the_pluggable_chandrupatla_reproduces_the_published_one():
+    """Without this the swap below compares against a different algorithm."""
+    a = score(lambda f, x, y, xt, mx: chandrupatla_guard(f, x, y, xt, mx,
+                                                         "own"), PROBS)
+    b = score(lambda f, x, y, xt, mx: chandrupatla(f, x, y, xt, mx), PROBS)
+    assert a[:2] == b[:2], (a, b)
+
+
+def test_credit_rescues_chandrupatlas_interpolation_but_loses_to_his_test():
+    """The sharp test.  Same interpolation, same bookkeeping, only the guard
+    differs.  Credit turns an unguarded rule that solves 165 into one that
+    solves 193 - and Chandrupatla's own acceptance test does the same job for
+    a third fewer evaluations."""
+    own = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx,
+                                                           "own"), PROBS)
+    cred = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx,
+                                                            "credit"), PROBS)
+    none = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx,
+                                                            "none"), PROBS)
+    assert cred[1] > none[1] and cred[0] < none[0]     # it rescues
+    assert own[0] < cred[0]                            # and is beaten
+    assert own[1] == cred[1] == 193
+
+
+def test_the_scope_sentence_the_paper_may_use():
+    """A default safeguard for a rule that has none - not a replacement for a
+    purpose-built one.  Both directions asserted together so neither can be
+    quoted alone."""
+    c_t, c_s, _cw = falsi("credit")
+    best_published = min(falsi(r)[0] for r in ("illinois", "pegasus",
+                                               "anderson"))
+    best_published = min(best_published, modern("ford")[0],
+                         modern("galdino")[0])
+    assert c_t < best_published                        # best repair known
+    own = score(lambda f, a, b, xt, mx: chandrupatla_guard(f, a, b, xt, mx,
+                                                           "own"), PROBS)
+    assert own[0] < c_t                                # and not the best guard