From 9cfe834fe796d34a7ede5c2c2d360faadd6c9d44 Mon Sep 17 00:00:00 2001 From: Joel Pulikkan Date: Sat, 24 Oct 2026 18:47:06 -0400 Subject: [PATCH 1/3] Exact owned-relation optimum on the #4610 word; re-fund #5413 caller at kappa 0.0030272882389 Part B proves that no owned helper-relation subspace (including sets without #5383's eight, rank-4/8 frame-0 pivots and warp-word rows) beats #5383 on the #4610 word; forward optimum 0. Part A re-funds the unchanged #5413 caller inside its own reserve: conditional kappa 0.0030272882389 (+3.9e-12, compiler headroom only, zero recursive economic gain). Co-Authored-By: Claude Opus 5.5 --- .../README.md | 139 +++++ .../RESULT-ENDPOINT.json | 50 ++ .../RESULT-RELATIONS.json | 48 ++ .../SOURCES.json | 480 ++++++++++++++++++ .../TASK.json | 62 +++ .../VERIFY.json | 127 +++++ .../endpoint.py | 210 ++++++++ .../relations.py | 257 ++++++++++ .../test_controls.py | 77 +++ 9 files changed, 1450 insertions(+) create mode 100644 research/owned-relation-exact-optimum-r14/README.md create mode 100644 research/owned-relation-exact-optimum-r14/RESULT-ENDPOINT.json create mode 100644 research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json create mode 100644 research/owned-relation-exact-optimum-r14/SOURCES.json create mode 100644 research/owned-relation-exact-optimum-r14/TASK.json create mode 100644 research/owned-relation-exact-optimum-r14/VERIFY.json create mode 100644 research/owned-relation-exact-optimum-r14/endpoint.py create mode 100644 research/owned-relation-exact-optimum-r14/relations.py create mode 100644 research/owned-relation-exact-optimum-r14/test_controls.py diff --git a/research/owned-relation-exact-optimum-r14/README.md b/research/owned-relation-exact-optimum-r14/README.md new file mode 100644 index 0000000000..1fa4769b5d --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/README.md @@ -0,0 +1,139 @@ +# Exact owned-relation optimum on the #4610 word, and the #5413 caller re-funded at κ = 0.0030272882389 + +This package has two parts. + +**Part A (numerical; compiler headroom only).** The complete #5413 caller, its invoice, its height carrier and +its precision proof stay unchanged. Re-funding it inside its own reserve gives conditional +**κ = 30272882389/10¹³ = 0.0030272882389**, tested at **0.0030272882489**. This is +**3.9 × 10⁻¹²** above the selected #5413 value 0.003027288235. The recursive economic gain is +**zero**. No paid job, target, word or compiler parameter changes, and the raw moment is identical. The +result uses part of the 1.5 × 10⁻¹¹ gap between #5413 and the fixed-profile ceiling U = 0.00302728825 +(#5409). It stays below U. + +**Part B (exact; negative for further relation gains).** We solve exactly for the best owned +helper-relation subspace on Cao Yifan's #4610 word, in both orientations. The search space covers: + +- relation sets that omit #5383's eight relations, which is #5433's open question; +- pivots on the 26 rank-4 and 6 rank-8 frame-0 helpers; +- rows that carry warp words. + +The optimum is exactly #5383's span, at **8 (8^t + 1 − 9^t) = 0.07570927 raw moment per backward +local**. The forward optimum is 0. No ninth relation and no better joint set exists. The 144 exchanges of the +#5398/#5413 controller are the maximum. + +## Part B: model and certificate (`relations.py`) + +The model is #5377/#5383's, as generalised by #5433. Helpers starting in the common input frame 0 are free +inputs. There are 358 of them: 326 have rank-9 targets, 26 have rank-4 targets and 6 have rank-8 targets. A +relation subspace V consists of linear forms in these inputs. Each dimension owns one pivot helper, which +loses its productive target. + +- A paid climb is free iff its row vanishes on the restricted domain. +- Rows are replayed exactly over Q in the free group ring of warp words. A row therefore vanishes iff, for + every warp word, its coefficient vector (its *component*) lies in V. +- A centre job is free iff `row(centre) − row(snapshot)` lies in V. + +| Check | backward | forward | +|---|---:|---:| +| helper-only paid climbs | 224 (166 word-free, 50 two-word, 8 three-word) | 358 | +| distinct components, linearly independent over Q | 225 | 358 | +| centre snapshot options (all in the component span, rank-9 support) | 56 (8 centres) | 0 | +| connected pieces (components joined by climbs/options) | 110×1, 1×3, 8×7, 4×14 | 358×1 | +| exact optimum per local call | **8(8^t+1−9^t)**, attained by the span of #5383's relations | **0** | + +The certificate has four steps: + +1. WLOG V is the span of a set S of components. An option outside span(S) adds a dimension with a rank-9 + pivot, which costs 9^t, more than the 8^t it can save. +2. Since S is independent, any pivot set has a perfect matching to S inside the supports (Laplace expansion). + The lost target moment is therefore at least Σ_{c∈S} min-target(c)^t. +3. Each centre's seven options are supported on its zero-site rank-1 climb plus at most one private climb. + These supports are disjoint across centres. +4. Each piece (at most 14 components) is enumerated exactly with 60-digit Decimal powers. + +This extends #5433 in three ways. It covers sets without #5383's relations, cheaper pivots and word-carrying +rows. The ILP cross-check below also covers off-frame helpers, which are outside the admissible construction. +A side check with HiGHS on all 408 helpers, including helpers in non-common start frames (332 rows, 4 disjoint +circuits), gives the same optimum. That check is not part of the registered replay. + +## Part A: what changes and what is reused (`endpoint.py`) + +1. Authenticate all 63 capsule files of `research/coupled-helper-neutral-completion` against its + `SOURCE-BINDINGS.json`, whose SHA256 its `verify.py` pins. Copy them into private scratch. +2. Rerun #5413's invoice/funding engine with only its two endpoint literals substituted. The regenerated + invoice equals #5413's expected invoice. Funding passes all endpoint predicates and the 54 strict plus 4 + functional outer predicates. + - The gap stays 1/7·10¹¹, the height grid stays j = 55099 and H = 38569300000000000. + - The fields that downstream checks read are identical: paid and target profiles, reserve 10⁻¹², tuple, + BIT stock and controls. +3. Rerun #5413's precision checker on a manifest whose funding row points to the new receipt. Its output + equals #5413's expected precision receipt except the manifest hash. The written precision proof is + symbolic in N = 2^H and uses only H, j and the gap, so it applies unchanged. Its §8 sentence naming the old + pair is the one textual difference. +4. Rerun #5413's 25-premise conjunction with only the endpoint-gate literals moved to the new pair: PASS, + 25/25. +5. Controls: + - #5413's unsubstituted conjunction rejects the new funding. + - Tested values .00302728825 and .00302728824898 fail `funded_alpha_reserve`. + - A non-unit gap fails the height grid. + - Brackets, computed with #5413's directed engine: + - raw root ∈ (.0030272882499, .00302728825); + - reserve-limited tested saving ∈ (.00302728824897, .00302728824898). + +At the same carrier, the reserve-limited maximum is κ < 0.00302728823898. The chosen κ is 8×10⁻¹⁶ below that +bound. A smaller unit gap, such as 1/7·10¹² (κ ≈ 0.0030272882479), also passes the endpoint arithmetic. It +would change H, however, and #5413's precision checker pins the gap. It is not claimed here. + +**Assumptions.** The κ is conditional on exactly the five retained selected premises of #5413: + +- native all-column operation; +- owned erasure; +- the compiler contract; +- precision/tape; +- analytic recovery. + +No unconditional theorem, formal-kernel acceptance or κ-maximality is claimed. On macOS, `endpoint.py` skips +the precision checker's `RLIMIT_AS` call, which Darwin cannot lower. Linux runs that checker byte-unchanged. + +## Reproduce + +```sh +python3.12 -B scripts/research_package.py --package research/owned-relation-exact-optimum-r14 +python3.12 -I -B research/owned-relation-exact-optimum-r14/relations.py # PASS_OWNED_RELATION_EXACT_OPTIMUM_EQUALS_5383 (~3 s) +python3.12 -I -B research/owned-relation-exact-optimum-r14/endpoint.py # PASS_5413_CALLER_REFUNDED_AT_KAPPA_0.0030272882389 (~10 s) +python3.12 -I -B research/owned-relation-exact-optimum-r14/test_controls.py # PASS_OWNED_RELATION_EXACT_OPTIMUM_CONTROLS +``` + +The registered replay also reruns #5413's full `verify.py`, which Part A depends on. + +## Open next questions + +- Can a changed paid profile on the #4610 word fund κ above the fixed-profile ceiling U = .00302728825, rather + than a relation exchange? Relations are now exhausted exactly. The endpoint headroom left at this carrier is + below 1.1×10⁻¹¹. First step: price one candidate histogram change with `scripts/compare_recursive_invoices.py` + before building a word. +- Can a precision proof that is parametric in the gap admit a finer unit gap? A gap of 1/7·10¹² would add about + 9×10⁻¹² more, and it is numerical only. + +## Credit + +- Cao Yifan (intqwq) supplied the #4610 word. +- Ali Romman (aliromman) supplied the owned-relation method and its successors: + - #5377, the first owned relation; + - #5383, eight joint relations; + - #5392, owned circuit transposition; + - #5398, the direct backward caller; + - #5421, nine BIT relations. +- Dillon Amburgey (dillona) supplied the #5402 coupled provider. +- Chris R (Clear1nsight) supplied: + - the #5413 complete caller, its funding engine and its conjunction; + - the reviews #5384 (owned-relation price ceiling), #5395 (eight-relation price plane) and + #5396/#5399/#5400/#5407/#5414. +- Dugongue supplied #5387/#5390, the reserve refinements. +- Mark (Matarener) supplied #5433, the relation-subspace certificate and open question that Part B answers. +- #5409 supplied the fixed-profile ceiling U. +- Lineage credit is retained for Cinna Davis, zxv, Jacob Alan Sussman (mixed-target paradigm, #4359) and the + native, compiler, BIT and analytic predecessors. + +Prepared by Joel Pulikkan (GamingPuzzled). AI disclosure: Claude Opus 5.5 (Anthropic) via Claude Code, +directed by Joel Pulikkan (GamingPuzzled). New material is Apache-2.0. diff --git a/research/owned-relation-exact-optimum-r14/RESULT-ENDPOINT.json b/research/owned-relation-exact-optimum-r14/RESULT-ENDPOINT.json new file mode 100644 index 0000000000..4ef6744afc --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/RESULT-ENDPOINT.json @@ -0,0 +1,50 @@ +{ + "authenticated_capsule_files": 63, + "carrier": { + "H": 38569300000000000, + "gap": "1/700000000000", + "j": 55099 + }, + "conjunction": { + "gain_over_prior_comparison": "89/10000000000000", + "premise_count": 25, + "status": "PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION" + }, + "controls": { + "non_unit_gap_rejected": true, + "tested_.00302728824898_rejected_alpha_reserve": true, + "tested_.00302728825_rejected_alpha_reserve": true, + "unsubstituted_5413_conjunction_rejects_new_funding": true + }, + "fixed_profile_ceiling_U": ".00302728825 (#5409); kappa stays below it", + "funding_changed_fields": [ + "alpha_upper", + "delta_upper", + "eta_lower", + "gain_over_comparison", + "gamma_upper", + "kappa", + "outer", + "raw_tested_margin", + "reserve_slack", + "tested" + ], + "gain_over_5398": "89/10000000000000", + "gain_over_5413": "39/10000000000000", + "kappa": ".0030272882389", + "precision_receipt": "equal to #5413 expected receipt except input_manifest_sha256", + "previous": { + "kappa": ".003027288235", + "tested": ".003027288245" + }, + "raw_root_bracket": [ + ".0030272882499", + ".00302728825" + ], + "reserve_limited_tested_bracket": [ + ".00302728824897", + ".00302728824898" + ], + "scope": "numerical compiler headroom only: same complete #5413 caller, invoice, carrier and precision proof", + "tested": ".0030272882489" +} diff --git a/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json b/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json new file mode 100644 index 0000000000..ed7eeb6303 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json @@ -0,0 +1,48 @@ +{ + "C": "0.003027288235", + "V0_gain_per_backward_local": "0.075709271555986216366649243749", + "conclusion": "No owned-relation subspace beats #5383; the 18 backward locals carry the maximum 144 exchanges.", + "frame0_helpers": 358, + "frame0_target_ranks": { + "4": 26, + "8": 6, + "9": 326 + }, + "model": "owned helper-relation subspaces over the 358 frame-0 helpers, any pivots, rows with warp words", + "orientations": { + "backward": { + "centre_options": 56, + "centres_with_options": 8, + "climbs_by_word_count": { + "1": 166, + "2": 50, + "3": 8 + }, + "components_independent": true, + "distinct_components": 225, + "helper_only_climbs": 224, + "optimum_attained_by": "span of the eight #5383 relations", + "optimum_per_local": "0.075709271555986216366649243749", + "piece_sizes": { + "1": 110, + "3": 1, + "7": 8, + "14": 4 + } + }, + "forward": { + "centre_options": 0, + "centres_with_options": 0, + "climbs_by_word_count": { + "1": 358 + }, + "components_independent": true, + "distinct_components": 358, + "helper_only_climbs": 358, + "optimum_per_local": "0E-30", + "piece_sizes": { + "1": 358 + } + } + } +} diff --git a/research/owned-relation-exact-optimum-r14/SOURCES.json b/research/owned-relation-exact-optimum-r14/SOURCES.json new file mode 100644 index 0000000000..84f89e0888 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/SOURCES.json @@ -0,0 +1,480 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/eight-owned-relations/RELATIONS.json", + "usage": "input", + "git_blob": "f558b9ddd903badb2301944cb978824b32ad42f7", + "sha256": "bc9ba05595497f399da5e5a548b2d2c83696e539fa1257ab7e2cb49d438cd9dd" + }, + { + "path": "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "usage": "input", + "git_blob": "ea9dfc3e40ad7bd5298b3add299b460f3eca11a4", + "sha256": "ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "usage": "input", + "git_blob": "cddadb2ce1f13393a63d739e92c7964a0403f27d", + "sha256": "bf328da5849a07eadad07e072252894acdc231915d0039df511d70d5d57955d3" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "usage": "input", + "git_blob": "c50958cf8d98edb9f1ff2f190c4df5016e5a2829", + "sha256": "14536ff6baf8b4a8bce96b6a35b5b6acbb9d416d83d9230a903e0d776c6edc02" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "usage": "input", + "git_blob": "04c6c7f36cb1b9fcf0b464bad3d3d83aaae7c864", + "sha256": "cc297ee54c2743615dfe857838d5f40424ccd33fdb08ecfafbc41b1710416d91" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "usage": "input", + "git_blob": "975714d0c15714070b2303ca48d31871f2095210", + "sha256": "1f17fda221bc781ca0b2a120916ed500ba84c305a916a65436a5d6c72d116bcf" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "usage": "input", + "git_blob": "0bbe283da6ab0874d78f6a6119952e75197f081e", + "sha256": "dfa125a8c26b86cfa2024edab9f8ed3c95ebe23bffc1bedfd3c90aa471e80ae0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "usage": "input", + "git_blob": "933b2234afa8c264b09c9b1096ae520e73c3432e", + "sha256": "ecefd9b890ccaa46e9f00a6e43faf16aaaf8ec8c992ab48bf245af38aa3e3f23" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "usage": "input", + "git_blob": "b868fe46ce7ff96a51f7b612758685a23014d31d", + "sha256": "a02e79fb4615f4f987e3b3617c2b42eea2c1d7415cc66fa702a8b0cd28e6387e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "usage": "input", + "git_blob": "faed00ed09bb24a99b8136aadcecf6b3832c72d1", + "sha256": "6fc67329c2772538be6f278e9787782ad064306917e3bb40889f4cef6421d41a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "usage": "input", + "git_blob": "856b4599eb999310ce693ba2f3db12663ecc50db", + "sha256": "438ead22afb57bd72275fdf6fd36e680918309d6492b6165e79c3ff7ea94c424" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "usage": "input", + "git_blob": "8cd6f8829e19b845a5df477353564cbf7abb88d7", + "sha256": "8296ae58fdbb45515d2b3e0158355804ade22c1c579d940c889c228dc1823891" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "usage": "input", + "git_blob": "60df54f0363f3eb26105b753f2432955d4468449", + "sha256": "63bd9003395cfdc2308f6f875464bb57ef6ca708759d5ea468dea74b300bfc92" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "usage": "input", + "git_blob": "9a2d8a37b80b613641f296d6c1edb69459c46298", + "sha256": "2253a106e5edeade264c8ca7cffdaeba1dacabc34a8635fa7a396d877dd723d4" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "usage": "input", + "git_blob": "579364b284d5c19c96135293e90b314ff1b2e3ea", + "sha256": "84df3e63ea1f185b61ed32a73c588373063ccbba90d94db9c1d5202f47ed5af2" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "usage": "input", + "git_blob": "3bf73d72cf1b91ac8a99747eab6e1b3d5aee1d4a", + "sha256": "1ce00ce7a0fc5f97eb9e8992b8b5d92195745d8ec289cd81d82201cd712d7305" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "usage": "input", + "git_blob": "0dd60294b2cf252774a7f9c4d5f27e22a1633e07", + "sha256": "8c874ecaf4d3824876c59d9868721bf237836acaef23ded3b58e6c1e6fca1ae9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "usage": "input", + "git_blob": "1acd6f7b1dce17d1d08911be68ffa017e9466014", + "sha256": "fbf04da0aeacaa8b9a56fa52c3c9b37449818ace7e5abed963ae03203a81f8eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "usage": "input", + "git_blob": "bf31af785122dea7cbceacbfa64c21e567e4fca7", + "sha256": "cf7439c9eb4095224126dd5eefc9f1c5dfe1968d6e8eca5b87d4a3897841182d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "usage": "input", + "git_blob": "444398e7bebee418b5bc9b52ef8702fa95d6bcd5", + "sha256": "e445e7da76e9d8e5dbad2c5fc0bd8aa17e3f5c6d0bfcf56f778c3960426909a1" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "usage": "input", + "git_blob": "ac6d803cf61b3be5031144283129ef899d6dca50", + "sha256": "dbdd056bece96b5c519336a7a1c44d2d9d8e84d134783d156a955bf472405f24" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "usage": "input", + "git_blob": "2114f57aa64c26b5a14917eeafa2a76fadac948f", + "sha256": "4292f2f93e91b556be3114f5aae2853ce9acd747619729b54badd2af97315eea" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "usage": "input", + "git_blob": "574c1d0bd75cd85f720991d815272738aa3e5b8f", + "sha256": "cda8f596f7854f42a228f757d5f8e68f6b2256a19c5ae3771fb40753cedc5b39" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "usage": "input", + "git_blob": "606dc5997217213d9bc1dfa7ebe6bb6f861f8530", + "sha256": "1bd319a30febee6053d24204442c827e1ee7216d70457311b9863a809786887a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "usage": "input", + "git_blob": "dab8936f66b856a829f52c8d87184a0f72d6c9e2", + "sha256": "c4bcb367b6e087a43b5db21e429b71dd845a18efb475c71fd37eb26bfc7430bd" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "usage": "input", + "git_blob": "4a264e2cec4db789bf6fea865511684f11fad3ff", + "sha256": "5a3385aaddb632e4e23372d73b104455e2824d15782df9df0458069e824f969e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "usage": "input", + "git_blob": "0c1a1ec8e22b183861b2a6db9f94126687ecc926", + "sha256": "b0fb7538240b08557689cf47384ecbe9708697f5576db1f1f33dce7119dd8375" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "usage": "input", + "git_blob": "bfe0f019bef756a698ce5a0d31f9229f1e1dc834", + "sha256": "5e2385eaae212161900cc98be2e07db8fdb96ef511edba2aff0a3c47d23a771c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "usage": "input", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "usage": "input", + "git_blob": "7ee84b30892f7354e1c36611f1a5e9b082dc6147", + "sha256": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "usage": "input", + "git_blob": "3ccee4f7645729889b4d38aaa69e6768db59dbd3", + "sha256": "e5b325235eeb6c976a8dc568df838f609fcca0f52945f00bb6b2e9a973a1a11b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "usage": "input", + "git_blob": "4959f78b9f940012d2d58f21d5b7148d73a61fe9", + "sha256": "15e90b63c5659090f02902cb38951ec4ab252352fb0b967b411ed547c501e2ba" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "usage": "input", + "git_blob": "013d48050eb69a73e2dbe387171289fabe8cd7f0", + "sha256": "a37fa9735bbb2697811de72a706b243842d1303243f6e6a0300bd5046d4f3d66" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "usage": "input", + "git_blob": "92d0d7e523dbf90c67b7244de4c87cc74c0d3b61", + "sha256": "0d86590c471a498f3b735397d42bbaf4d5e89c33b75ddbd48dbf972192ab351f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "usage": "input", + "git_blob": "7a16a7dfc2a4a09c55fe0ad8b90afc0a19c25fc8", + "sha256": "fc2e447a0043f74b133a24b67b2a87e4ff87232dd8a003253d19dbf2390a9092" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "usage": "input", + "git_blob": "dd77397ca519f0c15799b4f90a489af3d6a2cb0f", + "sha256": "f16756004bd3100e4993b250181c4c8d15c31b0a1478b627091dd900e1103888" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/engine_adapter.py", + "usage": "input", + "git_blob": "3825fd0799dac2f19360c75c26d1ff3bd3ec323d", + "sha256": "4a3de4a9ca3d65d0485826aa17368789015af7815e7febd74d335302b7dfb42b" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/global.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/local.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/source-loading.json", + "usage": "input", + "git_blob": "44b5b599730b6f7bbf6084a60a4fe9b1ee271297", + "sha256": "751bb2ffaadfdc2cd430ec9841fe572d70031f77e42e375ec02664ebb98760bf" + } + ] +} diff --git a/research/owned-relation-exact-optimum-r14/TASK.json b/research/owned-relation-exact-optimum-r14/TASK.json new file mode 100644 index 0000000000..7fa44a13ce --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/TASK.json @@ -0,0 +1,62 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "On the complex #4610 word of the selected #5383 -> #5392 -> #5398 -> #5413 chain: what is the exact optimum over ALL owned helper-relation subspaces (including sets that omit #5383's eight, rank-4/rank-8 frame-0 pivots and rows that carry warp words), and how much funded compiler headroom remains for the complete #5413 caller at its unchanged invoice and carrier?", + "scope_change_reason": "#5433 left open whether a relation set omitting #5383's eight can beat them, and covered only word-free cold rows; #5409/#5413 left 1.5e-11 between the selected endpoint and the fixed-profile ceiling. This package closes the first exactly and spends part of the second numerically, without a new construction.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/pull/5433", + "outcome": "completed", + "evidence": "relations.py replays the #4610 word exactly over Q in both orientations: 224 backward helper-only climbs (225 independent components incl. warp words), 56 centre options in their span; exact piecewise enumeration gives optimum 8(8^t+1-9^t) per backward local, attained by #5383's relations; forward optimum 0. endpoint.py authenticates #5413's 63 capsule files, regenerates its invoice byte-identically, re-funds (k,s)=(.0030272882389,.0030272882489) with the same gap/height carrier, reproduces #5413's precision receipt and passes all 25 conjunction premises with four rejecting controls.", + "claim": "Conditional kappa = .0030272882389 (+3.9e-12 over #5413) from funded compiler headroom only; zero recursive economic saving; and no owned helper-relation subspace on the #4610 word beats #5383's eight.", + "author": "Joel Pulikkan (GamingPuzzled)", + "ai_assistance": "Claude Opus 5.5 (Anthropic) via Claude Code, directed by Joel Pulikkan (GamingPuzzled).", + "open_questions": [ + { + "question": "Can a changed paid profile (not a relation exchange) on the #4610 word fund a kappa above the fixed-profile ceiling U = .00302728825?", + "why_it_matters": "Relations are now exhausted exactly and the remaining endpoint headroom is below 1.1e-11; any further gain must change the paid or target histogram.", + "first_step": "Price one candidate histogram change with scripts/compare_recursive_invoices.py before building a word.", + "blocked_by": "No admitted changed native word or helper factorization is available." + } + ], + "budget_minutes": 180, + "stop_rule": "Stop at the exact relation-subspace optimum for the fixed #4610 word and at the reserve-limited endpoint of the unchanged #5413 invoice and carrier; do not change the word, helper inventory, invoice or compiler tuple." +} diff --git a/research/owned-relation-exact-optimum-r14/VERIFY.json b/research/owned-relation-exact-optimum-r14/VERIFY.json new file mode 100644 index 0000000000..ff31990d6b --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/VERIFY.json @@ -0,0 +1,127 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "research/eight-owned-relations/RELATIONS.json", + "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "research/coupled-helper-neutral-completion/engine_adapter.py", + "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "research/coupled-helper-neutral-completion/reports/expected/global.json", + "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "research/coupled-helper-neutral-completion/reports/expected/local.json", + "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "research/coupled-helper-neutral-completion/reports/expected/source-loading.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/relations.py" + ], + "timeout_seconds": 120, + "checks": "Part B: pinned #4610 word and #5383 relations; exact Q replay of both orientations with warp words; 358 frame-0 helpers; distinct helper-only climb components linearly independent (225 backward / 358 forward); all 56 centre options in their span with rank-9 support; exact piecewise enumeration: backward optimum = 8(8^t+1-9^t) attained by the span of #5383's relations, forward optimum 0; stored RESULT-RELATIONS.json equals the rebuild." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/endpoint.py" + ], + "timeout_seconds": 300, + "checks": "Part A (numerical): authenticate #5413 capsule against its pinned SOURCE-BINDINGS.json; regenerate its invoice byte-identically; re-fund (kappa, tested) = (.0030272882389, .0030272882489) with the same gap 1/7e11, j=55099, H=38569300000000000; rerun #5413 precision checker (receipt equal to #5413's expected except manifest hash); rerun the 25-premise conjunction with only the endpoint literals moved; controls: unsubstituted conjunction rejects the new funding, tested .00302728825 and .00302728824898 fail the alpha reserve, a non-unit gap fails; raw-root and reserve brackets; stored RESULT-ENDPOINT.json equals the rebuild." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_controls.py" + ], + "timeout_seconds": 120, + "checks": "Mutation controls for Part B: a corrupted climb rank, a dropped #5383 relation in the attainment check, a fabricated dependent component and a tampered stored result are rejected." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/coupled-helper-neutral-completion/verify.py" + ], + "timeout_seconds": 300, + "checks": "Unchanged full #5413 registered replay (local 649 columns, whole caller, binding, invoice, precision, conjunction) on which Part A depends; Linux CI." + } + ] +} diff --git a/research/owned-relation-exact-optimum-r14/endpoint.py b/research/owned-relation-exact-optimum-r14/endpoint.py new file mode 100644 index 0000000000..f7f52319b9 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/endpoint.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +"""Part A: re-fund the complete #5413 caller at a higher endpoint inside its own funded reserve (numerical only). + +Nothing scientific in #5413 changes: the same B/F packets, controller, invoice, outer engine, height carrier +(gap 1/700000000000, j = 55099, H = 38569300000000000) and precision proof. Only the claimed/tested pair moves from +(.003027288235, .003027288245) to (KAPPA, TESTED) below. The script + 1. authenticates #5413's capsule against its own SOURCE-BINDINGS.json (whose SHA256 its verify.py pins) and copies it + into private scratch; + 2. reruns #5413's invoice/funding engine with exactly the two endpoint literals substituted (asserted unique) and + checks that the regenerated invoice equals #5413's expected invoice byte-for-byte in JSON; + 3. checks that every field the precision checker reads from the funding file (status, gap, H, j, paid, targets) is + unchanged, then reruns #5413's precision checker on a manifest whose funding row points to the new receipt and + compares its output with #5413's expected precision receipt (only the manifest hash may differ); + 4. reruns #5413's 25-premise conjunction with the endpoint gate literals substituted, on a manifest with the new + funding/precision rows; requires PASS and 25 premises; + 5. live controls: the unsubstituted conjunction rejects the new funding; the endpoint arithmetic rejects tested + .00302728825 (alpha reserve), tested .00302728824898 (alpha reserve) and an off-grid gap; exact brackets for the + raw root and the reserve-limited tested saving are recomputed with #5413's directed moment engine. +Usage: python3 -I -B endpoint.py [--write] +""" +import sys +import argparse, hashlib, json, os, shutil, subprocess, tempfile +from fractions import Fraction as F +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SRC = ROOT / 'research' / 'coupled-helper-neutral-completion' +BINDINGS_SHA256 = 'ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3' # pinned in #5413 verify.py +OLD_K, OLD_S = '.003027288235', '.003027288245' +KAPPA, TESTED = '.0030272882389', '.0030272882489' +AGENTS = 'swarm-coupled-caller-sol-high-20261024/agents/' +INVOICE_DIR = AGENTS + 'invoice/' +PREC_DIR = AGENTS + 'precision/' + + +def require(ok, message): + if not ok: + raise SystemExit('FAIL: ' + message) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def substitute(text, pairs): + for old, new in pairs: + require(text.count(old) == 1, 'unique substitution site: ' + old) + text = text.replace(old, new) + return text + + +def run(workspace, engine, argv, darwin_shim=False): + adapter = SRC / 'engine_adapter.py' + env = {k: v for k, v in os.environ.items() if not k.startswith('PYTHON')} + env['PYTHONDONTWRITEBYTECODE'] = '1' + r = subprocess.run([sys.executable, '-I', '-B', str(adapter), str(workspace), engine, *argv], cwd=workspace, + env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=240) + return r.returncode, r.stdout.decode(), r.stderr.decode() + + +def load(path): + return json.loads(Path(path).read_bytes()) + + +def build(): + require(sha(SRC / 'SOURCE-BINDINGS.json') == BINDINGS_SHA256, '#5413 SOURCE-BINDINGS.json is the pinned one') + bindings = load(SRC / 'SOURCE-BINDINGS.json')['files'] + scratch = Path(tempfile.mkdtemp(prefix='r14-endpoint-')).resolve() + try: + shutil.copytree(SRC / 'capsule', scratch, dirs_exist_ok=True) + checked = 0 + for row in bindings: + if row['path'].startswith('capsule/'): + require(sha(scratch / row['path'][8:]) == row['sha256'], 'authenticated capsule byte ' + row['path']) + checked += 1 + for row in bindings: + if row['path'] == 'engine_adapter.py': + require(sha(SRC / 'engine_adapter.py') == row['sha256'], 'authenticated engine adapter') + ws = scratch / 'workspace' + expected = {name: load(SRC / 'reports' / 'expected' / name) for name in + ('invoice.json', 'funding.json', 'precision.json', 'conjunction.json')} + # 2. invoice + funding at the new endpoint + lit = ws / INVOICE_DIR / 'check_neutral_literal.py' + (lit.parent / 'check_neutral_literal_r14.py').write_text(substitute(lit.read_text(), [ + (f"F('{OLD_K}'),F('{OLD_S}')", f"F('{KAPPA}'),F('{TESTED}')")])) + code, out, err = run(ws, INVOICE_DIR + 'check_neutral_literal_r14.py', [ + '--backward', AGENTS + 'caller/NEUTRAL-BACKWARD-v16c.json', '--forward', AGENTS + 'caller/NEUTRAL-FORWARD-v16c.json', + '--output-dir', INVOICE_DIR + 'R14-RUN']) + require(code == 0, 'funding run: ' + err[-800:]) + inv = load(ws / INVOICE_DIR / 'R14-RUN/INVOICE-NEUTRAL-LITERAL.json') + require(inv == expected['invoice.json'], 'regenerated invoice equals #5413 expected invoice') + fund_path = ws / INVOICE_DIR / 'R14-RUN/FUNDING-NEUTRAL-LITERAL.json' + new, old = load(fund_path), expected['funding.json'] + require(new['status'] == old['status'] == 'PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY', 'funding PASS') + require(F(new['kappa']) == F(KAPPA) and F(new['tested']) == F(TESTED), 'new endpoint recorded') + for key in ('gap', 'H', 'j', 'paid', 'targets', 'reserve', 'tuple', 'invoice_sha256', 'ordinary_BIT', 'controls'): + require(new[key] == old[key], 'funding field read downstream is unchanged: ' + key) + require(F(new['gap']) == F(1, 700000000000) and new['j'] == 55099 and new['H'] == 38569300000000000, 'carrier') + changed = sorted(k for k in set(new) | set(old) if new.get(k) != old.get(k)) + # 3. precision on the new funding receipt + pman_path = ws / PREC_DIR / 'V16-SOURCES-v3.json' + pman = load(pman_path) + rel_fund = INVOICE_DIR + 'R14-RUN/FUNDING-NEUTRAL-LITERAL.json' + for r in pman['rows']: + if r['id'] == 'funding': + r['path'], r['sha256'] = rel_fund, sha(fund_path) + pman['by_id']['funding'] = rel_fund + pman_path.write_text(json.dumps(pman, indent=2, sort_keys=True) + '\n') + checker = ws / PREC_DIR / 'check_v16_precision_v3.py' + shim = sys.platform == 'darwin' # macOS cannot lower RLIMIT_AS; Linux runs the frozen checker unchanged + if shim: + checker.write_text(substitute(checker.read_text(), [( + 'resource.setrlimit(resource.RLIMIT_AS,(256*1024**2,256*1024**2))', + 'resource.setrlimit(resource.RLIMIT_AS,(256*1024**2,256*1024**2)) if sys.platform!="darwin" else None')] + ).replace('import argparse,copy,', 'import sys,argparse,copy,', 1)) + code, out, err = run(ws, PREC_DIR + 'check_v16_precision_v3.py', ['--root', '.', '--output', PREC_DIR + 'R14-PRECISION.json']) + require(code == 0, 'precision run: ' + err[-800:]) + prec = load(ws / PREC_DIR / 'R14-PRECISION.json') + drop = {'seconds', 'input_manifest_sha256'} | ({'checker_sha256'} if shim else set()) + require({k: v for k, v in prec.items() if k not in drop} == {k: v for k, v in expected['precision.json'].items() if k not in drop}, + 'precision receipt equals #5413 expected receipt except the manifest hash') + require(prec['input_manifest_sha256'] == sha(pman_path), 'precision bound to the substituted manifest') + # 4. conjunction with the endpoint gate moved to the new pair + gain = F(KAPPA) - F('.00302728823') + clo = ws / INVOICE_DIR / 'check_neutral_closure.py' + original_closure = clo.read_text() + (clo.parent / 'check_neutral_closure_r14.py').write_text(substitute(original_closure, [ + (f"k==Q('{OLD_K}')", f"k==Q('{KAPPA}')"), (f"c==Q('{OLD_S}')", f"c==Q('{TESTED}')"), + ("k-Q('.00302728823')==Q(1,200000000000)", f"k-Q('.00302728823')==Q({gain.numerator},{gain.denominator})")])) + cman_path = ws / INVOICE_DIR / 'NEUTRAL-CLOSURE-INPUTS-v1.json' + cman = load(cman_path) + for r in cman['rows']: + if r['id'] == 'funding': + r['path'], r['sha256'] = rel_fund, sha(fund_path) + elif r['id'] == 'precision': + r['path'], r['sha256'] = PREC_DIR + 'R14-PRECISION.json', sha(ws / PREC_DIR / 'R14-PRECISION.json') + elif r['id'] == 'precision_manifest': + r['sha256'] = sha(pman_path) + new_cman = ws / INVOICE_DIR / 'R14-CLOSURE-INPUTS.json' + new_cman.write_text(json.dumps(cman, indent=2, sort_keys=True) + '\n') + code, out, err = run(ws, INVOICE_DIR + 'check_neutral_closure_r14.py', ['--root', '.', '--manifest', + INVOICE_DIR + 'R14-CLOSURE-INPUTS.json', '--output', INVOICE_DIR + 'R14-CONJUNCTION.json']) + require(code == 0, 'conjunction run: ' + err[-800:]) + conj = load(ws / INVOICE_DIR / 'R14-CONJUNCTION.json') + require(conj['status'] == 'PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION' and conj['premise_count'] == 25 + and all(conj['premises'].values()), 'all 25 conjunction premises PASS') + require(set(conj['premises']) == set(expected['conjunction.json']['premises']), 'same 25 premise names as #5413') + # 5. controls + controls = {} + code, _, err = run(ws, INVOICE_DIR + 'check_neutral_closure.py', ['--root', '.', '--manifest', + INVOICE_DIR + 'R14-CLOSURE-INPUTS.json', '--output', INVOICE_DIR + 'R14-CONTROL.json']) + controls['unsubstituted_5413_conjunction_rejects_new_funding'] = code != 0 and 'exact_new_positive_endpoint_gap' in err + sys.path.insert(0, str(ws / INVOICE_DIR)) + from fund_uniform_endpoint import evaluate_profiles + from exact_moments import moment, minus + P = {int(k): v for k, v in new['paid'].items()}; T = {int(k): v for k, v in new['targets'].items()} + + def rejected(k, s): + try: + evaluate_profiles(P, T, F(k), F(s), 1000, {}) + except ValueError as e: + return str(e) + return None + e1 = rejected('.00302728824', '.00302728825') + e2 = rejected('.00302728823898', '.00302728824898') + e3 = rejected('.0030272882389', '.0030272882488') + controls['tested_.00302728825_rejected_alpha_reserve'] = bool(e1) and 'funded_alpha_reserve' in e1 + controls['tested_.00302728824898_rejected_alpha_reserve'] = bool(e2) and 'funded_alpha_reserve' in e2 + controls['non_unit_gap_rejected'] = bool(e3) and 'unit height grid' in e3 + require(all(controls.values()), 'controls: ' + json.dumps(controls)) + + def raw(s): + return minus(moment(T, 1 - s), moment(P, 1 - s)) + + def alpha_ok(s): + return moment(P, 1 - s)[1] / moment(T, 1 - s)[0] < 1 - F(1, 10 ** 12) + require(raw(F('.0030272882499'))[0] > 0 and raw(F('.00302728825'))[1] < 0, 'raw root bracket') + require(alpha_ok(F('.00302728824897')) and not alpha_ok(F('.00302728824898')), 'reserve-limited tested bracket') + return dict( + scope='numerical compiler headroom only: same complete #5413 caller, invoice, carrier and precision proof', + previous=dict(kappa=OLD_K, tested=OLD_S), kappa=KAPPA, tested=TESTED, + gain_over_5413=str(F(KAPPA) - F(OLD_K)), gain_over_5398=str(gain), + authenticated_capsule_files=checked, funding_changed_fields=changed, + carrier=dict(gap=new['gap'], j=new['j'], H=new['H']), + raw_root_bracket=['.0030272882499', '.00302728825'], + reserve_limited_tested_bracket=['.00302728824897', '.00302728824898'], + fixed_profile_ceiling_U='.00302728825 (#5409); kappa stays below it', + conjunction=dict(status=conj['status'], premise_count=conj['premise_count'], + gain_over_prior_comparison=str(conj['gain_over_prior_comparison'])), + precision_receipt='equal to #5413 expected receipt except input_manifest_sha256', + controls=controls, macos_rlimit_shim_used=shim) + finally: + shutil.rmtree(scratch, ignore_errors=True) + + +def main(): + ap = argparse.ArgumentParser(); ap.add_argument('--write', action='store_true'); args = ap.parse_args() + result = build() + result.pop('macos_rlimit_shim_used') + path = HERE / 'RESULT-ENDPOINT.json' + text = json.dumps(result, indent=1, sort_keys=True) + '\n' + if args.write: + path.write_bytes(text.encode('utf-8')) + require(path.exists() and json.loads(path.read_text(encoding='utf-8')) == json.loads(text), 'stored RESULT-ENDPOINT.json equals the rebuild') + print('PASS_5413_CALLER_REFUNDED_AT_KAPPA_0.0030272882389') + + +if __name__ == '__main__': + main() diff --git a/research/owned-relation-exact-optimum-r14/relations.py b/research/owned-relation-exact-optimum-r14/relations.py new file mode 100644 index 0000000000..45c2c6bde7 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/relations.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +"""Part B: the exact optimum of every owned helper-relation subspace on the #4610 word (both orientations). + +Standard library only. Reads Cao Yifan's #4610 word (research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz) +and #5383's eight relations (research/eight-owned-relations/RELATIONS.json), both pinned in SOURCES.json. + +Model (#5377/#5383 owned-relation model, as generalised by #5433, widened here): + * helpers whose start frame is the common input frame 0 (358: 326 rank-9, 26 rank-4, 6 rank-8 targets) are free + inputs; a relation subspace V is a space of linear forms in them; each dimension owns one pivot helper, which + loses its productive target (rank = final - start dimension); + * a paid climb is free iff its logical row vanishes on the restricted domain. Rows are tracked exactly over Q in the + free group ring of warp words, so a row vanishes iff, for every warp word w, its coefficient vector over the + helpers ("component") lies in V. #5433 used only word-free rows of cold helpers; + * a centre job (rank 8) is free iff row(centre) - row(Z) lies in V for an earlier same-frame snapshot Z. +Certificate: + 1. the distinct components of all helper-only climb rows are linearly independent over Q (225 backward, 358 forward); + 2. every centre option lies in their span, with support inside the components of a single pure climb pair; + 3. WLOG V = span(S) for a set S of components: an option outside span(S) adds a dimension whose pivot is a rank-9 + helper (option rows are pure cold), costing 9^t > 8^t; + 4. for independent S, any pivot set has a perfect matching to S inside supports (Laplace), so the lost target moment + is >= sum_{c in S} min-target(c)^t; + 5. the climb/centre/component incidence splits into small connected pieces; each piece is enumerated exactly. +The optimum is 8 (8^t + 1 - 9^t) per backward local, attained only by #5383's eight relations; forward optimum 0. +Usage: python3 -I -B relations.py [--write] +""" +import argparse, collections, gzip, hashlib, itertools, json +from decimal import Decimal as D, getcontext +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +WORD = ROOT / 'research' / 'kappa-round3-warp-20261022' / 'ACTUAL-WORD.json.gz' +RELATIONS = ROOT / 'research' / 'eight-owned-relations' / 'RELATIONS.json' +PAID = {1: 2201, 2: 412, 3: 510, 4: 127, 5: 40, 8: 8} +C_SELECTED = D('0.003027288235') +NL = 632 +getcontext().prec = 60 + + +def require(ok, message): + if not ok: + raise SystemExit('FAIL: ' + message) + + +def pinned_inputs(): + for row in json.loads((HERE / 'SOURCES.json').read_text(encoding='utf-8'))['files']: + if row['usage'] == 'input' and row['path'] in (str(WORD.relative_to(ROOT)), str(RELATIONS.relative_to(ROOT))): + data = (ROOT / row['path']).read_bytes() + require(hashlib.sha256(data).hexdigest() == row['sha256'], 'input drift: ' + row['path']) + + +def add_into(dst, src, q): + for k, v in src.items(): + nv = dst.get(k, 0) + q * v + if nv: + dst[k] = nv + else: + dst.pop(k, None) + + +class Echelon: + """Exact rational row echelon on sparse rows {column: Fraction}, tracking combinations of added rows.""" + + def __init__(self): + self.rows = {} + + def reduce(self, v, combo=None): + v = dict(v); combo = dict(combo or {}) + while v: + col = min(v) + if col not in self.rows: + break + f = v[col]; pv, pc = self.rows[col] + add_into(v, pv, -f); add_into(combo, pc, -f) + return v, combo + + def add(self, v, tag): + v, combo = self.reduce(v, {tag: Q(1)}) + if not v: + return False + col = min(v); f = v[col] + self.rows[col] = ({k: x / f for k, x in v.items()}, {k: x / f for k, x in combo.items()}) + return True + + +def replay(word, orient, free): + """Exact replay; returns paid profile, helper-only climbs [(t, rank, {word: component})] and centre options.""" + c = word['canonical']; prog = word['programs'][orient] + rows = {('L', i): {(('L', i), ()): Q(1)} for i in range(NL)}; rows[('C', 0)] = {(('C', 0), ()): Q(1)} + frames = {('L', i): c['start'][i] for i in range(NL)}; frames[('C', 0)] = None + centre_frames = {e[3] for e in prog if e[0] == 'center'} + snapshots = collections.defaultdict(list) + paid = collections.Counter(); climbs, options = [], [] + + def helper_only(row): + return bool(row) and all(r[0] == 'L' and r[1] in free for (r, wd) in row) + + def split(row): + out = {} + for (r, wd), q in row.items(): + out.setdefault(wd, {})[r[1]] = q + return out + + def snap(role): + if frames[role] in centre_frames and rows[role]: + snapshots[frames[role]].append(dict(rows[role])) + for t, e in enumerate(prog): + k = e[0] + if k == 'climb': + X = ('L', e[2]); paid[e[5]] += 1 + if helper_only(rows[X]): + climbs.append((t, e[5], split(rows[X]))) + frames[X] = e[4]; snap(X) + elif k == 'center': + X = ('C', e[1]); paid[e[4]] += 1 + for rz in snapshots[e[3]]: + d = dict(rows[X]); add_into(d, rz, Q(-1)) + require(bool(d), 'no centre equals an earlier snapshot exactly') + if helper_only(d): + options.append((t, e[4], split(d))) + frames[X] = e[3] + elif k == 'warp': + X = tuple(e[1]); op = e[2] + sym = (1 if op > 0 else -1) * (abs(op) + 10 ** 6) + rows[X] = {(r_, wd[1:] if wd and wd[0] == -sym else (sym,) + wd): q for (r_, wd), q in rows[X].items()} + frames[X] = e[4]; snap(X) + elif k == 'scalar': + g, frame = e[1], e[2]; d_ = tuple(g[1]) + if g[0] == 'clear': + rows[d_] = {}; frames[d_] = frame + elif g[0] == 'copy': + rows[d_] = dict(rows[tuple(g[2])]) + elif g[0] == 'add': + add_into(rows[d_], rows[tuple(g[2])], Q(g[3], g[4])) + elif g[0] == 'scale': + rows[d_] = {kk: Q(g[2], g[3]) * v for kk, v in rows[d_].items()} + snap(d_) + require(dict(paid) == PAID, orient + ' paid profile of the #4610 word') + return climbs, options + + +def norm(v): + k = min(v); f = v[k] + return tuple(sorted((i, q / f) for i, q in v.items())) + + +def optimum(climbs, options, trank, pw): + keys, kid = [], {} + for _, _, comp in climbs: + for v in comp.values(): + n = norm(v) + if n not in kid: + kid[n] = len(keys); keys.append(n) + E = Echelon() + require(all(E.add(dict(k), i) for i, k in enumerate(keys)), 'distinct components are linearly independent over Q') + need = [sorted({kid[norm(v)] for v in comp.values()}) for _, _, comp in climbs] + cost = [pw(min(trank[h] for h, _ in k)) for k in keys] + centres = collections.defaultdict(list) + for t, r, comp in options: + require(list(comp) == [()] and r == 8, 'centre options are word-free rank-8 rows') + rest, combo = E.reduce(comp[()]) + require(not rest, 'every centre option lies in the span of the components') + require(all(min(trank[h] for h in comp[()]) == 9 for _ in [0]), 'option rows are pure rank-9 (cold) forms') + centres[t].append(sorted(combo)) + # connected pieces over components, joined by climbs and by the options of one centre + par = list(range(len(keys))) + + def find(x): + while par[x] != x: + par[x] = par[par[x]]; x = par[x] + return x + + def join(ids): + for j in ids[1:]: + par[find(j)] = find(ids[0]) + for ids in need: + join(ids) + for ol in centres.values(): + join(sorted({j for o in ol for j in o})) + pieces = collections.defaultdict(list) + for i in range(len(keys)): + pieces[find(i)].append(i) + total = D(0); best_sets = []; sizes = collections.Counter() + for root, comps in pieces.items(): + sizes[len(comps)] += 1 + cl = [(pw(climbs[j][1]), set(need[j])) for j in range(len(climbs)) if find(need[j][0]) == root] + ce = [[set(o) for o in ol] for ol in centres.values() if find(ol[0][0]) == root] + require(len(comps) <= 20, 'piece small enough for exact enumeration') + best, arg = D(0), () + for k in range(1, len(comps) + 1): + for S in itertools.combinations(comps, k): + S_ = set(S) + g = sum((w for w, nd in cl if nd <= S_), D(0)) - sum(cost[i] for i in S) + g += sum(pw(8) for ol in ce if any(o <= S_ for o in ol)) + if g > best: + best, arg = g, S + if arg: + best_sets.append(sorted(arg)) + total += best + return dict(components=len(keys), climbs=len(climbs), options=len(options), centres=len(centres), + piece_sizes=dict(sorted(sizes.items())), optimum=total, chosen=best_sets, keys=keys) + + +def build(): + pinned_inputs() + word = json.loads(gzip.decompress(WORD.read_bytes())) + c = word['canonical']; fr = c['frames'] + trank = {i: len(fr[c['final'][i]]) - len(fr[c['start'][i]]) for i in range(224, NL)} + free = {i for i in range(224, NL) if c['start'][i] == 0} + require(len(free) == 358 and collections.Counter(trank[i] for i in free) == {9: 326, 4: 26, 8: 6}, + '358 helpers start in the common input frame') + t = 1 - C_SELECTED + pw = lambda r: (t * D(r).ln()).exp() + per_local = 8 * (pw(8) + 1 - pw(9)) + rel = json.loads(RELATIONS.read_text(encoding='utf-8')) + V0 = [norm({int(k): Q(s) for k, s in row.items()}) for row in rel['rows']] + out = {} + for orient in ('backward', 'forward'): + climbs, options = replay(word, orient, free) + res = optimum(climbs, options, trank, pw) + words = collections.Counter(len(comp) for _, _, comp in climbs) + row = dict(helper_only_climbs=res['climbs'], climbs_by_word_count=dict(sorted(words.items())), + distinct_components=res['components'], components_independent=True, + centre_options=res['options'], centres_with_options=res['centres'], + piece_sizes=res['piece_sizes'], optimum_per_local=str(res['optimum'].quantize(D('1e-30')))) + if orient == 'backward': + require(abs(res['optimum'] - per_local) < D('1e-40'), 'backward optimum equals 8 (8^t + 1 - 9^t)') + chosen = sorted(res['keys'][i] for s in res['chosen'] for i in s) + span = Echelon() + for i, k in enumerate(V0): + require(span.add(dict(k), i), 'eight independent #5383 relations') + require(len(chosen) == 8 and all(not span.reduce(dict(k))[0] for k in chosen), + 'the optimum is attained exactly by the span of #5383 relations') + row['optimum_attained_by'] = 'span of the eight #5383 relations' + else: + require(res['optimum'] == 0 and res['options'] == 0, 'forward: no centre option and optimum 0') + out[orient] = row + return dict(model='owned helper-relation subspaces over the 358 frame-0 helpers, any pivots, rows with warp words', + C=str(C_SELECTED), V0_gain_per_backward_local=str(per_local.quantize(D('1e-30'))), + frame0_helpers=358, frame0_target_ranks={'4': 26, '8': 6, '9': 326}, orientations=out, + conclusion='No owned-relation subspace beats #5383; the 18 backward locals carry the maximum 144 exchanges.') + + +def main(): + ap = argparse.ArgumentParser(); ap.add_argument('--write', action='store_true'); args = ap.parse_args() + result = build() + path = HERE / 'RESULT-RELATIONS.json' + text = json.dumps(result, indent=1, sort_keys=True) + '\n' + if args.write: + path.write_bytes(text.encode('utf-8')) + require(path.exists() and json.loads(path.read_text(encoding='utf-8')) == json.loads(text), 'stored RESULT-RELATIONS.json equals the rebuild') + print('PASS_OWNED_RELATION_EXACT_OPTIMUM_EQUALS_5383') + + +if __name__ == '__main__': + main() diff --git a/research/owned-relation-exact-optimum-r14/test_controls.py b/research/owned-relation-exact-optimum-r14/test_controls.py new file mode 100644 index 0000000000..f3a92279f9 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/test_controls.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Rejecting mutation controls for relations.py (Part B). Standard library only.""" +import copy, gzip, json, sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import relations as R # noqa: E402 + + +def rejects(fn): + try: + fn() + except SystemExit as e: + return str(e).startswith('FAIL') + return False + + +def main(): + word = json.loads(gzip.decompress(R.WORD.read_bytes())) + c = word['canonical']; fr = c['frames'] + trank = {i: len(fr[c['final'][i]]) - len(fr[c['start'][i]]) for i in range(224, R.NL)} + free = {i for i in range(224, R.NL) if c['start'][i] == 0} + t = 1 - R.C_SELECTED + pw = lambda r: (t * R.D(r).ln()).exp() + results = {} + # 1. a corrupted climb rank breaks the pinned paid profile + bad = copy.deepcopy(word) + i = next(i for i, e in enumerate(bad['programs']['backward']) if e[0] == 'climb') + bad['programs']['backward'][i][5] += 1 + results['corrupted_climb_rank'] = rejects(lambda: R.replay(bad, 'backward', free)) + climbs, options = R.replay(word, 'backward', free) + # 2. a fabricated climb whose component is a combination of two existing ones breaks independence + a, b = climbs[0][2][()], climbs[1][2][()] + fake = dict(a); R.add_into(fake, b, Q(3)) + results['dependent_component'] = rejects(lambda: R.optimum(climbs + [(0, 1, {(7,): fake})], options, trank, pw)) + # 3. a centre option pointing outside the component span is rejected + stray = dict(options[0][2][()]); stray[max(free)] = stray.get(max(free), 0) + Q(1) + results['option_outside_span'] = rejects( + lambda: R.optimum(climbs, options + [(options[0][0], 8, {(): stray})], trank, pw)) + # 4. dropping one #5383 relation breaks the attainment check + orig = R.RELATIONS.read_text + + class Drop: + def __init__(self, path): self.path = path + def read_text(self, encoding=None): + d = json.loads(orig(encoding='utf-8')); d['rows'] = d['rows'][:-1]; return json.dumps(d) + def read_bytes(self): return self.path.read_bytes() + def relative_to(self, other): return self.path.relative_to(other) + saved = R.RELATIONS + R.RELATIONS = Drop(saved) + try: + results['dropped_5383_relation'] = rejects(R.build) + finally: + R.RELATIONS = saved + # 5. a tampered stored result is rejected by main() + path = HERE / 'RESULT-RELATIONS.json' + text = path.read_text(encoding='utf-8') + tampered = json.loads(text); tampered['orientations']['forward']['optimum_per_local'] = '1' + real = R.HERE + tmp = Path(__import__('tempfile').mkdtemp()) + (tmp / 'RESULT-RELATIONS.json').write_text(json.dumps(tampered)) + (tmp / 'SOURCES.json').write_text((HERE / 'SOURCES.json').read_text()) + R.HERE = tmp; sys.argv = ['relations.py'] + try: + results['tampered_result'] = rejects(R.main) + finally: + R.HERE = real + print(json.dumps(results, sort_keys=True)) + if not all(results.values()): + raise SystemExit('FAIL: a mutation was accepted') + print('PASS_OWNED_RELATION_EXACT_OPTIMUM_CONTROLS') + + +if __name__ == '__main__': + main() From eb289efb4f129a0c4e592b96002dc7849e5a9e4c Mon Sep 17 00:00:00 2001 From: Joel Pulikkan Date: Sat, 24 Oct 2026 19:25:12 -0400 Subject: [PATCH 2/3] Address review: owned-relation optimum is not unique (add 194->207 tie regression); fix endpoint-distance exponent Co-Authored-By: Claude Opus 5.5 --- .../README.md | 14 +++++--- .../RESULT-RELATIONS.json | 26 +++++++++++++- .../relations.py | 36 ++++++++++++++++--- 3 files changed, 65 insertions(+), 11 deletions(-) diff --git a/research/owned-relation-exact-optimum-r14/README.md b/research/owned-relation-exact-optimum-r14/README.md index 1fa4769b5d..3e28e29478 100644 --- a/research/owned-relation-exact-optimum-r14/README.md +++ b/research/owned-relation-exact-optimum-r14/README.md @@ -17,8 +17,11 @@ helper-relation subspace on Cao Yifan's #4610 word, in both orientations. The se - pivots on the 26 rank-4 and 6 rank-8 frame-0 helpers; - rows that carry warp words. -The optimum is exactly #5383's span, at **8 (8^t + 1 − 9^t) = 0.07570927 raw moment per backward -local**. The forward optimum is 0. No ninth relation and no better joint set exists. The 144 exchanges of the +The optimum is **8 (8^t + 1 − 9^t) = 0.07570927 raw moment per backward local**, and #5383's span +attains it. It is an optimum, not the unique one. Replacing component 194 by 207 (the relation +h288 − h294 − h296 − h297 + h300 + h303 = 0) gives a different eight-dimensional space with the same +value; zxv found this tie in review, and `relations.py` checks it as a regression. The forward optimum +is 0. No ninth relation and no better joint set exists. The 144 exchanges of the #5398/#5413 controller are the maximum. ## Part B: model and certificate (`relations.py`) @@ -39,7 +42,7 @@ loses its productive target. | distinct components, linearly independent over Q | 225 | 358 | | centre snapshot options (all in the component span, rank-9 support) | 56 (8 centres) | 0 | | connected pieces (components joined by climbs/options) | 110×1, 1×3, 8×7, 4×14 | 358×1 | -| exact optimum per local call | **8(8^t+1−9^t)**, attained by the span of #5383's relations | **0** | +| exact optimum per local call | **8(8^t+1−9^t)**, attained by the span of #5383's relations (not uniquely; see the 194→207 tie) | **0** | The certificate has four steps: @@ -80,8 +83,9 @@ circuits), gives the same optimum. That check is not part of the registered repl - raw root ∈ (.0030272882499, .00302728825); - reserve-limited tested saving ∈ (.00302728824897, .00302728824898). -At the same carrier, the reserve-limited maximum is κ < 0.00302728823898. The chosen κ is 8×10⁻¹⁶ below that -bound. A smaller unit gap, such as 1/7·10¹² (κ ≈ 0.0030272882479), also passes the endpoint arithmetic. It +At the same carrier, the reserve-limited maximum is κ < 0.00302728823898. The chosen κ is 8×10⁻¹⁴ below that +bound; against the certified bracket it sits between 7×10⁻¹⁴ and 8×10⁻¹⁴ below the actual reserve-limited +maximum (corrected from 8×10⁻¹⁶ after review). A smaller unit gap, such as 1/7·10¹² (κ ≈ 0.0030272882479), also passes the endpoint arithmetic. It would change H, however, and #5413's precision checker pins the gap. It is not claimed here. **Assumptions.** The κ is conditional on exactly the five retained selected premises of #5413: diff --git a/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json b/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json index ed7eeb6303..5d02059ecd 100644 --- a/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json +++ b/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json @@ -21,13 +21,37 @@ "components_independent": true, "distinct_components": 225, "helper_only_climbs": 224, - "optimum_attained_by": "span of the eight #5383 relations", + "optimum_attained_by": "span of the eight #5383 relations (an optimum; not unique)", "optimum_per_local": "0.075709271555986216366649243749", "piece_sizes": { "1": 110, "3": 1, "7": 8, "14": 4 + }, + "tied_optimum_regression": { + "original": [ + 56, + 65, + 66, + 194, + 200, + 203, + 205, + 212 + ], + "relation": "h288 - h294 - h296 - h297 + h300 + h303 = 0", + "swapped": "194 -> 207", + "tied": [ + 56, + 65, + 66, + 200, + 203, + 205, + 207, + 212 + ] } }, "forward": { diff --git a/research/owned-relation-exact-optimum-r14/relations.py b/research/owned-relation-exact-optimum-r14/relations.py index 45c2c6bde7..581177e0d0 100644 --- a/research/owned-relation-exact-optimum-r14/relations.py +++ b/research/owned-relation-exact-optimum-r14/relations.py @@ -20,7 +20,10 @@ 4. for independent S, any pivot set has a perfect matching to S inside supports (Laplace), so the lost target moment is >= sum_{c in S} min-target(c)^t; 5. the climb/centre/component incidence splits into small connected pieces; each piece is enumerated exactly. -The optimum is 8 (8^t + 1 - 9^t) per backward local, attained only by #5383's eight relations; forward optimum 0. +The optimum is 8 (8^t + 1 - 9^t) per backward local; #5383's eight relations attain it (an optimum, not +the unique one: replacing component 194 by 207, i.e. h288 - h294 - h296 - h297 + h300 + h303 = 0, gives a +different eight-dimensional optimal space; checked below as a regression, found in review by zxv). +Forward optimum 0. Usage: python3 -I -B relations.py [--write] """ import argparse, collections, gzip, hashlib, itertools, json @@ -181,11 +184,12 @@ def join(ids): pieces = collections.defaultdict(list) for i in range(len(keys)): pieces[find(i)].append(i) - total = D(0); best_sets = []; sizes = collections.Counter() + total = D(0); best_sets = []; sizes = collections.Counter(); piece_data = {} for root, comps in pieces.items(): sizes[len(comps)] += 1 cl = [(pw(climbs[j][1]), set(need[j])) for j in range(len(climbs)) if find(need[j][0]) == root] ce = [[set(o) for o in ol] for ol in centres.values() if find(ol[0][0]) == root] + piece_data[root] = (cl, ce) require(len(comps) <= 20, 'piece small enough for exact enumeration') best, arg = D(0), () for k in range(1, len(comps) + 1): @@ -198,8 +202,19 @@ def join(ids): if arg: best_sets.append(sorted(arg)) total += best + + def score(S): + """Exact score of an arbitrary component set, summed piece by piece with the same formula.""" + S_ = set(S); g = D(0) + for root, (cl, ce) in piece_data.items(): + Sp = {i for i in S_ if find(i) == root} + if not Sp: + continue + g += sum((w for w, nd in cl if nd <= Sp), D(0)) - sum(cost[i] for i in Sp) + g += sum(pw(8) for ol in ce if any(o <= Sp for o in ol)) + return g return dict(components=len(keys), climbs=len(climbs), options=len(options), centres=len(centres), - piece_sizes=dict(sorted(sizes.items())), optimum=total, chosen=best_sets, keys=keys) + piece_sizes=dict(sorted(sizes.items())), optimum=total, chosen=best_sets, keys=keys, score=score) def build(): @@ -231,8 +246,19 @@ def build(): for i, k in enumerate(V0): require(span.add(dict(k), i), 'eight independent #5383 relations') require(len(chosen) == 8 and all(not span.reduce(dict(k))[0] for k in chosen), - 'the optimum is attained exactly by the span of #5383 relations') - row['optimum_attained_by'] = 'span of the eight #5383 relations' + 'the span of the #5383 relations attains the optimum') + row['optimum_attained_by'] = 'span of the eight #5383 relations (an optimum; not unique)' + # Regression for the tie found in review (zxv): replace component 194 by 207. + orig = sorted(i for s in res['chosen'] for i in s) + require(orig == [56, 65, 66, 194, 200, 203, 205, 212], 'component numbering matches the reviewed head') + tied = sorted([i for i in orig if i != 194] + [207]) + tE = Echelon() + require(all(tE.add(dict(res['keys'][i]), i) for i in tied), 'tied set is independent (eight-dimensional)') + require(span.reduce(dict(res['keys'][207]))[0], 'tied space differs from the #5383 span') + require(abs(res['score'](tied) - res['score'](orig)) < D('1e-40') + and abs(res['score'](tied) - per_local) < D('1e-40'), 'tied space attains the same optimum') + row['tied_optimum_regression'] = dict(original=orig, tied=tied, swapped='194 -> 207', + relation='h288 - h294 - h296 - h297 + h300 + h303 = 0') else: require(res['optimum'] == 0 and res['options'] == 0, 'forward: no centre option and optimum 0') out[orient] = row From 0b9f50c3e5a2c62b77c75df14c97a6d8027d16d5 Mon Sep 17 00:00:00 2001 From: Joel Pulikkan Date: Sat, 24 Oct 2026 19:34:43 -0400 Subject: [PATCH 3/3] Gap-parametric precision for the #5413 caller: kappa 0.0030272882489783 #5413's precision checker and conjunction pinned the strict compiler gap 1/7e11 and its carrier (j,H) only as literals; its funding engine and written proof are symbolic in the gap and N=2^H. Replacing the one pinned-gap line by "positive unit gap" (conservative at #5413's carrier) and instantiating the proof's four carrier/endpoint literals funds the unchanged caller at gap 1/7e16, j=72096, H=5046720000000000000000: conditional kappa .0030272882489783 (tested .0030272882489784), +1.00783e-11 over #5462. Numerical/compiler-precision headroom only; zero economic gain. Co-Authored-By: Claude Opus 5.5 --- .../gap-parametric-precision-r15/README.md | 134 +++++ .../RESULT-GAP-PARAMETRIC.json | 137 +++++ .../gap-parametric-precision-r15/SOURCES.json | 468 ++++++++++++++++++ .../gap-parametric-precision-r15/TASK.json | 62 +++ .../V16-APPLICATION-PROOF-v3-R15.md | 457 +++++++++++++++++ .../gap-parametric-precision-r15/VERIFY.json | 105 ++++ .../gap_endpoint.py | 342 +++++++++++++ .../logs/check_only.txt | 1 + .../logs/gap_endpoint.txt | 1 + .../logs/research_package_replay.txt | 15 + 10 files changed, 1722 insertions(+) create mode 100644 research/gap-parametric-precision-r15/README.md create mode 100644 research/gap-parametric-precision-r15/RESULT-GAP-PARAMETRIC.json create mode 100644 research/gap-parametric-precision-r15/SOURCES.json create mode 100644 research/gap-parametric-precision-r15/TASK.json create mode 100644 research/gap-parametric-precision-r15/V16-APPLICATION-PROOF-v3-R15.md create mode 100644 research/gap-parametric-precision-r15/VERIFY.json create mode 100644 research/gap-parametric-precision-r15/gap_endpoint.py create mode 100644 research/gap-parametric-precision-r15/logs/check_only.txt create mode 100644 research/gap-parametric-precision-r15/logs/gap_endpoint.txt create mode 100644 research/gap-parametric-precision-r15/logs/research_package_replay.txt diff --git a/research/gap-parametric-precision-r15/README.md b/research/gap-parametric-precision-r15/README.md new file mode 100644 index 0000000000..58c8662f40 --- /dev/null +++ b/research/gap-parametric-precision-r15/README.md @@ -0,0 +1,134 @@ +# Gap-parametric precision for the #5413 caller: κ = 0.0030272882489783 (numerical headroom only) + +**Scope.** This package gains numerical headroom only, from the compiler gap and precision carrier. The recursive economic +gain is **zero**. The complete #5413 caller is unchanged: the same word, invoice, paid and target profiles, reserve +10⁻¹², compiler tuple, BIT stock and 25-premise conjunction. No paid job, target or compiler parameter other than the +strict gap and its recomputed height carrier changes, and the raw moment is identical. + +| | κ (conditional) | tested | gap | j | H | +|---|---:|---:|---:|---:|---:| +| #5413 (Clear1nsight) | .003027288235 | .003027288245 | 1/7·10¹¹ | 55099 | 38569300000000000 | +| #5462 (ours, same carrier) | .0030272882389 | .0030272882489 | 1/7·10¹¹ | 55099 | 38569300000000000 | +| **this package** | **.0030272882489783** | **.0030272882489784** | **1/7·10¹⁶** | **72096** | **5046720000000000000000** | + +The gain is **1.00783 × 10⁻¹¹** over #5462 and **1.39783 × 10⁻¹¹** over #5413. κ stays below the fixed-profile +ceiling U = .00302728825 (#5409) and below the raw root, which lies in (.0030272882499, .00302728825). + +## Why the gap was pinned, and why it need not be + +#5413's numerical funding engine (`fund_uniform_endpoint.py`) already accepts any **unit** gap g = (tested − κ)/7. +It derives the least height grid j with (H+1)¹⁰⁰⁰ < 2ʲ, where H = j·den(g). The gap was pinned only as literals: + +1. Precision checker `check_v16_precision_v3.py`, one line: + `need(gap==(tested-kappa)/7==Q(1,700000000000), 'actual strict compiler gap')`. + The carrier obligations next to it, `H==j*gap.denominator and (H+1)**1000<2**j`, are already parametric. +2. Conjunction `check_neutral_closure.py`: + - the endpoint gate (κ, tested, gap and gain literals); + - the height gate (H and j literals); + - the hash of the accepted written proof. +3. Written proof `V16-APPLICATION-PROOF-v3.md`. The argument is symbolic in N = 2^H and M = F16(N). The carrier + appears only as recorded values at four sites: + - §5, the H line; + - §5, the gap line; + - §6, a **non-claim** ("D0 < N^gap would fail: log₂D0 = 1048576 while H·gap = j, H·r0 = j/10"); + - §8, the funded (K, C) pair. + + §6/§7 explicitly avoid any absorption at the fixed carrier ("no C0bar0 and gap.numerator==1,'actual strict compiler gap (positive unit gap; gap-parametric)')", + "pinned": "need(gap==(Q(fund['tested'])-Q(fund['kappa']))/7==Q(1,700000000000),'actual strict compiler gap')" + }, + "precision_receipt_differs_only_in": [ + "carrier_H", + "carrier_gap", + "carrier_j", + "expanded", + "mathematical_application" + ], + "previous": { + "pr5413": { + "kappa": ".003027288235", + "tested": ".003027288245" + }, + "pr5462": { + "kappa": ".0030272882389", + "tested": ".0030272882489" + } + }, + "proof_literal_sites": 4, + "raw_root_bracket": [ + ".0030272882499", + ".00302728825" + ], + "reserve_limited_tested_bracket": [ + ".003027288248978444", + ".003027288248978445" + ], + "scope": "numerical compiler headroom only: same complete #5413 caller, invoice and profiles; zero economic gain", + "supremum_note": "every positive unit gap is admissible; kappa < tested < .003027288248978445 is the only bound", + "tested": ".0030272882489784" +} diff --git a/research/gap-parametric-precision-r15/SOURCES.json b/research/gap-parametric-precision-r15/SOURCES.json new file mode 100644 index 0000000000..5503ebb912 --- /dev/null +++ b/research/gap-parametric-precision-r15/SOURCES.json @@ -0,0 +1,468 @@ +{ + "schema_version": 1, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446", + "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "usage": "input", + "git_blob": "ea9dfc3e40ad7bd5298b3add299b460f3eca11a4", + "sha256": "ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "usage": "input", + "git_blob": "cddadb2ce1f13393a63d739e92c7964a0403f27d", + "sha256": "bf328da5849a07eadad07e072252894acdc231915d0039df511d70d5d57955d3" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "usage": "input", + "git_blob": "c50958cf8d98edb9f1ff2f190c4df5016e5a2829", + "sha256": "14536ff6baf8b4a8bce96b6a35b5b6acbb9d416d83d9230a903e0d776c6edc02" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "usage": "input", + "git_blob": "04c6c7f36cb1b9fcf0b464bad3d3d83aaae7c864", + "sha256": "cc297ee54c2743615dfe857838d5f40424ccd33fdb08ecfafbc41b1710416d91" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "usage": "input", + "git_blob": "975714d0c15714070b2303ca48d31871f2095210", + "sha256": "1f17fda221bc781ca0b2a120916ed500ba84c305a916a65436a5d6c72d116bcf" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "usage": "input", + "git_blob": "0bbe283da6ab0874d78f6a6119952e75197f081e", + "sha256": "dfa125a8c26b86cfa2024edab9f8ed3c95ebe23bffc1bedfd3c90aa471e80ae0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "usage": "input", + "git_blob": "933b2234afa8c264b09c9b1096ae520e73c3432e", + "sha256": "ecefd9b890ccaa46e9f00a6e43faf16aaaf8ec8c992ab48bf245af38aa3e3f23" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "usage": "input", + "git_blob": "b868fe46ce7ff96a51f7b612758685a23014d31d", + "sha256": "a02e79fb4615f4f987e3b3617c2b42eea2c1d7415cc66fa702a8b0cd28e6387e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "usage": "input", + "git_blob": "faed00ed09bb24a99b8136aadcecf6b3832c72d1", + "sha256": "6fc67329c2772538be6f278e9787782ad064306917e3bb40889f4cef6421d41a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "usage": "input", + "git_blob": "856b4599eb999310ce693ba2f3db12663ecc50db", + "sha256": "438ead22afb57bd72275fdf6fd36e680918309d6492b6165e79c3ff7ea94c424" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "usage": "input", + "git_blob": "8cd6f8829e19b845a5df477353564cbf7abb88d7", + "sha256": "8296ae58fdbb45515d2b3e0158355804ade22c1c579d940c889c228dc1823891" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "usage": "input", + "git_blob": "60df54f0363f3eb26105b753f2432955d4468449", + "sha256": "63bd9003395cfdc2308f6f875464bb57ef6ca708759d5ea468dea74b300bfc92" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "usage": "input", + "git_blob": "9a2d8a37b80b613641f296d6c1edb69459c46298", + "sha256": "2253a106e5edeade264c8ca7cffdaeba1dacabc34a8635fa7a396d877dd723d4" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "usage": "input", + "git_blob": "579364b284d5c19c96135293e90b314ff1b2e3ea", + "sha256": "84df3e63ea1f185b61ed32a73c588373063ccbba90d94db9c1d5202f47ed5af2" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "usage": "input", + "git_blob": "3bf73d72cf1b91ac8a99747eab6e1b3d5aee1d4a", + "sha256": "1ce00ce7a0fc5f97eb9e8992b8b5d92195745d8ec289cd81d82201cd712d7305" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "usage": "input", + "git_blob": "0dd60294b2cf252774a7f9c4d5f27e22a1633e07", + "sha256": "8c874ecaf4d3824876c59d9868721bf237836acaef23ded3b58e6c1e6fca1ae9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "usage": "input", + "git_blob": "1acd6f7b1dce17d1d08911be68ffa017e9466014", + "sha256": "fbf04da0aeacaa8b9a56fa52c3c9b37449818ace7e5abed963ae03203a81f8eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "usage": "input", + "git_blob": "bf31af785122dea7cbceacbfa64c21e567e4fca7", + "sha256": "cf7439c9eb4095224126dd5eefc9f1c5dfe1968d6e8eca5b87d4a3897841182d" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "usage": "input", + "git_blob": "444398e7bebee418b5bc9b52ef8702fa95d6bcd5", + "sha256": "e445e7da76e9d8e5dbad2c5fc0bd8aa17e3f5c6d0bfcf56f778c3960426909a1" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "usage": "input", + "git_blob": "ac6d803cf61b3be5031144283129ef899d6dca50", + "sha256": "dbdd056bece96b5c519336a7a1c44d2d9d8e84d134783d156a955bf472405f24" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "usage": "input", + "git_blob": "2114f57aa64c26b5a14917eeafa2a76fadac948f", + "sha256": "4292f2f93e91b556be3114f5aae2853ce9acd747619729b54badd2af97315eea" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "usage": "input", + "git_blob": "574c1d0bd75cd85f720991d815272738aa3e5b8f", + "sha256": "cda8f596f7854f42a228f757d5f8e68f6b2256a19c5ae3771fb40753cedc5b39" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "usage": "input", + "git_blob": "606dc5997217213d9bc1dfa7ebe6bb6f861f8530", + "sha256": "1bd319a30febee6053d24204442c827e1ee7216d70457311b9863a809786887a" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "usage": "input", + "git_blob": "dab8936f66b856a829f52c8d87184a0f72d6c9e2", + "sha256": "c4bcb367b6e087a43b5db21e429b71dd845a18efb475c71fd37eb26bfc7430bd" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "usage": "input", + "git_blob": "4a264e2cec4db789bf6fea865511684f11fad3ff", + "sha256": "5a3385aaddb632e4e23372d73b104455e2824d15782df9df0458069e824f969e" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "usage": "input", + "git_blob": "0c1a1ec8e22b183861b2a6db9f94126687ecc926", + "sha256": "b0fb7538240b08557689cf47384ecbe9708697f5576db1f1f33dce7119dd8375" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "usage": "input", + "git_blob": "bfe0f019bef756a698ce5a0d31f9229f1e1dc834", + "sha256": "5e2385eaae212161900cc98be2e07db8fdb96ef511edba2aff0a3c47d23a771c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "usage": "input", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "usage": "input", + "git_blob": "7ee84b30892f7354e1c36611f1a5e9b082dc6147", + "sha256": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "input", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "usage": "input", + "git_blob": "3ccee4f7645729889b4d38aaa69e6768db59dbd3", + "sha256": "e5b325235eeb6c976a8dc568df838f609fcca0f52945f00bb6b2e9a973a1a11b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "usage": "input", + "git_blob": "4959f78b9f940012d2d58f21d5b7148d73a61fe9", + "sha256": "15e90b63c5659090f02902cb38951ec4ab252352fb0b967b411ed547c501e2ba" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "usage": "input", + "git_blob": "ee684bfc8c3aef3521de0e0df80996c6c329135e", + "sha256": "9ef7ee4082631566eb7903c3e21e517ef58039dca2a47104a2279c459589eb47" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "usage": "input", + "git_blob": "013d48050eb69a73e2dbe387171289fabe8cd7f0", + "sha256": "a37fa9735bbb2697811de72a706b243842d1303243f6e6a0300bd5046d4f3d66" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "usage": "input", + "git_blob": "92d0d7e523dbf90c67b7244de4c87cc74c0d3b61", + "sha256": "0d86590c471a498f3b735397d42bbaf4d5e89c33b75ddbd48dbf972192ab351f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "usage": "input", + "git_blob": "01775a36ae1238350bf8cd859b04cb8c4589873b", + "sha256": "60cc512b39cdb9ea2c2ac6c6634c8d3f9627d96ace08ffa659a9d9472444122b" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "usage": "input", + "git_blob": "b8c7533352e91026f91b428c47cf4f3589bbb9c3", + "sha256": "a53bdbc009830f83b91233cf7cc2c8e9a03d76cff93c73bdd4f52fceb742e73f" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "usage": "input", + "git_blob": "7a16a7dfc2a4a09c55fe0ad8b90afc0a19c25fc8", + "sha256": "fc2e447a0043f74b133a24b67b2a87e4ff87232dd8a003253d19dbf2390a9092" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "usage": "input", + "git_blob": "dd77397ca519f0c15799b4f90a489af3d6a2cb0f", + "sha256": "f16756004bd3100e4993b250181c4c8d15c31b0a1478b627091dd900e1103888" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "usage": "input", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "usage": "input", + "git_blob": "5cbfc4fd02dce926c3d235f1549bdb2035dea088", + "sha256": "2d59282f3b5e9fb848d0099ce91729fa433162e6975f877a441e2ab4f57a29c5" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "usage": "input", + "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455", + "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65" + }, + { + "path": "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "usage": "input", + "git_blob": "f3111b47e89496da8ca0ee45b2e4b258c0634d8e", + "sha256": "7dc356001ed597ad6fc9fd3e0bc6ff7e3ec3a580a579a956827aa17fccfdd2dc" + }, + { + "path": "research/coupled-helper-neutral-completion/engine_adapter.py", + "usage": "input", + "git_blob": "3825fd0799dac2f19360c75c26d1ff3bd3ec323d", + "sha256": "4a3de4a9ca3d65d0485826aa17368789015af7815e7febd74d335302b7dfb42b" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "usage": "input", + "git_blob": "51dcd0091a9231548c7067b731f845517ec3c9cd", + "sha256": "5184c975c9a5a6364334fe665d27235c6aab96c14f7cd269ff68c1e0f4f16a6d" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "usage": "input", + "git_blob": "d777491f69b55d1e98d401f2875d5aa08c9c7dfc", + "sha256": "18225bcb8ec394c97b0f367df566359c2d822d8ed06d60fe1a20dc557ca52837" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "usage": "input", + "git_blob": "d5e3926721e0555ff43c40894bb95a15aee283f1", + "sha256": "a6c334252c16fa31687017a7a53c7e0f53499d0f5748062f0b8aaa43283d8ce7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "usage": "input", + "git_blob": "99a9f8ee9cdded70dbb3d4ac30c28500946469b0", + "sha256": "2172779f65f16b073a25e393bb0ac9cc320135360ad57c6f576917cda1ffd106" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "usage": "input", + "git_blob": "ffc2de2792f51111f73500be3a2e4e8f6bf55a57", + "sha256": "70ab7d13548962097ad83ad393b8482f52e827b8996869011ce6d071146bd3eb" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/global.json", + "usage": "input", + "git_blob": "91e35594f40bfd32ba993a5997f2b76549b5057d", + "sha256": "e1c90e659993561503c054455a5c21ddfd273432695863619df66654fa2358f7" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "usage": "input", + "git_blob": "d66216ad80b502c4042979269655bacb9f6668b9", + "sha256": "e7df9fe1a7a00f67bbf35e9b155537fd26a0c05b61788653b878bd84d9006450" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/local.json", + "usage": "input", + "git_blob": "e7d12a82da7942c3e9e41264ef898acfb2097a0d", + "sha256": "e77d3f0eec9e2d4d7d29926ba896dfb4840ce0e43d3780399a649ca6d7fc90a0" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "usage": "input", + "git_blob": "40775ddeb160f35510d814fd1ad8da96ce14360b", + "sha256": "756eaae414a4396b189d51bc0804f42d38c6e8d9750f5ca078ae8dae456ce1b9" + }, + { + "path": "research/coupled-helper-neutral-completion/reports/expected/source-loading.json", + "usage": "input", + "git_blob": "44b5b599730b6f7bbf6084a60a4fe9b1ee271297", + "sha256": "751bb2ffaadfdc2cd430ec9841fe572d70031f77e42e375ec02664ebb98760bf" + } + ] +} diff --git a/research/gap-parametric-precision-r15/TASK.json b/research/gap-parametric-precision-r15/TASK.json new file mode 100644 index 0000000000..2dc51c6283 --- /dev/null +++ b/research/gap-parametric-precision-r15/TASK.json @@ -0,0 +1,62 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 7, + "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "On the complete #5413 caller (unchanged invoice, profiles, reserve 1e-12, compiler tuple, BIT stock): is #5413's precision/height argument parametric in the strict compiler gap, and what endpoint does the finest admissible unit gap fund?", + "scope_change_reason": "#5413's precision checker and conjunction pin the gap 1/7e11 and its carrier (j,H)=(55099,38569300000000000); our #5462 therefore stopped at kappa .0030272882389 although the alpha reserve allows tested values up to .003027288248978444. The written proof is symbolic in N=2^H, so the pin is a literal, not a mathematical obligation.", + "bottleneck_link": "https://github.com/CrocSwap/integer-mult-bounds/pull/5413", + "outcome": "completed", + "evidence": "gap_endpoint.py: invoice byte-identical; funding PASS at gap 1/7e16 with recomputed least grid j=72096, H=5046720000000000000000; one-line gap-parametric precision checker is conservative at #5413's carrier and passes at the new one; written proof instantiated by four literal substitutions; 25/25 conjunction premises PASS with only endpoint/carrier literals moved; seven rejecting controls; every unit gap 1/(7*10^m), m=12..18, funds.", + "claim": "Conditional kappa = .0030272882489783 (tested .0030272882489784; +1.00783e-11 over #5462, +1.39783e-11 over #5413) from funded compiler/precision headroom only; zero recursive economic saving; the precision argument admits every positive unit gap, so the only bound is tested < .003027288248978445 (alpha reserve).", + "author": "Joel Pulikkan (GamingPuzzled)", + "ai_assistance": "Claude Opus 5.5 (Anthropic) via Claude Code, directed by Joel Pulikkan (GamingPuzzled).", + "open_questions": [ + { + "question": "Can a changed paid or target profile on the #4610 word fund kappa above the fixed-profile ceiling U = .00302728825?", + "why_it_matters": "With a gap-parametric carrier the remaining endpoint headroom at the #5413 profile is below 1.5e-16 (alpha reserve); the raw root is below U. Further progress needs an economic change.", + "first_step": "Price one candidate histogram change with scripts/compare_recursive_invoices.py before building a word.", + "blocked_by": "No admitted changed native word or helper factorization is available." + } + ], + "budget_minutes": 120, + "stop_rule": "Stop at the reserve-limited endpoint of the unchanged #5413 invoice; change only the gap literal, the recomputed carrier and the endpoint literals; no word, invoice, profile, reserve or tuple change." +} diff --git a/research/gap-parametric-precision-r15/V16-APPLICATION-PROOF-v3-R15.md b/research/gap-parametric-precision-r15/V16-APPLICATION-PROOF-v3-R15.md new file mode 100644 index 0000000000..41bedc2f3b --- /dev/null +++ b/research/gap-parametric-precision-r15/V16-APPLICATION-PROOF-v3-R15.md @@ -0,0 +1,457 @@ +# Fresh physical/precision/stock application for the frozen neutral v16c caller + +This is a **conditional source-specialization proof**, under exactly the +selected native/all-column, owned-erasure, finite-compiler, precision/tape and +analytic-recovery premises. It supplies no new physical oracle and makes no +unconditional multiplication or formal-kernel claim. It must be read jointly +with the frozen649-column local proof, the corrected145-axis global normalizer +packet, the fresh v3 ordinary/norm census and the independent numerical funding +certificate. The original component receipts retain their narrower scopes and +false overall-admission flags. + +## Fixed objects and two preserved diagnostics + +The actual local words are `caller/NEUTRAL-BACKWARD-v16c.json`, SHA256 +`cc297ee54c2743615dfe857838d5f40424ccd33fdb08ecfafbc41b1710416d91`, and the +review-only forward word, SHA256 +`dfa125a8c26b86cfa2024edab9f8ed3c95ebe23bffc1bedfd3c90aa471e80ae0`. +The complete raw caller is `caller/NEUTRAL-CALLER-v16c.json`. It uses all18 +backward words in the exact #5398 direct controller, not16B+2standaloneF. +This avoids double counting the direct wrappers already in its20SIGNED_SWAP +and4Q_POWER records. + +Source execution is **right boundary, physical events, left boundary**: the +matrix convention is L*W*R with the rightmost factor first. V1's execution +description reversed those boundaries. V2 corrected the order but still +misread the first diagonal integer as a scalar sign. It is a **Q exponent**. +A negative Q exponent requires the native central translation Q²=X after +the left boundary, not a scalar−1. Both earlier artifacts and run receipts +remain diagnostic; their count-only passes do not certify those descriptions. +The final v3 result must bind the corrected normalizers and actual order. + +The v16c local words themselves did not change. Their signs in standalone +SIGNED_SWAP wrappers really are exterior scalar signs and remain applied once +per whole field; they are unrelated to the global diagonal Q exponent. + +## 1. Source physical class: every new instruction has a realization + +Use canonical main `1ec1119972c9aefe42525172d07b332fcff81cb4` and its selected +`final4610-independent-admission/SPECIALIZATION.md` sections1–3,6, +`FINITE-PRECOMPILATION.md` sections1,3–6 and +`FINITE-TEMPLATE-CLOSURE.md` sections3–6. The higher-moment and logarithmic +compiler theorems are those pinned in this lane's `PINNED-HIGHER-MOMENT.md`. +The generic class permits fixed finite Gaussian-dyadic scalar words, complete +positive Gaussian jobs with two-sided signed monomial adapters, arbitrary +complete spectators, fixed binary coordinate permutations/quadratic unit +phases and owned storage with restoration. The instance must be established +to belong to that class; no premise “the new program works cheaply” is added. + +The new local ADD coefficients are halves and units. CLEAR targets only +the eight new owned T fields. The original nine owned fields belong to the +unchanged audited provider. T is cleared and retagged zero before its first +SWAP; the original arbitrary h data is moved into T rather than erased. +The later ADD restores the complete original h direction before T is erased. +The root's649-column replay proves all632 original directions and all17 +arbitrary owned entries, including exact zero returns. No promised blank +productive input or borrowed erasure is involved. + +All800 helper normalizers are actual signed phase-bearing maps installed on +all400 named complete source helper jobs. Their independently checked +17-class phase identities are byte-bound; no normalization is moved inside a +partial job. Their P matrices are invertible and D/X/phase factors have unit +modulus. The240 Z-basis maps are the source Kp/Km words and their explicit +inverses. The16 paid C8/D8 axis routes and16 productive h/C8 routes are literal +axis0/8 permutations. Their full phase-bearing C8/D8 identities were checked +separately. Thus all1072 outer B maps are counted **once**, including these +800+240+16+16 maps. The source's own464 boundary maps are additional. + +For f columns, every fixed P acts on each complete f-axis slot, and every +quadratic phase is `a*f+sum_j q(x_j)` modulo4. Exterior ADD/SCALE coefficients +are left unchanged. The source free-operator substitution, rather than tensor +distributivity across a scalar sum, gives all-column logical correctness. +All extra T, query and suspended-parent fields remain full spectators during +the appropriate child. This introduces no new field extension or scalar1/12; +that metric belonged to a historical proposed120-port route and is absent here. + +The global145-axis normalizers are fixed permutations of complete f-axis +slots, together with native X on the shared central slot for negative Q +exponents. They are source-permitted monomials. Actual main input/output +permutations surround the **whole** source caller, not individual coupled +instructions. Each helper's input/output145-axis permutations surround its +entire LOCAL occurrence, and convert its known stage-local positive job to +the common global first-rank layout. These are14688 additional helper field +maps, separate from the800 source phase aliases per LOCAL. Main normalization +has7168 permutation field maps and1792 native central X maps. Whole-IDLE +positive jobs additionally have6720 input/output permutation field maps. +The7168+14688+6720 layouts are28576 field maps; including1792 native central X +maps gives30368 additional normalization field maps. None is declared free or +fused away. The corrected +normalizer packet is an acceptance +dependency of v3, rather than inferred from a Laurent histogram alone. + +## 2. Same-chart whole-field SWAP lowering, including zeros and errors + +The declared whole-field/chart SWAP can use the retained scalar realization + +``` +a+=b; b-=a; a+=b; b*=(-1). +``` + +This is an exact ordinary SWAP, with tariff3*8+2=26 in the inherited scalar +unit. Each ADD has safe factor2 in both declared field norms; sign has factor1. +A conservative interval exponent is therefore three per SWAP. Completed +norm1 is never substituted for this instruction-prefix bound. SIGNED_SWAP +uses the first three ADDs and tariff24. + +Every ADD in this lowering requires the same physical ordered address space +and chart. At outer main boundaries the complete standard caller fields share +the ground computational ABI. The new h/T swap has an explicit cleared, +ground-retagged T partner; its h field is at that ordinary outer ABI. + +For the source provider's eight terminal mode/cache swaps, the independent +source proof establishes that the original persistent mode row is exactly zero +before consuming the normalized cache. Retag that **proved zero** to the +cache's current chart, execute the scalar SWAP in that shared chart, and +reset/clear the returned owned zero as required. The persistent output obtains +the cache's required data and chart. Any reset of the private zero's descriptor +occurs before its next use. These are fixed proof-directed retags, not runtime +zero predicates, nonlinear projections or extra Gaussian calls. The source +already permits identity retags on an identically zero field; the full-column +zero proof is the requisite premise, not a guessed numerical smallness test. + +This lowering adds only finitely many metadata/descriptor records, covered by +the fresh raw primitive-schema majorant. It preserves the exact whole-SWAP +endpoint and all ownership rules. A perturbation at a zero retag is carried +through physical identity; it is not set to zero by the proof annotation. +The declared field residual bound therefore remains valid under arbitrary +injected residuals, rather than relying on numerical cancellations staying zero. + +Alternatively, a retained direct tape-swap realization may be used with its +actual primitive-prefix/rounding contract. The numerical bounds in v3 use the +explicit26-unit scalar lowering; no missing direct-swap implementation is +assumed to have norm1 at every internal instruction. + +## 3. Actual raw ownership, completion and chronological return + +Each raw LOCAL has17 private fields, tagged by its physical occurrence. Across +18 calls these are306 fields. The actual caller separately reserves one112-field +query bank, reused by15 sequential queries. Each query clears its arbitrary +entry, copies the actual source field, completes the one rank-one Gaussian +(and required inverse translation), adds to the actual destination and clears +the query field. It returns zero before the next query starts. Thus the raw +program uses418 private field positions before recursive/movement scratch. +A larger1986-position reservation obtained by allocating each query occurrence +separately is a conservative overestimate, not the actual minimum or a productive +count. The corrected inventory distinguishes allocation from1680 query uses. + +The ordinary uniform compiler tags every raw-unit occurrence by its full +instance path. All suspended parent banks, descriptors and complete role streams +remain parked while a child runs. The child has distinct own banks, completes +its entire job, restores both adapters and physical ordering, and returns +before its parent resumes. Correlated contents do not identify owners. No +one-bank-per-depth reuse or syntax-node alias is presumed. These rules are +exactly the source constructive finite-batch implementation. + +The new local main map is the same ordinary uncoded B used by the existing +direct controller. Its408 helper outputs are autonomous. Substitution into +the old chronological source main identity therefore preserves that main +identity for arbitrary inputs. The new helpers do not become operands of later +main events. With the corrected actual145-axis normalizers, the full raw +program has10,928 independent productive inputs and64,260 paid calls. +The signed paid-minus-target profile change is +144H8−144H8, identically zero +at every exponent. The only proposed improvement is separately certified +compiler/outer headroom. + +## 4. Fresh ordinary record and coefficient bounds + +The v3 parser independently reconstructs the unchanged source body, both basis +programs and its exterior scales, then the actual frozen v16c outer word, +the retained controller boundaries/events, query realization and corrected +whole-main normalizers. It counts literal P/D/X/phase occurrences and all +scalar tariffs. Input/output whole-job permutation maps, central X aliases, +metadata/zero resets, address descriptors, owner parking and restoration are +additional **ordinary work**, never Gaussian credit or zero machine work. + +For a fixed d-axis binary affine/quadratic monomial, elimination uses finitely +many selected-bit row additions, at most3XOR per row swap, d translations, +linear/quadratic unit phases and fixed return routes. The conservative bound +`64*(d+1)^3` covers both directions and descriptor/instruction passes. Here +the raw ambient is145, so this is a new raw145-axis recipe bound; the old +nine-axis1000-record local number is not blindly applied to a full145-axis map. + +Let I be the fresh complete raw field-record count plus all owned positions, +paid jobs and productive roles, with one extra for ceilings. The fresh +overestimate + +``` +Rraw <=64*(145+1)^3*I^3+exact_scalar_tariff, +Graw <=exact_scalar_tariff+8*Rraw +``` + +pays explicit role-order permutations (at most a square in incidences), all +route descriptors, whole-job matching, forward/inverse recipes, owned scans +and the literal source/new words. It is separate from the exact literal +census and may deliberately count already-emitted routes again. No productive +credit results. V3 checks these **values**, the actual height allowance, +raw arities and private inventory are below A0=2^128. No old181million or10^9 +numerical cap is an acceptance premise. + +The tariff unit is an admitted primitive schema with its retained physical +cost, not one literal Turing tape instruction at arbitrary f. Fixed binary +recipes use the source compact-control implementation, complete dirty-control +reservations and repair. Its domain remains f<=p, address boundA=O(p), +K/log p tending to infinity and a superpolynomial record fiber. At the outer +layer f<=e<=floor(b_in^epsilon), p=6b_in, with epsilon<1. The same domain holds +eventually. No arbitrary RAM gather, new tape per coordinate or new movement +exponent is introduced. + +## 5. New constructive expanded compiler majorant + +Apply the source chronological product, charged target completion, disjoint +splitting and integer finite compiler to this newly specified raw program. +At q=1024 and raw maximum145, the complete strictified-unit count/height/owner +overestimate has base-two logarithm at most + +``` +2*(1024*(2+2*128)+10+2*8192)+6+3*8193=585757<1048576. +``` + +The product factor charges every circuit/bank incidence; completion/splitting +add at most ambient-rank squared; squaring the whole inventory pays role +order; the cubic matcher bound pays both adapters and descriptor passes. +Choose D0=2^1048576 for this **new** strictified unit. + +For every n>=0 construct the source integer compiler with sequential rank-one +bases, full chronological substitution, product of the widths of all distinct +needed smaller ranks to clear batch denominators, fresh instance-path banks, +and row-elimination coordinate/role recipes. Define + +``` +F16(0)=D0, +X_n=(n+1)*(D0+1)*(F16(n-1)+1), +F16(n)=X_n^(16*(n+1)^2) (n>=1). +``` + +Strong induction bounds every actual W_n,P_n,U_n,O_n,R_n,G_n by F16(n). +Separation makes all substituted exit/complement widths strictly smaller. +There are at most (D0+1)^(2n+2) mixed instances; denominator clearance is at +most F16(n-1)^(n-1), one factor per distinct smaller width. Their complete +bodies, all owned banks, coefficients and restoration fit +I_n<=X_n^(3n+5). Role permutations and cubic fixed-coordinate matchers then +fit `64*(n+1)^3*(I_n+1)^3<=X_n^(9n+20)<=F16(n)`, since +`16*(n+1)^2-(9n+20)=16n^2+23n-4>=35` for n>=1. +This is a terminating constructive definition; no enormous value or program +has been materialized, and no finite probe is the all-n proof. + +The independently funded carrier is + +``` +H=5046720000000000000000, N=2^H, +M=F16(N), W,P,U,O,R,G<=M. +``` + +The fresh strict tested/claim gap is1/70000000000000000. The separate funding +receipt proves the actual rank-one efficiency through the paid/target moments, +completion/tails, shifted exits, eta and successful H grid. The majorant M +supplies **no** efficiency ratio, productive credit or improved kappa. + +## 6. D0 is not absorbed at the fixed carrier rank + +In particular, it is **not claimed** that D00`, after the source ordinary exponent guards apply. C_word may +be huge; it does not need to be below N^(sigma'-sigma). The retained stopped +weighted-tree theorem supplies its precise internal/leaf version and powers. +The new finite multiplier is then absorbed against the strict outer gaps as +the **outer input/record size** grows, not against the already fixed N. + +Explicitly, for any fixed C>=1 and positive rational spare power delta, +`h>=2^ceil(log2(2C)/delta)` implies C<=h^delta/2. The same construction, with +an enlarged exponent for the fixed polynomial/log setup factors, gives an +effective domain-entry threshold. C may be a computable expression in M. +This threshold can be vastly larger than N; no practical-size claim is made. +The source's superpolynomial fiber absorbs every new fixed setup degree, +with a new threshold. It does not excuse nonuniform data-dependent gathers +or an unproved operation species. + +## 7. Fresh semantic grid, injected errors, storage and tape thresholds + +Put + +``` +Zbar=2M, Ebar=64*(4M+N+1)^3, +Bbar=M+Ebar, C0bar=32*N*Bbar^2, C1=1. +``` + +These new integers satisfy +`2*M*Zbar^2+8*M+4*Zbar+4+32*N=3, the same induction gives +a linear bound2Bbar*e, after the elementary base. The finite tree has at most +`(M+1)^(Dord(e)+1)` nodes, Dord(e)<=log2 e. The logarithm of its coordinatewise +residual-site count can be bounded explicitly using + +``` +Jsites(e)<=(M+N+1)*e*(M+1)^(Dord(e)+1), +log2Jsites(e)<=(3M+N+4)*e. +``` + +Prefix/suffix amplification, site summation and the retained outer/remainder +passes therefore fit `(4Bbar+36+3M+N+4)*e=p_grid, Delta=C0bar*d_axes<=p/4 and signed width +`p+2Delta+3<=2p`. This is an outer precision threshold; no C0bar=2N`; direct elementary leaves +handle smaller widths. + +Productive divisibility needs W^Dord(d_axes) complete rows. A safe private/ +parking overreservation is `[W*(O+1)]^Dord(d_axes)`. The associated complete +chunk reserve is at most +`(ceil(log2W)+ceil(log2(O+1)))*Dord(d_axes)+2`, a fresh fixed-coefficient +O(log d_axes) quantity. If Lstock bounds that coefficient plus constants, +`d_axes>=2^(2*(Lstock+2))` is a sufficient source-style domain threshold after +enlarging ceilings. Simultaneous BIT/complex/other independent stocks multiply; +their chunk reserves add. Pad once per actual support-local phase to a multiple +of the full stock product, with factor<2; preserve full spectators, restore +appended zero rows and remove them before later phases. Do not pad anew at +every recursion depth or replace a product of live stocks by their maximum. + +For the current actual BIT atom.004, the support-local source reservation has +form `C_new*(log2 h+h^.004*(log2 p)^3+1)` complete chunks. C_new is enlarged for +this actual template. A sufficient polynomial part of its new domain-entry +threshold is `[1024*C_new*(log2p)^3]^(1/.996)`, enlarged for logarithmic/base +terms. The source outer gate proves beta*(1-.004)>0. Thus the BIT reserve and +the new complex O(log d_axes) reserve are simultaneously sublinear after their +fresh threshold; their row cardinalities still multiply. This is where the +updated source BIT-stock condition, rather than a maximum of two reserves, +is used. + +Here is an explicit coarse simultaneous-stock absorption, also valid when +the source reserve has already been weakened to a larger power. Put atom=.004, +eta=beta*atom>0 and suppose the retained source-domain bounds are + +``` +log2 S_BIT <= C_BIT*h^(beta*(1-atom)), +log2 S_complex <= C_stock0+C_stock1*log2 h. +``` + +The exact exponent difference is beta−beta*(1−atom)=eta, not merely the +positivity of beta*(1−atom). For +`h>=(4*C_BIT)^(1/eta)`, the first term is at most h^beta/4. Set +`Lstock=ceil(log2(16*(C_stock0+C_stock1+1)))` and + +``` +Tstock=max(16,ceil((4/beta)^2),ceil(4*Lstock/beta)). +``` + +For h>=2^Tstock, put t=log2h. The inequalities log2t<=sqrt(t)<=beta*t/4 +and Lstock<=beta*t/4 show +`C_stock0+C_stock1*t<=h^beta/4`, with further slack. Therefore + +``` +log2(S_BIT*S_complex) + =log2S_BIT+log2S_complex <=h^beta/20; the computable condition +`h>=(log2p)^(2s/gamma)` bounds this factor by h^(gamma/2) and yields a weaker +power still below h^(beta*(1−atom)). Logarithmic h terms have an explicit +power-domination threshold of the same Tstock form. Alternatively, use the +source's supplied joint h,p threshold directly. This is compatible with the +checked outer source regime; no absorption at the fixed carrier N is used. + +Depth-first execution uses a fixed finite number of template-dependent tape, +route and instruction types. Levels occupy longer tape regions. Every parent +stream, owner bank and descriptor is parked and returned with the retained +selected-bit repair/movement tariff. No new tape per coordinate or RAM-to-tape +simulation is assumed. The final threshold is the maximum of the new grid, +stop, stock, polynomial setup, movement-domain, BIT and analytic/recovery +thresholds. If a source foundation supplies only an asymptotic domain-entry +hypothesis, its unknown implementation cutoff remains precisely that retained +hypothesis; no invented numerical cutoff replaces it. + +## 8. Funding, ordinary BIT and recovery interface + +The independent funding file uses K=.0030272882489783 and tested C=.0030272882489784, +reserve10^-12, cutoff20/floor21, offset1/5, product1024, ambient145, +theta63/64 and logarithm power1000. Its complete paid/target invoice is bound +to the actual neutral profile. The same general source theorem permits that +tuple and proves strict uniform leaf efficiency at the recorded H. All54 +strict and four functional outer predicates pass at its new rational +parameters, using the admitted ordinary BIT saving.0034 and actual atom.004. +The current source BIT interface, its simultaneous stock and effective-saving +gap are retained; no larger BIT exponent is invented. + +All new coefficients are dyadic; coordinate/phase maps introduce no new odd +denominator or field extension. Thus the source fine-prime exclusions, +conditioning, analytic decomposition and exact integer-recovery stack apply +in their same hypothesis class with the new precision/setup thresholds. +No rational1/12 metric or additional denominator3 avoidance is needed by v16c. +The numeric outer checks do not themselves prove that historical analytic/ +physical stack; it remains exactly the selected conditional premise set. + +The aggregate closure must bind this proof, corrected v3 inputs/results, +source controller/normalizers,649-column local acceptance, complete invoice +and numerical funding hashes. It may then state **fresh ordinary/precision/ +stock/source-compiler application under the five retained assumptions**. +It must not mutate earlier scoped receipts, present moment-neutral completion +as a recursive price improvement, or claim unconditional/end-to-end formal +acceptance. Selected-frontier promotion remains a separate maintainer action. + +Retain Dillon's provider campaign; Ali Romman's cached relations and direct +caller; Cao Yifan's native word; Cinna Davis's controller/helpers; zxv's +physical/compiler/semantic precision and higher-moment proofs; Jacob Alan +Sussman's integer flow; general Clifford/BIT/analytic contributors; and the +complete pinned predecessor notices. This new source application is Chris R / +Clear1nsight with substantial OpenAI Codex assistance, Apache-2.0. diff --git a/research/gap-parametric-precision-r15/VERIFY.json b/research/gap-parametric-precision-r15/VERIFY.json new file mode 100644 index 0000000000..66ed5aece6 --- /dev/null +++ b/research/gap-parametric-precision-r15/VERIFY.json @@ -0,0 +1,105 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/coupled-helper-neutral-completion/SOURCE-BINDINGS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/assertion_module.py", + "research/coupled-helper-neutral-completion/capsule/workspace/bootstrap_checks/check_source_loading.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-BACKWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-CALLER-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/caller/NEUTRAL-FORWARD-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CALLER-BINDING-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/CURRENT-HELPER-ALIASES-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/HELPER-ALIAS-RESULT-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/NEUTRAL-LOCAL-RESULT-v16c.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-COMPLETION-THEOREM.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-PLAN-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/WHOLECALLER-RESULT-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_caller_binding_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_helper_aliases_v2.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_literal_local.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_neutral_v16c.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_parametric_v14.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/challenge/check_wholecaller_v1.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-INPUTS-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/NEUTRAL-CLOSURE-v1.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_closure.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/check_neutral_literal.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/exact_moments.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/fund_uniform_endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/FUNDING-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/neutral-v16c-run/INVOICE-NEUTRAL-LITERAL.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_generic120.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/invoice/screen_uniform_global.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-APPLICATION-PROOF-v3.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-CALLER-IMPLEMENTATION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-PRECISION-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/V16-SOURCES-v3.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v14_instruction_envelopes.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/check_v16_precision_v3.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-coupled-caller-sol-high-20261024/agents/precision/v16_layout_inventory.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-PRECOMPILATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-execution-sol-high-20261024/agents/applicability/FINITE-TEMPLATE-CLOSURE.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/INVOICE-v2.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/numeric/exact_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/agents/provenance/custody/extra-canonical/research/final4610-independent-admission/SPECIALIZATION.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/kappa-backward-controller-20261023/CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-next-gain-sol-high-20261024/repository/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/RESULT.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/algebra/phase_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/independent_price_engine.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/ALL-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/README.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5398-CONTROLLER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/REFERENCE-5400-INVOICE.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-PINS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/SOURCES.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/agents/budget/inputs/WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/NORMALIZERS.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/coded-native-caller/clifford_exact.py", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-center-free-code/SOURCE-WORD.json.gz", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROOF.md", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/PROVIDER.json", + "research/coupled-helper-neutral-completion/capsule/workspace/swarm-provider-audit-sol-high-20261024/repository/research/native-rank8-helper-provider/WORD.json.gz", + "research/coupled-helper-neutral-completion/engine_adapter.py", + "research/coupled-helper-neutral-completion/reports/expected/alias-words.json", + "research/coupled-helper-neutral-completion/reports/expected/aliases.json", + "research/coupled-helper-neutral-completion/reports/expected/caller-binding.json", + "research/coupled-helper-neutral-completion/reports/expected/conjunction.json", + "research/coupled-helper-neutral-completion/reports/expected/funding.json", + "research/coupled-helper-neutral-completion/reports/expected/global.json", + "research/coupled-helper-neutral-completion/reports/expected/invoice.json", + "research/coupled-helper-neutral-completion/reports/expected/local.json", + "research/coupled-helper-neutral-completion/reports/expected/precision.json", + "research/coupled-helper-neutral-completion/reports/expected/source-loading.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/gap_endpoint.py" + ], + "timeout_seconds": 300, + "checks": "Numerical only. Authenticate #5413's 63 capsule files against its pinned SOURCE-BINDINGS.json; regenerate its invoice byte-identically; fund (kappa, tested) = (.0030272882489783, .0030272882489784) at the finer unit gap 1/7e16 with independently recomputed least height grid j=72096, H=5046720000000000000000 (all other funding fields read downstream unchanged); generalise #5413's precision checker by replacing its one pinned-gap literal with 'positive unit gap' (conservative: reproduces #5413's expected receipt at the old carrier; at the new carrier the receipt differs only in carrier_H/j/gap, expanded N/M and proof hash); instantiate the written precision proof by a four-literal carrier/endpoint substitution (stored file must equal it); rerun the 25-premise conjunction with only endpoint/carrier literals moved; controls: #5413's pinned-gap checker and unsubstituted conjunction reject the new funding, the generalised checker rejects the old H with the new gap and a non-unit gap, tested .00302728825 and .0030272882489785 fail funded_alpha_reserve, a non-unit gap fails the engine grid; raw-root and reserve brackets; gap sweep 1/(7*10^m), m=12..18; stored RESULT-GAP-PARAMETRIC.json equals the rebuild." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "research/coupled-helper-neutral-completion/verify.py" + ], + "timeout_seconds": 300, + "checks": "Unchanged full #5413 registered replay (local 649 columns, whole caller, binding, invoice, precision, conjunction) on which this package depends; Linux CI." + } + ] +} diff --git a/research/gap-parametric-precision-r15/gap_endpoint.py b/research/gap-parametric-precision-r15/gap_endpoint.py new file mode 100644 index 0000000000..7c04a71788 --- /dev/null +++ b/research/gap-parametric-precision-r15/gap_endpoint.py @@ -0,0 +1,342 @@ +#!/usr/bin/env python3 +"""Gap-parametric precision/height certificate for the complete #5413 caller (numerical compiler headroom only). + +#5413's precision checker and conjunction pin the strict compiler gap to 1/700000000000 and the height carrier to +(j, H) = (55099, 38569300000000000). Its funding engine already derives the least height grid j from ANY unit gap +(least j with (H+1)^1000 < 2^j, H = j*den(gap)), and its written precision proof V16-APPLICATION-PROOF-v3.md is +symbolic in N = 2^H: the carrier appears only as recorded literals (sec. 5 H and gap lines, the sec. 6 NON-claim +"H*gap = j, H*r0 = j/10 < log2 D0", the sec. 8 endpoint pair). This script + 1. authenticates #5413's capsule against its pinned SOURCE-BINDINGS.json and copies it into private scratch; + 2. reruns #5413's invoice/funding engine with only the two endpoint literals substituted, at the finer unit gap + 1/(7*10^16); the invoice is byte-identical, every downstream field except gap/j/H is unchanged, and j/H are + re-derived here independently (least grid, preceding grid fails); + 3. generalises #5413's precision checker by replacing its single pinned-gap literal with "positive unit gap" + (the H = j*den(gap) and (H+1)^1000 < 2^j obligations are unchanged), instantiates the written proof at the new + carrier (the only edits are the four literal sites above, asserted unique), and checks: + - conservativity: the generalised checker on #5413's own manifest reproduces #5413's expected receipt; + - at the new carrier its receipt equals #5413's expected receipt except carrier_{H,j,gap}, expanded.{N,M}, + the proof/manifest/checker hashes and timing; + 4. reruns #5413's 25-premise conjunction with only endpoint/carrier literals moved; + 5. controls: #5413's pinned-gap precision checker and unsubstituted conjunction reject the new funding; the + generalised checker rejects the old H with the new gap and a non-unit gap; tested values at/above the reserve + bracket fail funded_alpha_reserve; a non-unit gap fails the engine's height grid; brackets; a gap sweep showing + every unit gap 1/(7*10^m), m = 12..18, funds with its own least carrier. +Usage: python3 -I -B gap_endpoint.py [--write] +""" +import sys +import argparse, copy, hashlib, json, os, shutil, subprocess, tempfile +from fractions import Fraction as F +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SRC = ROOT / 'research' / 'coupled-helper-neutral-completion' +BINDINGS_SHA256 = 'ea8ea2ff3db043d33ec3f4ea84f9ab760950eea1768f8a5ee9db91d0abb840e3' # pinned in #5413 verify.py +OLD_K, OLD_S = '.003027288235', '.003027288245' +OLD_GAP, OLD_J, OLD_H = F(1, 700000000000), 55099, 38569300000000000 +KAPPA, TESTED = '.0030272882489783', '.0030272882489784' +GAP = (F(TESTED) - F(KAPPA)) / 7 +NEW_J, NEW_H = 72096, 5046720000000000000000 # recomputed below; recorded for review +R14_KAPPA = '.0030272882389' # our #5462, same caller at the pinned gap +AGENTS = 'swarm-coupled-caller-sol-high-20261024/agents/' +INVOICE_DIR = AGENTS + 'invoice/' +PREC_DIR = AGENTS + 'precision/' +PROOF = PREC_DIR + 'V16-APPLICATION-PROOF-v3.md' +PROOF_SHA256_5413 = 'cda8f596f7854f42a228f757d5f8e68f6b2256a19c5ae3771fb40753cedc5b39' +NEW_PROOF = PREC_DIR + 'V16-APPLICATION-PROOF-v3-R15.md' +PINNED_GAP_LINE = "need(gap==(Q(fund['tested'])-Q(fund['kappa']))/7==Q(1,700000000000),'actual strict compiler gap')" +PARAMETRIC_GAP_LINE = ("need(gap==(Q(fund['tested'])-Q(fund['kappa']))/7 and gap>0 and gap.numerator==1," + "'actual strict compiler gap (positive unit gap; gap-parametric)')") +RLIMIT = 'resource.setrlimit(resource.RLIMIT_AS,(256*1024**2,256*1024**2))' + + +def require(ok, message): + if not ok: + raise SystemExit('FAIL: ' + message) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def substitute(text, pairs): + for old, new in pairs: + require(text.count(old) == 1, 'unique substitution site: ' + old) + text = text.replace(old, new) + return text + + +def dec(x): + x = F(x) + for e in range(40): + if (x * 10 ** e).denominator == 1: + return '.' + str(x.numerator * 10 ** e // x.denominator).rjust(e, '0') if e else str(x) + return str(x) + + +def wins(den, j): + return (den * j + 1) ** 1000 < 2 ** j + + +def least_grid(den): + lo, hi = 1, 2 + while not wins(den, hi): + lo, hi = hi, 2 * hi + while hi - lo > 1: + mid = (lo + hi) // 2 + lo, hi = (lo, mid) if wins(den, mid) else (mid, hi) + return hi + + +def proof_substitutions(gap, j, H, k, s): + r0 = f'{j // 10}.{j % 10}' if j % 10 else str(j // 10) # H*r0 = j/10 since r0 = gap/10 + return [('H=38569300000000000, N=2^H,', f'H={H}, N=2^H,'), + ('The fresh strict tested/claim gap is1/700000000000.', + f'The fresh strict tested/claim gap is1/{gap.denominator}.'), + ('log2D0=1048576, while H*gap=55099 and H*r0=5509.9.', f'log2D0=1048576, while H*gap={j} and H*r0={r0}.'), + ('The independent funding file uses K=.003027288235 and tested C=.003027288245,', + f'The independent funding file uses K={k} and tested C={s},')] + + +def run(workspace, engine, argv): + adapter = SRC / 'engine_adapter.py' + env = {k: v for k, v in os.environ.items() if not k.startswith('PYTHON')} + env['PYTHONDONTWRITEBYTECODE'] = '1' + r = subprocess.run([sys.executable, '-I', '-B', str(adapter), str(workspace), engine, *argv], cwd=workspace, + env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=240) + return r.returncode, r.stdout.decode(), r.stderr.decode() + + +def load(path): + return json.loads(Path(path).read_bytes()) + + +def dump(path, obj): + Path(path).write_text(json.dumps(obj, indent=2, sort_keys=True) + '\n') + + +def build(): + require(GAP > 0 and GAP.numerator == 1 and GAP == F(1, 7 * 10 ** 16), 'new unit gap 1/(7*10^16)') + require(sha(SRC / 'SOURCE-BINDINGS.json') == BINDINGS_SHA256, '#5413 SOURCE-BINDINGS.json is the pinned one') + bindings = load(SRC / 'SOURCE-BINDINGS.json')['files'] + scratch = Path(tempfile.mkdtemp(prefix='r15-gap-')).resolve() + try: + shutil.copytree(SRC / 'capsule', scratch, dirs_exist_ok=True) + checked = 0 + for row in bindings: + if row['path'].startswith('capsule/'): + require(sha(scratch / row['path'][8:]) == row['sha256'], 'authenticated capsule byte ' + row['path']) + checked += 1 + if row['path'] == 'engine_adapter.py': + require(sha(SRC / 'engine_adapter.py') == row['sha256'], 'authenticated engine adapter') + ws = scratch / 'workspace' + expected = {name: load(SRC / 'reports' / 'expected' / name) for name in + ('invoice.json', 'funding.json', 'precision.json', 'conjunction.json')} + + # 2. invoice + funding at the new endpoint and finer unit gap + lit = ws / INVOICE_DIR / 'check_neutral_literal.py' + (lit.parent / 'check_neutral_literal_r15.py').write_text(substitute(lit.read_text(), [ + (f"F('{OLD_K}'),F('{OLD_S}')", f"F('{KAPPA}'),F('{TESTED}')")])) + code, out, err = run(ws, INVOICE_DIR + 'check_neutral_literal_r15.py', [ + '--backward', AGENTS + 'caller/NEUTRAL-BACKWARD-v16c.json', '--forward', AGENTS + 'caller/NEUTRAL-FORWARD-v16c.json', + '--output-dir', INVOICE_DIR + 'R15-RUN']) + require(code == 0, 'funding run: ' + err[-800:]) + require(load(ws / INVOICE_DIR / 'R15-RUN/INVOICE-NEUTRAL-LITERAL.json') == expected['invoice.json'], + 'regenerated invoice equals #5413 expected invoice') + rel_fund = INVOICE_DIR + 'R15-RUN/FUNDING-NEUTRAL-LITERAL.json' + fund_path = ws / rel_fund + new, old = load(fund_path), expected['funding.json'] + require(new['status'] == old['status'] == 'PASS_CONDITIONAL_COMPLETE_PROFILE_ENDPOINT_ARITHMETIC_ONLY', 'funding PASS') + require(F(new['kappa']) == F(KAPPA) and F(new['tested']) == F(TESTED), 'new endpoint recorded') + for key in ('paid', 'targets', 'reserve', 'tuple', 'invoice_sha256', 'ordinary_BIT', 'controls', + 'strict_minimum_rounding_reserve', 'predicates', 'source_predicates'): + require(new[key] == old[key], 'funding field unchanged: ' + key) + j = least_grid(GAP.denominator) + H = j * GAP.denominator + require(F(new['gap']) == GAP and new['j'] == j == NEW_J and new['H'] == H == NEW_H, 'recomputed carrier') + require(wins(GAP.denominator, j) and not wins(GAP.denominator, j - 1) and H > 8 * 1024, 'least height grid') + require(j < 1048576, 'sec. 6 non-claim still holds: H*gap = j < log2 D0') + changed = sorted(k for k in set(new) | set(old) if new.get(k) != old.get(k)) + + # 3. gap-parametric precision checker and carrier-instantiated proof + pdir = ws / PREC_DIR + orig_checker = (pdir / 'check_v16_precision_v3.py').read_text() + darwin = sys.platform == 'darwin' # macOS cannot lower RLIMIT_AS; Linux runs the checker text unchanged there + + def shimmed(text): + if not darwin: + return text + return substitute(text, [(RLIMIT, RLIMIT + ' if sys.platform!="darwin" else None')]).replace( + 'import argparse,copy,', 'import sys,argparse,copy,', 1) + parametric = substitute(orig_checker, [(PINNED_GAP_LINE, PARAMETRIC_GAP_LINE)]) + (pdir / 'check_precision_gap_parametric.py').write_text(shimmed(parametric)) + (pdir / 'check_precision_pinned.py').write_text(shimmed(orig_checker)) + stored_proof = (HERE / 'V16-APPLICATION-PROOF-v3-R15.md').read_text() + require(sha(ws / PROOF) == PROOF_SHA256_5413, '#5413 accepted written proof bytes') + proof_text = substitute((ws / PROOF).read_text(), proof_substitutions(GAP, j, H, KAPPA, TESTED)) + require(proof_text == stored_proof, 'stored instantiated proof equals the four-literal substitution of #5413 proof') + for literal in ('38569300000000000', 'is1/700000000000.', '55099', '5509.9', OLD_K, OLD_S): + require(literal not in proof_text, 'no old carrier/endpoint literal left in instantiated proof: ' + literal) + (ws / NEW_PROOF).write_text(proof_text) + pman_path = pdir / 'V16-SOURCES-v3.json' + pman_orig = load(pman_path) + pman_raw = pman_path.read_bytes() + + def precision_manifest(funding_rel, proof_rel, name): + m = copy.deepcopy(pman_orig) + for r in m['rows']: + if r['id'] == 'funding': + r['path'], r['sha256'] = funding_rel, sha(ws / funding_rel) + if r['id'] == 'application_proof': + r['path'], r['sha256'] = proof_rel, sha(ws / proof_rel) + m['by_id']['funding'], m['by_id']['application_proof'] = funding_rel, proof_rel + dump(pdir / name, m) + return pdir / name + + def run_checker(checker, manifest, output): + # the checker reads the fixed name V16-SOURCES-v3.json next to itself + pman_path.write_bytes(Path(manifest).read_bytes()) + try: + return run(ws, PREC_DIR + checker, ['--root', '.', '--output', PREC_DIR + output]) + finally: + pman_path.write_bytes(pman_raw) + volatile = {'seconds', 'checker_sha256', 'input_manifest_sha256'} + # 3a. conservativity: at #5413's own carrier the generalised checker gives #5413's receipt + code, _, err = run_checker('check_precision_gap_parametric.py', pdir / 'V16-SOURCES-v3.json', 'R15-PREC-OLD.json') + require(code == 0, 'generalised checker on #5413 manifest: ' + err[-800:]) + prec_old = load(pdir / 'R15-PREC-OLD.json') + require({k: v for k, v in prec_old.items() if k not in volatile} == + {k: v for k, v in expected['precision.json'].items() if k not in volatile}, + 'generalised checker reproduces #5413 expected precision receipt at the pinned gap') + # 3b. new carrier + new_pman = precision_manifest(rel_fund, NEW_PROOF, 'R15-SOURCES.json') + code, _, err = run_checker('check_precision_gap_parametric.py', new_pman, 'R15-PRECISION.json') + require(code == 0, 'generalised precision run: ' + err[-800:]) + prec = load(pdir / 'R15-PRECISION.json') + require(prec['carrier_H'] == H and prec['carrier_j'] == j and F(prec['carrier_gap']) == GAP, 'precision carrier') + require(prec['expanded']['N'] == f'2^{H}' and prec['expanded']['M'] == f'F16(2^{H})', 'symbolic N, M at new H') + require(prec['mathematical_application']['proof_sha256'] == sha(ws / NEW_PROOF), 'instantiated proof bound') + require(prec['input_manifest_sha256'] == sha(new_pman), 'precision bound to the new manifest') + diff = sorted(k for k in set(prec) | set(expected['precision.json']) + if prec.get(k) != expected['precision.json'].get(k) and k not in volatile) + require(diff == ['carrier_H', 'carrier_gap', 'carrier_j', 'expanded', 'mathematical_application'], 'diff ' + str(diff)) + for key in ('expanded', 'mathematical_application'): + a, b = prec[key], expected['precision.json'][key] + require(sorted(x for x in set(a) | set(b) if a.get(x) != b.get(x)) == + (['M', 'N'] if key == 'expanded' else ['proof_sha256']), 'only carrier/proof fields differ in ' + key) + + # 4. conjunction with endpoint/carrier literals moved + gain = F(KAPPA) - F('.00302728823') + clo = ws / INVOICE_DIR / 'check_neutral_closure.py' + (clo.parent / 'check_neutral_closure_r15.py').write_text(substitute(clo.read_text(), [ + (f"k==Q('{OLD_K}')", f"k==Q('{KAPPA}')"), (f"c==Q('{OLD_S}')", f"c==Q('{TESTED}')"), + ("gap==(c-k)/7==Q(1,700000000000)", f"gap==(c-k)/7==Q(1,{GAP.denominator})"), + ("k-Q('.00302728823')==Q(1,200000000000)", f"k-Q('.00302728823')==Q({gain.numerator},{gain.denominator})"), + ("H==38569300000000000 and j==55099", f"H=={H} and j=={j}"), + # the accepted written proof is bound by hash; its carrier instance is the four-literal substitution above + (f"digest('precision_proof')=='{PROOF_SHA256_5413}'", f"digest('precision_proof')=='{sha(ws / NEW_PROOF)}'")])) + cman = load(ws / INVOICE_DIR / 'NEUTRAL-CLOSURE-INPUTS-v1.json') + for r in cman['rows']: + if r['id'] == 'funding': + r['path'], r['sha256'] = rel_fund, sha(fund_path) + elif r['id'] == 'precision': + r['path'], r['sha256'] = PREC_DIR + 'R15-PRECISION.json', sha(pdir / 'R15-PRECISION.json') + elif r['id'] == 'precision_manifest': + r['path'], r['sha256'] = PREC_DIR + 'R15-SOURCES.json', sha(new_pman) + elif r['id'] == 'precision_proof': + r['path'], r['sha256'] = NEW_PROOF, sha(ws / NEW_PROOF) + dump(ws / INVOICE_DIR / 'R15-CLOSURE-INPUTS.json', cman) + code, out, err = run(ws, INVOICE_DIR + 'check_neutral_closure_r15.py', ['--root', '.', '--manifest', + INVOICE_DIR + 'R15-CLOSURE-INPUTS.json', '--output', INVOICE_DIR + 'R15-CONJUNCTION.json']) + require(code == 0, 'conjunction run: ' + err[-1500:]) + conj = load(ws / INVOICE_DIR / 'R15-CONJUNCTION.json') + require(conj['status'] == 'PASS_CONDITIONAL_MATHEMATICAL_KAPPA_CONJUNCTION' and conj['premise_count'] == 25 + and all(conj['premises'].values()), 'all 25 conjunction premises PASS') + require(set(conj['premises']) == set(expected['conjunction.json']['premises']), 'same 25 premise names as #5413') + + # 5. controls + controls = {} + code, _, err = run_checker('check_precision_pinned.py', new_pman, 'R15-CTL-PINNED.json') + controls['pinned_gap_5413_precision_checker_rejects_new_funding'] = code != 0 and 'actual strict compiler gap' in err + code, _, err = run(ws, INVOICE_DIR + 'check_neutral_closure.py', ['--root', '.', '--manifest', + INVOICE_DIR + 'R15-CLOSURE-INPUTS.json', '--output', INVOICE_DIR + 'R15-CTL-CONJ.json']) + controls['unsubstituted_5413_conjunction_rejects_new_funding'] = code != 0 and 'exact_new_positive_endpoint_gap' in err + + def mutated_funding(name, **fields): + m = dict(new, **fields) + dump(ws / INVOICE_DIR / name, m) + return precision_manifest(INVOICE_DIR + name, NEW_PROOF, 'R15-' + name) + code, _, err = run_checker('check_precision_gap_parametric.py', mutated_funding('MUT-OLD-H.json', H=OLD_H, j=OLD_J), + 'R15-CTL-OLDH.json') + controls['parametric_checker_rejects_old_carrier_with_new_gap'] = code != 0 and 'actual funded carrier rank' in err + code, _, err = run_checker('check_precision_gap_parametric.py', mutated_funding('MUT-NONUNIT.json', + kappa=str(F(TESTED) - 3 * F(1, 10 ** 16)), gap=str(F(3, 7 * 10 ** 16))), 'R15-CTL-NONUNIT.json') + controls['parametric_checker_rejects_non_unit_gap'] = code != 0 and 'actual strict compiler gap' in err + sys.path.insert(0, str(ws / INVOICE_DIR)) + from fund_uniform_endpoint import evaluate_profiles + from exact_moments import moment, minus + P = {int(k): v for k, v in new['paid'].items()}; T = {int(k): v for k, v in new['targets'].items()} + + def funded(k, s): + try: + r = evaluate_profiles(P, T, F(k), F(s), 1000, {}) + except ValueError as e: + return str(e) + return r + e1 = funded('.00302728824', '.00302728825') + e2 = funded('.0030272882489784', '.0030272882489785') + e3 = funded('.0030272882489781', TESTED) + controls['tested_.00302728825_rejected_alpha_reserve'] = isinstance(e1, str) and 'funded_alpha_reserve' in e1 + controls['tested_.0030272882489785_rejected_alpha_reserve'] = isinstance(e2, str) and 'funded_alpha_reserve' in e2 + controls['engine_non_unit_gap_rejected'] = isinstance(e3, str) and 'unit height grid' in e3 + require(all(controls.values()), 'controls: ' + json.dumps(controls)) + + def alpha_ok(s): + return moment(P, 1 - s)[1] / moment(T, 1 - s)[0] < 1 - F(1, 10 ** 12) + require(minus(moment(T, 1 - F('.0030272882499')), moment(P, 1 - F('.0030272882499')))[0] > 0 and + minus(moment(T, 1 - F('.00302728825')), moment(P, 1 - F('.00302728825')))[1] < 0, 'raw root bracket') + require(alpha_ok(F('.003027288248978444')) and not alpha_ok(F('.003027288248978445')), 'reserve-limited tested bracket') + # gap sweep: each finer unit gap 1/(7*10^m) funds with its own least carrier + sweep = [] + s_floor = F('.003027288248978444') # inside the reserve bracket (checked above) + for m in range(12, 19): + s = F(int(s_floor * 10 ** m), 10 ** m) # largest tested value on the 10^-m grid below the bracket + k = s - F(1, 10 ** m) + r = funded(k, s) + require(not isinstance(r, str), f'sweep m={m}: {r}') + g = F(r['gap']); jj = least_grid(g.denominator) + require(g == F(1, 7 * 10 ** m) and r['j'] == jj and r['H'] == jj * g.denominator, f'sweep carrier m={m}') + sweep.append(dict(gap=f'1/{g.denominator}', kappa=dec(k), tested=dec(s), j=jj, H=str(r['H']), + min_strict_outer=str(r['outer']['minimum_strict']))) + return dict( + scope='numerical compiler headroom only: same complete #5413 caller, invoice and profiles; zero economic gain', + previous=dict(pr5413=dict(kappa=OLD_K, tested=OLD_S), pr5462=dict(kappa=R14_KAPPA, tested='.0030272882489')), + kappa=KAPPA, tested=TESTED, gain_over_5413=str(F(KAPPA) - F(OLD_K)), gain_over_5462=str(F(KAPPA) - F(R14_KAPPA)), + carrier=dict(gap=str(GAP), j=j, H=str(H)), old_carrier=dict(gap=str(OLD_GAP), j=OLD_J, H=str(OLD_H)), + authenticated_capsule_files=checked, funding_changed_fields=changed, + precision_checker_change=dict(pinned=PINNED_GAP_LINE, parametric=PARAMETRIC_GAP_LINE), + precision_receipt_differs_only_in=diff, proof_literal_sites=4, + raw_root_bracket=['.0030272882499', '.00302728825'], + reserve_limited_tested_bracket=['.003027288248978444', '.003027288248978445'], + supremum_note='every positive unit gap is admissible; kappa < tested < .003027288248978445 is the only bound', + fixed_profile_ceiling_U='.00302728825 (#5409); kappa stays below it', + conjunction=dict(status=conj['status'], premise_count=conj['premise_count'], + gain_over_prior_comparison=str(conj['gain_over_prior_comparison'])), + gap_sweep=sweep, controls=controls) + finally: + shutil.rmtree(scratch, ignore_errors=True) + + +def main(): + ap = argparse.ArgumentParser(); ap.add_argument('--write', action='store_true'); args = ap.parse_args() + result = build() + path = HERE / 'RESULT-GAP-PARAMETRIC.json' + text = json.dumps(result, indent=1, sort_keys=True) + '\n' + if args.write: + path.write_bytes(text.encode('utf-8')) + require(path.exists() and json.loads(path.read_text(encoding='utf-8')) == json.loads(text), 'stored RESULT equals the rebuild') + print('PASS_5413_CALLER_GAP_PARAMETRIC_PRECISION_AT_KAPPA_0.0030272882489783') + + +if __name__ == '__main__': + main() diff --git a/research/gap-parametric-precision-r15/logs/check_only.txt b/research/gap-parametric-precision-r15/logs/check_only.txt new file mode 100644 index 0000000000..a6c9fb298a --- /dev/null +++ b/research/gap-parametric-precision-r15/logs/check_only.txt @@ -0,0 +1 @@ +PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) diff --git a/research/gap-parametric-precision-r15/logs/gap_endpoint.txt b/research/gap-parametric-precision-r15/logs/gap_endpoint.txt new file mode 100644 index 0000000000..9dfb460f85 --- /dev/null +++ b/research/gap-parametric-precision-r15/logs/gap_endpoint.txt @@ -0,0 +1 @@ +PASS_5413_CALLER_GAP_PARAMETRIC_PRECISION_AT_KAPPA_0.0030272882489783 diff --git a/research/gap-parametric-precision-r15/logs/research_package_replay.txt b/research/gap-parametric-precision-r15/logs/research_package_replay.txt new file mode 100644 index 0000000000..9edb7d9f48 --- /dev/null +++ b/research/gap-parametric-precision-r15/logs/research_package_replay.txt @@ -0,0 +1,15 @@ +CHECK Numerical only. Authenticate #5413's 63 capsule files against its pinned SOURCE-BINDINGS.json; regenerate its invoice byte-identically; fund (kappa, tested) = (.0030272882489783, .0030272882489784) at the finer unit gap 1/7e16 with independently recomputed least height grid j=72096, H=5046720000000000000000 (all other funding fields read downstream unchanged); generalise #5413's precision checker by replacing its one pinned-gap literal with 'positive unit gap' (conservative: reproduces #5413's expected receipt at the old carrier; at the new carrier the receipt differs only in carrier_H/j/gap, expanded N/M and proof hash); instantiate the written precision proof by a four-literal carrier/endpoint substitution (stored file must equal it); rerun the 25-premise conjunction with only endpoint/carrier literals moved; controls: #5413's pinned-gap checker and unsubstituted conjunction reject the new funding, the generalised checker rejects the old H with the new gap and a non-unit gap, tested .00302728825 and .0030272882489785 fail funded_alpha_reserve, a non-unit gap fails the engine grid; raw-root and reserve brackets; gap sweep 1/(7*10^m), m=12..18; stored RESULT-GAP-PARAMETRIC.json equals the rebuild. +PASS_5413_CALLER_GAP_PARAMETRIC_PRECISION_AT_KAPPA_0.0030272882489783 +CHECK Unchanged full #5413 registered replay (local 649 columns, whole caller, binding, invoice, precision, conjunction) on which this package depends; Linux CI. +{"status": "FAIL", "receipt": "$TMPDIR/neutral-completion-replay-ti17hzk4/REPLAY.json", "scratch": "$TMPDIR/neutral-completion-replay-ti17hzk4"} +Traceback (most recent call last): + File "/Users/joelpulikkan/imb-r15/research/coupled-helper-neutral-completion/verify.py", line 69, in + if __name__=='__main__':main() + ^^^^^^ + File "/Users/joelpulikkan/imb-r15/research/coupled-helper-neutral-completion/verify.py", line 56, in main + need(run.returncode==0,'Replay failed '+command['name']+'; '+str(root/f'run-{index}.stderr')) + File "/Users/joelpulikkan/imb-r15/research/coupled-helper-neutral-completion/verify.py", line 15, in need + if not ok:raise ValueError(message) + ^^^^^^^^^^^^^^^^^^^^^^^^^ +ValueError: Replay failed precision; $TMPDIR/neutral-completion-replay-ti17hzk4/run-6.stderr +verification command exited 1