PREREG_flat_creep outcome: NOT accepted. Unkept promise AND creep under the projection: APS 2806 -> 2878 (V2 fails), CHA 3220 -> 3354 (V1 fails), flat fun3-6 1823 -> 1991 (V4 fails), guarantee holds (V3). With G2: 2782 -> 2842, 3169 -> 3318. Under safe CHA 3390 -> 3149, weaker than the single flag (3037). None of the three flat-regime gates pays under the projection: its budget already does their work. Server regression x2: 952 passed, 1 failed = the expected paper-number check (46 numbers after the signfix, pending the paper decision).

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

results_analyze_flatcreep.txt

@@ -0,0 +1,32 @@
+sweep: 140 configurations x 199 problems (FULL)
+wrote sweep_flatcreep.json  (8s total)
+tent, 3-point, pairs (no gate -> flat gate)      APS          CHA        both      flat fun3-6
+  none           2806->2878    4104->3407    6910->6285    2707->2044  solved 193 over 9
+  none     +G2   2782->2842    3863->3374    6645->6216    2474->1990  solved 193 over 9
+  step           3036->3099    3524->3149    6560->6248    2111->1748  solved 193 over 0
+  step     +G2   3089->3074    3529->3182    6618->6256    2106->1770  solved 193 over 0
+  bracket        7260->7260    3604->3604   10864->10864   1730->1730  solved 193 over 0
+  bracket  +G2   6837->6837    3650->3650   10487->10487   1717->1717  solved 193 over 0
+  both           7239->7209    3515->3515   10754->10724   1529->1529  solved 193 over 0
+  both     +G2   7130->7130    3463->3463   10593->10593   1504->1504  solved 193 over 0
+  project        2806->2878    3220->3354    6026->6232    1823->1991  solved 193 over 0
+  project  +G2   2782->2842    3169->3318    5951->6160    1780->1934  solved 193 over 0
+  safe           3036->3099    3390->3149    6426->6248    1977->1748  solved 193 over 0
+  safe     +G2   3089->3074    3392->3182    6481->6256    1969->1770  solved 193 over 0
+  credit         3568->3625    3020->3040    6588->6665    1044->1064  solved 193 over 0
+  credit   +G2   3799->3798    3064->3063    6863->6861    1044->1064  solved 193 over 0
+
+VERDICTS
+  proposed rule        APS 2806->2878 (Z2 ✗)  CHA 3220->3354 (Z1 ✗)  Z3 ✓ (0 viol, 0 cells <193)  Z4 ✗  both 6232  vs Chandrupatla APS 78/27/48 p=0.0095   not accepted
+  proposed rule + G2   APS 2782->2842 (Z2 ✗)  CHA 3169->3318 (Z1 ✗)  Z3 ✓ (0 viol, 0 cells <193)  Z4 ✗  both 6160  vs Chandrupatla APS 88/20/45 p=0.00024   not accepted
+
+nine functions, projection, no gate -> flat gate, both sets:
+  cbrt         18003 ->  18131
+  cosine       19741 ->  18619
+  exp_abs       6652 ->   7038
+  exp_sq       19786 ->  16770
+  rat_sq       19793 ->  17399
+  ratio         6026 ->   6232
+  ratio_soft    9352 ->   9591
+  rational      6823 ->   7327
+  sqrt         13388 ->  13597

simroot/pure.py

@@ -666,7 +666,7 @@ def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived",
     if space not in SPACES:
         raise ValueError(f"unknown space {space!r}")
     if prestep not in ("none", "progress", "slope", "band", "defect", "simpair", "flat",
-                       "flat2"):
+                       "flat2", "flatcreep"):
         raise ValueError(f"unknown prestep {prestep!r}")
     if prestep in ("band", "defect", "simpair") and scale not in (
             "derived3", "derived3_cap", "derived3_m", "bracket", "far"):
@@ -902,6 +902,18 @@ def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived",
                         # the model's again and is judged by its own result.
                         step = 0.5 * (A + B) - x
                         pre_refused += 1
