vvs/sim-numerics
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
40 Commits 1 Branch 0 Tags
9884b2120465d01667f4c514af413ddc7e53e189
T
Clone
Open with VS Code Open with VSCodium Open with Intellij IDEA
Download ZIP Download TAR.GZ Download BUNDLE
vvsandClaude Opus 5 9884b21204 PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037. 
Mechanism: the flat cycle is undershoot, undershoot, crossing, near-empty step. The single flag fires after the first undershoot and replaces the second - a useless step; the twice flag fires after the second and replaces the CROSSING, the one step of the cycle that collapses the bracket. The second undershoot's r is ~0.26, next to the 1/4 threshold, so the pair often does not even form. Again a detectability gain that did not carry to run cost. Next candidate (not pre-registered): the unkept promise AND a creep - the same step moving the same way as the previous one.

Removed a vacuous pin I had written (s2 <= max(s1, s2)). Regression on the branch: 935 pass twice; the only red test is the paper-number check.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-21 13:45:20 +01:00
anc
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
article
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
odestep
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
relax
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
simroot
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
tests
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
.gitignore
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
analyze_decision.py
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
analyze_extrap2.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
analyze_extrap.py
A in the method (extrapolate='steps', default 'none' = published bit for bit): NOT accepted into the proposed rule by the declared stop rule - X2 fails. Proposed rule without -> with A: APS 2806 -> 2967 (X2 FAIL), CHA 3220 -> 2925 (X1 pass), flat fun3-6 1823 -> 1524 (X4 pass), guarantee intact, 0 violations in 39 family cells (X3 pass). The per-problem edge over Chandrupatla on APS is lost (87/24/42, p=9e-5 -> 42/62/49, p=0.53).
2026-09-21 12:11:06 +01:00
analyze_flat.py
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
analyze_order.py
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
audit_algorithm.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
audit_chandrupatla_library.py
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
audit_chandrupatla_tolerance.py
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
audit_head_to_head.py
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
audit_similarity_places.py
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
bench_full.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
compare_log_vs_x.py
logarithmic march MEASURED and REFUTED: APS 6940 vs the published 2806 (2.5x worse), CHA 3115 vs the 2857 target, two sets 10414 vs <6026; the mechanism did work in the predicted direction (CHA 4516 -> 3115 = 1.45x) but the canonical set pays for it — the same trade that ended the four previous attempts, now measured for the transform too. Guarantee intact everywhere (over2x = 0)
2026-09-20 22:59:42 +01:00
diag_band_by_family.py
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
diag_cha_gap.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_cha_phases.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_contraction_sequence.py
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
diag_contraction_similarity.py
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
diag_empty_step.py
PREREG before the run: the empty-step feature (similarity of |f_n| to |f_n-1|, rule S > 1/2, the bisection constant) and the repeating-pattern feature with the period chosen from the data (lag maximising the mean ratio similarity of rho_j and rho_j-p over the history, lags up to half the history). Detectability only; criteria E1/E2/R1/R2 and the falsifier declared; no rule in the method.
2026-09-21 11:23:02 +01:00
diag_flat_detectable.py
The new sections move into the canonical text, article/sim_numerics.md (Valeri's decision): section 7 'Where the similarity is read' with 7.1 per-place similarity, 7.2 the decision place, 7.3 the fun7 scoring artefact, 7.4 the gap decomposition; negative results 8-11 appended so items 1-7 keep their numbers; abstract paragraph; Future work rewritten (the refuted log transform removed); item 6 now says aps.13.00 is a scoring artefact, not a method failure. Translated into the .md's revised names: code 'ratio' = the tent max(0,1-|z|), code 'rational' = the ratio similarity 1/(1+|z|); the proposed method stays the .md's (tent, 3-point, projection).
2026-09-21 07:48:55 +01:00
diag_flat_flag.py
PREREG before code and run: flat regime recognised by the model's unkept promise - after a model step that did not cross the root, r = f_new/f_old >= 1/4, the break-even of a tangent step against a halving at m = 2 ((1-1/2)^2). Stage 1 detectability (F1), stage 2 in the method only if stage 1 passes (Z1-Z5, stop rule).
2026-09-21 13:02:40 +01:00
diag_flat_twice.py
PREREG before code and run: flat regime by the promise failing TWICE in a row (same r* = 1/4, a counter of consecutive unkept model steps, any other step resets it). Stage 1 detectability (T1, T2 against the single flag's 2.48 ratio), stage 2 in the method only if stage 1 passes (W1-W5, stop rule).
2026-09-21 13:35:37 +01:00
diag_fun1_endgame.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_fun7_root.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_fun7.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_model_order_checks.py
The new sections move into the canonical text, article/sim_numerics.md (Valeri's decision): section 7 'Where the similarity is read' with 7.1 per-place similarity, 7.2 the decision place, 7.3 the fun7 scoring artefact, 7.4 the gap decomposition; negative results 8-11 appended so items 1-7 keep their numbers; abstract paragraph; Future work rewritten (the refuted log transform removed); item 6 now says aps.13.00 is a scoring artefact, not a method failure. Translated into the .md's revised names: code 'ratio' = the tent max(0,1-|z|), code 'rational' = the ratio similarity 1/(1+|z|); the proposed method stays the .md's (tent, 3-point, projection).
2026-09-21 07:48:55 +01:00
diag_model_order.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_outcome_memory.py
PREREG B before the run: outcome memory - bisect when the most similar past state (ratio similarity of the contraction rho, select not weight, ties -> most recent) bought less than one halving. Replay check, criteria B1-B4 and falsifier declared.
2026-09-21 11:48:13 +01:00
diag_rescore_aps.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_rescore_cha.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_sign_flips.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diag_solved41.py
chasing Chandrupatla found a property of the BENCHMARK: on all five fun7 problems f vanishes identically near the declared root (f(0+t)=0 up to 3.2e-2), every method stops at a point where f(x)=0 exactly and is scored a failure by the |x-root|<=1e-6 rule — so 1000 evaluations of EVERY wide-bracket total are an artefact and the universal '40 of 45' is a scoring statement. Re-scored: 45/45 for everyone but Brent, ranking unchanged, gap to Chandrupatla 253 (17%) and diffuse across 8 families. Written into the paper with its reproducing scripts; pdflatex clean, verifier green
2026-09-20 23:57:49 +01:00
diag_step_extrapolation.py
Metric defect found by B's first run (mean = inf): an exact hit made the new width 0 and the floor (ulp of the root, 5e-324 when the root is 0) overflowed. Fixed to XTOL - an exact hit ends the run, so it is worth the halvings still needed to reach xtol - identical for every candidate; A re-run with it.
2026-09-21 11:49:39 +01:00
diag_who_caps_us.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
diff_sweeps.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
explain_chandrupatla.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
FINDINGS_decision_place.md
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
FINDINGS_logarithmic.md
explained, with numbers: Chandrupatla wins the probe by REFUSING its model cheaply, not by trusting it — it accepts the interpolation on only 28% of steps, its gate costs zero evaluations (read from data already in hand) and its refusal branch still halves the bracket; ours repairs 77.5% of evaluations after the fact and drops to 0.92 halvings/eval on fun8/fun9, worse than bisection. In similarity terms: their similarity is a PRE-step GATE on dimensionless ratios (a neighbourhood of the linear configuration), ours is an IN-step SCALE on the residual magnitude — the PLACEMENT of the reading matters more than its form
2026-09-20 23:05:22 +01:00
FINDINGS_model_order.md
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
FINDINGS_points_direction.md
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
FINDINGS_prestep_gate.md
pre-step gate MEASURED: repairs 77.5% -> 15.9%, CHA hits the ITP target for the first time (2851 <= 2857), two sets 7440 (best of the line) — but APS grows 2806 -> 4449, so by the pre-registered stop rule the mode is NOT accepted. Cause named: my gate refuses on BRACKET PROGRESS, and this project had already measured that currency to be wrong (a secant step collapses the error while barely moving the bracket: 150 vs 86). Chandrupatla refuses on the SHAPE of the configuration. Next candidate derived, not borrowed: slope-stability gate
2026-09-20 23:15:48 +01:00
FINDINGS_similarity_per_slot.md
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
FINDINGS_slope_gate.md
slope-stability gate: the PROJECT'S OWN target is met for the first time — 5922 < 6026 over both sets at 193/199 with the guarantee intact (slope.ratio.derived3.project: APS 2848 + CHA 3074), CHA improves 4516 -> 2903 (x1.56), repairs 77.5% -> 55.3%. Honest cost: APS 2806 -> 2848, which moves us from 1st to 3rd on the canonical set (chandrupatla 2785, toms748 2820), so my stricter S1 fails while the project target passes — a positioning decision, recorded not resolved. Refusal CURRENCY is what decides: bracket progress 4449 vs model shape 2848, a 1601-evaluation difference for the same 'refuse before the step' idea
2026-09-20 23:27:43 +01:00
measure_budget_factor.py
§3.1 and Tables 2-3 of the canonical .md brought to current data (Valeri's request). §3.1 said the projection's doubling 'is not a tuning constant' and that zero slack 'behaves as bisection'; both are refuted by measurement (stage12 part 3, rerun as measure_budget_factor.py): the canonical total is 2806 for every multiplier >= 1.25, but the wide-bracket total moves monotonically, 2752 at 1.25 to 4006 at 4, and multiplier 1 costs 4817/2997, nowhere near bisection's 7530/3090. So the proposed safeguard is the EARNED projection (credit, C0 = 1 bit: bisection + 1 step, the cheapest endowment within that promise, 8395 -> 7658 -> 6588), as code and verifier had already fixed but no text said; the scheduled projection stays as the one-constant end of the trade. The text says openly that this choice was made after a question, and that it was not made for the numbers - on the canonical set it costs 762 more.
2026-09-21 08:03:21 +01:00
measure_inertness.py
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
measure_records_vs_multiplier.py
§3.1 and Tables 2-3 of the canonical .md brought to current data (Valeri's request). §3.1 said the projection's doubling 'is not a tuning constant' and that zero slack 'behaves as bisection'; both are refuted by measurement (stage12 part 3, rerun as measure_budget_factor.py): the canonical total is 2806 for every multiplier >= 1.25, but the wide-bracket total moves monotonically, 2752 at 1.25 to 4006 at 4, and multiplier 1 costs 4817/2997, nowhere near bisection's 7530/3090. So the proposed safeguard is the EARNED projection (credit, C0 = 1 bit: bisection + 1 step, the cheapest endowment within that promise, 8395 -> 7658 -> 6588), as code and verifier had already fixed but no text said; the scheduled projection stays as the one-constant end of the trade. The text says openly that this choice was made after a question, and that it was not made for the numbers - on the canonical set it costs 762 more.
2026-09-21 08:03:21 +01:00
NEXT_PAPER_logarithmic.md
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
numbers_for_article.py
paper updated with the placement results and machine-checked: new section 'Where the similarity is read' (2527 on APS below every method measured, 5511 over both sets, the non-composition of the two readings, and the two negatives with their numbers), abstract extended, verify_article.py now also checks every new number against its own sweep file — all green, pdflatex clean
2026-09-20 23:52:13 +01:00
PREREG_decision_place_2026-09-21.md
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
PREREG_empty_step_2026-09-21.md
PREREG before the run: the empty-step feature (similarity of |f_n| to |f_n-1|, rule S > 1/2, the bisection constant) and the repeating-pattern feature with the period chosen from the data (lag maximising the mean ratio similarity of rho_j and rho_j-p over the history, lags up to half the history). Detectability only; criteria E1/E2/R1/R2 and the falsifier declared; no rule in the method.
2026-09-21 11:23:02 +01:00
PREREG_extrapolate_in_method_2026-09-21.md
PREREG before code and run: step extrapolation (A) inside the method - step/(1-S) with S the ratio similarity of the proposed step and the previous displacement, capped at the far end; paired grid; criteria X1-X5 and stop rule declared against the library baselines.
2026-09-21 11:56:36 +01:00
PREREG_extrapolation_gates_2026-09-21.md
PREREG before code and run: when is lengthening appropriate - G1 confirmed geometric series of three steps, G2 repeating step pattern with the period from the data (gate S_R > 1/2), G3 steps AND results (1/(1-min(S_step, S_res)), S_res = 0 after a sign change). Five-way paired grid, criteria Y1-Y6, stop rule: accept only if Y1, Y2 and Y3 all hold.
2026-09-21 12:16:25 +01:00
PREREG_flat_regime_2026-09-21.md
PREREG before code and run: flat regime recognised by the model's unkept promise - after a model step that did not cross the root, r = f_new/f_old >= 1/4, the break-even of a tangent step against a halving at m = 2 ((1-1/2)^2). Stage 1 detectability (F1), stage 2 in the method only if stage 1 passes (Z1-Z5, stop rule).
2026-09-21 13:02:40 +01:00
PREREG_flat_twice_2026-09-21.md
PREREG before code and run: flat regime by the promise failing TWICE in a row (same r* = 1/4, a counter of consecutive unkept model steps, any other step resets it). Stage 1 detectability (T1, T2 against the single flag's 2.48 ratio), stage 2 in the method only if stage 1 passes (W1-W5, stop rule).
2026-09-21 13:35:37 +01:00
PREREG_logarithmic_2026-09-20.md
logarithmic space mode: pure_root gains space='x'|'log' (default reproduces the published grid bit-for-bit), u = sign(x-c)*log1p(|x-c|/xtol) with c = the end of smaller |f| and s = xtol fixed by derivation; gates G1/G2' pinned by tests/test_log_space.py (7 green); sweep writes the log grid to its OWN sweep_log.json so the verified sweep_full.json is untouched
2026-09-20 22:52:58 +01:00
PREREG_outcome_memory_2026-09-21.md
PREREG B before the run: outcome memory - bisect when the most similar past state (ratio similarity of the contraction rho, select not weight, ties -> most recent) bought less than one halving. Replay check, criteria B1-B4 and falsifier declared.
2026-09-21 11:48:13 +01:00
PREREG_points_and_direction_2026-09-21.md
two more places for similarity: points='shape' (WHICH triple the model uses, argmin |phi-xi| over declared candidates — select, never weight) and direction='dissimilar' (the far end read by |f| rather than by distance); defaults bit-identical, P1-P5 pinned (7 green), inertness counters make an inert mode a failed EXPERIMENT rather than a pass; each grid writes to its own file
2026-09-20 23:39:41 +01:00
PREREG_prestep_gate_2026-09-21.md
pre-step gate: prestep='none'|'progress' (default bit-identical), refuse the similarity step BEFORE spending an evaluation when it promises less progress than bisection — two lengths already in hand, no new constant; R1-R4 pinned by tests/test_prestep_gate.py (6 green); the gate grid writes to its OWN sweep_gate.json
2026-09-20 23:12:34 +01:00
PREREG_scale_selection_2026-09-21.md
Valeri's objection measured: the principle is right (a similarity step should be large far away and small near), and our sigma = |f'|D defeats it — at x=1e4 on a 2e4 bracket the normalised residual is 0.167, so S=0.833 'similar' and the step is small five thousand step-lengths from the root. Selecting sigma = min(|f'|D, max|f| at the ends) — no new constant — improves 403 to 390 on eight hand-picked wide problems but is WORSE over the grid: APS 3288 vs 2726, CHA 3111 vs 2683, so the mode is rejected by its pre-registered rule. Its extra solves are two fun7 problems landing inside the flat zero region, i.e. the scoring artefact and not a capability. Written into Negative results as the answer to the natural objection
2026-09-21 00:19:03 +01:00
PREREG_similarity_per_slot_2026-09-21.md
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
PREREG_slope_gate_2026-09-21.md
slope-stability gate: the PROJECT'S OWN target is met for the first time — 5922 < 6026 over both sets at 193/199 with the guarantee intact (slope.ratio.derived3.project: APS 2848 + CHA 3074), CHA improves 4516 -> 2903 (x1.56), repairs 77.5% -> 55.3%. Honest cost: APS 2806 -> 2848, which moves us from 1st to 3rd on the canonical set (chandrupatla 2785, toms748 2820), so my stricter S1 fails while the project target passes — a positioning decision, recorded not resolved. Refusal CURRENCY is what decides: bracket progress 4449 vs model shape 2848, a 1601-evaluation difference for the same 'refuse before the step' idea
2026-09-20 23:27:43 +01:00
PREREG_step_extrapolation_2026-09-21.md
PREREG A before the run: similarity of successive steps as the multiplier, step d_n/(1-S), S = ratio similarity of the two displacements (0 if opposite). Replay check, one extra evaluation per state for our step, step A and the midpoint; criteria A1-A4 and falsifier declared; the one-step limitation declared.
2026-09-21 11:46:59 +01:00
README.md
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
report_sweep.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
results_analyze_extrap2.txt
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
results_analyze_extrap.txt
A in the method (extrapolate='steps', default 'none' = published bit for bit): NOT accepted into the proposed rule by the declared stop rule - X2 fails. Proposed rule without -> with A: APS 2806 -> 2967 (X2 FAIL), CHA 3220 -> 2925 (X1 pass), flat fun3-6 1823 -> 1524 (X4 pass), guarantee intact, 0 violations in 39 family cells (X3 pass). The per-problem edge over Chandrupatla on APS is lost (87/24/42, p=9e-5 -> 42/62/49, p=0.53).
2026-09-21 12:11:06 +01:00
results_analyze_flat2.txt
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
results_analyze_flat.txt
Flat regime (PREREG_flat_regime): the unkept-promise flag - after a model step that did not cross the root, r = f_new/f_old >= 1/4, the tangent-versus-halving break-even at m = 2 - RECOGNISES the regime (stage 1: 53.6% of model steps flagged on the flat families against 21.6% on APS and 17.0% on fun1; recall ten times the m>=2 estimator's 5.8%) and cuts the wide-bracket set by 350-490 wherever the budget does not already bind: safe 3390 -> 3037, step 3524 -> 3037, unguarded 4104 -> 3198.
2026-09-21 13:25:56 +01:00
results_audit_chandrupatla_library.txt
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
results_audit_chandrupatla_tolerance.txt
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
results_audit_head_to_head.txt
Audit on Valeri's challenge: our Chandrupatla implementation stops below 2*xtol (tl = tol/span > 1/2) while every other method, SciPy's included, stops at xtol; the protocol corrected that factor for ITP and not here, and best_of let the looser run win. Corrected it costs Chandrupatla 2 evaluations on APS (2785 -> 2787) and 18 on CHA (2423 -> 2441): real, in the competitor's favour, and not what changes the picture. The public scipy.optimize.elementwise.find_root, the private _chandrupatla and ours corrected agree on all 199 problems exactly.
2026-09-21 10:14:42 +01:00
results_audit_similarity_places.txt
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
results_budget_factor.txt
§3.1 and Tables 2-3 of the canonical .md brought to current data (Valeri's request). §3.1 said the projection's doubling 'is not a tuning constant' and that zero slack 'behaves as bisection'; both are refuted by measurement (stage12 part 3, rerun as measure_budget_factor.py): the canonical total is 2806 for every multiplier >= 1.25, but the wide-bracket total moves monotonically, 2752 at 1.25 to 4006 at 4, and multiplier 1 costs 4817/2997, nowhere near bisection's 7530/3090. So the proposed safeguard is the EARNED projection (credit, C0 = 1 bit: bisection + 1 step, the cheapest endowment within that promise, 8395 -> 7658 -> 6588), as code and verifier had already fixed but no text said; the scheduled projection stays as the one-constant end of the trade. The text says openly that this choice was made after a question, and that it was not made for the numbers - on the canonical set it costs 762 more.
2026-09-21 08:03:21 +01:00
results_cha_gap.txt
chasing Chandrupatla found a property of the BENCHMARK: on all five fun7 problems f vanishes identically near the declared root (f(0+t)=0 up to 3.2e-2), every method stops at a point where f(x)=0 exactly and is scored a failure by the |x-root|<=1e-6 rule — so 1000 evaluations of EVERY wide-bracket total are an artefact and the universal '40 of 45' is a scoring statement. Re-scored: 45/45 for everyone but Brent, ranking unchanged, gap to Chandrupatla 253 (17%) and diffuse across 8 families. Written into the paper with its reproducing scripts; pdflatex clean, verifier green
2026-09-20 23:57:49 +01:00
results_cha_phases.txt
the wide-bracket gap is NOT closed, and now it has an address: the STEP RULE, not the guarantee and not the reading places. fun1 is one function at growing widths — 7/8, 12/12, 19/15, 59/24, 63/44 — so we tie when narrow and lose as it widens, while our observed order is the HIGHER one (3.63 vs 2.02); 59 on a 2e4 bracket is what bisection needs, i.e. one halving per evaluation against their 2.3. With the safeguard removed entirely we still spend 46/57/61/68 against bisection 57/77/45/45 and Chandrupatla 24/44 — worse than bisection on two of them. |f|/|f'| is an absolute length and cannot march across decades; written into the paper as the stated limit. Also fixed a tracer bug that had best_of double-counting evaluations (2993 vs 1487)
2026-09-21 00:09:18 +01:00
results_diag_A_B_fixed_metric.txt
Metric defect found by B's first run (mean = inf): an exact hit made the new width 0 and the floor (ulp of the root, 5e-324 when the root is 0) overflowed. Fixed to XTOL - an exact hit ends the run, so it is worth the halvings still needed to reach xtol - identical for every candidate; A re-run with it.
2026-09-21 11:49:39 +01:00
results_diag_band_by_family.txt
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
results_diag_contraction_sequence.txt
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
results_diag_contraction_similarity.txt
Two audits, both on existing data or traces, method untouched. (1) Where S is evaluated: only in the step length (and simpair, and two refuted modes); the slope gate, the triple by shape, the far end and 'defect' decide by comparing - which is a similarity judgment of the ordinal kind ('which is more similar'), where every decreasing S gives the same decision. Their gains depend strongly on the S in the STEP: triple by shape -493 with the tent, up to +250 with others; defect -283 with the tent, up to +215. The records are the pairing of the tent step with those judgments.
2026-09-21 11:16:08 +01:00
results_diag_empty_step.txt
Outcome of PREREG_empty_step: both features FAIL by the declared criteria. Empty step (similarity of |f_n| to |f_n-1|): AUC 0.45/0.53/0.34 (proposed) and 0.46/0.51/0.31 (reading 3) against APS/fun1/other CHA; on the proposed rule it fires MORE on APS (36.0%) than on the flat families (18.9%). Repeating pattern with the period chosen from the data: separates the flat families from APS and fun1 (AUC 0.69/0.77 and 0.66/0.67; fires 77.1% vs 37.7%/38.2%, and 18.0% vs 6.2%/9.5%) but not from the other CHA families (AUC 0.41 and 0.22; fires 72.4% and 68.6%), so R1 fails and no rule is built.
2026-09-21 11:23:47 +01:00
results_diag_flat_detectable.txt
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
results_diag_flat_flag.txt
Flat regime (PREREG_flat_regime): the unkept-promise flag - after a model step that did not cross the root, r = f_new/f_old >= 1/4, the tangent-versus-halving break-even at m = 2 - RECOGNISES the regime (stage 1: 53.6% of model steps flagged on the flat families against 21.6% on APS and 17.0% on fun1; recall ten times the m>=2 estimator's 5.8%) and cuts the wide-bracket set by 350-490 wherever the budget does not already bind: safe 3390 -> 3037, step 3524 -> 3037, unguarded 4104 -> 3198.
2026-09-21 13:25:56 +01:00
results_diag_flat_twice.txt
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
results_diag_model_order_checks.txt
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
results_diag_model_order.txt
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
results_diag_outcome_memory.txt
Metric defect found by B's first run (mean = inf): an exact hit made the new width 0 and the floor (ulp of the root, 5e-324 when the root is 0) overflowed. Fixed to XTOL - an exact hit ends the run, so it is worth the halvings still needed to reach xtol - identical for every candidate; A re-run with it.
2026-09-21 11:49:39 +01:00
results_diag_step_extrapolation.txt
Outcome of PREREG A: PASSED on every declared criterion, both configurations. Paired, per one evaluation from the same state, bracket halvings: flat families 0.26 -> 2.87 (proposed) and 0.36 -> 1.16 (reading 3), i.e. above bisection's 1.00 (A1, A3); canonical set 8.21 -> 10.05 and 12.15 -> 12.96, no harm (A2); fun1 7.36 -> 9.01 and 7.28 -> 11.46. S > 0 on about half the canonical states (A4). Step A leaves the bracket on 6-28% of the states where it acts; excluded here, projected in a real method. One-step replay only - the whole-run effect needs the rule in the method, a separate pre-registration.
2026-09-21 11:47:42 +01:00
results_diags_library.txt
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
results_diff_signfix.txt
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
results_diff_sweeps.txt
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
results_explain_chandrupatla.txt
explained, with numbers: Chandrupatla wins the probe by REFUSING its model cheaply, not by trusting it — it accepts the interpolation on only 28% of steps, its gate costs zero evaluations (read from data already in hand) and its refusal branch still halves the bracket; ours repairs 77.5% of evaluations after the fact and drops to 0.92 halvings/eval on fun8/fun9, worse than bisection. In similarity terms: their similarity is a PRE-step GATE on dimensionless ratios (a neighbourhood of the linear configuration), ours is an IN-step SCALE on the residual magnitude — the PLACEMENT of the reading matters more than its form
2026-09-20 23:05:22 +01:00
results_fun1_endgame.txt
the wide-bracket gap is NOT closed, and now it has an address: the STEP RULE, not the guarantee and not the reading places. fun1 is one function at growing widths — 7/8, 12/12, 19/15, 59/24, 63/44 — so we tie when narrow and lose as it widens, while our observed order is the HIGHER one (3.63 vs 2.02); 59 on a 2e4 bracket is what bisection needs, i.e. one halving per evaluation against their 2.3. With the safeguard removed entirely we still spend 46/57/61/68 against bisection 57/77/45/45 and Chandrupatla 24/44 — worse than bisection on two of them. |f|/|f'| is an absolute length and cannot march across decades; written into the paper as the stated limit. Also fixed a tracer bug that had best_of double-counting evaluations (2993 vs 1487)
2026-09-21 00:09:18 +01:00
results_fun7_root.txt
chasing Chandrupatla found a property of the BENCHMARK: on all five fun7 problems f vanishes identically near the declared root (f(0+t)=0 up to 3.2e-2), every method stops at a point where f(x)=0 exactly and is scored a failure by the |x-root|<=1e-6 rule — so 1000 evaluations of EVERY wide-bracket total are an artefact and the universal '40 of 45' is a scoring statement. Re-scored: 45/45 for everyone but Brent, ranking unchanged, gap to Chandrupatla 253 (17%) and diffuse across 8 families. Written into the paper with its reproducing scripts; pdflatex clean, verifier green
2026-09-20 23:57:49 +01:00
results_records_vs_multiplier.txt
§3.1 and Tables 2-3 of the canonical .md brought to current data (Valeri's request). §3.1 said the projection's doubling 'is not a tuning constant' and that zero slack 'behaves as bisection'; both are refuted by measurement (stage12 part 3, rerun as measure_budget_factor.py): the canonical total is 2806 for every multiplier >= 1.25, but the wide-bracket total moves monotonically, 2752 at 1.25 to 4006 at 4, and multiplier 1 costs 4817/2997, nowhere near bisection's 7530/3090. So the proposed safeguard is the EARNED projection (credit, C0 = 1 bit: bisection + 1 step, the cheapest endowment within that promise, 8395 -> 7658 -> 6588), as code and verifier had already fixed but no text said; the scheduled projection stays as the one-constant end of the trade. The text says openly that this choice was made after a question, and that it was not made for the numbers - on the canonical set it costs 762 more.
2026-09-21 08:03:21 +01:00
results_rescore_aps.txt
the scoring artefact is in BOTH sets: aps.13.00 joins the five fun7 problems — 6 of 199 problems where f underflows to exactly zero on a ~3.2e-2 neighbourhood of the declared root, so every method returns a genuine root (|f(x)| below the smallest normal) and every method is scored a failure. About 1150 evaluations of EVERY two-set total are this artefact; re-scored, all methods solve 199/199 except Brent 197. Ranking unchanged: ours-by-shape 2337 on APS against chandrupatla 2593, chandrupatla 1487 on CHA against our 1740. Written into the paper as a table with both criteria; pdflatex clean, verifier green
2026-09-21 00:01:35 +01:00
results_rescore_cha.txt
chasing Chandrupatla found a property of the BENCHMARK: on all five fun7 problems f vanishes identically near the declared root (f(0+t)=0 up to 3.2e-2), every method stops at a point where f(x)=0 exactly and is scored a failure by the |x-root|<=1e-6 rule — so 1000 evaluations of EVERY wide-bracket total are an artefact and the universal '40 of 45' is a scoring statement. Re-scored: 45/45 for everyone but Brent, ranking unchanged, gap to Chandrupatla 253 (17%) and diffuse across 8 families. Written into the paper with its reproducing scripts; pdflatex clean, verifier green
2026-09-20 23:57:49 +01:00
results_sign_flips.txt
CORRECTION, prompted by Valeri: the step IS a fraction of the bracket — with the ratio similarity 1-S = min(1,|f|/(|f'|D)) so step = min(D,|f|/|f'|) — and my 'absolute length cannot march' was wrong, as was the follow-up guess that we creep along one side: measured, 91.5% of our probes DO shrink the bracket, more often than Chandrupatla's 87.5%. What differs is how much each probe removes: 0.93 halvings per evaluation against 2.26. A linear model of the value axis undershoots on a wide bracket of a convex function, so the new bracket is about half; inverse quadratic interpolation lands near the root and removes four fifths. The limit is the ORDER OF THE MODEL the similarity is read against, and all three parameter-free ways round it are now measured failures (cbrt, log change of variable, derived3_m). Paper corrected
2026-09-21 00:12:58 +01:00
results_sweep_cap.txt
Valeri's objection measured: the principle is right (a similarity step should be large far away and small near), and our sigma = |f'|D defeats it — at x=1e4 on a 2e4 bracket the normalised residual is 0.167, so S=0.833 'similar' and the step is small five thousand step-lengths from the root. Selecting sigma = min(|f'|D, max|f| at the ends) — no new constant — improves 403 to 390 on eight hand-picked wide problems but is WORSE over the grid: APS 3288 vs 2726, CHA 3111 vs 2683, so the mode is rejected by its pre-registered rule. Its extra solves are two fun7 problems landing inside the flat zero region, i.e. the scoring artefact and not a capability. Written into Negative results as the answer to the natural objection
2026-09-21 00:19:03 +01:00
results_sweep_combo.txt
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
results_sweep_decision.txt
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
results_sweep_direction.txt
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
results_sweep_gate.txt
pre-step gate MEASURED: repairs 77.5% -> 15.9%, CHA hits the ITP target for the first time (2851 <= 2857), two sets 7440 (best of the line) — but APS grows 2806 -> 4449, so by the pre-registered stop rule the mode is NOT accepted. Cause named: my gate refuses on BRACKET PROGRESS, and this project had already measured that currency to be wrong (a secant step collapses the error while barely moving the bracket: 150 vs 86). Chandrupatla refuses on the SHAPE of the configuration. Next candidate derived, not borrowed: slope-stability gate
2026-09-20 23:15:48 +01:00
results_sweep_log.txt
logarithmic march MEASURED and REFUTED: APS 6940 vs the published 2806 (2.5x worse), CHA 3115 vs the 2857 target, two sets 10414 vs <6026; the mechanism did work in the predicted direction (CHA 4516 -> 3115 = 1.45x) but the canonical set pays for it — the same trade that ended the four previous attempts, now measured for the transform too. Guarantee intact everywhere (over2x = 0)
2026-09-20 22:59:42 +01:00
results_sweep_order.txt
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
results_sweep_points.txt
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
results_sweep_slope.txt
slope-stability gate: the PROJECT'S OWN target is met for the first time — 5922 < 6026 over both sets at 193/199 with the guarantee intact (slope.ratio.derived3.project: APS 2848 + CHA 3074), CHA improves 4516 -> 2903 (x1.56), repairs 77.5% -> 55.3%. Honest cost: APS 2806 -> 2848, which moves us from 1st to 3rd on the canonical set (chandrupatla 2785, toms748 2820), so my stricter S1 fails while the project target passes — a positioning decision, recorded not resolved. Refusal CURRENCY is what decides: bracket progress 4449 vs model shape 2848, a 1601-evaluation difference for the same 'refuse before the step' idea
2026-09-20 23:27:43 +01:00
results_tables_for_md.txt
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
results_verify_article.txt
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
results_verify_signfix.txt
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
results_who_caps_us.txt
the wide-bracket gap is NOT closed, and now it has an address: the STEP RULE, not the guarantee and not the reading places. fun1 is one function at growing widths — 7/8, 12/12, 19/15, 59/24, 63/44 — so we tie when narrow and lose as it widens, while our observed order is the HIGHER one (3.63 vs 2.02); 59 on a 2e4 bracket is what bisection needs, i.e. one halving per evaluation against their 2.3. With the safeguard removed entirely we still spend 46/57/61/68 against bisection 57/77/45/45 and Chandrupatla 24/44 — worse than bisection on two of them. |f|/|f'| is an absolute length and cannot march across decades; written into the paper as the stated limit. Also fixed a tracer bug that had best_of double-counting evaluations (2993 vs 1487)
2026-09-21 00:09:18 +01:00
run_all_sweeps.sh
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
run_decision_sweep.sh
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
run_diag_model_order.sh
Why the wide-bracket gap remains, taken apart on the SAME evaluations: 'order of the model' explains only a third. Of the 262 evaluations lost on 33 problems, 178 sit on fun3-fun6 - pure powers of order 3, 5, 9, 19 - where no interpolating model works (our step 0.41-0.81 bracket halvings per evaluation, IQI from our own points 0.01-0.17) and Chandrupatla wins by BISECTING 93-100% of his steps; our step is slower than bisection there and our 2x-bisection guarantee licenses it. His band inside our step confirms it per family: fun4/5/6 573/456/456 -> 296/239/235 against his 293/228/228, while +164/+111/+170/+144 on fun1/2/8/9 where it refuses good steps - slot 2's total was two opposite effects summed. Only fun1 (58) is model order: IQI from our three points 10.37 halvings against our 0.62; a convex two-point step cannot carry IQI's negative weight (428/428 non-degenerate states; five underflowed to -0.0).
2026-09-21 07:38:16 +01:00
run_order_sweep.sh
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
run_regression.sh
Regression runner on the server with pytest-xdist -n 14 (installed into ~/torchenv with Valeri's consent) and BLAS threads pinned to 1: 755 passed in 2:00 and 2:04, against 5:49 single-process on the server and 3:42 on the laptop. Single-process pytest on the server is slower than the laptop; the server only pays with parallelism.
2026-09-21 07:10:31 +01:00
stage0_principle.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage0b_pure_similarity.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage0c_why_pure_fails.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage0d_derived_similarity.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage0e_guard_cost.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage1_sim_variants.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage2_guard_modes.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage2b_itp_fairness.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage3_bound_check.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage4_why.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage5_three_point.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage6_projection.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage6b_invariant.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage7_regimes.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage8_phase_detector.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage9_timing.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage10_claim_checks.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage11_crosscheck.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage12_validation.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
stage13_verdict.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
stage14_is_anything_reusable.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage15_ode.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage16_blend.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage17_anc.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage18_bulletproof.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage19_modern.py
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
stage20_prediction.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage21_cosine_vs_oracle.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage22_untuned.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
stage23_relaxation.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
summary_table.py
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
sweep_cap_smoke.json
Valeri's objection measured: the principle is right (a similarity step should be large far away and small near), and our sigma = |f'|D defeats it — at x=1e4 on a 2e4 bracket the normalised residual is 0.167, so S=0.833 'similar' and the step is small five thousand step-lengths from the root. Selecting sigma = min(|f'|D, max|f| at the ends) — no new constant — improves 403 to 390 on eight hand-picked wide problems but is WORSE over the grid: APS 3288 vs 2726, CHA 3111 vs 2683, so the mode is rejected by its pre-registered rule. Its extra solves are two fun7 problems landing inside the flat zero region, i.e. the scoring artefact and not a capability. Written into Negative results as the answer to the natural objection
2026-09-21 00:19:03 +01:00
sweep_cap.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_combo_smoke.json
similarity in two more places MEASURED: triple by shape gives APS 2527 — below the published 2806 and below EVERY baseline including chandrupatla 2785 — and far-end by dissimilarity gives CHA 2683 (the ITP target met) with 5511 over both sets (project target 6026 beaten, ITP-oracle 5871 passed). Guarantee intact everywhere, 193/199. Neither mode is inert (38.6% / 26.9% of steps changed). A+B do NOT compose: 2884/2859 is worse than either alone — select, never weight, and never assume composability
2026-09-20 23:45:55 +01:00
sweep_combo.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_decision_smoke.json
Slot 2, the decision place: Chandrupatla's own acceptance band, put inside our step rule as an instrument, does NOT close the gap - CHA 3066 (project) / 2899 (credit) against his 2423, while APS doubles 2806 -> 5432, and the band is not idle (63.6% refusals). The fifth independent test of one conclusion: the remaining gap is the ORDER of the model the step is built on, not the place the similarity is read in. By the declared stop rule (M1 and M2 both false) the 'where is the similarity read' line is closed: all four places measured.
2026-09-21 06:58:59 +01:00
sweep_decision.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_direction_smoke.json
two more places for similarity: points='shape' (WHICH triple the model uses, argmin |phi-xi| over declared candidates — select, never weight) and direction='dissimilar' (the far end read by |f| rather than by distance); defaults bit-identical, P1-P5 pinned (7 green), inertness counters make an inert mode a failed EXPERIMENT rather than a pass; each grid writes to its own file
2026-09-20 23:39:41 +01:00
sweep_direction.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_extrap2.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_extrap.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_flat2.json
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
sweep_flat.json
Flat regime (PREREG_flat_regime): the unkept-promise flag - after a model step that did not cross the root, r = f_new/f_old >= 1/4, the tangent-versus-halving break-even at m = 2 - RECOGNISES the regime (stage 1: 53.6% of model steps flagged on the flat families against 21.6% on APS and 17.0% on fun1; recall ten times the m>=2 estimator's 5.8%) and cuts the wide-bracket set by 350-490 wherever the budget does not already bind: safe 3390 -> 3037, step 3524 -> 3037, unguarded 4104 -> 3198.
2026-09-21 13:25:56 +01:00
sweep_full.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_full.py
PREREG_flat_twice outcome: stage 1 passed (twice-in-a-row fires on 27.8% of model steps on the flat families, 8.7% on APS, 4.3% on fun1; flat/APS ratio 3.20 against the single flag's 2.47), stage 2 FAILED: under the projection APS 2806 -> 2803 (W2 holds, the per-problem edge over Chandrupatla kept at 83/28/42) but CHA 3220 -> 3341 and the flat families 1823 -> 1975 (W1, W4 fail); with G2 the same. Under safe/step the twice gate is inert (3390 -> 3388) where the single one gave 3037.
2026-09-21 13:45:20 +01:00
sweep_gate_smoke.json
pre-step gate: prestep='none'|'progress' (default bit-identical), refuse the similarity step BEFORE spending an evaluation when it promises less progress than bisection — two lengths already in hand, no new constant; R1-R4 pinned by tests/test_prestep_gate.py (6 green); the gate grid writes to its OWN sweep_gate.json
2026-09-20 23:12:34 +01:00
sweep_gate.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_log_smoke.json
logarithmic march MEASURED and REFUTED: APS 6940 vs the published 2806 (2.5x worse), CHA 3115 vs the 2857 target, two sets 10414 vs <6026; the mechanism did work in the predicted direction (CHA 4516 -> 3115 = 1.45x) but the canonical set pays for it — the same trade that ended the four previous attempts, now measured for the transform too. Guarantee intact everywhere (over2x = 0)
2026-09-20 22:59:42 +01:00
sweep_log.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_order_smoke.json
Valeri's second point measured: the similarity function belongs to the PLACE it is read in, not to the method. False position's three-century stall is a similarity read at order one on an approach of order m: with sigma = |f(far)| the residual ratio is (e/E)^m, so raising it to the measured 1/m recovers the distance ratio exactly. Paired inside each cell, the correction is cheaper in 7 of 7 safeguards for S = 1/(1+z) - the one function that makes that place exact inverse interpolation - and in only 29 of 60 cells over all nine functions, i.e. a coin. It does NOT beat Chandrupatla (2884 against 2683 and 2423), it HARMS the slope reading (2806 -> 2854), and it does not cure false position: 127/154 and 10676 become 128/154 and 10043, where Illinois buys 153/154 and 7045 with one constant. Estimator bias measured and stated: a pure cube reads 2.830, not 3
2026-09-21 01:17:25 +01:00
sweep_order.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_points_smoke.json
two more places for similarity: points='shape' (WHICH triple the model uses, argmin |phi-xi| over declared candidates — select, never weight) and direction='dissimilar' (the far end read by |f| rather than by distance); defaults bit-identical, P1-P5 pinned (7 green), inertness counters make an inert mode a failed EXPERIMENT rather than a pass; each grid writes to its own file
2026-09-20 23:39:41 +01:00
sweep_points.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_slope_smoke.json
slope-stability gate: the PROJECT'S OWN target is met for the first time — 5922 < 6026 over both sets at 193/199 with the guarantee intact (slope.ratio.derived3.project: APS 2848 + CHA 3074), CHA improves 4516 -> 2903 (x1.56), repairs 77.5% -> 55.3%. Honest cost: APS 2806 -> 2848, which moves us from 1st to 3rd on the canonical set (chandrupatla 2785, toms748 2820), so my stricter S1 fails while the project target passes — a positioning decision, recorded not resolved. Refusal CURRENCY is what decides: bracket progress 4449 vs model shape 2848, a 1601-evaluation difference for the same 'refuse before the step' idea
2026-09-20 23:27:43 +01:00
sweep_slope.json
Sign tests by product underflowed: FIXED everywhere (branch, not master - the paper is not yet updated). FA * fnew < 0.0 with FA ~ -1e-200, fnew ~ 1e-150 is -0.0 and '-0.0 < 0.0' is False, so on flat functions (x^19) the bracket update moved the wrong end, the root left the bracket and the run still reported convergence - the proposed rule returned 4.9e-9, bisection 3.5e-9, ITP 1.6e-8 with a claimed 1e-12 bracket; the 1e-6 harness scored them solved. Same defect in our bisection, false-position family, Ridders, Brent, ITP and twelve copies in stage scripts, simroot/sim.py and one test; all replaced by _opposite / _same_sign, pinned by test_sign_underflow.
2026-09-21 12:49:01 +01:00
sweep_smoke.json
baseline: the published sim-numerics artifact as it stands (490 tests, verify_article.py checks all 72 paper numbers against sweep_full.json)
2026-09-20 22:38:17 +01:00
tables_for_md.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00
verify_article.py
Valeri's decisions (1) competitors from the library, (2) variant a. (1) Chandrupatla is scipy.optimize.elementwise.find_root, Brent is brentq, no more per-problem best_of. Our Chandrupatla stopped on a bracket twice as wide as every other method (the factor the protocol corrects for ITP); fixed (+0.5*xtol) in baselines.py and in the two copies found by grep (stage16_blend, stage19_modern) and the traced mirror, and pinned: ours == library on every problem. Regenerating sweep_full.json changed exactly three rows - chandrupatla APS 2785->2787, CHA 2423->2441, brent CHA 4099->4115 - and nothing else (diff_sweeps.py: 0 unexpected).
2026-09-21 10:53:00 +01:00

README.md

sim-numerics — similarity as a step rule for root finding

Artifact for the paper article/sim_numerics.tex. Every claim in the paper is produced by one of the scripts below; nothing in the text is transcribed by hand, and verify_article.py checks all 72 stated numbers against the run data as part of the test suite.

Reproducing

python -m pytest tests/ -q          # 490 tests
python sweep_full.py                # the full grid, writes sweep_full.json
python verify_article.py            # every paper number vs the data

Heavy runs go to a Linux machine (Python 3.12, run detached with a log, setsid nohup ... > sweep.log 2>&1). Use one platform for all numbers: the test functions call libm, whose last digit differs between Windows and Linux, and the same SciPy version scores 2819 for TOMS 748 on Windows against 2820 on Linux for the same set. The paper's numbers are the Linux ones.

Where each claim comes from

Paper Claim Script
Prop. 1 the two-point similarity step is regula falsi tests/test_simroot.py::test_the_pure_two_point_similarity_step_is_regula_falsi_exactly
Prop. 2, Table 1 contraction law, predicted 0.1716 vs measured 0.1716 stage0c_why_pure_fails.py
Cor. 1 a chosen similarity fails on 5–8 of 8 problems stage0b_pure_similarity.py
Cor. 2 faster similarity is not better (sqrt, cbrt) stage0d_derived_similarity.py
Cor. 3 derived scale ⇒ the step is |f|/|f'| ⇒ superlinear stage0d_derived_similarity.py, stage0e_guard_cost.py
§3 safeguards bracket vs step vs both, and what each costs stage2_guard_modes.py, stage3_bound_check.py
§3 order 1.584 (2-point) vs 1.944 (3-point) stage5_three_point.py
§3.1 project vs replace; the guarantee costs nothing stage6_projection.py
§3.1 the projection invariant, instrumented per step stage6b_invariant.py
§4 fairness ITP is not handicapped; κ₁ and n₀ sweeps stage2b_itp_fairness.py
Tables 2, 3 the 154-configuration ranking on both sets sweep_full.py → report_sweep.py
Table 4 the law across the whole grid sweep_full.py → report_sweep.py
§6 approach vs endgame, order, boldness, step quality stage4_why.py
§7.1 the prototype-aggregation form loses 0/6/147 bench_full.py (SIM.pair2d.*)
§7.2 the 2× bound and high order are incompatible stage5_three_point.py, tests/test_three_point.py
§7.4 the symmetric ratio similarity degenerates simroot/pure.py (PURE_SIMS["ratio"] docstring), stage0d

Layout

simroot/pure.py       the method: one similarity, one step rule, three guards
simroot/baselines.py  bisection, 4 false-position variants, Ridders, Brent,
                      TOMS 748 (SciPy), ITP (own, validated against its theorem)
simroot/sim.py        the prototype-aggregation form — a NEGATIVE result, kept
                      because the paper reports it
stage0*..stage5*      the derivation, in the order it was actually established
bench_full.py         17 methods on both sets
sweep_full.py         9 similarities x 4 scales x 4 guards + 10 baselines
report_sweep.py       reads sweep_full.json, produces the paper's tables
verify_article.py     asserts the paper against the data (72 checks)
tests/                490 tests; every bug found in audit is pinned here

Negative results, so they are not reopened

  1. Similarity normalised by the two bracket ends is regula falsi, identically.
  2. A faster-changing similarity is not better; what matters is the slope of 1 - S at zero matching the problem, and only the data supplies it.
  3. Prototype-pair aggregation with softmax over the whole memory loses to the simplest form: 0 wins / 6 ties / 147 losses against Brent on APS.
  4. "Our safeguard fires less often" — refuted: Brent discards 53% of its interpolations on the set it wins, 34% on the set it loses.
  5. "Our steps are bolder" — refuted: on Chandrupatla Brent is bolder (56.3% against 41.8%) and still loses. The mechanism is step quality: median bracket removed 0.275 against 0.058.
  6. Every safeguard that REPLACES the computed step with a midpoint destroys the order: with the three-point scale, order falls from 1.94 to 1.00 and the APS total from 2806 to 7260. Resolved by projecting the step onto the admissible interval instead (guard="project"), which costs nothing on APS (2806 either way) and gains on Chandrupatla (40/45 at 3220 against 35/45 at 4104 unguarded).
  7. Zero slack in the projection is degenerate: a worst case of exactly bisection demands a halving at every step, leaving the projection no freedom.
  8. Writing the projection as a radius around the midpoint instead of a clamp loses the invariant to cancellation — a relative 8.9e-5 overshoot on eleven Chandrupatla problems.
Reference in New Issue View Git Blame Copy Permalink
S
Description
Guaranteed bracketing root finder: beats Brent, TOMS 748 and Chandrupatla on multiple roots. Python/Cython, reproducible benchmarks, Apache-2.0.
https://doi.org/10.5281/zenodo.22894336
bisectionbracketingbrent-methodchandrupatlacythonmultiple-rootsnonlinear-equationsnumerical-analysisnumerical-methodspythonreproducible-researchroot-findingscientific-computingtoms748
Readme Apache-2.0
5.8 MiB
Languages
Python 87.7%
TeX 10.4%
Cython 1.3%
Shell 0.6%