From 0db560ebda32088ff451f8d647c0b3475212b9b3 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 22:08:07 +1100 Subject: [PATCH 1/2] Certify current-provider A2 transfer and unchanged owner-cone allowance Combine the credited PR4019/3998 fixed contractions with exact PR3945 inputs and PR4016 forced-cone accounting. Preserve source attribution and physical/precision limitations; no recursive-moment or kappa gain. --- .../.gitattributes | 2 + .../staged544-a2-cone-composition/.gitignore | 2 + .../staged544-a2-cone-composition/PROOF.md | 139 + .../staged544-a2-cone-composition/README.md | 108 + .../staged544-a2-cone-composition/RESULT.json | 3344 +++++++++++++++++ .../SOURCES.json | 147 + .../staged544-a2-cone-composition/TASK.json | 78 + .../staged544-a2-cone-composition/VERIFY.json | 59 + .../check_composition.py | 84 + .../check_controls.py | 36 + .../frozen/PR3945-NATIVE-LINEAGE-NOTICE | 14 + .../frozen/cone/OWNER-PATTERNS.json | 137 + .../frozen/cone/PROOF.md | 140 + .../frozen/cone/frozen/SOURCE-CREDITS.md | 14 + .../frozen/cone/frozen/audit_core.py | 480 +++ .../frozen/cone/frozen/retiming.py | 269 ++ .../frozen/cone/tariff.py | 71 + .../frozen/cone/verify.py | 128 + .../frozen/sep/PROOF.md | 196 + .../frozen/sep/README.md | 106 + .../frozen/sep/independent.py | 409 ++ .../frozen/sep/verify.py | 308 ++ .../inputs/WORD-base.json.gz | Bin 0 -> 74428 bytes .../inputs/WORD-extra.json.gz | Bin 0 -> 74425 bytes .../staged544-a2-cone-composition/verify.py | 133 + 25 files changed, 6404 insertions(+) create mode 100644 research/staged544-a2-cone-composition/.gitattributes create mode 100644 research/staged544-a2-cone-composition/.gitignore create mode 100644 research/staged544-a2-cone-composition/PROOF.md create mode 100644 research/staged544-a2-cone-composition/README.md create mode 100644 research/staged544-a2-cone-composition/RESULT.json create mode 100644 research/staged544-a2-cone-composition/SOURCES.json create mode 100644 research/staged544-a2-cone-composition/TASK.json create mode 100644 research/staged544-a2-cone-composition/VERIFY.json create mode 100644 research/staged544-a2-cone-composition/check_composition.py create mode 100644 research/staged544-a2-cone-composition/check_controls.py create mode 100644 research/staged544-a2-cone-composition/frozen/PR3945-NATIVE-LINEAGE-NOTICE create mode 100644 research/staged544-a2-cone-composition/frozen/cone/OWNER-PATTERNS.json create mode 100644 research/staged544-a2-cone-composition/frozen/cone/PROOF.md create mode 100644 research/staged544-a2-cone-composition/frozen/cone/frozen/SOURCE-CREDITS.md create mode 100644 research/staged544-a2-cone-composition/frozen/cone/frozen/audit_core.py create mode 100644 research/staged544-a2-cone-composition/frozen/cone/frozen/retiming.py create mode 100644 research/staged544-a2-cone-composition/frozen/cone/tariff.py create mode 100644 research/staged544-a2-cone-composition/frozen/cone/verify.py create mode 100644 research/staged544-a2-cone-composition/frozen/sep/PROOF.md create mode 100644 research/staged544-a2-cone-composition/frozen/sep/README.md create mode 100644 research/staged544-a2-cone-composition/frozen/sep/independent.py create mode 100644 research/staged544-a2-cone-composition/frozen/sep/verify.py create mode 100644 research/staged544-a2-cone-composition/inputs/WORD-base.json.gz create mode 100644 research/staged544-a2-cone-composition/inputs/WORD-extra.json.gz create mode 100644 research/staged544-a2-cone-composition/verify.py diff --git a/research/staged544-a2-cone-composition/.gitattributes b/research/staged544-a2-cone-composition/.gitattributes new file mode 100644 index 0000000000..f2f3bbc695 --- /dev/null +++ b/research/staged544-a2-cone-composition/.gitattributes @@ -0,0 +1,2 @@ +frozen/** -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol +inputs/** -text diff --git a/research/staged544-a2-cone-composition/.gitignore b/research/staged544-a2-cone-composition/.gitignore new file mode 100644 index 0000000000..7a60b85e14 --- /dev/null +++ b/research/staged544-a2-cone-composition/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.pyc diff --git a/research/staged544-a2-cone-composition/PROOF.md b/research/staged544-a2-cone-composition/PROOF.md new file mode 100644 index 0000000000..d8d8bce979 --- /dev/null +++ b/research/staged544-a2-cone-composition/PROOF.md @@ -0,0 +1,139 @@ +# Eight-site A2 transfer and owner-cone composition + +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. + +## Exact statement + +The two current PR3945 words at `91f81d131252db704f945891da1ea54e29d46b8b` +admit all eight fixed contractions in ToikY PR4019 +`f408e09df300b575235f7f77f81948071397e16d`, including the A1858 contraction +credited to PR3998 `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`. +This is a new source-specific applicability certificate; the identities and +selected sites are inherited. Native operators, role identities, cut, entrance +and terminal frames remain fixed. No register or dirty buffer is allocated. + +The complete profile remains `{1:2482,2:712,3:218,4:109,5:20,8:8}`: +3,549 recursive children and rank mass 5,160. The helper inventory remains +`{5:28,6:18,7:53,8:96,9:213}` across 408 roles. Relative to the already credited +PR3998 contraction, the additional saving is seven forward and five projected +inverse-cleanup ADD records. Against the raw current provider, it is eight and +six. These rational scalar counts are not a physical/native or runtime tariff. + +Moreover, each contracted site's two-gate frame itinerary is forced at fixed +neighbor boundaries. Composing all eight changes with the precise PR4016 +`08c8990f7022b94cf63207229465fb8fa0e8fc75` forced-intersection terminal-cone +domain leaves its finite outcome unchanged after remapping B indices. Five +survivors remove H1 locally but require at least H1 more owner idle cost under +the credited packing dual. Therefore the composition has no positive complete +optimistic allowance at the source endpoint. This is not a universal graph, +terminal or scalar-frame obstruction, nor a supplier or kappa admission. + +## Local equality, gathering and cleanup + +The sites are the original zero-based triples A(1858,1859,1860), +B(4,53,54), B(7,49,50), and restore(20,21,36), (22,23,38), +(26,27,51), (30,31,62), (32,33,73). Every gate and replacement is retained in +RESULT.json. The exact PR4019 proof is retained at frozen/sep/PROOF.md. + +For distinct x,y,z, let S(a) act by y+=a*z, T(b) by x+=b*y and U(c) +by x+=c*z. In chronological order, +`[S(a),T(b),U(-ab)]=[T(b),S(a)]` and +`[U(ab),T(b),S(a)]=[S(a),T(b)]` over the rationals. Both identities hold +on arbitrary dirty inputs, with no zero-input assumption. Both the primary +rational matrix check and ToikY's separate coordinate-column implementation +recompute each identity on the new source words. + +All intervening unselected events avoid every register in the selected support, +including reads. They commute with the selected triple. All eight supports are +pairwise disjoint. No prelude, target/centre, section or native event boundary +is crossed. Gather at the first selected position and substitute the two gates; +all other events survive in their original order. B native positions are remapped +to exactly the same surviving event cuts, and all native operator descriptors +and ordered frames stay identical. Every other top-level field compares equal. + +The non-target subsystem is autonomous because the current words satisfy the +inherited target-read hygiene. Full operator equality implies equality of its +non-target block and inverse. Literal cleanup is regenerated from that projection, +with unchanged protected-buffer renaming. Thus the composition preserves every +arbitrary dirty buffer, no buffer-to-live leakage and all endpoints. The five +new restore contractions each save one cleanup ADD; the two B contractions +remove target-writing ADDs and save no cleanup ADD. The credited old A site +saves one further forward and cleanup ADD. + +## Why there is exactly one compatible local frame itinerary + +Fix the frame just before the first selected use and the first unchanged +successor frame for each of the three touched registers. Include every climb +through that successor in the local invoice. Intervening events are disjoint, +so they impose no additional use of those registers. The source's required +checks and native entrance anchors remain fixed; the local relaxation already +includes their successor frames. + +The replacement has two gates whose supports share one register. Write their +common frames as F1 and F2; monotonic containment along the shared register +requires F1 contained in F2. The lower bound for F1 is the span of its two input +frames. Its upper bound is the intersection of **all three** fixed successor +frames: the third successor caps F2 and therefore also F1. This backward cap is +necessary; using only the first gate's two successors would retain dead ends. +On each of the eight sites this lower bound equals that upper bound. Thus F1 +is forced. After that assignment, the second gate's lower bound is the span of +its current input frames; its upper bound is the intersection of its two +successors. Those bounds also coincide. The forced pair is the original common +frame, up to equivalent basis order. Both implementations verify these set +identities and every local charge on both providers. + +Each support is disjoint from every other selected support, so the eight local +problems compose without a shared frame variable or omitted successor charge. +There is one complete flag for the fixed composite graph. Its profile agrees +rank by rank with the source, hence at every exponent, not just numerically at +one endpoint. This does not rule out optional changes outside the local bounds. + +## Changed graph and the owner-aware cone + +The exact forced-cone algorithm and tariff proof are retained from PR4016 in +frozen/cone/verify.py, tariff.py and PROOF.md. Their algorithms are reused, +not advertised as independent implementations. For every protected terminal +hyperplane, shrink its last scalar frame by intersection; propagate necessary +intersections to scalar predecessors. Reaching an incompatible immutable +entrance/native exit or a fixed check rejects. The successful assignment is +the greatest feasible one below the original scalar frames. It does not search +additional optional frame shrinks, arbitrary rotations or coupled terminals. + +Both original and combined current words yield the same 13,285 hyperplanes: +2,688 fail start containment; 10,023 reach an incompatible entrance/native; +552 reach a fixed check; 17 are the separately credited direct-refund class; +five have a changed scalar cone. The five helpers are 282, 293, 298, 309 and 373. +The entire candidate records agree except B event indices are reduced by two, +accounting for the two deleted B records before all five events. Each witness +has exactly one changed SCALE frame and terminal, local delta -H1, and width +5 to 4. All ten literal combined witnesses are reconstructed, invoiced and +checked with arbitrary-dirty forward/dual semantics and cleanup boundaries. + +At the source endpoint k=1730663236534549309146/10^24, write h(r)=r^(1-k). +The PR4016/3988 packing dual has pi4-pi5=h(1)=1. Its feasibility is rechecked +for all 2,551 capacity 8/16/32/48, width 4..9 patterns: 12 exact equalities and +2,539 strict rational interval bounds. The retained incumbent aggregate attains +the dual across 725,760 bins. Hence even fractional repacking after a width 5 to 4 +change increases the owner idle lower bound by H1. It cancels the local saving +exactly. These checks reuse the credited exact tariff engine. Actual physical +owner chronology remains inherited. Other unknown costs are not assigned zero. +The 17 direct refunds are excluded from the changed-cone claim and remain +credited to PR3988; this package does not newly audit their whole lifecycle. + +## Evidence boundaries + +The primary performs all 723-input ordinary, dual, reverse pullback and both +cleanup-boundary checks for original, credited-only and combined words for both +providers, comparing full ordinary and dual operator digests. The separate +checker reuses ToikY's no-primary-import point-set/coordinate engine on the new +inputs, reconstructs the word and cleanup digests, verifies all 149 complete +register-frame boundary states and recomputes the entire profile. A new separate +chronological timeline verifies the backward-cap singleton proof. This is +independence of representation from the primary, not fresh independent authorship +of the retained engines or a second full free-operator replay. + +Physical owner/holding/routing/control/tape costs, changed intermediate growth, +finite precision and signed-floor errors, concrete native phases/lowering, +uniform stock, all-size compilation, outer consumption and analytic/BIT +obligations remain inherited or unproved. No full multiplication theorem, +human/formal-kernel review, merger or selected-frontier change is claimed. diff --git a/research/staged544-a2-cone-composition/README.md b/research/staged544-a2-cone-composition/README.md new file mode 100644 index 0000000000..8d6d112c65 --- /dev/null +++ b/research/staged544-a2-cone-composition/README.md @@ -0,0 +1,108 @@ +# Current-provider A2 transfer with no new owner-cone allowance + +The exact current PR3945 providers admit ToikY PR4019's seven separated A2 +contractions together with the credited PR3998 A1858 contraction. Relative to +that already credited contraction, this removes **seven forward and five inverse +cleanup scalar ADDs**. Both complete paid profiles remain +`{1:2482,2:712,3:218,4:109,5:20,8:8}`: 3,549 children and rank mass 5,160. +There is no recursive-moment, runtime or kappa improvement. + +This answers PR4019's explicit later-word handoff and tests the requested +combination with PR4016's forced scalar cones and owner dual. The eight-site +changed graph has exactly one compatible two-gate frame assignment per site at +fixed neighboring boundaries. Backward cap propagation proves this directly; +first-step flags that cannot reach the second gate are excluded. Its terminal +cone census reproduces PR4016 exactly after B-index remapping: 13,285 hyperplanes, +five changed-cone survivors, each local -H1 canceled by at least +H1 owner idle +cost. The owner bound allows arbitrary fractional repacking. The 17 prior direct +refund cases are retained as a separate credited class, not re-admitted here. + +This is a bounded combination certificate, not a general graph search or proof +that optional interior changes, coupled terminal edits, rotations or changed +native interfaces cannot work. The complete favorable allowance stops further +dependent expansion of this fixed composite. + +## Frozen sources and credit + +- PR3945 `91f81d131252db704f945891da1ea54e29d46b8b`: the two current input words, + native descriptors and lineage notice, by Dugongue with retained predecessors. +- ToikY PR4019 `f408e09df300b575235f7f77f81948071397e16d`: the seven separated + sites, local identity/composition proof and separate point-set checker. +- Chris R/Clear1nsight PR3998 `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`: + A2 graph identity, credited consecutive A1858 contraction and current-source + source exports; dataisfire PR3734 supplies the older literal-word lineage. +- PR4016 `08c8990f7022b94cf63207229465fb8fa0e8fc75`: exact forced-cone and + owner-dual algorithms; PR3988, PR3969 and PR3815/3862/3890 retain tariff, + owner aggregate and packing-dual credit. Jeremy Kothe, zxv, RossRichardson, + ErwanSecousses and hexapode retain related profile/packing credit. +- Sagar Thakrar, roger-sato and Arham Tahir retain auditor/frame/native lineage; + unchanged notices are in `frozen/`. PR1865 by 1337isnot1337 retains the earlier + distinct nonconsecutive commuting-C3 precedent. + +Canonical base is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. Fourteen exact +package-local exports are authenticated with SHA256, length and Git blob before +execution. `SOURCES.json` records original source paths and commits. No pending +source history or network access is needed for execution. Only documented pure +helpers are invoked from retained modules; their older input-specific CLI +entrypoints are not used. In particular the old PR3734 manifest/constants +inside retained PR4019 files are historical context, not current-word pins. +Actual current inputs are independently hard-pinned by the second checker. + +## Proof and evidence + +`PROOF.md` gives exact scope, local gathering, projected inverse cleanup, +unique complete frame flags and owner-aware cone composition. `RESULT.json` +binds every site, reconstructed word/cleanup, full profile, cone candidate and +operator digest. The native descriptor order and frames, all helper entrances +and roles, and all other source fields remain unchanged; B positions account +only for deletion of the two selected B records. + +The primary checker reuses the credited rational dirty-state auditor, PR4019 +local checker and PR4016 cone/tariff engines. It replays source, credited-only and +combined current words on all 723 formal inputs, ordinary and dual operators, +reverse pullback and cleanup boundaries. Ten further combined cone witnesses +receive arbitrary-dirty forward/dual and cleanup-boundary checks. + +The second checker imports only ToikY's separate point-set/coordinate engine, +recomputes all 16 local identities, reconstructs all six words, compares their +cleanup digests and149 full-register frame states, and computes their complete +invoices. Its new chronological timeline separately verifies all 16 unique +complete frame flags. Fourteen inherited semantic controls plus six production +semantic controls and two actual optimized-CLI source/owner-receipt mutations +must reject. This is credited independent representation, not a newly independent +full-word interpreter or human/formal-kernel acceptance. + +Run from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/staged544-a2-cone-composition +``` + +The five registered commands verify base, extra, the 2,551-pattern owner dual, +the separate composition checker and controls. Python 3.12 standard library; +no optional packages. Full generation is explicit `verify.py --record`; normal +verification is read-only. `--quick` omits full dirty semantics and is for bounded +controls only. A passing certificate is not full supplier admission. + +Physical owner/holding/routing/control/tape costs, changed intermediate precision +and signed-floor behavior, concrete native phases/lowering, uniform stock, +all-size compilation, outer consumption and analytic/BIT obligations are inherited +or unproved, never priced as zero. No scalar/native unit-cost equivalence or +measured speedup is asserted. + +## Open next questions + +- Can a genuinely different graph or changed native/check boundary remove a + charged transition? Specify that exact boundary and a positive complete + owner-aware allowance before expanding a search. This eight-site composition + supplies neither; another adjacent census is not justified by these ties. +- Can the current producer adopt the verified scalar saving with its concrete + native/precision/owner implementation? First independently replay the frozen + transfer and audit intermediate growth. This package preserves formal operator + and frame contracts but does not admit those physical obligations. + +New transfer/composition work by Chris R/Clear1nsight with substantial OpenAI +Codex assistance. Apache-2.0. No merge, closure of others' work or selected-frontier +change. Entry overlap covered all 733 open PR bodies at 10:46:04 UTC, bounded live +handoffs and relevant predecessor claims; broader Discussion/code coverage is +partial. `TASK.json` retains the actual narrowed task and stopping decision. diff --git a/research/staged544-a2-cone-composition/RESULT.json b/research/staged544-a2-cone-composition/RESULT.json new file mode 100644 index 0000000000..72308407cd --- /dev/null +++ b/research/staged544-a2-cone-composition/RESULT.json @@ -0,0 +1,3344 @@ +{ + "schema_version": 1, + "tariff": { + "patterns": 2551, + "tight": 12, + "strict": 2539, + "refund_debit": "H1 exactly", + "incumbent_bins": 725760 + }, + "providers": { + "base": { + "provider": "base", + "sites": [ + { + "section": "A", + "indices": [ + 1858, + 1859, + 1860 + ], + "removed_position": 2, + "known": true, + "support": [ + 456, + 457, + 475 + ], + "gates": [ + [ + "add", + 457, + 475, + -1, + 1, + [ + 82, + 42 + ] + ], + [ + "add", + 456, + 457, + 1, + 1, + [ + 82, + 42 + ] + ], + [ + "add", + 456, + 475, + 1, + 1, + [ + 82, + 42 + ] + ] + ], + "replacement": [ + [ + "add", + 456, + 457, + 1, + 1, + [ + 42, + 82 + ] + ], + [ + "add", + 457, + 475, + -1, + 1, + [ + 42, + 82 + ] + ] + ], + "crossed_disjoint_events": 0 + }, + { + "section": "B", + "indices": [ + 4, + 53, + 54 + ], + "removed_position": 0, + "known": false, + "support": [ + 196, + 518, + 588 + ], + "gates": [ + [ + "add", + 196, + 518, + 1, + 1, + [ + 30 + ] + ], + [ + "add", + 196, + 588, + -1, + 1, + [ + 30 + ] + ], + [ + "add", + 588, + 518, + -1, + 1, + [ + 30 + ] + ] + ], + "replacement": [ + [ + "add", + 588, + 518, + -1, + 1, + [ + 30 + ] + ], + [ + "add", + 196, + 588, + -1, + 1, + [ + 30 + ] + ] + ], + "crossed_disjoint_events": 48 + }, + { + "section": "B", + "indices": [ + 7, + 49, + 50 + ], + "removed_position": 0, + "known": false, + "support": [ + 187, + 506, + 586 + ], + "gates": [ + [ + "add", + 187, + 506, + 1, + 1, + [ + 30 + ] + ], + [ + "add", + 187, + 586, + 1, + 2, + [ + 30 + ] + ], + [ + "add", + 586, + 506, + 2, + 1, + [ + 30 + ] + ] + ], + "replacement": [ + [ + "add", + 586, + 506, + 2, + 1, + [ + 30 + ] + ], + [ + "add", + 187, + 586, + 1, + 2, + [ + 30 + ] + ] + ], + "crossed_disjoint_events": 41 + }, + { + "section": "restore", + "indices": [ + 20, + 21, + 36 + ], + "removed_position": 2, + "known": false, + "support": [ + 231, + 448, + 484 + ], + "gates": [ + [ + "add", + 448, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 484, + 448, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 484, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "replacement": [ + [ + "add", + 484, + 448, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 448, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "crossed_disjoint_events": 14 + }, + { + "section": "restore", + "indices": [ + 22, + 23, + 38 + ], + "removed_position": 2, + "known": false, + "support": [ + 226, + 449, + 485 + ], + "gates": [ + [ + "add", + 449, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 485, + 449, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 485, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "replacement": [ + [ + "add", + 485, + 449, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 449, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "crossed_disjoint_events": 14 + }, + { + "section": "restore", + "indices": [ + 26, + 27, + 51 + ], + "removed_position": 2, + "known": false, + "support": [ + 228, + 451, + 509 + ], + "gates": [ + [ + "add", + 451, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 509, + 451, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 509, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ] + ], + "replacement": [ + [ + "add", + 509, + 451, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 451, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ] + ], + "crossed_disjoint_events": 23 + }, + { + "section": "restore", + "indices": [ + 30, + 31, + 62 + ], + "removed_position": 2, + "known": false, + "support": [ + 7, + 453, + 533 + ], + "gates": [ + [ + "add", + 453, + 7, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 533, + 453, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 533, + 7, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ] + ], + "replacement": [ + [ + "add", + 533, + 453, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 453, + 7, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ] + ], + "crossed_disjoint_events": 30 + }, + { + "section": "restore", + "indices": [ + 32, + 33, + 73 + ], + "removed_position": 2, + "known": false, + "support": [ + 236, + 454, + 556 + ], + "gates": [ + [ + "add", + 454, + 236, + -1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 556, + 454, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 556, + 236, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ] + ], + "replacement": [ + [ + "add", + 556, + 454, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 454, + 236, + -1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ] + ], + "crossed_disjoint_events": 39 + } + ], + "words": { + "source": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4079, + "B": 1870, + "restore": 212, + "cleanup": 5225 + }, + "primitive_counts": { + "A": { + "add": 3557, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1796, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 196, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4633, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "cee1ddcbdf3cdcba99146f281cbb452440dd1ed641aa3a47ccc3343680ae7ddc", + "cleanup_sha256": "c3a820f5d4aeb3ae9b3c6deff4dcf377a50299295783217dd86313b3bcb208af", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + }, + "credited_3998": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4078, + "B": 1870, + "restore": 212, + "cleanup": 5224 + }, + "primitive_counts": { + "A": { + "add": 3556, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1796, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 196, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4632, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "72701332e9b0281850e47916d929fd3d9bd9e14f3fafb1ee14d4c3ae3fc6b5d9", + "cleanup_sha256": "1fe863366ac0a277b32795c4d88aa9544313248ff29c5e0dea7c36e3adcfd878", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + }, + "combined": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4078, + "B": 1868, + "restore": 207, + "cleanup": 5219 + }, + "primitive_counts": { + "A": { + "add": 3556, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1794, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 191, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4627, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "20252290a5be71f5e226a37e635d2979d38196e2d843320050b4259a083447fc", + "cleanup_sha256": "f124a485bc57cc2e9426c255e554bffd6a54b6efb0d48cbae2c515c8330f270f", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + } + }, + "fixed_boundary_frames": [ + { + "section": "A", + "indices": [ + 1858, + 1859, + 1860 + ], + "unique_flag": [ + [ + 42, + 82 + ], + [ + 42, + 82 + ] + ], + "intervals": [ + { + "lower": [ + 42, + 82 + ], + "upper": [ + 42, + 82 + ] + }, + { + "lower": [ + 42, + 82 + ], + "upper": [ + 42, + 82 + ] + } + ], + "profile_delta": {} + }, + { + "section": "B", + "indices": [ + 4, + 53, + 54 + ], + "unique_flag": [ + [ + 30 + ], + [ + 30 + ] + ], + "intervals": [ + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + }, + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + } + ], + "profile_delta": {} + }, + { + "section": "B", + "indices": [ + 7, + 49, + 50 + ], + "unique_flag": [ + [ + 30 + ], + [ + 30 + ] + ], + "intervals": [ + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + }, + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 20, + 21, + 36 + ], + "unique_flag": [ + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 22, + 23, + 38 + ], + "unique_flag": [ + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 26, + 27, + 51 + ], + "unique_flag": [ + [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "upper": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "upper": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 30, + 31, + 62 + ], + "unique_flag": [ + [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "upper": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "upper": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 32, + 33, + 73 + ], + "unique_flag": [ + [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "upper": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "upper": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + } + ], + "cone": { + "total_hyperplanes": 13285, + "rejected": { + "credited-direct-refund": 17, + "fixed-check": 552, + "fixed-entrance/native": 10023, + "start-terminal": 2688 + }, + "candidates": [ + { + "register": 282, + "old_terminal": [ + 388, + 67, + 33, + 18, + 8 + ], + "new_terminal": [ + 26, + 41, + 75, + 388 + ], + "edits": [ + { + "section": "B", + "index": 533, + "old": [ + 388, + 67, + 33, + 18, + 8 + ], + "new": [ + 26, + 41, + 75, + 388 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 293, + "old_terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "new_terminal": [ + 51, + 85, + 145, + 273 + ], + "edits": [ + { + "section": "B", + "index": 552, + "old": [ + 273, + 145, + 85, + 51, + 8 + ], + "new": [ + 51, + 85, + 145, + 273 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 298, + "old_terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "new_terminal": [ + 51, + 85, + 145, + 273 + ], + "edits": [ + { + "section": "B", + "index": 557, + "old": [ + 273, + 145, + 85, + 51, + 8 + ], + "new": [ + 51, + 85, + 145, + 273 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 309, + "old_terminal": [ + 385, + 66, + 36, + 22, + 8 + ], + "new_terminal": [ + 30, + 44, + 74, + 385 + ], + "edits": [ + { + "section": "B", + "index": 578, + "old": [ + 385, + 66, + 36, + 22, + 8 + ], + "new": [ + 30, + 44, + 74, + 385 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 373, + "old_terminal": [ + 257, + 137, + 67, + 37, + 22 + ], + "new_terminal": [ + 22, + 37, + 67, + 392 + ], + "edits": [ + { + "section": "B", + "index": 680, + "old": [ + 257, + 137, + 67, + 37, + 22 + ], + "new": [ + 22, + 37, + 67, + 392 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + } + ] + }, + "cone_witnesses": [ + { + "register": 282, + "word_sha256": "d0ffb118893388f92e95246566488777176b0c731939ca2d05ba06fbc8787905", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 293, + "word_sha256": "528e5c22dc7ceb3af76f994f2a6b170b39f0a07b3df60a7d2b91aa24e54a8185", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 298, + "word_sha256": "745ca3bdad2f529a031b3dc87541835f8ddb41ee44429460014ba12ed1210597", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 309, + "word_sha256": "3bd7e39c693da212e462c31eace2a5b06482fc6f455307b6ceb9006b4a1137f8", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 373, + "word_sha256": "e1a9a42c93a8226806e1f9e88f0834a02f13e98c37adbcc829e4ed98ac6a7ab7", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + } + ], + "scalar_saving_vs_3998": { + "forward": 7, + "cleanup": 5 + }, + "new_kappa": false + }, + "extra": { + "provider": "extra", + "sites": [ + { + "section": "A", + "indices": [ + 1858, + 1859, + 1860 + ], + "removed_position": 2, + "known": true, + "support": [ + 456, + 457, + 475 + ], + "gates": [ + [ + "add", + 457, + 475, + -1, + 1, + [ + 82, + 42 + ] + ], + [ + "add", + 456, + 457, + 1, + 1, + [ + 82, + 42 + ] + ], + [ + "add", + 456, + 475, + 1, + 1, + [ + 82, + 42 + ] + ] + ], + "replacement": [ + [ + "add", + 456, + 457, + 1, + 1, + [ + 42, + 82 + ] + ], + [ + "add", + 457, + 475, + -1, + 1, + [ + 42, + 82 + ] + ] + ], + "crossed_disjoint_events": 0 + }, + { + "section": "B", + "indices": [ + 4, + 53, + 54 + ], + "removed_position": 0, + "known": false, + "support": [ + 196, + 518, + 588 + ], + "gates": [ + [ + "add", + 196, + 518, + 1, + 1, + [ + 30 + ] + ], + [ + "add", + 196, + 588, + -1, + 1, + [ + 30 + ] + ], + [ + "add", + 588, + 518, + -1, + 1, + [ + 30 + ] + ] + ], + "replacement": [ + [ + "add", + 588, + 518, + -1, + 1, + [ + 30 + ] + ], + [ + "add", + 196, + 588, + -1, + 1, + [ + 30 + ] + ] + ], + "crossed_disjoint_events": 48 + }, + { + "section": "B", + "indices": [ + 7, + 49, + 50 + ], + "removed_position": 0, + "known": false, + "support": [ + 187, + 506, + 586 + ], + "gates": [ + [ + "add", + 187, + 506, + 1, + 1, + [ + 30 + ] + ], + [ + "add", + 187, + 586, + 1, + 2, + [ + 30 + ] + ], + [ + "add", + 586, + 506, + 2, + 1, + [ + 30 + ] + ] + ], + "replacement": [ + [ + "add", + 586, + 506, + 2, + 1, + [ + 30 + ] + ], + [ + "add", + 187, + 586, + 1, + 2, + [ + 30 + ] + ] + ], + "crossed_disjoint_events": 41 + }, + { + "section": "restore", + "indices": [ + 20, + 21, + 36 + ], + "removed_position": 2, + "known": false, + "support": [ + 231, + 448, + 484 + ], + "gates": [ + [ + "add", + 448, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 484, + 448, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 484, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "replacement": [ + [ + "add", + 484, + 448, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 448, + 231, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "crossed_disjoint_events": 14 + }, + { + "section": "restore", + "indices": [ + 22, + 23, + 38 + ], + "removed_position": 2, + "known": false, + "support": [ + 226, + 449, + 485 + ], + "gates": [ + [ + "add", + 449, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 485, + 449, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 485, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "replacement": [ + [ + "add", + 485, + 449, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ], + [ + "add", + 449, + 226, + -1, + 1, + [ + 256, + 128, + 64, + 34, + 17, + 11, + 4 + ] + ] + ], + "crossed_disjoint_events": 14 + }, + { + "section": "restore", + "indices": [ + 26, + 27, + 51 + ], + "removed_position": 2, + "known": false, + "support": [ + 228, + 451, + 509 + ], + "gates": [ + [ + "add", + 451, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 509, + 451, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 509, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ] + ], + "replacement": [ + [ + "add", + 509, + 451, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ], + [ + "add", + 451, + 228, + -1, + 1, + [ + 256, + 128, + 64, + 38, + 20, + 10, + 1 + ] + ] + ], + "crossed_disjoint_events": 23 + }, + { + "section": "restore", + "indices": [ + 30, + 31, + 62 + ], + "removed_position": 2, + "known": false, + "support": [ + 7, + 453, + 533 + ], + "gates": [ + [ + "add", + 453, + 7, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 533, + 453, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 533, + 7, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ] + ], + "replacement": [ + [ + "add", + 533, + 453, + 2, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ], + [ + "add", + 453, + 7, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 19, + 11, + 6 + ] + ] + ], + "crossed_disjoint_events": 30 + }, + { + "section": "restore", + "indices": [ + 32, + 33, + 73 + ], + "removed_position": 2, + "known": false, + "support": [ + 236, + 454, + 556 + ], + "gates": [ + [ + "add", + 454, + 236, + -1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 556, + 454, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 556, + 236, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ] + ], + "replacement": [ + [ + "add", + 556, + 454, + 2, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ], + [ + "add", + 454, + 236, + -1, + 1, + [ + 256, + 128, + 64, + 37, + 21, + 8, + 3 + ] + ] + ], + "crossed_disjoint_events": 39 + } + ], + "words": { + "source": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4079, + "B": 1870, + "restore": 212, + "cleanup": 5225 + }, + "primitive_counts": { + "A": { + "add": 3557, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1796, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 196, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4633, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "cc1826748ed24cd085a5756b46f0090d5a43ad54820c025366cf2848aca589b2", + "cleanup_sha256": "c3a820f5d4aeb3ae9b3c6deff4dcf377a50299295783217dd86313b3bcb208af", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + }, + "credited_3998": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4078, + "B": 1870, + "restore": 212, + "cleanup": 5224 + }, + "primitive_counts": { + "A": { + "add": 3556, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1796, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 196, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4632, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "9c47d4c86244d533553fd60cdcf587677b3236a8d2b90e8d6b255b0917531f4c", + "cleanup_sha256": "1fe863366ac0a277b32795c4d88aa9544313248ff29c5e0dea7c36e3adcfd878", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + }, + "combined": { + "profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "helper_widths": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + }, + "lengths": { + "A": 4078, + "B": 1868, + "restore": 207, + "cleanup": 5219 + }, + "primitive_counts": { + "A": { + "add": 3556, + "scale": 498, + "warp": 24 + }, + "B": { + "add": 1794, + "scale": 74, + "warp": 0 + }, + "restore": { + "add": 191, + "scale": 16, + "warp": 0 + }, + "cleanup": { + "add": 4627, + "scale": 520, + "warp": 72 + } + }, + "canonical_word_sha256": "b3a3b0573a50c39e05f40e0efb7612940049b6b990db7ac7ed9a8c66aa7dfcb7", + "cleanup_sha256": "f124a485bc57cc2e9426c255e554bffd6a54b6efb0d48cbae2c515c8330f270f", + "native_operations": 72, + "semantics": { + "live_inputs": 632, + "arbitrary_dirty_buffers": 91, + "matrix_dimension": 723, + "ordinary_matrix_sha256": "c8ea87b1598c9bbc2b0be63217772110ff450ad12eff19aaf05a84239eb5d380", + "dual_matrix_sha256": "9bace9fb7525f64d5418ab54af173df7d320c898e980e89be8a90d280adb3744", + "ordinary": true, + "dual": true, + "reverse_equals_ordinary": true, + "cleanup_boundary_both_directions": true, + "buffer_to_live_leaks": 0, + "buffer_self_map": "identity" + } + } + }, + "fixed_boundary_frames": [ + { + "section": "A", + "indices": [ + 1858, + 1859, + 1860 + ], + "unique_flag": [ + [ + 42, + 82 + ], + [ + 42, + 82 + ] + ], + "intervals": [ + { + "lower": [ + 42, + 82 + ], + "upper": [ + 42, + 82 + ] + }, + { + "lower": [ + 42, + 82 + ], + "upper": [ + 42, + 82 + ] + } + ], + "profile_delta": {} + }, + { + "section": "B", + "indices": [ + 4, + 53, + 54 + ], + "unique_flag": [ + [ + 30 + ], + [ + 30 + ] + ], + "intervals": [ + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + }, + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + } + ], + "profile_delta": {} + }, + { + "section": "B", + "indices": [ + 7, + 49, + 50 + ], + "unique_flag": [ + [ + 30 + ], + [ + 30 + ] + ], + "intervals": [ + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + }, + { + "lower": [ + 30 + ], + "upper": [ + 30 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 20, + 21, + 36 + ], + "unique_flag": [ + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 22, + 23, + 38 + ], + "unique_flag": [ + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "upper": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 26, + 27, + 51 + ], + "unique_flag": [ + [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "upper": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "upper": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 30, + 31, + 62 + ], + "unique_flag": [ + [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "upper": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "upper": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + }, + { + "section": "restore", + "indices": [ + 32, + 33, + 73 + ], + "unique_flag": [ + [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + ], + "intervals": [ + { + "lower": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "upper": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + }, + { + "lower": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "upper": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ] + } + ], + "profile_delta": {} + } + ], + "cone": { + "total_hyperplanes": 13285, + "rejected": { + "credited-direct-refund": 17, + "fixed-check": 552, + "fixed-entrance/native": 10023, + "start-terminal": 2688 + }, + "candidates": [ + { + "register": 282, + "old_terminal": [ + 388, + 67, + 33, + 18, + 8 + ], + "new_terminal": [ + 26, + 41, + 75, + 388 + ], + "edits": [ + { + "section": "B", + "index": 533, + "old": [ + 388, + 67, + 33, + 18, + 8 + ], + "new": [ + 26, + 41, + 75, + 388 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 293, + "old_terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "new_terminal": [ + 51, + 85, + 145, + 273 + ], + "edits": [ + { + "section": "B", + "index": 552, + "old": [ + 273, + 145, + 85, + 51, + 8 + ], + "new": [ + 51, + 85, + 145, + 273 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 298, + "old_terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "new_terminal": [ + 51, + 85, + 145, + 273 + ], + "edits": [ + { + "section": "B", + "index": 557, + "old": [ + 273, + 145, + 85, + 51, + 8 + ], + "new": [ + 51, + 85, + 145, + 273 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 309, + "old_terminal": [ + 385, + 66, + 36, + 22, + 8 + ], + "new_terminal": [ + 30, + 44, + 74, + 385 + ], + "edits": [ + { + "section": "B", + "index": 578, + "old": [ + 385, + 66, + 36, + 22, + 8 + ], + "new": [ + 30, + 44, + 74, + 385 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 373, + "old_terminal": [ + 257, + 137, + 67, + 37, + 22 + ], + "new_terminal": [ + 22, + 37, + 67, + 392 + ], + "edits": [ + { + "section": "B", + "index": 680, + "old": [ + 257, + 137, + 67, + 37, + 22 + ], + "new": [ + 22, + 37, + 67, + 392 + ] + } + ], + "width_before": 5, + "width_after": 4, + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + } + ] + }, + "cone_witnesses": [ + { + "register": 282, + "word_sha256": "a65eb7e21c433d54fa428e39fb4e404d76adf824f82987391b57465f8ef902bc", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 293, + "word_sha256": "f6e3cb5a3e44ce8c5cf97c7fffdd42226d2136650c8b6044347766a8f2efa56a", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 298, + "word_sha256": "485ccb290800b2326c6667980facc0d41cc691ef0633fff632f50f710cddddcf", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 309, + "word_sha256": "0d789467dc07d1ac52b734287da410a1e6a0df696620ea66e0fd9125f9e39cf1", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + }, + { + "register": 373, + "word_sha256": "f32e49001079480ab61b6ea732a9f5ff7bd26ed8e8594f5fc710f05606fd5111", + "local_delta": { + "1": -1 + }, + "owner_debit": { + "1": 1 + }, + "optimistic_complete_delta": {} + } + ], + "scalar_saving_vs_3998": { + "forward": 7, + "cleanup": 5 + }, + "new_kappa": false + } + } +} diff --git a/research/staged544-a2-cone-composition/SOURCES.json b/research/staged544-a2-cone-composition/SOURCES.json new file mode 100644 index 0000000000..d2d89bff1a --- /dev/null +++ b/research/staged544-a2-cone-composition/SOURCES.json @@ -0,0 +1,147 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ], + "source_exports": [ + { + "path": "research/staged544-a2-cone-composition/frozen/sep/verify.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "f408e09df300b575235f7f77f81948071397e16d", + "origin_path": "research/staged544-separated-a2/verify.py", + "bytes": 15525, + "sha256": "515039e0fc2eab00802a04327066aa2ba7aff7b59ebe156369b60309635a8d43", + "git_blob": "877e57b88394fad56d8131641ce5bda5f1d1e09d" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/sep/independent.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "f408e09df300b575235f7f77f81948071397e16d", + "origin_path": "research/staged544-separated-a2/independent.py", + "bytes": 17545, + "sha256": "47bc548f28200f86d28f1f5f8eb466e588bdc01e31f70580280ea6ac72f400a6", + "git_blob": "501c54c11c5fea0337ecd51fa8b0491f19cb7581" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/sep/PROOF.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "f408e09df300b575235f7f77f81948071397e16d", + "origin_path": "research/staged544-separated-a2/PROOF.md", + "bytes": 10813, + "sha256": "8da3652a4e30dc79cd41c61b81315f864fe39e748d2420d74300a17d8d5c76ea", + "git_blob": "d39dd7eff0fb2acb99927254fb480f3876655ca4" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/sep/README.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "f408e09df300b575235f7f77f81948071397e16d", + "origin_path": "research/staged544-separated-a2/README.md", + "bytes": 5334, + "sha256": "69b1e9054227f707a63c952f213d7894fda0c77ef47a0c30223ee70a1df4eb23", + "git_blob": "4e2874528367344b877f3563492c8d05adf4ddbf" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/verify.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/verify.py", + "bytes": 7538, + "sha256": "46cacc806fb31c866d6c0865dc309c1fe6b6cd24cd6b43f134c541ff5e56d7d5", + "git_blob": "54402df9f1113f979cc2c5acd13731d761e16be5" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/tariff.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/tariff.py", + "bytes": 3158, + "sha256": "518d4cf986f1cc043959c7dfb4d02620faa5cf23508338f9e5fcde385574ef98", + "git_blob": "06c22dab77193881bc5b8ab9a9f59fc4992e42ca" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/PROOF.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/PROOF.md", + "bytes": 7665, + "sha256": "aa2b7516741cfb4600442a5dbc3c7784e94ebf30db85dc7bfc7810ff9d73e790", + "git_blob": "2a5078d8862cb2c9a65c9dc41cf98c9f48803062" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/OWNER-PATTERNS.json", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/OWNER-PATTERNS.json", + "bytes": 1397, + "sha256": "0ffae1b949bab97e7d5a6313c3936be248d75a43ba06593bc45faca4fb686e99", + "git_blob": "858a0225cae00233f0959675393a94660b41c69a" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/frozen/retiming.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/frozen/retiming.py", + "bytes": 10391, + "sha256": "591d7278541ac4de9e9b6fc1e17aba23b205ac4b6c81824a28fc08294658ef0d", + "git_blob": "c33d7bbcdf2435056b3a56526e8e43f6513e381b" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/frozen/audit_core.py", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/frozen/audit_core.py", + "bytes": 19364, + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/cone/frozen/SOURCE-CREDITS.md", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "08c8990f7022b94cf63207229465fb8fa0e8fc75", + "origin_path": "research/staged544-scalar-interior-refit/frozen/SOURCE-CREDITS.md", + "bytes": 2882, + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2" + }, + { + "path": "research/staged544-a2-cone-composition/inputs/WORD-base.json.gz", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-base.json.gz", + "bytes": 74428, + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8" + }, + { + "path": "research/staged544-a2-cone-composition/inputs/WORD-extra.json.gz", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-extra.json.gz", + "bytes": 74425, + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67" + }, + { + "path": "research/staged544-a2-cone-composition/frozen/PR3945-NATIVE-LINEAGE-NOTICE", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin_path": "research/staged544-terminal-gap-fill/native/NATIVE-LINEAGE-NOTICE", + "bytes": 2456, + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740" + } + ], + "source_export_contract": "Exact package-local exports authenticated before loading source. Only documented pure helpers are invoked from retained sep/cone modules, not their old input-specific CLIs. No foreign pending history dependency. Retained algorithms are credited reuse, not new independent interpreters." +} diff --git a/research/staged544-a2-cone-composition/TASK.json b/research/staged544-a2-cone-composition/TASK.json new file mode 100644 index 0000000000..94e3818146 --- /dev/null +++ b/research/staged544-a2-cone-composition/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "scalar-to-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "scalar-to-moment", + "question": "Can one known scalar simplification be converted into an actual paid-profile improvement?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Derive the changed legal frame itinerary and exact child histogram.", + "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract." + ], + "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Observe that the positive control improves scalar counts while retaining the paid histogram.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one simplification and derive the complete changed frame itinerary, or prove why it cannot change the histogram.", + "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.", + "allowed_variations": [ + "One existing scalar simplification and one proposed frame-path change." + ], + "scope_change_triggers": [ + "Submitting only another scalar count as completion of a paid-profile task." + ], + "overlap_terms": [ + "scalar simplification", + "paid profile", + "R439" + ] + }, + "scope_status": "refined", + "actual_scope": "Transfer the fixed PR4019/3998 eight-site composite to both current PR3945 words; prove the unique compatible local frame flags and test the changed graph against PR4016 forced-cone/owner allowance.", + "scope_change_reason": "Explicit donor combination request and PR4019 later-word handoff. No new sites or larger Gaussian census; current-source transfer plus complete owner-aware composition is the contribution.", + "bottleneck_link": "Scalar graph savings do not automatically change the recursive bill. This combined current-source experiment gives unique local flags and the same zero-net forced-cone allowance.", + "budget_minutes": 60, + "stop_rule": "Science freeze11:31UTC and final handoff by11:46UTC2026-10-19. Stop dependent expansion if the complete favorable profile/cone plus owner allowance is nonpositive.", + "outcome": "partial", + "evidence": "Exact16local identities, six full723ordinary/dual/reverse/cleanup replays,16unique complete frame flags,26570terminal cases,2551packing patterns and10literal cone witnesses; credited separate point-set checker.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance in implementation, proof and checks. Source algorithms credited as reuse; no human/formal review claim.", + "selection": { + "method": "Explicit assigned combination and PR4019 later-word handoff", + "entry_open_pr_bodies": 733, + "entry_checked_at_utc": "2026-10-19T10:46:04Z", + "coverage_limit": "All open PR bodies and bounded live handoff/source discussion. Broader Discussion/code coverage partial.", + "predecessors": [ + 4019, + 3998, + 3945, + 4016 + ] + }, + "open_questions": [ + { + "question": "Can a changed graph/native/check boundary yield positive complete owner-aware allowance?", + "why_it_matters": "Fixed eight-site graph has unique local flags and no new cone allowance.", + "first_step": "Specify one materially changed boundary and full favorable invoice before expanding.", + "blocked_by": "No such positive candidate supplied here." + }, + { + "question": "Can the scalar saving be integrated into the physical current producer?", + "why_it_matters": "Exact formal words do not certify concrete native cost or precision.", + "first_step": "Replay frozen transfer independently and audit changed intermediate growth.", + "blocked_by": "Native phases, owner chronology, precision and uniform outer obligations remain inherited." + } + ] +} diff --git a/research/staged544-a2-cone-composition/VERIFY.json b/research/staged544-a2-cone-composition/VERIFY.json new file mode 100644 index 0000000000..03b28d0f9d --- /dev/null +++ b/research/staged544-a2-cone-composition/VERIFY.json @@ -0,0 +1,59 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--provider", + "base" + ], + "timeout_seconds": 240, + "checks": "Current base source, credited and combined full723operator/cleanup checks and fivecone witnesses." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--provider", + "extra" + ], + "timeout_seconds": 240, + "checks": "Current extra source, credited and combined full723operator/cleanup checks and fivecone witnesses." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--tariff" + ], + "timeout_seconds": 180, + "checks": "Exact2551packingpattern dual and incumbent attainment." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/check_composition.py" + ], + "timeout_seconds": 120, + "checks": "Credited separate pointset representation and new timeline uniquecompleteframe proof;14semantic controls." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/check_controls.py" + ], + "timeout_seconds": 180, + "checks": "Production positives, sixsemantic rejections and twoactualoptimizedCLI source/ownerreceipt rejections." + } + ] +} diff --git a/research/staged544-a2-cone-composition/check_composition.py b/research/staged544-a2-cone-composition/check_composition.py new file mode 100644 index 0000000000..7163d74625 --- /dev/null +++ b/research/staged544-a2-cone-composition/check_composition.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 +"""Second representation for current-word composition and singleton frames. +Uses ToikY PR4019's separately implemented point-set/coordinate checker, +unchanged and credited. No primary verifier, trace or dirty auditor is imported. +Chris R / Clear1nsight, substantial OpenAI Codex assistance; Apache-2.0. +""" +from pathlib import Path +from collections import Counter +import gzip,hashlib,json,types +ROOT=Path(__file__).resolve().parent +PINS={'base':'08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0','extra':'d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299'} +CHECKER_SHA='47bc548f28200f86d28f1f5f8eb466e588bdc01e31f70580280ea6ac72f400a6' +PROFILE={'1':2482,'2':712,'3':218,'4':109,'5':20,'8':8} +WIDTHS={'5':28,'6':18,'7':53,'8':96,'9':213} +def need(ok,msg): + if not ok:raise ValueError(msg) +def load(): + path=ROOT/'frozen/sep/independent.py';raw=path.read_bytes();need(hashlib.sha256(raw).hexdigest()==CHECKER_SHA,'separate checker source') + m=types.ModuleType('credited_point_set_checker');m.__file__=str(path);exec(compile(raw,str(path),'exec'),m.__dict__);return m + +def timelines(w,I): + live=sorted(set(range(704))-set(w['removed']));zero=frozenset((0,));full=frozenset(range(512));current={};finish={};seq={r:[] for r in live} + for r in live: + current[r]=I.span((w['ports'][r],)) if r<112 else zero + finish[r]=frozenset(x for x in range(512) if (x&w['ports'][r-112]).bit_count()%2==0) if 112<=r<224 else full + for r,b in w['start_extra'].items():current[int(r)]=I.span(tuple(b)) + for r,b in w['helper_final'].items():finish[int(r)]=I.span(tuple(b)) + def event(r,address,frame): + seq[r].append((address,current[r],frame));current[r]=frame + def scalar(section,i,g): + for r in I.support(g):event(r,(section,i),I.span(tuple(g[-1]))) + for i,g in enumerate(w['A']): + if g[0]=='warp': + event(g[1],('A-native-in',i),I.span(tuple(g[3])));event(g[1],('A-native-out',i),I.span(tuple(g[4]))) + else:scalar('A',i,g) + levels={112+int(r):I.span(tuple(b)) for r,b in w['target_levels'].items()} + for r in range(112,224):event(r,('target',r),levels.get(r,zero)) + for r,b in zip(w['centers'],w['center_frames']):event(r,('centre',r),I.span(tuple(b))) + warps={} + for j,warp in enumerate(w['warps']):warps.setdefault(warp[0],[]).append((j,warp)) + for i in range(len(w['B'])+1): + for j,g in warps.get(i,[]): + event(g[1],('B-native-in',j),I.span(tuple(g[3])));event(g[1],('B-native-out',j),I.span(tuple(g[4]))) + if i> x & 1] + + +def dim(mask): + size = bin(mask).count('1') + need(size and size & (size - 1) == 0, 'not a subspace point set') + return size.bit_length() - 1 + + +FULL = (1 << 512) - 1 +ZERO = 1 + + +def hyperplane(port): + return sum(1 << x for x in range(512) if bin(x & port).count('1') % 2 == 0) + + +def warp_images(columns): + """Images of all 512 vectors under the F_2-linear map with columns G e_i.""" + need(len(columns) == H and all(type(c) is int and 0 <= c < 512 for c in columns), 'warp columns') + images = [0] * 512 + for x in range(1, 512): + low = x & -x + images[x] = images[x ^ low] ^ columns[low.bit_length() - 1] + need(len(set(images)) == 512, 'singular warp') + return images + + +def image_mask(images, mask): + return sum(1 << images[x] for x in points(mask)) + + +def lagrangian_action_ok(images, U, E): + """K_G(x,z)=(Gx, Gx+G^{-T}(x+z)) is symplectic and maps L_U to L_E, L_0 and L_FULL to themselves. + + L_U={(x,x+p): x in U, p in U^perp}. This is the binary frame action only; it + is not a Clifford phase or Gaussian-product certificate. For invertible G with + G(U)=E it is implied by the frame-map check ( = ), so it is a + consistency check of the implementation, not extra evidence. + """ + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + # G^{-T} z: bit j of the result is . + git = lambda z: sum((bin(inverse[1 << j] & z).count('1') & 1) << j for j in range(H)) + lift = lambda x, z: (images[x], images[x] ^ git(x ^ z)) + pair = lambda a, b: (bin(a[0] & b[1]).count('1') + bin(a[1] & b[0]).count('1')) & 1 + basis = [(1 << i, 0) for i in range(H)] + [(0, 1 << i) for i in range(H)] + lifted = [lift(*b) for b in basis] + if any(pair(lifted[i], lifted[j]) != pair(basis[i], basis[j]) for i in range(18) for j in range(i + 1, 18)): + return False + + def frame(mask): + us = points(mask) + perp = [p for p in range(512) if all(bin(p & u).count('1') % 2 == 0 for u in us)] + return {(u, u ^ p) for u in us for p in perp} + return all({lift(*pt) for pt in frame(a)} == frame(b) for a, b in ((ZERO, ZERO), (FULL, FULL), (U, E))) + + +# ---------------------------------------------------------------------------- +# Chronological binary-frame bill (BORROW-WORD contract) +# ---------------------------------------------------------------------------- +def frame_bill(w, lagrangian=False): + rep = w['report'] + need((rep['v'], 2 * rep['v'] + rep['R'], rep['h']) == (V, N, H), 'word geometry') + removed = set(w['removed']) + need(len(removed) == len(w['removed']) and all(2 * V <= r < N for r in removed), 'removed helpers') + live = [r for r in range(N) if r not in removed] + liveset = set(live) + B, warps = w['B'], w['warps'] + for k, (pos, lender, cols, U, E) in enumerate(warps, 1): + need(0 <= pos <= len(B), 'warp position', k) + need(lender in liveset and not is_target(lender), 'warp lender', k) + images = warp_images(cols) + su, se = span(U), span(E) + need(dim(su) == len(U) == len(E) == dim(se), 'warp frame bases', k) + need(image_mask(images, su) == se, 'warp does not map its frame', k) + if lagrangian: + need(lagrangian_action_ok(images, su, se), 'lifted frame action', k) + for name in ('A', 'B', 'restore'): + for g in w[name]: + if g[0] != 'warp': + need(all(r in liveset for r in touched(g)), 'removed/out-of-range register', name, g) + if g[0] == 'add' and not is_target(g[1]): + need(not is_target(g[2]), 'non-target reads a target', name, g) + need(all(g[-1] is None and is_target(g[1]) and g[0] == 'add' for g in w['cut']), 'cut gates') + need(all(g[-1] == [] and is_target(g[1]) for g in w['precondition'] + w['compensation']), 'zero-frame wrapper writes') + need(all(not is_target(g[1]) for g in w['restore']), 'restore writes a target') + + ports = w['ports'] + start, end = {}, {} + for r in live: + if r < V: + start[r], end[r] = span((ports[r],)), FULL + elif r < 2 * V: + start[r], end[r] = ZERO, hyperplane(ports[r - V]) + else: + start[r], end[r] = ZERO, FULL + for q, U in w['start_extra'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'entrance names a live helper', q) + start[int(q)] = span(U) + for q, U in w['helper_final'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'terminal names a live helper', q) + end[int(q)] = span(U) + + current, bill, chain = dict(start), Counter(), {} + + def climb(r, mask, where): + need(current[r] & ~mask == 0, 'frame containment fails', where, r) + d = dim(mask) - dim(current[r]) + if d: + bill[d] += 1 + chain.setdefault(r, []).append((where, d, mask)) + current[r] = mask + + npre = w['prelude_events'] + for i, g in enumerate(w['A']): + if g[0] == 'warp': + need(i < npre and len(g) == 5, 'warp outside the prelude', i) + _, r, op, fr, to = g + need(op != 0 and abs(op) <= len(warps) and warps[abs(op) - 1][1] == r, 'prelude warp lender', i) + images = warp_images(warps[abs(op) - 1][2]) + if op < 0: + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + images = inverse + need(image_mask(images, span(fr)) == span(to), 'prelude warp frame action', i) + need(current[r] == span(fr), 'prelude warp entry frame', i, r) + current[r] = span(to) + chain.setdefault(r, []).append((('A', i), 'warp', span(to))) + else: + if i < npre: + need(is_target(g[1]), 'prelude scalar writes a non-target', i) + for r in touched(g): + climb(r, span(g[-1]), ('A', i)) + levels = {V + int(t): span(U) for t, U in w['target_levels'].items()} + need(all(current[t] == levels.get(t, ZERO) for t in range(V, 2 * V)), 'target cut levels') + for q, U in zip(w['centers'], w['center_frames']): + U = span(U) + need(current[q] == U, 'centre entry frame', q) + served = {levels.get(g[1], ZERO) for g in w['cut'] if g[2] == q} + for T in sorted(served, key=lambda m: -dim(m)): + need(T & ~U == 0, 'centre descent not nested', q) + d = dim(U) - dim(T) + if d: + bill[d] += 1 + chain.setdefault(q, []).append((('centre',), d, T)) + U = T + at = {} + for k, rec in enumerate(warps, 1): + at.setdefault(rec[0], []).append(k) + for p in range(len(B) + 1): + for k in at.get(p, ()): + _, lender, _, U, E = warps[k - 1] + need(current[lender] == span(U), 'native warp entry frame', k, lender) + current[lender] = span(E) + chain.setdefault(lender, []).append((('warp', k), 'warp', span(E))) + if p < len(B): + for r in touched(B[p]): + climb(r, span(B[p][-1]), ('B', p)) + for i, g in enumerate(w['restore']): + for r in touched(g): + climb(r, span(g[-1]), ('restore', i)) + for r in live: + climb(r, end[r], ('end',)) + restored = set(map(int, w['helper_final'])) + need(all(end[r] == FULL for r in live if r not in restored and not is_target(r)), 'a FULL-cleanup register ends low') + widths = Counter(dim(end[r]) - dim(start[r]) for r in live if r >= 2 * V) + return dict(sorted(bill.items())), dict(sorted(widths.items())), chain, start, end + + +def hygiene(w): + """Inherited structural contract: dyadic scalars, power-of-two scales, wrapper and correction access.""" + entering = set(map(int, w['start_extra'])) + restored = set(map(int, w['helper_final'])) + live = set(range(N)) - set(w['removed']) + for name in ('precondition', 'compensation', 'A', 'cut', 'B', 'restore', 'cleanup'): + for g in w[name]: + if g[0] == 'warp': + continue + q = Q(g[3], g[4]) if g[0] == 'add' else Q(g[2], g[3]) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'non-dyadic scalar', name, g) + if g[0] == 'scale': + need(abs(q.numerator) & (abs(q.numerator) - 1) == 0, 'non power-of-two scale', name, g) + for g in w['precondition'] + w['compensation']: + need(not any(r in entering | restored for r in touched(g)), 'wrapper touches an entering or restored helper', g) + for c in w['initial_corrections']: + word = c['operator_word'] + need(is_target(c['target']) and c['source'] in live and c['source'] >= 2 * V + and c['source'] not in entering, 'correction access', c) + need(word and all(w['warps'][abs(o) - 1][1] == c['source'] for o in word), 'correction operator lender', c) + q = Q(c['coefficient']) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'correction coefficient', c) + return True + + +# ---------------------------------------------------------------------------- +# Literal inverse cleanup, derived from the contract +# ---------------------------------------------------------------------------- +def ordinary_forward(w): + """Chronological non-wrapper actions whose inverse forms cleanup.""" + out = [g for g in w['A'][w['prelude_events']:]] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + out += at.get(p, []) + if p < len(w['B']): + out.append(w['B'][p]) + return out + list(w['restore']) + + +def derive_cleanup(w): + restored = set(map(int, w['helper_final'])) + buf = lambda r: r + N if r in restored else r + full = [256, 128, 64, 32, 16, 8, 4, 2, 1] + out = [] + for g in reversed(ordinary_forward(w)): + if g[0] == 'warp': + out.append(['warp', buf(g[1]), -g[2], full]) + elif is_target(g[1]): + continue + elif g[0] == 'add': + out.append(['add', buf(g[1]), buf(g[2]), -g[3], g[4], full]) + else: + need(g[0] == 'scale', 'unknown primitive', g) + out.append(['scale', buf(g[1]), g[3], g[2], full]) + return out + + +def same_cleanup(a, b): + norm = lambda c: [(g[:-1], span(g[-1])) for g in c] + return len(a) == len(b) and norm(a) == norm(b) + + +# ---------------------------------------------------------------------------- +# Exact free-operator semantics. A value is a dict {(input, word): Fraction}; +# word is a reduced tuple of signed operator ids (leftmost = applied last). +# ---------------------------------------------------------------------------- +def program(w, cleanup=None): + """Literal executed sequence: corrections, wrapper, A, cut, B+warps, restore | cleanup.""" + items = [('corr', c['target'], c['source'], tuple(c['operator_word']), Q(c['coefficient'])) + for c in w['initial_corrections']] + items += w['precondition'] + w['compensation'] + w['A'] + w['cut'] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + items += at.get(p, []) + if p < len(w['B']): + items.append(w['B'][p]) + items += w['restore'] + return items, list(w['cleanup'] if cleanup is None else cleanup) + + +def dual_op(op): + return (1 if op > 0 else -1) * (abs(op) + DUAL) + + +def _left(op, word): + return word[1:] if word and word[0] == -op else (op,) + word + + +def _right(word, op): + return word[:-1] if word and word[-1] == -op else word + (op,) + + +def _axpy(dst, src, q): + for key, x in src.items(): + y = dst.get(key, 0) + q * x + if y: + dst[key] = y + else: + dst.pop(key, None) + + +def forward_rows(w, cleanup=None, dual=False, symbolic_buffers=True, snapshot=None): + """Schrodinger pass: every register's value as a combination of initial inputs. + + Live inputs are independent symbols. Private buffers are independent symbols + when symbolic_buffers is set (dirty), otherwise zero. The optional snapshot + callback sees the rows at the cleanup boundary. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + rows = {r: {(r, ()): Q(1)} for r in live} + for c in restored: + rows[c + N] = {(c + N, ()): Q(1)} if symbolic_buffers else {} + prefix, tail = program(w, cleanup) + + def apply(g): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + if dual: + t, s, q = s, t, -q + _axpy(rows[t], rows[s], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + if dual: + q = 1 / q + rows[g[1]] = {k: q * x for k, x in rows[g[1]].items()} + elif kind == 'warp': + op = dual_op(g[2]) if dual else g[2] + rows[g[1]] = {(var, _left(op, word)): x for (var, word), x in rows[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + if dual: + src, ops, dst, c = rows[t], [-dual_op(o) for o in word], s, -c + else: + src, ops, dst = rows[s], list(reversed(word)), t + moved = {} + for (var, wd), x in src.items(): + for o in ops: + wd = _left(o, wd) + moved[var, wd] = x + _axpy(rows[dst], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + + for g in prefix: + apply(g) + if snapshot is not None: + snapshot(rows) + for g in tail: + apply(g) + return rows + + +def reverse_columns(w, cleanup=None, upto_cleanup=False): + """Heisenberg pull-back: process the forward program backwards. + + cols[s] = {(output, word): coefficient}: the final output register 'output' + contains coefficient*word*x_s. Words grow on the right. Every live input and + every private buffer is an independent symbol. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + regs = live + [c + N for c in restored] + cols = {r: {(r, ()): Q(1)} for r in regs} + prefix, tail = program(w, cleanup) + seq = prefix if upto_cleanup else prefix + tail + for g in reversed(seq): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + _axpy(cols[s], cols[t], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + cols[g[1]] = {k: q * x for k, x in cols[g[1]].items()} + elif kind == 'warp': + op = g[2] + cols[g[1]] = {(out, _right(word, op)): x for (out, word), x in cols[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + moved = {} + for (out, wd), x in cols[t].items(): + for o in word: + wd = _right(wd, o) + moved[out, wd] = x + _axpy(cols[s], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + return cols + + +def transpose(cols): + rows = {} + for s, col in cols.items(): + for (r, word), x in col.items(): + rows.setdefault(r, {})[s, word] = x + return rows + + +def endpoint_defects(w, rows, dual=False): + """Compare final rows with the contract on the zero-buffer (live-input) domain. + + Returns (bad live registers, dirty buffers, buffer->live leaks, buffer self-map identity). + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + bad = [] + for r in live: + expect = {(r, ()): Q(1)} + if dual and r < V: + expect[r + V, ()] = Q(-1) + if not dual and is_target(r): + expect[r - V, ()] = Q(1) + got = {k: x for k, x in rows.get(r, {}).items() if k[0] < N} + if got != expect: + bad.append(r) + dirty = [c for c in restored if any(k[0] < N for k in rows.get(c + N, {}))] + leaks = sorted({r for r in live for k in rows.get(r, {}) if k[0] >= N}) + buffer_identity = all({k: x for k, x in rows.get(c + N, {}).items() if k[0] >= N} == {(c + N, ()): Q(1)} + for c in restored) + return bad, dirty, leaks, buffer_identity + + +def boundary_defects(w, rows): + """Contract at the cleanup boundary (forward): targets sheared, restored helpers clean and isolated.""" + restored = set(map(int, w['helper_final'])) + out = [] + for t in range(V, 2 * V): + if {k: x for k, x in rows[t].items() if k[0] < N} != {(t, ()): Q(1), (t - V, ()): Q(1)}: + out.append(('target', t)) + for c in restored: + if rows[c] != {(c, ()): Q(1)}: + out.append(('restored', c)) + for r, row in rows.items(): + if r < N and r not in restored and any(k[0] in restored for k in row): + out.append(('restored input read', r)) + return out diff --git a/research/staged544-a2-cone-composition/frozen/cone/frozen/retiming.py b/research/staged544-a2-cone-composition/frozen/cone/frozen/retiming.py new file mode 100644 index 0000000000..c33d7bbcdf --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/cone/frozen/retiming.py @@ -0,0 +1,269 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact, fixed-neighbour single-ADD retiming relaxation. + +Chris R / Clear1nsight, with substantial OpenAI assistance. The BORROW-WORD +frame contract and scalar-retiming mechanism are credited in README.md. +This module does not import the retained auditor or a numerical optimiser. +""" +from bisect import bisect_left +from collections import Counter +from copy import deepcopy +from fractions import Fraction +from functools import lru_cache + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +@lru_cache(maxsize=None) +def span(vectors): + points = {0} + for v in vectors: + need(type(v) is int and 0 <= v < 512, 'invalid frame vector') + points |= {x ^ v for x in tuple(points)} + return sum(1 << x for x in points) + + +@lru_cache(maxsize=None) +def basis(mask): + answer = [] + have = 1 + for v in range(1, 512): + if (mask >> v) & 1 and not (have >> v) & 1: + answer.append(v) + have = span(tuple(answer)) + need(have == mask, 'not a binary subspace') + return tuple(answer) + + +@lru_cache(maxsize=None) +def join(a, b): + return span(basis(a) + basis(b)) + + +@lru_cache(maxsize=None) +def rank(mask): + n = mask.bit_count() + need(n > 0 and n & (n - 1) == 0, 'invalid subspace cardinality') + return n.bit_length() - 1 + + +def contained(a, b): + return not a & ~b + + +def touched(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def tracing(word): + """Own chronological trace; centre descent is NOT persistent state. + + A check node is a fixed boundary, not a charged instruction. The census + relaxes it to a virtual climb. Every legal witness has zero such charge. + """ + full = (1 << 512) - 1 + live = set(range(704)) - set(word['removed']) + start, end = {}, {} + for r in live: + if r < 112: + start[r], end[r] = span((word['ports'][r],)), full + elif r < 224: + p = word['ports'][r - 112] + start[r] = 1 + end[r] = sum(1 << x for x in range(512) if (x & p).bit_count() % 2 == 0) + else: + start[r], end[r] = 1, full + for r, fr in word['start_extra'].items(): + start[int(r)] = span(tuple(fr)) + for r, fr in word['helper_final'].items(): + end[int(r)] = span(tuple(fr)) + current = dict(start) + nodes = {r: [] for r in live} + where = {} + bill = Counter() + + def event(r, frame, address, kind='climb'): + before = current[r] + if kind != 'map': + need(contained(before, frame), 'source frame containment') + d = rank(frame) - rank(before) + if kind == 'check': + need(d == 0, 'source fixed boundary') + elif d: + bill[d] += 1 + if kind == 'climb': + where[(address, r)] = len(nodes[r]) + nodes[r].append((address, kind, before, frame)) + current[r] = frame + + for i, gate in enumerate(word['A']): + if gate[0] == 'warp': + event(gate[1], span(tuple(gate[3])), ('check-A', i), 'check') + event(gate[1], span(tuple(gate[4])), ('map-A', i), 'map') + else: + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('A', i)) + levels = {112 + int(r): span(tuple(fr)) for r, fr in word['target_levels'].items()} + for r in range(112, 224): + event(r, levels.get(r, 1), ('target-cut', r), 'check') + for r, fr in zip(word['centers'], word['center_frames']): + u = span(tuple(fr)) + event(r, u, ('centre-cut', r), 'check') + served = {levels.get(g[1], 1) for g in word['cut'] if g[2] == r} + for v in sorted(served, key=lambda x: -rank(x)): + need(contained(v, u), 'centre nesting') + if rank(u) > rank(v): + bill[rank(u) - rank(v)] += 1 + u = v + # The main forward register remains at its declared centre entry. + warps = {} + for j, rec in enumerate(word['warps']): + warps.setdefault(rec[0], []).append((j, rec)) + for i in range(len(word['B']) + 1): + for j, rec in warps.get(i, []): + event(rec[1], span(tuple(rec[3])), ('check-B', j), 'check') + event(rec[1], span(tuple(rec[4])), ('map-B', j), 'map') + if i < len(word['B']): + gate = word['B'][i] + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('B', i)) + for i, gate in enumerate(word['restore']): + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('restore', i)) + for r in live: + event(r, end[r], ('end',)) + return nodes, where, dict(sorted(bill.items())) + + +def crosses(g, h): + """Sufficient exact scalar normal form, not all algebraic commutations.""" + if h[0] == 'add': + return g[1] != h[2] and h[1] != g[2] + return h[0] == 'scale' and h[2] != 0 + + +def segments(word, section): + if section == 'A': + cuts = [word['prelude_events'], len(word['A'])] + elif section == 'B': + cuts = sorted({0, len(word['B'])} | {rec[0] for rec in word['warps']}) + else: + cuts = [0, len(word[section])] + return list(zip(cuts, cuts[1:])) + + +def caps(delta): + return [sum(n * min(r, k) for r, n in enumerate(delta)) for k in range(1, 10)] + + +def all_power_nonnegative(delta): + """Sufficient exact certificate using decreasing positive curvatures.""" + values = caps(delta) + prefix = 0 + for value in values[:-1]: + prefix += value + if prefix < 0: + return False + return values[-1] == 0 + + +def census(word): + nodes, where, bill = tracing(word) + deltas = Counter() + counts = {} + for section in ('A', 'B', 'restore'): + gates = word[section] + count = 0 + for lo, hi in segments(word, section): + occurrences = {} + for i in range(lo, hi): + need(gates[i][0] in ('add', 'scale'), 'unexpected scalar segment') + for r in touched(gates[i]): + occurrences.setdefault(r, []).append(i) + for i in range(lo, hi): + g = gates[i] + if g[0] != 'add': + continue + lower = i + while lower > lo and crosses(g, gates[lower - 1]): + lower -= 1 + upper = i + 1 + while upper < hi and crosses(g, gates[upper]): + upper += 1 + removal = [0] * 10 + reduced, entries, exits = {}, {}, {} + for r in touched(g): + seq = nodes[r] + pos = where[((section, i), r)] + _, _, p, u = seq[pos] + need(pos + 1 < len(seq) and seq[pos + 1][1] != 'map', 'missing successor') + q = seq[pos + 1][3] + removal[rank(u) - rank(p)] -= 1 + removal[rank(q) - rank(u)] -= 1 + removal[rank(q) - rank(p)] += 1 + indices = occurrences[r] + reduced[r] = [x for x in indices if x != i] + entries[r] = seq[where[((section, indices[0]), r)]][2] + last = where[((section, indices[-1]), r)] + need(seq[last + 1][1] != 'map', 'missing exit check') + exits[r] = seq[last + 1][3] + for cut in range(lower, upper + 1): + if cut == i + 1: # Same placement as cut i, counted once. + continue + boundaries = [] + for r in touched(g): + indices = reduced[r] + j = bisect_left(indices, cut) + p = span(tuple(gates[indices[j - 1]][-1])) if j else entries[r] + q = span(tuple(gates[indices[j]][-1])) if j < len(indices) else exits[r] + boundaries.append((p, q)) + lower_frame = join(boundaries[0][0], boundaries[1][0]) + upper_frame = boundaries[0][1] & boundaries[1][1] + if not contained(lower_frame, upper_frame): + continue + dims = [(rank(p), rank(q)) for p, q in boundaries] + for d in range(rank(lower_frame), rank(upper_frame) + 1): + delta = removal.copy() + for p, q in dims: + delta[q - p] -= 1 + delta[d - p] += 1 + delta[q - d] += 1 + delta[0] = 0 + need(sum(r * n for r, n in enumerate(delta)) == 0, 'rank mass drift') + deltas[tuple(delta)] += 1 + count += 1 + counts[section] = count + return {'per_section': counts, 'candidates': sum(counts.values()), + 'source_profile': bill, + 'deltas': [{'delta': {r: n for r, n in enumerate(d) if n}, 'count': n, + 'caps': caps(d), 'certificate': all_power_nonnegative(d)} + for d, n in sorted(deltas.items())]} + + +def apply_move(word, section, index, cut, frame): + """Apply one exact scalar retiming. Caller must rederive cleanup and audit.""" + need(section in ('A', 'B', 'restore'), 'unknown section') + gates = word[section] + need(type(index) is int and 0 <= index < len(gates), 'bad source index') + need(type(cut) is int and 0 <= cut <= len(gates), 'bad insertion cut') + need(any(lo <= index < hi and lo <= cut <= hi for lo, hi in segments(word, section)), + 'crosses prelude or native warp boundary') + g = deepcopy(gates[index]) + need(g[0] == 'add', 'only ADD moves are covered') + crossed = gates[index + 1:cut] if cut > index else gates[cut:index] + need(all(crosses(g, h) for h in crossed), 'noncommuting scalar barrier') + coefficient = Fraction(g[3], g[4]) + for h in crossed: + if h[0] == 'scale' and h[1] in touched(g): + power = (1 if h[1] == g[1] else -1) * (1 if cut > index else -1) + coefficient *= Fraction(h[2], h[3]) ** power + g[3:5] = [coefficient.numerator, coefficient.denominator] + g[-1] = list(basis(span(tuple(frame)))) + result = deepcopy(word) + result[section].pop(index) + result[section].insert(cut - (cut > index), g) + # Segment length and all warp cuts are unchanged. No warp is crossed. + return result diff --git a/research/staged544-a2-cone-composition/frozen/cone/tariff.py b/research/staged544-a2-cone-composition/frozen/cone/tariff.py new file mode 100644 index 0000000000..06c22dab77 --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/cone/tariff.py @@ -0,0 +1,71 @@ +"""Exact tariff arithmetic adapted from PR3988, Chris R with OpenAI Codex. +Dual credited to PR3815/3862/3890. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path +import argparse, gzip, hashlib, importlib.util, json, math +ROOT=Path(__file__).resolve().parent +K=Q(1730663236534549309146,10**24) + +def need(ok,why): + if not ok: raise ValueError(why) +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def add(*terms): + out=Counter() + for factor,v in terms: + for r,c in v.items():out[r]+=factor*c + return {r:c for r,c in out.items() if c and r} +def h(r):return {r:Q(1)} if r else {} +def log_ratio(x): + z=(x-1)/(x+1);n=50 + value=2*sum((z**(2*j+1)/Q(2*j+1) for j in range(n)),Q(0)) + tail=2*z**(2*n+1)/(Q(2*n+1)*(1-z*z)) + return value,value+tail +@lru_cache(None) +def power(r): + if r==0:return Q(0),Q(0) + j=r.bit_length()-1;l2,u2=log_ratio(Q(2));lr,ur=log_ratio(Q(r,2**j)) + a,b=K*(j*l2+lr),K*(j*u2+ur) + need(0<=a<=b<1,'exponential range') + def exp_minus(x,n):return sum(((-x)**i/Q(math.factorial(i)) for i in range(n+1)),Q(0)) + return r*exp_minus(b,19),r*exp_minus(a,20) +def interval(v): + lo=hi=Q(0) + for r,c in v.items(): + a,b=power(r);lo+=c*(a if c>=0 else b);hi+=c*(b if c>=0 else a) + return lo,hi +def brief(ab): + scale=10**24;lo,hi=ab + return {'lower_numerator':lo.numerator*scale//lo.denominator,'upper_numerator':-((-hi.numerator*scale)//hi.denominator),'denominator':scale} +def patterns(): + for cap in (8,16,32,48): + def rec(i,ns,left): + if i==5: + yield cap,tuple(ns),left;return + for n in range(left//(i+5)+1):yield from rec(i+1,ns+[n],left-n*(i+5)) + yield from rec(0,[],cap) +def dual(): + q={48:Q(1,20),3:Q(-1,20),5:Q(-1,4)} + pi={w:add((-1,h(5)),(-(w-5),q)) for w in range(5,10)} + mu={8:add((-1,pi[8])),16:add((-2,pi[8])),32:add((-4,pi[8])),48:h(48)} + return q,pi,mu +def reduced(cap,ns,left,pi,mu):return add((1,h(left)),(-1,mu[cap]),*((-n,pi[w]) for w,n in zip(range(5,10),ns))) +def dual_check(): + q,pi,mu=dual();tight=[];strict=[] + for cap,ns,left in patterns(): + v=reduced(cap,ns,left,pi,mu) + if not v:tight.append([cap,list(ns),left]) + else: + ab=interval(v);need(ab[0]>0,'dual infeasibility');strict.append(ab) + gap=interval(add((1,h(9)),(-1,h(8)),(-1,q)));need(gap[0]>Q(6,1000),'terminal budget gap') + # Independently test every discrete marginal, not only the analytic minimum. + for r in range(1,10):need(interval(add((1,h(r)),(-1,h(r-1)),(-1,q)))[0]>0,'marginal budget') + return {'patterns':len(tight)+len(strict),'tight_patterns':tight,'strict_patterns':len(strict), + 'minimum_strict_reduced_cost':brief((min(x[0] for x in strict),min(x[1] for x in strict))), + 'idle_credit_per_dimension':brief(interval(q)), + 'minimum_terminal_charge_per_dimension':brief(interval(add((1,h(9)),(-1,h(8))))), + 'mandatory_interior_saving_per_dimension':brief(gap)} diff --git a/research/staged544-a2-cone-composition/frozen/cone/verify.py b/research/staged544-a2-cone-composition/frozen/cone/verify.py new file mode 100644 index 0000000000..54402df9f1 --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/cone/verify.py @@ -0,0 +1,128 @@ +"""Bounded scalar-cone refits, Chris R with substantial OpenAI Codex, Apache-2.0. +Trace/bitset helpers are credited frozen code; this is not an independent audit. +""" +from pathlib import Path +from collections import Counter +import sys,json,gzip,copy,hashlib,argparse +ROOT=Path(__file__).resolve().parent +sys.path.insert(0,str(ROOT/'frozen')) +import retiming as t +import audit_core as audit +import tariff as v +need=v.need + +def read(p):return json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +def canonical(w):return hashlib.sha256(json.dumps(w,sort_keys=True,separators=(',',':')).encode()).hexdigest() +def hyperplanes(mask): + bs=t.basis(mask) + for linear in range(1,1<>j&1 else 0) for j in range(len(bs)) if j!=pivot)) + +def prepare(w): + nodes,where,bill=t.tracing(w);gates={};preds={};fixed=set();edges=[] + for r,seq in nodes.items(): + before=None + for addr,kind,p,u in seq: + scalar=addr[0] in ('A','B','restore') and kind=='climb' + key=addr if scalar else ('terminal',r) if addr==('end',) else None + if scalar:gates[key]=u;preds.setdefault(key,[]).append((before,p)) + if kind=='check' and before is not None:fixed.add(before) + if kind=='climb':edges.append((before,p,key,u)) + before=key + return nodes,gates,preds,fixed,edges,bill + +def cone(gates,preds,fixed,targetkey,target): + changes={targetkey:target};queue=[targetkey] + while queue: + key=queue.pop();cap=changes[key] + if key in fixed:return None,'fixed-check' + for pred,mask in preds[key]: + pmask=changes.get(pred,mask) + if t.contained(pmask,cap):continue + if pred is None:return None,'fixed-entrance/native' + changes[pred]=pmask∩queue.append(pred) + return changes,None + +def census(w): + nodes,gates,preds,fixed,edges,bill=prepare(w);out=[];reject=Counter();total=0 + need(bill==audit.frame_bill(w)[0],'trace versus source auditor') + for sr,fr in sorted(w['helper_final'].items(),key=lambda x:int(x[0])): + r=int(sr);seq=nodes[r];last=seq[-2][0];old=t.span(tuple(fr));width=t.rank(old)-t.rank(seq[0][2]) + need(last in gates,'protected last event is not scalar') + seen=set() + for new in hyperplanes(old): + need(new not in seen,'duplicate hyperplane');seen.add(new);total+=1 + need(t.rank(new)==t.rank(old)-1 and t.contained(new,old),'invalid hyperplane') + if not t.contained(seq[0][2],new):reject['start-terminal']+=1;continue + if t.contained(gates[last],new):reject['credited-direct-refund']+=1;continue + changes,reason=cone(gates,preds,fixed,last,gates[last]&new) + if changes is None:reject[reason]+=1;continue + changes[('terminal',r)]=new;delta=Counter() + for pred,p,key,u in edges: + if pred not in changes and key not in changes:continue + a=changes.get(pred,p);b=changes.get(key,u) + need(t.contained(a,b),'propagation lost containment') + delta[t.rank(u)-t.rank(p)]-=1;delta[t.rank(b)-t.rank(a)]+=1 + delta={str(r):n for r,n in delta.items() if r and n} + need(width==5 and delta=={'1':-1},'unpriced feasible cone') + edits=[{'section':k[0],'index':k[1],'old':list(w[k[0]][k[1]][-1]),'new':list(t.basis(m))} for k,m in sorted(changes.items()) if k[0]!='terminal' and gates[k]!=m] + out.append({'register':r,'old_terminal':fr,'new_terminal':list(t.basis(new)),'edits':edits,'width_before':5,'width_after':4,'local_delta':delta,'owner_debit':{'1':1},'optimistic_complete_delta':{}}) + need(len(seen)==(1<0,'tariff dual infeasible');strict+=1 + else:tight+=1 + need((tight,strict)==(12,2539),'tariff domain') + need(not v.add((1,pi[4]),(-1,pi[5]),(-1,v.h(1))),'exact refund tariff') + # Frozen aggregate incumbent is dual-tight. Full owner chronology is inherited. + receipt=read(ROOT/'OWNER-PATTERNS.json');count=0;demand=Counter();bins=Counter() + for cap,ns,left,n in receipt['patterns']: + need(sum(w*c for w,c in zip(range(5,10),ns))+left==cap,'incumbent capacity') + need(not v.reduced(cap,ns,left,pi,mu),'incumbent attainment');count+=n;bins[cap]+=n + for width,c in zip(range(5,10),ns):demand[width]+=n*c + need(count==725760 and bins=={8:241920,16:161280,32:161280,48:161280},'incumbent bins') + need(demand=={5:90720,6:58320,7:171720,8:311040,9:690120},'incumbent demand') + return {'patterns':tight+strict,'tight':tight,'strict':strict,'refund_debit':'H1 exactly','incumbent_bins':count} + +def main(): + p=argparse.ArgumentParser();p.add_argument('--quick',action='store_true');p.add_argument('--record',action='store_true');a=p.parse_args() + for name,digest in read(ROOT/'FROZEN.json').items():need(hashlib.sha256((ROOT/name).read_bytes()).hexdigest()==digest,'frozen source hash') + result={'tariff':tariff_check(),'providers':{}};witnesses=[] + for tag in ('base','extra'): + w=read(ROOT/f'frozen/WORD-{tag}.json.gz');result['providers'][tag]=census(w) + for row in result['providers'][tag]['candidates']: + x=apply(w,row) + if not a.quick:semantics(x) + witnesses.append({'provider':tag,'register':row['register'],'canonical_sha256':canonical(x)}) + result['witnesses']=witnesses + if a.record:(ROOT/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n') + else:need(result==read(ROOT/'RESULT.json'),'result mismatch') + print(json.dumps({'status':'PASS_SCALAR_CONE_BUDGET','hyperplanes_each':13285,'literal_witnesses':len(witnesses),'exact_dirty_replayed':not a.quick,'complete_gain':0},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/staged544-a2-cone-composition/frozen/sep/PROOF.md b/research/staged544-a2-cone-composition/frozen/sep/PROOF.md new file mode 100644 index 0000000000..d39dd7eff0 --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/sep/PROOF.md @@ -0,0 +1,196 @@ +# Fixed separated A2 contractions and their complete unchanged frame bill + +ToikY, with substantial OpenAI Codex assistance. Apache-2.0. + +## Statement and frozen domain + +This certificate supplies seven fixed nonconsecutive scalar contractions on +each of the two PR3734 providers retained by PR3998. It also reproduces, and +credits to PR3998, the existing consecutive contraction at A1858. Its input +providers are PR3734 `fa041037a3374eaa08feeca0b26a5d6893194147`, exported +byte-exactly by PR3998 `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`. +The package is based on canonical main +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`; none of these attribution pins +asserts ancestry of a pending contribution. `SOURCES.json` binds the complete +local source closure. The retained PR3945 notice supplies lineage, not +applicability to the later PR3945 words. + +On arbitrary rational live inputs and dirty buffers, the changed word has the +same full operator as its source. It uses the same registers, native maps, +wrappers, target cut, initial corrections and helper entrance/exit frames. Its +complete paid profile is unchanged. Relative to PR3998's one-site contraction, +it removes seven forward scalar ADD records and five inverse-cleanup ADD +records. This is a fixed constructive simplification, with no recursive-moment +or kappa improvement. It is not an exhaustive separated-motif search, a graph +normal-form theorem, a runtime result or fresh native/supplier admission. + +Original zero-based sites are: + +| Section | Selected indices | Removed central position | Credit | +|---|---|---|---| +| A | 1858,1859,1860 | last | PR3998 | +| B | 4,53,54 | first | new fixed witness | +| B | 7,49,50 | first | new fixed witness | +| restore | 20,21,36 | last | new fixed witness | +| restore | 22,23,38 | last | new fixed witness | +| restore | 26,27,51 | last | new fixed witness | +| restore | 30,31,62 | last | new fixed witness | +| restore | 32,33,73 | last | new fixed witness | + +`data.json` retains every original gate, replacement, support and canonical +word/cleanup digest. The seven new replacements retain the exact original +ordered frame lists. For the credited old A1858 replacement only, the +publication's basis order `[42,82]` is reproduced instead of the raw source's +`[82,42]`; these span the same subspace. The old site's two canonical edited +word hashes are checked against PR3998's publication before applying the seven +additional changes. + +## Exact three-coordinate identity and legal gathering + +An ADD `(destination,source,c)` means +`x_destination <- x_destination + c*x_source`. A chronological list acts in +listed order, so its matrix product has the last event on the left. +For three distinct registers `x,y,z`, put + +``` +S(a): y += a*z T(b): x += b*y U(c): x += c*z. +``` + +The two relevant chronological identities, valid over the rationals, are + +``` +[S(a), T(b), U(-ab)] = [T(b), S(a)] +[U(ab), T(b), S(a)] = [S(a), T(b)]. +``` + +In the first identity both sides end at +`(x+b*y, y+a*z, z)` in terms of the initial coordinates. In the second both end +at `(x+b*y+ab*z, y+a*z, z)`. Thus these equalities preserve arbitrary dirty +inputs, rather than assuming any operand is zero. The primary checker compares +exact rational matrices; `independent.py` separately propagates the three +independent coordinate columns with `Fraction` arithmetic. Equality of these +three columns proves equality of the entire three-coordinate linear operator. + +At every selected site the three ADDs use one common frame. Every intervening +unselected scalar event reads and writes registers outside the entire selected +three-register support. Such an event commutes with every selected ADD as an +operator on the full register space. The selected triple can therefore be +gathered at its first old position, contracted by one of the identities above, +and followed by the unchanged intervening events. The checker includes both +reads and writes in the disjointness test; write-only independence would be +insufficient. + +All eight supports are pairwise disjoint. This also permits the overlapping +index windows of different sites to be contracted simultaneously. No selected +window crosses the A prelude, a section boundary, the target cut or a B native +warp cut. Reconstructed B warp indices change only to locate the same native +event after the same surviving source events. Native lender registers, map +columns, ordered entry/exit frames and native order remain identical. + +Each local identity embeds as that exact operator on its three registers and +the identity on every other live or buffer coordinate. Composing these +equalities with unchanged surrounding operators proves full operator equality +on all 632 live coordinates plus 91 independent dirty buffers. This argument +does not inspect or simplify a native map, commute across a native event, or +assume a native phase convention. It holds with any common linear realization +of the unchanged surrounding operators. Native realizability and their inherited +signed phases are separate obligations. + +## Projected inverse cleanup + +The word contract's ordinary forward sequence is A after `prelude_events`, +then B with its interleaved native events, then restore. No non-target scalar +instruction reads a target. This hygiene rule makes the non-target subsystem +autonomous: deleting target-writing events leaves its invertible operator +`F_N`. Literal cleanup reverses that projected program, negating ADD +coefficients, reciprocating nonzero scales and inverting native symbols. +For each protected helper `r`, the fixed renaming `r -> r+704` applies to both +sources and destinations of this inverse. It names the inherited private dirty +buffer; it is not a new allocation by this construction. + +Equal full forward operators have equal autonomous non-target blocks. +Consequently their projected inverses, under the same buffer renaming, are +equal. Regenerating literal cleanup from the edited ordinary sequence therefore +preserves its buffer action and every endpoint. The checker compares the entire +regenerated cleanup list and its canonical digest, rather than retaining an old +cleanup solely because the forward endpoint matches. + +For both new B sites, the first two original ADDs write a target, while the +third writes a helper. Their contraction changes the target part but retains +the same single helper ADD in the projection. These sites save two forward +ADD records and no cleanup records. Each of the five restore sites is wholly +non-target, saving one forward and one cleanup ADD record. Thus the new saving +is exactly `7+5=12` scalar ADD records versus PR3998. The old A1858 site adds +the separately credited `1+1`; against raw PR3734 the combined saving is +`8+6=14` records. + +These are rational scalar ADD records. Some coefficients are `2` or `1/2`. +The count is not an asserted unit-native instruction saving or physical tariff. +No zero buffer, unchanged helper or caller-boundary assumption is introduced +by the local identities. + +## Complete chronological frame bill + +Algebraic equality alone does not establish a legal or favorable framed +program. The primary auditor recomputes the entire chronological bill and +hygiene for each source, credited-only and final word. The independent checker +implements a second binary trace using explicit immutable point sets in +`F_2^9`, without importing the primary or retained executable. It authenticates +the two compressed input byte strings before loading either provider. + +A frame is the XOR closure of its listed vectors. A scalar event requires +every touched register's current frame to be contained in the event frame. +Each positive dimension difference contributes one recursive child of that +rank. The trace includes initial frames, the fixed target-cut levels, center +entry and nested borrowed descents, every native entry and binary frame image, +the restore stage, and all final successor climbs. Center descent views do +not replace the persistent main register state. Native frame images are +checked by enumerating all 512 binary vectors; this is a binary-frame check, +not signed Clifford verification. + +The independent checker compares 149 complete live-register frame states for +each source/credited/final word: entrance, A exit, both sides of all 72 B native +events, B exit, restore exit and terminal. All agree. It separately recomputes +every charge, including intermediate charges that those boundary comparisons +alone would not determine. The full profile for both providers is + +``` +{1:2440, 2:725, 3:224, 4:102, 5:20, 8:8}. +``` + +There are 3,519 recursive children and rank mass 5,134. Helper widths remain +`{4:26,5:2,6:18,7:53,8:96,9:213}`. No rank count changes, so the recursive +moment agrees identically at every exponent where the inherited profile price +is defined; no numerical optimization is required. Unchanged cleanup widths +and native descriptors do not certify physical scheduling, finite precision, +stock/tape, all-size compilation or outer/BIT obligations. Those remain +inherited or unknown, rather than being assigned cost zero. + +## Evidence, controls and attribution + +The primary replay uses the authenticated, unchanged predecessor +`audit_core.py`. For each provider it freshly checks all three words on the +full 723-input ordinary and dual free-operator matrices, reverse pullback, +cleanup boundaries, buffer identity and absence of buffer-to-live leakage. +This is reuse of a credited interpreter, not a newly independent full-word +interpreter. The independent checker proves the changes compositionally, +reconstructs the complete edited word and cleanup, matches their canonical +digests to `data.json`, and independently certifies the complete frame invoices. +It does not claim a second full free-operator matrix replay. + +Seven in-memory controls per provider must reject: wrong A2 sign, an intervening +read dependency, duplicate/overlapping support, a crossed native cut, a changed +common ordered frame, stale cleanup, and an omitted retained gate. Rejection +uses explicit exceptions and remains active under Python `-O`. These bounded +controls supplement the exact certificate; they do not imply universal test +coverage or independent human acceptance. + +Chris R / Clear1nsight PR3998 supplies the A2 identity, the old consecutive +A1858 contraction, and retained proof/source exports. Dataisfire supplies the +PR3734 literal words. Sagar Thakrar, roger-sato and Arham Tahir supply the +retained auditor lineage. Jeremy Kothe and Dugongue supply rank-profile and +paid-budget context, including PR3945/3863. PR1865 by 1337isnot1337 is earlier +nonconsecutive commuting C3 work with a different identity and source; this +certificate claims no general priority for commuting graph rewrites. +Original notices remain under `source/`. This package neither merges a PR nor +changes the selected frontier. diff --git a/research/staged544-a2-cone-composition/frozen/sep/README.md b/research/staged544-a2-cone-composition/frozen/sep/README.md new file mode 100644 index 0000000000..4e28745283 --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/sep/README.md @@ -0,0 +1,106 @@ +# Seven separated A2 contractions with an unchanged paid profile + +On each exact PR3734 provider, seven separated three-ADD blocks contract to +two ADDs without crossing a native event. Beyond PR3998's credited consecutive +A1858 contraction, this removes **seven forward and five inverse-cleanup ADDs**. +Against the original PR3734 words the combined saving is eight forward and six +cleanup ADDs. The entire recursive histogram remains +`{1:2440,2:725,3:224,4:102,5:20,8:8}`: 3,519 children and rank mass 5,134. +There is **no recursive-moment or kappa gain**, and no measured runtime claim. + +The changed premise is a literal event-graph contraction across strictly +disjoint scalar events. This is outside PR3998's consecutive domain and the +fixed-graph retiming domains. The seven new blocks retain their exact original ordered frames; +every intervening event must avoid all three selected registers. Prelude, +centre and native-warp boundaries remain fixed. It allocates no register or +buffer. The complete favorable frame bill already gives no recursive saving, +so this result stops at the frozen scalar witness rather than opening another +dependent optimization round. + +## Exact frozen scope + +Sources are PR3998 head `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`, +which retains the two PR3734 providers at +`fa041037a3374eaa08feeca0b26a5d6893194147`. All source bytes, blobs and hashes +are bound in `SOURCES.json`; package-local exports remove any pending-history +dependency. Only those two old providers are certified. The retained PR3945 +notice is attribution, not an applicability claim about its later words. + +Seven new sites use original zero-based coordinates: + +| Section | Three ADD indices | +|---|---| +| B | 4, 53, 54 | +| B | 7, 49, 50 | +| restore | 20, 21, 36 | +| restore | 22, 23, 38 | +| restore | 26, 27, 51 | +| restore | 30, 31, 62 | +| restore | 32, 33, 73 | + +For example, at B4/B53/B54, all three frames are span(30): + +``` +196 += 518; 196 -= 588; 588 -= 518 + equals +588 -= 518; 196 -= 588 +``` + +The equality holds over the rationals on arbitrary dirty inputs. Selected +events can be gathered because every intervening event is disjoint from all +three registers. Every source gate, replacement, index and canonical edited +word/cleanup digest is retained in `data.json`; full words are reconstructed +in memory without modifying inputs. This is a fixed witness certificate, +not a complete search or a graph-normal-form theorem. + +## Evidence and reproduction + +Python 3.12 or later, standard library only: + +``` +python3 -B scripts/research_package.py --package research/staged544-separated-a2 +``` + +`PROOF.md` gives local composition, frame-boundary and projected inverse-cleanup +arguments. The separate checker compares all 149 complete live-register frame +states at fixed boundaries for source, credited and final words in each provider, +and recomputes every intermediate charge. It supplies seven semantic rejection +controls per provider, alongside 40 production API/CLI controls. The primary verifier reuses the authenticated, unchanged credited +`audit_core.py` for the complete frame bill, hygiene and free-operator +ordinary/dual/reverse/cleanup replay. This reuse is not a new independent +interpreter. `independent.py` supplies separately implemented scoped checks; +`test_verify.py` exercises semantic and damaged-input controls. Registered +commands are read-only and Git-free. Exact measured validation and publication +receipts are recorded in the PR and handoff; a PASS is not full supplier admission. + +All native descriptors and their order, helper entrances/exits, cut, wrappers, +initial corrections and nonedited fields are retained. Warp event indices only +account for deleted B instructions within their original cut. Physical owner +scheduling, signed native lowering, finite-width precision/stock/tapes and +all-size/outer/BIT obligations are inherited or unknown, never zero. + +## Open next questions + +- Can a different graph remove a paid frame transition? First specify the + replacement boundary and complete favorable bill. These seven sites leave + every rank count unchanged; another seed or larger separated scan is not + justified by this result alone. +- Does one later exact source word admit these contractions? Pin it and recheck + every source index, boundary, cleanup and full invoice before claiming reuse. + No PR3945 or later-word applicability is established here. + +## Credit and status + +Chris R / Clear1nsight PR3998 supplies the A2 identity, consecutive A1858 +contraction, proof context and authenticated source exports. Dataisfire supplies +the PR3734 literal providers. Sagar Thakrar, roger-sato and Arham Tahir supply +the retained auditor lineage. Jeremy Kothe and Dugongue's PR3945/3863 supply +rank-profile and complete-budget context. PR1865 by 1337isnot1337 is an earlier +nonconsecutive commuting C3 fanout construction, with a different identity and +source; no general priority for nonconsecutive commuting rewrites is claimed. +Full native/compiler/owner/source lineage is retained unchanged under `source/`. + +New fixed-witness contraction and checks by ToikY with substantial OpenAI Codex +assistance, including separate AI proof and test contexts. Apache-2.0. No +independent human or formal-kernel acceptance, new supplier, merge, closure or +selected-frontier change is claimed. diff --git a/research/staged544-a2-cone-composition/frozen/sep/independent.py b/research/staged544-a2-cone-composition/frozen/sep/independent.py new file mode 100644 index 0000000000..501c54c11c --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/sep/independent.py @@ -0,0 +1,409 @@ +#!/usr/bin/env python3 +"""Independent fixed-site A2, cleanup and point-set frame certificate. + +No primary or predecessor executable is imported. The proof is compositional +on arbitrary inputs, rather than a second full free-operator interpreter. +Standard library, Python 3.9+. Apache-2.0; ToikY with OpenAI Codex assistance. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction +from functools import lru_cache +import gzip +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +N, V = 704, 112 +FULL_BASIS = [256, 128, 64, 32, 16, 8, 4, 2, 1] +PINS = { + 'base': '5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699', + 'extra': '965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e', +} +# This is the fixed witness, not a census or a search algorithm. +PLAN = ( + ('A', (1858, 1859, 1860), 2), + ('B', (4, 53, 54), 0), ('B', (7, 49, 50), 0), + ('restore', (20, 21, 36), 2), ('restore', (22, 23, 38), 2), + ('restore', (26, 27, 51), 2), ('restore', (30, 31, 62), 2), + ('restore', (32, 33, 73), 2), +) +PROFILE = {'1': 2440, '2': 725, '3': 224, '4': 102, '5': 20, '8': 8} +WIDTHS = {'4': 26, '5': 2, '6': 18, '7': 53, '8': 96, '9': 213} +KNOWN = { + 'base': '32415e93a50f0fdab5fa144da05977fe34bc8340bf967b91c7f7f0bc312df994', + 'extra': '439ce3544b68e3dffdb0cb4496fbc92330e825592515bc28c95580807c9d232d', +} + + +class Rejected(ValueError): + pass + + +def require(condition, message): + if not condition: + raise Rejected(message) + + +def no_duplicates(pairs): + answer = {} + for key, value in pairs: + require(key not in answer, 'duplicate JSON key') + answer[key] = value + return answer + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode('ascii') + + +def sha(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def target(r): + return V <= r < 2 * V + + +def support(gate): + require(gate[0] in ('add', 'scale'), 'non-scalar barrier') + registers = gate[1:3] if gate[0] == 'add' else gate[1:2] + require(all(type(r) is int and 0 <= r < N for r in registers), 'register domain') + return frozenset(registers) + + +def scalar(gate): + i = 3 if gate[0] == 'add' else 2 + a, b = gate[i:i + 2] + require(type(a) is int and type(b) is int and b != 0 and a != 0, 'nonzero rational') + return Fraction(a, b) + + +def coefficients(gates, registers): + """Propagate three independent coordinate columns using exact fractions.""" + result = [] + for column in range(len(registers)): + values = {r: Fraction(k == column) for k, r in enumerate(registers)} + for gate in gates: + require(gate[0] == 'add', 'A2 alphabet') + values[gate[1]] += scalar(gate) * values[gate[2]] + result.append(tuple(values[r] for r in registers)) + return tuple(result) + + +def certified_sites(word, plan=PLAN): + records, occupied = [], set() + for number, (section, indices, central) in enumerate(plan): + require(section in ('A', 'B', 'restore'), 'section domain') + require(len(indices) == 3 and all(type(i) is int for i in indices) + and 0 <= indices[0] < indices[1] < indices[2] < len(word[section]), 'site indices') + require(type(central) is int and central in (0, 1, 2), 'central position') + if section == 'A': + require(indices[0] >= word['prelude_events'], 'prelude barrier') + if section == 'B': + require(not any(indices[0] < w[0] <= indices[-1] for w in word['warps']), + 'native warp barrier') + gates = [word[section][i] for i in indices] + require(all(g[0] == 'add' and len(g) == 6 for g in gates), 'three ADDs') + touched = frozenset().union(*(support(g) for g in gates)) + require(len(touched) == 3 and len({tuple(g[1:3]) for g in gates}) == 3, + 'three distinct directed A2 edges') + require(not occupied.intersection(touched), 'overlapping site support') + occupied.update(touched) + require(gates[0][-1] == gates[1][-1] == gates[2][-1], 'common ordered frame') + for i in range(indices[0], indices[-1] + 1): + if i not in indices: + require(not support(word[section][i]).intersection(touched), 'intervening dependency') + replacement = [deepcopy(g) for j, g in reversed(list(enumerate(gates))) if j != central] + require(coefficients(gates, sorted(touched)) == coefficients(replacement, sorted(touched)), + 'exact three-coordinate identity') + # Match the credited PR3998 publication's basis order on this old site. + known = (section, indices, central) == PLAN[0] + if known: + for gate in replacement: + gate[-1] = [42, 82] + records.append({'section': section, 'indices': list(indices), 'removed_position': central, + 'known': known, 'support': sorted(touched), 'gates': deepcopy(gates), + 'replacement': replacement, + 'crossed_disjoint_events': indices[-1] - indices[0] - 2}) + return records + + +def ordinary_events(word): + yield from word['A'][word['prelude_events']:] + positions = {} + for k, warp in enumerate(word['warps'], 1): + positions.setdefault(warp[0], []).append(['warp', warp[1], k]) + for i in range(len(word['B']) + 1): + yield from positions.get(i, ()) + if i < len(word['B']): + yield word['B'][i] + yield from word['restore'] + + +def inverse_cleanup(word): + """Invert autonomous non-target block, then rename protected buffers.""" + protected = {int(r) for r in word['helper_final']} + rename = lambda r: N + r if r in protected else r + answer = [] + for gate in reversed(list(ordinary_events(word))): + kind, dst = gate[:2] + if kind == 'warp': + answer.append(['warp', rename(dst), -gate[2], FULL_BASIS[:]]) + elif not target(dst): + if kind == 'add': + require(not target(gate[2]), 'non-target reads target') + answer.append(['add', rename(dst), rename(gate[2]), -gate[3], gate[4], FULL_BASIS[:]]) + else: + require(kind == 'scale', 'cleanup alphabet') + answer.append(['scale', rename(dst), gate[3], gate[2], FULL_BASIS[:]]) + return answer + + +def reconstruct(word, records): + edited = deepcopy(word) + for section in ('A', 'B', 'restore'): + selected = [r for r in records if r['section'] == section] + first = {r['indices'][0]: r['replacement'] for r in selected} + suppressed = {i for r in selected for i in r['indices']} + edited[section], old_to_new = [], {} + for i, gate in enumerate(word[section]): + old_to_new[i] = len(edited[section]) + if i in first: + edited[section].extend(deepcopy(first[i])) + elif i not in suppressed: + edited[section].append(deepcopy(gate)) + old_to_new[len(word[section])] = len(edited[section]) + if section == 'B': + for warp in edited['warps']: + warp[0] = old_to_new[warp[0]] + edited['cleanup'] = inverse_cleanup(edited) + require(all(edited[k] == word[k] for k in word if k not in ('A', 'B', 'restore', 'cleanup', 'warps')), + 'unrelated field changed') + require([w[1:] for w in edited['warps']] == [w[1:] for w in word['warps']], 'native record changed') + return edited + + +@lru_cache(maxsize=None) +def span(basis): + result = {0} + for vector in basis: + require(type(vector) is int and 0 <= vector < 512, 'binary vector domain') + result |= {point ^ vector for point in result} + return frozenset(result) + + +def rank(points): + length = len(points) + require(length > 0 and length & (length - 1) == 0, 'binary subspace cardinality') + return length.bit_length() - 1 + + +FULL = frozenset(range(512)) +ZERO = frozenset([0]) + + +def binary_map(columns): + require(len(columns) == 9, 'binary map dimension') + table = [] + for vector in range(512): + image = 0 + for j, column in enumerate(columns): + if vector & (1 << j): + image ^= column + table.append(image) + require(len(set(table)) == 512, 'singular binary map') + return table + + +def frame_audit(word): + """Separate point-set trace; receipt includes full states at fixed cuts.""" + live = tuple(r for r in range(N) if r not in word['removed']) + require(len(live) == 632 and len(word['helper_final']) == 91, 'fixed all-input scope') + maps = [binary_map(w[2]) for w in word['warps']] + for w, table in zip(word['warps'], maps): + require(0 <= w[0] <= len(word['B']), 'warp position') + old, new = span(tuple(w[3])), span(tuple(w[4])) + require(rank(old) == len(w[3]) == len(w[4]) == rank(new), 'warp frame bases') + require(frozenset(table[x] for x in old) == new, 'binary warp frame action') + start, finish = {}, {} + for r in live: + if r < V: + start[r], finish[r] = span((word['ports'][r],)), FULL + elif target(r): + port = word['ports'][r - V] + start[r], finish[r] = ZERO, frozenset(x for x in range(512) if bin(x & port).count('1') % 2 == 0) + else: + start[r], finish[r] = ZERO, FULL + for r, basis in word['start_extra'].items(): + start[int(r)] = span(tuple(basis)) + for r, basis in word['helper_final'].items(): + finish[int(r)] = span(tuple(basis)) + current, paid, boundaries = start.copy(), Counter(), [] + def snapshot(label): + boundaries.append((label, tuple(tuple(sorted(current[r])) for r in live))) + def climb(register, frame): + require(register in current and current[register] <= frame, 'frame containment') + delta = rank(frame) - rank(current[register]) + if delta: + paid[delta] += 1 + current[register] = frame + def ordinary(gate): + for r in support(gate): + if not target(gate[1]) and gate[0] == 'add': + require(not target(gate[2]), 'non-target reads target') + climb(r, span(tuple(gate[-1]))) + snapshot('entrance') + for i, gate in enumerate(word['A']): + if gate[0] == 'warp': + require(i < word['prelude_events'], 'A native warp outside prelude') + _, r, op, before, after = gate + table = maps[abs(op) - 1] + if op < 0: + inverse = [0] * 512 + for x, y in enumerate(table): + inverse[y] = x + table = inverse + require(current[r] == span(tuple(before)), 'prelude entry') + require(frozenset(table[x] for x in current[r]) == span(tuple(after)), 'prelude binary image') + current[r] = span(tuple(after)) + else: + ordinary(gate) + snapshot('A_exit') + levels = {V + int(r): span(tuple(frame)) for r, frame in word['target_levels'].items()} + require(all(current[r] == levels.get(r, ZERO) for r in range(V, 2 * V)), 'target cut frame') + for r, frame in zip(word['centers'], word['center_frames']): + view = span(tuple(frame)) + require(current[r] == view, 'center entry') + served = {levels.get(g[1], ZERO) for g in word['cut'] if g[2] == r} + for child in sorted(served, key=lambda points: -rank(points)): + require(child <= view, 'center descent containment') + delta = rank(view) - rank(child) + if delta: + paid[delta] += 1 + view = child + at = {} + for k, warp in enumerate(word['warps']): + at.setdefault(warp[0], []).append(k) + for i in range(len(word['B']) + 1): + for k in at.get(i, ()): + _, r, _, before, after = word['warps'][k] + snapshot(('before_native', k)) + require(current[r] == span(tuple(before)), 'native entry') + current[r] = span(tuple(after)) + snapshot(('after_native', k)) + if i < len(word['B']): + ordinary(word['B'][i]) + snapshot('B_exit') + for gate in word['restore']: + ordinary(gate) + snapshot('restore_exit') + for r in live: + climb(r, finish[r]) + snapshot('terminal') + widths = Counter(rank(finish[r]) - rank(start[r]) for r in live if r >= 2 * V) + return ({str(k): v for k, v in sorted(paid.items())}, + {str(k): v for k, v in sorted(widths.items())}, boundaries) + + +def word_receipt(word): + profile, widths, boundaries = frame_audit(word) + require(word['cleanup'] == inverse_cleanup(word), 'literal projected inverse cleanup') + require(profile == PROFILE and widths == WIDTHS, 'complete fixed recursive bill') + counts = {s: {op: sum(g[0] == op for g in word[s]) for op in ('add', 'scale', 'warp')} + for s in ('A', 'B', 'restore', 'cleanup')} + return {'profile': profile, 'helper_widths': widths, 'lengths': {s: len(word[s]) for s in counts}, + 'primitive_counts': counts, 'canonical_word_sha256': sha(word), + 'cleanup_sha256': sha(word['cleanup']), 'native_operations': len(word['warps'])}, boundaries + + +def rejected(function): + try: + function() + except Rejected: + return + raise Rejected('negative control escaped') + + +def controls(word, records, contracted): + wrong = deepcopy(word) + wrong['B'][4][3] *= -1 + rejected(lambda: certified_sites(wrong)) + dependent = deepcopy(word) + dependent['B'][5][2] = 518 + rejected(lambda: certified_sites(dependent)) + rejected(lambda: certified_sites(word, PLAN + PLAN[:1])) + crossed = deepcopy(word) + crossed['warps'][0][0] = 8 + rejected(lambda: certified_sites(crossed)) + framed = deepcopy(word) + framed['B'][4][-1] = [31] + rejected(lambda: certified_sites(framed)) + stale = deepcopy(contracted) + stale['cleanup'] = deepcopy(word['cleanup']) + rejected(lambda: require(stale['cleanup'] == inverse_cleanup(stale), 'stale inverse cleanup')) + omitted = deepcopy(records) + omitted[1]['replacement'] = omitted[1]['replacement'][:1] + rejected(lambda: require(coefficients(records[1]['gates'], records[1]['support']) == + coefficients(omitted[1]['replacement'], records[1]['support']), 'missing retained gate')) + return 7 + + +def audit(root): + expected = json.loads((root / 'data.json').read_bytes(), object_pairs_hook=no_duplicates) + require(isinstance(expected, dict) and set(expected) == {'schema_version', 'providers'}, + 'certificate root schema') + require(type(expected['schema_version']) is int and expected['schema_version'] == 1, + 'typed certificate schema version') + require(isinstance(expected['providers'], dict) and set(expected['providers']) == {'base', 'extra'}, + 'certificate providers') + result = {} + for provider in ('base', 'extra'): + source = root / 'inputs' / ('BORROW-WORD-' + provider + '.json.gz') + require(not source.is_symlink(), 'input symlink') + raw = source.read_bytes() + require(hashlib.sha256(raw).hexdigest() == PINS[provider], 'source bytes') + word = json.loads(gzip.decompress(raw), object_pairs_hook=no_duplicates) + records = certified_sites(word) + known, changed = reconstruct(word, records[:1]), reconstruct(word, records) + require(sha(known) == KNOWN[provider], 'published PR3998 word') + require(expected['providers'][provider]['sites'] == records, 'literal fixed-site receipt') + receipts, traces = {}, [] + for name, candidate in (('source', word), ('credited_3998', known), ('separated', changed)): + receipt, trace = word_receipt(candidate) + reference = {k: v for k, v in expected['providers'][provider]['words'][name].items() + if k != 'semantics'} + require(receipt == reference, 'independent complete word/cleanup/frame receipt: ' + name) + receipts[name], traces = receipt, traces + [trace] + require(traces[0] == traces[1] == traces[2], 'all fixed whole-register boundary frames') + before, after = receipts['credited_3998']['primitive_counts'], receipts['separated']['primitive_counts'] + delta = sum(before[s]['add'] - after[s]['add'] for s in ('A', 'B', 'restore')) + cleanup_delta = before['cleanup']['add'] - after['cleanup']['add'] + require((delta, cleanup_delta) == (7, 5), 'additional exact scalar record saving') + negative_count = controls(word, records, changed) + result[provider] = {'new_sites': 7, 'known_sites': 1, 'inputs': 723, + 'local_exact_identities': 8, 'boundary_states': len(traces[0]), + 'negative_controls': negative_count, + 'forward_add_saving_vs_3998': delta, + 'cleanup_add_saving_vs_3998': cleanup_delta, + 'profile': PROFILE, 'helper_widths': WIDTHS} + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--root', type=Path, default=HERE, help='explicit package root for private checking') + args = parser.parse_args() + result = audit(args.root) + print('PASS_INDEPENDENT_SEPARATED_A2 ' + json.dumps(result, sort_keys=True, separators=(',', ':'))) + + +if __name__ == '__main__': + try: + main() + except Exception as error: + import sys + print('FAIL_INDEPENDENT_SEPARATED_A2 ' + str(error), file=sys.stderr) + raise SystemExit(1) diff --git a/research/staged544-a2-cone-composition/frozen/sep/verify.py b/research/staged544-a2-cone-composition/frozen/sep/verify.py new file mode 100644 index 0000000000..877e57b883 --- /dev/null +++ b/research/staged544-a2-cone-composition/frozen/sep/verify.py @@ -0,0 +1,308 @@ +#!/usr/bin/env python3 +"""Seven fixed separated A2 contractions, with complete unchanged paid invoices. + +Apache-2.0. ToikY with substantial OpenAI Codex assistance. The exact whole-word +arithmetic and frame engine is credited retained audit_core.py; this is not a +new independent interpreter or native/supplier audit. The replay adapter follows +the ordinary/dual/reverse contract of roger-sato's retained audit_verify.py. +""" +from __future__ import annotations +import argparse +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import hashlib +import json +from pathlib import Path +import types + +HERE = Path(__file__).resolve().parent +# Exact frozen exports: PR3734 fa041037..., PR3998 389268a6..., PR3945 91f81d13... +PINS = { + 'source/audit_core.py': (19364,'888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951','8b5e1d5f2a106402f036b63028ecef31a4e4c462'), + 'source/SOURCE-CREDITS.md': (2882,'d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b','c054fad87eeaa510865e682ee0c976c4cd728da2'), + 'source/PR3998-README.md': (6498,'d935e7d10e2935ca82a3ba952308d73b78e76a9039cb335682f1fc5ea3b580d7','dcd14ef45bcfb102d030e3f87a0bb2bf80d57ade'), + 'source/PR3998-PROOF.md': (11251,'0bbec6ba5b03e40e571f7f4a89e5776441a33b6ede41beeb80153ffad39d124f','afa6241fdaee6da1e567eb5ba74b780f9121ba8d'), + 'source/PR3945-NATIVE-LINEAGE-NOTICE': (2456,'ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420','380e979f0e84e00a22bd890615d87cc4684ad740'), + 'inputs/BORROW-WORD-base.json.gz': (72769,'5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699','674ea18ade4af85ca865fb08dc973637a09e30e6'), + 'inputs/BORROW-WORD-extra.json.gz': (72766,'965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e','b17e2be67e327f04802fd034c344fe4253c13a4a'), +} +SITES = ( + {'section':'A','indices':[1858,1859,1860],'removed_position':2,'known':True}, + {'section':'B','indices':[4,53,54],'removed_position':0,'known':False}, + {'section':'B','indices':[7,49,50],'removed_position':0,'known':False}, + {'section':'restore','indices':[20,21,36],'removed_position':2,'known':False}, + {'section':'restore','indices':[22,23,38],'removed_position':2,'known':False}, + {'section':'restore','indices':[26,27,51],'removed_position':2,'known':False}, + {'section':'restore','indices':[30,31,62],'removed_position':2,'known':False}, + {'section':'restore','indices':[32,33,73],'removed_position':2,'known':False}, +) +# These are PR3998's published canonical known-contraction words, including its +# ordered basis [42,82] rather than the older source's [82,42]. +KNOWN_WORD = {'base':'32415e93a50f0fdab5fa144da05977fe34bc8340bf967b91c7f7f0bc312df994', + 'extra':'439ce3544b68e3dffdb0cb4496fbc92330e825592515bc28c95580807c9d232d'} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def unique(pairs): + result = {} + for key,value in pairs: + need(key not in result,'duplicate JSON key') + result[key] = value + return result + + +def load_json(path): + return json.loads(path.read_bytes(),object_pairs_hook=unique) + + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(',',':')) + + +def digest(value): + return hashlib.sha256(canonical(value).encode()).hexdigest() + + +def authenticate(): + for relative,(length,sha,blob) in PINS.items(): + path = HERE / relative + need(not path.is_symlink(),'source symlink: '+relative) + raw = path.read_bytes() + need(len(raw)==length and hashlib.sha256(raw).hexdigest()==sha,'source bytes: '+relative) + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==blob, + 'source Git blob: '+relative) + path = HERE / 'source/audit_core.py' + core = types.ModuleType('credited_staged544_audit_core') + core.__file__ = str(path) + exec(compile(path.read_bytes(),str(path),'exec'),core.__dict__) + return core + + +def load_word(provider): + need(provider in ('base','extra'),'provider domain') + authenticate() + return json.loads(gzip.decompress((HERE/'inputs'/('BORROW-WORD-'+provider+'.json.gz')).read_bytes()), + object_pairs_hook=unique) + + +def touched(gate): + need(isinstance(gate,(tuple,list)) and gate,'scalar operation tuple') + kind = gate[0] + need(kind in ('add','scale'),'unknown scalar primitive barrier') + need(len(gate)==(6 if kind=='add' else 5),'scalar operation arity') + registers = gate[1:3] if kind=='add' else gate[1:2] + need(all(type(r) is int and 0<=r<704 for r in registers),'scalar register domain') + if kind=='add': + need(registers[0]!=registers[1],'self ADD') + return set(registers) + + +def matrix(gates, registers): + rows = {r:{s:Q(r==s) for s in registers} for r in registers} + for gate in gates: + need(gate[0]=='add','A2 ADD alphabet') + need(type(gate[3]) is int and type(gate[4]) is int and gate[4]>0 and gate[3]!=0, + 'typed nonzero rational coefficient') + destination,source = gate[1:3] + coefficient = Q(gate[3],gate[4]) + donor = rows[source].copy() + rows[destination] = {r:rows[destination][r]+coefficient*donor[r] for r in registers} + return rows + + +def segments(word,section): + if section=='A': + cuts = [word['prelude_events'],len(word['A'])] + elif section=='B': + cuts = sorted({0,len(word['B'])}|{record[0] for record in word['warps']}) + else: + cuts = [0,len(word['restore'])] + return list(zip(cuts,cuts[1:])) + + +def certify_site(word,site): + need(isinstance(site,dict) and set(site)=={'section','indices','removed_position','known'},'site schema') + section,indices,position = site['section'],site['indices'],site['removed_position'] + need(section in ('A','B','restore'),'site section') + need(isinstance(indices,(tuple,list)) and len(indices)==3 and + all(type(i) is int for i in indices),'typed site indices') + need(0<=indices[0]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±ve{cRKW+p~gSnVTb%BFZ)epEJ1I4*AP8ZrRXXU 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 JbW1Cn3jn$nQt1Ey literal 0 HcmV?d00001 diff --git a/research/staged544-a2-cone-composition/inputs/WORD-extra.json.gz b/research/staged544-a2-cone-composition/inputs/WORD-extra.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..c531be7383ad3ba941600c7ced14e5e10d6d1c67 GIT binary patch literal 74425 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 z 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,'cone remap domain');e['index']-=2 + need(expected==new,'cone candidates not exact remapping') + if full: + for name,x in (('source',w),('credited_3998',known),('combined',changed)): + receipts[name]['semantics']=sep.semantics(core,x);print('CHECKED',tag,name,'full723',flush=True) + need(len({r['semantics']['ordinary_matrix_sha256'] for r in receipts.values()})==1 and len({r['semantics']['dual_matrix_sha256'] for r in receipts.values()})==1,'full operator equality') + witnesses=[] + for row in new_cone['candidates']: + x=cone.apply(changed,row) + if full:cone.semantics(x) + witnesses.append({'register':row['register'],'word_sha256':digest(x),'local_delta':row['local_delta'],'owner_debit':row['owner_debit'],'optimistic_complete_delta':row['optimistic_complete_delta']}) + return {'provider':tag,'sites':records,'words':receipts,'fixed_boundary_frames':frames,'cone':new_cone,'cone_witnesses':witnesses,'scalar_saving_vs_3998':{'forward':7,'cleanup':5},'new_kappa':False} + +def audit(tag,full=True): + actual=provider(tag,full);expected=read(ROOT/'RESULT.json')['providers'][tag] + if not full: + expected=deepcopy(expected) + for r in expected['words'].values():r.pop('semantics',None) + need(canonical(actual)==canonical(expected),'result mismatch');return actual + +def main(): + p=argparse.ArgumentParser();p.add_argument('--provider',choices=('base','extra'),default='base');p.add_argument('--quick',action='store_true');p.add_argument('--record',action='store_true');p.add_argument('--tariff',action='store_true');a=p.parse_args() + if a.record: + t,c,v,k,s=load_engines();result={'schema_version':1,'tariff':k.tariff_check(),'providers':{tag:provider(tag,True) for tag in ('base','extra')}} + (ROOT/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n');print('WROTE combined result') + elif a.tariff: + t,c,v,k,s=load_engines();need(k.tariff_check()==read(ROOT/'RESULT.json')['tariff'],'tariff mismatch');print('PASS_OWNER_DUAL_2551_PATTERNS exact_net_zero') + else: + audit(a.provider,not a.quick);print('PASS_A2_CONE_COMPOSITION',a.provider,'full='+str(not a.quick),'no_new_kappa') +if __name__=='__main__': + try:main() + except Exception as e:print('FAIL_A2_CONE_COMPOSITION '+str(e),file=sys.stderr);raise SystemExit(1) From 722dc10801d74963a24d3061be48b93186559ac9 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 22:12:34 +1100 Subject: [PATCH 2/2] Keep private mutation controls usable from read-only exports Make only the temporary copied mutation target writable before corrupting it; frozen source and exported files stay read-only. Scientific construction, proof and result are unchanged. --- research/staged544-a2-cone-composition/check_controls.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/research/staged544-a2-cone-composition/check_controls.py b/research/staged544-a2-cone-composition/check_controls.py index 26752e489f..658d9504d5 100644 --- a/research/staged544-a2-cone-composition/check_controls.py +++ b/research/staged544-a2-cone-composition/check_controls.py @@ -26,9 +26,9 @@ def main(): with tempfile.TemporaryDirectory(prefix='combined-a2-control-') as tmp: dest=Path(tmp)/'package';shutil.copytree(ROOT,dest,ignore=shutil.ignore_patterns('__pycache__','*.pyc')) if kind=='owner-debit': - p=dest/'RESULT.json';x=json.loads(p.read_bytes());x['providers']['base']['cone_witnesses'][0]['owner_debit']={'1':0};p.write_text(json.dumps(x)) + p=dest/'RESULT.json';p.chmod(0o600);x=json.loads(p.read_bytes());x['providers']['base']['cone_witnesses'][0]['owner_debit']={'1':0};p.write_text(json.dumps(x)) else: - p=dest/'inputs/WORD-base.json.gz';p.write_bytes(p.read_bytes()+b'\0') + p=dest/'inputs/WORD-base.json.gz';p.chmod(0o600);p.write_bytes(p.read_bytes()+b'\0') env=os.environ.copy();env['PYTHONPYCACHEPREFIX']=str(Path(tmp)/'fresh-cache') r=subprocess.run([sys.executable,'-O','-B',str(dest/'verify.py'),'--quick'],capture_output=True,text=True,env=env,timeout=120) V.need(r.returncode!=0 and ('result mismatch' if kind=='owner-debit' else 'frozen source hash') in r.stderr,'actual CLI rejection '+kind)