From 42bfab4330fbd480cd9a51fa988e1c99007ad6a9 Mon Sep 17 00:00:00 2001 From: Valeri Sitnikov Date: Mon, 21 Sep 2026 14:48:30 +0100 Subject: [PATCH] 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 --- PREREG_flat_analogy_2026-09-21.md | 59 ++++++++++++++++ diag_flat_analogy.py | 111 ++++++++++++++++++++++++++++++ results_diag_flat_analogy.txt | 9 +++ 3 files changed, 179 insertions(+) create mode 100644 PREREG_flat_analogy_2026-09-21.md create mode 100644 diag_flat_analogy.py create mode 100644 results_diag_flat_analogy.txt diff --git a/PREREG_flat_analogy_2026-09-21.md b/PREREG_flat_analogy_2026-09-21.md new file mode 100644 index 0000000..f22cb1b --- /dev/null +++ b/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 или с «дефектом». diff --git a/diag_flat_analogy.py b/diag_flat_analogy.py new file mode 100644 index 0000000..89afe6f --- /dev/null +++ b/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() diff --git a/results_diag_flat_analogy.txt b/results_diag_flat_analogy.txt new file mode 100644 index 0000000..4ff6e36 --- /dev/null +++ b/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