From 1dbdaa414cfe4a4a0f015e88a04b52e146566786 Mon Sep 17 00:00:00 2001 From: Jerry Jiaheng Chen <80299683+CubeJerry@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:02:02 +0800 Subject: [PATCH] Generate the actual native translation descriptors from the five-field header and execute its complete same-owner pass --- .../BINDING-OPTIMIZED.json | 15 + .../BINDING.json | 15 + .../native-translation-descriptor/NOTICE.md | 20 + .../native-translation-descriptor/OVERLAP.md | 32 ++ .../PR-DESCRIPTION.md | 100 +++++ .../PR-TITLE.txt | 1 + .../native-translation-descriptor/PROOF.md | 377 ++++++++++++++++++ .../native-translation-descriptor/README.md | 102 +++++ .../native-translation-descriptor/RECIPE.json | 130 ++++++ .../RELOCATED-RESULT.json | 1 + .../native-translation-descriptor/RESULT.json | 280 +++++++++++++ .../SOURCES.json | 130 ++++++ .../native-translation-descriptor/TASK.json | 97 +++++ .../VALIDATION.md | 83 ++++ .../native-translation-descriptor/VERIFY.json | 73 ++++ .../bind_source.py | 83 ++++ .../independent/RESULT-OPTIMIZED.json | 1 + .../independent/RESULT.json | 1 + .../independent/REVIEW.md | 88 ++++ .../independent/SOURCE-BINDINGS.json | 94 +++++ .../independent/check.py | 162 ++++++++ .../reference/clifford_exact.py | 149 +++++++ .../reference/inputs/controller_reference.py | 112 ++++++ .../reference/native-phase-PROOF.md | 336 ++++++++++++++++ .../reference/native-phase.py | 335 ++++++++++++++++ .../reference/native_verify.py | 277 +++++++++++++ .../reference/reverse.py | 207 ++++++++++ .../reference/row-reversal-PROOF.md | 318 +++++++++++++++ .../reference/selected-native.json.gz | Bin 0 -> 350722 bytes .../translate.py | 221 ++++++++++ .../native-translation-descriptor/verify.py | 306 ++++++++++++++ 31 files changed, 4146 insertions(+) create mode 100644 research/native-translation-descriptor/BINDING-OPTIMIZED.json create mode 100644 research/native-translation-descriptor/BINDING.json create mode 100644 research/native-translation-descriptor/NOTICE.md create mode 100644 research/native-translation-descriptor/OVERLAP.md create mode 100644 research/native-translation-descriptor/PR-DESCRIPTION.md create mode 100644 research/native-translation-descriptor/PR-TITLE.txt create mode 100644 research/native-translation-descriptor/PROOF.md create mode 100644 research/native-translation-descriptor/README.md create mode 100644 research/native-translation-descriptor/RECIPE.json create mode 100644 research/native-translation-descriptor/RELOCATED-RESULT.json create mode 100644 research/native-translation-descriptor/RESULT.json create mode 100644 research/native-translation-descriptor/SOURCES.json create mode 100644 research/native-translation-descriptor/TASK.json create mode 100644 research/native-translation-descriptor/VALIDATION.md create mode 100644 research/native-translation-descriptor/VERIFY.json create mode 100644 research/native-translation-descriptor/bind_source.py create mode 100644 research/native-translation-descriptor/independent/RESULT-OPTIMIZED.json create mode 100644 research/native-translation-descriptor/independent/RESULT.json create mode 100644 research/native-translation-descriptor/independent/REVIEW.md create mode 100644 research/native-translation-descriptor/independent/SOURCE-BINDINGS.json create mode 100644 research/native-translation-descriptor/independent/check.py create mode 100644 research/native-translation-descriptor/reference/clifford_exact.py create mode 100644 research/native-translation-descriptor/reference/inputs/controller_reference.py create mode 100644 research/native-translation-descriptor/reference/native-phase-PROOF.md create mode 100644 research/native-translation-descriptor/reference/native-phase.py create mode 100644 research/native-translation-descriptor/reference/native_verify.py create mode 100644 research/native-translation-descriptor/reference/reverse.py create mode 100644 research/native-translation-descriptor/reference/row-reversal-PROOF.md create mode 100644 research/native-translation-descriptor/reference/selected-native.json.gz create mode 100644 research/native-translation-descriptor/translate.py create mode 100644 research/native-translation-descriptor/verify.py diff --git a/research/native-translation-descriptor/BINDING-OPTIMIZED.json b/research/native-translation-descriptor/BINDING-OPTIMIZED.json new file mode 100644 index 0000000000..a4658d5d9b --- /dev/null +++ b/research/native-translation-descriptor/BINDING-OPTIMIZED.json @@ -0,0 +1,15 @@ +{ + "actual_native_owner": 415, + "basis_states": 512, + "local_source_files": 9, + "native_event": 24472, + "negative_controls": [ + "changed translation from output bit0 to output bit8" + ], + "offset": 1, + "ordering": "diagonal, linear matrix, translation, commuting global phase", + "packed_coordinate": 0, + "scope": "Source factor only; no implementation of the preceding matrix or whole native MOVE.", + "side": "right", + "status": "PASS_SELECTED_TRANSLATION_SOURCE_BINDING" +} diff --git a/research/native-translation-descriptor/BINDING.json b/research/native-translation-descriptor/BINDING.json new file mode 100644 index 0000000000..a4658d5d9b --- /dev/null +++ b/research/native-translation-descriptor/BINDING.json @@ -0,0 +1,15 @@ +{ + "actual_native_owner": 415, + "basis_states": 512, + "local_source_files": 9, + "native_event": 24472, + "negative_controls": [ + "changed translation from output bit0 to output bit8" + ], + "offset": 1, + "ordering": "diagonal, linear matrix, translation, commuting global phase", + "packed_coordinate": 0, + "scope": "Source factor only; no implementation of the preceding matrix or whole native MOVE.", + "side": "right", + "status": "PASS_SELECTED_TRANSLATION_SOURCE_BINDING" +} diff --git a/research/native-translation-descriptor/NOTICE.md b/research/native-translation-descriptor/NOTICE.md new file mode 100644 index 0000000000..903e332da2 --- /dev/null +++ b/research/native-translation-descriptor/NOTICE.md @@ -0,0 +1,20 @@ +# Credit and assistance + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +New work is Apache-2.0. Exact retained sources preserve their original notices. + +The selected #7000 source, its application and predecessor native/Clifford +contributors supply the actual event and operator decomposition. The published +literal-native-quadratic-phase package supplies the exact current recipe +binding and five-Gamma/raw packed ABI. The published literal-row-reversal +package supplies the unchanged literal record-reversal graph, classical +two-stack implementation and exact cost/history theorem. The phase lineage +supplies the retained Gamma/unary helpers, and #7349 supplies the finite +machine grammar and builder. The earlier serial monomial descriptor iterator +is a distinct predecessor, not a solved numerical join on this ABI. + +This package contributes literal collapsed-descriptor production and the +actual fixed-graph join for one source-bound post-matrix translation. It does +not claim the source recipe, tensor translation identity, reversal algorithm, +or classical unary/binary conversion as new. Independent AI review, where +recorded, is not human or formal-kernel acceptance. diff --git a/research/native-translation-descriptor/OVERLAP.md b/research/native-translation-descriptor/OVERLAP.md new file mode 100644 index 0000000000..fcf362fd5e --- /dev/null +++ b/research/native-translation-descriptor/OVERLAP.md @@ -0,0 +1,32 @@ +# Bounded overlap and stopping record + +Canonical main was rechecked unchanged at e545235 before wave4b allocation. +This follows a stopped wave4 scalar-wrapper audit: current #7000 logical +owner maps and rational scalar tables do not supply an actual physical caller +producer. That audit is not repackaged here. + +The new scope was allocated explicitly to the descriptor gap left by the +published C3 row-reversal package, using B3's supplied five-Gamma raw packet. +Its sibling lane implements a positive native C leaf and does not provide +this translation producer. The source, axis, packet and method are fixed. + +Read before construction: current-serial-monomial-leaf README, selected- +monomial-tape-lift README, C3 PROOF/reverse.py and source-join section, +B3 PROOF/RECIPE and the retained Clifford monomial/lower_child source. The +serial iterator's numerical implementation remains structured control, and +the older tape lift emits records with a supplied primitive tariff. Neither +is this complete graph. C3 explicitly leaves collapsed-length production +open, and this package supplies exactly that work on the named packed ABI. + +A bounded live PR search for descriptor plus reversal found unrelated BIT +descriptor/continuation work and no matching join. This is not exhaustive +novelty evidence. Source-relative scope is the primary novelty argument. + +The optimistic budget passed: f,r,P,S,w and generated unary B are each at +most the complete packet V; geometric doubling and halving are linear in +their final expanded guides. A quadratic rescan, supplied runtime arithmetic, +wrong-axis mapping or uncharged format conversion would trigger stop/pivot. +The executed program instead admits the complete exact census in PROOF.md. + +Stop at one post-matrix translation. Actual native caller production, the +preceding matrix, a full monomial and the multiplier remain separate tasks. diff --git a/research/native-translation-descriptor/PR-DESCRIPTION.md b/research/native-translation-descriptor/PR-DESCRIPTION.md new file mode 100644 index 0000000000..0d982d3f84 --- /dev/null +++ b/research/native-translation-descriptor/PR-DESCRIPTION.md @@ -0,0 +1,100 @@ +## Result + +One local native interface is completed, with **no new kappa**. A fixed +25-tape, 1,878-location program reads the existing five-Gamma packed packet +header, generates the canonical binary reversal descriptors, executes the +retained complete-row reversal, and restores the same DATA owner, all heads +and private windows on success. + +The exact source is the right monomial of selected MOVE24472, +`["MOVE",415,3,99,false]`. Its affine offset1 is a translation on output +coordinate0 after its linear matrix. Under the supplied packed geometry, +the program produces `P'=P`, `R=2^f`, `B=2Sr w*2^(8f)` by literal local +operations. No decoded integer, runtime multiplication service or supplied +collapsed length enters its execution path. + +## Why this matters and what is new + +The published literal-row-reversal result assumes its three binary collapsed +lengths. The published native-phase result supplies a different, five-Gamma +packed ABI for an actual selected recipe. This package supplies the missing +runtime descriptor producer and a fixed-graph join between those boundaries. +It checks the source's bit/axis order and includes both components, every +coefficient, all spectator copies and the eight remaining coordinates. + +The reversal, translation identity, source lowering and numeral-conversion +algorithm are existing results. The contribution is their executable, +source-bound interface with complete costs. A new unary-to-binary helper has +exact cost `19n-12popcount(n)+19ell(n)+7`; its linear charge prevents a hidden +quadratic descriptor rescan. + +The exact full census is in PROOF.md. The convenient envelopes are +`T<=4096(V+E+1)` and `K_final<=K0+32(V+E+1)`, where +`V=2P*2^(9f)*Sr w`. This is complete O(V) work on the supplied local ABI, +including expansion, acquisition, copies, output staging, commit, all head +returns and descriptor/work retirement. Previous historical backing remains +charged. + +## Exact sources and checks + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +- Packed source ABI and actual recipe: + [published native-phase package](https://github.com/CubeJerry/integer-mult-bounds/tree/172f4535ce8dcff79f626410af845f757c1563be/research/literal-native-quadratic-phase). +- Retained literal reversal: + [published row-reversal package](https://github.com/CubeJerry/integer-mult-bounds/tree/7662d01d827c95d90032579c168cae78aa531f2f/research/literal-row-reversal). +- Actual selected source: CrocSwap/integer-mult-bounds#7000 and its retained + application, with canonical compressed source bytes pinned in SOURCES.json. + +The author corpus executes nine successful complete packets, totaling 702,464 +payload bits and 57,517,967 local transitions. This includes the entire +nine-coordinate f=2 packet. It checks actual produced descriptors, every +embedded predecessor instruction, a separate source-coordinate XOR oracle, +exact HEADER/DATA census, retained-object reuse, opaque exteriors and cleanup. +The encoder has 104 exact-census fixtures through n=1024. Controls detect a +missing real/imaginary factor, the wrong collapsed axis despite unchanged +volume, missing descriptor retirement, malformed header and wrong DATA length. +Source binding checks all 512 basis states and rejects a changed output axis. + +A separate lead-agent review accepted the universal source, map, complete +cost and history proof. Its new dense CPU and separately derived exact +instruction census pass ten complete cases and 54,801,743 transitions, +including actual m=9,f=2, four malformed controls and three program mutants. +Normal and optimized receipts agree. All eleven source commit:path bindings +were independently authenticated. Frozen review files are retained unchanged +under independent/. The review is AI-assisted, not human or proof-kernel +verification. + +```sh +python -I -W error -B research/native-translation-descriptor/bind_source.py +python -I -W error -B research/native-translation-descriptor/verify.py +python -I -W error -B research/native-translation-descriptor/independent/check.py research/native-translation-descriptor/translate.py +python -I -O -W error -B research/native-translation-descriptor/independent/check.py research/native-translation-descriptor/translate.py +python -B scripts/research_package.py --package research/native-translation-descriptor --check-only +``` + +Finite tests corroborate the written universal loop invariants; they do not +prove an asymptotic claim by extrapolation. + +## Limits and next obligations + +The actual native caller's five-Gamma owner/format production remains +supplied. The preceding matrix is not implemented; it cannot be dropped +between the phase and this translation. Other monomial factors, recursive +children, global allocation/stock and the whole multiplier remain open. +Failure cleanup or reuse after rejection is not claimed. Source owner415 +identifies the native event, not a solved physical owner selector for the +final compiler. All five selected assumptions and kappa0.00363005817 remain. + +Next steps are the exact source matrix on this packet, one actual caller's +physical descriptor/owner producer, and complete factor/child lifecycle joins. + +## Credit and assistance + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance in +proof, code, verification and writing. Credit the selected source and its +Clifford/native lineage, the published native-phase and row-reversal packages, +CrocSwap/integer-mult-bounds#6992 for the distinct literal descriptor iterator, +the prior Gamma/unary and original-owner staging work, and +CrocSwap/integer-mult-bounds#7349 for the literal machine. Original notices +remain in retained source files. No upstream PR is submitted by this run. diff --git a/research/native-translation-descriptor/PR-TITLE.txt b/research/native-translation-descriptor/PR-TITLE.txt new file mode 100644 index 0000000000..b0f33b15e8 --- /dev/null +++ b/research/native-translation-descriptor/PR-TITLE.txt @@ -0,0 +1 @@ +Generate the actual native translation descriptors from the five-field header and execute its complete same-owner pass diff --git a/research/native-translation-descriptor/PROOF.md b/research/native-translation-descriptor/PROOF.md new file mode 100644 index 0000000000..5c6325471a --- /dev/null +++ b/research/native-translation-descriptor/PROOF.md @@ -0,0 +1,377 @@ +# A literal descriptor join for one selected native translation + +**Scoped enabling lemma; no new kappa.** Prepared for Jerry Chen / @CubeJerry +with substantial OpenAI assistance. Canonical base: +`e54523517d0f03e58352e647c403a5af3e525a57`. + +## 1. Actual source factor and exact boundary + +The selected native word is +`research/shared-wire-split-composition/data/final.json.gz`, compressed SHA256 +`2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883`. +Its zero-based event 24472 is `["MOVE",415,3,99,false]`. The exact lowering of +the frame-3 to frame-99 operator has rank 1. Its right monomial has affine +offset **1**, with matrix rows +`(239,129,130,132,136,16,160,192,256)`. + +The retained Clifford constructor produces `diag; perm(G); xgate(offset); +global_phase`. Rows of G are indexed by output bits: the image integer is +`sum_i parity(G_i & x)*2^i`, then XOR offset. Therefore offset 1 flips +**output coordinate 0 after G**. It does not identify bit zero with the +fastest packed coordinate. The complete authenticated recipe is retained in +`RECIPE.json`; `bind_source.py` recomputes it and checks the post-matrix +translation with the separate retained signed-Pauli/Gaussian evaluator. + +The supplied entry ABI is exactly the five-Gamma/raw packed ABI of +[literal-native-quadratic-phase](https://github.com/CubeJerry/integer-mult-bounds/tree/172f4535ce8dcff79f626410af845f757c1563be/research/literal-native-quadratic-phase). +Its coordinate tuple is `a=(a_0,...,a_8)` with a_0 the slow coordinate, a_8 +the fast coordinate, and each `a_i` an f-bit nonnegative integer. For each +tensor column j, native coordinate bit i is `(a_i >> j)&1`. + +Consequently the source's lifted X_1 acts by + +`(a_0,a_1,...,a_8) -> (a_0 XOR (2^f-1),a_1,...,a_8)`. + +This package implements that translation alone at the stated post-matrix +boundary. It does not implement G, the source quadratic phase, the central +rank-one child, or the whole MOVE. In particular the existing phase pass +cannot simply be followed by this translation while omitting G. + +## 2. The joined literal theorem + +Supply positive integers `f,r,P,S,w` as five consecutive canonical Elias +Gamma codes on HEADER. Gamma(n) consists of `ell(n)-1` zeroes followed by +the ell(n) ordinary binary digits of n. Let E be their total bit length. +DATA is the complete lexicographic array + +`[P] x [2^f]^9 x [S]`, + +with r Gaussian coefficients per array entry and 2w raw bits per coefficient, +real component then imaginary component, each MSB first. The word contains +exactly + +`V = 2*P*2^(9f)*S*r*w` + +bits and then a physical blank. The payload may be arbitrary; no arithmetic +or signed headroom is needed for this permutation. HEADER can have opaque +data immediately after its fifth code. DATA can have opaque data after the +blank endpoint. All such exteriors remain unchanged. + +The fixed ports are HEADER=0, DATA=1, three private binary descriptors at +2,3,4, the nine retained reversal work roles at 5,...,13, and eleven producer +roles at 14,...,24. Thus there are **25 tapes**, of which 23 are private. +Each head begins at its own arbitrary origin, possibly negative. On private +roles, the guard at origin minus one and the active windows in Section 7 are +blank. This is an explicit allocation/blankness premise, not something two +local probes certify. Opaque cells outside those windows are preserved. + +**Theorem.** `compile_translation()` emits one fixed 1,878-location graph, +alphabet `{blank,0,1,|}`, using only scanned-symbol branches, one-cell writes, +unit moves, fixed jumps and halt. It has no runtime shape, integer, coordinate +array, source callback, multiplication service or graph-generation argument. +On every legal packet it applies the source translation above, commits to +the same DATA owner and exact original field, restores HEADER and every head, +and erases all private bodies and guards. + +For every successful call its complete local instruction count obeys + +`T <= 4096*(V+E+1)`, + +and its private historical backing obeys + +`K_final <= K0 + 32*(V+E+1)`. + +K0 is actual previous private backing, including currently blank retained +cells. No erasure reduces it. Both bounds are O(V) on this complete ABI. + +Missing DATA bits, an extra immediate DATA bit, or a malformed finite header +encountered by the literal parser cause rejection before any DATA write. +General malformed-input termination, failure cleanup, interrupted-call +recovery and later reuse after failure are not claimed. The normal runtime +graph contains no verifier step budget. + +## 3. Producing the correct collapsed lengths + +Collapse the complete packet as `[P'] x [R] x [B]`, taking + +`P'=P`, `R=2^f`, `B=2*S*r*w*2^(8f)`. + +The remaining eight coordinates, all spectator copies, r coefficients and +both complete w-bit components are in the B-bit suffix record. This includes +every real/imaginary bit; reversing B-bit records must preserve their internal +order. The identity `P' R B = V` is exact. + +The producer obtains these encodings from the actual HEADER as follows. + +1. The retained Gamma pattern creates unary guides of lengths f,r,P,S,w. + LENGTH counts prefix zeroes. Each tail digit b changes an existing unary + prefix v to `2v+b` using DOUBLE and physical scans. HTRACE records every + HEADER step and returns HEADER to its entry origin with erasure. +2. RDESC receives one `1`, then exactly f zeroes while scanning the F guide. + This is the canonical MSB-first encoding of `2^f`; it does not construct + an uncharged host power or require a supplied binary R. +3. Three literal nested scans over S, r and w append two unary marks per + innermost visit. PRODUCT therefore has exactly `B0=2Srw` marks. +4. For every mark of F, the fixed program executes eight unary doublings of + PRODUCT. Induction on the scanned F prefix gives the final length + `B=B0*2^(8f)`. Each doubling physically copies, clears, restores and + erases its scratch. Eight is a fixed property of this source geometry; + the number of iterations over f is discovered by local scans. +5. The routine in Section 4 consumes OUTER=P and PRODUCT=B and emits their + canonical binary words on PDESC and BDESC. RDESC is already canonical. + +At the reversal join all 25 heads are at their original origins. DATA has +not been written or moved. The three generated descriptor words are +canonical, positive, terminated by physical blanks, and on distinct owners. +The reversal's nine private windows are untouched and blank. Producer guards +at descriptor origin minus one are opaque exterior symbols to the reversal; +that routine neither reads nor changes them. + +## 4. A charged unary-to-binary bridge + +The descriptor routine `unary_binary` takes one positive unary run of length +n, a blank quotient role HALF, a blank DIGITS stack, and a blank destination. +Their roles and guards are distinct. Two fixed control copies alternate +which of the source/HALF roles holds the current positive quotient. This +does not allocate a changing family of tapes. + +While scanning the current run, a parity control bit toggles on every mark. +Every second mark appends one mark to the other role; all current marks are +erased. Thus at the scan end the other role has floor(n/2) marks and the +parity is n mod 2. The routine restores both unary heads and appends the +parity as one bit to DIGITS. A local read of the quotient distinguishes a +positive next iteration from termination. At termination both unary roles +are blank and restored. + +The resulting DIGITS word contains the remainders of repeated exact division +by two, least significant first. Its last bit is 1 because the last positive +quotient is 1. Popping DIGITS backward into the destination therefore writes +the canonical MSB-first binary representation, with no leading zero and no +external length. The pop erases DIGITS; guarded rewind restores destination +and all scratch heads. + +This is the classical division-by-two conversion with an explicit local +implementation and complete charge, not a claimed new numeral algorithm. +Here its linear cost matters: materializing unary B is affordable because +B is a complete suffix volume, and binary production must not add a hidden +quadratic rescan. + +For an iteration with current value n_i and quotient q_i=floor(n_i/2), the +literal instruction count is `7n_i+5q_i+10`. This includes the parity scan, +all writes, both rewinds, digit append and next-iteration test. If +`ell=ell(n)` and `s=popcount(n)`, then + +`sum_i n_i=2n-s`, `sum_i q_i=n-s`. + +The initial jump and final digit reversal/rewind add `9ell+7`. Hence the +routine's exact cost, excluding its caller's guard installation/removal, is + +`19n - 12s + 19ell + 7 <= 38n+7`. + +The current unary run never exceeds n, HALF never exceeds floor(n/2), and +DIGITS/destination never exceed ell(n). These are all-size loop invariants. +The finite encoder tests independently check the exact census; they are not +used as a universal interpolation argument. + +## 5. Actual reversal invocation and successful retirement + +The invoked graph is the exact +[literal-row-reversal](https://github.com/CubeJerry/integer-mult-bounds/tree/7662d01d827c95d90032579c168cae78aa531f2f/research/literal-row-reversal) +program, source SHA256 +`4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245`. +Its 524 instructions are included in the joined graph with a fixed tape and +label relabeling. The single successful halt becomes a fixed jump to the +descriptor-retirement epilogue, of the same one-instruction cost. No runtime +call, decoded size, computed target or interpreter callback is inserted. +The verifier checks every instruction of this embedded subgraph against the +retained graph, including its rejection branch. + +The predecessor theorem maps each `[P] x [R] x [B]` packet to +`A'(p,a,b)=A(p,R-1-a,b)`, preserving the internal order of each complete +B-bit suffix record. For R=2^f, `R-1-a=a XOR (R-1)`. Combined with Section 3, +this is exactly the source tensor X_1 and preserves all other coordinates, +Gaussian coefficients and individual component bits. + +The predecessor stages its entire output, checks exact DATA cardinality, +then installs only on the same DATA owner. It restores descriptor heads and +its nine private roles before jumping to the epilogue. The epilogue erases +all generated descriptor bodies and remaining unary parameter bodies, then +all fourteen producer guards. Each clearing scan stops at its current blank +frontier and rewinds to its local guard. At halt every private body and guard +is blank and all heads have returned to their entry origins. + +If the header parser or the reversal rejects, the producer has made no DATA +write and the reversal has not started commit. Public values are therefore +preserved, but private work and heads can remain dirty. The proof requires +successful cleanup before a subsequent clean call. + +## 6. Exact complete instruction bill and linear envelope + +Each local instruction, including a read, write, unit move, jump or halt, +costs one. Let `s(n)=popcount(n)`, `ell(n)=floor(log2(n))+1`, and set + +`E'=ell(P)+ell(R)+ell(B)`. + +Define two exact helper counts: + +`g(n)=47n-30s(n)+33ell(n)-42`, + +`h(n)=19n-12s(n)+19ell(n)+7`. + +The first is Gamma decoding before the shared HEADER return and guards; +the second is Section 4's complete unary-to-binary conversion. To verify +the first directly, each leading zero uses seven instructions. A binary +prefix update from v by b uses `47v+17b+18` instructions in its three unary +copy/clear helpers, plus eight in the Gamma wrapper. The strict prefix sum +is `n-s(n)`. Counting the leading one and terminal LENGTH read gives g(n). +The proof uses finite control states and local scans throughout. + +The exact predecessor reversal count is + +`C(P,R,B)=53V+23PR+71P+54R+54B+28E'` + +` -30(s(P)+s(R)+s(B))-8`. + +The entire joined program has the following additive census: + +| Executed region | Exact instruction count | +|---|---| +| Install fourteen producer guards | `42` | +| Decode the five Gamma values | `g(f)+g(r)+g(P)+g(S)+g(w)` | +| Return HEADER and erase its trace | `5E+3` | +| Produce RDESC and restore F/RDESC | `11f+12` | +| Produce B0 by complete nested scans | `16Srw+10Sr+10S+7` | +| Execute eight doublings per F mark | `47(B-B0)+150f+4` | +| Produce PDESC and BDESC | `h(P)+h(B)` | +| Complete retained reversal | `C(P,R,B)` | +| Erase producer bodies/guards and halt | `7(E'+f+r+S+w)+99` | + +For the doubling row, a zero-bit update costs `47v+18`; there are 8f such +updates and their previous values sum to B-B0. Scanning and returning F +adds `6f+4`. For the last row, OUTER and PRODUCT have been consumed and all +temporary guides are blank; the only remaining body lengths are the three +descriptors and f,r,S,w. Clearing a body of length n costs `7n+4`, including +its return. Fourteen guard removals and the final halt give the constant 99. + +This census includes source acquisition, every unary expansion, record load, +copy, two-stack reversal, full output stage, DATA returns, complete commit, +descriptor returns, setup and erasure. It is independent of payload bits and +absolute origins. The graph is built once at a fixed finite setup cost before +the numerical inputs vary; the displayed bill is for each execution of that +fixed graph. No input-dependent compilation is hidden. + +For a convenient envelope, put `Sigma=f+r+P+S+w`. Gamma acquisition plus +HEADER return is at most `256(E+Sigma+1)`. RDESC costs at most `32(f+1)`; +the nested product at most `18B0+7`; the doubling stage at most +`47B+286f+4`; the two encoders at most `38(P+B)+14`; and the reversal at +most `256(V+E'+1)`. The exact epilogue is as above. Since every parameter, +B and B0 is at most V, Sigma<=5V. Moreover `E'<=log2(V)+3<=V`, as V>=1024. +These bounds sum to less than `4096(V+E+1)`. + +Finally `E<=2log2(frPSw)+5<=2log2(V)+5`, so E is O(log V) and the complete +execution is O(V). A unary parameter unrelated to the packet volume would +not justify this argument. Here the exact complete-array product pays every +expanded guide, including the large suffix B. + +## 7. Private backing, exteriors and repeated calls + +Every private role has a guard at relative position -1. The table below +gives its largest possible body/end position; hence its visited interval is +contained in `[-1,cap]`. Define `M=max(P,B)` and `L=ell(M)`. + +| Producer role | Cap | +|---|---| +| PDESC, RDESC, BDESC | `ell(P)`, `f+1`, `ell(B)` respectively | +| HTRACE, LENGTH | `E` each | +| DOUBLE | `M` | +| F, COEFF, OUTER, SPECTATOR, WIDTH | `f,r,P,S,w` respectively | +| PRODUCT | `B` | +| HALF | `floor(M/2)` | +| DIGITS | `L` | + +B dominates f,r,S,w because `B=2Srw*2^(8f)` and all parameters are positive. +Thus DOUBLE never needs more than max(P,B), whether during Gamma acquisition +or suffix doubling. The encoder alternates source/HALF, and its quotient +can never exceed half its initial source length. Its digit stack is bounded +by L. These caps include all intermediate formats, not just final contents. + +The predecessor's nine reversal roles retain their proved windows: OUTPUT +and DTRACE cap V; prefix and row guides cap P and R; suffix guide and record +scratch cap B; doubling scratch caps max(P,R,B); descriptor trace caps the +largest descriptor length; and group scratch caps RB. Its private history +increment is at most `8V+E'+18`. + +Adding the fourteen producer intervals gives the explicit union bound + +`K_final <= K0 + 8V + 2E' + 2E + M + Sigma + B + floor(M/2) + L + 46`. + +This is below `K0+32(V+E+1)`. Public heads visit exactly HEADER's consumed +interval `[0,E]` and DATA's complete interval `[0,V]`; their input backing +and endpoints are separately part of the supplied public field storage. +All opaque exteriors are preserved by the guard/frontier invariants. + +Erasure leaves previous backing allocated. After successful reuse at fixed +origins, retain the per-role maximum cap reached and combine it with actual +initial history; do not replace that sum by equality with a maximum of +per-call sums. A coarse valid sequence bound is +`K_initial+32(V_max+E_max+1)`. A shorter call scans only its current bodies, +so its exact current-shape instruction bill is unaffected by old blank +capacity. If caller origins change, keep the per-role absolute unions and +pay caller transport corridors; there is no bound on arbitrary relocated +histories by current V alone. + +## 8. Evidence, novelty and remaining obligations + +The complete author receipt contains nine successful runs, totaling 702,464 +payload bits and 57,517,967 local transitions. This includes a full selected +nine-coordinate f=2 packet: 262,144 Gaussian coefficients and 524,288 bits. +It is complete coverage of that fixture, not a higher-width prefix. All +104 standalone encoder cases, through n=1024, satisfy the exact encoder +census. Whole-packet expected outputs use a separate source-coordinate XOR +formula at coefficient addresses, not the reversal algorithm. + +The checker inspects the actual three produced descriptor words before the +retained subgraph starts, verifies every embedded predecessor instruction, +and checks exact HEADER/DATA read, write and movement counts, all origins, +private retirement and opaque exteriors. The same physical Tape objects are +kept across a longer/shorter/regrowing chain. The shorter call has the exact +same instruction count as its fresh counterpart, with old history retained. + +Controls omit the real/imaginary factor, interchange collapsed prefix/suffix +descriptors while preserving total volume, and omit descriptor retirement. +The wrong-axis control runs past the descriptor check and fails the source +coordinate output oracle. Separate malformed-header, short-DATA and extra-DATA +cases reject with unchanged public contents. Source binding changes offset 1 +to bit 8 and requires the independent full-kernel comparison to reject it. +Independent review and its exact receipt are recorded separately when ready. + +The predecessor row-reversal theorem already proves the complete-record map, +its translation corollary and cost. Its caller supplied collapsed binary +lengths. The serial monomial predecessor already provides literal descriptor +iteration for a different view ABI, while its numerical service remains +structured control. This contribution is the actual runtime descriptor +producer and fixed-graph composition on the current supplied five-Gamma ABI, +with source-specific axis/order binding and complete costs. It does not +claim a new reversal, tensor identity, numeral-conversion method or faster +monomial tariff. + +The five-Gamma/raw entry packet is still supplied. Production of this ABI +from the selected caller, its actual physical owner selector, conversion from +other component encodings, the source matrix G, remaining monomial factors, +recursive children, global stock and analytic recovery remain separate. +In particular the source owner number 415 binds which native operation +contains the factor; it does not identify the physical DATA tape of a full +selected compiler invocation. The theorem's same-owner statement begins at +its explicit DATA entry owner. + +All five selected assumptions remain retained: `native_all_columns`, +`owned_erasure`, `compiler`, `precision_tape`, and `analytic_recovery`. +The complete selected kappa remains 0.00363005817. This is one removed local +descriptor-production premise, not an unconditional multiplication theorem. + +Credit the selected #7000 source and its retained Clifford/native contributors; +the exact source-binding and packed ABI in the published B3 package; the +published C3 literal-row-reversal program and its classical two-stack lineage; +the prior literal phase's Gamma/unary helpers; and #7349's literal machine. +The retained references preserve their notices. Independent AI review does +not constitute human or proof-kernel acceptance. diff --git a/research/native-translation-descriptor/README.md b/research/native-translation-descriptor/README.md new file mode 100644 index 0000000000..66cbb30c8a --- /dev/null +++ b/research/native-translation-descriptor/README.md @@ -0,0 +1,102 @@ +# Runtime descriptors for one actual selected native translation + +**No new kappa; one source-bound local interface is completed.** A fixed +25-tape, 1,878-location graph reads the five binary Gamma parameters of the +published native-phase packet ABI, produces the three canonical binary +lengths needed by literal whole-record reversal, executes that exact retained +graph, and retires its descriptors on successful return to the same DATA +owner. Runtime integers, multiplication callbacks and supplied collapsed +lengths are absent. + +The source is the right monomial of the actual selected MOVE at index 24472, +`["MOVE",415,3,99,false]`. Its offset 1 flips output coordinate zero **after +the source linear matrix**. In the packed `[P] x [2^f]^9 x [S]` order this +is the slow coordinate a0, so the produced lengths are + +`P'=P`, `R=2^f`, `B=2*S*r*w*2^(8f)`. + +The public five-Gamma packet itself is still supplied. The preceding matrix, +phase, central child, full native invocation and selected caller/owner/format +producer remain open. This does not execute the complete right monomial by +omitting its matrix. + +## Result and cost + +[PROOF.md](PROOF.md) proves the all-size descriptor and permutation theorem, +an exact complete instruction census, and the conservative envelopes + +`T <= 4096*(V+E+1)`, `K_final <= K0+32*(V+E+1)`, + +where `V=2P*2^(9f)*S*r*w` and E is the actual consumed Gamma-header length. +All unary expansion, head returns, copying, full staging, commit, descriptor +creation, cleanup and retained backing are included. E is O(log V), so the +complete local operation is O(V). No old higher-capacity tail is rescanned +on a shorter successful reuse. + +The new unary-to-binary bridge consumes unary n and emits a canonical binary +word with exact helper cost `19n-12popcount(n)+19ell(n)+7`. The algorithm is +classical; this package needs its literal implementation and full local bill. +The retained reversal algorithm and its translation identity are credited, +not presented as new. + +## Evidence and reproduction + +The complete author receipt contains nine successful packets, 702,464 payload +bits and 57,517,967 local transitions. It includes a **complete actual m=9, +f=2 packet**, not only a prefix, and a retained-object reuse chain. A separate +coefficient-address XOR oracle checks the source translation. The 104 unary +encoder cases verify the exact linear census. Three runtime mutations test a +missing factor, the wrong collapsed axis with unchanged volume, and unretired +descriptors. Malformed header and DATA-size controls preserve public data. + +```sh +python -I -W error -B research/native-translation-descriptor/bind_source.py +python -I -W error -B research/native-translation-descriptor/verify.py +python -B scripts/research_package.py --package research/native-translation-descriptor --check-only +``` + +Normal verification is read-only and compares the complete RESULT.json. +`verify.py --write` is the explicit receipt regeneration command. +`--quick` is only a development mode and cannot write an accepted receipt. +Expected markers are `PASS_SELECTED_TRANSLATION_SOURCE_BINDING` and +`PASS_NATIVE_TRANSLATION_DESCRIPTOR`. Source binding authenticates nine +retained files and all 512 basis states for the actual post-matrix offset. + +The separate lead-agent review in [independent/REVIEW.md](independent/REVIEW.md) +accepts the universal source, geometry, exact cost and history argument. Its +new dense CPU and separately derived exact census pass ten complete packets, +54,801,743 transitions, four malformed cases and three program mutants in +normal and optimized modes. All eleven source/provenance Git bindings were +independently authenticated. An executed replay after copying those review +files into this package produces the identical receipt. The frozen reviewer +files are unchanged; [VALIDATION.md](VALIDATION.md) distinguishes this evidence +from the author corpus. + +## Dependencies and limits + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +The packed source ABI and exact recipe are pinned to published B3 commit +`172f4535ce8dcff79f626410af845f757c1563be`; the reversal is pinned to published +C3 commit `7662d01d827c95d90032579c168cae78aa531f2f`. SOURCES.json records exact +commit:path, blob and SHA256 pins. The component imports only frozen local +copies. No predecessor or selected certificate is modified. + +Rejection preserves public values but need not retire private work or restore +heads. Physical blank entry windows and complete packet geometry are explicit +preconditions. Old backing remains allocated after success. Arbitrary input +relocation requires separately paid transport and absolute history unions. +The selected complete kappa and all five foundational assumptions remain +unchanged; no full native or multiplier claim follows. + +## Open next questions + +1. Lower the actual preceding binary matrix on the same packet and source + order, producing every needed descriptor and preserving full spectators. +2. Connect one actual selected caller occurrence to this supplied physical + owner/header format, including acquisition, conversion and transport. +3. Join the remaining native factors and recursive child with complete + lifecycle and common-grid/range admission. + +Prepared for @CubeJerry with substantial OpenAI assistance. Source, literal +phase, reversal and machine predecessors retain their credit in NOTICE.md. +Independent AI review is distinct from human or formal-kernel verification. diff --git a/research/native-translation-descriptor/RECIPE.json b/research/native-translation-descriptor/RECIPE.json new file mode 100644 index 0000000000..ea2bc6909e --- /dev/null +++ b/research/native-translation-descriptor/RECIPE.json @@ -0,0 +1,130 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "native_event_index": 24472, + "event": [ + "MOVE", + 415, + 3, + 99, + false + ], + "side": "right", + "rank": 1, + "recipe": { + "matrix_rows": [ + 239, + 129, + 130, + 132, + 136, + 16, + 160, + 192, + 256 + ], + "offset": 1, + "quadratic_rows": [ + 111, + 111, + 111, + 111, + 0, + 111, + 111, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 3, + 3, + 2, + 0 + ], + "phase": 1 + }, + "lowered_recipe": { + "rank": 1, + "left": { + "matrix_rows": [ + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 239, + 129, + 130, + 132, + 136, + 16, + 160, + 192, + 256 + ], + "offset": 1, + "quadratic_rows": [ + 111, + 111, + 111, + 111, + 0, + 111, + 111, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 3, + 3, + 2, + 0 + ], + "phase": 1 + } + }, + "catalogue_pairs_examined": 1, + "native_compressed_sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "native_canonical_sha256": "91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097" +} diff --git a/research/native-translation-descriptor/RELOCATED-RESULT.json b/research/native-translation-descriptor/RELOCATED-RESULT.json new file mode 100644 index 0000000000..e896e20e88 --- /dev/null +++ b/research/native-translation-descriptor/RELOCATED-RESULT.json @@ -0,0 +1 @@ +{"complete_cases": 10, "exact_helper_census": true, "includes_actual_dimension_f2": true, "locations": 1878, "malformed_controls": 4, "mutations": ["corrupted original-owner commit", "wrong collapsed prefix/row descriptors", "functionally correct extra instruction"], "private_history_span": 95353, "program_sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd", "status": "PASS_INDEPENDENT_TRANSLATION", "transitions": 54801743} diff --git a/research/native-translation-descriptor/RESULT.json b/research/native-translation-descriptor/RESULT.json new file mode 100644 index 0000000000..ee92f73634 --- /dev/null +++ b/research/native-translation-descriptor/RESULT.json @@ -0,0 +1,280 @@ +{ + "complete_runs": [ + { + "bits": 1024, + "descriptors": [ + "1", + "10", + "1000000000" + ], + "header_bits": 5, + "history_after": 6002, + "history_before": 114, + "input_sha256": "aa8d0fbf6475711a9ba9a33ee7397a826fd31b7aa76b627287bb6694a4779a2d", + "output_sha256": "32874a3876906bcc4d1cc7e52d3b622513767e184a8de016b34e79bc10716b0e", + "parameters": [ + 1, + 1, + 1, + 1, + 1 + ], + "producer_steps": 34246, + "steps": 116875 + }, + { + "bits": 36864, + "descriptors": [ + "11", + "10", + "1100000000000" + ], + "header_bits": 13, + "history_after": 119941, + "history_before": 114, + "input_sha256": "862157a268c83f78f2a055d901b8b6afc550fbd15e2cc5820e0f648b1d3e59de", + "output_sha256": "20abab3019dbfd7a1e0346453b384152ce512bf0e8ce3300d08d14c899daca88", + "parameters": [ + 1, + 2, + 3, + 2, + 3 + ], + "producer_steps": 405624, + "steps": 2692243 + }, + { + "bits": 12288, + "descriptors": [ + "110", + "10", + "10000000000" + ], + "header_bits": 11, + "history_after": 32383, + "history_before": 114, + "input_sha256": "c253d4623f2454034690eede6d1ad30cf306b23e47277aa20549fde6566ded04", + "output_sha256": "a0b6d9ce2d58af2a6d5fb4171f2fae3a34c451e01219348bee7ec49dadd786e5", + "parameters": [ + 1, + 1, + 6, + 1, + 2 + ], + "producer_steps": 68481, + "steps": 776417 + }, + { + "bits": 15360, + "descriptors": [ + "1", + "10", + "1111000000000" + ], + "header_bits": 11, + "history_after": 88451, + "history_before": 114, + "input_sha256": "04f4e0b61453db64e1f0a29086f79a1deaccc3f557c5936d69edcb169cf10632", + "output_sha256": "406dfb1ad80e008a042d3b316a03c30c452b136cf553d35711aac7c8b61ab614", + "parameters": [ + 1, + 5, + 1, + 3, + 1 + ], + "producer_steps": 506774, + "steps": 1736340 + }, + { + "bits": 17408, + "descriptors": [ + "1", + "10", + "10001000000000" + ], + "header_bits": 13, + "history_after": 100249, + "history_before": 114, + "input_sha256": "35e8879c8cf34244134ab76debc8312e59618068bbe12c05e3a2851786701a16", + "output_sha256": "16ad679f887bd7d2772ef235885053d10a5aceaca9081c6a5a584da96296f3be", + "parameters": [ + 1, + 1, + 1, + 1, + 17 + ], + "producer_steps": 574628, + "steps": 1968199 + }, + { + "bits": 524288, + "descriptors": [ + "1", + "100", + "100000000000000000" + ], + "header_bits": 7, + "history_after": 2293902, + "history_before": 114, + "input_sha256": "17142d0d2deef77c2525392f95c199a172f230f96d9eb72fd0b0a720b36d5d1d", + "output_sha256": "6a216732dc428a453dc4b73da26601fe6d1f5a09c1ab37dd9f203c3c515196b8", + "parameters": [ + 2, + 1, + 1, + 1, + 1 + ], + "producer_steps": 8651609, + "steps": 43517946 + } + ], + "complete_success_steps": 57517967, + "completed_payload_bits": 702464, + "encoder": { + "cases": 104, + "census_sha256": "ef31df26480bbf40905e61851ee0293732faf7b0e33839d43234b5b9662b6c89", + "maximum": 1024, + "sum_steps": 171972 + }, + "locations": 1878, + "negative_controls": [ + { + "diagnostic": "success expected: exact produced binary descriptors", + "mutation": "missing real/imaginary factor" + }, + { + "diagnostic": "source coordinate translation", + "mutation": "wrong prefix/suffix axis" + }, + { + "diagnostic": "all private bodies and guards retired", + "mutation": "unretired generated descriptors" + } + ], + "operations": { + "goto": 316, + "halt": 1, + "move": 947, + "read": 320, + "write": 294 + }, + "rejections": [ + { + "diagnostic": "invalid scanned symbol", + "fault": "header", + "parameters": [ + 1, + 1, + 1, + 1, + 1 + ], + "steps": 43 + }, + { + "diagnostic": "invalid scanned symbol", + "fault": "missing", + "parameters": [ + 1, + 1, + 1, + 1, + 1 + ], + "steps": 69413 + }, + { + "diagnostic": "invalid scanned symbol", + "fault": "extra", + "parameters": [ + 1, + 1, + 1, + 1, + 1 + ], + "steps": 88418 + } + ], + "retained_reversal_interval": [ + 1185, + 1709 + ], + "same_owner_reuse": [ + { + "bits": 36864, + "descriptors": [ + "11", + "10", + "1100000000000" + ], + "header_bits": 13, + "history_after": 119941, + "history_before": 114, + "input_sha256": "39a34287017f3eedb382fe6366c34eba3d0445b683765a1ccfd4e61cf0f89292", + "output_sha256": "3440bc460e1d19368fb49b4f7137c271d440dbd3c4dc04cf7168738bb2c94ba8", + "parameters": [ + 1, + 2, + 3, + 2, + 3 + ], + "producer_steps": 405624, + "steps": 2692243 + }, + { + "bits": 1024, + "descriptors": [ + "1", + "10", + "1000000000" + ], + "header_bits": 5, + "history_after": 119941, + "history_before": 119941, + "input_sha256": "43ef54fae5b61ee9e91bf7b1beb1be0377e8970b93231da6c868f98ca20a5887", + "output_sha256": "20b9452008ca5cf14b8ee59b3aea46bcfb269846e14204a1927d0ddc4cf3a538", + "parameters": [ + 1, + 1, + 1, + 1, + 1 + ], + "producer_steps": 34246, + "steps": 116875 + }, + { + "bits": 57344, + "descriptors": [ + "100", + "10", + "1110000000000" + ], + "header_bits": 15, + "history_after": 168589, + "history_before": 119941, + "input_sha256": "fd0aa26ee43152123995e7545b8f8ae6296670334157bb6d8e8435165e8b3014", + "output_sha256": "7175e9e10f022fb5c4569dc90030f37242380fd513671fe0fdbef10eba1a0571", + "parameters": [ + 1, + 1, + 4, + 2, + 7 + ], + "producer_steps": 473301, + "steps": 3900829 + } + ], + "scope": "One actual post-matrix translation on the supplied five-Gamma packed ABI; no full native body or new kappa.", + "status": "PASS_NATIVE_TRANSLATION_DESCRIPTOR", + "table_sha256": "7a439b8fd62e932fe148859d62a091f11ffac3118e41c60b3166ee7989916940", + "tapes": 25 +} diff --git a/research/native-translation-descriptor/SOURCES.json b/research/native-translation-descriptor/SOURCES.json new file mode 100644 index 0000000000..827783fb0d --- /dev/null +++ b/research/native-translation-descriptor/SOURCES.json @@ -0,0 +1,130 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "pin": "base_commit:docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "bytes": 82822 + }, + { + "path": "certificates/selected-result.json", + "pin": "base_commit:certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "bytes": 4803 + }, + { + "path": "research/literal-row-reversal/reverse.py", + "pin": "head:7662d01d827c95d90032579c168cae78aa531f2f:research/literal-row-reversal/reverse.py", + "usage": "provenance", + "local": "reference/reverse.py", + "local_path": "reference/reverse.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "git_blob": "60fce51dd8c3336e2bcf2873df254190e2203e14", + "sha256": "4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245", + "bytes": 6649 + }, + { + "path": "research/literal-row-reversal/PROOF.md", + "pin": "head:7662d01d827c95d90032579c168cae78aa531f2f:research/literal-row-reversal/PROOF.md", + "usage": "provenance", + "local": "reference/row-reversal-PROOF.md", + "local_path": "reference/row-reversal-PROOF.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "git_blob": "bfc768ec8d978a6e4f918e06fbbcf6da785746d6", + "sha256": "9dc3019f115098e1c14d41308b07266e48a6cd84f473e1205d472c640539f049", + "bytes": 17571 + }, + { + "path": "research/literal-row-reversal/inputs/controller_reference.py", + "pin": "head:7662d01d827c95d90032579c168cae78aa531f2f:research/literal-row-reversal/inputs/controller_reference.py", + "usage": "provenance", + "local": "reference/inputs/controller_reference.py", + "local_path": "reference/inputs/controller_reference.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72", + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "bytes": 5938 + }, + { + "path": "research/literal-native-quadratic-phase/phase.py", + "pin": "head:172f4535ce8dcff79f626410af845f757c1563be:research/literal-native-quadratic-phase/phase.py", + "usage": "provenance", + "local": "reference/native-phase.py", + "local_path": "reference/native-phase.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "git_blob": "d48978145821fc4a62d534bef2bef9449bda883a", + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "bytes": 11734 + }, + { + "path": "research/literal-native-quadratic-phase/PROOF.md", + "pin": "head:172f4535ce8dcff79f626410af845f757c1563be:research/literal-native-quadratic-phase/PROOF.md", + "usage": "provenance", + "local": "reference/native-phase-PROOF.md", + "local_path": "reference/native-phase-PROOF.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "git_blob": "46a43bf214d828aa972db66ad35e41b9cd07a964", + "sha256": "55f0a575f618bf467d0e25a25802053455d701cee1f23fb8811a671a1bd59ff3", + "bytes": 17878 + }, + { + "path": "research/literal-native-quadratic-phase/RECIPE.json", + "pin": "head:172f4535ce8dcff79f626410af845f757c1563be:research/literal-native-quadratic-phase/RECIPE.json", + "usage": "provenance", + "local": "RECIPE.json", + "local_path": "RECIPE.json", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "git_blob": "ea2bc6909e02d8aa61e170d65bb707da7279d0ab", + "sha256": "96fadb44c3316be93c6c02f50cd2c841a9541d67b98fd94fc47b73fa64dd404c", + "bytes": 1798 + }, + { + "path": "research/shared-wire-split-composition/data/final.json.gz", + "pin": "base_commit:research/shared-wire-split-composition/data/final.json.gz", + "usage": "provenance", + "local": "reference/selected-native.json.gz", + "local_path": "reference/selected-native.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "bytes": 350722 + }, + { + "path": "research/shared-wire-split-composition/frozen/clifford_exact.py", + "pin": "base_commit:research/shared-wire-split-composition/frozen/clifford_exact.py", + "usage": "provenance", + "local": "reference/clifford_exact.py", + "local_path": "reference/clifford_exact.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "bytes": 6824 + }, + { + "path": "research/shared-wire-split-composition/frozen/native_verify.py", + "pin": "base_commit:research/shared-wire-split-composition/frozen/native_verify.py", + "usage": "provenance", + "local": "reference/native_verify.py", + "local_path": "reference/native_verify.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "bytes": 12323 + } + ] +} diff --git a/research/native-translation-descriptor/TASK.json b/research/native-translation-descriptor/TASK.json new file mode 100644 index 0000000000..b6c27cce80 --- /dev/null +++ b/research/native-translation-descriptor/TASK.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "author": "Prepared for @CubeJerry", + "ai_assistance": "Substantial OpenAI assistance in proof, implementation, exact replay and writing; independent human/formal-kernel acceptance unclaimed.", + "scope_status": "changed", + "scope_change_reason": "The orchestrator isolated the literal descriptor-production join from B3 supplied raw packed native ABI to C3 complete-row reversal, for the actual current MOVE24472 right-factor offset1.", + "actual_scope": "Emit and verify one fixed 25-tape graph that reads Gamma(f,r,P,S,w), creates canonical binary P,2^f,2Srw*2^(8f), executes the exact retained reversal, and returns the same DATA owner with successful private retirement.", + "bottleneck_link": "One native_all_columns/precision_tape interface: eliminate supplied collapsed integers for one actual selected post-matrix translation.", + "stop_rule": "Stop after this one source-bound descriptor and numerical-free permutation join; retain supplied packed ABI, preceding matrix, other native fields and whole compiler.", + "evidence": "PROOF.md, literal graph, independent source-address oracle, exact encoder census, complete selected f=1/2 packets, source pins and semantic controls.", + "outcome": "partial", + "review_status": "Accepted independent universal/source/cost/history review; all eleven Git bindings authenticated; metadata gate and relocated independent replay passed.", + "track_seeds": [ + 40, + 85 + ], + "wave": "4b", + "open_questions": [ + { + "question": "Can the complete actual right affine matrix be joined on the same packed physical owner?", + "why_it_matters": "The offset is only one factor of the actual native monomial.", + "first_step": "Lower each source row addition and its actual spectator geometry to a literal complete field operation.", + "blocked_by": "An executable affine routing/descriptor schedule is not provided here." + }, + { + "question": "Can an actual native caller produce this five-Gamma packet ABI?", + "why_it_matters": "The local join takes the B3 physical entry layout as supplied.", + "first_step": "Bind one actual caller occurrence to physical owner origins, complete shape and header production.", + "blocked_by": "The selected physical caller producer remains an inherited compiler interface." + } + ], + "program_sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd", + "proof_sha256": "6b76d348203aed15cbc30d104c59571111ccf6cb7bb4592936e9170f736b68e0", + "branch": "research/native-translation-descriptor-be42-wave4b", + "next_action": "Parent commit-byte check and fork publication; no upstream PR submitted." +} diff --git a/research/native-translation-descriptor/VALIDATION.md b/research/native-translation-descriptor/VALIDATION.md new file mode 100644 index 0000000000..9080d24511 --- /dev/null +++ b/research/native-translation-descriptor/VALIDATION.md @@ -0,0 +1,83 @@ +# Executed verification and frozen scope + +The scientific implementation and accepted proof are frozen at: + +- `translate.py` SHA256 + `e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd`. +- `PROOF.md` SHA256 + `6b76d348203aed15cbc30d104c59571111ccf6cb7bb4592936e9170f736b68e0`. +- Generated graph SHA256 + `7a439b8fd62e932fe148859d62a091f11ffac3118e41c60b3166ee7989916940`. + +## Completed author checks + +`bind_source.py` passed under normal and optimized isolated Python; its +parsed receipts are identical. It authenticates nine retained local inputs, +recomputes the actual source lowering, checks all 512 monomial basis states +for the post-matrix coordinate-zero translation, and rejects a changed axis. +The retained compiler/interpreter are credited source engines, not newly +claimed independent implementations. + +The complete normal `verify.py --write` run passed. RESULT.json contains nine +complete successful executions, 702,464 payload bits and 57,517,967 local +transitions, including a full actual m=9,f=2 packet. It also records 104 +encoder exact-census cases, three malformed boundary controls, three semantic +program mutants and retained-object history tests. A separate development +`--quick` run omitted f=2 and is not treated as complete evidence or included +as a scientific receipt. + +The author uses the unchanged retained instruction interpreter with its own +source-coordinate expected-value formula. Rerunning that interpreter would +be regression testing, not an independent execution proof. The separately +written reviewer CPU supplies the independent runtime evidence below. + +## Completed independent review + +The lead independently inspected the all-size source/axis, Gamma, quotient, +geometric doubling, complete instruction census and history proof and accepted +its exact scope. All eleven commit:path source/provenance bindings were +retrieved and authenticated independently; the record is +`independent/SOURCE-BINDINGS.json`. + +The reviewer's dense byte-array CPU does not call the author's interpreter or +oracle. Its separately derived exact instruction count matches ten complete +packets and 54,801,743 transitions, including actual m=9,f=2. Four malformed +cases and three mutations are checked. A functionally correct added instruction +is rejected by the exact cost census. Grow/shrink/regrow retains the same +physical byte arrays and their historical spans. + +The reviewer executed both normal and optimized modes, producing identical +receipts. After copying all five frozen review artifacts unchanged into this +package, the author ran + +```sh +python -I -W error -B research/native-translation-descriptor/independent/check.py research/native-translation-descriptor/translate.py +``` + +That relocated receipt is byte-identical to both independent originals and +is retained as RELOCATED-RESULT.json. VERIFY.json registers the complete author +run, both source-binding modes and both independent runtime modes. + +## Package gates and limits + +The canonical `scripts/research_package.py --package +research/native-translation-descriptor --check-only` passes with +`PASS_PACKAGE_METADATA_AND_PINS`. It is a metadata/source-pin gate, not +mathematical acceptance. No full repository cold replay, unrelated historical +suite, hosted CI or proof-assistant acceptance is claimed. + +The full staged whitespace check reports the final blank line already present +in the exact retained C3 `reverse.py` and `PROOF.md`. Those two frozen files +remain byte-identical to their independently authenticated published sources. +The staged whitespace check excluding the retained reference directory passes; +new author files have no reported whitespace defects. No source was silently +normalized to suppress a provenance-preserving difference warning. + +All successful execution costs are local reads/writes/unit moves/jumps/halt; +verifier counters, fixture generation and expected values do not feed runtime +branches. The universal conclusions follow from the written loop invariants +and exact census. Complete finite f=2 coverage is not proof by extrapolation. + +The five-Gamma physical entry owner and layout remain supplied. The source +matrix, other native factors, full caller, owned allocation and multiplier +remain outside this result; no selected assumption or kappa is changed. diff --git a/research/native-translation-descriptor/VERIFY.json b/research/native-translation-descriptor/VERIFY.json new file mode 100644 index 0000000000..9f2717b7ca --- /dev/null +++ b/research/native-translation-descriptor/VERIFY.json @@ -0,0 +1,73 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "research/native-translation-descriptor/bind_source.py" + ], + "timeout_seconds": 90, + "checks": "Exact selected MOVE/offset/order binding and wrong-axis source control." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "research/native-translation-descriptor/verify.py" + ], + "timeout_seconds": 300, + "checks": "Complete descriptor/address/runtime/history, exact unary encoder census and three semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "research/native-translation-descriptor/bind_source.py" + ], + "timeout_seconds": 90, + "checks": "Exact selected MOVE/offset/order binding and wrong-axis source control." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "research/native-translation-descriptor/independent/check.py", + "research/native-translation-descriptor/translate.py" + ], + "timeout_seconds": 300, + "checks": "Independent dense CPU and separately derived exact complete census; ten complete packets including actual m=9 f=2, owner/history, four malformed cases, three mutants." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "research/native-translation-descriptor/independent/check.py", + "research/native-translation-descriptor/translate.py" + ], + "timeout_seconds": 300, + "checks": "Independent dense CPU and separately derived exact complete census; ten complete packets including actual m=9 f=2, owner/history, four malformed cases, three mutants." + } + ], + "inputs": [] +} diff --git a/research/native-translation-descriptor/bind_source.py b/research/native-translation-descriptor/bind_source.py new file mode 100644 index 0000000000..49da70ee65 --- /dev/null +++ b/research/native-translation-descriptor/bind_source.py @@ -0,0 +1,83 @@ +"""Bind the one actual post-matrix translation, without claiming a native body.""" +import copy +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + result = importlib.util.module_from_spec(spec) + sys.modules[name] = result + spec.loader.exec_module(result) + return result + + +def main(): + records = json.loads((HERE / 'SOURCES.json').read_text())['files'] + checked = 0 + for row in records: + if 'local_path' not in row: + continue + data = (HERE / row['local_path']).read_bytes() + need(hashlib.sha256(data).hexdigest() == row['sha256'], 'source SHA256 ' + row['local_path']) + need(hashlib.sha1(b'blob ' + str(len(data)).encode() + b'\0' + data).hexdigest() == row['git_blob'], + 'source Git blob ' + row['local_path']) + checked += 1 + C = module('translation_binding_compiler', HERE / 'reference/clifford_exact.py') + V = module('translation_binding_independent', HERE / 'reference/native_verify.py') + record = json.loads((HERE / 'RECIPE.json').read_text()) + raw = (HERE / 'reference/selected-native.json.gz').read_bytes() + word = json.loads(gzip.decompress(raw)) + need(hashlib.sha256(raw).hexdigest() == record['native_compressed_sha256'], 'selected compressed source') + need(hashlib.sha256(json.dumps(word, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + == record['native_canonical_sha256'], 'selected canonical JSON') + event = word['program'][24472] + need(event == ['MOVE', 415, 3, 99, False] == record['event'], 'exact current MOVE') + a = C.canonical_frame(9, tuple(word['frames'][3])) + b = C.canonical_frame(9, tuple(word['frames'][99])) + recipe, _ = C.lower_child(a.adjoint().then(b)) + recipe = json.loads(json.dumps(recipe)) + need(recipe == record['lowered_recipe'], 'unchanged full source recipe') + need(recipe['rank'] == 1 and recipe['right']['offset'] == 1, 'right offset is output bit zero') + target = V.adjoint(V.frame(word['frames'][3], 9)) + V.frame(word['frames'][99], 9) + V.equal(V.recipe(recipe), target, 'actual complete source decomposition') + right = recipe['right'] + no_translation = copy.deepcopy(right) + no_translation['offset'] = 0 + # Separate retained evaluator: the translation acts on the coordinate + # after the source matrix. Every complete basis coefficient is checked. + for x in range(512): + baseline, denominator = V.state(V.monomial(no_translation), x) + translated, denominator2 = V.state(V.monomial(right), x) + need(denominator == denominator2 and translated == {y ^ 1: v for y, v in baseline.items()}, + 'post-matrix coordinate-zero translation') + wrong = copy.deepcopy(recipe) + wrong['right']['offset'] = 1 << 8 + try: + V.equal(V.recipe(wrong), target, 'changed translation axis') + except ValueError: + pass + else: + raise ValueError('wrong-axis source control escaped') + result = dict(status='PASS_SELECTED_TRANSLATION_SOURCE_BINDING', local_source_files=checked, + native_event=24472, actual_native_owner=415, side='right', offset=1, + packed_coordinate=0, basis_states=512, + ordering='diagonal, linear matrix, translation, commuting global phase', + negative_controls=['changed translation from output bit0 to output bit8'], + scope='Source factor only; no implementation of the preceding matrix or whole native MOVE.') + print(json.dumps(result, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/native-translation-descriptor/independent/RESULT-OPTIMIZED.json b/research/native-translation-descriptor/independent/RESULT-OPTIMIZED.json new file mode 100644 index 0000000000..e896e20e88 --- /dev/null +++ b/research/native-translation-descriptor/independent/RESULT-OPTIMIZED.json @@ -0,0 +1 @@ +{"complete_cases": 10, "exact_helper_census": true, "includes_actual_dimension_f2": true, "locations": 1878, "malformed_controls": 4, "mutations": ["corrupted original-owner commit", "wrong collapsed prefix/row descriptors", "functionally correct extra instruction"], "private_history_span": 95353, "program_sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd", "status": "PASS_INDEPENDENT_TRANSLATION", "transitions": 54801743} diff --git a/research/native-translation-descriptor/independent/RESULT.json b/research/native-translation-descriptor/independent/RESULT.json new file mode 100644 index 0000000000..e896e20e88 --- /dev/null +++ b/research/native-translation-descriptor/independent/RESULT.json @@ -0,0 +1 @@ +{"complete_cases": 10, "exact_helper_census": true, "includes_actual_dimension_f2": true, "locations": 1878, "malformed_controls": 4, "mutations": ["corrupted original-owner commit", "wrong collapsed prefix/row descriptors", "functionally correct extra instruction"], "private_history_span": 95353, "program_sha256": "e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd", "status": "PASS_INDEPENDENT_TRANSLATION", "transitions": 54801743} diff --git a/research/native-translation-descriptor/independent/REVIEW.md b/research/native-translation-descriptor/independent/REVIEW.md new file mode 100644 index 0000000000..2126bdae88 --- /dev/null +++ b/research/native-translation-descriptor/independent/REVIEW.md @@ -0,0 +1,88 @@ +# Independent review of the selected native translation descriptor join + +**Disposition: ACCEPTED for the exact scoped component theorem.** No whole +native word, affine matrix, multiplier, foundational assumption discharge or +new kappa is accepted by this review. This is a separate lead-agent review +with independently written execution and arithmetic/count oracles, not human +or formal-kernel acceptance. + +Reviewed program SHA256: `e2750fef8c2b9c8019d67285df3ca0d04340cd241782c7845665b7de621ca3bd`. +Reviewed proof SHA256: `6b76d348203aed15cbc30d104c59571111ccf6cb7bb4592936e9170f736b68e0`. +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +## Universal source and interface review + +I authenticated all eleven Git commit:path inputs against their actual blob +bytes, sizes and SHA256; local copies match. SOURCE-BINDINGS.json records +these independent retrievals. I read the source binding and its retained +Clifford/independent evaluator boundary. MOVE24472's offset1 acts after the +linear matrix on coordinate zero. The five-Gamma packed ABI places that +coordinate first/slow, so the exact collapse is P, 2^f, +2Sr w 2^(8f), with complete real/imaginary records in the suffix. Applying +this after the phase alone would omit the actual intervening matrix; the +proof correctly excludes that composition. + +I checked the Gamma prefix induction, fixed eight-doubling loop, unary +quotient/parity conversion, and the inclusion of every retained reversal +instruction under an injective fixed tape/label map. The former halt becomes +one goto with equal local cost. Generated descriptors satisfy the predecessor +entry contract, and their guards are preserved opaque exterior cells to it. +The full private retirement and all public/head returns follow the stated +loop invariants, with clean owned work explicitly supplied at entry. + +## Independent complete census and runtime evidence + +The checker uses a new dense byte-array CPU; it does not execute the author's +Machine, check.py/verify.py or expected permutation. Its flat-address oracle +complements only the slow coordinate. I derived the complete additive helper +census directly from local reads, writes, moves and branches before matching +the author's recorded proof. In particular unary-to-binary costs +19n-12popcount(n)+19ell(n)+7, and Gamma acquisition before the common header +return costs 47n-30popcount(n)+33ell(n)-42. Summing all producer, retained +reversal and retirement regions gives complete_steps in check.py. This is +an exact count, not a fitted envelope. + +Normal and optimized execution agree: ten complete selected-dimension m=9 +packets, including an actual complete f=2 packet, 54,801,743 transitions, +four malformed controls, and three mutated programs. The mutations corrupt +original-owner installation, exchange collapsed prefix/row descriptors, and +insert a functionally correct extra instruction that the exact census rejects. +Grow/shrink/regrow calls retain the same byte arrays and monotonically +recorded historical intervals; the final observed private span is 95,353. +All successful private/exterior cells and heads are compared, and the exact +DATA read/write/move census is checked. Finite cases support but do not +replace the universal induction. + +The complete f=2 fixture has 524,288 payload bits; it is not a short prefix. +Larger f is established by the invariant and cost proof, not unperformed +finite execution. The helper-repeated construction is fixed independently of +f, P, r, S and w. + +## Costs, history and limits + +Every expanded unary guide is bounded by the supplied complete volume; B +is a suffix volume and E is logarithmic in V. The proved 4096(V+E+1) +envelope dominates the complete exact bill. The private-role caps include +all generated descriptors, doubling, quotient and digit storage as well as +the nine reversal roles. Their union gives the explicit historical bound in +the proof; erasure never releases old backing. Fixed-origin reuse must sum +per-role maxima, and arbitrary origin changes retain actual absolute unions +plus caller transport. The source-acquisition item in the census means reads +of the supplied encoded HEADER/DATA, not construction of a missing native +owner/layout producer. + +Initial ownership/blankness, the packed post-matrix input and entry heads are +premises. Malformed rejection preserves public data but supplies no cleanup +or retry theorem. The remaining matrix, source packing, phase/child caller, +full scaling and lifetime joins remain outside this result. + +Reproduce independently from a package copy: + +```sh +python -I -W error -B independent/check.py translate.py +python -I -W error -O -B independent/check.py translate.py +``` + +Prepared for @CubeJerry with substantial OpenAI assistance; credit the +unchanged source authors and the published B3/C3 components. The frozen +independent files should be retained unchanged when copied into the package. diff --git a/research/native-translation-descriptor/independent/SOURCE-BINDINGS.json b/research/native-translation-descriptor/independent/SOURCE-BINDINGS.json new file mode 100644 index 0000000000..ecd31547f1 --- /dev/null +++ b/research/native-translation-descriptor/independent/SOURCE-BINDINGS.json @@ -0,0 +1,94 @@ +{ + "status": "PASS_ROOT_EXACT_GIT_BINDINGS", + "files": 11, + "bindings": [ + { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "docs/research/agent-task-catalog.json", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "bytes": 82822, + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "copy_matches": false + }, + { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "certificates/selected-result.json", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "bytes": 4803, + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "copy_matches": false + }, + { + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "path": "research/literal-row-reversal/reverse.py", + "git_blob": "60fce51dd8c3336e2bcf2873df254190e2203e14", + "bytes": 6649, + "sha256": "4b516d85baf3303db809bc1174394009b1fc71a8f7d17fb6c729ec8bb6aba245", + "copy_matches": true + }, + { + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "path": "research/literal-row-reversal/PROOF.md", + "git_blob": "bfc768ec8d978a6e4f918e06fbbcf6da785746d6", + "bytes": 17571, + "sha256": "9dc3019f115098e1c14d41308b07266e48a6cd84f473e1205d472c640539f049", + "copy_matches": true + }, + { + "commit": "7662d01d827c95d90032579c168cae78aa531f2f", + "path": "research/literal-row-reversal/inputs/controller_reference.py", + "git_blob": "3ab6d0361f35038ffcdf0cf81a157f7a17b40e72", + "bytes": 5938, + "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73", + "copy_matches": true + }, + { + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/phase.py", + "git_blob": "d48978145821fc4a62d534bef2bef9449bda883a", + "bytes": 11734, + "sha256": "2be149aa1be504509bb480f85396f0be302082d638e81422f747daee5a3c1ce7", + "copy_matches": true + }, + { + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/PROOF.md", + "git_blob": "46a43bf214d828aa972db66ad35e41b9cd07a964", + "bytes": 17878, + "sha256": "55f0a575f618bf467d0e25a25802053455d701cee1f23fb8811a671a1bd59ff3", + "copy_matches": true + }, + { + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/RECIPE.json", + "git_blob": "ea2bc6909e02d8aa61e170d65bb707da7279d0ab", + "bytes": 1798, + "sha256": "96fadb44c3316be93c6c02f50cd2c841a9541d67b98fd94fc47b73fa64dd404c", + "copy_matches": true + }, + { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/shared-wire-split-composition/data/final.json.gz", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "bytes": 350722, + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "copy_matches": true + }, + { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/shared-wire-split-composition/frozen/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "copy_matches": true + }, + { + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "path": "research/shared-wire-split-composition/frozen/native_verify.py", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "bytes": 12323, + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "copy_matches": true + } + ] +} diff --git a/research/native-translation-descriptor/independent/check.py b/research/native-translation-descriptor/independent/check.py new file mode 100644 index 0000000000..005b9b4560 --- /dev/null +++ b/research/native-translation-descriptor/independent/check.py @@ -0,0 +1,162 @@ +"""Independent dense local CPU and complete descriptor/translation census. +Prepared for CubeJerry with OpenAI assistance. Apache-2.0. +The author interpreter, tests and expected-output routine are not used. +""" +from pathlib import Path +import hashlib, importlib.util, json, sys + +def need(x, message): + if not x: raise AssertionError(message) + +class Rejected(Exception): pass + +SYMBOLS = '_01|' + +class CPU: + def __init__(self, tapes, capacity): + self.origin = [19+2*t for t in range(tapes)] + self.head = self.origin.copy() + self.rows = [bytearray(capacity) for _ in range(tapes)] + for t,o in enumerate(self.origin): + self.rows[t][o-6:o-2] = bytes((2,1,3,2)) + self.rows[t][-5:-1] = bytes((1,2,3,1)) + self.low = self.origin.copy(); self.high = self.origin.copy() + + def supply(self, fields): + need(self.head==self.origin, 'clean successful reuse') + for t,word in enumerate(fields): + row=self.rows[t]; o=self.origin[t] + row[o:-6]=bytes(len(row)-6-o) + row[o:o+len(word)] = bytes(SYMBOLS.index(c) for c in word) + row[o+len(word)+1:o+len(word)+5] = bytes((1,2,3,1)) + self.before = [r[:] for r in self.rows] + + def run(self, code, limit=120_000_000): + compiled=[]; nt=len(self.rows) + for ins in code: + op,*args=ins + if op=='read': + t,branches=args; need(0<=thi[t]:hi[t]=h[t] + elif op==3:pc=t + else:return steps,counts + raise AssertionError('bounded observer budget exhausted') + +def gamma(n): + b=format(n,'b'); return '0'*(len(b)-1)+b + +def reversal_steps(P,R,B): + E=P.bit_length()+R.bit_length()+B.bit_length() + return 53*P*R*B+23*P*R+71*P+54*R+54*B+28*E-30*(P.bit_count()+R.bit_count()+B.bit_count())-8 + +def unary_binary_steps(n): + # Sum of successive quotient lengths is 2*n-popcount(n). + return 19*n-12*n.bit_count()+19*n.bit_length()+7 + +def gamma_steps(n): + return 47*n-30*n.bit_count()+33*n.bit_length()-42 + +def complete_steps(shape): + f,r,P,S,w=shape; B=2*S*r*w*(1<<(8*f)); R=1<>3)^(i>>9)).bit_count()&1) else '0' for i in range(V)) + fields=[''.join(map(gamma,shape)),data] + if bad=='short':fields[1]=data[:-1] + elif bad=='extra':fields[1]+='1' + elif bad=='header':fields[0]=fields[0][:-1]+'|' + elif bad=='symbol':fields[1]=data[:V//3]+'|'+data[V//3+1:] + if cpu is None:cpu=CPU(25,V+sum(shape)+1024) + cpu.supply(fields) + try:steps,counts=cpu.run(code) + except Rejected: + need(bad is not None,'unexpected rejection') + need(cpu.rows[:2]==cpu.before[:2],'failure public preservation') + return cpu,0 + need(bad is None,'missed malformed packet') + desired=[row[:] for row in cpu.before];o=cpu.origin[1] + # Flat address complement on only coordinate zero; no stack/chunk oracle. + for i in range(V): + source=(i//(Q*B))*(Q*B)+(Q-1-(i//B)%Q)*B+i%B + desired[1][o+i]=1+int(data[source]) + need(cpu.rows==desired,'exact selected translation and all private/exterior cells') + need(cpu.head==cpu.origin,'all successful heads') + need(steps==complete_steps(shape),'independent complete helper census') + need(counts[1]==[V+1,V,4*V],'retained same-owner DATA census') + return cpu,steps + +def main(): + path=Path(sys.argv[1]).resolve();spec=importlib.util.spec_from_file_location('translation_subject',path) + source_digest=hashlib.sha256(path.read_bytes()).hexdigest() + m=importlib.util.module_from_spec(spec);sys.modules[spec.name]=m;spec.loader.exec_module(m) + code,alphabet=m.compile_translation();need(set(alphabet)==set(SYMBOLS),'alphabet') + cases=steps=0 + for shape in ((1,1,1,1,1),(1,2,1,1,3),(1,1,2,2,2),(1,3,2,1,1),(1,1,1,3,5),(1,2,3,2,4),(2,1,1,1,1)): + _,n=check(code,shape);cases+=1;steps+=n + cpu=CPU(25,32000);ids=tuple(map(id,cpu.rows));history=0 + for shape in ((1,2,2,2,3),(1,1,1,1,1),(1,1,3,2,4)): + cpu,n=check(code,shape,cpu=cpu);cases+=1;steps+=n + need(tuple(map(id,cpu.rows))==ids,'one retained inventory') + new=sum(cpu.high[t]-cpu.low[t]+1 for t in range(2,25)) + need(new>=history,'monotone history');history=new + for bad in ('short','extra','header','symbol'):check(code,(1,1,1,1,2),bad=bad) + controls=[] + def detect(broken,label): + try:check(broken,(1,1,1,1,2)) + except (AssertionError,Rejected):controls.append(label) + else:raise AssertionError('undetected mutation: '+label) + broken=list(code) + for i,ins in enumerate(code): + if ins[:2]==('write',m.DATA) and ins[2]=='1':broken[i]=('write',m.DATA,'0') + detect(broken,'corrupted original-owner commit') + ports=m.REVERSE_PORTS;m.REVERSE_PORTS=(ports[1],ports[0],*ports[2:]) + wrong,_=m.compile_translation();m.REVERSE_PORTS=ports + detect(wrong,'wrong collapsed prefix/row descriptors') + broken=[] + for op,*args in code: + if op=='goto':args[0]+=1 + elif op=='read':args[1]={s:p+1 for s,p in args[1].items()} + broken.append((op,*args)) + detect([('goto',1)]+broken,'functionally correct extra instruction') + need(hashlib.sha256(path.read_bytes()).hexdigest()==source_digest,'source changed during review') + print(json.dumps({'status':'PASS_INDEPENDENT_TRANSLATION','program_sha256':source_digest, + 'locations':len(code),'complete_cases':cases,'includes_actual_dimension_f2':True,'transitions':steps, + 'malformed_controls':4,'mutations':controls,'private_history_span':history, + 'exact_helper_census':True},sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/native-translation-descriptor/reference/clifford_exact.py b/research/native-translation-descriptor/reference/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/native-translation-descriptor/reference/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<=budget: raise ValueError('finite verifier budget') + self.step() + return self + +def initial_tapes(width,origins=(0,0,0),ancestor=('0','1','t0','_','|','0')): + if width<1: raise ValueError('positive width') + u,c,p=origins + return [Tape({u-1:MARK,**{u+i:ONE for i in range(width)}},u),Tape({c-1:MARK},c), + Tape({p-1:MARK,**{p-2-i:s for i,s in enumerate(ancestor) if s!=BLANK}},p)] diff --git a/research/native-translation-descriptor/reference/native-phase-PROOF.md b/research/native-translation-descriptor/reference/native-phase-PROOF.md new file mode 100644 index 0000000000..46a43bf214 --- /dev/null +++ b/research/native-translation-descriptor/reference/native-phase-PROOF.md @@ -0,0 +1,336 @@ +# A literal quadratic phase for a current selected native recipe + +**Scoped enabling lemma; no new kappa.** Prepared for Jerry Chen / @CubeJerry +with substantial OpenAI assistance. Canonical base: +`e54523517d0f03e58352e647c403a5af3e525a57`. + +## 1. Exact claim, source and novelty + +Fix the nine-coordinate right monomial in the lowering of the actual retained +#7000 native `MOVE` at zero-based program index **24472**: +`["MOVE",415,3,99,false]`. Its before/after frames are 3 and 99 and its +proper-width central child has rank 1. The source is +`research/shared-wire-split-composition/data/final.json.gz`, compressed SHA256 +`2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883`, +with canonical uncompressed JSON SHA256 +`91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097`. +This is a current selected source event, not the historical event8814 fixture. + +`RECIPE.json` retains the whole exact lowering, including both monomial +recipes. The right factor has constant phase 1, linear coefficients +`(3,3,3,3,0,3,3,2,0)`, and symmetric quadratic row masks +`(111,111,111,111,0,111,111,0,0)`. Diagonal entries are already included in +the linear coefficients; only strictly upper matrix entries contribute +quadratic terms. With `J={0,1,2,3,5,6}`, its input-coordinate phase is + +\[ +q(x)=1+3\sum_{i\in J}x_i+2x_7+ + 2\sum_{i