+                    if (step is None and prestep == "flatcreep" and last_model
+                            and f_prev != 0.0 and fx / f_prev >= 0.25
+                            and x_prev2 is not None and x != x_prev
+                            and x_prev != x_prev2
+                            and (x > x_prev) == (x_prev > x_prev2)):
+                        # PREREG_flat_creep 2026-09-21.  The single flag's unkept promise
+                        # (model step, no crossing, r >= 1/4) AND a creep: the last two
+                        # moves went the same way.  A second, independent property of the
+                        # same moment - not a repeat in time, which would fire one step
+                        # late, before the crossing (flat2's failure).
+                        step = 0.5 * (A + B) - x
+                        pre_refused += 1
                     if step is None and prestep == "flat2" and unkept_run >= 2:
                         # PREREG_flat_twice 2026-09-21.  The same unkept promise as
                         # "flat" (model step, no crossing, r >= 1/4), but only after it has

sweep_full.py

@@ -413,10 +413,12 @@ def main():
     ext2mode = "--extrap2" in sys.argv     # gates G1-G3 on the lengthening
     flatmode = "--flat" in sys.argv        # the flat-regime gate
     flat2mode = "--flat2" in sys.argv      # the flat gate, promise failed twice
+    creepmode = "--flatcreep" in sys.argv  # the flat gate AND a creep
     combomode = "--combo" in sys.argv      # modes A and B together
     pointsmode = "--points" in sys.argv    # mode A: triple by shape
     dirmode = "--direction" in sys.argv    # mode B: far end by dissimilarity
-    specs = (build_grid_flat(smoke, "flat2") if flat2mode else
+    specs = (build_grid_flat(smoke, "flatcreep") if creepmode else
+             build_grid_flat(smoke, "flat2") if flat2mode else
              build_grid_flat(smoke) if flatmode else
              build_grid_extrap2(smoke) if ext2mode else
              build_grid_extrap(smoke) if extmode else
@@ -444,8 +446,9 @@ def main():
 
     # the published sweep_full.json is what verify_article.py checks the paper
     # against, so the log grid never writes into it
-    if flat2mode or flatmode or ext2mode or extmode or decmode or ordermode or capmode or combomode or pointsmode or dirmode:
+    if creepmode or flat2mode or flatmode or ext2mode or extmode or decmode or ordermode or capmode or combomode or pointsmode or dirmode:
-        base = ("sweep_flat2" if flat2mode else
+        base = ("sweep_flatcreep" if creepmode else
+                "sweep_flat2" if flat2mode else
                 "sweep_flat" if flatmode else
                 "sweep_extrap2" if ext2mode else
                 "sweep_extrap" if extmode else

tests/test_flat_gate.py

@@ -58,6 +58,31 @@ def test_the_twice_gate_is_silent_where_the_model_is_exact_and_fires_on_a_power(
     assert st["pre_refused"] > 0
 
 
+@pytest.mark.parametrize("f,a,b", PROBS)
+@pytest.mark.parametrize("guard", ("project", "credit"))
+@pytest.mark.parametrize("ext", ("none", "pattern"))
+def test_the_guarantee_holds_with_the_creep_gate(f, a, b, guard, ext):
+    x, n, ok = pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", scale="derived3",
+                         guard=guard, prestep="flatcreep", extrapolate=ext)
+    assert ok and min(a, b) <= x <= max(a, b)
+    half = math.ceil(math.log2(abs(b - a) / XTOL))
+    assert n <= (2 * half + 3 if guard == "project" else half + 4), n
+
+
+def test_the_creep_gate_is_silent_on_a_line_fires_on_a_power_and_spares_a_simple_root():
+    """Measured before pinning: silent where the model is exact, fires on x^9, and does
+    NOT fire on x^3 - 2x - 5 over [1, 4], where the single flag fired once."""
+    runs = {}
+    for name, f, a, b in (("line", lambda t: 3.0 * t - 1.0, -2.0, 5.0),
+                          ("x9", lambda t: t ** 9, -1.0, 2.0),
+                          ("cubic", lambda t: t ** 3 - 2.0 * t - 5.0, 1.0, 4.0)):
+        st = {}
+        pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", scale="derived3",
+                  guard="project", prestep="flatcreep", stats=st)
+        runs[name] = st["pre_refused"]
+    assert runs["line"] == 0 and runs["x9"] > 0 and runs["cubic"] == 0, runs
+
+
 def test_the_gate_never_fires_where_the_model_is_exact():
     """On a straight line the model's step lands on the root: r = 0, never >= 1/4."""
     st = {}