PREREG before code and run: entry into the flat regime by analogy. The dimensionless configuration (xi, phi) of the last three points is nearer to a past one than to the line phi = xi, AND the pair's similarity exponent m = ln(f shrink)/ln(x shrink) >= 2, on top of the unkept promise; midpoint exit as flatstickexit. Basis (diag_flat_analogy.py, traces only): entry would fire on 3/154 canonical, 20/20 flat, 0/15 fun2/8/9. Stop rule N1-N3; goal (below Chandrupatla on both) reported; expectation written: APS ~2806, CHA ~2454.

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

PREREG_flat_analogy_2026-09-21.md

@@ -0,0 +1,59 @@
+# PREREG — вход в плоский режим по аналогии
+
+Составлено до кода и до прогона, ветка `signfix-and-gates`. Валерий: «рассмотри задачу входа в режим
+на плоских функциях с точки зрения похожести или аналогичности»; «пред-регистрируй и проверяй вход
+по аналогии».
+
+## Основание (`diag_flat_analogy.py`, трассы предложенного метода, метод не менялся)
+
+Степень xᵐ подобна сама себе: безразмерная конфигурация трёх последних точек
+ξ = (x_k − x_{k−1})/(x_{k−2} − x_{k−1}), φ = (f_k − f_{k−1})/(f_{k−2} − f_{k−1}) **повторяется**;
+у простого корня она стремится к линейному образцу φ = ξ. Два образца — прямая и собственное
+прошлое. Второе отношение аналогии: у аналогичной пары сжатие f = (сжатие x)^m, отсюда
+m = ln(сжатие f)/ln(сжатие x); у степени m ≥ 2, у случайного совпадения на простом корне ≈ 1.
+
+Моменты флага «несбывшееся обещание», по задачам:
+
+| группа | задач | флаг | + конфигурация как в прошлом | + m ≥ 2 |
+|---|---|---|---|---|
+| канонические | 154 | 142 | 80 | **3** |
+| плоские fun3–6 | 20 | 20 | 20 | **20** |
+| fun1 | 5 | 5 | 2 | 1 |
+| fun2, fun8, fun9 | 15 | 14 | 6 | 0 |
+
+Различимость не предсказывает цену прогона (урок трёх прошлых опытов) — решает прогон метода.
+
+## Правило (новых констант нет)
+
+Режим `prestep="flatanalog"`. На каждом шаге, где решает гейт, конфигурация (ξ, φ) текущей тройки
+и её масштабы |x_k − x_{k−1}|, |f_k − f_{k−1}| записываются в память прогона.
+
+- **Вход:** флаг (шаг модели, знак не сменился, r ≥ ¼) **и** ближайшая прошлая конфигурация
+  ближе к текущей, чем текущая к прямой φ = ξ (евклидово расстояние в плоскости (ξ, φ); до прямой —
+  перпендикуляр) **и** показатель подобия этой пары m ≥ 2 (граница — та же, что у флага:
+  ¼ = (1 − ½)², касательная против деления при m = 2).
+- **В режиме:** каждый шаг — середина.
+- **Выход:** на середине f(M) ближе к линейному предсказанию (FA + FB)/2, чем к нулю (как в
+  `flatstickexit`).
+
+Предохранитель применяется к шагу как всегда.
+
+## Проверка
+
+Решение по **смоуку** (он считает предложенный метод на всех 199 задачах), сервер — только
+подтвердить прошедшее. Ячейки: предложенный метод и он же с Г2 (повтор рисунка шагов);
+`none / flatanalog / flatstickexit`.
+
+| # | ПРОЙДЕНО, если |
+|---|---|
+| **N1** | широкие скобки ниже, чем без режима (3220; с Г2 — 3169) |
+| **N2** | канонические не выше, чем без режима (2806; с Г2 — 2782) |
+| **N3** | гарантия: 0 нарушений, решено ≥ 193 |
+| **N4** | сообщается: задач с входом по группам (сверка с таблицей выше) |
+| **ЦЕЛЬ** | канонические < 2787 **и** широкие < 2441 (Чандрупатла) — сообщается, выполнена ли |
+
+**Правило остановки:** вход по аналогии принимается в метод, если N1, N2, N3 выполнены одновременно.
+
+**Ожидание, записано заранее:** при входе ровно там, где в таблице, канонические ≈ 2806 (без Г2 цель
+по ним не достигается и при идеальном входе — не хватает ≈ 19), широкие ≈ 2454 (fun9: 105 против 55
+у Чандрупатлы — отдельная причина). Цель, вероятно, достижима лишь с Г2 или с «дефектом».

diag_flat_analogy.py

