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..3e28e29478 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/README.md @@ -0,0 +1,143 @@ +# 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 **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`) + +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 (not uniquely; see the 194→207 tie) | **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; 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: + +- 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..5d02059ecd --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/RESULT-RELATIONS.json @@ -0,0 +1,72 @@ +{ + "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 (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": { + "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..581177e0d0 --- /dev/null +++ b/research/owned-relation-exact-optimum-r14/relations.py @@ -0,0 +1,283 @@ +#!/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; #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 +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(); 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): + 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 + + 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, score=score) + + +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 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 + 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()