From 8d1a267b708bd30bdd84a3ab47d5a67de7aeb745 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Fri, 23 Oct 2026 05:55:52 -0500 Subject: [PATCH] Reject native repeated-helper chains with exact all-C budget certificates --- .../homogeneous-chain-extraction/PROOF.md | 85 +++++++++++++++++++ .../homogeneous-chain-extraction/README.md | 29 ++++++- .../homogeneous-chain-extraction/RESULT.json | 66 ++++++++++++++ .../homogeneous-chain-extraction/SOURCES.json | 18 ++++ .../homogeneous-chain-extraction/TASK.json | 14 ++- .../homogeneous-chain-extraction/VERIFY.json | 6 +- .../homogeneous-chain-extraction/verify.py | 54 ++++++++++++ 7 files changed, 263 insertions(+), 9 deletions(-) diff --git a/research/homogeneous-chain-extraction/PROOF.md b/research/homogeneous-chain-extraction/PROOF.md index a8cd84a160..8d6eda641a 100644 --- a/research/homogeneous-chain-extraction/PROOF.md +++ b/research/homogeneous-chain-extraction/PROOF.md @@ -205,3 +205,88 @@ At b=0 and t>0 the same expression is exact. Thus direct acquisition of each chain edge loses for every useful saving. Already-paid native observations or a changed joint provider would be needed. Their physical acquisition and restoration costs are **unknown** here. + +## Source-bound gate: repeating the native H9 helper loses even optimistically + +The actual one-port tall offer in Chris R / Clear1nsight's +`research/one-terminal-h3-prefix/homogeneous/REPORT.md` has three original owners +and a dependent copied prefix. Its third owner is the original H9 helper. +Two native calls normally have different original helper owners. Reusing that +owner through both calls changes the productive inventory; two H9 rewards +cannot be retained for one owner. + +We now grant **more than has been constructed**: full112-port prefix capacity, +exact homogeneous charts, free boundaries/precision/cleanup, and no added split +cost. This is a budget relaxation, not a physical capacity or endpoint claim. +Assume both calls retain the source paid profile P and all other original +helper jobs. There are224 main owners and112 reused H9-helper owners in a +17-axis embedding. The bare three-chain consumer supplies224 H17+112 H16. +For a still more favorable test, grant even the third owner a free H17 output, +whether or not the retained dependent observations can construct it. + +The pinned native receipt (source20bb93cd990d2ff683e4d0fc56b87a42cd5d3296, +actual compressed word SHA2567679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05) +reports + + P = {1:2201,2:412,3:510,4:127,5:40,8:8}, + H = {4:28,7:7,8:47,9:326}. + +The receipt is authenticated byte-for-byte as an explicit replay input. This +uses its reported native census; it is **not** a fresh native operator replay. +The two-call paid profile has rank mass10654. Removing the two old H9 copies +per reused owner gives the remaining helper targets2(H-112 H9). Thus + + T_bare = 224 H17 + 112 H16 + 2(H-112 H9), rank mass10526, + T_bonus = 336 H17 + 2(H-112 H9), rank mass10638. + +Every owned prefix remains dependent and receives zero additional reward. +The other original helpers are granted their full unchanged rewards. +The actual positive split cost is also granted zero; adding it can only hurt. + +Here is an exact certificate for all real0= 0, + +and for the bonus case check + + K_(2P)(z)-K_T_bonus(z)-16 min(1,z) >= 0. + +The respective exact residuals at all positive breakpoints are + +| z | Bare residual | Bonus residual | +|---:|---:|---:| +| 1 | 5540 | 5652 | +| 2 | 6806 | 6918 | +| 3 | 7248 | 7360 | +| 4 | 6670 | 6782 | +| 5 | 5894 | 6006 | +| 7 | 4182 | 4294 | +| 8 | 3340 | 3452 | +| 9 | 2576 | 2688 | +| 16 | 224 | 336 | +| 17 | 0 | 0 | + +The bonus case is affine between9 and17, so16 is an optional additional +point rather than a required knot. Both differences vanish at0 and are +constant0 beyond17. Nonnegativity everywhere follows by piecewise affinity. +For any increasing concave phi with phi(0)=0 on[0,17], write phi(x) as a +nonnegative linear combination/integral of x and min(x,z). This follows +from its decreasing nonnegative derivative, or from the corresponding +piecewise-linear approximation. The cut inequalities therefore imply + + sum_r (2P)_r r^t - sum_r (T_bare)_r r^t >= 128, + sum_r (2P)_r r^t - sum_r (T_bonus)_r r^t >= 16, + +using phi(x)=x^t and phi(1)=1. Both inequalities extend to t=0 by the +right-hand limit, since all listed ranks are positive. Thus the entire +saving range0<=C<1 loses even before any completion or outer charges. + +This stops **the stated full-capacity repeated-H9-owner policy**. It does not +exclude a caller retaining both distinct helper jobs, a changed joint provider +or productive census, additional independent owners, a different stage/axis +count, broader physical address routing, or non-Gaussian recursive job types. +It does not assert the hypothetical capacity112 exists. Building that capacity +solely to feed this losing reuse policy is not justified. The actual remaining +construction question is a complete positive distinct-owner or changed-provider +caller, rather than another unpriced expansion of the same helper alias. diff --git a/research/homogeneous-chain-extraction/README.md b/research/homogeneous-chain-extraction/README.md index e4fb8c1fca..857d851baf 100644 --- a/research/homogeneous-chain-extraction/README.md +++ b/research/homogeneous-chain-extraction/README.md @@ -55,9 +55,30 @@ expansion is warranted until a named changed provider has a complete favorable budget. The retained-center source has heterogeneous charts and incoming helper noise, as recorded in [Discussion4840](https://github.com/CrocSwap/integer-mult-bounds/discussions/4840). No native homogeneous offer is obtained from its scalar Jordan chains. +The newer one-port H3 prefix supplies a distinct physical three-chain offer; +its repeated-helper consumer is priced separately below. Acquisition, actual chart maps, dirty restoration and independent helper targets are unknown for the proposed longer chain. Physical movement/precision, -completion, compiler, BIT and outer recovery remain unrun and unpriced. +completion, compiler, BIT and outer recovery remain unrun and unpriced +for a profitable distinct-owner or changed-provider caller. + +## A native repeated-helper policy is already too expensive + +The source-bound physical H3 prefix in Chris R / Clear1nsight's +`one-terminal-h3-prefix` package uses an original H9 helper as the third +chain owner. Repeating that owner across two calls replaces two independent +H9 jobs; it does not retain both rewards. Granting112 prefixes, all chart and +finite costs free, and the exact three-chain output still gives a moment +loss of at least128. Even granting a free H17 third output at every port +instead of H16 leaves a loss of at least16 for every0<=C<1. + +[PROOF.md](PROOF.md) gives the complete source profiles and exact +piecewise-linear concave-moment certificate. The verifier authenticates the +3772-byte native paid/helper receipt and checks both certificates plus three +budget mutations. This is a fresh exact arithmetic gate using a pinned +reported native census, not a fresh native replay or a112-prefix construction. +**Stop this repeated-H9-owner expansion.** Retaining both distinct helper +jobs or changing the provider/census is still a different open contract. ## Reproduce @@ -89,12 +110,14 @@ claim, and explicit expansion gate. Upstream and frozen predecessors are unchang ## Credit and scope -Cinna Davis / 1337isnot1337 supplies PR4694's coupled retained-center extension, +Chris R / Clear1nsight supplies the actual H3-prefix offer and its phase-bound +normalizers. Its frozen native source receipt is reused explicitly for the +new all-C budget gate. Cinna Davis / 1337isnot1337 supplies PR4694's coupled retained-center extension, PR4698's helper normalization and conditional three-chain consumer, and the PR4440/4470 controller lineage. Retain Cao Yifan / intqwq, zxv, Jacob Alan Sussman, Ryanson Jonathan and all cited native/compiler/precision predecessors. Their actual native construction is not replayed or modified here. The new contribution is the all-length proof/circuits, restricted workspace bound, -and explicit acquisition allowance. Prepared for Cinna Davis with substantial +explicit acquisition allowance, and the source-bound repeated-helper budget gate. Prepared for Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0. No independent human or proof-kernel acceptance is claimed. diff --git a/research/homogeneous-chain-extraction/RESULT.json b/research/homogeneous-chain-extraction/RESULT.json index 9a47089ca7..19af95cf74 100644 --- a/research/homogeneous-chain-extraction/RESULT.json +++ b/research/homogeneous-chain-extraction/RESULT.json @@ -310,6 +310,72 @@ 4, 4 ], + "native_reused_helper_budget": { + "source_receipt_sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "two_call_paid": { + "1": 4402, + "2": 824, + "3": 1020, + "4": 254, + "5": 80, + "8": 16 + }, + "reused_H9_owners": 112, + "cases": [ + { + "third_rank": 16, + "paid_minus_target_lower_bound": 128, + "targets": { + "4": 56, + "7": 14, + "8": 94, + "9": 428, + "16": 112, + "17": 224 + }, + "cut_residuals": { + "1": 5540, + "2": 6806, + "3": 7248, + "4": 6670, + "5": 5894, + "7": 4182, + "8": 3340, + "9": 2576, + "16": 224, + "17": 0 + } + }, + { + "third_rank": 17, + "paid_minus_target_lower_bound": 16, + "targets": { + "4": 56, + "7": 14, + "8": 94, + "9": 428, + "17": 336 + }, + "cut_residuals": { + "1": 5652, + "2": 6918, + "3": 7360, + "4": 6782, + "5": 6006, + "7": 4294, + "8": 3452, + "9": 2688, + "17": 0 + } + } + ], + "budget_controls": [ + "excess margin", + "double-counted aliased helper jobs", + "unpaid omitted centers" + ], + "scope": "Both hypothetical full-capacity policies lose for every 0<=C<1; no prefix capacity or native replay claimed" + }, "proof": "PROOF.md", "native_embedding": "unknown", "selected_kappa_changed": false diff --git a/research/homogeneous-chain-extraction/SOURCES.json b/research/homogeneous-chain-extraction/SOURCES.json index 0ede177907..5eb21d763e 100644 --- a/research/homogeneous-chain-extraction/SOURCES.json +++ b/research/homogeneous-chain-extraction/SOURCES.json @@ -25,6 +25,24 @@ "usage": "provenance", "git_blob": "7cf79600e5e46a3714e83fb04a694a1ddede065b", "sha256": "56dc7d458410637dd675e7807ec272f8e55381b4bfa1313ef5bb552e7488adc4" + }, + { + "path": "research/one-terminal-h3-prefix/inputs/research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json", + "usage": "input", + "git_blob": "d8a2e0a915edce68cfe7472b94bb87dfb9dc24c0", + "sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428" + }, + { + "path": "research/one-terminal-h3-prefix/homogeneous/REPORT.md", + "usage": "provenance", + "git_blob": "89bc05d40ce08f664b573996a61cbc0aae273619", + "sha256": "f4d192ae906cf6d70b05ee134e806bfe0502ee4944a00024882bb042ac9fb2d3" + }, + { + "path": "research/one-terminal-h3-prefix/README.md", + "usage": "provenance", + "git_blob": "d7bfa15070573221267e0c10391fc75f7ea1cc6d", + "sha256": "90a9602f073322436b6cf98cbc4a31f4ee6b6b28b4746f6c5e6115afbc217072" } ] } diff --git a/research/homogeneous-chain-extraction/TASK.json b/research/homogeneous-chain-extraction/TASK.json index aab630c889..ae171f62c4 100644 --- a/research/homogeneous-chain-extraction/TASK.json +++ b/research/homogeneous-chain-extraction/TASK.json @@ -70,13 +70,13 @@ ] }, "scope_status": "changed", - "actual_scope": "Exact two-call capacity 2 floor((n-1)/2) of homogeneous query chains, with attaining odd/even circuits, restored-workspace upper bound in the scalar/global-P ring, and a complete conditional acquisition allowance.", - "scope_change_reason": "Replace the installed QQ16 demand with the conditional PR4698 chain interface; extend its proved three-field module before any physical synthesis. Native heterogeneity and helper contamination remain explicit. A bounded four-field middle-boundary test produced a weighted cyclic construction, extended algebraically to all even lengths in the same module; this closes the initially open even attaining case.", + "actual_scope": "Exact two-call capacity 2 floor((n-1)/2) of homogeneous query chains, with attaining odd/even circuits, restored-workspace upper bound in the scalar/global-P ring, and a complete conditional acquisition allowance. Source-bound complete optimistic all-C rejection of the known native repeated-H9-owner policy, even granting a third H17 output.", + "scope_change_reason": "Replace the installed QQ16 demand with the conditional PR4698 chain interface; extend its proved three-field module before any physical synthesis. Native heterogeneity and helper contamination remain explicit. A bounded four-field middle-boundary test produced a weighted cyclic construction, extended algebraically to all even lengths in the same module; this closes the initially open even attaining case. The next physical read/derive gate found the repeated-helper policy loses even at hypothetical full prefix capacity; an exact source-receipt-bound ledger is retained without constructing that capacity.", "bottleneck_link": "A cheap homogeneous offer could turn two paid calls into n-1 main queries, but direct unary acquisition loses. The exact E<(n-1)/2 allowance identifies the missing physical producer.", "budget_minutes": 60, - "stop_rule": "Complete the all-length proof and bounded replay; stop direct unary synthesis. Do not begin native expansion without a named complete positive provider invoice.", + "stop_rule": "Complete the all-length proof and bounded replay; stop direct unary synthesis. Do not begin native expansion without a named complete positive provider invoice. Do not expand repeated-H9-helper prefix capacity: even an extra free H17 third output misses the complete moment by at least16.", "outcome": "partial", - "evidence": "PROOF.md; deterministic RESULT.json with exact all-input lengths 2..32 and both parity circuits; registered verifier; no native provider or new kappa.", + "evidence": "PROOF.md; deterministic RESULT.json with exact all-input lengths 2..32 and both parity circuits; registered verifier; no native provider or new kappa. NATIVE-REUSE section: exact concave cuts prove margins128 and16 for the two hypothetical all112-port reuse policies.", "author": "Cinna Davis with substantial OpenAI Codex assistance", "ai_assistance": "Substantial OpenAI Codex assistance for algebra, implementation, proof review and publication; no delegated agents or independent human review.", "open_questions": [ @@ -119,5 +119,11 @@ "local_notes_complete_at_head": true, "warning": "Title/body/local-note coverage is not exhaustive proof of novelty." } + }, + "followup_checkpoint": { + "canonical_main": "a5df48c55ea806d7952b65acc9c76d878ff09b13", + "selected_kappa": "0.00302015", + "priority_revision": 7, + "reason": "PR5137 all-length operator package archived at f2d83999edccdad625ea686ff3f0d03b7d208965; this follow-up adds only the source-bound native reused-owner budget gates. Canonical onboarding-fixture fixes read before rebasing; original frozen task/source pins preserved." } } diff --git a/research/homogeneous-chain-extraction/VERIFY.json b/research/homogeneous-chain-extraction/VERIFY.json index aabf2cc911..44bc885753 100644 --- a/research/homogeneous-chain-extraction/VERIFY.json +++ b/research/homogeneous-chain-extraction/VERIFY.json @@ -3,7 +3,9 @@ "status": "ready", "python": "3.12", "requirements": [], - "inputs": [], + "inputs": [ + "research/one-terminal-h3-prefix/inputs/research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json" + ], "commands": [ { "argv": [ @@ -12,7 +14,7 @@ "{package}/verify.py" ], "timeout_seconds": 120, - "checks": "Exact cyclic-ring all-input identities for every n=2..32, both parity circuits and full boundary counts, thirteen active mutations, parity guards, 256 dirty-workspace rank fixtures and faithful tensor-width qualification. All-length statements proved in PROOF.md; no physical supplier or higher kappa." + "checks": "Exact cyclic-ring all-input identities for every n=2..32, both parity circuits and full boundary counts, thirteen active mutations, parity guards, 256 dirty-workspace rank fixtures and faithful tensor-width qualification. All-length statements proved in PROOF.md; no physical supplier or higher kappa. Pinned native paid/helper receipt; exact all-C concave-cut certificates for two reused-helper policies and three budget mutations." } ] } diff --git a/research/homogeneous-chain-extraction/verify.py b/research/homogeneous-chain-extraction/verify.py index b0ab88118d..719ec6d3b7 100644 --- a/research/homogeneous-chain-extraction/verify.py +++ b/research/homogeneous-chain-extraction/verify.py @@ -4,6 +4,8 @@ """ import argparse +from collections import Counter +from hashlib import sha256 import json from pathlib import Path @@ -11,6 +13,8 @@ ONE = (1, 0, 0, 0) Q = (0, 1, 0, 0) P = (0, 0, 1, 0) +NATIVE_RECEIPT = 'research/one-terminal-h3-prefix/inputs/research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json' +NATIVE_RECEIPT_SHA256 = 'eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428' def need(condition, message): @@ -230,6 +234,55 @@ def faithful_gaussian_check(): return ranks +def cut_certificate(paid, targets, margin): + knots = sorted(set(paid) | set(targets) | {1}) + cuts = {str(z): sum(n*min(r, z) for r, n in paid.items()) + - sum(n*min(r, z) for r, n in targets.items()) - margin*min(1, z) + for z in knots} + need(all(x >= 0 for x in cuts.values()), 'Nonnegative complete concave-moment cuts') + return cuts + + +def native_reuse_budget(): + """Read a pinned source receipt, not a fresh native operator replay.""" + raw = (Path(__file__).resolve().parents[2] / NATIVE_RECEIPT).read_bytes() + need(sha256(raw).hexdigest() == NATIVE_RECEIPT_SHA256, 'Exact native paid/helper receipt') + source = json.loads(raw) + paid = {int(r): 2*n for r, n in source['paid'].items()} + helpers = {int(r): n for r, n in source['helpers'].items()} + need(helpers[9] >= 112, 'Sufficient H9 slots in the optimistic reused-owner policy') + remaining = {r: 2*(n-(112 if r == 9 else 0)) for r, n in helpers.items()} + cases = [] + for third_rank, margin in ((16, 128), (17, 16)): + targets = Counter(remaining) + targets[17] += 224 + targets[third_rank] += 112 + cuts = cut_certificate(paid, targets, margin) + cases.append({'third_rank': third_rank, 'paid_minus_target_lower_bound': margin, + 'targets': {str(r): n for r, n in sorted(targets.items())}, + 'cut_residuals': cuts}) + optimistic = Counter(remaining) + optimistic[17] += 336 + wrong = [ + (paid, optimistic, 17), # The claimed uniform margin is exactly too large. + (paid, optimistic + Counter({9: 224}), 16), # Alias owners counted twice. + ({r: n for r, n in paid.items() if r != 8}, optimistic, 16), + ] + for bad_paid, bad_target, margin in wrong: + try: + cut_certificate(bad_paid, bad_target, margin) + except ValueError: + pass + else: + raise ValueError('False native reused-owner budget accepted') + return {'source_receipt_sha256': NATIVE_RECEIPT_SHA256, + 'two_call_paid': {str(r): n for r, n in sorted(paid.items())}, + 'reused_H9_owners': 112, 'cases': cases, + 'budget_controls': ['excess margin', 'double-counted aliased helper jobs', + 'unpaid omitted centers'], + 'scope': 'Both hypothetical full-capacity policies lose for every 0<=C<1; no prefix capacity or native replay claimed'} + + def check(): lengths = list(range(2, 33)) rows = [] @@ -280,6 +333,7 @@ def check(): 'rejected_even_controller_mutations': even_mutations, 'dirty_workspace_rank_fixtures': lower_bound_fixtures(), 'tensor_evaluation_ranks_f1_through_f4': faithful_gaussian_check(), + 'native_reused_helper_budget': native_reuse_budget(), 'proof': 'PROOF.md', 'native_embedding': 'unknown', 'selected_kappa_changed': False,