@@ -0,0 +1,111 @@
+"""Premise check for entry into the flat regime by ANALOGY (Valeri, 2026-09-21: "рассмотри
+задачу входа в режим на плоских функциях с точки зрения похожести или аналогичности").
+
+A pure power f = c(x-r)^m is self-similar: zooming about the root maps every configuration
+of points onto an earlier one (x scaled by L, f by L^m).  So the DIMENSIONLESS configuration
+of the last three points,
+    xi  = (x_k - x_{k-1}) / (x_{k-2} - x_{k-1}),
+    phi = (f_k - f_{k-1}) / (f_{k-2} - f_{k-1}),
+RECURS.  At a simple root, zooming in makes f look like its tangent, and the configuration
+approaches the LINEAR prototype phi = xi (exact for a linear f) instead.  The static
+distance to the line cannot tell them apart (fun1 on a wide bracket looks as non-linear as
+x^9 - diag_contraction_similarity.py); the question is which prototype the configuration
+is NEARER to: the line, or its own past.
+
+Nearest-prototype judgment, ordinal, no threshold:
+    d_line = |phi - xi| / sqrt(2)                       (distance to the line phi = xi)
+    d_past = min over earlier states j of |(xi, phi)_k - (xi, phi)_j|   (Euclidean)
+    analogous-to-past  <=>  d_past < d_line
+Measured at the moments the unkept-promise flag rises (model step, no crossing, r >= 1/4),
+on the proposed rule (projection) with no regime, via the behaviour-neutral trace hook.
+Reported per PROBLEM (entry happens once per problem), per group.  Nothing in the method
+changes.
+
+    python -u diag_flat_analogy.py
+"""
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+
+from simroot.pure import pure_root
+from sweep_full import MAXFEV, XTOL, load_problems
+
+FLAT = ("fun3", "fun4", "fun5", "fun6")
+
+
+def config(s):
+    x, fx, xp, fp, xp2, fp2 = s["x"], s["fx"], s["xp"], s["fp"], s["xp2"], s["fp2"]
+    if xp2 is None or xp2 == xp or fp2 == fp:
+        return None
+    xi = (x - xp) / (xp2 - xp)
+    phi = (fx - fp) / (fp2 - fp)
+    if not (math.isfinite(xi) and math.isfinite(phi)):
+        return None
+    return xi, phi
+
+
+def group(s, pid):
+    if s == "APS":
+        return "APS"
+    fam = pid.split(".")[0]
+    return "CHA-flat" if fam in FLAT else f"CHA-{fam}"
+
+
+def pair_order(cur, old):
+    """The order the analogy itself implies: between two analogous states the x-scale
+    shrank by L and the f-scale by L^m, so m = ln(f ratio) / ln(x ratio).  Scales are the
+    last step |x_k - x_(k-1)| and its |f_k - f_(k-1)|.  None when undefined."""
+    lx = cur[2] / old[2] if old[2] > 0.0 else math.nan
+    lf = cur[3] / old[3] if old[3] > 0.0 else math.nan
+    if not (math.isfinite(lx) and math.isfinite(lf)) or lx <= 0.0 or lf <= 0.0 or lx == 1.0:
+        return None
+    return math.log(lf) / math.log(lx)
+
+
+def main():
+    per = defaultdict(lambda: [0, 0, 0, 0])  # problems, flag, flag & analogous, + order >= 2
+    ev = defaultdict(lambda: [0, 0, 0])    # flag events, analogous, analogous with m >= 2
+    for s, pid, f, a, b, _root in load_problems():
+        st = {"trace": []}
+        pure_root(f, a, b, XTOL, MAXFEV, similarity="ratio", scale="derived3",
+                  guard="project", stats=st)
+        g = group(s, pid)
+        per[g][0] += 1
+        past = []                          # (xi, phi, |dx|, |df|) of earlier states
+        flag_ever = ana_ever = ord_ever = False
+        for s_ in st["trace"]:
+            c = config(s_)
+            fx, fp = s_["fx"], s_["fp"]
+            flag = fp is not None and fp != 0.0 and fx / fp >= 0.25
+            if c is not None:
+                cur = (c[0], c[1], abs(s_["x"] - s_["xp"]), abs(fx - fp))
+            if c is not None and flag:
+                d_line = abs(c[1] - c[0]) / math.sqrt(2.0)
+                best = min(past, key=lambda q: math.hypot(c[0] - q[0], c[1] - q[1]),
+                           default=None)
+                ana = best is not None and math.hypot(c[0] - best[0], c[1] - best[1]) < d_line
+                m = pair_order(cur, best) if ana else None
+                steep = m is not None and m >= 2.0
+                ev[g][0] += 1
+                ev[g][1] += ana
+                ev[g][2] += steep
+                flag_ever = True
+                ana_ever = ana_ever or ana
+                ord_ever = ord_ever or steep
+            if c is not None:
+                past.append(cur)
+        per[g][1] += flag_ever
+        per[g][2] += ana_ever
+        per[g][3] += ord_ever
+    print(f"{'group':<10} {'problems':>8} {'flag':>6} {'flag&analog':>12} {'&m>=2':>7}"
+          f"   events: {'flag':>5} {'analog':>7} {'&m>=2':>6}")
+    for g in sorted(per):
+        n, fl, an, od = per[g]
+        e, a, o = ev[g]
+        print(f"{g:<10} {n:8d} {fl:6d} {an:12d} {od:7d}   {'':8}{e:5d} {a:7d} {o:6d}")
+    print("diag done")
+
+
+if __name__ == "__main__":
+    main()

results_diag_flat_analogy.txt

@@ -0,0 +1,9 @@
+group      problems   flag  flag&analog   &m>=2   events:  flag  analog  &m>=2
+APS             154    142           80       3             420     102      7
+CHA-flat         20     20           20      20             678     324    319
+CHA-fun1          5      5            2       1              24       2      1
+CHA-fun2          5      5            3       0              73      57      0
+CHA-fun7          5      5            3       3              68      28     27
+CHA-fun8          5      5            0       0               8       0      0
+CHA-fun9          5      4            3       0              50      18      0
+diag done