PREREG_flat_exp_limit outcome: ACCEPTED (server numbers equal to the smoke in every projection cell; 0 violations in the guaranteed family).

Translation limit of the analogy (f shrank, x-scale did not -> m = inf):
  defect + remembered + point + exp        APS 2531  CHA 1972  both 4503
  G2 + defect + remembered + point + exp   APS 2588  CHA 1997  both 4585
  G2 + contra + remembered + point + exp   APS 2773  CHA 2073  both 4846
  Chandrupatla                             APS 2787  CHA 2441  both 5228
Per problem against Chandrupatla now SIGNIFICANT ON BOTH SETS: G2+contra+rem+pt+exp APS 98/18/37 p=1.5e-7, CHA 28/3/9 p=0.0026; defect+rem+pt+exp APS 86/20/47 p=9e-4, CHA 27/3/10 p=0.0076.
NOT where predicted: fun9 only -1..-3; the gain is on the flat families (x^9 177 -> 161, x^19 339 -> 167).
Server regression x2: 1179 passed, 1 failed = the paper-number check.

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

simroot/pure.py

@@ -607,7 +607,7 @@ def _config3(x, fx, xp, fp, xp2, fp2):
     return xi, phi, abs(x - xp), abs(fx - fp)
 
 
-def _analogy_order(cur, past):
+def _analogy_order(cur, past, translation=False):
     """The order m of the analogous pair, or None when the configuration is not nearer to
     its own past than to the line phi = xi (or the pair's scales are undefined).  The judgment
     is ordinal; m = ln(f ratio) / ln(x ratio) is read, not chosen.
@@ -623,6 +623,12 @@ def _analogy_order(cur, past):
     if best[2] <= 0.0 or best[3] <= 0.0 or cur[2] <= 0.0 or cur[3] <= 0.0:
         return None
     lx, lf = cur[2] / best[2], cur[3] / best[3]
+    if translation and math.isfinite(lx) and math.isfinite(lf) and 0.0 < lf < 1.0 <= lx:
+        # PREREG_flat_exp_limit 2026-09-21.  f shrank while the step in x did not: the pair
+        # is similar by TRANSLATION (exp(x - 1) = exp(x)/e), the limit of scaling as the
+        # order grows without bound - steeper than any power.  m = inf, the boundary of the
+        # same definition, not a new constant.
+        return math.inf
     if not (math.isfinite(lx) and math.isfinite(lf)) or lx == 1.0 or lf <= 0.0:
         return None
     return math.log(lf) / math.log(lx)
@@ -758,11 +764,15 @@ def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived",
     # category variables below then carry the same string the old tests compared.
     if "+" in prestep:
         parts = prestep.split("+")
-        cats = ({"defect"}, {"contra"}, {"flatanalog", "flatanalogmem", "flatanalogpt",
+        cats = ({"defect"}, {"contra"}, {"exp"}, {"flatanalog", "flatanalogmem", "flatanalogpt",
                                           "flatanalogmempt"})
         if (len(parts) != len(set(parts)) or any(not any(p in c for c in cats) for p in parts)
                 or any(sum(p in c for p in parts) > 1 for c in cats)):
             raise ValueError(f"unknown composite prestep {prestep!r}")
+        if "exp" in parts and not any(p.startswith("flatanalog") for p in parts):
+            # the translation limit changes how the analogy reads its order; without the
+            # flat regime there is no analogy to read (PREREG_flat_exp_limit)
+            raise ValueError("prestep component 'exp' needs a flatanalog* component")
     elif prestep not in ("none", "progress", "slope", "band", "defect", "simpair", "flat",
                          "flat2", "flatcreep", "flatstick", "flatstickmid", "flatstickexit",
                          "flatjudge", "flatanalog", "flatanalogmem", "contra",
@@ -776,6 +786,7 @@ def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived",
     flat_mem = pre_flat in ("flatanalogmem", "flatanalogmempt")
     flat_pt = pre_flat in ("flatanalogpt", "flatanalogmempt")
     pre_contra = "contra" in parts
+    pre_exp = "exp" in parts            # PREREG_flat_exp_limit: translation similarity, m = inf
     if pre_dec != "none" and scale not in (
             "derived3", "derived3_cap", "derived3_m", "bracket", "far"):
         # the decision reads a TRIPLE; under the two-point scale there is no third point
@@ -1065,7 +1076,7 @@ def pure_root(f, a, b, xtol, maxfev, similarity="ratio", scale="derived",
                         cur = _config3(x, fx, x_prev, f_prev, x_prev2, f_prev2)
                         flag = (sticky_m is None and last_model and f_prev != 0.0
                                 and fx / f_prev >= 0.25)
-                        m_pair = _analogy_order(cur, configs)
+                        m_pair = _analogy_order(cur, configs, translation=pre_exp)
                         steep = m_pair is not None and m_pair >= 2.0
                         if flat_mem:
                             if steep: