diff --git a/research/selected-move-packed-grid-interface/INDEPENDENT-REVIEW.md b/research/selected-move-packed-grid-interface/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..43d30d91f2 --- /dev/null +++ b/research/selected-move-packed-grid-interface/INDEPENDENT-REVIEW.md @@ -0,0 +1,65 @@ +# Independent review of numerical admission and the packing boundary + +The lead agent reviewed the frozen worker proof against the exact selected +application, common-grid proof, old coded interface and literal leaf contract +bundled here. This is a separate mathematical and implementation review, not +independent human acceptance or a proof-kernel certificate. + +## Critical universal implication + +First define the ideal fields algebraically. Every completed central-axis +prefix multiplies each complete-root Clifford term by another Clifford, +leaving the exterior scalar and denominator/mass allowance unchanged. This +holds for every order of the distinct selected axes. The retained row theorem +therefore applies at every axis boundary without assuming that the physical +child already returns an exact answer. + +The rounding step holds for both parities of n. For n=2m the depth bound gives +178t<=m-1; for n=2m+1 it gives 178t<=m. Hence ceil(n/2)+178t<=n. Since +161t<=178t, the claimed magnitude allowance h+n+2 is conservative. Multiplying +by 2^(p+n) gives strict integer magnitude below 2^(p+h+2n+2)=2^(w-1). +Neither signed overflow endpoint can occur. + +A partially processed field need not be a Clifford image. That is not +required: the literal leaf reads a completed old-axis buffer and writes a +separate new-axis buffer. Each scalar result is an entry of the ideal next +prefix. Its four-term numerator fits w+2 bits by the inherited leaf proof; +integral half and signed fit follow from the ideal bound. The w+26 temporary +reserve suffices. Completed axis returns are the induction cuts. + +This proves numerical admission conditional on the root invariant, complete +spectators, distinct axes, retained scaling and a faithful paid packed +entrance. It supplies no physical conversion or dispatcher. + +## Interface checks and correction + +Old stored component width is b; root input magnitude uses h. Here +b=w=p+h+2n+3. These meanings were separated during review. The literal contract +requires exactly V bits followed by blank. The old three-bit codec and +delimiters have length ratio 3(b+1)/b>3 on the same logical coefficient set. +Thus unchanged DATA with a replacement header violates the cardinality +contract. Changing arithmetic width to force a length match changes the +coefficient interpretation. + +The address permutation is a bijection of every address bit. Its uniform +column reversal occurs in all nine slots and commutes with the tensor of +identical factors. Return owes the inverse permutation and codec conversion. +Neither is free. The payload lower bound is not an upper implementation bill. + +## Independent executed controls + +`independent_checks.py` uses four real-coordinate Gaussian rows without the +author's arithmetic helpers. Both axis orders send [1,0,0,1] to [0,1,1,0] +but have a half-integral first prefix. A separate pair has integral output6 +from legal width-three inputs, rejecting integrality as a substitute for +signed fit. Fifteen address round trips check column reversal and spectators; +nine exact size cases check the cardinality ratio. These finite controls +support, and do not replace, the universal written argument. + +The actual portable verifier is run against changed native-source and literal +contract bytes in disposable copies, in normal and optimized Python. Four +mutations must fail at source binding before acceptance. The registered +package command runs the author and review controls. No heavy literal f=2 +machine replay, complete supplier replay or hosted CI acceptance is claimed. + +All five foundational assumptions remain. No new kappa. diff --git a/research/selected-move-packed-grid-interface/LICENSE b/research/selected-move-packed-grid-interface/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/selected-move-packed-grid-interface/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/selected-move-packed-grid-interface/NOTICE b/research/selected-move-packed-grid-interface/NOTICE new file mode 100644 index 0000000000..dcfe84cbdd --- /dev/null +++ b/research/selected-move-packed-grid-interface/NOTICE @@ -0,0 +1,28 @@ +Selected MOVE packed-grid numerical interface +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Copyright 2026. Licensed under Apache License 2.0; see LICENSE. + +This package applies, rather than reclaims, the complete-root Clifford, +common-grid and depth invariants, selected source lowering and literal-leaf +contracts of its predecessors. The bundled inputs retain exact source bytes. + +Retain the notices in inputs/notices/: +- selected-NOTICE: selected shared-native construction, frame/compiler, + helper split and caller predecessors. +- common-grid-NOTICE.md: odd scalar precision, complete-root Clifford and + compiler-depth lineage. +- old-coded-NOTICE.md: current coded Gaussian MOVE/codec and physical + monomial/positive leaf predecessors. +- literal-leaf-NOTICE.md: the pending literal positive C provider and its + numerical, layout and machine predecessors. + +The source includes the retained exact Clifford compiler. Its source hash, +Git blob and canonical path are listed in SOURCES.json; source authors keep +their original credit. The Gaussian row kernel follows Jose Manuel's #3091 +lineage; common-root and odd clearing follow the authors identified in the +retained precision proof. Classical tensor, Clifford norm and fixed-rational +arguments are not claimed as new. + +No physical full bridge, whole MOVE, nonleaf dispatcher, foundational +assumption discharge, independent human/formal acceptance or new kappa is +asserted. All original selected five assumptions remain explicit. diff --git a/research/selected-move-packed-grid-interface/PR-DESCRIPTION.md b/research/selected-move-packed-grid-interface/PR-DESCRIPTION.md new file mode 100644 index 0000000000..580b2b969f --- /dev/null +++ b/research/selected-move-packed-grid-interface/PR-DESCRIPTION.md @@ -0,0 +1,54 @@ +# Derive every-axis numerical admission for selected MOVE24472 and identify its necessary paid payload bridge + +The literal positive C provider requires every tensor-axis prefix to be +integral and signed-representable. An integral final image does not establish +that premise. This package applies the selected complete-root precision +invariant to exact #7000 MOVE24472, owner415, frames3 to99: every Gaussian +prefix is another Clifford on the same complete root, with unchanged exterior +debt. Hence the retained common format admits every executed axis after a +faithful paid packed entrance, retaining the full local time/history bill. + +The remaining bridge is stated explicitly. Writing b for old component width, distinct from root magnitude h, old +coded and new packed payloads +have length ratio3(b+1)/b>3, so replacing only the header on unchanged DATA +fails the literal provider's cardinality guard. A correct codec/strided bridge, +complete factor join, owner/stock return and fast nonleaf tariff remain open. +All five global assumptions and the selected conditional kappa are unchanged. + +The small self-contained standard-library verifier authenticates exact local +source exports, regenerates the actual recipe, and checks exact sparse +Gaussian controls in normal and optimized Python. The endpoint-only control +has integral full native entrance and endpoint but a half-integral first +central axis; the guarded control admits all prefixes. Complete spectator +permutations and exact payload sizes are also checked. These are scoped +algebraic/numerical controls, not a new full physical trace or formal proof. + +The registered normal/-O replay is read-only and portable, with no network, +foreign Git object, absolute workspace path or saved old research receipt. +Source-bound tensor, precision, physical-leaf, codec and compiler predecessors +retain exact notices. Prepared for Jerry Chen / CubeJerry with substantial +OpenAI assistance. Independent proof review is recorded in INDEPENDENT-REVIEW.md; committed execution checks are in VALIDATION.json. + +## Exact pins, novelty and predecessor credit + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Selected native SHA256: `2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883`. +Actual regenerated recipe SHA256: `064d51e9c347dbcfd9e172e5b5cab75f96912e0eb9a6f9537d53540cf4780ca9`. +Literal leaf #7429 is pinned at CubeJerry commit `1a555e469b89af70d309bc966f8f813ac11dc887`. Source paths, Git blobs, SHA256 values and exact notices are retained in SOURCES.json and inputs/. + +#6890 already supplies older source-specific algebraic tensor closure; the selected #7000 application and common-grid lineage supply the retained root invariant. #6974 supplies an older coded protected-MOVE join. #7426, #7428, #7429 and #7430 supply distinct literal factors/interfaces. This package adds the source-bound numerical implication and the explicit codec/cardinality boundary. It does not claim a new Kronecker identity, Clifford row theorem or literal machine construction. + +The full inherited leaf bills remain T<=65536(fV+E+1), K_after<=K_entry+64(V+E+1), counting all29 owners. No acquisition, codec conversion, complete factor join, inverse return or fast nonleaf dispatch cost is silently set to zero. **No new kappa**: the complete selected conditional value remains0.00363005817, with all five foundational assumptions retained. + +## Reproduction and review + +```sh +python3 -B scripts/research_package.py --package research/selected-move-packed-grid-interface +python3 -B scripts/check_research_commit.py --package research/selected-move-packed-grid-interface --check-modes +``` + +Expected markers: `PASS_SELECTED_MOVE_PACKED_GRID_INTERFACE`, `PASS_INDEPENDENT_SELECTED_GRID_CONTROLS`, and `PASS_REGISTERED_RESEARCH_PACKAGE`. All ten exact source/notice inputs are declared. Independent real-coordinate arithmetic checks both Gaussian axis orders and a signed-width counterexample. Fifteen complete address round trips check spectator preservation and column reversal. Four source-byte mutations execute the actual verifier in normal and optimized Python and must fail at source binding before acceptance. Registered and read-only Git-free export checks are recorded in VALIDATION.json. + +INDEPENDENT-REVIEW.md checks the universal rounding, partial-buffer induction, source contracts and column order. Finite controls do not prove the universal result by enumeration. No heavy literal f=2 machine run, complete selected supplier replay, hosted CI or proof-kernel acceptance is claimed. + +Prepared for **Jerry Chen / @CubeJerry** with substantial **OpenAI assistance** in research, separate checks, adversarial review and packaging. Every predecessor retains its authorship and notice. Separate agent review is not independent human acceptance. Only this isolated package is added; no selected certificate is changed. diff --git a/research/selected-move-packed-grid-interface/PROOF.md b/research/selected-move-packed-grid-interface/PROOF.md new file mode 100644 index 0000000000..a9c224b2f9 --- /dev/null +++ b/research/selected-move-packed-grid-interface/PROOF.md @@ -0,0 +1,246 @@ +# Selected common-grid admission to one literal all-column Gaussian leaf + +This is a scoped enabling implication and interface reduction for selected +#7000, not a discharge of native_all_columns. The canonical base is +e54523517d0f03e58352e647c403a5af3e525a57; exact byte, Git-blob and SHA256 +bindings are in SOURCES.json. The selected +application review SHA256 is +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055. + +The chosen actual native event is zero-based 24472, +`["MOVE",415,3,99,false]`, in selected `data/final.json.gz`, SHA256 +2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883. +Its exact lowered recipe has rank 1, right constant phase 1 and left constant +phase 0. The complete record SHA256 is +064d51e9c347dbcfd9e172e5b5cab75f96912e0eb9a6f9537d53540cf4780ca9. +The literal positive leaf in #7429 is pinned at CubeJerry commit +1a555e469b89af70d309bc966f8f813ac11dc887. Its proof and source are copied +at exact Git bytes, including their original line endings. + +## 1. Premise and conclusion + +Write n for the number of bits in the complete selected root factor. This +is distinct from an array's vector-space dimension in the block theorem. +Assume the selected root/precision invariant at the entrance of this MOVE: + +* Each original real/imaginary input component is on grid 2^-p and has + absolute value strictly below 2^h, with p,h>=0. +* Every ideal current field is a finite sum c U x on that same complete + n-bit factor. U is a Gaussian-dyadic Clifford; all genuine spectators + and external rows remain complete. Exterior coefficients have denominator + height at most 178t and total Gaussian coefficient mass at most + 2*2^(161t). The selected depth condition is 356t3. + +This immediately refutes a header-only drop-in adapter on the unchanged old +physical DATA word. The literal leaf's clone expects exactly V_packed bits +and a blank; the old word still has physical bits there. Its cardinality +guard rejects before numerical execution. Changing the descriptor width to +make lengths match would change the coefficient arithmetic interpretation. +This is a concrete interface obstruction, not a counterexample to the +selected conditional theorem or to a correctly implemented bridge. + +A correct bridge owes physical source access, complete codec conversion, +component orientation, all selected and spectator address transport, the +six Gamma values with actual cutoff, one common quantum and width, genuinely +separate bank ownership, head returns and inverse conversion to the original +owner. In the explicit separate packed-bank model it has worst-case payload +work at least Omega(V_old+V_packed): arbitrary last input coefficients force +the old source head to visit its far data end, and the new full field has +to be materialized. In particular E-only descriptor work cannot pay it. +This lower bound does not preclude an admissible linear or fast ordinary +bridge; no such complete upper tariff is proved here. Reentry retains the +absolute per-role history union, not merely current field sizes. + +## 5. Exact premise-to-conclusion map and remaining gap + +| Premise/source | What it supplies | What it does not supply | +| --- | --- | --- | +| Selected #7000 application, sections 2 and 5 | Full normalized source products, exterior scalars, phase, complete root/spectators, exact-grid/depth specialization | Literal occurrence packing and physical tariff | +| Earlier #6890 | Already proved source-specific algebraic tensor/caller closure for older #6030 | A new #7000 physical provider | +| #6974 | Protected raw #6030 current_local event 9896 join under its 23-field format and direct-leaf premises | New selected source token, enclosing placement, nonleaf service | +| #7426/#7428/#7430 | Literal phase, post-matrix translation descriptor, and both binary linear factors for #7000 event 24472 | Their complete same-occurrence join and old-format acquisition | +| #7429 plus section 2 above | Exact literal positive C on every column; common-root precision forces every-axis admission on its supplied packed ABI | Codec/strided packing, whole MOVE failure retirement, fast nonleaf dispatch | + +The still-missing uniform interface is a selected-occurrence paid physical +bridge and dispatcher from actual retained field/owner/descriptor state to +that packed ABI and back, with complete monomial/child composition, complete +stock and recursive return. Algebraic A tensor identity normalization is +already settled conditional on exact primitive actions; it cannot replace +this bridge. No operator may be silently evaluated on a projected role or +partial spectator view. A literal final-image calculation alone cannot +establish the numerical domain either, as the exact control below shows. + +The enabling implication above removes a separate per-axis numerical +precondition once the selected complete-root invariant and faithful bridge +are supplied. It leaves physical all-column admission, owned erasure, +compiler closure, precision/tape implementation and analytic recovery +explicit. The selected conditional kappa remains 0.00363005817. + +## 6. Bounded evidence and controls + +`verify.py` authenticates the exact selected source exports and remote Git +blobs, regenerates the actual event 24472 recipe, and executes exact sparse +Gaussian-rational controls. Starting after the actual right monomial with +the f=2 fibre [1,0,0,1], it constructs the exact pre-right native entrance. +Both complete native entrance and complete native endpoint are integral, +while the first central Gaussian prefix is half-integral. This rejects the +weaker endpoint-only provider premise. It is not asserted reachable from +the selected guarded root pipeline. Multiplying the full native entrance +by 2^18 under the explicit n=18,p=0,h=1,F=18,w=40 control admits both prefixes. +The script also checks complete spectator-preserving packing permutations +and exact volumes for three legal strided geometries. A 5,000-value integer +scan corroborates the depth inequalities; their universal proof is section2. +No heavy literal f=2 packet or historical native catalogue was rerun. + +The remote overlap check covered exact #7421 through #7430 metadata and +targeted all-column, native dispatch, coded-remap and MOVE24472 PR queries. +#7462 shortens the left linear word, and #7503 proves a phase-observation +lower bound; neither claims the remaining bridge. Metadata coverage is +recorded in README.md and is not a proof that no unsearched work exists. +All predecessors keep their authorship; no already settled Kronecker or +Clifford-row lemma is claimed as new. Prepared for Jerry Chen / CubeJerry +with substantial OpenAI assistance; no independent human or proof-kernel +acceptance is claimed. diff --git a/research/selected-move-packed-grid-interface/README.md b/research/selected-move-packed-grid-interface/README.md new file mode 100644 index 0000000000..add96c0d50 --- /dev/null +++ b/research/selected-move-packed-grid-interface/README.md @@ -0,0 +1,123 @@ +# Admit every numerical axis of the selected MOVE24472 literal Gaussian leaf from the complete-root grid and expose its required payload bridge + +**Scoped enabling implication and interface reduction. No new kappa.** +The selected complete-root precision invariant implies every numerical +prefix guard of the literal positive C leaf in #7429 after a faithful, +fully paid packed entrance. Final-image integrality alone does not suffice. +The exact selected source is #7000 at canonical +`e54523517d0f03e58352e647c403a5af3e525a57`, native event 24472 +`["MOVE",415,3,99,false]`. + +For a complete root of n address bits, the retained invariant has exterior +denominator debt 178t, coefficient-mass debt 161t and 356t3. + +It gathers selected slots by a complete address permutation, preserves all +spectators, changes the codec/component orientation and restores the inverse +on return. Merely replacing the header on unchanged old DATA fails the +literal leaf's exact cardinality check. A correct bridge can still be +possible; no fast upper tariff is proved here. [PROOF.md](PROOF.md) states +the minimal bridge and complete acquisition/factor/return bill. + +Normalized scalar tensor identities do not supply a physical layout or +dispatcher. All five assumptions remain: native_all_columns, owned_erasure, +compiler, precision_tape and analytic_recovery. The selected conditional +kappa remains 0.00363005817. No whole MOVE, physical bridge, accelerated +nonleaf dispatcher or multiplier is implemented. + +## Portable read-only reproduction + +Python 3.12 and its standard library suffice. These commands need only this +directory, with no Git, network, repository checkout or absolute path: + +```sh +python3 -I -B verify.py +python3 -I -O -B verify.py +``` + +Both print identical deterministic JSON with +`PASS_SELECTED_MOVE_PACKED_GRID_INTERFACE`. The verifier writes no files, +authenticates bundled source hashes, compiles source bytes without package +bytecode caches, regenerates the exact selected recipe, and executes sparse +Gaussian-rational controls. Its complete recipe SHA256 is +`064d51e9c347dbcfd9e172e5b5cab75f96912e0eb9a6f9537d53540cf4780ca9`. + +The actual-source control has integral full native entrance and endpoint +but a half-integral first central axis. It rejects endpoint-only provider +admission, not the selected guarded root pipeline. A guarded n=18,F=18,w=40 +control admits every prefix. Three geometry cases check complete spectator +permutations and exact lengths without materializing their huge payloads. +A 5,000-value scan corroborates the integer rounding; the universal result +rests on the written proof. No heavy predecessor replay is claimed. + +Registered repository commands are: + +```sh +python3 -B scripts/research_package.py --package research/selected-move-packed-grid-interface --check-only +python3 -B scripts/research_package.py --package research/selected-move-packed-grid-interface +``` + +`SOURCES.json` separates canonical historical provenance from bundled runtime +inputs. The pending #7429 contract and notice are retained at exact published +Git bytes; its foreign commit is not needed at runtime. Its entire physical +implementation is not rerun or silently admitted here. + +## Predecessors and scope + +The selected application and older #6890 already address their source-bound +all-column algebra. #6974 joins an older raw #6030 occurrence. Exact #7421 +through #7430 metadata and targeted successors were checked on 2026-11-13. +#7426, #7428, #7429 and #7430 provide the phase, translation, leaf and linear +factors while leaving their complete occurrence bridge open. #7462 shortens +the left linear word; #7503 studies phase observations. This is bounded +coverage, not archive-wide novelty certification. + +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Source lowering, precision, tensor phase, physical-leaf and compiler authors +retain their credit and exact notices in inputs/notices/. The new contribution +is the numerical premise-to-provider application and complete-format reduction. +Author checks are not independent human or proof-kernel acceptance. + +## Open next questions + +1. Build the actual selected-occurrence payload/six-Gamma bridge from the + permutation in PROOF section 4, charging codec conversion, transport, + original-owner return and absolute historical backing. +2. Compose all literal factors on a protected occurrence and supply required + failure retirement. Disjoint private ownership and complete returns are + still to be joined; correct individual factors are insufficient. +3. Admit the producer's cutoff, stock and accelerated nonleaf tariff. The + direct-leaf O(fV) bill does not establish that rate or remove the other + foundations. TASK.json records first steps and blockers. + +## Independent review + +The registered command also runs the separate real-coordinate arithmetic, +width, packing and actual source-mutation checks in independent_checks.py. +INDEPENDENT-REVIEW.md records the universal proof review and its limits. diff --git a/research/selected-move-packed-grid-interface/SOURCES.json b/research/selected-move-packed-grid-interface/SOURCES.json new file mode 100644 index 0000000000..3a7cf22ff6 --- /dev/null +++ b/research/selected-move-packed-grid-interface/SOURCES.json @@ -0,0 +1,160 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + }, + { + "path": "research/current-coded-atomic-move/NOTICE.md", + "usage": "provenance", + "git_blob": "9ec74ef6051fcd53f11b569b232b639261daf81f", + "sha256": "db63191f6fbf8d5b3b577ba7afb07c15bd0a89a7446626217cadf401acc4ffde" + }, + { + "path": "research/current-coded-atomic-move/PROOF.md", + "usage": "provenance", + "git_blob": "4303bc7de83739a7c9294436dd70eab278f86aca", + "sha256": "e39f25a054aab42b0c866f09131ee2ac752e77f1fcd1bfe2269bd04798203857" + }, + { + "path": "research/odd-native-common-grid/NOTICE.md", + "usage": "provenance", + "git_blob": "51fa9d494c79e6c5a113bc09f2852bfacece6b52", + "sha256": "3a3d353a0fb41ce5688c8ae2bcc82306f4499ffc19f0c44eeaa85679f895a5d3" + }, + { + "path": "research/odd-native-common-grid/PROOF.md", + "usage": "provenance", + "git_blob": "edea8e98a082f4513aedbfb7bd55f32063e32b38", + "sha256": "b710cc953163ebe282fce7cf0a426744c155a0d5acbfb9bf7d67e81195b66a1e" + }, + { + "path": "research/shared-wire-split-composition/NOTICE", + "usage": "provenance", + "git_blob": "a3687d65a00794277cdaad37558d24008cbc37f5", + "sha256": "da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249" + }, + { + "path": "research/shared-wire-split-composition/data/final.json.gz", + "usage": "provenance", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883" + }, + { + "path": "research/shared-wire-split-composition/frozen/clifford_exact.py", + "usage": "provenance", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + ], + "bundled_inputs": [ + { + "path": "inputs/WORD.json.gz", + "source_path": "research/shared-wire-split-composition/data/final.json.gz", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "bytes": 350722 + }, + { + "path": "inputs/clifford_exact.py", + "source_path": "research/shared-wire-split-composition/frozen/clifford_exact.py", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "bytes": 6824 + }, + { + "path": "inputs/selected-application.md", + "source_path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "bytes": 25533 + }, + { + "path": "inputs/common-grid.md", + "source_path": "research/odd-native-common-grid/PROOF.md", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "edea8e98a082f4513aedbfb7bd55f32063e32b38", + "sha256": "b710cc953163ebe282fce7cf0a426744c155a0d5acbfb9bf7d67e81195b66a1e", + "bytes": 12720 + }, + { + "path": "inputs/old-coded-move-contract.md", + "source_path": "research/current-coded-atomic-move/PROOF.md", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "4303bc7de83739a7c9294436dd70eab278f86aca", + "sha256": "e39f25a054aab42b0c866f09131ee2ac752e77f1fcd1bfe2269bd04798203857", + "bytes": 21919 + }, + { + "path": "inputs/notices/selected-NOTICE", + "source_path": "research/shared-wire-split-composition/NOTICE", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "a3687d65a00794277cdaad37558d24008cbc37f5", + "sha256": "da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249", + "bytes": 893 + }, + { + "path": "inputs/notices/common-grid-NOTICE.md", + "source_path": "research/odd-native-common-grid/NOTICE.md", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "51fa9d494c79e6c5a113bc09f2852bfacece6b52", + "sha256": "3a3d353a0fb41ce5688c8ae2bcc82306f4499ffc19f0c44eeaa85679f895a5d3", + "bytes": 1078 + }, + { + "path": "inputs/notices/old-coded-NOTICE.md", + "source_path": "research/current-coded-atomic-move/NOTICE.md", + "source_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "repository": "CrocSwap/integer-mult-bounds", + "git_blob": "9ec74ef6051fcd53f11b569b232b639261daf81f", + "sha256": "db63191f6fbf8d5b3b577ba7afb07c15bd0a89a7446626217cadf401acc4ffde", + "bytes": 1468 + }, + { + "path": "inputs/literal-leaf-contract.md", + "source_path": "research/literal-positive-c-leaf/PROOF.md", + "source_commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "repository": "CubeJerry/integer-mult-bounds", + "git_blob": "a8ae6684d55e3a1aaa7f2aa432f15ae9db580b11", + "sha256": "c99157c3c43ae490b858cdbce04d85f3661ca5d9752770506d18ec4876c4ed6c", + "bytes": 16608 + }, + { + "path": "inputs/notices/literal-leaf-NOTICE.md", + "source_path": "research/literal-positive-c-leaf/NOTICE.md", + "source_commit": "1a555e469b89af70d309bc966f8f813ac11dc887", + "repository": "CubeJerry/integer-mult-bounds", + "git_blob": "71c5f6dae2c799ce5d76c544e98d1ee7c52ef76c", + "sha256": "773921ac301cf7e37de97ed8a0066e6bbb69ec1150cc2b5f74a12cb20103f3cf", + "bytes": 1900 + } + ], + "external_source_policy": "External pending proof contract is retained at exact bytes and authenticated by Git blob and SHA256 in the standalone verifier. No network or foreign Git object is required at runtime. Canonical rows are historical provenance, not repository-relative runtime inputs.", + "author_evidence": "Frozen wave53 source-bound audit; packaging preserves its science. No predecessor full replay is claimed." +} diff --git a/research/selected-move-packed-grid-interface/TASK.json b/research/selected-move-packed-grid-interface/TASK.json new file mode 100644 index 0000000000..2328675658 --- /dev/null +++ b/research/selected-move-packed-grid-interface/TASK.json @@ -0,0 +1,95 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "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" + } + ] + }, + "scope_status": "refined", + "actual_scope": "For exact selected #7000 MOVE24472, derive the every-axis numerical domain of literal positive leaf #7429 from the retained complete-root common-grid/depth invariant after a faithful paid packed bridge; specify the complete bridge contract and disprove header-only reuse by exact payload lengths.", + "scope_change_reason": "The assigned foundational audit narrows the broad all-column question to one source-bound numerical provider seam. Algebraic tensor closure is already covered; physical packing, dispatcher/nonleaf work and all five global assumptions remain.", + "bottleneck_link": "A literal leaf requires every executed prefix integral and signed-representable. The selected invariant supplies that premise, leaving the actual paid codec/strided occurrence bridge as the uncovered interface.", + "budget_minutes": 30, + "stop_rule": "Freeze the quantified numerical implication, exact source controls, complete inherited local bill and precise bridge obligations. Do not build a full physical bridge or claim foundation removal.", + "outcome": "partial", + "evidence": "Exact selected source/recipe pins; exact rational endpoint-only and guarded-prefix controls; complete spectator packing/length checks; normal and optimized read-only replay. Universal argument is in PROOF.md; no heavy historical replay.", + "author": "Jerry Chen / CubeJerry", + "ai_assistance": "Substantial OpenAI assistance in source audit, mathematical application, implementation, controls and writing. Independent human/formal acceptance is not claimed.", + "open_questions": [ + { + "question": "Construct one actual selected-occurrence old-codec/strided payload and six-Gamma bridge.", + "why_it_matters": "The supplied packed literal format has a different cardinality and orientation; metadata alone does not transport data.", + "first_step": "Implement the full spectator-preserving permutation and dimensions in PROOF section4 and prove original-owner inverse return with a complete bill.", + "blocked_by": "Literal codec conversion, paid transport, descriptor generation and historical ownership/backing." + }, + { + "question": "Compose all selected literal factors with complete success and required failure return.", + "why_it_matters": "Separate phase, linear, translation and C kernels do not establish a complete occurrence.", + "first_step": "Join the pinned contracts on one protected shadow owner with disjoint private cohorts and explicit head-return/retirement bounds.", + "blocked_by": "Complete physical bridge and a priced failure-retirement continuation where required." + }, + { + "question": "Admit the producer cutoff and nonleaf service at the selected recurrence.", + "why_it_matters": "A direct O(fV) leaf and a numerical grid do not imply an accelerated native dispatcher.", + "first_step": "Bind the actual leaf dispatch cutoff, full suspended stock and recursive return bill to the unchanged selected recurrence.", + "blocked_by": "Producer/caller, owned, compiler, physical precision/tape and ordinary-supplier interfaces." + } + ] +} diff --git a/research/selected-move-packed-grid-interface/VALIDATION.json b/research/selected-move-packed-grid-interface/VALIDATION.json new file mode 100644 index 0000000000..380aea0504 --- /dev/null +++ b/research/selected-move-packed-grid-interface/VALIDATION.json @@ -0,0 +1,294 @@ +{ + "independent_controls": { + "cardinality_cases": 9, + "exact_axis_orders": 2, + "packing_roundtrips": 15, + "scope": "Independent finite controls, not a literal machine replay or universal proof.", + "signed_width_rejection": true, + "source_mutations": [ + { + "optimized": false, + "rejected_at_source_binding": true, + "source": "inputs/WORD.json.gz" + }, + { + "optimized": true, + "rejected_at_source_binding": true, + "source": "inputs/WORD.json.gz" + }, + { + "optimized": false, + "rejected_at_source_binding": true, + "source": "inputs/literal-leaf-contract.md" + }, + { + "optimized": true, + "rejected_at_source_binding": true, + "source": "inputs/literal-leaf-contract.md" + } + ], + "status": "PASS_INDEPENDENT_SELECTED_GRID_CONTROLS" + }, + "independent_controls_export": { + "empty_PATH": true, + "git_free": true, + "package_bytes_modes_unchanged": true, + "read_only": true, + "stderr_empty": true, + "stdout_sha256": "0e5e824b1bef48cc50e889ec06c5db73b12a6c3fb5dc9383054d90acb86ef2ef" + }, + "normal_optimized_export_receipts_equal": true, + "portable_export": { + "declared_inputs_checked": 10, + "empty_path": true, + "exit_code": 0, + "files": 21, + "git_free": true, + "package_bytes_and_modes_unchanged": true, + "read_only_modes": true, + "seconds": 0.344, + "status": "PASS_READ_ONLY_GIT_FREE_EMPTY_PATH_EXPORT", + "stderr_empty": true, + "stdout_sha256": "4f086a6557625ea06956f41c3ac4b0547909a9cab04f15544f904166ef21e198", + "tested_commit": "439576281160cf79cf3a1ec6b54c669e6a8008e4" + }, + "scientific_receipt": { + "actual_event": 24472, + "actual_move": [ + "MOVE", + 415, + 3, + 99, + false + ], + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "common_root_scaled_control": { + "F": 18, + "W": 40, + "all_prefixes_integral": true, + "h": 1, + "p": 0, + "root_axes": 18, + "scale": 262144 + }, + "depth_inequality_cases": 5000, + "endpoint_only_control": { + "central_first_prefix": { + "0": [ + "1/2", + "1/2" + ], + "1": [ + "1/2", + "-1/2" + ], + "2": [ + "1/2", + "-1/2" + ], + "3": [ + "1/2", + "1/2" + ] + }, + "complete_native_entrance": { + "0": [ + "-1", + "0" + ], + "64767": [ + "-1", + "0" + ] + }, + "complete_native_final": { + "21589": [ + "-1", + "0" + ], + "43178": [ + "-1", + "0" + ] + }, + "entrance_integral": true, + "final_integral": true, + "interpretation": "Rejects endpoint-only admission to this literal provider, not the selected guarded root pipeline.", + "prefix_integral": false + }, + "packing_cases": [ + { + "K": 2, + "address_bits": 21, + "f": 1, + "old_bits": 603979776, + "packed_bits": 176160768, + "ratio": "24/7", + "rho": 0, + "selected_positions": [ + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18 + ] + }, + { + "K": 2, + "address_bits": 39, + "f": 2, + "old_bits": 158329674399744, + "packed_bits": 46179488366592, + "ratio": "24/7", + "rho": 1, + "selected_positions": [ + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 35, + 37 + ] + }, + { + "K": 3, + "address_bits": 84, + "f": 3, + "old_bits": 5570730176784211237046059008, + "packed_bits": 1624796301562061610805100544, + "ratio": "24/7", + "rho": 1, + "selected_positions": [ + 3, + 6, + 9, + 12, + 15, + 18, + 21, + 24, + 27, + 30, + 33, + 36, + 39, + 42, + 45, + 48, + 51, + 54, + 57, + 60, + 63, + 66, + 69, + 72, + 75, + 78, + 81 + ] + } + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 32, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 239, + 129, + 130, + 132, + 136, + 16, + 160, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 111, + 111, + 111, + 111, + 0, + 111, + 111, + 0, + 0 + ] + } + }, + "recipe_sha256": "064d51e9c347dbcfd9e172e5b5cab75f96912e0eb9a6f9537d53540cf4780ca9", + "scope": "Source-bound numerical admission implication conditional on the existing complete-root Clifford/depth premise and a faithful paid packed ABI. No physical packing, whole MOVE, nonleaf tariff, all-column foundation discharge or new kappa.", + "selected_word_sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "source_files_verified": 10, + "status": "PASS_SELECTED_MOVE_PACKED_GRID_INTERFACE" + }, + "scope": "Separate universal proof review and exact finite controls. No literal full machine or complete supplier replay; all five assumptions retained; no new kappa.", + "status": "PASS_REGISTERED_AUTHOR_AND_INDEPENDENT_PAIRS_AND_READ_ONLY_EXPORT", + "tested_scientific_commit": "439576281160cf79cf3a1ec6b54c669e6a8008e4" +} diff --git a/research/selected-move-packed-grid-interface/VERIFY.json b/research/selected-move-packed-grid-interface/VERIFY.json new file mode 100644 index 0000000000..ce584b9ab1 --- /dev/null +++ b/research/selected-move-packed-grid-interface/VERIFY.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/selected-move-packed-grid-interface/inputs/WORD.json.gz", + "research/selected-move-packed-grid-interface/inputs/clifford_exact.py", + "research/selected-move-packed-grid-interface/inputs/selected-application.md", + "research/selected-move-packed-grid-interface/inputs/common-grid.md", + "research/selected-move-packed-grid-interface/inputs/old-coded-move-contract.md", + "research/selected-move-packed-grid-interface/inputs/notices/selected-NOTICE", + "research/selected-move-packed-grid-interface/inputs/notices/common-grid-NOTICE.md", + "research/selected-move-packed-grid-interface/inputs/notices/old-coded-NOTICE.md", + "research/selected-move-packed-grid-interface/inputs/literal-leaf-contract.md", + "research/selected-move-packed-grid-interface/inputs/notices/literal-leaf-NOTICE.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Exact bundled/source pins, actual selected recipe, half-integral-prefix negative control, guarded prefixes, complete spectator permutation and cardinality reduction." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Same semantic checks under optimized Python; no reliance on assertions in this verifier." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/independent_checks.py" + ], + "timeout_seconds": 60, + "checks": "Independent exact real-coordinate Gaussian endpoint/width controls, complete packing round trips and four executed source-byte rejection controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "-O", + "{package}/independent_checks.py" + ], + "timeout_seconds": 60, + "checks": "Independent exact real-coordinate Gaussian endpoint/width controls, complete packing round trips and four executed source-byte rejection controls." + } + ] +} diff --git a/research/selected-move-packed-grid-interface/independent_checks.py b/research/selected-move-packed-grid-interface/independent_checks.py new file mode 100644 index 0000000000..6279428c5c --- /dev/null +++ b/research/selected-move-packed-grid-interface/independent_checks.py @@ -0,0 +1,105 @@ +"""Separate exact arithmetic, packing, and executed source-binding controls.""" +from fractions import Fraction as Q +from pathlib import Path +import json +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def pair(a, b): + x = (*a, *b) + rows = ((1, -1, 1, 1), (1, 1, -1, 1), + (1, 1, 1, -1), (-1, 1, 1, 1)) + y = [sum(Q(c)*v for c, v in zip(row, x))/2 for row in rows] + return (y[0], y[1]), (y[2], y[3]) + + +def axis(values, bit): + out = list(values) + for j in range(len(values)): + if not j & (1 << bit): + out[j], out[j | (1 << bit)] = pair(values[j], values[j | (1 << bit)]) + return out + + +def main(): + entrance = [(Q(v), Q(0)) for v in (1, 0, 0, 1)] + expected = [(Q(v), Q(0)) for v in (0, 1, 1, 0)] + for order in ((0, 1), (1, 0)): + middle = axis(entrance, order[0]) + need(any(v.denominator != 1 for z in middle for v in z), + 'endpoint-only admission must fail at first axis') + need(axis(middle, order[1]) == expected, 'two-axis exact endpoint') + overflow = pair((Q(3), Q(-3)), (Q(3), Q(3))) + need(overflow == ((Q(6), Q(0)), (Q(0), Q(0))), 'exact width control') + need(any(not -4 <= v <= 3 for z in overflow for v in z), + 'integrality alone must not imply signed width admission') + packing_trials = 0 + for f, step, offset in ((1, 2, 0), (2, 2, 1), (3, 3, 1)): + prefix = 2 + nbits = prefix + 9*f*step + 1 + selected = [prefix+(i*f+j)*step+offset for i in range(9) for j in range(f)] + permutation = list(range(prefix))+selected+[ + k for k in range(prefix, nbits) if k not in selected] + need(sorted(permutation) == list(range(nbits)), 'complete bijection') + for seed in range(5): + original = [(k*k+seed*k+seed//2) % 2 for k in range(nbits)] + packed = [original[k] for k in permutation] + restored = [None]*nbits + for j, k in enumerate(permutation): + restored[k] = packed[j] + need(restored == original, 'inverse preserves every spectator bit') + for i in range(9): + chunk = packed[prefix+i*f:prefix+(i+1)*f] + value = sum(x << (f-1-j) for j, x in enumerate(chunk)) + for bit in range(f): + need((value >> bit) & 1 == original[selected[i*f+f-1-bit]], + 'uniform tensor-column reversal') + packing_trials += 1 + for width in (2, 7, 40): + old = 3*(1 << nbits)*6*2*(width+1) + new = 2*3*(1 << nbits)*2*width + need(Q(old, new) == Q(3*(width+1), width) and old > new, + 'header-only cardinality mismatch') + mutations = [] + with tempfile.TemporaryDirectory(prefix='selected-grid-controls-') as tmp: + copied = Path(tmp)/'package' + shutil.copytree(HERE, copied, ignore=shutil.ignore_patterns('__pycache__')) + for relative in ('inputs/WORD.json.gz', 'inputs/literal-leaf-contract.md'): + target = copied/relative + original = target.read_bytes() + changed = bytearray(original) + changed[len(changed)//2] ^= 1 + target.chmod(0o600) + target.write_bytes(changed) + for optimized in (False, True): + argv = [sys.executable, '-I', '-B'] + if optimized: + argv.append('-O') + done = subprocess.run(argv+[str(copied/'verify.py')], + capture_output=True, timeout=20) + need(done.returncode != 0 and b'exact bundled SHA256' in done.stderr, + 'actual source-binding verifier rejects changed bytes') + need(b'PASS_' not in done.stdout, 'mutant cannot emit acceptance') + mutations.append({'source': relative, 'optimized': optimized, + 'rejected_at_source_binding': True}) + target.write_bytes(original) + print(json.dumps({'status': 'PASS_INDEPENDENT_SELECTED_GRID_CONTROLS', + 'exact_axis_orders': 2, 'signed_width_rejection': True, + 'packing_roundtrips': packing_trials, + 'cardinality_cases': 9, 'source_mutations': mutations, + 'scope': 'Independent finite controls, not a literal machine replay or universal proof.'}, + sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/selected-move-packed-grid-interface/inputs/WORD.json.gz b/research/selected-move-packed-grid-interface/inputs/WORD.json.gz new file mode 100644 index 0000000000..74563a7867 Binary files /dev/null and b/research/selected-move-packed-grid-interface/inputs/WORD.json.gz differ diff --git a/research/selected-move-packed-grid-interface/inputs/clifford_exact.py b/research/selected-move-packed-grid-interface/inputs/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/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<=0 and D>=1. Finite external row counts, dirty public inputs, correlations +and spectators are arbitrary. Root preprocessing must supply p,h and layouts. + +## 2. Exact finite source envelopes + +The independent rational row interpreter treats MOVE as a chart change, +INIT as owned zero, CLEAR as lifetime completion, and ADD/COPY/SCALE as +literal row operations. It checks common-frame use and completed frames. +All stored rows and separate pre-ADD products, multiplied by S=1125, are +dyadic; completed public rows themselves are dyadic. The full scan visits +14,060,742 coefficients and obtains: + +| Local property | Exact bound | +|---|---:| +| Dyadic denominator height after scaling | 24 | +| Maximum scaled row/product l1 mass | 1636447290138225/16384 <2^37 | +| Scalar numerator bit length | 24 | + +Input scaling is included because S<2^37. These are finite source +certificates, not an independent native-map or all-size proof. + +A separate caller recurrence majorizes expansions in **products of Clifford +operators**, without commuting the products or substituting numerical +characters. For ADD, use M_t+|q|M_s and +max(H_t,H_s+v2(den(q))). SCALE, SWAP and QUERY use their literal rules. +IDLE is a Clifford product. LAMBDA is expanded as +((1+s i)I+(1-s i)Q^2)/2 for s=+-1. With Gaussian coefficient mass +|Re|+|Im|, its safe update is M<-2M and H<-H+1. + +At a joint event use the two actual type-A shear endpoints and type-B +(x-Qy,(Q^-1 x+y)/2), followed by the relevant Clifford. Their roles are +disjoint; both old B bounds are read before either is updated. The complete +current caller gives: + +| Cut | Dyadic height | Coefficient mass | +|---|---:|---:| +| Any completed caller event | <=163 | <=16246698892210214036146399419475929893435/256 <2^126 | +| Entrance of any joint call | <=154 | <=2^124 | + +Fresh productive helpers have mass1 and height0 relative to the current +raw-call entrance. A nested helper retains its actual entrance expansion and +all inherited debt relative to the original root inputs. During a local +call, composition with its scaled word adds the local bounds. Therefore, +including both caller-only and local-interior cuts, the raw caller has + +A=max(163,154+24)=178 exterior denominator bits, +B=max(126,124+37)=161 coefficient-mass bits, per unfinished context. + +A separate whole-stream product bound gives caller height1240 and mass +below2^4362. It cross-checks the eventwise numerical result using a different, +coarser aggregation. The written induction on these source operations is the +proof; endpoint norms alone would be insufficient. + +## 3. Per-call odd clearing and recursive reset + +For formal input row R and current chart D_v, the scaled local word holds +D_v(S R x). The source certificate makes its exterior coefficients dyadic. +The same certificate covers a pre-ADD product. Thus the odd part of each +divisor divides the stored integer numerator on every sufficiently fine +binary grid. At completion the unscaled endpoint is dyadic, so final +division by S is exact too. + +Each nested invocation scales its own actual entrances, runs the word and +unscales its completed outputs. Unfinished contexts accumulate mass and +binary denominator debt. A completed positive Gaussian endpoint resets the +**extra exterior debt relative to its entrance**, retaining all debt already +present at that entrance. Its Gaussian action joins the Clifford factor. +No numerical grid is reset. + +One S is charged per unfinished local context. Completed siblings add no +persistent debt. Scaling once by S at the outer boundary is a different +program and cannot replace arbitrary nesting: the boundary-only program +needs S raised to a proved depth bound, as #104 prescribes. The verifier +includes a nested exact-division countercontrol to this mistaken shortcut. + +This is a formal linear expansion in original complete root inputs, so no +independence of their values is needed. The expansion is proof state, not a +runtime data structure. Exterior scalars stay outside tensor powers. + +## 4. Current compiler depth and the integer threshold + +The candidate parameters are v=1920, carrier153, separated paid ceiling11^v, +productive floor12^v and m=153^v. In particular r_max=2. +These apply to the separated rule, not the unpowered raw rank-one targets. + +The retained compiler has complement n-s<(1-1/m)n and deepest-exit ratio +at most (r_max/m)(r_max/k_min)^G <=1-1/m. Its path has at most +m(1+floor(log2 n)) nonbase frames, each carrying at most +v(1+floor(log2 n)) raw contexts. Thus the credited recurrence specializes to + +K(n) <= v m (1+floor(log2 n))^2. + +Independently regenerate the written threshold from the source's exact +candidate/tested rationals and logarithm power2224: +H=1,339,210,000,000,000,000, N=2^H, and +K_star=1920*153^1920*(H+1)^2. +K_star has14066 bits; 357K_star has14075 bits, so 357K_star<2^H. +The threshold search has one crossing: with L=2224 and step=10^13, +(step*j+1)^L>2^j for j<=2L. For j>=2L the ratio of successive +((step*j+1)^L/2^j) values is strictly below +(1+1/j)^L/2 < 1/(2(1-L/j)) <=1. Thus checking the adjacent +integer indices justifies the regenerated threshold. +No floating logarithm or construction of N is used. Also153<2^8 and +8*1920=1, N ell<=N^ell<=D; for ell=0, t=0. Therefore 356t=2` and `f<=cutoff`; both are physically checked. DATA is exactly +V bits followed by a blank. HEADER may have opaque symbols after the sixth +code. Both public heads start at their origins. Supply 27 genuinely distinct +private tape owners, blank from one cell before each origin through the caps +in Section 6. Opaque exteriors are preserved on successful legal calls. +Origins may differ or be negative; the controller never decodes them. + +This is an explicit packed boundary, not the full old #6967 ABI. That provider +uses a 23-value length/unary-prefix/LSB descriptor and three-bit coded LSB +component fields with delimiters. A caller must supply the exact semantic +packing, component orientation, delimiter and header bridge, with its full +cost and ownership contract. Reversing individual already packed components +is linear, but the old codec and arbitrary strided packing are not silently +implemented here. The first five new fields match the published phase ABI; +its opaque-tail contract permits preservation of the added cutoff code. + +## 2. Universal accepting and failure contract + +For every legal encoded entry, suppose each output component of every +executed C axis is integral on the common grid and lies in +`[-2^(w-1),2^(w-1)-1]`. Then the fixed graph replaces DATA by the exact positive +`C^(tensor f)` on all f bits of coordinate zero. All eight other coordinates, +prefixes, suffixes, coefficient indices and absolute phase are preserved. +HEADER, every head, private body/guard and opaque exterior is restored; +DATA remains its original owner. + +At each executed scalar row the program rejects exactly a nonintegral half +or an out-of-range w-bit result. A finite missing or extra DATA bit is detected +by the header-derived clone before numerical execution. Width/cutoff failures +reject before the clone. These rejections precede every DATA write, so the +original public field/header remain intact. Missing local branches are +explicit reject endpoints in the reference interpreter. Failure-time private +retirement, head return and same-bank retry are not claimed. This is a weaker +failure lifecycle than structured #6967, not its full drop-in export. + +The domain is a prefix condition: final tensor-image fit alone does not +establish it. A credited sufficient condition from #3091 and its Gaussian +reserve/norm predecessors is that input components are divisible by +`2^ceil(f/2)`, bounded by M, and `2^ceil(f/2) M <= 2^(w-1)-1`. +This supplies all integral signed prefixes. Those reserve/norm results are +inherited, not new claims here. A caller can instead prove its actual +correlated prefix conditions. + +For a concrete obstruction to endpoint-only admission, the real f=2 fibre +`[1,0,0,1]` has final `C tensor C` image `[0,1,1,0]`. Its first low-bit-axis +pair `(1,0)` nevertheless produces nonintegral halves. The exact program +must reject it even though the final image is integral and fits at w=2. + +## 3. Literal acquisition and generated geometry + +`compile_leaf()` has no runtime arguments. Its 6,826-location graph uses 29 +fixed tapes and `{blank,0,1,|}`, with only scanned-symbol branches, one-cell +writes, unit moves, fixed jumps and halt. Compile-time loops enumerate fixed +bit/carry possibilities, never input-sized code. Varying counts and geometry +stay on tapes. + +The first five Gamma codes become unary guides by repeated `v -> 2v+b` +copies. Strict binary prefixes sum to less than the represented value, so +these conversions cost `O(f+r+P+S+w+E)=O(V+E)`. The first value's canonical +binary word and bit length are also copied. Cutoff is copied only in binary, +with a unary bit length. Comparing lengths and, only if equal, MSB words +checks `f<=cutoff`. An arbitrarily large represented cutoff thus costs O(E), +not its value. HTRACE records every public header advance and restores its +head without an origin oracle. All comparison words are retired afterwards. + +For axis j, `0<=j=2: the initial width-guided seek, w digit transitions, +two sign extensions, parity/range scans, output emission and all returns are +included. Each ordinary digit uses at most thirteen instructions. The four +input loads plus clears cost at most `84w+44`. Four scalar rows, pair control +and component handling therefore cost at most 640w per pair. There are +N/2 pairs per complete axis. All half loads, stream merges, whole-field +returns, suffix/prefix loops and their resets are linear scans of V; their +loops have fixed depth and every range is nonempty. A conservative count +places a complete axis, including its geometry update when present, below +`8192(V+1)` instructions. The actual table has no per-bit scan of a full +descriptor or whole address word. + +Separately, header/initial geometry/source clone and final commit/retirement +are each below `8192(V+E+1)`: the preceding exact unary-helper prices and +constant-many full scans give much smaller coefficients, and this allowance +also covers all fixed guard and branch instructions. Hence + +`T <=8192[f(V+1)+2(V+E+1)] <=65536(fV+E+1)`. + +The second inequality uses f,V>=1. This is a complete direct-leaf bill: +source access and return, geometry, every axis, copying, full staging, +installation and erasure are charged. It is not a faster nonleaf tariff. +The fixed program construction is input independent. Entry acquisition, +old-format conversion, source packing and transport to the entry heads are +supplied caller work and must be added where required. + +For backing, put `U*=Sr 2^(9f-1)`, `A*=P 2^(f-1)`, and +`C*=max(A*,U*,f,r,P,S,w)`. Relative to its own origin, each private role visits +only `[-1,cap]`, including the guard and blank endpoint, with these caps: + +| Role | cap | +| --- | --- | +| A, B, DTRACE | V on each role | +| MODE | 1 | +| HTRACE, LENGTH | E on each role | +| DOUBLE | C* | +| F, R, P, S, WIDTH | f,r,P,S,w respectively | +| FBIN, FLEN | ell(f) on each role | +| TBIN, TLEN | ell(cutoff) on each role | +| PREFIX, SUFFIX | A*, U* respectively | +| LEFT, RIGHT, LOUT, ROUT | `2w U*` on each role, using the maximum U* | +| AR, AI, BR, BI | w on each role | +| NUM | w+2 | + +Every cap in the twenty volume-type roles is <=V, except NUM's harmless +additional two cells; six code-type roles are <=E, and MODE needs one cell. +Including 27 guards/endpoints, their total allowance is at most +`20V+6E+57 <=64(V+E+1)`. Here K0 counts the actual pre-entry historical +backing of the 27 private owners only. Their backing at every time is at most + +`K0+64(V+E+1)`. + +For a complete 29-owner history statement, include all public history in K0 +and add at most `E+V+2` public head positions. The same loose envelope remains +valid, since `21V+7E+59 <=64(V+E+1)`. Supplied source/opaque entry backing is +included in actual K0; a test fixture's unpriced construction is not a theorem +about free caller acquisition. + +Erasure never subtracts historical cells. All successful-call writes are +blank again at return; older tails are already blank from prior successes. +Thus a smaller clean call needs no scan of old capacity and retains its own +current-shape time bound. At fixed origins repeated calls use per-role maxima, +then sum. Under changing origins retain absolute per-role history unions and +the caller's paid transport corridors; do not replace them by maximum current +volume. Whole-tail blankness and genuinely distinct owned windows are entry +premises, not inferred from a few local reads or fresh wrapper identities. + +## 7. Exact source transfer, evidence and unresolved interfaces + +The selected native tensor convention packs coordinate i as +`a_i=sum_j x_(j,i) 2^j`. The central rank-one compiler factor acts on i=0 in +each column j. The identity of its two source columns, with denominator two, +therefore identifies the operator implemented above exactly, including phase +and normalization. The source binder checks the entire retained local recipe; +this does not claim that this package implements its two surrounding factors. + +For a current coded caller, an admitted semantic bridge must identify these +actual bits, preserve the complete other coordinate/spectator/coefficient +fields, preserve the common grid and signed width, and supply the six values +above, including the actual cutoff. It must price real packing and coefficient +orientation. The generic #6967 domain contains shapes that are not already +this complete packed nine-coordinate tensor; those calls are not silently +included. A supplied view cannot make strided payload movement free. + +The author checker uses a direct tensor-row Gaussian polynomial oracle, +not the executable butterfly/carry algorithm. It tests complete m=9,f=1 +packets, endpoint values, coefficient/spectator multiplicities, both named +arithmetic failures, cardinality/width/cutoff failures and a 2049-bit threshold. +The separate C++ interpreter executes the same fixed 6,826-location table on +the complete actual m=9,f=2 array: 262,144 addresses, 2,621,440 bits, and +704,382,528 table instructions. Its output matches the independent direct +tensor formula, and every header/head/private/exterior check passes. It +cross-checks the original interpreter at f=1. A mutant that executes only +the first axis still retires correctly but fails the f=2 tensor oracle, +directly detecting rank-one/f=1 conflation. No reduced dimension substitutes +for that actual full-field f=2 execution. + +Independent root/peer evidence is recorded separately in REVIEW.md. Finite +tests support, but do not replace, the universal graph invariants and cost +proof above. Open obligations remain: full old-codec and placement bridges, +failure retirement if required, entire source MOVE/caller composition, +global producer/cutoff/precision admission, nonleaf speed and the other +foundational assumptions. No selected certificate, new kappa or unconditional +integer-multiplication theorem is claimed. diff --git a/research/selected-move-packed-grid-interface/inputs/notices/common-grid-NOTICE.md b/research/selected-move-packed-grid-interface/inputs/notices/common-grid-NOTICE.md new file mode 100644 index 0000000000..51fa9d494c --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/notices/common-grid-NOTICE.md @@ -0,0 +1,20 @@ +# Credit and retained source notice + +Prepared for @CubeJerry with substantial OpenAI assistance. Apache-2.0. + +The five files under `source/` are unchanged snapshots from DreamingOfClouds' +`research/p104-shared-odd-native` at +`4e13b7acdbea1c9f12aa88126435360eecea7401`. Their original LICENSE and NOTICE +are retained alongside them. The original word, caller, scale1125 certificate, +strictification parameters and candidate bound are their contributors' work. + +The proof explicitly credits #104's odd clearing and #6901's fixed-root +precision theorem, with the #4586/#5443/#6878 compiler and occurrence lineage. +Credit icekylinx, Ross Richardson, zxv, Jacob Alan Sussman and all authors +identified by those predecessor packages. No predecessor method, endpoint +identity or independent human acceptance is claimed as a new result here. + +The rational audit and fixed-grid/transfer-matrix audit were authored by +different same-session AI research agents. That separation supplies an +independent method and review; it does not imply external authorship or +formal proof verification. diff --git a/research/selected-move-packed-grid-interface/inputs/notices/literal-leaf-NOTICE.md b/research/selected-move-packed-grid-interface/inputs/notices/literal-leaf-NOTICE.md new file mode 100644 index 0000000000..71c5f6dae2 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/notices/literal-leaf-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and license + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +New material is Apache-2.0; copied predecessors retain their original notices. + +Jose Manuel (jmbarrancoml), CrocSwap/integer-mult-bounds#3091, supplies the +Gaussian C numerator rows, exact carry/parity/signed-fit argument, physical +complete-axis strategy and direct tensor tariff. Credit its #3055/#3087 +physical lineage, Alejandro Zarzuelo Urdiales's #45 Gaussian tensor reserve +and norm results, James Chang's #1869 ripple arithmetic, AAAmirinu's #2327 +prefix audit, and Nick Petalas's #2772/#3089 prefix/capacity work. + +@CubeJerry's #6967 current-coded leaf supplies the earlier source/format/ +lifecycle binding and explicitly leaves literal numerical export open. +#6978, #6986 and #6989 provide distinct all-source, cutoff-transport and +rounded wrappers. Their stronger failure-retirement and old coded interfaces +are not silently inherited by this packed component. + +The actual #7000 source, Clifford compiler and retained independent Gaussian +verifier are credited to DreamingOfClouds, Ali Romman, Cinna Davis, zxv, +unpaidmoon, icekylinx, CubeJerry and the earlier authors named by the retained +sources. The construction, lowering and matrix identities are not claimed anew. + +The packed ABI is published at +`172f4535ce8dcff79f626410af845f757c1563be`. Unary/Gamma/trace patterns follow +literal-layer-phase at `8b549ca6557ccbb3017b104b27ea35051f990416`, which credits +literal-layer-egress at `51ab0539059214fcfa044938c36a0b6017232be5`. The exact +Builder/Machine originates in #7349, head +`9dfe6747b8553fd11b408f2b045c5954ef1e6eaa`. + +The parent's dense execution/oracle and literal_layer_boundary's independent +source/Gaussian/universal-cost review are separately attributed in REVIEW.md. +Their artifacts are unchanged. Independent AI work is not human approval or +formal proof-kernel acceptance. diff --git a/research/selected-move-packed-grid-interface/inputs/notices/old-coded-NOTICE.md b/research/selected-move-packed-grid-interface/inputs/notices/old-coded-NOTICE.md new file mode 100644 index 0000000000..9ec74ef605 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/notices/old-coded-NOTICE.md @@ -0,0 +1,25 @@ +# Attribution and scope + +Prepared for @CubeJerry with substantial OpenAI assistance in source analysis, +composition proof, implementation, independent matrix/arithmetic checks and +documentation. Apache-2.0. Same-session lead review is author-side evidence, +not independent human or formal-kernel acceptance. + +The published current coded monomial and positive leaf are exact dependencies, +not new algorithms in this package. Their computational files and attribution +are retained unchanged; public source pins are in DEPENDENCIES.json and +REMOTE-SOURCE-TREES.json. Shared runtime copies inside the monomial closure +retain their original notices. The thin leaf source closure is connected by +this package's discovery shim to that identical shared physical vocabulary. + +Credit Jose Manuel (`jmbarrancoml`) for #3087 and #3091 with OpenAI assistance, +and the #3055/#2250/#2378/#2422 physical permutation and coefficient lineage. +Credit Chris R (`Clear1nsight`) for #4129's older prepared common-grid binding. +Credit DreamingOfClouds and the selected #6030 construction, Ali Romman and +the retained native compiler/source lineage, #6293, unpaidmoon #6930, and +Ali Romman's distinct stochastic-rounding use of event9896 in #6532. + +Only the whole-occurrence protected current join, its explicit full invoice, +independent original-source matrix evaluation and bounded verification +composition are claimed here. No new kappa or universal selected assumption +discharge follows. diff --git a/research/selected-move-packed-grid-interface/inputs/notices/selected-NOTICE b/research/selected-move-packed-grid-interface/inputs/notices/selected-NOTICE new file mode 100644 index 0000000000..a3687d65a0 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/notices/selected-NOTICE @@ -0,0 +1,9 @@ +New shared-wire composition, seventeenth wire, and two enabling splits: developed with substantial OpenAI assistance, 2026. Apache-2.0. + +Frozen predecessor native words and odd verifier: DreamingOfClouds, with Claude Opus 5.5 (Anthropic), from #6936 and #6937. + +Retained Clifford compiler and exact native interpreter retain their original headers and lineage from #6833: native source by DreamingOfClouds; independent-helper mechanism by Ali Romman; inventory, retiming and helper-retirement extensions by Jerry Chen / @CubeJerry with OpenAI assistance. + +Helper-split lemma: Ali Romman (#5599). Shared native applications: CubeJerry (#6916). Caller blocks: CubeJerry (#6912). Owned-rise argument: CubeJerry (#6914). Width-2 phase convention: unpaidmoon (#6930). Odd-grid precedent: icekylinx (#104). + +The higher-level caller and BIT integration require their own source attribution and pins. diff --git a/research/selected-move-packed-grid-interface/inputs/old-coded-move-contract.md b/research/selected-move-packed-grid-interface/inputs/old-coded-move-contract.md new file mode 100644 index 0000000000..4303bc7de8 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/old-coded-move-contract.md @@ -0,0 +1,399 @@ +# Protected composition of the current raw MOVE 9896 + +Prepared for **@CubeJerry**, with substantial OpenAI assistance. Apache-2.0. +This is a source-level fixed-control composition theorem under the stated +service premises. No new kappa or complete selected-assumption admission. + +## 1. Exact object and novelty + +The canonical base is `7c49fe32c55de02c2c873655c804b16e4c3fef0a`. +The selected #6030 word has raw event 9896 +`["MOVE",236,3,7,false]`. The unchanged lifecycle lowering emits consecutively + +1. `SERVICE`, owner 236, token `("move-in","local",9896,raw)`; +2. positive `PAID`, rank 1, owner 236, token `("local",9896,raw)`; +3. `SERVICE`, owner 236, token `("move-out","local",9896,raw)`. + +The source representation has native rank nine. The canonical transition from +frame 3 to frame 7 lowers as `M_right`, positive C on coordinate zero, then +`M_left`. The full record's canonical SHA-256 is +`0fb29a9ddca346f0b17d11f720d80607a0a64859d75afb50e9680be7a4647ac4`. +The positive middle matrix is exactly + + C = 1/2 [[1+i, 1-i], [1-i, 1+i]]. + +The two implemented source services are independently published at: + +- current monomial: CubeJerry commit + `7d1ff23714e6f9182c1d0ff9214f65def2f30e04`, + `research/current-coded-gaussian-monomial`; +- current positive leaf: CubeJerry commit + `61edc4fe348f0aeadc82a3b642a802cbfb03aed8`, + `research/current-coded-gaussian-leaf`. + +The monomial depends on unchanged #3087; the leaf depends on unchanged #3091. +Their shared current codec/header/lifecycle export is the published +`5629e7772d1720d6727465e328a45694f8620538` binding. Computational bytes are +retained unchanged. `move_sources.py` shares only discovery so every factor +uses the same actual Count, Tape, codec and header classes. The thin leaf +discovery object supplies the same objects its provider previously received; +it changes no arithmetic, layout, scratch, error or cleanup body. + +This package adds the complete current-coded **raw-source occurrence join** +and a protected whole-occurrence commit. Neither predecessor supplied the +three-factor physical join. A leaf-local failure guarantee alone is insufficient: +the entrance monomial may already have changed the original input before the +leaf rejects. Our one extra complete field protects that earlier state. + +The phase identity and all-width convention belong to #3087/#6293, and the +primary event's phase inspection to #6930. The source circuit identity and +Clifford lowering are inherited. #6532 concerns unbiased stochastic rounding +of this same event, a different operation and numerical contract. + +## 2. Quantified current interface and retained premises + +Fix the source triple and two completed ordinary supplier instances before +runtime input varies. They must satisfy the monomial predecessor's exact +ordinary interface, source access, return, erasure and backing contracts. +Their complete bills are retained below; constructing an object of the right +class or replaying its elementary branch does not admit a faster supplier. + +Supply one complete `CodedPort` field for actual owner 236 and one read-only +`BinaryContextPort` with the unchanged twenty-three-field schema. Let Q_R +and Q_L be the inventories of those two constructed monomial providers. +Supply Q=1+Q_R+349+Q_L fixed private physical ports with genuinely disjoint +segments. The exercised binary ordinary template with register capacity 64 +has Q_R=Q_L=1878 and Q=4106; changing the compiled ordinary inventory changes +these constants. All public, +descriptor and private heads start at their local origins. Every private body, +including the extra staging field, starts physically blank, with its local +LEFT marker already provided by the caller's charged allocation contract. +Ancestors before these markers are protected. Object-identity tests reject +obvious aliases; actual disjointness of different wrappers remains a premise. + +Use the monomial notation + + a = within_bits, u = active_start, z = back_start, + C_rows = outer*rows, n=f-1, t=nG. + +The exact common geometry is + + outer, rows, f, K, G, H > 0, 0 <= rho < K, + t <= H, 2H <= u, u+9fK <= z, z+H <= a, + selected_axes=9f+remainder <= d, 0 <= remainder < 9, + cutoff > 0, f <= cutoff. + +Positions are already normalized within-row positions counted from the left. +This package does not establish them from an enclosing caller's global prefix. +It accepts the exact raw `current_local` tokens above. The different nested +tokens emitted by `source_ir.remap` are rejected, rather than guessed at. + +Each record contains r>=1 complex coefficients. Each real/imaginary component +has h>=2 least-significant-first two's-complement bits and delimiter 2. Each +virtual symbol is represented by the current three-bit code. Consequently + + b=record_bits=6r(h+1), row_bits=2^a b, V=C_rows*2^a*b. + +The field has precisely V physical data bits followed by the physical blank +frontier. All components share one caller-supplied quantum. Header values, +width h, coefficient ordering and quantum remain unchanged across the factors. +The root common-grid theorem, actual producer conditions such as H=dG and +K=128G, placement services, suspended-owner stack and complete caller are +separate premises when this local service is used there. + +The numerical admission domain requires every phase negation selected by the +two monomials to fit the signed h-bit component and every complete C pair +division and intermediate result to be exact and signed-representable. Final +output representability by itself does not imply this domain. These are the +inherited arithmetic guards; this wrapper does not round or repair a failure. + +A sufficient, conservative common-grid condition is that every input integer +component is divisible by 2^f and has absolute value strictly below +2^(h-f-1). A monomial preserves the component bound and divisibility. Each C +stage uses four signed summands divided by two, so it doubles the component +bound at most and spends one binary divisibility bit. After k stages the +components remain divisible by 2^(f-k) and bounded by 2^k times the initial +bound. All f stages and both monomials therefore fit strictly inside signed +range. The exact guard domain is larger; the finite fixture uses that larger +domain and is checked pair by pair by the actual kernel. + +## 3. Complete-coordinate algebra and current geometry + +For each j in 0,...,f-1, its rank-nine column consists of current address bits + + p_(i,j) = u+(if+j)K+rho, 0<=i<9. + +The monomial predecessor applies the source affine map and its Gaussian phase +independently to every such column. Its old low-bit residue is K-1-rho. +Its folded suffix comprises complete original coefficient fibres; no original +coefficient, delimiter, spectator, row or outer-row label is omitted. + +The leaf receives the **same unchanged descriptor**. Its selected interval is +the first fK-bit vector interval beginning at u. It acts at +u+jK+rho, precisely p_(0,j). Every other address bit, including all other eight +vector intervals and the front/back reservations, is a complete spectator. +The leaf visits these disjoint factors in reversed column order after the +low-bit conversion; they commute. It therefore implements C on coordinate +zero in every rank-nine column, with the exact positive normalization above. + +Let U be the authenticated original frame transition. The source lowering gives + + U = M_left (C tensor I_8) M_right. + +Tensor functoriality on the f disjoint selected columns now gives + + M_left^[f] C_0^[f] M_right^[f] = U^(tensor f). + +This is an equality of linear maps on the complete 9f selected factor, +tensored with identity on every spectator; hence it holds on dirty, +correlated and entangled input coefficients as well. No input independence is +needed for the numerical equality. Both monomials already repeat their +constant phase per column. In particular the right constant 1 contributes +i^f, not one factor i independent of f. C's half denominator and absolute +phase are retained. No projective-phase identification is used. + +## 4. Protected execution and named failure return + +`AtomicMove.bind` partitions the fixed private inventory into the one raw +staging port and disjoint complete entrance, leaf and exit cohorts. Each +provider sees the staging port as its current field; it never receives the +public original. Its own work roles are distinct from that field and the +descriptor, as required by its predecessor. The three provider inventories +are not reused as if erased backing were free capacity. + +The executed sequence is: + +1. Use the retained administrative `transfer` to copy all V physical data + bits into the initially blank stage and restore both heads. +2. Run the right monomial, the positive leaf, then the left monomial on that + complete stage and the same read-only descriptor. +3. Only after all three return successfully, copy all stage bits back over + the same-length public field. Restore the public and stage heads. +4. Physically retire every stage byte, restoring its head. Each factor has + already retired every byte in its own complete private cohort. + +Administrative copying preserves encoded zeros and delimiters literally; +it is not a free arithmetic COPY and is fully charged in section 5. Runtime +control reads only physical symbols and moves one cell at a time. It does not +inspect a host address, extent, payload array or decoded numerical value. + +On admitted input, induction over the three completed services gives the +endpoint of section 3, unchanged length/format/header, restored field/context +origins and clean completed private cohorts. This proves the conditions for +the commit loop: every source and target position contains a physical bit, +and their blank frontiers coincide. The final retirement erases the entire +protected copy including all physical codewords. + +For a named signed-phase or Gaussian parity/headroom rejection on otherwise +valid input, the failing provider preserves its entrance stage, restores its +field/context heads and cleans its own cohort. Earlier factors have already +returned and cleaned; later factors have not run. The public original has +not been written at all. The final retirement erases the stage at its returned +origin. The original complete public word, descriptor and every ancestor are +unchanged; every owned private body is blank and can be reused. A valid-format +f>cutoff rejection at the positive leaf has the same outer staging conclusion. + +This is the precise atomicity claim. A corrupted or truncated supposedly +successful result could make the late commit fail after writing a prefix; +hardware interruption can do likewise. Neither is a named inherited +arithmetic rejection, and arbitrary malformation/crash rollback is not claimed. +The protected-stage blankness and origin premises are necessary even before +the first transfer. + +## 5. Complete physical bill and retained backing + +Count one raw physical read, write or unit move as one action. On a contiguous +binary body of V bits at its origin, the retained functions give: + +| Administrative step | Physical actions | +|---|---:| +| Borrowed field to blank stage, with both heads restored | 8V+14 | +| Successful same-length commit, with both heads restored | 9V+14 | +| Stage retirement from its returned origin | 5V+7 | + +For example `origin` from displacement L>=0 costs 2L+3 actions. Transfer pays +its two starting origins, blank-target check, every source read/target write/ +unit move, and both terminal rewinds. The commit similarly pays both complete +rewinds and its two frontier checks. Retirement includes all encoded bytes. +Thus the new wrapper contributes exactly **22V+35** on successful return and +**13V+21** on the named rejection path after a factor restores the stage head. +These constants exclude the executed factor bills, not their shared-field +accesses. A direct independent arithmetic count and executable administrative +controls check the formulas. + +Let T_R,T_C,T_L be the complete current-physical bills of the three factor +providers, including their stage and descriptor accesses, format conversions, +source construction, setup, restoration, private cleanup and their native +children. The complete successful invoice is + + F_join + T_R + T_C + T_L + 22V+35. + +F_join is the positive fixed source/port preparation cost. A rejecting invoice +includes each actually executed complete factor bill and 13V+21. No unfinished +factor or failed scan is free. Each current factor already reads and charges +the full E-bit descriptor, including otherwise unused large metadata. + +For the leaf, + + T_C = F_C + O(fV+(E+1)^4+349), f<=cutoff. + +It is a direct positive leaf, with no ordinary call. For each monomial retain +its **entire** predecessor invoice. Write s=a-z-(f-1)G, a'=z+(f-1)G, +R=2hr*2^s, M=C_rows*2^a', v0=2^a'R, and +A=2+a'+ceil(log2(R+1)). If its affine word has g_E early and g_L late gates, +g=g_E+g_L and S=4g_E+12g_L, its old-symbol bill for f>1 is + + S * sum_(row=1)^C_rows T_B(v0,(f-1)G) + + O_9((g+1)*(Vraw+M*A^6) + +g*delta*M*A*(R+A)), + +where Vraw=C_rows*v0 and +delta=min(1,(f-1)*(2*2^(-G)+8*2^(G-K))). Apply the predecessor's fixed +whole-source codec factor, add O_9(V+(E+1)^4+Q), and its explicit +64*(Z+Q) retirement allowance for this call's reached extents. At f=1 the +ordinary and exceptional terms disappear; the complete affine, phase, +metadata, conversion and retirement work remains. The exact source census is + +| Factor | Early gates | Late gates | Total gates | Ordinary calls per row, f>1 | +|---|---:|---:|---:|---:| +| Right entrance | 5 | 6 | 11 | 92 | +| Left exit | 5 | 7 | 12 | 104 | + +Thus the two factors together retain 196 ordinary calls per outer-row when +f>1. At f=1 both counts are zero. Neither a finite fixture nor this join +strengthens the inherited ordinary exponent 99830289/100000000. + +For clarity, these are worst-case source bounds, separate from any measured +fixture. They can be written without asymptotic notation by retaining the +fixed positive constants from the predecessor proofs. For i in {R,L}, let +g_R=11, g_L=12, S_R=92, S_L=104. Choose fixed program constants c_old,i, +c_codec,i, c_wrap,i, c_reach,i that dominate the corresponding proved source, +codec, wrapper and reached-extent bounds. Their existence and independence of +all runtime parameters are inherited premises, not measured from the traces. +Define + + B_i = c_old,i*((g_i+1)*Vraw+M*A^6), f=1, + B_i = S_i*sum_rows T_B(v0,(f-1)G) + +c_old,i*((g_i+1)*(Vraw+M*A^6) + +g_i*delta*M*A*(R+A)), f>1, + B_C = c_old,C*f*Vraw, + U_i = F_i + c_codec,i*B_i + +c_wrap,i*(V+(E+1)^4+Q_i) + +64*(c_reach,i*(B_i+V+(E+1)^4+Q_i)+Q_i). + +Use the actual constructed Q_R,Q_L and Q_C=349, with the leaf's own fixed +constants for U_C. The exercised capacity-64 template has Q_R=Q_L=1878. +Each complete factor is bounded by its U_i. Hence a finite symbolic upper +bound for the successful whole service is + + F_join+U_R+U_C+U_L+22V+35. + +This states the complete inherited constant-dependent bound explicitly. It +does not claim an extracted numerical value for the predecessor program +constants or a supplied numerical ordinary-service ceiling. The literal +finite action counts below are exact observations on one input and are not +used as replacements for any of these worst-case bounds. + +The constructor-fixed inventory is 1+Q_R+349+Q_L private ports, equal to +4106 for the exercised capacity-64 binary template. The capacity-65 control +has Q_R=Q_L=1884 and 4118 total ports, so 4106 is not a universal constant for +every ordinary constructor. No per-input tape allocation is introduced. +Fresh occupied/ +backing bounds add the actual public field V and header E, the new V-bit +stage with constant frontier/origin allowance, and **both** monomial cohorts' +and the leaf cohort's source backing allowances. Summing the per-family +allowances is safe; taking only the largest active family would forget the +other families' retained blank allocations. After repeated calls, each role +is charged by its historical maximum reached extent. The new stage similarly +retains max_previous V plus its fixed origin/frontier allowance. Erasure +does not shrink backing. A smaller later call stops at its own fresh blank +frontier and pays only its current V; it does not rescan an older blank tail. + +## 6. Evidence, model limits and remaining work + +`check_move.py` independently evaluates the original source P/D/C circuit on +all 512 basis columns, covering all 262,144 matrix coefficient positions and +all absolute phases. It never computes the expected complete answer by +executing the lowered monomial/C/monomial recipe. The source's direct matrix +routine is a second comparison. The resulting sparse matrix has exactly +1,024 nonzero entries, each with the exact half denominator. +The literal monomial/positive-C/monomial map is then compared with this +independent original-source oracle on all 512 columns. Every zero and +nonzero position and absolute phase agrees. Four changed-phase, reversed-C, +wrong-axis and omitted-exit controls are rejected by that complete matrix +comparison and separately by the full reference-packet comparison. + +The smallest permitted local fixture still has 4,096 original records: +H>=1, f,K>=1, u>=2H, z>=u+9fK and a>=z+H imply a>=12. The proposed +512/1024-record fixtures would violate the published adapter's reservation +guards and were rejected as a test design, not reported as reductions. +H=G=K=1 is a reduced **local** descriptor; it is not the actual producer's +H=dG, K=128G allocation. Even a complete successful local packet would not +execute that enclosing caller. + +Exact completed finite evidence and interrupted attempts are recorded in +`VERIFICATION.md` and generated receipts. An interrupted run is not a +completed whole-MOVE witness. Any bounded factor-wise evidence is labelled +sliced execution and joined by exact intermediate bytes; it is not described +as a completed uninterrupted process. The all-width theorem above instead +uses the explicit predecessor contracts and current interface join. + +The actual physical evidence in this package is **partial**: the complete +4,096-record entrance and leaf slices passed, as did a separately seeded +reachable final-pair leaf rejection. The exit slice timed out with no +complete receipt. Therefore no complete three-factor sliced witness and no +uninterrupted whole-MOVE receipt is claimed. The exact original-source matrix +factorization and reviewed predecessor-contract composition establish the +scoped mathematical statement independently of that unfinished finite run. + +The sliced join has a state equivalence stronger than matching payload +hashes. The returned stage and unchanged descriptor are compared byte for +byte with the complete next-slice inputs, with their heads at their origins. +The original public field and every protected ancestor agree. Completed +providers have closed engines, empty live-role pools and completely blank +private bodies, with every private head at its origin. The next provider's +cohort and finite control are still unused at the actual composite boundary, +so they agree with its fresh slice state. Earlier completed providers may +retain different diagnostic call counters and historical highwater values; +their disjoint roles are never read again by this invocation. These values +are observations, not numerical inputs or runtime control read by a later +provider. Reinsert their blank retained tails into the fresh slice state: +the later sequence of literal actions and numerical result is unchanged. +The corresponding backing invoice is the componentwise maximum extent of +each fixed role over all compatible slices, then the sum over roles. Taking +the maximum total slice size would omit other cohorts' retained backing. + +The recorded arrays measure materialized cells, not the largest head position +ever visited: a unit move can traverse an implicit blank without extending +the array. The receipt therefore gives separately the exact rolewise union +of materialized extents and a conservative upper bound on all visited cells. +Start from the fixed local origins, one blank private body cell per role, +and the complete public/header regions with a frontier cell. Each additional +visited cell requires at least one literal unit move, and hence at least one +action. Adding the complete joined action count to those initial regions +is a valid, deliberately loose visited-backing upper bound. No asymptotic +space improvement is inferred from it; the predecessor's per-role source +backing proof remains the size-dependent bound used in section 5. + +`physical_hardware.py` changes only Python observation overhead. Its legal +read, write and unit-move definitions have the same state transition and +counter increments as the retained primitive hardware, as can be inspected +directly. The 30,000-command comparison is finite regression evidence for +those literal definitions; it is not a new implementation theorem, bulk tape +operation or algorithmic time improvement. + +The controller remains a source-level structured finite-control refinement. +No literal `Controller.execute_table` export is supplied. Enclosing caller +token normalization, live placement/stock, the producer's common-grid proof, +full ordinary tariff, nonleaf recursion, analytic recovery and complete +selected multiplication admission remain open. All five selected assumptions +and the selected certificate are unchanged. No new kappa follows. + +## Open next questions + +1. Bind the real nested caller token and its normalized descriptor to this + source triple, including the suspended owner and complete placement bill. +2. Export the complete protected join and its numerical factors into literal + lifecycle tables with the same error and head-return interface. +3. Admit the completed ordinary supplier and nonleaf positive child at the + current full recurrence, retaining all format, stock and precision costs. diff --git a/research/selected-move-packed-grid-interface/inputs/selected-application.md b/research/selected-move-packed-grid-interface/inputs/selected-application.md new file mode 100644 index 0000000000..3dd1af2285 --- /dev/null +++ b/research/selected-move-packed-grid-interface/inputs/selected-application.md @@ -0,0 +1,420 @@ +# Current-source conditional application of #7000 and #7001 + +This continuation applies the five assumptions of selected #6030 to Jerry +Chen / CubeJerry's #7000 (`93effe2a135bf57b9e484cb630d8dd057159aec9`) and +#7001 (`d777f3a0aa2878bea0478918923dabcf86b9878b`). It supplies the owner, +geometry, exact-scalar, root-boundary and finite-cost substitutions left open +by [the preceding review](../pr7000-admission/PROOF-REVIEW.md). +The claimed complex saving is **κ=.00363005817**. + +**Decision: admit κ=.00363005817 under the same five retained assumptions.** +All 18 required executions have completed: eleven source-bound receipts from +the preceding review and seven new executions. The complete native catalogue +parts pass in 222.34, 249.59 and 338.04 seconds; their peak sampled descendant +memory is below 60,000 KiB. Normal and optimized application/scalar checks pass. +The 600-second monolithic timeout is separately retained and contributes no +completed coverage. The source manifest, claim and replay driver bind this +decision to the exact construction and the 134-axis BIT repair. + +This is a conditional application theorem. The native/owned-storage, +compiler, fixed-tape movement and analytic/recovery assumptions are retained, +not proved here. No complete uniform word, literal multiplier execution, +independent human proof or formal-kernel proof is asserted. Execution status +and the admission decision are recorded in VALIDATION.json; prose does not +turn an unfinished check into a pass. + +## 1. Exact coverage and the admission standard + +The previous five registered replays, two supporting local checks and four +normal/optimized review checks are reused only at their recorded scientific +input hashes. They cover cold construction, scalar endpoints, current frame +and owned chronology, COPY into ideal zero, the complete formal caller, +paid/target invoices, independent rational interval inequalities and finite +512-component corroboration. Their original limits remain explicit. + +New `check_application.py` imports no contributor scientific code. It checks +the actual mixed caller's port/owner allocation and all 14,400 native boundary +contacts through degree-two phase polynomials modulo four; it also checks +636 rational BIT frames and 111 main charts. Its ordered job digests bind +117,612 complex and 107,352 BIT paid positions to their actual owners. +Aliased mains, wrong stages, singular spectator bases and omitted contact +translations are rejected. Normal and optimized runs agree. + +The candidate's chart-delta check covered 73 new maps; archive status did +not establish the remaining maps. `check_native_catalogue.py` therefore +checks the complete current union of paid and helper maps, including the +inherited ones, plus every main boundary pair. It uses the pinned Clifford +compiler and the distinct signed-Pauli/Gaussian-phase interpreter. Equal +signed Pauli action fixes a Clifford up to scalar; an exact Gaussian state +fixes that scalar, so this determines the full matrix, not a random sample. +The generic nested-frame factorization and its product lift then apply. +The 3,057-map catalogue is partitioned into the disjoint index intervals +[0,1000), [1000,2000), [2000,3057) of one authenticated sorted catalogue; +the final part also checks all 104 main-boundary pairs. An earlier monolithic +run reached its 600-second limit and is retained as a failed execution, not +reused as completed coverage. Each part repeats the global-phase fault control. + +The exact fixed-rational scalar reference is separate from those engines. +It exercises all 4,469 source/conversion coefficients on 100,148 signed +bit-state cases and rejects 4,149 nonexact division controls. The all-width +argument below follows from the finite carry/remainder invariants, not from +extrapolation of those finite tests. + +## 2. Complex local words and complete physical caller + +For a live field with frame U, write its physical value as +`T_U^(tensor f) z`, on all nine native slots and complete spectators. +Every MOVE applies the exact quotient of its two frames; every scalar +contact is between equal current frames. Consequently the source's exact +scalar endpoint is an identity on arbitrary full arrays at every f, with +the exterior rational coefficients unchanged. A nested quotient factors +as `L C_r R`; tensor the product to obtain one positive rank-rf child with +its two monomial adapters. Absolute phase `i^a` becomes `i^(af)`. +No tensor power is distributed over an ADD or a matrix sum. + +Every autonomous helper is normalized only around the whole completed +native invocation. Its two-sided factors need not be inverses. The new +splits retain their independently checked arbitrary-input cut identities. +There are 400 mains, 1,080 independent helpers and 51 owned native labels. +The 23 owned rises have the exact recipes checked in the preceding review; +the current word's peak is 43 and its 54 lifetimes are checked chronologically. +The retained completed-child rule permits correlated current owned contents; +it does not permit aliasing fields or resuming before complete return. + +For the caller use nine central axes and eighteen disjoint eight-axis stage +blocks, ambient **153**. For each actual odd central direction q, the source +provides an orthonormal basis `[q,b1,...,b8]`. At stage s the map R exchanges +the b directions with that stage's eight standard axes, fixes q and fixes +every other coordinate. The checker verifies its full inverse and spectators. + +Here is the absolute-phase test. Write `Γ(t)=product_v C_v^(t_v)`. +Its character phase is `sum_v t_v parity(v·x) mod4`. Expanding parity gives +linear coefficients and quadratic coefficients modulo four; there are no +higher terms. A residual is an ordinary translation exactly when all +quadratic coefficients vanish and all linear coefficients are even. The +checker computes these coefficients, installs the translation and verifies +both directions of each contact. These Γ frames are auxiliary expressions +for proving the intertwining identities; they are not extra uncharged +Fourier operations executed at the caller entrance. + +After the retained main-boundary monomials, the native endpoint is exactly + +``` +type A, first plane: D_s (x, y + Q^-1 x) +type A, second plane: D_s (u - Q v, v) +type B: D_s (x - Q y, (Q^-1 x + y)/2). +``` + +The second-plane native boundary frames equal the first-plane frames; the +four physical fields are nevertheless distinct. The checker binds all +18 invocations, 96 type-A ports and eight type-B ports. For every invocation, +400 main slots map injectively to the named current caller owners; all 1,080 +helpers have fresh `(invocation, native slot)` tags. No equality of frames +or values merges two owners. The complete raw unit has **23,392** productive +fields: 3,952 root fields and 19,440 helpers. + +Each native MOVE retains its actual position and owner. QUERY uses a separate +full scratch, copies by ADD, executes the signed positive rank-one child and +its adapters, adds the result and clears before proceeding. Its 416 uses +are paid. The 3,616 whole idles act on the union of their distinct selected +stage blocks and are paid once on that owner. The 14,480 global LAMBDA uses +have the ordinary translation-and-scalar lowering established previously; +they create no child or target. A single full query/normalizer bank can be +reused serially; conservatively reserve all 18·51 native banks separately. + +The checked caller identity is in `Q(i)[q,D1,...,D18]/(q^4-1)`, retaining +free body powers. The actual Q has order four, and the stage factors commute +on disjoint complete axes, so substitution is valid at every f. Each output +is a product of distinct stage factors and Q or Q^-1. The latter has the +exact ordinary correction Q². Thus every target is a positive whole job +with charged boundaries and complete spectators. The resulting complete +invoice agrees with the independently replayed P,T and has surplus 1,520. + +## 3. BIT frame, paired-call and delayed-cover application + +A BIT frame supplies rational row bases B for its selected space and A for +its annihilating complement. The new check verifies their dimensions, +annihilation and invertibility of `G=[B^T A^T]` for **all 636 frames**. +It therefore defines the rational projector +`P=G diag(I_dim,0) G^-1`. On the two complete address chunks, the partial +interchange has block matrix `[[I-P,P],[P,I-P]]`. For nested frames, +the projectors commute and their product is the smaller projector; their +interchange quotient is the interchange on the positive-rank difference. +Changing to a basis of that difference and back is precisely the retained +rational whole-job interface. Source XOR contacts commute with a common +current address permutation. The already replayed binary endpoint therefore +lifts to complete chunks and arbitrary payloads, with owned erasures retained. + +For each of the 111 main ports, `[u,B_body]` is an invertible rational basis +with one head and seven complementary body directions. At a stage, exchange +those seven basis directions with seven fresh stage coordinates, fixing u +and all external spectators. In this basis that map is a coordinate +involution; conjugating it gives the explicit rational map on actual fields. +It conjugates the body projector to the stage projector and fixes the head +projector. These equations prove the simultaneous main/body interface; +orthonormality of the seven rational body vectors is not needed. + +The paired caller executes two real native invocations at each stage on +disjoint main pairs. Each invocation receives its own 437 helpers and 237 +owned labels. The full allocation gives **19,950** distinct productive +fields, 107,352 paid positions, 8,532 conservatively reserved native banks +and one serial query bank, before compiler/primitive workspace. The four +queries and every whole idle are charged. Integral transfer occurs before +reduction modulo two; no fraction 1/2 is reduced in characteristic two. +The finite caller equality in `F2[q,D1,...,D18]/(q²-1)` consequently supplies +the stated completed positive outputs without empty-root credit. + +The complete working cap is **134**, as repaired previously. Rational native +maps and subsequent finite compiler matchers form a finite catalogue before +the cover prime is chosen. Choose q larger than the retained cover bound and +avoiding all denominators, nonzero determinants and fixed rank witnesses of +that entire catalogue. The checker's finite witness list concerns the raw +source only; it is not claimed to contain the later compiler's exclusions. +The delayed whole-cover theorem handles right routes `g -> gS` with fixed +rational S. It does not exclude q-dependent cover entries, discard nonunit +pivots without charging the bad classes, or permit weights depending on a +child's fresh cover/roles. External weights may depend on exposed ancestors. + +Use the repaired power 768, cutoff 15, floor 16, logarithm power 617, +`H_B=296630000000000`, and the two separate 10^-10 losses. The covered +saving is .0038525298. Freeze two ordinary backends in order: + +``` +.0034 -> .0038507 -> .00385248. +``` + +The first backend is the selected completed .0034 interface, including its +spectators, restored stock and radix boundary. Each subsequent algorithm +uses only its completed predecessor for ordinary maps/high-part exchanges, +with atom exponent ρ=1/250. Its source-bound cost is +`O(C V [e^(1-ρ) + e^((1-ρ)(1-covered)+ρ(1-previous)) + e^ρ log e])`. +The exact positive bootstrap gaps were checked previously. C is the new +finite constant, not one. Freeze each backend's threshold before using it +in the next step; smaller widths use the predecessor. This dependency is +acyclic and supplies the weaker .00376669 used by the complex outer ledger. + +Reserve the full input-dependent row stock with +`D_stock(e)=2+ceil(log_(N_B)(max(1,ceil(e/ceil(e^ρ)))))` and +`W(w)^D_stock(e) S_old`, as in the pinned delayed-cover proof. The high-digit +reserve is `O_fixed(w log e)`. Internal BIT recursion preserves the entire +external complex factor and restores its own borrowed stock. The fixed two +backend levels are not substituted for the input-dependent recursion depth. + +## 4. Exact fixed-rational scalar service + +Choose the per-native-call scale-1125 route, not the independently rounded +ADD implementation. Multiply each actual public entrance by S=1125, execute +the literal word, and divide each completed output by S. All 53,280 boundary +conversions are counted. The previously checked row and pre-product invariant +proves odd divisibility on the common grid described below. + +For a fixed reduced scalar a/b, multiply an unsigned magnitude bit stream +least-significant-bit first. Its state is carry c, and the transition on bit +u emits `(c+|a|u) mod2` and retains `floor((c+|a|u)/2)`. The carry remains +between 0 and |a|; append `bitlength(|a|)+1` zero bits. Reverse direction +for division by fixed positive b. From remainder r and bit u, form `2r+u`, +emit its comparison with b, and keep the remainder after subtracting b when +necessary. Here `0<=r=1, +integer logarithmic degree d0 and positive rational slack δ in the retained +outer bounds, choose an integer j beyond `4d0/δ` with +`C(j+1)^d0 <= 2^(δj)` and freeze the input threshold at least 2^j. Subsequent +ratios decrease, so the inequality holds thereafter. Choose j on a multiple +of δ's denominator to make this an integer comparison. Likewise the retained +record fiber `2^(Omega(p^(1-epsilon)))` eventually exceeds every new fixed +descriptor polynomial; choose the cutoff after its constants/degrees. +Take the maximum of these finitely many cutoffs, the scalar-fit boundary, +stock conditions and the primitive-family cutoffs. No input-dependent +algorithm or growing tape alphabet is introduced by this choice. + +## 7. Compiler funding and outer conclusion + +The independently checked complex invoice has tested price +`C=.00363005817007=κ+7g`, `g=10^-14`. Use product power 1920, cutoff 11, +completion floor 12, offset 1/7 and actual ambient `153^1920`. +The certified bounds give `alpha<1-10^-27`, `gamma,delta<31/32` and +`1/(1+1920·10^-27)+4(31/32)^1920<1`. The separated paid ceiling is below +the target floor. Whole-job completion and integer splitting retain all +their arrays, paid positions and fresh adapters. + +The ambient-cap proof supplies the source band `(N/A,N]` with A=153^1920; +no target of rank A is needed. Logarithm power 2228 and +`H_C=14174600000000000000` give the checked uniform saving `κ+6g`. +All 54 strict and four functional outer predicates pass; their minimum +positive margin is 10^-15. The completed BIT saving .00385248 supplies the +weaker .00376669 premise with ample positive margin. Section 6 changes finite +constants and eventual thresholds, leaving these rank and exponent inequalities +unchanged. The resulting conclusion is the conditional bound + +`T(n)=O(n (log n)^(1-.00363005817))`. + +The five assumptions are still native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. Local owned ascent, global LAMBDA, +mixed/shared native calls and exact odd division have explicit applications +within those assumptions above. The conclusion does not admit arbitrary +rounded providers, the old numerical tape-cost cap, or newer words with the +same headline/interface names. Any changed source needs its affected checks. + +## Attribution and open next questions + +CubeJerry supplied #7000/#7001 and the precision, owned-ascent, global-LAMBDA +and compiler-application work. DreamingOfClouds supplied the shared native, +two-chain and helper constructions; Ali Romman supplied the helper-basis +lineage. Retain zxv's rational BIT/native/compiler work, Jacob Alan Sussman's +mixed integer compiler, icekylinx/Dugongue's frame theory, Cinna Davis, +Matarener, Chris R/Clear1nsight and all unchanged NOTICE attributions. +The phase-polynomial route method and common-grid induction are credited +reuses; the current occurrence map, complete catalogue closure, exact-scalar +application and finite-cost/root-boundary substitutions are this review's work. +Prepared for Douglas Colkitt with substantial OpenAI Codex assistance, +Apache-2.0; no separate human or formal-kernel verification. + +Open next questions: implement the complete fixed-tape dispatcher rather than +its conditional grammar; tighten the deliberately loose scalar/route constants; +and transfer this application to later changed words using exact-source deltas. +Those questions do not turn an archived successor into an admitted result. diff --git a/research/selected-move-packed-grid-interface/verify.py b/research/selected-move-packed-grid-interface/verify.py new file mode 100644 index 0000000000..50dc99d7e7 --- /dev/null +++ b/research/selected-move-packed-grid-interface/verify.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Read-only exact-source controls for the selected packed grid interface.""" +from fractions import Fraction as Q +from pathlib import Path +from hashlib import sha1,sha256 +import gzip,json,sys,types +HERE=Path(__file__).resolve().parent +PIN='e54523517d0f03e58352e647c403a5af3e525a57' +def need(ok,label): + if not ok:raise ValueError(label) +def mul(a,b):return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]) +def plus(a,b):return (a[0]+b[0],a[1]+b[1]) +def iphase(a,k):return mul(a,[(1,0),(0,1),(-1,0),(0,-1)][k%4]) +def deposit(v,x,a): + b=plus(v.get(x,(Q(0),Q(0))),a) + if b!=(0,0):v[x]=b + else:v.pop(x,None) +def axis(v,j): + out={} + for x,a in v.items(): + deposit(out,x,mul(a,(Q(1,2),Q(1,2)))) + deposit(out,x^(1<>(i*f+j))&1)<>i)&1)<packed,'header-only bridge rejected by exact cardinality') + bridge.append(dict(f=f,K=K,rho=rho,address_bits=a,selected_positions=selected,old_bits=old,packed_bits=packed,ratio=str(Q(old,packed)))) + encode=lambda v:{str(x):list(map(str,z)) for x,z in sorted(v.items())} + out=dict(status='PASS_SELECTED_MOVE_PACKED_GRID_INTERFACE',base=PIN,selected_word_sha256=sha256(word_bytes).hexdigest(),actual_event=24472,actual_move=w['program'][24472],recipe=record,recipe_sha256=sha256(json.dumps(record,sort_keys=True,separators=(',',':')).encode()).hexdigest(),endpoint_only_control=dict(complete_native_entrance=encode(entrance),central_first_prefix=encode(first),complete_native_final=encode(final),entrance_integral=integral(entrance),final_integral=integral(final),prefix_integral=integral(first),interpretation='Rejects endpoint-only admission to this literal provider, not the selected guarded root pipeline.'),common_root_scaled_control=dict(root_axes=18,p=0,h=1,F=18,W=40,scale=1<<18,all_prefixes_integral=True),depth_inequality_cases=tested,packing_cases=bridge,scope='Source-bound numerical admission implication conditional on the existing complete-root Clifford/depth premise and a faithful paid packed ABI. No physical packing, whole MOVE, nonleaf tariff, all-column foundation discharge or new kappa.',source_files_verified=len(sources['bundled_inputs'])) + print(json.dumps(out,indent=2,sort_keys=True)) +if __name__=='__main__':main()