diff --git a/research/selected-owned-gamma-init/CHECKSUMS.sha256 b/research/selected-owned-gamma-init/CHECKSUMS.sha256 new file mode 100644 index 0000000000..a8d0f86d24 --- /dev/null +++ b/research/selected-owned-gamma-init/CHECKSUMS.sha256 @@ -0,0 +1,29 @@ +24cc8c6dbf43aad21a62f03bf13a74f76f3f1547b4f08ffcc50c3a339c7db64b CLAIM.md +3a159222acf8af40a63dad3dd5129e1df5c32dcc92ed29a9021dba00881c112e INDEPENDENT-RESULT.json +920dbd740c0d37db976a14bfa10d2a346060bb7d30c691bdeda874021e7cfa92 INDEPENDENT-REVIEW.md +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 LICENSE +bfed4d98d683d304f349a13203216bda75048ca6d73746bf049c3e874fff35e7 NOTICE.md +1d08b8f75321d63eddd1af648a183fe92595be2aaf1baa917d76685a0094a034 PR-BODY.md +8804e85b284e9ed69e3635dd2b60801141b05e14beeccc66589857fcef4637fb PR-TITLE.txt +ca83f3bc41eeba904bd67cefcafe745eaa4744743d60e9da4387a3be23ec4ada PROOF.md +fbfe08f723720c947aedf764fcdff19fc921ae236039feb500833dc255d7c1f5 README.md +2f5a979901041bf10a7a2d94d1aefc0977189aa58fe34f0734128b71b2b7d085 RESULT.json +e3cce7546d158255d1299f5cb2375759fe272d3d597dd0fb3a874daded28f3f2 SOURCE-BINDING.json +de25b0896f997718a565d9ea9de48d39f8f51e3a8d07b08d6f1af0c61b0dde79 SOURCE-PINS.json +d173c1ec62ba6090979958f9e15a4951dfbe367f7f486df6067d918879e78dfc SOURCES.json +7fc78f8a06e675458db3283b6119e69aaa27309bb62efc6751ab21b91b3639de TASK.json +243ea2e30779da16c93ff5498977b0b658c5331f464bee8a5de3efce5b8f9e90 TESTS.md +fee7e02002666cde27a3a282f7bc600295732723adf64c38ea895981bd21f111 VALIDATION.json +1f6b36d6804e2e103251bbac8e76f46086da4185636078b4d8007a65db49d93f VERIFY.json +f214b0fd3aabf35537bb157b5c9dc7817daa0b4f7af1841f00640f4ead38b69c independent_check.py +9a23a277249597815b8110ff4981f23273dd5f8483698883f2f2b47c1725c2cd init.py +ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee inputs/machine.py +9d39f6596a51aa8717908431017a51e69c3091145b03157087978b8c84073a94 inputs/notices/home-NOTICE.md +5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0 inputs/notices/native-NOTICE +8d46ade764824f03c98a4a1319521e946158f9c7aaa4638d94c656133e18b093 inputs/notices/signed-NOTICE.md +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055 inputs/selected-application-review.md +2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883 inputs/selected-native.json.gz +7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54 inputs/tape_graph.py +5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b predecessor_add.py +05dda474468d6df48e14b6fe056a9f50d1baa9dd45e02bfd1bcb06cb473a8242 source.py +0dd369a07b73641f362997d3b671d58232905b0d48fdc6927cef674b1b8ecdce verify.py diff --git a/research/selected-owned-gamma-init/CLAIM.md b/research/selected-owned-gamma-init/CLAIM.md new file mode 100644 index 0000000000..c11f752546 --- /dev/null +++ b/research/selected-owned-gamma-init/CLAIM.md @@ -0,0 +1,52 @@ +# Recovery checkpoint: selected owned Gamma/HOME initialization + +Status: **local proof, ordinary execution and optimized-Python regression +complete; independent review pending**, 2026-11-14. No new kappa. +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +## Exact intended claim + +For a valid six-positive-Gamma packet `h || DATA` of length F, an exclusively +inactive same-F owned home with arbitrary binary contents can be initialized +by a single uniform finite fixed-tape graph to `h || 0^(F-|h|)`. The graph preserves every donor bit, +keeps permanent owner identities, returns all heads, retires its private guide, +and costs O(F+1) including full-capacity zeroing. A separate literal CLEAR +returns every one of the F body cells to raw zero. Full permanent-home +reservation, gather/scatter, and retained history remain separately charged. +The argument applies to all positive columns and widths, not a finite sample. + +Actual selected source binding: all 54 INIT lifetimes on 51 raw owned labels +can use live public donor0 under the supplied common Gamma6 format. Zero is +invariant under every linear native frame, so donor1349 in frame3 is also +valid header supply for INIT28037 in frame601; equal donor frame is not +necessary. The first scalar contact is SUB28041, which does require equal +current frames. Existing #7567 supplies the exact signed contacts; existing +#7564 supplies MOVE28141. +Both are pending dependencies, not merged assumptions discharged by this work. + +## Scope and method + +Use only donor's immutable header and extent. Parse exactly six Elias-Gamma +codes by a local unary prefix guide; never decode numerical fields or copy +donor DATA into the zero owner. Prove zero-frame covariance, loop invariants +and complete cost. +Replay literal graphs with an independent integer/string oracle. Reject +wrong scalar frames, inactive donors, aliases, overwriting live owned bodies, +partial clear, and incomplete six-code headers. Accept arbitrary correlated +inactive binary bodies. Check heads, exteriors, all private cells, complete +HOME bodies, and old history. Full declared-volume validation remains outside +this valid-packet transformer theorem. + +The source's interleaved donor changes are retained: 728,729,730 change +before their contacts and 1515 changes after ADD28159. A projected static +contact fixture is not the full source word. The exact chronological caller, +root-to-Gamma6/view producer, MOVE precision/cutoff admission, and recursive +paid-leaf service remain explicit obligations. Generic nested ownership was +already proved by earlier selected-owned-dispatch/delimited-stack packages. + +## Stopping rule + +Publish only the proved local initialized-owned contract and actual source +join. Do not invent a full caller or discharge owned_erasure from contact +fixtures. If existing code already supplies this exact typed initializer, +stop and report the overlap instead. Parent owns cross-review/publication. diff --git a/research/selected-owned-gamma-init/INDEPENDENT-RESULT.json b/research/selected-owned-gamma-init/INDEPENDENT-RESULT.json new file mode 100644 index 0000000000..eb6af02470 --- /dev/null +++ b/research/selected-owned-gamma-init/INDEPENDENT-RESULT.json @@ -0,0 +1,64 @@ +{ + "status": "PASS_INDEPENDENT_TYPED_INIT_CLEAR", + "init_sha256": "9a23a277249597815b8110ff4981f23273dd5f8483698883f2f2b47c1725c2cd", + "primitive_cases": [ + { + "shape": [ + 1, + 1, + 1, + 1, + 2, + 1 + ], + "F": 2056, + "INIT_steps": 6183, + "CLEAR_steps": 4116 + }, + { + "shape": [ + 1, + 2, + 1, + 2, + 3, + 340282366920938463463374607431768211461 + ], + "F": 12556, + "INIT_steps": 37813, + "CLEAR_steps": 25116 + }, + { + "shape": [ + 1, + 1, + 1, + 1, + 1, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230663 + ], + "F": 5126, + "INIT_steps": 17440, + "CLEAR_steps": 10256 + } + ], + "cold_home": { + "steps": 92613, + "F": 2056, + "K": 3, + "productive": 2 + }, + "source_inventory": { + "events": 71261, + "lifetimes": 54, + "labels": 51, + "distinct_historical_homes": 1534, + "reused": { + "1504": 2, + "1480": 2, + "1488": 2 + }, + "inventory_sha256": "8ad561d8979dfeaf150a43415d03f0e997127f940deabe1a7dfc736a2eed3d22" + }, + "CLEAR_write_mutation": "detected" +} diff --git a/research/selected-owned-gamma-init/INDEPENDENT-REVIEW.md b/research/selected-owned-gamma-init/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..03be061340 --- /dev/null +++ b/research/selected-owned-gamma-init/INDEPENDENT-REVIEW.md @@ -0,0 +1,19 @@ +# Independent review of the typed INIT/CLEAR interface + +The packed-codec worker independently reviewed init.py (SHA256 9a23a277249597815b8110ff4981f23273dd5f8483698883f2f2b47c1725c2cd), its loop proof, and the exact selected source. The root separately inspected the graph, zero-frame reasoning and bank1526 chronology. This is separate-agent mathematical and implementation review, not independent human acceptance or formal verification. + +## Critical obligations + +For a Gamma field with a prefix zeros, the guide records exactly a unary marks and erases one for each copied suffix bit. Repeating six fixed states copies exactly the header. The following scan overwrites every DATA bit, including arbitrary correlated prior bits, and the three rewinds return donor, target and guide. The exact count is 3A+V+2F+20, with E=2A+6, hence at most4F+8. CLEAR overwrites the full F-bit body and takes2F+4. Neither statement assumes a free root/header producer. Zero is preserved by every native linear frame, while nonzero arithmetic still requires matching current frames. + +The independent script uses its own sparse-dictionary interpreter rather than the imported Program/Tape implementation. It checks three complete primitive packets including a2049-bit cutoff, complementary dirty inactive bodies, opaque exteriors, exact transition bills and private-guide retirement. It also executes the real B1 cold-HOME reservation followed by INIT/CLEAR. Removing CLEAR's nonzero write is detected. + +An independently written event replay verifies every one of71,261 selected events,54 complete owned lifetimes on51 raw labels, live public donor0 at every INIT, and1534 distinct historical homes under the stated permanent-owner policy. This is finite source inventory, not execution of the complete scientific caller. + +## Reproduce + +Run `python3 -I -W error -B independent_check.py` and repeat with `-O`. Expected status: `PASS_INDEPENDENT_TYPED_INIT_CLEAR`. INDEPENDENT-RESULT.json preserves the original review result; publication replay checks portability after replacing only the workspace locator with the package directory. + +## Retained boundaries + +The donor must already be a valid common-format packet and the target must be exclusively inactive with the same extent. The graph does not infer shape from length, validate frame/grid metadata, produce a new cutoff, erase a live borrowed body, or supply failed-child cleanup. The source/stock/root, complete chronological service and recursive-caller obligations remain. diff --git a/research/selected-owned-gamma-init/LICENSE b/research/selected-owned-gamma-init/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/selected-owned-gamma-init/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-owned-gamma-init/NOTICE.md b/research/selected-owned-gamma-init/NOTICE.md new file mode 100644 index 0000000000..83ca1066f5 --- /dev/null +++ b/research/selected-owned-gamma-init/NOTICE.md @@ -0,0 +1,7 @@ +# Attribution and scope + +New material is Apache-2.0, prepared for Jerry Chen / @CubeJerry with substantial OpenAI ChatGPT assistance in research, code, separate review and packaging. The original notices in inputs/notices/ are retained unchanged. + +The permanent HOME graph is from CrocSwap/integer-mult-bounds#7565; the literal interpreter and signed contact implementation are from #7567. #7564 supplies the separate rank-two MOVE ABI comparison and is not executed here. The selected #7000 application review and native archive supply exact chronology; their authors and retained native/compiler/precision lineage remain credited in the bundled notices. All three recent literal interface predecessors remain pending review. + +Gamma coding, finite-state copying, zero erasure and linearity are classical. The contribution is the source-bound uniform typed initializer and full retirement bill at every raw selected lifetime, under the explicitly supplied common-format boundary. Separate automated agent review is not independent human or proof-kernel acceptance. All five foundational assumptions remain and there is no new kappa. diff --git a/research/selected-owned-gamma-init/PR-BODY.md b/research/selected-owned-gamma-init/PR-BODY.md new file mode 100644 index 0000000000..efc69471a1 --- /dev/null +++ b/research/selected-owned-gamma-init/PR-BODY.md @@ -0,0 +1,105 @@ +## Result + +This package supplies the uniform formatted-zero initializer missing between +the permanent HOME dispatcher and the recently published exact native packet +services. On a valid common-format six-Gamma/HOME boundary, one finite +four-tape graph initializes an exclusively inactive owned body from an +existing live header donor, preserves every donor value, returns every head +and retires all private guide storage. Target bits may be arbitrary and +correlated before initialization; complete overwrite is allowed only for an +inactive owned lifetime. + +The zero-frame covariance lemma shows that the donor need not share the +new zero's frame. The exact selected native source has54 INIT/CLEAR lifetimes +on51 raw owned labels, and public donor0 is live at every INIT. The package +therefore binds the one graph at all54 source boundaries under the stated +common-format packet contract. Raw labels1480,1488 and1504 each occur in two +lifetimes; B1's distinct historical-owner policy counts54 owned homes, giving +K=1534 for this raw word, without adding productive credit. + +Standalone INIT costs at most4F+8 literal transitions; full-capacity CLEAR +costs2F+4. Reservation, complete HOME delivery, private copies, restoration, +old backing history and any surrounding child calls remain fully charged. + +## Why this is new and useful + +CrocSwap/integer-mult-bounds#7565 explicitly supplied raw binary reservation +while leaving typed scientific initialization to the caller. +CrocSwap/integer-mult-bounds#7567 supplied all signed bank1526 contacts but +left this formatted-zero producer open; CrocSwap/integer-mult-bounds#7564 +supplied its actual rank-two MOVE under a separate numerical domain. The +new graph closes that local producer interface and proves availability at +every actual INIT, without confusing a zero/header operation with a +nonzero frame transform. The predecessors remain pending review. + +The concrete bank1526 audit retains its real chronology. Donor1349 at +frame3 is accepted as an INIT header donor, while a forged nonzero scalar +contact in the wrong frame is rejected. Interleaved donor updates and +later1515 work are recorded rather than replaced by a frozen contact list. + +Gamma coding, zeroing and linearity are classical; the claimed contribution +is the complete literal source-bound interface and cost, not new arithmetic +or another generic suspended-ancestor theorem. + +## Pins and reproduction + +- Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +- B1 dispatcher dependency: #7565 at + `b4fcc9d64971fdabd0b1d82cfb749d8aac920437`. +- Signed contact dependency: #7567 at + `dcd6352db7e5a5353498203c0c2699334019ba56`. +- Rank-two ABI comparison: #7564 at + `caba500cefa8d1745a187e60198a97b2647e2e90`. +- Full selected native archive and selected #7000 application review are + frozen with byte, Git-blob and SHA-256 pins in `SOURCE-PINS.json`. + +From `research/selected-owned-gamma-init`: + +```sh +python3 -I -W error -B verify.py +python3 -O -I -W error -B verify.py +``` + +Expected marker: `PASS_SELECTED_OWNED_GAMMA_INIT`. `RESULT.json` retains the +full deterministic evidence. The largest case is a complete f=2 packet with +524,300 body bits, exercised through real allocation, INIT and CLEAR in +18,350,585 local transitions. Other cases include widths1,2,3,17, a Gamma +cutoff of bitlength2049, nontrivial spectator/record factors, arbitrary +correlated inactive contents, and a genuine nonzero SUB ABI join. + +The independent string/integer oracle checks complete outputs. Exact local +transition counts are checked against a derived formula. Controls detect +inactive/live ownership violations, wrong nonzero frames, aliasing, malformed +Gamma and a partial CLEAR mutation. Donor contents, parked correlated HOME, +heads, exteriors, scratch and earlier history are verified. + +## Scope, limitations and kappa status + +**No new kappa.** The selected `kappa=0.00363005817` remains conditional on +all five foundational assumptions. This removes a local initializer premise +under an already valid common-format native packet boundary; it does not +construct that boundary from the root input, and equal F alone is not a +proof of equal shape. Root/header/view production, source-strided packing, +real cutoff policy, rank-two intermediate precision, complete compiler +output and chronological child/service returns remain open. + +The full71,261-event scientific word and the complete multiplication caller +are not executed. Source inventory/typing is finite evidence, the universal +initializer theorem is the loop proof, and the corpus checks the literal +implementation. Optimized-Python replay is regression, not independent +mathematical verification. + +## Credit and assistance + +Prepared for @CubeJerry with substantial OpenAI Codex assistance. Credit +the originating #7565/#7567/#7564 packages, the selected #7000 application, +and the earlier generic ownership/continuation work. The data-only alternate +ABI in #7560 and prior common-root-header notes are acknowledged; their +remaining root-producer obligation is retained here. New material is +Apache-2.0. No selected certificate or unrelated file is changed. + +## Independent review and canonical replay + +INDEPENDENT-REVIEW.md and independent_check.py contain the separate sparse-tape and full source-inventory review, with an executed missing-write control. Run `python3 -B scripts/research_package.py --package research/selected-owned-gamma-init` from the repository root for registered normal/optimized primary and independent checks. SOURCE-PINS.json authenticates bundled dependencies; SOURCES.json pins canonical task/selected provenance. + +Publication checkout registered replay, committed bytes/modes, direct base ancestry and export/all8 inputs pass. Exact originating bytes and notices were checked. VALIDATION.json records the scope; no full-history gate success is claimed for the shallow checkout. diff --git a/research/selected-owned-gamma-init/PR-TITLE.txt b/research/selected-owned-gamma-init/PR-TITLE.txt new file mode 100644 index 0000000000..21e3340cf8 --- /dev/null +++ b/research/selected-owned-gamma-init/PR-TITLE.txt @@ -0,0 +1 @@ +Supply uniform typed initialization and complete retirement for every selected raw-native owned lifetime diff --git a/research/selected-owned-gamma-init/PROOF.md b/research/selected-owned-gamma-init/PROOF.md new file mode 100644 index 0000000000..257db46361 --- /dev/null +++ b/research/selected-owned-gamma-init/PROOF.md @@ -0,0 +1,293 @@ +# Uniform typed INIT for all selected raw-native owned lifetimes + +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. Scoped implementation/proof +contribution. **No new kappa; all five foundational assumptions remain.** +New material is Apache-2.0, prepared for @CubeJerry with OpenAI Codex assistance. + +## 1. Exact scope and predecessor obligation + +Pending CrocSwap/integer-mult-bounds#7565 supplies permanent binary HOME +reservation but explicitly requires a scientific initializer before a body +becomes live. Pending CrocSwap/integer-mult-bounds#7567 supplies the five +selected signed contacts of bank1526 on the combined six-Gamma/HOME ABI, +but leaves its formatted-zero producer open. Pending +CrocSwap/integer-mult-bounds#7564 supplies actual rank-two MOVE28141 on +that ABI under its own precision/integrality/cutoff domain. + +The new result is one uniform four-tape initializer, with a linear complete +cost, and its source binding to **all54 actual INIT lifetimes on51 raw owned +labels**. It needs an existing valid common-format header donor, which can +be public row0 throughout this word. The donor need not have the target +frame. Target contents need not already be zero: exclusive inactive ownership +permits complete overwrite of arbitrary binary data. The literal CLEAR +returns the entire F-bit capacity, including its header, to raw zero. + +This removes a local supplied initializer premise; it does not produce the +root descriptor/view, execute the full chronological caller, or discharge +`owned_erasure`. The dependency statuses above remain pending. Generic +nested-lifetime and suspended-ancestor composition were already proved in +selected-owned-dispatch, delimited-continuation-stack and fixed-bank recursive +caller work under their own service contracts; they are not claimed anew. + +## 2. Domain, zero-frame covariance and common-format boundary + +Write + +`h=Gamma(f)Gamma(r)Gamma(P)Gamma(S)Gamma(w)Gamma(c)`, +`E=|h|`, `V=2PSr 2^(9f) w`, and `F=E+V`, + +with all six integers positive. A valid packet is h followed by exactly V +binary scientific DATA bits. Components are signed w-bit two's-complement +numerators on a supplied common grid. The initializer works for w=1 as well +as every larger width; the inherited signed ADD/SUB domain requires w>=2. +Gamma6 does not itself encode the grid, frame or lifetime state. + +Assume a live donor supplies a valid packet, and a physically distinct, +exclusively inactive owned home has the same F-bit binary extent. Every +initial target bit may depend arbitrarily on donor DATA, other homes or +ancestor state. Inactive means no live/public semantic obligation requires +those old target contents to be restored. This is a stronger transformer +domain than fresh B1 raw0^F reservation, not authority to overwrite live +borrowed dirty inputs. Private scratch still has the ordinary blank-entry +contract; historical backing and opaque exteriors remain charged. + +**Zero-frame covariance lemma.** For every native frame U, positive column +count f and complete spectator factor, the linear map +`T_U^(tensor f) tensor I` sends0 to0. Consequently the DATA string0^V is +the exact scientific zero in every such frame on the supplied grid. A header +copied from a same-format donor in any other frame produces a legitimate +zero in the target's source INIT frame. No donor-to-target MOVE is required: +there is no donor scientific value being transported. + +Proof: each output coordinate of a linear map is a sum of coefficients +times zero, hence zero; tensor products and spectator identities are still +linear. The signed zero numerator fits every positive width and is integral +on every grid. This argument does not assume a missing uniform tape +implementation of the native map. It proves only this zero case. Nonzero +ADD/SUB contacts still require their exact equal current frames. + +**What supplies equal format?** The selected #7000 review, section2, acts on +all nine native slots with complete spectators at every f; section5 gives +one common numerical grid and component width through descendants. The raw +native word changes frame labels, not that complete scientific factor. +The imported literal Gamma6 boundary additionally supplies f,r,P,S,w,c and +the already packed view for that invocation. Under that explicit boundary, +all owners share h, E and V even when their frames have different ranks. +The frame table's nine-coordinate alphabet is checked independently of the +packet oracle. The word itself contains no Gamma6 root producer or cutoff +policy, so this package does not infer those from frame IDs or from equal F. +In particular equal total length alone does not prove equal header fields. + +The initializer copies the donor's actual header, including its c. It makes +no later native-cutoff admission claim; the actual rank-two primitive still +requires2f<=c and its interior representability conditions. No numerical +value is decoded just to initialize zero. A caller wishing to change any +format field needs a separate producer, not this header-copy theorem. + +## 3. Complete selected source inventory + +`source.py` authenticates the entire350,722-byte compressed selected native +archive and its canonical JSON, pinned at fork commit +`172f4535ce8dcff79f626410af845f757c1563be`. Its program has71,261 events. +The checker follows every actual INIT, CLEAR, MOVE, ADD, COPY and SCALE +frame/liveness transition. All54 INITs open absent owned lifetimes, and all +have a subsequent matching CLEAR before another INIT of the same label. +All1480 public labels are live throughout. Therefore public donor0 is +available at every INIT, independently of its current DATA or frame. + +The51 raw owned labels include1504,1480 and1488 used for two disjoint +lifetimes each. A permanent-history dispatcher must distinguish those +lifetimes. Under B1's distinct historical-tag policy, a single complete raw +word has54 owned home tags and1480 public tags, thus K=1534, **not**1531. +This is the exact local inventory for that policy; it does not prove a +complete compiler caller's stock or forbid a separately proved safe reuse +scheme. Repeating a raw label never gives extra productive output credit. + +Bank1526's entire contact projection is: + +| Event | Exact instruction | Typed effect | +|---|---|---| +|28037|`INIT 1526 601`|Inactive reservation to zero in frame601| +|28041|`ADD 1526 1349 -1 601`|Exterior SUB| +|28129|`ADD 1526 728 -1 601`|Exterior SUB| +|28135|`ADD 1526 729 -1 601`|Exterior SUB| +|28139|`ADD 1526 730 -1 601`|Exterior SUB| +|28141|`MOVE 1526 601 470 true`|Owned positive-rank-two route| +|28159|`ADD 1515 1526 1 470`|Read1526 and update1515| +|37618|`CLEAR 1526 470`|Complete raw retirement| + +At INIT28037, donor1349 is still in frame3 and donor0 in frame0; both are +valid same-format header sources by zero covariance. Donor728 is also live +in frame601. The verifier explicitly accepts1349 at this earlier boundary. +It separately rejects a forged nonzero contact in frame470 at28041, where +the actual current operands are in601. Wrong source INIT/frame bindings, +inactive donors, aliases and attempts to overwrite a live owned lifetime +are rejected by the static typed checker. These are source-protocol checks, +not runtime frame detection from Gamma6 bits. + +## 4. Literal graph and all-parameter correctness + +`init.primitive` emits a finite graph independent of every input parameter. +HOME is tape0, donor tape1, target tape2, and unary prefix guide tape3. Rules +test current cells, write current cells and move each head by at most one +cell. Python selects six header states offline; runtime has no host integer +decoder, indexed payload operation or numerical Word oracle. + +For each Gamma code, append one guide1 per prefix zero, copying each zero +to target regardless of its previous0/1 value. At the first donor1, write +target1 and move the guide left. Each remaining guide1 is erased and permits +exactly one suffix bit to be copied donor-to-target. Reaching the guide's +permanent `^` completes the code and moves guide to its first blank cell. +Repeat this fixed pattern exactly six times. + +If a code has a prefix zeros, an induction on its prefix scan gives exactly +a guide digits; an induction on popping gives exactly a copied suffix bits. +The guide is blank at the next code boundary. Thus precisely the six-code +header h is copied and both operands reach the first DATA bit. The graph +has never written a donor cell. This holds for every positive code value, +including cutoffs with arbitrarily long encodings. + +The following scan ignores every donor DATA value, overwrites every matching +target DATA bit with0, and requires simultaneous outside delimiters. It +therefore writes exactly V zero DATA bits on the supplied valid common-F +domain. Rewinding both operands and the guide restores every head to its +permanent origin, with private guide blank. The result is exactly h||0^V, +independent of old target contents and arbitrary correlations. + +A malformed/incomplete header or mismatched boundary cannot return through +this graph's successful path. Before return B1 has not scattered the private +working copy, so rejection at an already-reserved entry leaves HOME values +unchanged. Failed private cleanup/retry is not claimed. Reservation already +performed before a failed call is still real work and real retained storage. +The graph is a transformer on valid declared scientific packets; it is not +a validator that recomputes V or discovers external chart/grid metadata. + +The CLEAR graph writes0 at every one of the F working-body cells, including +all header and DATA cells, and returns the operand head. B1 scatters that +complete body to the same permanent owned home, then erases the duplicate. +The result0^F is a retired raw body, not a live Gamma packet. No algebraic +zero inference or partial-capacity erasure substitutes for this scan. + +## 5. Complete time and retained-history bill + +Let A be the sum of the six Gamma prefix-zero counts, so E=2A+6. With local +working copies and all heads at their permanent origins, the initializer +uses exactly + +`1 + (3A+12) + (V+1) + 2(F+2) + 2` +`= 3A+V+2F+20 <= 4F+8` + +transitions. The terms pay entry, all six header/guide loops, every DATA +overwrite and final delimiter test, both complete-field head returns, and +guide return. Simultaneous unit moves on finitely many fixed tapes count +as one transition in the inherited multitape model. Arbitrary old target +bits do not alter this count. CLEAR uses exactly2F+4 transitions. + +For R services, K permanent homes, B initial productive homes and b<=2 +operand tapes, retain the independently supplied B1 dispatcher bound + +`16(R+1)(K+b+1)(F+2)`. + +Add4F+8 per INIT,2F+4 per CLEAR, and every other actual primitive/child bill. +B1's term pays raw reservation, complete HOME scans, full duplicate copies, +scatter, duplicate erasure, and all head returns. Included cold tests begin +with only productive homes and actually execute reserve; raw zeros do not +appear for free. Dirty-inactive tests start from an already existing charged +body, making no claim to allocate dirty storage for free. + +For a sequence of these services on four tapes, fresh HOME extension visits +at most(K-B)(F+1) new cells. Each of the two operand tapes and the shared +reservation/prefix guide visits at most F+1 positive cells. Consequently + +`history_final <= history_entry + (K-B+3)(F+2) + 8` + +is a conservative complete historical increment bound. Entry history +includes earlier erased visits and all extant productive/ancestor storage. +Erasure never refunds that history. The tests deliberately retain a larger +previous private extent. Add each arithmetic/native service's own retained +increment; six tapes suffice for the included signed-primitive composition. +The bound is local and does not replace selected root-volume accounting. + +All successful private windows are blank and all heads return to their B +origins, so another admitted B1 service may follow directly. The graphs make +no CALL. If an actual surrounding caller suspends the bank across a child, +that child's real allocation, restoration and completed-return contracts +remain required and its complete bill is added. No child work is treated +as zero, no ancestor footprint is deallocated by CLEAR, and no continuation +may resume early. Unselected HOME values and opaque exteriors are preserved. + +## 6. Exact composition boundary and limitations + +Successful INIT returns the exact combined packet demanded by #7567 and +#7564: unchanged h, all nine native blocks and complete spectators, fixed +grid, outside delimiter and permanent head origin. This is a byte-for-byte +interface match. It does not replace f by2f, discard seven native blocks, +or charge an unexecuted nonzero frame change as free. The copied header's +shape comes from the supplied donor; its validity and desired context are +not inferred from body length alone. + +The executable join reserves an owned HOME, initializes it, performs the +real inherited SUB from a nonzero donor, and later executes a full CLEAR. +A third correlated binary home is parked throughout. This is a nontrivial +physical ABI composition, not execution of the actual entire source slice. + +Indeed the source changes728 at28127,729 at28133 and730 at28137 before their +SUBs;1349 moves at28039;1515 is initialized at28153 and changes after its +ADD28159. All those current values matter. A frozen donor fixture cannot +replace them. A full source caller must install the actual intervening +operations, maintain their frame/grid state, satisfy every numerical +service domain, and wait for every child and adapter return. This work +does not commute away source events that happen not to write1526. + +The proof removes the local formatted-zero producer premise **under the +existing valid common-format donor boundary** at every raw INIT. Root to +Gamma6/view production, source-strided packing, actual cutoff policy, +interior native precision, all other primitive families, complete compiler +output and recursive paid-leaf admission remain. The full multiplication +bound and all five foundational assumptions remain conditional. + +## 7. Evidence, negative controls and independence + +`python3 -I -W error -B verify.py` executes the literal graph against an +independent ordinary binary-string/two's-complement result oracle. The nine +complete-packet cases include positive widths1,2,3,17; nontrivial r/P/S; +a cutoff with bitlength2049; and a complete f=2 field. Four additional +inactive-body cases use all ones, a donor copy, its complement, and a lone +last-cell1. Exact primitive transition totals are compared to the derived +formula, not merely to another interpreter run. All donor/body bits, +parked values, heads, private windows, permanent markers, exteriors and +retained histories are checked. + +Source controls reject forged INIT/frame/index bindings, an inactive donor, +aliasing and overwriting a live owned lifetime; a wrong nonzero scalar frame +also fails. The differently framed valid header donor1349 is a **positive** +control, preventing a false same-frame restriction. Machine controls reject +an incomplete six-code header and duplicate physical operand identities. +A mutated CLEAR clears only its first cell while returning a full binary +body and clean scratch; the full-body oracle detects its residual contents. +This distinguishes actual capacity erasure from merely passing the ABI. + +The finite corpus corroborates the universal prefix/scan proof; it is not +the proof for every parameter. The source audit is static liveness/typing, +not numerical scientific execution. The inherited interpreter's code is +frozen. A rerun with Python -O ensures assertions are not required gates, +but is regression testing, not a second independent proof. No independence +claim is made for every inherited arithmetic/native kernel. + +## 8. Attribution and open next questions + +Credit @CubeJerry; the selected CrocSwap/integer-mult-bounds#7000 application; +the permanent-home dispatcher #7565; signed-contact #7567; and rank-two +MOVE #7564. Header coding, zero initialization and the linearity lemma are +classical. The contribution is their complete literal interface and all54 +source-bound ownership obligations, not a new arithmetic algorithm. +The borrowed-header/data-only alternative #7560 addresses a different ABI; +it does not supply this combined-packet initializer. Prior unfinished +common-root-header notes correctly retain the root descriptor/packing gate. + +**Open next questions:** instantiate every actual chronological service +surrounding bank1526; produce a source-compatible packed packet and header +from the real root input with an admitted cutoff; or join the all54 INIT +bindings to the materialized full compiler manifest, retaining all54 +historical tags and every child cost. None follows merely from this local +uniform initializer, and no selected-certificate change is proposed. diff --git a/research/selected-owned-gamma-init/README.md b/research/selected-owned-gamma-init/README.md new file mode 100644 index 0000000000..da208b057f --- /dev/null +++ b/research/selected-owned-gamma-init/README.md @@ -0,0 +1,60 @@ +# Initialize all selected raw-native owned lifetimes from a live common-format header + +Scoped enabling proof and literal implementation. **No new kappa**: selected +`kappa=0.00363005817` remains conditional on all five assumptions. Canonical +main is `e54523517d0f03e58352e647c403a5af3e525a57`. + +One uniform four-tape graph fills the formatted-zero premise between #7565's +permanent HOME allocation and #7567/#7564's native packet services. It copies +only a live donor's six positive Gamma header codes and overwrites every +scientific DATA bit with zero. By zero-frame covariance the donor can have +any frame; the target may contain arbitrary binary bits provided its owner +is exclusively inactive. Every head returns and all private scratch retires. + +The exact selected word has54 INIT/CLEAR lifetimes on51 raw owned labels; +public donor0 is live at every INIT. The source inventory therefore binds +the primitive at all54 boundaries under the supplied common-format packet +contract. B1's distinct historical-tag policy counts54 owned homes, including +the second lifetimes of1480,1488 and1504. This is local raw-word inventory, +not a complete caller stock theorem. + +INIT uses at most4F+8 local transitions and complete CLEAR uses2F+4. Physical +reservation, full-home delivery, erasure and historical capacity are charged +separately. Tests include a complete f=2 field, long Gamma codes, arbitrary +correlated inactive bits, nonzero signed arithmetic composition and a +partial-capacity CLEAR mutation that the full-body oracle rejects. + +The root/header/view producer and complete chronological selected caller +remain open. Equal total packet length alone is insufficient to prove common +format. This package removes a local initializer premise under its precise +input domain; it does not discharge `owned_erasure` or improve the full bound. + +## Reproduce + +From this directory: + +```sh +python3 -I -W error -B verify.py +python3 -O -I -W error -B verify.py +``` + +Expected marker: `PASS_SELECTED_OWNED_GAMMA_INIT`. `RESULT.json` is the full +deterministic receipt. Use `--write` only to regenerate it in an isolated +writable copy. No network, third-party Python package or full repository +replay is needed. The complete f=2 tape fixture is the largest bounded case. + +See [PROOF.md](PROOF.md) for the precise theorem, proof and full bill; +[SOURCE-PINS.json](SOURCE-PINS.json) for pins; [PR-BODY.md](PR-BODY.md) for the proposed +review description. Pending #7565/#7567/#7564 remain pending dependencies. + +## Open next questions + +Bind every actual intervening service and child return to the chronological +caller, or implement the root-to-native packet/view producer with the real +cutoff admission. Both remain required for a full selected caller. + +New material: Apache-2.0. Prepared for @CubeJerry with OpenAI Codex assistance. + +## Independent review and canonical replay + +INDEPENDENT-REVIEW.md and independent_check.py contain the separate sparse-tape and full source-inventory review, with an executed missing-write control. Run `python3 -B scripts/research_package.py --package research/selected-owned-gamma-init` from the repository root for registered normal/optimized primary and independent checks. SOURCE-PINS.json authenticates bundled dependencies; SOURCES.json pins canonical task/selected provenance. diff --git a/research/selected-owned-gamma-init/RESULT.json b/research/selected-owned-gamma-init/RESULT.json new file mode 100644 index 0000000000..e43b4c898a --- /dev/null +++ b/research/selected-owned-gamma-init/RESULT.json @@ -0,0 +1,1253 @@ +{ + "additive_join": { + "CLEAR_steps": 131324, + "INIT_SUB_steps": 435111, + "K": 3, + "productive": 2, + "scope": "literal ABI composition; actual source donor-changing intervals remain supplied", + "shape": [ + 1, + 1, + 1, + 1, + 8, + 2 + ], + "tapes": 6 + }, + "arbitrary_inactive_cases": [ + { + "F": 5132, + "old_sha256": "a8f0c058cf8f9d2e0fa8247835dcb28e6c45243a174b632417cb15a7049b1bb1", + "pattern": "all_ones", + "steps": 77023 + }, + { + "F": 5132, + "old_sha256": "c8423ba32a727e47fd9b123529c1aed67287bd0177e004bf29aa93c19c0ef6ea", + "pattern": "same_as_donor", + "steps": 77023 + }, + { + "F": 5132, + "old_sha256": "25497e2d7d69e33ce7753f4ddee4ec2cb71fd42a8ba07e47c4918a2c92366efa", + "pattern": "complement_of_donor", + "steps": 77023 + }, + { + "F": 5132, + "old_sha256": "f4aba13d4c36b1594188ca8d8977add0efe36d3663c6339a829b1e1fb4d67f51", + "pattern": "last_cell_only", + "steps": 77023 + } + ], + "cases": [ + { + "E": 6, + "F": 1030, + "V": 1024, + "clear": false, + "complete_bound": 169248, + "donor_sha256": "e4e58afc328faa87c14c1be3b650c96abbbad16ec62f95a2ab391ecc8e99954f", + "history_entry": 6186, + "history_final": 9279, + "shape": [ + 1, + 1, + 1, + 1, + 1, + 1 + ], + "states": 49, + "steps": 23748 + }, + { + "E": 6, + "F": 1030, + "V": 1024, + "clear": true, + "complete_bound": 253872, + "donor_sha256": "e4e58afc328faa87c14c1be3b650c96abbbad16ec62f95a2ab391ecc8e99954f", + "history_entry": 6186, + "history_final": 9279, + "shape": [ + 1, + 1, + 1, + 1, + 1, + 1 + ], + "states": 64, + "steps": 36132 + }, + { + "E": 10, + "F": 2058, + "V": 2048, + "clear": false, + "complete_bound": 337840, + "donor_sha256": "daa68606f9c064f491bf0abc757d0b92e92d0a62e76dbcd761561d2bdb9d7421", + "history_entry": 12354, + "history_final": 18531, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 2 + ], + "states": 49, + "steps": 47394 + }, + { + "E": 10, + "F": 2058, + "V": 2048, + "clear": true, + "complete_bound": 506760, + "donor_sha256": "daa68606f9c064f491bf0abc757d0b92e92d0a62e76dbcd761561d2bdb9d7421", + "history_entry": 12354, + "history_final": 18531, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 2 + ], + "states": 64, + "steps": 72114 + }, + { + "E": 14, + "F": 36878, + "V": 36864, + "clear": false, + "complete_bound": 6048320, + "donor_sha256": "611ee4eead1bf6ad4340d3b1ec8799ec38a477d2cfbe27dcb0817e8ed3074f8f", + "history_entry": 221274, + "history_final": 331911, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "states": 49, + "steps": 848256 + }, + { + "E": 14, + "F": 36878, + "V": 36864, + "clear": true, + "complete_bound": 9072480, + "donor_sha256": "611ee4eead1bf6ad4340d3b1ec8799ec38a477d2cfbe27dcb0817e8ed3074f8f", + "history_entry": 221274, + "history_final": 331911, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "states": 64, + "steps": 1290816 + }, + { + "E": 4110, + "F": 21518, + "V": 17408, + "clear": false, + "complete_bound": 3529280, + "donor_sha256": "c193199b28064e5346a36d59952b4b4e89e3099cdb0ec0476ce79cf7970a2ef3", + "history_entry": 129114, + "history_final": 193671, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "states": 49, + "steps": 497024 + }, + { + "E": 4110, + "F": 21518, + "V": 17408, + "clear": true, + "complete_bound": 5293920, + "donor_sha256": "c193199b28064e5346a36d59952b4b4e89e3099cdb0ec0476ce79cf7970a2ef3", + "history_entry": 129114, + "history_final": 193671, + "shape": [ + 1, + 1, + 1, + 1, + 17, + 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656 + ], + "states": 64, + "steps": 755264 + }, + { + "E": 12, + "F": 524300, + "V": 524288, + "clear": true, + "complete_bound": 128978292, + "donor_sha256": "f922ce634452796eb30112c62125e06124d51aace81ef7b5c475a93b2564dc19", + "history_entry": 3145806, + "history_final": 4718709, + "shape": [ + 2, + 1, + 1, + 1, + 1, + 4 + ], + "states": 64, + "steps": 18350585 + } + ], + "controls": [ + "incomplete_six_Gamma_header", + "physical_operand_alias", + "partial_capacity_clear_detected_by_full_body_oracle" + ], + "exact_local_cost": [ + { + "derived_steps": 3104, + "shape": [ + 1, + 1, + 1, + 1, + 1, + 1 + ], + "states": 23, + "steps": 3104 + }, + { + "derived_steps": 6190, + "shape": [ + 1, + 1, + 1, + 1, + 2, + 2 + ], + "states": 23, + "steps": 6190 + }, + { + "derived_steps": 110652, + "shape": [ + 1, + 2, + 2, + 3, + 3, + 1 + ], + "states": 23, + "steps": 110652 + } + ], + "marker": "PASS_SELECTED_OWNED_GAMMA_INIT", + "scope": "typed INIT and full-capacity CLEAR; no full chronological selected caller or new kappa", + "source": { + "INIT_binding": { + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 601, + "index": 28037, + "owner": 1526 + }, + "all_INIT_lifetimes": [ + { + "clear_index": 37618, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 601, + "index": 28037, + "ordinal_for_raw_owner": 0, + "owner": 1526 + }, + { + "clear_index": 37664, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 470, + "index": 28097, + "ordinal_for_raw_owner": 0, + "owner": 1487 + }, + { + "clear_index": 42806, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 477, + "index": 28099, + "ordinal_for_raw_owner": 0, + "owner": 1489 + }, + { + "clear_index": 42776, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 1090, + "index": 28109, + "ordinal_for_raw_owner": 0, + "owner": 1499 + }, + { + "clear_index": 37619, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 470, + "index": 28121, + "ordinal_for_raw_owner": 0, + "owner": 1500 + }, + { + "clear_index": 39073, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 470, + "index": 28153, + "ordinal_for_raw_owner": 0, + "owner": 1515 + }, + { + "clear_index": 39074, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 470, + "index": 28155, + "ordinal_for_raw_owner": 0, + "owner": 1525 + }, + { + "clear_index": 39075, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 1090, + "index": 28157, + "ordinal_for_raw_owner": 0, + "owner": 1516 + }, + { + "clear_index": 43010, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 260, + "index": 29918, + "ordinal_for_raw_owner": 0, + "owner": 1519 + }, + { + "clear_index": 41761, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 594, + "index": 30308, + "ordinal_for_raw_owner": 0, + "owner": 1510 + }, + { + "clear_index": 36725, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 267, + "index": 30616, + "ordinal_for_raw_owner": 0, + "owner": 1508 + }, + { + "clear_index": 41821, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 117, + "index": 30643, + "ordinal_for_raw_owner": 0, + "owner": 1503 + }, + { + "clear_index": 37263, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 543, + "index": 30791, + "ordinal_for_raw_owner": 0, + "owner": 1507 + }, + { + "clear_index": 37586, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 260, + "index": 30810, + "ordinal_for_raw_owner": 0, + "owner": 1485 + }, + { + "clear_index": 42784, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 1091, + "index": 30811, + "ordinal_for_raw_owner": 0, + "owner": 1490 + }, + { + "clear_index": 42781, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 1091, + "index": 30814, + "ordinal_for_raw_owner": 0, + "owner": 1493 + }, + { + "clear_index": 40843, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 541, + "index": 30820, + "ordinal_for_raw_owner": 0, + "owner": 1481 + }, + { + "clear_index": 39220, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 593, + "index": 31002, + "ordinal_for_raw_owner": 0, + "owner": 1509 + }, + { + "clear_index": 38231, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 115, + "index": 31736, + "ordinal_for_raw_owner": 0, + "owner": 1504 + }, + { + "clear_index": 37588, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 431, + "index": 32419, + "ordinal_for_raw_owner": 0, + "owner": 1514 + }, + { + "clear_index": 37592, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 431, + "index": 32550, + "ordinal_for_raw_owner": 0, + "owner": 1486 + }, + { + "clear_index": 42816, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 517, + "index": 32551, + "ordinal_for_raw_owner": 0, + "owner": 1492 + }, + { + "clear_index": 42787, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 243, + "index": 32556, + "ordinal_for_raw_owner": 0, + "owner": 1497 + }, + { + "clear_index": 37591, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 431, + "index": 32561, + "ordinal_for_raw_owner": 0, + "owner": 1498 + }, + { + "clear_index": 36075, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 599, + "index": 33264, + "ordinal_for_raw_owner": 0, + "owner": 1520 + }, + { + "clear_index": 37587, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 600, + "index": 33530, + "ordinal_for_raw_owner": 0, + "owner": 1524 + }, + { + "clear_index": 37589, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 431, + "index": 33534, + "ordinal_for_raw_owner": 0, + "owner": 1523 + }, + { + "clear_index": 37590, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 243, + "index": 33535, + "ordinal_for_raw_owner": 0, + "owner": 1518 + }, + { + "clear_index": 37573, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 598, + "index": 34300, + "ordinal_for_raw_owner": 0, + "owner": 1522 + }, + { + "clear_index": 37707, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 394, + "index": 34303, + "ordinal_for_raw_owner": 0, + "owner": 1513 + }, + { + "clear_index": 37708, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 394, + "index": 34304, + "ordinal_for_raw_owner": 0, + "owner": 1521 + }, + { + "clear_index": 37709, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 240, + "index": 34305, + "ordinal_for_raw_owner": 0, + "owner": 1517 + }, + { + "clear_index": 37575, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 394, + "index": 34443, + "ordinal_for_raw_owner": 0, + "owner": 1484 + }, + { + "clear_index": 42801, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 518, + "index": 34444, + "ordinal_for_raw_owner": 0, + "owner": 1491 + }, + { + "clear_index": 42800, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 240, + "index": 34448, + "ordinal_for_raw_owner": 0, + "owner": 1495 + }, + { + "clear_index": 37574, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 394, + "index": 34453, + "ordinal_for_raw_owner": 0, + "owner": 1496 + }, + { + "clear_index": 43006, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 1091, + "index": 35857, + "ordinal_for_raw_owner": 0, + "owner": 1530 + }, + { + "clear_index": 37520, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 529, + "index": 35910, + "ordinal_for_raw_owner": 0, + "owner": 1527 + }, + { + "clear_index": 41753, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 541, + "index": 35941, + "ordinal_for_raw_owner": 0, + "owner": 1529 + }, + { + "clear_index": 38219, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 549, + "index": 35968, + "ordinal_for_raw_owner": 0, + "owner": 1528 + }, + { + "clear_index": 37609, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 595, + "index": 36055, + "ordinal_for_raw_owner": 0, + "owner": 1511 + }, + { + "clear_index": 40099, + "donor": 0, + "donor_frame": 0, + "donor_frame_columns": [ + 11 + ], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 597, + "index": 36061, + "ordinal_for_raw_owner": 0, + "owner": 1512 + }, + { + "clear_index": 37563, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 737, + "index": 36754, + "ordinal_for_raw_owner": 0, + "owner": 1480 + }, + { + "clear_index": 37481, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 531, + "index": 36879, + "ordinal_for_raw_owner": 0, + "owner": 1505 + }, + { + "clear_index": 38224, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 559, + "index": 37344, + "ordinal_for_raw_owner": 0, + "owner": 1506 + }, + { + "clear_index": 40125, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 1031, + "index": 37350, + "ordinal_for_raw_owner": 0, + "owner": 1502 + }, + { + "clear_index": 41056, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 549, + "index": 37544, + "ordinal_for_raw_owner": 0, + "owner": 1501 + }, + { + "clear_index": 37617, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 529, + "index": 37545, + "ordinal_for_raw_owner": 0, + "owner": 1482 + }, + { + "clear_index": 40126, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 591, + "index": 37566, + "ordinal_for_raw_owner": 0, + "owner": 1483 + }, + { + "clear_index": 37585, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 260, + "index": 37578, + "ordinal_for_raw_owner": 0, + "owner": 1494 + }, + { + "clear_index": 40842, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 549, + "index": 37698, + "ordinal_for_raw_owner": 1, + "owner": 1480 + }, + { + "clear_index": 37702, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 595, + "index": 37699, + "ordinal_for_raw_owner": 0, + "owner": 1488 + }, + { + "clear_index": 42896, + "donor": 0, + "donor_frame": 249, + "donor_frame_columns": [ + 11, + 38 + ], + "donor_last_MOVE": 36481, + "donor_public": true, + "frame": 603, + "index": 37703, + "ordinal_for_raw_owner": 1, + "owner": 1488 + }, + { + "clear_index": 42753, + "donor": 0, + "donor_frame": 634, + "donor_frame_columns": [ + 7, + 11, + 16, + 33, + 64, + 128, + 256 + ], + "donor_last_MOVE": 38272, + "donor_public": true, + "frame": 245, + "index": 40847, + "ordinal_for_raw_owner": 1, + "owner": 1504 + } + ], + "bank1526_contacts": [ + [ + 28037, + [ + "INIT", + 1526, + 601 + ] + ], + [ + 28041, + [ + "ADD", + 1526, + 1349, + "-1", + 601 + ] + ], + [ + 28129, + [ + "ADD", + 1526, + 728, + "-1", + 601 + ] + ], + [ + 28135, + [ + "ADD", + 1526, + 729, + "-1", + 601 + ] + ], + [ + 28139, + [ + "ADD", + 1526, + 730, + "-1", + 601 + ] + ], + [ + 28141, + [ + "MOVE", + 1526, + 601, + 470, + true + ] + ], + [ + 28159, + [ + "ADD", + 1515, + 1526, + "1", + 470 + ] + ], + [ + 37618, + [ + "CLEAR", + 1526, + 470 + ] + ] + ], + "common_format_boundary": "all packets in the supplied raw-native invocation share f,r,P,S,w,c and grid; source word alone contains no Gamma6 producer", + "controls": [ + "wrong_INIT_frame", + "inactive_owned_donor", + "donor_owned_alias", + "wrong_INIT_index", + "wrong_nonzero_scalar_contact_frame", + "overwrite_live_owned_lifetime" + ], + "different_frame_donor_accepted": { + "donor": 1349, + "donor_frame": 3, + "donor_frame_columns": [], + "donor_last_MOVE": null, + "donor_public": true, + "frame": 601, + "index": 28037, + "owner": 1526 + }, + "frames_at_INIT": { + "1349": 3, + "728": 601, + "729": 601, + "730": 601 + }, + "historical_owned_lifetimes": 54, + "interleaving_witnesses": [ + [ + 28127, + [ + "ADD", + 728, + 1500, + "1", + 601 + ] + ], + [ + 28131, + [ + "MOVE", + 728, + 601, + 471, + false + ] + ], + [ + 28133, + [ + "ADD", + 729, + 1500, + "1", + 601 + ] + ], + [ + 28137, + [ + "ADD", + 730, + 1500, + "1", + 601 + ] + ], + [ + 28153, + [ + "INIT", + 1515, + 470 + ] + ], + [ + 28161, + [ + "SCALE", + 1515, + "-1/4", + 470 + ] + ], + [ + 28165, + [ + "ADD", + 1515, + 402, + "1/4", + 470 + ] + ] + ], + "owned_labels": 51, + "program_length": 71261, + "reused_raw_labels": { + "1480": 2, + "1488": 2, + "1504": 2 + }, + "scope": "all exact INIT lifetime bindings; no numerical full-word execution or root format producer", + "source": { + "blob": "74563a7867d9d762b6588f65362369668841bb3e", + "bytes": 350722, + "canonical_word_sha256": "91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/reference/selected-native.json.gz", + "repository": "CubeJerry/integer-mult-bounds", + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883" + } + } +} diff --git a/research/selected-owned-gamma-init/SOURCE-BINDING.json b/research/selected-owned-gamma-init/SOURCE-BINDING.json new file mode 100644 index 0000000000..69a55b2f32 --- /dev/null +++ b/research/selected-owned-gamma-init/SOURCE-BINDING.json @@ -0,0 +1,36 @@ +{ + "status": "PASS_EXACT_ORIGIN_BYTES", + "checks": [ + { + "package": "selected-owned-gamma-init", + "pin": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437:research/compiler-permanent-home-dispatch/tape_graph.py", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7", + "bytes": 12069 + }, + { + "package": "selected-owned-gamma-init", + "pin": "dcd6352db7e5a5353498203c0c2699334019ba56:research/source-bound-signed-home-add/inputs/machine.py", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "bytes": 6041 + }, + { + "package": "selected-owned-gamma-init", + "pin": "dcd6352db7e5a5353498203c0c2699334019ba56:research/source-bound-signed-home-add/add.py", + "git_blob": "ff9b8c45e37f0f3f5f6043efe6ed74b3fd4a8fe2", + "bytes": 5110 + }, + { + "package": "selected-owned-gamma-init", + "pin": "172f4535ce8dcff79f626410af845f757c1563be:research/literal-native-quadratic-phase/reference/selected-native.json.gz", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "bytes": 350722 + }, + { + "package": "selected-owned-gamma-init", + "pin": "e54523517d0f03e58352e647c403a5af3e525a57:docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "bytes": 25533 + } + ], + "notice_count": 3 +} diff --git a/research/selected-owned-gamma-init/SOURCE-PINS.json b/research/selected-owned-gamma-init/SOURCE-PINS.json new file mode 100644 index 0000000000..5a2593ae9b --- /dev/null +++ b/research/selected-owned-gamma-init/SOURCE-PINS.json @@ -0,0 +1,97 @@ +{ + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "bytes": 12069, + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "git_blob": "f307133f2b0bba2e5969825cb814503d819322e7", + "local": "inputs/tape_graph.py", + "path": "research/compiler-permanent-home-dispatch/tape_graph.py", + "pull_request": 7565, + "repository": "CubeJerry/integer-mult-bounds", + "sha256": "7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54", + "status_at_pin": "open pending review" + }, + { + "bytes": 6041, + "commit": "dcd6352db7e5a5353498203c0c2699334019ba56", + "git_blob": "fcd4ac01f03a4689fe9fa45d4ca5ea95950103da", + "local": "inputs/machine.py", + "path": "research/source-bound-signed-home-add/inputs/machine.py", + "pull_request": 7567, + "repository": "CubeJerry/integer-mult-bounds", + "sha256": "ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee", + "status_at_pin": "open pending review" + }, + { + "bytes": 5110, + "commit": "dcd6352db7e5a5353498203c0c2699334019ba56", + "git_blob": "ff9b8c45e37f0f3f5f6043efe6ed74b3fd4a8fe2", + "local": "predecessor_add.py", + "path": "research/source-bound-signed-home-add/add.py", + "pull_request": 7567, + "repository": "CubeJerry/integer-mult-bounds", + "sha256": "5534273103aacf26f0096e75b6c7ab5d8f3286f8b66f0b5d42ba8631e2c94e8b", + "status_at_pin": "open pending review" + }, + { + "bytes": 350722, + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "git_blob": "74563a7867d9d762b6588f65362369668841bb3e", + "local": "inputs/selected-native.json.gz", + "path": "research/literal-native-quadratic-phase/reference/selected-native.json.gz", + "repository": "CubeJerry/integer-mult-bounds", + "sha256": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883" + }, + { + "bytes": 25533, + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "local": "inputs/selected-application-review.md", + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "pull_request": 7000, + "repository": "CrocSwap/integer-mult-bounds", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "status_at_pin": "selected application" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "b4fcc9d64971fdabd0b1d82cfb749d8aac920437", + "path": "research/compiler-permanent-home-dispatch/NOTICE.md", + "local": "inputs/notices/home-NOTICE.md", + "bytes": 2050, + "git_blob": "23bbd0b1c82915aa9426dd12dda5206a3c4874a1", + "sha256": "9d39f6596a51aa8717908431017a51e69c3091145b03157087978b8c84073a94", + "role": "unchanged predecessor notice" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "dcd6352db7e5a5353498203c0c2699334019ba56", + "path": "research/source-bound-signed-home-add/NOTICE.md", + "local": "inputs/notices/signed-NOTICE.md", + "bytes": 1957, + "git_blob": "3f4d72ffe066e478cedb97b7dc8078de6e20966d", + "sha256": "8d46ade764824f03c98a4a1319521e946158f9c7aaa4638d94c656133e18b093", + "role": "unchanged predecessor notice" + }, + { + "repository": "CubeJerry/integer-mult-bounds", + "commit": "172f4535ce8dcff79f626410af845f757c1563be", + "path": "research/literal-native-quadratic-phase/NOTICE", + "local": "inputs/notices/native-NOTICE", + "bytes": 808, + "git_blob": "7a1f1da9c59d40b1e72905fee5344a8db9ca4353", + "sha256": "5654eeb7fdc1acd6a6d246ef87b1155812efdcd0949f54be78e048fe905fbae0", + "role": "unchanged predecessor notice" + } + ], + "proof_only_dependencies": [ + { + "head": "caba500cefa8d1745a187e60198a97b2647e2e90", + "pr": 7564, + "role": "actual rank-two MOVE ABI comparison; kernel not imported or executed here", + "status_at_pin": "open pending review" + } + ], + "selected_kappa": "0.00363005817" +} diff --git a/research/selected-owned-gamma-init/SOURCES.json b/research/selected-owned-gamma-init/SOURCES.json new file mode 100644 index 0000000000..89b7c5747a --- /dev/null +++ b/research/selected-owned-gamma-init/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + } + ] +} diff --git a/research/selected-owned-gamma-init/TASK.json b/research/selected-owned-gamma-init/TASK.json new file mode 100644 index 0000000000..5d2d29b10b --- /dev/null +++ b/research/selected-owned-gamma-init/TASK.json @@ -0,0 +1,90 @@ +{ + "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": "Prove and implement one uniform four-tape typed INIT/CLEAR service for all 54 selected raw-native owned lifetimes under the supplied common Gamma6/HOME boundary.", + "scope_change_reason": "Narrow the assumption audit to the typed initializer explicitly missing from permanent HOME reservation and selected signed contacts.", + "bottleneck_link": "A raw binary reservation is not a live scientific packet; formatted-zero production and full retirement must be charged at the actual selected INIT/CLEAR boundaries.", + "budget_minutes": 90, + "stop_rule": "Verify the uniform primitive and all54 source bindings; retain root/header/view production and global ownership/child closure.", + "outcome": "completed", + "evidence": "PROOF.md, init.py, source.py, verify.py and independent_check.py", + "result_summary": "Uniform arbitrary-inactive-target INIT and full-capacity CLEAR with exact transition bills; all54 source lifetime binding; no global assumption discharged.", + "author": "Jerry Chen / @CubeJerry", + "ai_assistance": "Substantial OpenAI ChatGPT assistance in research, implementation, independent verification and packaging.", + "open_questions": [ + { + "question": "Produce the valid Gamma6 packet and common view from actual old root input.", + "why_it_matters": "The local initializer currently needs an already live common-format donor.", + "first_step": "Construct a paid physical producer from a pinned old-coded field/context without assuming a free format change.", + "blocked_by": "Root source/header/view and stock interface must be supplied." + }, + { + "question": "Compose complete chronological native services and recursive children through permanent HOME.", + "why_it_matters": "Typed local primitives do not prove the selected compiler or ownership assumption.", + "first_step": "Pin one complete actual occurrence and all service entry/return and numerical domains.", + "blocked_by": "Remaining source delivery, frame/MOVE and faster nonleaf contracts." + } + ] +} diff --git a/research/selected-owned-gamma-init/TESTS.md b/research/selected-owned-gamma-init/TESTS.md new file mode 100644 index 0000000000..23b72ead06 --- /dev/null +++ b/research/selected-owned-gamma-init/TESTS.md @@ -0,0 +1,41 @@ +# Executed local verification + +Environment: Python3.12.14, Linux; no third-party packages. Canonical base +`e54523517d0f03e58352e647c403a5af3e525a57`. + +Executed: + +```sh +python3 -I -W error -B verify.py --write +python3 -O -I -W error -B verify.py +``` + +Both completed with `PASS_SELECTED_OWNED_GAMMA_INIT`. The second command +authenticates the frozen source files and compares the full deterministic +receipt. The first non-writing receipt comparison initially compared JSON +lists with in-memory tuples; that verifier-only normalization bug was fixed +and the entire optimized command then rerun successfully. No scientific +result or transition graph depended on that bug. + +Evidence retained in `RESULT.json`: + +- Nine complete scientific packet runs, including the full f=2, F=524300 + allocation/INIT/CLEAR case with18350585 literal transitions. +- Four arbitrary inactive-body runs: all1, equal to donor, complement of + donor, and a final-cell1. All preserve donor and return the exact typed zero. +- Three separately checked exact local transition counts, matching + `3A+V+2F+20` and the uniform bound `4F+8`. +- Real inherited SUB composition from a nonzero initialized donor, followed + by complete header/DATA CLEAR, with a third correlated parked HOME intact. +- All54 exact source INIT/CLEAR lifetimes,51 raw labels and1480 public rows; + source frame/liveness verification and repeated-label inventory. +- Differently framed donor1349 accepted for INIT28037; incorrect nonzero + scalar frame, inactive donor, alias, live-target overwrite and wrong source + binding rejected. +- Incomplete Gamma header rejection and a partial-CLEAR mutation caught by + the complete-body result oracle despite its otherwise clean return ABI. + +Every successful complete run checks heads, origins, private body retirement, +opaque exteriors and retained earlier history. The fixed unary graph proof +establishes the universal claim; finite cases and source inventory are not +a universal scientific execution of the selected multiplication program. diff --git a/research/selected-owned-gamma-init/VALIDATION.json b/research/selected-owned-gamma-init/VALIDATION.json new file mode 100644 index 0000000000..754865709f --- /dev/null +++ b/research/selected-owned-gamma-init/VALIDATION.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "status": "PASS_SCOPED_PUBLICATION_CHECKS", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "classification": "uniform local initializer and exact selected source inventory; no new kappa", + "passed": [ + "Registered normal/optimized primary and independent sparse-tape replay", + "Exact source bytes, Git blobs, SHA256 and original notice retention", + "Committed package bytes and modes", + "Direct canonical-base ancestry", + "Portable export and all8 declared inputs" + ], + "independent_review": "INDEPENDENT-REVIEW.md and independent_check.py; separate sparse-tape interpreter, full71,261event chronology,54 lifetimes and CLEAR-write mutation", + "history_gate_boundary": "No generic full-history check success claimed for the intentionally shallow checkout. Canonical source pins were checked at the exact base; bundled source pins were compared with originating commit bytes in the reusable local cache.", + "limitations": [ + "No human or formal-kernel acceptance", + "No full scientific source replay or root Gamma6 producer", + "No global assumption discharged; selected kappa unchanged" + ], + "core_hashes": { + "init.py": "9a23a277249597815b8110ff4981f23273dd5f8483698883f2f2b47c1725c2cd", + "source.py": "05dda474468d6df48e14b6fe056a9f50d1baa9dd45e02bfd1bcb06cb473a8242", + "verify.py": "0dd369a07b73641f362997d3b671d58232905b0d48fdc6927cef674b1b8ecdce", + "independent_check.py": "f214b0fd3aabf35537bb157b5c9dc7817daa0b4f7af1841f00640f4ead38b69c", + "PROOF.md": "ca83f3bc41eeba904bd67cefcafe745eaa4744743d60e9da4387a3be23ec4ada" + } +} diff --git a/research/selected-owned-gamma-init/VERIFY.json b/research/selected-owned-gamma-init/VERIFY.json new file mode 100644 index 0000000000..e537ea34e5 --- /dev/null +++ b/research/selected-owned-gamma-init/VERIFY.json @@ -0,0 +1,68 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/selected-owned-gamma-init/inputs/tape_graph.py", + "research/selected-owned-gamma-init/inputs/machine.py", + "research/selected-owned-gamma-init/predecessor_add.py", + "research/selected-owned-gamma-init/inputs/selected-native.json.gz", + "research/selected-owned-gamma-init/inputs/selected-application-review.md", + "research/selected-owned-gamma-init/inputs/notices/home-NOTICE.md", + "research/selected-owned-gamma-init/inputs/notices/signed-NOTICE.md", + "research/selected-owned-gamma-init/inputs/notices/native-NOTICE" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Primary complete packet, source bindings, exact costs and adversarial controls" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Primary complete packet, source bindings, exact costs and adversarial controls with assertions disabled" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 120, + "checks": "Separate sparse-tape interpreter, source inventory and missing-CLEAR-write mutation" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/independent_check.py" + ], + "timeout_seconds": 120, + "checks": "Separate sparse-tape interpreter, source inventory and missing-CLEAR-write mutation with assertions disabled" + } + ] +} diff --git a/research/selected-owned-gamma-init/independent_check.py b/research/selected-owned-gamma-init/independent_check.py new file mode 100644 index 0000000000..a5f7c150a2 --- /dev/null +++ b/research/selected-owned-gamma-init/independent_check.py @@ -0,0 +1,108 @@ +"""Independent sparse-tape/chronology check of worker B's typed INIT/CLEAR.""" +from pathlib import Path +import gzip,hashlib,importlib.util,json,sys +P=Path(__file__).resolve().parent +spec=importlib.util.spec_from_file_location('reviewed_typed_init',P/'init.py') +I=importlib.util.module_from_spec(spec);sys.modules[spec.name]=I +exec(compile((P/'init.py').read_bytes(),str(P/'init.py'),'exec'),I.__dict__) + +def need(ok,msg): + if not ok:raise ValueError(msg) + +def execute(g,mem,heads,start=None): + q=g.start if start is None else start;steps=0;low=heads[:] + while q!='HALT': + candidates=[r for r in g.rules[q] if all(mem[t].get(heads[t],'_')==s for t,s in r.tests)] + need(len(candidates)==1,'literal determinism/entry');r=candidates[0] + for t,s in r.writes:mem[t][heads[t]]=s + for t,d in r.moves: + need(d in (-1,0,1),'unit moves');heads[t]+=d;low[t]=min(low[t],heads[t]) + q=r.target;steps+=1 + need(steps<5_000_000,'finite review budget') + return steps,low + +def gamma(n): + s=format(n,'b');return '0'*(len(s)-1)+s + +def packet(shape): + f,r,p,s,w,c=shape;h=''.join(map(gamma,shape));V=2*p*s*r*(1<<(9*f))*w + data=('10100111001001'*((V+13)//14))[:V] + return h+data,h,V + +def tape(text,origin):return {origin+i:s for i,s in enumerate(text)}|{origin-3:'X'} + +def primitive_case(shape): + body,h,V=packet(shape);F=len(body);orig=[5,8,11,14] + target=''.join('1' if x=='0' else '0' for x in body) + mem=[tape('^',orig[0]),tape('^'+body+'|',orig[1]),tape('^'+target+'|',orig[2]),tape('^',orig[3])] + before=[dict(x) for x in mem];heads=orig[:] + g=I.D.Graph();g.start=I.primitive(g,'INIT',2,'HALT');g.validate() + steps,low=execute(g,mem,heads);A=sum(n.bit_length()-1 for n in shape) + need(steps==3*A+V+2*F+20,'independent exact INIT count') + need(steps<=4*F+8,'uniform INIT bound') + expect='^'+h+'0'*V+'|' + need(''.join(mem[2].get(orig[2]+j,'_') for j in range(F+2))==expect,'dirty inactive target typed zero') + need(mem[0]==before[0] and mem[1]==before[1],'donor/home untouched') + need(heads==orig and all(lo>=o for lo,o in zip(low,orig)),'INIT relative origins') + need(all(s=='_' or k<=orig[3] for k,s in mem[3].items()),'prefix guide erased') + clear=I.D.Graph();clear.start=I.primitive(clear,'CLEAR',1,'HALT');clear.validate() + cm=[tape('^',orig[0]),tape('^'+expect[1:-1]+'|',orig[1]),tape('^',orig[2]),tape('^',orig[3])];ch=orig[:] + csteps,_=execute(clear,cm,ch) + need(csteps==2*F+4,'independent exact CLEAR count') + need(''.join(cm[1].get(orig[1]+1+j,'_') for j in range(F))=='0'*F,'full header and DATA erasure') + need(ch==orig,'CLEAR head returns') + return {'shape':shape,'F':F,'INIT_steps':steps,'CLEAR_steps':csteps} + +def cold_home(): + from collections import namedtuple + Event=namedtuple('Event','service owners') + owners=(('public','donor'),('public','parked'),('owned',1526,28037,37618)) + body,_,_=packet((1,1,1,1,2,1));parked=body[::-1];F=len(body) + events=[Event('INIT',(owners[0],owners[2])),Event('CLEAR',(owners[2],))] + g=I.compile_home(events,owners,2) + orig=[5,8,11,14];mem=[tape('^'+body+'|'+parked+'|$',orig[0])]+[tape('^',o) for o in orig[1:]] + heads=orig[:];steps,low=execute(g,mem,heads) + expected='^'+body+'|'+parked+'|'+'0'*F+'|$' + need(''.join(mem[0].get(orig[0]+j,'_') for j in range(len(expected)))==expected,'cold reservation/INIT/CLEAR HOME image') + need(heads==orig and all(lo>=o for lo,o in zip(low,orig)),'HOME/primitive return') + for i in range(1,4):need(all(s=='_' or k<=orig[i] for k,s in mem[i].items()),'all private cohorts retired') + return {'steps':steps,'F':F,'K':3,'productive':2} + +def inventory(): + raw=(P/'inputs/selected-native.json.gz').read_bytes() + need(hashlib.sha256(raw).hexdigest()=='2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883','selected archive') + w=json.loads(gzip.decompress(raw));live={k:v for k,v in enumerate(w['initial'])};openings={};pairs=[] + for i,e in enumerate(w['program']): + op=e[0];a=e[1] + if op=='INIT': + need(a>=w['public'] and a not in live and 0 in live,'fresh owned lifetime with live public donor') + openings[a]=(i,e[2]);live[a]=e[2] + elif op=='CLEAR': + need(a in openings and live[a]==e[2] and a>=w['public'],'matched owned retirement') + start,frame=openings.pop(a);pairs.append((start,i,a,frame,e[2]));del live[a] + elif op=='MOVE': + need(live.get(a)==e[2] and bool(e[4])==(a>=w['public']),'MOVE exact source frame and ownership') + live[a]=e[3] + elif op in ('ADD','COPY'):need(live.get(a)==live.get(e[2])==e[4],'binary actual frames') + elif op=='SCALE':need(live.get(a)==e[3],'SCALE current frame') + else:raise ValueError('opcode') + need(not openings and set(live)==set(range(w['public'])),'all owned lifetimes closed') + pairs.sort();counts={} + for row in pairs:counts[row[2]]=counts.get(row[2],0)+1 + need(len(pairs)==54 and len(counts)==51 and w['public']==1480,'54/51/1480 inventory') + return {'events':len(w['program']),'lifetimes':len(pairs),'labels':len(counts),'distinct_historical_homes':1480+len(pairs), + 'reused':{str(k):v for k,v in counts.items() if v>1},'inventory_sha256':hashlib.sha256(json.dumps(pairs).encode()).hexdigest()} + +def mutation(): + g=I.D.Graph();g.start=I.primitive(g,'CLEAR',1,'HALT') + for q,rules in g.rules.items(): + for j,r in enumerate(rules): + if r.writes==((1,'0'),) and (1,'1') in r.tests:rules[j]=I.D.Rule(r.tests,(),r.moves,r.target) + mem=[{0:'^'} for _ in range(4)];mem[1]=tape('^11101|',0);heads=[0]*4 + execute(g,mem,heads) + need(''.join(mem[1].get(1+j,'_') for j in range(5))!='00000','missing nonzero CLEAR write detected') + return 'detected' + +print(json.dumps({'status':'PASS_INDEPENDENT_TYPED_INIT_CLEAR','init_sha256':hashlib.sha256((P/'init.py').read_bytes()).hexdigest(), + 'primitive_cases':[primitive_case(s) for s in [(1,1,1,1,2,1),(1,2,1,2,3,(1<<128)+5),(1,1,1,1,1,(1<<2048)+7)]], + 'cold_home':cold_home(),'source_inventory':inventory(),'CLEAR_write_mutation':mutation()},indent=2)) diff --git a/research/selected-owned-gamma-init/init.py b/research/selected-owned-gamma-init/init.py new file mode 100644 index 0000000000..2f66c21d9f --- /dev/null +++ b/research/selected-owned-gamma-init/init.py @@ -0,0 +1,85 @@ +"""Uniform six-Gamma typed zero and full-capacity raw retirement. + +Apache-2.0. Prepared with OpenAI Codex assistance. Python only constructs +finite transition tables; execution uses local tape tests/writes/unit moves. +""" +from pathlib import Path +import hashlib +import importlib.util +import sys + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +sys.pycache_prefix = str(HERE / '_unwritten_cache') +if Path(sys.pycache_prefix).exists(): + raise ValueError('bytecode isolation path exists') + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + +def pinned(path, digest): + if hashlib.sha256(path.read_bytes()).hexdigest() != digest: + raise ValueError('frozen dependency drift: ' + str(path)) + +pinned(HERE/'inputs/tape_graph.py', '7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54') +pinned(HERE/'inputs/machine.py', 'ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee') +D = load('typed_init_dispatch', HERE/'inputs/tape_graph.py') +DONOR, TARGET, GUIDE = 1, 2, 3 +TAPES = 4 + +def primitive(g, name, arity, after, stages=None): + stages = {} if stages is None else stages + if name == 'CLEAR': + if arity != 1: + raise ValueError('CLEAR has exactly one owned operand') + done = g.rewind(1, after) + loop = g.state('raw-clear-all-capacity') + g.add(loop, done, tests=((1, '|'),)) + for bit in '01': + g.add(loop, loop, tests=((1, bit),), writes=((1, '0'),), moves=((1, 1),)) + entry = g.jump(loop, ((1, 1),)) + stages['entry'] = entry + stages['return'] = after + return entry + if name != 'INIT' or arity != 2: + raise ValueError('INIT requires distinct donor and inactive owned target') + done = g.rewind(DONOR, g.rewind(TARGET, g.rewind(GUIDE, after))) + data = g.state('init-full-zero-data') + g.add(data, done, tests=((DONOR, '|'), (TARGET, '|'))) + for bit in '01': + for old in '01': + g.add(data, data, tests=((DONOR, bit), (TARGET, old)), + writes=((TARGET, '0'),), moves=((DONOR, 1), (TARGET, 1))) + nxt = data + for field in range(5, -1, -1): + prefix = g.state('init-Gamma-prefix') + pop = g.state('init-Gamma-pop') + suffix = g.state('init-Gamma-suffix') + for old in '01': + g.add(prefix, prefix, tests=((DONOR, '0'), (TARGET, old)), + writes=((TARGET, '0'), (GUIDE, '1')), + moves=((DONOR, 1), (TARGET, 1), (GUIDE, 1))) + g.add(prefix, pop, tests=((DONOR, '1'), (TARGET, old)), + writes=((TARGET, '1'),), + moves=((DONOR, 1), (TARGET, 1), (GUIDE, -1))) + g.add(pop, nxt, tests=((GUIDE, '^'),), moves=((GUIDE, 1),)) + g.add(pop, suffix, tests=((GUIDE, '1'),), + writes=((GUIDE, '_'),), moves=((GUIDE, -1),)) + for bit in '01': + for old in '01': + g.add(suffix, pop, tests=((DONOR, bit), (TARGET, old)), + writes=((TARGET, bit),), moves=((DONOR, 1), (TARGET, 1))) + nxt = prefix + entry = g.jump(nxt, ((DONOR, 1), (TARGET, 1), (GUIDE, 1))) + stages['entry'] = entry + stages['data'] = data + stages['return'] = after + return entry + +def compile_home(events, owners, productive_count): + return D.compile_graph(events, owners, primitive=primitive, + productive_count=productive_count) diff --git a/research/selected-owned-gamma-init/inputs/machine.py b/research/selected-owned-gamma-init/inputs/machine.py new file mode 100644 index 0000000000..fcd4ac01f0 --- /dev/null +++ b/research/selected-owned-gamma-init/inputs/machine.py @@ -0,0 +1,129 @@ +"""Dense interpreter of literal Graphs; observers never drive control. Apache-2.0.""" +from dataclasses import dataclass +SYMBOLS={s:i for i,s in enumerate('_01^|$')} + + +class Rejected(ValueError):pass +class MonitorViolation(ValueError):pass + + +@dataclass +class State: + tapes:list + heads:list + origins:list + lows:list + highs:list + entry_lows:list + entry_highs:list + writes:list + steps:int=0 + + def clone(self): + return State([bytearray(t) for t in self.tapes],self.heads.copy(),self.origins.copy(), + self.lows.copy(),self.highs.copy(),self.entry_lows.copy(),self.entry_highs.copy(), + self.writes.copy(),self.steps) + + +def initial(payloads,tape_count,*,old_history=0): + if len(payloads)!=2 or len(payloads[0])!=len(payloads[1]) or not payloads[0]: + raise ValueError('two complete same-F source homes') + f=len(payloads[0]);capacity=16*(f+128)+256 + origins=[17+(t%7) for t in range(tape_count)] + text='^'+'|'.join(payloads)+'|$' + tapes=[bytearray(capacity) for _ in range(tape_count)] + for tape,o in zip(tapes,origins): + tape[o]=SYMBOLS['^'];tape[o-3:o]=bytes([2,1,4]);tape[-3:]=bytes([1,4,2]) + o=origins[0];tapes[0][o:o+len(text)]=bytes(SYMBOLS[s] for s in text) + lows=origins.copy();highs=origins.copy();highs[0]=o+len(text)-1 + if old_history:highs[-1]=origins[-1]+old_history + return State(tapes,origins.copy(),origins,lows.copy(),highs.copy(),lows,highs,[0]*tape_count) + + +class Program: + def __init__(self,graph): + names=list(graph.rules);self.labels={name:i for i,name in enumerate(names)} + self.labels['HALT']=-1;self.start=self.labels[graph.start];self.rows=[] + for name in names: + rules=[(tuple((t,SYMBOLS[s]) for t,s in r.tests), + tuple((t,SYMBOLS[s]) for t,s in r.writes),r.moves, + self.labels[r.target]) for r in graph.rules[name]] + if rules and all(len(r[0])==1 and not r[1] and not r[2] for r in rules) and len({r[0][0][0] for r in rules})==1: + branch=[-2]*6 + for r in rules:branch[r[0][0][1]]=r[3] + self.rows.append((0,rules[0][0][0][0],branch)) + elif len(rules)==1 and not rules[0][0]: + _,writes,moves,nxt=rules[0] + if len(writes)==1 and not moves:self.rows.append((1,writes[0][0],(writes[0][1],nxt))) + elif len(moves)==1 and not writes:self.rows.append((2,moves[0][0],(moves[0][1],nxt))) + elif not moves and not writes:self.rows.append((3,nxt,None)) + else:self.rows.append((4,rules,None)) + else:self.rows.append((4,rules,None)) + + def run(self,state,*,start=None,stop=None,budget=100000000): + pc=self.start if start is None else self.labels[start] + stop_pc=None if stop is None else self.labels[stop] + rows=self.rows;tapes=state.tapes;heads=state.heads + lows=state.lows;highs=state.highs;writes=state.writes + while pc!=-1 and pc!=stop_pc: + op,t,arg=rows[pc] + if op==0: + pc=arg[tapes[t][heads[t]]] + if pc==-2:raise Rejected('literal scanned-symbol rejection') + elif op==1: + value,pc=arg + if heads[t]==state.origins[t] and value!=3: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + elif op==2: + delta,pc=arg + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t]budget:raise ValueError('finite execution budget') + return state + + def _general(self,state,rules): + tapes=state.tapes;heads=state.heads;lows=state.lows;highs=state.highs;writes=state.writes + found=None + for rule in rules: + if all(tapes[t][heads[t]]==symbol for t,symbol in rule[0]): + if found is not None:raise ValueError('nondeterministic emitted table') + found=rule + if found is None:raise Rejected('literal scanned-symbol rejection') + for t,value in found[1]: + if heads[t]==state.origins[t] and value!=SYMBOLS['^']: + raise MonitorViolation('attempted permanent B origin marker overwrite') + tapes[t][heads[t]]=value;writes[t]+=1 + for t,delta in found[2]: + if delta not in (-1,0,1):raise ValueError('nonunit emitted move') + heads[t]+=delta + if not 0<=heads[t] 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-owned-gamma-init/inputs/selected-native.json.gz b/research/selected-owned-gamma-init/inputs/selected-native.json.gz new file mode 100644 index 0000000000..74563a7867 Binary files /dev/null and b/research/selected-owned-gamma-init/inputs/selected-native.json.gz differ diff --git a/research/selected-owned-gamma-init/inputs/tape_graph.py b/research/selected-owned-gamma-init/inputs/tape_graph.py new file mode 100644 index 0000000000..f307133f2b --- /dev/null +++ b/research/selected-owned-gamma-init/inputs/tape_graph.py @@ -0,0 +1,281 @@ +"""Literal fixed-tape scan graphs; no indexed payload access in execution. + +Alphabet is fixed. K, all homes and all service choices are frozen in states. +F is never stored in a runtime counter. New material: Apache-2.0. +""" +from dataclasses import dataclass + +ALPHABET = '_01^|$' + + +class Tape: + def __init__(self, text='^'): + self.cells = list(text) + self.head = 0 + self.peak = len(self.cells) + self.visited = {0} + + def read(self): + self.visited.add(self.head) + self.peak = max(self.peak,self.head+1) + return self.cells[self.head] if self.head < len(self.cells) else '_' + + def write(self, value): + self.visited.add(self.head) + if self.head >= len(self.cells): + self.cells.extend('_' for _ in range(self.head+1-len(self.cells))) + self.cells[self.head] = value + self.peak = max(self.peak, len(self.cells)) + + def move(self, delta): + if delta not in (-1,0,1): + raise ValueError('one physical transition moves at most one cell') + if self.head+delta < 0: + raise ValueError('head crossed permanent origin') + self.head += delta + self.visited.add(self.head) + self.peak = max(self.peak,self.head+1) + + def contents(self): + return ''.join(self.cells) + + +@dataclass(frozen=True) +class Rule: + tests: tuple + writes: tuple + moves: tuple + target: str + + +class Graph: + def __init__(self): + self.rules = {} + self.serial = 0 + self.start = None + self.execution_start = None + self.checkpoints = {} + + def state(self, stem): + result = f'{stem}.{self.serial}' + self.serial += 1 + return result + + def add(self, state, target, tests=(), writes=(), moves=()): + self.rules.setdefault(state, []).append(Rule(tuple(tests), tuple(writes), + tuple(moves), target)) + + def jump(self, target, moves=()): + state = self.state('jump') + self.add(state, target, moves=moves) + return state + + def rewind(self, tape, target, erase=False): + state = self.state('erase' if erase else 'rewind') + self.add(state, target, tests=((tape, '^'),)) + for symbol in ALPHABET.replace('^', ''): + self.add(state, state, tests=((tape, symbol),), + writes=((tape, '_'),) if erase else (), moves=((tape, -1),)) + return state + + def validate(self): + # Exact symbolic determinism: two patterns overlap iff every shared + # tested tape has the same symbol. No wildcard expansion is needed. + for state, rules in self.rules.items(): + for i, a in enumerate(rules): + if a.target not in self.rules and a.target != 'HALT': + raise ValueError('undefined graph continuation') + for b in rules[:i]: + left, right = dict(a.tests), dict(b.tests) + if all(left[t] == right[t] for t in left.keys() & right.keys()): + raise ValueError('nondeterministic graph state '+state) + + def run(self, tapes, limit=10000000, checkpoint=None, start=None): + state, steps = self.start if start is None else start, 0 + while state != 'HALT': + if checkpoint and state in self.checkpoints: + checkpoint(self.checkpoints[state], tapes) + if steps >= limit: + raise ValueError('literal graph execution capacity') + matches = [r for r in self.rules[state] + if all(tapes[t].read() == value for t, value in r.tests)] + if len(matches) != 1: + raise ValueError('malformed tape or nondeterministic transition '+state) + rule, = matches + for tape, value in rule.writes: + tapes[tape].write(value) + for tape, delta in rule.moves: + tapes[tape].move(delta) + state, steps = rule.target, steps+1 + if checkpoint and 'HALT' in self.checkpoints: + checkpoint(self.checkpoints['HALT'], tapes) + return steps + + +def service(graph, name, arity, target): + """Four small supplied primitive graphs used ONLY by finite fixtures. + + Real scientific scalar/route/leaf graphs are still premises of the theorem. + Tapes 1,2 are operands; tape 3 is retained private primitive scratch. + """ + if name == 'REV': + if arity != 1: + raise ValueError('unary reversal') + cleanup = graph.rewind(3, target, erase=True) + back_operand = graph.rewind(1, cleanup) + copy = graph.state('reverse-install') + graph.add(copy, back_operand, tests=((3, '|'),), writes=((1, '|'),)) + for bit in '01': + graph.add(copy, copy, tests=((3, bit),), writes=((1, bit),), + moves=((1, 1), (3, 1))) + install = graph.jump(copy, ((1, 1), (3, 1))) + rewind_scratch = graph.rewind(3, install) + reverse = graph.state('reverse-copy') + graph.add(reverse, rewind_scratch, tests=((1, '^'),), writes=((3, '|'),)) + for bit in '01': + graph.add(reverse, reverse, tests=((1, bit),), writes=((3, bit),), + moves=((1, -1), (3, 1))) + begin_reverse = graph.jump(reverse, ((1, -1), (3, 1))) + seek = graph.state('reverse-seek') + graph.add(seek, begin_reverse, tests=((1, '|'),)) + for bit in '01': + graph.add(seek, seek, tests=((1, bit),), moves=((1, 1),)) + return graph.jump(seek, ((1, 1),)) + if name == 'FIRST': + if arity != 1: + raise ValueError('unary leaf fixture') + at = graph.state('first-bit') + for bit in '01': + graph.add(at, target, tests=((1, bit),), writes=((1, str(1-int(bit))),), + moves=((1, -1),)) + return graph.jump(at, ((1, 1),)) + if name not in ('ZERO', 'NOT', 'XOR') or arity != (2 if name == 'XOR' else 1): + raise ValueError('missing supplied primitive graph') + cleanup = target + for tape in range(arity, 0, -1): + cleanup = graph.rewind(tape, cleanup) + loop = graph.state('primitive-'+name) + graph.add(loop, cleanup, tests=tuple((t, '|') for t in range(1, arity+1))) + if name == 'XOR': + for a in '01': + for b in '01': + graph.add(loop, loop, tests=((1, a), (2, b)), + writes=((2, str(int(a)^int(b))),), moves=((1, 1), (2, 1))) + else: + for bit in '01': + graph.add(loop, loop, tests=((1, bit),), + writes=((1, '0' if name == 'ZERO' else str(1-int(bit))),), + moves=((1, 1),)) + return graph.jump(loop, tuple((t, 1) for t in range(1, arity+1))) + + +def scan(graph, homes, selected, gather, target): + """Unroll finite home order; scan arbitrary F only by field delimiters.""" + next_state = graph.rewind(0, target) + for home in range(homes-1, -1, -1): + work = selected.get(home) + after = next_state + loop = graph.state('gather' if gather else 'return') + if work: + graph.add(loop, after, tests=((0, '|'),) if gather else ((0, '|'), (work, '|')), + writes=((work, '|'),) if gather else (), moves=((0, 1),)) + else: + graph.add(loop, after, tests=((0, '|'),), moves=((0, 1),)) + for bit in '01': + if not work: + graph.add(loop, loop, tests=((0, bit),), moves=((0, 1),)) + elif gather: + graph.add(loop, loop, tests=((0, bit),), writes=((work, bit),), + moves=((0, 1), (work, 1))) + else: + for output in '01': + graph.add(loop, loop, tests=((0, bit), (work, output)), + writes=((0, output),), moves=((0, 1), (work, 1))) + next_state = graph.jump(loop, ((work, 1),)) if work else loop + return graph.jump(next_state, ((0, 1),)) + + +def reserve(graph, extra_homes, target): + """Append full zero homes by copying first-field extent, without F arithmetic.""" + if not extra_homes: + return target + return_home = graph.rewind(0, target) + finish = graph.state('reserve-finish') + graph.add(finish, return_home, writes=((0, '$'),)) + next_state = graph.rewind(3, finish, erase=True) + for position in range(extra_homes-1,-1,-1): + loop = graph.state('reserve-zero-home') + graph.add(loop, loop, tests=((3, '0'),), writes=((0, '0'),), moves=((0, 1),(3, 1))) + graph.add(loop, next_state, tests=((3, '|'),), writes=((0, '|'),), moves=((0, 1),)) + begin = graph.jump(loop, ((3, 1),)) + next_state = graph.rewind(3, begin) if position else begin + seek = graph.state('reserve-seek-end') + graph.add(seek, next_state, tests=((0, '$'),)) + for symbol in '^01|': + graph.add(seek, seek, tests=((0, symbol),), moves=((0, 1),)) + rewind_template = graph.rewind(3, seek) + rewind_home = graph.rewind(0, rewind_template) + copy = graph.state('reserve-copy-extent') + for bit in '01': + graph.add(copy, copy, tests=((0, bit),), writes=((3, '0'),), moves=((0, 1),(3, 1))) + graph.add(copy, rewind_home, tests=((0, '|'),), writes=((3, '|'),)) + return graph.jump(copy, ((0, 1),(3, 1))) + + +def compile_graph(events, owners, primitive=service, productive_count=None): + """Return a real transition graph on four tapes for the fixture family. + + General theorem: replace primitive by supplied finite graphs using m + scratch tapes; tape count is 1+b+m, independently of Q,K,F. + """ + graph, next_state = Graph(), 'HALT' + home_index = {owner: i for i, owner in enumerate(owners)} + if len(home_index) != len(owners): + raise ValueError('permanent home owner identities must be distinct') + for index in range(len(events)-1, -1, -1): + event = events[index] + if not event.service: + continue + graph.checkpoints[next_state] = index + if not 1 <= len(event.owners) <= 2 or len(set(event.owners)) != len(event.owners): + raise ValueError('bounded distinct physical operands') + selected = {home_index[owner]: i+1 for i, owner in enumerate(event.owners)} + cleanup = next_state + for tape in range(len(event.owners), 0, -1): + cleanup = graph.rewind(tape, cleanup, erase=True) + scatter = scan(graph, len(owners), selected, False, cleanup) + invoke = primitive(graph, event.service, len(event.owners), scatter) + origin = invoke + for tape in range(len(event.owners), 0, -1): + origin = graph.rewind(tape, origin) + next_state = scan(graph, len(owners), selected, True, origin) + graph.execution_start = next_state + productive_count = len(owners) if productive_count is None else productive_count + if not 1 <= productive_count <= len(owners): + raise ValueError('positive productive count within permanent bank') + graph.start = reserve(graph,len(owners)-productive_count,next_state) + graph.validate() + return graph + + +def initial_tapes(payloads, home_count, preformatted=False): + if not payloads or len({len(x) for x in payloads}) != 1 or not payloads[0]: + raise ValueError('positive common full field format') + if len(payloads) > home_count or any(set(x)-set('01') for x in payloads): + raise ValueError('binary productive bank in declared homes') + # Only productive fields are supplied. New private extents are prepared + # by the literal reserve graph. Optional preformatting is for fault tests. + fields = list(payloads) + if preformatted: + fields += ['0'*len(payloads[0])]*(home_count-len(payloads)) + return [Tape('^'+'|'.join(fields)+'|$'), Tape(), Tape(), Tape()] + + +def decoded(tapes, home_count): + raw = tapes[0].contents() + if raw[0] != '^' or not raw.endswith('|$'): + raise ValueError('home boundaries changed') + fields = tuple(raw[1:-2].split('|')) + if len(fields) != home_count: + raise ValueError('permanent home count changed') + return fields diff --git a/research/selected-owned-gamma-init/predecessor_add.py b/research/selected-owned-gamma-init/predecessor_add.py new file mode 100644 index 0000000000..ff9b8c45e3 --- /dev/null +++ b/research/selected-owned-gamma-init/predecessor_add.py @@ -0,0 +1,98 @@ +"""Uniform packed Γ6 signed ±1 ADD/SUB; classical carry, new paid ABI. +Apache-2.0. Prepared with OpenAI Codex assistance. No runtime Word oracle. +""" +from pathlib import Path +import importlib.util,sys,hashlib +HERE=Path(__file__).resolve().parent +sys.dont_write_bytecode=True;sys.pycache_prefix=str(HERE/'_unwritten_cache') +if Path(sys.pycache_prefix).exists():raise ValueError('bytecode isolation path exists') +def load(name,path): + s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);sys.modules[name]=m;s.loader.exec_module(m);return m +if hashlib.sha256((HERE/'inputs/tape_graph.py').read_bytes()).hexdigest()!='7d3cee3e79ba5fe410e1a6b5f4cf6a2fbe5e274f838b798cd8860344ff258b54':raise ValueError('B1 source drift') +if hashlib.sha256((HERE/'inputs/machine.py').read_bytes()).hexdigest()!='ffe2677bb5b82932873cb08b05f890a1218070215ebe670a0b05079518e8baee':raise ValueError('literal interpreter source drift') +D=load('signed_add_dispatch',HERE/'inputs/tape_graph.py') +S,T,L,W,B=1,2,3,4,5 +TAPES=6 + +def origin_one(g,t,after):return g.rewind(t,g.jump(after,((t,1),))) + +def double_plus(g,bit,after): + """W=n unary, B blank; return W=2n+bit, B blank, both at cell1.""" + finish=origin_one(g,W,origin_one(g,B,after)) + transfer=g.state('width-transfer') + g.add(transfer,finish,tests=((B,'_'),)) + g.add(transfer,transfer,tests=((B,'1'),),writes=((B,'_'),(W,'1')),moves=((B,1),(W,1))) + begin_transfer=origin_one(g,B,g.jump(transfer,((W,1),))) + erase_old=g.rewind(W,begin_transfer,erase=True) + append=g.jump(erase_old) if not bit else g.state('width-append') + if bit:g.add(append,erase_old,writes=((B,'1'),),moves=((B,1),)) + loop=g.state('width-double');second=g.state('width-double-second') + g.add(loop,append,tests=((W,'_'),)) + g.add(loop,second,tests=((W,'1'),),writes=((B,'1'),),moves=((B,1),)) + g.add(second,loop,writes=((B,'1'),),moves=((B,1),(W,1))) + return loop + +def forward_width(g,after): + loop=g.state('width-forward') + g.add(loop,after,tests=((W,'_'),)) + g.add(loop,loop,tests=((W,'1'),),moves=((W,1),(S,1),(T,1))) + return loop + +def primitive(g,name,arity,after,stages=None): + if name not in ('ADD','SUB') or arity!=2:raise ValueError('fixed ±1 two-operand service') + stages={} if stages is None else stages;sub=name=='SUB' + # Successful private cleanup; source and target working copies are returned. + done=g.rewind(S,g.rewind(T,g.rewind(L,g.rewind(B,after)))) + clear=g.state('retire-width') + g.add(clear,g.rewind(W,done),tests=((W,'_'),)) + g.add(clear,clear,tests=((W,'1'),),writes=((W,'_'),),moves=((W,1),)) + cleanup=clear + next_component=g.state('next-component');reject=g.state('true-overflow');g.rules[reject]=[] + stages['overflow']=reject;stages['component_entry']=next_component + # After arithmetic, heads are one cell left of this component; restore its + # full width before considering the next component. All moves are paid. + next_ready=origin_one(g,W,next_component) + restore=forward_width(g,next_ready) + restore=g.jump(restore,((S,1),(T,1),(W,1))) + loops={c:g.state('carry-'+str(c)) for c in (0,1)} + checks={(c,o):g.state('MSB-check') for c in (0,1) for o in (0,1)} + for (c,overflow),state in checks.items(): + g.add(state,loops[c],tests=((W,'1'),)) + g.add(state,reject if overflow else restore,tests=((W,'^'),)) + for carry,state in loops.items(): + for s in (0,1): + for t in (0,1): + total=t+(1-s if sub else s)+carry;out=total%2;c=total//2 + overflow=int((t!=s if sub else t==s) and out!=t) + g.add(state,checks[c,overflow],tests=((S,str(s)),(T,str(t))),writes=((T,str(out)),),moves=((S,-1),(T,-1),(W,-1))) + lsb=g.jump(loops[1 if sub else 0],((S,-1),(T,-1),(W,-1))) + seek=forward_width(g,lsb) + g.add(next_component,cleanup,tests=((S,'|'),(T,'|'))) + for s in '01': + for t in '01':g.add(next_component,seek,tests=((S,s),(T,t))) + # Parse/compare all six positive Γ headers. Only fifth value is decoded. + nxt=next_component + for field in range(5,-1,-1): + prefix=g.state('Gamma-prefix');pop=g.state('Gamma-pop');suffix=g.state('Gamma-suffix') + g.add(prefix,prefix,tests=((S,'0'),(T,'0')),writes=((L,'1'),),moves=((S,1),(T,1),(L,1))) + writes=((W,'1'),) if field==4 else () + g.add(prefix,pop,tests=((S,'1'),(T,'1')),writes=writes,moves=((S,1),(T,1),(L,-1))) + g.add(pop,nxt,tests=((L,'^'),),moves=((L,1),)) + g.add(pop,suffix,tests=((L,'1'),),writes=((L,'_'),),moves=((L,-1),)) + for bit in (0,1): + resume=g.jump(pop,((S,1),(T,1))) + destination=double_plus(g,bit,resume) if field==4 else resume + g.add(suffix,destination,tests=((S,str(bit)),(T,str(bit)))) + nxt=prefix + entry=g.jump(nxt,tuple((t,1) for t in (S,T,L,W,B))) + stages['entry']=entry;stages['return']=after + return entry + +def compile_home(operation,owners=(0,1),operand_indices=(0,1),productive_count=None): + from collections import namedtuple + Event=namedtuple('Event','service owners');stages={} + if productive_count is None:productive_count=len(owners) + active=tuple(owners[i] for i in operand_indices) + g=D.compile_graph((Event(operation,active),),owners,productive_count=productive_count, + primitive=lambda g,n,a,k:primitive(g,n,a,k,stages)) + return g,stages diff --git a/research/selected-owned-gamma-init/source.py b/research/selected-owned-gamma-init/source.py new file mode 100644 index 0000000000..16cd73b139 --- /dev/null +++ b/research/selected-owned-gamma-init/source.py @@ -0,0 +1,158 @@ +"""Read-only source binding and typed lifetime gates, not scientific execution.""" +from pathlib import Path +import gzip +import hashlib +import json + +HERE = Path(__file__).resolve().parent +SOURCE = { + 'repository': 'CubeJerry/integer-mult-bounds', + 'commit': '172f4535ce8dcff79f626410af845f757c1563be', + 'path': 'research/literal-native-quadratic-phase/reference/selected-native.json.gz', + 'blob': '74563a7867d9d762b6588f65362369668841bb3e', + 'bytes': 350722, + 'sha256': '2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883', + 'canonical_word_sha256': '91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097', +} +EXPECTED = [ + (28037, ['INIT', 1526, 601]), + (28041, ['ADD', 1526, 1349, '-1', 601]), + (28129, ['ADD', 1526, 728, '-1', 601]), + (28135, ['ADD', 1526, 729, '-1', 601]), + (28139, ['ADD', 1526, 730, '-1', 601]), + (28141, ['MOVE', 1526, 601, 470, True]), + (28159, ['ADD', 1515, 1526, '1', 470]), + (37618, ['CLEAR', 1526, 470]), +] + +def need(ok, message): + if not ok: + raise ValueError(message) + +def read_source(path=None): + raw = (Path(path) if path else HERE/'inputs/selected-native.json.gz').read_bytes() + need(len(raw) == SOURCE['bytes'] and hashlib.sha256(raw).hexdigest() == SOURCE['sha256'], 'selected archive pin') + word = json.loads(gzip.decompress(raw)) + canonical = json.dumps(word, separators=(',', ':'), sort_keys=True).encode() + need(hashlib.sha256(canonical).hexdigest() == SOURCE['canonical_word_sha256'], 'selected canonical word pin') + return word + +def touched(event): + return event[1:3] if event[0] in ('ADD', 'COPY') else event[1:2] + +def prefix_states(word, end): + """Only exact frame/liveness typing; no numeric operation is interpreted.""" + frames = dict(enumerate(word['initial'])) + last_move = {} + for index, event in enumerate(word['program'][:end]): + op, owner = event[:2] + if op == 'INIT': + need(owner not in frames and owner >= word['public'], 'source INIT must open an absent owned lifetime') + frames[owner] = event[2] + elif op == 'CLEAR': + need(frames.get(owner) == event[2] and owner >= word['public'], 'source CLEAR frame/lifetime') + del frames[owner] + elif op == 'MOVE': + need(frames.get(owner) == event[2], 'source MOVE input frame') + need(event[4] == (owner >= word['public']), 'source MOVE ownership flag') + frames[owner] = event[3] + last_move[owner] = index + elif op in ('ADD', 'COPY'): + need(frames.get(owner) == event[4] == frames.get(event[2]), 'source binary current frames') + elif op == 'SCALE': + need(frames.get(owner) == event[3], 'source SCALE current frame') + else: + raise ValueError('unknown source opcode') + return frames, last_move + +def bind_init(word, index=28037, owner=1526, donor=0, frame=601): + need(word['program'][index] == ['INIT', owner, frame], 'binding is not the exact source INIT') + need(owner != donor, 'donor/owned alias') + current, last_move = prefix_states(word, index) + need(owner not in current, 'owned lifetime already open') + need(donor in current, 'header donor is not live') + return {'index': index, 'owner': owner, 'donor': donor, 'frame': frame, + 'donor_last_MOVE': last_move.get(donor), + 'donor_frame': current[donor], + 'donor_frame_columns': word['frames'][current[donor]], + 'donor_public': donor < word['public']} + +def audit(): + word = read_source() + got = [(i, e) for i, e in enumerate(word['program']) if 1526 in touched(e)] + need(got == EXPECTED, 'selected bank1526 full contact projection') + binding = bind_init(word) + at_init, moves = prefix_states(word, 28037) + need(at_init[1349] == 3 and word['program'][28039] == ['MOVE', 1349, 3, 601, False], 'different-frame donor source fact changed') + # Zero is invariant under every linear frame; frame3 is valid HEADER supply. + different_frame_donor = bind_init(word, donor=1349) + # Bind every selected contact in its genuine chronology, not a static-frame projection. + for i, event in EXPECTED[1:]: + current, _ = prefix_states(word, i) + if event[0] == 'ADD': + need(current[event[1]] == event[4] == current[event[2]], 'actual scalar contact frames') + else: + need(current[event[1]] == event[2], 'actual MOVE/CLEAR input frame') + controls = [] + for label, kwargs in ( + ('wrong_INIT_frame', {'frame': 470}), + ('inactive_owned_donor', {'donor': 1515}), + ('donor_owned_alias', {'donor': 1526}), + ('wrong_INIT_index', {'index': 28039}), + ): + try: + bind_init(word, **kwargs) + except ValueError: + controls.append(label) + else: + raise ValueError('source negative control accepted: ' + label) + # Audit every actual INIT using public donor0. These are finite source + # lifetimes, not a physical execution of all native operations. + inits = [(i, e) for i, e in enumerate(word['program']) if e[0] == 'INIT'] + clears = [(i, e) for i, e in enumerate(word['program']) if e[0] == 'CLEAR'] + inventory = [] + counts = {} + for i, event in inits: + _, owner, frame = event + b = bind_init(word, index=i, owner=owner, donor=0, frame=frame) + matching = next((j for j, e in clears if j > i and e[1] == owner), None) + need(matching is not None, 'unretired actual owned lifetime') + need(not any(i < j < matching and e[1] == owner for j, e in inits), 'overlapping raw owned lifetimes') + counts[owner] = counts.get(owner, 0)+1 + b.update(clear_index=matching, ordinal_for_raw_owner=counts[owner]-1) + inventory.append(b) + need(len(inventory) == 54 and len(counts) == 51, 'actual lifetime/label inventory changed') + need(all(0 not in touched(e) for _, e in clears), 'public donor was cleared') + need(all(all(0 < a < 512 for a in frame) for frame in word['frames']), 'native nine-coordinate frame labels') + end_frames, _ = prefix_states(word, len(word['program'])) + need(set(end_frames) == set(range(word['public'])), 'full word did not restore exactly its public lifetime set') + # Frame covariance applies to zero initialization only. A nonzero scalar + # contact still must match the exact current charts. + changed = dict(word) + changed['program'] = word['program'].copy() + changed['program'][28041] = ['ADD', 1526, 1349, '-1', 470] + try: + prefix_states(changed, 28042) + except ValueError: + controls.append('wrong_nonzero_scalar_contact_frame') + else: + raise ValueError('wrong scalar contact frame accepted') + changed['program'] = word['program'].copy() + changed['program'][28129] = ['INIT', 1526, 601] + try: + bind_init(changed, index=28129, owner=1526, donor=0, frame=601) + except ValueError: + controls.append('overwrite_live_owned_lifetime') + else: + raise ValueError('live owned contents offered to inactive INIT') + interleaved = [28127, 28131, 28133, 28137, 28153, 28161, 28165] + return {'source': SOURCE, 'program_length': len(word['program']), + 'bank1526_contacts': got, 'INIT_binding': binding, + 'frames_at_INIT': {str(k): at_init[k] for k in (728, 729, 730, 1349)}, + 'interleaving_witnesses': [(i, word['program'][i]) for i in interleaved], + 'different_frame_donor_accepted': different_frame_donor, + 'all_INIT_lifetimes': inventory, + 'owned_labels': len(counts), 'historical_owned_lifetimes': len(inventory), + 'reused_raw_labels': {str(k): v for k, v in counts.items() if v > 1}, + 'common_format_boundary': 'all packets in the supplied raw-native invocation share f,r,P,S,w,c and grid; source word alone contains no Gamma6 producer', + 'controls': controls, 'scope': 'all exact INIT lifetime bindings; no numerical full-word execution or root format producer'} diff --git a/research/selected-owned-gamma-init/verify.py b/research/selected-owned-gamma-init/verify.py new file mode 100644 index 0000000000..c9e3821acc --- /dev/null +++ b/research/selected-owned-gamma-init/verify.py @@ -0,0 +1,211 @@ +"""Independent packet oracle, literal execution, and source/lifetime controls.""" +from pathlib import Path +from collections import namedtuple +import hashlib +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.dont_write_bytecode = True +for pin in json.loads((HERE/'SOURCE-PINS.json').read_text())['files']: + raw = (HERE/pin['local']).read_bytes() + if len(raw) != pin['bytes'] or hashlib.sha256(raw).hexdigest() != pin['sha256']: + raise ValueError('retained input drift: '+pin['local']) +import init as I +import source +M = I.load('typed_init_machine', HERE/'inputs/machine.py') +A = I.load('typed_init_predecessor_add', HERE/'predecessor_add.py') +Event = namedtuple('Event', 'service owners') +DONOR = ('selected-7000-raw-native', 'productive', 728) +OWNED = ('selected-7000-raw-native', 'owned', 1526, 28037, 37618) + +def need(ok, message): + if not ok: + raise ValueError(message) + +def gamma(n): + need(isinstance(n, int) and n > 0, 'positive Gamma input') + b = bin(n)[2:] + return '0'*(len(b)-1) + b + +def packet(shape, values=None): + f, r, p, s, w, cutoff = shape + h = ''.join(gamma(n) for n in shape) + count = 2*p*s*r*(1 << (9*f)) + if values is None: + # Arbitrary, correlated donor data; zero production must ignore its value. + bits = ('1011010001110010' * ((count*w+15)//16))[:count*w] + else: + bits = ''.join(format(values[i % len(values)] % (1 << w), '0'+str(w)+'b') for i in range(count)) + return h+bits, h, count*w + +def state_for(payloads, tapes, old_history=0): + need(payloads and len({len(x) for x in payloads}) == 1, 'fixture common F') + state = M.initial((payloads[0], payloads[0]), tapes, old_history=old_history) + text = '^' + '|'.join(payloads) + '|$' + o = state.origins[0] + state.tapes[0][o+1:-3] = bytes(len(state.tapes[0])-o-4) + state.tapes[0][o:o+len(text)] = bytes(M.SYMBOLS[x] for x in text) + state.highs[0] = state.entry_highs[0] = o+len(text)-1 + return state + +def graph(events, owners=(DONOR, OWNED), productive=1, arithmetic=False, replacement=None): + def service(g, name, arity, after): + if replacement and name == 'CLEAR': + return replacement(g, name, arity, after) + if arithmetic and name in ('ADD', 'SUB'): + return A.primitive(g, name, arity, after) + return I.primitive(g, name, arity, after) + return I.D.compile_graph(events, owners, primitive=service, productive_count=productive) + +def history(state): + return sum(b-a+1 for a, b in zip(state.lows, state.highs)) + +def basic_case(shape, clear=False): + body, h, v = packet(shape) + events = [Event('INIT', (DONOR, OWNED))] + if clear: + events.append(Event('CLEAR', (OWNED,))) + g = graph(events) + f = len(body) + state = state_for((body,), I.TAPES, old_history=5*f) + before_history = history(state) + M.Program(g).run(state) + expected = '0'*f if clear else h+'0'*v + need(M.fields(state) == (body, expected), 'complete initialized/retired owned packet') + M.check_retired(state) + need(state.highs[-1] >= state.entry_highs[-1], 'earlier private history refunded') + need(history(state)-before_history <= 4*(f+2)+8, 'complete historical increment') + bound = 16*(len(events)+1)*5*(f+2) + (4*f+8) + (2*f+4 if clear else 0) + need(state.steps <= bound, 'complete reserve/delivery/primitive bill') + return {'shape': shape, 'E': len(h), 'V': v, 'F': f, 'clear': clear, + 'states': len(g.rules), 'steps': state.steps, 'complete_bound': bound, + 'history_entry': before_history, 'history_final': history(state), + 'donor_sha256': hashlib.sha256(body.encode()).hexdigest()} + +def primitive_exact_cost(shape): + body, h, v = packet(shape) + f = len(body) + g = I.D.Graph() + g.start = I.primitive(g, 'INIT', 2, 'HALT') + g.validate() + state = state_for((body, '0'*f), I.TAPES) + for t, text in ((1, '^'+body+'|'), (2, '^'+'0'*f+'|')): + o = state.origins[t] + state.tapes[t][o:o+len(text)] = bytes(M.SYMBOLS[x] for x in text) + M.Program(g).run(state) + a = sum(x.bit_length()-1 for x in shape) + exact = 3*a + v + 2*f + 20 + need(state.steps == exact, 'independent exact primitive transition count') + need(state.steps <= 4*f+8, 'uniform primitive linear bound') + return {'shape': shape, 'states': len(g.rules), 'steps': state.steps, 'derived_steps': exact} + +def additive_join(): + # This is a primitive ABI fixture. It is not a replay of the interleaved source word. + shape = (1, 1, 1, 1, 8, 2) + body, h, v = packet(shape, values=(3, -2, 1, 0, -5)) + owners = (DONOR, ('parked-correlated-public', 0), OWNED) + parked = body[::-1] # opaque binary same-F exterior HOME, never a typed operand + events = [Event('INIT', (DONOR, OWNED)), Event('SUB', (DONOR, OWNED))] + g = graph(events, owners, productive=2, arithmetic=True) + state = state_for((body, parked), A.TAPES, old_history=7*len(body)) + M.Program(g).run(state) + expected, _, _ = packet(shape, values=(-3, 2, -1, 0, 5)) + need(M.fields(state, 3) == (body, parked, expected), 'INIT to exact signed primitive ABI') + M.check_retired(state) + first = state.steps + # Continue with a separately compiled real CLEAR at the already-reserved boundary. + retire = graph([Event('CLEAR', (OWNED,))], owners, productive=2) + M.Program(retire).run(state, start=retire.execution_start) + need(M.fields(state, 3) == (body, parked, '0'*len(body)), 'nonzero DATA/full-header retirement') + M.check_retired(state) + return {'shape': shape, 'K': 3, 'productive': 2, 'tapes': A.TAPES, + 'INIT_SUB_steps': first, 'CLEAR_steps': state.steps-first, + 'scope': 'literal ABI composition; actual source donor-changing intervals remain supplied'} + +def controls(): + checked = [] + body, h, v = packet((1, 1, 1, 1, 4, 2)) + f = len(body) + g = graph([Event('INIT', (DONOR, OWNED))]) + program = M.Program(g) + # No raw reservation in these malformed-entry tests: already-reserved body boundary. + for label, donor, target in ( + ('incomplete_six_Gamma_header', '0'*f, '0'*f), + ): + state = state_for((donor, target), I.TAPES) + before = bytes(state.tapes[0]) + try: + program.run(state, start=g.execution_start) + except M.Rejected: + need(bytes(state.tapes[0]) == before and state.writes[0] == 0, 'rejected INIT scattered HOME') + else: + raise ValueError('malformed INIT admitted: ' + label) + checked.append(label) + try: + graph([Event('INIT', (DONOR, DONOR))]) + except ValueError: + checked.append('physical_operand_alias') + else: + raise ValueError('alias accepted') + # Mutation: clear only the first body cell, still returning a full binary body. + def partial(g, name, arity, after): + done = g.rewind(1, after) + loop = g.state('bad-partial-clear-remainder') + g.add(loop, done, tests=((1, '|'),)) + for bit in '01': + g.add(loop, loop, tests=((1, bit),), moves=((1, 1),)) + first = g.state('bad-partial-clear-first') + for bit in '01': + g.add(first, loop, tests=((1, bit),), writes=((1, '0'),), moves=((1, 1),)) + return g.jump(first, ((1, 1),)) + bad = graph([Event('CLEAR', (OWNED,))], replacement=partial) + state = state_for((body, body), I.TAPES) + M.Program(bad).run(state, start=bad.execution_start) + M.check_retired(state) + need(M.fields(state)[1] != '0'*f, 'partial-capacity clear negative control escaped') + checked.append('partial_capacity_clear_detected_by_full_body_oracle') + return checked + +def arbitrary_inactive_cases(): + shape = (1, 1, 1, 1, 5, 2) + body, h, v = packet(shape) + f = len(body) + g = graph([Event('INIT', (DONOR, OWNED))]) + program = M.Program(g) + patterns = {'all_ones': '1'*f, 'same_as_donor': body, + 'complement_of_donor': ''.join('1' if b == '0' else '0' for b in body), + 'last_cell_only': '0'*(f-1)+'1'} + receipts = [] + for label, old in patterns.items(): + state = state_for((body, old), I.TAPES, old_history=6*f) + program.run(state, start=g.execution_start) + need(M.fields(state) == (body, h+'0'*v), 'inactive dirty body not completely overwritten') + M.check_retired(state) + receipts.append({'pattern': label, 'steps': state.steps, 'F': f, + 'old_sha256': hashlib.sha256(old.encode()).hexdigest()}) + return receipts + +def verify(): + shapes = [(1, 1, 1, 1, 1, 1), (1, 1, 1, 1, 2, 2), + (1, 2, 2, 3, 3, 1), (1, 1, 1, 1, 17, 1 << 2048)] + cases = [basic_case(s, clear=c) for s in shapes for c in (False, True)] + # A complete f=2 packet; no synthetic component-only all-column control. + cases.append(basic_case((2, 1, 1, 1, 1, 4), clear=True)) + return {'marker': 'PASS_SELECTED_OWNED_GAMMA_INIT', 'source': source.audit(), + 'cases': cases, 'exact_local_cost': [primitive_exact_cost(s) for s in shapes[:3]], + 'additive_join': additive_join(), 'controls': controls(), + 'arbitrary_inactive_cases': arbitrary_inactive_cases(), + 'scope': 'typed INIT and full-capacity CLEAR; no full chronological selected caller or new kappa'} + +if __name__ == '__main__': + result = verify() + text = json.dumps(result, sort_keys=True, indent=2)+'\n' + if '--write' in sys.argv: + (HERE/'RESULT.json').write_text(text) + elif (HERE/'RESULT.json').exists(): + need(json.loads((HERE/'RESULT.json').read_text()) == json.loads(text), 'verification receipt changed') + print(json.dumps({'marker': result['marker'], 'complete_packet_cases': len(result['cases']), + 'source_controls': result['source']['controls'], 'machine_controls': result['controls'], + 'additive_join': result['additive_join']}, sort_keys=True))