diff --git a/research/shared-kernel-packing/BRANCH.txt b/research/shared-kernel-packing/BRANCH.txt new file mode 100644 index 0000000000..47a7ba24c4 --- /dev/null +++ b/research/shared-kernel-packing/BRANCH.txt @@ -0,0 +1 @@ +research/shared-kernel-packing-optimum-20261015 diff --git a/research/shared-kernel-packing/CLAIM.json b/research/shared-kernel-packing/CLAIM.json new file mode 100644 index 0000000000..47e3e13cfa --- /dev/null +++ b/research/shared-kernel-packing/CLAIM.json @@ -0,0 +1,37 @@ +{ + "admission_result_sha256": "21fd39c78a6f2932cbc07af448bf193c9e483ba76942ec87b59d653981991f25", + "baseline_claim_sha256": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "baseline_head": "0b2e2537b368a0cade07ce3f71452ea018ebe394", + "baseline_kappa": "17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "baseline_pr": 2857, + "calls": 1665, + "display": "0.001720100805416885927944 - 10^-46 - 10^-70", + "gain_decimal": "0.000000004176732053326972", + "gain_over_full_pr2857": "1044183013331743/250000000000000000000000", + "helper_roles": 679320, + "inherited_hypotheses": "All-size compiler; common-label/source access; mutable source; hosting; precision/tape; recovery; ordinary recursion; BIT; analytic transfer. No new Lean audit or unconditional multiplication theorem.", + "kappa": "17201008054168859279439999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017201008054168859279439999999999999999999998999999999999999999999999", + "live": 165760, + "native_receipt_sha256": "e39f1da10b10f649366722157517c15d0d040ec6b651db4ef5624fe173df121f", + "optimality_certificate_sha256": "c015d2e8324775a76904a3fe33972d15c5a685c95d9679cebaaddf3745b81025", + "original_source_head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", + "paid_profile": { + "1": 4029300, + "2": 1068930, + "3": 458874, + "4": 213120, + "48": 66896, + "5": 65490, + "8": 13320 + }, + "physical": 166250, + "proof_origin": "Root and three Codex agents; informal proofs and exact finite computational checks. No independent human peer review claimed.", + "release_receipt_sha256": "932b22b422e1f74a2b3c705045087260a20b2eea085157693f2b318d360e4a4c", + "replicas": 185, + "retained_payload": 2048, + "scope": "Conditional outer headline. Actual T185 attains the fixed native-word/inventory/capacity fractional packing optimum near its moment root; no maximum over changed native words, geometries, controllers or multiplication algorithms.", + "source_manifest_entries": 547, + "source_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "status": "PASS_CONDITIONAL_T185_RELEASE_AND_FIXED_PACKING_OPTIMUM" +} diff --git a/research/shared-kernel-packing/CONSTRUCTION.md b/research/shared-kernel-packing/CONSTRUCTION.md new file mode 100644 index 0000000000..f7b6173034 --- /dev/null +++ b/research/shared-kernel-packing/CONSTRUCTION.md @@ -0,0 +1,40 @@ +# Five-copy vacancy completion of the shared-kernel allocation + +This construction uses Yiyang/Lyy-iiis’s actual PR #2857 shared-kernel words and T37 allocation at head `0b2e2537b368a0cade07ce3f71452ea018ebe394`. It preserves the native providers and constructs a literal T185 allocation. The finite owner witness and directed rational moment pass; complete native and outer admission are separate root-owned checks. All inherited sufficient hypotheses remain in force. + +## Exact construction + +The original T37 allocation has exactly one capacity-16 bin with unused rank 9: owner 35, child 16, port 37. Its existing role has width 7. Moving a width-9 role from a full [7,9] bin into this vacancy leaves the donor with the same unused rank 9, so it changes no paid cost. The actual relay moves helper 208 at call 320 from bin (28,16,76) to (35,16,37). + +The new vacancy’s source window admits every role of the actual capacity-48 donor bin (32,13,94). This donor holds five width-9 roles at calls 292, 293, 311, 316, and 317, and has unused rank 3. The role identifiers are 17, 151, 107, 54, and 26 respectively. These are literal received rows, not hypothetical equal-width replacements. + +Make five disjoint copies of the complete T37 call schedule. Interleave them in lockstep: original call t in copy b becomes call 5t+b, and every owner index is increased by 37b. Replicate the one-step vacancy relay in all five copies. Then move the five roles of one actual donor bin into the five resulting rank-9 vacancies, one role per vacancy. Their width-7 occupants remain in place. The five capacity-16 bins become full, and the capacity-48 donor becomes empty. + +The exported journal has exactly ten whole-role moves. Every helper identifier and call time remains unchanged after the initial copied schedule is formed. The full recount checks the expanded bridge and source events, strict source windows, distinct physical families at each call, complete coverage of all 408 helpers per call, integral coordinates, disjoint masks, capacity bounds, used prefixes, and exact rank mass. It checks 679,320 roles in 1,665 calls, with live stock 165,760. Four invalid controls are rejected for their intended reasons. The copied source-event projection is exactly the original 30-event projection for each of the 185 replicas; it is checked explicitly rather than inferred from the lockstep construction. + +## Sufficient paid-cost proof + +Relative to five complete incoming PR #2857 profiles, the exact paid difference is + + H_48 − H_3 − 5 H_9. + +The rank mass is unchanged because 48 = 3 + 5·9. For every 0 < p < 1 and positive a,b, strict subadditivity gives (a+b)^p < a^p+b^p. One proof writes b=ta and differentiates g(t)=1+t^p−(1+t)^p: g(0)=0 and g′(t)=p(t^(p−1)−(1+t)^(p−1))>0. Repeated application proves 48^p < 3^p+5·9^p. Thus the complete paid power cost decreases strictly, with no discarded idle charge. + +The outgoing profile is + + {1:4029300, 2:1068930, 3:458874, 4:213120, + 5:65490, 8:13320, 48:66896}. + +It is exactly 185 times the fractional packing support. The separate exact primal/dual checker subsequently verified all 1,163 capacity-feasible patterns, including 11 symbolically tight patterns, and certified equality of the actual profile with the fixed-inventory fractional optimum throughout the root interval. Thus this construction attains that packing bound for the fixed capacities and native inventory. This does not bound changed native words, alternate controllers, or all suppliers. + +The directed rational root bracket is [0.00172010080541688592794400, 0.00172010080541688592794401]. The conservative 24-digit target is 0.001720100805416885927944 − 10^−46 − 10^−70. The exact comparator is the full incoming PR #2857 rational, whose claim file has SHA-256 `c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f`. The gain is approximately 4.17673205333 × 10^−9. The finer bracket is an independent interval result; the final outer receipt determines the completed release precision. + +## Reproduction and limits + +`reproduce_t185.py` takes `--baseline`, `--relay-plan`, and `--out`. It authenticates the six PR #2857 source inputs and the actual source template and plan before writing a fresh destination. The candidate is generated without a solver. Its output fill, order, dispatch, providers, and profile must match the frozen candidate hashes. The source fixture directory can be flat or retain the upstream `sources/` subdirectory. The immutable relay plan is RELAY-PLAN-5.json. Root-owned independent audits and complete admission supplement this constructor’s own checks. + +The T37 same-call greedy, neutral-exchange, and two-exchange screens found no paid improvement. The actual two-copy merge was checked and improved the prior claim, but the five-copy construction gives the stronger selected result. Direct three-copy donor transfer failed the original late source windows; a two-step relay plan was found, but no complete three-copy literal export was checked because the stronger five-copy witness was already available. No global maximum over changed native words is claimed. + +## Attribution + +Credit Yiyang/Lyy-iiis for PR #2857’s staged shared kernels, cheaper local profile, actual T37 fill, and PR #2848’s residue concentration. Credit Marius-Paul Dumitrean/mdumitrean’s PR #2856 for the related paid-profile-preserving vacancy-path method, and PR #2843’s allocation transport. Philippe Van Velzen’s PR #2853 treats the same four A-phase helpers through a different schedule. Jeremy Kothe’s PR #2833 supplies the preceding dirty-entry words. Dugongue’s PR #2855 and the retained Tekalign/Dugongue checker lineage supply prior atlas applications and independent-checking work. Preserve all upstream notices and licenses. No exclusive helper-selection or global novelty claim is made. diff --git a/research/shared-kernel-packing/CREDITS.md b/research/shared-kernel-packing/CREDITS.md new file mode 100644 index 0000000000..5c41c22bdd --- /dev/null +++ b/research/shared-kernel-packing/CREDITS.md @@ -0,0 +1,24 @@ +# Attribution and actual composition + +The final construction depends on the following public work, rather than summing unrelated headline decimals. + +- **Yiyang/Lyy-iiis, [PR #2857](https://github.com/CrocSwap/integer-mult-bounds/pull/2857)**, immutable head `0b2e2537b368a0cade07ce3f71452ea018ebe394`: staged shared-kernel words, cheaper complete local profile, actual T37 owner fill, fractional packing-cap precedent, source overlay, native/outer integration and separate review tooling. The complete words are retained; no priority or exclusive helper-selection claim is made. +- **Marius-Paul Dumitrean/mdumitrean, [PR #2856](https://github.com/CrocSwap/integer-mult-bounds/pull/2856)**, head `7a43b24c4b6729d171f3a2a11ef3b7dc77aabaa4`, with substantial Codex assistance: related cost-neutral vacancy-path method and rank concentration on [PR #2853](https://github.com/CrocSwap/integer-mult-bounds/pull/2853). The present literal witness uses width 9 instead of that work's width 7 paths. +- **Philippe Van Velzen/philippeVV, [PR #2853](https://github.com/CrocSwap/integer-mult-bounds/pull/2853)**, head `d01045dfb67428679618027dff552f1d032fa999`: dirty A-phase entry for the same four helper quartets, actual rebuilt inventory and supplier, with a different more expensive read schedule. That alternative is not added on top of the shared kernel a second time. +- **Jeremy Kothe, [PR #2833](https://github.com/CrocSwap/integer-mult-bounds/pull/2833)**, head `e9307b48d7d1b690939935ecef0f8e524e6d92f4`: preceding dirt-entry words, source package and native mechanisms. +- **Yiyang/Lyy-iiis, [PR #2848](https://github.com/CrocSwap/integer-mult-bounds/pull/2848)**, with substantial Codex assistance: full paid residue-exchange method, portable preparation/admission and independent source-event audit lineage. Our root source-event checker is a credited generalization, not falsely described as wholly unrelated code. +- **Marius-Paul Dumitrean, [PR #2843](https://github.com/CrocSwap/integer-mult-bounds/pull/2843)**: actual allocation transport and construction precedent. **Dugongue, [PR #2839](https://github.com/CrocSwap/integer-mult-bounds/pull/2839)**: tensor-block replica contract and lift/reconstruction/block-norm tooling, with all retained contributor notices. +- **Dugongue, [PR #2855](https://github.com/CrocSwap/integer-mult-bounds/pull/2855)**, head `90c52db35dd2f8cdf0dd81976e698a6192a09126`: the previous atlas applications, paid-rank concentration and independent-checking work. **[PR #2849](https://github.com/CrocSwap/integer-mult-bounds/pull/2849)** supplies the informal atlas, especially D021–D026 on concavity and majorization. These mathematical tools are classical; no global novelty claim is made for them. +- **[PR #2802](https://github.com/CrocSwap/integer-mult-bounds/pull/2802)** by Marius-Paul Dumitrean, **[PR #2751](https://github.com/CrocSwap/integer-mult-bounds/pull/2751)** by Tekalign, **[PR #2766](https://github.com/CrocSwap/integer-mult-bounds/pull/2766)** by DavidAriasC, **[PR #2733](https://github.com/CrocSwap/integer-mult-bounds/pull/2733)** and the retained earlier provider, alias, routing/frame, pre-life and outer-transfer lineage remain credited. Philippe Van Velzen, Mason Hale and every other original contributor keep their upstream credits, copyright and license notices. + +The exact new contribution is the ten-move five-copy causal witness and the independent proof/certification that its full profile attains the current fixed-inventory packing optimum. Root and three Codex agents produced the construction, separately implemented audits, explicit symbolic dual and proof notes. This is automated mathematical review, not independent human peer review. Original author/assistant attributions in the source package remain intact. + +The campaign first completed a smaller improvement on [PR #2853](https://github.com/CrocSwap/integer-mult-bounds/pull/2853). A later refresh found [PR #2856](https://github.com/CrocSwap/integer-mult-bounds/pull/2856) and the stronger [PR #2857](https://github.com/CrocSwap/integer-mult-bounds/pull/2857); the selected deliverable was revised to combine their usable ideas and the existing concentration method. The earlier complete checkpoint is preserved locally and is not passed off as the final frontier result. + +The source comparison includes an earlier complete open-PR pagination, a fresh 100 recently created and 100 recently updated records, subsequent new-head refreshes, current main/priority/catalog sources and actual immutable relevant files. Discussions and all historical repositories were not exhaustively audited. No global priority or novelty inference follows from this bounded neighborhood search. The final refresh records its exact scope. + +The final main snapshot is `d311a18c6061af67d0aa35cbeced605b8b7472ed`; the selected maintainer-reviewed conditional saving remains 0.001672660197076918. [PR #2858](https://github.com/CrocSwap/integer-mult-bounds/pull/2858) was inspected as a scoped priced obstruction without a new κ claim or a replacement native/packing construction. See `evidence/SOURCE-REFRESH.json`. + +All cited PRs are in https://github.com/CrocSwap/integer-mult-bounds/pulls. Original byte-preserved sources, notices and SPDX headers are under `vendor/pr2857/` and the authenticated external source export. New code is Apache-2.0. No source or package was externally published by this agent. + +The release refresh at 2026-10-16 04:42:49 UTC also read the actual bodies of [PR #2859](https://github.com/CrocSwap/integer-mult-bounds/pull/2859) by Dennis / antunishdPursuit, [PR #2860](https://github.com/CrocSwap/integer-mult-bounds/pull/2860) and [PR #2861](https://github.com/CrocSwap/integer-mult-bounds/pull/2861) by Wentao Li / VictorLiwentao, and [PR #2862](https://github.com/CrocSwap/integer-mult-bounds/pull/2862) by DreamingOfClouds. These cover phase-order bank sharing and scoped decoder/walk obstructions, with no new supplier or κ claim. They provide no drop-in replacement for this literal packing; their code/proofs were not independently reaudited or used as theorem premises here. This is a recorded neighborhood comparison, not an exhaustive novelty audit. diff --git a/research/shared-kernel-packing/FINAL-RESEARCH-PLAN.md b/research/shared-kernel-packing/FINAL-RESEARCH-PLAN.md new file mode 100644 index 0000000000..77632dadd1 --- /dev/null +++ b/research/shared-kernel-packing/FINAL-RESEARCH-PLAN.md @@ -0,0 +1,7 @@ +# Sufficient final assembly + +Construct five actual source copies of PR #2857, relocate their rank 9 vacancies through the checked width 9 path, and fill all five vacancies from one actual capacity 48 donor. Independently check every role and exact moment. Prove primal/dual equality for all fixed-inventory patterns, then validate the changed native providers and complete inherited hosting, compiler, precision, BIT and modern outer release. Only the conjunction supports the conditional headline. + +The initial PR #2853 checkpoint succeeded, but a new source refresh exposed a stronger cheaper-kernel construction. This justified a changed representation, not resampling the same failed contract. A direct transplantation of the earlier allocation into new words failed its economic gate; the selected route uses the actual new T37 fill. The literal five-copy witness closes the previously unproved chronological realization of the fractional optimum. No unknown gadget is assumed. + +Root owns immutable source and final release; product owns the exact relay construction; compiler owns separate literal/moment and exact LP proof; physical owns the local source-compatibility review. Each mathematical claim has an explicit finite witness/check or a complete English proof. Native and global checks retain their original predicates. All inherited asymptotic hypotheses remain. This informal construction does not create a fake Lean root or a competing proof DAG. diff --git a/research/shared-kernel-packing/LICENSE b/research/shared-kernel-packing/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/shared-kernel-packing/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/shared-kernel-packing/MANIFEST.json b/research/shared-kernel-packing/MANIFEST.json new file mode 100644 index 0000000000..b43e7989cf --- /dev/null +++ b/research/shared-kernel-packing/MANIFEST.json @@ -0,0 +1,166 @@ +{ + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "BRANCH.txt": "b73ee116eb7b006f8c7d576b78ad06f6ab322c28fe1ea9f5f92480057555d1e7", + "CLAIM.json": "eebaf5fc6d4721ba99418bdd0bbcbb933c5bf4f351025065f39a11120680f0f9", + "CONSTRUCTION.md": "c9c355551dec37e8e2c3e3dad8c6c9c7218af1a2333cf1cb688655fa531da9da", + "CREDITS.md": "5144a2d0774dbbb41cded421f00a05cf7c106a9278bbb2869c8dbe31ed71bbe5", + "FINAL-RESEARCH-PLAN.md": "ff888bf2216a2c1a5cd0e071bb508f5cce2e0f67e382384f9dccfe47a531278d", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "1493711f66e5cf8d53dd7d4f67edfe2eab8d17dd232b86e08c2d35cc9398cf39", + "PR-BODY.md": "0fd90e0dc506c34be4a5bf9ad2bbdb278ecdf0788da30b2885338fda738f0b66", + "PR-TITLE.txt": "cebb5147e02f356d3b530efbe2ec35cea5b22e25bcc0cad371e5b984c5a12f33", + "README.md": "1514045503fe5215e07092bfead5e8370a62ce9b119eb9f686fd28698aecda57", + "RELAY-PLAN.json": "67462bcf89e0381b922aa1b130cc55db31dd6f77d563035f02e91acab3634c6b", + "SOURCES.json": "163b028f64651bbac91d9f3f954521a83d5093c25b1c006b404f0c1a364b3f4d", + "TASK.json": "c8862761f2099c31d840d009c6c0242a8dd5fcbee8e5532f838d8b439a09a780", + "UPLOAD.md": "9fc4582e42c89263ba2583efcc90bdee803e083b9aa5fcc94bf02d132edc7a4e", + "VERIFY.json": "575ddf9711636006844ef192c12e04980c34236ffe235c64e4e457fe9f417339", + "data/DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "data/FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "data/ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "data/OWNER-RECEIPT.json": "3d24c14566eab1eea1e82944e2f458a4c9d6753e3c72a9d63d964b8e7d10f730", + "data/PROFILE.json": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672", + "data/PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "evidence/ADMISSION-RESULT.json": "21fd39c78a6f2932cbc07af448bf193c9e483ba76942ec87b59d653981991f25", + "evidence/ADMISSION-STAGES.json": "28c953f1621c51d2ea4d652ffee59a225022ed4e7a1cb4d8651980e29ea0aea1", + "evidence/ADMIT2857-DERIVATION.json": "0ac2a4f59728682173242f73d0e71117baf18fc5bee3f1da2482b53822a25b31", + "evidence/ASSEMBLY.json": "ce044d660ac667a050a72199583a3c887c27bbb09bcfc1ca561434bcb6c51006", + "evidence/FINAL2857-MOMENT.json": "17320db6e321633ff59f3eb49add5f5d2de44700a62bc227c126eeb78d37b7c4", + "evidence/FINAL2857-OWNERS.json": "31ddda14f82d89700a2c1b5afbe1e767c15fe68df952ccec569a9574f61bf037", + "evidence/NATIVE-ENVIRONMENT.json": "08277c6877869e37abdc75900ce22f449e4ec1216258fb8a2b5bea1991fdf315", + "evidence/NATIVE-RECEIPT.json": "e39f1da10b10f649366722157517c15d0d040ec6b651db4ef5624fe173df121f", + "evidence/NATIVE-RESULT.json": "dfe7cda1a68c5efd5090f158b1e1c79ab1a9141fa5f5dd539835f57d8a25a40e", + "evidence/PREPARE2857-DERIVATION.json": "677534b9984a74f696aacc49873e15525e717166f5f1fef7ead8abacdb8c3497", + "evidence/RELEASE-RECEIPT.json": "932b22b422e1f74a2b3c705045087260a20b2eea085157693f2b318d360e4a4c", + "evidence/REPLAY-NOTE.json": "f160152ebb4e35591039b6511610899d8c48a8617f1d1cd43ee83f98b4e62932", + "evidence/RETAINED-BOOTSTRAP-RECEIPT.json": "f7b5c990a5e86294f6562c4c59e8225864bf7ed31d1c0dee8d7a4fbd7700ff52", + "evidence/RETAINED-BOOTSTRAP-RESULT.json": "7670a819312e740f16beb5b52de35c3361026852b073831b20a472c0dbea1d3d", + "evidence/SOURCE-OVERLAY-DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "evidence/SOURCE-REFRESH.json": "0a6f1f90274068fc879440bd3e7e82a0478fa780406c354e3f752b3ac8367aa2", + "evidence/SUPPLIER-RESULT.json": "4672cc8d67eb00671849ef721434ad45321e4c16ea6ea50bfee7dd9a410407ca", + "evidence/SUPPLIER-STAGES.json": "297e5271a222db41b54c405f600eb864fca667a5a41127cb127ad614d65c0180", + "evidence/UPSTREAM-PR2857-SOURCE.json": "d6f9d0a96fa096873e20a8c79d1b7ce54a080d1006e695844e500038dfdeabf2", + "reproduce.py": "ba1b23cfcf9a31961b0cf574f2ad9c53447942d7187507054a272d25d9dc296d", + "reproduce_t185.py": "6cb84e05e6dfe72f35dd09b3f85c093f913750104d799e31870144a1dcfc2c0e", + "review/PROOF.md": "71a45d195eb9ea46e0b0027d7d6f750aef109b1e853b9ff6b90ab864039bae6f", + "review/REVIEW-FINAL.json": "793e5dbd9dadfa34f926c827291e2394f62a4628bba9b9f31e82abc6eba8bf75", + "review/RUN.md": "15695884cd263f6688f3467a09d9aa580f92a639b0231e70a326cff8ccdd1e23", + "review/SOURCE-COMPATIBILITY.json": "711e7b0c2ae45a77d98839bddcad57e7a011a91ada52aceb4d274245f9b5d278", + "review/SOURCE-COMPATIBILITY.md": "23cab131ec3f43d7403ee3cfec8808279de025af8657272a6761230c92f43ea6", + "review/T185-PEER-REVIEW.json": "d8115dc9bf53b35b7e35f9ec739f2820ed8561e8d4cf578017b457fd15849d06", + "review/literal_core.py": "f5b36146de862c4f9f68412b1a9177409cb390ad4051b0f71483f36591e6a5d6", + "review/lp-final-01/PATTERNS.json": "a7a1aeede7b2b551e23629e5a4c539d344393572e3b9ee45b07a6bf00587e116", + "review/lp-final-01/RESULT.json": "c015d2e8324775a76904a3fe33972d15c5a685c95d9679cebaaddf3745b81025", + "review/moment_core.py": "22290074f138fa9b902e5f6f6e8a0ec366d6f812992adb6df9b617ce952fb852", + "review/profile_lp_certificate.py": "96cd1d6d84d9a224f3b5521e43e6d0572c779bdcccdd97f52dff36c76e5aa31a", + "review/review_current.py": "839ebb3ae5c209082a49b5456e331216db47ee6ce36fb87cab7723e9da11a8bd", + "tools/admit2857.py": "1d4b8b9df01e42f5f2450b5837132861c5aa8cd3a011e6a6fa35e53463417346", + "tools/audit_moment2857.py": "514b991460c47430476c9b2a73a321a85318097dace499d79bf33b4d839240c5", + "tools/audit_owners2857.py": "c26cda8f80f4914a16beab9615eb076868abdd572d511d870561973181172114", + "tools/ci_verify.py": "3880f8d53193d68535bb08ffabc767a5f3ef85777517d6c5bab1a8478c51c310", + "tools/fetch_source.cjs": "ee1b241e5321dff91f58a31d2c3c956dcc29930e0861807674dac01fd090614e", + "tools/make_lf_runtime.py": "da701eede36962e104050099475a9a6a632c8acd5bd49497bc56ea4cc3041d46", + "tools/materialize_source.py": "4f496ed6263aec187019a9005a4125487137e5380bbc88a14a4962a0d77bd881", + "tools/prepare2857.py": "f18c6d7c7cf94153300b124107a0b66ab8d2147244d522056658d85c40105ae9", + "tools/prepare_retained.py": "2962be17ee23d9c7953490e2d2919539b22b0ae2a29a10d89fddb6cfd3600431", + "tools/verify_package.py": "12655c07d514015abfd7feb82387ee329a38eb0a990edbf9bc73cc38a85c434f", + "validation/MOMENT-RECEIPT.json": "3414a77765698dbcbc95bfe442447fc26a7399eabf6956a774ac6d909e26f301", + "validation/PORTABLE-REPLAY-RECEIPT.json": "f409758a38dbf9ea5608808d55e17e4776b029064f43e798249178d139dea86e", + "vendor/pr2857/.gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "vendor/pr2857/CLAIM.json": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "vendor/pr2857/DISPATCH.json": "5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4", + "vendor/pr2857/FILL.json.gz": "82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501", + "vendor/pr2857/LOCAL-PINS.json": "5ddefde0c678a19bcae67352157b4b5d7868ba097951d079d04579cff8f41252", + "vendor/pr2857/NOTICE": "63e39c215eecec07f0eae6fd76ef69ec886ecefa0175e80f0526c9af83dc5f9b", + "vendor/pr2857/ORDER.json": "84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc", + "vendor/pr2857/PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "vendor/pr2857/PROOF.md": "0b6208bf6de980daae1879cf3b22f0464cb12938ec91d0c7af61b8e18413649d", + "vendor/pr2857/PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "vendor/pr2857/README.md": "814b37dba638ba5550b955438e8acca84f004853ba3e24232bb253f4534cc01e", + "vendor/pr2857/SOURCES.json": "6d2b70e225aaf76213572e0ccddf3514fb2a874719c199031fd55b504b030a8a", + "vendor/pr2857/TASK.json": "29221111a4695dc8011a36063915b6ff9bf944af429887f18b61163059b0963d", + "vendor/pr2857/VERIFY.json": "354e2957f52694c98e23173d636cb7696fe82ca855540ec453e2c31bd32e87db", + "vendor/pr2857/admit_shared_replica.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "vendor/pr2857/allocation/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr2857/allocation/MANIFEST.json": "d18c89aa44bec5b1f2afc5ca3990e5e8132761e7abfab368e02f700a2e04e852", + "vendor/pr2857/allocation/NOTICE": "642e6acf32c22212f8c249e0ef36f65f7e28bd90eff75cb9b03b3fbcb79d94bf", + "vendor/pr2857/allocation/PINS.json": "d6defca921082408338cae3c90ac8466d8a252fb6f3a7e12d6724003732a206e", + "vendor/pr2857/allocation/README.md": "93e16cb95c3daf10c2bffa43a818230f7af4c2a14c05ea0099aca872c6ffc6fa", + "vendor/pr2857/allocation/construction/COMPRESSION-CONTROLS.json": "225083da80b8d0b2195abea932b73fab989e4b14fe3075cc1c76d25552d81d2b", + "vendor/pr2857/allocation/construction/FLOW.json.gz": "432f6e7ea0af6208a5a30323dcda936abfa6689c13cc136a5f0c25b0c498368e", + "vendor/pr2857/allocation/construction/MODEL.json": "25c2caab5b6ad85f9977639049b5e4679b6c635d800df43b35b3e580d915365c", + "vendor/pr2857/allocation/construction/NEGATIVE-CONTROLS.json": "d1cee69137cf7cf3239b5265f4538bd0e3547650ae5862f5a3579dd3fc16d4eb", + "vendor/pr2857/allocation/construction/PR2843-INDEPENDENT-NOTICE": "b1a13e97bf3503b4a52033518dd528d010f57be7b591245bf48910c20320d186", + "vendor/pr2857/allocation/construction/PR2843-build_allocation.py": "c8281fef278ff84bc6ff698699cb662f63e150e8f797dba07137103e9d81af71", + "vendor/pr2857/allocation/construction/REPLAY-CHECK.json": "8eda15bd557c2dcd153187dd39551e44e4c9f6fcc3b29aa3ede0638c184fe5d9", + "vendor/pr2857/allocation/construction/SOLVER.json": "62da09c8cd9a5ed3819e0e222cba83529c049e6e86e182940de2cb434f83f8b1", + "vendor/pr2857/allocation/construction/check_compression_policy.py": "810c35176d252db60f01725fe20b71330e5d6f702c4e991cc5552f1e3d53bbb9", + "vendor/pr2857/allocation/construction/discover_original.py": "c0aebddeb7271b8dc62cf9ac94b85c40c90f4ec938fc23a9d03c61888232614c", + "vendor/pr2857/allocation/replay_allocation.py": "f53a7f44b471dfb9d13ff3e8bdf06f87e402a31e2753118fafb4a27863da337f", + "vendor/pr2857/audit_owners.py": "18545051734238fe82690c15e4dd84d716e17372952b67c506248b1aafb5f86c", + "vendor/pr2857/audit_relaxation.py": "0e489823b37303ba383648e3fd21aca1b497abc74c297b5b131a3e4684cf5302", + "vendor/pr2857/build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "vendor/pr2857/check_ceiling.py": "5bcd91806d1b47c085c17e52de36939d7761f77c0e0af2c5e5ac4263c5fe0580", + "vendor/pr2857/check_four_kernels.py": "34ded7db6524ca4e7229c887c24ad7a5ce2531007f7c1ebfc4dd9af952406614", + "vendor/pr2857/check_release_evidence.py": "e996f252cc4dd23b02ad623dfdca1a6cb62799a1f390f92fb9eaaa5fc89558e7", + "vendor/pr2857/integration-review/DERIVATION-REVIEW-OPTIMIZED.json": "9c5316e77ec1520e47214e8f673ca357918544f174f316f9557a8875daaf1279", + "vendor/pr2857/integration-review/DERIVATION-REVIEW.json": "b4673c060f8502ced720e5f4b7095da7c4ed305455a6cdd0d5a507001733d5fa", + "vendor/pr2857/integration-review/FAILED-V1.json": "4beb6dce762b626bfeac2ab93a54c6b5b2165e7f1e25db1b69b1a43fb6455389", + "vendor/pr2857/integration-review/FINAL-CHAIN-REVIEW.json": "a738972f0010d878032f9608070d0f649ca9d5d6798d0e696251aef51030d84c", + "vendor/pr2857/integration-review/REVIEW.md": "d103b7ca1d805c7de6b3ac9f1d95ac150294858adca06554e305045f32e2b6ec", + "vendor/pr2857/integration-review/T37-GEOMETRY-PREFLIGHT.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "vendor/pr2857/integration-review/check_integration_derivation.py": "0f02d3e0fb0d53dc4d2c444bbdd7054040ee32bf2a1fef8ff96e3a780d579203", + "vendor/pr2857/integration-review/fixtures/derivation/DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "vendor/pr2857/integration-review/fixtures/derivation/build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "vendor/pr2857/integration-review/fixtures/derivation/prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "vendor/pr2857/integration-review/fixtures/derivation/reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "vendor/pr2857/integration-review/fixtures/new/admit.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "vendor/pr2857/integration-review/fixtures/new/runtime/geometry_controls.py": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "vendor/pr2857/integration-review/fixtures/new/source/MANIFEST.json": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "vendor/pr2857/integration-review/fixtures/new/source/new/rebuild_borrow.py": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "vendor/pr2857/integration-review/fixtures/new/source/verify.py": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "vendor/pr2857/integration-review/fixtures/old/admit.py": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "vendor/pr2857/integration-review/fixtures/old/runtime/geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "vendor/pr2857/integration-review/fixtures/old/source/MANIFEST.json": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "vendor/pr2857/integration-review/fixtures/old/source/new/rebuild_borrow.py": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "vendor/pr2857/integration-review/fixtures/old/source/verify.py": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0", + "vendor/pr2857/materialize_source.py": "4f496ed6263aec187019a9005a4125487137e5380bbc88a14a4962a0d77bd881", + "vendor/pr2857/owner_controls.py": "db9837c4d3905418b55dbeb3aebed29341cf5e98c948f37f56d0fc4c49ca2087", + "vendor/pr2857/prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "vendor/pr2857/reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "vendor/pr2857/requirements-reproduction.txt": "5e665fa5c409df8f7a561a4c0286173802aad59f3f90587f83b804efa146f7bd", + "vendor/pr2857/review_four_groups.py": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "vendor/pr2857/run_integration_review.py": "195b5ebeac758f6766ff78586ffa177d3c5de011e007d299d9d900d42b2d31f4", + "vendor/pr2857/run_owner_controls.py": "3bbe39c554345ff7d48a117597ea7d925c183c13c1d743360bd0e128c763b56b", + "vendor/pr2857/shared_kernel.py": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "vendor/pr2857/source_pin_controls.py": "1a76d03b22e93122e2b6f980bffea3a19882722dc220f7c9864621c697995cdd", + "vendor/pr2857/sources/PR2833-DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "vendor/pr2857/sources/PR2833-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "vendor/pr2857/sources/PR2833-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "vendor/pr2857/sources/PR2833-PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "vendor/pr2857/sources/PR2833-PROVIDERS.json": "3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda", + "vendor/pr2857/sources/PR2833-T37-DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "vendor/pr2857/sources/PR2833-T37-OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr2857/sources/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "vendor/pr2857/sources/PR2833-WORD-base.json.gz": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "vendor/pr2857/sources/PR2833-WORD-extra.json.gz": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "vendor/pr2857/sources/PR2839-CREDITS.md": "d8eea66efb6796d3caeec985949724eab9df1eb214182b7db2ef84ba6e19b5e9", + "vendor/pr2857/sources/PR2839-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr2857/sources/PR2843-DISPATCH.json": "e06a95c589425f92e4cce90b0d71664b96d5955bb34d9ffefdae4b432fa8746b", + "vendor/pr2857/sources/PR2843-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr2857/sources/PR2843-NOTICE": "b1a13e97bf3503b4a52033518dd528d010f57be7b591245bf48910c20320d186", + "vendor/pr2857/sources/PR2843-ORDER.json": "5fc45c6e6a50db17c1eb2577d36e0dab3057005bc269ea6be1241c79f61aeced", + "vendor/pr2857/sources/PR2848-CLAIM.json": "aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9", + "vendor/pr2857/sources/PR2853-OUTER-CLAIM.json": "eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa", + "vendor/pr2857/vendor/ceiling.py": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "vendor/pr2857/vendor/pr2839/CREDITS.md": "d8eea66efb6796d3caeec985949724eab9df1eb214182b7db2ef84ba6e19b5e9", + "vendor/pr2857/vendor/pr2839/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr2857/vendor/pr2839/blocknorm_certificate.py": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92", + "vendor/pr2857/vendor/pr2839/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "vendor/pr2857/vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "vendor/pr2857/vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "vendor/pr2857/vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "vendor/pr2857/verify.py": "1a16ddf9778ea41bc3ed50532ea3c00b6cbc4ec55a2bae5c4842277a02fd99ac", + "vendor/pr2857/words/WORD-base.json.gz": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "vendor/pr2857/words/WORD-extra.json.gz": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546" +} diff --git a/research/shared-kernel-packing/NOTICE b/research/shared-kernel-packing/NOTICE new file mode 100644 index 0000000000..124fd0dcd8 --- /dev/null +++ b/research/shared-kernel-packing/NOTICE @@ -0,0 +1,30 @@ +T185 attainment of the current shared-kernel packing optimum +This MathProof deliverable adds the ten-move construction, exact fixed-model +optimality proof, separate audits and portable replay, prepared with substantial +OpenAI Codex assistance (root and three Codex agents). New code is Apache-2.0. +Marius-Paul Dumitrean's PR #2856 vacancy-path method and Dugongue's PR #2855 +concentration work are additionally credited; see CREDITS.md for full scope. +Original copyrights, licenses and notices remain in the retained sources. + +The following is the original PR #2857 notice, reproduced unchanged. Its +preparation attribution and directory references describe that upstream package. + +Four staged compensation kernels and chronological owner repacking +Prepared for Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +New contributions are licensed under Apache-2.0. + +Jeremy Kothe (@jeremykothe2), PR2833: pinned source words, dirt-entry mechanism, +local audit, cleanup and native reconstruction lineage. +@philippeVV, concurrent PR2853: the same four A-phase helper quartets +and entrance mechanism, with a different early-read schedule and paid profile. +Marius-Paul Dumitrean (@mdumitrean), PR2843 and predecessors: integer owner-flow +construction and edge-coloring realization, retained in allocation/construction. +Dugongue, PR2839: tensor-block norm and replica/owner interfaces. +Tekalign (@tekuuu), native and source-bound admission lineage. +David Arias C and the other contributors credited in the retained sources. + +Original source-specific licenses and notices are retained in sources/, vendor/ +and allocation/. This notice supplements, and does not replace, their attribution. +Independent checks here are separate AI-assisted implementations; no independent +human or maintainer review, new selected frontier, or full theorem formalization +is claimed. diff --git a/research/shared-kernel-packing/PR-BODY.md b/research/shared-kernel-packing/PR-BODY.md new file mode 100644 index 0000000000..f3a0593ae4 --- /dev/null +++ b/research/shared-kernel-packing/PR-BODY.md @@ -0,0 +1,9 @@ +Combines the complete shared-kernel words from PR #2857 with a width 9 vacancy relay inspired by PR #2856 and five-copy concentration from PR #2848 / PR #2855. The literal T185 construction raises conditional κ to **0.001720100805416885927944 − 10⁻⁴⁶ − 10⁻⁷⁰**, an exact gain of **4.176732053326972 × 10⁻⁹** over the full pinned PR #2857 claim. + +Adds the ten actual moves, complete owner data, a deterministic constructor, separate source-event and rational moment checks, and a matching exact rational primal/dual across all 1,163 packing patterns. The actual allocation attains the fractional optimum near its moment root for the fixed current native words, helper inventory and bin capacities. The bound applies to every admissible replica count. This closes that packing gap; it is not a maximum over new native words or multiplication algorithms. + +Validation: both changed native chains freshly passed all five stages and both orientations on 632 columns. Two unchanged retained chains and the 16-stage parent are explicitly reused from this campaign's fresh four-chain bootstrap. Complete serial supplier/controller, geometry, compiler/precision invoice, BIT and modern outer release passed with source/cache guards and validator predicates retained. A first parallel attempt hit a temporary receipt-read failure; the preserved note explains the serial rerun. The portable wrapper is preflighted separately; its underlying full stages were executed, but a second cold wrapper replay is not claimed. + +All inherited asymptotic hypotheses remain. This is informal mathematics and exact finite certification, not Lean formalization or an unconditional multiplication theorem. Credits include Yiyang/Lyy-iiis (#2857, #2848), Marius-Paul Dumitrean (#2856, #2843), Philippe Van Velzen (#2853), Jeremy Kothe (#2833), Dugongue (#2855, #2839) and all retained contributors. Original licenses/notices remain. Root and three Codex agents supplied the new work; no independent human review or global priority claim. + +Package: `research/shared-kernel-packing/`. Start with `README.md`; run `python -B tools/verify_package.py --work `. Full native/outer replay, exact claim, proof notes and evidence are included. `evidence/SOURCE-REFRESH.json` records the latest inspected main/PR snapshots and bounded overlap scope. diff --git a/research/shared-kernel-packing/PR-TITLE.txt b/research/shared-kernel-packing/PR-TITLE.txt new file mode 100644 index 0000000000..4b0b9137ef --- /dev/null +++ b/research/shared-kernel-packing/PR-TITLE.txt @@ -0,0 +1 @@ +Attain the fixed-word packing optimum: conditional κ ≈ 0.0017201008054 diff --git a/research/shared-kernel-packing/README.md b/research/shared-kernel-packing/README.md new file mode 100644 index 0000000000..dc336712a4 --- /dev/null +++ b/research/shared-kernel-packing/README.md @@ -0,0 +1,84 @@ +# T185 attains the shared-kernel packing optimum + +**Conditional κ = 0.001720100805416885927944 − 10⁻⁴⁶ − 10⁻⁷⁰.** + +The exact increase over the full pinned PR #2857 headline is **4.176732053326972 × 10⁻⁹**. The new allocation attains the fractional packing optimum at the moment root for the explicitly fixed current native words, helper inventory and bin capacities. This is a constructed optimum in that model, not a maximum over all multiplication algorithms or future native circuits. + +## The compatible combination + +| Ingredient | Source | Actual use | +|---|---|---| +| Cheaper staged shared kernels | Yiyang/Lyy-iiis, PR #2857 | Both complete changed words, including compensation and inverse cleanup. | +| Dirty A-phase entry and prior native improvements | Philippe Van Velzen, PR #2853; Jeremy Kothe, PR #2833; their retained lineage | Source and ABI precedents, with the shared-kernel schedule replacing the more expensive alternative for the same quartet. | +| Cost-neutral vacancy paths | Marius-Paul Dumitrean, PR #2856 | A checked width 9 relay moves the unique unused rank 9 to a useful source window. | +| Concentration and interleaved copies | PR #2848, PR #2855 and retained replica contracts | Five exact copies, followed by filling all five rank 9 vacancies from one actual donor. | +| Exact fixed-inventory packing relaxation | PR #2857 precedent and the new symbolic certificate | A matching rational primal and dual across every one of the 1,163 capacity-feasible patterns. | + +The construction has ten literal whole-role moves. In each of five copies, helper 208 at source call 320 moves from bin (28,16,76) to (35,16,37), transferring the vacancy without changing its paid profile. Five actual width 9 roles from the capacity 48 donor (32,13,94) then fill the five resulting vacancies. Interleaving preserves every replica's source-event order; the literal full checker establishes the strict bridge-aware windows, physical-family separation and all masks. + +Relative to five complete incoming profiles, the entire cost changes by + + H₄₈ − H₃ − 5H₉ < 0, where Hᵣ = rᵖ and 0 < p < 1. + +The inequality follows from strict subadditivity and 48 = 3 + 5 × 9. Native paid work is included and unchanged. All 679,320 roles in 1,665 calls, live stock 165,760 and physical stock 166,250 are counted. The final profile is + + {1:4029300, 2:1068930, 3:458874, 4:213120, + 5:65490, 8:13320, 48:66896}. + +## Why this reaches the packing bound + +Each replica has bin counts {8:672, 16:448, 32:448, 48:448} and nine copies of the fixed 408-helper inventory {4:26, 5:2, 7:62, 8:84, 9:234}. Every integral packing, regardless of its chronology, induces a feasible point of the same fractional pattern program after dividing by its replica count. + +`review/PROOF.md` gives exact rational primal multiplicities and explicit symbolic dual prices. `review/profile_lp_certificate.py` checks all 1,163 patterns, handles 11 tight identities symbolically, and proves every other inequality by directed integer series uniformly around the moment root. The actual T185 histogram equals that rational optimum multiplied by 185. Combined with the literal causal witness, this proves attainment rather than just an optimistic numerical cap. + +Every paid rank is at most 48 < 73, so each feasible normalized moment increases strictly with the saving parameter. The exact dual upper-endpoint check bounds all packings in this fixed model. The independent root bracket is [0.00172010080541688592794400, 0.00172010080541688592794401]. The released outer headline uses the conservative 24-digit endpoint above. A finer moment bracket is not silently promoted to a finer outer claim. + +## Fast offline replay + +Python 3.12 or newer with its standard library suffices. Keep assertions enabled. From this folder: + +```text +python -B tools/verify_package.py --hash-only +python -B tools/verify_package.py --work ../t185-check +``` + +Choose a fresh external work directory. This authenticates the complete file inventory and hashes, regenerates all five data files byte-for-byte without a solver, runs the separate source-event and exact rational moment auditors, runs the second independently implemented owner/provider/moment check, and regenerates the complete fixed-model primal/dual certificate. The source words and baseline allocation are included in `vendor/pr2857/` as byte-preserved immutable inputs. The package remains unchanged during replay. + +`CONSTRUCTION.md` contains the explicit ten moves and universal paid-cost proof. `review/PROOF.md` defines the restricted optimality model and dual. `review/SOURCE-COMPATIBILITY.md` records the separate local operator/frame review. Review by Codex agents is identified as such; it is not independent human peer review. + +## Complete fresh native and outer replay + +Fetch the exact original PR #2833 source into a fresh external directory: + +```text +node --use-system-ca tools/fetch_source.cjs ../original-source +``` + +This checks all 541 manifest entries at immutable head `e9307b48d7d1b690939935ecef0f8e524e6d92f4`, using normal certificate verification. It does not change an installed checkout. `tools/materialize_source.py` can instead export exact local Git objects. + +For the complete replay, use Python 3.13 with NumPy, SciPy, SymPy and mpmath. The actual runs used NumPy 2.5.4, SciPy 1.18.1, SymPy 1.14.0 and mpmath 1.4.1; gmpy2 and psutil were absent. On Windows, create an isolated interpreter that reuses those installed packages read-only and gives generated `Path.write_text` output an LF default: + +```text +python -B tools/make_lf_runtime.py --out ../t185-runtime +../t185-runtime/Scripts/python.exe -B reproduce.py --source ../original-source --work F:/proof/t185-run --jobs 3 +``` + +Use a short fresh absolute work path. On a POSIX system with LF defaults, run `python -B reproduce.py` directly with the same arguments. The isolated helper changes no global configuration or validator predicate. Native bootstrap jobs may overlap. The complete admission runs its mutation controls in one process: the inherited parallel sharder shares a temporary receipt filename and the first parallel attempt hit a Windows receipt-read failure. Serial replay retains every control and predicate. See `evidence/REPLAY-NOTE.json`. + +The default wrapper freshly bootstraps the retained source/native/parent evidence, builds the byte-exact 547-entry shared-kernel overlay, runs both changed native chains freshly, and runs complete admission. `--prepared-retained` explicitly reuses a completed authenticated bootstrap; the strict preparer still checks the entire cache, exact retained source, native word identities and all 16 retained parent stages. One exact receipt pin is rebound to that bootstrap, with a derivation receipt; no semantic predicate is removed. `--dry-run` authenticates inputs and prints commands without replay. + +The actual campaign ran four fresh predecessor chains and the retained parent, then both changed shared-kernel chains freshly; the final admission explicitly reused the authenticated retained evidence. The underlying complete admission and new native stages were executed. The published orchestration wrapper's command plan is separately preflighted; a second cold replay of that wrapper is not claimed. + +## Scope and source lineage + +The root `CLAIM.json` and `evidence/RELEASE-RECEIPT.json` are the authoritative outer headline. Legacy supplier receipts may retain historical κ/status labels; their current source manifests, complex endpoint and outer arithmetic are explicitly bound. + +All inherited all-size compiler, common-label/source-access, mutable-source, hosting, precision/tape, recovery, ordinary recursion, BIT and analytic-transfer assumptions remain. This is informal mathematics plus exact finite computational certification, not a new unconditional multiplication theorem or Lean kernel/axiom audit. The fixed packing optimum does not cover different native words, helper inventories, capacities or controllers. No measured runtime or hardware gain is asserted. + +See `CREDITS.md` for the relevant PRs, exact source heads and overlap scope; all original licenses and notices remain. `UPLOAD.md` gives the branch, PR title/body and short hash-checked upload batches. The canonical Lean tree and authoritative DAG remain on D:. + +## Open next questions + +The fixed-word gap is closed near the moment root. A further gain would require an actual changed native/consumer contract with a better complete paid bill, or another changed source premise with a proved applicable normalization. The contract must account for arbitrary dirt, restoration, transport and precision before its benefit is counted; none is assumed here. + +A separate useful direction is a sufficient all-size compiler or precision/tape transfer theorem for the actual words. This package does not settle that inherited question. `TASK.json` records these directions and the bounded completed scope. `VERIFY.json` registers the standard-library finite/LP replay for the repository's Python 3.12 research-package CI; the actual campaign ran Python 3.13.5, while a full native replay uses the separately documented dependency runtime. diff --git a/research/shared-kernel-packing/RELAY-PLAN.json b/research/shared-kernel-packing/RELAY-PLAN.json new file mode 100644 index 0000000000..3263f0a322 --- /dev/null +++ b/research/shared-kernel-packing/RELAY-PLAN.json @@ -0,0 +1,79 @@ +{ + "status": "FOUND_ACTUAL_VACANCY_RELAY", + "initial_hole": [ + 35, + 16, + 37 + ], + "relay": [ + { + "source": [ + 28, + 16, + 76 + ], + "destination": [ + 35, + 16, + 37 + ], + "row": [ + 320, + 208, + 28, + 16, + 76, + 7 + ] + } + ], + "donor": [ + 32, + 13, + 94 + ], + "donor_rows": [ + [ + 292, + 17, + 32, + 13, + 94, + 0 + ], + [ + 293, + 151, + 32, + 13, + 94, + 9 + ], + [ + 311, + 107, + 32, + 13, + 94, + 18 + ], + [ + 316, + 54, + 32, + 13, + 94, + 27 + ], + [ + 317, + 26, + 32, + 13, + 94, + 36 + ] + ], + "nodes": 1950, + "seconds": 0.1005509999813512 +} diff --git a/research/shared-kernel-packing/SOURCES.json b/research/shared-kernel-packing/SOURCES.json new file mode 100644 index 0000000000..3eb6be049e --- /dev/null +++ b/research/shared-kernel-packing/SOURCES.json @@ -0,0 +1,19 @@ +{ + "schema_version": 1, + "base_commit": "d311a18c6061af67d0aa35cbeced605b8b7472ed", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ], + "note": "Actual immutable PR #2857 vendor blobs are separately pinned in evidence/UPSTREAM-PR2857-SOURCE.json and the complete package MANIFEST.json. Native/source replay is documented in README." +} diff --git a/research/shared-kernel-packing/TASK.json b/research/shared-kernel-packing/TASK.json new file mode 100644 index 0000000000..239f582c98 --- /dev/null +++ b/research/shared-kernel-packing/TASK.json @@ -0,0 +1,67 @@ +{ + "actual_scope": "Construct the T185 ten-move relay on complete PR #2857 native words and prove attainment of their fixed inventory/capacity fractional packing optimum near the moment root, with complete inherited supplier/outer admission.", + "ai_assistance": "Substantial OpenAI Codex assistance from root and three agents for construction, proof, implementation and separate audits. No independent human review is claimed.", + "author": "MathProof research contributor; retained authors are listed in CREDITS.md.", + "base_commit": "d311a18c6061af67d0aa35cbeced605b8b7472ed", + "bottleneck_link": "The remaining fractional packing gap is about 4.18e-9. This bounded construction closes it; a materially larger gain needs a changed fully priced native or source premise.", + "evidence": "Actual T185 causal witness and exact moment; complete 1163-pattern primal/dual attainment; both fresh changed native chains and authenticated retained parent; complete serial supplier/controller/geometry/invoice/BIT/modern outer PASS_RELEASE. See CLAIM.json and evidence receipts.", + "open_questions": [ + { + "blocked_by": "No such new contract is assumed or established here; its costs and all obligations must be proved.", + "first_step": "Specify the actual input, output, arbitrary dirt, consumption and restoration interfaces, then charge a proposed complete word before searching for a literal allocation.", + "question": "Can a changed fully priced native/consumer contract yield a lower complete paid moment than this fixed-word optimum?", + "why_it_matters": "Changing packing alone cannot improve the certified fixed inventory optimum near its root." + }, + { + "blocked_by": "This deliverable supplies finite certification and informal packing theory, not the missing all-size proof.", + "first_step": "Choose a named inherited implication, state its exact source hypotheses and prove a sufficient uniform transfer theorem.", + "question": "Can one retained all-size compiler or precision/tape implication be proved for the actual words?", + "why_it_matters": "The finite and outer certification remains conditional on inherited uniform interfaces." + } + ], + "original_card": { + "acceptance_gate": "Check live PR overlap first, price both suppliers and distinguish a search best from an optimum. Report the word's packing cap from ceiling.ceiling() and the fraction of it realized; label packing gains as such.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Locate the selected packing source in the review and check live PRs for the same residual problem.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "id": "selected-packing", + "methods": [ + "Search a named unclaimed canonical candidate domain with a reproducible partition.", + "Prove a stronger scoped relaxation or exact optimum for one named residual subproblem." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ], + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ] + }, + "outcome": "completed", + "priority_revision": 5, + "schema_version": 1, + "scope_change_reason": "The user requested a useful composition of the best current work. The target is the newly published PR #2857 fixed-word packing gap, not the older maintainer-selected supplier; actual attainability and an exact optimum proof define the bounded result.", + "scope_status": "refined", + "stop_rule": "Accept only a literal causal witness, independent exact moment, matching exhaustive primal/dual and complete unchanged native/supplier/outer release. Stop fixed-word packing expansion after attainment.", + "task_id": "selected-packing" +} diff --git a/research/shared-kernel-packing/UPLOAD.md b/research/shared-kernel-packing/UPLOAD.md new file mode 100644 index 0000000000..9b4a4e88a3 --- /dev/null +++ b/research/shared-kernel-packing/UPLOAD.md @@ -0,0 +1,15 @@ +# Browser upload + +PR title: **Attain the fixed-word packing optimum: conditional κ ≈ 0.0017201008054** + +Branch: `research/shared-kernel-packing-optimum-20261015` + +Use `PR-BODY.md` as the body. Create this branch from current main in `CrocSwap/integer-mult-bounds`; use the same branch for every batch. + +- Batch 01: drag `F:/proof/up/kc57/01/research` at the **repository root** (80 files recursively). +- Batch 02: drag `F:/proof/up/kc57/02/research` at the **repository root** (80 files recursively). +- Batch 03: drag `F:/proof/up/kc57/03/research` at the **repository root** (5 files recursively). + +Each batch preserves `research/shared-kernel-packing/` exactly. Upload the extracted files by dragging the named `research` folder. The intended union is 165 files; no existing research package is deleted. Each batch has at most 80 files recursively, every file is below 25 MiB, and the longest staged absolute path is 128 characters. The external `PREFLIGHT.json` verifies every staged byte against the final source manifest and records its digest. Intended `.json.gz` files contain compressed JSON proof data. Original licenses and notices are included. + +After all batches are committed, compare with `MANIFEST.json` and run the fast offline verifier. Full replay is documented in README. This handoff prepares a new PR; it does not publish one or guarantee against browser/network errors. diff --git a/research/shared-kernel-packing/VERIFY.json b/research/shared-kernel-packing/VERIFY.json new file mode 100644 index 0000000000..a8266b8a29 --- /dev/null +++ b/research/shared-kernel-packing/VERIFY.json @@ -0,0 +1,19 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/tools/ci_verify.py" + ], + "timeout_seconds": 600, + "checks": "Authenticate complete package; reproduce T185 byte-exactly; check every source event and role, exact moment, separate reviewer and exhaustive 1163-pattern exact fixed-model optimum; authenticate full release/native provenance. Full fresh native replay remains a separate documented command." + } + ] +} diff --git a/research/shared-kernel-packing/data/DISPATCH.json b/research/shared-kernel-packing/data/DISPATCH.json new file mode 100644 index 0000000000..da25908ade --- /dev/null +++ b/research/shared-kernel-packing/data/DISPATCH.json @@ -0,0 +1 @@ +[[0,0,"extra"],[0,1,"extra"],[0,2,"extra"],[0,3,"extra"],[0,4,"extra"],[0,5,"extra"],[0,6,"extra"],[0,7,"extra"],[0,8,"extra"],[0,9,"extra"],[0,10,"extra"],[0,11,"extra"],[0,12,"extra"],[0,13,"extra"],[0,14,"extra"],[0,15,"extra"],[0,16,"extra"],[0,17,"extra"],[0,18,"extra"],[0,19,"extra"],[0,20,"extra"],[0,21,"extra"],[0,22,"extra"],[0,23,"extra"],[0,24,"extra"],[0,25,"extra"],[0,26,"extra"],[0,27,"extra"],[0,28,"extra"],[0,29,"extra"],[0,30,"extra"],[0,31,"extra"],[0,32,"extra"],[0,33,"extra"],[0,34,"extra"],[0,35,"extra"],[0,36,"extra"],[0,37,"extra"],[0,38,"extra"],[0,39,"extra"],[0,40,"extra"],[0,41,"extra"],[0,42,"extra"],[0,43,"extra"],[0,44,"extra"],[0,45,"extra"],[0,46,"extra"],[0,47,"extra"],[0,48,"extra"],[0,49,"extra"],[0,50,"extra"],[0,51,"extra"],[0,52,"extra"],[0,53,"extra"],[0,54,"extra"],[0,55,"extra"],[0,56,"extra"],[0,57,"extra"],[0,58,"extra"],[0,59,"extra"],[0,60,"extra"],[0,61,"extra"],[0,62,"extra"],[0,63,"extra"],[0,64,"extra"],[0,65,"extra"],[0,66,"extra"],[0,67,"extra"],[0,68,"extra"],[0,69,"extra"],[0,70,"extra"],[0,71,"extra"],[0,72,"extra"],[0,73,"extra"],[0,74,"extra"],[0,75,"extra"],[0,76,"extra"],[0,77,"extra"],[0,78,"extra"],[0,79,"extra"],[0,80,"extra"],[0,81,"extra"],[0,82,"extra"],[0,83,"extra"],[0,84,"extra"],[0,85,"extra"],[0,86,"extra"],[0,87,"extra"],[0,88,"extra"],[0,89,"extra"],[0,90,"extra"],[0,91,"extra"],[0,92,"extra"],[0,93,"extra"],[0,94,"extra"],[0,95,"extra"],[0,96,"extra"],[0,97,"extra"],[0,98,"extra"],[0,99,"extra"],[0,100,"extra"],[0,101,"extra"],[0,102,"extra"],[0,103,"extra"],[0,104,"extra"],[0,105,"extra"],[0,106,"extra"],[0,107,"extra"],[0,108,"extra"],[0,109,"extra"],[0,110,"extra"],[0,111,"extra"],[0,112,"extra"],[0,113,"extra"],[0,114,"extra"],[0,115,"extra"],[0,116,"extra"],[0,117,"extra"],[0,118,"extra"],[0,119,"extra"],[0,120,"extra"],[0,121,"extra"],[0,122,"extra"],[0,123,"extra"],[0,124,"extra"],[0,125,"extra"],[0,126,"extra"],[0,127,"extra"],[0,128,"extra"],[0,129,"extra"],[0,130,"extra"],[0,131,"extra"],[0,132,"extra"],[0,133,"extra"],[0,134,"extra"],[0,135,"extra"],[0,136,"extra"],[0,137,"extra"],[0,138,"extra"],[0,139,"extra"],[0,140,"extra"],[0,141,"extra"],[0,142,"extra"],[0,143,"extra"],[0,144,"extra"],[0,145,"extra"],[0,146,"extra"],[0,147,"extra"],[0,148,"extra"],[0,149,"extra"],[0,150,"extra"],[0,151,"extra"],[0,152,"extra"],[0,153,"extra"],[0,154,"extra"],[0,155,"extra"],[0,156,"extra"],[0,157,"extra"],[0,158,"extra"],[0,159,"extra"],[0,160,"extra"],[0,161,"extra"],[0,162,"extra"],[0,163,"extra"],[0,164,"extra"],[0,165,"extra"],[0,166,"extra"],[0,167,"extra"],[0,168,"extra"],[0,169,"extra"],[0,170,"extra"],[0,171,"extra"],[0,172,"extra"],[0,173,"extra"],[0,174,"extra"],[0,175,"extra"],[0,176,"extra"],[0,177,"extra"],[0,178,"extra"],[0,179,"extra"],[0,180,"extra"],[0,181,"extra"],[0,182,"extra"],[0,183,"extra"],[0,184,"extra"],[1,0,"extra"],[1,1,"extra"],[1,2,"extra"],[1,3,"extra"],[1,4,"extra"],[1,5,"extra"],[1,6,"extra"],[1,7,"extra"],[1,8,"extra"],[1,9,"extra"],[1,10,"extra"],[1,11,"extra"],[1,12,"extra"],[1,13,"extra"],[1,14,"extra"],[1,15,"extra"],[1,16,"extra"],[1,17,"extra"],[1,18,"extra"],[1,19,"extra"],[1,20,"extra"],[1,21,"extra"],[1,22,"extra"],[1,23,"extra"],[1,24,"extra"],[1,25,"extra"],[1,26,"extra"],[1,27,"extra"],[1,28,"extra"],[1,29,"extra"],[1,30,"extra"],[1,31,"extra"],[1,32,"extra"],[1,33,"extra"],[1,34,"extra"],[1,35,"extra"],[1,36,"extra"],[1,37,"extra"],[1,38,"extra"],[1,39,"extra"],[1,40,"extra"],[1,41,"extra"],[1,42,"extra"],[1,43,"extra"],[1,44,"extra"],[1,45,"extra"],[1,46,"extra"],[1,47,"extra"],[1,48,"extra"],[1,49,"extra"],[1,50,"extra"],[1,51,"extra"],[1,52,"extra"],[1,53,"extra"],[1,54,"extra"],[1,55,"extra"],[1,56,"extra"],[1,57,"extra"],[1,58,"extra"],[1,59,"extra"],[1,60,"extra"],[1,61,"extra"],[1,62,"extra"],[1,63,"extra"],[1,64,"extra"],[1,65,"extra"],[1,66,"extra"],[1,67,"extra"],[1,68,"extra"],[1,69,"extra"],[1,70,"extra"],[1,71,"extra"],[1,72,"extra"],[1,73,"extra"],[1,74,"extra"],[1,75,"extra"],[1,76,"extra"],[1,77,"extra"],[1,78,"extra"],[1,79,"extra"],[1,80,"extra"],[1,81,"extra"],[1,82,"extra"],[1,83,"extra"],[1,84,"extra"],[1,85,"extra"],[1,86,"extra"],[1,87,"extra"],[1,88,"extra"],[1,89,"extra"],[1,90,"extra"],[1,91,"extra"],[1,92,"extra"],[1,93,"extra"],[1,94,"extra"],[1,95,"extra"],[1,96,"extra"],[1,97,"extra"],[1,98,"extra"],[1,99,"extra"],[1,100,"extra"],[1,101,"extra"],[1,102,"extra"],[1,103,"extra"],[1,104,"extra"],[1,105,"extra"],[1,106,"extra"],[1,107,"extra"],[1,108,"extra"],[1,109,"extra"],[1,110,"extra"],[1,111,"extra"],[1,112,"extra"],[1,113,"extra"],[1,114,"extra"],[1,115,"extra"],[1,116,"extra"],[1,117,"extra"],[1,118,"extra"],[1,119,"extra"],[1,120,"extra"],[1,121,"extra"],[1,122,"extra"],[1,123,"extra"],[1,124,"extra"],[1,125,"extra"],[1,126,"extra"],[1,127,"extra"],[1,128,"extra"],[1,129,"extra"],[1,130,"extra"],[1,131,"extra"],[1,132,"extra"],[1,133,"extra"],[1,134,"extra"],[1,135,"extra"],[1,136,"extra"],[1,137,"extra"],[1,138,"extra"],[1,139,"extra"],[1,140,"extra"],[1,141,"extra"],[1,142,"extra"],[1,143,"extra"],[1,144,"extra"],[1,145,"extra"],[1,146,"extra"],[1,147,"extra"],[1,148,"extra"],[1,149,"extra"],[1,150,"extra"],[1,151,"extra"],[1,152,"extra"],[1,153,"extra"],[1,154,"extra"],[1,155,"extra"],[1,156,"extra"],[1,157,"extra"],[1,158,"extra"],[1,159,"extra"],[1,160,"extra"],[1,161,"extra"],[1,162,"extra"],[1,163,"extra"],[1,164,"extra"],[1,165,"extra"],[1,166,"extra"],[1,167,"extra"],[1,168,"extra"],[1,169,"extra"],[1,170,"extra"],[1,171,"extra"],[1,172,"extra"],[1,173,"extra"],[1,174,"extra"],[1,175,"extra"],[1,176,"extra"],[1,177,"extra"],[1,178,"extra"],[1,179,"extra"],[1,180,"extra"],[1,181,"extra"],[1,182,"extra"],[1,183,"extra"],[1,184,"extra"],[2,0,"extra"],[2,1,"extra"],[2,2,"extra"],[2,3,"extra"],[2,4,"extra"],[2,5,"extra"],[2,6,"extra"],[2,7,"extra"],[2,8,"extra"],[2,9,"extra"],[2,10,"extra"],[2,11,"extra"],[2,12,"extra"],[2,13,"extra"],[2,14,"extra"],[2,15,"extra"],[2,16,"extra"],[2,17,"extra"],[2,18,"extra"],[2,19,"extra"],[2,20,"extra"],[2,21,"extra"],[2,22,"extra"],[2,23,"extra"],[2,24,"extra"],[2,25,"extra"],[2,26,"extra"],[2,27,"extra"],[2,28,"extra"],[2,29,"extra"],[2,30,"extra"],[2,31,"extra"],[2,32,"extra"],[2,33,"gauge44"],[2,34,"gauge44"],[2,35,"gauge44"],[2,36,"gauge44"],[2,37,"extra"],[2,38,"extra"],[2,39,"extra"],[2,40,"extra"],[2,41,"extra"],[2,42,"extra"],[2,43,"extra"],[2,44,"extra"],[2,45,"extra"],[2,46,"extra"],[2,47,"extra"],[2,48,"extra"],[2,49,"extra"],[2,50,"extra"],[2,51,"extra"],[2,52,"extra"],[2,53,"extra"],[2,54,"extra"],[2,55,"extra"],[2,56,"extra"],[2,57,"extra"],[2,58,"extra"],[2,59,"extra"],[2,60,"extra"],[2,61,"extra"],[2,62,"extra"],[2,63,"extra"],[2,64,"extra"],[2,65,"extra"],[2,66,"extra"],[2,67,"extra"],[2,68,"extra"],[2,69,"extra"],[2,70,"gauge44"],[2,71,"gauge44"],[2,72,"gauge44"],[2,73,"gauge44"],[2,74,"extra"],[2,75,"extra"],[2,76,"extra"],[2,77,"extra"],[2,78,"extra"],[2,79,"extra"],[2,80,"extra"],[2,81,"extra"],[2,82,"extra"],[2,83,"extra"],[2,84,"extra"],[2,85,"extra"],[2,86,"extra"],[2,87,"extra"],[2,88,"extra"],[2,89,"extra"],[2,90,"extra"],[2,91,"extra"],[2,92,"extra"],[2,93,"extra"],[2,94,"extra"],[2,95,"extra"],[2,96,"extra"],[2,97,"extra"],[2,98,"extra"],[2,99,"extra"],[2,100,"extra"],[2,101,"extra"],[2,102,"extra"],[2,103,"extra"],[2,104,"extra"],[2,105,"extra"],[2,106,"extra"],[2,107,"gauge44"],[2,108,"gauge44"],[2,109,"gauge44"],[2,110,"gauge44"],[2,111,"extra"],[2,112,"extra"],[2,113,"extra"],[2,114,"extra"],[2,115,"extra"],[2,116,"extra"],[2,117,"extra"],[2,118,"extra"],[2,119,"extra"],[2,120,"extra"],[2,121,"extra"],[2,122,"extra"],[2,123,"extra"],[2,124,"extra"],[2,125,"extra"],[2,126,"extra"],[2,127,"extra"],[2,128,"extra"],[2,129,"extra"],[2,130,"extra"],[2,131,"extra"],[2,132,"extra"],[2,133,"extra"],[2,134,"extra"],[2,135,"extra"],[2,136,"extra"],[2,137,"extra"],[2,138,"extra"],[2,139,"extra"],[2,140,"extra"],[2,141,"extra"],[2,142,"extra"],[2,143,"extra"],[2,144,"gauge44"],[2,145,"gauge44"],[2,146,"gauge44"],[2,147,"gauge44"],[2,148,"extra"],[2,149,"extra"],[2,150,"extra"],[2,151,"extra"],[2,152,"extra"],[2,153,"extra"],[2,154,"extra"],[2,155,"extra"],[2,156,"extra"],[2,157,"extra"],[2,158,"extra"],[2,159,"extra"],[2,160,"extra"],[2,161,"extra"],[2,162,"extra"],[2,163,"extra"],[2,164,"extra"],[2,165,"extra"],[2,166,"extra"],[2,167,"extra"],[2,168,"extra"],[2,169,"extra"],[2,170,"extra"],[2,171,"extra"],[2,172,"extra"],[2,173,"extra"],[2,174,"extra"],[2,175,"extra"],[2,176,"extra"],[2,177,"extra"],[2,178,"extra"],[2,179,"extra"],[2,180,"extra"],[2,181,"gauge44"],[2,182,"gauge44"],[2,183,"gauge44"],[2,184,"gauge44"],[3,0,"extra"],[3,1,"extra"],[3,2,"extra"],[3,3,"extra"],[3,4,"extra"],[3,5,"extra"],[3,6,"extra"],[3,7,"extra"],[3,8,"extra"],[3,9,"extra"],[3,10,"extra"],[3,11,"extra"],[3,12,"extra"],[3,13,"extra"],[3,14,"extra"],[3,15,"extra"],[3,16,"extra"],[3,17,"extra"],[3,18,"extra"],[3,19,"extra"],[3,20,"extra"],[3,21,"extra"],[3,22,"extra"],[3,23,"extra"],[3,24,"extra"],[3,25,"extra"],[3,26,"extra"],[3,27,"extra"],[3,28,"gauge44"],[3,29,"gauge44"],[3,30,"gauge44"],[3,31,"gauge44"],[3,32,"gauge44"],[3,33,"gauge44"],[3,34,"gauge44"],[3,35,"gauge44"],[3,36,"gauge44"],[3,37,"extra"],[3,38,"extra"],[3,39,"extra"],[3,40,"extra"],[3,41,"extra"],[3,42,"extra"],[3,43,"extra"],[3,44,"extra"],[3,45,"extra"],[3,46,"extra"],[3,47,"extra"],[3,48,"extra"],[3,49,"extra"],[3,50,"extra"],[3,51,"extra"],[3,52,"extra"],[3,53,"extra"],[3,54,"extra"],[3,55,"extra"],[3,56,"extra"],[3,57,"extra"],[3,58,"extra"],[3,59,"extra"],[3,60,"extra"],[3,61,"extra"],[3,62,"extra"],[3,63,"extra"],[3,64,"extra"],[3,65,"gauge44"],[3,66,"gauge44"],[3,67,"gauge44"],[3,68,"gauge44"],[3,69,"gauge44"],[3,70,"gauge44"],[3,71,"gauge44"],[3,72,"gauge44"],[3,73,"gauge44"],[3,74,"extra"],[3,75,"extra"],[3,76,"extra"],[3,77,"extra"],[3,78,"extra"],[3,79,"extra"],[3,80,"extra"],[3,81,"extra"],[3,82,"extra"],[3,83,"extra"],[3,84,"extra"],[3,85,"extra"],[3,86,"extra"],[3,87,"extra"],[3,88,"extra"],[3,89,"extra"],[3,90,"extra"],[3,91,"extra"],[3,92,"extra"],[3,93,"extra"],[3,94,"extra"],[3,95,"extra"],[3,96,"extra"],[3,97,"extra"],[3,98,"extra"],[3,99,"extra"],[3,100,"extra"],[3,101,"extra"],[3,102,"gauge44"],[3,103,"gauge44"],[3,104,"gauge44"],[3,105,"gauge44"],[3,106,"gauge44"],[3,107,"gauge44"],[3,108,"gauge44"],[3,109,"gauge44"],[3,110,"gauge44"],[3,111,"extra"],[3,112,"extra"],[3,113,"extra"],[3,114,"extra"],[3,115,"extra"],[3,116,"extra"],[3,117,"extra"],[3,118,"extra"],[3,119,"extra"],[3,120,"extra"],[3,121,"extra"],[3,122,"extra"],[3,123,"extra"],[3,124,"extra"],[3,125,"extra"],[3,126,"extra"],[3,127,"extra"],[3,128,"extra"],[3,129,"extra"],[3,130,"extra"],[3,131,"extra"],[3,132,"extra"],[3,133,"extra"],[3,134,"extra"],[3,135,"extra"],[3,136,"extra"],[3,137,"extra"],[3,138,"extra"],[3,139,"gauge44"],[3,140,"gauge44"],[3,141,"gauge44"],[3,142,"gauge44"],[3,143,"gauge44"],[3,144,"gauge44"],[3,145,"gauge44"],[3,146,"gauge44"],[3,147,"gauge44"],[3,148,"extra"],[3,149,"extra"],[3,150,"extra"],[3,151,"extra"],[3,152,"extra"],[3,153,"extra"],[3,154,"extra"],[3,155,"extra"],[3,156,"extra"],[3,157,"extra"],[3,158,"extra"],[3,159,"extra"],[3,160,"extra"],[3,161,"extra"],[3,162,"extra"],[3,163,"extra"],[3,164,"extra"],[3,165,"extra"],[3,166,"extra"],[3,167,"extra"],[3,168,"extra"],[3,169,"extra"],[3,170,"extra"],[3,171,"extra"],[3,172,"extra"],[3,173,"extra"],[3,174,"extra"],[3,175,"extra"],[3,176,"gauge44"],[3,177,"gauge44"],[3,178,"gauge44"],[3,179,"gauge44"],[3,180,"gauge44"],[3,181,"gauge44"],[3,182,"gauge44"],[3,183,"gauge44"],[3,184,"gauge44"],[4,0,"extra"],[4,1,"extra"],[4,2,"extra"],[4,3,"extra"],[4,4,"extra"],[4,5,"extra"],[4,6,"extra"],[4,7,"extra"],[4,8,"extra"],[4,9,"extra"],[4,10,"extra"],[4,11,"extra"],[4,12,"extra"],[4,13,"extra"],[4,14,"extra"],[4,15,"extra"],[4,16,"extra"],[4,17,"extra"],[4,18,"extra"],[4,19,"extra"],[4,20,"extra"],[4,21,"extra"],[4,22,"extra"],[4,23,"extra"],[4,24,"gauge44"],[4,25,"gauge44"],[4,26,"gauge44"],[4,27,"gauge44"],[4,28,"gauge44"],[4,29,"gauge44"],[4,30,"gauge44"],[4,31,"gauge44"],[4,32,"gauge44"],[4,33,"gauge44"],[4,34,"gauge44"],[4,35,"gauge44"],[4,36,"gauge44"],[4,37,"extra"],[4,38,"extra"],[4,39,"extra"],[4,40,"extra"],[4,41,"extra"],[4,42,"extra"],[4,43,"extra"],[4,44,"extra"],[4,45,"extra"],[4,46,"extra"],[4,47,"extra"],[4,48,"extra"],[4,49,"extra"],[4,50,"extra"],[4,51,"extra"],[4,52,"extra"],[4,53,"extra"],[4,54,"extra"],[4,55,"extra"],[4,56,"extra"],[4,57,"extra"],[4,58,"extra"],[4,59,"extra"],[4,60,"extra"],[4,61,"gauge44"],[4,62,"gauge44"],[4,63,"gauge44"],[4,64,"gauge44"],[4,65,"gauge44"],[4,66,"gauge44"],[4,67,"gauge44"],[4,68,"gauge44"],[4,69,"gauge44"],[4,70,"gauge44"],[4,71,"gauge44"],[4,72,"gauge44"],[4,73,"gauge44"],[4,74,"extra"],[4,75,"extra"],[4,76,"extra"],[4,77,"extra"],[4,78,"extra"],[4,79,"extra"],[4,80,"extra"],[4,81,"extra"],[4,82,"extra"],[4,83,"extra"],[4,84,"extra"],[4,85,"extra"],[4,86,"extra"],[4,87,"extra"],[4,88,"extra"],[4,89,"extra"],[4,90,"extra"],[4,91,"extra"],[4,92,"extra"],[4,93,"extra"],[4,94,"extra"],[4,95,"extra"],[4,96,"extra"],[4,97,"extra"],[4,98,"gauge44"],[4,99,"gauge44"],[4,100,"gauge44"],[4,101,"gauge44"],[4,102,"gauge44"],[4,103,"gauge44"],[4,104,"gauge44"],[4,105,"gauge44"],[4,106,"gauge44"],[4,107,"gauge44"],[4,108,"gauge44"],[4,109,"gauge44"],[4,110,"gauge44"],[4,111,"extra"],[4,112,"extra"],[4,113,"extra"],[4,114,"extra"],[4,115,"extra"],[4,116,"extra"],[4,117,"extra"],[4,118,"extra"],[4,119,"extra"],[4,120,"extra"],[4,121,"extra"],[4,122,"extra"],[4,123,"extra"],[4,124,"extra"],[4,125,"extra"],[4,126,"extra"],[4,127,"extra"],[4,128,"extra"],[4,129,"extra"],[4,130,"extra"],[4,131,"extra"],[4,132,"extra"],[4,133,"extra"],[4,134,"extra"],[4,135,"gauge44"],[4,136,"gauge44"],[4,137,"gauge44"],[4,138,"gauge44"],[4,139,"gauge44"],[4,140,"gauge44"],[4,141,"gauge44"],[4,142,"gauge44"],[4,143,"gauge44"],[4,144,"gauge44"],[4,145,"gauge44"],[4,146,"gauge44"],[4,147,"gauge44"],[4,148,"extra"],[4,149,"extra"],[4,150,"extra"],[4,151,"extra"],[4,152,"extra"],[4,153,"extra"],[4,154,"extra"],[4,155,"extra"],[4,156,"extra"],[4,157,"extra"],[4,158,"extra"],[4,159,"extra"],[4,160,"extra"],[4,161,"extra"],[4,162,"extra"],[4,163,"extra"],[4,164,"extra"],[4,165,"extra"],[4,166,"extra"],[4,167,"extra"],[4,168,"extra"],[4,169,"extra"],[4,170,"extra"],[4,171,"extra"],[4,172,"gauge44"],[4,173,"gauge44"],[4,174,"gauge44"],[4,175,"gauge44"],[4,176,"gauge44"],[4,177,"gauge44"],[4,178,"gauge44"],[4,179,"gauge44"],[4,180,"gauge44"],[4,181,"gauge44"],[4,182,"gauge44"],[4,183,"gauge44"],[4,184,"gauge44"],[5,0,"extra"],[5,1,"extra"],[5,2,"extra"],[5,3,"extra"],[5,4,"extra"],[5,5,"extra"],[5,6,"extra"],[5,7,"extra"],[5,8,"extra"],[5,9,"extra"],[5,10,"extra"],[5,11,"extra"],[5,12,"extra"],[5,13,"extra"],[5,14,"extra"],[5,15,"extra"],[5,16,"extra"],[5,17,"extra"],[5,18,"extra"],[5,19,"gauge44"],[5,20,"gauge44"],[5,21,"gauge44"],[5,22,"gauge44"],[5,23,"gauge44"],[5,24,"gauge44"],[5,25,"gauge44"],[5,26,"gauge44"],[5,27,"gauge44"],[5,28,"gauge44"],[5,29,"gauge44"],[5,30,"gauge44"],[5,31,"gauge44"],[5,32,"gauge44"],[5,33,"gauge44"],[5,34,"gauge44"],[5,35,"gauge44"],[5,36,"gauge44"],[5,37,"extra"],[5,38,"extra"],[5,39,"extra"],[5,40,"extra"],[5,41,"extra"],[5,42,"extra"],[5,43,"extra"],[5,44,"extra"],[5,45,"extra"],[5,46,"extra"],[5,47,"extra"],[5,48,"extra"],[5,49,"extra"],[5,50,"extra"],[5,51,"extra"],[5,52,"extra"],[5,53,"extra"],[5,54,"extra"],[5,55,"extra"],[5,56,"gauge44"],[5,57,"gauge44"],[5,58,"gauge44"],[5,59,"gauge44"],[5,60,"gauge44"],[5,61,"gauge44"],[5,62,"gauge44"],[5,63,"gauge44"],[5,64,"gauge44"],[5,65,"gauge44"],[5,66,"gauge44"],[5,67,"gauge44"],[5,68,"gauge44"],[5,69,"gauge44"],[5,70,"gauge44"],[5,71,"gauge44"],[5,72,"gauge44"],[5,73,"gauge44"],[5,74,"extra"],[5,75,"extra"],[5,76,"extra"],[5,77,"extra"],[5,78,"extra"],[5,79,"extra"],[5,80,"extra"],[5,81,"extra"],[5,82,"extra"],[5,83,"extra"],[5,84,"extra"],[5,85,"extra"],[5,86,"extra"],[5,87,"extra"],[5,88,"extra"],[5,89,"extra"],[5,90,"extra"],[5,91,"extra"],[5,92,"extra"],[5,93,"gauge44"],[5,94,"gauge44"],[5,95,"gauge44"],[5,96,"gauge44"],[5,97,"gauge44"],[5,98,"gauge44"],[5,99,"gauge44"],[5,100,"gauge44"],[5,101,"gauge44"],[5,102,"gauge44"],[5,103,"gauge44"],[5,104,"gauge44"],[5,105,"gauge44"],[5,106,"gauge44"],[5,107,"gauge44"],[5,108,"gauge44"],[5,109,"gauge44"],[5,110,"gauge44"],[5,111,"extra"],[5,112,"extra"],[5,113,"extra"],[5,114,"extra"],[5,115,"extra"],[5,116,"extra"],[5,117,"extra"],[5,118,"extra"],[5,119,"extra"],[5,120,"extra"],[5,121,"extra"],[5,122,"extra"],[5,123,"extra"],[5,124,"extra"],[5,125,"extra"],[5,126,"extra"],[5,127,"extra"],[5,128,"extra"],[5,129,"extra"],[5,130,"gauge44"],[5,131,"gauge44"],[5,132,"gauge44"],[5,133,"gauge44"],[5,134,"gauge44"],[5,135,"gauge44"],[5,136,"gauge44"],[5,137,"gauge44"],[5,138,"gauge44"],[5,139,"gauge44"],[5,140,"gauge44"],[5,141,"gauge44"],[5,142,"gauge44"],[5,143,"gauge44"],[5,144,"gauge44"],[5,145,"gauge44"],[5,146,"gauge44"],[5,147,"gauge44"],[5,148,"extra"],[5,149,"extra"],[5,150,"extra"],[5,151,"extra"],[5,152,"extra"],[5,153,"extra"],[5,154,"extra"],[5,155,"extra"],[5,156,"extra"],[5,157,"extra"],[5,158,"extra"],[5,159,"extra"],[5,160,"extra"],[5,161,"extra"],[5,162,"extra"],[5,163,"extra"],[5,164,"extra"],[5,165,"extra"],[5,166,"extra"],[5,167,"gauge44"],[5,168,"gauge44"],[5,169,"gauge44"],[5,170,"gauge44"],[5,171,"gauge44"],[5,172,"gauge44"],[5,173,"gauge44"],[5,174,"gauge44"],[5,175,"gauge44"],[5,176,"gauge44"],[5,177,"gauge44"],[5,178,"gauge44"],[5,179,"gauge44"],[5,180,"gauge44"],[5,181,"gauge44"],[5,182,"gauge44"],[5,183,"gauge44"],[5,184,"gauge44"],[6,0,"extra"],[6,1,"extra"],[6,2,"extra"],[6,3,"extra"],[6,4,"extra"],[6,5,"extra"],[6,6,"extra"],[6,7,"extra"],[6,8,"extra"],[6,9,"extra"],[6,10,"extra"],[6,11,"extra"],[6,12,"extra"],[6,13,"extra"],[6,14,"extra"],[6,15,"gauge44"],[6,16,"gauge44"],[6,17,"gauge44"],[6,18,"gauge44"],[6,19,"gauge44"],[6,20,"gauge44"],[6,21,"gauge44"],[6,22,"gauge44"],[6,23,"gauge44"],[6,24,"gauge44"],[6,25,"gauge44"],[6,26,"gauge44"],[6,27,"gauge44"],[6,28,"gauge44"],[6,29,"gauge44"],[6,30,"gauge44"],[6,31,"gauge44"],[6,32,"gauge44"],[6,33,"gauge44"],[6,34,"gauge44"],[6,35,"gauge44"],[6,36,"gauge44"],[6,37,"extra"],[6,38,"extra"],[6,39,"extra"],[6,40,"extra"],[6,41,"extra"],[6,42,"extra"],[6,43,"extra"],[6,44,"extra"],[6,45,"extra"],[6,46,"extra"],[6,47,"extra"],[6,48,"extra"],[6,49,"extra"],[6,50,"extra"],[6,51,"extra"],[6,52,"gauge44"],[6,53,"gauge44"],[6,54,"gauge44"],[6,55,"gauge44"],[6,56,"gauge44"],[6,57,"gauge44"],[6,58,"gauge44"],[6,59,"gauge44"],[6,60,"gauge44"],[6,61,"gauge44"],[6,62,"gauge44"],[6,63,"gauge44"],[6,64,"gauge44"],[6,65,"gauge44"],[6,66,"gauge44"],[6,67,"gauge44"],[6,68,"gauge44"],[6,69,"gauge44"],[6,70,"gauge44"],[6,71,"gauge44"],[6,72,"gauge44"],[6,73,"gauge44"],[6,74,"extra"],[6,75,"extra"],[6,76,"extra"],[6,77,"extra"],[6,78,"extra"],[6,79,"extra"],[6,80,"extra"],[6,81,"extra"],[6,82,"extra"],[6,83,"extra"],[6,84,"extra"],[6,85,"extra"],[6,86,"extra"],[6,87,"extra"],[6,88,"extra"],[6,89,"gauge44"],[6,90,"gauge44"],[6,91,"gauge44"],[6,92,"gauge44"],[6,93,"gauge44"],[6,94,"gauge44"],[6,95,"gauge44"],[6,96,"gauge44"],[6,97,"gauge44"],[6,98,"gauge44"],[6,99,"gauge44"],[6,100,"gauge44"],[6,101,"gauge44"],[6,102,"gauge44"],[6,103,"gauge44"],[6,104,"gauge44"],[6,105,"gauge44"],[6,106,"gauge44"],[6,107,"gauge44"],[6,108,"gauge44"],[6,109,"gauge44"],[6,110,"gauge44"],[6,111,"extra"],[6,112,"extra"],[6,113,"extra"],[6,114,"extra"],[6,115,"extra"],[6,116,"extra"],[6,117,"extra"],[6,118,"extra"],[6,119,"extra"],[6,120,"extra"],[6,121,"extra"],[6,122,"extra"],[6,123,"extra"],[6,124,"extra"],[6,125,"extra"],[6,126,"gauge44"],[6,127,"gauge44"],[6,128,"gauge44"],[6,129,"gauge44"],[6,130,"gauge44"],[6,131,"gauge44"],[6,132,"gauge44"],[6,133,"gauge44"],[6,134,"gauge44"],[6,135,"gauge44"],[6,136,"gauge44"],[6,137,"gauge44"],[6,138,"gauge44"],[6,139,"gauge44"],[6,140,"gauge44"],[6,141,"gauge44"],[6,142,"gauge44"],[6,143,"gauge44"],[6,144,"gauge44"],[6,145,"gauge44"],[6,146,"gauge44"],[6,147,"gauge44"],[6,148,"extra"],[6,149,"extra"],[6,150,"extra"],[6,151,"extra"],[6,152,"extra"],[6,153,"extra"],[6,154,"extra"],[6,155,"extra"],[6,156,"extra"],[6,157,"extra"],[6,158,"extra"],[6,159,"extra"],[6,160,"extra"],[6,161,"extra"],[6,162,"extra"],[6,163,"gauge44"],[6,164,"gauge44"],[6,165,"gauge44"],[6,166,"gauge44"],[6,167,"gauge44"],[6,168,"gauge44"],[6,169,"gauge44"],[6,170,"gauge44"],[6,171,"gauge44"],[6,172,"gauge44"],[6,173,"gauge44"],[6,174,"gauge44"],[6,175,"gauge44"],[6,176,"gauge44"],[6,177,"gauge44"],[6,178,"gauge44"],[6,179,"gauge44"],[6,180,"gauge44"],[6,181,"gauge44"],[6,182,"gauge44"],[6,183,"gauge44"],[6,184,"gauge44"],[7,0,"extra"],[7,1,"extra"],[7,2,"extra"],[7,3,"extra"],[7,4,"extra"],[7,5,"extra"],[7,6,"extra"],[7,7,"extra"],[7,8,"extra"],[7,9,"extra"],[7,10,"gauge44"],[7,11,"gauge44"],[7,12,"gauge44"],[7,13,"gauge44"],[7,14,"gauge44"],[7,15,"gauge44"],[7,16,"gauge44"],[7,17,"gauge44"],[7,18,"gauge44"],[7,19,"gauge44"],[7,20,"gauge44"],[7,21,"gauge44"],[7,22,"gauge44"],[7,23,"gauge44"],[7,24,"gauge44"],[7,25,"gauge44"],[7,26,"gauge44"],[7,27,"gauge44"],[7,28,"gauge44"],[7,29,"gauge44"],[7,30,"gauge44"],[7,31,"gauge44"],[7,32,"gauge44"],[7,33,"gauge44"],[7,34,"gauge44"],[7,35,"gauge44"],[7,36,"gauge44"],[7,37,"extra"],[7,38,"extra"],[7,39,"extra"],[7,40,"extra"],[7,41,"extra"],[7,42,"extra"],[7,43,"extra"],[7,44,"extra"],[7,45,"extra"],[7,46,"extra"],[7,47,"gauge44"],[7,48,"gauge44"],[7,49,"gauge44"],[7,50,"gauge44"],[7,51,"gauge44"],[7,52,"gauge44"],[7,53,"gauge44"],[7,54,"gauge44"],[7,55,"gauge44"],[7,56,"gauge44"],[7,57,"gauge44"],[7,58,"gauge44"],[7,59,"gauge44"],[7,60,"gauge44"],[7,61,"gauge44"],[7,62,"gauge44"],[7,63,"gauge44"],[7,64,"gauge44"],[7,65,"gauge44"],[7,66,"gauge44"],[7,67,"gauge44"],[7,68,"gauge44"],[7,69,"gauge44"],[7,70,"gauge44"],[7,71,"gauge44"],[7,72,"gauge44"],[7,73,"gauge44"],[7,74,"extra"],[7,75,"extra"],[7,76,"extra"],[7,77,"extra"],[7,78,"extra"],[7,79,"extra"],[7,80,"extra"],[7,81,"extra"],[7,82,"extra"],[7,83,"extra"],[7,84,"gauge44"],[7,85,"gauge44"],[7,86,"gauge44"],[7,87,"gauge44"],[7,88,"gauge44"],[7,89,"gauge44"],[7,90,"gauge44"],[7,91,"gauge44"],[7,92,"gauge44"],[7,93,"gauge44"],[7,94,"gauge44"],[7,95,"gauge44"],[7,96,"gauge44"],[7,97,"gauge44"],[7,98,"gauge44"],[7,99,"gauge44"],[7,100,"gauge44"],[7,101,"gauge44"],[7,102,"gauge44"],[7,103,"gauge44"],[7,104,"gauge44"],[7,105,"gauge44"],[7,106,"gauge44"],[7,107,"gauge44"],[7,108,"gauge44"],[7,109,"gauge44"],[7,110,"gauge44"],[7,111,"extra"],[7,112,"extra"],[7,113,"extra"],[7,114,"extra"],[7,115,"extra"],[7,116,"extra"],[7,117,"extra"],[7,118,"extra"],[7,119,"extra"],[7,120,"extra"],[7,121,"gauge44"],[7,122,"gauge44"],[7,123,"gauge44"],[7,124,"gauge44"],[7,125,"gauge44"],[7,126,"gauge44"],[7,127,"gauge44"],[7,128,"gauge44"],[7,129,"gauge44"],[7,130,"gauge44"],[7,131,"gauge44"],[7,132,"gauge44"],[7,133,"gauge44"],[7,134,"gauge44"],[7,135,"gauge44"],[7,136,"gauge44"],[7,137,"gauge44"],[7,138,"gauge44"],[7,139,"gauge44"],[7,140,"gauge44"],[7,141,"gauge44"],[7,142,"gauge44"],[7,143,"gauge44"],[7,144,"gauge44"],[7,145,"gauge44"],[7,146,"gauge44"],[7,147,"gauge44"],[7,148,"extra"],[7,149,"extra"],[7,150,"extra"],[7,151,"extra"],[7,152,"extra"],[7,153,"extra"],[7,154,"extra"],[7,155,"extra"],[7,156,"extra"],[7,157,"extra"],[7,158,"gauge44"],[7,159,"gauge44"],[7,160,"gauge44"],[7,161,"gauge44"],[7,162,"gauge44"],[7,163,"gauge44"],[7,164,"gauge44"],[7,165,"gauge44"],[7,166,"gauge44"],[7,167,"gauge44"],[7,168,"gauge44"],[7,169,"gauge44"],[7,170,"gauge44"],[7,171,"gauge44"],[7,172,"gauge44"],[7,173,"gauge44"],[7,174,"gauge44"],[7,175,"gauge44"],[7,176,"gauge44"],[7,177,"gauge44"],[7,178,"gauge44"],[7,179,"gauge44"],[7,180,"gauge44"],[7,181,"gauge44"],[7,182,"gauge44"],[7,183,"gauge44"],[7,184,"gauge44"],[8,0,"extra"],[8,1,"extra"],[8,2,"extra"],[8,3,"extra"],[8,4,"extra"],[8,5,"gauge44"],[8,6,"gauge44"],[8,7,"gauge44"],[8,8,"gauge44"],[8,9,"gauge44"],[8,10,"gauge44"],[8,11,"gauge44"],[8,12,"gauge44"],[8,13,"gauge44"],[8,14,"gauge44"],[8,15,"gauge44"],[8,16,"gauge44"],[8,17,"gauge44"],[8,18,"gauge44"],[8,19,"gauge44"],[8,20,"gauge44"],[8,21,"gauge44"],[8,22,"gauge44"],[8,23,"gauge44"],[8,24,"gauge44"],[8,25,"gauge44"],[8,26,"gauge44"],[8,27,"gauge44"],[8,28,"gauge44"],[8,29,"gauge44"],[8,30,"gauge44"],[8,31,"gauge44"],[8,32,"gauge44"],[8,33,"gauge44"],[8,34,"gauge44"],[8,35,"gauge44"],[8,36,"gauge44"],[8,37,"extra"],[8,38,"extra"],[8,39,"extra"],[8,40,"extra"],[8,41,"extra"],[8,42,"gauge44"],[8,43,"gauge44"],[8,44,"gauge44"],[8,45,"gauge44"],[8,46,"gauge44"],[8,47,"gauge44"],[8,48,"gauge44"],[8,49,"gauge44"],[8,50,"gauge44"],[8,51,"gauge44"],[8,52,"gauge44"],[8,53,"gauge44"],[8,54,"gauge44"],[8,55,"gauge44"],[8,56,"gauge44"],[8,57,"gauge44"],[8,58,"gauge44"],[8,59,"gauge44"],[8,60,"gauge44"],[8,61,"gauge44"],[8,62,"gauge44"],[8,63,"gauge44"],[8,64,"gauge44"],[8,65,"gauge44"],[8,66,"gauge44"],[8,67,"gauge44"],[8,68,"gauge44"],[8,69,"gauge44"],[8,70,"gauge44"],[8,71,"gauge44"],[8,72,"gauge44"],[8,73,"gauge44"],[8,74,"extra"],[8,75,"extra"],[8,76,"extra"],[8,77,"extra"],[8,78,"extra"],[8,79,"gauge44"],[8,80,"gauge44"],[8,81,"gauge44"],[8,82,"gauge44"],[8,83,"gauge44"],[8,84,"gauge44"],[8,85,"gauge44"],[8,86,"gauge44"],[8,87,"gauge44"],[8,88,"gauge44"],[8,89,"gauge44"],[8,90,"gauge44"],[8,91,"gauge44"],[8,92,"gauge44"],[8,93,"gauge44"],[8,94,"gauge44"],[8,95,"gauge44"],[8,96,"gauge44"],[8,97,"gauge44"],[8,98,"gauge44"],[8,99,"gauge44"],[8,100,"gauge44"],[8,101,"gauge44"],[8,102,"gauge44"],[8,103,"gauge44"],[8,104,"gauge44"],[8,105,"gauge44"],[8,106,"gauge44"],[8,107,"gauge44"],[8,108,"gauge44"],[8,109,"gauge44"],[8,110,"gauge44"],[8,111,"extra"],[8,112,"extra"],[8,113,"extra"],[8,114,"extra"],[8,115,"extra"],[8,116,"gauge44"],[8,117,"gauge44"],[8,118,"gauge44"],[8,119,"gauge44"],[8,120,"gauge44"],[8,121,"gauge44"],[8,122,"gauge44"],[8,123,"gauge44"],[8,124,"gauge44"],[8,125,"gauge44"],[8,126,"gauge44"],[8,127,"gauge44"],[8,128,"gauge44"],[8,129,"gauge44"],[8,130,"gauge44"],[8,131,"gauge44"],[8,132,"gauge44"],[8,133,"gauge44"],[8,134,"gauge44"],[8,135,"gauge44"],[8,136,"gauge44"],[8,137,"gauge44"],[8,138,"gauge44"],[8,139,"gauge44"],[8,140,"gauge44"],[8,141,"gauge44"],[8,142,"gauge44"],[8,143,"gauge44"],[8,144,"gauge44"],[8,145,"gauge44"],[8,146,"gauge44"],[8,147,"gauge44"],[8,148,"extra"],[8,149,"extra"],[8,150,"extra"],[8,151,"extra"],[8,152,"extra"],[8,153,"gauge44"],[8,154,"gauge44"],[8,155,"gauge44"],[8,156,"gauge44"],[8,157,"gauge44"],[8,158,"gauge44"],[8,159,"gauge44"],[8,160,"gauge44"],[8,161,"gauge44"],[8,162,"gauge44"],[8,163,"gauge44"],[8,164,"gauge44"],[8,165,"gauge44"],[8,166,"gauge44"],[8,167,"gauge44"],[8,168,"gauge44"],[8,169,"gauge44"],[8,170,"gauge44"],[8,171,"gauge44"],[8,172,"gauge44"],[8,173,"gauge44"],[8,174,"gauge44"],[8,175,"gauge44"],[8,176,"gauge44"],[8,177,"gauge44"],[8,178,"gauge44"],[8,179,"gauge44"],[8,180,"gauge44"],[8,181,"gauge44"],[8,182,"gauge44"],[8,183,"gauge44"],[8,184,"gauge44"]] \ No newline at end of file diff --git a/research/shared-kernel-packing/data/FILL.json.gz b/research/shared-kernel-packing/data/FILL.json.gz new file mode 100644 index 0000000000..fb5e9f0be1 Binary files /dev/null and b/research/shared-kernel-packing/data/FILL.json.gz differ diff --git a/research/shared-kernel-packing/data/ORDER.json b/research/shared-kernel-packing/data/ORDER.json new file mode 100644 index 0000000000..da0c5cf8c2 --- /dev/null +++ b/research/shared-kernel-packing/data/ORDER.json @@ -0,0 +1 @@ +[[0,0],[0,37],[0,74],[0,111],[0,148],[0,1],[0,38],[0,75],[0,112],[0,149],[0,2],[0,39],[0,76],[0,113],[0,150],[0,3],[0,40],[0,77],[0,114],[0,151],[0,4],[0,41],[0,78],[0,115],[0,152],[1,0],[1,37],[1,74],[1,111],[1,148],[0,5],[0,42],[0,79],[0,116],[0,153],[1,1],[1,38],[1,75],[1,112],[1,149],[0,6],[0,43],[0,80],[0,117],[0,154],[1,2],[1,39],[1,76],[1,113],[1,150],[0,7],[0,44],[0,81],[0,118],[0,155],[1,3],[1,40],[1,77],[1,114],[1,151],[0,8],[0,45],[0,82],[0,119],[0,156],[1,4],[1,41],[1,78],[1,115],[1,152],[0,9],[0,46],[0,83],[0,120],[0,157],[2,0],[2,37],[2,74],[2,111],[2,148],[1,5],[1,42],[1,79],[1,116],[1,153],[0,10],[0,47],[0,84],[0,121],[0,158],[2,1],[2,38],[2,75],[2,112],[2,149],[1,6],[1,43],[1,80],[1,117],[1,154],[0,11],[0,48],[0,85],[0,122],[0,159],[2,2],[2,39],[2,76],[2,113],[2,150],[1,7],[1,44],[1,81],[1,118],[1,155],[0,12],[0,49],[0,86],[0,123],[0,160],[2,3],[2,40],[2,77],[2,114],[2,151],[1,8],[1,45],[1,82],[1,119],[1,156],[0,13],[0,50],[0,87],[0,124],[0,161],[2,4],[2,41],[2,78],[2,115],[2,152],[1,9],[1,46],[1,83],[1,120],[1,157],[3,0],[3,37],[3,74],[3,111],[3,148],[0,14],[0,51],[0,88],[0,125],[0,162],[2,5],[2,42],[2,79],[2,116],[2,153],[1,10],[1,47],[1,84],[1,121],[1,158],[3,1],[3,38],[3,75],[3,112],[3,149],[0,15],[0,52],[0,89],[0,126],[0,163],[2,6],[2,43],[2,80],[2,117],[2,154],[1,11],[1,48],[1,85],[1,122],[1,159],[3,2],[3,39],[3,76],[3,113],[3,150],[0,16],[0,53],[0,90],[0,127],[0,164],[2,7],[2,44],[2,81],[2,118],[2,155],[1,12],[1,49],[1,86],[1,123],[1,160],[3,3],[3,40],[3,77],[3,114],[3,151],[0,17],[0,54],[0,91],[0,128],[0,165],[2,8],[2,45],[2,82],[2,119],[2,156],[1,13],[1,50],[1,87],[1,124],[1,161],[3,4],[3,41],[3,78],[3,115],[3,152],[0,18],[0,55],[0,92],[0,129],[0,166],[2,9],[2,46],[2,83],[2,120],[2,157],[4,0],[4,37],[4,74],[4,111],[4,148],[1,14],[1,51],[1,88],[1,125],[1,162],[3,5],[3,42],[3,79],[3,116],[3,153],[0,19],[0,56],[0,93],[0,130],[0,167],[2,10],[2,47],[2,84],[2,121],[2,158],[4,1],[4,38],[4,75],[4,112],[4,149],[1,15],[1,52],[1,89],[1,126],[1,163],[3,6],[3,43],[3,80],[3,117],[3,154],[0,20],[0,57],[0,94],[0,131],[0,168],[2,11],[2,48],[2,85],[2,122],[2,159],[4,2],[4,39],[4,76],[4,113],[4,150],[1,16],[1,53],[1,90],[1,127],[1,164],[3,7],[3,44],[3,81],[3,118],[3,155],[0,21],[0,58],[0,95],[0,132],[0,169],[2,12],[2,49],[2,86],[2,123],[2,160],[4,3],[4,40],[4,77],[4,114],[4,151],[1,17],[1,54],[1,91],[1,128],[1,165],[3,8],[3,45],[3,82],[3,119],[3,156],[0,22],[0,59],[0,96],[0,133],[0,170],[2,13],[2,50],[2,87],[2,124],[2,161],[4,4],[4,41],[4,78],[4,115],[4,152],[1,18],[1,55],[1,92],[1,129],[1,166],[3,9],[3,46],[3,83],[3,120],[3,157],[0,23],[0,60],[0,97],[0,134],[0,171],[5,0],[5,37],[5,74],[5,111],[5,148],[2,14],[2,51],[2,88],[2,125],[2,162],[4,5],[4,42],[4,79],[4,116],[4,153],[1,19],[1,56],[1,93],[1,130],[1,167],[3,10],[3,47],[3,84],[3,121],[3,158],[0,24],[0,61],[0,98],[0,135],[0,172],[5,1],[5,38],[5,75],[5,112],[5,149],[2,15],[2,52],[2,89],[2,126],[2,163],[4,6],[4,43],[4,80],[4,117],[4,154],[1,20],[1,57],[1,94],[1,131],[1,168],[3,11],[3,48],[3,85],[3,122],[3,159],[0,25],[0,62],[0,99],[0,136],[0,173],[5,2],[5,39],[5,76],[5,113],[5,150],[2,16],[2,53],[2,90],[2,127],[2,164],[4,7],[4,44],[4,81],[4,118],[4,155],[1,21],[1,58],[1,95],[1,132],[1,169],[3,12],[3,49],[3,86],[3,123],[3,160],[0,26],[0,63],[0,100],[0,137],[0,174],[5,3],[5,40],[5,77],[5,114],[5,151],[2,17],[2,54],[2,91],[2,128],[2,165],[4,8],[4,45],[4,82],[4,119],[4,156],[1,22],[1,59],[1,96],[1,133],[1,170],[3,13],[3,50],[3,87],[3,124],[3,161],[0,27],[0,64],[0,101],[0,138],[0,175],[5,4],[5,41],[5,78],[5,115],[5,152],[2,18],[2,55],[2,92],[2,129],[2,166],[4,9],[4,46],[4,83],[4,120],[4,157],[1,23],[1,60],[1,97],[1,134],[1,171],[6,0],[6,37],[6,74],[6,111],[6,148],[3,14],[3,51],[3,88],[3,125],[3,162],[0,28],[0,65],[0,102],[0,139],[0,176],[5,5],[5,42],[5,79],[5,116],[5,153],[2,19],[2,56],[2,93],[2,130],[2,167],[4,10],[4,47],[4,84],[4,121],[4,158],[1,24],[1,61],[1,98],[1,135],[1,172],[6,1],[6,38],[6,75],[6,112],[6,149],[3,15],[3,52],[3,89],[3,126],[3,163],[0,29],[0,66],[0,103],[0,140],[0,177],[5,6],[5,43],[5,80],[5,117],[5,154],[2,20],[2,57],[2,94],[2,131],[2,168],[4,11],[4,48],[4,85],[4,122],[4,159],[1,25],[1,62],[1,99],[1,136],[1,173],[6,2],[6,39],[6,76],[6,113],[6,150],[3,16],[3,53],[3,90],[3,127],[3,164],[0,30],[0,67],[0,104],[0,141],[0,178],[5,7],[5,44],[5,81],[5,118],[5,155],[2,21],[2,58],[2,95],[2,132],[2,169],[4,12],[4,49],[4,86],[4,123],[4,160],[1,26],[1,63],[1,100],[1,137],[1,174],[6,3],[6,40],[6,77],[6,114],[6,151],[3,17],[3,54],[3,91],[3,128],[3,165],[0,31],[0,68],[0,105],[0,142],[0,179],[5,8],[5,45],[5,82],[5,119],[5,156],[2,22],[2,59],[2,96],[2,133],[2,170],[4,13],[4,50],[4,87],[4,124],[4,161],[1,27],[1,64],[1,101],[1,138],[1,175],[6,4],[6,41],[6,78],[6,115],[6,152],[3,18],[3,55],[3,92],[3,129],[3,166],[0,32],[0,69],[0,106],[0,143],[0,180],[5,9],[5,46],[5,83],[5,120],[5,157],[2,23],[2,60],[2,97],[2,134],[2,171],[7,0],[7,37],[7,74],[7,111],[7,148],[4,14],[4,51],[4,88],[4,125],[4,162],[1,28],[1,65],[1,102],[1,139],[1,176],[6,5],[6,42],[6,79],[6,116],[6,153],[3,19],[3,56],[3,93],[3,130],[3,167],[0,33],[0,70],[0,107],[0,144],[0,181],[5,10],[5,47],[5,84],[5,121],[5,158],[2,24],[2,61],[2,98],[2,135],[2,172],[7,1],[7,38],[7,75],[7,112],[7,149],[4,15],[4,52],[4,89],[4,126],[4,163],[1,29],[1,66],[1,103],[1,140],[1,177],[6,6],[6,43],[6,80],[6,117],[6,154],[3,20],[3,57],[3,94],[3,131],[3,168],[0,34],[0,71],[0,108],[0,145],[0,182],[5,11],[5,48],[5,85],[5,122],[5,159],[2,25],[2,62],[2,99],[2,136],[2,173],[7,2],[7,39],[7,76],[7,113],[7,150],[4,16],[4,53],[4,90],[4,127],[4,164],[1,30],[1,67],[1,104],[1,141],[1,178],[6,7],[6,44],[6,81],[6,118],[6,155],[3,21],[3,58],[3,95],[3,132],[3,169],[0,35],[0,72],[0,109],[0,146],[0,183],[5,12],[5,49],[5,86],[5,123],[5,160],[2,26],[2,63],[2,100],[2,137],[2,174],[7,3],[7,40],[7,77],[7,114],[7,151],[4,17],[4,54],[4,91],[4,128],[4,165],[1,31],[1,68],[1,105],[1,142],[1,179],[6,8],[6,45],[6,82],[6,119],[6,156],[3,22],[3,59],[3,96],[3,133],[3,170],[0,36],[0,73],[0,110],[0,147],[0,184],[5,13],[5,50],[5,87],[5,124],[5,161],[2,27],[2,64],[2,101],[2,138],[2,175],[7,4],[7,41],[7,78],[7,115],[7,152],[4,18],[4,55],[4,92],[4,129],[4,166],[1,32],[1,69],[1,106],[1,143],[1,180],[6,9],[6,46],[6,83],[6,120],[6,157],[3,23],[3,60],[3,97],[3,134],[3,171],[8,0],[8,37],[8,74],[8,111],[8,148],[5,14],[5,51],[5,88],[5,125],[5,162],[2,28],[2,65],[2,102],[2,139],[2,176],[7,5],[7,42],[7,79],[7,116],[7,153],[4,19],[4,56],[4,93],[4,130],[4,167],[1,33],[1,70],[1,107],[1,144],[1,181],[6,10],[6,47],[6,84],[6,121],[6,158],[3,24],[3,61],[3,98],[3,135],[3,172],[8,1],[8,38],[8,75],[8,112],[8,149],[5,15],[5,52],[5,89],[5,126],[5,163],[2,29],[2,66],[2,103],[2,140],[2,177],[7,6],[7,43],[7,80],[7,117],[7,154],[4,20],[4,57],[4,94],[4,131],[4,168],[1,34],[1,71],[1,108],[1,145],[1,182],[6,11],[6,48],[6,85],[6,122],[6,159],[3,25],[3,62],[3,99],[3,136],[3,173],[8,2],[8,39],[8,76],[8,113],[8,150],[5,16],[5,53],[5,90],[5,127],[5,164],[2,30],[2,67],[2,104],[2,141],[2,178],[7,7],[7,44],[7,81],[7,118],[7,155],[4,21],[4,58],[4,95],[4,132],[4,169],[1,35],[1,72],[1,109],[1,146],[1,183],[6,12],[6,49],[6,86],[6,123],[6,160],[3,26],[3,63],[3,100],[3,137],[3,174],[8,3],[8,40],[8,77],[8,114],[8,151],[5,17],[5,54],[5,91],[5,128],[5,165],[2,31],[2,68],[2,105],[2,142],[2,179],[7,8],[7,45],[7,82],[7,119],[7,156],[4,22],[4,59],[4,96],[4,133],[4,170],[1,36],[1,73],[1,110],[1,147],[1,184],[6,13],[6,50],[6,87],[6,124],[6,161],[3,27],[3,64],[3,101],[3,138],[3,175],[8,4],[8,41],[8,78],[8,115],[8,152],[5,18],[5,55],[5,92],[5,129],[5,166],[2,32],[2,69],[2,106],[2,143],[2,180],[7,9],[7,46],[7,83],[7,120],[7,157],[4,23],[4,60],[4,97],[4,134],[4,171],[6,14],[6,51],[6,88],[6,125],[6,162],[3,28],[3,65],[3,102],[3,139],[3,176],[8,5],[8,42],[8,79],[8,116],[8,153],[5,19],[5,56],[5,93],[5,130],[5,167],[2,33],[2,70],[2,107],[2,144],[2,181],[7,10],[7,47],[7,84],[7,121],[7,158],[4,24],[4,61],[4,98],[4,135],[4,172],[6,15],[6,52],[6,89],[6,126],[6,163],[3,29],[3,66],[3,103],[3,140],[3,177],[8,6],[8,43],[8,80],[8,117],[8,154],[5,20],[5,57],[5,94],[5,131],[5,168],[2,34],[2,71],[2,108],[2,145],[2,182],[7,11],[7,48],[7,85],[7,122],[7,159],[4,25],[4,62],[4,99],[4,136],[4,173],[6,16],[6,53],[6,90],[6,127],[6,164],[3,30],[3,67],[3,104],[3,141],[3,178],[8,7],[8,44],[8,81],[8,118],[8,155],[5,21],[5,58],[5,95],[5,132],[5,169],[2,35],[2,72],[2,109],[2,146],[2,183],[7,12],[7,49],[7,86],[7,123],[7,160],[4,26],[4,63],[4,100],[4,137],[4,174],[6,17],[6,54],[6,91],[6,128],[6,165],[3,31],[3,68],[3,105],[3,142],[3,179],[8,8],[8,45],[8,82],[8,119],[8,156],[5,22],[5,59],[5,96],[5,133],[5,170],[2,36],[2,73],[2,110],[2,147],[2,184],[7,13],[7,50],[7,87],[7,124],[7,161],[4,27],[4,64],[4,101],[4,138],[4,175],[6,18],[6,55],[6,92],[6,129],[6,166],[3,32],[3,69],[3,106],[3,143],[3,180],[8,9],[8,46],[8,83],[8,120],[8,157],[5,23],[5,60],[5,97],[5,134],[5,171],[7,14],[7,51],[7,88],[7,125],[7,162],[4,28],[4,65],[4,102],[4,139],[4,176],[6,19],[6,56],[6,93],[6,130],[6,167],[3,33],[3,70],[3,107],[3,144],[3,181],[8,10],[8,47],[8,84],[8,121],[8,158],[5,24],[5,61],[5,98],[5,135],[5,172],[7,15],[7,52],[7,89],[7,126],[7,163],[4,29],[4,66],[4,103],[4,140],[4,177],[6,20],[6,57],[6,94],[6,131],[6,168],[3,34],[3,71],[3,108],[3,145],[3,182],[8,11],[8,48],[8,85],[8,122],[8,159],[5,25],[5,62],[5,99],[5,136],[5,173],[7,16],[7,53],[7,90],[7,127],[7,164],[4,30],[4,67],[4,104],[4,141],[4,178],[6,21],[6,58],[6,95],[6,132],[6,169],[3,35],[3,72],[3,109],[3,146],[3,183],[8,12],[8,49],[8,86],[8,123],[8,160],[5,26],[5,63],[5,100],[5,137],[5,174],[7,17],[7,54],[7,91],[7,128],[7,165],[4,31],[4,68],[4,105],[4,142],[4,179],[6,22],[6,59],[6,96],[6,133],[6,170],[3,36],[3,73],[3,110],[3,147],[3,184],[8,13],[8,50],[8,87],[8,124],[8,161],[5,27],[5,64],[5,101],[5,138],[5,175],[7,18],[7,55],[7,92],[7,129],[7,166],[4,32],[4,69],[4,106],[4,143],[4,180],[6,23],[6,60],[6,97],[6,134],[6,171],[8,14],[8,51],[8,88],[8,125],[8,162],[5,28],[5,65],[5,102],[5,139],[5,176],[7,19],[7,56],[7,93],[7,130],[7,167],[4,33],[4,70],[4,107],[4,144],[4,181],[6,24],[6,61],[6,98],[6,135],[6,172],[8,15],[8,52],[8,89],[8,126],[8,163],[5,29],[5,66],[5,103],[5,140],[5,177],[7,20],[7,57],[7,94],[7,131],[7,168],[4,34],[4,71],[4,108],[4,145],[4,182],[6,25],[6,62],[6,99],[6,136],[6,173],[8,16],[8,53],[8,90],[8,127],[8,164],[5,30],[5,67],[5,104],[5,141],[5,178],[7,21],[7,58],[7,95],[7,132],[7,169],[4,35],[4,72],[4,109],[4,146],[4,183],[6,26],[6,63],[6,100],[6,137],[6,174],[8,17],[8,54],[8,91],[8,128],[8,165],[5,31],[5,68],[5,105],[5,142],[5,179],[7,22],[7,59],[7,96],[7,133],[7,170],[4,36],[4,73],[4,110],[4,147],[4,184],[6,27],[6,64],[6,101],[6,138],[6,175],[8,18],[8,55],[8,92],[8,129],[8,166],[5,32],[5,69],[5,106],[5,143],[5,180],[7,23],[7,60],[7,97],[7,134],[7,171],[6,28],[6,65],[6,102],[6,139],[6,176],[8,19],[8,56],[8,93],[8,130],[8,167],[5,33],[5,70],[5,107],[5,144],[5,181],[7,24],[7,61],[7,98],[7,135],[7,172],[6,29],[6,66],[6,103],[6,140],[6,177],[8,20],[8,57],[8,94],[8,131],[8,168],[5,34],[5,71],[5,108],[5,145],[5,182],[7,25],[7,62],[7,99],[7,136],[7,173],[6,30],[6,67],[6,104],[6,141],[6,178],[8,21],[8,58],[8,95],[8,132],[8,169],[5,35],[5,72],[5,109],[5,146],[5,183],[7,26],[7,63],[7,100],[7,137],[7,174],[6,31],[6,68],[6,105],[6,142],[6,179],[8,22],[8,59],[8,96],[8,133],[8,170],[5,36],[5,73],[5,110],[5,147],[5,184],[7,27],[7,64],[7,101],[7,138],[7,175],[6,32],[6,69],[6,106],[6,143],[6,180],[8,23],[8,60],[8,97],[8,134],[8,171],[7,28],[7,65],[7,102],[7,139],[7,176],[6,33],[6,70],[6,107],[6,144],[6,181],[8,24],[8,61],[8,98],[8,135],[8,172],[7,29],[7,66],[7,103],[7,140],[7,177],[6,34],[6,71],[6,108],[6,145],[6,182],[8,25],[8,62],[8,99],[8,136],[8,173],[7,30],[7,67],[7,104],[7,141],[7,178],[6,35],[6,72],[6,109],[6,146],[6,183],[8,26],[8,63],[8,100],[8,137],[8,174],[7,31],[7,68],[7,105],[7,142],[7,179],[6,36],[6,73],[6,110],[6,147],[6,184],[8,27],[8,64],[8,101],[8,138],[8,175],[7,32],[7,69],[7,106],[7,143],[7,180],[8,28],[8,65],[8,102],[8,139],[8,176],[7,33],[7,70],[7,107],[7,144],[7,181],[8,29],[8,66],[8,103],[8,140],[8,177],[7,34],[7,71],[7,108],[7,145],[7,182],[8,30],[8,67],[8,104],[8,141],[8,178],[7,35],[7,72],[7,109],[7,146],[7,183],[8,31],[8,68],[8,105],[8,142],[8,179],[7,36],[7,73],[7,110],[7,147],[7,184],[8,32],[8,69],[8,106],[8,143],[8,180],[8,33],[8,70],[8,107],[8,144],[8,181],[8,34],[8,71],[8,108],[8,145],[8,182],[8,35],[8,72],[8,109],[8,146],[8,183],[8,36],[8,73],[8,110],[8,147],[8,184]] \ No newline at end of file diff --git a/research/shared-kernel-packing/data/OWNER-RECEIPT.json b/research/shared-kernel-packing/data/OWNER-RECEIPT.json new file mode 100644 index 0000000000..a731d66fe2 --- /dev/null +++ b/research/shared-kernel-packing/data/OWNER-RECEIPT.json @@ -0,0 +1,397 @@ +{ + "status": "PASS_LITERAL_PR2857_RESIDUE_CONCENTRATION", + "replicas": 185, + "live": 165760, + "physical": 166250, + "roles": 679320, + "calls": 1665, + "moves": [ + { + "kind": "histogram-neutral width9 vacancy relay", + "before": [ + [ + 1600, + 208, + 28, + 16, + 76, + 7 + ] + ], + "after": [ + [ + 1600, + 208, + 35, + 16, + 37, + 7 + ] + ], + "source": [ + 28, + 16, + 76 + ], + "destination": [ + 35, + 16, + 37 + ] + }, + { + "kind": "histogram-neutral width9 vacancy relay", + "before": [ + [ + 1601, + 208, + 65, + 16, + 76, + 7 + ] + ], + "after": [ + [ + 1601, + 208, + 72, + 16, + 37, + 7 + ] + ], + "source": [ + 65, + 16, + 76 + ], + "destination": [ + 72, + 16, + 37 + ] + }, + { + "kind": "histogram-neutral width9 vacancy relay", + "before": [ + [ + 1602, + 208, + 102, + 16, + 76, + 7 + ] + ], + "after": [ + [ + 1602, + 208, + 109, + 16, + 37, + 7 + ] + ], + "source": [ + 102, + 16, + 76 + ], + "destination": [ + 109, + 16, + 37 + ] + }, + { + "kind": "histogram-neutral width9 vacancy relay", + "before": [ + [ + 1603, + 208, + 139, + 16, + 76, + 7 + ] + ], + "after": [ + [ + 1603, + 208, + 146, + 16, + 37, + 7 + ] + ], + "source": [ + 139, + 16, + 76 + ], + "destination": [ + 146, + 16, + 37 + ] + }, + { + "kind": "histogram-neutral width9 vacancy relay", + "before": [ + [ + 1604, + 208, + 176, + 16, + 76, + 7 + ] + ], + "after": [ + [ + 1604, + 208, + 183, + 16, + 37, + 7 + ] + ], + "source": [ + 176, + 16, + 76 + ], + "destination": [ + 183, + 16, + 37 + ] + }, + { + "kind": "whole-role residue concentration", + "before": [ + [ + 1460, + 17, + 32, + 13, + 94, + 0 + ] + ], + "after": [ + [ + 1460, + 17, + 28, + 16, + 76, + 7 + ] + ], + "source": [ + 32, + 13, + 94 + ], + "destination": [ + 28, + 16, + 76 + ] + }, + { + "kind": "whole-role residue concentration", + "before": [ + [ + 1465, + 151, + 32, + 13, + 94, + 0 + ] + ], + "after": [ + [ + 1465, + 151, + 65, + 16, + 76, + 7 + ] + ], + "source": [ + 32, + 13, + 94 + ], + "destination": [ + 65, + 16, + 76 + ] + }, + { + "kind": "whole-role residue concentration", + "before": [ + [ + 1555, + 107, + 32, + 13, + 94, + 0 + ] + ], + "after": [ + [ + 1555, + 107, + 102, + 16, + 76, + 7 + ] + ], + "source": [ + 32, + 13, + 94 + ], + "destination": [ + 102, + 16, + 76 + ] + }, + { + "kind": "whole-role residue concentration", + "before": [ + [ + 1580, + 54, + 32, + 13, + 94, + 0 + ] + ], + "after": [ + [ + 1580, + 54, + 139, + 16, + 76, + 7 + ] + ], + "source": [ + 32, + 13, + 94 + ], + "destination": [ + 139, + 16, + 76 + ] + }, + { + "kind": "whole-role residue concentration", + "before": [ + [ + 1585, + 26, + 32, + 13, + 94, + 0 + ] + ], + "after": [ + [ + 1585, + 26, + 176, + 16, + 76, + 7 + ] + ], + "source": [ + 32, + 13, + 94 + ], + "destination": [ + 176, + 16, + 76 + ] + } + ], + "profile": { + "1": 4029300, + "2": 1068930, + "3": 458874, + "4": 213120, + "5": 65490, + "8": 13320, + "48": 66896 + }, + "idle": { + "1": 43290, + "3": 15984, + "5": 22200, + "48": 66896 + }, + "profile_delta": { + "3": -1, + "48": 1, + "9": -5 + }, + "rank_mass": 12041280, + "controls": [ + { + "name": "missing_last_helper", + "reason": "complete helpers" + }, + { + "name": "noninteger_call_time", + "reason": "integer row" + }, + { + "name": "capacity_overflow", + "reason": "capacity" + }, + { + "name": "duplicate_physical_family", + "reason": "family collision" + } + ], + "input_sha256": { + "source/FILL.json.gz": "82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501", + "source/ORDER.json": "84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc", + "source/DISPATCH.json": "5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4", + "source/PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "source/PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "source/CLAIM.json": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "source/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "source/PR2833-PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + "candidate_sha256": { + "FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "PROFILE.json": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672" + }, + "scope": "Actual full owner/source-event/family/mask/profile validation and actual copied chronology, unchanged native providers, complete owner/source/family/mask/profile recount; exact moment and full release separate. Exact moment and full native/admission separate." +} diff --git a/research/shared-kernel-packing/data/PROFILE.json b/research/shared-kernel-packing/data/PROFILE.json new file mode 100644 index 0000000000..e3f186cb03 --- /dev/null +++ b/research/shared-kernel-packing/data/PROFILE.json @@ -0,0 +1 @@ +{"1":4029300,"2":1068930,"3":458874,"4":213120,"5":65490,"8":13320,"48":66896} \ No newline at end of file diff --git a/research/shared-kernel-packing/data/PROVIDERS.json b/research/shared-kernel-packing/data/PROVIDERS.json new file mode 100644 index 0000000000..39998c1f3c --- /dev/null +++ b/research/shared-kernel-packing/data/PROVIDERS.json @@ -0,0 +1 @@ +{"extra":{"actual_paid_profile":{"1":2394,"2":642,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,8,9,8,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,8,9,8,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]},"gauge44":{"actual_paid_profile":{"1":2394,"2":642,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,8,9,8,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,8,9,8,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]}} \ No newline at end of file diff --git a/research/shared-kernel-packing/evidence/ADMISSION-RESULT.json b/research/shared-kernel-packing/evidence/ADMISSION-RESULT.json new file mode 100644 index 0000000000..529486eaf1 --- /dev/null +++ b/research/shared-kernel-packing/evidence/ADMISSION-RESULT.json @@ -0,0 +1,382 @@ +{ + "actual_expected_helpers": 408, + "comparison_claim_sha256": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "comparison_head": "0b2e2537b368a0cade07ce3f71452ea018ebe394", + "comparison_kappa": "17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2857, + "complex_lower": "215012600677110740993/125000000000000000000000", + "dispatch_sha256": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "external_input_sha256": { + "F:\\proof\\research\\kappa-composition-20261015\\allocation\\pr2857\\five-copy-relay-01\\DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "F:\\proof\\research\\kappa-composition-20261015\\allocation\\pr2857\\five-copy-relay-01\\FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "F:\\proof\\research\\kappa-composition-20261015\\allocation\\pr2857\\five-copy-relay-01\\ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "F:\\proof\\research\\kappa-composition-20261015\\upstream\\pr2857\\CLAIM.json": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "F:\\proof\\research\\kappa-composition-20261015\\upstream\\pr2857\\vendor\\pr2839\\blocknorm_certificate.py": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92", + "F:\\proof\\research\\kappa-composition-20261015\\upstream\\pr2857\\vendor\\pr2839\\lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "F:\\proof\\research\\kappa-composition-20261015\\upstream\\pr2857\\vendor\\pr2839\\reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "F:\\proof\\research\\kappa-composition-20261015\\upstream\\pr2857\\vendor\\pr2839\\replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4" + }, + "fill_sha256": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "gain": "1044183013331743/250000000000000000000000", + "kappa": "17201008054168859279439999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017201008054168859279439999999999999999999998999999999999999999999999", + "native_receipt_sha256": "e39f1da10b10f649366722157517c15d0d040ec6b651db4ef5624fe173df121f", + "order_sha256": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "package_manifest_sha256": "6167060885325808ef867779e0f6020c96c46a0b63a240d15e455604b8cdd4dc", + "patches": [ + { + "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "path": "new/rebind.py", + "replacements": [ + [ + "physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))" + ] + ] + }, + { + "after_sha256": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "before_sha256": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "path": "geometry_controls.py", + "replacements": [ + [ + " i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1" + ], + [ + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh" + ] + ] + }, + { + "after_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "before_sha256": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183", + "path": "verify_release.py", + "replacements": [ + [ + "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)", + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))" + ], + [ + "epsilon=1-(1025/1024)e-3080", + "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}" + ], + [ + "at the one 3000-digit rejection call", + "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call" + ] + ] + }, + { + "after_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "before_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "path": "outer/check_ledger.py", + "replacements": [ + [ + "assert (m,W)==(73,66304)", + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "114a80b70c8c4819f10adf88aefc1571b18337e5da92bcff2ca3aa001650b83c", + "before_sha256": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "4e7b5ddd11b23c92ab26bc0c80884ed64a2d45e9247b5f52bc03f27fa83dbee0", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+42: + relay=rd(args.relay_plan) + for move in relay['relay']: + for b in range(copies): + t,h,o,c,p,z=move['row'];kb=list(move['destination']);kb[0]+=37*b;relocate(index[copies*t+b,h],tuple(kb),'histogram-neutral width9 vacancy relay') +exception=[k for k in bins if caps[k[1]]==16 and rem[k]==9] +assert len(exception)==copies and all(len(bins[k])==1 and width(bins[k][0])==7 for k in exception) +choice=None +if copies==2: + ka,kb=exception;i=bins[ka][0];assert eligible(i,kb);selection=[(i,kb)] +else: + donorcap=32 if copies==3 else 48;donorrem=5 if copies==3 else 3 + for ka,ii in bins.items(): + if caps[ka[1]]!=donorcap or rem[ka]!=donorrem or len(ii)!=copies or any(width(i)!=9 for i in ii):continue + for dests in permutations(exception): + if all(eligible(i,k)for i,k in zip(ii,dests)):choice=list(zip(ii,dests));break + if choice:break + assert choice is not None,'no eligible actual whole-role donor';selection=choice +for i,kb in selection:relocate(i,kb,'whole-role residue concentration') +for k in list(bins): + off=0 + for i in sorted(bins[k],key=lambda z:rows[z][5]):rows[i][5]=off;off+=width(i) + used[k]=off;rem[k]=caps[k[1]]-off +print('ACTUAL_RESIDUE_TRANSFERS',copies,len(moves),flush=True) +def audit(data): + masks={};helpers=[0]*len(order);families=[set()for _ in order] + for row in data: + assert len(row)==6 and all(type(z)is int for z in row),'integer row' + t,h,o,c,p,z=row;assert 0<=t=0,'range' + w=providers[dispatch[tuple(order[t])]]['widths'][h];lo,hi=windows[o,c];assert lo>h&1,'duplicate helper';helpers[t]|=1<1);i,j=calls[first][:2] +reject('duplicate_physical_family',lambda a:a[j].__setitem__(slice(2,5),a[i][2:5]),'family collision') +out=args.out;assert not out.exists();out.mkdir() +fill['rows']=rows +objects={'FILL.json.gz':fill,'ORDER.json':order,'DISPATCH.json':[[s,r,p]for(s,r),p in sorted(dispatch.items())],'PROVIDERS.json':providers,'PROFILE.json':H} +for name,obj in objects.items(): + p=out/name;lock=p.with_suffix(p.suffix+'.lock') + with lock.open('x')as h: + h.write('Exclusive literal same-call improvement\n');h.flush();b=json.dumps(obj,sort_keys=True,separators=(',',':')).encode();p.write_bytes(gzip.compress(b,mtime=0)if p.suffix=='.gz'else b) + lock.unlink() +result=dict(status='PASS_LITERAL_PR2857_RESIDUE_CONCENTRATION',replicas=T,live=896*T,physical=896*T+490,roles=len(rows),calls=len(order),moves=moves,profile=H,idle=idle,profile_delta=deltaH,rank_mass=sum(k*v for k,v in H.items()),controls=controls,input_sha256=pins,candidate_sha256={n:sha(out/n)for n in objects},scope='Actual full owner/source-event/family/mask/profile validation and actual copied chronology, unchanged native providers, complete owner/source/family/mask/profile recount; exact moment and full release separate. Exact moment and full native/admission separate.') +p=out/'OWNER-RECEIPT.json';lock=p.with_suffix('.json.lock') +with lock.open('x')as h:h.write('Exclusive full owner receipt\n');h.flush();p.write_text(json.dumps(result,indent=2)+'\n',encoding='utf8',newline='\n') +lock.unlink();assert pins=={p.name:sha(p)for p in paths} +print(json.dumps({k:result[k]for k in ['status','profile','profile_delta','candidate_sha256']}),flush=True) diff --git a/research/shared-kernel-packing/review/PROOF.md b/research/shared-kernel-packing/review/PROOF.md new file mode 100644 index 0000000000..c9b3ee5390 --- /dev/null +++ b/research/shared-kernel-packing/review/PROOF.md @@ -0,0 +1,120 @@ +# Actual T185 attainment of the current fixed-packing optimum + +The actual five-copy relay has complete paid profile + + {1: 4029300, 2: 1068930, 3: 458874, 4: 213120, + 5: 65490, 8: 13320, 48: 66896}. + +The independent review checks every one of its 679,320 helper roles in 1,665 calls, reconstructs its source-event windows, recounts the full profile, and certifies its exact moment above the full PR #2857 rational. Separately, an exact primal/dual certificate proves that this actual profile attains the fractional packing minimum for the fixed current word, inventory and bin capacities throughout the moment-root interval below. This is not a global optimality statement about integer multiplication or alternative native words. + +## 1. Universal strict improvement of the actual relay + +Let H_r = r^p for any 0 < p < 1. Relative to five source copies, the actual profile change is + + H_48 − H_3 − 5 H_9 < 0. + +Indeed, 48 = 3 + 9 + 9 + 9 + 9 + 9. Divide these six positive parts by 48 to obtain positive numbers t_i < 1 with sum 1. Since t_i^p > t_i, their p-th powers sum to more than 1. Multiplying by 48^p proves the inequality. The live stock and normalization per source copy are unchanged. Thus the normalized paid moment decreases strictly for every exponent in this interval, independently of a displayed decimal approximation. + +The allocation worker's actual ten whole-role moves consist of five replicated width 9 vacancy relays, followed by moving five actual width 9 roles out of one capacity 48 donor. Five capacity 16 bins that each held width 7 become full [7, 9] bins; the capacity 48 donor becomes empty. This converts the six old idle ranks [3, 9, 9, 9, 9, 9] into [48]. This explanation does not replace the literal checks: all source windows, family exclusions, disjoint masks and prefixes are recounted by `review_current.py`. + +## 2. Precisely fixed packing model + +For any positive replica count T, assume the unchanged source geometry and current native providers. Per replica the bin counts are + +| Capacity c | 8 | 16 | 32 | 48 | +|---|---:|---:|---:|---:| +| B_c | 672 | 448 | 448 | 448 | + +The current ordered native inventory has widths {4: 26, 5: 2, 7: 62, 8: 84, 9: 234}. There are nine calls per replica. The local paid profile is + + 2394 H_1 + 642 H_2 + 266 H_3 + 128 H_4 + 26 H_5 + 8 H_8. + +A bin pattern is a capacity c and a vector u = (u_4, u_5, u_7, u_8, u_9) of nonnegative integers with Σ_w w u_w ≤ c. Its remainder is r = c − Σ_w w u_w. Put H_0 = 0. There are exactly 1,163 such patterns over these four capacities. + +For each pattern let x_(c,u) ≥ 0 be its fractional multiplicity. The constraints are + + Σ_u x_(c,u) = T B_c, + Σ_(c,u) u_w x_(c,u) = 9 T I_w, + +where I_w is the width inventory above. The objective is the sum of idle costs Σ_(c,u) H_r x_(c,u); add the fixed native paid cost separately. This relaxation allows more assignments than a chronological literal allocation. It therefore gives a valid lower bound for every actual allocation with these inventories, for every positive integer T whose enclosing source geometry and finite admission are admissible. It does not prove that every T satisfies the enclosing finite invoice, nor that every fractional solution has a literal realization. + +## 3. Exact rational primal + +The following bin multiplicities are per replica. A tuple lists the widths in the bin; an empty tuple leaves the entire bin idle. + +| Capacity | Widths | Multiplicity | Remainder | +|---:|---|---:|---:| +| 8 | (8) | 672 | 0 | +| 16 | (7, 9) | 448 | 0 | +| 32 | (9, 9, 9) | 120 | 5 | +| 32 | (8, 8, 8, 8) | 21 | 0 | +| 32 | (7, 7, 9, 9) | 55 | 0 | +| 32 | (5, 9, 9, 9) | 18 | 0 | +| 32 | (4, 9, 9, 9) | 234 | 1 | +| 48 | () | 1808/5 | 48 | +| 48 | (9, 9, 9, 9, 9) | 432/5 | 3 | + +Adding these rows gives every bin-count and helper-count constraint exactly over the rationals. Its idle objective is + + 234 H_1 + (432/5) H_3 + 120 H_5 + (1808/5) H_48. + +Adding the nine native call costs gives the complete per-replica profile + + H* = 21780 H_1 + 5778 H_2 + (12402/5) H_3 + + 1152 H_4 + 354 H_5 + 72 H_8 + (1808/5) H_48. + +The actual T185 profile is exactly 185 times this profile, entry by entry. This is checked directly from the complete candidate file; no idealized replacement is made in the release. + +## 4. Symbolic dual and weak duality + +Set + + q = (H_3 − H_48)/5, C = H_5 − 3q. + +Use capacity prices + + λ_8 = C/4, λ_16 = C/2, λ_32 = C, λ_48 = H_48, + +and helper prices + + μ_4 = H_1 − H_5, μ_5 = −H_5, + μ_7 = −C/2 − q, μ_8 = −C/4, μ_9 = q. + +Prices are unrestricted real numbers because the primal inventory constraints are equalities. For each of the 1,163 patterns the required inequality is + + λ_c + Σ_w u_w μ_w ≤ H_(c − Σ_w w u_w). + +`profile_lp_certificate.py` verifies every one of these inequalities with exact symbolic coefficients and outward integer power intervals, uniformly throughout the root bracket in Section 5. Eleven inequalities are symbolically exact equalities. Every other inequality has a strictly positive lower slack. `lp-final-01/PATTERNS.json` records every pattern, its exact symbolic slack and its directed interval. A forged capacity price is explicitly rejected. + +Why does this prove optimality? Multiply each inequality by its nonnegative primal multiplicity and sum. The two sets of inventory equalities give + + idle cost ≥ T [Σ_c B_c λ_c + 9 Σ_w I_w μ_w]. + +This is weak duality, proved directly without a solver. Substituting the displayed prices makes the bracket exactly the rational primal idle objective from Section 3; the code checks this as an identity of coefficients of H_1, H_3, H_5 and H_48. Thus the rational primal is optimal in the full fractional model. The actual T185 allocation has its objective value, so it attains that minimum despite the additional chronological restrictions. For any other admissible T the same scaled dual is a lower bound; integral attainment at that T is not assumed. + +## 5. Uniform root bracket and exact arithmetic + +The optimal normalized moment is + + Φ(p) = H*(p) / (896 × 73^p). + +With α = 1 − p, each positive term (r/73)^(1−α) increases strictly with α because 0 < r < 73. Hence Φ(1−α) is continuous and strictly increasing. Directed arithmetic gives opposite strict signs at + + α_low = 0.001720100805416885927944, + α_high = 0.001720100805416885927945. + +The unique moment root lies strictly between these rationals. The dual is feasible uniformly across this entire interval: for each integer r its lower power bound is evaluated at α_high and its upper bound at α_low, using monotonicity. Symbolic zero slacks are recognized as identities; positive and negative coefficients of every other slack select the appropriate outward endpoints. Consequently this is a locally uniform optimum certificate, not merely a floating comparison at a nominated exponent. + +All power bounds use only integer arithmetic and Fraction. Write n = 2^k a with 1 ≤ a < 2 and z = (a−1)/(a+1), so 0 ≤ z ≤ 1/3. Integrating the geometric series for 2/(1−z²) gives + + log a = 2 Σ_(j≥0) z^(2j+1)/(2j+1). + +After J terms the positive tail is at most 9 z^(2J+1)/(4(2J+1)). The code encloses the sum and powers by outward dyadic recurrences. It computes log 2 in the same way, then log n. For t = α log n in [0, 1/2], the positive Taylor series for exp(t) has remaining tail at most twice its next term. Outward reciprocal arithmetic yields n^(1−α) = n/exp(t). The scale is 2^512. No solver or floating transcendental is trusted in either the moment signs or the dual inequalities. + +The enclosing target is α_low − 10^−46 − 10^−70. `REVIEW-FINAL.json` independently checks its moment and its exact rational superiority over PR #2857. This statement is conditional on the retained all-size compiler, native, hosting, precision/tape and analytic interfaces. Full admission, which retains payload 2048 and all denominator, mass and C0 guards, is a separate enclosing check. + +## 6. Source and verification boundary + +The actual staged words and T37 source are PR #2857 at `0b2e2537b368a0cade07ce3f71452ea018ebe394`, by Yiyang/Lyy-iiis with Codex assistance. It credits Jeremy Kothe's PR #2833 and Philippe Van Velzen's independent PR #2853 treatment of the same quartet. The vacancy-relay neighborhood overlaps Marius-Paul Dumitrean's PR #2856; no priority or previously-unused claim is made. The preserved PR #2855 atlas/mixed-fibre work is not silently inserted into this candidate. Earlier notices and licenses remain with the enclosing package. + +The five-copy construction belongs to the allocation worker. This supplement supplies an independent owner/moment review and an exact fixed-model optimum certificate. Its arithmetic, source-event checks and LP dual are not new general mathematical identities. It asserts neither global optimality across dimensions or native circuits nor an unconditional integer multiplication theorem. No Lean process was used for this exact informal campaign. diff --git a/research/shared-kernel-packing/review/REVIEW-FINAL.json b/research/shared-kernel-packing/review/REVIEW-FINAL.json new file mode 100644 index 0000000000..78c204378b --- /dev/null +++ b/research/shared-kernel-packing/review/REVIEW-FINAL.json @@ -0,0 +1,53 @@ +{ + "above_complete_current_frontier": true, + "calls": 1665, + "idle_profile": { + "1": 43290, + "3": 15984, + "5": 22200, + "48": 66896 + }, + "input_sha256": { + "candidate/DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "candidate/FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "candidate/ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "candidate/PROFILE.json": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672", + "claim": "3414a77765698dbcbc95bfe442447fc26a7399eabf6956a774ac6d909e26f301", + "source/CLAIM.json": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "source/DISPATCH.json": "5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4", + "source/ORDER.json": "84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc", + "source/PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "source/PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "source/sources/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "source/words/WORD-base.json.gz": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "source/words/WORD-extra.json.gz": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546" + }, + "moment_interval_scaled": [ + "-3251328592586188540477290629750707327762817057458792709003686496786524937154583693404655229383121884738824983032899144566952319368811872", + "-3251328592586188540477290629750707327762817057458792709003686496786524937154583693404655229383121884738824983032899144566952316966729026" + ], + "negative_controls_rejected": [ + "missing_helper", + "noninteger_descriptor", + "slice_capacity_overflow", + "hidden_dispatch_override" + ], + "physical": 166250, + "profile": { + "1": 4029300, + "2": 1068930, + "3": 458874, + "4": 213120, + "5": 65490, + "8": 13320, + "48": 66896 + }, + "rank_mass": 12041280, + "replicas": 185, + "roles": 679320, + "scale": "2^512", + "scope": "Independent literal chronology/windows/families/masks/prefixes/current-provider profile and exact directed moment. No constructor or solver imports. Fresh native phase/primitive and complete compiler/precision/release guards remain separate.", + "source_events": 5552, + "source_head": "0b2e2537b368a0cade07ce3f71452ea018ebe394", + "status": "PASS_INDEPENDENT_CURRENT_STAGED_OWNER_MOMENT_REVIEW" +} diff --git a/research/shared-kernel-packing/review/RUN.md b/research/shared-kernel-packing/review/RUN.md new file mode 100644 index 0000000000..0e62b4a0f8 --- /dev/null +++ b/research/shared-kernel-packing/review/RUN.md @@ -0,0 +1,14 @@ +# Replay the current-word optimum and literal review + +Use Python 3.12 or later and the standard library. No numerical package, solver, network call or Lean compiler is required by these reviewers. Inputs are read-only and output paths must be fresh. From the package root: + +```text +python -B review/review_current.py --package vendor/pr2857 --candidate data --claim CLAIM.json --field kappa --out ../t185-independent-review.json +python -B review/profile_lp_certificate.py --package vendor/pr2857 --candidate-profile data/PROFILE.json --out ../t185-independent-lp +``` + +Authenticate the complete source first with `python -B tools/verify_package.py --hash-only`, or use its full offline replay to run both reviewers together with construction and the separate root checks. The baseline is the unchanged PR #2857 package at head `0b2e2537b368a0cade07ce3f71452ea018ebe394`; its word, registry, source template and paid profile pins are checked again by the reviewers. + +The first command checks every helper descriptor, source-event clock, strict idle window, family exclusion, mask, prefix, current paid profile and exact rational moment. Four malformed inputs are rejected. The second checks rational primal constraints, all 1,163 exact dual inequalities, symbolic objective equality, actual T185 attainment and the locally uniform root bracket. A forged dual price is rejected. Imported helper predicates are compiled directly from authenticated source bytes so stale bytecode is not loaded. + +Recorded positive receipts are `REVIEW-FINAL.json` and `lp-final-01/{RESULT,PATTERNS}.json`. These supplementary checks do not replace the enclosing changed-native chains, phase/wrapper audits, generated hosted controller, compiler/precision invoice or complete outer release. Payload remains 2048. No local absolute path is required by these scripts. diff --git a/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.json b/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.json new file mode 100644 index 0000000000..1982d569a9 --- /dev/null +++ b/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.json @@ -0,0 +1,66 @@ +{ + "authenticated_core_files": 97, + "negative_controls": [ + { + "name": "wrong_compensation", + "rejected_for": "exact_compensation_column_replacements" + }, + { + "name": "missing_inverse", + "rejected_for": "exact_inverse_reverse_cleanup_excludes_prelude_targets_and_uses_private_buffers" + }, + { + "name": "unpaid_profile", + "rejected_for": "independent_full_frame_profile" + }, + { + "name": "optimized_mode", + "rejected_before_input_access": true + } + ], + "producer_execution": "compile authenticated source bytes into a fresh ModuleType; no source loader or bytecode cache", + "remaining": "Fresh changed-provider native phase/Gaussian chains, regenerated charts and actual complete owner/controller/precision/outer admission are separate requirements.", + "same_boundary_fields": "All word fields other than A, compensation, report and cleanup agree with PR2853, including start_extra and all input/output frame metadata.", + "source_head": "0b2e2537b368a0cade07ce3f71452ea018ebe394", + "source_package": "research/shared-kernel-repacking", + "source_receipt_sha256": "d6f9d0a96fa096873e20a8c79d1b7ce54a080d1006e695844e500038dfdeabf2", + "status": "PASS_INDEPENDENT_SOURCE_BOUND_NATIVE_COMPATIBILITY_REVIEW", + "words": { + "base": { + "changed_fields": [ + "A", + "compensation", + "report", + "cleanup" + ], + "current": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "local_delta_from_2853": { + "1": -8, + "2": 4 + }, + "previous": "7f0a0715aa962f24c112ca32d1b57fc275eff0f15eac6eccd684ba702af82f8b", + "producer_decoded_equal": true, + "producer_input_unchanged": true, + "same_ordered_widths": true, + "standalone_audit_sha256": "ad752bc736134dcc53acb1e322c4dcf68987b9e27cb36ae08ade1394b5fa9a98" + }, + "extra": { + "changed_fields": [ + "A", + "compensation", + "report", + "cleanup" + ], + "current": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546", + "local_delta_from_2853": { + "1": -8, + "2": 4 + }, + "previous": "c94a0ac238ca72951e4580895334d39f66ea950fa7af62ca2667251a2f796d6e", + "producer_decoded_equal": true, + "producer_input_unchanged": true, + "same_ordered_widths": true, + "standalone_audit_sha256": "3248b6262a0b29047a603f1e5bef602ebf8bda2c121e4b6699efeb93e00b150f" + } + } +} diff --git a/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.md b/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.md new file mode 100644 index 0000000000..4ee79613db --- /dev/null +++ b/research/shared-kernel-packing/review/SOURCE-COMPATIBILITY.md @@ -0,0 +1,17 @@ +# PR #2857 native word and owner compatibility review + +The pinned [shared-kernel construction](https://github.com/Lyy-iiis/integer-mult-bounds/tree/0b2e2537b368a0cade07ce3f71452ea018ebe394/research/shared-kernel-repacking) passes a fresh independent differential audit of both providers: 68 checks for each word. This review uses head `0b2e2537b368a0cade07ce3f71452ea018ebe394`. The authenticated producer, compiled directly from source bytes into a fresh module, reconstructs both complete decoded words exactly without mutating either input. The adjacent JSON binds the source receipt, words and executed checks. + +For each ordered quartet, the raw-dirt transformation is the invertible triangular map S taking (z₀,z₁,z₂,z₃) to (z₀,z₁+z₀,z₂−z₀,z₃+z₂−z₀). Its first column is (1,1,−1,−1). The actual compensation block annihilates that column. The staged A word realizes A_old S, so the required compensation orientation is C S, not C S⁻¹. The independent replay checks this on all 704 formal rows, with arbitrary independent dirty values and noncommuting warp symbols. It also checks the full inverse cleanup and forward/dual endpoints, with all 72 private buffers zero. This establishes the stated free-operator identity, without assuming a dirty input is zero. + +The paid frame recount changes the four quartet leaders by H₁ − H₂ each and their four third members by 2 H₁ − H₂ each. Thus the complete local change from PR #2833 is 12 H₁ − 8 H₂, including the inverse cleanup convention. The literal producer adds 20 A primitives and 20 inverse primitives; compensation removes 28 and adds 28. No extra helper, port, warp or private buffer is omitted from this account. Compared with PR #2853, the paid change is −8 H₁ + 4 H₂. It has zero rank mass and is strictly negative at every 0 < p < 1 because 2ᵖ < 2. + +Both full ordered 408-helper width lists agree exactly with PR #2853. Direct comparison of both words finds differences only in A, compensation, report and cleanup. In particular start_extra, all boundary frames, target levels, centres, ports, B, warps, restored/removed helpers and wrappers agree. Therefore an owner exchange or relay whose proof uses the unchanged source windows and ordered widths remains an admissible allocation transformation. Its idle invoice must still be recounted for its actual fill, and its local invoice must use the new profile. This is compatibility of sufficient interfaces, not permission to add independently quoted numerical gains. + +The intermediate A frame paths and cleanup do change. Reusing the previous native receipts or hosted chart materialization would be unsound; both changed native chains and their hosting charts must be regenerated. The exact free-symbol audit does not establish Clifford/Gaussian phase identities, scalar/tape bounds or the whole outer claim. The final complete admission remains separate. No new unitarity premise is inferred merely from invertibility of S. + +Three actual corruptions were rejected for their intended predicates: a compensation sign error, a missing inverse gate and an uncharged profile count. Optimized Python mode is rejected before input access. All 97 authenticated core source files agree with their pinned hashes before and after this review. + +A source-loader caution remains in the upstream convenience verify.py/shared_kernel.py CLI: spec_from_file_location can read a timestamp-valid cached pyc even with -B. This review avoids that path by compiling the authenticated producer bytes and invoking the standalone checker directly. A new integration should retain the same source-byte execution safeguard; this caution does not invalidate the independently checked word contents. + +Credit belongs to Yiyang/Lyy-iiis and the separately credited construction/audit work in [PR #2857](https://github.com/CrocSwap/integer-mult-bounds/pull/2857). It builds on Jeremy Kothe’s PR #2833 and explicitly credits Philippe Van Velzen’s concurrent PR #2853 for the same four helper quartets. The cheaper staged schedule is not our new native discovery. This review supplies current source-bound compatibility and independent checks only. diff --git a/research/shared-kernel-packing/review/T185-PEER-REVIEW.json b/research/shared-kernel-packing/review/T185-PEER-REVIEW.json new file mode 100644 index 0000000000..6e59ae6669 --- /dev/null +++ b/research/shared-kernel-packing/review/T185-PEER-REVIEW.json @@ -0,0 +1,192 @@ +{ + "blocking_findings": [], + "calls": 1665, + "checked_moved_rows": [ + { + "call": 1600, + "call_clock": 5080, + "capacity": 16, + "destination": [ + 35, + 16, + 37 + ], + "helper": 208, + "strict_window": [ + 4942, + 5453 + ], + "width": 9 + }, + { + "call": 1601, + "call_clock": 5090, + "capacity": 16, + "destination": [ + 72, + 16, + 37 + ], + "helper": 208, + "strict_window": [ + 4945, + 5463 + ], + "width": 9 + }, + { + "call": 1602, + "call_clock": 5100, + "capacity": 16, + "destination": [ + 109, + 16, + 37 + ], + "helper": 208, + "strict_window": [ + 4948, + 5473 + ], + "width": 9 + }, + { + "call": 1603, + "call_clock": 5110, + "capacity": 16, + "destination": [ + 146, + 16, + 37 + ], + "helper": 208, + "strict_window": [ + 4951, + 5483 + ], + "width": 9 + }, + { + "call": 1604, + "call_clock": 5120, + "capacity": 16, + "destination": [ + 183, + 16, + 37 + ], + "helper": 208, + "strict_window": [ + 4954, + 5493 + ], + "width": 9 + }, + { + "call": 1460, + "call_clock": 4470, + "capacity": 16, + "destination": [ + 28, + 16, + 76 + ], + "helper": 17, + "strict_window": [ + 4392, + 5083 + ], + "width": 9 + }, + { + "call": 1465, + "call_clock": 4475, + "capacity": 16, + "destination": [ + 65, + 16, + 76 + ], + "helper": 151, + "strict_window": [ + 4395, + 5093 + ], + "width": 9 + }, + { + "call": 1555, + "call_clock": 4870, + "capacity": 16, + "destination": [ + 102, + 16, + 76 + ], + "helper": 107, + "strict_window": [ + 4398, + 5103 + ], + "width": 9 + }, + { + "call": 1580, + "call_clock": 5005, + "capacity": 16, + "destination": [ + 139, + 16, + 76 + ], + "helper": 54, + "strict_window": [ + 4401, + 5113 + ], + "width": 9 + }, + { + "call": 1585, + "call_clock": 5010, + "capacity": 16, + "destination": [ + 176, + 16, + 76 + ], + "helper": 26, + "strict_window": [ + 4404, + 5123 + ], + "width": 9 + } + ], + "complete_profile_delta": { + "3": -1, + "9": -5, + "48": 1 + }, + "input_sha256": { + "CONSTRUCTION.md": "c9c355551dec37e8e2c3e3dad8c6c9c7218af1a2333cf1cb688655fa531da9da", + "CREDITS.md": "eac7e3aa1330c133a60a9f2d8385ef6dbd5e3b4c083af727f2383c9cbe3c868a", + "README.md": "f840c395334184ca0f4ae85045b3c2816d6591b5502c7f274892b9541a9aa0b3", + "data/DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "data/FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "data/ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "data/OWNER-RECEIPT.json": "3d24c14566eab1eea1e82944e2f458a4c9d6753e3c72a9d63d964b8e7d10f730", + "data/PROFILE.json": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672", + "data/PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "review/PROOF.md": "71a45d195eb9ea46e0b0027d7d6f750aef109b1e853b9ff6b90ab864039bae6f", + "review/lp-final-01/RESULT.json": "c015d2e8324775a76904a3fe33972d15c5a685c95d9679cebaaddf3745b81025", + "review/profile_lp_certificate.py": "96cd1d6d84d9a224f3b5521e43e6d0572c779bdcccdd97f52dff36c76e5aa31a", + "vendor/pr2857/PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "vendor/pr2857/sources/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + "rank_mass": 12041280, + "roles": 679320, + "scope": "Independent reconstruction of the ten changed roles strict event windows, actual widths/capacities, touched-call family uniqueness, active-family separation, copied source projections and full-profile delta. Mathematical proof/LP and publication claims read; no heavy replay or substitute for full admission.", + "source_projections": 185, + "status": "PASS_READ_ONLY_T185_RELAY_AND_PUBLICATION_REVIEW" +} diff --git a/research/shared-kernel-packing/review/literal_core.py b/research/shared-kernel-packing/review/literal_core.py new file mode 100644 index 0000000000..aa4d879457 --- /dev/null +++ b/research/shared-kernel-packing/review/literal_core.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent literal owner/provider audit. No constructor or solver imports.""" +import argparse,collections,copy,gzip,hashlib,json,os +from pathlib import Path + +def need(p,m): + if not p:raise AssertionError(m) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def chronology(template,order,T): + schedule=template['execution_schedule'];need(len(schedule)==32,'source schedule length');blocks={};s=None + for j,e in enumerate(schedule[:30]): + if e['kind']=='local_cover_sweep':s=e['stage'];blocks[s]=[] + need(s is not None,'source starts with local call');blocks[s].append((j,e)) + need(set(blocks)==set(range(9))and [e['kind']for e in schedule[30:]]==['bank_padding_cover_sweep','translate_every_live_family'],'nine source blocks and final routes') + stages={e['stage']:e['pair']for e in template['recipe']if e['kind']=='local'};caps={e['child']:e['rank']for e in template['idle_children']};pairs={};sides={};last={};bounds={};clock=0;times=[];projection=collections.defaultdict(list) + for s,r in order: + for j,e in blocks[s]: + projection[r].append(j) + if e['kind']=='local_cover_sweep':times.append(clock);last[r,stages[s]]=clock + elif e['kind']=='bridge':last[r,e['src']]=clock;last[r,e['dst']]=clock + elif e['kind']=='idle_cover_sweep': + for side,ch in enumerate(e['child_indices']): + + if ch not in caps: + need(e['from_level']==e['to_level'],'omitted positive-rank source child');continue + pairs[ch]=e['pair'];sides[ch]=side;bounds[r,ch]=(last.get((r,e['pair']),-1),clock) + else:need(e['kind']in('terminal','terminal_Y_translations'),'unknown source event') + clock+=1 + need(set(projection)==set(range(T))and all(v==list(range(30))for v in projection.values()),'every actual source event once per replica') + need(set(pairs)==set(caps)and len(times)==9*T,'all source child intervals') + return caps,pairs,sides,bounds,times,stages + +def audit(fill,order,dispatch,providers,context,T): + caps,pairs,sides,bounds,times,stages=context;need(fill['columns']==['time','helper','owner_replica','child','port','offset']and fill['dispatch_overrides']==[],'literal fill schema/no hidden dispatch') + occupied={};families=[set()for _ in order];helper_masks=[0 for _ in order];rows=fill['rows'] + for row in rows: + need(isinstance(row,list)and len(row)==6 and all(type(x)is int for x in row),'integer role descriptor') + t,h,o,c,p,off=row;need(0<=t=0,'role coordinate range') + pid=dispatch[tuple(order[t])];w=providers[pid]['widths'][h];need(1<=w<=9 and off+w<=caps[c],'actual width and capacity') + need(bounds[o,c][0]>h&1),'duplicate logical helper');helper_masks[t]|=1<=1,'positive integer base') + if n==1:return 0,0 + k=n.bit_length()-1;l,u=log_ratio(2,1);a,b=log_ratio(n,1<0,'extra paid child control not strictly rejected');rejected.append('extra_unpaid_rank_one_child') + return rejected + diff --git a/research/shared-kernel-packing/review/profile_lp_certificate.py b/research/shared-kernel-packing/review/profile_lp_certificate.py new file mode 100644 index 0000000000..e3f4b0dd07 --- /dev/null +++ b/research/shared-kernel-packing/review/profile_lp_certificate.py @@ -0,0 +1,78 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact fixed-inventory fractional primal/dual certificate near its moment root. +All transcendental bounds use authenticated stdlib directed integer series. +""" +import argparse,collections,functools,hashlib,itertools,json,os,types +from pathlib import Path +from fractions import Fraction as Q + +def need(p,m): + if not p:raise AssertionError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def add(*ds): + z={} + for d in ds: + for r,c in d.items():z[r]=z.get(r,Q(0))+c + return {r:c for r,c in z.items()if c} +def mul(a,d):return {r:a*c for r,c in d.items()if a*c} +def f(r):return {r:Q(1)}if r else{} +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--package',type=Path,required=True);ap.add_argument('--candidate-profile',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args();need(not a.out.exists(),'fresh output');here=Path(__file__).resolve().parent + cp=here/'moment_core.py';body=cp.read_bytes();need(hashlib.sha256(body).hexdigest()=='22290074f138fa9b902e5f6f6e8a0ec366d6f812992adb6df9b617ce952fb852','executed arithmetic source bytes');m=types.ModuleType('directed');m.__file__=str(cp);exec(compile(body,str(cp),'exec'),m.__dict__);m.BITS=512;m.S=1<<512;m.LOG_TERMS=220;m.EXP_TERMS=114;m.log_int=functools.lru_cache(None)(m.log_int) + paths={'registry':a.package/'PROVIDERS.json','baseline_profile':a.package/'PROFILE.json','baseline_claim':a.package/'CLAIM.json','candidate_profile':a.candidate_profile};pins={k:sha(p)for k,p in paths.items()};reg=json.loads(paths['registry'].read_bytes());inventory=collections.Counter(reg['extra']['widths']);need(inventory=={4:26,5:2,7:62,8:84,9:234},'current actual inventory');native={int(r):n for r,n in reg['extra']['actual_paid_profile'].items()};need(all(z['widths']==reg['extra']['widths']and z['actual_paid_profile']==reg['extra']['actual_paid_profile']for z in reg.values()),'fixed common native price/inventory') + support=[(8,[0,0,0,1,0],Q(672)),(16,[0,0,1,0,1],Q(448)),(32,[0,0,0,0,3],Q(120)),(32,[0,0,0,4,0],Q(21)),(32,[0,0,2,0,2],Q(55)),(32,[0,1,0,0,3],Q(18)),(32,[1,0,0,0,3],Q(234)),(48,[0,0,0,0,0],Q(1808,5)),(48,[0,0,0,0,5],Q(432,5))] + widths=[4,5,7,8,9];caps={8:672,16:448,32:448,48:448};capcheck=collections.Counter();widthcheck=collections.Counter();idle=collections.Counter();primal=[] + for c,u,n in support: + rem=c-sum(w*z for w,z in zip(widths,u));need(rem>=0 and n>=0,'primal nonnegative bins');capcheck[c]+=n + for w,z in zip(widths,u):widthcheck[w]+=z*n + if rem:idle[rem]+=n + primal.append(dict(capacity=c,width_counts=u,bins=str(n),remainder=rem)) + need(capcheck==caps and all(widthcheck[w]==9*inventory[w]for w in widths),'all exact primal inventory constraints') + H={r:9*Q(n)for r,n in native.items()} + for r,n in idle.items():H[r]=H.get(r,0)+n + C={int(r):int(n)for r,n in json.loads(paths['candidate_profile'].read_bytes()).items()};need(all(Q(C.get(r,0),185)==H.get(r,0)for r in set(C)|set(H)),'actual T185 profile attains exact fractional shape') + # Find a directed 24-decimal bracket for the common optimum's moment root. + grid=10**24;alpha=Q(json.loads(paths['baseline_claim'].read_bytes())['kappa']);lo=alpha.numerator*grid//alpha.denominator;hi=lo+10**17 + need(m.moment(H,896,73,Q(lo,grid))[1]<0 and m.moment(H,896,73,Q(hi,grid))[0]>0,'initial root bracket') + while hi-lo>1: + mid=(lo+hi)//2;l,u,_=m.moment(H,896,73,Q(mid,grid)) + if u<0:lo=mid + elif l>0:hi=mid + else:raise AssertionError('directed series resolution insufficient') + al,au=Q(lo,grid),Q(hi,grid) + # Symbolic dual prices for objective H_remainder, with H_r = r^p. + mu9=mul(Q(1,5),add(f(3),mul(-1,f(48))));c32=add(f(5),mul(-3,mu9)) + capprice={8:mul(Q(1,4),c32),16:mul(Q(1,2),c32),32:c32,48:f(48)} + mu={9:mu9,8:mul(Q(-1,4),c32),7:add(mul(Q(-1,2),c32),mul(-1,mu9)),5:mul(-1,f(5)),4:add(f(1),mul(-1,f(5)))} + dualobjective=add(*(mul(n,capprice[c])for c,n in caps.items()),*(mul(9*inventory[w],mu[w])for w in widths));need(dualobjective==dict(idle),'symbolic primal/dual objective equality') + bounds={r:(m.power(r,au)[0],m.power(r,al)[1])for r in range(1,49)} + def evaluate(d): + l=u=Q(0) + for r,c in d.items(): + a,b=bounds[r] + if c>=0:l+=c*a;u+=c*b + else:l+=c*b;u+=c*a + return l,u + patterns=[];minimum=None;zeros=0 + for c in caps: + for z in itertools.product(*(range(c//w+1)for w in widths)): + used=sum(w*n for w,n in zip(widths,z)) + if used>c:continue + rem=c-used;slack=add(f(rem),mul(-1,capprice[c]),*(mul(-n,mu[w])for w,n in zip(widths,z))) + if not slack:zeros+=1;l=u=Q(0) + else: + l,u=evaluate(slack);need(l>0,'dual-infeasible packing pattern');minimum=l if minimum is None else min(minimum,l) + patterns.append(dict(capacity=c,width_counts=z,remainder=rem,symbolic_slack={r:str(v)for r,v in slack.items()},scaled_interval=[str(l),str(u)])) + need(len(patterns)==1163,'exhaustive actual packing patterns') + # A forged dual price must be detected by its tight [8] pattern. + bad=add(capprice[8],f(1));badslack=add(mul(-1,bad),mul(-1,mu[8]));need(evaluate(badslack)[1]<0,'forged dual control') + for k,p in paths.items():need(sha(p)==pins[k],'input changed '+k) + result=dict(status='PASS_EXACT_CURRENT_INVENTORY_PRIMAL_DUAL_AND_ACTUAL_ATTAINMENT',input_sha256=pins,profile_at_T185=C,per_replica_profile={r:str(n)for r,n in H.items()},primal_support=primal,dual_capacity_prices={c:{r:str(v)for r,v in d.items()}for c,d in capprice.items()},dual_helper_prices={w:{r:str(v)for r,v in d.items()}for w,d in mu.items()},moment_root_bracket=[str(al),str(au)],symbolic_objective_equals_primal=True,pattern_count=len(patterns),symbolically_tight_patterns=zeros,minimum_nontight_slack_scaled=str(minimum),scale='2^512',negative_control='forged_dual_capacity_price_rejected',scope='Actual T185 profile attains the complete fixed-capacity/fixed-native-inventory fractional packing optimum throughout the certified moment-root interval. The certificate does not cover changed native words, chronology outside the literal owner audit, alternate controllers or global optimality across all suppliers.') + # Preserve every individual dual inequality in a separate finite certificate. + a.out.mkdir(); + for name,obj in [('RESULT.json',result),('PATTERNS.json',patterns)]: + p=a.out/name;lock=p.with_name(p.name+'.lock');fd=os.open(lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY);os.close(fd) + try:p.write_text(json.dumps(obj,sort_keys=True,indent=2)+'\n',encoding='utf8',newline='\n') + finally:lock.unlink() + print(json.dumps(result,sort_keys=True,indent=2)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/review/review_current.py b/research/shared-kernel-packing/review/review_current.py new file mode 100644 index 0000000000..683f50129f --- /dev/null +++ b/research/shared-kernel-packing/review/review_current.py @@ -0,0 +1,48 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent source-bound owner/profile/moment review for current staged words.""" +import argparse,hashlib,json,os,types +from pathlib import Path +from fractions import Fraction as Q + +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def need(p,m): + if not p:raise AssertionError(m) +def code(name,path,expected): + body=path.read_bytes();need(hashlib.sha256(body).hexdigest()==expected,'executed source bytes '+name);m=types.ModuleType(name);m.__file__=str(path);exec(compile(body,str(path),'exec'),m.__dict__);return m + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--package',type=Path,required=True);ap.add_argument('--candidate',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);ap.add_argument('--claim',type=Path);ap.add_argument('--field',default='claim');a=ap.parse_args();need(not a.out.exists(),'fresh output');here=Path(__file__).resolve().parent + lc=code('literal_core',here/'literal_core.py','f5b36146de862c4f9f68412b1a9177409cb390ad4051b0f71483f36591e6a5d6');mc=code('moment_core',here/'moment_core.py','22290074f138fa9b902e5f6f6e8a0ec366d6f812992adb6df9b617ce952fb852');mc.BITS=512;mc.S=1<<512;mc.LOG_TERMS=220;mc.EXP_TERMS=114 + localpins=lc.rd(a.package/'LOCAL-PINS.json');sourcefiles=['PROVIDERS.json','PROFILE.json','CLAIM.json','ORDER.json','DISPATCH.json','words/WORD-base.json.gz','words/WORD-extra.json.gz','sources/PR2833-T37-TEMPLATE.json.gz'];pins={};candidatefiles=['FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json'] + for n in sourcefiles: + h=sha(a.package/n);need(localpins[n]==h,'actual source pin '+n);pins['source/'+n]=h + for n in candidatefiles:pins['candidate/'+n]=sha(a.candidate/n) + providers=lc.rd(a.package/'PROVIDERS.json');need(set(providers)=={'extra','gauge44'},'fixed current provider registry') + for pid in providers: + need(len(providers[pid]['widths'])==408,'all current helpers');need(providers[pid]['actual_paid_profile']=={'1':2394,'2':642,'3':266,'4':128,'5':26,'8':8},'actual staged local price') + order=lc.rd(a.candidate/'ORDER.json');dispatch_list=lc.rd(a.candidate/'DISPATCH.json');dispatch={(s,r):p for s,r,p in dispatch_list};T=len(order)//9 + need(T>0 and len(order)==9*T and len(set(map(tuple,order)))==9*T and len(dispatch_list)==len(dispatch)==9*T,'full actual call partition') + need(set(dispatch)==set(map(tuple,order))and all(pid in providers for pid in dispatch.values()),'actual selected provider per call') + context=lc.chronology(lc.rd(a.package/'sources/PR2833-T37-TEMPLATE.json.gz'),order,T);fill=lc.rd(a.candidate/'FILL.json.gz');H,idle=lc.audit(fill,order,dispatch,providers,context,T) + need(H=={int(r):n for r,n in lc.rd(a.candidate/'PROFILE.json').items()},'exact complete candidate profile') + negative=[] + def reject(name,mut): + f=lc.copy.deepcopy(fill);mut(f) + try:lc.audit(f,order,dispatch,providers,context,T) + except AssertionError:negative.append(name);return + raise AssertionError('corruption accepted '+name) + reject('missing_helper',lambda f:f['rows'].pop());reject('noninteger_descriptor',lambda f:f['rows'][0].__setitem__(0,.5));reject('slice_capacity_overflow',lambda f:f['rows'][0].__setitem__(5,100));reject('hidden_dispatch_override',lambda f:f['dispatch_overrides'].append([0,'forged'])) + claimpath=a.claim or a.candidate/'MOMENT-RECEIPT.json';pins['claim']=sha(claimpath);alpha=mc.rational(lc.rd(claimpath)[a.field]);lo,hi,_=mc.moment(H,896*T,73,alpha);need(hi<0,'full moment not strictly certified');baseline=Q(lc.rd(a.package/'CLAIM.json')['kappa']);need(alpha>baseline,'claim not strictly above actual current frontier') + native={} + for c in order: + for r,n in providers[dispatch[tuple(c)]]['actual_paid_profile'].items():native[int(r)]=native.get(int(r),0)+n + need(all(H.get(r,0)>=n for r,n in native.items()),'all native paid ranks present') + for n in sourcefiles:need(sha(a.package/n)==pins['source/'+n],'source changed during review') + for n in candidatefiles:need(sha(a.candidate/n)==pins['candidate/'+n],'candidate changed during review') + need(sha(claimpath)==pins['claim'],'claim changed during review') + result=dict(status='PASS_INDEPENDENT_CURRENT_STAGED_OWNER_MOMENT_REVIEW',source_head='0b2e2537b368a0cade07ce3f71452ea018ebe394',input_sha256=pins,replicas=T,calls=9*T,roles=len(fill['rows']),physical=896*T+490,source_events=30*T+2,profile=H,idle_profile=idle,rank_mass=sum(r*n for r,n in H.items()),moment_interval_scaled=[str(lo),str(hi)],scale='2^512',above_complete_current_frontier=True,negative_controls_rejected=negative,scope='Independent literal chronology/windows/families/masks/prefixes/current-provider profile and exact directed moment. No constructor or solver imports. Fresh native phase/primitive and complete compiler/precision/release guards remain separate.') + lock=a.out.with_name(a.out.name+'.lock');fd=os.open(lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY);os.close(fd) + try:a.out.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n',encoding='utf8',newline='\n') + finally:lock.unlink() + print(json.dumps(result,sort_keys=True,indent=2)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/tools/admit2857.py b/research/shared-kernel-packing/tools/admit2857.py new file mode 100644 index 0000000000..836a00014c --- /dev/null +++ b/research/shared-kernel-packing/tools/admit2857.py @@ -0,0 +1,412 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a changed-replica literal order/fill derivative. + +PR2833 extension by Yiyang Lu with OpenAI Codex assistance: add the exact +immutable dirt-entry source profile and exact full outer-claim comparisons to +PR2833 and the newer PR2843 T124 allocation. All +inherited native, owner, invoice, block-norm, controls and release checks retained. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-refit393' +SOURCE_MANIFEST = '1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +COMPARISON_SHA = '252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3' +COMPARISON_HEAD = 'e8b771ba132fe632796b28c1742a8d096c04519f' +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +# Supported immutable source versions; CLI selection never accepts arbitrary hashes. +SOURCE_PROFILES = { + 'shared-four': dict(commit='shared-four-kernel-pr2833', manifest='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869', helpers=408, source_file_count=547, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2766': dict(commit='local-joint12-refit393', manifest='1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb', helpers=415, source_file_count=491, upstream_head='e6df920cd0110e4b629e2ad84eddcb539001e174'), + 'pr2802': dict(commit='local-joint12-pr2733', manifest='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451', helpers=408, source_file_count=506, upstream_head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd'), +} +COMPARISONS = { + 'pr2857': dict(pr=2857, head='0b2e2537b368a0cade07ce3f71452ea018ebe394', sha256='c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f', field='kappa'), + 'pr2848': dict(pr=2848, head='c50d12e4720cd1fef2b5a65e337e37de9731879a', sha256='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', field='kappa'), + 'pr2843': dict(pr=2843, head='47a7227c044cd0cabb1432a06c61dd5d60c07f5a', sha256='0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9', field='kappa'), + 'pr2833': dict(pr=2833, head='e9307b48d7d1b690939935ecef0f8e524e6d92f4', sha256='6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70', field='kappa_rational'), + 'pr2767': dict(pr=2767, head='e8b771ba132fe632796b28c1742a8d096c04519f', sha256='252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3', field='kappa_rational'), + 'pr2802': dict(pr=2802, head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd', sha256='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51', field='kappa'), +} + + + +# Discovery records are shared by parallel mutation-audit processes on Windows. +# Only discovery bookkeeping changes; strict pin comparison below it is untouched. +DISCOVERY_APPEND_OLD = " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))" +DISCOVERY_APPEND_NEW = r''' import time as _wr_time + _wr_path=Path(os.environ['WITNESS_RECORD']) + _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock') + _wr_deadline=_wr_time.monotonic()+60 + _wr_fd=None + while _wr_fd is None: + try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + except FileExistsError: + if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved') + _wr_time.sleep(.005) + try: + with _wr_path.open('a',encoding='utf-8',newline='\n')as _wr_out: + _wr_out.write(json.dumps([key,got],default=str)+chr(10)) + _wr_out.flush() + finally: + os.close(_wr_fd) + _wr_lock.unlink()''' + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + # All output targets belong to this fresh work tree; never unlink an open lock. + lock = path.with_name(path.name + '.lock') + descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + try: + os.write(descriptor, str(os.getpid()).encode()) + os.close(descriptor) + descriptor = None + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + finally: + if descriptor is not None: + os.close(descriptor) + lock.unlink() + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'dispatch', 'native-cache', 'native-receipt', 'work', 'replica-helper-dir', 'reconstructor', 'comparison-claim', 'blocknorm-checker'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + ap.add_argument('--source-profile', choices=sorted(SOURCE_PROFILES), default='shared-four') + ap.add_argument('--comparison-profile', choices=sorted(COMPARISONS), default='pr2848') + a = ap.parse_args() + global SOURCE_COMMIT, SOURCE_MANIFEST, COMPARISON_SHA, COMPARISON_HEAD + source_profile = SOURCE_PROFILES[a.source_profile] + comparison = COMPARISONS[a.comparison_profile] + SOURCE_COMMIT, SOURCE_MANIFEST = source_profile['commit'], source_profile['manifest'] + COMPARISON_SHA, COMPARISON_HEAD = comparison['sha256'], comparison['head'] + expected_helpers, comparison_pr = source_profile['helpers'], comparison['pr'] + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == source_profile['source_file_count'] and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + helper_dir = a.replica_helper_dir.resolve() + helper_paths = [helper_dir / n for n in ('lift_parent.py', 'replica_parent.py')] + [a.reconstructor.resolve()] + external_hashes = {str(p): sha(p) for p in helper_paths + [a.fill.resolve(), a.order.resolve(), a.dispatch.resolve(), a.comparison_claim.resolve(), a.blocknorm_checker.resolve()]} + need(sha(a.comparison_claim) == COMPARISON_SHA, 'exact pinned frontier headline comparison') + comparison_claim = read(a.comparison_claim) + need('headline_kappa_source' not in comparison_claim and comparison['field'] in comparison_claim, + 'comparison must be full headline outer claim, not supplier-only CLAIM') + previous = Q(comparison_claim[comparison['field']]) + need(previous == Q(comparison_claim['kappa']), 'comparison rational/decimal equality') + order_input = read(a.order) + need(order_input and all(isinstance(x,list) and len(x)==2 and all(type(v)is int for v in x) for x in order_input), 'literal integer call order') + T = 1 + max(r for st,r in order_input) + need(T > 0 and len(order_input)==9*T and set(map(tuple,order_input))=={(st,r) for st in range(9) for r in range(T)}, 'complete new replica coverage') + need(all([st for st,r in order_input if r==rep]==list(range(9)) for rep in range(T)), 'source stage projection') + dispatch_input = read(a.dispatch) + need(len(dispatch_input)==9*T and {(st,r) for st,r,pid in dispatch_input}==set(map(tuple,order_input)), 'complete explicit dispatch') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + # Only the fresh external clone changes. Immutable source/cache inventories remain pinned. + for hp in helper_paths[:2]: + shutil.copy2(hp, package / hp.name) + need(sha(package / hp.name)==external_hashes[str(hp)], 'helper copy hash') + shutil.copy2(a.blocknorm_checker, package / 'blocknorm_certificate.py') + shutil.copy2(a.blocknorm_checker, package / 'code/blocknorm_certificate.py') + need(sha(package / 'blocknorm_certificate.py') == external_hashes[str(a.blocknorm_checker.resolve())], 'block-norm checker exact source binding') + shutil.copy2(a.reconstructor, package / 'reconstruct.py') + need(sha(package / 'reconstruct.py')==external_hashes[str(a.reconstructor.resolve())], 'reconstructor copy hash') + # The original subprocesses also write generated hash-bound source. Windows + # callers use a process-scoped LF adapter; no system configuration is changed. + lf_probe = work / '.lf-preflight.txt' + lf_probe.write_text('LF\n', encoding='utf-8') + need(lf_probe.read_bytes()==b'LF\n', 'process-scoped LF output required on Windows') + lf_probe.unlink() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # At T37 the historical fixed333 mutant is a no-op. Preserve the + # undercharge test by subtracting one from both actual charges, and + # require every geometry mutant to differ before the unchanged assembly. + patch('geometry_controls.py', [ + (" i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1"), + (" o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + # Keep the native dimension and paid moment ledger fixed; bind replica + # width to both the checked source geometry and the independent B invoice. + patch('outer/check_ledger.py', [ + ('assert (m,W)==(73,66304)', + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']")]) + patch('code/witness.py', [(DISCOVERY_APPEND_OLD, DISCOVERY_APPEND_NEW)]) + patch('verify.py', [ + ("run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')")]) + # A sharper local reserve is certified against actual scalar/Horner + # prefixes of BOTH orientations and BOTH providers. All sweep and physical + # row charges remain unchanged; this never omits an invocation or bridge. + patch('code/witness.py', [ + ("PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4")]) + patch('independent_core.py', [ + (" payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm,"), + (" primitive_arithmetic_margin_bits=4,controller_audit_sha256=", " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256="), + ("Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix.")]) + patch('independent_core.py', [ + (" prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4"), + ("prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn")]) + patch('audit_mixed.py', [ + ("pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)")]) + patch('code/assemble.py', [ + (" assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 previous, + 'candidate must strictly improve full exact pinned frontier headline before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=COMPARISON_HEAD, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + (package / 'provenance').mkdir(exist_ok=True) + shutil.copy2(a.comparison_claim, package / ('provenance/PR' + str(comparison_pr) + '-HEADLINE-CLAIM.json')) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + need(all(sha(Path(p))==h for p,h in external_hashes.items()), 'external candidate/helper inputs changed during admission') + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/tools/audit_moment2857.py b/research/shared-kernel-packing/tools/audit_moment2857.py new file mode 100644 index 0000000000..e7371596fa --- /dev/null +++ b/research/shared-kernel-packing/tools/audit_moment2857.py @@ -0,0 +1,79 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent dyadic interval moment auditor, atlas D020. +Uses only Python integers/Fraction; imports no inherited numerical implementation. +This authenticates a paid histogram and its root, not a physical realization. +""" +from fractions import Fraction as F +from pathlib import Path +from functools import lru_cache +from collections import Counter +import argparse,json,hashlib + +BITS=192 +SCALE=1<=1,'log domain');k=0 + while q>2:q/=2;k+=1 + def unit(y): + z=(y-1)/(y+1);z2=z*z;term=z;value=F(0) + for j in range(128): + value+=term/(2*j+1);term*=z2 + remainder=2*term/(257*(1-z2)) + return 2*value,2*value+remainder + l,u=unit(q);l2,u2=unit(F(2));return down(l+k*l2),up(u+k*u2) +def exp_bounds(y): + need(0<=y0,'profile domain');l,u=log_bounds(F(73,rank));a=exp_bounds(b*l)[0];z=exp_bounds(b*u)[1];weight=F(rank*count,73*W);lo+=weight*a;hi+=weight*z + return down(lo),up(hi) +def run(candidate,source): + import sys + if hasattr(sys,'set_int_max_str_digits'):sys.set_int_max_str_digits(0) + need(hashlib.sha256((source/'CLAIM.json').read_bytes()).hexdigest()=='c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f','exact pinned PR2857 full headline') + prof={int(k):v for k,v in json.loads((candidate/'PROFILE.json').read_bytes()).items()} + old={int(k):v for k,v in json.loads((source/'PROFILE.json').read_bytes()).items()} + W=896*(1+max(r for s,r in json.loads((candidate/'ORDER.json').read_bytes()))) + oldW=896*(1+max(r for s,r in json.loads((source/'ORDER.json').read_bytes()))) + need(sum(r*n for r,n in prof.items())==W*73-W*320//896,'new rank mass') + need(sum(r*n for r,n in old.items())==oldW*73-oldW*320//896,'old rank mass') + # No floating endpoint or inherited numerical implementation is used. + q=10**26;lo=0;hi=q//200 + need(moment(prof,F(lo,q),W)[1]<1 and moment(prof,F(hi,q),W)[0]>1,'global root bracket') + while hi-lo>1: + mid=(lo+hi)//2;l,u=moment(prof,F(mid,q),W) + if u<1:lo=mid + elif l>1:hi=mid + else:raise ValueError('interval precision insufficient') + endpoint=F((lo//100),10**24) + target=endpoint-F(1,10**46)-F(1,10**70) + prior=F(json.loads((source/'CLAIM.json').read_bytes())['kappa']) + need(target>prior and target1,'overstated endpoint rejected') + wrong=dict(prof);wrong[32]=wrong.get(32,0)+1 + need(moment(wrong,F(lo,q),W)[0]>1,'omitted rank charge rejected') + import decimal + with decimal.localcontext() as c: + c.prec=80 + todec=lambda x:str(decimal.Decimal(x.numerator)/decimal.Decimal(x.denominator)) + texttarget=todec(target);textgain=todec(target-prior) + return dict(status='PASS_SEPARATE_EXACT_RATIONAL_FRONTIER_MOMENT',lower=str(F(lo,q)),upper=str(F(hi,q)),outer_endpoint=str(endpoint),target=str(target),target_decimal=texttarget,previous=str(prior),gain=str(target-prior),gain_decimal=textgain,W=W,oldW=oldW,normalized_profile_delta=normalized_delta,new_moment_at_full_prior=[str(x)for x in at_old],profile_sha256=hashlib.sha256((candidate/'PROFILE.json').read_bytes()).hexdigest(),baseline_profile_sha256=hashlib.sha256((source/'PROFILE.json').read_bytes()).hexdigest(),baseline_claim_sha256=hashlib.sha256((source/'CLAIM.json').read_bytes()).hexdigest(),method='Independent 128-term atanh / degree24 exponential with explicit positive tails and outward 192-bit dyadic rounding',controls=['zero log/exp identities','overstated endpoint','added rank32 charge'],scope='Complete paid histogram and exact moment only; full native/physical/outer release is separate.') +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--candidate',type=Path,required=True);p.add_argument('--source',type=Path,required=True);p.add_argument('--out',type=Path,required=True);a=p.parse_args() + need(not a.out.exists(),'fresh output required');d=run(a.candidate,a.source);a.out.write_text(json.dumps(d,sort_keys=True,indent=2)+'\n',encoding='utf-8',newline='\n');print(json.dumps({k:d[k]for k in ['status','target_decimal','gain_decimal','lower','upper']})) diff --git a/research/shared-kernel-packing/tools/audit_owners2857.py b/research/shared-kernel-packing/tools/audit_owners2857.py new file mode 100644 index 0000000000..55e2aa1a8d --- /dev/null +++ b/research/shared-kernel-packing/tools/audit_owners2857.py @@ -0,0 +1,84 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Source-event audit derived from PR2848's independently implemented auditor. +Credit Yiyang / Lyy-iiis, OpenAI Codex assistance, and the retained source notices. +Generalized here to a pinned PR2857 baseline, its round-robin lifts and changed literal allocations; +imports no producer, candidate generator or inherited owner engine. +""" +from pathlib import Path +from collections import Counter, defaultdict +import argparse,gzip,hashlib,json + +def need(c,m): + if not c: raise ValueError(m) +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def audit(source,candidate): + pins={'CLAIM.json': 'c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f', 'DISPATCH.json': '5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4', 'FILL.json.gz': '82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501', 'ORDER.json': '84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc', 'PROFILE.json': 'f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa', 'PROVIDERS.json': 'b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2', 'sources/PR2833-PLAN.json.gz': 'd566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e', 'sources/PR2833-T37-TEMPLATE.json.gz': '21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e'} + def inventory(): + need(all(sha(source/n)==h for n,h in pins.items()),'pinned complete owner-source inputs changed') + inventory() + raw={} + raw['BASE-ORDER']=read(source/'ORDER.json') + raw['BASE-FILL']=read(source/'FILL.json.gz') + raw['BASE-DISPATCH']=read(source/'DISPATCH.json') + raw['SOURCE-TEMPLATE']=read(source/'sources/PR2833-T37-TEMPLATE.json.gz') + raw['SOURCE-PLAN']=read(source/'sources/PR2833-PLAN.json.gz') + raw['PROVIDERS']=read(source/'PROVIDERS.json') + order=read(candidate/'ORDER.json');rows=read(candidate/'FILL.json.gz')['rows'];dr=read(candidate/'DISPATCH.json');dispatch={(s,r):p for s,r,p in dr} + oldorder=raw['BASE-ORDER'];oldfill=raw['BASE-FILL']['rows'];olddispatch={(s,r):p for s,r,p in raw['BASE-DISPATCH']} + T=1+max(r for s,r in oldorder);N=1+max(r for s,r in order);need(N%T==0,'integer lift');copies=N//T;calls=9*N + need(copies>=1 and order==[[s,r+T*g]for s,r in oldorder for g in range(copies)],'exact round-robin source call lift') + need(len(dr)==len(dispatch)==calls and dispatch=={(s,r+T*g):p for (s,r),p in olddispatch.items()for g in range(copies)},'exact provider lift') + expected=[[copies*t+g,h,o+T*g,c,p,z]for t,h,o,c,p,z in oldfill for g in range(copies)] + need(len(rows)==len(expected)==408*calls,'complete role count') + changes=[{'before':a,'after':b}for a,b in zip(expected,rows)if a!=b] + template=raw['SOURCE-TEMPLATE'];plan=raw['SOURCE-PLAN'];providers=raw['PROVIDERS'] + blocks={};stage=None;tail=[] + for ix,e in enumerate(template['execution_schedule']): + if e['kind'] in ('bank_padding_cover_sweep','translate_every_live_family'):tail.append(ix);continue + if e['kind']=='local_cover_sweep':stage=e['stage'];blocks[stage]=[] + need(stage is not None,'leading source event');blocks[stage].append((ix,e)) + need(tail==[30,31],'exact source terminal events') + pair={e['stage']:e['pair']for e in template['recipe']if e['kind']=='local'};caps={} + for e in template['idle_children']: + need(e['child'] not in caps or caps[e['child']]==e['rank'],'consistent capacity');caps[e['child']]=e['rank'] + last={};windows={};callclock=[];projection=defaultdict(list);clock=0 + for t,(stage,replica) in enumerate(order): + for ix,e in blocks[stage]: + projection[replica].append(ix) + if e['kind']=='local_cover_sweep':last[replica,pair[stage]]=clock;callclock.append(clock) + elif e['kind']=='bridge':last[replica,e['src']]=clock;last[replica,e['dst']]=clock + elif e['kind']=='idle_cover_sweep': + for child in e['child_indices']: + if child in caps:windows[replica,child]=(last.get((replica,e['pair']),-1),clock) + clock+=1 + need(len(projection)==N and all(v==list(range(30))for v in projection.values()),'every ordered source projection') + need(len(callclock)==calls,'exact local event count') + masks={};helpers=[0]*calls;families=[set() for _ in order] + for row in rows: + need(type(row) is list and len(row)==6 and all(type(v)is int for v in row),'integer role') + t,h,o,c,p,z=row;need(0<=t=0,'role range') + width=providers[dispatch[tuple(order[t])]]['widths'][h];begin,end=windows[o,c] + need(begin>h)&1,'duplicate helper');helpers[t]|=1<crypto.createHash('sha256').update(b).digest('hex'); +async function get(rel){const r=await fetch(prefix+rel,{signal:AbortSignal.timeout(60000)});if(!r.ok)throw Error(r.status+' '+rel);return Buffer.from(await r.arrayBuffer());} +(async()=>{const raw=await get('MANIFEST.json');if(sha(raw)!=='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f')throw Error('manifest hash mismatch');const pins=JSON.parse(raw);if(Object.keys(pins).length!==541)throw Error('source count');for(const name of Object.keys(pins)){if(path.isAbsolute(name)||name.includes('\\')||name.includes(':')||name.split('/').some(x=>x==='..'||x==='.'||x===''))throw Error('unsafe source path');}fs.mkdirSync(dest,{recursive:true});fs.writeFileSync(path.join(dest,'MANIFEST.json'),raw,{flag:'wx'});const todo=Object.entries(pins);let at=0,done=0;async function worker(){while(at{console.error(e.message);process.exitCode=1;}); diff --git a/research/shared-kernel-packing/tools/make_lf_runtime.py b/research/shared-kernel-packing/tools/make_lf_runtime.py new file mode 100644 index 0000000000..e2e01aad23 --- /dev/null +++ b/research/shared-kernel-packing/tools/make_lf_runtime.py @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Create an isolated replay interpreter with LF-default Path.write_text outputs. +No installed package, source validator or global setting is changed. +""" +import argparse, importlib.metadata as md, json, os, sys, venv +from pathlib import Path + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + out=a.out.resolve();root=Path(__file__).resolve().parents[1] + if out.exists() or out.is_relative_to(root) or root.is_relative_to(out):raise ValueError('fresh external runtime required') + paths=set();versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try: + d=md.distribution(name);versions[name]=d.version;paths.add(str(Path(d.locate_file('')).resolve())) + except md.PackageNotFoundError: + versions[name]=None + if any(versions[n] is None for n in ['numpy','scipy','sympy','mpmath']):raise ValueError('install replay dependencies in the launching environment first') + venv.EnvBuilder(with_pip=False).create(out) + site=out/'Lib/site-packages' if os.name=='nt' else out/'lib'/('python'+str(sys.version_info.major)+'.'+str(sys.version_info.minor))/'site-packages' + (site/'replay-dependencies.pth').write_text('\n'.join(sorted(paths))+'\n',encoding='utf-8',newline='\n') + patch="from pathlib import Path\n_original_write_text = Path.write_text\ndef _lf_write_text(self, data, encoding=None, errors=None, newline=None):\n return _original_write_text(self, data, encoding=encoding, errors=errors, newline='\\n' if newline is None else newline)\nPath.write_text = _lf_write_text\n" + (site/'sitecustomize.py').write_text(patch,encoding='utf-8',newline='\n') + (out/'REPLAY-RUNTIME.json').write_text(json.dumps(dict(scope='Task-local LF output default; installed dependency locations reused read-only; no validator changes.',versions=versions),indent=2)+'\n',encoding='utf-8',newline='\n') + exe=out/'Scripts/python.exe' if os.name=='nt' else out/'bin/python' + print(str(exe)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/tools/materialize_source.py b/research/shared-kernel-packing/tools/materialize_source.py new file mode 100644 index 0000000000..15631dd5df --- /dev/null +++ b/research/shared-kernel-packing/tools/materialize_source.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Export the exact PR2833 source from local Git objects, without fetching. + +The output is the package directory itself, suitable for reproduce.py --source. +Jeremy Kothe and the retained PR2833 contributors retain source attribution. +""" +import argparse +import hashlib +import io +import json +from pathlib import Path, PurePosixPath +import subprocess +import sys +import tarfile + +sys.dont_write_bytecode = True +HEAD = 'e9307b48d7d1b690939935ecef0f8e524e6d92f4' +PREFIX = 'research/gmx-t74-borrow43-handoff' +MANIFEST_SHA = 'c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +FILE_COUNT = 541 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def safe_relative(name): + path = PurePosixPath(name) + need(name and not path.is_absolute() and '..' not in path.parts + and '\\' not in name and '\0' not in name, + 'unsafe source path: ' + name) + need('__pycache__' not in path.parts and path.suffix != '.pyc', + 'bytecode is forbidden in exact source: ' + name) + return path + + +def authenticate_payload(files): + need('MANIFEST.json' in files, 'missing exact source manifest') + need(digest(files['MANIFEST.json']) == MANIFEST_SHA, 'exact PR2833 manifest hash') + pins = json.loads(files['MANIFEST.json']) + need(isinstance(pins, dict) and len(pins) == FILE_COUNT, 'exact 541-entry manifest') + for name in pins: + safe_relative(name) + actual = {name: digest(raw) for name, raw in files.items() if name != 'MANIFEST.json'} + need(actual == pins, 'complete exact PR2833 file inventory and hashes') + return pins + + +def authenticate_source(source): + source = Path(source) + need(source.is_dir() and not source.is_symlink(), 'source must be a real directory') + files = {} + for path in sorted(source.rglob('*')): + name = path.relative_to(source).as_posix() + safe_relative(name) # Checks empty __pycache__ directories too. + need(not path.is_symlink(), 'source symlink: ' + name) + if path.is_file(): + files[name] = path.read_bytes() + else: + need(path.is_dir(), 'nonregular source entry: ' + name) + return authenticate_payload(files) + + +def export(repo, out): + repo, out = Path(repo).resolve(), Path(out).resolve() + need(not out.exists() and not out.is_symlink(), 'fresh output directory required') + check = subprocess.run(['git', '-C', str(repo), 'rev-parse', '--verify', HEAD + '^{commit}'], + check=True, capture_output=True, text=True) + need(check.stdout.strip() == HEAD, 'exact locally available PR2833 commit') + archive = subprocess.run(['git', '-C', str(repo), 'archive', '--format=tar', HEAD, PREFIX], + check=True, capture_output=True).stdout + prefix = PurePosixPath(PREFIX) + files = {} + with tarfile.open(fileobj=io.BytesIO(archive), mode='r:') as package: + for member in package.getmembers(): + path = PurePosixPath(member.name) + need(not path.is_absolute() and '..' not in path.parts and '\\' not in member.name, + 'unsafe Git archive path') + if member.isdir() and (path == prefix or path in prefix.parents): + continue + need(path.is_relative_to(prefix), 'archive entry outside pinned package') + relative = path.relative_to(prefix).as_posix() + safe_relative(relative) + need(member.isfile() or member.isdir(), 'archive links/special files forbidden') + if member.isdir(): + continue + need(relative not in files, 'duplicate archive file') + stream = package.extractfile(member) + need(stream is not None, 'missing archive file stream') + files[relative] = stream.read() + authenticate_payload(files) + out.mkdir(parents=True, exist_ok=False) + for name, raw in files.items(): + destination = out / name + destination.parent.mkdir(parents=True, exist_ok=True) + with destination.open('xb') as handle: + handle.write(raw) + authenticate_source(out) + return {'status': 'PASS_EXACT_PR2833_SOURCE_EXPORT', 'head': HEAD, + 'manifest_sha256': MANIFEST_SHA, 'manifest_entries': FILE_COUNT, + 'source': str(out), 'network_fetch': False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, default=Path.cwd(), + help='Local Git repository containing the pinned commit (default: cwd)') + parser.add_argument('--out', type=Path, required=True, help='Fresh source package directory') + args = parser.parse_args() + print(json.dumps(export(args.repo, args.out), sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/tools/prepare2857.py b/research/shared-kernel-packing/tools/prepare2857.py new file mode 100644 index 0000000000..0232d3ce81 --- /dev/null +++ b/research/shared-kernel-packing/tools/prepare2857.py @@ -0,0 +1,76 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Two fresh changed-word native chains; explicit authenticated parent reuse. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Derived from the PR2839/PR2848 native preparation lineage, retaining validators. +""" +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +from importlib import metadata +import argparse,hashlib,json,gzip,os,platform,shutil,subprocess,sys,time +sys.dont_write_bytecode=True +SOURCE_SHA='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +SOURCE_FILES=547 +SOURCE_COMMIT='shared-four-kernel-pr2833' +PARENT_SHA='e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +OLD_RECEIPT_SHA='f7b5c990a5e86294f6562c4c59e8225864bf7ed31d1c0dee8d7a4fbd7700ff52' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p,exclude=()): + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no cache/source symlinks') + if f.is_file()and f.relative_to(p).as_posix()not in exclude:out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser() + for n in ['source','retained-cache','retained-receipt','out']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--jobs',type=int,default=2);a=ap.parse_args();source=a.source.resolve();out=a.out.resolve();oldcache=a.retained_cache.resolve() + need(not sys.flags.optimize and 1<=a.jobs<=2,'assertions enabled and max2 jobs') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==SOURCE_FILES and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'complete immutable derived source') + need(not list(source.rglob('__pycache__'))and not list(source.rglob('*.pyc')),'source free of bytecode and cache folders') + before=tree(source);oldreceipt=read(a.retained_receipt) + need(sha(a.retained_receipt)==OLD_RECEIPT_SHA and tree(oldcache)==oldreceipt['cache_files'],'complete PR2848 retained native/cache evidence') + old=source/'vendor/pr1297';need(sha(old/'MANIFEST.json')==PARENT_SHA and tree(old,('MANIFEST.json',))==read(old/'MANIFEST.json'),'unchanged retained source') + prdir=oldcache/'_receipts'/PARENT_SHA;need(sha(prdir/'RECEIPT.json')==oldreceipt['retained_parent_receipt_sha256'],'retained parent receipt identity');pr=read(prdir/'RECEIPT.json') + need(pr['vendor_manifest_sha256']==PARENT_SHA and pr['claim_sha256']==sha(old/'CLAIM.json'),'retained parent source claim') + for name,h in pr['files'].items():need(sha(prdir/name)==h,'retained parent result binding') + need(read(prdir/'RESULT.json')['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and read(prdir/'RESULT.json')['kappa']==read(old/'CLAIM.json')['kappa'],'retained full parent admission') + pstages=read(prdir/'STAGES.json');need(len(pstages)==16 and all(s['exit_code']==0 for s in pstages),'all16 retained parent stages') + need(not out.exists()and not out.is_relative_to(source)and not out.is_relative_to(oldcache),'fresh external native work');out.mkdir(parents=True);cache=out/'native-cache';cache.mkdir() + steps=['native','ledgers','local-replay','wrappers','phases'] + for tag,name in [('base','gauge44-word.json.gz'),('extra','extra-word.json.gz')]: + word=old/name;key=sha(word);need(pr['words'][tag]==key,'retained word hash');entry=oldcache/key + need(read(entry/'local/FULL-WORD.json.gz')==read(word),'retained complete literal word');st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'retained native five stages') + cj=read(entry/'CACHE.json');need(cj['word_sha256']==key and cj['files']==tree(entry,('CACHE.json',)),'retained full native files') + shutil.copytree(entry,cache/key) + shutil.copytree(prdir,cache/'_receipts'/PARENT_SHA) + versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try:versions[name]=metadata.version(name) + except metadata.PackageNotFoundError:versions[name]=None + write(out/'ENVIRONMENT.json',dict(python=platform.python_version(),executable=sys.executable,dependency_versions=versions,assertions_enabled=True)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for k in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(k,None) + driver=source/'new/fastnative/run_native.py';start=time.monotonic();stages=[];words={t:source/('new/borrow/words/BORROW-WORD-43'+t+'.json.gz')for t in ['base','extra']} + def fresh(tag): + word=words[tag];work=out/('fresh-'+tag);cmd=[sys.executable,'-B',str(driver),str(word),str(work)];log=out/('native-'+tag+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=out,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + need(r.returncode==0,'fresh native '+tag+' failed; '+str(log));res=read(work/'RESULT.json');need(res['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY'and res['word_sha256']==sha(word),'fresh native result') + entry=cache/sha(word);shutil.copytree(work/'native',entry);need(read(entry/'local/FULL-WORD.json.gz')==read(word),'fresh complete literal word') + st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'fresh native five stages') + checks=read(entry/'local/LOCAL-CHECKS.json');can=read(entry/'local/CANONICAL-WORD.json.gz') + need(can['R']==408 and len(can['centers'])==8 and len(can['zero_buffers'])==72,'complete physical ABI') + for orientation in ['forward','backward']:need(checks[orientation]['all_columns']==632 and checks[orientation]['paid_profile']==read(word)['report']['local_profile'],'actual all-column native profile') + write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry))) + rec=dict(name='fresh-current-'+tag,exit_code=0,command=cmd,script_sha256=sha(driver),log_sha256=sha(log),result_sha256=sha(work/'RESULT.json'),seconds=time.monotonic()-begin);print('PASS',rec['name'],flush=True);return rec + with ThreadPoolExecutor(max_workers=a.jobs)as pool:stages=list(pool.map(fresh,['base','extra'])) + need(tree(source)==before and tree(oldcache)==oldreceipt['cache_files']and sha(a.retained_receipt)==OLD_RECEIPT_SHA,'read-only input drift') + rec=dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',source_commit=SOURCE_COMMIT,manifest_sha256=SOURCE_SHA,providers={t:dict(word_sha256=sha(w),complete_native_files=tree(cache/sha(w),('CACHE.json',)))for t,w in words.items()},retained_parent_receipt_sha256=sha(cache/'_receipts'/PARENT_SHA/'RECEIPT.json'),cache_files=tree(cache),fresh_current_provider_count=2,fresh_retained_native_count=0,reused_retained_native_count=2,fresh_retained_parent=False,reused_retained_parent=True,retained_reuse_receipt_sha256=OLD_RECEIPT_SHA) + write(out/'NATIVE-RECEIPT.json',rec);write(out/'STAGES.json',stages);write(out/'RESULT.json',dict(status='PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',source_manifest_sha256=SOURCE_SHA,native_receipt_sha256=sha(out/'NATIVE-RECEIPT.json'),preparer_sha256=sha(Path(__file__)),environment_sha256=sha(out/'ENVIRONMENT.json'),stages=stages,seconds=time.monotonic()-start,scope='Fresh changed base/extra native chains; two unchanged retained native chains and16-stage parent admission explicitly reused by exact full-tree receipts. No owner/controller/outer admission yet.')) + print('PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/tools/prepare_retained.py b/research/shared-kernel-packing/tools/prepare_retained.py new file mode 100644 index 0000000000..b9a35609c0 --- /dev/null +++ b/research/shared-kernel-packing/tools/prepare_retained.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Source-bound PR2833 native preparation; derived from PR2839's preparer. + +Credit: Tekalign (@tekuuu), Jeremy Kothe (@jeremykothe2) and source notices. +This composition driver uses unchanged source/validators and four fresh chains. +""" +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +import argparse, hashlib, gzip, json, os, platform, shutil, subprocess, sys, tarfile, threading, time +from importlib import metadata +SOURCE_SHA='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +SOURCE_COMMIT='pr2833-dirtentry' +PARENT_SHA='e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +def need(x,m): + if not x: raise RuntimeError(m) +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def write(p,v): p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n',encoding='utf-8',newline='\n') +def tree(p,exclude=()): + d={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'source symlink') + if f.is_file() and f.relative_to(p).as_posix() not in exclude:d[f.relative_to(p).as_posix()]=sha(f) + return d +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--out','--work',dest='work',type=Path,required=True);ap.add_argument('--jobs',type=int,default=4);a=ap.parse_args() + need(not sys.flags.optimize and 1<=a.jobs<=4,'enabled assertions and max4 jobs') + sys.dont_write_bytecode=True + source=a.source.resolve();work=a.work.resolve() + need(sha(source/'MANIFEST.json')==SOURCE_SHA,'exact PR2833 manifest') + need(not list(source.rglob('__pycache__')) and not list(source.rglob('*.pyc')),'source must contain no bytecode files or cache directories, even empty ones') + pins=read(source/'MANIFEST.json');need(len(pins)==541 and tree(source,('MANIFEST.json',))==pins,'complete PR2833 source') + need(not work.exists() and not work.is_relative_to(source),'fresh external work');work.mkdir(parents=True) + versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try:versions[name]=metadata.version(name) + except metadata.PackageNotFoundError:versions[name]=None + write(work/'ENVIRONMENT.json',dict(python=platform.python_version(),executable=sys.executable,dependency_versions=versions,assertions_enabled=not bool(sys.flags.optimize),optional_accelerator='gmpy2; exact integer results unchanged',scope='Versions captured before this fresh native replay. No package/source dependency constraint is patched.')) + cache=work/'native-cache';cache.mkdir();old=source/'vendor/pr1297' + need(sha(old/'MANIFEST.json')==PARENT_SHA,'retained parent pin') + words={tag:source/('new/borrow/words/BORROW-WORD-43'+tag+'.json.gz') for tag in ('base','extra')} + retained={tag:old/name for tag,name in [('base','gauge44-word.json.gz'),('extra','extra-word.json.gz')]} + layout=work/'retained-layout';layout.mkdir() + with tarfile.open(old/'upstream-layout.tar.gz') as archive: + need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts for m in archive.getmembers()),'safe retained archive') + archive.extractall(layout,filter='data') + rd=layout/'joint1148-round45/source/research/k8-eight-ends/replay_native.py';need(rd.is_file(),'retained native driver') + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1',BW_IDLE='0') + for k in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(k,None) + stages=[];mutex=threading.Lock();start=time.monotonic() + def run(name,script,*args): + before=time.monotonic();log=work/(name+'.log');cmd=[sys.executable,'-B',str(script),*map(str,args)] + with log.open('w') as f:r=subprocess.run(cmd,cwd=work,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + with mutex: + stages.append(dict(name=name,exit_code=r.returncode,command=cmd,script_sha256=sha(script),log_sha256=sha(log),seconds=time.monotonic()-before));write(work/'STAGES.json',stages) + need(r.returncode==0,'failed '+name+'; '+str(log));print('PASS',name,flush=True) + def fresh(tag): + isret=tag.startswith('retained-');word=retained[tag[9:]] if isret else words[tag];entry=cache/sha(word) + if isret:run('native-'+tag,rd,word,entry) + else: + fw=work/('fast-'+tag);run('native-'+tag,source/'new/fastnative/run_native.py',word,fw) + need(read(fw/'RESULT.json')['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY','complete sparse native result');shutil.copytree(fw/'native',entry) + need(read(entry/'local/FULL-WORD.json.gz')==read(word),'complete native word identity') + s=read(entry/'STEPS.json');need([v['step'] for v in s]==['native','ledgers','local-replay','wrappers','phases'] and all(v['exit_code']==0 for v in s),'five native stages') + write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry))) + with ThreadPoolExecutor(max_workers=a.jobs) as pool:list(pool.map(fresh,['base','extra','retained-base','retained-extra'])) + run('retained-parent',old/'verify.py','--work',work/'retained-parent','--base-native-from',cache/sha(retained['base']),'--extra-native-from',cache/sha(retained['extra'])) + parent=read(work/'retained-parent/RESULT.json');pstages=read(work/'retained-parent/STAGES.json') + need(len(pstages)==16 and all(v['exit_code']==0 for v in pstages),'retained 16 stages') + need(parent['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and parent['kappa']==read(old/'CLAIM.json')['kappa'],'retained exact admission') + receipts=cache/'_receipts'/PARENT_SHA;receipts.mkdir(parents=True) + for n in ['RESULT.json','STAGES.json']:shutil.copy2(work/'retained-parent'/n,receipts/n) + write(receipts/'RECEIPT.json',dict(schema='parent-receipt/1',vendor_manifest_sha256=PARENT_SHA,claim_sha256=sha(old/'CLAIM.json'),words={t:sha(w) for t,w in retained.items()},files={n:sha(receipts/n) for n in ['RESULT.json','STAGES.json']})) + need(tree(source,('MANIFEST.json',))==pins,'unchanged full source') + receipt=dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',source_commit=SOURCE_COMMIT,manifest_sha256=SOURCE_SHA,providers={t:dict(word_sha256=sha(w),complete_native_files=tree(cache/sha(w),('CACHE.json',))) for t,w in words.items()},retained_parent_receipt_sha256=sha(receipts/'RECEIPT.json'),cache_files=tree(cache),fresh_current_provider_count=2,fresh_retained_native_count=2,reused_retained_native_count=0,fresh_retained_parent=True,reused_retained_parent=False,retained_reuse_receipt_sha256=None) + write(work/'NATIVE-RECEIPT.json',receipt) + write(work/'RESULT.json',dict(status='PASS_PR2833_FRESH_NATIVE_PREPARATION',native_receipt_sha256=sha(work/'NATIVE-RECEIPT.json'),source_manifest_sha256=SOURCE_SHA,preparer_sha256=sha(Path(__file__)),source_file_count=541,stages=stages,seconds=time.monotonic()-start,python=platform.python_version(),environment_sha256=sha(work/'ENVIRONMENT.json'),scope='Four fresh native chains plus retained parent; no replica/outer admission yet.')) + print('PASS_PR2833_FRESH_NATIVE_PREPARATION',flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/tools/verify_package.py b/research/shared-kernel-packing/tools/verify_package.py new file mode 100644 index 0000000000..095b44a14a --- /dev/null +++ b/research/shared-kernel-packing/tools/verify_package.py @@ -0,0 +1,40 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Replay actual construction, complete owners/moments and fixed-model optimality.""" +import argparse,hashlib,json,os,subprocess,sys +from pathlib import Path +from fractions import Fraction as Q +sys.dont_write_bytecode=True +if hasattr(sys,'set_int_max_str_digits'):sys.set_int_max_str_digits(0) +def need(c,m): + if not c:raise ValueError(m) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def rd(p):return json.loads(p.read_bytes()) +def authenticate(root): + pins=rd(root/'MANIFEST.json');actual={} + for f in root.rglob('*'): + need(not f.is_symlink(),'package symlink') + if f.is_file()and f!=root/'MANIFEST.json':actual[f.relative_to(root).as_posix()]=sha(f) + need(actual==pins,'complete package inventory/hashes');return pins + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--hash-only',action='store_true');ap.add_argument('--work',type=Path);a=ap.parse_args();need(not sys.flags.optimize,'assertions required');root=Path(__file__).resolve().parents[1];pins=authenticate(root) + if a.hash_only:print(json.dumps(dict(status='PASS_COMPLETE_PACKAGE_HASHES',files=len(pins)+1)));return + need(a.work is not None,'fresh external --work required');work=a.work.resolve();need(not work.exists()and not work.is_relative_to(root)and not root.is_relative_to(work),'fresh disjoint work');work.mkdir(parents=True);base=root/'vendor/pr2857' + cmds=[('construct',[root/'reproduce_t185.py','--baseline',base,'--relay-plan',root/'RELAY-PLAN.json','--out',work/'constructed']),('owners',[root/'tools/audit_owners2857.py','--source-package',base,'--candidate',root/'data','--out',work/'OWNERS.json']),('moment',[root/'tools/audit_moment2857.py','--source',base,'--candidate',root/'data','--out',work/'MOMENT.json']),('separate-review',[root/'review/review_current.py','--package',base,'--candidate',root/'data','--claim',root/'CLAIM.json','--field','kappa','--out',work/'REVIEW.json']),('exact-optimality',[root/'review/profile_lp_certificate.py','--package',base,'--candidate-profile',root/'data/PROFILE.json','--out',work/'lp'])] + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0');stages=[] + for name,args in cmds: + log=work/(name+'.txt') + with log.open('w',encoding='utf-8',newline='\n')as out:proc=subprocess.run([sys.executable,'-B',*map(str,args)],env=env,cwd=work,stdout=out,stderr=subprocess.STDOUT) + need(proc.returncode==0,'failed '+name+'; inspect '+str(log));stages.append(dict(stage=name,exit_code=0,output_sha256=sha(log)));print('PASS',name,flush=True) + for name in ['FILL.json.gz','ORDER.json','DISPATCH.json','PROVIDERS.json','PROFILE.json']:need(sha(work/'constructed'/name)==sha(root/'data'/name),'byte-exact constructed '+name) + claim=rd(root/'CLAIM.json');admission=rd(root/'evidence/ADMISSION-RESULT.json');release=rd(root/'evidence/RELEASE-RECEIPT.json');native=rd(root/'evidence/NATIVE-RESULT.json');moment=rd(work/'MOMENT.json');lp=rd(work/'lp/RESULT.json') + need(admission['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE'and release['status']=='PASS_RELEASE','stored complete release statuses') + need(Q(claim['kappa'])==Q(admission['kappa'])==Q(release['kappa_decimal'])==Q(moment['target']),'exact verified headline binding') + need(sha(root/'evidence/RELEASE-RECEIPT.json')==admission['release_receipt_sha256']==claim['release_receipt_sha256'],'complete release receipt binding') + need(sha(root/'evidence/NATIVE-RECEIPT.json')==native['native_receipt_sha256'],'fresh shared-native binding') + need(claim['native_receipt_sha256']==admission['native_receipt_sha256']==native['native_receipt_sha256'],'headline native provenance binding') + need(lp['status']=='PASS_EXACT_CURRENT_INVENTORY_PRIMAL_DUAL_AND_ACTUAL_ATTAINMENT'and lp['pattern_count']==1163,'complete fixed-model optimality') + need(authenticate(root)==pins,'read-only package drift') + result=dict(status='PASS_T185_PACKAGE_CONSTRUCTION_OWNER_MOMENT_AND_OPTIMALITY',package_manifest_sha256=sha(root/'MANIFEST.json'),stages=stages,scope='Fresh exact construction and independent finite/LP checks; complete source/native/outer receipts authenticated. Fresh full replay is reproduce.py; inherited all-size hypotheses remain. Optimality applies only to fixed native words/inventory/capacities.') + (work/'RESULT.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n',encoding='utf-8',newline='\n');print(result['status']) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/validation/MOMENT-RECEIPT.json b/research/shared-kernel-packing/validation/MOMENT-RECEIPT.json new file mode 100644 index 0000000000..5470effe43 --- /dev/null +++ b/research/shared-kernel-packing/validation/MOMENT-RECEIPT.json @@ -0,0 +1,20 @@ +{ + "status": "PASS_EXACT_RATIONAL_MOMENT_VS_FULL_PR2857", + "lower": "215012600677110740993/125000000000000000000000", + "upper": "172010080541688592794401/100000000000000000000000000", + "claim": "17201008054168859279439999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "gain": "1044183013331743/250000000000000000000000", + "claim_decimal": "0.00172010080541688598", + "baseline_claim_sha256": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "profile_sha256": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672", + "new_moment_at_prior": [ + "6277101660580461564143484948440861437918834587050674619481/6277101735386680763835789423207666416102355444464034512896", + "3138550830290230782071742474220430718959417293525337309741/3138550867693340381917894711603833208051177722232017256448" + ], + "old_moment_at_prior": [ + "6277101735386680763835773649000790235125787288028243259297/6277101735386680763835789423207666416102355444464034512896", + "6277101735386680763835773649000790235125787288028243259299/6277101735386680763835789423207666416102355444464034512896" + ], + "method": "Exact 128-term atanh and 24-term exponential inclusions rounded outward to 2^-192; full incoming rational comparison.", + "scope": "Exact normalized paid-moment comparison. Native and outer release admission separate." +} diff --git a/research/shared-kernel-packing/validation/PORTABLE-REPLAY-RECEIPT.json b/research/shared-kernel-packing/validation/PORTABLE-REPLAY-RECEIPT.json new file mode 100644 index 0000000000..4b2bfe48bd --- /dev/null +++ b/research/shared-kernel-packing/validation/PORTABLE-REPLAY-RECEIPT.json @@ -0,0 +1,13 @@ +{ + "status": "PASS_PORTABLE_DETERMINISTIC_T185_REPRODUCTION", + "candidate_sha256": { + "FILL.json.gz": "1796e64d25f462683bf655992a212c9204cdb47f5d5100956161ecc3e6190f41", + "ORDER.json": "da0700f6bd28b2a97b386d1a7eeafe296e6666f4a8d3695af2e2a2d0612d914e", + "DISPATCH.json": "de25af2200715ce5327160e7734391e786bb0b85c7dcdc59d9db8e41ab52ec3f", + "PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "PROFILE.json": "ef36eda129e3463ce7fb76dedd953a16035924c201e38ee46dc79d56d4229672" + }, + "constructor_sha256": "6cb84e05e6dfe72f35dd09b3f85c093f913750104d799e31870144a1dcfc2c0e", + "relay_plan_sha256": "67462bcf89e0381b922aa1b130cc55db31dd6f77d563035f02e91acab3634c6b", + "scope": "Five complete output data files reproduced byte-for-byte from authenticated PR2857 inputs; full owner checks and four rejecting controls reran in the constructor. Native and outer admission are separate." +} diff --git a/research/shared-kernel-packing/vendor/pr2857/CLAIM.json b/research/shared-kernel-packing/vendor/pr2857/CLAIM.json new file mode 100644 index 0000000000..4667bf460a --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/CLAIM.json @@ -0,0 +1,50 @@ +{ + "calls": 333, + "derived_source_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "gain": "1438120379902596153/1000000000000000000000000", + "generated_package_manifest_sha256": "88a7ad8ce5cf4cec2633957215f5849459e7eb1087f3e7e1f1865bbe38d685ff", + "helper_roles": 135864, + "helper_widths": { + "4": 26, + "5": 2, + "7": 62, + "8": 84, + "9": 234 + }, + "kappa": "17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017200966286848326009719999999999999999999998999999999999999999999999", + "local_profile": { + "1": 2394, + "2": 642, + "3": 266, + "4": 128, + "5": 26, + "8": 8 + }, + "native_receipt_sha256": "5a7571fec09d1d0326a430540df3c19bb90d337dbdf602a63bde032c0da9b98d", + "primary_comparison": { + "gain": "1438120379902596153/1000000000000000000000000", + "head": "c50d12e4720cd1fef2b5a65e337e37de9731879a", + "pr": 2848 + }, + "provider_calls": { + "base": 125, + "extra": 208 + }, + "release_evidence": "evidence/full/candidate/release/RELEASE-RECEIPT.json", + "release_receipt_sha256": "c052decb90ceae345b398f111781f567fb787309a528877500cf7fe1cff13b3d", + "replicas": 37, + "scope": "Conditional finite supplier and modern outer release; unchanged inherited all-size/compiler/hosting/precision/tape/analytic obligations remain. Two changed providers run fresh; retained provider/parent proof explicitly reused by full-tree hashes.", + "secondary_comparison": { + "approx_gain": 7.189699872459419e-07, + "claim_sha256": "eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa", + "field": "kappa_rational", + "gain": "7189699872459419246615827392278185991042548574990569587539942495595928959576094075629078385983063650400003424201948266247923600171338928575471866883795891334423521795338535080382401656414515475297025982710190359391689059992403495452686828582357709232440249149672963556236041050723298684385915817417449217705385073145833321366481834904425363262086388277060576458834487330051420123305137059179205677318395952964350749396627325186506122864263229477305890867900841422512149140310616381583896986380573136991988405796041170226076081690532164214595205463319682197469561285276245917780703258673321936645454308733802343795514953059992805396235772113157342387297422742421097475941428317704173074317340082269694285184507473985003475180269741189839472921497904173465107437611568251598211830549290124106996746202512863157520875898830570894349239603302420825373319627797702543534380125158663478190413347597219888009613829827731626618157906706211989401620644315146109394751787258425715988485402242350781648255868925790279096436111257453481811020106093076840760381071476443244027402799472212513790113884546643511903086639310852161627260562673732027874207808079081174463327575486182860044450915169366870555864346156800137051690759468033008812059850619771713471985897237223844424552196447632994994465482645547300181042498740278627879457171042245722157324591147473041097794508520855143063613445481313297138037348119414575080415504525065215107960743710791777056616058472907429431602780660294720287570294573048177705995922097707217381181886097305547549708540060153571280838342848582791950064711314352305401994658064501488847081053752160040731329682450427587522306848026164750958321832171183172313246930191281326155839107184163897623242324963328981882933221566460260043336755861150201070299077615353824821249637769963793904591798784685748010489538196403328294367101757099214406024993482359244986132338450501698568318389206930329146685614223279773016403313273558629122554912175279404746427984360734735058898328595159640039918619156266091951993980877845424594843423904413154022805679242435642413749641590037256571435337964457390354992042520804801385366866375473383018642084250750877331668028309577710100527378552646744286161242932444044048230615482982854868459601872387735992298097909513338347119321588960759847578745040876817413849897043779584950767543895448564146277294667621883810866803105375526835035838098721535011955187709169712874792728677303643413182690345742458350457206548949236257000387340638184257405123125634380278802891605263939959334688659055419461035018741653126475632920705352790184221569032092926099142413569639127028526066387118245241503563673647999297742661103274184416241295606247743751395286327320778923120523916930363312378469495818977657875419381016680284091605307629204826370832779055204920797952564322222252163701419880833695731670320700306852666150897548924069204570864843045801665567645977324958861110130871980201306710823067625186023033001954002269744349148000615184917666691457424694260310000000000000000000001000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "head": "d01045dfb67428679618027dff552f1d032fa999", + "pr": 2853 + }, + "selected_frontier_changed": false, + "source_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "status": "PASS_CONDITIONAL_FINITE_SHARED_KERNEL_RELEASE", + "wrapper_sha256": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/DISPATCH.json b/research/shared-kernel-packing/vendor/pr2857/DISPATCH.json new file mode 100644 index 0000000000..2c48b2e02c --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/DISPATCH.json @@ -0,0 +1 @@ +[[0,0,"extra"],[0,1,"extra"],[0,2,"extra"],[0,3,"extra"],[0,4,"extra"],[1,0,"extra"],[0,5,"extra"],[1,1,"extra"],[0,6,"extra"],[1,2,"extra"],[0,7,"extra"],[1,3,"extra"],[0,8,"extra"],[1,4,"extra"],[0,9,"extra"],[2,0,"extra"],[1,5,"extra"],[0,10,"extra"],[2,1,"extra"],[1,6,"extra"],[0,11,"extra"],[2,2,"extra"],[1,7,"extra"],[0,12,"extra"],[2,3,"extra"],[1,8,"extra"],[0,13,"extra"],[2,4,"extra"],[1,9,"extra"],[3,0,"extra"],[0,14,"extra"],[2,5,"extra"],[1,10,"extra"],[3,1,"extra"],[0,15,"extra"],[2,6,"extra"],[1,11,"extra"],[3,2,"extra"],[0,16,"extra"],[2,7,"extra"],[1,12,"extra"],[3,3,"extra"],[0,17,"extra"],[2,8,"extra"],[1,13,"extra"],[3,4,"extra"],[0,18,"extra"],[2,9,"extra"],[4,0,"extra"],[1,14,"extra"],[3,5,"extra"],[0,19,"extra"],[2,10,"extra"],[4,1,"extra"],[1,15,"extra"],[3,6,"extra"],[0,20,"extra"],[2,11,"extra"],[4,2,"extra"],[1,16,"extra"],[3,7,"extra"],[0,21,"extra"],[2,12,"extra"],[4,3,"extra"],[1,17,"extra"],[3,8,"extra"],[0,22,"extra"],[2,13,"extra"],[4,4,"extra"],[1,18,"extra"],[3,9,"extra"],[0,23,"extra"],[5,0,"extra"],[2,14,"extra"],[4,5,"extra"],[1,19,"extra"],[3,10,"extra"],[0,24,"extra"],[5,1,"extra"],[2,15,"extra"],[4,6,"extra"],[1,20,"extra"],[3,11,"extra"],[0,25,"extra"],[5,2,"extra"],[2,16,"extra"],[4,7,"extra"],[1,21,"extra"],[3,12,"extra"],[0,26,"extra"],[5,3,"extra"],[2,17,"extra"],[4,8,"extra"],[1,22,"extra"],[3,13,"extra"],[0,27,"extra"],[5,4,"extra"],[2,18,"extra"],[4,9,"extra"],[1,23,"extra"],[6,0,"extra"],[3,14,"extra"],[0,28,"extra"],[5,5,"extra"],[2,19,"extra"],[4,10,"extra"],[1,24,"extra"],[6,1,"extra"],[3,15,"extra"],[0,29,"extra"],[5,6,"extra"],[2,20,"extra"],[4,11,"extra"],[1,25,"extra"],[6,2,"extra"],[3,16,"extra"],[0,30,"extra"],[5,7,"extra"],[2,21,"extra"],[4,12,"extra"],[1,26,"extra"],[6,3,"extra"],[3,17,"extra"],[0,31,"extra"],[5,8,"extra"],[2,22,"extra"],[4,13,"extra"],[1,27,"extra"],[6,4,"extra"],[3,18,"extra"],[0,32,"extra"],[5,9,"extra"],[2,23,"extra"],[7,0,"extra"],[4,14,"extra"],[1,28,"extra"],[6,5,"extra"],[3,19,"extra"],[0,33,"extra"],[5,10,"extra"],[2,24,"extra"],[7,1,"extra"],[4,15,"extra"],[1,29,"extra"],[6,6,"extra"],[3,20,"extra"],[0,34,"extra"],[5,11,"extra"],[2,25,"extra"],[7,2,"extra"],[4,16,"extra"],[1,30,"extra"],[6,7,"extra"],[3,21,"extra"],[0,35,"extra"],[5,12,"extra"],[2,26,"extra"],[7,3,"extra"],[4,17,"extra"],[1,31,"extra"],[6,8,"extra"],[3,22,"extra"],[0,36,"extra"],[5,13,"extra"],[2,27,"extra"],[7,4,"extra"],[4,18,"extra"],[1,32,"extra"],[6,9,"extra"],[3,23,"extra"],[8,0,"extra"],[5,14,"extra"],[2,28,"extra"],[7,5,"extra"],[4,19,"extra"],[1,33,"extra"],[6,10,"extra"],[3,24,"extra"],[8,1,"extra"],[5,15,"extra"],[2,29,"extra"],[7,6,"extra"],[4,20,"extra"],[1,34,"extra"],[6,11,"extra"],[3,25,"extra"],[8,2,"extra"],[5,16,"extra"],[2,30,"extra"],[7,7,"extra"],[4,21,"extra"],[1,35,"extra"],[6,12,"extra"],[3,26,"extra"],[8,3,"extra"],[5,17,"extra"],[2,31,"extra"],[7,8,"extra"],[4,22,"extra"],[1,36,"extra"],[6,13,"extra"],[3,27,"extra"],[8,4,"extra"],[5,18,"extra"],[2,32,"extra"],[7,9,"extra"],[4,23,"extra"],[6,14,"extra"],[3,28,"gauge44"],[8,5,"gauge44"],[5,19,"gauge44"],[2,33,"gauge44"],[7,10,"gauge44"],[4,24,"gauge44"],[6,15,"gauge44"],[3,29,"gauge44"],[8,6,"gauge44"],[5,20,"gauge44"],[2,34,"gauge44"],[7,11,"gauge44"],[4,25,"gauge44"],[6,16,"gauge44"],[3,30,"gauge44"],[8,7,"gauge44"],[5,21,"gauge44"],[2,35,"gauge44"],[7,12,"gauge44"],[4,26,"gauge44"],[6,17,"gauge44"],[3,31,"gauge44"],[8,8,"gauge44"],[5,22,"gauge44"],[2,36,"gauge44"],[7,13,"gauge44"],[4,27,"gauge44"],[6,18,"gauge44"],[3,32,"gauge44"],[8,9,"gauge44"],[5,23,"gauge44"],[7,14,"gauge44"],[4,28,"gauge44"],[6,19,"gauge44"],[3,33,"gauge44"],[8,10,"gauge44"],[5,24,"gauge44"],[7,15,"gauge44"],[4,29,"gauge44"],[6,20,"gauge44"],[3,34,"gauge44"],[8,11,"gauge44"],[5,25,"gauge44"],[7,16,"gauge44"],[4,30,"gauge44"],[6,21,"gauge44"],[3,35,"gauge44"],[8,12,"gauge44"],[5,26,"gauge44"],[7,17,"gauge44"],[4,31,"gauge44"],[6,22,"gauge44"],[3,36,"gauge44"],[8,13,"gauge44"],[5,27,"gauge44"],[7,18,"gauge44"],[4,32,"gauge44"],[6,23,"gauge44"],[8,14,"gauge44"],[5,28,"gauge44"],[7,19,"gauge44"],[4,33,"gauge44"],[6,24,"gauge44"],[8,15,"gauge44"],[5,29,"gauge44"],[7,20,"gauge44"],[4,34,"gauge44"],[6,25,"gauge44"],[8,16,"gauge44"],[5,30,"gauge44"],[7,21,"gauge44"],[4,35,"gauge44"],[6,26,"gauge44"],[8,17,"gauge44"],[5,31,"gauge44"],[7,22,"gauge44"],[4,36,"gauge44"],[6,27,"gauge44"],[8,18,"gauge44"],[5,32,"gauge44"],[7,23,"gauge44"],[6,28,"gauge44"],[8,19,"gauge44"],[5,33,"gauge44"],[7,24,"gauge44"],[6,29,"gauge44"],[8,20,"gauge44"],[5,34,"gauge44"],[7,25,"gauge44"],[6,30,"gauge44"],[8,21,"gauge44"],[5,35,"gauge44"],[7,26,"gauge44"],[6,31,"gauge44"],[8,22,"gauge44"],[5,36,"gauge44"],[7,27,"gauge44"],[6,32,"gauge44"],[8,23,"gauge44"],[7,28,"gauge44"],[6,33,"gauge44"],[8,24,"gauge44"],[7,29,"gauge44"],[6,34,"gauge44"],[8,25,"gauge44"],[7,30,"gauge44"],[6,35,"gauge44"],[8,26,"gauge44"],[7,31,"gauge44"],[6,36,"gauge44"],[8,27,"gauge44"],[7,32,"gauge44"],[8,28,"gauge44"],[7,33,"gauge44"],[8,29,"gauge44"],[7,34,"gauge44"],[8,30,"gauge44"],[7,35,"gauge44"],[8,31,"gauge44"],[7,36,"gauge44"],[8,32,"gauge44"],[8,33,"gauge44"],[8,34,"gauge44"],[8,35,"gauge44"],[8,36,"gauge44"]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/FILL.json.gz b/research/shared-kernel-packing/vendor/pr2857/FILL.json.gz new file mode 100644 index 0000000000..9abdc1370a Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/FILL.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/LOCAL-PINS.json b/research/shared-kernel-packing/vendor/pr2857/LOCAL-PINS.json new file mode 100644 index 0000000000..17f70edcdb --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/LOCAL-PINS.json @@ -0,0 +1,278 @@ +{ + "CLAIM.json": "c2a04b639c86f462caef654a29817545c57b8e5ba809e37d4d476d3577f5cd6f", + "DISPATCH.json": "5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4", + "FILL.json.gz": "82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501", + "NOTICE": "63e39c215eecec07f0eae6fd76ef69ec886ecefa0175e80f0526c9af83dc5f9b", + "ORDER.json": "84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc", + "PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "PROOF.md": "0b6208bf6de980daae1879cf3b22f0464cb12938ec91d0c7af61b8e18413649d", + "PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2", + "admit_shared_replica.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "allocation/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "allocation/MANIFEST.json": "d18c89aa44bec5b1f2afc5ca3990e5e8132761e7abfab368e02f700a2e04e852", + "allocation/NOTICE": "642e6acf32c22212f8c249e0ef36f65f7e28bd90eff75cb9b03b3fbcb79d94bf", + "allocation/PINS.json": "d6defca921082408338cae3c90ac8466d8a252fb6f3a7e12d6724003732a206e", + "allocation/README.md": "93e16cb95c3daf10c2bffa43a818230f7af4c2a14c05ea0099aca872c6ffc6fa", + "allocation/construction/COMPRESSION-CONTROLS.json": "225083da80b8d0b2195abea932b73fab989e4b14fe3075cc1c76d25552d81d2b", + "allocation/construction/DISCOVERY.log": "e73d6bc740664c1b7b999afd03a96d36d2550a4b90c4ef2998ed8bae78e85337", + "allocation/construction/FLOW.json.gz": "432f6e7ea0af6208a5a30323dcda936abfa6689c13cc136a5f0c25b0c498368e", + "allocation/construction/MODEL.json": "25c2caab5b6ad85f9977639049b5e4679b6c635d800df43b35b3e580d915365c", + "allocation/construction/NEGATIVE-CONTROLS.json": "d1cee69137cf7cf3239b5265f4538bd0e3547650ae5862f5a3579dd3fc16d4eb", + "allocation/construction/PR2843-INDEPENDENT-NOTICE": "b1a13e97bf3503b4a52033518dd528d010f57be7b591245bf48910c20320d186", + "allocation/construction/PR2843-build_allocation.py": "c8281fef278ff84bc6ff698699cb662f63e150e8f797dba07137103e9d81af71", + "allocation/construction/REPLAY-CHECK.json": "8eda15bd557c2dcd153187dd39551e44e4c9f6fcc3b29aa3ede0638c184fe5d9", + "allocation/construction/SOLVER.json": "62da09c8cd9a5ed3819e0e222cba83529c049e6e86e182940de2cb434f83f8b1", + "allocation/construction/check_compression_policy.py": "810c35176d252db60f01725fe20b71330e5d6f702c4e991cc5552f1e3d53bbb9", + "allocation/construction/discover_original.py": "c0aebddeb7271b8dc62cf9ac94b85c40c90f4ec938fc23a9d03c61888232614c", + "allocation/replay_allocation.py": "f53a7f44b471dfb9d13ff3e8bdf06f87e402a31e2753118fafb4a27863da337f", + "audit_owners.py": "18545051734238fe82690c15e4dd84d716e17372952b67c506248b1aafb5f86c", + "audit_relaxation.py": "0e489823b37303ba383648e3fd21aca1b497abc74c297b5b131a3e4684cf5302", + "build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "check_ceiling.py": "5bcd91806d1b47c085c17e52de36939d7761f77c0e0af2c5e5ac4263c5fe0580", + "check_four_kernels.py": "34ded7db6524ca4e7229c887c24ad7a5ce2531007f7c1ebfc4dd9af952406614", + "check_release_evidence.py": "e996f252cc4dd23b02ad623dfdca1a6cb62799a1f390f92fb9eaaa5fc89558e7", + "evidence/full/ACTUAL-CONTROLS.json": "9f9a32307cf0fd48051384851cfde83e993fa7ade222e29df643dfbb3a3ea17f", + "evidence/full/CEILING-REALIZED.json": "6c6e3078c63917f316bdf2a12900e07627b8d5d8b4983e5daf1bf9b407697554", + "evidence/full/COMPLETE.json": "5e8748de7160449c292336ca9691ff75d006d64765fa37615850455e667405e2", + "evidence/full/INVENTORY-RELAXATION.json": "6d9c1c117704c7b3e9f6da6c7b56745c53f01a625da5c9cdac52a85b2fccb1b4", + "evidence/full/LOCAL-CEILING.json": "891c46cb4bdb98b343d904663a83c4909dbfa94143317107b1e0febad91f75e7", + "evidence/full/MANIFEST.json": "ef7b8983700d51fce63869121cb0cad28f930bd0a8901ebfce57b1d714aee0fe", + "evidence/full/candidate/RESULT.json": "48b4d851c64ab6f406178a5903f714561ac3fd66c27e2d29447e64cb8732acb4", + "evidence/full/candidate/RUNTIME-PATCHES.json": "8f0926f99d79f389918a0491fe09b32273e5f31d363d7208026661ec82f6f691", + "evidence/full/candidate/STAGES.json": "27092127ebbb612df6011bcbad27a59589e42aa7850608e549ef4770c79db842", + "evidence/full/candidate/admitted-package/CLAIM.json": "1c101dc2d56d4424c5c7972b87186665469efdefb3680def14df7b0f8fbdb04b", + "evidence/full/candidate/admitted-package/MANIFEST.json": "88a7ad8ce5cf4cec2633957215f5849459e7eb1087f3e7e1f1865bbe38d685ff", + "evidence/full/candidate/admitted-package/new/PROFILE.json": "46b03bac794130baa3c14fa2fe463db61faf16f92e15ff8ca4946d90c1e05eeb", + "evidence/full/candidate/admitted-package/new/SPEC.json": "0670a30540d020444b2ac2292b7ef5dd0b7d86b62512d3a7658915d7cd03a350", + "evidence/full/candidate/discovery.log": "2a3d3dd0eba4b8c4ebdcdec46ccf239db633ed0ef584066508d44ad5c855928f", + "evidence/full/candidate/outer-check_ledger.py.log": "5f160f2b35c61257aa5215401e98acff3caeea433117aa3c96f552abe19b9a40", + "evidence/full/candidate/outer-independent_check.py.log": "ff78246d25781b0ba71810f0af01ead1b4a68aac6dda93300ee37555672d846f", + "evidence/full/candidate/outer/B.json": "1602c6b44570f3283959bc029f219cedce1bdb710f6c23393a03ae55a2db14c3", + "evidence/full/candidate/outer/INDEPENDENT.json": "ff78246d25781b0ba71810f0af01ead1b4a68aac6dda93300ee37555672d846f", + "evidence/full/candidate/outer/LEDGER.json": "3bf9f615a8dab6b87bbdf500b83678a7bcef5b0174bb19604d74b51fd33e5215", + "evidence/full/candidate/outer/OUTER-CLAIM.json": "d8b0dd1fc712d9f4e6f0fe09dd53e996929f6d9b67c63dce8c15a011c04bf3f1", + "evidence/full/candidate/owners.log": "c428a9572a1f42f227c5d7f1bf9660bab5c2384466536043640504c46aadb6b6", + "evidence/full/candidate/owners/PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "evidence/full/candidate/owners/RESULT.json": "6cdeb13316f78a46370eb93bdc753572c14461b6c2a70f0f2d0cedbbf3611f44", + "evidence/full/candidate/parent-data/PARENT-LIFT-RECEIPT.json": "b57ca93089c99c26df1286ea47f702acb99f526ad234f991c752ddc7a1577fc1", + "evidence/full/candidate/parent-lift.log": "ea74ad55229acb8d6979bf7307e2875049dbb18bc4a9309719cb7011cc36dcec", + "evidence/full/candidate/rebind.log": "0b1693d2c13addcf8b2e3004887ca35bbf20cba5e4f3497f38643740fc6fe7a7", + "evidence/full/candidate/release.log": "e980a17f9cd3ea9669474df93714a80a0d3a573426641efb379dba0d1915e6cc", + "evidence/full/candidate/release/RELEASE-RECEIPT.json": "c052decb90ceae345b398f111781f567fb787309a528877500cf7fe1cff13b3d", + "evidence/full/candidate/release/outer.log": "3a94231dc52ee45eb742d818bbc6969a8cd26d8f33bfe8f4917f199c409258cb", + "evidence/full/candidate/release/verify.log": "52822bb9b8c3534efc633567c2af78c5484bcb9f2b6ed75520a41b8dcd878dbb", + "evidence/full/candidate/release/verify/AUDIT-LOCAL-566-base.json": "cf7a5e44d25eaa52fe1ff1814929008eed08133207c9a1550c27a20666de776c", + "evidence/full/candidate/release/verify/AUDIT-LOCAL-566-extra.json": "aa9519b141396a28c6a717c0c6b870049c23524f5b5830b8aca10f71ccbb349b", + "evidence/full/candidate/release/verify/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/full/candidate/release/verify/LEMMAG-LABELS.json": "2d20be1a35ce5533560005ae4e02f286ac957bc9827494d72e995b5f57deb215", + "evidence/full/candidate/release/verify/RESULT.json": "1c165d588ef574ca102f5f74f86fdf08c50db775f29b8968a0390ac6b5661f3d", + "evidence/full/candidate/release/verify/STAGES.json": "be3beb968a0fdf2b56aa2d0c4489f714eb9fd52dc73df7ebaa10d01f43fd374a", + "evidence/full/candidate/release/verify/audit-local-566-base.log": "3ae12c434638976b7809a086fb5c275619cc35f4e323bf17d1ed45f06d955f3e", + "evidence/full/candidate/release/verify/audit-local-566-extra.log": "afc379b6e05c39464b20eb8a095b870333576bdd0f7c0d05adbcb7d25ae5cb1d", + "evidence/full/candidate/release/verify/borrow-receipts/ALIAS-ENUMERATION-43base.json": "7e539045b689ba62dd73c409905e11b56f330d88542f1e6c119f64fe16a11ca4", + "evidence/full/candidate/release/verify/borrow-receipts/ALIAS-ENUMERATION-43extra.json": "7e539045b689ba62dd73c409905e11b56f330d88542f1e6c119f64fe16a11ca4", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43base-pinned.json": "f7d031153290c9701c8f223103d86e071167a0db1eb8af934ab7315250b4dd2a", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43base-prekernel.json": "508b463b31b33f4ad909b9418dd0ad244b0b0642359cd723e168e9b22b8466e8", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43base.json": "9e746488284367d50eabc697307d4d75ee7d0e348b5b974893ba35673b662fd3", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43extra-pinned.json": "e234f9f88948af5fc123b8c19683b8e24f7d72b901bfb35423cc68287d64ab11", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43extra-prekernel.json": "6ebbf8c8dd75b4492568a188b132385823fb22f6863dea2d3db63794004ef7f8", + "evidence/full/candidate/release/verify/borrow-receipts/AUDIT-43extra.json": "6a256e55cf7dbf6425b1a9f4a9ef11803e1909213043ee9ad549c1911839c058", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-43base.json": "5ffa81adddbe817010350b0d9254b02e2dabc63160bb8e40555570b8cc94cdc8", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-43extra.json": "e0ed3dc429eb09874ed7e5e82d428aa3dccea8bc62506c48609c960aa7b053dc", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-ALIAS1-43base.json": "921c3e5716beb84e710ccb445e9ee8d5d5e6388382e422babd4a9dd15c06ff08", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-ALIAS1-43extra.json": "921c3e5716beb84e710ccb445e9ee8d5d5e6388382e422babd4a9dd15c06ff08", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-KERNEL-43base.json": "62b9385f2a5ca917641f5511627def546fd74a080154586a7ea2e850eaec3a80", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-KERNEL-43extra.json": "62b9385f2a5ca917641f5511627def546fd74a080154586a7ea2e850eaec3a80", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-LOWFOUR-43base.json": "d2276cd9b463eb9700705ba773705c791469e160664e25f435f15598c22a9dac", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-LOWFOUR-43extra.json": "d2276cd9b463eb9700705ba773705c791469e160664e25f435f15598c22a9dac", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-PRELIFE-43base.json": "7924504ccb3ec857468fc1bdc2e51c89926c3b19ec8ed64adb36540d713310e1", + "evidence/full/candidate/release/verify/borrow-receipts/CONTROLS-PRELIFE-43extra.json": "7924504ccb3ec857468fc1bdc2e51c89926c3b19ec8ed64adb36540d713310e1", + "evidence/full/candidate/release/verify/fine-engine-oracle.log": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "evidence/full/candidate/release/verify/geometry-controls.log": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "evidence/full/candidate/release/verify/lemmag-labels.log": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469", + "evidence/full/candidate/release/verify/lift-parent.log": "ea74ad55229acb8d6979bf7307e2875049dbb18bc4a9309719cb7011cc36dcec", + "evidence/full/candidate/release/verify/rebind-566.log": "0b1693d2c13addcf8b2e3004887ca35bbf20cba5e4f3497f38643740fc6fe7a7", + "evidence/full/candidate/release/verify/rebuild-borrow-words.log": "7b1a745ff5564ce0290a39d8aa7c91760dab7ae8335eb7e9f1c7d71c842ff492", + "evidence/full/candidate/release/verify/rebuild-words-566.log": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "evidence/full/candidate/release/verify/reconstruct-owners.log": "c428a9572a1f42f227c5d7f1bf9660bab5c2384466536043640504c46aadb6b6", + "evidence/full/candidate/release/verify/shared-kernel-independent-review.log": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/FOUR-GROUP-INDEPENDENT-REVIEW.json": "7aca0b7bf52d639a28d619d6bc1a5b5bc92588355a7ee985bb07b896d5c8bce3", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/POSITIVE-AUDIT-base.json": "7812533fbb119f9160dcbe327d044cf508484f647b2815c60f1657c92a6b4188", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/POSITIVE-AUDIT-base.log": "b91d7a8cfc43166165eec04e352ca4e3612ccd42f7954e54f0f9c3ee05ddcf5c", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/POSITIVE-AUDIT-extra.json": "d085c41cf2070b47653727ef8d7378ffce3ddb5d8f493ed5c86b2c9ddb0f5d7a", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/POSITIVE-AUDIT-extra.log": "cdc315a436d621c5013008a7c165fe774b80b41c7f99594ee054b7e6395e6093", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-drop_primary_A_injection.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-missing_compensation_regeneration.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-missing_raw_dirt_reconstruction.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-stale_cleanup.log": "affed680052e51bcb4e849f9e38647b90d0d89010522ce3a7078a86c5dc87ee3", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-suppressed_compensation_without_transport.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-wrong_compensation_sign.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-wrong_kernel_sign.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-base-wrong_start_extra.log": "efd3758ddcde6086b323b162f92089d7a1c2689120de868c735e63848464e144", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-drop_primary_A_injection.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-missing_compensation_regeneration.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-missing_raw_dirt_reconstruction.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-stale_cleanup.log": "affed680052e51bcb4e849f9e38647b90d0d89010522ce3a7078a86c5dc87ee3", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-suppressed_compensation_without_transport.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-wrong_compensation_sign.log": "ba33685abf50806357e186fa35b350448faf252310e890bacad085aec66dd180", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-wrong_kernel_sign.log": "9fe6b9e33d096efe7369bec6245b1a1f6453ca6ec7347099dc73070dd8df9c25", + "evidence/full/candidate/release/verify/shared-kernel-independent-review/control-extra-wrong_start_extra.log": "efd3758ddcde6086b323b162f92089d7a1c2689120de868c735e63848464e144", + "evidence/full/candidate/release/verify/strict-t74.log": "d0964f1b24a731ee8e1a12fe3819ccf1d0fabb043c66baa004b880d2bf5cff8d", + "evidence/full/candidate/release/verify/strict/ADMISSION-CONTROLS.json": "66dcad6fe36f869facad07cb9785073ea1932804275243557a62aa3f6a22bb7c", + "evidence/full/candidate/release/verify/strict/ASSEMBLY.json": "b4caa035c35d94b09cd350db581fe409c88eacebc779746a713c1d30a1612bdc", + "evidence/full/candidate/release/verify/strict/BIT-CONTROLS.json": "e0adc5d7f3eae3eaf9240f80710b08aabb64383399aa55bf3aa63a3f8950229c", + "evidence/full/candidate/release/verify/strict/INDEPENDENT.json": "dada1a16bfde4fafe235cee1fe5c9c2c1e415a777b3882d2547194fd784926a6", + "evidence/full/candidate/release/verify/strict/RESULT.json": "2559c05f5c366c299a0318611844cc7cd15feeec47831f5a13a95b64425a9c43", + "evidence/full/candidate/release/verify/strict/STAGES.json": "cdb1dcb621d0c871b60a538a88c37ffa96559eb20b69cdeaa571403f410c2ae0", + "evidence/full/candidate/release/verify/strict/admission.log": "ed18dce7229c1bdb4a487dad40c1f457e49127f6c92ad3f9ddc1978471e96996", + "evidence/full/candidate/release/verify/strict/assembly.log": "5896c397dae627a2e9e994b5abccb30b30b34b343a9a84ae07e0b4435751075e", + "evidence/full/candidate/release/verify/strict/audit.log": "5b33d085ace0bdb72755b36baf40537152cf3e8ebf36144b4f8cc643554305a4", + "evidence/full/candidate/release/verify/strict/bind.log": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "evidence/full/candidate/release/verify/strict/bit.log": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "evidence/full/candidate/release/verify/strict/emit.log": "1fa7a9237439bcf04710fa1b1101001c4c39debd27f76fdeabdfbd797e2c85d4", + "evidence/full/candidate/release/verify/strict/global/audit/ASYNC-AUDIT.json": "5b33d085ace0bdb72755b36baf40537152cf3e8ebf36144b4f8cc643554305a4", + "evidence/full/candidate/release/verify/strict/global/audit/GLOBAL-PREFIX.json": "43d4c35d8278d9c58a65869fd2e49718fe33c2193cc9c552bdc0b400d12f8554", + "evidence/full/candidate/release/verify/strict/global/audit/IDLE-REMAINDER-FRAMES.json": "9bc5d4bf2ff4687ff6be14e0fb223ee1244c0fbb10e727fe4a0a8fca41ccdb13", + "evidence/full/candidate/release/verify/strict/global/audit/OWNERS-AND-PROFILE.json": "09606f7a3b4ef4e72fb71650743d6218f293f3e66d0561edf4cf1849b47a4cc9", + "evidence/full/candidate/release/verify/strict/global/audit/PREFIX-AND-INVOICE.json": "6884788a08d15a5f69ce31ee1f0f9cf65dc4b09f7ec60175cfdde835179ff155", + "evidence/full/candidate/release/verify/strict/independent.log": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "evidence/full/candidate/release/verify/strict/invoice.log": "a264c44dc692e071d8064806dbfd6eb2fc136428b79b1bec70430b8477c59aa5", + "evidence/full/experimental-failure/CORRECTED-MUTANTS-PREFLIGHT.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/full/experimental-failure/EXPLANATION.json": "f36f275d77622aa5ef7a44d12daca2feaecddacb9d9525951bec4f9e55c7d17f", + "evidence/full/experimental-failure/STAGES.json": "f9daa6c70045017b3fe216479c32d67516e8ca3fc0a9ae847dfca24803659868", + "evidence/full/experimental-failure/candidate/RESULT.json": "efa6f45346cb09c85c9c024b0635e99354e7a9c1bb686482efd9704591ff8cc1", + "evidence/full/experimental-failure/candidate/STAGES.json": "dc4eb90e0610903685985ba13a243b70c667370414d7a11e0a35b3c5178e0358", + "evidence/full/experimental-failure/candidate/release.log": "ee72649fbe83aafa81e4489656a21cbbcf38d4264aa438c990cd231f1da3f261", + "evidence/full/experimental-failure/candidate/release/verify.log": "ca04ea96bcb4707eee0a4591e3a058c9b9087dc3176e4aee56f7a6273710ff3d", + "evidence/full/experimental-failure/candidate/release/verify/geometry-controls.log": "70e7e4494cfe911c168f1cb5b4eed5405454eea42043471ba95294ca6fa66028", + "evidence/full/experimental-failure/candidate/release/verify/strict/RESULT.json": "b0283753c7825cc8dde496e9aeca9f4429f73461816a73550d389af422612a3c", + "evidence/full/experimental-failure/complete-admission.log": "ebe9007597816467588148f4d21d262a97c1277c675e2ffcea2b968eee88278f", + "evidence/full/experimental-failure/scripts/admit_shared_replica.py": "a8781eb619ba7584b5e193de0e9d766c245f7fcd3bfb6a799ebc92aff2d5e329", + "evidence/full/experimental-failure/scripts/reproduce.py": "61207eba2ea62ed096bc1cb5187343cd7e782172e5208578999f67dcf352697e", + "evidence/full/native/ENVIRONMENT.json": "322a9f8bb0db0885613f39632bf411aa4cb3f58eb0ba2050e369a52b36a9c3c7", + "evidence/full/native/NATIVE-CACHE.tar.gz": "c5cfe104e5fdec6f5fff8429a134466580323d3c0b1e907f27b0ec8e44dfc5f1", + "evidence/full/native/NATIVE-RECEIPT.json": "5a7571fec09d1d0326a430540df3c19bb90d337dbdf602a63bde032c0da9b98d", + "evidence/full/native/RESULT.json": "cdc055b9a482d0d3b7e6ee96ddc481b36af02c42621198ed95385f108b50c082", + "evidence/full/native/STAGES.json": "72b5a71f5983ed94a42647ddd107a4daeb3a1b8cd3c7e43cbade59fd437c4c28", + "evidence/full/native/base/INDEPENDENT-LOCAL-REPLAY.json": "240361290b8abb9621cfa847e8b7d440b2ef3b2d743ed5f7477114105bf68b71", + "evidence/full/native/base/LOCAL-CHECKS.json": "9f8c0bebcc0cff992859aef70f1d9bb927a721fd0233eca23476daa86e16e2a9", + "evidence/full/native/base/SCALAR-FRAME-AUDIT.json": "1785896c02a0383f0287755f3def7729200256fad04762101b3d762921898e60", + "evidence/full/native/base/WARP-RECIPE-CHECKS.json": "52bf0e60183e83d21fee17b20c08e532dc4325e487be421782db7d217984db0d", + "evidence/full/native/base/WRAPPER-CHECKS.json": "b4f425e69bdf22df071e9e0372fef4de4c07512a75a678cf3010cfb53e3d5f7e", + "evidence/full/native/extra/INDEPENDENT-LOCAL-REPLAY.json": "3420e7bcd0a0fa99098a1e6e88ec31d7844f0c3cf4bfc48d4eee4b77c7aa7683", + "evidence/full/native/extra/LOCAL-CHECKS.json": "9f8c0bebcc0cff992859aef70f1d9bb927a721fd0233eca23476daa86e16e2a9", + "evidence/full/native/extra/SCALAR-FRAME-AUDIT.json": "0c7fadecbb8540d4e8c63197d0926835e344c1125671a41da529e6ed810e5d55", + "evidence/full/native/extra/WARP-RECIPE-CHECKS.json": "ff3172997afe4cb9d42e6dc6b14ff3acd9ce66562ee4e147103844af6819f0ef", + "evidence/full/native/extra/WRAPPER-CHECKS.json": "b4f425e69bdf22df071e9e0372fef4de4c07512a75a678cf3010cfb53e3d5f7e", + "evidence/full/native/fresh-base/COMMANDS.json": "eeed5c64a5974589c49b1f1bdeaa83f7c77253d4dc3ab9aaad60b42a2d91cf1c", + "evidence/full/native/fresh-base/RESULT.json": "5f4e275b02df2cc5964c5b4faccb23c56ff86446711a7816090cc79c4bee15e3", + "evidence/full/native/fresh-base/ledgers-bw_emit.py.log": "64f75712f6126f8132a35c4ed83aba3277e73df6c34ef32f4f36b81b91496cba", + "evidence/full/native/fresh-base/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "evidence/full/native/fresh-base/native-bw_transport.py.log": "e242d58633973f4540c2b18097255c38aa4832be2dbd11bbb5b27aa7a54a1a44", + "evidence/full/native/fresh-base/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "evidence/full/native/fresh-base/phases-bw_phases.py.log": "4f6d4cb04af2a3c95e0f1e425a502b2406c0aecf013ef98cfee506a3e65a948b", + "evidence/full/native/fresh-base/wrappers-bw_adapters.py.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "evidence/full/native/fresh-extra/COMMANDS.json": "2dace75bf059896a5e41f07b929cd706cef31f70aec43b3f222f63a20e8e846f", + "evidence/full/native/fresh-extra/RESULT.json": "b0c11ddd8442afdde711f975d651cf210b18700acf48f9e577682692234ab1df", + "evidence/full/native/fresh-extra/ledgers-bw_emit.py.log": "64f75712f6126f8132a35c4ed83aba3277e73df6c34ef32f4f36b81b91496cba", + "evidence/full/native/fresh-extra/local-replay-bw_audit_local.py.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "evidence/full/native/fresh-extra/native-bw_transport.py.log": "b7599f5970a48ce37edaca99290a6db6d948d4ad4ca196ef51debd71286fcb79", + "evidence/full/native/fresh-extra/phases-bw_check_recipes.py.log": "985f91e7b90482d89b062b43dbe9c3885521fe26e4f8600c3b7757c33d3181ed", + "evidence/full/native/fresh-extra/phases-bw_phases.py.log": "34ac109f9a0d993adb8ab4509183290998e6d3ba2db96c092199c578d4871821", + "evidence/full/native/fresh-extra/wrappers-bw_adapters.py.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "evidence/full/native/native-base.log": "efc83346c36b64d06a09c5c13fbbae413fc0fe622f3e92db1ea68bee0262d8bc", + "evidence/full/native/native-extra.log": "3e9f2ad18701405f0e7143f2d5f0feddd2561899ad4b799c0ec222ce213416bb", + "evidence/full/reused-retained-input/NATIVE-RECEIPT.json": "a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc", + "evidence/full/reused-retained-input/RESULT.json": "508ed06e438284da22aef306c4c46ca4d11414d1699e3263c95890ec1fa8fc9b", + "evidence/full/reused-retained-input/STAGES.json": "0f9f38bd73b51215561db52eda09aea3eec9b879728642d2a25655cc2af5d38f", + "evidence/full/scripts/admit_shared_replica.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "evidence/full/scripts/build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "evidence/full/scripts/prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "evidence/full/scripts/reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "evidence/full/scripts/shared_kernel.py": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "evidence/full/scripts/shared_kernel_review.py": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "evidence/full/source/DERIVED-MANIFEST.json": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "evidence/full/source/PR2833-MANIFEST.json": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "evidence/full/wrapper/RESULT.json": "5b999d2ea2aa688367acd11743a8c2aa319c3f9fabb7a19c3221964f811cf581", + "evidence/full/wrapper/STAGES.json": "d0813879a0c4096865f521f89d2d6b37d16ce58dd1a0f2548ad593f2c01aa542", + "evidence/full/wrapper/complete-admission.log": "96af884c6eeec6a581d6e60dcb5985a97e6e6870469b5afc117f554ed209ce50", + "evidence/full/wrapper/derive-source.log": "f2bbb6462b3f5bb8a6415bb33c0c35355353b13343ddb90961660f7473caa5a2", + "evidence/full/wrapper/fresh-current-native.log": "d7581123b0f3330f2598e7758ccbca466018d2599124fc6ceb1b678a9ee27dec", + "evidence/full/wrapper/source-DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "evidence/local/FOUR-GROUP-INDEPENDENT-REVIEW.json": "09e3b1ef5c03946b3f965e2cba97b34c40d531e751dfb258ab7339ad818a3b80", + "evidence/local/INDEPENDENT-AUDIT-base.json": "7253623ffa6f94326ec3e9fc41c2eec0c2b8e2caaddbe7d5fed688f81e9561c0", + "evidence/local/INDEPENDENT-AUDIT-extra.json": "bb43f1c1ae940ab36680d756efa881fbcec4876cd30eb2486b1b0b518da48e72", + "evidence/local/INHERITED-AUDIT-base.json": "9a5a66e4aeb4a7f1d5281fa309df4e0985a3b873315fb9a779c2edab7e81d755", + "evidence/local/INHERITED-AUDIT-extra.json": "da324a7cc59987843480da0670c9a7ec3afbc0f1daa78bcc8bf9b6684bdfad6a", + "evidence/local/OPTIMIZATION-REJECTION.json": "fe127382bf5530dbbcf07e08b05d238704d96dd7f5e4570921132f93a01b2f3a", + "evidence/local/PRODUCER-base.json": "01a3fe9465859dd29f36a4630b48f7223cf84f7f89d5aba240c979e26a106504", + "evidence/local/PRODUCER-extra.json": "e3adba660b0cb7622c3b26c1ea309a5c10ed2d414f7dcdec3abdb35c1f07dcaf", + "evidence/owners/CONTROLS.json": "b2b4e65f33e08ccddb685a062fdc04fd008023c89255a19acd5ed5c48e70a96d", + "evidence/owners/INDEPENDENT.json": "3e5713aa35824a80387f4f7aeeac83030c13962a13af4ab85873a6d20daf6798", + "evidence/owners/LITERAL-PRODUCER.json": "d3fd3d48174009e126c0e3feece20d8ce1f9f1cc95a680fa764caf8b6cbdf805", + "evidence/relaxation/FOUR-ACTUAL-RELAXATION.json": "6d9c1c117704c7b3e9f6da6c7b56745c53f01a625da5c9cdac52a85b2fccb1b4", + "evidence/relaxation/INDEPENDENT-LP-AUDIT.json": "ccb3e7f55117c6d6d1bd6ab6fea7b59477ce1df3be464515cc376db4467a5cdf", + "evidence/relaxation/LOCAL-CEILING.json": "891c46cb4bdb98b343d904663a83c4909dbfa94143317107b1e0febad91f75e7", + "evidence/retained/NATIVE-CACHE.tar.gz": "74ba5d3aee4251aab374ca3be542072d4ca96c56ce1a6c0a3c381f7f354a3961", + "evidence/retained/NATIVE-RECEIPT.json": "a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc", + "integration-review/DERIVATION-REVIEW-OPTIMIZED.json": "9c5316e77ec1520e47214e8f673ca357918544f174f316f9557a8875daaf1279", + "integration-review/DERIVATION-REVIEW.json": "b4673c060f8502ced720e5f4b7095da7c4ed305455a6cdd0d5a507001733d5fa", + "integration-review/FAILED-V1.json": "4beb6dce762b626bfeac2ab93a54c6b5b2165e7f1e25db1b69b1a43fb6455389", + "integration-review/FINAL-CHAIN-REVIEW.json": "a738972f0010d878032f9608070d0f649ca9d5d6798d0e696251aef51030d84c", + "integration-review/REVIEW.md": "d103b7ca1d805c7de6b3ac9f1d95ac150294858adca06554e305045f32e2b6ec", + "integration-review/T37-GEOMETRY-PREFLIGHT.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "integration-review/check_integration_derivation.py": "0f02d3e0fb0d53dc4d2c444bbdd7054040ee32bf2a1fef8ff96e3a780d579203", + "integration-review/fixtures/derivation/DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "integration-review/fixtures/derivation/build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "integration-review/fixtures/derivation/prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "integration-review/fixtures/derivation/reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "integration-review/fixtures/new/admit.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "integration-review/fixtures/new/runtime/geometry_controls.py": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "integration-review/fixtures/new/source/MANIFEST.json": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "integration-review/fixtures/new/source/new/rebuild_borrow.py": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "integration-review/fixtures/new/source/verify.py": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "integration-review/fixtures/old/admit.py": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "integration-review/fixtures/old/runtime/geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "integration-review/fixtures/old/source/MANIFEST.json": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "integration-review/fixtures/old/source/new/rebuild_borrow.py": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "integration-review/fixtures/old/source/verify.py": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0", + "materialize_source.py": "4f496ed6263aec187019a9005a4125487137e5380bbc88a14a4962a0d77bd881", + "owner_controls.py": "db9837c4d3905418b55dbeb3aebed29341cf5e98c948f37f56d0fc4c49ca2087", + "prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "requirements-reproduction.txt": "5e665fa5c409df8f7a561a4c0286173802aad59f3f90587f83b804efa146f7bd", + "review_four_groups.py": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "run_integration_review.py": "195b5ebeac758f6766ff78586ffa177d3c5de011e007d299d9d900d42b2d31f4", + "run_owner_controls.py": "3bbe39c554345ff7d48a117597ea7d925c183c13c1d743360bd0e128c763b56b", + "shared_kernel.py": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "source_pin_controls.py": "1a76d03b22e93122e2b6f980bffea3a19882722dc220f7c9864621c697995cdd", + "sources/PR2833-DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "sources/PR2833-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "sources/PR2833-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "sources/PR2833-PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "sources/PR2833-PROVIDERS.json": "3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda", + "sources/PR2833-T37-DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "sources/PR2833-T37-OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "sources/PR2833-T37-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "sources/PR2833-WORD-base.json.gz": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "sources/PR2833-WORD-extra.json.gz": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "sources/PR2839-CREDITS.md": "d8eea66efb6796d3caeec985949724eab9df1eb214182b7db2ef84ba6e19b5e9", + "sources/PR2839-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/PR2843-DISPATCH.json": "e06a95c589425f92e4cce90b0d71664b96d5955bb34d9ffefdae4b432fa8746b", + "sources/PR2843-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/PR2843-NOTICE": "b1a13e97bf3503b4a52033518dd528d010f57be7b591245bf48910c20320d186", + "sources/PR2843-ORDER.json": "5fc45c6e6a50db17c1eb2577d36e0dab3057005bc269ea6be1241c79f61aeced", + "sources/PR2848-CLAIM.json": "aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9", + "sources/PR2853-OUTER-CLAIM.json": "eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa", + "vendor/ceiling.py": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "vendor/pr2839/CREDITS.md": "d8eea66efb6796d3caeec985949724eab9df1eb214182b7db2ef84ba6e19b5e9", + "vendor/pr2839/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr2839/blocknorm_certificate.py": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92", + "vendor/pr2839/independent_owners.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "vendor/pr2839/lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "vendor/pr2839/reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "vendor/pr2839/replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "verify.py": "1a16ddf9778ea41bc3ed50532ea3c00b6cbc4ec55a2bae5c4842277a02fd99ac", + "words/WORD-base.json.gz": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "words/WORD-extra.json.gz": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/NOTICE b/research/shared-kernel-packing/vendor/pr2857/NOTICE new file mode 100644 index 0000000000..b1a6935191 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/NOTICE @@ -0,0 +1,19 @@ +Four staged compensation kernels and chronological owner repacking +Prepared for Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +New contributions are licensed under Apache-2.0. + +Jeremy Kothe (@jeremykothe2), PR2833: pinned source words, dirt-entry mechanism, +local audit, cleanup and native reconstruction lineage. +@philippeVV, concurrent PR2853: the same four A-phase helper quartets +and entrance mechanism, with a different early-read schedule and paid profile. +Marius-Paul Dumitrean (@mdumitrean), PR2843 and predecessors: integer owner-flow +construction and edge-coloring realization, retained in allocation/construction. +Dugongue, PR2839: tensor-block norm and replica/owner interfaces. +Tekalign (@tekuuu), native and source-bound admission lineage. +David Arias C and the other contributors credited in the retained sources. + +Original source-specific licenses and notices are retained in sources/, vendor/ +and allocation/. This notice supplements, and does not replace, their attribution. +Independent checks here are separate AI-assisted implementations; no independent +human or maintainer review, new selected frontier, or full theorem formalization +is claimed. diff --git a/research/shared-kernel-packing/vendor/pr2857/ORDER.json b/research/shared-kernel-packing/vendor/pr2857/ORDER.json new file mode 100644 index 0000000000..2a7f9f1ed2 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/ORDER.json @@ -0,0 +1 @@ +[[0,0],[0,1],[0,2],[0,3],[0,4],[1,0],[0,5],[1,1],[0,6],[1,2],[0,7],[1,3],[0,8],[1,4],[0,9],[2,0],[1,5],[0,10],[2,1],[1,6],[0,11],[2,2],[1,7],[0,12],[2,3],[1,8],[0,13],[2,4],[1,9],[3,0],[0,14],[2,5],[1,10],[3,1],[0,15],[2,6],[1,11],[3,2],[0,16],[2,7],[1,12],[3,3],[0,17],[2,8],[1,13],[3,4],[0,18],[2,9],[4,0],[1,14],[3,5],[0,19],[2,10],[4,1],[1,15],[3,6],[0,20],[2,11],[4,2],[1,16],[3,7],[0,21],[2,12],[4,3],[1,17],[3,8],[0,22],[2,13],[4,4],[1,18],[3,9],[0,23],[5,0],[2,14],[4,5],[1,19],[3,10],[0,24],[5,1],[2,15],[4,6],[1,20],[3,11],[0,25],[5,2],[2,16],[4,7],[1,21],[3,12],[0,26],[5,3],[2,17],[4,8],[1,22],[3,13],[0,27],[5,4],[2,18],[4,9],[1,23],[6,0],[3,14],[0,28],[5,5],[2,19],[4,10],[1,24],[6,1],[3,15],[0,29],[5,6],[2,20],[4,11],[1,25],[6,2],[3,16],[0,30],[5,7],[2,21],[4,12],[1,26],[6,3],[3,17],[0,31],[5,8],[2,22],[4,13],[1,27],[6,4],[3,18],[0,32],[5,9],[2,23],[7,0],[4,14],[1,28],[6,5],[3,19],[0,33],[5,10],[2,24],[7,1],[4,15],[1,29],[6,6],[3,20],[0,34],[5,11],[2,25],[7,2],[4,16],[1,30],[6,7],[3,21],[0,35],[5,12],[2,26],[7,3],[4,17],[1,31],[6,8],[3,22],[0,36],[5,13],[2,27],[7,4],[4,18],[1,32],[6,9],[3,23],[8,0],[5,14],[2,28],[7,5],[4,19],[1,33],[6,10],[3,24],[8,1],[5,15],[2,29],[7,6],[4,20],[1,34],[6,11],[3,25],[8,2],[5,16],[2,30],[7,7],[4,21],[1,35],[6,12],[3,26],[8,3],[5,17],[2,31],[7,8],[4,22],[1,36],[6,13],[3,27],[8,4],[5,18],[2,32],[7,9],[4,23],[6,14],[3,28],[8,5],[5,19],[2,33],[7,10],[4,24],[6,15],[3,29],[8,6],[5,20],[2,34],[7,11],[4,25],[6,16],[3,30],[8,7],[5,21],[2,35],[7,12],[4,26],[6,17],[3,31],[8,8],[5,22],[2,36],[7,13],[4,27],[6,18],[3,32],[8,9],[5,23],[7,14],[4,28],[6,19],[3,33],[8,10],[5,24],[7,15],[4,29],[6,20],[3,34],[8,11],[5,25],[7,16],[4,30],[6,21],[3,35],[8,12],[5,26],[7,17],[4,31],[6,22],[3,36],[8,13],[5,27],[7,18],[4,32],[6,23],[8,14],[5,28],[7,19],[4,33],[6,24],[8,15],[5,29],[7,20],[4,34],[6,25],[8,16],[5,30],[7,21],[4,35],[6,26],[8,17],[5,31],[7,22],[4,36],[6,27],[8,18],[5,32],[7,23],[6,28],[8,19],[5,33],[7,24],[6,29],[8,20],[5,34],[7,25],[6,30],[8,21],[5,35],[7,26],[6,31],[8,22],[5,36],[7,27],[6,32],[8,23],[7,28],[6,33],[8,24],[7,29],[6,34],[8,25],[7,30],[6,35],[8,26],[7,31],[6,36],[8,27],[7,32],[8,28],[7,33],[8,29],[7,34],[8,30],[7,35],[8,31],[7,36],[8,32],[8,33],[8,34],[8,35],[8,36]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/PROFILE.json b/research/shared-kernel-packing/vendor/pr2857/PROFILE.json new file mode 100644 index 0000000000..e50b6e37c7 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/PROFILE.json @@ -0,0 +1 @@ +{"1":805860,"2":213786,"3":91775,"4":42624,"5":13098,"8":2664,"9":1,"48":13379} \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/PROOF.md b/research/shared-kernel-packing/vendor/pr2857/PROOF.md new file mode 100644 index 0000000000..f344169fd9 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/PROOF.md @@ -0,0 +1,70 @@ +# Independent audit of the four compensation-kernel lifts + +This checks the changed local words against the two immutable PR2833 words at commit `e9307b48d7d1b690939935ecef0f8e524e6d92f4`. It imports no construction, inherited audit, or repository modules. Credit for the base word and dirt-entry mechanism remains with Jeremy Kothe / PR2833 and the lineage credited there. The four-group construction is the separate producer's work; this audit independently checks its algebra, frames and cleanup. + +Both providers pass 68 named checks, including the original 65 checks and additional source geometry, key-set and input-immutability checks. Python `-O`/`-OO` is explicitly rejected before input access because the frame ledger also uses assertions. `OPTIMIZATION-REJECTION.json` records that test. Earlier executed single-group and four-group checker files and receipts were retained outside this portable directory. + +## Algebra and orientation of the compensation equation + +For a group ordered as `(q0,q1,q2,q3)`, let `z` be the column vector of its four independent original dirty helper values. The inserted A gates produce the same A output as the original A word started with `S z`, where + +``` +S = [[ 1, 0, 0, 0], + [ 1, 1, 0, 0], + [-1, 0, 1, 0], + [-1, 0, 1, 1]]. +``` + +Thus the transformed dirty inputs are `(z0, z1+z0, z2-z0, z3+z2-z0)`. The checker establishes `A_new = A_old S` for every one of the 704 formal output rows, using exact rational coefficients and independent noncommuting symbols for the warp operators. Of these slots, 632 are live independent inputs and 72 removed slots remain untouched identities. No dirty input is assumed zero. The source partners that reconstruct raw dirt are also independent inputs. + +`S` is lower triangular with diagonal entries1, so it is invertible. Let `C` map original helper dirt to the initial target compensation. Its four columns obey `C*(1,1,-1,-1)^T=0`. The required new compensation is **`C_new=C S`**, not `C S^-1`: the changed A word consumes the transformed dirty inputs `S z`, so its target dirt response is transformed by the same right multiplication. The first column of `C S` is zero; the third is old column3 plus old column4; the other two remain their old columns. This is exactly the producer's removal of compensation reads from q0 and addition of old q3 compensation to q2. The checker verifies this equation across all112 target rows, not just the displayed nonzero supports, then independently replays the complete program. + +| Group order | Raised entrance | Partner frame intersection | +| --- | --- | --- | +| 478,479,490,491 | 478 | span(25) | +| 460,461,468,469 | 460 | span(7) | +| 462,463,470,471 | 462 | span(7) | +| 480,481,492,493 | 480 | span(25) | + +Each compensation block has exact rational rank3 and the stated one-dimensional kernel. Both the four operand supports and the four compensation target supports are pairwise disjoint. The combined compensation matrix has rank12 and nullity4. These facts justify composition for these groups; they do not establish optimality over other rewrites or boundary changes. + +## Cleanup and frame cost + +The audit independently reconstructs cleanup by reversing and inverting the changed non-target forward word, excluding the inherited84-event prelude and target writes. It independently checks the private-buffer remapping against the unchanged72 restored helpers. Forward and dual free-operator replay both yield the required endpoint on every formal register, with every private buffer zero. This proves arbitrary-dirty linear/operator endpoint behavior; it does not itself prove Clifford phase or Gaussian-product identities. + +The exact GF(2) frame ledger checks monotonicity, warp endpoints, target and centre cut pins, final frames and ordered helper widths. Only eight helper climb profiles change: each q0 contributes `H1-H2`, and each q2 contributes `2H1-H2`. Therefore + +`local profile delta = 12 H1 - 8 H2`. + +Only ordered helper widths460,462,478,480 change, each from9 to8. The resulting local profile is `{1:2394,2:642,3:266,4:128,5:26,8:8}`. The complete width histogram is `{4:26,5:2,7:62,8:84,9:234}`. The reconstruction adds20 A primitives and20 inverse-cleanup primitives. Compensation removes28 primitives and adds28, so its count is unchanged. No helper, warp, private buffer or port assignment is added. Cleanup is at the same FULL frame; the extra scalar gates do not create additional climb charges in this ledger, but their native phase behavior still needs verification. + +The four freed width units must be priced by the actual owner fill and idle profile. This audit does not count them as free, assign each a standalone H1 cost, or claim that a fractional packing witness is a realizable order/dispatch. + +## Remaining admission conditions + +A bound improvement remains conditional on the fresh declared source stage and its rejection controls; whole-package strict source release; native phase/Gaussian replay of all new primitives and cleanup; actual owner fill, order and dispatch using the changed ordered width list; and both exact outer checks plus selected-parent admission and inherited rejection controls. The local audit found no algebraic or frame blocker. It does not substitute for those gates or alter the selected frontier. + +## Portable reproduction + +The checker accepts only the two pinned original PR2833 compressed source words, then checks the supplied candidate structurally and algebraically. Run once for each provider: + +```sh +PYTHONDONTWRITEBYTECODE=1 python3 -B check_four_kernels.py \ + --source-word PATH/TO/BORROW-WORD-43base.json.gz \ + --candidate-word PATH/TO/WORD-base.json.gz \ + --out RESULT-base.json +``` + +For the second run use `43extra`, `WORD-extra.json.gz` and `RESULT-extra.json`. The checker reads its two inputs and writes only the requested JSON receipt; it does not import or execute the candidate. + +| Object | SHA256 | +| --- | --- | +| Pinned source base compressed | dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7 | +| Pinned source extra compressed | bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac | +| Candidate base compressed | 001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458 | +| Candidate base decompressed | fd073806137fdd0b2e74f7075c7079304797227011c30147341328b928a8840c | +| Candidate extra compressed | bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546 | +| Candidate extra decompressed | d61a8077a8bb60b5e36b742fca6c04df21a701b09ef432600ec62462caaa8f6d | +| Historical prototype producer inspected | 90aa848c2fc4c4c79d18a792417d73ab3683440d79ca89d9efd348a430e0f91f | +| Current production producer, separately checked to reconstruct both identical decoded words | b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed | +| Portable checker executed | 34ded7db6524ca4e7229c887c24ad7a5ce2531007f7c1ebfc4dd9af952406614 | diff --git a/research/shared-kernel-packing/vendor/pr2857/PROVIDERS.json b/research/shared-kernel-packing/vendor/pr2857/PROVIDERS.json new file mode 100644 index 0000000000..39998c1f3c --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/PROVIDERS.json @@ -0,0 +1 @@ +{"extra":{"actual_paid_profile":{"1":2394,"2":642,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,8,9,8,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,8,9,8,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]},"gauge44":{"actual_paid_profile":{"1":2394,"2":642,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,8,9,8,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,8,9,8,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]}} \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/README.md b/research/shared-kernel-packing/vendor/pr2857/README.md new file mode 100644 index 0000000000..5397917b93 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/README.md @@ -0,0 +1,228 @@ +# Four shared dirt kernels and chronological repacking + +This package establishes a **conditional finite supplier and modern outer +release** with + +``` +kappa = 0.001720096628684832600972 - 10^-46 - 10^-70 +``` + +The exact rational is in [CLAIM.json](CLAIM.json). Both changed providers run +fresh native chains; the complete strict supplier and modern outer checks return +`PASS_RELEASE`. Retained provider and parent proofs are reused with exact +full-tree source bindings. This is author-checked, with separate AI-assisted +checkers, not maintainer acceptance or a full theorem formalization. The selected +result remains unchanged. + +| Pinned comparison | Headline κ (display rounded) | Exact/approximate gain | +| --- | ---: | ---: | +| [PR2848](https://github.com/CrocSwap/integer-mult-bounds/pull/2848), `c50d12e4720cd1fef2b5a65e337e37de9731879a` | 0.001718658508304930 | exactly `1438120379902596153 / 10^24` | +| [PR2853](https://github.com/CrocSwap/integer-mult-bounds/pull/2853), `d01045dfb67428679618027dff552f1d032fa999` | 0.001719377658697587 | approximately `7.189699872459419e-7` | +| This contribution | 0.001720096628684833 | exact rational comparisons in `CLAIM.json` | + +The PR2848 gain is about `1.43812e-6`, exceeding the donor's preferred `1e-6` +target. This is an exponent saving, not a measured runtime speedup. + +Fresh overlap found @philippeVV's concurrent PR2853 on the **same four helper +quartets**. That work uses an early-read schedule with local delta +`20 H1 - 12 H2`. Here delayed within-pair mixing and a different compensation +basis give `12 H1 - 8 H2`, followed by a new actual owner fill. This credits the +shared mechanism and helper selection; no priority or exclusive discovery claim +is made. Both comparisons are against frozen heads, not all current work. + +## Construction + +The scientific baseline is Jeremy Kothe's PR2833, exact head +`e9307b48d7d1b690939935ecef0f8e524e6d92f4`, whose source package has 541 +manifest entries. In each of four disjoint helper quartets, the compensation +matrix has rank three with kernel `(1,1,-1,-1)`. A staged reversible change of +raw dirt makes one compensation column zero, permitting a one-line entrance +frame and reducing a helper width from nine to eight. + +| Quartet | Helper with smaller width | New entrance line | +| --- | --- | --- | +| 478, 479, 490, 491 | 478 | 25 | +| 460, 461, 468, 469 | 460 | 7 | +| 462, 463, 470, 471 | 462 | 7 | +| 480, 481, 492, 493 | 480 | 25 | + +For a quartet ordered `(q0,q1,q2,q3)`, the raw-dirt map is +`q1 += q0; q2 -= q0; q3 += old q2 - q0`. With matrix `S`, the new A map is +`A_old*S` and compensation is `C*S`. Its first column vanishes; its third is +the sum of the old third and fourth columns. Mixing within each pair only after +its first A writes preserves the inherited two-dimensional frames. The producer +regenerates the inverse cleanup; [PROOF.md](PROOF.md) and the independent +`check_four_kernels.py` explain and check the full operator, not only the kernel. + +| Child rank | PR2833 per call | New per call | +| --- | ---: | ---: | +| 1 | 2382 | 2394 | +| 2 | 650 | 642 | +| 3 | 266 | 266 | +| 4 | 128 | 128 | +| 5 | 26 | 26 | +| 8 | 8 | 8 | + +The helper inventory becomes `{4:26,5:2,7:62,8:84,9:234}` from +`{4:26,5:2,7:62,8:80,9:238}`. The interface still has 408 helpers, 72 private +buffers and 632 live independent inputs. All 20 added A operations, 20 inverse +cleanup operations, compensation and frame changes are charged. + +Reusing the old fill loses. The new **T37** construction uses 333 calls +(125 base, 208 extra), assigning every one of 135,864 helper roles under the +actual chronological windows, family and offset guards. `FILL.json.gz`, +`ORDER.json`, `DISPATCH.json` and `PROFILE.json` are the literal witness. Its +complete profile, including idle children, is + +``` +{1:805860, 2:213786, 3:91775, 4:42624, 5:13098, 8:2664, 9:1, 48:13379} +``` + +There are 33,152 live and 33,642 physical families; rank mass is 2,408,256. +The independent exact moment audit brackets the complex endpoint between +`17200966286848326009728 / 10^25` and +`17200966286848326009729 / 10^25`. The modern outer wrapper applies the strict +margins displayed above. The inherited supplier bootstrap certificate has the +lower κ `0.001717142976839401`; it is a different layer and is not this headline. + +The local coverage-law packing ceiling is in +`[0.001758838083985131367624, 0.001758838083985131367625]`. +The headline realizes **97.797326789%** of its upper bound. The tighter +changed-inventory, fixed-capacity fractional relaxation has upper bound +`0.001720100805416885927945`; this construction realizes **99.71041112% of the +available gain over PR2848**. An independent checker enumerates all 1,163 +patterns, proves the primal balances and dual signs (11 tight, 1,152 strict), +and brackets its complete moment. These relaxations are not chronological +witnesses or universal barriers. See `evidence/relaxation/` and +`evidence/full/CEILING-REALIZED.json`. + +## Evidence + +- `verify.py` regenerates both complete decoded words and runs the separate + exact 68-check audit per provider, with semantic, cleanup, source-binding and + optimized-mode rejection controls. It imports only the pinned pure producer. +- `audit_owners.py` independently checks all roles, original template projection, + windows, dimensions, disjoint offsets, provider-word bindings, idle bill, + prefixes and exact moment. Four targeted owner/source mutations are rejected. +- `evidence/full/` retains the executed full replay scripts, manifests, logs, + invoices, cache receipt and modern outer evidence. The release receipt SHA256 + is `c052decb90ceae345b398f111781f567fb787309a528877500cf7fe1cff13b3d`. + Actual rejected controls include 119 admission, 12 bit, **25 controller**, + 8 owner and 6 geometry mutations; the modern outer ledger checks 63 strict + inequalities and 17 rejections. `ACTUAL-CONTROLS.json` counts the actual + serialized arrays; inherited summary metadata saying 15 controller checks + is stale. +- `check_release_evidence.py` binds all 167 full-release evidence files and + 63 native archive members to the shipped words, owners and exact claim. It + checks the actual outer margins and rejects 20 targeted corruptions without + importing packaged Python or extracting the archive. +- `integration-review/` checks the exact admission AST and 11-path source + overlay (five modified, six added), retaining all previous checks. It rejects + 20 altered-source/control cases, including with Python optimization enabled. + +An initial full replay **failed**: the inherited geometry `old_call_count` +mutation set both counts to 333, exactly the correct count for this T37 witness, +so it changed nothing. The corrected derived test subtracts one from each +actual charge and checks that every mutant changes its inputs before calling +the unchanged assembly predicate. All six geometry controls remain required. +The complete replay was then rerun and passed. Failed artifacts and the exact +correction are retained in `evidence/full/experimental-failure/` and +`integration-review/FAILED-V1.json`; this is not a waived test. + +## Reproduction + +From the repository root, metadata and the bounded, standard-library checks: + +```sh +python3 -B scripts/research_package.py --package research/shared-kernel-repacking --check-only +python3.12 -B scripts/research_package.py --package research/shared-kernel-repacking +``` + +`VERIFY.json` lists every command explicitly. Locally these commands were +executed directly with **Python 3.13.7**, not the generic Python 3.12 runner; +no hosted CI or fresh Lean result is claimed. The fast checks inspect and bind +retained release evidence; they do not substitute for rerunning the full native +and outer pipeline. + +For the full reproduction, use a Python environment with the exact pins in +`requirements-reproduction.txt`. Keep bytecode disabled for all frozen inputs. +Fetch the frozen scientific source once, then materialize it from local Git +objects. The exporter verifies its entire 541-file manifest before writing: + +```sh +git fetch --no-tags https://github.com/CrocSwap/integer-mult-bounds.git refs/pull/2833/head +pkg="$PWD/research/shared-kernel-repacking" +work=$(mktemp -d) +export PYTHONDONTWRITEBYTECODE=1 +unset PYTHONOPTIMIZE +python3 -B "$pkg/materialize_source.py" --repo "$PWD" --out "$work/pr2833" +mkdir "$work/retained-cache" +tar -xzf "$pkg/evidence/retained/NATIVE-CACHE.tar.gz" -C "$work/retained-cache" +python3 -B "$pkg/reproduce.py" \ + --source "$work/pr2833" --words "$pkg/words" \ + --fill "$pkg/FILL.json.gz" --order "$pkg/ORDER.json" --dispatch "$pkg/DISPATCH.json" \ + --retained-cache "$work/retained-cache" \ + --retained-receipt "$pkg/evidence/retained/NATIVE-RECEIPT.json" \ + --comparison-claim "$pkg/sources/PR2848-CLAIM.json" \ + --comparison-latest-claim "$pkg/sources/PR2853-OUTER-CLAIM.json" \ + --work "$work/release" --jobs 4 +``` + +The executed wrapper completed in about 259 seconds locally. It freshly runs +**both changed current native chains** and authenticates the exact retained +cache, receipt and source trees for **two retained native chains and the +16-stage retained parent proof**. This is explicit source-bound reuse, not a +fresh cold replay of every predecessor. Paths and timing make replay receipts +run-specific; regenerated compressed words are compared by complete decoded +content. Committed source containers retain exact byte pins. + +The allocation can be reconstructed without a solver or network, from the +committed exact flow and original source template: + +```sh +python3 -B "$pkg/allocation/replay_allocation.py" \ + --source "$work/pr2833" \ + --owner-engine "$pkg/vendor/pr2839/independent_owners.py" \ + --work "$work/allocation" +``` + +This checks the mathematical flow constraints before the retained edge-coloring +realization. Regenerated FILL equality uses the **whole decompressed payload**, +with a successful changed-gzip-container control and a rejected changed-payload +control. The original discovery used OR-Tools 9.14.6206 (four workers, seed 124, +300-second cap): T37 was feasible in about 39 seconds. `OPTIMAL` here is a +feasibility solver status, not proof of an optimal bound. A T124 attempt timed +out `UNKNOWN`; no impossibility claim follows. Search code, exact flow, model, +solver settings, controls and predecessor attribution are retained in +`allocation/`. + +## Open next questions + +Finite evidence remains conditional on inherited all-size compiler, +source-access, hosting, precision/tape and analytic interface obligations. +There is no new Lean kernel audit, unconditional multiplication theorem, +maintainer review or selected-frontier change. + +Further repacking of this inventory has at most about `4.18e-9` of the displayed +fixed-capacity relaxation gap, so it does not justify another search for a +`1e-6` gain. A materially larger follow-up should change the local or +source-consuming contract and first price its complete consumer, cleanup, +transport and precision costs. A separate useful task is to close one named +all-size interface obligation. [TASK.json](TASK.json) records these questions, +feasible first steps and blockers. + +## Credit and coordination + +Prepared for Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance, +including separate construction and audit implementations. Builds on Jeremy +Kothe's PR2833 dirt-entry words; concurrent @philippeVV PR2853; Marius-Paul +Dumitrean's PR2843 owner construction and earlier local words; Dugongue's PR2839 +tensor-block interface; Tekalign's native/admission work; and the other retained +source authors. See [NOTICE](NOTICE) and source-specific notices and licenses. +New work is Apache-2.0. + +The initial base is `c719a5e0b3a6760a6fdf5d5af82d6ff2399329e5`; the branch was +advanced to current main at `130a7ce63a233e6812b7c037993c721fec827014` before +submission without changing scientific pins. Latest priority/overlap coverage is in +`TASK.json`. The canonical coordination update is +[Discussion #2612](https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18963373). diff --git a/research/shared-kernel-packing/vendor/pr2857/SOURCES.json b/research/shared-kernel-packing/vendor/pr2857/SOURCES.json new file mode 100644 index 0000000000..2f97810ed9 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "c719a5e0b3a6760a6fdf5d5af82d6ff2399329e5", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/shared-kernel-packing/vendor/pr2857/TASK.json b/research/shared-kernel-packing/vendor/pr2857/TASK.json new file mode 100644 index 0000000000..09d52d71e8 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/TASK.json @@ -0,0 +1,122 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 5, + "base_commit": "c719a5e0b3a6760a6fdf5d5af82d6ff2399329e5", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "refined", + "actual_scope": "Four delayed shared-kernel dirt shears on PR2833 base/extra words, replacing four width-nine helpers by width-eight helpers; an actual T37 chronological owner allocation and completed source-bound conditional modern outer release.", + "scope_change_reason": "The donor requested a materially larger improvement after completed PR2848. Fixed-word packing has only about 1.01e-9 remaining headroom. The new scalar A schedule and compensation basis alter both the actual paid local profile and helper inventory; this is not another allocation of the frozen old word.", + "bottleneck_link": "Per call, the literal profile changes by 12 H1 - 8 H2 and four helper widths shrink 9 to 8. Repacking the released dimensions into larger idle children can lower the complete recursive moment; the previous literal fill loses, so no standalone local saving is counted as a bound.", + "budget_minutes": 240, + "stop_rule": "The donor extended research until an improved bound or token exhaustion. Target at least1e-7, preferably1e-6 over pinned PR2848; accept only after actual word, chronological owners and full native/global/outer release. No expansion if the complete optimistic bill fails the target.", + "outcome": "completed", + "evidence": "Both full arbitrary-dirt words independently audited; 135864 actual chronological helper roles independently checked; exact moment brackets; two fresh current native chains; full strict supplier and modern outer PASS_RELEASE. Retained provider and parent chains explicitly reused by full-tree hashes. See CLAIM.json and evidence/full/COMPLETE.json.", + "author": "Yiyang (@Lyy-iiis)", + "ai_assistance": "Substantial OpenAI Codex assistance for research, derivation, implementation, exact computation, separate construction/audit agents and publication; no independent human or maintainer review claimed.", + "open_questions": [ + { + "question": "Can a different chronological template realize more of the changed-inventory fractional gain?", + "why_it_matters": "The actual T37 witness realizes 99.71041112% of available gain over PR2848; the remaining gap to this fixed-capacity relaxation is only about4.18e-9. It cannot deliver another1e-6 improvement.", + "first_step": "Inspect the exact tight patterns and leftover idle residues in evidence/relaxation/FOUR-ACTUAL-RELAXATION.json before allocating any search budget.", + "blocked_by": "No further packing expansion is proposed here: this small scoped gap does not meet the donor's larger-gain target. T124 search timed out without a feasibility conclusion." + }, + { + "question": "Can a changed source-consuming kernel contract reduce local cost beyond the inherited-frame four-helper grammar?", + "why_it_matters": "The attained per-quartet cost floor is scoped to a specific dirt basis and frame schedule.", + "first_step": "Specify a new dirt/consumer contract and derive its fully charged favorable cost before synthesis.", + "blocked_by": "Unknown consumer, cleanup, transport and precision costs must not be zeroed." + }, + { + "question": "Can inherited compiler, source-access and precision/tape hypotheses be established uniformly in size?", + "why_it_matters": "Finite supplier evidence remains conditional on these all-size obligations.", + "first_step": "Audit one named interface in the selected review against the literal new native words.", + "blocked_by": "This contribution does not supply a complete all-size proof or fresh Lean kernel audit." + } + ], + "original_assignment_nonce": "c852d3b254a485ad8d9d6147e5a37c7c", + "coordination_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2612#discussioncomment-18963373", + "donor_budget_override": "Continue until a better bound or token exhaustion; budget_minutes is a planning estimate.", + "concurrent_overlap": { + "pr": 2853, + "head": "d01045dfb67428679618027dff552f1d032fa999", + "author": "philippeVV", + "discovered_at": "2026-10-16T03:18:00Z", + "same_object": "Four A-phase dirty-entry helper quartets460/462/478/480", + "distinct_delta": "Delayed within-pair mixing and changed compensation basis: +12H1-8H2 rather than +20H1-12H2; new actual chronological owners. No helper-selection novelty claim." + }, + "upstream_checkpoint": { + "commit": "130a7ce63a233e6812b7c037993c721fec827014", + "checked_at": "2026-10-16T03:42:25.731180+00:00", + "priority_revision": 5, + "guidance_changes": [ + "autoresearch.md documents optional --include-closed remote historical overlap coverage and five-source connector scope map.", + "bottleneck-brief links P104 helper-lifetime scope map; current-status links PR1048 correction map." + ], + "decision": "continue; selected record, task card and scientific dependency obligations unchanged; fetched canonical main and fast-forwarded isolated branch" + }, + "expansion_decision": { + "decision": "complete this construction and stop further fixed-inventory expansion", + "evidence": "An actual complete paid T37 owner bill met the stated1e-6 target; all local/current-native/global/modern outer release gates passed. Uniform compiler/source-access/hosting/precision/tape/analytic obligations remain inherited, not zero-cost or newly proved.", + "next_mechanism_gate": "Require a changed fully priced local/consumer contract for another material gain." + }, + "overlap_refresh": { + "checked_at": "2026-10-16T03:42:25.731180+00:00", + "coverage": { + "all_updates_since_cutoff_in_page": true, + "count": 100, + "limitation": "Not a scan of all historical open/closed bodies or nested code; complete post-cutoff updated-open coverage within this page at retrieval.", + "method": "REST state=open sort=updated direction=desc per_page=100", + "oldest_page_update": "2026-10-15T20:59:53Z" + }, + "discussion": 2612, + "pr2853_head": "d01045dfb67428679618027dff552f1d032fa999", + "new_relevant_pr": { + "number": 2855, + "head": "90c52db35dd2f8cdf0dd81976e698a6192a09126", + "scope": "weaker T372 allocation; no cheaper shared-kernel word" + }, + "limitations": "Earlier broad open-PR snapshot and local package/ledger overlap supplemented by updated-open scan; no exhaustive code or closed-PR novelty claim. Discussion2612 retrieved; earlier broad Discussion pagination had intermittent transport failures." + } +} diff --git a/research/shared-kernel-packing/vendor/pr2857/VERIFY.json b/research/shared-kernel-packing/vendor/pr2857/VERIFY.json new file mode 100644 index 0000000000..e898378a19 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/VERIFY.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Reconstruct both complete decoded words; separate operator/frame/kernel/cleanup audits and nonvacuous semantic/source/optimized-mode controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/audit_owners.py", + "--source-dir", + "{package}/sources", + "--candidate-dir", + "{package}", + "--words-dir", + "{package}/words" + ], + "timeout_seconds": 180, + "checks": "Independent chronological owners, full provider-word binding, idle profile, prefixes and exact moment bracket." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/run_owner_controls.py" + ], + "timeout_seconds": 180, + "checks": "Reject four targeted false-profile, window, overlap-offset and source mutations." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/audit_relaxation.py", + "--source-dir", + "{package}/sources", + "--receipt", + "{package}/evidence/relaxation/FOUR-ACTUAL-RELAXATION.json", + "--candidate-dir", + "{package}/words" + ], + "timeout_seconds": 180, + "checks": "Independent full 1163-pattern primal/dual feasibility and exact global relaxation moment." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/check_ceiling.py" + ], + "timeout_seconds": 120, + "checks": "Exact coverage-law ceiling from both literal local profiles and its realized fraction." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/run_integration_review.py" + ], + "timeout_seconds": 120, + "checks": "Exact admission AST guard preservation,11-path source derivation,20 corruptions including Python-O mode." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/check_release_evidence.py", + "--package", + "{package}", + "--controls" + ], + "timeout_seconds": 120, + "checks": "Bind all167 full-release evidence files and63 archive members to actual words/owners/exactheadline; verify actual controlarrays,63 outer margins and20 rejecting corruptions without importing package code." + } + ] +} diff --git a/research/shared-kernel-packing/vendor/pr2857/admit_shared_replica.py b/research/shared-kernel-packing/vendor/pr2857/admit_shared_replica.py new file mode 100644 index 0000000000..8c71cc69ce --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/admit_shared_replica.py @@ -0,0 +1,411 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a changed-replica literal order/fill derivative. + +PR2833 extension by Yiyang Lu with OpenAI Codex assistance: add the exact +immutable dirt-entry source profile and exact full outer-claim comparisons to +PR2833 and the newer PR2843 T124 allocation. All +inherited native, owner, invoice, block-norm, controls and release checks retained. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-refit393' +SOURCE_MANIFEST = '1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +COMPARISON_SHA = '252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3' +COMPARISON_HEAD = 'e8b771ba132fe632796b28c1742a8d096c04519f' +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +# Supported immutable source versions; CLI selection never accepts arbitrary hashes. +SOURCE_PROFILES = { + 'shared-four': dict(commit='shared-four-kernel-pr2833', manifest='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869', helpers=408, source_file_count=547, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2766': dict(commit='local-joint12-refit393', manifest='1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb', helpers=415, source_file_count=491, upstream_head='e6df920cd0110e4b629e2ad84eddcb539001e174'), + 'pr2802': dict(commit='local-joint12-pr2733', manifest='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451', helpers=408, source_file_count=506, upstream_head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd'), +} +COMPARISONS = { + 'pr2848': dict(pr=2848, head='c50d12e4720cd1fef2b5a65e337e37de9731879a', sha256='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', field='kappa'), + 'pr2843': dict(pr=2843, head='47a7227c044cd0cabb1432a06c61dd5d60c07f5a', sha256='0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9', field='kappa'), + 'pr2833': dict(pr=2833, head='e9307b48d7d1b690939935ecef0f8e524e6d92f4', sha256='6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70', field='kappa_rational'), + 'pr2767': dict(pr=2767, head='e8b771ba132fe632796b28c1742a8d096c04519f', sha256='252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3', field='kappa_rational'), + 'pr2802': dict(pr=2802, head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd', sha256='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51', field='kappa'), +} + + + +# Discovery records are shared by parallel mutation-audit processes on Windows. +# Only discovery bookkeeping changes; strict pin comparison below it is untouched. +DISCOVERY_APPEND_OLD = " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))" +DISCOVERY_APPEND_NEW = r''' import time as _wr_time + _wr_path=Path(os.environ['WITNESS_RECORD']) + _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock') + _wr_deadline=_wr_time.monotonic()+60 + _wr_fd=None + while _wr_fd is None: + try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + except FileExistsError: + if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved') + _wr_time.sleep(.005) + try: + with _wr_path.open('a',encoding='utf-8',newline='\n')as _wr_out: + _wr_out.write(json.dumps([key,got],default=str)+chr(10)) + _wr_out.flush() + finally: + os.close(_wr_fd) + _wr_lock.unlink()''' + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + # All output targets belong to this fresh work tree; never unlink an open lock. + lock = path.with_name(path.name + '.lock') + descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + try: + os.write(descriptor, str(os.getpid()).encode()) + os.close(descriptor) + descriptor = None + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + finally: + if descriptor is not None: + os.close(descriptor) + lock.unlink() + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'dispatch', 'native-cache', 'native-receipt', 'work', 'replica-helper-dir', 'reconstructor', 'comparison-claim', 'blocknorm-checker'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + ap.add_argument('--source-profile', choices=sorted(SOURCE_PROFILES), default='shared-four') + ap.add_argument('--comparison-profile', choices=sorted(COMPARISONS), default='pr2848') + a = ap.parse_args() + global SOURCE_COMMIT, SOURCE_MANIFEST, COMPARISON_SHA, COMPARISON_HEAD + source_profile = SOURCE_PROFILES[a.source_profile] + comparison = COMPARISONS[a.comparison_profile] + SOURCE_COMMIT, SOURCE_MANIFEST = source_profile['commit'], source_profile['manifest'] + COMPARISON_SHA, COMPARISON_HEAD = comparison['sha256'], comparison['head'] + expected_helpers, comparison_pr = source_profile['helpers'], comparison['pr'] + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == source_profile['source_file_count'] and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + helper_dir = a.replica_helper_dir.resolve() + helper_paths = [helper_dir / n for n in ('lift_parent.py', 'replica_parent.py')] + [a.reconstructor.resolve()] + external_hashes = {str(p): sha(p) for p in helper_paths + [a.fill.resolve(), a.order.resolve(), a.dispatch.resolve(), a.comparison_claim.resolve(), a.blocknorm_checker.resolve()]} + need(sha(a.comparison_claim) == COMPARISON_SHA, 'exact pinned frontier headline comparison') + comparison_claim = read(a.comparison_claim) + need('headline_kappa_source' not in comparison_claim and comparison['field'] in comparison_claim, + 'comparison must be full headline outer claim, not supplier-only CLAIM') + previous = Q(comparison_claim[comparison['field']]) + need(previous == Q(comparison_claim['kappa']), 'comparison rational/decimal equality') + order_input = read(a.order) + need(order_input and all(isinstance(x,list) and len(x)==2 and all(type(v)is int for v in x) for x in order_input), 'literal integer call order') + T = 1 + max(r for st,r in order_input) + need(T > 0 and len(order_input)==9*T and set(map(tuple,order_input))=={(st,r) for st in range(9) for r in range(T)}, 'complete new replica coverage') + need(all([st for st,r in order_input if r==rep]==list(range(9)) for rep in range(T)), 'source stage projection') + dispatch_input = read(a.dispatch) + need(len(dispatch_input)==9*T and {(st,r) for st,r,pid in dispatch_input}==set(map(tuple,order_input)), 'complete explicit dispatch') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + # Only the fresh external clone changes. Immutable source/cache inventories remain pinned. + for hp in helper_paths[:2]: + shutil.copy2(hp, package / hp.name) + need(sha(package / hp.name)==external_hashes[str(hp)], 'helper copy hash') + shutil.copy2(a.blocknorm_checker, package / 'blocknorm_certificate.py') + shutil.copy2(a.blocknorm_checker, package / 'code/blocknorm_certificate.py') + need(sha(package / 'blocknorm_certificate.py') == external_hashes[str(a.blocknorm_checker.resolve())], 'block-norm checker exact source binding') + shutil.copy2(a.reconstructor, package / 'reconstruct.py') + need(sha(package / 'reconstruct.py')==external_hashes[str(a.reconstructor.resolve())], 'reconstructor copy hash') + # The original subprocesses also write generated hash-bound source. Windows + # callers use a process-scoped LF adapter; no system configuration is changed. + lf_probe = work / '.lf-preflight.txt' + lf_probe.write_text('LF\n', encoding='utf-8') + need(lf_probe.read_bytes()==b'LF\n', 'process-scoped LF output required on Windows') + lf_probe.unlink() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # At T37 the historical fixed333 mutant is a no-op. Preserve the + # undercharge test by subtracting one from both actual charges, and + # require every geometry mutant to differ before the unchanged assembly. + patch('geometry_controls.py', [ + (" i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1"), + (" o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + # Keep the native dimension and paid moment ledger fixed; bind replica + # width to both the checked source geometry and the independent B invoice. + patch('outer/check_ledger.py', [ + ('assert (m,W)==(73,66304)', + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']")]) + patch('code/witness.py', [(DISCOVERY_APPEND_OLD, DISCOVERY_APPEND_NEW)]) + patch('verify.py', [ + ("run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')")]) + # A sharper local reserve is certified against actual scalar/Horner + # prefixes of BOTH orientations and BOTH providers. All sweep and physical + # row charges remain unchanged; this never omits an invocation or bridge. + patch('code/witness.py', [ + ("PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4")]) + patch('independent_core.py', [ + (" payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm,"), + (" primitive_arithmetic_margin_bits=4,controller_audit_sha256=", " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256="), + ("Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix.")]) + patch('independent_core.py', [ + (" prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4"), + ("prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn")]) + patch('audit_mixed.py', [ + ("pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)")]) + patch('code/assemble.py', [ + (" assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 previous, + 'candidate must strictly improve full exact pinned frontier headline before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=COMPARISON_HEAD, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + (package / 'provenance').mkdir(exist_ok=True) + shutil.copy2(a.comparison_claim, package / ('provenance/PR' + str(comparison_pr) + '-HEADLINE-CLAIM.json')) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + need(all(sha(Path(p))==h for p,h in external_hashes.items()), 'external candidate/helper inputs changed during admission') + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/LICENSE b/research/shared-kernel-packing/vendor/pr2857/allocation/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/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/shared-kernel-packing/vendor/pr2857/allocation/MANIFEST.json b/research/shared-kernel-packing/vendor/pr2857/allocation/MANIFEST.json new file mode 100644 index 0000000000..43a2c216dc --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/MANIFEST.json @@ -0,0 +1,22 @@ +{ + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "642e6acf32c22212f8c249e0ef36f65f7e28bd90eff75cb9b03b3fbcb79d94bf", + "PINS.json": "d6defca921082408338cae3c90ac8466d8a252fb6f3a7e12d6724003732a206e", + "README.md": "93e16cb95c3daf10c2bffa43a818230f7af4c2a14c05ea0099aca872c6ffc6fa", + "construction/COMPRESSION-CONTROLS.json": "225083da80b8d0b2195abea932b73fab989e4b14fe3075cc1c76d25552d81d2b", + "construction/DISCOVERY.log": "e73d6bc740664c1b7b999afd03a96d36d2550a4b90c4ef2998ed8bae78e85337", + "construction/FLOW.json.gz": "432f6e7ea0af6208a5a30323dcda936abfa6689c13cc136a5f0c25b0c498368e", + "construction/MODEL.json": "25c2caab5b6ad85f9977639049b5e4679b6c635d800df43b35b3e580d915365c", + "construction/NEGATIVE-CONTROLS.json": "d1cee69137cf7cf3239b5265f4538bd0e3547650ae5862f5a3579dd3fc16d4eb", + "construction/PR2843-INDEPENDENT-NOTICE": "b1a13e97bf3503b4a52033518dd528d010f57be7b591245bf48910c20320d186", + "construction/PR2843-build_allocation.py": "c8281fef278ff84bc6ff698699cb662f63e150e8f797dba07137103e9d81af71", + "construction/REPLAY-CHECK.json": "8eda15bd557c2dcd153187dd39551e44e4c9f6fcc3b29aa3ede0638c184fe5d9", + "construction/SOLVER.json": "62da09c8cd9a5ed3819e0e222cba83529c049e6e86e182940de2cb434f83f8b1", + "construction/check_compression_policy.py": "810c35176d252db60f01725fe20b71330e5d6f702c4e991cc5552f1e3d53bbb9", + "construction/discover_original.py": "c0aebddeb7271b8dc62cf9ac94b85c40c90f4ec938fc23a9d03c61888232614c", + "replay_allocation.py": "f53a7f44b471dfb9d13ff3e8bdf06f87e402a31e2753118fafb4a27863da337f" + }, + "source_algorithm_head": "47a7227c044cd0cabb1432a06c61dd5d60c07f5a", + "source_algorithm_path": "research/replica-integer-prefix/build_allocation.py" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/NOTICE b/research/shared-kernel-packing/vendor/pr2857/allocation/NOTICE new file mode 100644 index 0000000000..9fd6ca72a3 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/NOTICE @@ -0,0 +1,22 @@ +SPDX-License-Identifier: Apache-2.0 + +The exact per-pattern/time flow construction and regular bipartite multigraph +edge-coloring method are adapted from Marius-Paul Dumitrean's PR2843 +build_allocation.py, at head 47a7227c044cd0cabb1432a06c61dd5d60c07f5a. +Its original header and complete source are retained in construction/. + +Source chronology and physical-family geometry retain Tekalign's PR2751 and +Marius-Paul Dumitrean's replica lineage. The independent owner algorithm is +Dugongue's PR2827/PR2839 work, with retained Tekalign PR2751 geometry and Mason +Hale/PR2696 literal replay lineage. PR2833's dirt-entry providers and source +handoff are Jeremy Kothe's work and retain their full upstream notices. + +The changed provider words, smaller T37 construction, discovery adaptation and +portable exact-flow replay were prepared with substantial OpenAI Codex +assistance. Source author notices remain authoritative; this file does not +claim ownership of their constructions. + +Concurrent PR2853 independently uses the same four helper registers. The +present result's distinction is the cheaper actual local profile, its complete +chronological owner allocation and full independently replayed invoice; the +helper selection is not claimed as novel. diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/PINS.json b/research/shared-kernel-packing/vendor/pr2857/allocation/PINS.json new file mode 100644 index 0000000000..e975ccfde8 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/PINS.json @@ -0,0 +1,23 @@ +{ + "expected_output_payload_sha256": { + "FILL.json.gz": "b2e91b7573e6cf0df8de4079ab2f0bd6ff035581714899db849eb68c7924cd03" + }, + "expected_output_sha256": { + "DISPATCH.json": "5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4", + "FILL.json.gz": "82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501", + "ORDER.json": "84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc", + "PROFILE.json": "f5d91190e5a062585a99c3959615b837271feca987eed04ae7d707d5714b17aa", + "PROVIDERS.json": "b1e31d1b3af2c8db9b8dd8f1337fee7fc2570ee58c1d541c43963c640efa1aa2" + }, + "flow_sha256": "432f6e7ea0af6208a5a30323dcda936abfa6689c13cc136a5f0c25b0c498368e", + "owner_engine_sha256": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "regenerated_gzip_policy": "Accept the SHA256 of the entire decompressed payload; retain original container SHA256 for provenance. Frozen source pins remain container hashes.", + "source_head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", + "source_sha256": { + "inputs/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "inputs/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "new/BORROW-PROVIDERS.json": "3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda" + } +} diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/README.md b/research/shared-kernel-packing/vendor/pr2857/allocation/README.md new file mode 100644 index 0000000000..8fcd2a8d8e --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/README.md @@ -0,0 +1,94 @@ +# T37 exact allocation replay + +This package reconstructs the complete 135,864-role allocation from a saved +integer flow, using the authentic T37 chronology in PR2833's frozen source +owners. It does not reuse any of that source's 480-helper allocation: all 408 +helpers in each new call receive newly realized owners. + +The two actual local providers have width inventory +`{4:26, 5:2, 7:62, 8:84, 9:234}` and paid profile +`{1:2394, 2:642, 3:266, 4:128, 5:26, 8:8}`. The four changed helpers are registers +460, 462, 478 and 480. Their actual words and native admissibility must be +verified separately by the complete contribution's unchanged scientific +guards; this allocation utility does not establish their local algebra. + +Run with NumPy 2.4.5 and SciPy 1.16.1 (tested on Python 3.13.7): + +```sh +PYTHONDONTWRITEBYTECODE=1 OMP_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1 \ +python -B replay_allocation.py \ + --source /absolute/extracted/gmx-t74-borrow43-handoff \ + --owner-engine /absolute/independent_candidate_owners_retired7.py \ + --work /absolute/fresh-output +``` + +The source is PR2833 head `e9307b48d7d1b690939935ecef0f8e524e6d92f4`. +The owner engine is the immutable file from PR2839 head +`2fdd289fcd0896f4691f9dd78a8bf1511573e434`. +`PINS.json` authenticates each actual input and all five emitted artifacts. +Regenerated `FILL.json.gz` is checked by the SHA256 of its entire decompressed +canonical payload, allowing compression-container differences across Python or +zlib versions. The original container SHA256 is retained for provenance; source +artifact container pins remain unchanged. +No solver or network access is needed for replay. The output must be fresh and +outside both source and this package. Source bytecode artifacts are rejected. + +The replay checks all flow constraints with Python integers: exact bin counts, +global pattern counts, time/width demand, per-pattern width supply, source-window +eligibility, and at most one role in a given bin at each time. Each pattern is +then realized by edge coloring a regular bipartite multigraph. The colors are +literal bins; a perfect matching gives at most one role at each time. Distinct +children in one physical family have disjoint strict source windows, which is +checked before realization. The external owner engine subsequently checks every +literal helper, owner, family, prefix offset, time window and full paid profile. +This assigns helper names to existing source slots; it introduces no routing +operation or uncharged relabeling gate. + +The exact integer patterns are: + +| Capacity | Widths | Bin count | +| --- | --- | ---: | +| 8 | 8 | 24,864 | +| 16 | 7,9 | 15,021 | +| 16 | 8,8 | 1,554 | +| 16 | 7 | 1 | +| 32 | 4,9,9,9 | 8,658 | +| 32 | 5,9,9,9 | 666 | +| 32 | 7,7,9,9 | 2,812 | +| 32 | 9,9,9 | 4,440 | +| 48 | 9,9,9,9,9 | 3,197 | +| 48 | empty | 13,379 | + +Idle cost is `8658 H1 + 3197 H3 + 4440 H5 + H9 + 13379 H48`. The rank9 +residue is fully billed. The complete profile is +`{1:805860, 2:213786, 3:91775, 4:42624, 5:13098, 8:2664, 9:1, 48:13379}`; +live width is 33,152, physical width 33,642, and paid rank mass 2,408,256. + +`construction/FLOW.json.gz` is the saved exact integer solution. +`construction/MODEL.json`, `SOLVER.json` and `DISCOVERY.log` record discovery. +CP-SAT 9.14.6206 found a feasible solution in 39.3081 seconds, using four workers, +seed 124 and a 300-second limit. Its `OPTIMAL` status refers to a feasibility +problem and does not assert global optimality of the mathematical bound. + +`construction/discover_original.py` retains the research script as executed; +its original scratch paths are provenance, not a portable entrypoint. +`construction/PR2843-build_allocation.py` preserves the immutable upstream +algorithm used as the starting point. The portable replay removes optimization +and obsolete T74/T124 discovery branches, authenticates source inputs, checks +the saved flow exactly, and preserves the same edge-coloring realization. + +The flow replay was executed in a fresh output path containing a space and +reproduced all five frozen output payloads exactly. The whole contribution's +independent native/global/outer replay is still the authority for the claimed +bound. + +Three deliberately corrupted flows were also tested after refreshing their +test-only digest, so the tests exercise mathematical checks rather than merely +hash rejection: an increased pattern count, an increased time/width count, and +an out-of-window time all fail before an output directory is created. + +`construction/check_compression_policy.py` additionally performs two complete +replays: changing only gzip level and timestamp succeeds with the identical +full payload; changing a single emitted owner offset fails before output. +Its arguments are the same `--source`, `--owner-engine`, and fresh `--work` paths +as above. Results are retained in `construction/COMPRESSION-CONTROLS.json`. diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/COMPRESSION-CONTROLS.json b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/COMPRESSION-CONTROLS.json new file mode 100644 index 0000000000..c4f4ea4c29 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/COMPRESSION-CONTROLS.json @@ -0,0 +1,13 @@ +[ + { + "control": "repacked-container", + "status": "PASS_ACCEPTED_IDENTICAL_FULL_PAYLOAD", + "container_sha256": "2e6b3229d56426ad5dfba236b6369b3089323d2fe48e5517f9b8422bb1134450", + "payload_sha256": "b2e91b7573e6cf0df8de4079ab2f0bd6ff035581714899db849eb68c7924cd03" + }, + { + "control": "wrong-payload", + "status": "PASS_REJECTED_BEFORE_OUTPUT", + "reason": "realization differs from stored witness payload: FILL.json.gz" + } +] diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/FLOW.json.gz b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/FLOW.json.gz new file mode 100644 index 0000000000..585dbcf732 Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/FLOW.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/MODEL.json b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/MODEL.json new file mode 100644 index 0000000000..9505a792dd --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/MODEL.json @@ -0,0 +1 @@ +{"T":37,"constraints":83770,"fixed_roles":0,"flow_variables":99357,"groups":333,"nonzeros":381387,"pattern_variables":777,"variables":100134,"workers":4} \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/NEGATIVE-CONTROLS.json b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/NEGATIVE-CONTROLS.json new file mode 100644 index 0000000000..881c9c0799 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/NEGATIVE-CONTROLS.json @@ -0,0 +1,17 @@ +[ + { + "control": "pattern-count", + "exit": 1, + "rejection": "ValueError: global integer pattern counts differ" + }, + { + "control": "time-width-count", + "exit": 1, + "rejection": "ValueError: pattern-width supply" + }, + { + "control": "ineligible-time", + "exit": 1, + "rejection": "ValueError: ineligible time/width flow" + } +] diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-INDEPENDENT-NOTICE b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-INDEPENDENT-NOTICE new file mode 100644 index 0000000000..df85dcfd9c --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-INDEPENDENT-NOTICE @@ -0,0 +1 @@ +Independent algorithms: Dugongue PR2827, with retained Tekalign PR2751 geometry and Mason Hale/PR2696 literal replay lineage. PR2833 dirt-entry construction and all source notices retain their credits. Paths/pins/comparator derivative prepared with substantial OpenAI Codex assistance. See source/*NOTICE and exact DERIVATION.json. diff --git a/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-build_allocation.py b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-build_allocation.py new file mode 100644 index 0000000000..7c355c4a1e --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/allocation/construction/PR2843-build_allocation.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""PR2833/T124 composition by per-pattern/time flow and exact edge coloring. + +Source chronology/masks: Tekalign, Marius-Paul Dumitrean, and PR2827 lineage. +Construction model and deterministic realization prepared with OpenAI Codex. +No source bytes are modified; independent native owner admission is external. +""" +import argparse,collections,gzip,hashlib,json,pathlib,sys,time,types +from fractions import Fraction as Q +import numpy as np +from scipy.sparse import coo_matrix,csr_matrix +from scipy.sparse.csgraph import maximum_bipartite_matching +from scipy.optimize import milp,Bounds,LinearConstraint +HERE=pathlib.Path(__file__).resolve().parent +CONSTRUCTION=HERE/'construction' +ROOT=HERE.parent.parent +SOURCE=HERE.parent/'superior-replica-kappa' +SUPPORT={'original_build_p33.py': 'aa1d7bfee082a283ee5dd42071f76144b67d19c15b13b2160c0e8a42c976eedd', 'T-EXACT-BOUND.json': '6dc65010c19d41a4b0e6617ad374a794a9a10e4bd15e0ba612b996bae29f023c', 'MODEL.json': 'c2c4459c0860a767f331719cd3bce6b2ca34dc2e36f590f22ad2459d7b0552a7', 'FLOW.json.gz': '0c8e60379cc2db33942ead798bcfcb77e666f6a13d899b61ede7d4edd9b2815f'} +for name,pin in SUPPORT.items(): + if hashlib.sha256((CONSTRUCTION/name).read_bytes()).hexdigest()!=pin:raise ValueError('construction artifact pin '+name) +PIN={'data/ORDER.json':'b9b3eb71f8082a2349224a7a7cddab1cc0e4590ef27c3542755ff7c4c75c7fd0','data/FILL.json.gz':'2f43f57725a7b1d9293d8c4a9617ffc5bb413c4e1539a60e806fdcdecfd82588','data/DISPATCH.json':'5360d34ca04cf4973f37dce872db1f36e57e3f40382da75e4e2676d412a8b509','data/PROFILE.json':'f8146c8703e5c865d45c618ff291ff542fb792cb6cda21e0feb45ad2c5c5ff62','independent_candidate_owners_retired7.py':'77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461'} +for n,pin in PIN.items(): + if hashlib.sha256((SOURCE/n).read_bytes()).hexdigest()!=pin:raise ValueError('source pin '+n) +def read(p): + b=pathlib.Path(p).read_bytes();return json.loads(gzip.decompress(b)if b[:2]==b'\x1f\x8b'else b) +def save(p,x): + b=json.dumps(x,sort_keys=True,separators=(',',':')).encode() + if str(p).endswith('.gz'): + b=bytearray(gzip.compress(b,mtime=0));b[9]=255;b=bytes(b) + pathlib.Path(p).write_bytes(b) +owner=types.ModuleType('pinned_owner');exec(compile((SOURCE/'independent_candidate_owners_retired7.py').read_bytes(),'pinned_owner','exec'),owner.__dict__) +P33=HERE.parent/'gmx-t74-borrow43-handoff' +P33PIN={'new/BORROW-PROVIDERS.json':'3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda','new/borrow-fill/ORDER.json':'aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667','new/borrow-fill/DISPATCH.json':'fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca','new/borrow-fill/FILL.json.gz':'0cb7522e071ff064ada2efec169e23a2fe7d3daf928eec6ba752b166cffb3468'} +for n,pin in P33PIN.items(): + if hashlib.sha256((P33/n).read_bytes()).hexdigest()!=pin:raise ValueError('P33 source pin '+n) +P=SOURCE/'vendor/frontier';template=read(P/'inputs/GLOBAL-TEMPLATE.json.gz');plan=read(P/'inputs/PLAN.json.gz');providers=read(P33/'new/BORROW-PROVIDERS.json') +for pid in providers:providers[pid]['actual_paid_profile']={int(r):n for r,n in providers[pid]['actual_paid_profile'].items()} +widths=providers['gauge44']['widths'];assert widths==providers['extra']['widths'] and providers['gauge44']['actual_paid_profile']==providers['extra']['actual_paid_profile'] +ap=argparse.ArgumentParser();ap.add_argument('--T',type=int,choices=[114,124],default=124);ap.add_argument('--late',type=int,default=300);ap.add_argument('--seconds',type=int,default=240);ap.add_argument('--solver',choices=['cp','highs'],default='cp');ap.add_argument('--reuse',action='store_true');ap.add_argument('--workers',type=int,default=40);ap.add_argument('--work',type=pathlib.Path,required=True);ap.add_argument('--cp-deps',type=pathlib.Path,help='Optional directory containing installed OR-Tools9.11.4210 dependencies for discovery only');a=ap.parse_args() +assert 0=74};oldtimes=[t for t,(_,r)in enumerate(order)if r<74];selected=newtimes|set(oldtimes[-a.late:]if a.late else[]) +WID=[4,5,7,8,9] +tight=read(CONSTRUCTION/'T-EXACT-BOUND.json')['tight_patterns'];pats=collections.defaultdict(list) +for cap,p in tight:pats[cap].append(tuple(p.count(w)for w in WID)) +pats[16].append((0,0,1,0,0)) +fixed=collections.defaultdict(list);oldbybin=collections.defaultdict(list);need=collections.defaultdict(collections.Counter) +for row in rows: + t,h,o,c,p,k=row;oldbybin[o,c,p].append(row) + if t in selected:need[t][widths[h]]+=1 + else:fixed[o,c,p].append(row) +for t in newtimes:need[t]=collections.Counter(widths) +groups=collections.defaultdict(list);oldpattern={};target=collections.Counter() +for(o,c),(cap,lo,hi)in win.items(): + ts=tuple(t for t in sorted(selected)if lo=fi for qi,fi in zip(q,fp))for q in pats[cap]):raise ValueError('fixed pattern outside admissible face') + groups[cap,ts,fp].append(b) + if o<74: + q=tuple(sum(widths[r[1]]==w for r in oldbybin[b])for w in WID);assert q in pats[cap];oldpattern[b]=q;target[cap,q]+=1 +for cap,p,n in [(8,[8],672),(16,[7,9],448),(32,[9,9,9],129),(32,[4,9,9,9],234),(32,[5,9,9,9],18),(32,[7,7,9,9],43),(32,[7,8,8,9],24),(48,[],Q(1799,5)),(48,[9]*5,Q(441,5))]: + v=Q(n)*(a.T-74);assert v.denominator==1;target[cap,tuple(p.count(w)for w in WID)]+=int(v) +G=sorted(groups);groupof={b:gi for gi,g in enumerate(G)for b in groups[g]} +# Every Z variable names an actual pattern, time and width. A pattern/time can +# use at most one item per assigned bin. Each pattern-width supply is exact. +edge=[];lb=[];ub=[];rl=[];ru=[];X={};Z={};hints={} +def cr(l,u=None):j=len(rl);rl.append(l);ru.append(l if u is None else u);return j +def cv(u,hint=0):j=len(lb);lb.append(0);ub.append(u);hints[j]=hint;return j +def put(r,v,n): + if n:edge.append((r,v,n)) +callrow={(t,w):cr(n)for t,c in need.items()for w,n in c.items()};globalrow={key:cr(n)for key,n in target.items()} +oldx=collections.Counter();oldz=collections.Counter() +for b,q in oldpattern.items():oldx[groupof[b],q]+=1 +for t,h,o,c,p,k in rows: + if t in selected:oldz[groupof[o,c,p],oldpattern[o,c,p],t,widths[h]]+=1 +for gi,(cap,ts,fp)in enumerate(G): + nb=len(groups[G[gi]]);br=cr(nb) + for q in pats[cap]: + if not all(qi>=fi for qi,fi in zip(q,fp))or(not ts and q!=fp):continue + if(cap,q)not in globalrow:continue + xv=cv(nb,oldx[gi,q]);X[gi,q]=xv;put(br,xv,1);put(globalrow[cap,q],xv,1) + residual={w:q[j]-fp[j]for j,w in enumerate(WID)if q[j]>fp[j]} + wr={w:cr(0)for w in residual} + for w,n in residual.items():put(wr[w],xv,-n) + for t in ts: + tr=cr(-nb,0);put(tr,xv,-1) + for w in residual: + if(t,w)not in callrow:continue + zv=cv(min(nb,need[t][w]),oldz[gi,q,t,w]);Z[gi,q,t,w]=zv;put(tr,zv,1);put(wr[w],zv,1);put(callrow[t,w],zv,1) +modelinfo=dict(T=a.T,late=a.late,selected_calls=len(selected),groups=len(G),variables=len(lb),pattern_variables=len(X),flow_variables=len(Z),constraints=len(rl),nonzeros=len(edge),workers=a.workers,same_family_windows_disjoint=True) +save(out/'MODEL.json',modelinfo);print('MODEL',modelinfo,flush=True) +rr=np.fromiter((e[0]for e in edge),np.int32);cc=np.fromiter((e[1]for e in edge),np.int32);vv=np.fromiter((e[2]for e in edge),np.float64);mat=coo_matrix((vv,(rr,cc)),shape=(len(rl),len(lb))).tocsr();del edge +if a.reuse: + stored_model=read(CONSTRUCTION/'MODEL.json') + for key in modelinfo: + if key!='workers' and modelinfo[key]!=stored_model[key]:raise ValueError('stored flow model mismatch: '+key) + saved=read(CONSTRUCTION/'FLOW.json.gz');value=np.zeros(len(lb),dtype=np.int64) + for gi,q,n in saved['x']:value[X[gi,tuple(q)]]=n + for gi,q,t,w,n in saved['z']:value[Z[gi,tuple(q),t,w]]=n + status='REPLAY_EXACT_FLOW' +elif a.solver=='highs': + r=milp(np.zeros(len(lb)),integrality=np.ones(len(lb)),bounds=Bounds(lb,ub),constraints=LinearConstraint(mat,rl,ru),options={'threads':a.workers,'time_limit':a.seconds,'mip_rel_gap':0,'disp':True}) + status=r.message;value=None if r.x is None else np.rint(r.x).astype(np.int64) + if value is not None and np.max(abs(value-r.x))>1e-5:raise ValueError('fractional solver output') +else: + if a.cp_deps:sys.path.insert(0,str(a.cp_deps.resolve())) + from ortools.sat.python import cp_model + model=cp_model.CpModel();vs=[model.NewIntVar(l,u,'')for l,u in zip(lb,ub)] + for j,(l,u)in enumerate(zip(rl,ru)): + b,e=mat.indptr[j:j+2];ind=mat.indices[b:e];co=mat.data[b:e];expr=cp_model.LinearExpr.WeightedSum([vs[int(k)]for k in ind],[int(k)for k in co]);model.AddLinearConstraint(expr,l,u) + for j,v in hints.items():model.AddHint(vs[j],v) + solver=cp_model.CpSolver();solver.parameters.num_search_workers=a.workers;solver.parameters.max_time_in_seconds=a.seconds;solver.parameters.random_seed=124;solver.parameters.log_search_progress=True + result=solver.Solve(model);status=solver.StatusName(result);value=np.array([solver.Value(v)for v in vs],dtype=np.int64)if result in(cp_model.OPTIMAL,cp_model.FEASIBLE)else None + print(solver.ResponseStats(),flush=True) +print('SOLVER',status,flush=True) +if value is None:save(out/'SOLVER.json',{'status':status,'candidate':False});raise SystemExit(2) +if np.any(valueub)or np.any(mat@valueru):raise ValueError('exact integer constraint failure') +xc=collections.defaultdict(collections.Counter);zc=collections.defaultdict(collections.Counter) +for(gi,q),v in X.items(): + if value[v]:xc[gi][q]=int(value[v]) +for(gi,q,t,w),v in Z.items(): + if value[v]:zc[gi,q][t,w]=int(value[v]) +save(out/'FLOW.json.gz',{'x':[[gi,list(q),n]for gi,c in xc.items()for q,n in c.items()],'z':[[gi,list(q),t,w,n]for(gi,q),c in zc.items()for(t,w),n in c.items()]}) +# For one pattern, split each width into q_w identical slots. Balance each slot +# to degree n, complete the bipartite multigraph to n-regular with dummy slots, +# then peel n perfect matchings. Each color is a literal bin, never twice/time. +def color_pattern(n,residual,counts): + slots=[w for j,w in enumerate(WID)for _ in range(residual[j])] + if not slots: + assert not counts;return [[]for _ in range(n)] + times=sorted({t for t,w in counts});K=len(times);assert K>=len(slots);ti={t:j for j,t in enumerate(times)};A=np.zeros((K,K),dtype=np.int64);slot_by_w=collections.defaultdict(list) + for j,w in enumerate(slots):slot_by_w[w].append(j) + for w,js in slot_by_w.items(): + atslot=0;remaining=n + for t in times: + needed=counts.get((t,w),0) + while needed: + take=min(needed,remaining);A[ti[t],js[atslot]]+=take;needed-=take;remaining-=take + if remaining==0:atslot+=1;remaining=n + assert atslot==len(js) + assert all(v<=n for v in A.sum(axis=1));j=len(slots);remaining=n + for r in range(K): + needed=n-int(A[r].sum()) + while needed: + assert j0),perm_type='column');assert len(matching)==K and min(matching)>=0 and len(set(map(int,matching)))==K + output.append([(times[r],slots[int(c)])for r,c in enumerate(matching)if c=min(hi,h)for l,h,d in ww[i+1:]) +oldbybin=collections.defaultdict(list) +for row in oldfill['rows']:oldbybin[tuple(row[2:5])].append(row) +fixed=[];active={};need={t:collections.Counter(widths)for t in range(len(order))} +fixed45=set();f9=collections.Counter() +for b,rs in oldbybin.items(): + ww=[oldwidth[r[1]]for r in rs] + if 4 in ww or 5 in ww: + fixed45.add(b) + for r in rs: + if oldwidth[r[1]]==9:f9[r[0]]+=1 +bad={t for t,n in f9.items()if n>234} +if a.freeze45:fixed45={b for b in fixed45 if not any(r[0]in bad for r in oldbybin[b])} +else:fixed45=set() +fixedpat=collections.Counter() +for(o,c),(cap,lo,hi)in win.items(): + for port in range(112): + b=(o,c,port);rr=oldbybin[b];ww=[oldwidth[r[1]]for r in rr] + if (cap==8 and T!=37) or b in fixed45: + if b in fixed45:fixedpat[cap,tuple(ww.count(w)for w in WID)]+=1 + for t,h,oo,cc,pp,z in rr: + w=oldwidth[h];fixed.append((t,w,oo,cc,pp,z));need[t][w]-=1 + else:active[b]=(cap,lo,hi) +assert all(n>=0 for cc in need.values()for n in cc.values()) +assert all(set(w for w,n in cc.items()if n)<=set(WID)for cc in need.values()) +pats={16:[(0,0,1,0,1),(0,0,0,2,0),(0,0,1,0,0)],32:[(0,0,2,0,2),(0,0,0,0,3),(1,0,0,0,3),(0,1,0,0,3)],48:[(0,0,0,0,0),(0,0,0,0,5)]} +residue=1 if T==37 else 2 +target={(16,(0,0,1,0,1)):406*T-residue,(16,(0,0,0,2,0)):42*T,(16,(0,0,1,0,0)):residue,(32,(0,0,2,0,2)):76*T,(32,(0,0,0,0,3)):120*T,(32,(1,0,0,0,3)):234*T,(32,(0,1,0,0,3)):18*T,(48,(0,0,0,0,5)):(432*T+residue)//5,(48,(0,0,0,0,0)):448*T-(432*T+residue)//5} +if T==37:pats[8]=[(0,0,0,1,0)];target[8,(0,0,0,1,0)]=672*T +for key,n in fixedpat.items():target[key]-=n +assert (432*T+residue)%5==0 +groups=collections.defaultdict(list) +for b,(cap,lo,hi)in active.items():groups[cap,tuple(range(max(0,lo+1),min(len(order),hi+1)))].append(b) +G=sorted(groups);groupof={b:gi for gi,g in enumerate(G)for b in groups[g]} +oldx=collections.Counter();oldz=collections.Counter() +for b in active: + q=tuple(sum(oldwidth[r[1]]==w for r in oldbybin[b])for w in WID);gi=groupof[b];oldx[gi,q]+=1 + for t,h,o,c,p,z in oldbybin[b]:oldz[gi,q,t,oldwidth[h]]+=1 +edge=[];lb=[];ub=[];rl=[];ru=[];X={};Z={};hints={} +def cr(l,u=None):j=len(rl);rl.append(l);ru.append(l if u is None else u);return j +def cv(u,hint=0):j=len(lb);lb.append(0);ub.append(u);hints[j]=hint;return j +def put(r,v,n): + if n:edge.append((r,v,n)) +callrow={(t,w):cr(n)for t,c in need.items()for w,n in c.items()if n};globalrow={key:cr(n)for key,n in target.items()} +for gi,(cap,ts)in enumerate(G): + nb=len(groups[G[gi]]);br=cr(nb) + for q in pats[cap]: + xv=cv(nb,oldx[gi,q]);X[gi,q]=xv;put(br,xv,1);put(globalrow[cap,q],xv,1) + residual={w:q[j]for j,w in enumerate(WID)if q[j]};wr={w:cr(0)for w in residual} + for w,n in residual.items():put(wr[w],xv,-n) + for t in ts: + tr=cr(-nb,0);put(tr,xv,-1) + for w in residual: + if(t,w)not in callrow:continue + zv=cv(min(nb,need[t][w]),oldz[gi,q,t,w]);Z[gi,q,t,w]=zv;put(tr,zv,1);put(wr[w],zv,1);put(callrow[t,w],zv,1) +modelinfo=dict(T=T,groups=len(G),variables=len(lb),pattern_variables=len(X),flow_variables=len(Z),constraints=len(rl),nonzeros=len(edge),fixed_roles=len(fixed),workers=a.workers) +save(out/'MODEL.json',modelinfo);print('MODEL',modelinfo,flush=True) +rr=np.fromiter((e[0]for e in edge),np.int32);cc=np.fromiter((e[1]for e in edge),np.int32);vv=np.fromiter((e[2]for e in edge),np.float64);mat=coo_matrix((vv,(rr,cc)),shape=(len(rl),len(lb))).tocsr();del edge +if a.reuse: + saved=read(a.reuse);value=np.zeros(len(lb),dtype=np.int64) + for gi,q,n in saved['x']:value[X[gi,tuple(q)]]=n + for gi,q,t,w,n in saved['z']:value[Z[gi,tuple(q),t,w]]=n + status='EXACT_FLOW_REPLAY' +elif a.solver=='highs': + r=milp(np.zeros(len(lb)),integrality=np.ones(len(lb)),bounds=Bounds(lb,ub),constraints=LinearConstraint(mat,rl,ru),options={'threads':a.workers,'time_limit':a.seconds,'mip_rel_gap':0,'disp':True});status=r.message;value=None if r.x is None else np.rint(r.x).astype(np.int64) + if value is not None:assert np.max(abs(value-r.x))<1e-5 +else: + from ortools.sat.python import cp_model + model=cp_model.CpModel();vs=[model.NewIntVar(l,u,'')for l,u in zip(lb,ub)] + for j,(l,u)in enumerate(zip(rl,ru)): + b,e=mat.indptr[j:j+2];ind=mat.indices[b:e];co=mat.data[b:e];model.AddLinearConstraint(cp_model.LinearExpr.WeightedSum([vs[int(k)]for k in ind],[int(k)for k in co]),l,u) + for j,v in hints.items():model.AddHint(vs[j],v) + solver=cp_model.CpSolver();solver.parameters.num_search_workers=a.workers;solver.parameters.max_time_in_seconds=a.seconds;solver.parameters.random_seed=124;solver.parameters.log_search_progress=True + result=solver.Solve(model);status=solver.StatusName(result);value=np.array([solver.Value(v)for v in vs],dtype=np.int64)if result in(cp_model.OPTIMAL,cp_model.FEASIBLE)else None + print(solver.ResponseStats(),flush=True) +print('SOLVER',status,flush=True) +if value is None:save(out/'SOLVER.json',dict(status=status,candidate=False));raise SystemExit(2) +assert not(np.any(valueub)or np.any(mat@valueru)) +xc=collections.defaultdict(collections.Counter);zc=collections.defaultdict(collections.Counter) +for(gi,q),v in X.items(): + if value[v]:xc[gi][q]=int(value[v]) +for(gi,q,t,w),v in Z.items(): + if value[v]:zc[gi,q][t,w]=int(value[v]) +save(out/'FLOW.json.gz',{'x':[[gi,list(q),n]for gi,c in xc.items()for q,n in c.items()],'z':[[gi,list(q),t,w,n]for(gi,q),c in zc.items()for(t,w),n in c.items()]}) +def color_pattern(n,q,counts): + slots=[w for j,w in enumerate(WID)for _ in range(q[j])] + if not slots:assert not counts;return [[]for _ in range(n)] + times=sorted({t for t,w in counts});K=len(times);assert K>=len(slots);ti={t:j for j,t in enumerate(times)};A=np.zeros((K,K),dtype=np.int64);slot_by_w=collections.defaultdict(list) + for j,w in enumerate(slots):slot_by_w[w].append(j) + for w,js in slot_by_w.items(): + atslot=0;remaining=n + for t in times: + needed=counts.get((t,w),0) + while needed: + take=min(needed,remaining);A[ti[t],js[atslot]]+=take;needed-=take;remaining-=take + if remaining==0:atslot+=1;remaining=n + assert atslot==len(js) + assert all(v<=n for v in A.sum(axis=1));j=len(slots);remaining=n + for r in range(K): + needed=n-int(A[r].sum()) + while needed: + assert j0),perm_type='column');assert len(matching)==K and min(matching)>=0 and len(set(map(int,matching)))==K + output.append([(times[r],slots[int(c)])for r,c in enumerate(matching)if c 0 + + +def authenticate_output(name, raw, pins): + """Regenerated gzip containers may differ; bind the complete payload bytes.""" + if name.endswith('.gz'): + payload = gzip.decompress(raw) + expected = pins['expected_output_payload_sha256'][name] + else: + payload = raw + expected = pins['expected_output_sha256'][name] + require(hashlib.sha256(payload).hexdigest() == expected, + 'realization differs from stored witness payload: ' + name) + + +def realize_pattern(n, pattern, counts, np, csr_matrix, maximum_bipartite_matching): + """Use n matchings of an n-regular bipartite multigraph as literal bins.""" + slots = [w for j, w in enumerate(WID) for _ in range(pattern[j])] + if not slots: + require(not counts, 'empty pattern has nonempty time flow') + return [[] for _ in range(n)] + times = sorted({t for t, w in counts}) + K = len(times) + require(K >= len(slots), 'insufficient distinct times for a pattern') + ti = {t: j for j, t in enumerate(times)} + A = np.zeros((K, K), dtype=np.int64) + slot_by_w = collections.defaultdict(list) + for j, w in enumerate(slots): + slot_by_w[w].append(j) + for w, js in slot_by_w.items(): + atslot, remaining = 0, n + for t in times: + needed = counts.get((t, w), 0) + while needed: + take = min(needed, remaining) + A[ti[t], js[atslot]] += take + needed -= take + remaining -= take + if remaining == 0: + atslot += 1 + remaining = n + require(atslot == len(js), 'slot supply mismatch') + require(all(v <= n for v in A.sum(axis=1)), 'time degree exceeds bin count') + j, remaining = len(slots), n + for r in range(K): + needed = n - int(A[r].sum()) + while needed: + require(j < K, 'dummy slot overflow') + take = min(needed, remaining) + A[r, j] += take + needed -= take + remaining -= take + if remaining == 0: + j += 1 + remaining = n + require(np.all(A.sum(axis=0) == n) and np.all(A.sum(axis=1) == n), 'graph is not regular') + output = [] + for color in range(n): + matching = maximum_bipartite_matching(csr_matrix(A > 0), perm_type='column') + require(len(matching) == K and min(matching) >= 0 and len(set(map(int, matching))) == K, + 'perfect matching failure') + output.append([(times[r], slots[int(c)]) for r, c in enumerate(matching) if c < len(slots)]) + A[np.arange(K), matching] -= 1 + require(not A.any(), 'unassigned graph edges') + return output + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--source', required=True, type=pathlib.Path, + help='Exact extracted PR2833 gmx-t74-borrow43-handoff directory') + ap.add_argument('--owner-engine', required=True, type=pathlib.Path, + help='Pinned independent_candidate_owners_retired7.py from PR2839') + ap.add_argument('--work', required=True, type=pathlib.Path, help='Fresh output directory') + args = ap.parse_args() + source, out = args.source.resolve(), args.work.resolve() + require(not out.exists(), 'output must be fresh') + require(not out.is_relative_to(source) and not out.is_relative_to(HERE), 'output must be outside sources') + require(not any(p.name == '__pycache__' or p.suffix == '.pyc' for p in source.rglob('*')), + 'source contains bytecode artifacts') + pins = read(HERE / 'PINS.json') + for name, digest in pins['source_sha256'].items(): + authenticate(source / name, digest) + owner_code = authenticate(args.owner_engine, pins['owner_engine_sha256']) + authenticate(HERE / 'construction/FLOW.json.gz', pins['flow_sha256']) + + # Imports occur only after the immutable scientific inputs are authenticated. + import numpy as np + from scipy.sparse import csr_matrix + from scipy.sparse.csgraph import maximum_bipartite_matching + + owner = types.ModuleType('pinned_owner') + exec(compile(owner_code, str(args.owner_engine), 'exec'), owner.__dict__) + template = read(source / 'inputs/GLOBAL-TEMPLATE.json.gz') + plan = read(source / 'inputs/PLAN.json') + historical_owners = read(source / 'inputs/OWNERS.json.gz') + timecalls = {} + for row in historical_owners: + key, call = row['time'], (row['stage'], row['replica']) + require(key not in timecalls or timecalls[key] == call, 'ambiguous historical time') + timecalls[key] = call + require(set(timecalls) == set(range(9 * T)), 'historical call coverage') + order = [list(timecalls[t]) for t in range(9 * T)] + dispatch = read(source / 'inputs/DISPATCH.json') + require(len(dispatch) == 9 * T and {(s, r) for s, r, pid in dispatch} == set(map(tuple, order)), + 'dispatch coverage') + require({pid for s, r, pid in dispatch} == {'gauge44', 'extra'}, 'provider coverage') + + providers = read(source / 'new/BORROW-PROVIDERS.json') + for pid in providers: + widths = providers[pid]['widths'] + require(len(widths) == 408, 'source helper count') + for register in (478, 460, 462, 480): + require(widths[register - 224] == 9, 'source changed-helper width') + widths[register - 224] = 8 + providers[pid]['actual_paid_profile'] = {1: 2394, 2: 642, 3: 266, 4: 128, 5: 26, 8: 8} + widths = providers['gauge44']['widths'] + require(widths == providers['extra']['widths'], 'provider inventory mismatch') + require(collections.Counter(widths) == {4: 26, 5: 2, 7: 62, 8: 84, 9: 234}, 'new width inventory') + + win = owner.windows(template, order, T) + family = lambda b: b[0] * 896 + (2 * plan['pairs'][str(b[1])] + plan['sides'][str(b[1])]) * 112 + b[2] + family_windows = collections.defaultdict(list) + for (o, c), (cap, lo, hi) in win.items(): + family_windows[family((o, c, 0))].append((lo, hi, c)) + for windows in family_windows.values(): + for i, (lo, hi, c) in enumerate(windows): + require(all(max(lo, l) >= min(hi, h) for l, h, d in windows[i + 1:]), + 'overlapping source windows in one physical family') + + groups = collections.defaultdict(list) + for (o, c), (cap, lo, hi) in win.items(): + times = tuple(range(max(0, lo + 1), min(len(order), hi + 1))) + for port in range(112): + groups[cap, times].append((o, c, port)) + G = sorted(groups) + patterns = { + 8: [(0, 0, 0, 1, 0)], + 16: [(0, 0, 1, 0, 1), (0, 0, 0, 2, 0), (0, 0, 1, 0, 0)], + 32: [(0, 0, 2, 0, 2), (0, 0, 0, 0, 3), (1, 0, 0, 0, 3), (0, 1, 0, 0, 3)], + 48: [(0, 0, 0, 0, 0), (0, 0, 0, 0, 5)], + } + target = { + (8, (0, 0, 0, 1, 0)): 672 * T, + (16, (0, 0, 1, 0, 1)): 406 * T - 1, + (16, (0, 0, 0, 2, 0)): 42 * T, + (16, (0, 0, 1, 0, 0)): 1, + (32, (0, 0, 2, 0, 2)): 76 * T, + (32, (0, 0, 0, 0, 3)): 120 * T, + (32, (1, 0, 0, 0, 3)): 234 * T, + (32, (0, 1, 0, 0, 3)): 18 * T, + (48, (0, 0, 0, 0, 5)): (432 * T + 1) // 5, + (48, (0, 0, 0, 0, 0)): 448 * T - (432 * T + 1) // 5, + } + flow = read(HERE / 'construction/FLOW.json.gz') + xc, zc = collections.defaultdict(collections.Counter), collections.defaultdict(collections.Counter) + global_count = collections.Counter() + for gi, raw_pattern, n in flow['x']: + require(type(gi) is int and 0 <= gi < len(G) and positive_integer(n), 'invalid pattern count') + pattern = tuple(raw_pattern) + require(pattern in patterns[G[gi][0]] and pattern not in xc[gi], 'invalid or duplicate pattern') + xc[gi][pattern] = n + global_count[G[gi][0], pattern] += n + require(dict(global_count) == target, 'global integer pattern counts differ') + for gi in range(len(G)): + require(sum(xc[gi].values()) == len(groups[G[gi]]), 'window class bin count') + call_count = collections.defaultdict(collections.Counter) + for gi, raw_pattern, t, w, n in flow['z']: + pattern = tuple(raw_pattern) + require(type(gi) is int and 0 <= gi < len(G) and pattern in xc[gi], 'unknown pattern flow') + require(type(t) is int and t in G[gi][1] and w in WID and pattern[WID.index(w)] > 0, + 'ineligible time/width flow') + require(positive_integer(n) and (t, w) not in zc[gi, pattern], 'invalid or duplicate time flow') + zc[gi, pattern][t, w] = n + call_count[t][w] += n + for gi, counts in xc.items(): + for pattern, n in counts.items(): + by_width, by_time = collections.Counter(), collections.Counter() + for (t, w), count in zc[gi, pattern].items(): + by_width[w] += count + by_time[t] += count + require(all(by_width[w] == pattern[j] * n for j, w in enumerate(WID)), 'pattern-width supply') + require(all(count <= n for count in by_time.values()), 'more than one role per bin/time') + require(set(call_count) == set(range(9 * T)), 'flow call coverage') + require(all(call_count[t] == collections.Counter(widths) for t in range(9 * T)), 'flow call width demand') + + slots = [] + for gi, (cap, times) in enumerate(G): + bins, offset = groups[G[gi]], 0 + for pattern, n in sorted(xc[gi].items()): + assigned = realize_pattern(n, pattern, zc[gi, pattern], np, csr_matrix, maximum_bipartite_matching) + for b, entries in zip(bins[offset:offset + n], assigned): + z = 0 + for t, w in sorted(entries): + slots.append((t, w, *b, z)) + z += w + require(z <= cap, 'bin capacity exceeded') + offset += n + require(offset == len(bins), 'unassigned literal bins') + available = {t: collections.defaultdict(list) for t in range(9 * T)} + for t in available: + for h, w in enumerate(widths): + available[t][w].append(h) + rows = [] + for t, w, o, c, port, z in sorted(slots): + require(available[t][w], 'helper width shortage') + rows.append([t, available[t][w].pop(), o, c, port, z]) + require(not any(v for d in available.values() for v in d.values()), 'unassigned literal helpers') + fill = {'columns': ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'], + 'dispatch_overrides': [], 'rows': sorted(rows)} + profile = {1: 805860, 2: 213786, 3: 91775, 4: 42624, 5: 13098, 8: 2664, 9: 1, 48: 13379} + result, _, _ = owner.check(T, order, fill, {(s, r): pid for s, r, pid in dispatch}, + profile, plan, template, providers) + payloads = {'ORDER.json': order, 'FILL.json.gz': fill, 'DISPATCH.json': dispatch, + 'PROFILE.json': profile, 'PROVIDERS.json': providers} + encoded = {name: encode(obj, name.endswith('.gz')) for name, obj in payloads.items()} + for name, raw in encoded.items(): + authenticate_output(name, raw, pins) + out.mkdir(parents=True) + for name, raw in encoded.items(): + (out / name).write_bytes(raw) + result.update(status='PASS_EXACT_FLOW_LITERAL_ALLOCATION_REPLAY', + full_native_and_outer_admission='required separately', + source_head=pins['source_head']) + (out / 'ALLOCATION-REPLAY.json').write_bytes(encode(result)) + print(json.dumps(result, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/audit_owners.py b/research/shared-kernel-packing/vendor/pr2857/audit_owners.py new file mode 100644 index 0000000000..4da762eea0 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/audit_owners.py @@ -0,0 +1,168 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent literal-owner and rational-moment audit for shared-kernel repacking. +Prepared by Yiyang with OpenAI Codex assistance; arithmetic extends our T248 audit. + +No producer, inherited checker or numerical library is imported. For 1<=y<=2, +log(y)=2*sum_{j>=0} z^(2j+1)/(2j+1), z=(y-1)/(y+1). After100 terms the tail +is at most 2*z^201/(201*(1-z^2)). Binary range reduction and outward rational +rounding at10^-45 preserve inclusion. For0<=x<1, the Taylor sum through degree18 +has positive remainder at most (x^18/18!)*x/19/(1-x/20). The geometric denominator +bounds all ratios after the first omitted term. All subsequent operations use +Fraction. The resulting finite intervals certify moment signs, not physical +realization or an unconditional multiplication theorem. +""" +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path +from collections import Counter,defaultdict +import argparse,json,hashlib,gzip +SCALE=10**45 + +def need(c,m): + if not c:raise ValueError(m) +def blob(pin,data): + need(hashlib.sha256(data).hexdigest()==pin['sha256'],'source SHA256: '+pin['name']) + need(hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==pin['git_blob'],'source Git blob: '+pin['name']) +# Exact fixture pins from PR2833, PR2843 and PR2848; source bytes are never executed. +FIXED_PINS = {'PR2833-WORD-base.json.gz': ('dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7', 'd3878e3be59c50ef60ef1d758215547554134c39'), 'PR2833-WORD-extra.json.gz': ('bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac', '0638b6ad9d29eec2be61bdb46140c0c5b7b0d21b'), 'PR2833-T37-TEMPLATE.json.gz': ('21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e', '114808c32b1799da53524bdc25cea67efb60009e'), 'PR2833-PROVIDERS.json': ('3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda', 'bf7c87b4d1b0fc72b8048751782f9ea6d6657096'), 'PR2833-PLAN.json': ('163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08', '5af9dd20821ae5b79778d85cd7183873c5999732'), 'PR2833-ORDER.json': ('aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667', '7141bd58cc465e28f0189345713ddd366c814ca4'), 'PR2833-DISPATCH.json': ('fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca', '693ed0d022791c43d59000718521fded1ef8def7'), 'PR2843-ORDER.json': ('5fc45c6e6a50db17c1eb2577d36e0dab3057005bc269ea6be1241c79f61aeced', 'b5cc1c6e73ea923bfbc78a493dd25eccf47b532c'), 'PR2843-DISPATCH.json': ('e06a95c589425f92e4cce90b0d71664b96d5955bb34d9ffefdae4b432fa8746b', '1c0260deab477a1600254e3bfc6a3dc69ae483b8'), 'PR2848-CLAIM.json': ('aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', '16125d43c4479676f3aa7593574be30780cd3506'), 'PR2848-ORDER.json': ('f6b3bcd6ae7e7f0339cd881204bffc095509cf738982a2d8e221cd622cd54fb1', '73cc025938918fd7876bbcfc0daf54783d7d2629'), 'PR2848-DISPATCH.json': ('24d263f53c792558b1639a85e9f6ed4ee8633d36812db82957006bfbb7e523f7', '30e94fd4fcff569217e0d8b2c8fcceb74d6d21e2')} + +FIXED_PINS.update({'PR2833-T37-OWNERS.json.gz': ('3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f', '34fa5d69aaa2574af60f1e8f7d43640b03698bca'), 'PR2833-T37-DISPATCH.json': ('b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4', '613e01490d24a39e551ba75915320617003c1c81')}) + +def sources(folder): + folder=folder/'sources' if (folder/'sources').is_dir() else folder + raw={};pins=[] + for name,(sha,git) in FIXED_PINS.items(): + p=folder/name + if p.exists():data=p.read_bytes() + elif name=='PR2833-PLAN.json' and (folder/(name+'.gz')).exists():data=gzip.decompress((folder/(name+'.gz')).read_bytes()) + else:continue + pin={'name':name,'sha256':sha,'git_blob':git};blob(pin,data);raw[name]=data;pins.append(pin) + return pins,raw + +def decode(data,compressed=False):return json.loads(gzip.decompress(data)if compressed else data) +@lru_cache(None) +def logarithm(x): + need(x>=1,'log argument');k=0 + while x>=2:x/=2;k+=1 + def unit(y): + z=(y-1)/(y+1);power=z;total=Q(0) + for j in range(100):total+=power/(2*j+1);power*=z*z + total*=2;tail=2*power/(201*(1-z*z)) + return total,total+tail + lo,hi=unit(x);l2,h2=unit(Q(2));lo+=k*l2;hi+=k*h2 + return Q((lo*SCALE).__floor__(),SCALE),Q((hi*SCALE).__ceil__(),SCALE) +def exponential(x): + need(0<=x<1,'exp argument');term=total=Q(1) + for j in range(1,19):term*=x/j;total+=term + tail=term*x/19/(1-x/20) + return total,total+tail +def moment(profile,b,W): + lo=hi=Q(0) + for rank,count in profile.items(): + need(00,'child profile');l,h=logarithm(Q(73,rank));e0=exponential(b*l)[0];e1=exponential(b*h)[1] + lo+=Q(count*rank,73*W)*e0;hi+=Q(count*rank,73*W)*e1 + return Q((lo*SCALE).__floor__(),SCALE),Q((hi*SCALE).__ceil__(),SCALE) + +def read(path):return decode(path.read_bytes(),path.suffix=='.gz') +CANDIDATE_WORD_PINS={'gauge44':'001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458','extra':'bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546'} +def frame_rank(vectors): + rows={} + for x in vectors: + while x: + k=x.bit_length()-1 + if k in rows:x^=rows[k] + else:rows[k]=x;break + return len(rows) +def audit(base,D,words_dir): + pins,raw=sources(base) + def source(name):return decode(raw[name],name.endswith('.gz')) + order=read(D/'ORDER.json');rows=read(D/'FILL.json.gz')['rows'];drows=read(D/'DISPATCH.json');dispatch={(s,r):p for s,r,p in drows};providers=read(D/'PROVIDERS.json') + template=source('PR2833-T37-TEMPLATE.json.gz');plan=source('PR2833-PLAN.json');oldproviders=source('PR2833-PROVIDERS.json') + order_source=None + for prefix in ['PR2848','PR2843','PR2833']: + if prefix+'-ORDER.json'not in raw or prefix+'-DISPATCH.json'not in raw:continue + old_order=source(prefix+'-ORDER.json');old_dispatch=source(prefix+'-DISPATCH.json') + if order==old_order and dispatch=={(s,r):p for s,r,p in old_dispatch}:order_source=prefix;break + if order_source is None and 'PR2833-T37-OWNERS.json.gz'in raw: + timecalls={} + for row in source('PR2833-T37-OWNERS.json.gz'): + t=row['time'];pair_=[row['stage'],row['replica']] + need(t not in timecalls or timecalls[t]==pair_,'unique source T37 time-to-call map');timecalls[t]=pair_ + need(set(timecalls)==set(range(333)),'complete source T37 chronology') + old_order=[timecalls[t]for t in range(333)];old_dispatch=source('PR2833-T37-DISPATCH.json') + if order==old_order and dispatch=={(s,r):p for s,r,p in old_dispatch}:order_source='PR2833-T37' + need(order_source is not None,'authenticated exact call order and provider dispatch') + T=1+max(r for s,r in order);calls=9*T;W=896*T + need(len(order)==len(set(map(tuple,order)))==len(dispatch)==len(drows)==calls,'complete unique calls') + need(set(providers)==set(oldproviders),'provider coverage') + word_hashes={};canonical_hashes={} + for pid,p in providers.items(): + word_name='WORD-base.json.gz'if pid=='gauge44'else'WORD-extra.json.gz';word_bytes=(words_dir/word_name).read_bytes();word_hashes[pid]=hashlib.sha256(word_bytes).hexdigest() + need(word_hashes[pid]==CANDIDATE_WORD_PINS[pid],'fixed candidate word SHA256') + word=decode(word_bytes,True);canonical_hashes[pid]=hashlib.sha256(json.dumps(word,sort_keys=True,separators=(',',':')).encode()).hexdigest() + ids=[q for q in range(2*word['report']['v'],2*word['report']['v']+word['report']['R'])if q not in set(word['removed'])] + ordered_widths=[frame_rank(word['helper_final'].get(str(q),[1<0 and 0=0,'role ranges') + width=providers[dispatch[tuple(order[t])]]['widths'][h];begin,end=interval[owner,ch] + need(begin>h&1,'duplicate helper');helpers[t]|=1<1 else'UNRESOLVED' + G=10**25;low=0;high=G//100 + need(moment(profile,Q(low,G),W)[1]<11: + mid=(low+high)//2;a,b=moment(profile,Q(mid,G),W) + if b<1:low=mid + elif a>1:high=mid + else:raise ValueError('root interval precision exhausted') + return dict(complex_lower=str(Q(low,G)),complex_upper=str(Q(high,G)),gain_lower=str(Q(low,G)-prior),gain_upper=str(Q(high,G)-prior),candidate_word_sha256=word_hashes,candidate_word_canonical_sha256=canonical_hashes,status='PASS_INDEPENDENT_ACTUAL_REPACK_OWNERS',order_source=order_source,roles=len(rows),calls=calls,replicas=T,live=W,rank_mass=mass,profile=dict(sorted(profile.items())),idle=dict(sorted(idle.items())),gain_thresholds=tests,prior_kappa=str(prior),window_coordinate='expanded source-event positions, strict endpoints; exact per-replica event projection checked',candidate_sha256={name:hashlib.sha256((D/name).read_bytes()).hexdigest()for name in ['FILL.json.gz','ORDER.json','DISPATCH.json','PROVIDERS.json']},source_sha256={pin['name']:pin['sha256']for pin in pins},scope='Literal unchanged-order owner feasibility, all idle costs and independent exact moment signs. Candidate provider scalar/native validity and full prefix/outer admission remain separate.') + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--base','--source-dir',dest='base',type=Path,required=True);ap.add_argument('--candidate','--candidate-dir',dest='candidate',type=Path,required=True);ap.add_argument('--words-dir',type=Path,required=True);a=ap.parse_args();print(json.dumps(audit(a.base,a.candidate,a.words_dir),sort_keys=True,indent=2)) diff --git a/research/shared-kernel-packing/vendor/pr2857/audit_relaxation.py b/research/shared-kernel-packing/vendor/pr2857/audit_relaxation.py new file mode 100644 index 0000000000..e917e4c68a --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/audit_relaxation.py @@ -0,0 +1,156 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent shared-kernel changed-inventory LP and rational-moment audit. +Prepared by Yiyang with OpenAI Codex assistance; arithmetic extends our T248 audit. + +No producer, inherited checker or numerical library is imported. For 1<=y<=2, +log(y)=2*sum_{j>=0} z^(2j+1)/(2j+1), z=(y-1)/(y+1). After100 terms the tail +is at most 2*z^201/(201*(1-z^2)). Binary range reduction and outward rational +rounding at10^-45 preserve inclusion. For0<=x<1, the Taylor sum through degree18 +has positive remainder at most (x^18/18!)*x/19/(1-x/20). The geometric denominator +bounds all ratios after the first omitted term. All subsequent operations use +Fraction. The resulting finite intervals certify moment signs, not physical +realization or an unconditional multiplication theorem. +""" +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path +from collections import Counter,defaultdict +import argparse,json,hashlib,gzip +SCALE=10**45 + +def need(c,m): + if not c:raise ValueError(m) +def blob(pin,data): + need(hashlib.sha256(data).hexdigest()==pin['sha256'],'source SHA256: '+pin['name']) + need(hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest()==pin['git_blob'],'source Git blob: '+pin['name']) +# Exact fixture pins from PR2833, PR2843 and PR2848; source bytes are never executed. +FIXED_PINS = {'PR2833-WORD-base.json.gz': ('dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7', 'd3878e3be59c50ef60ef1d758215547554134c39'), 'PR2833-WORD-extra.json.gz': ('bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac', '0638b6ad9d29eec2be61bdb46140c0c5b7b0d21b'), 'PR2833-T37-TEMPLATE.json.gz': ('21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e', '114808c32b1799da53524bdc25cea67efb60009e'), 'PR2833-PROVIDERS.json': ('3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda', 'bf7c87b4d1b0fc72b8048751782f9ea6d6657096'), 'PR2833-PLAN.json': ('163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08', '5af9dd20821ae5b79778d85cd7183873c5999732'), 'PR2833-ORDER.json': ('aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667', '7141bd58cc465e28f0189345713ddd366c814ca4'), 'PR2833-DISPATCH.json': ('fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca', '693ed0d022791c43d59000718521fded1ef8def7'), 'PR2843-ORDER.json': ('5fc45c6e6a50db17c1eb2577d36e0dab3057005bc269ea6be1241c79f61aeced', 'b5cc1c6e73ea923bfbc78a493dd25eccf47b532c'), 'PR2843-DISPATCH.json': ('e06a95c589425f92e4cce90b0d71664b96d5955bb34d9ffefdae4b432fa8746b', '1c0260deab477a1600254e3bfc6a3dc69ae483b8'), 'PR2848-CLAIM.json': ('aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', '16125d43c4479676f3aa7593574be30780cd3506'), 'PR2848-ORDER.json': ('f6b3bcd6ae7e7f0339cd881204bffc095509cf738982a2d8e221cd622cd54fb1', '73cc025938918fd7876bbcfc0daf54783d7d2629'), 'PR2848-DISPATCH.json': ('24d263f53c792558b1639a85e9f6ed4ee8633d36812db82957006bfbb7e523f7', '30e94fd4fcff569217e0d8b2c8fcceb74d6d21e2')} + +def sources(folder): + folder=folder/'sources' if (folder/'sources').is_dir() else folder + raw={};pins=[] + for name,(sha,git) in FIXED_PINS.items(): + p=folder/name + if p.exists():data=p.read_bytes() + elif name=='PR2833-PLAN.json' and (folder/(name+'.gz')).exists():data=gzip.decompress((folder/(name+'.gz')).read_bytes()) + else:continue + pin={'name':name,'sha256':sha,'git_blob':git};blob(pin,data);raw[name]=data;pins.append(pin) + return pins,raw + +def decode(data,compressed=False):return json.loads(gzip.decompress(data)if compressed else data) +@lru_cache(None) +def logarithm(x): + need(x>=1,'log argument');k=0 + while x>=2:x/=2;k+=1 + def unit(y): + z=(y-1)/(y+1);power=z;total=Q(0) + for j in range(100):total+=power/(2*j+1);power*=z*z + total*=2;tail=2*power/(201*(1-z*z)) + return total,total+tail + lo,hi=unit(x);l2,h2=unit(Q(2));lo+=k*l2;hi+=k*h2 + return Q((lo*SCALE).__floor__(),SCALE),Q((hi*SCALE).__ceil__(),SCALE) +def exponential(x): + need(0<=x<1,'exp argument');term=total=Q(1) + for j in range(1,19):term*=x/j;total+=term + tail=term*x/19/(1-x/20) + return total,total+tail +def moment(profile,b,W): + lo=hi=Q(0) + for rank,count in profile.items(): + need(00,'child profile');l,h=logarithm(Q(73,rank));e0=exponential(b*l)[0];e1=exponential(b*h)[1] + lo+=Q(count*rank,73*W)*e0;hi+=Q(count*rank,73*W)*e1 + return Q((lo*SCALE).__floor__(),SCALE),Q((hi*SCALE).__ceil__(),SCALE) +from itertools import product + +def rank(vs): + piv={} + for x in vs: + while x: + k=x.bit_length()-1 + if k in piv:x^=piv[k] + else:piv[k]=x;break + return len(piv) + +def widths(word): + v=word['report']['v'];n=2*v+word['report']['R'];removed=set(word['removed']);out={} + for q in range(2*v,n): + if q not in removed:out[q]=rank(word['helper_final'].get(str(q),[1<=0 and (cap,counts)in allkeys and set(p['widths'])<=set(ws),'primal pattern') + primal_bins[cap]+=n + for w,m in zip(ws,counts):primal_widths[w]+=n*m + r=cap-sum(p['widths']) + if r:idle[r]+=n + need(primal_bins==bins and primal_widths==inventory,'all exact primal balance equations') + need(dict(idle)=={int(k):Q(v)for k,v in receipt['idle'].items()},'idle remainder bill') + hist=Counter(local);hist.update(idle);need(dict(hist)=={int(k):Q(v)for k,v in receipt['global_paid'].items()},'complete global profile') + mass=sum(r*n for r,n in hist.items());need(mass==65088*T==16141824,'rank-mass identity') + lo,hi=Q(receipt['complex_lower']),Q(receipt['complex_upper']);need(moment(hist,lo,W)[1]<10 else 1]for k,n in zip(ranks,coeff)) + need(lower>0,'dual sign/slack failure') + minimum=lower if minimum is None else min(minimum,lower) + expected={(p['capacity'],tuple(p['widths'].count(w)for w in ws))for p in receipt['dual']['tight_patterns']} + need(set(tight)==expected and len(patterns)-len(tight)==receipt['dual']['strict_positive'],'tight pattern and strict slack counts') + active={(p['capacity'],tuple(p['widths'].count(w)for w in ws))for p in receipt['active_patterns']} + need(active<=set(tight),'complementary slackness') + thresholds={} + for gain,expected in receipt['material_gain_checks'].items(): + a,b=moment(hist,prior+Q(gain),W);actual='PASS_EXACT_PRIMAL_MOMENT'if b<1 else'FAIL_EXACT_PRIMAL_MOMENT'if a>1 else'UNRESOLVED' + need(actual==expected,'independent material threshold '+gain);thresholds[gain]=actual + return dict(status='PASS_INDEPENDENT_FULL_PATTERN_RELAXATION_AUDIT',replicas=T,live=W,calls=dict(calls),call_count_source=order_source,patterns=len(patterns),patterns_by_capacity=dict(Counter(cap for cap,counts,r in patterns)),tight_patterns=len(tight),strict_patterns=len(patterns)-len(tight),minimum_slack_lower=str(minimum),rank_mass=str(mass),material_gain_checks=thresholds,changed_helpers=changes,complex_lower=str(lo),complex_upper=str(hi),gain_lower=str(lo-prior),gain_upper=str(hi-prior),receipt_sha256=hashlib.sha256(receipt_path.read_bytes()).hexdigest(),source_sha256={pin['name']:pin['sha256']for pin in pins},scope='Complete fractional nonchronological bin-pattern relaxation and independent exact moment/dual signs. Local word/frame validity is separately audited; a positive fractional primal is not an actual owner witness.') + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--base','--source-dir',dest='base',type=Path,required=True);ap.add_argument('--receipt',type=Path,required=True);ap.add_argument('--candidate-dir',type=Path);a=ap.parse_args();print(json.dumps(run_audit(a.base,a.receipt,a.candidate_dir),sort_keys=True,indent=2)) diff --git a/research/shared-kernel-packing/vendor/pr2857/build_overlay.py b/research/shared-kernel-packing/vendor/pr2857/build_overlay.py new file mode 100644 index 0000000000..9215ce67b5 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/build_overlay.py @@ -0,0 +1,89 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Build a source-bound four-kernel supplier overlay without changing PR2833. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Native, scalar, Clifford, all-column, owner and outer validators are retained. +""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +import argparse,copy,gzip,hashlib,json,shutil,types +UPSTREAM_MANIFEST='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +GROUPS=[478,460,462,480] +# Final source hashes are frozen before the first build. +GENERATOR_SHA='b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed' +REVIEW_SHA='5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def sem(v):return hashlib.sha256(json.dumps(v,sort_keys=True,separators=(',',':')).encode()).hexdigest() +def read(p): + p=Path(p);b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p): + need(not list(p.rglob('__pycache__')) and not list(p.rglob('*.pyc')),'no source bytecode or cache folders') + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no source symlinks') + if f.is_file() and f!=p/'MANIFEST.json':out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--generator',type=Path,required=True);ap.add_argument('--review',type=Path,required=True);ap.add_argument('--candidate-dir',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + need(not sys.flags.optimize,'assertions required');source=a.source.resolve();out=a.out.resolve() + need(sha(source/'MANIFEST.json')==UPSTREAM_MANIFEST and tree(source)==read(source/'MANIFEST.json'),'exact PR2833 source inventory') + need(sha(a.generator)==GENERATOR_SHA and sha(a.review)==REVIEW_SHA,'exact new producer and independent review source') + need(not out.exists() and not out.is_relative_to(source),'fresh external overlay');shutil.copytree(source,out) + gen=types.ModuleType('shared_kernel');exec(compile(a.generator.read_bytes(),str(a.generator),'exec'),gen.__dict__) + auditor=types.ModuleType('independent_frames');apath=source/'new/borrow/audit_local.py';exec(compile(apath.read_bytes(),str(apath),'exec'),auditor.__dict__) + # Independently audited literal words are shipped byte-for-byte. The pure + # source-bound producer must reconstruct every decoded field from PR2833. + providers=read(source/'new/BORROW-PROVIDERS.json');records={} + for tag,pid in [('base','gauge44'),('extra','extra')]: + src=source/('new/borrow/words/BORROW-WORD-43'+tag+'.json.gz');target=a.candidate_dir/('WORD-'+tag+'.json.gz');old=read(src);new=read(target);derived,ledger=gen.apply(old,GROUPS) + need(derived==new,'complete producer reconstruction '+tag) + need(set(k for k in old if old[k]!=new[k])=={'A','compensation','start_extra','report','cleanup'},'exact changed sections') + need(new['report']['local_profile']=={'1':2394,'2':642,'3':266,'4':128,'5':26,'8':8},'complete per-call paid profile') + need(new['report']['width_inventory']=={'4':26,'5':2,'7':62,'8':84,'9':234},'complete helper inventory') + live=sorted(set(range(224,704))-set(new['removed']));need(len(live)==408,'unchanged helper identities') + widths=[] + for r in live: + end=auditor.basis(new['helper_final'].get(str(r),[256,128,64,32,16,8,4,2,1]));start=auditor.basis(new['start_extra'].get(str(r),[]));widths.append(len(end)-len(start)) + need(len(new['warps'])==len(old['warps']) and new['helper_final']==old['helper_final'] and new['removed']==old['removed'],'all phase and buffer ABI fields unchanged') + providers[pid]=dict(widths=widths,actual_paid_profile=new['report']['local_profile']) + shutil.copy2(target,out/('new/borrow/words/BORROW-WORD-43'+tag+'.json.gz')) + shutil.copy2(src,out/('new/borrow/inputs/PR2833-WORD-'+tag+'.json.gz')) + rec=dict(groups=GROUPS,source_word_sha256=sha(src),source_canonical_sha256=sem(old),candidate_word_sha256=sha(target),candidate_canonical_sha256=sem(new),generator_sha256=GENERATOR_SHA,ledger=ledger) + write(out/('new/borrow/inputs/shared_kernel_43'+tag+'.json'),rec);records[tag]=rec + shutil.copy2(a.generator,out/'new/borrow/shared_kernel.py');shutil.copy2(a.review,out/'new/borrow/shared_kernel_review.py');write(out/'new/BORROW-PROVIDERS.json',providers) + patches=[] + def patch(name,old,new): + p=out/name;before=sha(p);body=p.read_text();need(body.count(old)==1,'exact overlay preimage '+name);p.write_text(body.replace(old,new));patches.append(dict(path=name,before_sha256=before,after_sha256=sha(p),old=old,new=new)) + anchor=' final=json.loads(gzip.decompress(shipped.read_bytes()))' + block=''' # Four disjoint staged compensation kernels, after the complete pinned + # PR2833 derivation. Every previous state stays in the audit chain. + sf_=D/'inputs'/f'shared_kernel_43{wt}.json' + if sf_.exists(): + import shared_kernel + shared_patch=json.loads(sf_.read_text());previous_shared=chain[-1] + canonical=lambda z:hashlib.sha256(json.dumps(z,sort_keys=True,separators=(',',':')).encode()).hexdigest() + assert shared_patch['groups']==[478,460,462,480] + assert canonical(previous_shared)==shared_patch['source_canonical_sha256'] + shared_word,shared_ledger=shared_kernel.apply(previous_shared,shared_patch['groups']) + assert canonical(shared_word)==shared_patch['candidate_canonical_sha256'] + assert json.loads(json.dumps(shared_ledger))==shared_patch['ledger'] + assert set(k_ for k_ in previous_shared if previous_shared[k_]!=shared_word[k_])=={'A','compensation','start_extra','report','cleanup'} + stripped_shared=json.loads(json.dumps(shared_word));stripped_shared['A']=stripped_shared['A'][stripped_shared['prelude_events']:] + assert shared_word['cleanup']==word_patch.derive_cleanup(stripped_shared,word_patch.restored_of(shared_word)) + chain.append(shared_word);steps.append('shared-four-kernel') +'''+anchor + patch('new/rebuild_borrow.py',anchor,block) + anchor2="run('rebuild-borrow-words',P/'new/rebuild_borrow.py')" + block2=anchor2+"\nrun('shared-kernel-independent-review',P/'new/borrow/shared_kernel_review.py','--source-dir',P/'new/borrow','--source-base',P/'new/borrow/inputs/PR2833-WORD-base.json.gz','--source-extra',P/'new/borrow/inputs/PR2833-WORD-extra.json.gz','--candidate-base',P/'new/borrow/words/BORROW-WORD-43base.json.gz','--candidate-extra',P/'new/borrow/words/BORROW-WORD-43extra.json.gz','--out-dir',work/'shared-kernel-independent-review')" + patch('verify.py',anchor2,block2) + before=read(source/'MANIFEST.json');after=tree(out);write(out/'MANIFEST.json',after) + change={p:dict(before_sha256=before.get(p),after_sha256=after.get(p)) for p in sorted(set(before)|set(after)) if before.get(p)!=after.get(p)} + expected={'new/borrow/words/BORROW-WORD-43base.json.gz','new/borrow/words/BORROW-WORD-43extra.json.gz','new/borrow/inputs/PR2833-WORD-base.json.gz','new/borrow/inputs/PR2833-WORD-extra.json.gz','new/borrow/inputs/shared_kernel_43base.json','new/borrow/inputs/shared_kernel_43extra.json','new/borrow/shared_kernel.py','new/borrow/shared_kernel_review.py','new/BORROW-PROVIDERS.json','new/rebuild_borrow.py','verify.py'} + need(set(change)==expected,'exact overlay change allowlist');need(tree(source)==before,'original source remained byte-exact') + receipt=dict(status='PASS_SOURCE_BOUND_FOUR_KERNEL_OVERLAY_DERIVATION',upstream_manifest_sha256=UPSTREAM_MANIFEST,derived_manifest_sha256=sha(out/'MANIFEST.json'),source_file_count=len(after),builder_sha256=sha(Path(__file__)),changes=change,patches=patches,words=records,scope='Exact source overlay construction only. Full native and owner/controller/outer admission remain separate; all inherited validators are retained and an independent kernel review is added.') + write(out.parent/(out.name+'-DERIVATION.json'),receipt);print(json.dumps({k:receipt[k] for k in ['status','derived_manifest_sha256','source_file_count']},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/check_ceiling.py b/research/shared-kernel-packing/vendor/pr2857/check_ceiling.py new file mode 100644 index 0000000000..cc2cec7788 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/check_ceiling.py @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Check the unchanged coverage-law envelope for the changed local word. + +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. The envelope +engine and its scope are retained from complex-local-word-ceiling. +""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +from fractions import Fraction as Q +import argparse,gzip,hashlib,json,types + +def need(ok,why): + if not ok: raise ValueError(why) +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--package',type=Path,default=Path(__file__).resolve().parent);a=ap.parse_args();p=a.package + tool=p/'vendor/ceiling.py' + need(hashlib.sha256(tool.read_bytes()).hexdigest()=='86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc','exact retained envelope engine') + c=types.ModuleType('retained_coverage_ceiling');exec(compile(tool.read_bytes(),str(tool),'exec'),c.__dict__) + pins={'base':'001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458','extra':'bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546'} + local={1:2394,2:642,3:266,4:128,5:26,8:8} + for tag,h in pins.items(): + f=p/('words/WORD-'+tag+'.json.gz');need(hashlib.sha256(f.read_bytes()).hexdigest()==h,'exact candidate word') + need({int(k):v for k,v in read(f)['report']['local_profile'].items()}==local,'both actual local profiles') + evidence=read(p/'evidence/relaxation/LOCAL-CEILING.json');model=c.model(local,73,896,9,64) + need({k:str(v) for k,v in model.items()}==evidence['model'],'coverage law and idle mass') + lo=Q(evidence['complex_cap_lower']);hi=Q(evidence['complex_cap_upper']) + need(c.relax(local,73,896,9,64,lo)[1]<1>bit&1] + if not choices:continue + p=choices[0];rows.remove(p);rows=[a^p if a>>bit&1 else a for a in rows];out=[a^p if a>>bit&1 else a for a in out];out.append(p) + return tuple(out) +def sub(U,F):return basis(U+F)==F +def regs(e):return e[1:3] if e[0]=='add' else e[1:2] +def coeff(e):return Q(e[3],e[4]) if e[0]=='add' else Q(e[2],e[3]) +def plus(dst,src,c): + for k,a in src.items(): + z=dst.get(k,Q(0))+c*a + if z:dst[k]=z + else:dst.pop(k,None) +def left(row,op): + out={} + for (r,word),a in row.items(): + seq=word[1:] if word and word[0]==-op else (op,)+word + out[r,seq]=a + return out +def apply(rows,e,dual=False): + kind=e[0] + if kind=='warp': + op=e[2];op=op+(1000000 if op>0 else -1000000) if dual else op + rows[e[1]]=left(rows[e[1]],op) + elif kind=='corr': + _,t,s,word,c=e + if dual: + tmp=rows[t] + for op in word:tmp=left(tmp,-op-(1000000 if op>0 else -1000000)) + plus(rows[s],tmp,-c) + else: + tmp=rows[s] + for op in reversed(word):tmp=left(tmp,op) + plus(rows[t],tmp,c) + elif kind=='add': + t,s=e[1:3];c=coeff(e) + if dual:t,s,c=s,t,-c + plus(rows[t],rows[s],c) + elif kind=='scale': + c=coeff(e);c=1/c if dual else c + rows[e[1]]={k:a*c for k,a in rows[e[1]].items()} + else:raise AssertionError(kind) +def eye():return {r:{(r,()):Q(1)} for r in range(N)} +def b_events(z): + byp=collections.defaultdict(list) + for op,rec in enumerate(z['warps'],1):byp[rec[0]].append(['warp',rec[1],op]) + out=[] + for i in range(len(z['B'])+1): + out.extend(byp[i]) + if i=N}==restored,'private_buffer_inventory_unchanged_72') +# Fresh exact endpoint replay, both orientations and all independent dirty columns. +corr=[['corr',c['target'],c['source'],tuple(c['operator_word']),Q(c['coefficient'])] for c in x['initial_corrections']] +program=corr+x['precondition']+x['compensation']+x['A']+x['cut']+b_events(x)+x['restore'] +for dual in [False,True]: + rows=eye();rows.update({r+N:{} for r in restored}) + for e in program:apply(rows,e,dual) + if not dual: + ok(all(rows[V+t]=={(V+t,()):Q(1),(t,()):Q(1)} for t in range(V)),'precleanup_forward_target_map') + ok(all(rows[r]=={(r,()):Q(1)} for r in restored),'precleanup_restored_inputs_exact') + for e in x['cleanup']:apply(rows,e,dual) + exp=eye() + for t in range(V): + if dual:exp[t][V+t,()]=Q(-1) + else:exp[V+t][t,()]=Q(1) + ok(all(rows[r]==exp[r] for r in range(N)),'independent_'+('dual' if dual else 'forward')+'_all_column_endpoint') + ok(all(not rows[r+N] for r in restored),'independent_'+('dual' if dual else 'forward')+'_zero_buffers') +# Independent GF2 frame accounting with no inherited audit functions. +def frame_ledger(z): + starts=[(p,) for p in z['ports']]+[()]*(N-V) + ends=[FULL]*V+[basis([a for a in range(1,512) if (a&p).bit_count()%2==0]) for p in z['ports']]+[FULL]*(N-2*V) + for r,U in z['start_extra'].items():starts[int(r)]=basis(U) + for r,U in z['helper_final'].items():ends[int(r)]=basis(U) + current=starts[:];counts=collections.Counter();byreg=collections.defaultdict(collections.Counter) + def climb(r,U): + U=basis(U);assert sub(current[r],U),(r,current[r],U) + d=len(U)-len(current[r]) + if d:counts[d]+=1;byreg[r][d]+=1 + current[r]=U + for e in z['A']: + if e[0]=='warp':assert current[e[1]]==basis(e[3]);current[e[1]]=basis(e[4]) + else: + for r in regs(e):climb(r,e[-1]) + lev={int(t):basis(U) for t,U in z['target_levels'].items()} + assert all(current[V+t]==lev.get(t,()) for t in range(V)) + for r,U in zip(z['centers'],z['center_frames']): + U=basis(U);assert current[r]==U + for end in sorted({lev.get(e[1]-V,()) for e in z['cut'] if e[2]==r},key=lambda t:-len(t)): + assert sub(end,U) + if end!=U:counts[len(U)-len(end)]+=1 + U=end + for e in b_events(z)+z['restore']: + if e[0]=='warp':rec=z['warps'][e[2]-1];assert current[e[1]]==basis(rec[3]);current[e[1]]=basis(rec[4]) + else: + for r in regs(e):climb(r,e[-1]) + for r in live:climb(r,ends[r]) + widths={r:len(ends[r])-len(starts[r]) for r in live if r>=2*V} + assert all(ends[r]==FULL for r in live if r<112 or r>=224 and r not in restored) + return counts,byreg,widths +p0,c0,wi0=frame_ledger(w);p1,c1,wi1=frame_ledger(x) +ok(dict(p1)=={int(d):n for d,n in x['report']['local_profile'].items()},'independent_full_frame_profile') +ok(collections.Counter(wi1.values())==collections.Counter({int(d):n for d,n in x['report']['width_inventory'].items()}),'independent_width_inventory') +delta={d:p1[d]-p0[d] for d in sorted(set(p0)|set(p1)) if p1[d]!=p0[d]} +ok(delta=={1:12,2:-8},'profile_delta_plus12H1_minus8H2') +ok({r:(wi0[r],wi1[r]) for r in wi0 if wi0[r]!=wi1[r]}=={q:(9,8) for q in ENTRIES},'only_four_ordered_widths_shrink9to8') +changed_climbs={r:{d:c1[r][d]-c0[r][d] for d in set(c0[r])|set(c1[r]) if c0[r][d]!=c1[r][d]} for r in live if c0[r]!=c1[r]} +expected_climbs={} +for q0,q1,q2,q3 in GROUPS:expected_climbs.update({q0:{1:1,2:-1},q2:{1:2,2:-1}}) +ok(changed_climbs==expected_climbs,'only_eight_declared_helpers_change_paid_climbs') +ok(sha(BASE)==source_sha and sha(CAND)==candidate_sha,'inputs_unchanged_during_audit') +result=dict(status='PASS_INDEPENDENT_FOUR_GROUP_LOCAL_DIFFERENTIAL_AUDIT',variant=VARIANT,groups=group_records,candidate_compressed_sha256=sha(CAND),candidate_content_sha256=hashlib.sha256(gzip.decompress(CAND.read_bytes())).hexdigest(),base_compressed_sha256=sha(BASE),checker_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),source_commit='e9307b48d7d1b690939935ecef0f8e524e6d92f4',checks=checks,compensation_targets=targets,compensation_matrix=[[str(v) for v in row] for row in M],compensation_rank=rank,dirty_shear=T,profile_delta=delta,changed_register_profiles=changed_climbs,ordered_width_change={str(q):[9,8] for q in ENTRIES},primitive_count_changes={'A':20,'cleanup':20,'compensation':0},remaining_admission=['fresh declared-stage producer/source bindings and negative controls','strict source release including no stale bytecode','native phase/Gaussian replay including all extra gates and cleanup','actual owner fill/order/dispatch with changed ordered width list; recompute actual idle profile','both exact outer checkers and selected-parent admission at claimed target','full inherited borrowed-word/owner/geometry/controller rejection controls'],limitations=['This checks candidate word bytes only; no owner/native/outer admission or whole-package source-release audit is performed.','The free-operator endpoint proof does not itself certify Clifford phase/Gaussian products.','No unrestricted optimality claim for rank-three kernel or frame schedule.']) +args.out.write_text(json.dumps(result,indent=2)+'\n') +print(json.dumps(result,indent=2)) diff --git a/research/shared-kernel-packing/vendor/pr2857/check_release_evidence.py b/research/shared-kernel-packing/vendor/pr2857/check_release_evidence.py new file mode 100644 index 0000000000..c394f4df14 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/check_release_evidence.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Yiyang (@Lyy-iiis), with substantial OpenAI Codex and multi-agent assistance. +"""Read-only, bounded verifier for this exact conditional release's evidence. + +This does not rerun the native scalar algebra or establish the inherited analytic +interfaces. It authenticates the executed proof artifacts, checks their exact +bindings and arithmetic, and independently replays the literal finite packing. +No packaged Python is imported or executed; tar members are never extracted. +""" +import argparse +from collections import Counter +import copy +from fractions import Fraction as Q +import gzip +import hashlib +import io +import json +from pathlib import Path, PurePosixPath +import stat +import sys +import tarfile + +sys.dont_write_bytecode = True +MANIFEST_PIN = 'ef7b8983700d51fce63869121cb0cad28f930bd0a8901ebfce57b1d714aee0fe' +SOURCE_PIN = 'c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +DERIVED_PIN = '54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +PLAN_PIN = '163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08' +OLD_RECEIPT_PIN = 'a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc' +PR2848_PIN = 'aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9' +PR2853_PIN = 'eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa' +WORDS = {'base': '001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458', + 'extra': 'bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546'} +LOCAL = {'1':2394,'2':642,'3':266,'4':128,'5':26,'8':8} +WIDTHS = {4:26,5:2,7:62,8:84,9:234} +PROFILE = {'1':805860,'2':213786,'3':91775,'4':42624,'5':13098,'8':2664,'9':1,'48':13379} +IDLE = {'1':8658,'3':3197,'5':4440,'9':1,'48':13379} +C = Q(1720096628684832600972,10**24) +KAPPA = C-Q(1,10**46)-Q(1,10**70) +GAIN = Q(1438120379902596153,10**24) +E = 'evidence/full/' +AUDIT = E+'candidate/release/verify/strict/global/audit/' +COUNTS = {'admission':119,'bit':12,'controller':25,'independent_owner':8,'geometry':6, + 'modern_outer_rejections':17,'modern_outer_strict_inequalities':63,'supplier_outer_rows':47, + 'shared_kernel_base':8,'shared_kernel_extra':8,'base_native_mutants':46,'extra_native_mutants':46, + 'base_wrapper_mutants':25,'extra_wrapper_mutants':25,'base_warp_mutants':13,'extra_warp_mutants':13} +MAX_FILE = 16*1024*1024 +MAX_TOTAL = 128*1024*1024 + +class Invalid(ValueError): pass + +def need(ok, why): + if not ok: raise Invalid(why) + +def sha(b): return hashlib.sha256(b).hexdigest() + +def safe_name(name): + p = PurePosixPath(name) + need(isinstance(name,str) and name and not p.is_absolute() and '\\' not in name + and all(x not in ('','.', '..') for x in name.split('/')), 'unsafe relative path') + return name + +def read_file(root, name): + safe_name(name) + p=root + for part in PurePosixPath(name).parts: + p=p/part + need(not p.is_symlink(), 'symlink input: '+name) + s=p.stat() + need(stat.S_ISREG(s.st_mode) and s.st_size<=MAX_FILE, 'input type/size: '+name) + with p.open('rb') as f: b=f.read(MAX_FILE+1) + need(len(b)==s.st_size and len(b)<=MAX_FILE, 'unstable/oversize input: '+name) + return b + +def unzip(b): + with gzip.GzipFile(fileobj=io.BytesIO(b)) as f: result=f.read(MAX_FILE+1) + need(len(result)<=MAX_FILE, 'expanded gzip size') + return result + +def unique_object(pairs): + out={} + for k,v in pairs: + need(k not in out,'duplicate JSON key');out[k]=v + return out + +def decode(b): + return json.loads(b,object_pairs_hook=unique_object, + parse_constant=lambda x: (_ for _ in ()).throw(Invalid('nonfinite JSON'))) + +def rational(x): + if isinstance(x,dict):x=x['rational'] + need(isinstance(x,(str,int)) and not isinstance(x,bool) and len(str(x))<=10000,'bounded rational') + return Q(x) + +def canonical(x):return sha(json.dumps(x,sort_keys=True,separators=(',',':')).encode()) + +def load(package): + root=package.resolve(strict=True) + need(root.is_dir(),'package directory') + raw={};docs={} + def add(name): + b=read_file(root,name);raw[name]=b + if name.endswith('.json'):docs[name]=decode(b) + elif name.endswith('.json.gz'):docs[name]=decode(unzip(b)) + add(E+'MANIFEST.json') + need(sha(raw[E+'MANIFEST.json'])==MANIFEST_PIN,'frozen evidence manifest SHA256') + manifest=docs[E+'MANIFEST.json'] + need(len(manifest)==167,'evidence inventory count') + actual=[];entries=0 + for p in (root/E).rglob('*'): + entries+=1;need(entries<=512,'bounded evidence directory entries') + need(not p.is_symlink(),'symlink evidence entry') + need(p.name!='__pycache__' and p.suffix not in ('.pyc','.pyo'),'stale bytecode evidence') + if p.is_file():actual.append(p.relative_to(root/E).as_posix()) + need(set(actual)==set(manifest)|{'MANIFEST.json'},'exact evidence inventory') + for name,digest in manifest.items(): + add(E+safe_name(name));need(sha(raw[E+name])==digest,'evidence file hash: '+name) + names=['CLAIM.json','FILL.json.gz','ORDER.json','DISPATCH.json','PROFILE.json','PROVIDERS.json', + 'sources/PR2833-PLAN.json.gz','sources/PR2848-CLAIM.json','sources/PR2853-OUTER-CLAIM.json'] + names += ['words/WORD-'+tag+'.json.gz' for tag in WORDS] + names += ['sources/PR2833-WORD-'+tag+'.json.gz' for tag in WORDS] + names += ['reproduce.py','build_overlay.py','prepare_shared_native.py','admit_shared_replica.py','shared_kernel.py','review_four_groups.py'] + for name in names:add(name) + for n in ['lift_parent.py','replica_parent.py','reconstruct_replica.py','blocknorm_certificate.py']: + add('vendor/pr2839/'+n) + archive=raw[E+'native/NATIVE-CACHE.tar.gz'];cache={};expanded=0 + with tarfile.open(fileobj=io.BytesIO(archive),mode='r|gz') as t: + for i,m in enumerate(t): + need(i<128 and m.isfile() and not m.issym() and not m.islnk(),'native archive member type/count') + safe_name(m.name);need(m.name not in cache,'native archive duplicate') + need(0<=m.size<=MAX_FILE,'native archive member size');expanded+=m.size + need(expanded<=MAX_TOTAL,'native archive expanded size') + with t.extractfile(m) as f:b=f.read(m.size+1) + need(len(b)==m.size,'native archive member length');cache[m.name]=sha(b) + raw['cache/'+m.name]=b + if m.name.endswith('.json'):docs['cache/'+m.name]=decode(b) + need(sum(map(len,raw.values()))<=MAX_TOTAL,'bounded total input bytes') + return raw,docs,cache + +def sources(raw,d): + original=d[E+'source/PR2833-MANIFEST.json'];derived=d[E+'source/DERIVED-MANIFEST.json'] + need(sha(raw[E+'source/PR2833-MANIFEST.json'])==SOURCE_PIN and len(original)==541,'original source inventory') + need(sha(raw[E+'source/DERIVED-MANIFEST.json'])==DERIVED_PIN and len(derived)==547,'derived source inventory') + receipt=d[E+'wrapper/source-DERIVATION.json'] + delta={k:{'before_sha256':original.get(k),'after_sha256':derived.get(k)} for k in set(original)|set(derived) if original.get(k)!=derived.get(k)} + need(len(delta)==11 and delta==receipt['changes'],'exact eleven source changes') + need(receipt['upstream_manifest_sha256']==SOURCE_PIN and receipt['derived_manifest_sha256']==DERIVED_PIN,'source derivation manifest bindings') + need(receipt['builder_sha256']==sha(raw['build_overlay.py']),'executed builder binding') + for tag,wordhash in WORDS.items(): + old='sources/PR2833-WORD-'+tag+'.json.gz';new='words/WORD-'+tag+'.json.gz';wr=receipt['words'][tag] + need(sha(raw[new])==wordhash==wr['candidate_word_sha256'],'changed word byte binding') + need(sha(raw[old])==wr['source_word_sha256'],'original word binding') + need(canonical(d[new])==wr['candidate_canonical_sha256'] and canonical(d[old])==wr['source_canonical_sha256'],'decoded word binding') + need(wr['groups']==[478,460,462,480] and wr['ledger']['delta']=={'1':12,'2':-8},'four kernel local delta') + need(d[new]['report']['local_profile']==LOCAL,'literal word local profile') + need(derived['new/borrow/words/BORROW-WORD-43'+tag+'.json.gz']==wordhash,'derived word source binding') + for file,shipped in [('reproduce.py','reproduce.py'),('build_overlay.py','build_overlay.py'),('prepare_shared_native.py','prepare_shared_native.py'),('admit_shared_replica.py','admit_shared_replica.py'),('shared_kernel.py','shared_kernel.py'),('shared_kernel_review.py','review_four_groups.py')]: + need(raw[E+'scripts/'+file]==raw[shipped],'executed script exact copy: '+shipped) + inputs=d[E+'wrapper/RESULT.json']['input_sha256'] + for k,v in inputs.items(): + suffix=PurePosixPath(k).name + local=None + if suffix in ['FILL.json.gz','ORDER.json','DISPATCH.json']:local=suffix + elif suffix in ['WORD-base.json.gz','WORD-extra.json.gz']:local='words/'+suffix + elif suffix in ['lift_parent.py','replica_parent.py','reconstruct_replica.py','blocknorm_certificate.py']:local='vendor/pr2839/'+suffix + elif suffix in ['build_overlay.py','prepare_shared_native.py','admit_shared_replica.py','shared_kernel.py','review_four_groups.py']:local=suffix + if local:need(sha(raw[local])==v,'wrapper actual input binding: '+local) + need(sha(unzip(raw['sources/PR2833-PLAN.json.gz']))==PLAN_PIN,'authentic source T37 windows') + +def native(raw,d,cache): + nr=d[E+'native/NATIVE-RECEIPT.json'] + need(cache==nr['cache_files'] and len(cache)==63,'complete native archive tree') + need(nr['manifest_sha256']==DERIVED_PIN,'native derived source binding') + need(nr['fresh_current_provider_count']==2 and nr['fresh_retained_native_count']==0 and nr['fresh_retained_parent'] is False + and nr['reused_retained_native_count']==2 and nr['reused_retained_parent'] is True,'fresh versus reused provenance') + old=d[E+'reused-retained-input/NATIVE-RECEIPT.json'] + need(sha(raw[E+'reused-retained-input/NATIVE-RECEIPT.json'])==nr['retained_reuse_receipt_sha256']==OLD_RECEIPT_PIN,'retained source receipt') + fresh=set(WORDS.values()) + for name,value in cache.items(): + if name.split('/')[0] not in fresh:need(old['cache_files'].get(name)==value,'unchanged retained cache member') + parent=[n for n in cache if n.startswith('_receipts/') and n.endswith('/RECEIPT.json')] + need(len(parent)==1 and cache[parent[0]]==nr['retained_parent_receipt_sha256'],'retained parent receipt') + parent_stages=d['cache/'+parent[0].replace('RECEIPT.json','STAGES.json')] + need(len(parent_stages)==16 and all(x['exit_code']==0 for x in parent_stages),'retained sixteen-stage parent') + for tag,wordhash in WORDS.items(): + p=nr['providers'][tag];base='cache/'+wordhash+'/' + need(p['word_sha256']==wordhash,'native current word hash') + for name,digest in p['complete_native_files'].items():need(cache[wordhash+'/'+name]==digest,'complete current native file binding') + need(raw[base+'local/FULL-WORD.json.gz']==raw['words/WORD-'+tag+'.json.gz'],'native consumes actual changed word') + result=d[E+'native/fresh-'+tag+'/RESULT.json'];steps=result['steps'] + need([x['step'] for x in steps]==['native','ledgers','local-replay','wrappers','phases'] and all(x['exit_code']==0 for x in steps),'five fresh native stages') + need(steps==d[base+'STEPS.json'] and result['word_sha256']==wordhash,'fresh result versus cached stages') + derived=d[E+'source/DERIVED-MANIFEST.json'] + for name,digest in result['source_sha256'].items():need(derived.get('new/fastnative/vendor/'+name)==digest,'native executed source pin') + scalar=d[E+'native/'+tag+'/SCALAR-FRAME-AUDIT.json'] + need(scalar['local_profile']==LOCAL and scalar['local_rank_mass']==5182 and scalar['helpers']==408 + and scalar['live_columns_each_orientation']==632 and scalar['zero_buffers']==72,'scalar endpoint and profile bill') + pid='gauge44' if tag=='base' else 'extra' + need(d['PROVIDERS.json'][pid]['widths']==scalar['widths'] and Counter(scalar['widths'])==WIDTHS,'ordered native provider widths') + need(d['PROVIDERS.json'][pid]['actual_paid_profile']==LOCAL,'provider local profile') + checks=d[E+'native/'+tag+'/LOCAL-CHECKS.json'];ind=d[E+'native/'+tag+'/INDEPENDENT-LOCAL-REPLAY.json'] + for orient in ('forward','backward'): + c=checks[orient];a=ind['local'][orient] + need(c['all_columns']==632 and c['paid_profile']==LOCAL and c['zero_buffers_returned_to_zero']==72 + and c['private_centers_cleared'] is True and c['private_coefficient_stream_cleared_after_each_macro'] is True,'all-column native check') + need(a['all_exact_columns']==632 and a['private_work_erased'] is True and a['zero_buffers_returned_to_zero']==72 + and a['warp_columns_each_exact']==512 and ind['paid_profiles'][orient]==LOCAL,'independent native endpoint') + for name in ['SCALAR-FRAME-AUDIT.json','LOCAL-CHECKS.json','INDEPENDENT-LOCAL-REPLAY.json','WRAPPER-CHECKS.json','WARP-RECIPE-CHECKS.json']: + need(raw[E+'native/'+tag+'/'+name]==raw[base+'local/'+name],'published native receipt versus archive') + +def packing(d): + plan=d['sources/PR2833-PLAN.json.gz'];order=d['ORDER.json'];dispatch=d['DISPATCH.json'];fill=d['FILL.json.gz'] + need(order==plan['order'] and len(order)==333 and sorted(map(tuple,order))==[(s,r) for s in range(9) for r in range(37)],'authentic complete T37 order') + need([x[:2] for x in dispatch]==order and Counter(x[2] for x in dispatch)=={'gauge44':125,'extra':208},'complete provider dispatch') + need(fill['dispatch_overrides']==[] and len(fill['rows'])==135864,'complete literal roles') + windows={tuple(map(int,k.split(','))):(cap,set(times)) for k,(cap,times) in plan['windows'].items()} + masks={};helpers=[0]*333;families=[set() for _ in order] + for row in fill['rows']: + need(len(row)==6 and all(type(x) is int for x in row),'integer owner role') + t,h,r,ch,port,off=row + need(0<=t<333 and 0<=h<408 and 0<=r<37 and (r,ch) in windows and 0<=port<112 and 0<=off<=48,'owner role ranges') + cap,times=windows[r,ch];need(t in times,'strict authenticated owner window') + width=d['PROVIDERS.json'][dispatch[t][2]]['widths'][h] + family=r*896+(2*plan['pairs'][str(ch)]+plan['sides'][str(ch)])*112+port + need(family not in families[t],'per-call physical family collision');families[t].add(family) + need(not (helpers[t]>>h)&1,'duplicate helper role');helpers[t]|=1<0),'strict independent moment sign') + need([rational(x['endpoint']) for x in rows if x['side']=='complex']==[C,C+Q(1,10**24)],'complex endpoint bracket') + need(rational(rows[0]['endpoint'])==Q(1733427039589844234749,10**24),'actual bit endpoint') + +def controls(d): + registry=d[E+'ACTUAL-CONTROLS.json']['counts'];need(set(registry)==set(COUNTS),'all control families') + for label,count in COUNTS.items(): + item=registry[label];value=d[E+item['source']] + for k in item['json_path']:value=value[k] + need(isinstance(value,(dict,list)) and len(value)==item['count']==count,'actual control array: '+label) + if isinstance(value,list) and value and isinstance(value[0],str):need(len(set(value))==count,'unique controls: '+label) + review=d[E+'candidate/release/verify/shared-kernel-independent-review/FOUR-GROUP-INDEPENDENT-REVIEW.json'] + for tag in WORDS: + v=review['variants'][tag] + need(v['candidate_sha256']==WORDS[tag] and v['inserted_A_gates']==20 and v['compensation_removed']==28 and v['compensation_added']==28,'kernel review literal scope') + need(v['all_four_operand_and_target_supports_disjoint'] is True and v['all_other_sections_unchanged'] is True,'kernel structural checks') + names=[x['name'] for x in v['controls']];need(len(set(names))==8,'unique kernel controls') + for x in v['controls']: + need(bool(x['rejected_for']) and x['cleanup_rederived']==(x['name']!='stale_cleanup'),'meaningful semantic kernel controls') + ledger=d[E+'candidate/outer/LEDGER.json'] + for v in ledger['rows']['struct_boundary_radix_union']['strict_checks'].values():need(rational(v)>0,'strict modern outer inequality') + for values in ledger['rejecting_controls']['struct_boundary_radix_union'].values(): + need(values and any(rational(v)<=0 for v in values.values()),'modern outer rejection witness') + for v in d[E+'candidate/release/verify/strict/ASSEMBLY.json']['outer'].values():need(rational(v)>0,'strict supplier outer row') + +def claims(raw,d): + claim=d['CLAIM.json'];wrapper=d[E+'wrapper/RESULT.json'];complete=d[E+'COMPLETE.json'];candidate=d[E+'candidate/RESULT.json'] + need(sha(raw['sources/PR2848-CLAIM.json'])==PR2848_PIN and sha(raw['sources/PR2853-OUTER-CLAIM.json'])==PR2853_PIN,'comparison source pins') + prior=rational(d['sources/PR2848-CLAIM.json']['kappa']);latest=rational(d['sources/PR2853-OUTER-CLAIM.json']['kappa_rational']) + need(KAPPA-prior==GAIN and KAPPA-latest>0,'exact improvement over both comparisons') + for x in [claim,wrapper,complete,candidate]:need(rational(x['kappa'])==KAPPA and rational(x['gain'])==GAIN and rational(x['kappa_decimal'])==KAPPA,'exact headline and gain') + for x in [claim,wrapper,complete]: + s=x['secondary_comparison'];need(s['pr']==2853 and s['head']=='d01045dfb67428679618027dff552f1d032fa999' and s['claim_sha256']==PR2853_PIN and rational(s['gain'])==KAPPA-latest,'exact secondary comparison') + need(claim['replicas']==37 and claim['calls']==333 and claim['helper_roles']==135864 and claim['local_profile']==LOCAL and claim['selected_frontier_changed'] is False,'scoped top-level claim') + bindings={'native_receipt_sha256':'native/NATIVE-RECEIPT.json','derived_source_manifest_sha256':'source/DERIVED-MANIFEST.json','generated_package_manifest_sha256':'candidate/admitted-package/MANIFEST.json','release_receipt_sha256':'candidate/release/RELEASE-RECEIPT.json','wrapper_sha256':'scripts/reproduce.py'} + for key,path in bindings.items(): + actual=sha(raw[E+path]);need(claim[key]==wrapper[key]==actual,'claim release chain '+key) + need(claim['source_manifest_sha256']==SOURCE_PIN and wrapper['source_manifest_sha256']==SOURCE_PIN,'original source identity') + need(wrapper['candidate_result_sha256']==sha(raw[E+'candidate/RESULT.json']),'wrapper candidate binding') + need(complete['native_cache_archive_sha256']==sha(raw[E+'native/NATIVE-CACHE.tar.gz']),'published native archive hash') + manifest=d[E+'candidate/admitted-package/MANIFEST.json'] + need(len(manifest)==551,'admitted generated file count') + for name in ['FILL.json.gz','ORDER.json','DISPATCH.json']: + need(sha(raw[name])==manifest['new/borrow-fill/'+name]==candidate[name.split('.')[0].lower()+'_sha256'],'actual owner payload admission binding') + for tag,h in WORDS.items():need(manifest['new/borrow/words/BORROW-WORD-43'+tag+'.json.gz']==h,'admitted changed provider') + for name in ['PROFILE.json']: + need(d[E+'candidate/owners/'+name]==PROFILE and d[E+'candidate/admitted-package/new/'+name]==PROFILE,'admitted full profile') + outer=d[E+'candidate/outer/OUTER-CLAIM.json'];ledger=d[E+'candidate/outer/LEDGER.json'] + need(rational(outer['kappa_rational'])==rational(outer['kappa'])==KAPPA and rational(outer['gain'])==GAIN,'outer exact headline') + need(rational(ledger['rows']['struct_boundary_radix_union']['kappa'])==KAPPA and ledger['profile']==PROFILE and ledger['m']==73 and ledger['W']==33152,'modern outer actual profile denominator') + need(rational(ledger['complex_lower_pinned'])==C and all(rational(x)<1 for x in ledger['native_moment']),'modern outer supplier endpoint') + release=d[E+'candidate/release/RELEASE-RECEIPT.json'];need(release['manifest_sha256']==sha(raw[E+'candidate/admitted-package/MANIFEST.json']) and rational(release['kappa_decimal'])==KAPPA,'final release exact binding') + stages=[('wrapper/STAGES.json','stage',['derive-source','fresh-current-native','complete-admission']),('candidate/STAGES.json','name',['owners','parent-lift','rebind','discovery','outer-check_ledger.py','outer-independent_check.py','release'])] + for path,key,names in stages: + v=d[E+path];need([x[key] for x in v]==names and all(x['exit_code']==0 for x in v),'successful complete stages '+path) + v=d[E+'candidate/release/verify/STAGES.json'];need(len(v)==13 and len({x['name'] for x in v})==13 and all(x['exit_code']==0 for x in v),'all thirteen supplier release stages') + need(any(x['name']=='shared-kernel-independent-review' for x in v) and any(x['name']=='geometry-controls' for x in v),'mandatory new proof and geometry stages') + for label,item in d[E+'ACTUAL-CONTROLS.json']['counts'].items():need(item['source_sha256']==sha(raw[E+item['source']]),'control source binding '+label) + ceiling=d[E+'CEILING-REALIZED.json'];need(rational(ceiling['fraction_of_local_profile_ceiling_lower'])==KAPPA/rational(ceiling['local_profile_ceiling_upper']),'exact ceiling realization') + + +def corruption_controls(raw,d,cache): + results=[] + def trial(name,fn,mutation,target,expected): + changed=copy.deepcopy(target);mutation(changed) + need(changed!=target,'nonvacuous evidence mutation '+name) + try:fn(changed) + except Invalid as ex: + need(expected in str(ex),'wrong rejection reason '+name+': '+str(ex)) + results.append({'name':name,'rejected_for':str(ex)}) + else:raise Invalid('accepted corruption '+name) + def change(key,field,value):return lambda z:z[key].__setitem__(field,value) + trial('inflated_headline',lambda z:claims(raw,z),change('CLAIM.json','kappa',str(KAPPA+Q(1,10**9))),d,'exact headline') + trial('false_secondary_gain',lambda z:claims(raw,z),lambda z:z['CLAIM.json']['secondary_comparison'].__setitem__('gain','0'),d,'secondary comparison') + trial('source_manifest_substitution',lambda z:sources(raw,z),lambda z:z[E+'source/DERIVED-MANIFEST.json'].__setitem__('verify.py','0'*64),d,'eleven source changes') + trial('missing_native_stage',lambda z:native(raw,z,cache),lambda z:z[E+'native/fresh-base/RESULT.json']['steps'].pop(),d,'five fresh native stages') + trial('native_profile_undercharge',lambda z:native(raw,z,cache),lambda z:z[E+'native/base/SCALAR-FRAME-AUDIT.json']['local_profile'].__setitem__('1',2393),d,'scalar endpoint') + trial('missing_native_cache_member',lambda z:native(raw,d,z),lambda z:z.pop(next(iter(z))),cache,'complete native archive') + trial('stale_controller_count_15',controls,lambda z:z[AUDIT+'ASYNC-AUDIT.json']['mutations_rejected'].__delitem__(slice(15,None)),d,'actual control array: controller') + trial('missing_shared_kernel_control',controls,lambda z:z[E+'candidate/release/verify/shared-kernel-independent-review/FOUR-GROUP-INDEPENDENT-REVIEW.json']['variants']['extra']['controls'].pop(),d,'actual control array: shared_kernel_extra') + trial('non_strict_outer_margin',controls,lambda z:next(iter(z[E+'candidate/outer/LEDGER.json']['rows']['struct_boundary_radix_union']['strict_checks'].values())).__setitem__('rational','0'),d,'strict modern outer inequality') + trial('omitted_private_buffers',lambda z:billing(raw,z),change(AUDIT+'PREFIX-AND-INVOICE.json','private_zero_buffers',0),d,'complete physical stock') + trial('undercharged_geometry_sweep',lambda z:billing(raw,z),change(AUDIT+'PREFIX-AND-INVOICE.json','bridge_sweeps',332),d,'sweep and prefix invoice') + trial('wrong_live_denominator',lambda z:claims(raw,z),change(E+'candidate/outer/LEDGER.json','W',33151),d,'actual profile denominator') + trial('missing_owner_role',packing,lambda z:z['FILL.json.gz']['rows'].pop(),d,'complete literal roles') + trial('overlapping_owner_role',packing,lambda z:z['FILL.json.gz']['rows'].__setitem__(1,list(z['FILL.json.gz']['rows'][0])),d,'physical family collision') + trial('free_idle_remainder',packing,lambda z:z['PROFILE.json'].__setitem__('9',0),d,'literal whole profile') + trial('changed_shipped_word',lambda z:sources(z,d),lambda z:z.__setitem__('words/WORD-base.json.gz',z['words/WORD-base.json.gz']+b'x'),raw,'changed word byte binding') + for name in ['../escape','/absolute','a/../escape','a\\escape']: + try:safe_name(name) + except Invalid:results.append({'name':'unsafe_path_'+name,'rejected_for':'unsafe relative path'}) + else:raise Invalid('accepted unsafe path') + return results + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--package',type=Path,required=True);ap.add_argument('--out',type=Path);ap.add_argument('--controls',action='store_true');a=ap.parse_args() + root=a.package.resolve(strict=True) + if a.out: + out=a.out.absolute();need(not out.exists() and not out.is_symlink(),'fresh external output required') + need(not out.resolve().is_relative_to(root),'output must be outside inspected package') + raw,d,cache=load(root) + sources(raw,d);native(raw,d,cache);owner=packing(d);billing(raw,d);controls(d);claims(raw,d) + tests=corruption_controls(raw,d,cache) if a.controls else [] + receipt={'status':'PASS_BOUNDED_READ_ONLY_RELEASE_EVIDENCE','checker_sha256':sha(Path(__file__).read_bytes()),'evidence_manifest_sha256':MANIFEST_PIN, + 'package_claim_sha256':sha(raw['CLAIM.json']),'evidence_files':167,'native_archive_members':len(cache),'literal_owner':owner, + 'kappa':str(KAPPA),'gain_over_pr2848':str(GAIN),'secondary_comparison_claim_sha256':PR2853_PIN,'actual_controls':COUNTS, + 'fresh_current_native_chains':2,'reused_retained_native_chains':2,'reused_retained_parent_stages':16, + 'corruption_controls':tests,'scope':'Authenticates the executed full-release evidence and replays the literal finite owner bill; does not rerun the native scalar or outer engines. Two current chains were fresh in the recorded release; two unchanged retained chains and parent were reused. Inherited all-size/compiler/hosting/precision/tape/analytic obligations remain; no new Lean proof.'} + # Re-read every consumed file to detect accidental changes; no package writes. + for name,b in raw.items(): + if not name.startswith('cache/'):need(read_file(root,name)==b,'input changed during read-only verification') + output=json.dumps(receipt,sort_keys=True,indent=2)+'\n' + if a.out: + with a.out.open('x',encoding='utf-8') as f:f.write(output) + print(output,end='') +if __name__=='__main__': + try:main() + except (Invalid,KeyError,TypeError,ValueError,OSError) as exc: + raise SystemExit('REJECT_RELEASE_EVIDENCE: '+str(exc)) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW-OPTIMIZED.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW-OPTIMIZED.json new file mode 100644 index 0000000000..dc1ca9a67c --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW-OPTIMIZED.json @@ -0,0 +1,78 @@ +{ + "adapter_sha256": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "added_paths": 6, + "candidate_code_executed": false, + "check_count": 11, + "checker_sha256": "0f02d3e0fb0d53dc4d2c444bbdd7054040ee32bf2a1fef8ff96e3a780d579203", + "checks": [ + "adapter_exact_AST_guard_preservation", + "pinned_before_after_manifests_541_to547", + "eleven_changes_five_modified_six_added_no_deletions", + "all_536_other_source_hashes_unchanged", + "derivation_receipt_manifest_delta_binding", + "builder_native_preparer_executed_wrapper_pins", + "exact_additive_patch_new/rebuild_borrow.py", + "exact_additive_patch_verify.py", + "two_word_snapshots_and_generator_review_bound", + "executed_wrapper_pins_derivation_and_adapter", + "runtime_geometry_exact_undercharge_nonvacuity_six_controls_retained" + ], + "derivation_sha256": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "fixture_sha256": { + "derivation": { + "DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5" + }, + "new": { + "admit.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "runtime/geometry_controls.py": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "source/MANIFEST.json": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "source/new/rebuild_borrow.py": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "source/verify.py": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92" + }, + "old": { + "admit.py": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "runtime/geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "source/MANIFEST.json": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "source/new/rebuild_borrow.py": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "source/verify.py": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0" + } + }, + "full_source_trees_rehashed": {}, + "modified_paths": 5, + "overlay_change_count": 11, + "overlay_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "predecessor_adapter_sha256": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "rejected_controls": [ + "weakened_stage_exit_guard", + "wrong_source_manifest", + "wrong_comparison_field", + "float_helper_count", + "wrong_default", + "weakened_final_source_guard", + "zero_decrement_geometry_mutant", + "geometry_control_waiver", + "weakened_assemble_predicate", + "removed_geometry_nonvacuity_check", + "altered_predecessor_bytes", + "unlisted_source_change", + "removed_inherited_verify_guard", + "removed_kernel_chain_stage", + "altered_derivation_receipt", + "weakened_cache_binding", + "weakened_secondary_comparison", + "empty_source_cache_directory", + "source_bytecode_file", + "source_symlink" + ], + "scope": "Exact adapter AST guard preservation except the approved non-vacuous geometry mutant patch, authenticated unchanged overlay manifest delta, two additive supplier validator patches, frozen wrapper/preparer pins. Minimal fixtures do not prove omitted file bytes or full runtime admission; optional whole-source rehashes and full release evidence are reported separately.", + "source_file_counts": { + "new": 547, + "old": 541 + }, + "source_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "status": "PASS_EXACT_SHARED_KERNEL_INTEGRATION_DERIVATION", + "wrapper_sha256": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW.json new file mode 100644 index 0000000000..6d39ddae94 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/DERIVATION-REVIEW.json @@ -0,0 +1,81 @@ +{ + "adapter_sha256": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "added_paths": 6, + "candidate_code_executed": false, + "check_count": 11, + "checker_sha256": "0f02d3e0fb0d53dc4d2c444bbdd7054040ee32bf2a1fef8ff96e3a780d579203", + "checks": [ + "adapter_exact_AST_guard_preservation", + "pinned_before_after_manifests_541_to547", + "eleven_changes_five_modified_six_added_no_deletions", + "all_536_other_source_hashes_unchanged", + "derivation_receipt_manifest_delta_binding", + "builder_native_preparer_executed_wrapper_pins", + "exact_additive_patch_new/rebuild_borrow.py", + "exact_additive_patch_verify.py", + "two_word_snapshots_and_generator_review_bound", + "executed_wrapper_pins_derivation_and_adapter", + "runtime_geometry_exact_undercharge_nonvacuity_six_controls_retained" + ], + "derivation_sha256": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "fixture_sha256": { + "derivation": { + "DERIVATION.json": "da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7", + "build_overlay.py": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "prepare_shared_native.py": "9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07", + "reproduce.py": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5" + }, + "new": { + "admit.py": "c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f", + "runtime/geometry_controls.py": "99bef04f24a99088e5c0c9b8f6bbc8386669d8315b8f572d6bbfb932c5d51145", + "source/MANIFEST.json": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "source/new/rebuild_borrow.py": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "source/verify.py": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92" + }, + "old": { + "admit.py": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "runtime/geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "source/MANIFEST.json": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "source/new/rebuild_borrow.py": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "source/verify.py": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0" + } + }, + "full_source_trees_rehashed": { + "new": 547, + "old": 541 + }, + "modified_paths": 5, + "overlay_change_count": 11, + "overlay_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "predecessor_adapter_sha256": "b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b", + "rejected_controls": [ + "weakened_stage_exit_guard", + "wrong_source_manifest", + "wrong_comparison_field", + "float_helper_count", + "wrong_default", + "weakened_final_source_guard", + "zero_decrement_geometry_mutant", + "geometry_control_waiver", + "weakened_assemble_predicate", + "removed_geometry_nonvacuity_check", + "altered_predecessor_bytes", + "unlisted_source_change", + "removed_inherited_verify_guard", + "removed_kernel_chain_stage", + "altered_derivation_receipt", + "weakened_cache_binding", + "weakened_secondary_comparison", + "empty_source_cache_directory", + "source_bytecode_file", + "source_symlink" + ], + "scope": "Exact adapter AST guard preservation except the approved non-vacuous geometry mutant patch, authenticated unchanged overlay manifest delta, two additive supplier validator patches, frozen wrapper/preparer pins. Minimal fixtures do not prove omitted file bytes or full runtime admission; optional whole-source rehashes and full release evidence are reported separately.", + "source_file_counts": { + "new": 547, + "old": 541 + }, + "source_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "status": "PASS_EXACT_SHARED_KERNEL_INTEGRATION_DERIVATION", + "wrapper_sha256": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/FAILED-V1.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/FAILED-V1.json new file mode 100644 index 0000000000..0cceac8f4a --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/FAILED-V1.json @@ -0,0 +1,11 @@ +{ + "status": "PRESERVED_FAILED_V1_COMPLETE_ADMISSION", + "failure": "old_call_count assigned333 to actual333, so the intended undercharge mutant was identical to its baseline", + "actual_invocation_sweeps": 333, + "actual_bridge_sweeps": 333, + "invoice_sha256": "6ee76d9e40536cd9c3e8a0f59f09efd35089d630d6dd2680906c1d83306e502f", + "v1_wrapper_sha256": "61207eba2ea62ed096bc1cb5187343cd7e782172e5208578999f67dcf352697e", + "v1_adapter_sha256": "a8781eb619ba7584b5e193de0e9d766c245f7fcd3bfb6a799ebc92aff2d5e329", + "stages_sha256": "f9daa6c70045017b3fe216479c32d67516e8ca3fc0a9ae847dfca24803659868", + "scope": "Failure was not waived; all six geometry controls remain required in v2." +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/FINAL-CHAIN-REVIEW.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/FINAL-CHAIN-REVIEW.json new file mode 100644 index 0000000000..7f3c8b5092 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/FINAL-CHAIN-REVIEW.json @@ -0,0 +1,112 @@ +{ + "status": "PASS_INDEPENDENT_FINAL_RELEASE_CHAIN_REVIEW", + "checks": [ + "wrapper_candidate_release_PASS", + "executed_v2_wrapper_hash", + "wrapper_binds_candidate_result", + "wrapper_candidate_native_receipt_chain", + "wrapper_candidate_release_receipt_chain", + "wrapper_candidate_release_package_manifest_chain", + "all_generated_package_file_hashes", + "source_derivation_receipt", + "derived_source_manifest_chain", + "all_547_derived_source_files_unchanged", + "all_541_original_source_files_unchanged", + "all_bound_external_inputs_unchanged", + "entire_native_cache_file_inventory", + "fresh_and_reused_provenance_exact", + "fresh_base_word_and_complete_files_bound", + "fresh_base_five_native_stages", + "fresh_base_native_result", + "fresh_extra_word_and_complete_files_bound", + "fresh_extra_five_native_stages", + "fresh_extra_native_result", + "all_three_wrapper_stages_and_logs", + "all_admission_stage_exit_codes", + "exact_modern_outer_headline_all_layers", + "exact_positive_gain_vs_PR2848", + "exact_positive_gain_vs_PR2853", + "all_six_nonvacuous_geometry_controls_pass", + "executed_geometry_script_matches_reviewed_v2", + "publication_bundle_all_files_match_manifest", + "publication_COMPLETE_pins_full_run", + "published_primary_receipts_byte_exact", + "actual_control_source_admission", + "actual_control_count_admission", + "actual_control_source_base_native_mutants", + "actual_control_count_base_native_mutants", + "actual_control_source_base_warp_mutants", + "actual_control_count_base_warp_mutants", + "actual_control_source_base_wrapper_mutants", + "actual_control_count_base_wrapper_mutants", + "actual_control_source_bit", + "actual_control_count_bit", + "actual_control_source_controller", + "actual_control_count_controller", + "actual_control_source_extra_native_mutants", + "actual_control_count_extra_native_mutants", + "actual_control_source_extra_warp_mutants", + "actual_control_count_extra_warp_mutants", + "actual_control_source_extra_wrapper_mutants", + "actual_control_count_extra_wrapper_mutants", + "actual_control_source_geometry", + "actual_control_count_geometry", + "actual_control_source_independent_owner", + "actual_control_count_independent_owner", + "actual_control_source_modern_outer_rejections", + "actual_control_count_modern_outer_rejections", + "actual_control_source_modern_outer_strict_inequalities", + "actual_control_count_modern_outer_strict_inequalities", + "actual_control_source_shared_kernel_base", + "actual_control_count_shared_kernel_base", + "actual_control_source_shared_kernel_extra", + "actual_control_count_shared_kernel_extra", + "actual_control_source_supplier_outer_rows", + "actual_control_count_supplier_outer_rows", + "actual_controls_not_stale_summary_metadata", + "root_package_executed_admit_shared_replica.py", + "root_package_executed_reproduce.py", + "root_package_executed_build_overlay.py", + "root_package_executed_prepare_shared_native.py", + "published_native_archive_hash", + "published_native_archive_exact_cache_inventory" + ], + "check_count": 69, + "kappa": "17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "gain_vs_pr2848": "1438120379902596153/1000000000000000000000000", + "gain_vs_pr2853_approx": 7.189699872459419e-07, + "wrapper_sha256": "7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5", + "source_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "overlay_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "native_receipt_sha256": "5a7571fec09d1d0326a430540df3c19bb90d337dbdf602a63bde032c0da9b98d", + "package_manifest_sha256": "88a7ad8ce5cf4cec2633957215f5849459e7eb1087f3e7e1f1865bbe38d685ff", + "release_receipt_sha256": "c052decb90ceae345b398f111781f567fb787309a528877500cf7fe1cff13b3d", + "package_files": 551, + "publication_files": 167, + "actual_control_counts": { + "admission": 119, + "base_native_mutants": 46, + "base_warp_mutants": 13, + "base_wrapper_mutants": 25, + "bit": 12, + "controller": 25, + "extra_native_mutants": 46, + "extra_warp_mutants": 13, + "extra_wrapper_mutants": 25, + "geometry": 6, + "independent_owner": 8, + "modern_outer_rejections": 17, + "modern_outer_strict_inequalities": 63, + "shared_kernel_base": 8, + "shared_kernel_extra": 8, + "supplier_outer_rows": 47 + }, + "observations": [ + "Inherited controller summary metadata15 is stale; actual array25 verified.", + "Inherited finite supplier kappa is a coarse layer; modern headline bound verified through wrapper, outer claim and release receipt.", + "Failed first full run remains preserved; corrected geometry controls all passed.", + "README/TASK were drafts during review; root is finalizing them.", + "Published native archive contains output cache; full reproduction requires the separately pinned PR2848 input cache." + ], + "scope": "Read-only hash-chain, source immutability, exact claim and evidence review. No new replay or selected-frontier change; conditional inherited obligations remain." +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/REVIEW.md b/research/shared-kernel-packing/vendor/pr2857/integration-review/REVIEW.md new file mode 100644 index 0000000000..4715465b14 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/REVIEW.md @@ -0,0 +1,49 @@ +# Independent integration derivation review + +Status: PASS for the frozen source/admission derivation; complete runtime admission remains a separate result. No integration blocker was found in the reviewed wrapper and cache/source bindings. + +`check_integration_derivation.py` is portable and does not execute candidate, builder, wrapper or admission code. The fixture directories preserve the exact predecessor and successor admission scripts, the two source manifests, both versions of the two altered validator scripts, the builder receipt, and the frozen integration scripts. The bundle is about328KB; the two full manifests account for133KB. It now also includes the original and exactly derived runtime geometry-control script. No immutable source or executing wrapper was edited by this review. + +## What was established + +- The predecessor admission script is pinned at SHA256 `b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b`. The new admission AST differs only by the exact `shared-four` source record, exact PR2848 comparison record, the corresponding two CLI defaults, and one precisely specified runtime patch call for the geometry mutation tests described below. All remaining executable AST nodes, guards, function bodies and the docstring match. The new script is pinned by the executing wrapper at `c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f`. +- The original541-file manifest and new547-file manifest are authenticated. There are exactly five modified paths and six added paths, with no deletions. The other536 original file hashes are unchanged. A separate executed whole-tree check rehashed all541 original and547 derived files, rejected symlinks, and rejected both bytecode files and empty cache directories. +- `new/rebuild_borrow.py` has exactly the declared additive stage before the retained final-word check. It authenticates the preceding word's canonical hash, invokes the pinned pure generator, checks the result hash and ledger, checks the changed-field set and derived cleanup, and appends the new state to the existing audit chain. All previous source bytes are retained. Because the complete source manifest binds the added stage-input files, the optional file-presence branch cannot omit this stage in an authenticated overlay. +- `verify.py` retains every original byte and adds exactly one independent-review call immediately after the original word-rebuild call. The inverse replacement recovers the original file byte-for-byte. +- The two archived original words match their original compressed hashes. The derived words, generator and review identities are bound through the manifest and derivation receipt. Manual provider inspection confirmed both profiles and all408 ordered widths: only positions236,238,254,256 shrink9→8, corresponding to helper IDs460,462,478,480. Provider record keys are unchanged. + +## Wrapper and cache review + +The executing `reproduce.py` is frozen at SHA256 `7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5`. It accepts explicit paths, resolves them, requires fresh work outside both source and replay package, authenticates source and script/input hashes before work, runs every stage with bytecode disabled and assertions enabled, and rechecks bound inputs after each stage. At completion it checks exact headline equality, package/release hash chaining, original and overlay source immutability, and accurate fresh/reused-native provenance. + +The primary admission comparator remains the immutable PR2848 claim. The PR2853 check is an additional exact rational comparison in the wrapper, with its separate claim hash and exact head recorded; it does not replace or relax the primary admission guards. Both before and after release, the expected/actual headline must beat the pinned PR2853 rational headline. + +`prepare_shared_native.py` binds the complete derived source, refuses source caches, and checks the full retained-cache file map against the pinned PR2848 receipt. It verifies the retained parent source/claim/receipt and all16 retained parent stages, then copies only the authenticated retained proofs. Both changed providers run fresh five-stage native chains. Their complete literal word,408-helper/72-buffer ABI,632 all-column checks and paid profile are checked. The new receipt explicitly reports two fresh current chains, two reused retained chains and one reused retained parent; it does not claim all evidence is fresh. Original source and old cache are rehashed after preparation. + +The builder and wrapper require no absolute scratch path. The minimal fixture checker can be run with Python isolated/optimized flags; it uses explicit exceptions instead of assertions for its own checks. + +## Verification and failure controls + +The checker passed11 named groups of checks and rejected20 mutations/invalid inputs, covering an altered stage-success predicate, wrong source manifest, wrong comparison field, a numeric-type change, wrong default, weakened final source guard, altered predecessor, unlisted source path, altered inherited validator, missing appended kernel stage, altered derivation receipt, weakened retained-cache predicate, weakened secondary comparison, empty source cache directory, bytecode file and symlink. Four additional controls reject a zero decrement, a geometry-control waiver, a weakened assembly predicate, and removal of the non-vacuity check. The same20 controls passed under `python -I -O -B`. + +The four source/native wrapper files are authenticated by exact bytes; pinning them does not itself prove their runtime outcome. The runtime review above is a source inspection. The minimal fixture proof authenticates the full manifest maps but cannot rehash omitted payload files. `DERIVATION-REVIEW.json` separately records the actual whole-tree rehash; `DERIVATION-REVIEW-OPTIMIZED.json` records a portable minimal-fixture run without claiming those payload reads. + +## Preserved first-run failure and exact runtime correction + +The first full run passed source derivation and fresh native replay, then failed during complete admission because `old_call_count` assigned333 to both sweep counts. The actual T37 invoice already had333 invocation sweeps and333 bridge sweeps, so that particular mutation was a no-op. `FAILED-V1.json` preserves the actual invoice hash, counts, stage-log hash and executed v1 script hashes. Original v1 fixtures and receipts remain in the parent review directory. This failure was not waived or recategorized as a successful release. + +The corrected adapter adds one exact runtime `patch('geometry_controls.py', ...)` call, placed between its existing rebind and verify-release patches. It makes exactly two replacements: decrement each actual sweep count by1, and require `(o,i)!=(owner,invoice)` immediately after invoking every mutation and **before** updating the owner hash or calling assembly. Thus at this invoice the undercharge is333→332 for both counts. All six mutation names, the original assembly calls, their exception requirements and the failure-on-acceptance branch remain byte-for-byte unchanged. + +The checker authenticates the original geometry script against both unchanged source manifests, applies only those two literal replacements, and compares every byte of the derived runtime script. It checks both `-=` AST nodes and the complete six-control list. It removes only this exact, location-bound patch call before comparing the admission AST with its predecessor, so a change to the existing assembly predicates is still rejected. The geometry source file inside the547-file overlay is unchanged; this is a declared derived-package runtime patch. `T37-GEOMETRY-PREFLIGHT.json` records that all six corrected mutations were rejected against the first run's strict assembly. The corrected full replay starts in a fresh directory and its final release outcome remains separate from this source review. + +## Reproduce + +```sh +PYTHONDONTWRITEBYTECODE=1 python3 -B check_integration_derivation.py \ + --old fixtures/old --new fixtures/new --derivation fixtures/derivation \ + --out DERIVATION-REVIEW.json --controls +``` + +For an actual payload rehash also pass `--full-old-source ORIGINAL_PR2833_DIRECTORY --full-new-source DERIVED_OVERLAY_DIRECTORY`. This review does not replace fresh native phase/Gaussian replay, owner/controller/geometry checks, exact outer checks, or the final strict release receipt. + +`PRODUCTION-EQUIVALENCE.json` additionally records that the current production generator `b3241527...` reconstructed both frozen candidate decoded words without mutating its inputs. The earlier prototype hash `90aa848c...` is historical, not the production generator's identity. The local algebra proof has been relabeled accordingly. diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/T37-GEOMETRY-PREFLIGHT.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/T37-GEOMETRY-PREFLIGHT.json new file mode 100644 index 0000000000..9f71586085 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/T37-GEOMETRY-PREFLIGHT.json @@ -0,0 +1,29 @@ +{ + "status": "PASS_T74_GEOMETRY_AND_CHARGE_CONTROLS", + "rejected": [ + { + "name": "old_prefix", + "reason": "strict arithmetic invariant" + }, + { + "name": "old_call_count", + "reason": "strict arithmetic invariant" + }, + { + "name": "old_parent_idle", + "reason": "strict arithmetic invariant" + }, + { + "name": "old_stock", + "reason": "strict arithmetic invariant" + }, + { + "name": "missing_call", + "reason": "strict arithmetic invariant" + }, + { + "name": "low_row", + "reason": "strict arithmetic invariant" + } + ] +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/check_integration_derivation.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/check_integration_derivation.py new file mode 100644 index 0000000000..ea8d42a561 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/check_integration_derivation.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Check the frozen shared-kernel integration derivation without executing candidate code. + +--old/--new contain admit.py, source/{MANIFEST.json,new/rebuild_borrow.py,verify.py}, +and runtime/geometry_controls.py (original versus exact runtime control patch). +--derivation contains DERIVATION.json,build_overlay.py,prepare_shared_native.py,reproduce.py. +The minimal fixture proof authenticates complete manifest inventories and the two +changed validator scripts. Optional full-source paths additionally rehash every file. +Prepared for Yiyang (@Lyy-iiis) with substantial OpenAI Codex assistance. +""" +import argparse,ast,copy,hashlib,json,tempfile +from pathlib import Path,PurePosixPath + +BASE_ADMIT='b926725ea029c71979e48e785578aa4821ea7ea73c8e9139c4e2c71fa6bfc91b' +OLD_MANIFEST='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +NEW_MANIFEST='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +DERIVATION_SHA='da6024f182a95a5b39cfbc24638aff14a104c2e7cf3037aa5840ef4fc6395eb7' +SCRIPT_PINS={'build_overlay.py':'4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666','prepare_shared_native.py':'9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07','reproduce.py':'7fc4cd1277f42ba0a25a1eae72c6290878fefd5bab7053f4e548c15d95d914c5'} +CHANGED={'new/BORROW-PROVIDERS.json','new/borrow/inputs/PR2833-WORD-base.json.gz','new/borrow/inputs/PR2833-WORD-extra.json.gz','new/borrow/inputs/shared_kernel_43base.json','new/borrow/inputs/shared_kernel_43extra.json','new/borrow/shared_kernel.py','new/borrow/shared_kernel_review.py','new/borrow/words/BORROW-WORD-43base.json.gz','new/borrow/words/BORROW-WORD-43extra.json.gz','new/rebuild_borrow.py','verify.py'} +ADDITIONS={ + 'SOURCE_PROFILES':{'shared-four':{'commit':'shared-four-kernel-pr2833','manifest':NEW_MANIFEST,'helpers':408,'source_file_count':547,'upstream_head':'e9307b48d7d1b690939935ecef0f8e524e6d92f4'}}, + 'COMPARISONS':{'pr2848':{'pr':2848,'head':'c50d12e4720cd1fef2b5a65e337e37de9731879a','sha256':'aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9','field':'kappa'}}, +} +DEFAULTS={'--source-profile':('pr2833','shared-four'),'--comparison-profile':('pr2843','pr2848')} +ANCHORS={'new/rebuild_borrow.py':' final=json.loads(gzip.decompress(shipped.read_bytes()))','verify.py':"run('rebuild-borrow-words',P/'new/rebuild_borrow.py')"} +def need(ok,reason): + if not ok:raise ValueError(reason) +def sha(data):return hashlib.sha256(data).hexdigest() +def jdata(data):return json.loads(data) +def canon(obj):return json.dumps(obj,sort_keys=True,separators=(',',':')) +def assignment(tree,name): + nodes=[x for x in tree.body if isinstance(x,ast.Assign) and len(x.targets)==1 and isinstance(x.targets[0],ast.Name) and x.targets[0].id==name] + need(len(nodes)==1,'one assignment: '+name);return nodes[0] +def literal_records(node): + need(isinstance(node.value,ast.Dict),'literal outer dict') + keys=[ast.literal_eval(k) for k in node.value.keys];need(all(type(k)is str for k in keys) and len(keys)==len(set(keys)),'distinct literal record keys') + out={} + for k,v in zip(keys,node.value.values): + need(isinstance(v,ast.Call) and isinstance(v.func,ast.Name) and v.func.id=='dict' and not v.args,'literal dict keyword record') + names=[x.arg for x in v.keywords];need(None not in names and len(names)==len(set(names)),'distinct explicit record fields') + out[k]={q.arg:ast.literal_eval(q.value) for q in v.keywords} + return out +def default_node(tree,flag): + calls=[n for n in ast.walk(tree) if isinstance(n,ast.Call) and isinstance(n.func,ast.Attribute) and n.func.attr=='add_argument' and n.args and isinstance(n.args[0],ast.Constant) and n.args[0].value==flag] + need(len(calls)==1,'one CLI option: '+flag);kw=[k for k in calls[0].keywords if k.arg=='default'];need(len(kw)==1,'one CLI default: '+flag);return kw[0] +GEOMETRY_REPLACEMENTS=[ + (" i['complete_invocation_sweeps']=i['bridge_sweeps']=333", " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1"), + (" o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh"), +] +def remove_exact_geometry_patch(tree): + mains=[n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='main'];need(len(mains)==1,'one admission main') + body=mains[0].body;matches=[] + for i,n in enumerate(body): + if isinstance(n,ast.Expr) and isinstance(n.value,ast.Call): + c=n.value + if isinstance(c.func,ast.Name) and c.func.id=='patch' and c.args and isinstance(c.args[0],ast.Constant) and c.args[0].value=='geometry_controls.py':matches.append((i,c)) + need(len(matches)==1,'exactly one geometry control patch call');i,c=matches[0] + need(len(c.args)==2 and not c.keywords and ast.literal_eval(c.args[1])==GEOMETRY_REPLACEMENTS,'only exact undercharge and non-vacuity geometry edits') + def patch_target(n): + if isinstance(n,ast.Expr) and isinstance(n.value,ast.Call) and isinstance(n.value.func,ast.Name) and n.value.func.id=='patch' and n.value.args and isinstance(n.value.args[0],ast.Constant):return n.value.args[0].value + need(i>0 and i+1Q(latest['kappa_rational'])","True")) + for name,kind in [('empty_source_cache_directory','cache'),('source_bytecode_file','bytecode'),('source_symlink','symlink')]: + with tempfile.TemporaryDirectory(prefix='integration-derivation-control-') as temp: + p=Path(temp) + if kind=='cache':(p/'__pycache__').mkdir() + elif kind=='bytecode':(p/'unexpected.pyc').write_bytes(b'not executable') + else:(p/'link').symlink_to('absent-target') + try:full_tree(p,{}) + except ValueError:rejected.append(name) + else:raise RuntimeError('accepted invalid full-source control: '+name) + return rejected + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + for n in ['old','new','derivation','out']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--controls',action='store_true');ap.add_argument('--full-old-source',type=Path);ap.add_argument('--full-new-source',type=Path);a=ap.parse_args() + b=read_bundle(a.old,a.new,a.derivation);checks=check_bundle(b);extra={} + for tag,path in [('old',a.full_old_source),('new',a.full_new_source)]: + if path is not None: + expected=jdata(b[tag]['source/MANIFEST.json']);need((path/'MANIFEST.json').read_bytes()==b[tag]['source/MANIFEST.json'],'full source manifest bytes');extra[tag]=full_tree(path,expected) + rejected=controls(b) if a.controls else [] + result=dict(status='PASS_EXACT_SHARED_KERNEL_INTEGRATION_DERIVATION',checks=checks,check_count=len(checks),rejected_controls=rejected,adapter_sha256=sha(b['new']['admit.py']),predecessor_adapter_sha256=BASE_ADMIT,source_manifest_sha256=OLD_MANIFEST,overlay_manifest_sha256=NEW_MANIFEST,overlay_change_count=11,modified_paths=5,added_paths=6,source_file_counts={'old':541,'new':547},full_source_trees_rehashed=extra,wrapper_sha256=SCRIPT_PINS['reproduce.py'],derivation_sha256=DERIVATION_SHA,checker_sha256=sha(Path(__file__).read_bytes()),fixture_sha256={g:{p:sha(v) for p,v in files.items()} for g,files in b.items()},candidate_code_executed=False,scope='Exact adapter AST guard preservation except the approved non-vacuous geometry mutant patch, authenticated unchanged overlay manifest delta, two additive supplier validator patches, frozen wrapper/preparer pins. Minimal fixtures do not prove omitted file bytes or full runtime admission; optional whole-source rehashes and full release evidence are reported separately.') + a.out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n');print(json.dumps({k:result[k] for k in ['status','check_count','rejected_controls','full_source_trees_rehashed']},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/DERIVATION.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/DERIVATION.json new file mode 100644 index 0000000000..458221c714 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/DERIVATION.json @@ -0,0 +1,764 @@ +{ + "builder_sha256": "4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666", + "changes": { + "new/BORROW-PROVIDERS.json": { + "after_sha256": "5527d70aa83ad3b05a7176903016c12fc410bc9968082377eeed66c8d298dafa", + "before_sha256": "3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda" + }, + "new/borrow/inputs/PR2833-WORD-base.json.gz": { + "after_sha256": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "before_sha256": null + }, + "new/borrow/inputs/PR2833-WORD-extra.json.gz": { + "after_sha256": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "before_sha256": null + }, + "new/borrow/inputs/shared_kernel_43base.json": { + "after_sha256": "d06f52975d4d48523177fd3010f9b6d36094636b3d31b90c492404a9c21ef6e3", + "before_sha256": null + }, + "new/borrow/inputs/shared_kernel_43extra.json": { + "after_sha256": "79a3d0309ee1154f778f05592ac09f51db64286828456f8c1fca22c1c8b05af2", + "before_sha256": null + }, + "new/borrow/shared_kernel.py": { + "after_sha256": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "before_sha256": null + }, + "new/borrow/shared_kernel_review.py": { + "after_sha256": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "before_sha256": null + }, + "new/borrow/words/BORROW-WORD-43base.json.gz": { + "after_sha256": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "before_sha256": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7" + }, + "new/borrow/words/BORROW-WORD-43extra.json.gz": { + "after_sha256": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546", + "before_sha256": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac" + }, + "new/rebuild_borrow.py": { + "after_sha256": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "before_sha256": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3" + }, + "verify.py": { + "after_sha256": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "before_sha256": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0" + } + }, + "derived_manifest_sha256": "54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869", + "patches": [ + { + "after_sha256": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "before_sha256": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "new": " # Four disjoint staged compensation kernels, after the complete pinned\n # PR2833 derivation. Every previous state stays in the audit chain.\n sf_=D/'inputs'/f'shared_kernel_43{wt}.json'\n if sf_.exists():\n import shared_kernel\n shared_patch=json.loads(sf_.read_text());previous_shared=chain[-1]\n canonical=lambda z:hashlib.sha256(json.dumps(z,sort_keys=True,separators=(',',':')).encode()).hexdigest()\n assert shared_patch['groups']==[478,460,462,480]\n assert canonical(previous_shared)==shared_patch['source_canonical_sha256']\n shared_word,shared_ledger=shared_kernel.apply(previous_shared,shared_patch['groups'])\n assert canonical(shared_word)==shared_patch['candidate_canonical_sha256']\n assert json.loads(json.dumps(shared_ledger))==shared_patch['ledger']\n assert set(k_ for k_ in previous_shared if previous_shared[k_]!=shared_word[k_])=={'A','compensation','start_extra','report','cleanup'}\n stripped_shared=json.loads(json.dumps(shared_word));stripped_shared['A']=stripped_shared['A'][stripped_shared['prelude_events']:]\n assert shared_word['cleanup']==word_patch.derive_cleanup(stripped_shared,word_patch.restored_of(shared_word))\n chain.append(shared_word);steps.append('shared-four-kernel')\n final=json.loads(gzip.decompress(shipped.read_bytes()))", + "old": " final=json.loads(gzip.decompress(shipped.read_bytes()))", + "path": "new/rebuild_borrow.py" + }, + { + "after_sha256": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "before_sha256": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0", + "new": "run('rebuild-borrow-words',P/'new/rebuild_borrow.py')\nrun('shared-kernel-independent-review',P/'new/borrow/shared_kernel_review.py','--source-dir',P/'new/borrow','--source-base',P/'new/borrow/inputs/PR2833-WORD-base.json.gz','--source-extra',P/'new/borrow/inputs/PR2833-WORD-extra.json.gz','--candidate-base',P/'new/borrow/words/BORROW-WORD-43base.json.gz','--candidate-extra',P/'new/borrow/words/BORROW-WORD-43extra.json.gz','--out-dir',work/'shared-kernel-independent-review')", + "old": "run('rebuild-borrow-words',P/'new/rebuild_borrow.py')", + "path": "verify.py" + } + ], + "scope": "Exact source overlay construction only. Full native and owner/controller/outer admission remain separate; all inherited validators are retained and an independent kernel review is added.", + "source_file_count": 547, + "status": "PASS_SOURCE_BOUND_FOUR_KERNEL_OVERLAY_DERIVATION", + "upstream_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "words": { + "base": { + "candidate_canonical_sha256": "c0af0ef7ee6282e91f046d027983b35eaed7ebcb46489134d47e07724cf664bc", + "candidate_word_sha256": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "generator_sha256": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "groups": [ + 478, + 460, + 462, + 480 + ], + "ledger": { + "chosen": [ + 478, + 460, + 462, + 480 + ], + "delta": { + "1": 12, + "2": -8 + }, + "groups": [ + { + "compensation_added": 4, + "compensation_removed": 4, + "entry": [ + 25 + ], + "group": [ + 478, + 479, + 490, + 491 + ], + "new_width": 8, + "raised": 478, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 7 + ], + "group": [ + 460, + 461, + 468, + 469 + ], + "new_width": 8, + "raised": 460, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 7 + ], + "group": [ + 462, + 463, + 470, + 471 + ], + "new_width": 8, + "raised": 462, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 25 + ], + "group": [ + 480, + 481, + 492, + 493 + ], + "new_width": 8, + "raised": 480, + "source_width": 9 + } + ], + "insertions": { + "1301": [ + [ + "add", + 470, + 462, + -1, + 1, + [ + 7 + ] + ] + ], + "1303": [ + [ + "add", + 490, + 478, + -1, + 1, + [ + 25 + ] + ], + [ + "add", + 471, + 470, + 1, + 1, + [ + 75, + 7 + ] + ], + [ + "add", + 471, + 524, + -1, + 2, + [ + 75, + 7 + ] + ] + ], + "1305": [ + [ + "add", + 479, + 478, + 1, + 1, + [ + 75, + 25 + ] + ], + [ + "add", + 479, + 526, + 1, + 1, + [ + 75, + 25 + ] + ] + ], + "1307": [ + [ + "add", + 468, + 460, + -1, + 1, + [ + 7 + ] + ] + ], + "1309": [ + [ + "add", + 469, + 468, + 1, + 1, + [ + 97, + 7 + ] + ], + [ + "add", + 469, + 536, + -1, + 2, + [ + 97, + 7 + ] + ], + [ + "add", + 492, + 480, + -1, + 1, + [ + 25 + ] + ] + ], + "1311": [ + [ + "add", + 481, + 480, + 1, + 1, + [ + 97, + 25 + ] + ], + [ + "add", + 481, + 540, + 1, + 1, + [ + 97, + 25 + ] + ] + ], + "1317": [ + [ + "add", + 491, + 490, + 1, + 1, + [ + 102, + 25 + ] + ], + [ + "add", + 491, + 538, + 1, + 1, + [ + 102, + 25 + ] + ] + ], + "1321": [ + [ + "add", + 493, + 492, + 1, + 1, + [ + 76, + 25 + ] + ], + [ + "add", + 493, + 528, + 1, + 1, + [ + 76, + 25 + ] + ] + ], + "1327": [ + [ + "add", + 463, + 462, + 1, + 1, + [ + 120, + 7 + ] + ], + [ + "add", + 463, + 534, + -1, + 2, + [ + 120, + 7 + ] + ] + ], + "1329": [ + [ + "add", + 461, + 460, + 1, + 1, + [ + 82, + 7 + ] + ], + [ + "add", + 461, + 522, + -1, + 2, + [ + 82, + 7 + ] + ] + ] + }, + "local_profile": { + "1": 2394, + "2": 642, + "3": 266, + "4": 128, + "5": 26, + "8": 8 + }, + "source_canonical_sha256": "aaf1d752501a30fdf7305be9515617698d0b4753411844d28f005aab1b67f3df", + "variant": "base", + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 84, + "9": 234 + } + }, + "source_canonical_sha256": "aaf1d752501a30fdf7305be9515617698d0b4753411844d28f005aab1b67f3df", + "source_word_sha256": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7" + }, + "extra": { + "candidate_canonical_sha256": "61b20fbe78fdcbca0cde0597befcc254017ee206dad0724c576672aca690c66f", + "candidate_word_sha256": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546", + "generator_sha256": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "groups": [ + 478, + 460, + 462, + 480 + ], + "ledger": { + "chosen": [ + 478, + 460, + 462, + 480 + ], + "delta": { + "1": 12, + "2": -8 + }, + "groups": [ + { + "compensation_added": 4, + "compensation_removed": 4, + "entry": [ + 25 + ], + "group": [ + 478, + 479, + 490, + 491 + ], + "new_width": 8, + "raised": 478, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 7 + ], + "group": [ + 460, + 461, + 468, + 469 + ], + "new_width": 8, + "raised": 460, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 7 + ], + "group": [ + 462, + 463, + 470, + 471 + ], + "new_width": 8, + "raised": 462, + "source_width": 9 + }, + { + "compensation_added": 8, + "compensation_removed": 8, + "entry": [ + 25 + ], + "group": [ + 480, + 481, + 492, + 493 + ], + "new_width": 8, + "raised": 480, + "source_width": 9 + } + ], + "insertions": { + "1301": [ + [ + "add", + 470, + 462, + -1, + 1, + [ + 7 + ] + ] + ], + "1303": [ + [ + "add", + 490, + 478, + -1, + 1, + [ + 25 + ] + ], + [ + "add", + 471, + 470, + 1, + 1, + [ + 75, + 7 + ] + ], + [ + "add", + 471, + 524, + -1, + 2, + [ + 75, + 7 + ] + ] + ], + "1305": [ + [ + "add", + 479, + 478, + 1, + 1, + [ + 75, + 25 + ] + ], + [ + "add", + 479, + 526, + 1, + 1, + [ + 75, + 25 + ] + ] + ], + "1307": [ + [ + "add", + 468, + 460, + -1, + 1, + [ + 7 + ] + ] + ], + "1309": [ + [ + "add", + 469, + 468, + 1, + 1, + [ + 97, + 7 + ] + ], + [ + "add", + 469, + 536, + -1, + 2, + [ + 97, + 7 + ] + ], + [ + "add", + 492, + 480, + -1, + 1, + [ + 25 + ] + ] + ], + "1311": [ + [ + "add", + 481, + 480, + 1, + 1, + [ + 97, + 25 + ] + ], + [ + "add", + 481, + 540, + 1, + 1, + [ + 97, + 25 + ] + ] + ], + "1317": [ + [ + "add", + 491, + 490, + 1, + 1, + [ + 102, + 25 + ] + ], + [ + "add", + 491, + 538, + 1, + 1, + [ + 102, + 25 + ] + ] + ], + "1321": [ + [ + "add", + 493, + 492, + 1, + 1, + [ + 76, + 25 + ] + ], + [ + "add", + 493, + 528, + 1, + 1, + [ + 76, + 25 + ] + ] + ], + "1327": [ + [ + "add", + 463, + 462, + 1, + 1, + [ + 120, + 7 + ] + ], + [ + "add", + 463, + 534, + -1, + 2, + [ + 120, + 7 + ] + ] + ], + "1329": [ + [ + "add", + 461, + 460, + 1, + 1, + [ + 82, + 7 + ] + ], + [ + "add", + 461, + 522, + -1, + 2, + [ + 82, + 7 + ] + ] + ] + }, + "local_profile": { + "1": 2394, + "2": 642, + "3": 266, + "4": 128, + "5": 26, + "8": 8 + }, + "source_canonical_sha256": "1b02e1ea0214b45071f9d93ad074cc392fd7e59f6fb83a7c4e8cd99c36150a3c", + "variant": "extra", + "width_inventory": { + "4": 26, + "5": 2, + "7": 62, + "8": 84, + "9": 234 + } + }, + "source_canonical_sha256": "1b02e1ea0214b45071f9d93ad074cc392fd7e59f6fb83a7c4e8cd99c36150a3c", + "source_word_sha256": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac" + } + } +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/build_overlay.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/build_overlay.py new file mode 100644 index 0000000000..9215ce67b5 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/build_overlay.py @@ -0,0 +1,89 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Build a source-bound four-kernel supplier overlay without changing PR2833. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Native, scalar, Clifford, all-column, owner and outer validators are retained. +""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +import argparse,copy,gzip,hashlib,json,shutil,types +UPSTREAM_MANIFEST='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +GROUPS=[478,460,462,480] +# Final source hashes are frozen before the first build. +GENERATOR_SHA='b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed' +REVIEW_SHA='5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def sem(v):return hashlib.sha256(json.dumps(v,sort_keys=True,separators=(',',':')).encode()).hexdigest() +def read(p): + p=Path(p);b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p): + need(not list(p.rglob('__pycache__')) and not list(p.rglob('*.pyc')),'no source bytecode or cache folders') + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no source symlinks') + if f.is_file() and f!=p/'MANIFEST.json':out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--generator',type=Path,required=True);ap.add_argument('--review',type=Path,required=True);ap.add_argument('--candidate-dir',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + need(not sys.flags.optimize,'assertions required');source=a.source.resolve();out=a.out.resolve() + need(sha(source/'MANIFEST.json')==UPSTREAM_MANIFEST and tree(source)==read(source/'MANIFEST.json'),'exact PR2833 source inventory') + need(sha(a.generator)==GENERATOR_SHA and sha(a.review)==REVIEW_SHA,'exact new producer and independent review source') + need(not out.exists() and not out.is_relative_to(source),'fresh external overlay');shutil.copytree(source,out) + gen=types.ModuleType('shared_kernel');exec(compile(a.generator.read_bytes(),str(a.generator),'exec'),gen.__dict__) + auditor=types.ModuleType('independent_frames');apath=source/'new/borrow/audit_local.py';exec(compile(apath.read_bytes(),str(apath),'exec'),auditor.__dict__) + # Independently audited literal words are shipped byte-for-byte. The pure + # source-bound producer must reconstruct every decoded field from PR2833. + providers=read(source/'new/BORROW-PROVIDERS.json');records={} + for tag,pid in [('base','gauge44'),('extra','extra')]: + src=source/('new/borrow/words/BORROW-WORD-43'+tag+'.json.gz');target=a.candidate_dir/('WORD-'+tag+'.json.gz');old=read(src);new=read(target);derived,ledger=gen.apply(old,GROUPS) + need(derived==new,'complete producer reconstruction '+tag) + need(set(k for k in old if old[k]!=new[k])=={'A','compensation','start_extra','report','cleanup'},'exact changed sections') + need(new['report']['local_profile']=={'1':2394,'2':642,'3':266,'4':128,'5':26,'8':8},'complete per-call paid profile') + need(new['report']['width_inventory']=={'4':26,'5':2,'7':62,'8':84,'9':234},'complete helper inventory') + live=sorted(set(range(224,704))-set(new['removed']));need(len(live)==408,'unchanged helper identities') + widths=[] + for r in live: + end=auditor.basis(new['helper_final'].get(str(r),[256,128,64,32,16,8,4,2,1]));start=auditor.basis(new['start_extra'].get(str(r),[]));widths.append(len(end)-len(start)) + need(len(new['warps'])==len(old['warps']) and new['helper_final']==old['helper_final'] and new['removed']==old['removed'],'all phase and buffer ABI fields unchanged') + providers[pid]=dict(widths=widths,actual_paid_profile=new['report']['local_profile']) + shutil.copy2(target,out/('new/borrow/words/BORROW-WORD-43'+tag+'.json.gz')) + shutil.copy2(src,out/('new/borrow/inputs/PR2833-WORD-'+tag+'.json.gz')) + rec=dict(groups=GROUPS,source_word_sha256=sha(src),source_canonical_sha256=sem(old),candidate_word_sha256=sha(target),candidate_canonical_sha256=sem(new),generator_sha256=GENERATOR_SHA,ledger=ledger) + write(out/('new/borrow/inputs/shared_kernel_43'+tag+'.json'),rec);records[tag]=rec + shutil.copy2(a.generator,out/'new/borrow/shared_kernel.py');shutil.copy2(a.review,out/'new/borrow/shared_kernel_review.py');write(out/'new/BORROW-PROVIDERS.json',providers) + patches=[] + def patch(name,old,new): + p=out/name;before=sha(p);body=p.read_text();need(body.count(old)==1,'exact overlay preimage '+name);p.write_text(body.replace(old,new));patches.append(dict(path=name,before_sha256=before,after_sha256=sha(p),old=old,new=new)) + anchor=' final=json.loads(gzip.decompress(shipped.read_bytes()))' + block=''' # Four disjoint staged compensation kernels, after the complete pinned + # PR2833 derivation. Every previous state stays in the audit chain. + sf_=D/'inputs'/f'shared_kernel_43{wt}.json' + if sf_.exists(): + import shared_kernel + shared_patch=json.loads(sf_.read_text());previous_shared=chain[-1] + canonical=lambda z:hashlib.sha256(json.dumps(z,sort_keys=True,separators=(',',':')).encode()).hexdigest() + assert shared_patch['groups']==[478,460,462,480] + assert canonical(previous_shared)==shared_patch['source_canonical_sha256'] + shared_word,shared_ledger=shared_kernel.apply(previous_shared,shared_patch['groups']) + assert canonical(shared_word)==shared_patch['candidate_canonical_sha256'] + assert json.loads(json.dumps(shared_ledger))==shared_patch['ledger'] + assert set(k_ for k_ in previous_shared if previous_shared[k_]!=shared_word[k_])=={'A','compensation','start_extra','report','cleanup'} + stripped_shared=json.loads(json.dumps(shared_word));stripped_shared['A']=stripped_shared['A'][stripped_shared['prelude_events']:] + assert shared_word['cleanup']==word_patch.derive_cleanup(stripped_shared,word_patch.restored_of(shared_word)) + chain.append(shared_word);steps.append('shared-four-kernel') +'''+anchor + patch('new/rebuild_borrow.py',anchor,block) + anchor2="run('rebuild-borrow-words',P/'new/rebuild_borrow.py')" + block2=anchor2+"\nrun('shared-kernel-independent-review',P/'new/borrow/shared_kernel_review.py','--source-dir',P/'new/borrow','--source-base',P/'new/borrow/inputs/PR2833-WORD-base.json.gz','--source-extra',P/'new/borrow/inputs/PR2833-WORD-extra.json.gz','--candidate-base',P/'new/borrow/words/BORROW-WORD-43base.json.gz','--candidate-extra',P/'new/borrow/words/BORROW-WORD-43extra.json.gz','--out-dir',work/'shared-kernel-independent-review')" + patch('verify.py',anchor2,block2) + before=read(source/'MANIFEST.json');after=tree(out);write(out/'MANIFEST.json',after) + change={p:dict(before_sha256=before.get(p),after_sha256=after.get(p)) for p in sorted(set(before)|set(after)) if before.get(p)!=after.get(p)} + expected={'new/borrow/words/BORROW-WORD-43base.json.gz','new/borrow/words/BORROW-WORD-43extra.json.gz','new/borrow/inputs/PR2833-WORD-base.json.gz','new/borrow/inputs/PR2833-WORD-extra.json.gz','new/borrow/inputs/shared_kernel_43base.json','new/borrow/inputs/shared_kernel_43extra.json','new/borrow/shared_kernel.py','new/borrow/shared_kernel_review.py','new/BORROW-PROVIDERS.json','new/rebuild_borrow.py','verify.py'} + need(set(change)==expected,'exact overlay change allowlist');need(tree(source)==before,'original source remained byte-exact') + receipt=dict(status='PASS_SOURCE_BOUND_FOUR_KERNEL_OVERLAY_DERIVATION',upstream_manifest_sha256=UPSTREAM_MANIFEST,derived_manifest_sha256=sha(out/'MANIFEST.json'),source_file_count=len(after),builder_sha256=sha(Path(__file__)),changes=change,patches=patches,words=records,scope='Exact source overlay construction only. Full native and owner/controller/outer admission remain separate; all inherited validators are retained and an independent kernel review is added.') + write(out.parent/(out.name+'-DERIVATION.json'),receipt);print(json.dumps({k:receipt[k] for k in ['status','derived_manifest_sha256','source_file_count']},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/prepare_shared_native.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/prepare_shared_native.py new file mode 100644 index 0000000000..b3af64dd80 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/prepare_shared_native.py @@ -0,0 +1,76 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Two fresh changed-word native chains; explicit authenticated parent reuse. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Derived from the PR2839/PR2848 native preparation lineage, retaining validators. +""" +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +from importlib import metadata +import argparse,hashlib,json,gzip,os,platform,shutil,subprocess,sys,time +sys.dont_write_bytecode=True +SOURCE_SHA='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +SOURCE_FILES=547 +SOURCE_COMMIT='shared-four-kernel-pr2833' +PARENT_SHA='e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +OLD_RECEIPT_SHA='a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p,exclude=()): + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no cache/source symlinks') + if f.is_file()and f.relative_to(p).as_posix()not in exclude:out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser() + for n in ['source','retained-cache','retained-receipt','out']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--jobs',type=int,default=2);a=ap.parse_args();source=a.source.resolve();out=a.out.resolve();oldcache=a.retained_cache.resolve() + need(not sys.flags.optimize and 1<=a.jobs<=2,'assertions enabled and max2 jobs') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==SOURCE_FILES and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'complete immutable derived source') + need(not list(source.rglob('__pycache__'))and not list(source.rglob('*.pyc')),'source free of bytecode and cache folders') + before=tree(source);oldreceipt=read(a.retained_receipt) + need(sha(a.retained_receipt)==OLD_RECEIPT_SHA and tree(oldcache)==oldreceipt['cache_files'],'complete PR2848 retained native/cache evidence') + old=source/'vendor/pr1297';need(sha(old/'MANIFEST.json')==PARENT_SHA and tree(old,('MANIFEST.json',))==read(old/'MANIFEST.json'),'unchanged retained source') + prdir=oldcache/'_receipts'/PARENT_SHA;need(sha(prdir/'RECEIPT.json')==oldreceipt['retained_parent_receipt_sha256'],'retained parent receipt identity');pr=read(prdir/'RECEIPT.json') + need(pr['vendor_manifest_sha256']==PARENT_SHA and pr['claim_sha256']==sha(old/'CLAIM.json'),'retained parent source claim') + for name,h in pr['files'].items():need(sha(prdir/name)==h,'retained parent result binding') + need(read(prdir/'RESULT.json')['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and read(prdir/'RESULT.json')['kappa']==read(old/'CLAIM.json')['kappa'],'retained full parent admission') + pstages=read(prdir/'STAGES.json');need(len(pstages)==16 and all(s['exit_code']==0 for s in pstages),'all16 retained parent stages') + need(not out.exists()and not out.is_relative_to(source)and not out.is_relative_to(oldcache),'fresh external native work');out.mkdir(parents=True);cache=out/'native-cache';cache.mkdir() + steps=['native','ledgers','local-replay','wrappers','phases'] + for tag,name in [('base','gauge44-word.json.gz'),('extra','extra-word.json.gz')]: + word=old/name;key=sha(word);need(pr['words'][tag]==key,'retained word hash');entry=oldcache/key + need(read(entry/'local/FULL-WORD.json.gz')==read(word),'retained complete literal word');st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'retained native five stages') + cj=read(entry/'CACHE.json');need(cj['word_sha256']==key and cj['files']==tree(entry,('CACHE.json',)),'retained full native files') + shutil.copytree(entry,cache/key) + shutil.copytree(prdir,cache/'_receipts'/PARENT_SHA) + versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try:versions[name]=metadata.version(name) + except metadata.PackageNotFoundError:versions[name]=None + write(out/'ENVIRONMENT.json',dict(python=platform.python_version(),executable=sys.executable,dependency_versions=versions,assertions_enabled=True)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for k in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(k,None) + driver=source/'new/fastnative/run_native.py';start=time.monotonic();stages=[];words={t:source/('new/borrow/words/BORROW-WORD-43'+t+'.json.gz')for t in ['base','extra']} + def fresh(tag): + word=words[tag];work=out/('fresh-'+tag);cmd=[sys.executable,'-B',str(driver),str(word),str(work)];log=out/('native-'+tag+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=out,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + need(r.returncode==0,'fresh native '+tag+' failed; '+str(log));res=read(work/'RESULT.json');need(res['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY'and res['word_sha256']==sha(word),'fresh native result') + entry=cache/sha(word);shutil.copytree(work/'native',entry);need(read(entry/'local/FULL-WORD.json.gz')==read(word),'fresh complete literal word') + st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'fresh native five stages') + checks=read(entry/'local/LOCAL-CHECKS.json');can=read(entry/'local/CANONICAL-WORD.json.gz') + need(can['R']==408 and len(can['centers'])==8 and len(can['zero_buffers'])==72,'complete physical ABI') + for orientation in ['forward','backward']:need(checks[orientation]['all_columns']==632 and checks[orientation]['paid_profile']==read(word)['report']['local_profile'],'actual all-column native profile') + write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry))) + rec=dict(name='fresh-current-'+tag,exit_code=0,command=cmd,script_sha256=sha(driver),log_sha256=sha(log),result_sha256=sha(work/'RESULT.json'),seconds=time.monotonic()-begin);print('PASS',rec['name'],flush=True);return rec + with ThreadPoolExecutor(max_workers=a.jobs)as pool:stages=list(pool.map(fresh,['base','extra'])) + need(tree(source)==before and tree(oldcache)==oldreceipt['cache_files']and sha(a.retained_receipt)==OLD_RECEIPT_SHA,'read-only input drift') + rec=dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',source_commit=SOURCE_COMMIT,manifest_sha256=SOURCE_SHA,providers={t:dict(word_sha256=sha(w),complete_native_files=tree(cache/sha(w),('CACHE.json',)))for t,w in words.items()},retained_parent_receipt_sha256=sha(cache/'_receipts'/PARENT_SHA/'RECEIPT.json'),cache_files=tree(cache),fresh_current_provider_count=2,fresh_retained_native_count=0,reused_retained_native_count=2,fresh_retained_parent=False,reused_retained_parent=True,retained_reuse_receipt_sha256=OLD_RECEIPT_SHA) + write(out/'NATIVE-RECEIPT.json',rec);write(out/'STAGES.json',stages);write(out/'RESULT.json',dict(status='PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',source_manifest_sha256=SOURCE_SHA,native_receipt_sha256=sha(out/'NATIVE-RECEIPT.json'),preparer_sha256=sha(Path(__file__)),environment_sha256=sha(out/'ENVIRONMENT.json'),stages=stages,seconds=time.monotonic()-start,scope='Fresh changed base/extra native chains; two unchanged retained native chains and16-stage parent admission explicitly reused by exact full-tree receipts. No owner/controller/outer admission yet.')) + print('PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/reproduce.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/reproduce.py new file mode 100644 index 0000000000..dcc664bb96 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/derivation/reproduce.py @@ -0,0 +1,89 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Portable source derivation, two fresh native chains and full outer release. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Unchanged retained native/parent evidence is explicitly reused by full-tree hashes. +""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +from fractions import Fraction as Q +import argparse,hashlib,json,os,subprocess,time +HERE=Path(__file__).resolve().parent +SCRIPT_PINS={ + 'build_overlay.py':'4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666', + 'prepare_shared_native.py':'9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07', + 'admit_shared_replica.py':'c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f', +} +HELPER_PINS={ + 'lift_parent.py':'9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e', + 'replica_parent.py':'48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4', + 'reconstruct_replica.py':'5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15', + 'blocknorm_certificate.py':'e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92', +} +WORD_PINS={'base':'001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458','extra':'bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546'} +CANDIDATE_PINS={'fill': '82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501', 'order': '84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc', 'dispatch': '5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4'} +EXPECTED_KAPPA='17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000' +GENERATOR_SHA='b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed' +REVIEW_SHA='5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1' +COMPARISON_SHA='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9' +SOURCE_SHA='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +OVERLAY_SHA='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_text()) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p): + need(not list(p.rglob('__pycache__')) and not list(p.rglob('*.pyc')),'no bytecode or cache dirs in immutable source') + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no source symlinks') + if f.is_file()and f!=p/'MANIFEST.json':out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + for n in ['source','words','fill','order','dispatch','retained-cache','retained-receipt','comparison-claim','comparison-latest-claim','work']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--generator',type=Path,default=HERE/'shared_kernel.py');ap.add_argument('--review',type=Path,default=HERE/'review_four_groups.py');ap.add_argument('--helper-dir',type=Path,default=HERE/'vendor/pr2839');ap.add_argument('--jobs',type=int,choices=range(1,5),default=4);a=ap.parse_args() + for name,value in vars(a).items(): + if isinstance(value,Path):setattr(a,name,value.resolve()) + need(not sys.flags.optimize,'assertions enabled');source=a.source.resolve();work=a.work.resolve() + need(not work.exists()and not work.is_relative_to(source)and not source.is_relative_to(work),'fresh work external to source') + need(not work.is_relative_to(HERE)and not HERE.is_relative_to(work),'fresh work external to replay package') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and tree(source)==read(source/'MANIFEST.json'),'complete original PR2833 source') + files={} + def bind(p,expected): + p=p.resolve();need(sha(p)==expected,'pinned input '+str(p));files[str(p)]=expected + for n,h in SCRIPT_PINS.items():bind(HERE/n,h) + for n,h in HELPER_PINS.items():bind(a.helper_dir/n,h) + for tag,h in WORD_PINS.items():bind(a.words/('WORD-'+tag+'.json.gz'),h) + for n,h in CANDIDATE_PINS.items():bind(getattr(a,n),h) + bind(a.generator,GENERATOR_SHA);bind(a.review,REVIEW_SHA);bind(a.comparison_claim,COMPARISON_SHA) + bind(a.retained_receipt,'a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc') + bind(a.comparison_latest_claim,'eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa') + latest=read(a.comparison_latest_claim);need(Q(latest['kappa'])==Q(latest['kappa_rational'])and Q(EXPECTED_KAPPA)>Q(latest['kappa_rational']),'exact improved target beats concurrent PR2853 full outer headline') + source_before=tree(source);work.mkdir(parents=True);overlay=work/'source';native=work/'native';candidate=work/'candidate' + commands=[('derive-source',[sys.executable,'-B',str(HERE/'build_overlay.py'),'--source',str(source),'--generator',str(a.generator),'--review',str(a.review),'--candidate-dir',str(a.words),'--out',str(overlay)]), + ('fresh-current-native',[sys.executable,'-B',str(HERE/'prepare_shared_native.py'),'--source',str(overlay),'--retained-cache',str(a.retained_cache),'--retained-receipt',str(a.retained_receipt),'--out',str(native),'--jobs',str(min(a.jobs,2))]), + ('complete-admission',[sys.executable,'-B',str(HERE/'admit_shared_replica.py'),'--source',str(overlay),'--fill',str(a.fill),'--order',str(a.order),'--dispatch',str(a.dispatch),'--native-cache',str(native/'native-cache'),'--native-receipt',str(native/'NATIVE-RECEIPT.json'),'--work',str(candidate),'--replica-helper-dir',str(a.helper_dir),'--reconstructor',str(a.helper_dir/'reconstruct_replica.py'),'--blocknorm-checker',str(a.helper_dir/'blocknorm_certificate.py'),'--comparison-claim',str(a.comparison_claim),'--source-profile','shared-four','--comparison-profile','pr2848','--jobs',str(a.jobs)])] + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for n in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(n,None) + stages=[];start=time.monotonic() + for name,cmd in commands: + log=work/(name+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=work,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + stages.append(dict(stage=name,command=cmd,exit_code=r.returncode,log_sha256=sha(log),seconds=time.monotonic()-begin));write(work/'STAGES.json',stages) + need(r.returncode==0,'failed '+name+'; '+str(log));print('PASS',name,flush=True) + need(all(sha(Path(p))==h for p,h in files.items()),'bound replay input drift') + result=read(candidate/'RESULT.json');release=read(candidate/'release/RELEASE-RECEIPT.json');nrec=read(native/'NATIVE-RECEIPT.json') + need(result['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE'and release['status']=='PASS_RELEASE','complete release statuses') + need(Q(result['kappa'])==Q(release['kappa_decimal'])==Q(EXPECTED_KAPPA),'exact expected headline') + need(result['release_receipt_sha256']==sha(candidate/'release/RELEASE-RECEIPT.json')and result['package_manifest_sha256']==release['manifest_sha256']==sha(candidate/'package/MANIFEST.json'),'strict release chain') + need(sha(overlay/'MANIFEST.json')==OVERLAY_SHA and tree(overlay)==read(overlay/'MANIFEST.json'),'unchanged exact derived source') + need(tree(source)==source_before and sha(source/'MANIFEST.json')==SOURCE_SHA,'unchanged original source') + need(nrec['fresh_current_provider_count']==2 and nrec['reused_retained_native_count']==2 and nrec['reused_retained_parent']is True,'accurate fresh/reused native provenance') + final=dict(status='PASS_SHARED_KERNEL_PORTABLE_COMPLETE_REPLAY',kappa=result['kappa'],kappa_decimal=result['kappa_decimal'],gain=result['gain'],source_manifest_sha256=SOURCE_SHA,derived_source_manifest_sha256=OVERLAY_SHA,source_derivation_sha256=sha(work/'source-DERIVATION.json'),native_receipt_sha256=sha(native/'NATIVE-RECEIPT.json'),candidate_result_sha256=sha(candidate/'RESULT.json'),release_receipt_sha256=sha(candidate/'release/RELEASE-RECEIPT.json'),generated_package_manifest_sha256=result['package_manifest_sha256'],fresh_current_native_chains=2,reused_retained_native_chains=2,reused_retained_parent=True,wrapper_sha256=sha(Path(__file__)),input_sha256=files,stages=stages,seconds=time.monotonic()-start,scope='Conditional finite supplier and modern outer release; unchanged inherited all-size/compiler/hosting/precision/tape/analytic obligations remain. Two changed providers run fresh; retained provider/parent proof explicitly reused by full-tree hashes.') + need(Q(result['kappa'])>Q(latest['kappa_rational']),'actual full release beats exact concurrent headline') + final['secondary_comparison']=dict(pr=2853,head='d01045dfb67428679618027dff552f1d032fa999',claim_sha256=sha(a.comparison_latest_claim),field='kappa_rational',gain=str(Q(result['kappa'])-Q(latest['kappa_rational'])),approx_gain=float(Q(result['kappa'])-Q(latest['kappa_rational']))) + write(work/'RESULT.json',final);print(final['status'],final['kappa_decimal'],flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/admit.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/admit.py new file mode 100644 index 0000000000..8c71cc69ce --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/admit.py @@ -0,0 +1,411 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a changed-replica literal order/fill derivative. + +PR2833 extension by Yiyang Lu with OpenAI Codex assistance: add the exact +immutable dirt-entry source profile and exact full outer-claim comparisons to +PR2833 and the newer PR2843 T124 allocation. All +inherited native, owner, invoice, block-norm, controls and release checks retained. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-refit393' +SOURCE_MANIFEST = '1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +COMPARISON_SHA = '252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3' +COMPARISON_HEAD = 'e8b771ba132fe632796b28c1742a8d096c04519f' +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +# Supported immutable source versions; CLI selection never accepts arbitrary hashes. +SOURCE_PROFILES = { + 'shared-four': dict(commit='shared-four-kernel-pr2833', manifest='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869', helpers=408, source_file_count=547, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2766': dict(commit='local-joint12-refit393', manifest='1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb', helpers=415, source_file_count=491, upstream_head='e6df920cd0110e4b629e2ad84eddcb539001e174'), + 'pr2802': dict(commit='local-joint12-pr2733', manifest='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451', helpers=408, source_file_count=506, upstream_head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd'), +} +COMPARISONS = { + 'pr2848': dict(pr=2848, head='c50d12e4720cd1fef2b5a65e337e37de9731879a', sha256='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9', field='kappa'), + 'pr2843': dict(pr=2843, head='47a7227c044cd0cabb1432a06c61dd5d60c07f5a', sha256='0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9', field='kappa'), + 'pr2833': dict(pr=2833, head='e9307b48d7d1b690939935ecef0f8e524e6d92f4', sha256='6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70', field='kappa_rational'), + 'pr2767': dict(pr=2767, head='e8b771ba132fe632796b28c1742a8d096c04519f', sha256='252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3', field='kappa_rational'), + 'pr2802': dict(pr=2802, head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd', sha256='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51', field='kappa'), +} + + + +# Discovery records are shared by parallel mutation-audit processes on Windows. +# Only discovery bookkeeping changes; strict pin comparison below it is untouched. +DISCOVERY_APPEND_OLD = " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))" +DISCOVERY_APPEND_NEW = r''' import time as _wr_time + _wr_path=Path(os.environ['WITNESS_RECORD']) + _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock') + _wr_deadline=_wr_time.monotonic()+60 + _wr_fd=None + while _wr_fd is None: + try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + except FileExistsError: + if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved') + _wr_time.sleep(.005) + try: + with _wr_path.open('a',encoding='utf-8',newline='\n')as _wr_out: + _wr_out.write(json.dumps([key,got],default=str)+chr(10)) + _wr_out.flush() + finally: + os.close(_wr_fd) + _wr_lock.unlink()''' + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + # All output targets belong to this fresh work tree; never unlink an open lock. + lock = path.with_name(path.name + '.lock') + descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + try: + os.write(descriptor, str(os.getpid()).encode()) + os.close(descriptor) + descriptor = None + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + finally: + if descriptor is not None: + os.close(descriptor) + lock.unlink() + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'dispatch', 'native-cache', 'native-receipt', 'work', 'replica-helper-dir', 'reconstructor', 'comparison-claim', 'blocknorm-checker'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + ap.add_argument('--source-profile', choices=sorted(SOURCE_PROFILES), default='shared-four') + ap.add_argument('--comparison-profile', choices=sorted(COMPARISONS), default='pr2848') + a = ap.parse_args() + global SOURCE_COMMIT, SOURCE_MANIFEST, COMPARISON_SHA, COMPARISON_HEAD + source_profile = SOURCE_PROFILES[a.source_profile] + comparison = COMPARISONS[a.comparison_profile] + SOURCE_COMMIT, SOURCE_MANIFEST = source_profile['commit'], source_profile['manifest'] + COMPARISON_SHA, COMPARISON_HEAD = comparison['sha256'], comparison['head'] + expected_helpers, comparison_pr = source_profile['helpers'], comparison['pr'] + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == source_profile['source_file_count'] and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + helper_dir = a.replica_helper_dir.resolve() + helper_paths = [helper_dir / n for n in ('lift_parent.py', 'replica_parent.py')] + [a.reconstructor.resolve()] + external_hashes = {str(p): sha(p) for p in helper_paths + [a.fill.resolve(), a.order.resolve(), a.dispatch.resolve(), a.comparison_claim.resolve(), a.blocknorm_checker.resolve()]} + need(sha(a.comparison_claim) == COMPARISON_SHA, 'exact pinned frontier headline comparison') + comparison_claim = read(a.comparison_claim) + need('headline_kappa_source' not in comparison_claim and comparison['field'] in comparison_claim, + 'comparison must be full headline outer claim, not supplier-only CLAIM') + previous = Q(comparison_claim[comparison['field']]) + need(previous == Q(comparison_claim['kappa']), 'comparison rational/decimal equality') + order_input = read(a.order) + need(order_input and all(isinstance(x,list) and len(x)==2 and all(type(v)is int for v in x) for x in order_input), 'literal integer call order') + T = 1 + max(r for st,r in order_input) + need(T > 0 and len(order_input)==9*T and set(map(tuple,order_input))=={(st,r) for st in range(9) for r in range(T)}, 'complete new replica coverage') + need(all([st for st,r in order_input if r==rep]==list(range(9)) for rep in range(T)), 'source stage projection') + dispatch_input = read(a.dispatch) + need(len(dispatch_input)==9*T and {(st,r) for st,r,pid in dispatch_input}==set(map(tuple,order_input)), 'complete explicit dispatch') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + # Only the fresh external clone changes. Immutable source/cache inventories remain pinned. + for hp in helper_paths[:2]: + shutil.copy2(hp, package / hp.name) + need(sha(package / hp.name)==external_hashes[str(hp)], 'helper copy hash') + shutil.copy2(a.blocknorm_checker, package / 'blocknorm_certificate.py') + shutil.copy2(a.blocknorm_checker, package / 'code/blocknorm_certificate.py') + need(sha(package / 'blocknorm_certificate.py') == external_hashes[str(a.blocknorm_checker.resolve())], 'block-norm checker exact source binding') + shutil.copy2(a.reconstructor, package / 'reconstruct.py') + need(sha(package / 'reconstruct.py')==external_hashes[str(a.reconstructor.resolve())], 'reconstructor copy hash') + # The original subprocesses also write generated hash-bound source. Windows + # callers use a process-scoped LF adapter; no system configuration is changed. + lf_probe = work / '.lf-preflight.txt' + lf_probe.write_text('LF\n', encoding='utf-8') + need(lf_probe.read_bytes()==b'LF\n', 'process-scoped LF output required on Windows') + lf_probe.unlink() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # At T37 the historical fixed333 mutant is a no-op. Preserve the + # undercharge test by subtracting one from both actual charges, and + # require every geometry mutant to differ before the unchanged assembly. + patch('geometry_controls.py', [ + (" i['complete_invocation_sweeps']=i['bridge_sweeps']=333", + " i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1"), + (" o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh", + " o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + # Keep the native dimension and paid moment ledger fixed; bind replica + # width to both the checked source geometry and the independent B invoice. + patch('outer/check_ledger.py', [ + ('assert (m,W)==(73,66304)', + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']")]) + patch('code/witness.py', [(DISCOVERY_APPEND_OLD, DISCOVERY_APPEND_NEW)]) + patch('verify.py', [ + ("run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')")]) + # A sharper local reserve is certified against actual scalar/Horner + # prefixes of BOTH orientations and BOTH providers. All sweep and physical + # row charges remain unchanged; this never omits an invocation or bridge. + patch('code/witness.py', [ + ("PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4")]) + patch('independent_core.py', [ + (" payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm,"), + (" primitive_arithmetic_margin_bits=4,controller_audit_sha256=", " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256="), + ("Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix.")]) + patch('independent_core.py', [ + (" prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4"), + ("prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn")]) + patch('audit_mixed.py', [ + ("pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)")]) + patch('code/assemble.py', [ + (" assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 previous, + 'candidate must strictly improve full exact pinned frontier headline before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=COMPARISON_HEAD, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + (package / 'provenance').mkdir(exist_ok=True) + shutil.copy2(a.comparison_claim, package / ('provenance/PR' + str(comparison_pr) + '-HEADLINE-CLAIM.json')) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + need(all(sha(Path(p))==h for p,h in external_hashes.items()), 'external candidate/helper inputs changed during admission') + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/runtime/geometry_controls.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/runtime/geometry_controls.py new file mode 100644 index 0000000000..295e9081ed --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/runtime/geometry_controls.py @@ -0,0 +1,31 @@ +"""Reject understated T74 prefix, stock and invocation charges using strict assembly.""" +import argparse,copy,hashlib,json,os,sys +from pathlib import Path +assert __debug__ +P=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--strict',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() +sys.path.insert(0,str(P/'code'));os.environ['GAIN_PR564_SOURCE']=str(a.source.resolve());os.environ['WITNESS_SPEC']=str(a.strict/'runtime/data/SPEC.json') +from assemble import assemble +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +digest=lambda v:hashlib.sha256(json.dumps(v,sort_keys=True,separators=(',',':')).encode()).hexdigest() +op=a.strict/'global/audit/OWNERS-AND-PROFILE.json';ip=a.strict/'global/audit/PREFIX-AND-INVOICE.json';owner=json.loads(op.read_text());invoice=json.loads(ip.read_text());assemble(owner,invoice,sha(op),sha(ip)) +def old_prefix(o,i): + i['charged_prefix_bits']=1024;i['row_prefix_extra']=2048;i['finite']['physical_row_coefficient']-=2048 + +def old_call_count(o,i): + i['complete_invocation_sweeps']-=1;i['bridge_sweeps']-=1 + +def old_parent_idle(o,i):o['source_idle_children_charged']//=2 + +def old_stock(o,i):i['physical_stock_identity']['data_and_owner_families']//=2 + +def missing_call(o,i):i['selected_calls'].pop() + +def low_row(o,i):i['finite']['physical_row_coefficient']-=1 +rejected=[] +for fn in [old_prefix,old_call_count,old_parent_idle,old_stock,missing_call,low_row]: + o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);assert (o,i)!=(owner,invoice), 'geometry mutant must change actual receipts';oh=digest(o);i['owner_audit_sha256']=oh + try:assemble(o,i,oh,digest(i)) + except AssertionError as e:rejected.append(dict(name=fn.__name__,reason=str(e) or 'strict arithmetic invariant')) + else:raise AssertionError('accepted '+fn.__name__) +a.out.write_text(json.dumps(dict(status='PASS_T74_GEOMETRY_AND_CHARGE_CONTROLS',rejected=rejected),indent=2)+'\n');print('PASS_GEOMETRY_CONTROLS',len(rejected)) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/MANIFEST.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/MANIFEST.json new file mode 100644 index 0000000000..a585410189 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/MANIFEST.json @@ -0,0 +1,549 @@ +{ + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "ADMISSION-DERIVATION.patch": "7021000d75635fc5806af821640c02f9d7cbbbe1cf314dacfcc743fc6875fdd8", + "CLAIM.json": "94fced945b1171e97c3ac7c71f819a5ba6c5230c10ef0b15556482990b46b368", + "CONSTRUCTION.json": "07c8c640de821978b6d2945100e2492ea7a6c006baa6b7b7585bbcb3b7f3eba9", + "DISPATCH.json": "2d178ebfbf3147d1f844897c779d151e04a0b9f480cbf57b76add4a24b8858ee", + "EXACT-ARITHMETIC-DERIVATION.json": "c0d40deaa495a7365e91aa5d9e6a846f91e0cb6daff98bb3b7f2acef84d64ec4", + "GLOBAL-TEMPLATE.json.gz": "1d31424c4e27e26a35a9932ca778e43f1f3577589275422cc642aa68b31112db", + "NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "ORDER.json": "30856f042860e5b5c613357b236ff643f107d7d70e2c64eb5fcaaa09bf81a90d", + "OWNERS.json.gz": "25e70226d625ec6222f9436332fb8f4a82664f71cb6e5af0e056d0d32ca76baa", + "PARENT-LIFT-RECEIPT.json": "787db0b6f847cb03ff9b71246aba6e702ad3ab8e2fbbcb7dff9f51b8a8a783e8", + "PLAN.json": "5345bbb91255a3229000ef154daab7d6dcb31c98aadeac9d5dac748a58cc5c44", + "PRICE.json": "c5ec535fd9edbdec7b64edd5a8b862edb1a7f173d411dacb279172659573e16a", + "PROFILE.json": "dafbfc76552e3b0c5d6f29bbf5bbafe5602149d3a3f8e35d5c316741e7eff64a", + "README.md": "b794473b965406360e7732f0e86b66fbcf8e91bc16632330ada8e1150f2ddb62", + "RELEASE.json": "034e061609a987eb6275787e74b3b775ef0782a277bb26e2ca664f61b2863e55", + "SOURCE-PIN-REFINEMENT.json": "8c0bad79978decd6f8aba0932c0a94c7f61c64bf9ce5a19a36f67cc1390bf74f", + "SOURCE-PIN.json": "66faac1fd4e79bb6d9fc774fd8ba63522ad3309456be1c81405794b284c55c83", + "SPEC.json": "81676590c26018aa95082e3252f394ac99c61c0c4e5578f59501401700e38033", + "audit_fast.py": "26950da76589b13cd9c452fdee1b0c354806977f881299bd94073f00e4646fcd", + "audit_mixed.py": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "code/assemble.py": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "code/assembly_controls.py": "d7675ff0b0994b29541d37eaa3010c5f39bb1447700c9f8e750522bf8c951f56", + "code/audit_allcold.py": "fa3488b62efdf8a0c37de0ca0caba587b4b036c5f068e002eb04c71c12b9e9b4", + "code/bind_providers_portable.py": "1d39bcc7b63ac158e021454beaae897d123e174360573762aecade3cd43193f6", + "code/bit_supplier_controls.py": "e6d33fb61a570c3f50669412acc467a3fd06ef0b806da6a75bc296c6ba2142a5", + "code/emit_allcold.py": "549603ca6d28b163a43b2dfaaaa788161c73d7952ab9190289407caca5418c71", + "code/exact_coarse.py": "5fd03ee160a8bb02a00927cb144359fbcf8b0ec323ae0662778dd1f655b4a216", + "code/fine_cache.py": "89282a83ab102893a4fc1e663ad2137d891d81e843b1c9ea140d13e58b7c7dbd", + "code/fine_mercator.py": "6cf29658b5c1618de4aae8bd49d6d890be06d57ead1ad0f2d41bc8d25cc578d3", + "code/fine_moment.py": "bdfc492be6a663b219d76beff444db14bd67bb53c7c8ec4086ab0f56e48323c0", + "code/freeze_spec.py": "e9132a9d195c66123f2747a17f7ef404b4d1e3ef6263ab4c28c983a052cf10bd", + "code/generated_identity.py": "c8af22719c0f3097a991a3f6ccac8f090afd2faba554745733d9ea88f2c25708", + "code/invoice_allcold.py": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "code/lemmag_checks.py": "cc753c5953e58f5900ce580ece8f814a352d672bcee6d4566c7dd52647912393", + "code/lemmag_stage.py": "5158e1e95e46b3119de9f4add7d849c8ad2d2dd92b17a79b0f93b86e7d4e6049", + "code/oracle_check.py": "4836046db4bec939515a5a272559f92192b56612b98f635910fd81ea754ce2e1", + "code/prepare_global.py": "8c0dae301a8f34b77a5a462f840952d08ed120576212adf5051bc09bcad874dc", + "code/pyc_guard.py": "1def35bd093a7b3893c1cf410301d875435a2a7a096b42f49ecb060ed2a61f0e", + "code/restore_parent.py": "69b7b25ff85e9b8160e233c1d415cc6a0272019e5c486dcec14cb6c349e7024d", + "code/witness.py": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "construction/leaver/PIVOT-SWAP-k8.json": "3ef7acf0cf67442a532f25b53d5fbeda76d3a84524118df8e003ca69b5cac0bb", + "evidence/ADMISSION-CONTROLS.json": "5cdefeff2516a67c4dd60e609019b3e2e38eb3d43142df2d3c7ed9a6822d5050", + "evidence/ASSEMBLY.json": "5d9eb1ce551386024b5b6894836f81ed03a83d2e0c0bd0e02e3f6410a596bb2c", + "evidence/BIT-CONTROLS.json": "d74d9d2ba363c3709e9a3b33abf6d14abd6b9c68d950b35b7669d8e6edefa59e", + "evidence/FULL-ADMISSION.json": "cda48de718d060b8ca329f1254f4f999a5a5bade5cecabb265f0a9bef1135089", + "evidence/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/INDEPENDENT.json": "7150546e840e859268c40c11c2c79ba4fd646fc632fced68e3c19355b292fa61", + "evidence/OUTER-DISCOVERY.json": "413ef3e9eb1c3ff680cff1e600dc7160afda228e0b6b021c1a4e4a37ee486cc1", + "evidence/REGRESSION37-CONTROLS.json": "0196ae228d583f2bac3c42d3576a8d378fe622592e377c4c1921b5ae81351854", + "evidence/pr1377/CLAIM.json": "cd089b08077e0151b9ed917a5c33aa7aa6b0de790bd9567442531b48729da8d3", + "evidence/pr1377/PROOF-NOTE.md": "dafd8286b1c9224ed6f50bf71bc34b77918323b936ea7427a4b71c3b644b2264", + "evidence/pr1377/RELEASE.json": "a4fa2ca0f79a11dcdc3227ad16a408d4d22d83b7401c894cb0e31eb2c9c5f7df", + "evidence/pr1377/RESULT.json": "1cdadc74fef4cddeb2bae5e32fff7bc27456740150440ae8fda8822f569c2492", + "freeze_spec.py": "1d965b7a329b98008fcc67e73d03dcf6e75f0f33c2858a39f1182bb3d0ed0ea1", + "geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "independent_core.py": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "inputs/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "inputs/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "inputs/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "lift_parent.py": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "new/BORROW-PROVIDERS.json": "5527d70aa83ad3b05a7176903016c12fc410bc9968082377eeed66c8d298dafa", + "new/CHAIN.json": "f18804a71bef7005e892b0b7baac818d5362fff685fe5b5aadfe8de6e442446d", + "new/EDITS-1.json": "dffa640c04d71111d3e4bdd7f5a991450ba07049a1d434edeef84791c0cc2d05", + "new/EDITS.json": "d5f9a0444dddcccd35c0217f60dbd6863486241629a747c3bbe4140b3d55eea1", + "new/PLAN.json": "fe48f2a29535cfae3b0889170b87ebc1384eeeef9ab635a901929f9a40a2c95b", + "new/PROFILE.json": "69a5c98958d196e61d158c856392c9587363ee47d2c8665081e4688795c1f2b0", + "new/SPEC.json": "85635e7f1ceff706fe43c9eda5bb8847e6273b4d7509b119114e39684b0ddbdf", + "new/borrow-fill/DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "new/borrow-fill/FILL.json.gz": "0cb7522e071ff064ada2efec169e23a2fe7d3daf928eec6ba752b166cffb3468", + "new/borrow-fill/ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "new/borrow-fill/search/agg.py": "267a66287336b72731b897508073dae1a7c85fa72cd86093a7340ddfc12af04c", + "new/borrow-fill/search/base74.py": "acc99c57730fe50f88538e4061e7165a7f278ed7499728c24b0522d479be8b8c", + "new/borrow-fill/search/ceil74.py": "99df541abe458fb6154755d9c67066b2ba0430b06f879a7b5a43e30618f4c1d7", + "new/borrow-fill/search/evac.py": "7c6ce4e8aa9833a9d451c5d4b891bbd1927315bcbf112d3c15845f0ede2d9dc3", + "new/borrow-fill/search/fillbase.py": "4fc6fa920d8703ccec860bee0e1187a0a8b1e37b245789256f7a4d01ae8a2b00", + "new/borrow-fill/search/inv.py": "eec279ea8e8d9d1dccc2733a88129351678c73fb51f06a4604a9c1da1d771387", + "new/borrow-fill/search/lattice.py": "8f2ee194fa4992d1f45394b09b5151ec699b28e4c950b9d40b826f33cbb635ba", + "new/borrow-fill/search/lnstime.py": "3a1ff558f10b0b935389137627359f875ca484717ffa3ced7de8d8b588836755", + "new/borrow/alias1_controls.py": "f4cc82312af891ea48956d9953a061196a8c3b113ef6d81e5848fe95745147b2", + "new/borrow/alias_build.py": "40b97536c8347733eaae24a3c4a13f5d21711e983106454777837be487959f1b", + "new/borrow/alias_enumerate.py": "7324f2569e6b76981d8c964a16ff9a3bc9e770e41b9cc6ec1c9defe8e662c153", + "new/borrow/audit_local.diff": "202f6f2032552eba069b9ec7e33b729d4af2ffc20974a9e82e444d906d7137b4", + "new/borrow/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "new/borrow/borrow_controls.py": "07fbbf8e2f06df063dc9d88e5e4f721222a9fcf30b983bf9127cd5aa4b611627", + "new/borrow/build_word.py": "40047409dd9f9c406bb37a2ed0b4c8159797e0e4a114d525a368355418128707", + "new/borrow/emit_word.py": "a057ed0c81fbb07dabf38247e0ce0cec6c5fbfa31d8bf1b38838bd3758e41f87", + "new/borrow/guard_cut_centres.py": "5df204597697756808e6c959f5bba81cf35a2f0e7a0f1f75748dca1814373b72", + "new/borrow/guard_helper_indices.py": "d93aeb2d51d77ca93ecbf9e566d9000bb436c279e2a25b699a867e9697f782fd", + "new/borrow/inputs/PR2833-WORD-base.json.gz": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "new/borrow/inputs/PR2833-WORD-extra.json.gz": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "new/borrow/inputs/alias1_43base.json": "2c5b5491da4b3e8a8356fd42a12a8fc8b2c9b4b0b20c4adc4e273ba217230e11", + "new/borrow/inputs/alias1_43extra.json": "0a54f41f886bf4f61fa620c65725373be905524ce906e5e95d501890de783179", + "new/borrow/inputs/alias8_43base.json": "3b91dd5a0d1b297a48e278b45903e073c5cefb23f22921f6a738bcbbf21e521f", + "new/borrow/inputs/alias8_43extra.json": "3ab265a33750a229a9201c2baff45ad91f1bef556879306d2fb743f5290cab31", + "new/borrow/inputs/blocks.json": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f", + "new/borrow/inputs/dirtentry_43base.json": "a067f7138f23eed6434286e7bd53548c86a7eef58c654374b778b4f424e9ffef", + "new/borrow/inputs/dirtentry_43extra.json": "8280fafb4642389ae91989e870ece7c9f2bffa38c9b52f2424b8abf489ba71f8", + "new/borrow/inputs/entrance_43base.json": "1b3c09f9558c50e7f299aa10fb21dcbd1b5ff397794838d8629c80d4c7a565f5", + "new/borrow/inputs/entrance_43extra.json": "e57ec67fa0a3fca63bf9e4bb9edf4e6be48db0bd7c9e092cddad29b26b897463", + "new/borrow/inputs/extra.canonical.json.gz": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015", + "new/borrow/inputs/gauge44.canonical.json.gz": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91", + "new/borrow/inputs/handoff_43base.json": "5ae3062bcce666c8c3a3a650e345adf15c22a2800fa0e17d79ad6e8b97208a2f", + "new/borrow/inputs/handoff_43extra.json": "4238a7c5093a4347fe69adf4f76e507d2f43c4e727d91b2c4705039e1cbaa06a", + "new/borrow/inputs/kernel_43base.json": "7f06b4b08a49192a27e8f4132ad0c93521dad90f97ca985a173944ba02c5442b", + "new/borrow/inputs/kernel_43extra.json": "ef95eae03915f0222bcd486959c6dfe307a9a0a856702420fa35491abfae4c84", + "new/borrow/inputs/lowfour_43base.json": "a8df0a2acf85e96febb35d24ae047c370d179095b46142bae968f06348bf1c18", + "new/borrow/inputs/lowfour_43extra.json": "9dbfb49fb3c04a0652dcae9a962d973489679f5d1ee2baf4e65c58d2e8ef578c", + "new/borrow/inputs/prelife_43base.json": "ec43328c198094c0e8b37cf93de0210d2ba0397ed20dcaec1f1d121ffa5cdb69", + "new/borrow/inputs/prelife_43extra.json": "a7fc8362edaf33de314bebc400bcda6a6cc345ac6ca86220e1f53ae43cbc8600", + "new/borrow/inputs/refit563_43base.json": "4ba6d0fe6f5f03095821f1080f1cceb97204a3189ab0e48092e1cbccb1d7ceae", + "new/borrow/inputs/refit563_43extra.json": "4ba6d0fe6f5f03095821f1080f1cceb97204a3189ab0e48092e1cbccb1d7ceae", + "new/borrow/inputs/refit_43base.json": "19a97e80b0ee3146e0244e6bc36bd365d89e9c1cd0f885c4e06be4193606a323", + "new/borrow/inputs/refit_43extra.json": "1349d54f704847fdcd4a00e323cdc9e1118fac7fedb0c7573e9b2b3f0169a7eb", + "new/borrow/inputs/retired7_43base.json": "74daf5826d9191be4613a61447f4dc12789190fb49a3219f6a9df63075cac1e1", + "new/borrow/inputs/retired7_43extra.json": "25d9774b512da78f042287ce1de91c79c8658d06488b8fe94e548cbdd036f034", + "new/borrow/inputs/shared_kernel_43base.json": "d06f52975d4d48523177fd3010f9b6d36094636b3d31b90c492404a9c21ef6e3", + "new/borrow/inputs/shared_kernel_43extra.json": "79a3d0309ee1154f778f05592ac09f51db64286828456f8c1fca22c1c8b05af2", + "new/borrow/inputs/twelve_43base.json": "ee268c45a9c768a6a4cecf401cd4446cebb042e67d69e5fb6d078934d5a49498", + "new/borrow/inputs/twelve_43extra.json": "4ff1d00714d0dfacf95b89778f6c1abb113877f8c9880c01a06d0f30998756ee", + "new/borrow/inputs/witness_43_base.json": "65ee52604e2e49a30c1e978b7ce829482a694a20a8744f37b9bf40dad1ff3a2e", + "new/borrow/inputs/witness_43_extra.json": "19c652db80d5215c958c63b5d6f2de96d9cf34a0e4d56dab5c13e556c57f7467", + "new/borrow/lowfour_controls.py": "b1484a0ab1ad5f87a71b8e48ee8c5ba7604835acfe2b841b6f13cbd12f32e344", + "new/borrow/prelife/results/gap-base.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/gap-extra.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/prelo-base.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/prelo-extra.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/tryE-base.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/results/tryE-extra.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/search/chains.py": "588d6cdb2312febfee5f3d576295f2edff53ca74c14d21ed9bffed3312dfa32c", + "new/borrow/prelife/search/edit.py": "8e5eea35d0bb83aa60bd066ae9ddf3f4b0ad46cf9ac9d31d8fc5777f49013713", + "new/borrow/prelife/search/fm.py": "36174e2b7e012726964282af926fdf541332556bcc548af5b41502cdb8b198e2", + "new/borrow/prelife/search/gapbound.py": "a0fa0fbd079a456bf5f9b75352eb68c4b7e2febad0c99e66b7553bdc744772c8", + "new/borrow/prelife/search/mk1.py": "4bab66a4e1514a067572c7854731a4fbd29681300e95a4384fdb68e0eb140575", + "new/borrow/prelife/search/prelife2.py": "db1fc5eea7bd70066188d7c7f52cf4be8991e61b821d3fe4b779ee30c7f3c9eb", + "new/borrow/prelife/search/prelo.py": "157dc45b5fcc421d26507d6d7fca6d4caeff6c73efcd679fd28e906f600ea886", + "new/borrow/prelife/search/propbound.py": "735cd4d1a6a43c96f397eb5ae2972e86ab71c2c232e6d14ac6cbf1eb7f638c1c", + "new/borrow/prelife/search/repair2.py": "410ddd6f9b3e14be6b9247cc5792d1a893175e843a0c21bf667e71a6e3a9710f", + "new/borrow/prelife/search/tryE.py": "130a859c0ad20623943b25800dd2f1d0355cf03b8520fc493ec870baa010b2ae", + "new/borrow/prelife/search/wordmodel.py": "215e678d3f3711b4291f9da5d7937cdbb0b091390bba089e6949b8c42a29f6f4", + "new/borrow/prelife_controls.py": "c24398bdc407aaf6713201100d27ba851233525a9dfd747b641d99e1cde66cba", + "new/borrow/receipts/AUDIT-43base-pinned.json": "8dc6daa8929c1137c1e37fa5a1bf869afafe94c3e65ed2705ea9f41f2dc8cee8", + "new/borrow/receipts/AUDIT-43base-prekernel.json": "fb6f40a1d117bd304cc0757ac21915bd8558e8d3f31b8709129f395033fc534e", + "new/borrow/receipts/AUDIT-43base.json": "07b8a4836fe2659d0d46957ed0973ba3334f6752b5c1235d03b961a107fb95d5", + "new/borrow/receipts/AUDIT-43extra-pinned.json": "4176a6190fb1a224d45797064cde2aa758970bce7c1ed2a009ecb2fc7839d26e", + "new/borrow/receipts/AUDIT-43extra-prekernel.json": "09041e49888a1360b7ddee29d54d82836a875ecb6547c7ad1eb92427e7f3b384", + "new/borrow/receipts/AUDIT-43extra.json": "a01ae6847449ddb88c56fa8e44d10bc0b005f1b24daa283d38ba00089d8f89f2", + "new/borrow/receipts/CONTROLS-43base.json": "02b73bfbf72c63926ebb244bbd6bf87a03201ee1487e2c15292ad52684fb4d69", + "new/borrow/receipts/CONTROLS-43extra.json": "f8b93901ef5b4810bb39a7b5ccdc62497612c2efba67920a8d6119ae8a898126", + "new/borrow/receipts/CONTROLS-KERNEL-43base.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-KERNEL-43extra.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-LOWFOUR-43base.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/receipts/CONTROLS-LOWFOUR-43extra.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/refit/results/pairs-base.json": "8178d2a34be82601f2361afbc63b37294255a435b243e65295bf7b641edfc4a3", + "new/borrow/refit/results/pairs-extra.json": "3a64b6ace504a5d410a4cfd87ae2fc04576df61883ce56e3f7eb38d4b26df8af", + "new/borrow/refit/search/bounds.py": "690986e69e3125723b12255cc5aa135fceec93894d589eb196ab7fa5da37e9fb", + "new/borrow/refit/search/eval1.py": "0547e606468ad4670512ea83fb3d6e7f39fda9b66537fdf791ad22a3bf4aeeee", + "new/borrow/refit/search/mkcand.py": "c5b437f6a991de674bd781d610d98a43d9f84179beb1187340354e55f42ceaa4", + "new/borrow/refit/search/pairs.py": "7922404bf942eff2dda0125b78ff1234bfdfda5101ff428b11f8a5ed73ce4882", + "new/borrow/refit/search/refit.py": "c036d0d4cc91360e583a7ed01d6c69c17a69f16c5838062c2b9de83a616d2e23", + "new/borrow/refit/search/why.py": "209a95a62a95c06138f0b5af2d1dd1f9c60c403c4da294d39663928c2312425e", + "new/borrow/shared_kernel.py": "b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed", + "new/borrow/shared_kernel_review.py": "5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1", + "new/borrow/word_patch.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "new/borrow/words/BORROW-WORD-43base.json.gz": "001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546", + "new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "new/code/borrow/bw_audit_local.py": "6bc8a07942a027a52ede46521f6b5dab755643eb693efc7dcb829496050fde09", + "new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "new/extra-word-566.json.gz": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62", + "new/fastnative/.gitattributes": "92e5734dbb86fb8958622e6dcea5895601800a24b0722ef86220322449a44ff8", + "new/fastnative/EXPECTED.json": "8d45fba81564631f9f8614e637b9fbe69dc911b4e2f0b77f0a7071f39cfd7ca8", + "new/fastnative/FRESHNESS.json": "92abf8c25be59ff71a90781f38c5db2f9176c623df046a6d0e2327fd0235cb6c", + "new/fastnative/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "new/fastnative/NATIVE-LINEAGE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "new/fastnative/PINS.json": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9", + "new/fastnative/README.md": "6a2026383804606cd7981e087192b3488c674f2d9443ec218dcb2e85d06406dc", + "new/fastnative/SOURCE-PROVENANCE.json": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee", + "new/fastnative/SOURCES.json": "3599ed28c8d8a9ce096bc13507b066d09e3968587781748b2bc72f634618331b", + "new/fastnative/TASK.json": "8159b49d5c73dd887d432a4680dc947f63e7158a01a66d7736ff7138e8149732", + "new/fastnative/VERIFY.json": "e46542b70296c039b5bea0c0aa9cfd4e95e1df8859e67885ed3403bea9da7b32", + "new/fastnative/benchmark.py": "3e544453c89310281d745a37e861cbd79065b1740d90f1ec883fc200b189a557", + "new/fastnative/common.py": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914", + "new/fastnative/compare.py": "ebf877a6f47ef1fd2b797fd6077bd45d132d8cb56ab7553044bae3d86e238e45", + "new/fastnative/controls.py": "03131f4dc6a1830f10e35fb837ada456f060ca510994d250c5c2666a6342c23a", + "new/fastnative/evidence/BENCHMARK.json": "9b192c5697514c7b36b709d0e5506915425ca61f24af0210e2508d7b1bdb295f", + "new/fastnative/evidence/COVERAGE.json": "8bead250cc97614528d9448dfd29529bf08605daa5e8007e701038ab317e00f6", + "new/fastnative/evidence/REGISTERED.log": "78a49def69d0465f4318b9e24613246ba5fb6de19441e54b88fb50dfe823f149", + "new/fastnative/evidence/VALIDATION.json": "d265ce16251effd6b5d3b7429f31f98cd385fe79f659cfa24a2820bc17ac70dd", + "new/fastnative/fixtures/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "new/fastnative/fixtures/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "new/fastnative/requirements.txt": "a23aaf94250a9f53031a592980142245a848e2372b6c6c3093e8260b129265b8", + "new/fastnative/run_native.py": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627", + "new/fastnative/stage.py": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe", + "new/fastnative/vendor/accelerators/SPARSE-NOTICE.md": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "new/fastnative/vendor/accelerators/SPARSE-PROOF.md": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "new/fastnative/vendor/accelerators/sparse_state.py": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "new/fastnative/vendor/accelerators/tables.py": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "new/fastnative/vendor/native/new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "new/fastnative/vendor/native/new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "new/fastnative/vendor/native/new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "new/fastnative/vendor/native/new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "new/fastnative/vendor/native/new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "new/fastnative/vendor/native/new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "new/fastnative/vendor/native/new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "new/fastnative/vendor/native/new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "new/fastnative/vendor/native/new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "new/fastnative/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "new/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "new/fastnative/vendor/native/new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "new/fastnative/vendor/native/new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "new/fastnative/vendor/native/new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "new/fastnative/verify.py": "6dbdc56ca6cfde987869e12990a495d7eded78dd1887fb3fdf2d196060220fcc", + "new/gauge44-word-566.json.gz": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "new/pivotcheck.py": "6eb1752f077df108c908974413fc71abc751356b07c6e650e75d2075f1a51391", + "new/rebind.py": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "new/rebuild.py": "7391a7228d6b5afc2f88afd5d5a987565d78a100386c1f03b8696bcde2e8ef3e", + "new/rebuild_borrow.py": "97bd36b840501dd125d4d660750b8b7bc6550bba0150b7d2851c8a41668a8a6d", + "new/rebuild_chain.py": "3a5739f94f0fea1aa267e7d12e1c986210e483c841a8855e11020128a017510f", + "new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "new/steps/0/extra.json.gz": "17cc6c177c89eb264514e1efb3685ab9a621f3952a8f393a6a5eb28cf77e2884", + "new/steps/0/gauge44.json.gz": "0740b6f33927b9e60c9a7f35e7fcb2fd9ac6e2d3982112428b302a6966a18c73", + "new/unpin_spec.py": "03901dbb881fa608b6540a0541b26311dd4bab23bd8768e9ed48b8b355e1b36b", + "outer/B.json": "73be46ba298e18a9849354345bc9aea956cfb35db47dc279230e7237d323e729", + "outer/CLASSICAL-BOUNDARY.md": "6647d5a71d9f6c3f628ac71a7be2e63bcb0cac9618cd4fee7493dcc4ef02529a", + "outer/FINE-PADDING-COMPOSITION.md": "d20d8e5f84a9e33cc9996f875be06c24c74ea53874cc76564953785ff29c5c6c", + "outer/GAUGEFREE-INTERIORS.md": "ebeb7fa53dca671e45b3a3dedf4603607d19461bbeb977445bf5e17bbdb25db8", + "outer/INDEPENDENT.json": "1f76d5f31d69fda9d677788321e2d0f6fb7b057159a0a55525d327d7dc0019bb", + "outer/LEDGER.json": "bfd5abdc0c933f7391d1a43ea01a22a304e0b4f66cd038cfeb5973dbb319017e", + "outer/OUTER-CLAIM.json": "6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70", + "outer/PROOF-GRID-MAX.md": "19dc50ad398993d156f9366fc752321a88a7337dc016c00b0d5a53eceff93cf6", + "outer/RECT-BOUNDARY.md": "17ece1cc1eb4a02df4d8433e3612231768633e6674d315acbcf880f36e30bdc7", + "outer/RETUNED-SLACKS.md": "d87beb3869fb60143c2c3872d7c427ee16174aa51b5e6f42689312fbd40d3d42", + "outer/STRUCTURED-BOUNDARY.md": "ceef915be6462a8ad81449eefb86bf4d97db6ac41c87660e9dd7cfd2c2bc1efa", + "outer/UNION-SCHEDULE.md": "bc8e9cf7c178bb39b092ab5aafc4eeb523e72b1f69639bfcb9f27d0f74109357", + "outer/check_fine_padding.py": "a0ae691251cc50ba20b7f23f89fffaed802d62f9192a441131476914a5bdfae8", + "outer/check_gaugefree.py": "f8d49739d3f5819a62f9862a624dab7bebb019f3d8ab949524cb9bbf58d3ef66", + "outer/check_ledger.py": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "outer/independent_check.py": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "outer/replay_evidence.py": "d3bdcfc8ce29865b3a76d64d99b5177e73fe994a2eb915f35fa233c5ab81df65", + "outer/run_outer.py": "9d5dc0a7ea38973ce52a1cda02d311c235bc7c39c4d20921d5811cab1a57ef8c", + "outer/sched_review.py": "f440a57f1f46119ee8c2934c8f0d618ca1c85c73cda8cfb8453c2aa1b9fc40fb", + "outer/sched_test.py": "f96d09b5990931e3df8cea291520bf17c424215748cd9ec068214c58309a21c8", + "outer/struct_check.py": "f1df92bb6247034a22e141dcb39c1e8b6b9df6eb9791493be25a3911f7add8d4", + "reconstruct.py": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "replay.py": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "requirements.txt": "255a2ee4a60637759d4d5c89448c55849153e81ec1d1383555c6697784d9dc97", + "vendor/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/CLAIM.json": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "vendor/pr1297/COMPOSITION.json": "6fb74e73fd298b356402eb2fbcd625463b2fa540a6be4ef2d6335ddfa31d70f6", + "vendor/pr1297/CONSTRUCTION.json": "fb5f74f59c89b93c63ec47e32e2c9264658e115d1f21eed3eceefec7dc7a0cde", + "vendor/pr1297/CONTROL-SITES-base.json": "b41361f5a2f6ab3d223c146269c8027a0537f1a6e3c963f28cf1ebbe05c5d7e2", + "vendor/pr1297/CONTROL-SITES-extra.json": "f1aada769389ec410b41bc9e2082826bb916b8332c915ee9e07045135c30393b", + "vendor/pr1297/DEPENDENCIES.json": "9c9fff3ac059da4d4e2f13e655afb9e42ada1a57987f5b47b68dda4b64797966", + "vendor/pr1297/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "vendor/pr1297/EXACT-RELATIONS.json": "6864f378d917d0ecfd8cd53cc26303217ebb48f47f2987bbc01cf1e2c9a28093", + "vendor/pr1297/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "vendor/pr1297/INDEPENDENT-DERIVATION.patch": "6b3af098ec1c9e2360a366933eb7fbf0e16ebb37d43809d26b275e66fb5ee779", + "vendor/pr1297/KERNEL-CONTROLS-base.json": "cbe755333f469a1f01258b65f2b273763212dba6642edabfb58f7490f326abda", + "vendor/pr1297/KERNEL-CONTROLS-extra.json": "cf255deb866ecaefca4b6ecb72f105d6b08dc8ea907a8381d45aedc39b2022cf", + "vendor/pr1297/MANIFEST.json": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "vendor/pr1297/MAPPED-RECIPE.json": "09aca649da97a37116262827cbd3ebe0addcd2b1a33c08e8347f3daf3394176a", + "vendor/pr1297/NATIVE-VALIDATION.json": "755b7087e0ae964c538e9378311e07dba2867c16b568d1bf6ae9051657f9f5cb", + "vendor/pr1297/NOTICE": "b352129a07fc8693f57c77cbb0ea92230b2fa77439f86c9f35b828213f9c42db", + "vendor/pr1297/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "vendor/pr1297/PRICE.json": "e19f9f9e70e4fda2bc4a39fae93ea44555945cdaea59728864c5a44dcc5522e6", + "vendor/pr1297/PROFILE.json": "d9bbe0d73ba005749615915a2d884819a6b141e3402d9e7f87f4592a2d27af99", + "vendor/pr1297/README.md": "102ac7f080c1799aaedd5345ffb3631845215e8ab770e2af34750c25f667686d", + "vendor/pr1297/RECIPE-base.json.gz": "0f2db2c658e9732fdd1aeb7bbbb5c786d6045de8a2575b7654b9e6fddc71b03d", + "vendor/pr1297/RECIPE-extra.json.gz": "9e6f58570b0a8f9e8271bfbc73a339fce42f1cf28bf14d4db93f246b8f63a3c9", + "vendor/pr1297/SEARCH-RESULT.json": "7cdacadcbbf83b81f9f91668fcc707f8a238c6025f35a8bdc36758619c2591c4", + "vendor/pr1297/SOURCE-PIN.json": "e93f303f4de383757e50d612ada5e379533d46737a32281aa6879fb4b6138e09", + "vendor/pr1297/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "vendor/pr1297/UPSTREAM-NOTICE.md": "b97fb4731e84aef736c58a9c126334eb5b8d3a057a8d9d45b4ffff24af65c38b", + "vendor/pr1297/VALIDATION.json": "1008f637a22f954ee774920a8362931ca7cfed63ca146e725768c0f39803c0a5", + "vendor/pr1297/audit_mixed.py": "7466461cc15cbb12135d94f2d904d4e90e78cbf4755d0293ab9bd55e3568d4b0", + "vendor/pr1297/build_word.py": "ff08af2851b4813c113ef63113566cbd79625e9310611292913d51be554b5aa9", + "vendor/pr1297/construct.py": "71aff454291d4a35068c43dbb65c00ff511f48e91ab7cdada462833f04ac73e3", + "vendor/pr1297/controls.py": "935cf39ed6601eb6ac411b7b1a4adf5d4238589cad9fd5969d7dca967ace4c4b", + "vendor/pr1297/extra-word.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "vendor/pr1297/freeze_spec.py": "0f5c8ad43180a633a2cbbd11f7832729039402c68f593679552c43a1693d69fa", + "vendor/pr1297/gauge44-word.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "vendor/pr1297/independent_core.py": "d1dcd5593a05cf647b485db38891984f829abea5f95c6cc91e37d554bf163d48", + "vendor/pr1297/inputs/base.json.gz": "b87c706d14a7e1972514ee901002a930908073811ef38761def31c8e36351916", + "vendor/pr1297/inputs/extra.json.gz": "ded6903e00deb9e158fa700b03ccc9b8bfaae6c8bad8ca4842f0ad9b963234ab", + "vendor/pr1297/kernel543_controls.py": "ac16d605e773197e3664643d40b36c15a7130a45e95e36bfe7b42d939644367c", + "vendor/pr1297/kernel_controls.py": "436e3f3d9974da7c1968ef99fdde5ad203a61544d8195493e3150eb25869f4dc", + "vendor/pr1297/original-main/research/complex-t21-owners/vendor/pr870/t16/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/premise/inputs/CODED-CELLS-k8.json": "7347f814850a838bd617bc7a55c307cec2b72becde2f12ea3e2e1af344b43563", + "vendor/pr1297/premise/inputs/TRI-LEAVER-k8.json": "b22e6ecf76104de66844bd617c4ca80f5546ba0966a50e5e9aa0ffea4976cb30", + "vendor/pr1297/premise/premise_check.py": "28a7f881a988b29b8ed3c927dd142ac3d4ee273dedab3a65bb02c01a64eb2639", + "vendor/pr1297/premise/verify_1049.py": "a1736324c6db161733d8e11f608defd87b7f97cacd611203d22499e4c7de5545", + "vendor/pr1297/replay.py": "d3ea7c2e74ff6df9d14969f994eaa85f825372cee92dafb77bec4767edb242e7", + "vendor/pr1297/search_relations.py": "58f3bd092cb8592a070d7879918ff318a658a6fa02bfad7b5b8f4cb0fe16691c", + "vendor/pr1297/upstream-layout.tar.gz": "a0cc229bb0fc9ab8ee5c14d5de87b3de31d1fcb793e99192c9cdc63781e794a0", + "vendor/pr1297/vendor/pr1193/CLAIM.json": "b9db2fbfb004b505ad535e4763915275dc5908feaefef32e65863fa65de061ff", + "vendor/pr1297/vendor/pr1193/DEPENDENCY-PINS.json": "c9330aa6a4226c804060499429cb450820d7142ab17696eb47408b04b410b5bc", + "vendor/pr1297/vendor/pr1193/MANIFEST.json": "4837d070679d9e70218c7cfa2d3e70d7d742a5b74dc66d224840b1a3a4ac4a31", + "vendor/pr1297/vendor/pr1193/NOTICE.md": "c7a17a0a35dc249f8ebcc550b3791e214aa65872eab8a6458c5167dd7b948e5b", + "vendor/pr1297/vendor/pr1193/PROOF.md": "b2a38120ddb75e90764d0b81913d60b46cddac4d943cb731bd9c7134f1c236d1", + "vendor/pr1297/vendor/pr1193/README.md": "cdcf62624912150ce4e6e05356c27299251eef4cfc130e4f209839cdabc05e08", + "vendor/pr1297/vendor/pr1193/SOURCE-PINS.json": "08eed0d6822a1c17053161929591e7ac36b9f91f8fd61190183a6d975948db85", + "vendor/pr1297/vendor/pr1193/audit.py": "1118d483b6abbe7036390c0a1053bcfec2038dbac273fd1bac92a68f38e6d7da", + "vendor/pr1297/vendor/pr1193/build_word.py": "effb72aecfff9958fe078ee89e0d37b85d601eddb19fec4520d7ee6e936edfae", + "vendor/pr1297/vendor/pr1193/common.py": "274274df31f8ef2a47b801d1f30ec226f94bce674fe15586d814ca754f6b7785", + "vendor/pr1297/vendor/pr1193/construct.py": "3dd333b50f4bd1d86956a6df4a334ed746d75d0a9e03dfadbb6724b4356e0cd6", + "vendor/pr1297/vendor/pr1193/controller.py": "d93ed519a0f2316b87b66f44c5ea615f0768a263dbd800815b536d8b7c86b8b7", + "vendor/pr1297/vendor/pr1193/controls.py": "574c55a01cfc34f5b9688cdec5646160cf22b403decee36d18b11f1b07e71f21", + "vendor/pr1297/vendor/pr1193/data/FLOW.json.gz": "e8e6dfa66e083ff8f3617a8441b5b2d766c3c9d9ac62ddc37d99edc24051f79e", + "vendor/pr1297/vendor/pr1193/data/FOUR-RECIPE.json": "384b32c5b0e9b3baa1c7232db884809596d30fc55553094245f7b739b1a43484", + "vendor/pr1297/vendor/pr1193/data/FOUR-WORD.json.gz": "7d09ee1b8b9881313e5fb1f623c0961d59b0c6352a019bc9164a6cad8c58e27f", + "vendor/pr1297/vendor/pr1193/data/MIX.json": "dd86bbb792a5c9f0d7507d55bd2f8392c66716023934b03b24f48ca737204eea", + "vendor/pr1297/vendor/pr1193/data/ORDER.json": "7757df3b54ca5e84c6dba9563b10bc6215c5e289313392b5a4b493179a245c29", + "vendor/pr1297/vendor/pr1193/data/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/vendor/pr1193/data/PLAN.json.gz": "1f1085beb84b516b9a96ceaedc6c3de1c58941fd00b6e70f0d0c686b6546ff79", + "vendor/pr1297/vendor/pr1193/data/SPEC.json": "82b263990afdc5efdc1dfe38ae16d7815004dff8d70f85c28fd8286c31f688bb", + "vendor/pr1297/vendor/pr1193/evidence/ANCESTRY.json": "cd880b2d1c2fb8d9050458bd13f228385c417a95e4d1985607d9f4bb60b5c109", + "vendor/pr1297/vendor/pr1193/evidence/ENTRANCE-CONTROLS.json": "7b101dd97c1025667fb3615930a9d6cd2ec443169d263a3bc1191b80fc712a1f", + "vendor/pr1297/vendor/pr1193/evidence/FLOW-CONTROLS.json": "43fe7e94bd72607d502ed947ac1463405be18728eb0b8faabd7ba63ab1d28ab4", + "vendor/pr1297/vendor/pr1193/evidence/INDEPENDENT-OWNERS.json": "4c295ff53f51631e1720b0dc2ea895c34861435fa92112ee52439e4569de968a", + "vendor/pr1297/vendor/pr1193/evidence/PARENT-CHECK.json": "2b729fd666ffe4e34a355223b57f74ba460fb171b19c84f260378dd109f0b9a0", + "vendor/pr1297/vendor/pr1193/evidence/PRICE.json": "a1dac219b019f8d40d5b434b0e0c25b0d1f097fe5ae13eae45c76869aec4758b", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote3.json": "02150d4cb1b2f4763b5c5c20ce979c740cbdfc1066e021a8aa5d407de5c4b9d3", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote4.json": "7adf0070125b2c61e04d46c5f1cbf57af079eb733799bbfcc3fe9b0551d964b1", + "vendor/pr1297/vendor/pr1193/evidence/REPLAY-SOURCE.json": "a5a290aa8c75fffa45c9ad2e3441d5051d3adaf7934f4d0311875fb4d8f023cf", + "vendor/pr1297/vendor/pr1193/evidence/RESULT.json": "62aca8286cbb021d2535d81494f7ba7a3aec20898fd7c40a895a461bbd303ac4", + "vendor/pr1297/vendor/pr1193/evidence/STAGES.json": "0dce559b2a8f371f369a05ae25ca5dd6a48019b5685b0097f001a23bd849429d", + "vendor/pr1297/vendor/pr1193/evidence/WORD-RECIPE.json": "b6750c8123c205b63786fb825da26a819592f71736a82009809ae1cf96173a5c", + "vendor/pr1297/vendor/pr1193/local_controls.py": "fe3d13491fa7523eedb8d24577ffe4bbd6c36a87b4a7d1178e5795d223bed4b8", + "vendor/pr1297/vendor/pr1193/native.py": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "vendor/pr1297/vendor/pr1193/package.py": "cde0b2d66125649ee84440fc0a67f0d91f900fc838fbda069b579422289ea3be", + "vendor/pr1297/vendor/pr1193/prepare.py": "9fe454a5f857ff73c70a5b276bc9e289422b051a4cbbbb51123a91bb2200e6d8", + "vendor/pr1297/vendor/pr1193/price.py": "d45042f4c1fea352349377b43def363cf75a742546a1d5c790ad30da91791803", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/JOINT-WORD.json.gz": "a0622d86259c4163e58cf0677ce575b6039a8ae4c95aa6d8b82a8163cbd42718", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/NOTICE.md": "afbd38d6c8a232ea566c296424a86420f204e6cfaac565c0a147340bda3d3da6", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/PLAN.json.gz": "e963ed64b9970858902b9388bcf1c5f9cc704859ad021ce8bda465a4dcef8310", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/SPEC.json": "55bdb68d5d126c6be0e0acc419bd62301a978afd514f9834ed1e08b1aa4f563e", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-coordinated-owners-NOTICE.md": "442756fc1c5ecfd7b7b7694b53b1ecc70aa525004cd80f7d748ccd7270555189", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-NOTICE.md": "820fa13161f857c221f2c4099dd2985c7ff72249dc7a0221bc00fd0c1b9760e5", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-t16-NOTICE.md": "a9e85b59dde61fbff0b006923b441cbd1419e24fa9802426785bca667437fdc0", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-three-demotions-NOTICE.md": "a0fe85fb2207f0e6831a96deaeefb65afa379c1377a29f0b586f1db4bb4b2137", + "vendor/pr1297/vendor/pr1193/verify.py": "e5c952989344a65b7e63fa112dda4d464979814205644a8ec34e407a0d96be29", + "vendor/pr1297/verify.py": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "vendor/pr1297/x54_controls.py": "82f91b81be9173dca546345dbdaddfc71e6d21e626fb84a8b4d1b4ba0d673814", + "vendor/pr1673/capped-phase-fusion/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/FINAL-PACKAGE-REVIEW.json": "3457385de52d8e86853d96026a70aef2e8dece516db9eea020d8774e01d076a8", + "vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/INDEPENDENT-FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/MANIFEST-UPDATE.json": "32c58bcab8e19ef895660331c13d31b5fae7d0c95f7cda4147870f29d8299f6d", + "vendor/pr1673/capped-phase-fusion/MANIFEST.json": "9af581d640e9c69d513256cf69babb0717287642134cfc807cedcd79966c1706", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/MATRIX-TRANSFER-MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/NATIVE-RECEIPT-CAPSULE.json": "a04d6bba3d15c11a219536b66a23012797484ae106ec1952ecd7b76f077ddb01", + "vendor/pr1673/capped-phase-fusion/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/PACKAGE-MANIFEST.json": "298f1eaf79b5d5d57cb96fb3abb422174b78c31c14491a878f6176431d731d04", + "vendor/pr1673/capped-phase-fusion/PHASE-LAYOUT-AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-CHECKS.json": "6e2fb68e6768c3aa4224aacb4900263586fc8114815a51df40f3f9fdf6124217", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-SOURCES.json": "6082583794168b1c2320187214b86c93a5a6e76fbbddfcb3bdbb8c5bd34c0586", + "vendor/pr1673/capped-phase-fusion/README.md": "91af88b8fc53a22e1e968908f0e449cdfe2154c83f0dddb8a504e661c0c6965c", + "vendor/pr1673/capped-phase-fusion/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/ROOT-EXACT-REPLAY.json": "d36114abe9d7a83c327f49f5ea153c6dcada4a7421f5e74a9a5ceb392cecb994", + "vendor/pr1673/capped-phase-fusion/ROOT-MATRIX-EXACT-REPLAY.json": "d6bd4fcb8a528655181b4aa3fd1bad7e6647a4ca5aa76ee7f2cdd800b698b225", + "vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/SOURCES.json": "14ce6fdc7c83e18ccf4fee19ff51062726c960ca44462a45af60dd686167d456", + "vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/TASK.json": "47b82ef23e20991010fae838ad4da9bdac3f947a8fea916a028fd6260f95f5f8", + "vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/VERIFIER-NEGATIVE-CONTROLS.json": "eeb887cdc0c76426c75ddbfc3d4af7ccbbe19d17962c6ad7a1549dafe8dabb5a", + "vendor/pr1673/capped-phase-fusion/VERIFY.json": "cb50aa523a0863a457181ca815e69a1b3b4d91ed1006a79263f4a8f18457c669", + "vendor/pr1673/capped-phase-fusion/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-CONTROLS.json": "eb3ba38d18bac4aceaffba39ef48dbb55bd15e6abcb68cdf66920d9d13ec00ab", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-CONTROLS.json": "ae8f0eb121a2f4da5c3f982ee6e7f45dab7b18368cadb5d2060602b0393b7120", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CYCLIC-SCAN-CONTROLS.json": "4c37249f12b4cb4df847d179df8f378fbf1f42917e9fa703b2d847146f29b95c", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/DYADIC-INTERIOR-CONTROLS.json": "afbaee9f56f6a66fd9421bba7dfa8c3610c12bd447b01d0e9d79f97d1216aa90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-CELL-CONTROLS.json": "4417a518ba3b6833f06b4f5e33d4f73ea74100b9110cf20e8d1c2070f1833fcc", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-SCHUR-CONTROLS.json": "046191420a24d8b2c063c190af5e954c85e39357902988c4df79f5abcdf1596d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-CONTROLS.json": "323cb4acae960a6fa05527df5ede9d48e274883272b8ddb5151ebcee6dd26e52", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-FACTOR.md": "dbc7eff783695e0f50fec57b0f7ca4212d51428eea04fa2ae5e0a9178fa69b30", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/README.md": "8fb5321b514af9260c44e150125205fe564efd073c456214f76bbdb358279cf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-ALGORITHM.md": "46b98b9c013dc5a94c9f17fd85acd7c1896c8e93ad2ee4a7c34f583895f1daf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-CONTROLS.json": "c9e6fd7f338f2cb78a0ed15ee944fde63549ae3d8522ab0874d184f3e252db76", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-LIFTING.md": "69535a48416a5435ea2a5ef4ecfe70fde30c32c4043bfc56f1ae2d7f49cd34bd", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-MERGE-CONTROLS.json": "c5729bdb36237c0691fba56d149019f78d94e996749532d907a84c35ef01319d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_bilateral.py": "8d5c79bd4f4c96de5c1fa91553b19e3a62419333b414fc84dec894a4b729d5e0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_capped_gauges.py": "121279bef47dd490bf29fc72ddbce547176cdaf1154af67dc8b96d7baa8cfc6f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_cyclic_scan.py": "d25156f852cb95f013e0ee74b319fc8c20d6a7a53fa851543244d5af7898ee61", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_dyadic_interiors.py": "a39617147870719a0296eef77101c90df8fbe716841cb9ed823f36b94254c3e1", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_forward_cell.py": "082a0e46c175f6e59fe1f8c168ca56bc444c71a602c9b7318c0834aae1f2de90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_log_a_schur.py": "a0f1116ce27ecbff18de7089ce1f56714ed7966dfa0105b20419d408feb7ca41", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_lower.py": "027c77d8ce33c3d5e3c436234668f11bafc3de8658b9c3d03d455eb0e4d71f95", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_data.py": "de4f9df64cf31e94adb9a5d04b38d53d823d864f51632c49c7c80c6a46b5224d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_merge.py": "95c9908134905e3ebdd030375e36a942c886cfc59edde3c6a419f36da6754780", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/EMBEDDING-CONTROLS.json": "d0182e172f16b55ec64a5edfabb10816e416348ef2db15449f3ed4b47f3fec1f", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-CONTROLS.json": "ae370f7d7421f2f96e101a4b9d8082110507c47211220fd6ead065c2366aa828", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/MANIFEST.json": "37946d7691b90d39906d93581839bdf8ae2cf899d459e5520c39e782766e9327", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/PARAMETER-CHECK.json": "e38cdfc13f1959186d888383458c9030c4bd3c8c3915aea4743d55637d2f8d76", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-CONTROLS.json": "c3688f65565486b585727374abfbe478f7544aa61381bd73cc6ffa168b4221b6", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-PERIODS.md": "c6e4dfe7f58dac7c5a513ffb3a9ab4801ab0717efae5c1e764e570335402ff25", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/README.md": "575a3acfc18a0e05ffe04a8563318a2770ce32cd7bf3a5e6123ce2de39a1cd4c", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RECTANGULAR-EMBEDDING.md": "e64447bff7e7717802ee049290faaf29e45db3e36a6f7fcec109184478f15f26", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SPARSE-SHEAR-CONTROLS.json": "d3b9763f7ef6a3a5752c6c11a8a4d5f465646ad75b178a1c1b3363540fcc4871", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_embedding.py": "597cb5304498456575c99d46a7fb503e04db28d5a7f57857b102b50f703b7464", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_halo.py": "0a3257cbb8f37b6cc9bb44019cb114ea2ae9b28738a416bff4bc712d1306e1b7", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_ragged.py": "54b761cfe3404d524af3a2abdf09bcea8dfb5cca6199c0c182cee310e3ca8c78", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_sparse_shear.py": "6e22c989e6bae92c4cd209c9336aad4359956cf370bdbd5f6b70609144598121", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/CORE-SOURCES.json": "2546f47dacc47c2d63dc5bb9cc52ef86c5e02ee159c4fb6e00dfac3f8f34d89c", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/core_review.md": "13f2df4d5b240f9b89ca0ae44bba198c935532098ff4c1161631fcbd86b3e8b1", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/gaussian_layout_review.md": "ebd7188970f55b5979b1b1a13f874a31ed0ee6c82bee329e7ad0b2a38c42c430", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/layout_subreview.md": "637e4698a9fb02978ebc4032d8939ce0db9528e89e908c94d63b9f0d2a41f64a", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/union_subreview.md": "738b35a04d6871cd73b14b4165ae69a1feb3a103eb46e064a64a22c4c7426856", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/CIRCUIT-REPLAY.json": "2ce5cf9ef9461e5897374ad389c26af66aeee85e8f514a9da4ed3bb2028cb1da", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/EXACT-ALGEBRA.json": "694898bfb1afcb3b8b8ef951634ac8919decdde0904350b355d254601ae3dc12", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/MANIFEST.json": "3b018dc660c6add775c12f75b9e8f5281825aeebc3888a508833ce6106c1229b", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/READING-COVERAGE.json": "756e52726b161eea27e27f1d519b05d4fb0ebf67ef9a67b33947194d5d02b709", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SOURCES.json": "fb3771f66771250aa9f4406ae9e7eb176f9cdef03976cbc9558440c674a4a94a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-AUDIT-SOURCES.json": "d0c274d6edd6193b09d28e45e7cbfe9236fb35474d35ea3af0664ba36f9e006a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-CAPACITY-CONTROLS.json": "6922b7d7a936d53846569ad3be53fe4f3c63d6cfe794f9279fdc6a1fe411ef0c", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER-CONTROLS.json": "db8a5c0dc2be956d83bc7667177252a4968e0ffaee8352e6a5dba5ab983d7ada", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_circuits.py": "06d1861bfe8af543908e26557ffda7e451ff176bceb9bacfaf0f04f234b336d5", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_exact_algebra.py": "5ff7f25c55b370a1d0cda6c84ab9cdf2c7b0de3266d3f2e7a43280a6491074ab", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_supplier_capacity.py": "035ed96b39414eadec46e8de4bf3811b785862fd313deb044f42e17cf2ad3f78", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_tensor_compiler.py": "dc4b1f1884489215a2c2d0e8978a241e99e6c8c9f1d2fa2460c73d2c7d4ba30a", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/check_source_constructions.py": "9d387098403c0355be8e93158df02bae5a435b2366bd28efdf0b127e470c8c1c", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/README.md": "17c393075292b364899cb7c451cebbc9b20834f9fac934ce3740aba360c27246", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_outer.py": "6a0c5f8956323615df8bc4b12996832471c0ae607d05429c9d70ad1b50568f10", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-LAYOUT-CONTROLS.json": "e6951790238b4998c632c95aa329ee2cd2527a5d74a2f28bd15249fec6d2419a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MANIFEST.json": "c98559147bb498ac78af998eed63ab6661af934fa1a0df6844176b1811753fb9", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/PARAMETERS.json": "9f72cfffa34844764ca65a6b4431cc5c779141751df746019db9d3ad8f1dee92", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/Q-EMBEDDING-CONTROLS.json": "24ead3534482397c00c23ad3dbbd4e930e02290e00c97765353d8783c6575c7d", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/README.md": "0ec721f76dfa943e808afd3c2cc39ee69f1a6e5f4f77ba3c7c1373ad60db25af", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/UNION-CONTROLS.json": "6c5262144215cc603bbc3bee93a9a6d9d2318d0177a59115fe560762998498f9", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_capped_layout.py": "267d93ab5114ec160f88a6e65fd34c9f0696a686c36ba2dd194d6b70fa32a6bd", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_q_embedding.py": "ac858a14bbaf37e0e412a7ada282cd1586632f52b8a979733e775f50130969b6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_union.py": "74608380d72567edcd4470c8d226b15848f9d3a4e5d77d652bdd8963480ab9ce", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/CONTROLS.json": "12d9207e887fda73159a9e2e4776003ca6f905fc3dc45d77ced588a1c9f80cb2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/ERASURE-ROUNDING-CONTROL.json": "cceb2ade8ce5e18be3871f771955e38258f5eb4e39790c016aab96d8cf0488ef", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-LDU-CONTROLS.json": "d6bda457fff01e04b6565d84c7bdbac870569a2ba7ef18a1fc8db11b738faf38", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-AND-Q-LDU.md": "c6a032ed495325806ddf491c5c85bc822a7fdd613aff906a7be553960d0f85a3", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-CONTROLS.json": "3f7e98ce524d5fb2ba2f911a350081340215e806ae945abf15a2fa07988ca2f8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/LEDGER.json": "87eab0eb334ddc16e50cedbcab56320d2ff056c3dc87d7a5191171bb5a4c206e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-CONTROLS.json": "b85eca6098847e7b2f77b49a6c8c35e33cf790bc5dd01b95e1334daef9af47f4", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-NORM.md": "7955383d50fc59b5c4c4d839c7e4d630add6208a3a233d7372a80309085ac6b2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/POSITIVE-TREE-CONTROLS.json": "7b31811402ddda4668fe8375f6c90a6047511d50836dbb7cfc7ffcf24fe19a11", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/Q-LDU-CONTROLS.json": "370a07aa1a56c656ec1f44d7651dfbe999ad0c19dede9036257cc2f29dc39452", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/STABLE-POSITIVE-TREE.md": "ec2f8a1c4273b81217545d2710bcffdd09b5c9ba9349e887b5f7bf6f5bddfdc7", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/SYLVESTER-CONTROLS.json": "198af9f58c2950f17d8b1861ba4566bb2f6a0108a889a56db328fe67f8faa1a2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/TASK.md": "5eef77fb23f26f5bfb5dc8e376ed25e769924f2b6420ebfc8671e3b2a2f1f611", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_constructions.py": "91387c9bd763a5c55c22a9907947bd07b6002f739aa6feedf6d3a02adea1e316", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_erasure_rounding.py": "486efd4692665a548b94b79877abb76ad13157268f05c270c4e75d8f97700795", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_fixed_a_ldu.py": "15134147317a7d789c9ea0ebd71db5ff11e59a20ef140f681d87478977734cd0", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_holes.py": "99c5dc4601ea88b553f52e235d36fba0aeb867e7fcd54130cdb3eb115a9bb0d8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_ledger.py": "254342c05949e5cefe4f507a35487e0a1ffb7137a60d2b97831d5ad55d7d7ce5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_nearest_neighbor.py": "21bf2be683cefa7a760bf1e1bdaa647f57bf47ab86b13fd7a74e8d650f492913", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_positive_tree.py": "46db2ce9122ff57bb4eeaa723db1f351891e671a7eaa7bf4fb61f85dafee9e37", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_q_ldu.py": "ec2589ca9abe71d674ba9ccf81f289b1526f56f3001c48d22977accb1be3e4dc", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_sylvester_factor.py": "60b21fda4ff451582087d30222a072eb1a214d531277e92883eaf28221aafced", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/FRONTIER-FUSION-ARITHMETIC.json": "82656563e7c8725f95c4aea7e273805a3d3faf34c495a330f1c91a036765414a", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-RECEIPT.json": "49a8450289f1c1730c7d11d7c1506ad4af26fe9a1f76341f808a3025123e9519", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-REVIEW.md": "b48d3e14083829db81336b639a6cfc698ac0dccc76fa2606d11b4be7a968ddeb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/NATIVE-ADMISSION-BINDING.json": "ec4e89e0513958c1d553736cd06eedbc5f2aca61b40f92aeade3eb882bf588bc", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/REPRODUCE.txt": "76808b685f1623813658f5b596a4b8191a07e7c0810550f6fada7fb4a4992913", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/T74-APPENDIX.tex": "d053a6b69de2ff4005ee52eb3b673de606326aa0f0e290354675f9f08f915b99", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/bind_native_admission.py": "166541ca2b7f3066f4c2421e5a9f1886d58e1fdd7677904976261ab2c82b32cb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/check_frontier_fusion.py": "02f7f9ebf29487331171954c7ceb37ff5315e2f28a9d56096ebbf9fb865c70ab", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/independent_substitution_check.py": "579bbde41e90792818c2726b38dcab26cf5a2695d3348731e814175146b0a737", + "vendor/pr1673/capped-phase-fusion/gaussian_fixed_width_note.tex": "6f3edb7b238f2b6af4f3e2d98dee90fe6f4ba063a5ccd120422e45c941712aab", + "vendor/pr1673/capped-phase-fusion/make_native_capsule.py": "8f342ca212b8d601a11f704042c577c1b088e0079bda04b3065467c2f3c36ea0", + "vendor/pr1673/capped-phase-fusion/phase_fusion_note.tex": "b5957f38c98a68f2584a42cedf91d753180dab438129fdf749b441074f00d4e1", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/RESULT.json": "11c57817a4d43a489010a13af7621d37eeedc398308c036e63a2a97119443861", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/STAGES.json": "c2edb01a61c03e04bf48e605422ff83c1d304e4d586268959d4ea24b743640fb", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/CLAIM.json": "70aacd45f9e6fac8675687cf50da32e0ad4e479d9a5c28f2afd1550311ae8849", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/MANIFEST.json": "d90d49eaa68e48c6992a07972e736ef4b9cd80274361cbbc1ec980d43f29ad7f", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/NOTICE": "3918a42010a435782de0fe8c38fab8f7df5d48a375ecf603c2bad1b818a16d6f", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/new/SPEC.json": "d6b6a2140f3a61ae8cfdd8b51a1131934d63d2dd8573c1b13eb2b9528f3c3db8", + "vendor/pr1673/capped-phase-fusion/verify.py": "93ef0f46e132485da6194587199b8f039e25b1b9f099f93bbdaeac5c0d66de7f", + "vendor/pr1786/FINE-PRIME-PADDING.md": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce", + "vendor/pr1786/NOTICE.md": "dcc1adb2461aa93ca62b6a912dbd8b215599e6af8053dfbacb7423b544dd659a", + "verify.py": "1591a3eed02d3532e46183543bd2ddc7129c079a5fd70f1e6b4d9bc897153e92", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/new/rebuild_borrow.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/new/rebuild_borrow.py new file mode 100644 index 0000000000..ecbab3d6e5 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/new/rebuild_borrow.py @@ -0,0 +1,285 @@ +"""rebuild_borrow.py: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), +check they equal the shipped borrow/words byte-for-content, run the extended auditor (borrow/audit_local.py) and its negative controls. +usage: python -B rebuild_borrow.py [--no-controls] (exit 0 only if everything passes)""" +import sys,json,gzip,subprocess,hashlib,tempfile +from pathlib import Path +D=Path(__file__).resolve().parent/'borrow';sys.path.insert(0,str(D)) +import os +RCP=Path(os.environ['BORROW_RECEIPTS']) if os.environ.get('BORROW_RECEIPTS') else Path(tempfile.mkdtemp());RCP.mkdir(parents=True,exist_ok=True) # receipts (with elapsed_seconds) never go into the package during verification +import build_word,word_patch +CASES=[('gauge44','base','eeb6a236'),('extra','extra','cd417b90')] +def content(p):return hashlib.sha256(gzip.decompress(Path(p).read_bytes())).hexdigest() +def refit_apply(word0,patch): + """frame refit: replace exactly the listed gate frames (gates unchanged) and the local profile.""" + import copy + w=copy.deepcopy(word0) + for sec,i,fr in patch['frames']: + assert w[sec][i][:-1]==word0[sec][i][:-1];w[sec][i][-1]=fr + w['report']['local_profile']=patch['local_profile'] + return w +def run_audit(word,base,rec): + cmd=[sys.executable,'-B',str(D/'audit_local.py'),'--word',str(word),'--output',str(rec)]+(['--base',str(base)] if base else []) + return subprocess.run(cmd,capture_output=True,text=True) +def kernel_check(prev,w,patch): + """The kernel edit(s) (helper-donor pivot kernels, PR1625 shape): the shipped B section differs from the previous word's by exactly the declared gate-level edit + (frames ignored): reads of the pivots inserted/deleted, nothing else; every inserted and deleted gate is a read of a declared pivot with coefficient +-1.""" + qs=set(patch['pivots']);ed=word_patch.kernel_gate_edit(prev['B'],w['B']) + ok=ed==patch['declared_gate_edit'] and all(g[0]=='add' and g[2] in qs and abs(g[3])==1 and g[4]==1 for _,_,g in ed) + ok&=sum(e[0]=='delete' for e in ed)==len(qs) and sum(e[0]=='insert' for e in ed)==4*len(qs) + for k in w: + if k not in('A','B','restore','warps','report','cleanup'):ok&=w[k]==prev[k] + for k in('A','restore'): # frame-only changes outside B + ok&=len(w[k])==len(prev[k]) and all(x[:-1]==y[:-1] for x,y in zip(w[k],prev[k])) + return ok +def kernel_controls(w,patch,tmp): + """every perturbation of the kernel edit must be rejected by the independent audit""" + import copy + res={};qs=set(patch['pivots']) + pos=[j for kind,j,g in patch['declared_gate_edit'] if kind=='insert'] + def audit_bad(name,m): + bp=Path(tmp)/(name+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode())) + r=run_audit(bp,None,Path(tmp)/(name+'.out.json'));res[name]=r.returncode!=0;return r.returncode!=0 + ok=True + m=copy.deepcopy(w);m['B'][pos[0]][3]=-m['B'][pos[0]][3];m['cleanup']=word_patch.derive_cleanup(m,word_patch.restored_of(w));ok&=audit_bad('kernel_sign_flipped',m) + m=copy.deepcopy(w);del m['B'][pos[1]];ok&=audit_bad('kernel_read_dropped',m) + m=copy.deepcopy(w);m['B'][pos[2]][3]*=2;ok&=audit_bad('kernel_coefficient_doubled',m) + m=copy.deepcopy(w);m['B'][pos[3]][1]=m['B'][pos[3]][1]+1;ok&=audit_bad('kernel_read_moved_to_neighbour_register',m) + return ok,res +def _rd(m,ref): + """re-derive the explicit inverse-reverse cleanup of a mutated word (A section without its prelude), so a control is rejected for its own reason and not for a stale cleanup""" + try: + t=json.loads(json.dumps(m));t['A']=t['A'][t.get('prelude_events',0):];return word_patch.derive_cleanup(t,word_patch.restored_of(ref)) + except Exception: + return m['cleanup'] +ok=True;out={} +for canon,wt,h in CASES: + tmp=Path(tempfile.mkdtemp())/'w.json.gz' + build_word.main(str(D/'inputs'/f'{canon}.canonical.json.gz'),str(D/'inputs/blocks.json'),str(D/'inputs'/f'witness_43_{wt}.json'),str(tmp),h) + shipped=D/'words'/f'BORROW-WORD-43{"base" if wt=="base" else "extra"}.json.gz' + base=str(D/'inputs'/f'{canon}.canonical.json.gz') + word0=json.loads(gzip.decompress(tmp.read_bytes())) + chain=[word0];steps=[] + rf=D/'inputs'/f'refit_43{wt}.json';kf=D/'inputs'/f'kernel_43{wt}.json' + if rf.exists():chain.append(refit_apply(chain[-1],json.loads(rf.read_text())));steps.append('refit') + kpatch=json.loads(kf.read_text());kpre=chain[-1];chain.append(word_patch.apply_kernel(chain[-1],kpatch));steps.append('kernel');kstate=chain[-1] + kok=kernel_check(kpre,kstate,kpatch) + hf=D/'inputs'/f'handoff_43{wt}.json';hpatch=None + if hf.exists(): # coherent four-helper handoff (PR2322, Vlado-V) on top of the kernel state: four high roles replaced by retired source registers + hpatch=json.loads(hf.read_text());chain.append(word_patch.apply_handoff(kstate,hpatch));steps.append('handoff') + kok&=sorted(hpatch['fields'])==sorted(k_ for k_ in chain[-1] if k_ not in('report','cleanup') and chain[-1][k_]!=kstate[k_]) and len(chain[-1]['removed'])==len(kstate['removed'])+4 + ef=D/'inputs'/f'entrance_43{wt}.json' + if ef.exists(): # entrance raise: start_extra and frames only (gates unchanged); previous state audited, tamper controls below + epatch=json.loads(ef.read_text());prev_e=chain[-1];chain.append(word_patch.apply_handoff(prev_e,epatch));steps.append('entrance') + kok&=all(x_[:-1]==y_[:-1] for k_ in('A','B','restore') for x_,y_ in zip(chain[-1][k_],prev_e[k_])) and chain[-1]['removed']==prev_e['removed'] and chain[-1]['warps']==prev_e['warps'] + lf=D/'inputs'/f'lowfour_43{wt}.json';lpatch=None + if lf.exists(): # four low aliases through lifted-target compensation (PR2436 mechanism) on top of the entrance state + lpatch=json.loads(lf.read_text());prev_l=chain[-1];chain.append(word_patch.apply_lowfour(prev_l,lpatch));steps.append('lowfour') + nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[640,641,642,644]==lpatch['derived_removed_diff'] + kok&=[x[1:] for x in nw['warps'][:len(prev_l['warps'])]]==[x[1:] for x in prev_l['warps']] and [x[1] for x in nw['warps'][-4:]]==[33,55,74,85] and len(nw['warps'])==len(prev_l['warps'])+4 + kok&=[g[:-1] for g in nw['A'][nw['prelude_events']:]]==[g[:-1] for g in prev_l['A']] and nw['restore']==prev_l['restore'] and nw['helper_final']==prev_l['helper_final'] + kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('640','641','642','644')}==nw['start_extra'] + af=D/'inputs'/f'alias637_43{wt}.json';apatch=None + if af.exists(): # alias 637 borrowing retired source 31 (PR2436 pair) stacked on the four lifted-target aliases + apatch=json.loads(af.read_text());prev_a=chain[-1];chain.append(word_patch.apply_lowfour(prev_a,apatch));steps.append('alias637');na=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a['B'],na['B'])==apatch['declared_gate_edit'] and sorted(set(na['removed'])-set(prev_a['removed']))==[637] and len(na['warps'])==len(prev_a['warps'])+1 and na['restore']==prev_a['restore'] and na['A']==prev_a['A'] + af2=D/'inputs'/f'alias656_43{wt}.json';apatch2=None + if af2.exists(): # alias 656 borrowing lender 88 (PR2436 type) stacked on the fifth alias + apatch2=json.loads(af2.read_text());prev_a2=chain[-1];chain.append(word_patch.apply_lowfour(prev_a2,apatch2));steps.append('alias656');na2=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a2['B'],na2['B'])==apatch2['declared_gate_edit'] and sorted(set(na2['removed'])-set(prev_a2['removed']))==[656] and len(na2['warps'])==len(prev_a2['warps'])+1 and na2['restore']==prev_a2['restore'] and True + af3=D/'inputs'/f'alias8_43{wt}.json';apatch3=None + if af3.exists(): # eight source-partner aliases (PR2530) (PR2530 zxv: eight source-partner aliases) + apatch3=json.loads(af3.read_text());prev_a3=chain[-1];chain.append(word_patch.apply_lowfour(prev_a3,apatch3));steps.append('alias8');na3=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a3['B'],na3['B'])==apatch3['declared_gate_edit'] and sorted(set(na3['removed'])-set(prev_a3['removed']))==apatch3['removed_added'] and len(na3['warps'])==len(prev_a3['warps'])+8 and True and True + pf=D/'inputs'/f'prelife_43{wt}.json';ppatch=None + if pf.exists(): # pre-life hosting (this package): six cold width-4 hosts h each host the whole life of a width-9 dim-0-start helper L after retiring + ppatch=json.loads(pf.read_text());prev_p=chain[-1];chain.append(word_patch.apply_prelife(prev_p,ppatch));steps.append('prelife');npl=chain[-1] + PLs=sorted(x_['L'] for x_ in ppatch['pairs']);PHs=[x_['h'] for x_ in ppatch['pairs']] + kok&=PLs==[482,483,494,495,507,519] and sorted(set(npl['removed'])-set(prev_p['removed']))==PLs and set(prev_p['removed'])<=set(npl['removed']) + kok&=sorted(set(prev_p['helper_final'])-set(npl['helper_final']))==sorted(map(str,PHs)) and all(npl['helper_final'][k_]==prev_p['helper_final'][k_] for k_ in npl['helper_final']) + kok&=npl['warps'][:len(prev_p['warps'])]==prev_p['warps'] and [x_[1] for x_ in npl['warps'][len(prev_p['warps']):]]==PHs + kok&=npl['compensation']==[e_ for e_ in prev_p['compensation'] if not(e_[0]=='add' and e_[2] in set(PLs))] # the hosted helpers' dirt-compensation reads are removed ... + kok&=all(c_ in prev_p['initial_corrections'] or (c_['source'] in set(PHs) and len(c_['operator_word'])==1 and npl['warps'][c_['operator_word'][0]-1][1]==c_['source']) for c_ in npl['initial_corrections']) # ... and replaced by anticipatory corrections through the host's warp + kok&=word_patch.kernel_gate_edit(prev_p['B'],npl['B'])==ppatch['declared_gate_edit'] + kok&=all(npl[k_]==prev_p[k_] for k_ in ('A','precondition','cut','start_extra','target_levels','centers','center_frames','ports','prelude_events')) + rf2=D/'inputs'/f'refit563_43{wt}.json';rpatch2=None + if rf2.exists(): # one-gate exact frame lowering (B 894, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) + rpatch2=json.loads(rf2.read_text());prev_r=chain[-1];chain.append(refit_apply(prev_r,rpatch2));steps.append('refit563');nr=chain[-1] + kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',894] and prev_r['B'][894][:5]==['add',515,563,1,1] + kok&=len(nr['B'][894][-1])==len(prev_r['B'][894][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=894) + kok&=not({515,563}&({x_['L'] for x_ in ppatch['pairs']}|{x_['h'] for x_ in ppatch['pairs']}) if ppatch else set()) + xf=D/'inputs'/f'alias1_43{wt}.json';xpatch=None + if xf.exists(): # retired-lender alias 653<-563 on the refit state (this package) + xpatch=json.loads(xf.read_text());prev_x=chain[-1];chain.append(word_patch.apply_lowfour(prev_x,xpatch));steps.append('alias1');nx=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_x['B'],nx['B'])==xpatch['declared_gate_edit'] and sorted(set(nx['removed'])-set(prev_x['removed']))==[653] and len(nx['warps'])==len(prev_x['warps'])+1 and nx['A']==prev_x['A'] and nx['restore']==prev_x['restore'] + kok&=all(g_[0]=='add' and 563 in g_[1:3] for kd_,_,g_ in xpatch['declared_gate_edit'] if kd_=='insert') and nx['warps'][-1][1]==563 + # exhaustive enumeration of retired-lender aliases (borrow/alias_enumerate.py): on the pre-life + refit563 state exactly one pair (653<-563) exists; none on the shipped word + import alias_enumerate as AE,tempfile as tf_ + def enum_(w_): + p_=Path(tf_.mkdtemp())/'w.json.gz';p_.write_bytes(gzip.compress(json.dumps(w_,separators=(',',':')).encode(),mtime=0));o_,s_=AE.main(str(p_));return o_,dict(s_) + e0,s0=enum_(prev_x);e1,s1=enum_(nx) + kok&=[(x_['h'],x_['L']) for x_ in e0]==[(653,563)] and len(e1)==0 + (RCP/f'ALIAS-ENUMERATION-43{wt}.json').write_text(json.dumps(dict(prelife_refit_state=dict(counts=s0,pairs=[{k_:x_[k_] for k_ in('h','L','p1','d','s','f1','width','dprof')} for x_ in e0]),shipped=dict(counts=s1,pairs=len(e1)), + note='counts: h_used_in_A_or_early = helpers first used before B (needs the prelude/lifted-target mechanism); the other counts are (h,L) pairs failing that condition'),indent=1)+'\n') + tf_=D/'inputs'/f'twelve_43{wt}.json';tpatch=None + if tf_.exists(): # PR2751's twelve-alias reassignment with the frame re-solve of the final word (this package); no phase-B warps + tpatch=json.loads(tf_.read_text());prev_t=chain[-1];chain.append(word_patch.apply_lowfour(prev_t,tpatch));steps.append('twelve');nt_=chain[-1] + pre_t_path=Path(tempfile.mkdtemp())/'pre-twelve.json.gz';pre_t_path.write_bytes(gzip.compress(json.dumps(prev_t,separators=(',',':')).encode(),mtime=0)) # earlier-stage controls run on the state they were written for + kok&=word_patch.kernel_gate_edit(prev_t['B'],nt_['B'])==tpatch['declared_gate_edit'] + kok&=nt_['report']['width_inventory']==prev_t['report']['width_inventory'] and not any(e_[0]=='warp' for e_ in nt_['B']) + r7f_=D/'inputs'/f'retired7_43{wt}.json';r7patch=None + if r7f_.exists(): # PR2802's seven retired-lender aliases and two hostee moves, one declared patch on the twelve state (this package) + r7patch=json.loads(r7f_.read_text());prev_7=chain[-1];chain.append(word_patch.apply_lowfour(prev_7,r7patch));steps.append('retired7');n7_=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_7['B'],n7_['B'])==r7patch['declared_gate_edit'] and not any(e_[0]=='warp' for e_ in n7_['B']) + kok&=n7_['target_levels']==prev_7['target_levels'] and n7_['prelude_events']==prev_7['prelude_events'] and n7_['centers']==prev_7['centers'] + def_=D/'inputs'/f'dirtentry_43{wt}.json';depatch=None + if def_.exists(): # dirt-entry rewrite of helpers 530/542 (this package): four inserted entry gates, the listed compensation gates removed, entry frames [30] + depatch=json.loads(def_.read_text());prev_d=chain[-1];chain.append(word_patch.apply_lowfour(prev_d,depatch));steps.append('dirtentry');nd_=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_d['B'],nd_['B'])==depatch['declared_gate_edit'] and not any(e_[0]=='warp' for e_ in nd_['B']) + kok&=[g_ for g_ in prev_d['compensation'] if g_ not in nd_['compensation']]==depatch['declared_compensation_removed'] and all(g_ in prev_d['compensation'] for g_ in nd_['compensation']) + kok&=len(prev_d['compensation'])-len(nd_['compensation'])==len(depatch['declared_compensation_removed']) and nd_['helper_final']==prev_d['helper_final'] and nd_['target_levels']==prev_d['target_levels'] + # Four disjoint staged compensation kernels, after the complete pinned + # PR2833 derivation. Every previous state stays in the audit chain. + sf_=D/'inputs'/f'shared_kernel_43{wt}.json' + if sf_.exists(): + import shared_kernel + shared_patch=json.loads(sf_.read_text());previous_shared=chain[-1] + canonical=lambda z:hashlib.sha256(json.dumps(z,sort_keys=True,separators=(',',':')).encode()).hexdigest() + assert shared_patch['groups']==[478,460,462,480] + assert canonical(previous_shared)==shared_patch['source_canonical_sha256'] + shared_word,shared_ledger=shared_kernel.apply(previous_shared,shared_patch['groups']) + assert canonical(shared_word)==shared_patch['candidate_canonical_sha256'] + assert json.loads(json.dumps(shared_ledger))==shared_patch['ledger'] + assert set(k_ for k_ in previous_shared if previous_shared[k_]!=shared_word[k_])=={'A','compensation','start_extra','report','cleanup'} + stripped_shared=json.loads(json.dumps(shared_word));stripped_shared['A']=stripped_shared['A'][stripped_shared['prelude_events']:] + assert shared_word['cleanup']==word_patch.derive_cleanup(stripped_shared,word_patch.restored_of(shared_word)) + chain.append(shared_word);steps.append('shared-four-kernel') + final=json.loads(gzip.decompress(shipped.read_bytes())) + same=final==chain[-1] + # lifted-target offsets: the shipped word's set (and frames) must equal the one declared by the last patch input that declares target_levels + _tl_decl=None + for _pn in ('lpatch','apatch','apatch2','apatch3','tpatch'): + _pv=locals().get(_pn) + if _pv and 'target_levels' in _pv.get('fields',{}):_tl_decl=_pv['fields']['target_levels'] + tl_ok=lambda w_:_tl_decl is not None and w_['target_levels']==_tl_decl + kok&=tl_ok(final) + # audits: the pinned pre-refit/pre-kernel word against the canonical base; every later state independently (forward + dual free-algebra replay; refit and kernel change frames inside the pinned sections) + tag=lambda n:RCP/f'AUDIT-43{wt}{n}.json' + pw=Path(tempfile.mkdtemp());ps=[] + for j,w_ in enumerate(chain[:-1]): + f_=pw/f'w{j}.json.gz';f_.write_bytes(gzip.compress(json.dumps(w_,separators=(',',':')).encode())) + r=run_audit(f_,base if j==0 else None,tag('-pinned' if j==0 else '-prekernel'));ps.append(r.returncode) + r=run_audit(shipped,None,tag('')) + ok&=same and kok and all(x==0 for x in ps) and r.returncode==0 + res=dict(rebuild_plus_patches_equals_shipped=same,patches=steps,kernel_edit_exact=kok,prior_state_audit_rc=ps,audit_rc=r.returncode) + if '--no-controls' not in sys.argv: + import copy as cp9 + _m1=cp9.deepcopy(final);_m1['target_levels'].pop(sorted(_m1['target_levels'],key=int)[0]);_m2=cp9.deepcopy(final);_m2['target_levels'][str(next(t_ for t_ in range(112) if str(t_) not in final['target_levels']))]=next(iter(final['target_levels'].values()));_m3=cp9.deepcopy(final);_m3['target_levels'][sorted(_m3['target_levels'],key=int)[0]]=[999] + res['target_offsets_declared']=tl_ok(final);res['target_offset_missing_rejected']=not tl_ok(_m1);res['target_offset_extra_rejected']=not tl_ok(_m2);res['target_offset_changed_rejected']=not tl_ok(_m3) + ok&=res['target_offsets_declared'] and res['target_offset_missing_rejected'] and res['target_offset_extra_rejected'] and res['target_offset_changed_rejected'] + print('TARGET-OFFSETS',wt,'declared by patch input',len(_tl_decl),'missing/extra/changed rejected',res['target_offset_missing_rejected'],res['target_offset_extra_rejected'],res['target_offset_changed_rejected'],flush=True) + c=subprocess.run([sys.executable,'-B',str(D/'borrow_controls.py'),str(tmp),base,str(RCP/f'CONTROLS-43{wt}.json')],capture_output=True,text=True) + ok&=c.returncode==0;res['controls_rc']=c.returncode + if lpatch: + lc=subprocess.run([sys.executable,'-B',str(D/'lowfour_controls.py'),str(pre_t_path if tpatch else shipped),str(RCP/f'CONTROLS-LOWFOUR-43{wt}.json')],capture_output=True,text=True) + ok&=lc.returncode==0;res['lowfour_controls_rc']=lc.returncode + if ppatch: + pw_=Path(tempfile.mkdtemp())/'orig.json.gz';pw_.write_bytes(gzip.compress(json.dumps(prev_p,separators=(',',':')).encode(),mtime=0)) + pc=subprocess.run([sys.executable,'-B',str(D/'prelife_controls.py'),str(shipped),str(pw_),str(RCP/f'CONTROLS-PRELIFE-43{wt}.json')],capture_output=True,text=True) + pc_ok=pc.returncode==0 and json.loads((RCP/f'CONTROLS-PRELIFE-43{wt}.json').read_text())['all_rejected_for_expected_reason'];ok&=pc_ok;res['prelife_controls_ok']=pc_ok + if rpatch2: # control: the shipped word with the B 894 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) + import copy as cp6 + m=cp6.deepcopy(prev_t if tpatch else final);m['B'][894][-1]=prev_r['B'][894][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) + br=run_audit(bp,None,bp.parent/'refit563_undone.out.json');ru=br.returncode!=0 and 'warp frame mismatch' in (br.stdout+br.stderr);res['refit563_undone_rejected_by_warp_frame_mismatch']=ru;ok&=ru + if xpatch: + xc=subprocess.run([sys.executable,'-B',str(D/'alias1_controls.py'),str(pre_t_path if tpatch else shipped),str(xf),str(RCP/f'CONTROLS-ALIAS1-43{wt}.json')],capture_output=True,text=True) + ok&=xc.returncode==0;res['alias1_controls_rc']=xc.returncode + okc=[] + def stage_controls(state,patch,pre): # tamper controls on the gates changed by a declared stage; each mutant carries the cleanup re-derived from its own forward word + import copy as cp7 + _ins=[i_ for i_,e_ in enumerate(state['B']) if e_[0]=='add' and any(k_=='insert' and g_==e_[:-1] for k_,_,g_ in patch['declared_gate_edit'])] + def _rd7(m): + t_=cp7.deepcopy(m);t_['A']=m['A'][m['prelude_events']:];m['cleanup']=word_patch.derive_cleanup(t_,{int(q_) for q_ in m['helper_final']});return m + def _mk7(f_): + m=cp7.deepcopy(state);f_(m);return _rd7(m) + for _nm7,_mut7 in ((pre+'_gate_sign_flipped',lambda m:m['B'][_ins[0]].__setitem__(3,-m['B'][_ins[0]][3])), + (pre+'_gate_coefficient_doubled',lambda m:m['B'][_ins[0]].__setitem__(3,2*m['B'][_ins[0]][3])), + (pre+'_gate_dropped',lambda m:m['B'].pop(_ins[0])), + (pre+'_warp_dropped',lambda m:m['warps'].pop(0)), + (pre+'_target_frame_changed',lambda m:m['target_levels'].__setitem__(sorted(m['target_levels'],key=int)[0],[30]))): + m=_mk7(_mut7);bp=pw/(_nm7+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(_nm7+'.out.json'));res[_nm7+'_rejected']=br.returncode!=0;okc.append(br.returncode!=0) + print(pre.upper()+'-CONTROLS',wt,{k_:v_ for k_,v_ in res.items() if k_.startswith(pre+'_')},flush=True) + if tpatch:stage_controls(nt_,tpatch,'twelve') + if r7patch:stage_controls(n7_,r7patch,'retired7') + if depatch: + import copy as cp3 + def _rdd(m): + t_=cp3.deepcopy(m);t_['A']=m['A'][m['prelude_events']:];m['cleanup']=word_patch.derive_cleanup(t_,{int(q_) for q_ in m['helper_final']});return m + _ins=[i_ for i_,e_ in enumerate(final['B']) if e_[0]=='add' and any(k_=='insert' and g_==e_[:-1] for k_,_,g_ in depatch['declared_gate_edit'])] + def _mkd(f_): + m=cp3.deepcopy(final);f_(m);return _rdd(m) + def _bad(m): + return m + for _nmd,_mutd in (('dirtentry_injection_dropped',lambda m:m['B'].pop(_ins[0])), + ('dirtentry_injection_sign_flipped',lambda m:m['B'][_ins[0]].__setitem__(3,-m['B'][_ins[0]][3])), + ('dirtentry_injection_wrong_time',lambda m:(lambda g_,r_:m['B'].insert(max(i_ for i_,e_ in enumerate(m['B']) if e_[0]=='add' and r_ in e_[1:3])+1,m['B'].pop(_ins[0])))(m['B'][_ins[0]],m['B'][_ins[0]][2])), + ('dirtentry_removal_missing',lambda m:m['compensation'].append(cp3.deepcopy(depatch['declared_compensation_removed'][0])))): + m=_mkd(_mutd);bp=pw/(_nmd+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(_nmd+'.out.json'));res[_nmd+'_rejected']=br.returncode!=0;okc.append(br.returncode!=0) + print('DIRTENTRY-CONTROLS',wt,{k_:v_ for k_,v_ in res.items() if k_.startswith('dirtentry_')},flush=True) + ok&=all(okc) + kc_ok,kc=kernel_controls(kstate,kpatch,tempfile.mkdtemp());ok&=kc_ok;res['kernel_controls_rejected']=kc + if apatch: + import copy as cp4 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias637_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias637_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias637_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp4.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if apatch2: + import copy as cp5 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a2['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias656_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias656_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias656_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp5.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if apatch3: + import copy as cp6 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a3['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias8_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias8_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias8_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp6.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if ef.exists(): + import copy as cp3 + q=next(iter(epatch['fields']['start_extra'])); + for nm_,mut in (('entrance_start_frame_dropped',lambda m:m['start_extra'].__setitem__(q,[])),('entrance_start_frame_widened',lambda m:m['start_extra'].__setitem__(q,[1<0 + ok&=not gv and res['cut_centre_guard_negative_control_rejected'] + print('CUT-CENTRE-GUARD',wt,'cut gates',len(final['cut']),'violations',len(gv),'negative control rejected',res['cut_centre_guard_negative_control_rejected'],flush=True) + # HELPER-INDEX GUARD (PR2508, ywz65): audit_local accepts a negative helper_final key that aliases a target endpoint; every helper_final key must be a canonical non-negative decimal inside the helper interval [2v, 2v+R). + import guard_helper_indices as ghi + hv=ghi.violations(final);hbad=json.loads(json.dumps(final));hbad['helper_final']['-1']=hbad['helper_final'].get('-1',list(next(iter(hbad['helper_final'].values())))) + res['helper_index_guard_violations']=len(hv);res['helper_index_guard_negative_control_rejected']=len(ghi.violations(hbad))>0 + ok&=not hv and res['helper_index_guard_negative_control_rejected'] + print('HELPER-INDEX-GUARD',wt,'helper_final keys',len(final['helper_final']),'violations',len(hv),'negative control (key -1) rejected',res['helper_index_guard_negative_control_rejected'],flush=True) + # ENTRANCE-WIDTH BINDING (answers whether the hosted helpers are delivered at the raised entrance frames): the per-helper residual width |final|-|start_extra| of THIS word must equal the ordered widths of new/BORROW-PROVIDERS.json, + # which are the widths reconstruct.py/emit/audit_allcold use for every hosted role (audit: 'wrong per-call residual width', 'entering helper width silently restored to nine'); bind_providers_portable.py re-derives them from the native canonical word. + prov_w=json.loads((D.parent/'BORROW-PROVIDERS.json').read_text())['gauge44' if wt=='base' else 'extra']['widths'] + def word_widths(w_): + rem=[r_ for r_ in range(224,704) if r_ not in set(w_['removed'])];se_={int(k_):v_ for k_,v_ in w_['start_extra'].items()};hf_={int(k_):v_ for k_,v_ in w_['helper_final'].items()} + return [len(hf_.get(r_,range(9)))-len(se_.get(r_,[])) for r_ in rem] + bind_ok=word_widths(final)==prov_w + tw=json.loads(json.dumps(final));raised=[int(k_) for k_,v_ in tw['start_extra'].items() if len(v_)==2] + if raised:tw['start_extra'][str(raised[0])]=tw['start_extra'][str(raised[0])][:1] # a raised copy buffer delivered at dim 1 again + tamper_rejected=bool(raised) and word_widths(tw)!=prov_w + res['entrance_widths_bound_to_providers']=bind_ok;res['dim1_delivery_rejected']=tamper_rejected;res['raised_buffers']=len(raised) + ok&=bind_ok and (tamper_rejected or not raised) + print('ENTRANCE-WIDTH-BINDING',wt,'raised',len(raised),'bound',bind_ok,'dim1 tamper rejected',tamper_rejected,flush=True) + out[canon]=res;print(canon,res,flush=True) +print('PASS_REBUILD_BORROW' if ok else 'FAIL_REBUILD_BORROW');sys.exit(0 if ok else 1) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/verify.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/verify.py new file mode 100644 index 0000000000..407e57fbb8 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/new/source/verify.py @@ -0,0 +1,140 @@ +"""Portable finite admission. Fresh native suppliers by default; explicit bound reuse supported.""" +import argparse,gzip,hashlib,json,os,shutil,subprocess,sys,tarfile,threading,time +from pathlib import Path +P=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--work',type=Path,required=True);ap.add_argument('--base-native-from',type=Path);ap.add_argument('--extra-native-from',type=Path);ap.add_argument('--parent-receipt-cache',type=Path);ap.add_argument('--new-base-native-from',type=Path);ap.add_argument('--new-extra-native-from',type=Path);ap.add_argument('--native-cache',type=Path);ap.add_argument('--audit-shards',type=int,default=4);ap.add_argument('--reference-native',action='store_true');a=ap.parse_args();work=a.work.resolve();assert __debug__ and not work.exists() and not work.is_relative_to(P) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +pins=rd(P/'MANIFEST.json');actual={p.relative_to(P).as_posix() for p in P.rglob('*') if p.is_file() and p!=P/'MANIFEST.json'};assert actual==set(pins) +for rel,h in pins.items():assert sha(P/rel)==h,rel +work.mkdir();(work/'tmp').mkdir();env=dict(os.environ,TMPDIR=str(work/'tmp'),PYTHONDONTWRITEBYTECODE='1',PYTHONPYCACHEPREFIX=str(work/'pycache-prefix'),PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') +for k in ('PYTHONOPTIMIZE','WITNESS_DISCOVER','WITNESS_RECORD','WITNESS_SPEC'):env.pop(k,None) +env['AUDIT_FAST_SHARDS']=str(max(1,a.audit_shards)) +stages=[];lock=threading.Lock() +def run(name,script,*args): + t=time.monotonic();log=work/(name+'.log') + with log.open('w') as f:r=subprocess.run([sys.executable,'-B',str(script),*map(str,args)],cwd=work,env=env,stdout=f,stderr=subprocess.STDOUT) + with lock:stages.append(dict(name=name,exit_code=r.returncode,seconds=time.monotonic()-t,log_sha256=sha(log)));(work/'STAGES.json').write_text(json.dumps(stages,indent=2)) + assert r.returncode==0,(name,log.read_text()[-5000:]);print('PASS',name,flush=True) +old=P/'vendor/pr1297' +# The pinned input witness must be the exact retained predecessor, not merely a similar profile. +for n in ['PLAN.json','OWNERS.json.gz','GLOBAL-TEMPLATE.json.gz','DISPATCH.json','SPEC.json']:assert rd(P/'inputs'/n)==rd(old/n),n +env['FINE_ENGINE_CACHE']=str(work/'fine-cache') +env['BORROW_RECEIPTS']=str(work/'borrow-receipts') # receipts carry timings: written to the work directory, never into the package +run('fine-engine-oracle',P/'code/oracle_check.py') +opts=[] +for key,path in [('base',a.base_native_from),('extra',a.extra_native_from)]: + if path:opts.extend(['--'+key+'-native-from',path.resolve()]) +PARENT_STATUS='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' +def retained_files_ok(): + # the retained package must be byte-for-byte the one every receipt below is bound to (same check as its own verify.py) + vm=rd(old/'MANIFEST.json');have={p.relative_to(old).as_posix() for p in old.rglob('*') if p.is_file() and '__pycache__' not in p.parts and p!=old/'MANIFEST.json'} + assert have==set(vm),'retained package file set differs from its manifest' + for rel,h in vm.items():assert sha(old/rel)==h,rel +def natives_bound(path,word): + assert gzip.decompress((path/'local/FULL-WORD.json.gz').read_bytes())==gzip.decompress((old/word).read_bytes()),word + st=rd(path/'STEPS.json');assert [x['step'] for x in st]==['native','ledgers','local-replay','wrappers','phases'] and all(x['exit_code']==0 for x in st) +rc=None;receipt=None +if a.parent_receipt_cache and a.base_native_from and a.extra_native_from: + retained_files_ok();rc=a.parent_receipt_cache.resolve()/sha(old/'MANIFEST.json') + if (rc/'RECEIPT.json').is_file(): + receipt=rd(rc/'RECEIPT.json') + try: + assert receipt['schema']=='parent-receipt/1' and receipt['vendor_manifest_sha256']==sha(old/'MANIFEST.json') + assert receipt['claim_sha256']==sha(old/'CLAIM.json') and receipt['words']=={'base':sha(old/'gauge44-word.json.gz'),'extra':sha(old/'extra-word.json.gz')} + for name,h in receipt['files'].items():assert sha(rc/name)==h,name + pr=rd(rc/'RESULT.json');assert pr['status']==PARENT_STATUS and pr['kappa']==rd(old/'CLAIM.json')['kappa'] and pr['base_native_reuse'] is True and pr['extra_native_reuse'] is True + natives_bound(a.base_native_from.resolve(),'gauge44-word.json.gz');natives_bound(a.extra_native_from.resolve(),'extra-word.json.gz') + except (AssertionError,KeyError,OSError,ValueError) as exc: + print('parent receipt rejected (%r); running the full retained admission'%(exc,),flush=True);receipt=None +if receipt: + t0=time.monotonic();pl=work/'parent';pl.mkdir();lay=pl/'layout';lay.mkdir() + with tarfile.open(old/'upstream-layout.tar.gz') as t: + for m in t.getmembers():assert m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + t.extractall(lay,filter='data') + (lay/'globalmix51').mkdir();shutil.copytree(a.extra_native_from.resolve(),lay/'globalmix51/native-extra') + with lock:stages.append(dict(name='retained-provider-and-parent-admission',reused_receipt=str(rc.name),exit_code=0,seconds=time.monotonic()-t0));(work/'STAGES.json').write_text(json.dumps(stages,indent=2)) + print('PASS retained-provider-and-parent-admission (hash-checked receipt)',flush=True) +else: + run('retained-provider-and-parent-admission',old/'verify.py','--work',work/'parent',*opts) + pr=rd(work/'parent/RESULT.json');assert pr['status']==PARENT_STATUS and pr['kappa']==rd(old/'CLAIM.json')['kappa'] + if rc is not None and a.base_native_from and a.extra_native_from: + natives_bound(a.base_native_from.resolve(),'gauge44-word.json.gz');natives_bound(a.extra_native_from.resolve(),'extra-word.json.gz') + rc.mkdir(parents=True,exist_ok=True);shutil.copy2(work/'parent/RESULT.json',rc/'RESULT.json');shutil.copy2(work/'parent/STAGES.json',rc/'STAGES.json') + (rc/'RECEIPT.json').write_text(json.dumps(dict(schema='parent-receipt/1',vendor_manifest_sha256=sha(old/'MANIFEST.json'),claim_sha256=sha(old/'CLAIM.json'),words={'base':sha(old/'gauge44-word.json.gz'),'extra':sha(old/'extra-word.json.gz')},files={'RESULT.json':sha(rc/'RESULT.json'),'STAGES.json':sha(rc/'STAGES.json')}),indent=1)+'\n') +pre_words={'base':P/'new/gauge44-word-566.json.gz','extra':P/'new/extra-word-566.json.gz'} +new_words={'base':P/'new/borrow/words/BORROW-WORD-43base.json.gz','extra':P/'new/borrow/words/BORROW-WORD-43extra.json.gz'} +nat={};nat_err=[] +def new_native(key): + try: + w=new_words[key];reuse=getattr(a,'new_%s_native_from'%key);d=None;ws=sha(w) + def tree(e):return {x.relative_to(e).as_posix():sha(x) for x in sorted(e.rglob('*')) if x.is_file() and x.name!='CACHE.json'} + if reuse:d=reuse.resolve() + elif a.native_cache: + e=a.native_cache.resolve()/ws + if (e/'CACHE.json').is_file(): + cj=rd(e/'CACHE.json') + if cj.get('word_sha256')==ws and cj.get('files')==tree(e):d=e + if d is None: + if a.reference_native: + d=work/('native-new-'+key);run('native-new-'+key,P/'new/run_native_borrow.py',w,d) + else: # PR2768 (tekuuu): the same five-stage native replay with the exact sparse Clifford evaluator (unchanged independent warp checks and controls); same output layout + fw=work/('native-new-'+key+'-fast');run('native-new-'+key,P/'new/fastnative/run_native.py',w,fw);d=fw/'native' + for x_ in d.rglob('*'): # text artifacts are LF on every OS (the pinned PLAN binds their hashes); the vendored scripts write CRLF on Windows + if x_.is_file() and x_.suffix in ('.json','.log','.txt'): + b_=x_.read_bytes() + if b'\r\n' in b_:x_.write_bytes(b_.replace(b'\r\n',b'\n')) + if a.native_cache: + root=a.native_cache.resolve();root.mkdir(parents=True,exist_ok=True);dst=root/ws + if not dst.exists(): + tmp=root/('.tmp-%s-%d'%(ws,os.getpid()));shutil.copytree(d,tmp);(tmp/'CACHE.json').write_text(json.dumps(dict(word_sha256=ws,files=tree(tmp)),indent=1)) + try:tmp.rename(dst) + except OSError:shutil.rmtree(tmp,ignore_errors=True) + assert gzip.decompress((d/'local/FULL-WORD.json.gz').read_bytes())==gzip.decompress(w.read_bytes()),(key,'native directory is not bound to the shipped word') + st_=rd(d/'STEPS.json');assert [x['step'] for x in st_]==['native','ledgers','local-replay','wrappers','phases'] and all(x['exit_code']==0 for x in st_) + nat[key]=d + except BaseException as exc:nat_err.append(exc) +nthreads=[threading.Thread(target=new_native,args=(k,)) for k in new_words] +for t_ in nthreads:t_.start() +def rebuild_chain(): + run('reconstruct-owners',P/'reconstruct.py','--out',work/'rebuilt-owners') + for n in ['OWNERS.json.gz','ORDER.json','DISPATCH.json','PROFILE.json']:assert rd(work/'rebuilt-owners'/n)==rd(P/n),n + run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent') + for n in ['GLOBAL-TEMPLATE.json.gz','PLAN.json','CONSTRUCTION.json']:assert rd(work/'rebuilt-parent'/n)==rd(P/n),n + assert rd(work/'rebuilt-parent/SPEC.json')['geometry']==rd(P/'SPEC.json')['geometry'] +chain_err=[] +def chain_thread(): + try:rebuild_chain() + except BaseException as exc:chain_err.append(exc) +chain=threading.Thread(target=chain_thread);chain.start() +for t_ in nthreads:t_.join() +if nat_err:raise nat_err[0] +SRCL=work/'parent/layout/joint1148-round45/source' +run('rebuild-words-566',P/'new/rebuild_chain.py') +run('rebuild-borrow-words',P/'new/rebuild_borrow.py') +run('shared-kernel-independent-review',P/'new/borrow/shared_kernel_review.py','--source-dir',P/'new/borrow','--source-base',P/'new/borrow/inputs/PR2833-WORD-base.json.gz','--source-extra',P/'new/borrow/inputs/PR2833-WORD-extra.json.gz','--candidate-base',P/'new/borrow/words/BORROW-WORD-43base.json.gz','--candidate-extra',P/'new/borrow/words/BORROW-WORD-43extra.json.gz','--out-dir',work/'shared-kernel-independent-review') +for key_,w_ in pre_words.items():run('audit-local-566-'+key_,SRCL/'research/gauge44-slots/independent/audit_local.py','--word',w_,'--main',SRCL,'--output',work/('AUDIT-LOCAL-566-'+key_+'.json')) +run('rebind-566',P/'new/rebind.py',P,nat['base']/'local',nat['extra']/'local',work/'data-rebound') +run('lemmag-labels',P/'code/lemmag_stage.py',work/'LEMMAG-LABELS.json',nat['base'],nat['extra'],*[p_ for p_ in (a.base_native_from,a.extra_native_from) if p_]) +STABLE=('LOCAL-CHECKS.json','CLIFFORD-RECIPES.json','RESIDUAL-ADAPTERS.json') +def bind_view(plan): + plan=json.loads(json.dumps(plan)) + for desc in plan['provider_registry'].values():desc['artifact_sha256']={n:h for n,h in desc['artifact_sha256'].items() if n in STABLE} + return plan +assert bind_view(rd(work/'data-rebound/PLAN.json'))==bind_view(rd(P/'new/PLAN.json')),'regenerated PLAN differs from new/PLAN.json beyond bind-rebound receipt hashes' +assert rd(work/'data-rebound/PROFILE.json')==rd(P/'new/PROFILE.json') +layout=work/'parent/layout';runtime=layout/'packing74';runtime.mkdir();data=runtime/'candidate';data.mkdir() +for n in ['replay.py','freeze_spec.py','audit_mixed.py','independent_core.py','geometry_controls.py','audit_fast.py']:shutil.copy2(P/n,runtime/n) +for n in ['code','construction']:shutil.copytree(P/n,runtime/n) +(runtime/'inputs').mkdir();shutil.copy2(P/'inputs/PR589-EXPECTED.json',runtime/'inputs/PR589-EXPECTED.json') +for n in ['PLAN.json','SPEC.json','PROFILE.json','OWNERS.json.gz','DISPATCH.json','CONSTRUCTION.json','GLOBAL-TEMPLATE.json.gz']:shutil.copy2((P/'new' if n in ('PLAN.json','SPEC.json','PROFILE.json') else P)/n,data/n) +shutil.copytree(nat['extra'],runtime/'native-extra') +base=nat['base'] +run('strict-t74',runtime/'replay.py','--data',data,'--work',work/'strict','--local',base/'local') +run('geometry-controls',runtime/'geometry_controls.py','--source',layout/'joint1148-round45/source/research/complex-k492-owner-repair/vendor/multicold','--strict',work/'strict','--out',work/'GEOMETRY-CONTROLS.json') +chain.join() +if chain_err:raise chain_err[0] +r=rd(work/'strict/RESULT.json');assert r['status']=='PASS_STRICT_MIXED_T74_EXACT_FILL' and r['kappa']==rd(P/'CLAIM.json')['kappa'];assert len(rd(work/'GEOMETRY-CONTROLS.json')['rejected'])==6 +result=dict(status='PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION',kappa=r['kappa'],kappa_decimal=r['kappa_decimal'],manifest_sha256=sha(P/'MANIFEST.json'),native_reuse=dict(base=bool(a.base_native_from),extra=bool(a.extra_native_from)),provider_verification=pr['status'],roles=r['independent']['roles'],prefix_bits=r['independent']['prefix_bits'],charged_prefix_bits=r['independent']['charged_prefix_bits'],physical_row_coefficient=r['independent']['physical_row_coefficient'],row_limit=r['independent']['row_limit'],controls=dict(admission=114,bit=12,controller=15,independent_owner=8,geometry=6),stages=stages,scope=rd(P/'CLAIM.json')['scope']) +(work/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n');print(result['status'],result['kappa_decimal'],flush=True) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/admit.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/admit.py new file mode 100644 index 0000000000..85e20e52cf --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/admit.py @@ -0,0 +1,401 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a changed-replica literal order/fill derivative. + +PR2833 extension by Yiyang Lu with OpenAI Codex assistance: add the exact +immutable dirt-entry source profile and exact full outer-claim comparisons to +PR2833 and the newer PR2843 T124 allocation. All +inherited native, owner, invoice, block-norm, controls and release checks retained. + +Research runtime only: native providers must already have passed freshly and +are authenticated by --native-receipt. --prepare-only stops before discovery. +Default complete admission preserves the original verify.py and release stages. +Source inputs and the native cache are read-only; all output uses fresh --work. +""" +import argparse +from fractions import Fraction as Q +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import time + +SOURCE_COMMIT = 'local-joint12-refit393' +SOURCE_MANIFEST = '1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb' +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +COMPARISON_SHA = '252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3' +COMPARISON_HEAD = 'e8b771ba132fe632796b28c1742a8d096c04519f' +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +# Supported immutable source versions; CLI selection never accepts arbitrary hashes. +SOURCE_PROFILES = { + 'pr2833': dict(commit='pr2833-dirtentry', manifest='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f', helpers=408, source_file_count=541, upstream_head='e9307b48d7d1b690939935ecef0f8e524e6d92f4'), + 'pr2766': dict(commit='local-joint12-refit393', manifest='1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb', helpers=415, source_file_count=491, upstream_head='e6df920cd0110e4b629e2ad84eddcb539001e174'), + 'pr2802': dict(commit='local-joint12-pr2733', manifest='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451', helpers=408, source_file_count=506, upstream_head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd'), +} +COMPARISONS = { + 'pr2843': dict(pr=2843, head='47a7227c044cd0cabb1432a06c61dd5d60c07f5a', sha256='0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9', field='kappa'), + 'pr2833': dict(pr=2833, head='e9307b48d7d1b690939935ecef0f8e524e6d92f4', sha256='6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70', field='kappa_rational'), + 'pr2767': dict(pr=2767, head='e8b771ba132fe632796b28c1742a8d096c04519f', sha256='252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3', field='kappa_rational'), + 'pr2802': dict(pr=2802, head='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd', sha256='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51', field='kappa'), +} + + + +# Discovery records are shared by parallel mutation-audit processes on Windows. +# Only discovery bookkeeping changes; strict pin comparison below it is untouched. +DISCOVERY_APPEND_OLD = " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))" +DISCOVERY_APPEND_NEW = r''' import time as _wr_time + _wr_path=Path(os.environ['WITNESS_RECORD']) + _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock') + _wr_deadline=_wr_time.monotonic()+60 + _wr_fd=None + while _wr_fd is None: + try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + except FileExistsError: + if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved') + _wr_time.sleep(.005) + try: + with _wr_path.open('a',encoding='utf-8',newline='\n')as _wr_out: + _wr_out.write(json.dumps([key,got],default=str)+chr(10)) + _wr_out.flush() + finally: + os.close(_wr_fd) + _wr_lock.unlink()''' + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + body = path.read_bytes() + return json.loads(gzip.decompress(body) if path.suffix == '.gz' else body) + + +def write(path, value): + # All output targets belong to this fresh work tree; never unlink an open lock. + lock = path.with_name(path.name + '.lock') + descriptor = os.open(lock, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + try: + os.write(descriptor, str(os.getpid()).encode()) + os.close(descriptor) + descriptor = None + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', encoding='utf-8', newline='\n') + finally: + if descriptor is not None: + os.close(descriptor) + lock.unlink() + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unbound symlink: ' + str(path)) + name = path.relative_to(root).as_posix() + if path.is_file() and name not in exclude: + result[name] = sha(path) + return result + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + for name in ('source', 'fill', 'order', 'dispatch', 'native-cache', 'native-receipt', 'work', 'replica-helper-dir', 'reconstructor', 'comparison-claim', 'blocknorm-checker'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + ap.add_argument('--source-profile', choices=sorted(SOURCE_PROFILES), default='pr2833') + ap.add_argument('--comparison-profile', choices=sorted(COMPARISONS), default='pr2843') + a = ap.parse_args() + global SOURCE_COMMIT, SOURCE_MANIFEST, COMPARISON_SHA, COMPARISON_HEAD + source_profile = SOURCE_PROFILES[a.source_profile] + comparison = COMPARISONS[a.comparison_profile] + SOURCE_COMMIT, SOURCE_MANIFEST = source_profile['commit'], source_profile['manifest'] + COMPARISON_SHA, COMPARISON_HEAD = comparison['sha256'], comparison['head'] + expected_helpers, comparison_pr = source_profile['helpers'], comparison['pr'] + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + source, cache, work = a.source.resolve(), a.native_cache.resolve(), a.work.resolve() + need(not work.exists() and not work.is_relative_to(source) and not work.is_relative_to(cache), + 'fresh external work required') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') + need(len(source_files) == source_profile['source_file_count'] and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + helper_dir = a.replica_helper_dir.resolve() + helper_paths = [helper_dir / n for n in ('lift_parent.py', 'replica_parent.py')] + [a.reconstructor.resolve()] + external_hashes = {str(p): sha(p) for p in helper_paths + [a.fill.resolve(), a.order.resolve(), a.dispatch.resolve(), a.comparison_claim.resolve(), a.blocknorm_checker.resolve()]} + need(sha(a.comparison_claim) == COMPARISON_SHA, 'exact pinned frontier headline comparison') + comparison_claim = read(a.comparison_claim) + need('headline_kappa_source' not in comparison_claim and comparison['field'] in comparison_claim, + 'comparison must be full headline outer claim, not supplier-only CLAIM') + previous = Q(comparison_claim[comparison['field']]) + need(previous == Q(comparison_claim['kappa']), 'comparison rational/decimal equality') + order_input = read(a.order) + need(order_input and all(isinstance(x,list) and len(x)==2 and all(type(v)is int for v in x) for x in order_input), 'literal integer call order') + T = 1 + max(r for st,r in order_input) + need(T > 0 and len(order_input)==9*T and set(map(tuple,order_input))=={(st,r) for st in range(9) for r in range(T)}, 'complete new replica coverage') + need(all([st for st,r in order_input if r==rep]==list(range(9)) for rep in range(T)), 'source stage projection') + dispatch_input = read(a.dispatch) + need(len(dispatch_input)==9*T and {(st,r) for st,r,pid in dispatch_input}==set(map(tuple,order_input)), 'complete explicit dispatch') + native_receipt = read(a.native_receipt) + need(native_receipt['status'] == 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' + and native_receipt['source_commit'] == SOURCE_COMMIT + and native_receipt['manifest_sha256'] == SOURCE_MANIFEST, 'native receipt source binding') + need(tree(cache) == native_receipt['cache_files'], 'complete native/parent cache hashes') + old = source / 'vendor/pr1297' + need(sha(old / 'MANIFEST.json') == PARENT_MANIFEST, 'retained parent pin') + parent_receipt = cache / '_receipts' / PARENT_MANIFEST / 'RECEIPT.json' + need(sha(parent_receipt) == native_receipt['retained_parent_receipt_sha256'], 'parent receipt pin') + pr = read(parent_receipt) + need(pr['vendor_manifest_sha256'] == PARENT_MANIFEST and pr['claim_sha256'] == sha(old / 'CLAIM.json'), + 'parent receipt claim binding') + for name, digest in pr['files'].items(): + need(sha(parent_receipt.parent / name) == digest, 'parent receipt file') + parent_result = read(parent_receipt.parent / 'RESULT.json') + need(parent_result['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent_result['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent completed admission') + natives = {} + for tag in ('base', 'extra'): + word = source / ('new/borrow/words/BORROW-WORD-43' + tag + '.json.gz') + entry = cache / sha(word) + binding = native_receipt['providers'][tag] + need(binding['word_sha256'] == sha(word) + and tree(entry, ('CACHE.json',)) == binding['complete_native_files'], 'native full-tree binding') + need(read(entry / 'local/FULL-WORD.json.gz') == read(word), 'native complete word') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == NATIVE_STAGES and all(s['exit_code'] == 0 for s in stages), + 'native five-stage coverage') + checks = read(entry / 'local/LOCAL-CHECKS.json') + need(all(checks[o]['paid_profile'] == read(word)['report']['local_profile'] for o in ('forward', 'backward')), + 'native actual paid profiles') + natives[tag] = entry + work.mkdir(parents=True) + package = work / 'package' + shutil.copytree(source, package) + # Only the fresh external clone changes. Immutable source/cache inventories remain pinned. + for hp in helper_paths[:2]: + shutil.copy2(hp, package / hp.name) + need(sha(package / hp.name)==external_hashes[str(hp)], 'helper copy hash') + shutil.copy2(a.blocknorm_checker, package / 'blocknorm_certificate.py') + shutil.copy2(a.blocknorm_checker, package / 'code/blocknorm_certificate.py') + need(sha(package / 'blocknorm_certificate.py') == external_hashes[str(a.blocknorm_checker.resolve())], 'block-norm checker exact source binding') + shutil.copy2(a.reconstructor, package / 'reconstruct.py') + need(sha(package / 'reconstruct.py')==external_hashes[str(a.reconstructor.resolve())], 'reconstructor copy hash') + # The original subprocesses also write generated hash-bound source. Windows + # callers use a process-scoped LF adapter; no system configuration is changed. + lf_probe = work / '.lf-preflight.txt' + lf_probe.write_text('LF\n', encoding='utf-8') + need(lf_probe.read_bytes()==b'LF\n', 'process-scoped LF output required on Windows') + lf_probe.unlink() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', AUDIT_FAST_SHARDS=str(a.jobs)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, patches = [], [] + + def run(name, script, *args): + start = time.monotonic() + command = [sys.executable, '-B', str(script), *map(str, args)] + log = work / (name + '.log') + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + stages.append(dict(name=name, exit_code=result.returncode, seconds=time.monotonic() - start, + script_sha256=sha(script), log_sha256=sha(log), command=command)) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + def patch(name, replacements): + path = package / name + before = sha(path) + body = path.read_text() + for old_text, new_text in replacements: + need(body.count(old_text) == 1, 'exact patch preimage: ' + name + ': ' + old_text[:80]) + body = body.replace(old_text, new_text) + path.write_text(body) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), replacements=replacements)) + + # PR2530's already checked correction: restored zero buffers occupy physical + # rows. COMPOSED's shipped SPEC includes them; its rebound SPEC omitted them. + patch('new/rebind.py', [ + ("physical=spec['expected']['live'] + 8 + R + 2)", + "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))")]) + # Preserve the exact fixed-grid-maximum equality while deriving precision + # from the same SPEC read by both independent outer arithmetic checkers. + patch('verify_release.py', [ + ('Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)', + "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"), + ('epsilon=1-(1025/1024)e-3080', "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"), + ('at the one 3000-digit rejection call', "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call")]) + # Keep the native dimension and paid moment ledger fixed; bind replica + # width to both the checked source geometry and the independent B invoice. + patch('outer/check_ledger.py', [ + ('assert (m,W)==(73,66304)', + "T=spec['geometry']['replicas']\nassert type(T) is int and T>0\nassert m==73 and W==896*T and W==BJ['live']")]) + patch('code/witness.py', [(DISCOVERY_APPEND_OLD, DISCOVERY_APPEND_NEW)]) + patch('verify.py', [ + ("run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')")]) + # A sharper local reserve is certified against actual scalar/Horner + # prefixes of BOTH orientations and BOTH providers. All sweep and physical + # row charges remain unchanged; this never omits an invocation or bridge. + patch('code/witness.py', [ + ("PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4")]) + patch('independent_core.py', [ + (" payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()")]) + patch('code/invoice_allcold.py', [ + (" complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm,"), + (" primitive_arithmetic_margin_bits=4,controller_audit_sha256=", " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256="), + ("Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix.")]) + patch('independent_core.py', [ + (" prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4"), + ("prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn")]) + patch('audit_mixed.py', [ + ("pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)")]) + patch('code/assemble.py', [ + (" assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+4 previous, + 'candidate must strictly improve full exact pinned frontier headline before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=COMPARISON_HEAD, baseline_kappa=str(previous), gain=str(kappa-previous), + b='certified complex_lower - 1e-104 (outer/B.json)', + retuned_slacks='Endpoint precision24; free gaps follow outer/check_ledger.py from the frozen SPEC.', + fixed_grid_maximum='kappa=C-10^-70-10^-46 exactly; same fixed-grid-maximum proof at precision24.') + write(package / 'outer/OUTER-CLAIM.json', outer_claim) + (package / 'provenance').mkdir(exist_ok=True) + shutil.copy2(a.comparison_claim, package / ('provenance/PR' + str(comparison_pr) + '-HEADLINE-CLAIM.json')) + write(package / 'MANIFEST.json', tree(package, ('MANIFEST.json',))) + run('release', package / 'verify_release.py', '--main', source.parents[1], '--work', work / 'release', + '--native-cache', cache, '--jobs', a.jobs) + receipt = read(work / 'release/RELEASE-RECEIPT.json') + need(receipt['status'] == 'PASS_RELEASE' and Q(receipt['kappa_decimal']) == kappa + and receipt['manifest_sha256'] == sha(package / 'MANIFEST.json'), 'complete release binding') + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST + and tree(source, ('MANIFEST.json',)) == source_files and tree(cache) == native_receipt['cache_files'], + 'read-only source/cache inputs changed') + need(all(sha(Path(p))==h for p,h in external_hashes.items()), 'external candidate/helper inputs changed during admission') + result.update(status='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE', + complex_lower=str(C), kappa=str(kappa), kappa_decimal=row['decimal'], + gain=str(kappa-previous), release_receipt_sha256=sha(work / 'release/RELEASE-RECEIPT.json'), + package_manifest_sha256=sha(package / 'MANIFEST.json'), stages=stages, + scope='Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.') + write(work / 'RESULT.json', result) + print(result['status'], row['decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/runtime/geometry_controls.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/runtime/geometry_controls.py new file mode 100644 index 0000000000..feb5fda97f --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/runtime/geometry_controls.py @@ -0,0 +1,31 @@ +"""Reject understated T74 prefix, stock and invocation charges using strict assembly.""" +import argparse,copy,hashlib,json,os,sys +from pathlib import Path +assert __debug__ +P=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--strict',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() +sys.path.insert(0,str(P/'code'));os.environ['GAIN_PR564_SOURCE']=str(a.source.resolve());os.environ['WITNESS_SPEC']=str(a.strict/'runtime/data/SPEC.json') +from assemble import assemble +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +digest=lambda v:hashlib.sha256(json.dumps(v,sort_keys=True,separators=(',',':')).encode()).hexdigest() +op=a.strict/'global/audit/OWNERS-AND-PROFILE.json';ip=a.strict/'global/audit/PREFIX-AND-INVOICE.json';owner=json.loads(op.read_text());invoice=json.loads(ip.read_text());assemble(owner,invoice,sha(op),sha(ip)) +def old_prefix(o,i): + i['charged_prefix_bits']=1024;i['row_prefix_extra']=2048;i['finite']['physical_row_coefficient']-=2048 + +def old_call_count(o,i): + i['complete_invocation_sweeps']=i['bridge_sweeps']=333 + +def old_parent_idle(o,i):o['source_idle_children_charged']//=2 + +def old_stock(o,i):i['physical_stock_identity']['data_and_owner_families']//=2 + +def missing_call(o,i):i['selected_calls'].pop() + +def low_row(o,i):i['finite']['physical_row_coefficient']-=1 +rejected=[] +for fn in [old_prefix,old_call_count,old_parent_idle,old_stock,missing_call,low_row]: + o,i=copy.deepcopy(owner),copy.deepcopy(invoice);fn(o,i);oh=digest(o);i['owner_audit_sha256']=oh + try:assemble(o,i,oh,digest(i)) + except AssertionError as e:rejected.append(dict(name=fn.__name__,reason=str(e) or 'strict arithmetic invariant')) + else:raise AssertionError('accepted '+fn.__name__) +a.out.write_text(json.dumps(dict(status='PASS_T74_GEOMETRY_AND_CHARGE_CONTROLS',rejected=rejected),indent=2)+'\n');print('PASS_GEOMETRY_CONTROLS',len(rejected)) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/MANIFEST.json b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/MANIFEST.json new file mode 100644 index 0000000000..1bdfa4cada --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/MANIFEST.json @@ -0,0 +1,543 @@ +{ + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "ADMISSION-DERIVATION.patch": "7021000d75635fc5806af821640c02f9d7cbbbe1cf314dacfcc743fc6875fdd8", + "audit_fast.py": "26950da76589b13cd9c452fdee1b0c354806977f881299bd94073f00e4646fcd", + "audit_mixed.py": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "CLAIM.json": "94fced945b1171e97c3ac7c71f819a5ba6c5230c10ef0b15556482990b46b368", + "code/assemble.py": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "code/assembly_controls.py": "d7675ff0b0994b29541d37eaa3010c5f39bb1447700c9f8e750522bf8c951f56", + "code/audit_allcold.py": "fa3488b62efdf8a0c37de0ca0caba587b4b036c5f068e002eb04c71c12b9e9b4", + "code/bind_providers_portable.py": "1d39bcc7b63ac158e021454beaae897d123e174360573762aecade3cd43193f6", + "code/bit_supplier_controls.py": "e6d33fb61a570c3f50669412acc467a3fd06ef0b806da6a75bc296c6ba2142a5", + "code/emit_allcold.py": "549603ca6d28b163a43b2dfaaaa788161c73d7952ab9190289407caca5418c71", + "code/exact_coarse.py": "5fd03ee160a8bb02a00927cb144359fbcf8b0ec323ae0662778dd1f655b4a216", + "code/fine_cache.py": "89282a83ab102893a4fc1e663ad2137d891d81e843b1c9ea140d13e58b7c7dbd", + "code/fine_mercator.py": "6cf29658b5c1618de4aae8bd49d6d890be06d57ead1ad0f2d41bc8d25cc578d3", + "code/fine_moment.py": "bdfc492be6a663b219d76beff444db14bd67bb53c7c8ec4086ab0f56e48323c0", + "code/freeze_spec.py": "e9132a9d195c66123f2747a17f7ef404b4d1e3ef6263ab4c28c983a052cf10bd", + "code/generated_identity.py": "c8af22719c0f3097a991a3f6ccac8f090afd2faba554745733d9ea88f2c25708", + "code/invoice_allcold.py": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "code/lemmag_checks.py": "cc753c5953e58f5900ce580ece8f814a352d672bcee6d4566c7dd52647912393", + "code/lemmag_stage.py": "5158e1e95e46b3119de9f4add7d849c8ad2d2dd92b17a79b0f93b86e7d4e6049", + "code/oracle_check.py": "4836046db4bec939515a5a272559f92192b56612b98f635910fd81ea754ce2e1", + "code/prepare_global.py": "8c0dae301a8f34b77a5a462f840952d08ed120576212adf5051bc09bcad874dc", + "code/pyc_guard.py": "1def35bd093a7b3893c1cf410301d875435a2a7a096b42f49ecb060ed2a61f0e", + "code/restore_parent.py": "69b7b25ff85e9b8160e233c1d415cc6a0272019e5c486dcec14cb6c349e7024d", + "code/witness.py": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "construction/leaver/PIVOT-SWAP-k8.json": "3ef7acf0cf67442a532f25b53d5fbeda76d3a84524118df8e003ca69b5cac0bb", + "CONSTRUCTION.json": "07c8c640de821978b6d2945100e2492ea7a6c006baa6b7b7585bbcb3b7f3eba9", + "DISPATCH.json": "2d178ebfbf3147d1f844897c779d151e04a0b9f480cbf57b76add4a24b8858ee", + "evidence/ADMISSION-CONTROLS.json": "5cdefeff2516a67c4dd60e609019b3e2e38eb3d43142df2d3c7ed9a6822d5050", + "evidence/ASSEMBLY.json": "5d9eb1ce551386024b5b6894836f81ed03a83d2e0c0bd0e02e3f6410a596bb2c", + "evidence/BIT-CONTROLS.json": "d74d9d2ba363c3709e9a3b33abf6d14abd6b9c68d950b35b7669d8e6edefa59e", + "evidence/FULL-ADMISSION.json": "cda48de718d060b8ca329f1254f4f999a5a5bade5cecabb265f0a9bef1135089", + "evidence/GEOMETRY-CONTROLS.json": "13a50b2f2448931ca302a55e5839c082f651331f20402448fe6ff29d1eb2f481", + "evidence/INDEPENDENT.json": "7150546e840e859268c40c11c2c79ba4fd646fc632fced68e3c19355b292fa61", + "evidence/OUTER-DISCOVERY.json": "413ef3e9eb1c3ff680cff1e600dc7160afda228e0b6b021c1a4e4a37ee486cc1", + "evidence/pr1377/CLAIM.json": "cd089b08077e0151b9ed917a5c33aa7aa6b0de790bd9567442531b48729da8d3", + "evidence/pr1377/PROOF-NOTE.md": "dafd8286b1c9224ed6f50bf71bc34b77918323b936ea7427a4b71c3b644b2264", + "evidence/pr1377/RELEASE.json": "a4fa2ca0f79a11dcdc3227ad16a408d4d22d83b7401c894cb0e31eb2c9c5f7df", + "evidence/pr1377/RESULT.json": "1cdadc74fef4cddeb2bae5e32fff7bc27456740150440ae8fda8822f569c2492", + "evidence/REGRESSION37-CONTROLS.json": "0196ae228d583f2bac3c42d3576a8d378fe622592e377c4c1921b5ae81351854", + "EXACT-ARITHMETIC-DERIVATION.json": "c0d40deaa495a7365e91aa5d9e6a846f91e0cb6daff98bb3b7f2acef84d64ec4", + "freeze_spec.py": "1d965b7a329b98008fcc67e73d03dcf6e75f0f33c2858a39f1182bb3d0ed0ea1", + "geometry_controls.py": "7edb4732b34e5814b27650a55c938626cb50d68f06397744dd4fe451437e90e0", + "GLOBAL-TEMPLATE.json.gz": "1d31424c4e27e26a35a9932ca778e43f1f3577589275422cc642aa68b31112db", + "independent_core.py": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "inputs/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "inputs/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "inputs/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "lift_parent.py": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "new/borrow/alias1_controls.py": "f4cc82312af891ea48956d9953a061196a8c3b113ef6d81e5848fe95745147b2", + "new/borrow/alias_build.py": "40b97536c8347733eaae24a3c4a13f5d21711e983106454777837be487959f1b", + "new/borrow/alias_enumerate.py": "7324f2569e6b76981d8c964a16ff9a3bc9e770e41b9cc6ec1c9defe8e662c153", + "new/borrow/audit_local.diff": "202f6f2032552eba069b9ec7e33b729d4af2ffc20974a9e82e444d906d7137b4", + "new/borrow/audit_local.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "new/borrow/borrow_controls.py": "07fbbf8e2f06df063dc9d88e5e4f721222a9fcf30b983bf9127cd5aa4b611627", + "new/borrow/build_word.py": "40047409dd9f9c406bb37a2ed0b4c8159797e0e4a114d525a368355418128707", + "new/borrow/emit_word.py": "a057ed0c81fbb07dabf38247e0ce0cec6c5fbfa31d8bf1b38838bd3758e41f87", + "new/borrow/guard_cut_centres.py": "5df204597697756808e6c959f5bba81cf35a2f0e7a0f1f75748dca1814373b72", + "new/borrow/guard_helper_indices.py": "d93aeb2d51d77ca93ecbf9e566d9000bb436c279e2a25b699a867e9697f782fd", + "new/borrow/inputs/alias1_43base.json": "2c5b5491da4b3e8a8356fd42a12a8fc8b2c9b4b0b20c4adc4e273ba217230e11", + "new/borrow/inputs/alias1_43extra.json": "0a54f41f886bf4f61fa620c65725373be905524ce906e5e95d501890de783179", + "new/borrow/inputs/alias8_43base.json": "3b91dd5a0d1b297a48e278b45903e073c5cefb23f22921f6a738bcbbf21e521f", + "new/borrow/inputs/alias8_43extra.json": "3ab265a33750a229a9201c2baff45ad91f1bef556879306d2fb743f5290cab31", + "new/borrow/inputs/blocks.json": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f", + "new/borrow/inputs/dirtentry_43base.json": "a067f7138f23eed6434286e7bd53548c86a7eef58c654374b778b4f424e9ffef", + "new/borrow/inputs/dirtentry_43extra.json": "8280fafb4642389ae91989e870ece7c9f2bffa38c9b52f2424b8abf489ba71f8", + "new/borrow/inputs/entrance_43base.json": "1b3c09f9558c50e7f299aa10fb21dcbd1b5ff397794838d8629c80d4c7a565f5", + "new/borrow/inputs/entrance_43extra.json": "e57ec67fa0a3fca63bf9e4bb9edf4e6be48db0bd7c9e092cddad29b26b897463", + "new/borrow/inputs/extra.canonical.json.gz": "d7e48dcbafa236a2e1e41f7958244211506f7c7630fe6a2d43d2bdf17b7ae015", + "new/borrow/inputs/gauge44.canonical.json.gz": "65c6d17ffee2eacf27bff438f37fc549c9ed0c909cbc7a52976cc75cf2d15b91", + "new/borrow/inputs/handoff_43base.json": "5ae3062bcce666c8c3a3a650e345adf15c22a2800fa0e17d79ad6e8b97208a2f", + "new/borrow/inputs/handoff_43extra.json": "4238a7c5093a4347fe69adf4f76e507d2f43c4e727d91b2c4705039e1cbaa06a", + "new/borrow/inputs/kernel_43base.json": "7f06b4b08a49192a27e8f4132ad0c93521dad90f97ca985a173944ba02c5442b", + "new/borrow/inputs/kernel_43extra.json": "ef95eae03915f0222bcd486959c6dfe307a9a0a856702420fa35491abfae4c84", + "new/borrow/inputs/lowfour_43base.json": "a8df0a2acf85e96febb35d24ae047c370d179095b46142bae968f06348bf1c18", + "new/borrow/inputs/lowfour_43extra.json": "9dbfb49fb3c04a0652dcae9a962d973489679f5d1ee2baf4e65c58d2e8ef578c", + "new/borrow/inputs/prelife_43base.json": "ec43328c198094c0e8b37cf93de0210d2ba0397ed20dcaec1f1d121ffa5cdb69", + "new/borrow/inputs/prelife_43extra.json": "a7fc8362edaf33de314bebc400bcda6a6cc345ac6ca86220e1f53ae43cbc8600", + "new/borrow/inputs/refit563_43base.json": "4ba6d0fe6f5f03095821f1080f1cceb97204a3189ab0e48092e1cbccb1d7ceae", + "new/borrow/inputs/refit563_43extra.json": "4ba6d0fe6f5f03095821f1080f1cceb97204a3189ab0e48092e1cbccb1d7ceae", + "new/borrow/inputs/refit_43base.json": "19a97e80b0ee3146e0244e6bc36bd365d89e9c1cd0f885c4e06be4193606a323", + "new/borrow/inputs/refit_43extra.json": "1349d54f704847fdcd4a00e323cdc9e1118fac7fedb0c7573e9b2b3f0169a7eb", + "new/borrow/inputs/retired7_43base.json": "74daf5826d9191be4613a61447f4dc12789190fb49a3219f6a9df63075cac1e1", + "new/borrow/inputs/retired7_43extra.json": "25d9774b512da78f042287ce1de91c79c8658d06488b8fe94e548cbdd036f034", + "new/borrow/inputs/twelve_43base.json": "ee268c45a9c768a6a4cecf401cd4446cebb042e67d69e5fb6d078934d5a49498", + "new/borrow/inputs/twelve_43extra.json": "4ff1d00714d0dfacf95b89778f6c1abb113877f8c9880c01a06d0f30998756ee", + "new/borrow/inputs/witness_43_base.json": "65ee52604e2e49a30c1e978b7ce829482a694a20a8744f37b9bf40dad1ff3a2e", + "new/borrow/inputs/witness_43_extra.json": "19c652db80d5215c958c63b5d6f2de96d9cf34a0e4d56dab5c13e556c57f7467", + "new/borrow/lowfour_controls.py": "b1484a0ab1ad5f87a71b8e48ee8c5ba7604835acfe2b841b6f13cbd12f32e344", + "new/borrow/prelife/results/gap-base.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/gap-extra.json.gz": "cf596232260cadcc02bf1020c2e138a31e9482140c4ee2bdf6a0a32797a1187c", + "new/borrow/prelife/results/prelo-base.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/prelo-extra.json": "9d6fa7827d991281a647043a4675c001964bf5bfa4045e54ce0e192ab74a19c9", + "new/borrow/prelife/results/tryE-base.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/results/tryE-extra.json": "aeb3e8e7442ff104806ab39e8fcbe366fdcda95b64909c107d255c379ad579fb", + "new/borrow/prelife/search/chains.py": "588d6cdb2312febfee5f3d576295f2edff53ca74c14d21ed9bffed3312dfa32c", + "new/borrow/prelife/search/edit.py": "8e5eea35d0bb83aa60bd066ae9ddf3f4b0ad46cf9ac9d31d8fc5777f49013713", + "new/borrow/prelife/search/fm.py": "36174e2b7e012726964282af926fdf541332556bcc548af5b41502cdb8b198e2", + "new/borrow/prelife/search/gapbound.py": "a0fa0fbd079a456bf5f9b75352eb68c4b7e2febad0c99e66b7553bdc744772c8", + "new/borrow/prelife/search/mk1.py": "4bab66a4e1514a067572c7854731a4fbd29681300e95a4384fdb68e0eb140575", + "new/borrow/prelife/search/prelife2.py": "db1fc5eea7bd70066188d7c7f52cf4be8991e61b821d3fe4b779ee30c7f3c9eb", + "new/borrow/prelife/search/prelo.py": "157dc45b5fcc421d26507d6d7fca6d4caeff6c73efcd679fd28e906f600ea886", + "new/borrow/prelife/search/propbound.py": "735cd4d1a6a43c96f397eb5ae2972e86ab71c2c232e6d14ac6cbf1eb7f638c1c", + "new/borrow/prelife/search/repair2.py": "410ddd6f9b3e14be6b9247cc5792d1a893175e843a0c21bf667e71a6e3a9710f", + "new/borrow/prelife/search/tryE.py": "130a859c0ad20623943b25800dd2f1d0355cf03b8520fc493ec870baa010b2ae", + "new/borrow/prelife/search/wordmodel.py": "215e678d3f3711b4291f9da5d7937cdbb0b091390bba089e6949b8c42a29f6f4", + "new/borrow/prelife_controls.py": "c24398bdc407aaf6713201100d27ba851233525a9dfd747b641d99e1cde66cba", + "new/borrow/receipts/AUDIT-43base-pinned.json": "8dc6daa8929c1137c1e37fa5a1bf869afafe94c3e65ed2705ea9f41f2dc8cee8", + "new/borrow/receipts/AUDIT-43base-prekernel.json": "fb6f40a1d117bd304cc0757ac21915bd8558e8d3f31b8709129f395033fc534e", + "new/borrow/receipts/AUDIT-43base.json": "07b8a4836fe2659d0d46957ed0973ba3334f6752b5c1235d03b961a107fb95d5", + "new/borrow/receipts/AUDIT-43extra-pinned.json": "4176a6190fb1a224d45797064cde2aa758970bce7c1ed2a009ecb2fc7839d26e", + "new/borrow/receipts/AUDIT-43extra-prekernel.json": "09041e49888a1360b7ddee29d54d82836a875ecb6547c7ad1eb92427e7f3b384", + "new/borrow/receipts/AUDIT-43extra.json": "a01ae6847449ddb88c56fa8e44d10bc0b005f1b24daa283d38ba00089d8f89f2", + "new/borrow/receipts/CONTROLS-43base.json": "02b73bfbf72c63926ebb244bbd6bf87a03201ee1487e2c15292ad52684fb4d69", + "new/borrow/receipts/CONTROLS-43extra.json": "f8b93901ef5b4810bb39a7b5ccdc62497612c2efba67920a8d6119ae8a898126", + "new/borrow/receipts/CONTROLS-KERNEL-43base.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-KERNEL-43extra.json": "2b40a169ede95155b5ffe276589b911d9704ef904cfaac41bf41b24140d40907", + "new/borrow/receipts/CONTROLS-LOWFOUR-43base.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/receipts/CONTROLS-LOWFOUR-43extra.json": "e0e3e01afefb69952da0063b3e6daaa032a4d1dd71d1d68cbcb7f3530a6ecb38", + "new/borrow/refit/results/pairs-base.json": "8178d2a34be82601f2361afbc63b37294255a435b243e65295bf7b641edfc4a3", + "new/borrow/refit/results/pairs-extra.json": "3a64b6ace504a5d410a4cfd87ae2fc04576df61883ce56e3f7eb38d4b26df8af", + "new/borrow/refit/search/bounds.py": "690986e69e3125723b12255cc5aa135fceec93894d589eb196ab7fa5da37e9fb", + "new/borrow/refit/search/eval1.py": "0547e606468ad4670512ea83fb3d6e7f39fda9b66537fdf791ad22a3bf4aeeee", + "new/borrow/refit/search/mkcand.py": "c5b437f6a991de674bd781d610d98a43d9f84179beb1187340354e55f42ceaa4", + "new/borrow/refit/search/pairs.py": "7922404bf942eff2dda0125b78ff1234bfdfda5101ff428b11f8a5ed73ce4882", + "new/borrow/refit/search/refit.py": "c036d0d4cc91360e583a7ed01d6c69c17a69f16c5838062c2b9de83a616d2e23", + "new/borrow/refit/search/why.py": "209a95a62a95c06138f0b5af2d1dd1f9c60c403c4da294d39663928c2312425e", + "new/borrow/word_patch.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "new/borrow/words/BORROW-WORD-43base.json.gz": "dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac", + "new/borrow-fill/DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "new/borrow-fill/FILL.json.gz": "0cb7522e071ff064ada2efec169e23a2fe7d3daf928eec6ba752b166cffb3468", + "new/borrow-fill/ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "new/borrow-fill/search/agg.py": "267a66287336b72731b897508073dae1a7c85fa72cd86093a7340ddfc12af04c", + "new/borrow-fill/search/base74.py": "acc99c57730fe50f88538e4061e7165a7f278ed7499728c24b0522d479be8b8c", + "new/borrow-fill/search/ceil74.py": "99df541abe458fb6154755d9c67066b2ba0430b06f879a7b5a43e30618f4c1d7", + "new/borrow-fill/search/evac.py": "7c6ce4e8aa9833a9d451c5d4b891bbd1927315bcbf112d3c15845f0ede2d9dc3", + "new/borrow-fill/search/fillbase.py": "4fc6fa920d8703ccec860bee0e1187a0a8b1e37b245789256f7a4d01ae8a2b00", + "new/borrow-fill/search/inv.py": "eec279ea8e8d9d1dccc2733a88129351678c73fb51f06a4604a9c1da1d771387", + "new/borrow-fill/search/lattice.py": "8f2ee194fa4992d1f45394b09b5151ec699b28e4c950b9d40b826f33cbb635ba", + "new/borrow-fill/search/lnstime.py": "3a1ff558f10b0b935389137627359f875ca484717ffa3ced7de8d8b588836755", + "new/BORROW-PROVIDERS.json": "3666edf67d61b01336e58166ec9edebd72902cc37a2da693b05691ab2a387cda", + "new/CHAIN.json": "f18804a71bef7005e892b0b7baac818d5362fff685fe5b5aadfe8de6e442446d", + "new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "new/code/borrow/bw_audit_local.py": "6bc8a07942a027a52ede46521f6b5dab755643eb693efc7dcb829496050fde09", + "new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "new/EDITS-1.json": "dffa640c04d71111d3e4bdd7f5a991450ba07049a1d434edeef84791c0cc2d05", + "new/EDITS.json": "d5f9a0444dddcccd35c0217f60dbd6863486241629a747c3bbe4140b3d55eea1", + "new/extra-word-566.json.gz": "cd417b904408c221d9840d08faff8af040cc4207f9804284f2f5375d21298a62", + "new/fastnative/.gitattributes": "92e5734dbb86fb8958622e6dcea5895601800a24b0722ef86220322449a44ff8", + "new/fastnative/benchmark.py": "3e544453c89310281d745a37e861cbd79065b1740d90f1ec883fc200b189a557", + "new/fastnative/common.py": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914", + "new/fastnative/compare.py": "ebf877a6f47ef1fd2b797fd6077bd45d132d8cb56ab7553044bae3d86e238e45", + "new/fastnative/controls.py": "03131f4dc6a1830f10e35fb837ada456f060ca510994d250c5c2666a6342c23a", + "new/fastnative/evidence/BENCHMARK.json": "9b192c5697514c7b36b709d0e5506915425ca61f24af0210e2508d7b1bdb295f", + "new/fastnative/evidence/COVERAGE.json": "8bead250cc97614528d9448dfd29529bf08605daa5e8007e701038ab317e00f6", + "new/fastnative/evidence/REGISTERED.log": "78a49def69d0465f4318b9e24613246ba5fb6de19441e54b88fb50dfe823f149", + "new/fastnative/evidence/VALIDATION.json": "d265ce16251effd6b5d3b7429f31f98cd385fe79f659cfa24a2820bc17ac70dd", + "new/fastnative/EXPECTED.json": "8d45fba81564631f9f8614e637b9fbe69dc911b4e2f0b77f0a7071f39cfd7ca8", + "new/fastnative/fixtures/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "new/fastnative/fixtures/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "new/fastnative/FRESHNESS.json": "92abf8c25be59ff71a90781f38c5db2f9176c623df046a6d0e2327fd0235cb6c", + "new/fastnative/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "new/fastnative/NATIVE-LINEAGE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "new/fastnative/PINS.json": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9", + "new/fastnative/README.md": "6a2026383804606cd7981e087192b3488c674f2d9443ec218dcb2e85d06406dc", + "new/fastnative/requirements.txt": "a23aaf94250a9f53031a592980142245a848e2372b6c6c3093e8260b129265b8", + "new/fastnative/run_native.py": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627", + "new/fastnative/SOURCE-PROVENANCE.json": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee", + "new/fastnative/SOURCES.json": "3599ed28c8d8a9ce096bc13507b066d09e3968587781748b2bc72f634618331b", + "new/fastnative/stage.py": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe", + "new/fastnative/TASK.json": "8159b49d5c73dd887d432a4680dc947f63e7158a01a66d7736ff7138e8149732", + "new/fastnative/vendor/accelerators/SPARSE-NOTICE.md": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "new/fastnative/vendor/accelerators/SPARSE-PROOF.md": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "new/fastnative/vendor/accelerators/sparse_state.py": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "new/fastnative/vendor/accelerators/tables.py": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "new/fastnative/vendor/native/new/code/borrow/bw_adapters.py": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "new/fastnative/vendor/native/new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "new/fastnative/vendor/native/new/code/borrow/bw_check_recipes.py": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "new/fastnative/vendor/native/new/code/borrow/bw_emit.py": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "new/fastnative/vendor/native/new/code/borrow/bw_gauss.py": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "new/fastnative/vendor/native/new/code/borrow/bw_phases.py": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "new/fastnative/vendor/native/new/code/borrow/bw_tamper.py": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "new/fastnative/vendor/native/new/code/borrow/bw_transport.py": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "new/fastnative/vendor/native/new/code/borrow/NOTICE-PR2226.md": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "new/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "new/fastnative/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "new/fastnative/vendor/native/new/code/borrow/vendor/pr2226_operators.py": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "new/fastnative/vendor/native/new/code/borrow/vendor/pr2226_replay.py": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "new/fastnative/vendor/native/new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "new/fastnative/VERIFY.json": "e46542b70296c039b5bea0c0aa9cfd4e95e1df8859e67885ed3403bea9da7b32", + "new/fastnative/verify.py": "6dbdc56ca6cfde987869e12990a495d7eded78dd1887fb3fdf2d196060220fcc", + "new/gauge44-word-566.json.gz": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "new/pivotcheck.py": "6eb1752f077df108c908974413fc71abc751356b07c6e650e75d2075f1a51391", + "new/PLAN.json": "fe48f2a29535cfae3b0889170b87ebc1384eeeef9ab635a901929f9a40a2c95b", + "new/PROFILE.json": "69a5c98958d196e61d158c856392c9587363ee47d2c8665081e4688795c1f2b0", + "new/rebind.py": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "new/rebuild.py": "7391a7228d6b5afc2f88afd5d5a987565d78a100386c1f03b8696bcde2e8ef3e", + "new/rebuild_borrow.py": "a65079e5ea9553a150879898b5ab9cecb01c1be19247c20461c97211988c1ef3", + "new/rebuild_chain.py": "3a5739f94f0fea1aa267e7d12e1c986210e483c841a8855e11020128a017510f", + "new/run_native_borrow.py": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "new/SPEC.json": "85635e7f1ceff706fe43c9eda5bb8847e6273b4d7509b119114e39684b0ddbdf", + "new/steps/0/extra.json.gz": "17cc6c177c89eb264514e1efb3685ab9a621f3952a8f393a6a5eb28cf77e2884", + "new/steps/0/gauge44.json.gz": "0740b6f33927b9e60c9a7f35e7fcb2fd9ac6e2d3982112428b302a6966a18c73", + "new/unpin_spec.py": "03901dbb881fa608b6540a0541b26311dd4bab23bd8768e9ed48b8b355e1b36b", + "NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "ORDER.json": "30856f042860e5b5c613357b236ff643f107d7d70e2c64eb5fcaaa09bf81a90d", + "outer/B.json": "73be46ba298e18a9849354345bc9aea956cfb35db47dc279230e7237d323e729", + "outer/check_fine_padding.py": "a0ae691251cc50ba20b7f23f89fffaed802d62f9192a441131476914a5bdfae8", + "outer/check_gaugefree.py": "f8d49739d3f5819a62f9862a624dab7bebb019f3d8ab949524cb9bbf58d3ef66", + "outer/check_ledger.py": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "outer/CLASSICAL-BOUNDARY.md": "6647d5a71d9f6c3f628ac71a7be2e63bcb0cac9618cd4fee7493dcc4ef02529a", + "outer/FINE-PADDING-COMPOSITION.md": "d20d8e5f84a9e33cc9996f875be06c24c74ea53874cc76564953785ff29c5c6c", + "outer/GAUGEFREE-INTERIORS.md": "ebeb7fa53dca671e45b3a3dedf4603607d19461bbeb977445bf5e17bbdb25db8", + "outer/INDEPENDENT.json": "1f76d5f31d69fda9d677788321e2d0f6fb7b057159a0a55525d327d7dc0019bb", + "outer/independent_check.py": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "outer/LEDGER.json": "bfd5abdc0c933f7391d1a43ea01a22a304e0b4f66cd038cfeb5973dbb319017e", + "outer/OUTER-CLAIM.json": "6f2c4195f0226c5a7f9ba604bc038cfd4100ba3caeeac8ed2defb6fb00632b70", + "outer/PROOF-GRID-MAX.md": "19dc50ad398993d156f9366fc752321a88a7337dc016c00b0d5a53eceff93cf6", + "outer/RECT-BOUNDARY.md": "17ece1cc1eb4a02df4d8433e3612231768633e6674d315acbcf880f36e30bdc7", + "outer/replay_evidence.py": "d3bdcfc8ce29865b3a76d64d99b5177e73fe994a2eb915f35fa233c5ab81df65", + "outer/RETUNED-SLACKS.md": "d87beb3869fb60143c2c3872d7c427ee16174aa51b5e6f42689312fbd40d3d42", + "outer/run_outer.py": "9d5dc0a7ea38973ce52a1cda02d311c235bc7c39c4d20921d5811cab1a57ef8c", + "outer/sched_review.py": "f440a57f1f46119ee8c2934c8f0d618ca1c85c73cda8cfb8453c2aa1b9fc40fb", + "outer/sched_test.py": "f96d09b5990931e3df8cea291520bf17c424215748cd9ec068214c58309a21c8", + "outer/struct_check.py": "f1df92bb6247034a22e141dcb39c1e8b6b9df6eb9791493be25a3911f7add8d4", + "outer/STRUCTURED-BOUNDARY.md": "ceef915be6462a8ad81449eefb86bf4d97db6ac41c87660e9dd7cfd2c2bc1efa", + "outer/UNION-SCHEDULE.md": "bc8e9cf7c178bb39b092ab5aafc4eeb523e72b1f69639bfcb9f27d0f74109357", + "OWNERS.json.gz": "25e70226d625ec6222f9436332fb8f4a82664f71cb6e5af0e056d0d32ca76baa", + "PARENT-LIFT-RECEIPT.json": "787db0b6f847cb03ff9b71246aba6e702ad3ab8e2fbbcb7dff9f51b8a8a783e8", + "PLAN.json": "5345bbb91255a3229000ef154daab7d6dcb31c98aadeac9d5dac748a58cc5c44", + "PRICE.json": "c5ec535fd9edbdec7b64edd5a8b862edb1a7f173d411dacb279172659573e16a", + "PROFILE.json": "dafbfc76552e3b0c5d6f29bbf5bbafe5602149d3a3f8e35d5c316741e7eff64a", + "README.md": "b794473b965406360e7732f0e86b66fbcf8e91bc16632330ada8e1150f2ddb62", + "reconstruct.py": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "RELEASE.json": "034e061609a987eb6275787e74b3b775ef0782a277bb26e2ca664f61b2863e55", + "replay.py": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "requirements.txt": "255a2ee4a60637759d4d5c89448c55849153e81ec1d1383555c6697784d9dc97", + "SOURCE-PIN-REFINEMENT.json": "8c0bad79978decd6f8aba0932c0a94c7f61c64bf9ce5a19a36f67cc1390bf74f", + "SOURCE-PIN.json": "66faac1fd4e79bb6d9fc774fd8ba63522ad3309456be1c81405794b284c55c83", + "SPEC.json": "81676590c26018aa95082e3252f394ac99c61c0c4e5578f59501401700e38033", + "vendor/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/audit_mixed.py": "7466461cc15cbb12135d94f2d904d4e90e78cbf4755d0293ab9bd55e3568d4b0", + "vendor/pr1297/build_word.py": "ff08af2851b4813c113ef63113566cbd79625e9310611292913d51be554b5aa9", + "vendor/pr1297/CLAIM.json": "bc9e90a475333b957a8c4eae8b950988caea89e20e9b44a919e83415fb76b1b8", + "vendor/pr1297/COMPOSITION.json": "6fb74e73fd298b356402eb2fbcd625463b2fa540a6be4ef2d6335ddfa31d70f6", + "vendor/pr1297/construct.py": "71aff454291d4a35068c43dbb65c00ff511f48e91ab7cdada462833f04ac73e3", + "vendor/pr1297/CONSTRUCTION.json": "fb5f74f59c89b93c63ec47e32e2c9264658e115d1f21eed3eceefec7dc7a0cde", + "vendor/pr1297/CONTROL-SITES-base.json": "b41361f5a2f6ab3d223c146269c8027a0537f1a6e3c963f28cf1ebbe05c5d7e2", + "vendor/pr1297/CONTROL-SITES-extra.json": "f1aada769389ec410b41bc9e2082826bb916b8332c915ee9e07045135c30393b", + "vendor/pr1297/controls.py": "935cf39ed6601eb6ac411b7b1a4adf5d4238589cad9fd5969d7dca967ace4c4b", + "vendor/pr1297/DEPENDENCIES.json": "9c9fff3ac059da4d4e2f13e655afb9e42ada1a57987f5b47b68dda4b64797966", + "vendor/pr1297/DISPATCH.json": "b7b971df9dce435556145df307e2bb5138d87e5aa933f1fe61fcc5b5163301c4", + "vendor/pr1297/EXACT-RELATIONS.json": "6864f378d917d0ecfd8cd53cc26303217ebb48f47f2987bbc01cf1e2c9a28093", + "vendor/pr1297/extra-word.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "vendor/pr1297/freeze_spec.py": "0f5c8ad43180a633a2cbbd11f7832729039402c68f593679552c43a1693d69fa", + "vendor/pr1297/gauge44-word.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "vendor/pr1297/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "vendor/pr1297/INDEPENDENT-DERIVATION.patch": "6b3af098ec1c9e2360a366933eb7fbf0e16ebb37d43809d26b275e66fb5ee779", + "vendor/pr1297/independent_core.py": "d1dcd5593a05cf647b485db38891984f829abea5f95c6cc91e37d554bf163d48", + "vendor/pr1297/inputs/base.json.gz": "b87c706d14a7e1972514ee901002a930908073811ef38761def31c8e36351916", + "vendor/pr1297/inputs/extra.json.gz": "ded6903e00deb9e158fa700b03ccc9b8bfaae6c8bad8ca4842f0ad9b963234ab", + "vendor/pr1297/KERNEL-CONTROLS-base.json": "cbe755333f469a1f01258b65f2b273763212dba6642edabfb58f7490f326abda", + "vendor/pr1297/KERNEL-CONTROLS-extra.json": "cf255deb866ecaefca4b6ecb72f105d6b08dc8ea907a8381d45aedc39b2022cf", + "vendor/pr1297/kernel543_controls.py": "ac16d605e773197e3664643d40b36c15a7130a45e95e36bfe7b42d939644367c", + "vendor/pr1297/kernel_controls.py": "436e3f3d9974da7c1968ef99fdde5ad203a61544d8195493e3150eb25869f4dc", + "vendor/pr1297/MANIFEST.json": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "vendor/pr1297/MAPPED-RECIPE.json": "09aca649da97a37116262827cbd3ebe0addcd2b1a33c08e8347f3daf3394176a", + "vendor/pr1297/NATIVE-VALIDATION.json": "755b7087e0ae964c538e9378311e07dba2867c16b568d1bf6ae9051657f9f5cb", + "vendor/pr1297/NOTICE": "b352129a07fc8693f57c77cbb0ea92230b2fa77439f86c9f35b828213f9c42db", + "vendor/pr1297/original-main/research/complex-t21-owners/vendor/pr870/t16/build_parent.py": "82e274d0c7a94f9bf0468dd37f0505d0c42017559ebb4ba8c079a1f4e403d91e", + "vendor/pr1297/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/PLAN.json": "163431bf8d3bc0d9b894994b1a3cfa7947367b2243b3c0b3a97d740195a1cb08", + "vendor/pr1297/premise/inputs/CODED-CELLS-k8.json": "7347f814850a838bd617bc7a55c307cec2b72becde2f12ea3e2e1af344b43563", + "vendor/pr1297/premise/inputs/TRI-LEAVER-k8.json": "b22e6ecf76104de66844bd617c4ca80f5546ba0966a50e5e9aa0ffea4976cb30", + "vendor/pr1297/premise/premise_check.py": "28a7f881a988b29b8ed3c927dd142ac3d4ee273dedab3a65bb02c01a64eb2639", + "vendor/pr1297/premise/verify_1049.py": "a1736324c6db161733d8e11f608defd87b7f97cacd611203d22499e4c7de5545", + "vendor/pr1297/PRICE.json": "e19f9f9e70e4fda2bc4a39fae93ea44555945cdaea59728864c5a44dcc5522e6", + "vendor/pr1297/PROFILE.json": "d9bbe0d73ba005749615915a2d884819a6b141e3402d9e7f87f4592a2d27af99", + "vendor/pr1297/README.md": "102ac7f080c1799aaedd5345ffb3631845215e8ab770e2af34750c25f667686d", + "vendor/pr1297/RECIPE-base.json.gz": "0f2db2c658e9732fdd1aeb7bbbb5c786d6045de8a2575b7654b9e6fddc71b03d", + "vendor/pr1297/RECIPE-extra.json.gz": "9e6f58570b0a8f9e8271bfbc73a339fce42f1cf28bf14d4db93f246b8f63a3c9", + "vendor/pr1297/replay.py": "d3ea7c2e74ff6df9d14969f994eaa85f825372cee92dafb77bec4767edb242e7", + "vendor/pr1297/SEARCH-RESULT.json": "7cdacadcbbf83b81f9f91668fcc707f8a238c6025f35a8bdc36758619c2591c4", + "vendor/pr1297/search_relations.py": "58f3bd092cb8592a070d7879918ff318a658a6fa02bfad7b5b8f4cb0fe16691c", + "vendor/pr1297/SOURCE-PIN.json": "e93f303f4de383757e50d612ada5e379533d46737a32281aa6879fb4b6138e09", + "vendor/pr1297/SPEC.json": "2daedf579c8abf30ceed79fe739bdd7659fce4c514de3894a028933143265d98", + "vendor/pr1297/upstream-layout.tar.gz": "a0cc229bb0fc9ab8ee5c14d5de87b3de31d1fcb793e99192c9cdc63781e794a0", + "vendor/pr1297/UPSTREAM-NOTICE.md": "b97fb4731e84aef736c58a9c126334eb5b8d3a057a8d9d45b4ffff24af65c38b", + "vendor/pr1297/VALIDATION.json": "1008f637a22f954ee774920a8362931ca7cfed63ca146e725768c0f39803c0a5", + "vendor/pr1297/vendor/pr1193/audit.py": "1118d483b6abbe7036390c0a1053bcfec2038dbac273fd1bac92a68f38e6d7da", + "vendor/pr1297/vendor/pr1193/build_word.py": "effb72aecfff9958fe078ee89e0d37b85d601eddb19fec4520d7ee6e936edfae", + "vendor/pr1297/vendor/pr1193/CLAIM.json": "b9db2fbfb004b505ad535e4763915275dc5908feaefef32e65863fa65de061ff", + "vendor/pr1297/vendor/pr1193/common.py": "274274df31f8ef2a47b801d1f30ec226f94bce674fe15586d814ca754f6b7785", + "vendor/pr1297/vendor/pr1193/construct.py": "3dd333b50f4bd1d86956a6df4a334ed746d75d0a9e03dfadbb6724b4356e0cd6", + "vendor/pr1297/vendor/pr1193/controller.py": "d93ed519a0f2316b87b66f44c5ea615f0768a263dbd800815b536d8b7c86b8b7", + "vendor/pr1297/vendor/pr1193/controls.py": "574c55a01cfc34f5b9688cdec5646160cf22b403decee36d18b11f1b07e71f21", + "vendor/pr1297/vendor/pr1193/data/FLOW.json.gz": "e8e6dfa66e083ff8f3617a8441b5b2d766c3c9d9ac62ddc37d99edc24051f79e", + "vendor/pr1297/vendor/pr1193/data/FOUR-RECIPE.json": "384b32c5b0e9b3baa1c7232db884809596d30fc55553094245f7b739b1a43484", + "vendor/pr1297/vendor/pr1193/data/FOUR-WORD.json.gz": "7d09ee1b8b9881313e5fb1f623c0961d59b0c6352a019bc9164a6cad8c58e27f", + "vendor/pr1297/vendor/pr1193/data/MIX.json": "dd86bbb792a5c9f0d7507d55bd2f8392c66716023934b03b24f48ca737204eea", + "vendor/pr1297/vendor/pr1193/data/ORDER.json": "7757df3b54ca5e84c6dba9563b10bc6215c5e289313392b5a4b493179a245c29", + "vendor/pr1297/vendor/pr1193/data/OWNERS.json.gz": "3a56f578b2db5647cf6cb811bc6263c7a802ae3e31e9e672596d43185e4e5c9f", + "vendor/pr1297/vendor/pr1193/data/PLAN.json.gz": "1f1085beb84b516b9a96ceaedc6c3de1c58941fd00b6e70f0d0c686b6546ff79", + "vendor/pr1297/vendor/pr1193/data/SPEC.json": "82b263990afdc5efdc1dfe38ae16d7815004dff8d70f85c28fd8286c31f688bb", + "vendor/pr1297/vendor/pr1193/DEPENDENCY-PINS.json": "c9330aa6a4226c804060499429cb450820d7142ab17696eb47408b04b410b5bc", + "vendor/pr1297/vendor/pr1193/evidence/ANCESTRY.json": "cd880b2d1c2fb8d9050458bd13f228385c417a95e4d1985607d9f4bb60b5c109", + "vendor/pr1297/vendor/pr1193/evidence/ENTRANCE-CONTROLS.json": "7b101dd97c1025667fb3615930a9d6cd2ec443169d263a3bc1191b80fc712a1f", + "vendor/pr1297/vendor/pr1193/evidence/FLOW-CONTROLS.json": "43fe7e94bd72607d502ed947ac1463405be18728eb0b8faabd7ba63ab1d28ab4", + "vendor/pr1297/vendor/pr1193/evidence/INDEPENDENT-OWNERS.json": "4c295ff53f51631e1720b0dc2ea895c34861435fa92112ee52439e4569de968a", + "vendor/pr1297/vendor/pr1193/evidence/PARENT-CHECK.json": "2b729fd666ffe4e34a355223b57f74ba460fb171b19c84f260378dd109f0b9a0", + "vendor/pr1297/vendor/pr1193/evidence/PRICE.json": "a1dac219b019f8d40d5b434b0e0c25b0d1f097fe5ae13eae45c76869aec4758b", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote3.json": "02150d4cb1b2f4763b5c5c20ce979c740cbdfc1066e021a8aa5d407de5c4b9d3", + "vendor/pr1297/vendor/pr1193/evidence/RAW-demote4.json": "7adf0070125b2c61e04d46c5f1cbf57af079eb733799bbfcc3fe9b0551d964b1", + "vendor/pr1297/vendor/pr1193/evidence/REPLAY-SOURCE.json": "a5a290aa8c75fffa45c9ad2e3441d5051d3adaf7934f4d0311875fb4d8f023cf", + "vendor/pr1297/vendor/pr1193/evidence/RESULT.json": "62aca8286cbb021d2535d81494f7ba7a3aec20898fd7c40a895a461bbd303ac4", + "vendor/pr1297/vendor/pr1193/evidence/STAGES.json": "0dce559b2a8f371f369a05ae25ca5dd6a48019b5685b0097f001a23bd849429d", + "vendor/pr1297/vendor/pr1193/evidence/WORD-RECIPE.json": "b6750c8123c205b63786fb825da26a819592f71736a82009809ae1cf96173a5c", + "vendor/pr1297/vendor/pr1193/local_controls.py": "fe3d13491fa7523eedb8d24577ffe4bbd6c36a87b4a7d1178e5795d223bed4b8", + "vendor/pr1297/vendor/pr1193/MANIFEST.json": "4837d070679d9e70218c7cfa2d3e70d7d742a5b74dc66d224840b1a3a4ac4a31", + "vendor/pr1297/vendor/pr1193/native.py": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "vendor/pr1297/vendor/pr1193/NOTICE.md": "c7a17a0a35dc249f8ebcc550b3791e214aa65872eab8a6458c5167dd7b948e5b", + "vendor/pr1297/vendor/pr1193/package.py": "cde0b2d66125649ee84440fc0a67f0d91f900fc838fbda069b579422289ea3be", + "vendor/pr1297/vendor/pr1193/prepare.py": "9fe454a5f857ff73c70a5b276bc9e289422b051a4cbbbb51123a91bb2200e6d8", + "vendor/pr1297/vendor/pr1193/price.py": "d45042f4c1fea352349377b43def363cf75a742546a1d5c790ad30da91791803", + "vendor/pr1297/vendor/pr1193/PROOF.md": "b2a38120ddb75e90764d0b81913d60b46cddac4d943cb731bd9c7134f1c236d1", + "vendor/pr1297/vendor/pr1193/README.md": "cdcf62624912150ce4e6e05356c27299251eef4cfc130e4f209839cdabc05e08", + "vendor/pr1297/vendor/pr1193/SOURCE-PINS.json": "08eed0d6822a1c17053161929591e7ac36b9f91f8fd61190183a6d975948db85", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/JOINT-WORD.json.gz": "a0622d86259c4163e58cf0677ce575b6039a8ae4c95aa6d8b82a8163cbd42718", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-coordinated-owners-NOTICE.md": "442756fc1c5ecfd7b7b7694b53b1ecc70aa525004cd80f7d748ccd7270555189", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-NOTICE.md": "820fa13161f857c221f2c4099dd2985c7ff72249dc7a0221bc00fd0c1b9760e5", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-eight-ends-t16-NOTICE.md": "a9e85b59dde61fbff0b006923b441cbd1419e24fa9802426785bca667437fdc0", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/k8-three-demotions-NOTICE.md": "a0fe85fb2207f0e6831a96deaeefb65afa379c1377a29f0b586f1db4bb4b2137", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/NOTICE.md": "afbd38d6c8a232ea566c296424a86420f204e6cfaac565c0a147340bda3d3da6", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/PLAN.json.gz": "e963ed64b9970858902b9388bcf1c5f9cc704859ad021ce8bda465a4dcef8310", + "vendor/pr1297/vendor/pr1193/vendor/pr1148/SPEC.json": "55bdb68d5d126c6be0e0acc419bd62301a978afd514f9834ed1e08b1aa4f563e", + "vendor/pr1297/vendor/pr1193/verify.py": "e5c952989344a65b7e63fa112dda4d464979814205644a8ec34e407a0d96be29", + "vendor/pr1297/verify.py": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "vendor/pr1297/x54_controls.py": "82f91b81be9173dca546345dbdaddfc71e6d21e626fb84a8b4d1b4ba0d673814", + "vendor/pr1673/capped-phase-fusion/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-CONTROLS.json": "eb3ba38d18bac4aceaffba39ef48dbb55bd15e6abcb68cdf66920d9d13ec00ab", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/BILATERAL-LDU.md": "0d65e66d227464dda1a19f781ae0a0be671cbfd347c41e37ec954f3d629d8a77", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-AUDIT.md": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CAPPED-GAUGE-CONTROLS.json": "ae8f0eb121a2f4da5c3f982ee6e7f45dab7b18368cadb5d2060602b0393b7120", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_bilateral.py": "8d5c79bd4f4c96de5c1fa91553b19e3a62419333b414fc84dec894a4b729d5e0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_capped_gauges.py": "121279bef47dd490bf29fc72ddbce547176cdaf1154af67dc8b96d7baa8cfc6f", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_cyclic_scan.py": "d25156f852cb95f013e0ee74b319fc8c20d6a7a53fa851543244d5af7898ee61", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_dyadic_interiors.py": "a39617147870719a0296eef77101c90df8fbe716841cb9ed823f36b94254c3e1", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_forward_cell.py": "082a0e46c175f6e59fe1f8c168ca56bc444c71a602c9b7318c0834aae1f2de90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_log_a_schur.py": "a0f1116ce27ecbff18de7089ce1f56714ed7966dfa0105b20419d408feb7ca41", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_lower.py": "027c77d8ce33c3d5e3c436234668f11bafc3de8658b9c3d03d455eb0e4d71f95", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_data.py": "de4f9df64cf31e94adb9a5d04b38d53d823d864f51632c49c7c80c6a46b5224d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/check_upper_merge.py": "95c9908134905e3ebdd030375e36a942c886cfc59edde3c6a419f36da6754780", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/CYCLIC-SCAN-CONTROLS.json": "4c37249f12b4cb4df847d179df8f378fbf1f42917e9fa703b2d847146f29b95c", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/DYADIC-INTERIOR-CONTROLS.json": "afbaee9f56f6a66fd9421bba7dfa8c3610c12bd447b01d0e9d79f97d1216aa90", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-CELL-CONTROLS.json": "4417a518ba3b6833f06b4f5e33d4f73ea74100b9110cf20e8d1c2070f1833fcc", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOG-A-SCHUR-CONTROLS.json": "046191420a24d8b2c063c190af5e954c85e39357902988c4df79f5abcdf1596d", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-CONTROLS.json": "323cb4acae960a6fa05527df5ede9d48e274883272b8ddb5151ebcee6dd26e52", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/LOWER-FACTOR.md": "dbc7eff783695e0f50fec57b0f7ca4212d51428eea04fa2ae5e0a9178fa69b30", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/README.md": "8fb5321b514af9260c44e150125205fe564efd073c456214f76bbdb358279cf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-ALGORITHM.md": "46b98b9c013dc5a94c9f17fd85acd7c1896c8e93ad2ee4a7c34f583895f1daf0", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-DATA-CONTROLS.json": "c9e6fd7f338f2cb78a0ed15ee944fde63549ae3d8522ab0874d184f3e252db76", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-LIFTING.md": "69535a48416a5435ea2a5ef4ecfe70fde30c32c4043bfc56f1ae2d7f49cd34bd", + "vendor/pr1673/capped-phase-fusion/evidence/gaussian_fast_ultra/UPPER-MERGE-CONTROLS.json": "c5729bdb36237c0691fba56d149019f78d94e996749532d907a84c35ef01319d", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_embedding.py": "597cb5304498456575c99d46a7fb503e04db28d5a7f57857b102b50f703b7464", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_halo.py": "0a3257cbb8f37b6cc9bb44019cb114ea2ae9b28738a416bff4bc712d1306e1b7", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_ragged.py": "54b761cfe3404d524af3a2abdf09bcea8dfb5cca6199c0c182cee310e3ca8c78", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/check_sparse_shear.py": "6e22c989e6bae92c4cd209c9336aad4359956cf370bdbd5f6b70609144598121", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/EMBEDDING-CONTROLS.json": "d0182e172f16b55ec64a5edfabb10816e416348ef2db15449f3ed4b47f3fec1f", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-CONTROLS.json": "ae370f7d7421f2f96e101a4b9d8082110507c47211220fd6ead065c2366aa828", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/MANIFEST.json": "37946d7691b90d39906d93581839bdf8ae2cf899d459e5520c39e782766e9327", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/PARAMETER-CHECK.json": "e38cdfc13f1959186d888383458c9030c4bd3c8c3915aea4743d55637d2f8d76", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-CONTROLS.json": "c3688f65565486b585727374abfbe478f7544aa61381bd73cc6ffa168b4221b6", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RAGGED-PERIODS.md": "c6e4dfe7f58dac7c5a513ffb3a9ab4801ab0717efae5c1e764e570335402ff25", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/README.md": "575a3acfc18a0e05ffe04a8563318a2770ce32cd7bf3a5e6123ce2de39a1cd4c", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/RECTANGULAR-EMBEDDING.md": "e64447bff7e7717802ee049290faaf29e45db3e36a6f7fcec109184478f15f26", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SPARSE-SHEAR-CONTROLS.json": "d3b9763f7ef6a3a5752c6c11a8a4d5f465646ad75b178a1c1b3363540fcc4871", + "vendor/pr1673/capped-phase-fusion/evidence/halo_layout_ultra/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/CORE-SOURCES.json": "2546f47dacc47c2d63dc5bb9cc52ef86c5e02ee159c4fb6e00dfac3f8f34d89c", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/core_review.md": "13f2df4d5b240f9b89ca0ae44bba198c935532098ff4c1161631fcbd86b3e8b1", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/gaussian_layout_review.md": "ebd7188970f55b5979b1b1a13f874a31ed0ee6c82bee329e7ad0b2a38c42c430", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/layout_subreview.md": "637e4698a9fb02978ebc4032d8939ce0db9528e89e908c94d63b9f0d2a41f64a", + "vendor/pr1673/capped-phase-fusion/evidence/independent_fusion_review_ultra/union_subreview.md": "738b35a04d6871cd73b14b4165ae69a1feb3a103eb46e064a64a22c4c7426856", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_circuits.py": "06d1861bfe8af543908e26557ffda7e451ff176bceb9bacfaf0f04f234b336d5", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_exact_algebra.py": "5ff7f25c55b370a1d0cda6c84ab9cdf2c7b0de3266d3f2e7a43280a6491074ab", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_supplier_capacity.py": "035ed96b39414eadec46e8de4bf3811b785862fd313deb044f42e17cf2ad3f78", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/check_tensor_compiler.py": "dc4b1f1884489215a2c2d0e8978a241e99e6c8c9f1d2fa2460c73d2c7d4ba30a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/CIRCUIT-REPLAY.json": "2ce5cf9ef9461e5897374ad389c26af66aeee85e8f514a9da4ed3bb2028cb1da", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/EXACT-ALGEBRA.json": "694898bfb1afcb3b8b8ef951634ac8919decdde0904350b355d254601ae3dc12", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/MANIFEST.json": "3b018dc660c6add775c12f75b9e8f5281825aeebc3888a508833ce6106c1229b", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/READING-COVERAGE.json": "756e52726b161eea27e27f1d519b05d4fb0ebf67ef9a67b33947194d5d02b709", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SOURCES.json": "fb3771f66771250aa9f4406ae9e7eb176f9cdef03976cbc9558440c674a4a94a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-AUDIT-SOURCES.json": "d0c274d6edd6193b09d28e45e7cbfe9236fb35474d35ea3af0664ba36f9e006a", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-CAPACITY-CONTROLS.json": "6922b7d7a936d53846569ad3be53fe4f3c63d6cfe794f9279fdc6a1fe411ef0c", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER-CONTROLS.json": "db8a5c0dc2be956d83bc7667177252a4968e0ffaee8352e6a5dba5ab983d7ada", + "vendor/pr1673/capped-phase-fusion/evidence/inplace_algebra_ultra/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/ALGEBRAIC-STABILITY-INDEPENDENT.md": "7873e7d9a99fdc9de3ee224b9925d3e277e9773d7f5f8c2d0f1c19b0e52bc87f", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/check_source_constructions.py": "9d387098403c0355be8e93158df02bae5a435b2366bd28efdf0b127e470c8c1c", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/evidence/matrix_boundary_ultra/SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-INTERIORS.md": "983c5cab2d2398f2192a8aec07daecb655f2de136e12a37f75672a14d27172ba", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/CAPPED-OUTER-ARITHMETIC.json": "22caac9ec2ecf4d5743b7eb946b633911fbac55a714399556e87e2eae0457dec", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_capped_outer.py": "b4555c77de7a3ed4abc708a8d93363ef7c9a914be1091f80ab3ddea83f71230a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_matrix_corollary.py": "30db2d8e0f40fcc5c91e25f74cdc54e46aa4a0353c725345f9bcf5744e0b617f", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/check_outer.py": "6a0c5f8956323615df8bc4b12996832471c0ae607d05429c9d70ad1b50568f10", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/README.md": "17c393075292b364899cb7c451cebbc9b20834f9fac934ce3740aba360c27246", + "vendor/pr1673/capped-phase-fusion/evidence/phase_assembly_ultra/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-LAYOUT-CONTROLS.json": "e6951790238b4998c632c95aa329ee2cd2527a5d74a2f28bd15249fec6d2419a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/CAPPED-SIGNOFF.md": "70e9175ebde200f8b016236adc88c4a1c4858945e7c3e5c453a8b6a5f79a263a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_capped_layout.py": "267d93ab5114ec160f88a6e65fd34c9f0696a686c36ba2dd194d6b70fa32a6bd", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_q_embedding.py": "ac858a14bbaf37e0e412a7ada282cd1586632f52b8a979733e775f50130969b6", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/check_union.py": "74608380d72567edcd4470c8d226b15848f9d3a4e5d77d652bdd8963480ab9ce", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MANIFEST.json": "c98559147bb498ac78af998eed63ab6661af934fa1a0df6844176b1811753fb9", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/PARAMETERS.json": "9f72cfffa34844764ca65a6b4431cc5c779141751df746019db9d3ad8f1dee92", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/Q-EMBEDDING-CONTROLS.json": "24ead3534482397c00c23ad3dbbd4e930e02290e00c97765353d8783c6575c7d", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/README.md": "0ec721f76dfa943e808afd3c2cc39ee69f1a6e5f4f77ba3c7c1373ad60db25af", + "vendor/pr1673/capped-phase-fusion/evidence/phase_layout_audit_ultra/UNION-CONTROLS.json": "6c5262144215cc603bbc3bee93a9a6d9d2318d0177a59115fe560762998498f9", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_constructions.py": "91387c9bd763a5c55c22a9907947bd07b6002f739aa6feedf6d3a02adea1e316", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_erasure_rounding.py": "486efd4692665a548b94b79877abb76ad13157268f05c270c4e75d8f97700795", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_fixed_a_ldu.py": "15134147317a7d789c9ea0ebd71db5ff11e59a20ef140f681d87478977734cd0", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_holes.py": "99c5dc4601ea88b553f52e235d36fba0aeb867e7fcd54130cdb3eb115a9bb0d8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_ledger.py": "254342c05949e5cefe4f507a35487e0a1ffb7137a60d2b97831d5ad55d7d7ce5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_nearest_neighbor.py": "21bf2be683cefa7a760bf1e1bdaa647f57bf47ab86b13fd7a74e8d650f492913", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_positive_tree.py": "46db2ce9122ff57bb4eeaa723db1f351891e671a7eaa7bf4fb61f85dafee9e37", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_q_ldu.py": "ec2589ca9abe71d674ba9ccf81f289b1526f56f3001c48d22977accb1be3e4dc", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/check_sylvester_factor.py": "60b21fda4ff451582087d30222a072eb1a214d531277e92883eaf28221aafced", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/CONTROLS.json": "12d9207e887fda73159a9e2e4776003ca6f905fc3dc45d77ced588a1c9f80cb2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/ERASURE-ROUNDING-CONTROL.json": "cceb2ade8ce5e18be3871f771955e38258f5eb4e39790c016aab96d8cf0488ef", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-LDU-CONTROLS.json": "d6bda457fff01e04b6565d84c7bdbac870569a2ba7ef18a1fc8db11b738faf38", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/FIXED-A-PERIODIC-NORM-AUDIT.md": "21027a569588922c491b2c5b4f31e01ddb784f1f20cdf48b7d482d0e85b66bdb", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-AND-Q-LDU.md": "c6a032ed495325806ddf491c5c85bc822a7fdd613aff906a7be553960d0f85a3", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/HOLES-CONTROLS.json": "3f7e98ce524d5fb2ba2f911a350081340215e806ae945abf15a2fa07988ca2f8", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/LEDGER.json": "87eab0eb334ddc16e50cedbcab56320d2ff056c3dc87d7a5191171bb5a4c206e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-CONTROLS.json": "b85eca6098847e7b2f77b49a6c8c35e33cf790bc5dd01b95e1334daef9af47f4", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/NEAREST-NEIGHBOR-NORM.md": "7955383d50fc59b5c4c4d839c7e4d630add6208a3a233d7372a80309085ac6b2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/PARTIAL-FUSION.md": "811a3a0c88a90708add5b12fb0a05c25623f0af155010d5dcacd56021c55cba5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/POSITIVE-TREE-CONTROLS.json": "7b31811402ddda4668fe8375f6c90a6047511d50836dbb7cfc7ffcf24fe19a11", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/Q-LDU-CONTROLS.json": "370a07aa1a56c656ec1f44d7651dfbe999ad0c19dede9036257cc2f29dc39452", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/README.md": "4d65ea3c8b6a0d5faef819a58c8b8277681d11bed54686e9a7f78de29736e68e", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/REFINED-PHASE-FUSION.md": "b4367eac012624f803b3d2e3a72339e050a0071bbec37e6d33b2cf322bd70bc5", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/STABLE-POSITIVE-TREE.md": "ec2f8a1c4273b81217545d2710bcffdd09b5c9ba9349e887b5f7bf6f5bddfdc7", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/SYLVESTER-CONTROLS.json": "198af9f58c2950f17d8b1861ba4566bb2f6a0108a889a56db328fe67f8faa1a2", + "vendor/pr1673/capped-phase-fusion/evidence/radical_reduction_ultra/TASK.md": "5eef77fb23f26f5bfb5dc8e376ed25e769924f2b6420ebfc8671e3b2a2f1f611", + "vendor/pr1673/capped-phase-fusion/FINAL-PACKAGE-REVIEW.json": "3457385de52d8e86853d96026a70aef2e8dece516db9eea020d8774e01d076a8", + "vendor/pr1673/capped-phase-fusion/FORWARD-SMALL-A-AUDIT.md": "e37aaa30b15671a1dff00676b14572213efaaac99df202dbba5e09f57af487c0", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/bind_native_admission.py": "166541ca2b7f3066f4c2421e5a9f1886d58e1fdd7677904976261ab2c82b32cb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/check_frontier_fusion.py": "02f7f9ebf29487331171954c7ceb37ff5315e2f28a9d56096ebbf9fb865c70ab", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/FRONTIER-FUSION-ARITHMETIC.json": "82656563e7c8725f95c4aea7e273805a3d3faf34c495a330f1c91a036765414a", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-RECEIPT.json": "49a8450289f1c1730c7d11d7c1506ad4af26fe9a1f76341f808a3025123e9519", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/INDEPENDENT-SUBSTITUTION-REVIEW.md": "b48d3e14083829db81336b639a6cfc698ac0dccc76fa2606d11b4be7a968ddeb", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/independent_substitution_check.py": "579bbde41e90792818c2726b38dcab26cf5a2695d3348731e814175146b0a737", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/NATIVE-ADMISSION-BINDING.json": "ec4e89e0513958c1d553736cd06eedbc5f2aca61b40f92aeade3eb882bf588bc", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/REPRODUCE.txt": "76808b685f1623813658f5b596a4b8191a07e7c0810550f6fada7fb4a4992913", + "vendor/pr1673/capped-phase-fusion/frontier_fusion/T74-APPENDIX.tex": "d053a6b69de2ff4005ee52eb3b673de606326aa0f0e290354675f9f08f915b99", + "vendor/pr1673/capped-phase-fusion/gaussian_fixed_width_note.tex": "6f3edb7b238f2b6af4f3e2d98dee90fe6f4ba063a5ccd120422e45c941712aab", + "vendor/pr1673/capped-phase-fusion/HALO-THEOREM.md": "cb9e1da38400b658f9209e465b4e5896fadd17dc66afa862f38bae8d8c1f2058", + "vendor/pr1673/capped-phase-fusion/INDEPENDENT-FINAL-REVIEW.json": "6b98e5222aa109a35be8b4fc9ec19669daebcc06d542ecec0a9c820da7930501", + "vendor/pr1673/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272", + "vendor/pr1673/capped-phase-fusion/make_native_capsule.py": "8f342ca212b8d601a11f704042c577c1b088e0079bda04b3065467c2f3c36ea0", + "vendor/pr1673/capped-phase-fusion/MANIFEST-UPDATE.json": "32c58bcab8e19ef895660331c13d31b5fae7d0c95f7cda4147870f29d8299f6d", + "vendor/pr1673/capped-phase-fusion/MANIFEST.json": "9af581d640e9c69d513256cf69babb0717287642134cfc807cedcd79966c1706", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-ARITHMETIC.json": "c6efc4d2f6d17159cefebf5c2dd6099a6327fe0911c5dd87623cad96c7d6c56a", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY-REVIEW.json": "5cd5e97f93a9b3e439bfeffb52139d7bb1730de96ad13b59b7e1b20fdca6a3f6", + "vendor/pr1673/capped-phase-fusion/MATRIX-COROLLARY.md": "2d7fb1088e58bb86e574277733e082f135362215a69add71d9090213d32c9221", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-CONTROLS.json": "f8bd8729cb8438188e90fb9149f598b825461c97b4ed290584ca4367f812a48a", + "vendor/pr1673/capped-phase-fusion/MATRIX-LAYOUT-SIGNOFF.md": "4c8c62f723232e842dc3bbdcc4defcc8ff1aeb86ba9f694661899dc6783b13c4", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-CONSTRUCTIONS.json": "114c1d8fb70592455a80c73d8a1bc6bfc9aca4e7395a420b6331d5474b4d1917", + "vendor/pr1673/capped-phase-fusion/MATRIX-SOURCE-COVERAGE.json": "fdc6849f97999a6cf99cdaa50591d24f78d6fb0bc580315f205452e5906b35cc", + "vendor/pr1673/capped-phase-fusion/MATRIX-TRANSFER-MANIFEST.json": "35d98d7579a16dae36530b4e5f4d0b8f925a069daa3f6fe1ea5276916167e0c2", + "vendor/pr1673/capped-phase-fusion/NATIVE-RECEIPT-CAPSULE.json": "a04d6bba3d15c11a219536b66a23012797484ae106ec1952ecd7b76f077ddb01", + "vendor/pr1673/capped-phase-fusion/OUTER-ARITHMETIC.json": "050c61d90236c593fd0827d7edc297e05604884e4ec093659aee46a9ee336020", + "vendor/pr1673/capped-phase-fusion/OUTER-AUDIT.md": "94799bfa2794eb867d6ba68593c3e92988ade083e74d895e8d07ae3b8d0670dc", + "vendor/pr1673/capped-phase-fusion/PACKAGE-MANIFEST.json": "298f1eaf79b5d5d57cb96fb3abb422174b78c31c14491a878f6176431d731d04", + "vendor/pr1673/capped-phase-fusion/PHASE-LAYOUT-AUDIT.md": "54aafc7afd09fe1a5312e69fad09c87422690543ab75c6ae35f6cbcc26b3eb8a", + "vendor/pr1673/capped-phase-fusion/phase_fusion_note.tex": "b5957f38c98a68f2584a42cedf91d753180dab438129fdf749b441074f00d4e1", + "vendor/pr1673/capped-phase-fusion/PROOF-AND-COVERAGE.md": "db7509d754bb7fc3381419e0fed2674f22a9d57d34e8420fd5afa3c688fde9aa", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-CHECKS.json": "6e2fb68e6768c3aa4224aacb4900263586fc8114815a51df40f3f9fdf6124217", + "vendor/pr1673/capped-phase-fusion/PUBLICATION-SOURCES.json": "6082583794168b1c2320187214b86c93a5a6e76fbbddfcb3bdbb8c5bd34c0586", + "vendor/pr1673/capped-phase-fusion/README.md": "91af88b8fc53a22e1e968908f0e449cdfe2154c83f0dddb8a504e661c0c6965c", + "vendor/pr1673/capped-phase-fusion/REVIEW-RECEIPT.json": "97b20e50d3722fcde3831124a107df6c15c0ffdbb9e057b7867f41aaa2481800", + "vendor/pr1673/capped-phase-fusion/ROOT-EXACT-REPLAY.json": "d36114abe9d7a83c327f49f5ea153c6dcada4a7421f5e74a9a5ceb392cecb994", + "vendor/pr1673/capped-phase-fusion/ROOT-MATRIX-EXACT-REPLAY.json": "d6bd4fcb8a528655181b4aa3fd1bad7e6647a4ca5aa76ee7f2cdd800b698b225", + "vendor/pr1673/capped-phase-fusion/SHALLOW-TOEPLITZ.md": "b384b93f3fb4a8c97da2e617ebc14d55cebb0a739070e7f8dbb66f63e24e9310", + "vendor/pr1673/capped-phase-fusion/SOURCES.json": "14ce6fdc7c83e18ccf4fee19ff51062726c960ca44462a45af60dd686167d456", + "vendor/pr1673/capped-phase-fusion/SUPPLIER-SUPPORT-AUDIT.md": "bd5b06eca043c5c871227264f6a954473c55cd16ec85bb420ff538fb8ec1d8d6", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ADVERSARIAL-AUDIT.md": "b1290f8720bf075ea2ad58d6070f3e1fc95c0155f8e33b165bc13439bbb9222d", + "vendor/pr1673/capped-phase-fusion/SUPPORT-ROUTER.md": "6ddb322e11883c1177ba6cd1a77d23a1dac827d7290b32eaf642457b1d762a54", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/RESULT.json": "11c57817a4d43a489010a13af7621d37eeedc398308c036e63a2a97119443861", + "vendor/pr1673/capped-phase-fusion/target002_upstream/full-1661-verification/STAGES.json": "c2edb01a61c03e04bf48e605422ff83c1d304e4d586268959d4ea24b743640fb", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/CLAIM.json": "70aacd45f9e6fac8675687cf50da32e0ad4e479d9a5c28f2afd1550311ae8849", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/MANIFEST.json": "d90d49eaa68e48c6992a07972e736ef4b9cd80274361cbbc1ec980d43f29ad7f", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/new/SPEC.json": "d6b6a2140f3a61ae8cfdd8b51a1131934d63d2dd8573c1b13eb2b9528f3c3db8", + "vendor/pr1673/capped-phase-fusion/target002_upstream/pr1661/research/gmx-t74-p566-ep400/NOTICE": "3918a42010a435782de0fe8c38fab8f7df5d48a375ecf603c2bad1b818a16d6f", + "vendor/pr1673/capped-phase-fusion/TASK.json": "47b82ef23e20991010fae838ad4da9bdac3f947a8fea916a028fd6260f95f5f8", + "vendor/pr1673/capped-phase-fusion/TENSOR-COMPILER.md": "4d3b8466598a864a234b978e25976648d4e761840aad9153dd18d73d3dfe4d15", + "vendor/pr1673/capped-phase-fusion/VERIFIER-NEGATIVE-CONTROLS.json": "eeb887cdc0c76426c75ddbfc3d4af7ccbbe19d17962c6ad7a1549dafe8dabb5a", + "vendor/pr1673/capped-phase-fusion/VERIFY.json": "cb50aa523a0863a457181ca815e69a1b3b4d91ed1006a79263f4a8f18457c669", + "vendor/pr1673/capped-phase-fusion/verify.py": "93ef0f46e132485da6194587199b8f039e25b1b9f099f93bbdaeac5c0d66de7f", + "vendor/pr1786/FINE-PRIME-PADDING.md": "47d1b1b4df28aadda3cd6bdeb1fbc47290595e9208cd09c1a1f338520d33fdce", + "vendor/pr1786/NOTICE.md": "dcc1adb2461aa93ca62b6a912dbd8b215599e6af8053dfbacb7423b544dd659a", + "verify.py": "c52149ed10c0cae4950c92cef0edc38f382c5cc74cf66c5eeeebb7191b4bc0a0", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "c43680a2da390f79925547a5ee1919d8a76637cccf98e2c8164b6f667fbc3183" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/new/rebuild_borrow.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/new/rebuild_borrow.py new file mode 100644 index 0000000000..9b310547f4 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/new/rebuild_borrow.py @@ -0,0 +1,269 @@ +"""rebuild_borrow.py: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), +check they equal the shipped borrow/words byte-for-content, run the extended auditor (borrow/audit_local.py) and its negative controls. +usage: python -B rebuild_borrow.py [--no-controls] (exit 0 only if everything passes)""" +import sys,json,gzip,subprocess,hashlib,tempfile +from pathlib import Path +D=Path(__file__).resolve().parent/'borrow';sys.path.insert(0,str(D)) +import os +RCP=Path(os.environ['BORROW_RECEIPTS']) if os.environ.get('BORROW_RECEIPTS') else Path(tempfile.mkdtemp());RCP.mkdir(parents=True,exist_ok=True) # receipts (with elapsed_seconds) never go into the package during verification +import build_word,word_patch +CASES=[('gauge44','base','eeb6a236'),('extra','extra','cd417b90')] +def content(p):return hashlib.sha256(gzip.decompress(Path(p).read_bytes())).hexdigest() +def refit_apply(word0,patch): + """frame refit: replace exactly the listed gate frames (gates unchanged) and the local profile.""" + import copy + w=copy.deepcopy(word0) + for sec,i,fr in patch['frames']: + assert w[sec][i][:-1]==word0[sec][i][:-1];w[sec][i][-1]=fr + w['report']['local_profile']=patch['local_profile'] + return w +def run_audit(word,base,rec): + cmd=[sys.executable,'-B',str(D/'audit_local.py'),'--word',str(word),'--output',str(rec)]+(['--base',str(base)] if base else []) + return subprocess.run(cmd,capture_output=True,text=True) +def kernel_check(prev,w,patch): + """The kernel edit(s) (helper-donor pivot kernels, PR1625 shape): the shipped B section differs from the previous word's by exactly the declared gate-level edit + (frames ignored): reads of the pivots inserted/deleted, nothing else; every inserted and deleted gate is a read of a declared pivot with coefficient +-1.""" + qs=set(patch['pivots']);ed=word_patch.kernel_gate_edit(prev['B'],w['B']) + ok=ed==patch['declared_gate_edit'] and all(g[0]=='add' and g[2] in qs and abs(g[3])==1 and g[4]==1 for _,_,g in ed) + ok&=sum(e[0]=='delete' for e in ed)==len(qs) and sum(e[0]=='insert' for e in ed)==4*len(qs) + for k in w: + if k not in('A','B','restore','warps','report','cleanup'):ok&=w[k]==prev[k] + for k in('A','restore'): # frame-only changes outside B + ok&=len(w[k])==len(prev[k]) and all(x[:-1]==y[:-1] for x,y in zip(w[k],prev[k])) + return ok +def kernel_controls(w,patch,tmp): + """every perturbation of the kernel edit must be rejected by the independent audit""" + import copy + res={};qs=set(patch['pivots']) + pos=[j for kind,j,g in patch['declared_gate_edit'] if kind=='insert'] + def audit_bad(name,m): + bp=Path(tmp)/(name+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode())) + r=run_audit(bp,None,Path(tmp)/(name+'.out.json'));res[name]=r.returncode!=0;return r.returncode!=0 + ok=True + m=copy.deepcopy(w);m['B'][pos[0]][3]=-m['B'][pos[0]][3];m['cleanup']=word_patch.derive_cleanup(m,word_patch.restored_of(w));ok&=audit_bad('kernel_sign_flipped',m) + m=copy.deepcopy(w);del m['B'][pos[1]];ok&=audit_bad('kernel_read_dropped',m) + m=copy.deepcopy(w);m['B'][pos[2]][3]*=2;ok&=audit_bad('kernel_coefficient_doubled',m) + m=copy.deepcopy(w);m['B'][pos[3]][1]=m['B'][pos[3]][1]+1;ok&=audit_bad('kernel_read_moved_to_neighbour_register',m) + return ok,res +def _rd(m,ref): + """re-derive the explicit inverse-reverse cleanup of a mutated word (A section without its prelude), so a control is rejected for its own reason and not for a stale cleanup""" + try: + t=json.loads(json.dumps(m));t['A']=t['A'][t.get('prelude_events',0):];return word_patch.derive_cleanup(t,word_patch.restored_of(ref)) + except Exception: + return m['cleanup'] +ok=True;out={} +for canon,wt,h in CASES: + tmp=Path(tempfile.mkdtemp())/'w.json.gz' + build_word.main(str(D/'inputs'/f'{canon}.canonical.json.gz'),str(D/'inputs/blocks.json'),str(D/'inputs'/f'witness_43_{wt}.json'),str(tmp),h) + shipped=D/'words'/f'BORROW-WORD-43{"base" if wt=="base" else "extra"}.json.gz' + base=str(D/'inputs'/f'{canon}.canonical.json.gz') + word0=json.loads(gzip.decompress(tmp.read_bytes())) + chain=[word0];steps=[] + rf=D/'inputs'/f'refit_43{wt}.json';kf=D/'inputs'/f'kernel_43{wt}.json' + if rf.exists():chain.append(refit_apply(chain[-1],json.loads(rf.read_text())));steps.append('refit') + kpatch=json.loads(kf.read_text());kpre=chain[-1];chain.append(word_patch.apply_kernel(chain[-1],kpatch));steps.append('kernel');kstate=chain[-1] + kok=kernel_check(kpre,kstate,kpatch) + hf=D/'inputs'/f'handoff_43{wt}.json';hpatch=None + if hf.exists(): # coherent four-helper handoff (PR2322, Vlado-V) on top of the kernel state: four high roles replaced by retired source registers + hpatch=json.loads(hf.read_text());chain.append(word_patch.apply_handoff(kstate,hpatch));steps.append('handoff') + kok&=sorted(hpatch['fields'])==sorted(k_ for k_ in chain[-1] if k_ not in('report','cleanup') and chain[-1][k_]!=kstate[k_]) and len(chain[-1]['removed'])==len(kstate['removed'])+4 + ef=D/'inputs'/f'entrance_43{wt}.json' + if ef.exists(): # entrance raise: start_extra and frames only (gates unchanged); previous state audited, tamper controls below + epatch=json.loads(ef.read_text());prev_e=chain[-1];chain.append(word_patch.apply_handoff(prev_e,epatch));steps.append('entrance') + kok&=all(x_[:-1]==y_[:-1] for k_ in('A','B','restore') for x_,y_ in zip(chain[-1][k_],prev_e[k_])) and chain[-1]['removed']==prev_e['removed'] and chain[-1]['warps']==prev_e['warps'] + lf=D/'inputs'/f'lowfour_43{wt}.json';lpatch=None + if lf.exists(): # four low aliases through lifted-target compensation (PR2436 mechanism) on top of the entrance state + lpatch=json.loads(lf.read_text());prev_l=chain[-1];chain.append(word_patch.apply_lowfour(prev_l,lpatch));steps.append('lowfour') + nw=chain[-1];kok&=word_patch.kernel_gate_edit(prev_l['B'],nw['B'])==lpatch['declared_gate_edit'] and sorted(set(nw['removed'])-set(prev_l['removed']))==[640,641,642,644]==lpatch['derived_removed_diff'] + kok&=[x[1:] for x in nw['warps'][:len(prev_l['warps'])]]==[x[1:] for x in prev_l['warps']] and [x[1] for x in nw['warps'][-4:]]==[33,55,74,85] and len(nw['warps'])==len(prev_l['warps'])+4 + kok&=[g[:-1] for g in nw['A'][nw['prelude_events']:]]==[g[:-1] for g in prev_l['A']] and nw['restore']==prev_l['restore'] and nw['helper_final']==prev_l['helper_final'] + kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('640','641','642','644')}==nw['start_extra'] + af=D/'inputs'/f'alias637_43{wt}.json';apatch=None + if af.exists(): # alias 637 borrowing retired source 31 (PR2436 pair) stacked on the four lifted-target aliases + apatch=json.loads(af.read_text());prev_a=chain[-1];chain.append(word_patch.apply_lowfour(prev_a,apatch));steps.append('alias637');na=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a['B'],na['B'])==apatch['declared_gate_edit'] and sorted(set(na['removed'])-set(prev_a['removed']))==[637] and len(na['warps'])==len(prev_a['warps'])+1 and na['restore']==prev_a['restore'] and na['A']==prev_a['A'] + af2=D/'inputs'/f'alias656_43{wt}.json';apatch2=None + if af2.exists(): # alias 656 borrowing lender 88 (PR2436 type) stacked on the fifth alias + apatch2=json.loads(af2.read_text());prev_a2=chain[-1];chain.append(word_patch.apply_lowfour(prev_a2,apatch2));steps.append('alias656');na2=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a2['B'],na2['B'])==apatch2['declared_gate_edit'] and sorted(set(na2['removed'])-set(prev_a2['removed']))==[656] and len(na2['warps'])==len(prev_a2['warps'])+1 and na2['restore']==prev_a2['restore'] and True + af3=D/'inputs'/f'alias8_43{wt}.json';apatch3=None + if af3.exists(): # eight source-partner aliases (PR2530) (PR2530 zxv: eight source-partner aliases) + apatch3=json.loads(af3.read_text());prev_a3=chain[-1];chain.append(word_patch.apply_lowfour(prev_a3,apatch3));steps.append('alias8');na3=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_a3['B'],na3['B'])==apatch3['declared_gate_edit'] and sorted(set(na3['removed'])-set(prev_a3['removed']))==apatch3['removed_added'] and len(na3['warps'])==len(prev_a3['warps'])+8 and True and True + pf=D/'inputs'/f'prelife_43{wt}.json';ppatch=None + if pf.exists(): # pre-life hosting (this package): six cold width-4 hosts h each host the whole life of a width-9 dim-0-start helper L after retiring + ppatch=json.loads(pf.read_text());prev_p=chain[-1];chain.append(word_patch.apply_prelife(prev_p,ppatch));steps.append('prelife');npl=chain[-1] + PLs=sorted(x_['L'] for x_ in ppatch['pairs']);PHs=[x_['h'] for x_ in ppatch['pairs']] + kok&=PLs==[482,483,494,495,507,519] and sorted(set(npl['removed'])-set(prev_p['removed']))==PLs and set(prev_p['removed'])<=set(npl['removed']) + kok&=sorted(set(prev_p['helper_final'])-set(npl['helper_final']))==sorted(map(str,PHs)) and all(npl['helper_final'][k_]==prev_p['helper_final'][k_] for k_ in npl['helper_final']) + kok&=npl['warps'][:len(prev_p['warps'])]==prev_p['warps'] and [x_[1] for x_ in npl['warps'][len(prev_p['warps']):]]==PHs + kok&=npl['compensation']==[e_ for e_ in prev_p['compensation'] if not(e_[0]=='add' and e_[2] in set(PLs))] # the hosted helpers' dirt-compensation reads are removed ... + kok&=all(c_ in prev_p['initial_corrections'] or (c_['source'] in set(PHs) and len(c_['operator_word'])==1 and npl['warps'][c_['operator_word'][0]-1][1]==c_['source']) for c_ in npl['initial_corrections']) # ... and replaced by anticipatory corrections through the host's warp + kok&=word_patch.kernel_gate_edit(prev_p['B'],npl['B'])==ppatch['declared_gate_edit'] + kok&=all(npl[k_]==prev_p[k_] for k_ in ('A','precondition','cut','start_extra','target_levels','centers','center_frames','ports','prelude_events')) + rf2=D/'inputs'/f'refit563_43{wt}.json';rpatch2=None + if rf2.exists(): # one-gate exact frame lowering (B 894, add 515 += 563: dim 6 -> 5) so that 563 retires at the dimension of 653's entrance frame (this package) + rpatch2=json.loads(rf2.read_text());prev_r=chain[-1];chain.append(refit_apply(prev_r,rpatch2));steps.append('refit563');nr=chain[-1] + kok&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',894] and prev_r['B'][894][:5]==['add',515,563,1,1] + kok&=len(nr['B'][894][-1])==len(prev_r['B'][894][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=894) + kok&=not({515,563}&({x_['L'] for x_ in ppatch['pairs']}|{x_['h'] for x_ in ppatch['pairs']}) if ppatch else set()) + xf=D/'inputs'/f'alias1_43{wt}.json';xpatch=None + if xf.exists(): # retired-lender alias 653<-563 on the refit state (this package) + xpatch=json.loads(xf.read_text());prev_x=chain[-1];chain.append(word_patch.apply_lowfour(prev_x,xpatch));steps.append('alias1');nx=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_x['B'],nx['B'])==xpatch['declared_gate_edit'] and sorted(set(nx['removed'])-set(prev_x['removed']))==[653] and len(nx['warps'])==len(prev_x['warps'])+1 and nx['A']==prev_x['A'] and nx['restore']==prev_x['restore'] + kok&=all(g_[0]=='add' and 563 in g_[1:3] for kd_,_,g_ in xpatch['declared_gate_edit'] if kd_=='insert') and nx['warps'][-1][1]==563 + # exhaustive enumeration of retired-lender aliases (borrow/alias_enumerate.py): on the pre-life + refit563 state exactly one pair (653<-563) exists; none on the shipped word + import alias_enumerate as AE,tempfile as tf_ + def enum_(w_): + p_=Path(tf_.mkdtemp())/'w.json.gz';p_.write_bytes(gzip.compress(json.dumps(w_,separators=(',',':')).encode(),mtime=0));o_,s_=AE.main(str(p_));return o_,dict(s_) + e0,s0=enum_(prev_x);e1,s1=enum_(nx) + kok&=[(x_['h'],x_['L']) for x_ in e0]==[(653,563)] and len(e1)==0 + (RCP/f'ALIAS-ENUMERATION-43{wt}.json').write_text(json.dumps(dict(prelife_refit_state=dict(counts=s0,pairs=[{k_:x_[k_] for k_ in('h','L','p1','d','s','f1','width','dprof')} for x_ in e0]),shipped=dict(counts=s1,pairs=len(e1)), + note='counts: h_used_in_A_or_early = helpers first used before B (needs the prelude/lifted-target mechanism); the other counts are (h,L) pairs failing that condition'),indent=1)+'\n') + tf_=D/'inputs'/f'twelve_43{wt}.json';tpatch=None + if tf_.exists(): # PR2751's twelve-alias reassignment with the frame re-solve of the final word (this package); no phase-B warps + tpatch=json.loads(tf_.read_text());prev_t=chain[-1];chain.append(word_patch.apply_lowfour(prev_t,tpatch));steps.append('twelve');nt_=chain[-1] + pre_t_path=Path(tempfile.mkdtemp())/'pre-twelve.json.gz';pre_t_path.write_bytes(gzip.compress(json.dumps(prev_t,separators=(',',':')).encode(),mtime=0)) # earlier-stage controls run on the state they were written for + kok&=word_patch.kernel_gate_edit(prev_t['B'],nt_['B'])==tpatch['declared_gate_edit'] + kok&=nt_['report']['width_inventory']==prev_t['report']['width_inventory'] and not any(e_[0]=='warp' for e_ in nt_['B']) + r7f_=D/'inputs'/f'retired7_43{wt}.json';r7patch=None + if r7f_.exists(): # PR2802's seven retired-lender aliases and two hostee moves, one declared patch on the twelve state (this package) + r7patch=json.loads(r7f_.read_text());prev_7=chain[-1];chain.append(word_patch.apply_lowfour(prev_7,r7patch));steps.append('retired7');n7_=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_7['B'],n7_['B'])==r7patch['declared_gate_edit'] and not any(e_[0]=='warp' for e_ in n7_['B']) + kok&=n7_['target_levels']==prev_7['target_levels'] and n7_['prelude_events']==prev_7['prelude_events'] and n7_['centers']==prev_7['centers'] + def_=D/'inputs'/f'dirtentry_43{wt}.json';depatch=None + if def_.exists(): # dirt-entry rewrite of helpers 530/542 (this package): four inserted entry gates, the listed compensation gates removed, entry frames [30] + depatch=json.loads(def_.read_text());prev_d=chain[-1];chain.append(word_patch.apply_lowfour(prev_d,depatch));steps.append('dirtentry');nd_=chain[-1] + kok&=word_patch.kernel_gate_edit(prev_d['B'],nd_['B'])==depatch['declared_gate_edit'] and not any(e_[0]=='warp' for e_ in nd_['B']) + kok&=[g_ for g_ in prev_d['compensation'] if g_ not in nd_['compensation']]==depatch['declared_compensation_removed'] and all(g_ in prev_d['compensation'] for g_ in nd_['compensation']) + kok&=len(prev_d['compensation'])-len(nd_['compensation'])==len(depatch['declared_compensation_removed']) and nd_['helper_final']==prev_d['helper_final'] and nd_['target_levels']==prev_d['target_levels'] + final=json.loads(gzip.decompress(shipped.read_bytes())) + same=final==chain[-1] + # lifted-target offsets: the shipped word's set (and frames) must equal the one declared by the last patch input that declares target_levels + _tl_decl=None + for _pn in ('lpatch','apatch','apatch2','apatch3','tpatch'): + _pv=locals().get(_pn) + if _pv and 'target_levels' in _pv.get('fields',{}):_tl_decl=_pv['fields']['target_levels'] + tl_ok=lambda w_:_tl_decl is not None and w_['target_levels']==_tl_decl + kok&=tl_ok(final) + # audits: the pinned pre-refit/pre-kernel word against the canonical base; every later state independently (forward + dual free-algebra replay; refit and kernel change frames inside the pinned sections) + tag=lambda n:RCP/f'AUDIT-43{wt}{n}.json' + pw=Path(tempfile.mkdtemp());ps=[] + for j,w_ in enumerate(chain[:-1]): + f_=pw/f'w{j}.json.gz';f_.write_bytes(gzip.compress(json.dumps(w_,separators=(',',':')).encode())) + r=run_audit(f_,base if j==0 else None,tag('-pinned' if j==0 else '-prekernel'));ps.append(r.returncode) + r=run_audit(shipped,None,tag('')) + ok&=same and kok and all(x==0 for x in ps) and r.returncode==0 + res=dict(rebuild_plus_patches_equals_shipped=same,patches=steps,kernel_edit_exact=kok,prior_state_audit_rc=ps,audit_rc=r.returncode) + if '--no-controls' not in sys.argv: + import copy as cp9 + _m1=cp9.deepcopy(final);_m1['target_levels'].pop(sorted(_m1['target_levels'],key=int)[0]);_m2=cp9.deepcopy(final);_m2['target_levels'][str(next(t_ for t_ in range(112) if str(t_) not in final['target_levels']))]=next(iter(final['target_levels'].values()));_m3=cp9.deepcopy(final);_m3['target_levels'][sorted(_m3['target_levels'],key=int)[0]]=[999] + res['target_offsets_declared']=tl_ok(final);res['target_offset_missing_rejected']=not tl_ok(_m1);res['target_offset_extra_rejected']=not tl_ok(_m2);res['target_offset_changed_rejected']=not tl_ok(_m3) + ok&=res['target_offsets_declared'] and res['target_offset_missing_rejected'] and res['target_offset_extra_rejected'] and res['target_offset_changed_rejected'] + print('TARGET-OFFSETS',wt,'declared by patch input',len(_tl_decl),'missing/extra/changed rejected',res['target_offset_missing_rejected'],res['target_offset_extra_rejected'],res['target_offset_changed_rejected'],flush=True) + c=subprocess.run([sys.executable,'-B',str(D/'borrow_controls.py'),str(tmp),base,str(RCP/f'CONTROLS-43{wt}.json')],capture_output=True,text=True) + ok&=c.returncode==0;res['controls_rc']=c.returncode + if lpatch: + lc=subprocess.run([sys.executable,'-B',str(D/'lowfour_controls.py'),str(pre_t_path if tpatch else shipped),str(RCP/f'CONTROLS-LOWFOUR-43{wt}.json')],capture_output=True,text=True) + ok&=lc.returncode==0;res['lowfour_controls_rc']=lc.returncode + if ppatch: + pw_=Path(tempfile.mkdtemp())/'orig.json.gz';pw_.write_bytes(gzip.compress(json.dumps(prev_p,separators=(',',':')).encode(),mtime=0)) + pc=subprocess.run([sys.executable,'-B',str(D/'prelife_controls.py'),str(shipped),str(pw_),str(RCP/f'CONTROLS-PRELIFE-43{wt}.json')],capture_output=True,text=True) + pc_ok=pc.returncode==0 and json.loads((RCP/f'CONTROLS-PRELIFE-43{wt}.json').read_text())['all_rejected_for_expected_reason'];ok&=pc_ok;res['prelife_controls_ok']=pc_ok + if rpatch2: # control: the shipped word with the B 894 frame restored to its un-refitted (dim 6) frame must be rejected (the 653<-563 warp then starts from the wrong frame) + import copy as cp6 + m=cp6.deepcopy(prev_t if tpatch else final);m['B'][894][-1]=prev_r['B'][894][-1];bp=Path(tempfile.mkdtemp())/'refit563_undone.json.gz';bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode(),mtime=0)) + br=run_audit(bp,None,bp.parent/'refit563_undone.out.json');ru=br.returncode!=0 and 'warp frame mismatch' in (br.stdout+br.stderr);res['refit563_undone_rejected_by_warp_frame_mismatch']=ru;ok&=ru + if xpatch: + xc=subprocess.run([sys.executable,'-B',str(D/'alias1_controls.py'),str(pre_t_path if tpatch else shipped),str(xf),str(RCP/f'CONTROLS-ALIAS1-43{wt}.json')],capture_output=True,text=True) + ok&=xc.returncode==0;res['alias1_controls_rc']=xc.returncode + okc=[] + def stage_controls(state,patch,pre): # tamper controls on the gates changed by a declared stage; each mutant carries the cleanup re-derived from its own forward word + import copy as cp7 + _ins=[i_ for i_,e_ in enumerate(state['B']) if e_[0]=='add' and any(k_=='insert' and g_==e_[:-1] for k_,_,g_ in patch['declared_gate_edit'])] + def _rd7(m): + t_=cp7.deepcopy(m);t_['A']=m['A'][m['prelude_events']:];m['cleanup']=word_patch.derive_cleanup(t_,{int(q_) for q_ in m['helper_final']});return m + def _mk7(f_): + m=cp7.deepcopy(state);f_(m);return _rd7(m) + for _nm7,_mut7 in ((pre+'_gate_sign_flipped',lambda m:m['B'][_ins[0]].__setitem__(3,-m['B'][_ins[0]][3])), + (pre+'_gate_coefficient_doubled',lambda m:m['B'][_ins[0]].__setitem__(3,2*m['B'][_ins[0]][3])), + (pre+'_gate_dropped',lambda m:m['B'].pop(_ins[0])), + (pre+'_warp_dropped',lambda m:m['warps'].pop(0)), + (pre+'_target_frame_changed',lambda m:m['target_levels'].__setitem__(sorted(m['target_levels'],key=int)[0],[30]))): + m=_mk7(_mut7);bp=pw/(_nm7+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(_nm7+'.out.json'));res[_nm7+'_rejected']=br.returncode!=0;okc.append(br.returncode!=0) + print(pre.upper()+'-CONTROLS',wt,{k_:v_ for k_,v_ in res.items() if k_.startswith(pre+'_')},flush=True) + if tpatch:stage_controls(nt_,tpatch,'twelve') + if r7patch:stage_controls(n7_,r7patch,'retired7') + if depatch: + import copy as cp3 + def _rdd(m): + t_=cp3.deepcopy(m);t_['A']=m['A'][m['prelude_events']:];m['cleanup']=word_patch.derive_cleanup(t_,{int(q_) for q_ in m['helper_final']});return m + _ins=[i_ for i_,e_ in enumerate(final['B']) if e_[0]=='add' and any(k_=='insert' and g_==e_[:-1] for k_,_,g_ in depatch['declared_gate_edit'])] + def _mkd(f_): + m=cp3.deepcopy(final);f_(m);return _rdd(m) + def _bad(m): + return m + for _nmd,_mutd in (('dirtentry_injection_dropped',lambda m:m['B'].pop(_ins[0])), + ('dirtentry_injection_sign_flipped',lambda m:m['B'][_ins[0]].__setitem__(3,-m['B'][_ins[0]][3])), + ('dirtentry_injection_wrong_time',lambda m:(lambda g_,r_:m['B'].insert(max(i_ for i_,e_ in enumerate(m['B']) if e_[0]=='add' and r_ in e_[1:3])+1,m['B'].pop(_ins[0])))(m['B'][_ins[0]],m['B'][_ins[0]][2])), + ('dirtentry_removal_missing',lambda m:m['compensation'].append(cp3.deepcopy(depatch['declared_compensation_removed'][0])))): + m=_mkd(_mutd);bp=pw/(_nmd+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(_nmd+'.out.json'));res[_nmd+'_rejected']=br.returncode!=0;okc.append(br.returncode!=0) + print('DIRTENTRY-CONTROLS',wt,{k_:v_ for k_,v_ in res.items() if k_.startswith('dirtentry_')},flush=True) + ok&=all(okc) + kc_ok,kc=kernel_controls(kstate,kpatch,tempfile.mkdtemp());ok&=kc_ok;res['kernel_controls_rejected']=kc + if apatch: + import copy as cp4 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias637_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias637_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias637_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp4.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if apatch2: + import copy as cp5 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a2['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias656_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias656_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias656_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp5.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if apatch3: + import copy as cp6 + ii=next(q for q,(x,y) in enumerate(zip(final['B'],prev_a3['B'])) if x[:-1]!=y[:-1] and x[0]=='add') + for nm_,mut in (('alias8_sign_flipped',lambda m:m['B'][ii].__setitem__(3,-m['B'][ii][3])),('alias8_coefficient_doubled',lambda m:m['B'][ii].__setitem__(3,2*m['B'][ii][3])),('alias8_warp_dropped',lambda m:m.__setitem__('warps',m['warps'][:-1]))): + m=cp6.deepcopy(final);mut(m);m['cleanup']=_rd(m,final);bp=pw/(nm_+'.json.gz');bp.write_bytes(gzip.compress(json.dumps(m,separators=(',',':')).encode()));br=run_audit(bp,None,pw/(nm_+'.out.json'));kc[nm_]=br.returncode!=0;ok&=br.returncode!=0 + if ef.exists(): + import copy as cp3 + q=next(iter(epatch['fields']['start_extra'])); + for nm_,mut in (('entrance_start_frame_dropped',lambda m:m['start_extra'].__setitem__(q,[])),('entrance_start_frame_widened',lambda m:m['start_extra'].__setitem__(q,[1<0 + ok&=not gv and res['cut_centre_guard_negative_control_rejected'] + print('CUT-CENTRE-GUARD',wt,'cut gates',len(final['cut']),'violations',len(gv),'negative control rejected',res['cut_centre_guard_negative_control_rejected'],flush=True) + # HELPER-INDEX GUARD (PR2508, ywz65): audit_local accepts a negative helper_final key that aliases a target endpoint; every helper_final key must be a canonical non-negative decimal inside the helper interval [2v, 2v+R). + import guard_helper_indices as ghi + hv=ghi.violations(final);hbad=json.loads(json.dumps(final));hbad['helper_final']['-1']=hbad['helper_final'].get('-1',list(next(iter(hbad['helper_final'].values())))) + res['helper_index_guard_violations']=len(hv);res['helper_index_guard_negative_control_rejected']=len(ghi.violations(hbad))>0 + ok&=not hv and res['helper_index_guard_negative_control_rejected'] + print('HELPER-INDEX-GUARD',wt,'helper_final keys',len(final['helper_final']),'violations',len(hv),'negative control (key -1) rejected',res['helper_index_guard_negative_control_rejected'],flush=True) + # ENTRANCE-WIDTH BINDING (answers whether the hosted helpers are delivered at the raised entrance frames): the per-helper residual width |final|-|start_extra| of THIS word must equal the ordered widths of new/BORROW-PROVIDERS.json, + # which are the widths reconstruct.py/emit/audit_allcold use for every hosted role (audit: 'wrong per-call residual width', 'entering helper width silently restored to nine'); bind_providers_portable.py re-derives them from the native canonical word. + prov_w=json.loads((D.parent/'BORROW-PROVIDERS.json').read_text())['gauge44' if wt=='base' else 'extra']['widths'] + def word_widths(w_): + rem=[r_ for r_ in range(224,704) if r_ not in set(w_['removed'])];se_={int(k_):v_ for k_,v_ in w_['start_extra'].items()};hf_={int(k_):v_ for k_,v_ in w_['helper_final'].items()} + return [len(hf_.get(r_,range(9)))-len(se_.get(r_,[])) for r_ in rem] + bind_ok=word_widths(final)==prov_w + tw=json.loads(json.dumps(final));raised=[int(k_) for k_,v_ in tw['start_extra'].items() if len(v_)==2] + if raised:tw['start_extra'][str(raised[0])]=tw['start_extra'][str(raised[0])][:1] # a raised copy buffer delivered at dim 1 again + tamper_rejected=bool(raised) and word_widths(tw)!=prov_w + res['entrance_widths_bound_to_providers']=bind_ok;res['dim1_delivery_rejected']=tamper_rejected;res['raised_buffers']=len(raised) + ok&=bind_ok and (tamper_rejected or not raised) + print('ENTRANCE-WIDTH-BINDING',wt,'raised',len(raised),'bound',bind_ok,'dim1 tamper rejected',tamper_rejected,flush=True) + out[canon]=res;print(canon,res,flush=True) +print('PASS_REBUILD_BORROW' if ok else 'FAIL_REBUILD_BORROW');sys.exit(0 if ok else 1) diff --git a/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/verify.py b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/verify.py new file mode 100644 index 0000000000..c9c6ca06c9 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/integration-review/fixtures/old/source/verify.py @@ -0,0 +1,139 @@ +"""Portable finite admission. Fresh native suppliers by default; explicit bound reuse supported.""" +import argparse,gzip,hashlib,json,os,shutil,subprocess,sys,tarfile,threading,time +from pathlib import Path +P=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--work',type=Path,required=True);ap.add_argument('--base-native-from',type=Path);ap.add_argument('--extra-native-from',type=Path);ap.add_argument('--parent-receipt-cache',type=Path);ap.add_argument('--new-base-native-from',type=Path);ap.add_argument('--new-extra-native-from',type=Path);ap.add_argument('--native-cache',type=Path);ap.add_argument('--audit-shards',type=int,default=4);ap.add_argument('--reference-native',action='store_true');a=ap.parse_args();work=a.work.resolve();assert __debug__ and not work.exists() and not work.is_relative_to(P) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +pins=rd(P/'MANIFEST.json');actual={p.relative_to(P).as_posix() for p in P.rglob('*') if p.is_file() and p!=P/'MANIFEST.json'};assert actual==set(pins) +for rel,h in pins.items():assert sha(P/rel)==h,rel +work.mkdir();(work/'tmp').mkdir();env=dict(os.environ,TMPDIR=str(work/'tmp'),PYTHONDONTWRITEBYTECODE='1',PYTHONPYCACHEPREFIX=str(work/'pycache-prefix'),PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') +for k in ('PYTHONOPTIMIZE','WITNESS_DISCOVER','WITNESS_RECORD','WITNESS_SPEC'):env.pop(k,None) +env['AUDIT_FAST_SHARDS']=str(max(1,a.audit_shards)) +stages=[];lock=threading.Lock() +def run(name,script,*args): + t=time.monotonic();log=work/(name+'.log') + with log.open('w') as f:r=subprocess.run([sys.executable,'-B',str(script),*map(str,args)],cwd=work,env=env,stdout=f,stderr=subprocess.STDOUT) + with lock:stages.append(dict(name=name,exit_code=r.returncode,seconds=time.monotonic()-t,log_sha256=sha(log)));(work/'STAGES.json').write_text(json.dumps(stages,indent=2)) + assert r.returncode==0,(name,log.read_text()[-5000:]);print('PASS',name,flush=True) +old=P/'vendor/pr1297' +# The pinned input witness must be the exact retained predecessor, not merely a similar profile. +for n in ['PLAN.json','OWNERS.json.gz','GLOBAL-TEMPLATE.json.gz','DISPATCH.json','SPEC.json']:assert rd(P/'inputs'/n)==rd(old/n),n +env['FINE_ENGINE_CACHE']=str(work/'fine-cache') +env['BORROW_RECEIPTS']=str(work/'borrow-receipts') # receipts carry timings: written to the work directory, never into the package +run('fine-engine-oracle',P/'code/oracle_check.py') +opts=[] +for key,path in [('base',a.base_native_from),('extra',a.extra_native_from)]: + if path:opts.extend(['--'+key+'-native-from',path.resolve()]) +PARENT_STATUS='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' +def retained_files_ok(): + # the retained package must be byte-for-byte the one every receipt below is bound to (same check as its own verify.py) + vm=rd(old/'MANIFEST.json');have={p.relative_to(old).as_posix() for p in old.rglob('*') if p.is_file() and '__pycache__' not in p.parts and p!=old/'MANIFEST.json'} + assert have==set(vm),'retained package file set differs from its manifest' + for rel,h in vm.items():assert sha(old/rel)==h,rel +def natives_bound(path,word): + assert gzip.decompress((path/'local/FULL-WORD.json.gz').read_bytes())==gzip.decompress((old/word).read_bytes()),word + st=rd(path/'STEPS.json');assert [x['step'] for x in st]==['native','ledgers','local-replay','wrappers','phases'] and all(x['exit_code']==0 for x in st) +rc=None;receipt=None +if a.parent_receipt_cache and a.base_native_from and a.extra_native_from: + retained_files_ok();rc=a.parent_receipt_cache.resolve()/sha(old/'MANIFEST.json') + if (rc/'RECEIPT.json').is_file(): + receipt=rd(rc/'RECEIPT.json') + try: + assert receipt['schema']=='parent-receipt/1' and receipt['vendor_manifest_sha256']==sha(old/'MANIFEST.json') + assert receipt['claim_sha256']==sha(old/'CLAIM.json') and receipt['words']=={'base':sha(old/'gauge44-word.json.gz'),'extra':sha(old/'extra-word.json.gz')} + for name,h in receipt['files'].items():assert sha(rc/name)==h,name + pr=rd(rc/'RESULT.json');assert pr['status']==PARENT_STATUS and pr['kappa']==rd(old/'CLAIM.json')['kappa'] and pr['base_native_reuse'] is True and pr['extra_native_reuse'] is True + natives_bound(a.base_native_from.resolve(),'gauge44-word.json.gz');natives_bound(a.extra_native_from.resolve(),'extra-word.json.gz') + except (AssertionError,KeyError,OSError,ValueError) as exc: + print('parent receipt rejected (%r); running the full retained admission'%(exc,),flush=True);receipt=None +if receipt: + t0=time.monotonic();pl=work/'parent';pl.mkdir();lay=pl/'layout';lay.mkdir() + with tarfile.open(old/'upstream-layout.tar.gz') as t: + for m in t.getmembers():assert m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts + t.extractall(lay,filter='data') + (lay/'globalmix51').mkdir();shutil.copytree(a.extra_native_from.resolve(),lay/'globalmix51/native-extra') + with lock:stages.append(dict(name='retained-provider-and-parent-admission',reused_receipt=str(rc.name),exit_code=0,seconds=time.monotonic()-t0));(work/'STAGES.json').write_text(json.dumps(stages,indent=2)) + print('PASS retained-provider-and-parent-admission (hash-checked receipt)',flush=True) +else: + run('retained-provider-and-parent-admission',old/'verify.py','--work',work/'parent',*opts) + pr=rd(work/'parent/RESULT.json');assert pr['status']==PARENT_STATUS and pr['kappa']==rd(old/'CLAIM.json')['kappa'] + if rc is not None and a.base_native_from and a.extra_native_from: + natives_bound(a.base_native_from.resolve(),'gauge44-word.json.gz');natives_bound(a.extra_native_from.resolve(),'extra-word.json.gz') + rc.mkdir(parents=True,exist_ok=True);shutil.copy2(work/'parent/RESULT.json',rc/'RESULT.json');shutil.copy2(work/'parent/STAGES.json',rc/'STAGES.json') + (rc/'RECEIPT.json').write_text(json.dumps(dict(schema='parent-receipt/1',vendor_manifest_sha256=sha(old/'MANIFEST.json'),claim_sha256=sha(old/'CLAIM.json'),words={'base':sha(old/'gauge44-word.json.gz'),'extra':sha(old/'extra-word.json.gz')},files={'RESULT.json':sha(rc/'RESULT.json'),'STAGES.json':sha(rc/'STAGES.json')}),indent=1)+'\n') +pre_words={'base':P/'new/gauge44-word-566.json.gz','extra':P/'new/extra-word-566.json.gz'} +new_words={'base':P/'new/borrow/words/BORROW-WORD-43base.json.gz','extra':P/'new/borrow/words/BORROW-WORD-43extra.json.gz'} +nat={};nat_err=[] +def new_native(key): + try: + w=new_words[key];reuse=getattr(a,'new_%s_native_from'%key);d=None;ws=sha(w) + def tree(e):return {x.relative_to(e).as_posix():sha(x) for x in sorted(e.rglob('*')) if x.is_file() and x.name!='CACHE.json'} + if reuse:d=reuse.resolve() + elif a.native_cache: + e=a.native_cache.resolve()/ws + if (e/'CACHE.json').is_file(): + cj=rd(e/'CACHE.json') + if cj.get('word_sha256')==ws and cj.get('files')==tree(e):d=e + if d is None: + if a.reference_native: + d=work/('native-new-'+key);run('native-new-'+key,P/'new/run_native_borrow.py',w,d) + else: # PR2768 (tekuuu): the same five-stage native replay with the exact sparse Clifford evaluator (unchanged independent warp checks and controls); same output layout + fw=work/('native-new-'+key+'-fast');run('native-new-'+key,P/'new/fastnative/run_native.py',w,fw);d=fw/'native' + for x_ in d.rglob('*'): # text artifacts are LF on every OS (the pinned PLAN binds their hashes); the vendored scripts write CRLF on Windows + if x_.is_file() and x_.suffix in ('.json','.log','.txt'): + b_=x_.read_bytes() + if b'\r\n' in b_:x_.write_bytes(b_.replace(b'\r\n',b'\n')) + if a.native_cache: + root=a.native_cache.resolve();root.mkdir(parents=True,exist_ok=True);dst=root/ws + if not dst.exists(): + tmp=root/('.tmp-%s-%d'%(ws,os.getpid()));shutil.copytree(d,tmp);(tmp/'CACHE.json').write_text(json.dumps(dict(word_sha256=ws,files=tree(tmp)),indent=1)) + try:tmp.rename(dst) + except OSError:shutil.rmtree(tmp,ignore_errors=True) + assert gzip.decompress((d/'local/FULL-WORD.json.gz').read_bytes())==gzip.decompress(w.read_bytes()),(key,'native directory is not bound to the shipped word') + st_=rd(d/'STEPS.json');assert [x['step'] for x in st_]==['native','ledgers','local-replay','wrappers','phases'] and all(x['exit_code']==0 for x in st_) + nat[key]=d + except BaseException as exc:nat_err.append(exc) +nthreads=[threading.Thread(target=new_native,args=(k,)) for k in new_words] +for t_ in nthreads:t_.start() +def rebuild_chain(): + run('reconstruct-owners',P/'reconstruct.py','--out',work/'rebuilt-owners') + for n in ['OWNERS.json.gz','ORDER.json','DISPATCH.json','PROFILE.json']:assert rd(work/'rebuilt-owners'/n)==rd(P/n),n + run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent') + for n in ['GLOBAL-TEMPLATE.json.gz','PLAN.json','CONSTRUCTION.json']:assert rd(work/'rebuilt-parent'/n)==rd(P/n),n + assert rd(work/'rebuilt-parent/SPEC.json')['geometry']==rd(P/'SPEC.json')['geometry'] +chain_err=[] +def chain_thread(): + try:rebuild_chain() + except BaseException as exc:chain_err.append(exc) +chain=threading.Thread(target=chain_thread);chain.start() +for t_ in nthreads:t_.join() +if nat_err:raise nat_err[0] +SRCL=work/'parent/layout/joint1148-round45/source' +run('rebuild-words-566',P/'new/rebuild_chain.py') +run('rebuild-borrow-words',P/'new/rebuild_borrow.py') +for key_,w_ in pre_words.items():run('audit-local-566-'+key_,SRCL/'research/gauge44-slots/independent/audit_local.py','--word',w_,'--main',SRCL,'--output',work/('AUDIT-LOCAL-566-'+key_+'.json')) +run('rebind-566',P/'new/rebind.py',P,nat['base']/'local',nat['extra']/'local',work/'data-rebound') +run('lemmag-labels',P/'code/lemmag_stage.py',work/'LEMMAG-LABELS.json',nat['base'],nat['extra'],*[p_ for p_ in (a.base_native_from,a.extra_native_from) if p_]) +STABLE=('LOCAL-CHECKS.json','CLIFFORD-RECIPES.json','RESIDUAL-ADAPTERS.json') +def bind_view(plan): + plan=json.loads(json.dumps(plan)) + for desc in plan['provider_registry'].values():desc['artifact_sha256']={n:h for n,h in desc['artifact_sha256'].items() if n in STABLE} + return plan +assert bind_view(rd(work/'data-rebound/PLAN.json'))==bind_view(rd(P/'new/PLAN.json')),'regenerated PLAN differs from new/PLAN.json beyond bind-rebound receipt hashes' +assert rd(work/'data-rebound/PROFILE.json')==rd(P/'new/PROFILE.json') +layout=work/'parent/layout';runtime=layout/'packing74';runtime.mkdir();data=runtime/'candidate';data.mkdir() +for n in ['replay.py','freeze_spec.py','audit_mixed.py','independent_core.py','geometry_controls.py','audit_fast.py']:shutil.copy2(P/n,runtime/n) +for n in ['code','construction']:shutil.copytree(P/n,runtime/n) +(runtime/'inputs').mkdir();shutil.copy2(P/'inputs/PR589-EXPECTED.json',runtime/'inputs/PR589-EXPECTED.json') +for n in ['PLAN.json','SPEC.json','PROFILE.json','OWNERS.json.gz','DISPATCH.json','CONSTRUCTION.json','GLOBAL-TEMPLATE.json.gz']:shutil.copy2((P/'new' if n in ('PLAN.json','SPEC.json','PROFILE.json') else P)/n,data/n) +shutil.copytree(nat['extra'],runtime/'native-extra') +base=nat['base'] +run('strict-t74',runtime/'replay.py','--data',data,'--work',work/'strict','--local',base/'local') +run('geometry-controls',runtime/'geometry_controls.py','--source',layout/'joint1148-round45/source/research/complex-k492-owner-repair/vendor/multicold','--strict',work/'strict','--out',work/'GEOMETRY-CONTROLS.json') +chain.join() +if chain_err:raise chain_err[0] +r=rd(work/'strict/RESULT.json');assert r['status']=='PASS_STRICT_MIXED_T74_EXACT_FILL' and r['kappa']==rd(P/'CLAIM.json')['kappa'];assert len(rd(work/'GEOMETRY-CONTROLS.json')['rejected'])==6 +result=dict(status='PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION',kappa=r['kappa'],kappa_decimal=r['kappa_decimal'],manifest_sha256=sha(P/'MANIFEST.json'),native_reuse=dict(base=bool(a.base_native_from),extra=bool(a.extra_native_from)),provider_verification=pr['status'],roles=r['independent']['roles'],prefix_bits=r['independent']['prefix_bits'],charged_prefix_bits=r['independent']['charged_prefix_bits'],physical_row_coefficient=r['independent']['physical_row_coefficient'],row_limit=r['independent']['row_limit'],controls=dict(admission=114,bit=12,controller=15,independent_owner=8,geometry=6),stages=stages,scope=rd(P/'CLAIM.json')['scope']) +(work/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n');print(result['status'],result['kappa_decimal'],flush=True) diff --git a/research/shared-kernel-packing/vendor/pr2857/materialize_source.py b/research/shared-kernel-packing/vendor/pr2857/materialize_source.py new file mode 100644 index 0000000000..15631dd5df --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/materialize_source.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Export the exact PR2833 source from local Git objects, without fetching. + +The output is the package directory itself, suitable for reproduce.py --source. +Jeremy Kothe and the retained PR2833 contributors retain source attribution. +""" +import argparse +import hashlib +import io +import json +from pathlib import Path, PurePosixPath +import subprocess +import sys +import tarfile + +sys.dont_write_bytecode = True +HEAD = 'e9307b48d7d1b690939935ecef0f8e524e6d92f4' +PREFIX = 'research/gmx-t74-borrow43-handoff' +MANIFEST_SHA = 'c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +FILE_COUNT = 541 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def safe_relative(name): + path = PurePosixPath(name) + need(name and not path.is_absolute() and '..' not in path.parts + and '\\' not in name and '\0' not in name, + 'unsafe source path: ' + name) + need('__pycache__' not in path.parts and path.suffix != '.pyc', + 'bytecode is forbidden in exact source: ' + name) + return path + + +def authenticate_payload(files): + need('MANIFEST.json' in files, 'missing exact source manifest') + need(digest(files['MANIFEST.json']) == MANIFEST_SHA, 'exact PR2833 manifest hash') + pins = json.loads(files['MANIFEST.json']) + need(isinstance(pins, dict) and len(pins) == FILE_COUNT, 'exact 541-entry manifest') + for name in pins: + safe_relative(name) + actual = {name: digest(raw) for name, raw in files.items() if name != 'MANIFEST.json'} + need(actual == pins, 'complete exact PR2833 file inventory and hashes') + return pins + + +def authenticate_source(source): + source = Path(source) + need(source.is_dir() and not source.is_symlink(), 'source must be a real directory') + files = {} + for path in sorted(source.rglob('*')): + name = path.relative_to(source).as_posix() + safe_relative(name) # Checks empty __pycache__ directories too. + need(not path.is_symlink(), 'source symlink: ' + name) + if path.is_file(): + files[name] = path.read_bytes() + else: + need(path.is_dir(), 'nonregular source entry: ' + name) + return authenticate_payload(files) + + +def export(repo, out): + repo, out = Path(repo).resolve(), Path(out).resolve() + need(not out.exists() and not out.is_symlink(), 'fresh output directory required') + check = subprocess.run(['git', '-C', str(repo), 'rev-parse', '--verify', HEAD + '^{commit}'], + check=True, capture_output=True, text=True) + need(check.stdout.strip() == HEAD, 'exact locally available PR2833 commit') + archive = subprocess.run(['git', '-C', str(repo), 'archive', '--format=tar', HEAD, PREFIX], + check=True, capture_output=True).stdout + prefix = PurePosixPath(PREFIX) + files = {} + with tarfile.open(fileobj=io.BytesIO(archive), mode='r:') as package: + for member in package.getmembers(): + path = PurePosixPath(member.name) + need(not path.is_absolute() and '..' not in path.parts and '\\' not in member.name, + 'unsafe Git archive path') + if member.isdir() and (path == prefix or path in prefix.parents): + continue + need(path.is_relative_to(prefix), 'archive entry outside pinned package') + relative = path.relative_to(prefix).as_posix() + safe_relative(relative) + need(member.isfile() or member.isdir(), 'archive links/special files forbidden') + if member.isdir(): + continue + need(relative not in files, 'duplicate archive file') + stream = package.extractfile(member) + need(stream is not None, 'missing archive file stream') + files[relative] = stream.read() + authenticate_payload(files) + out.mkdir(parents=True, exist_ok=False) + for name, raw in files.items(): + destination = out / name + destination.parent.mkdir(parents=True, exist_ok=True) + with destination.open('xb') as handle: + handle.write(raw) + authenticate_source(out) + return {'status': 'PASS_EXACT_PR2833_SOURCE_EXPORT', 'head': HEAD, + 'manifest_sha256': MANIFEST_SHA, 'manifest_entries': FILE_COUNT, + 'source': str(out), 'network_fetch': False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, default=Path.cwd(), + help='Local Git repository containing the pinned commit (default: cwd)') + parser.add_argument('--out', type=Path, required=True, help='Fresh source package directory') + args = parser.parse_args() + print(json.dumps(export(args.repo, args.out), sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/owner_controls.py b/research/shared-kernel-packing/vendor/pr2857/owner_controls.py new file mode 100644 index 0000000000..aefdf8ff7a --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/owner_controls.py @@ -0,0 +1,41 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Four rejecting controls for the standalone shared-kernel owner auditor. +Prepared by Yiyang with OpenAI Codex assistance. Inputs remain read-only. +""" +import argparse,copy,gzip,hashlib,json,tempfile,types +from pathlib import Path +ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source-dir',type=Path,required=True);ap.add_argument('--candidate-dir',type=Path,required=True);ap.add_argument('--words-dir',type=Path,required=True);ap.add_argument('--work-dir',type=Path,required=True);a=ap.parse_args() +p=Path(__file__).with_name('audit_owners.py');raw=p.read_bytes();m=types.ModuleType('independent_owner_auditor');m.__file__=str(p);exec(compile(raw,str(p),'exec'),m.__dict__) +a.work_dir.mkdir(parents=True,exist_ok=True);results=[] +def shadow(src,dst): + dst.mkdir() + for f in src.iterdir(): + if f.is_file():(dst/f.name).symlink_to(f.resolve()) +def write(dst,name,data): + p=dst/name + if p.is_symlink():p.unlink() + p.write_bytes(data) +with tempfile.TemporaryDirectory(dir=a.work_dir)as temp: + root=Path(temp) + for case,reason in [('same_mass_wrong_profile','provider bound to fixed word'),('invalid_source_window','strict source-event window'),('overlapping_offsets','bin capacity or overlapping offsets'),('source_byte_mutation','source SHA256')]: + D=root/case;D.mkdir();src=D/'sources';cand=D/'candidate';shadow(a.source_dir,src);shadow(a.candidate_dir,cand) + if case=='same_mass_wrong_profile': + v=json.loads((cand/'PROVIDERS.json').read_bytes());prof=v['gauge44']['actual_paid_profile'];prof['1']-=2;prof['2']+=1;write(cand,'PROVIDERS.json',json.dumps(v).encode()) + elif case=='invalid_source_window': + v=json.loads(gzip.decompress((cand/'FILL.json.gz').read_bytes()));row=next(r for r in v['rows']if r[0]==0);row[2:]=[0,12,0,0];write(cand,'FILL.json.gz',gzip.compress(json.dumps(v).encode(),mtime=0)) + elif case=='overlapping_offsets': + v=json.loads(gzip.decompress((cand/'FILL.json.gz').read_bytes()));seen={} + for row in v['rows']: + key=tuple(row[2:5]) + if key in seen:row[5]=seen[key];break + seen[key]=row[5] + else:raise ValueError('no multi-role bin for overlap control') + write(cand,'FILL.json.gz',gzip.compress(json.dumps(v).encode(),mtime=0)) + else: + n='PR2833-T37-DISPATCH.json';write(src,n,(src/n).read_bytes()+b'\n') + try:m.audit(src,cand,a.words_dir) + except ValueError as e: + if reason not in str(e):raise ValueError((case,'unexpected rejection',str(e))) + results.append({'case':case,'status':'REJECTED','reason':str(e)}) + else:raise ValueError((case,'mutant accepted')) +print(json.dumps({'status':'PASS_TARGETED_INDEPENDENT_OWNER_CONTROLS','auditor_sha256':hashlib.sha256(raw).hexdigest(),'controls':results},sort_keys=True,indent=2)) diff --git a/research/shared-kernel-packing/vendor/pr2857/prepare_shared_native.py b/research/shared-kernel-packing/vendor/pr2857/prepare_shared_native.py new file mode 100644 index 0000000000..b3af64dd80 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/prepare_shared_native.py @@ -0,0 +1,76 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Two fresh changed-word native chains; explicit authenticated parent reuse. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Derived from the PR2839/PR2848 native preparation lineage, retaining validators. +""" +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor +from importlib import metadata +import argparse,hashlib,json,gzip,os,platform,shutil,subprocess,sys,time +sys.dont_write_bytecode=True +SOURCE_SHA='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +SOURCE_FILES=547 +SOURCE_COMMIT='shared-four-kernel-pr2833' +PARENT_SHA='e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +OLD_RECEIPT_SHA='a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p,exclude=()): + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no cache/source symlinks') + if f.is_file()and f.relative_to(p).as_posix()not in exclude:out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser() + for n in ['source','retained-cache','retained-receipt','out']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--jobs',type=int,default=2);a=ap.parse_args();source=a.source.resolve();out=a.out.resolve();oldcache=a.retained_cache.resolve() + need(not sys.flags.optimize and 1<=a.jobs<=2,'assertions enabled and max2 jobs') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==SOURCE_FILES and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'complete immutable derived source') + need(not list(source.rglob('__pycache__'))and not list(source.rglob('*.pyc')),'source free of bytecode and cache folders') + before=tree(source);oldreceipt=read(a.retained_receipt) + need(sha(a.retained_receipt)==OLD_RECEIPT_SHA and tree(oldcache)==oldreceipt['cache_files'],'complete PR2848 retained native/cache evidence') + old=source/'vendor/pr1297';need(sha(old/'MANIFEST.json')==PARENT_SHA and tree(old,('MANIFEST.json',))==read(old/'MANIFEST.json'),'unchanged retained source') + prdir=oldcache/'_receipts'/PARENT_SHA;need(sha(prdir/'RECEIPT.json')==oldreceipt['retained_parent_receipt_sha256'],'retained parent receipt identity');pr=read(prdir/'RECEIPT.json') + need(pr['vendor_manifest_sha256']==PARENT_SHA and pr['claim_sha256']==sha(old/'CLAIM.json'),'retained parent source claim') + for name,h in pr['files'].items():need(sha(prdir/name)==h,'retained parent result binding') + need(read(prdir/'RESULT.json')['status']=='PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and read(prdir/'RESULT.json')['kappa']==read(old/'CLAIM.json')['kappa'],'retained full parent admission') + pstages=read(prdir/'STAGES.json');need(len(pstages)==16 and all(s['exit_code']==0 for s in pstages),'all16 retained parent stages') + need(not out.exists()and not out.is_relative_to(source)and not out.is_relative_to(oldcache),'fresh external native work');out.mkdir(parents=True);cache=out/'native-cache';cache.mkdir() + steps=['native','ledgers','local-replay','wrappers','phases'] + for tag,name in [('base','gauge44-word.json.gz'),('extra','extra-word.json.gz')]: + word=old/name;key=sha(word);need(pr['words'][tag]==key,'retained word hash');entry=oldcache/key + need(read(entry/'local/FULL-WORD.json.gz')==read(word),'retained complete literal word');st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'retained native five stages') + cj=read(entry/'CACHE.json');need(cj['word_sha256']==key and cj['files']==tree(entry,('CACHE.json',)),'retained full native files') + shutil.copytree(entry,cache/key) + shutil.copytree(prdir,cache/'_receipts'/PARENT_SHA) + versions={} + for name in ['numpy','scipy','sympy','mpmath','psutil','gmpy2']: + try:versions[name]=metadata.version(name) + except metadata.PackageNotFoundError:versions[name]=None + write(out/'ENVIRONMENT.json',dict(python=platform.python_version(),executable=sys.executable,dependency_versions=versions,assertions_enabled=True)) + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for k in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(k,None) + driver=source/'new/fastnative/run_native.py';start=time.monotonic();stages=[];words={t:source/('new/borrow/words/BORROW-WORD-43'+t+'.json.gz')for t in ['base','extra']} + def fresh(tag): + word=words[tag];work=out/('fresh-'+tag);cmd=[sys.executable,'-B',str(driver),str(word),str(work)];log=out/('native-'+tag+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=out,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + need(r.returncode==0,'fresh native '+tag+' failed; '+str(log));res=read(work/'RESULT.json');need(res['status']=='PASS_COMPLETE_T74_NATIVE_REPLAY'and res['word_sha256']==sha(word),'fresh native result') + entry=cache/sha(word);shutil.copytree(work/'native',entry);need(read(entry/'local/FULL-WORD.json.gz')==read(word),'fresh complete literal word') + st=read(entry/'STEPS.json');need([s['step']for s in st]==steps and all(s['exit_code']==0 for s in st),'fresh native five stages') + checks=read(entry/'local/LOCAL-CHECKS.json');can=read(entry/'local/CANONICAL-WORD.json.gz') + need(can['R']==408 and len(can['centers'])==8 and len(can['zero_buffers'])==72,'complete physical ABI') + for orientation in ['forward','backward']:need(checks[orientation]['all_columns']==632 and checks[orientation]['paid_profile']==read(word)['report']['local_profile'],'actual all-column native profile') + write(entry/'CACHE.json',dict(word_sha256=sha(word),files=tree(entry))) + rec=dict(name='fresh-current-'+tag,exit_code=0,command=cmd,script_sha256=sha(driver),log_sha256=sha(log),result_sha256=sha(work/'RESULT.json'),seconds=time.monotonic()-begin);print('PASS',rec['name'],flush=True);return rec + with ThreadPoolExecutor(max_workers=a.jobs)as pool:stages=list(pool.map(fresh,['base','extra'])) + need(tree(source)==before and tree(oldcache)==oldreceipt['cache_files']and sha(a.retained_receipt)==OLD_RECEIPT_SHA,'read-only input drift') + rec=dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',source_commit=SOURCE_COMMIT,manifest_sha256=SOURCE_SHA,providers={t:dict(word_sha256=sha(w),complete_native_files=tree(cache/sha(w),('CACHE.json',)))for t,w in words.items()},retained_parent_receipt_sha256=sha(cache/'_receipts'/PARENT_SHA/'RECEIPT.json'),cache_files=tree(cache),fresh_current_provider_count=2,fresh_retained_native_count=0,reused_retained_native_count=2,fresh_retained_parent=False,reused_retained_parent=True,retained_reuse_receipt_sha256=OLD_RECEIPT_SHA) + write(out/'NATIVE-RECEIPT.json',rec);write(out/'STAGES.json',stages);write(out/'RESULT.json',dict(status='PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',source_manifest_sha256=SOURCE_SHA,native_receipt_sha256=sha(out/'NATIVE-RECEIPT.json'),preparer_sha256=sha(Path(__file__)),environment_sha256=sha(out/'ENVIRONMENT.json'),stages=stages,seconds=time.monotonic()-start,scope='Fresh changed base/extra native chains; two unchanged retained native chains and16-stage parent admission explicitly reused by exact full-tree receipts. No owner/controller/outer admission yet.')) + print('PASS_TWO_FRESH_SHARED_KERNEL_NATIVE_CHAINS_AUTHENTICATED_PARENT_REUSE',flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/reproduce.py b/research/shared-kernel-packing/vendor/pr2857/reproduce.py new file mode 100644 index 0000000000..dcc664bb96 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/reproduce.py @@ -0,0 +1,89 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Portable source derivation, two fresh native chains and full outer release. +Yiyang (@Lyy-iiis), with substantial OpenAI Codex assistance. +Unchanged retained native/parent evidence is explicitly reused by full-tree hashes. +""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +from fractions import Fraction as Q +import argparse,hashlib,json,os,subprocess,time +HERE=Path(__file__).resolve().parent +SCRIPT_PINS={ + 'build_overlay.py':'4c83a251a03045144608456e6b3bdbcced9255ce7c2d89f7039e766972100666', + 'prepare_shared_native.py':'9d86bf49f6aec1d4f671a5d060815e97cb470151221a29fba736e91f06c74b07', + 'admit_shared_replica.py':'c36c482e5df550daf1e0f0da8ed71eb00e12ac41df8de973583f4db9d98f586f', +} +HELPER_PINS={ + 'lift_parent.py':'9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e', + 'replica_parent.py':'48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4', + 'reconstruct_replica.py':'5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15', + 'blocknorm_certificate.py':'e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92', +} +WORD_PINS={'base':'001b14314d8db873d4d80826d4af9c40a3e5a1fecde743e5a26391bdf673f458','extra':'bc5bfe51178f0c3312d28318412ec490463c896ceed0660b9c443fcb76496546'} +CANDIDATE_PINS={'fill': '82218aaaf08825bd4a3cca676815c7e9c00d06d0da123b1c5ad234c8c91cb501', 'order': '84f030a59dde4fa4635988ef0931ebae66964b3a202df79d38247fbe8a5592dc', 'dispatch': '5513481a70c83767b5836b15fb7ff204d2a8f8fca83c6bcaee90a20b3d1ec6c4'} +EXPECTED_KAPPA='17200966286848326009719999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000' +GENERATOR_SHA='b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed' +REVIEW_SHA='5b323e50fb5a10ac088472b3e085b54d7d2ae3a29f8552ff44b788a984eb97d1' +COMPARISON_SHA='aceb1394b3e8f3abcc9b1a0dc82756ab937ffbefc2f37305a229a00ccc5137e9' +SOURCE_SHA='c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f' +OVERLAY_SHA='54dc42f25c1d8b85adcf593c4bf6c0f83f7351388af857812790b8a0b4c3d869' +def need(ok,why): + if not ok:raise ValueError(why) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_text()) +def write(p,v):p.write_text(json.dumps(v,sort_keys=True,indent=2)+'\n') +def tree(p): + need(not list(p.rglob('__pycache__')) and not list(p.rglob('*.pyc')),'no bytecode or cache dirs in immutable source') + out={} + for f in sorted(p.rglob('*')): + need(not f.is_symlink(),'no source symlinks') + if f.is_file()and f!=p/'MANIFEST.json':out[f.relative_to(p).as_posix()]=sha(f) + return out + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + for n in ['source','words','fill','order','dispatch','retained-cache','retained-receipt','comparison-claim','comparison-latest-claim','work']:ap.add_argument('--'+n,type=Path,required=True) + ap.add_argument('--generator',type=Path,default=HERE/'shared_kernel.py');ap.add_argument('--review',type=Path,default=HERE/'review_four_groups.py');ap.add_argument('--helper-dir',type=Path,default=HERE/'vendor/pr2839');ap.add_argument('--jobs',type=int,choices=range(1,5),default=4);a=ap.parse_args() + for name,value in vars(a).items(): + if isinstance(value,Path):setattr(a,name,value.resolve()) + need(not sys.flags.optimize,'assertions enabled');source=a.source.resolve();work=a.work.resolve() + need(not work.exists()and not work.is_relative_to(source)and not source.is_relative_to(work),'fresh work external to source') + need(not work.is_relative_to(HERE)and not HERE.is_relative_to(work),'fresh work external to replay package') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and tree(source)==read(source/'MANIFEST.json'),'complete original PR2833 source') + files={} + def bind(p,expected): + p=p.resolve();need(sha(p)==expected,'pinned input '+str(p));files[str(p)]=expected + for n,h in SCRIPT_PINS.items():bind(HERE/n,h) + for n,h in HELPER_PINS.items():bind(a.helper_dir/n,h) + for tag,h in WORD_PINS.items():bind(a.words/('WORD-'+tag+'.json.gz'),h) + for n,h in CANDIDATE_PINS.items():bind(getattr(a,n),h) + bind(a.generator,GENERATOR_SHA);bind(a.review,REVIEW_SHA);bind(a.comparison_claim,COMPARISON_SHA) + bind(a.retained_receipt,'a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc') + bind(a.comparison_latest_claim,'eb3260be191774b931cff6e562978a2af27bbc6ff666ca8c1d387a2b18dc86fa') + latest=read(a.comparison_latest_claim);need(Q(latest['kappa'])==Q(latest['kappa_rational'])and Q(EXPECTED_KAPPA)>Q(latest['kappa_rational']),'exact improved target beats concurrent PR2853 full outer headline') + source_before=tree(source);work.mkdir(parents=True);overlay=work/'source';native=work/'native';candidate=work/'candidate' + commands=[('derive-source',[sys.executable,'-B',str(HERE/'build_overlay.py'),'--source',str(source),'--generator',str(a.generator),'--review',str(a.review),'--candidate-dir',str(a.words),'--out',str(overlay)]), + ('fresh-current-native',[sys.executable,'-B',str(HERE/'prepare_shared_native.py'),'--source',str(overlay),'--retained-cache',str(a.retained_cache),'--retained-receipt',str(a.retained_receipt),'--out',str(native),'--jobs',str(min(a.jobs,2))]), + ('complete-admission',[sys.executable,'-B',str(HERE/'admit_shared_replica.py'),'--source',str(overlay),'--fill',str(a.fill),'--order',str(a.order),'--dispatch',str(a.dispatch),'--native-cache',str(native/'native-cache'),'--native-receipt',str(native/'NATIVE-RECEIPT.json'),'--work',str(candidate),'--replica-helper-dir',str(a.helper_dir),'--reconstructor',str(a.helper_dir/'reconstruct_replica.py'),'--blocknorm-checker',str(a.helper_dir/'blocknorm_certificate.py'),'--comparison-claim',str(a.comparison_claim),'--source-profile','shared-four','--comparison-profile','pr2848','--jobs',str(a.jobs)])] + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + for n in ['PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD']:env.pop(n,None) + stages=[];start=time.monotonic() + for name,cmd in commands: + log=work/(name+'.log');begin=time.monotonic() + with log.open('w')as f:r=subprocess.run(cmd,cwd=work,env=env,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + stages.append(dict(stage=name,command=cmd,exit_code=r.returncode,log_sha256=sha(log),seconds=time.monotonic()-begin));write(work/'STAGES.json',stages) + need(r.returncode==0,'failed '+name+'; '+str(log));print('PASS',name,flush=True) + need(all(sha(Path(p))==h for p,h in files.items()),'bound replay input drift') + result=read(candidate/'RESULT.json');release=read(candidate/'release/RELEASE-RECEIPT.json');nrec=read(native/'NATIVE-RECEIPT.json') + need(result['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE'and release['status']=='PASS_RELEASE','complete release statuses') + need(Q(result['kappa'])==Q(release['kappa_decimal'])==Q(EXPECTED_KAPPA),'exact expected headline') + need(result['release_receipt_sha256']==sha(candidate/'release/RELEASE-RECEIPT.json')and result['package_manifest_sha256']==release['manifest_sha256']==sha(candidate/'package/MANIFEST.json'),'strict release chain') + need(sha(overlay/'MANIFEST.json')==OVERLAY_SHA and tree(overlay)==read(overlay/'MANIFEST.json'),'unchanged exact derived source') + need(tree(source)==source_before and sha(source/'MANIFEST.json')==SOURCE_SHA,'unchanged original source') + need(nrec['fresh_current_provider_count']==2 and nrec['reused_retained_native_count']==2 and nrec['reused_retained_parent']is True,'accurate fresh/reused native provenance') + final=dict(status='PASS_SHARED_KERNEL_PORTABLE_COMPLETE_REPLAY',kappa=result['kappa'],kappa_decimal=result['kappa_decimal'],gain=result['gain'],source_manifest_sha256=SOURCE_SHA,derived_source_manifest_sha256=OVERLAY_SHA,source_derivation_sha256=sha(work/'source-DERIVATION.json'),native_receipt_sha256=sha(native/'NATIVE-RECEIPT.json'),candidate_result_sha256=sha(candidate/'RESULT.json'),release_receipt_sha256=sha(candidate/'release/RELEASE-RECEIPT.json'),generated_package_manifest_sha256=result['package_manifest_sha256'],fresh_current_native_chains=2,reused_retained_native_chains=2,reused_retained_parent=True,wrapper_sha256=sha(Path(__file__)),input_sha256=files,stages=stages,seconds=time.monotonic()-start,scope='Conditional finite supplier and modern outer release; unchanged inherited all-size/compiler/hosting/precision/tape/analytic obligations remain. Two changed providers run fresh; retained provider/parent proof explicitly reused by full-tree hashes.') + need(Q(result['kappa'])>Q(latest['kappa_rational']),'actual full release beats exact concurrent headline') + final['secondary_comparison']=dict(pr=2853,head='d01045dfb67428679618027dff552f1d032fa999',claim_sha256=sha(a.comparison_latest_claim),field='kappa_rational',gain=str(Q(result['kappa'])-Q(latest['kappa_rational'])),approx_gain=float(Q(result['kappa'])-Q(latest['kappa_rational']))) + write(work/'RESULT.json',final);print(final['status'],final['kappa_decimal'],flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/requirements-reproduction.txt b/research/shared-kernel-packing/vendor/pr2857/requirements-reproduction.txt new file mode 100644 index 0000000000..77cd5d09ff --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/requirements-reproduction.txt @@ -0,0 +1,6 @@ +numpy==2.4.5 +scipy==1.16.1 +sympy==1.14.0 +mpmath==1.3.0 +gmpy2==2.3.2 +psutil==7.2.1 diff --git a/research/shared-kernel-packing/vendor/pr2857/review_four_groups.py b/research/shared-kernel-packing/vendor/pr2857/review_four_groups.py new file mode 100644 index 0000000000..39036b21f2 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/review_four_groups.py @@ -0,0 +1,256 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent four-kernel review and semantic fault controls. + +Contribution: Yiyang Lu (@Lyy-iiis), with substantial OpenAI Codex assistance, +including separate analysis and review agents. Retains Jeremy Kothe's PR2833 +source construction and credited PR2802/earlier lineage. This reviewer does not +import the construction producer. Source cleanup and auditor dependencies are +SHA256-authenticated before execution. All output is confined to a fresh external +directory; input bytes and the source directory tree are checked unchanged. +""" + +def require(condition, reason): + if not condition: + raise RuntimeError(reason) + +import os, sys, json, gzip, copy, hashlib, subprocess +from pathlib import Path +from fractions import Fraction as F +from collections import Counter +import argparse, importlib.util +sys.dont_write_bytecode = True +os.environ['PYTHONDONTWRITEBYTECODE'] = '1' +parser = argparse.ArgumentParser(description=__doc__) +parser.add_argument('--source-dir', type=Path, required=True, help='Pinned PR2833 new/borrow directory containing audit_local.py and word_patch.py') +parser.add_argument('--source-base', type=Path, required=True, help='Original pinned PR2833 base word, before overlay') +parser.add_argument('--source-extra', type=Path, required=True, help='Original pinned PR2833 extra word, before overlay') +parser.add_argument('--candidate-base', type=Path, required=True) +parser.add_argument('--candidate-extra', type=Path, required=True) +parser.add_argument('--out-dir', type=Path, required=True, help='Fresh external directory; must not already exist or be inside source-dir') +args = parser.parse_args() +ROOT = args.source_dir.resolve() +OUT = args.out_dir.resolve() +sources = {'base': args.source_base.resolve(), 'extra': args.source_extra.resolve()} +candidates = {'base': args.candidate_base.resolve(), 'extra': args.candidate_extra.resolve()} + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + +def tree_snapshot(root): + return {str(p.relative_to(root)): sha(p) for p in sorted(root.rglob('*')) if p.is_file()} + +def manifest_sha(manifest): + return hashlib.sha256(json.dumps(manifest, sort_keys=True, separators=(',', ':')).encode()).hexdigest() +require(not OUT.exists(), 'out-dir must be fresh') +require(OUT != ROOT and ROOT not in OUT.parents and (OUT not in ROOT.parents), 'out-dir must be external to source-dir') +protected = {'source_base': sources['base'], 'source_extra': sources['extra'], 'word_patch': ROOT / 'word_patch.py', 'audit_local': ROOT / 'audit_local.py', 'candidate_base': candidates['base'], 'candidate_extra': candidates['extra']} +pins = {'source_base': 'dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7', 'source_extra': 'bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac', 'word_patch': '9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce', 'audit_local': 'a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90'} +before = {k: sha(p) for k, p in protected.items()} +for key, digest in pins.items(): + require(before[key] == digest, ('pinned source mismatch', key, before[key], digest)) +source_tree_before = tree_snapshot(ROOT) +OUT.mkdir(parents=True) +spec = importlib.util.spec_from_file_location('_authenticated_pr2833_cleanup', ROOT / 'word_patch.py') +require(spec is not None and spec.loader is not None, 'cannot load pinned cleanup helper') +module = importlib.util.module_from_spec(spec) +spec.loader.exec_module(module) +derive_cleanup = module.derive_cleanup +restored_of = module.restored_of +GROUPS = [(478, 479, 490, 491), (460, 461, 468, 469), (462, 463, 470, 471), (480, 481, 492, 493)] + +def regs(g): + return g[1:3] if g[0] == 'add' else g[1:2] + +def enc(g): + return json.dumps(g, separators=(',', ':')) + +def add(a, b, c): + for k, v in b.items(): + z = a.get(k, F(0)) + c * v + if z: + a[k] = z + else: + a.pop(k, None) + +def columns(gs): + out = {} + for g in gs: + require(g[0] == 'add', "check failed: g[0] == 'add'") + a = out.setdefault(g[2], {}) + z = a.get(g[1], F(0)) + F(g[3], g[4]) + if z: + a[g[1]] = z + else: + a.pop(g[1], None) + return out +receipt = {'status': 'PASS_INDEPENDENT_FOUR_GROUP_REVIEW', 'variants': {}} +for variant in ('base', 'extra'): + source = sources[variant] + path = candidates[variant] + w = json.load(gzip.open(source)) + x = json.load(gzip.open(path)) + oldA = w['A'] + newA = x['A'] + expected = {} + all_support = set() + all_targets = set() + groups = [] + changes = {} + newstart = dict(w['start_extra']) + oldC = columns(w['compensation']) + expectedC = copy.deepcopy(oldC) + for q, p, r, t in GROUPS: + info = {} + for h in (q, p, r, t): + touches = [(i, g) for i, g in enumerate(oldA) if h in regs(g)] + require(len(touches) == 1, 'check failed: len(touches) == 1') + i, g = touches[0] + require(g[0] == 'add' and g[1] == h, "check failed: g[0] == 'add' and g[1] == h") + a = g[2] + require(not any((e[1] == a for e in oldA)), 'check failed: not any((e[1] == a for e in oldA))') + info[h] = (i, a, F(g[3], g[4]), g[-1]) + i0, a0, c0, E = info[q] + i1, a1, c1, E1 = info[p] + i2, a2, c2, G = info[r] + i3, a3, c3, G1 = info[t] + require(E == E1 and G == G1, 'check failed: E == E1 and G == G1') + + def span(U): + s = {0} + for z in U: + s |= {z ^ v for v in list(s)} + return s + line = list((span(E) & span(G)) - {0}) + require(len(line) == 1, 'check failed: len(line) == 1') + mk = lambda d, s, c, U: ['add', d, s, c.numerator, c.denominator, U] + ops = [(min(i0, i2), mk(r, q, F(-1), line)), (max(i0, i1) + 1, mk(p, q, F(1), E)), (max(i0, i1) + 1, mk(p, a0, -c0, E)), (max(i2, i3) + 1, mk(t, r, F(1), G)), (max(i2, i3) + 1, mk(t, a2, -c2, G))] + for pos, g in ops: + expected.setdefault(pos, []).append(g) + support = set((q, p, r, t, a0, a1, a2, a3)) + require(len(support) == 8 and (not support & all_support), 'check failed: len(support) == 8 and (not support & all_support)') + all_support |= support + targets = set().union(*(set(oldC[h]) for h in (q, p, r, t))) + require(not targets & all_targets, 'check failed: not targets & all_targets') + all_targets |= targets + z = {} + for h, c in ((q, 1), (p, 1), (r, -1), (t, -1)): + add(z, oldC[h], F(c)) + require(not z, 'check failed: not z') + rows = {h: {h: F(1)} for h in support} + sched = {} + for h, (i, a, c, U) in info.items(): + sched.setdefault(i, []).append(mk(h, a, c, U)) + for pos in sorted(set(sched) | {p for p, g in ops}): + for pp, g in ops: + if pp == pos: + add(rows[g[1]], rows[g[2]], F(g[3], g[4])) + for g in sched.get(pos, []): + add(rows[g[1]], rows[g[2]], F(g[3], g[4])) + H = {h: {h: F(1)} for h in support} + add(H[p], {q: F(1)}, F(1)) + add(H[r], {q: F(1)}, F(-1)) + add(H[t], {r: F(1), q: F(-1)}, F(1)) + for h, (i, a, c, U) in info.items(): + add(H[h], {a: F(1)}, c) + require(rows == H, 'check failed: rows == H') + expectedC[q] = {} + add(expectedC[r], oldC[t], F(1)) + newstart[str(q)] = line + groups.append({'helpers': [q, p, r, t], 'source_A_positions': {str(h): info[h][0] for h in info}, 'partners': {str(h): info[h][1] for h in info}, 'raw_dirt_map': {str(p): f'd{p}+d{q}', str(r): f'd{r}-d{q}', str(t): f'd{t}+d{r}-d{q}'}, 'target_support': sorted(targets), 'operand_support': sorted(support)}) + actual = {} + j = 0 + for g in newA: + if j < len(oldA) and g == oldA[j]: + j += 1 + else: + actual.setdefault(j, []).append(g) + require(j == len(oldA) and sum(map(len, actual.values())) == 20, 'check failed: j == len(oldA) and sum(map(len, actual.values())) == 20') + require(set(actual) == set(expected), 'check failed: set(actual) == set(expected)') + for pos in actual: + require(Counter(map(enc, actual[pos])) == Counter(map(enc, expected[pos])), 'check failed: Counter(map(enc, actual[pos])) == Counter(map(enc, expected[pos]))') + require(x['start_extra'] == newstart, "check failed: x['start_extra'] == newstart") + gotC = columns(x['compensation']) + require({k: v for k, v in gotC.items() if v} == {k: v for k, v in expectedC.items() if v}, 'check failed: {k: v for k, v in gotC.items() if v} == {k: v for k, v in expectedC.items() if v}') + removed = [g for g in w['compensation'] if g[2] in {q for q, p, r, t in GROUPS}] + retained = [g for g in w['compensation'] if g[2] not in {q for q, p, r, t in GROUPS}] + require(len(removed) == 28 and x['compensation'][:len(retained)] == retained and (len(x['compensation']) - len(retained) == 28), "check failed: len(removed) == 28 and x['compensation'][:len(retained)] == retained and (len(x['compensation']) - len(retained) == 28)") + allowed = {'A', 'compensation', 'start_extra', 'report', 'cleanup'} + require({k for k in w if w[k] != x[k]} <= allowed, 'check failed: {k for k in w if w[k] != x[k]} <= allowed') + require(x['report']['local_profile'] == {'1': 2394, '2': 642, '3': 266, '4': 128, '5': 26, '8': 8}, "check failed: x['report']['local_profile'] == {'1': 2394, '2': 642, '3': 266, '4': 128, '5': 26, '8': 8}") + require(x['report']['width_inventory'] == {'4': 26, '5': 2, '7': 62, '8': 84, '9': 234}, "check failed: x['report']['width_inventory'] == {'4': 26, '5': 2, '7': 62, '8': 84, '9': 234}") + positive_path = OUT / f'POSITIVE-AUDIT-{variant}.json' + positive_cmd = [sys.executable, '-B', str(ROOT / 'audit_local.py'), '--word', str(path), '--output', str(positive_path)] + positive_run = subprocess.run(positive_cmd, text=True, capture_output=True, env=dict(os.environ, PYTHONDONTWRITEBYTECODE='1')) + (OUT / f'POSITIVE-AUDIT-{variant}.log').write_text(positive_run.stdout + positive_run.stderr) + require(positive_run.returncode == 0, ('positive candidate audit failed', variant, positive_run.stdout, positive_run.stderr)) + positive_receipt = json.loads(positive_path.read_text()) + require(positive_receipt.get('status') == 'PASS_INDEPENDENT_EXACT_BORROWING_WORD', 'positive auditor status mismatch') + controls = [] + + def remove_exact(m, needle): + hits = [i for i, g in enumerate(m['A']) if g == needle] + require(len(hits) == 1, 'check failed: len(hits) == 1') + m['A'].pop(hits[0]) + + def drop_primary(m): + remove_exact(m, ['add', 479, 478, 1, 1, [75, 25]]) + + def drop_partner(m): + remove_exact(m, ['add', 479, 526, 1, 1, [75, 25]]) + + def flip_cross(m): + needle = ['add', 468, 460, -1, 1, [7]] + hits = [i for i, g in enumerate(m['A']) if g == needle] + require(len(hits) == 1, 'check failed: len(hits) == 1') + m['A'][hits[0]][3] = 1 + + def omit_comp(m): + m['compensation'] = copy.deepcopy(retained) + + def wrong_comp(m): + m['compensation'][len(retained)][3] *= -1 + + def wrong_start(m): + m['start_extra']['478'] = [75] + + def suppress_without_transport(m): + m['A'] = copy.deepcopy(w['A']) + m['compensation'] = copy.deepcopy(retained) + m['report']['local_profile'] = dict(w['report']['local_profile']) + m['report']['local_profile']['1'] += 4 + m['report']['local_profile']['2'] -= 4 + + def stale_cleanup(m): + m['cleanup'] = copy.deepcopy(w['cleanup']) + cases = [('wrong_kernel_sign', flip_cross, 'endpoint', True), ('drop_primary_A_injection', drop_primary, 'endpoint', True), ('missing_raw_dirt_reconstruction', drop_partner, 'endpoint', True), ('missing_compensation_regeneration', omit_comp, 'endpoint', True), ('wrong_compensation_sign', wrong_comp, 'endpoint', True), ('wrong_start_extra', wrong_start, 'frame', True), ('suppressed_compensation_without_transport', suppress_without_transport, 'endpoint', True), ('stale_cleanup', stale_cleanup, 'cleanup', False)] + for name, mut, expected_kind, rederive in cases: + m = copy.deepcopy(x) + mut(m) + if rederive: + t = copy.deepcopy(m) + t['A'] = t['A'][t['prelude_events']:] + m['cleanup'] = derive_cleanup(t, restored_of(m)) + mp = OUT / f'control-{variant}-{name}.json.gz' + mp.write_bytes(gzip.compress(json.dumps(m, separators=(',', ':')).encode(), mtime=0)) + ap = OUT / f'control-{variant}-{name}-audit.json' + cmd = [sys.executable, '-B', str(ROOT / 'audit_local.py'), '--word', str(mp), '--output', str(ap)] + res = subprocess.run(cmd, text=True, capture_output=True, env=dict(os.environ, PYTHONDONTWRITEBYTECODE='1')) + log = res.stdout + res.stderr + (OUT / f'control-{variant}-{name}.log').write_text(log) + require(res.returncode != 0, (name, log)) + reason = next((z for z in reversed(log.splitlines()) if z.startswith('RuntimeError:')), log.splitlines()[-1]) + if expected_kind == 'endpoint': + require('frames/profile PASS' in log and ('target map failed' in reason or 'all-column endpoint failure' in reason), (name, log)) + elif expected_kind == 'frame': + require('frame' in reason, (name, log)) + else: + require('cleanup' in reason, (name, log)) + controls.append({'name': name, 'cleanup_rederived': rederive, 'expected_failure_kind': expected_kind, 'frames_profile_pass': 'frames/profile PASS' in log, 'rejected_for': reason}) + receipt['variants'][variant] = {'source_sha256': hashlib.sha256(source.read_bytes()).hexdigest(), 'candidate_sha256': hashlib.sha256(path.read_bytes()).hexdigest(), 'positive_audit': {'status': positive_receipt['status'], 'checked_columns': positive_receipt['checked_columns'], 'orientations': positive_receipt['orientations'], 'receipt_sha256': sha(positive_path)}, 'inserted_A_gates': 20, 'compensation_removed': 28, 'compensation_added': 28, 'groups': groups, 'all_four_operand_and_target_supports_disjoint': True, 'all_other_sections_unchanged': True, 'controls': controls} +after = {k: sha(p) for k, p in protected.items()} +source_tree_after = tree_snapshot(ROOT) +require(after == before, 'source, dependency or candidate bytes changed during review') +require(source_tree_after == source_tree_before, 'source-dir tree changed during review') +receipt['source_authentication'] = {'pins': pins, 'before': before, 'after': after, 'all_protected_files_unchanged': True, 'source_tree_before_sha256': manifest_sha(source_tree_before), 'source_tree_after_sha256': manifest_sha(source_tree_after), 'source_tree_files': len(source_tree_before), 'source_tree_unchanged': True, 'reviewer_sha256': sha(Path(__file__).resolve())} +(OUT / 'FOUR-GROUP-INDEPENDENT-REVIEW.json').write_text(json.dumps(receipt, indent=2) + '\n') +print(json.dumps({'status': receipt['status'], 'variants': {k: {'inserted_A_gates': v['inserted_A_gates'], 'compensation_removed': v['compensation_removed'], 'compensation_added': v['compensation_added'], 'controls': v['controls']} for k, v in receipt['variants'].items()}}, indent=2)) diff --git a/research/shared-kernel-packing/vendor/pr2857/run_integration_review.py b/research/shared-kernel-packing/vendor/pr2857/run_integration_review.py new file mode 100644 index 0000000000..485b957d94 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/run_integration_review.py @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Run the frozen source-derivation review with disposable output. + +Prepared for Yiyang (@Lyy-iiis) with substantial OpenAI Codex assistance. +""" +import os +from pathlib import Path +import subprocess +import sys +import tempfile +sys.dont_write_bytecode = True +p = Path(__file__).resolve().parent +r = p / 'integration-review' +with tempfile.TemporaryDirectory(prefix='shared-kernel-integration-review-') as work: + subprocess.run([sys.executable, '-I', '-O', '-B', + str(r / 'check_integration_derivation.py'), + '--old', str(r / 'fixtures/old'), '--new', str(r / 'fixtures/new'), + '--derivation', str(r / 'fixtures/derivation'), '--controls', + '--out', str(Path(work) / 'RESULT.json')], + check=True, env=dict(os.environ, PYTHONDONTWRITEBYTECODE='1')) diff --git a/research/shared-kernel-packing/vendor/pr2857/run_owner_controls.py b/research/shared-kernel-packing/vendor/pr2857/run_owner_controls.py new file mode 100644 index 0000000000..b6b8770e4a --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/run_owner_controls.py @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Run independent owner failure controls in an automatically cleaned workspace.""" +import sys +sys.dont_write_bytecode=True +from pathlib import Path +import os,subprocess,tempfile +p=Path(__file__).resolve().parent +with tempfile.TemporaryDirectory(prefix='shared-kernel-owner-controls-') as work: + subprocess.run([sys.executable,'-I','-B',str(p/'owner_controls.py'), + '--source-dir',str(p/'sources'),'--candidate-dir',str(p), + '--words-dir',str(p/'words'),'--work-dir',str(Path(work)/'controls')], + check=True,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1')) diff --git a/research/shared-kernel-packing/vendor/pr2857/shared_kernel.py b/research/shared-kernel-packing/vendor/pr2857/shared_kernel.py new file mode 100644 index 0000000000..0f0f8f22dd --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/shared_kernel.py @@ -0,0 +1,170 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Staged four-helper compensation kernels for pinned PR2833 supplier words. + +Prepared for Yiyang (@Lyy-iiis) with substantial OpenAI Codex assistance, +including separate construction and review agents. Builds on Jeremy Kothe's +PR2833 dirt-entry supplier and its credited PR2802/earlier lineage. Frame and +inverse-cleanup conventions follow that supplier's Apache-2.0 word_patch.py and +audit_local.py; the CLI authenticates and calls the inherited implementation. +No source files, imports, processes, or outputs are touched by apply(). +""" +import copy, hashlib, json +from collections import Counter +from fractions import Fraction as F + +CANONICAL_INPUTS={ + 'aaf1d752501a30fdf7305be9515617698d0b4753411844d28f005aab1b67f3df':'base', + '1b02e1ea0214b45071f9d93ad074cc392fd7e59f6fb83a7c4e8cd99c36150a3c':'extra', +} +COMPRESSED_INPUTS={ + 'dda9878455b3a3bec64ca16b1ac7789bbf5ffb603d5713b8df8644485e85b1b7':'base', + 'bbe6bcba59e45e827a8e932ee4b23650d56ed4a0b8e0875c14f23c36b9e47eac':'extra', +} +DEPENDENCIES={ + 'word_patch.py':'9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce', + 'audit_local.py':'a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90', +} +GROUPS={460:(460,461,468,469),462:(462,463,470,471),478:(478,479,490,491),480:(480,481,492,493)} + +def require(ok, reason): + if not ok:raise ValueError(str(reason)) + +def basis(vs): + piv={} + for a in vs: + while a: + bit=a.bit_length()-1 + if bit in piv:a^=piv[bit] + else:piv[bit]=a;break + for k in sorted(piv): + for j in piv: + if j>k and piv[j]>>k&1:piv[j]^=piv[k] + return tuple(piv[k] for k in sorted(piv,reverse=True)) + +def contained(a,b):return basis(a+b)==b + +def _restored_of(w): + n=2*w['report']['v']+w['report']['R'] + return {g[1]-n for g in w['cleanup'] if g[1]>=n}|{g[2]-n for g in w['cleanup'] if g[0]=='add' and g[2]>=n} + +def _derive_cleanup(w,restored): + # Literal inverse-reverse, excluding target writes; caller removes the prelude. + v=w['report']['v'];n=2*v+w['report']['R'];full=list(basis([1<=224) + x['report']['local_profile']={str(k):v for k,v in sorted(paid.items())};x['report']['width_inventory']={str(k):v for k,v in sorted(inv.items())} + oldprof=Counter({int(k):v for k,v in w['report']['local_profile'].items()});diff={k:paid[k]-oldprof[k] for k in paid.keys()|oldprof.keys() if paid[k]!=oldprof[k]} + require(diff=={1:3*len(chosen),2:-2*len(chosen)}, ('unexpected paid profile',diff)) + t=copy.deepcopy(x);t['A']=t['A'][t['prelude_events']:];x['cleanup']=_derive_cleanup(t,_restored_of(x)) + ledger=dict(variant=variant,source_canonical_sha256=digest,chosen=chosen,local_profile=x['report']['local_profile'],width_inventory=x['report']['width_inventory'],delta=diff,groups=ledger,insertions=byp) + return x,ledger + +def main(): + import argparse,gzip,importlib.util,os,subprocess,sys + from pathlib import Path + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--source-word',required=True,type=Path) + p.add_argument('--source-dir',required=True,type=Path,help='pinned PR2833 new/borrow directory') + p.add_argument('--output',required=True,type=Path) + p.add_argument('--ledger',type=Path) + p.add_argument('--groups',nargs='+',type=int,default=[478,460,462,480]) + p.add_argument('--no-audit',action='store_true',help='skip the separate inherited auditor; input and cleanup pins remain mandatory') + a=p.parse_args();sys.dont_write_bytecode=True;os.environ['PYTHONDONTWRITEBYTECODE']='1' + raw=a.source_word.read_bytes();digest=hashlib.sha256(raw).hexdigest() + require(digest in COMPRESSED_INPUTS,'unauthorized compressed source SHA256') + for name,expected in DEPENDENCIES.items(): + require(hashlib.sha256((a.source_dir/name).read_bytes()).hexdigest()==expected,'unauthorized dependency SHA256: '+name) + source=json.loads(gzip.decompress(raw));word,ledger=apply(source,a.groups) + spec=importlib.util.spec_from_file_location('_pinned_shared_kernel_word_patch',a.source_dir/'word_patch.py') + inherited=importlib.util.module_from_spec(spec);spec.loader.exec_module(inherited) + stripped=copy.deepcopy(word);stripped['A']=stripped['A'][stripped.get('prelude_events',0):] + clean=inherited.derive_cleanup(stripped,inherited.restored_of(word)) + require(clean==word['cleanup'],'pure and inherited cleanup disagree') + word['cleanup']=clean + a.output.parent.mkdir(parents=True,exist_ok=True) + data=json.dumps(word,separators=(',',':')).encode();a.output.write_bytes(gzip.compress(data,mtime=0)) + ledger.update(source_compressed_sha256=digest,output_content_sha256=hashlib.sha256(data).hexdigest(),output_compressed_sha256=hashlib.sha256(a.output.read_bytes()).hexdigest(),dependencies=DEPENDENCIES,inherited_cleanup_matches=True) + lp=a.ledger or a.output.with_name(a.output.name+'.ledger.json');lp.write_text(json.dumps(ledger,indent=2)+'\n') + if not a.no_audit: + receipt=a.output.with_name(a.output.name+'.audit.json') + subprocess.run([sys.executable,'-B',str(a.source_dir/'audit_local.py'),'--word',str(a.output),'--output',str(receipt)],check=True,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1')) + print(json.dumps({'word':str(a.output),'ledger':str(lp),'content_sha256':ledger['output_content_sha256'],'profile':ledger['local_profile']},sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/source_pin_controls.py b/research/shared-kernel-packing/vendor/pr2857/source_pin_controls.py new file mode 100644 index 0000000000..24c617cc57 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/source_pin_controls.py @@ -0,0 +1,41 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Source-authentication controls for Yiyang (@Lyy-iiis), with OpenAI Codex assistance.""" +import argparse,copy,gzip,hashlib,importlib.util,json,os,subprocess,sys +from pathlib import Path +PRODUCER_SHA='b3241527e6c136dc4b54975ef401c49d452bd6159fb99030accaf095c8fbd3ed' +def digest(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def require(ok,msg): + if not ok:raise RuntimeError(msg) +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--producer',required=True,type=Path);p.add_argument('--source-base',required=True,type=Path);p.add_argument('--source-extra',required=True,type=Path);p.add_argument('--source-dir',required=True,type=Path);p.add_argument('--out-dir',required=True,type=Path) + a=p.parse_args();sys.dont_write_bytecode=True;os.environ['PYTHONDONTWRITEBYTECODE']='1' + require(digest(a.producer)==PRODUCER_SHA,'producer SHA mismatch') + require(not a.out_dir.exists(),'out-dir must be fresh');a.out_dir.mkdir(parents=True) + watched=[a.producer,a.source_base,a.source_extra,a.source_dir/'word_patch.py',a.source_dir/'audit_local.py'];before={str(x):digest(x) for x in watched} + spec=importlib.util.spec_from_file_location('_shared_kernel_pin_control',a.producer);m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m) + checks=[] + for variant,source in [('base',a.source_base),('extra',a.source_extra)]: + original=json.loads(gzip.decompress(source.read_bytes()));prior=copy.deepcopy(original);new,ledger=m.apply(original) + require(original==prior,'apply mutated its input') + changed=copy.deepcopy(original);changed['report']['R']+=1 + try:m.apply(changed) + except ValueError as e:require('unauthorized decoded source SHA256' in str(e),'wrong decoded mutation failure') + else:raise RuntimeError('decoded mutation accepted') + checks.append(dict(variant=variant,control='decoded_source_mutation',rejected=True,reason='unauthorized decoded source SHA256')) + bad=a.out_dir/f'{variant}-source-byte-mutant.json.gz';bad.write_bytes(source.read_bytes()+b'\n') + output=a.out_dir/f'{variant}-must-not-exist.json.gz' + cmd=[sys.executable,'-B',str(a.producer),'--source-word',str(bad),'--source-dir',str(a.source_dir),'--output',str(output),'--no-audit'] + r=subprocess.run(cmd,capture_output=True,text=True,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1')) + require(r.returncode!=0 and 'unauthorized compressed source SHA256' in r.stderr and not output.exists(),'compressed mutation was not rejected before output') + checks.append(dict(variant=variant,control='compressed_source_byte_mutation',rejected=True,reason='unauthorized compressed source SHA256',no_output=True)) + fake=a.out_dir/'mutant-dependencies';fake.mkdir() + for name in('word_patch.py','audit_local.py'):(fake/name).write_bytes((a.source_dir/name).read_bytes()+(b'\n' if name=='word_patch.py' else b'')) + output=a.out_dir/'dependency-must-not-exist.json.gz' + r=subprocess.run([sys.executable,'-B',str(a.producer),'--source-word',str(a.source_base),'--source-dir',str(fake),'--output',str(output),'--no-audit'],capture_output=True,text=True,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1')) + require(r.returncode!=0 and 'unauthorized dependency SHA256: word_patch.py' in r.stderr and not output.exists(),'dependency mutation was not rejected before import/output') + checks.append(dict(control='cleanup_dependency_mutation',rejected=True,reason='unauthorized dependency SHA256: word_patch.py',no_output=True)) + after={str(x):digest(x) for x in watched};require(before==after,'watched source changed') + receipt=dict(status='PASS_SHARED_KERNEL_SOURCE_PIN_CONTROLS',checks=checks,pure_apply_preserves_both_inputs=True,before=before,after=after) + (a.out_dir/'SOURCE-PIN-CONTROLS.json').write_text(json.dumps(receipt,indent=2)+'\n');print(json.dumps({'status':receipt['status'],'controls':len(checks),'receipt':str(a.out_dir/'SOURCE-PIN-CONTROLS.json')})) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-DISPATCH.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-DISPATCH.json new file mode 100644 index 0000000000..693ed0d022 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-DISPATCH.json @@ -0,0 +1 @@ +[[0,0,"extra"],[0,1,"extra"],[0,2,"extra"],[0,3,"extra"],[0,4,"extra"],[1,0,"extra"],[0,5,"extra"],[1,1,"extra"],[0,6,"extra"],[1,2,"extra"],[0,7,"extra"],[1,3,"extra"],[0,8,"extra"],[1,4,"extra"],[2,0,"extra"],[0,9,"extra"],[1,5,"extra"],[2,1,"extra"],[0,10,"extra"],[1,6,"extra"],[2,2,"extra"],[0,11,"extra"],[1,7,"extra"],[2,3,"extra"],[0,12,"extra"],[1,8,"extra"],[2,4,"extra"],[3,0,"extra"],[0,13,"extra"],[1,9,"extra"],[2,5,"extra"],[3,1,"extra"],[0,14,"extra"],[1,10,"extra"],[2,6,"extra"],[3,2,"extra"],[0,15,"extra"],[1,11,"extra"],[2,7,"extra"],[3,3,"extra"],[0,16,"extra"],[1,12,"extra"],[2,8,"extra"],[3,4,"extra"],[4,0,"extra"],[0,17,"extra"],[1,13,"extra"],[2,9,"extra"],[3,5,"extra"],[4,1,"extra"],[0,18,"extra"],[1,14,"extra"],[2,10,"extra"],[3,6,"extra"],[4,2,"extra"],[0,19,"extra"],[1,15,"extra"],[2,11,"extra"],[3,7,"extra"],[4,3,"extra"],[0,20,"extra"],[1,16,"extra"],[2,12,"extra"],[3,8,"extra"],[4,4,"extra"],[5,0,"extra"],[0,21,"extra"],[1,17,"extra"],[2,13,"extra"],[3,9,"extra"],[4,5,"extra"],[5,1,"extra"],[0,22,"extra"],[1,18,"extra"],[2,14,"extra"],[3,10,"extra"],[4,6,"extra"],[5,2,"extra"],[0,23,"extra"],[1,19,"extra"],[2,15,"extra"],[3,11,"extra"],[4,7,"extra"],[5,3,"extra"],[0,24,"extra"],[1,20,"extra"],[2,16,"extra"],[3,12,"extra"],[4,8,"extra"],[5,4,"extra"],[6,0,"extra"],[0,25,"extra"],[1,21,"extra"],[2,17,"extra"],[3,13,"extra"],[4,9,"extra"],[5,5,"extra"],[6,1,"extra"],[0,26,"extra"],[1,22,"extra"],[2,18,"extra"],[3,14,"extra"],[4,10,"extra"],[5,6,"extra"],[6,2,"extra"],[0,27,"extra"],[1,23,"extra"],[2,19,"extra"],[3,15,"extra"],[4,11,"extra"],[5,7,"extra"],[6,3,"extra"],[0,28,"extra"],[1,24,"extra"],[2,20,"extra"],[3,16,"extra"],[4,12,"extra"],[5,8,"extra"],[6,4,"extra"],[7,0,"extra"],[0,29,"extra"],[1,25,"extra"],[2,21,"extra"],[3,17,"extra"],[4,13,"extra"],[5,9,"extra"],[6,5,"extra"],[7,1,"extra"],[0,30,"extra"],[1,26,"extra"],[2,22,"extra"],[3,18,"extra"],[4,14,"extra"],[5,10,"extra"],[6,6,"extra"],[7,2,"extra"],[0,31,"extra"],[1,27,"extra"],[2,23,"extra"],[3,19,"extra"],[4,15,"extra"],[5,11,"extra"],[6,7,"extra"],[7,3,"extra"],[0,32,"extra"],[1,28,"extra"],[2,24,"extra"],[3,20,"extra"],[4,16,"extra"],[5,12,"extra"],[6,8,"extra"],[7,4,"extra"],[8,0,"extra"],[0,33,"extra"],[1,29,"extra"],[2,25,"extra"],[3,21,"extra"],[4,17,"extra"],[5,13,"extra"],[6,9,"extra"],[7,5,"extra"],[8,1,"extra"],[0,34,"extra"],[1,30,"extra"],[2,26,"extra"],[3,22,"extra"],[4,18,"extra"],[5,14,"extra"],[6,10,"extra"],[7,6,"extra"],[8,2,"extra"],[0,35,"extra"],[1,31,"extra"],[2,27,"extra"],[3,23,"extra"],[4,19,"extra"],[5,15,"extra"],[6,11,"extra"],[7,7,"extra"],[8,3,"extra"],[0,36,"extra"],[1,32,"extra"],[2,28,"extra"],[3,24,"extra"],[4,20,"extra"],[5,16,"extra"],[6,12,"extra"],[7,8,"extra"],[8,4,"extra"],[0,37,"extra"],[1,33,"extra"],[2,29,"extra"],[3,25,"extra"],[4,21,"extra"],[5,17,"extra"],[6,13,"extra"],[7,9,"extra"],[8,5,"gauge44"],[0,38,"extra"],[1,34,"extra"],[2,30,"extra"],[3,26,"extra"],[4,22,"extra"],[5,18,"extra"],[6,14,"extra"],[7,10,"gauge44"],[8,6,"gauge44"],[0,39,"extra"],[1,35,"extra"],[2,31,"extra"],[3,27,"extra"],[4,23,"extra"],[5,19,"gauge44"],[6,15,"gauge44"],[7,11,"gauge44"],[8,7,"gauge44"],[0,40,"extra"],[1,36,"extra"],[2,32,"extra"],[3,28,"extra"],[4,24,"gauge44"],[5,20,"gauge44"],[6,16,"gauge44"],[7,12,"gauge44"],[8,8,"gauge44"],[0,41,"extra"],[1,37,"extra"],[2,33,"gauge44"],[3,29,"gauge44"],[4,25,"gauge44"],[5,21,"gauge44"],[6,17,"gauge44"],[7,13,"gauge44"],[8,9,"gauge44"],[0,42,"extra"],[1,38,"extra"],[2,34,"gauge44"],[3,30,"gauge44"],[4,26,"gauge44"],[5,22,"gauge44"],[6,18,"gauge44"],[7,14,"gauge44"],[8,10,"gauge44"],[0,43,"extra"],[1,39,"extra"],[2,35,"gauge44"],[3,31,"gauge44"],[4,27,"gauge44"],[5,23,"gauge44"],[6,19,"gauge44"],[7,15,"gauge44"],[8,11,"gauge44"],[0,44,"extra"],[1,40,"extra"],[2,36,"gauge44"],[3,32,"gauge44"],[4,28,"gauge44"],[5,24,"gauge44"],[6,20,"gauge44"],[7,16,"gauge44"],[8,12,"gauge44"],[0,45,"extra"],[1,41,"extra"],[2,37,"extra"],[3,33,"gauge44"],[4,29,"gauge44"],[5,25,"gauge44"],[6,21,"gauge44"],[7,17,"gauge44"],[8,13,"gauge44"],[0,46,"extra"],[1,42,"extra"],[2,38,"extra"],[3,34,"gauge44"],[4,30,"gauge44"],[5,26,"gauge44"],[6,22,"gauge44"],[7,18,"gauge44"],[8,14,"gauge44"],[0,47,"extra"],[1,43,"extra"],[2,39,"extra"],[3,35,"gauge44"],[4,31,"gauge44"],[5,27,"gauge44"],[6,23,"gauge44"],[7,19,"gauge44"],[8,15,"gauge44"],[0,48,"extra"],[1,44,"extra"],[2,40,"extra"],[3,36,"gauge44"],[4,32,"gauge44"],[5,28,"gauge44"],[6,24,"gauge44"],[7,20,"gauge44"],[8,16,"gauge44"],[0,49,"extra"],[1,45,"extra"],[2,41,"extra"],[3,37,"extra"],[4,33,"gauge44"],[5,29,"gauge44"],[6,25,"gauge44"],[7,21,"gauge44"],[8,17,"gauge44"],[0,50,"extra"],[1,46,"extra"],[2,42,"extra"],[3,38,"extra"],[4,34,"gauge44"],[5,30,"gauge44"],[6,26,"gauge44"],[7,22,"gauge44"],[8,18,"gauge44"],[0,51,"extra"],[1,47,"extra"],[2,43,"extra"],[3,39,"extra"],[4,35,"gauge44"],[5,31,"gauge44"],[6,27,"gauge44"],[7,23,"gauge44"],[8,19,"gauge44"],[0,52,"extra"],[1,48,"extra"],[2,44,"extra"],[3,40,"extra"],[4,36,"gauge44"],[5,32,"gauge44"],[6,28,"gauge44"],[7,24,"gauge44"],[8,20,"gauge44"],[0,53,"extra"],[1,49,"extra"],[2,45,"extra"],[3,41,"extra"],[4,37,"extra"],[5,33,"gauge44"],[6,29,"gauge44"],[7,25,"gauge44"],[8,21,"gauge44"],[0,54,"extra"],[1,50,"extra"],[2,46,"extra"],[3,42,"extra"],[4,38,"extra"],[5,34,"gauge44"],[6,30,"gauge44"],[7,26,"gauge44"],[8,22,"gauge44"],[0,55,"extra"],[1,51,"extra"],[2,47,"extra"],[3,43,"extra"],[4,39,"extra"],[5,35,"gauge44"],[6,31,"gauge44"],[7,27,"gauge44"],[8,23,"gauge44"],[0,56,"extra"],[1,52,"extra"],[2,48,"extra"],[3,44,"extra"],[4,40,"extra"],[5,36,"gauge44"],[6,32,"gauge44"],[7,28,"gauge44"],[8,24,"gauge44"],[0,57,"extra"],[1,53,"extra"],[2,49,"extra"],[3,45,"extra"],[4,41,"extra"],[5,37,"extra"],[6,33,"gauge44"],[7,29,"gauge44"],[8,25,"gauge44"],[0,58,"extra"],[1,54,"extra"],[2,50,"extra"],[3,46,"extra"],[4,42,"extra"],[5,38,"extra"],[6,34,"gauge44"],[7,30,"gauge44"],[8,26,"gauge44"],[0,59,"extra"],[1,55,"extra"],[2,51,"extra"],[3,47,"extra"],[4,43,"extra"],[5,39,"extra"],[6,35,"gauge44"],[7,31,"gauge44"],[8,27,"gauge44"],[0,60,"extra"],[1,56,"extra"],[2,52,"extra"],[3,48,"extra"],[4,44,"extra"],[5,40,"extra"],[6,36,"gauge44"],[7,32,"gauge44"],[8,28,"gauge44"],[0,61,"extra"],[1,57,"extra"],[2,53,"extra"],[3,49,"extra"],[4,45,"extra"],[5,41,"extra"],[6,37,"extra"],[7,33,"gauge44"],[8,29,"gauge44"],[0,62,"extra"],[1,58,"extra"],[2,54,"extra"],[3,50,"extra"],[4,46,"extra"],[5,42,"extra"],[6,38,"extra"],[7,34,"gauge44"],[8,30,"gauge44"],[0,63,"extra"],[1,59,"extra"],[2,55,"extra"],[3,51,"extra"],[4,47,"extra"],[5,43,"extra"],[6,39,"extra"],[7,35,"gauge44"],[8,31,"gauge44"],[0,64,"extra"],[1,60,"extra"],[2,56,"extra"],[3,52,"extra"],[4,48,"extra"],[5,44,"extra"],[6,40,"extra"],[7,36,"gauge44"],[8,32,"gauge44"],[0,65,"extra"],[1,61,"extra"],[2,57,"extra"],[3,53,"extra"],[4,49,"extra"],[5,45,"extra"],[6,41,"extra"],[7,37,"extra"],[8,33,"gauge44"],[0,66,"extra"],[1,62,"extra"],[2,58,"extra"],[3,54,"extra"],[4,50,"extra"],[5,46,"extra"],[6,42,"extra"],[7,38,"extra"],[8,34,"gauge44"],[0,67,"extra"],[1,63,"extra"],[2,59,"extra"],[3,55,"extra"],[4,51,"extra"],[5,47,"extra"],[6,43,"extra"],[7,39,"extra"],[8,35,"gauge44"],[0,68,"extra"],[1,64,"extra"],[2,60,"extra"],[3,56,"extra"],[4,52,"extra"],[5,48,"extra"],[6,44,"extra"],[7,40,"extra"],[8,36,"gauge44"],[0,69,"extra"],[1,65,"extra"],[2,61,"extra"],[3,57,"extra"],[4,53,"extra"],[5,49,"extra"],[6,45,"extra"],[7,41,"extra"],[8,37,"extra"],[0,70,"extra"],[1,66,"extra"],[2,62,"extra"],[3,58,"extra"],[4,54,"extra"],[5,50,"extra"],[6,46,"extra"],[7,42,"extra"],[8,38,"extra"],[0,71,"extra"],[1,67,"extra"],[2,63,"extra"],[3,59,"extra"],[4,55,"extra"],[5,51,"extra"],[6,47,"extra"],[7,43,"extra"],[8,39,"extra"],[0,72,"extra"],[1,68,"extra"],[2,64,"extra"],[3,60,"extra"],[4,56,"extra"],[5,52,"extra"],[6,48,"extra"],[7,44,"extra"],[8,40,"extra"],[0,73,"extra"],[1,69,"extra"],[2,65,"extra"],[3,61,"extra"],[4,57,"extra"],[5,53,"extra"],[6,49,"extra"],[7,45,"extra"],[8,41,"extra"],[1,70,"extra"],[2,66,"extra"],[3,62,"extra"],[4,58,"extra"],[5,54,"extra"],[6,50,"extra"],[7,46,"extra"],[8,42,"gauge44"],[1,71,"extra"],[2,67,"extra"],[3,63,"extra"],[4,59,"extra"],[5,55,"extra"],[6,51,"extra"],[7,47,"gauge44"],[8,43,"gauge44"],[1,72,"extra"],[2,68,"extra"],[3,64,"extra"],[4,60,"extra"],[5,56,"gauge44"],[6,52,"gauge44"],[7,48,"gauge44"],[8,44,"gauge44"],[1,73,"extra"],[2,69,"extra"],[3,65,"gauge44"],[4,61,"gauge44"],[5,57,"gauge44"],[6,53,"gauge44"],[7,49,"gauge44"],[8,45,"gauge44"],[2,70,"gauge44"],[3,66,"gauge44"],[4,62,"gauge44"],[5,58,"gauge44"],[6,54,"gauge44"],[7,50,"gauge44"],[8,46,"gauge44"],[2,71,"gauge44"],[3,67,"gauge44"],[4,63,"gauge44"],[5,59,"gauge44"],[6,55,"gauge44"],[7,51,"gauge44"],[8,47,"gauge44"],[2,72,"gauge44"],[3,68,"gauge44"],[4,64,"gauge44"],[5,60,"gauge44"],[6,56,"gauge44"],[7,52,"gauge44"],[8,48,"gauge44"],[2,73,"gauge44"],[3,69,"gauge44"],[4,65,"gauge44"],[5,61,"gauge44"],[6,57,"gauge44"],[7,53,"gauge44"],[8,49,"gauge44"],[3,70,"gauge44"],[4,66,"gauge44"],[5,62,"gauge44"],[6,58,"gauge44"],[7,54,"gauge44"],[8,50,"gauge44"],[3,71,"gauge44"],[4,67,"gauge44"],[5,63,"gauge44"],[6,59,"gauge44"],[7,55,"gauge44"],[8,51,"gauge44"],[3,72,"gauge44"],[4,68,"gauge44"],[5,64,"gauge44"],[6,60,"gauge44"],[7,56,"gauge44"],[8,52,"gauge44"],[3,73,"gauge44"],[4,69,"gauge44"],[5,65,"gauge44"],[6,61,"gauge44"],[7,57,"gauge44"],[8,53,"gauge44"],[4,70,"gauge44"],[5,66,"gauge44"],[6,62,"gauge44"],[7,58,"gauge44"],[8,54,"gauge44"],[4,71,"gauge44"],[5,67,"gauge44"],[6,63,"gauge44"],[7,59,"gauge44"],[8,55,"gauge44"],[4,72,"gauge44"],[5,68,"gauge44"],[6,64,"gauge44"],[7,60,"gauge44"],[8,56,"gauge44"],[4,73,"gauge44"],[5,69,"gauge44"],[6,65,"gauge44"],[7,61,"gauge44"],[8,57,"gauge44"],[5,70,"gauge44"],[6,66,"gauge44"],[7,62,"gauge44"],[8,58,"gauge44"],[5,71,"gauge44"],[6,67,"gauge44"],[7,63,"gauge44"],[8,59,"gauge44"],[5,72,"gauge44"],[6,68,"gauge44"],[7,64,"gauge44"],[8,60,"gauge44"],[5,73,"gauge44"],[6,69,"gauge44"],[7,65,"gauge44"],[8,61,"gauge44"],[6,70,"gauge44"],[7,66,"gauge44"],[8,62,"gauge44"],[6,71,"gauge44"],[7,67,"gauge44"],[8,63,"gauge44"],[6,72,"gauge44"],[7,68,"gauge44"],[8,64,"gauge44"],[6,73,"gauge44"],[7,69,"gauge44"],[8,65,"gauge44"],[7,70,"gauge44"],[8,66,"gauge44"],[7,71,"gauge44"],[8,67,"gauge44"],[7,72,"gauge44"],[8,68,"gauge44"],[7,73,"gauge44"],[8,69,"gauge44"],[8,70,"gauge44"],[8,71,"gauge44"],[8,72,"gauge44"],[8,73,"gauge44"]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-NOTICE b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-NOTICE new file mode 100644 index 0000000000..46411b80b2 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-NOTICE @@ -0,0 +1,10 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-ORDER.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-ORDER.json new file mode 100644 index 0000000000..7141bd58cc --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-ORDER.json @@ -0,0 +1 @@ +[[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [0, 8], [1, 0], [0, 9], [1, 1], [0, 10], [1, 2], [2, 0], [0, 11], [1, 3], [2, 1], [0, 12], [1, 4], [2, 2], [0, 13], [3, 0], [1, 5], [2, 3], [0, 14], [3, 1], [1, 6], [2, 4], [0, 15], [3, 2], [1, 7], [2, 5], [0, 16], [3, 3], [1, 8], [2, 6], [0, 17], [3, 4], [1, 9], [2, 7], [0, 18], [3, 5], [1, 10], [2, 8], [0, 19], [3, 6], [1, 11], [2, 9], [0, 20], [3, 7], [1, 12], [2, 10], [0, 21], [3, 8], [1, 13], [2, 11], [4, 0], [0, 22], [3, 9], [1, 14], [2, 12], [4, 1], [0, 23], [3, 10], [1, 15], [2, 13], [4, 2], [0, 24], [3, 11], [1, 16], [2, 14], [4, 3], [0, 25], [3, 12], [5, 0], [1, 17], [2, 15], [4, 4], [0, 26], [3, 13], [5, 1], [1, 18], [2, 16], [4, 5], [0, 27], [3, 14], [5, 2], [1, 19], [2, 17], [4, 6], [0, 28], [3, 15], [5, 3], [1, 20], [2, 18], [4, 7], [0, 29], [3, 16], [5, 4], [6, 0], [1, 21], [2, 19], [4, 8], [0, 30], [3, 17], [5, 5], [6, 1], [1, 22], [2, 20], [4, 9], [0, 31], [3, 18], [5, 6], [6, 2], [1, 23], [2, 21], [4, 10], [0, 32], [3, 19], [5, 7], [6, 3], [1, 24], [2, 22], [4, 11], [0, 33], [3, 20], [5, 8], [6, 4], [7, 0], [1, 25], [2, 23], [4, 12], [0, 34], [3, 21], [5, 9], [6, 5], [7, 1], [1, 26], [2, 24], [4, 13], [0, 35], [3, 22], [5, 10], [6, 6], [7, 2], [1, 27], [2, 25], [4, 14], [0, 36], [3, 23], [5, 11], [6, 7], [7, 3], [1, 28], [2, 26], [4, 15], [0, 37], [3, 24], [5, 12], [6, 8], [7, 4], [8, 0], [1, 29], [2, 27], [4, 16], [0, 38], [3, 25], [5, 13], [6, 9], [7, 5], [8, 1], [1, 30], [2, 28], [4, 17], [0, 39], [3, 26], [5, 14], [6, 10], [7, 6], [8, 2], [1, 31], [2, 29], [4, 18], [0, 40], [3, 27], [5, 15], [6, 11], [7, 7], [8, 3], [1, 32], [2, 30], [4, 19], [0, 41], [3, 28], [5, 16], [6, 12], [7, 8], [8, 4], [1, 33], [2, 31], [4, 20], [0, 42], [3, 29], [5, 17], [6, 13], [7, 9], [8, 5], [1, 34], [2, 32], [4, 21], [0, 43], [3, 30], [5, 18], [6, 14], [7, 10], [8, 6], [1, 35], [2, 33], [4, 22], [0, 44], [3, 31], [5, 19], [6, 15], [7, 11], [8, 7], [1, 36], [2, 34], [4, 23], [0, 45], [3, 32], [5, 20], [6, 16], [7, 12], [8, 8], [1, 37], [2, 35], [4, 24], [0, 46], [3, 33], [5, 21], [6, 17], [7, 13], [8, 9], [1, 38], [2, 36], [4, 25], [0, 47], [3, 34], [5, 22], [6, 18], [7, 14], [8, 10], [1, 39], [2, 37], [4, 26], [0, 48], [3, 35], [5, 23], [6, 19], [7, 15], [8, 11], [1, 40], [2, 38], [4, 27], [0, 49], [3, 36], [5, 24], [6, 20], [7, 16], [8, 12], [1, 41], [2, 39], [4, 28], [0, 50], [3, 37], [5, 25], [6, 21], [7, 17], [8, 13], [1, 42], [2, 40], [4, 29], [0, 51], [3, 38], [5, 26], [6, 22], [7, 18], [8, 14], [1, 43], [2, 41], [4, 30], [0, 52], [3, 39], [5, 27], [6, 23], [7, 19], [8, 15], [1, 44], [2, 42], [4, 31], [0, 53], [3, 40], [5, 28], [6, 24], [7, 20], [8, 16], [1, 45], [2, 43], [4, 32], [0, 54], [3, 41], [5, 29], [6, 25], [7, 21], [8, 17], [1, 46], [2, 44], [4, 33], [0, 55], [3, 42], [5, 30], [6, 26], [7, 22], [8, 18], [1, 47], [2, 45], [4, 34], [0, 56], [3, 43], [5, 31], [6, 27], [7, 23], [8, 19], [1, 48], [2, 46], [4, 35], [0, 57], [3, 44], [5, 32], [6, 28], [7, 24], [8, 20], [1, 49], [2, 47], [4, 36], [0, 58], [3, 45], [5, 33], [6, 29], [7, 25], [8, 21], [1, 50], [2, 48], [4, 37], [0, 59], [3, 46], [5, 34], [6, 30], [7, 26], [8, 22], [1, 51], [2, 49], [4, 38], [0, 60], [3, 47], [5, 35], [6, 31], [7, 27], [8, 23], [1, 52], [2, 50], [4, 39], [0, 61], [3, 48], [5, 36], [6, 32], [7, 28], [8, 24], [1, 53], [2, 51], [4, 40], [0, 62], [3, 49], [5, 37], [6, 33], [7, 29], [8, 25], [1, 54], [2, 52], [4, 41], [0, 63], [3, 50], [5, 38], [6, 34], [7, 30], [8, 26], [1, 55], [2, 53], [4, 42], [0, 64], [3, 51], [5, 39], [6, 35], [7, 31], [8, 27], [1, 56], [2, 54], [4, 43], [0, 65], [3, 52], [5, 40], [6, 36], [7, 32], [8, 28], [1, 57], [2, 55], [4, 44], [0, 66], [3, 53], [5, 41], [6, 37], [7, 33], [8, 29], [1, 58], [2, 56], [4, 45], [0, 67], [3, 54], [5, 42], [6, 38], [7, 34], [8, 30], [1, 59], [2, 57], [4, 46], [0, 68], [3, 55], [5, 43], [6, 39], [7, 35], [8, 31], [1, 60], [2, 58], [4, 47], [0, 69], [3, 56], [5, 44], [6, 40], [7, 36], [8, 32], [1, 61], [2, 59], [4, 48], [0, 70], [3, 57], [5, 45], [6, 41], [7, 37], [8, 33], [1, 62], [2, 60], [4, 49], [0, 71], [3, 58], [5, 46], [6, 42], [7, 38], [8, 34], [1, 63], [2, 61], [4, 50], [0, 72], [3, 59], [5, 47], [6, 43], [7, 39], [8, 35], [1, 64], [2, 62], [4, 51], [0, 73], [3, 60], [5, 48], [6, 44], [7, 40], [8, 36], [1, 65], [2, 63], [4, 52], [3, 61], [5, 49], [6, 45], [7, 41], [8, 37], [1, 66], [2, 64], [4, 53], [3, 62], [5, 50], [6, 46], [7, 42], [8, 38], [1, 67], [2, 65], [4, 54], [3, 63], [5, 51], [6, 47], [7, 43], [8, 39], [1, 68], [2, 66], [4, 55], [3, 64], [5, 52], [6, 48], [7, 44], [8, 40], [1, 69], [2, 67], [4, 56], [3, 65], [5, 53], [6, 49], [7, 45], [8, 41], [1, 70], [2, 68], [4, 57], [3, 66], [5, 54], [6, 50], [7, 46], [8, 42], [1, 71], [2, 69], [4, 58], [3, 67], [5, 55], [6, 51], [7, 47], [8, 43], [1, 72], [2, 70], [4, 59], [3, 68], [5, 56], [6, 52], [7, 48], [8, 44], [1, 73], [2, 71], [4, 60], [3, 69], [5, 57], [6, 53], [7, 49], [8, 45], [2, 72], [4, 61], [3, 70], [5, 58], [6, 54], [7, 50], [8, 46], [2, 73], [4, 62], [3, 71], [5, 59], [6, 55], [7, 51], [8, 47], [4, 63], [3, 72], [5, 60], [6, 56], [7, 52], [8, 48], [4, 64], [3, 73], [5, 61], [6, 57], [7, 53], [8, 49], [4, 65], [5, 62], [6, 58], [7, 54], [8, 50], [4, 66], [5, 63], [6, 59], [7, 55], [8, 51], [4, 67], [5, 64], [6, 60], [7, 56], [8, 52], [4, 68], [5, 65], [6, 61], [7, 57], [8, 53], [4, 69], [5, 66], [6, 62], [7, 58], [8, 54], [4, 70], [5, 67], [6, 63], [7, 59], [8, 55], [4, 71], [5, 68], [6, 64], [7, 60], [8, 56], [4, 72], [5, 69], [6, 65], [7, 61], [8, 57], [4, 73], [5, 70], [6, 66], [7, 62], [8, 58], [5, 71], [6, 67], [7, 63], [8, 59], [5, 72], [6, 68], [7, 64], [8, 60], [5, 73], [6, 69], [7, 65], [8, 61], [6, 70], [7, 66], [8, 62], [6, 71], [7, 67], [8, 63], [6, 72], [7, 68], [8, 64], [6, 73], [7, 69], [8, 65], [7, 70], [8, 66], [7, 71], [8, 67], [7, 72], [8, 68], [7, 73], [8, 69], [8, 70], [8, 71], [8, 72], [8, 73]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PLAN.json.gz b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PLAN.json.gz new file mode 100644 index 0000000000..7a1db55a4d Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PLAN.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PROVIDERS.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PROVIDERS.json new file mode 100644 index 0000000000..bf7c87b4d1 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-PROVIDERS.json @@ -0,0 +1 @@ +{"gauge44":{"actual_paid_profile":{"1":2382,"2":650,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]},"extra":{"actual_paid_profile":{"1":2382,"2":650,"3":266,"4":128,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,8,7,7,7,7,7,7,7,7,7,7,7,8,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,5,8,8,8,8]}} \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-DISPATCH.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-DISPATCH.json new file mode 100644 index 0000000000..613e01490d --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-DISPATCH.json @@ -0,0 +1,1667 @@ +[ + [ + 0, + 0, + "extra" + ], + [ + 0, + 1, + "extra" + ], + [ + 0, + 2, + "extra" + ], + [ + 0, + 3, + "extra" + ], + [ + 0, + 4, + "extra" + ], + [ + 1, + 0, + "extra" + ], + [ + 0, + 5, + "extra" + ], + [ + 1, + 1, + "extra" + ], + [ + 0, + 6, + "extra" + ], + [ + 1, + 2, + "extra" + ], + [ + 0, + 7, + "extra" + ], + [ + 1, + 3, + "extra" + ], + [ + 0, + 8, + "extra" + ], + [ + 1, + 4, + "extra" + ], + [ + 0, + 9, + "extra" + ], + [ + 2, + 0, + "extra" + ], + [ + 1, + 5, + "extra" + ], + [ + 0, + 10, + "extra" + ], + [ + 2, + 1, + "extra" + ], + [ + 1, + 6, + "extra" + ], + [ + 0, + 11, + "extra" + ], + [ + 2, + 2, + "extra" + ], + [ + 1, + 7, + "extra" + ], + [ + 0, + 12, + "extra" + ], + [ + 2, + 3, + "extra" + ], + [ + 1, + 8, + "extra" + ], + [ + 0, + 13, + "extra" + ], + [ + 2, + 4, + "extra" + ], + [ + 1, + 9, + "extra" + ], + [ + 3, + 0, + "extra" + ], + [ + 0, + 14, + "extra" + ], + [ + 2, + 5, + "extra" + ], + [ + 1, + 10, + "extra" + ], + [ + 3, + 1, + "extra" + ], + [ + 0, + 15, + "extra" + ], + [ + 2, + 6, + "extra" + ], + [ + 1, + 11, + "extra" + ], + [ + 3, + 2, + "extra" + ], + [ + 0, + 16, + "extra" + ], + [ + 2, + 7, + "extra" + ], + [ + 1, + 12, + "extra" + ], + [ + 3, + 3, + "extra" + ], + [ + 0, + 17, + "extra" + ], + [ + 2, + 8, + "extra" + ], + [ + 1, + 13, + "extra" + ], + [ + 3, + 4, + "extra" + ], + [ + 0, + 18, + "extra" + ], + [ + 2, + 9, + "extra" + ], + [ + 4, + 0, + "extra" + ], + [ + 1, + 14, + "extra" + ], + [ + 3, + 5, + "extra" + ], + [ + 0, + 19, + "extra" + ], + [ + 2, + 10, + "extra" + ], + [ + 4, + 1, + "extra" + ], + [ + 1, + 15, + "extra" + ], + [ + 3, + 6, + "extra" + ], + [ + 0, + 20, + "extra" + ], + [ + 2, + 11, + "extra" + ], + [ + 4, + 2, + "extra" + ], + [ + 1, + 16, + "extra" + ], + [ + 3, + 7, + "extra" + ], + [ + 0, + 21, + "extra" + ], + [ + 2, + 12, + "extra" + ], + [ + 4, + 3, + "extra" + ], + [ + 1, + 17, + "extra" + ], + [ + 3, + 8, + "extra" + ], + [ + 0, + 22, + "extra" + ], + [ + 2, + 13, + "extra" + ], + [ + 4, + 4, + "extra" + ], + [ + 1, + 18, + "extra" + ], + [ + 3, + 9, + "extra" + ], + [ + 0, + 23, + "extra" + ], + [ + 5, + 0, + "extra" + ], + [ + 2, + 14, + "extra" + ], + [ + 4, + 5, + "extra" + ], + [ + 1, + 19, + "extra" + ], + [ + 3, + 10, + "extra" + ], + [ + 0, + 24, + "extra" + ], + [ + 5, + 1, + "extra" + ], + [ + 2, + 15, + "extra" + ], + [ + 4, + 6, + "extra" + ], + [ + 1, + 20, + "extra" + ], + [ + 3, + 11, + "extra" + ], + [ + 0, + 25, + "extra" + ], + [ + 5, + 2, + "extra" + ], + [ + 2, + 16, + "extra" + ], + [ + 4, + 7, + "extra" + ], + [ + 1, + 21, + "extra" + ], + [ + 3, + 12, + "extra" + ], + [ + 0, + 26, + "extra" + ], + [ + 5, + 3, + "extra" + ], + [ + 2, + 17, + "extra" + ], + [ + 4, + 8, + "extra" + ], + [ + 1, + 22, + "extra" + ], + [ + 3, + 13, + "extra" + ], + [ + 0, + 27, + "extra" + ], + [ + 5, + 4, + "extra" + ], + [ + 2, + 18, + "extra" + ], + [ + 4, + 9, + "extra" + ], + [ + 1, + 23, + "extra" + ], + [ + 6, + 0, + "extra" + ], + [ + 3, + 14, + "extra" + ], + [ + 0, + 28, + "extra" + ], + [ + 5, + 5, + "extra" + ], + [ + 2, + 19, + "extra" + ], + [ + 4, + 10, + "extra" + ], + [ + 1, + 24, + "extra" + ], + [ + 6, + 1, + "extra" + ], + [ + 3, + 15, + "extra" + ], + [ + 0, + 29, + "extra" + ], + [ + 5, + 6, + "extra" + ], + [ + 2, + 20, + "extra" + ], + [ + 4, + 11, + "extra" + ], + [ + 1, + 25, + "extra" + ], + [ + 6, + 2, + "extra" + ], + [ + 3, + 16, + "extra" + ], + [ + 0, + 30, + "extra" + ], + [ + 5, + 7, + "extra" + ], + [ + 2, + 21, + "extra" + ], + [ + 4, + 12, + "extra" + ], + [ + 1, + 26, + "extra" + ], + [ + 6, + 3, + "extra" + ], + [ + 3, + 17, + "extra" + ], + [ + 0, + 31, + "extra" + ], + [ + 5, + 8, + "extra" + ], + [ + 2, + 22, + "extra" + ], + [ + 4, + 13, + "extra" + ], + [ + 1, + 27, + "extra" + ], + [ + 6, + 4, + "extra" + ], + [ + 3, + 18, + "extra" + ], + [ + 0, + 32, + "extra" + ], + [ + 5, + 9, + "extra" + ], + [ + 2, + 23, + "extra" + ], + [ + 7, + 0, + "extra" + ], + [ + 4, + 14, + "extra" + ], + [ + 1, + 28, + "extra" + ], + [ + 6, + 5, + "extra" + ], + [ + 3, + 19, + "extra" + ], + [ + 0, + 33, + "extra" + ], + [ + 5, + 10, + "extra" + ], + [ + 2, + 24, + "extra" + ], + [ + 7, + 1, + "extra" + ], + [ + 4, + 15, + "extra" + ], + [ + 1, + 29, + "extra" + ], + [ + 6, + 6, + "extra" + ], + [ + 3, + 20, + "extra" + ], + [ + 0, + 34, + "extra" + ], + [ + 5, + 11, + "extra" + ], + [ + 2, + 25, + "extra" + ], + [ + 7, + 2, + "extra" + ], + [ + 4, + 16, + "extra" + ], + [ + 1, + 30, + "extra" + ], + [ + 6, + 7, + "extra" + ], + [ + 3, + 21, + "extra" + ], + [ + 0, + 35, + "extra" + ], + [ + 5, + 12, + "extra" + ], + [ + 2, + 26, + "extra" + ], + [ + 7, + 3, + "extra" + ], + [ + 4, + 17, + "extra" + ], + [ + 1, + 31, + "extra" + ], + [ + 6, + 8, + "extra" + ], + [ + 3, + 22, + "extra" + ], + [ + 0, + 36, + "extra" + ], + [ + 5, + 13, + "extra" + ], + [ + 2, + 27, + "extra" + ], + [ + 7, + 4, + "extra" + ], + [ + 4, + 18, + "extra" + ], + [ + 1, + 32, + "extra" + ], + [ + 6, + 9, + "extra" + ], + [ + 3, + 23, + "extra" + ], + [ + 8, + 0, + "extra" + ], + [ + 5, + 14, + "extra" + ], + [ + 2, + 28, + "extra" + ], + [ + 7, + 5, + "extra" + ], + [ + 4, + 19, + "extra" + ], + [ + 1, + 33, + "extra" + ], + [ + 6, + 10, + "extra" + ], + [ + 3, + 24, + "extra" + ], + [ + 8, + 1, + "extra" + ], + [ + 5, + 15, + "extra" + ], + [ + 2, + 29, + "extra" + ], + [ + 7, + 6, + "extra" + ], + [ + 4, + 20, + "extra" + ], + [ + 1, + 34, + "extra" + ], + [ + 6, + 11, + "extra" + ], + [ + 3, + 25, + "extra" + ], + [ + 8, + 2, + "extra" + ], + [ + 5, + 16, + "extra" + ], + [ + 2, + 30, + "extra" + ], + [ + 7, + 7, + "extra" + ], + [ + 4, + 21, + "extra" + ], + [ + 1, + 35, + "extra" + ], + [ + 6, + 12, + "extra" + ], + [ + 3, + 26, + "extra" + ], + [ + 8, + 3, + "extra" + ], + [ + 5, + 17, + "extra" + ], + [ + 2, + 31, + "extra" + ], + [ + 7, + 8, + "extra" + ], + [ + 4, + 22, + "extra" + ], + [ + 1, + 36, + "extra" + ], + [ + 6, + 13, + "extra" + ], + [ + 3, + 27, + "extra" + ], + [ + 8, + 4, + "extra" + ], + [ + 5, + 18, + "extra" + ], + [ + 2, + 32, + "extra" + ], + [ + 7, + 9, + "extra" + ], + [ + 4, + 23, + "extra" + ], + [ + 6, + 14, + "extra" + ], + [ + 3, + 28, + "gauge44" + ], + [ + 8, + 5, + "gauge44" + ], + [ + 5, + 19, + "gauge44" + ], + [ + 2, + 33, + "gauge44" + ], + [ + 7, + 10, + "gauge44" + ], + [ + 4, + 24, + "gauge44" + ], + [ + 6, + 15, + "gauge44" + ], + [ + 3, + 29, + "gauge44" + ], + [ + 8, + 6, + "gauge44" + ], + [ + 5, + 20, + "gauge44" + ], + [ + 2, + 34, + "gauge44" + ], + [ + 7, + 11, + "gauge44" + ], + [ + 4, + 25, + "gauge44" + ], + [ + 6, + 16, + "gauge44" + ], + [ + 3, + 30, + "gauge44" + ], + [ + 8, + 7, + "gauge44" + ], + [ + 5, + 21, + "gauge44" + ], + [ + 2, + 35, + "gauge44" + ], + [ + 7, + 12, + "gauge44" + ], + [ + 4, + 26, + "gauge44" + ], + [ + 6, + 17, + "gauge44" + ], + [ + 3, + 31, + "gauge44" + ], + [ + 8, + 8, + "gauge44" + ], + [ + 5, + 22, + "gauge44" + ], + [ + 2, + 36, + "gauge44" + ], + [ + 7, + 13, + "gauge44" + ], + [ + 4, + 27, + "gauge44" + ], + [ + 6, + 18, + "gauge44" + ], + [ + 3, + 32, + "gauge44" + ], + [ + 8, + 9, + "gauge44" + ], + [ + 5, + 23, + "gauge44" + ], + [ + 7, + 14, + "gauge44" + ], + [ + 4, + 28, + "gauge44" + ], + [ + 6, + 19, + "gauge44" + ], + [ + 3, + 33, + "gauge44" + ], + [ + 8, + 10, + "gauge44" + ], + [ + 5, + 24, + "gauge44" + ], + [ + 7, + 15, + "gauge44" + ], + [ + 4, + 29, + "gauge44" + ], + [ + 6, + 20, + "gauge44" + ], + [ + 3, + 34, + "gauge44" + ], + [ + 8, + 11, + "gauge44" + ], + [ + 5, + 25, + "gauge44" + ], + [ + 7, + 16, + "gauge44" + ], + [ + 4, + 30, + "gauge44" + ], + [ + 6, + 21, + "gauge44" + ], + [ + 3, + 35, + "gauge44" + ], + [ + 8, + 12, + "gauge44" + ], + [ + 5, + 26, + "gauge44" + ], + [ + 7, + 17, + "gauge44" + ], + [ + 4, + 31, + "gauge44" + ], + [ + 6, + 22, + "gauge44" + ], + [ + 3, + 36, + "gauge44" + ], + [ + 8, + 13, + "gauge44" + ], + [ + 5, + 27, + "gauge44" + ], + [ + 7, + 18, + "gauge44" + ], + [ + 4, + 32, + "gauge44" + ], + [ + 6, + 23, + "gauge44" + ], + [ + 8, + 14, + "gauge44" + ], + [ + 5, + 28, + "gauge44" + ], + [ + 7, + 19, + "gauge44" + ], + [ + 4, + 33, + "gauge44" + ], + [ + 6, + 24, + "gauge44" + ], + [ + 8, + 15, + "gauge44" + ], + [ + 5, + 29, + "gauge44" + ], + [ + 7, + 20, + "gauge44" + ], + [ + 4, + 34, + "gauge44" + ], + [ + 6, + 25, + "gauge44" + ], + [ + 8, + 16, + "gauge44" + ], + [ + 5, + 30, + "gauge44" + ], + [ + 7, + 21, + "gauge44" + ], + [ + 4, + 35, + "gauge44" + ], + [ + 6, + 26, + "gauge44" + ], + [ + 8, + 17, + "gauge44" + ], + [ + 5, + 31, + "gauge44" + ], + [ + 7, + 22, + "gauge44" + ], + [ + 4, + 36, + "gauge44" + ], + [ + 6, + 27, + "gauge44" + ], + [ + 8, + 18, + "gauge44" + ], + [ + 5, + 32, + "gauge44" + ], + [ + 7, + 23, + "gauge44" + ], + [ + 6, + 28, + "gauge44" + ], + [ + 8, + 19, + "gauge44" + ], + [ + 5, + 33, + "gauge44" + ], + [ + 7, + 24, + "gauge44" + ], + [ + 6, + 29, + "gauge44" + ], + [ + 8, + 20, + "gauge44" + ], + [ + 5, + 34, + "gauge44" + ], + [ + 7, + 25, + "gauge44" + ], + [ + 6, + 30, + "gauge44" + ], + [ + 8, + 21, + "gauge44" + ], + [ + 5, + 35, + "gauge44" + ], + [ + 7, + 26, + "gauge44" + ], + [ + 6, + 31, + "gauge44" + ], + [ + 8, + 22, + "gauge44" + ], + [ + 5, + 36, + "gauge44" + ], + [ + 7, + 27, + "gauge44" + ], + [ + 6, + 32, + "gauge44" + ], + [ + 8, + 23, + "gauge44" + ], + [ + 7, + 28, + "gauge44" + ], + [ + 6, + 33, + "gauge44" + ], + [ + 8, + 24, + "gauge44" + ], + [ + 7, + 29, + "gauge44" + ], + [ + 6, + 34, + "gauge44" + ], + [ + 8, + 25, + "gauge44" + ], + [ + 7, + 30, + "gauge44" + ], + [ + 6, + 35, + "gauge44" + ], + [ + 8, + 26, + "gauge44" + ], + [ + 7, + 31, + "gauge44" + ], + [ + 6, + 36, + "gauge44" + ], + [ + 8, + 27, + "gauge44" + ], + [ + 7, + 32, + "gauge44" + ], + [ + 8, + 28, + "gauge44" + ], + [ + 7, + 33, + "gauge44" + ], + [ + 8, + 29, + "gauge44" + ], + [ + 7, + 34, + "gauge44" + ], + [ + 8, + 30, + "gauge44" + ], + [ + 7, + 35, + "gauge44" + ], + [ + 8, + 31, + "gauge44" + ], + [ + 7, + 36, + "gauge44" + ], + [ + 8, + 32, + "gauge44" + ], + [ + 8, + 33, + "gauge44" + ], + [ + 8, + 34, + "gauge44" + ], + [ + 8, + 35, + "gauge44" + ], + [ + 8, + 36, + "gauge44" + ] +] diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-OWNERS.json.gz b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-OWNERS.json.gz new file mode 100644 index 0000000000..34fa5d69aa Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-OWNERS.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-TEMPLATE.json.gz b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-TEMPLATE.json.gz new file mode 100644 index 0000000000..114808c32b Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-T37-TEMPLATE.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-base.json.gz b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-base.json.gz new file mode 100644 index 0000000000..d3878e3be5 Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-base.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-extra.json.gz b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-extra.json.gz new file mode 100644 index 0000000000..0638b6ad9d Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/sources/PR2833-WORD-extra.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-CREDITS.md b/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-CREDITS.md new file mode 100644 index 0000000000..f9775c75c6 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-CREDITS.md @@ -0,0 +1,67 @@ +# Attribution and overlap + +This derivative retains PR2802's actual native words and uses a new source-bound +application of elementary owner-block norm accounting to the precision invoice. +The T114 gain has a new checked literal owner allocation and complete +admission. It does not claim a new general tensor-isomorphism identity, a first +TI application to multiplication, or an improvement from covariance alone. + +## Direct native and allocation ancestry + +Marius-Paul Dumitrean's [PR2802](https://github.com/CrocSwap/integer-mult-bounds/pull/2802), +head `17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd`, supplies the retained retired7 +native words, frame refits and restoration; its NOTICE records substantial +Anthropic Claude/Claude Code assistance. Tekalign's PR2751 supplies joint +twelve-source recovery. PR2766 and PR2733 contribute frame-route/refit work; +Philippe Van Velzen's PR2679 contributes pre-life hosting and retired-lender +aliases; Mason Hale's PR2696 contributes the assignment; zxv's PR2530 supplies +source-partner loans; Jeremy Kothe's PR2588 supplies helper-label exchange; +Cinna Davis's PR2226 supplies anticipatory dirty borrowing. Their exact notices +and licenses remain authoritative. + +[PR2824](https://github.com/CrocSwap/integer-mult-bounds/pull/2824), by Dugongue, +is the preceding checked T94 tail-dilution construction. The succeeding admitted +T104 allocation and its authenticated native receipts are direct predecessors. +The native words and paid local mechanism are inherited; replica dilution does +not earn credit for a new word construction. Existing Rohan Arun and selected +icekylinx/source-frame/compiler lineage remains credited by retained notices. + +## Earlier tensor, gauge and response mechanisms + +| Source | Author | Relevant earlier contribution | +|---|---|---| +| [PR471](https://github.com/CrocSwap/integer-mult-bounds/pull/471) | Dugongue | Full-nine-axis two-sided monomial normalization, arbitrary dirty endpoints and restored same-owner spectators. | +| [PR476](https://github.com/CrocSwap/integer-mult-bounds/pull/476), [PR478](https://github.com/CrocSwap/integer-mult-bounds/pull/478) | Dugongue | Target transvections and interval correction/recovery, including overlapping factors. | +| [PR483](https://github.com/CrocSwap/integer-mult-bounds/pull/483) | Dugongue | Simultaneous response-packet cancellation and nested donor flags. | +| [PR492](https://github.com/CrocSwap/integer-mult-bounds/pull/492) | Dugongue | Equal nonzero-response relocation and stage-conditioned providers. | +| [PR498](https://github.com/CrocSwap/integer-mult-bounds/pull/498) | Dugongue | Rational-span intersections and paired rational whole-owner routing. | +| [PR508](https://github.com/CrocSwap/integer-mult-bounds/pull/508) | Dugongue | Joint gauge collapse; shared maxima require a complete reconstructed invoice. | +| [PR537](https://github.com/CrocSwap/integer-mult-bounds/pull/537) | Dugongue | Higher-dimensional response spaces, rank32 saturation, observational rewriting and contextual registry gluing. | +| [PR556](https://github.com/CrocSwap/integer-mult-bounds/pull/556) | Dugongue | Exact directed-cut frame optimization and eight costed structural transfers. | +| [PR563](https://github.com/CrocSwap/integer-mult-bounds/pull/563) | Dugongue | Contextual provider selection, partial-group penalties and finite pooling. | +| [PR2742](https://github.com/CrocSwap/integer-mult-bounds/pull/2742) | Jose Manuel (`jmbarrancoml`) | Actual native dirty-reader covariance, dyadic helper chart and phase-correct monomials; eight rank-eight descents remain. | + +PR2742 records substantial OpenAI Codex assistance and credits ywz65/PR2491 for +the full dirty reader, signed data permutation and framed interpretation; Ross +Richardson/PR2500 for the dyadic chart and typed cost audit; Cinna Davis/PR1391 +and PR1410 for order-four echo; Aaron Wang (`navinor`)/PR2595 for phase windows; +and Ali Romman/PR1719 for the Gaussian-dyadic compiler/interpreter. An unsigned +ERASE transport rule does not apply automatically to its mixed helper chart. + +PR2341 (bitplane), PR2378 (AAAmirinu) and PR2422 (bitplane) provide earlier +conditional whole-array tensor/monomial semantics. Their retained credits include +Jose Manuel, Gareth Davidson, AAAmirinu, DreamingOfClouds and Lemma G contributors, +plus Mathlib. These interfaces do not by themselves discharge the full physical +compiler. Relevant older R715 lineage also includes DreamingOfClouds/PR463, +Rohan Arun/PR467/470 and chafreaky/PR458/472/502. + +## This review's scope + +The current-source endpoint/block audit, finite allocations, directed arithmetic +and new Mathlib energy lemmas are distinct from inherited native evidence. +Authenticated reuse must be described explicitly. Current reader symmetries and +failed bounded gauge searches are research evidence, not additional kappa gains. +The finite-group and direct-sum mathematics is classical; no global novelty +claim is made. [FRONTIER.md](FRONTIER.md) records the bounded source coverage and +missing historical records. Exact source hashes and original notices take +precedence over summaries or mutable PR titles. diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-LICENSE b/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2839-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/shared-kernel-packing/vendor/pr2857/sources/PR2843-DISPATCH.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-DISPATCH.json new file mode 100644 index 0000000000..1c0260deab --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-DISPATCH.json @@ -0,0 +1 @@ +[[0,0,"extra"],[0,1,"extra"],[0,2,"extra"],[0,3,"extra"],[0,4,"extra"],[0,5,"extra"],[0,6,"extra"],[0,7,"extra"],[0,8,"extra"],[1,0,"extra"],[0,9,"extra"],[1,1,"extra"],[0,10,"extra"],[1,2,"extra"],[2,0,"extra"],[0,11,"extra"],[1,3,"extra"],[2,1,"extra"],[0,12,"extra"],[1,4,"extra"],[2,2,"extra"],[0,13,"extra"],[3,0,"extra"],[1,5,"extra"],[2,3,"extra"],[0,14,"extra"],[3,1,"extra"],[1,6,"extra"],[2,4,"extra"],[0,15,"extra"],[3,2,"extra"],[1,7,"extra"],[2,5,"extra"],[0,16,"extra"],[3,3,"extra"],[1,8,"extra"],[2,6,"extra"],[0,17,"extra"],[3,4,"extra"],[1,9,"extra"],[2,7,"extra"],[0,18,"extra"],[3,5,"extra"],[1,10,"extra"],[2,8,"extra"],[0,19,"extra"],[3,6,"extra"],[1,11,"extra"],[2,9,"extra"],[0,20,"extra"],[3,7,"extra"],[1,12,"extra"],[2,10,"extra"],[0,21,"extra"],[3,8,"extra"],[1,13,"extra"],[2,11,"extra"],[4,0,"extra"],[0,22,"extra"],[3,9,"extra"],[1,14,"extra"],[2,12,"extra"],[4,1,"extra"],[0,23,"extra"],[3,10,"extra"],[1,15,"extra"],[2,13,"extra"],[4,2,"extra"],[0,24,"extra"],[3,11,"extra"],[1,16,"extra"],[2,14,"extra"],[4,3,"extra"],[0,25,"extra"],[3,12,"extra"],[5,0,"extra"],[1,17,"extra"],[2,15,"extra"],[4,4,"extra"],[0,26,"extra"],[3,13,"extra"],[5,1,"extra"],[1,18,"extra"],[2,16,"extra"],[4,5,"extra"],[0,27,"extra"],[3,14,"extra"],[5,2,"extra"],[1,19,"extra"],[2,17,"extra"],[4,6,"extra"],[0,28,"extra"],[3,15,"extra"],[5,3,"extra"],[1,20,"extra"],[2,18,"extra"],[4,7,"extra"],[0,29,"extra"],[3,16,"extra"],[5,4,"extra"],[6,0,"extra"],[1,21,"extra"],[2,19,"extra"],[4,8,"extra"],[0,30,"extra"],[3,17,"extra"],[5,5,"extra"],[6,1,"extra"],[1,22,"extra"],[2,20,"extra"],[4,9,"extra"],[0,31,"extra"],[3,18,"extra"],[5,6,"extra"],[6,2,"extra"],[1,23,"extra"],[2,21,"extra"],[4,10,"extra"],[0,32,"extra"],[3,19,"extra"],[5,7,"extra"],[6,3,"extra"],[1,24,"extra"],[2,22,"extra"],[4,11,"extra"],[0,33,"extra"],[3,20,"extra"],[5,8,"extra"],[6,4,"extra"],[7,0,"extra"],[1,25,"extra"],[2,23,"extra"],[4,12,"extra"],[0,34,"extra"],[3,21,"extra"],[5,9,"extra"],[6,5,"extra"],[7,1,"extra"],[1,26,"extra"],[2,24,"extra"],[4,13,"extra"],[0,35,"extra"],[3,22,"extra"],[5,10,"extra"],[6,6,"extra"],[7,2,"extra"],[1,27,"extra"],[2,25,"extra"],[4,14,"extra"],[0,36,"extra"],[3,23,"extra"],[5,11,"extra"],[6,7,"extra"],[7,3,"extra"],[1,28,"extra"],[2,26,"extra"],[4,15,"extra"],[0,37,"extra"],[3,24,"extra"],[5,12,"extra"],[6,8,"extra"],[7,4,"extra"],[8,0,"extra"],[1,29,"extra"],[2,27,"extra"],[4,16,"extra"],[0,38,"extra"],[3,25,"extra"],[5,13,"extra"],[6,9,"extra"],[7,5,"extra"],[8,1,"extra"],[1,30,"extra"],[2,28,"extra"],[4,17,"extra"],[0,39,"extra"],[3,26,"extra"],[5,14,"extra"],[6,10,"extra"],[7,6,"extra"],[8,2,"extra"],[1,31,"extra"],[2,29,"extra"],[4,18,"extra"],[0,40,"extra"],[3,27,"extra"],[5,15,"extra"],[6,11,"extra"],[7,7,"extra"],[8,3,"extra"],[1,32,"extra"],[2,30,"extra"],[4,19,"extra"],[0,41,"extra"],[3,28,"extra"],[5,16,"extra"],[6,12,"extra"],[7,8,"extra"],[8,4,"extra"],[1,33,"extra"],[2,31,"extra"],[4,20,"extra"],[0,42,"extra"],[3,29,"gauge44"],[5,17,"extra"],[6,13,"extra"],[7,9,"extra"],[8,5,"gauge44"],[1,34,"extra"],[2,32,"extra"],[4,21,"extra"],[0,43,"extra"],[3,30,"gauge44"],[5,18,"extra"],[6,14,"extra"],[7,10,"gauge44"],[8,6,"gauge44"],[1,35,"extra"],[2,33,"gauge44"],[4,22,"extra"],[0,44,"extra"],[3,31,"gauge44"],[5,19,"gauge44"],[6,15,"gauge44"],[7,11,"gauge44"],[8,7,"gauge44"],[1,36,"extra"],[2,34,"gauge44"],[4,23,"extra"],[0,45,"extra"],[3,32,"gauge44"],[5,20,"gauge44"],[6,16,"gauge44"],[7,12,"gauge44"],[8,8,"gauge44"],[1,37,"extra"],[2,35,"gauge44"],[4,24,"gauge44"],[0,46,"extra"],[3,33,"gauge44"],[5,21,"gauge44"],[6,17,"gauge44"],[7,13,"gauge44"],[8,9,"gauge44"],[1,38,"extra"],[2,36,"gauge44"],[4,25,"gauge44"],[0,47,"extra"],[3,34,"gauge44"],[5,22,"gauge44"],[6,18,"gauge44"],[7,14,"gauge44"],[8,10,"gauge44"],[1,39,"extra"],[2,37,"extra"],[4,26,"gauge44"],[0,48,"extra"],[3,35,"gauge44"],[5,23,"gauge44"],[6,19,"gauge44"],[7,15,"gauge44"],[8,11,"gauge44"],[1,40,"extra"],[2,38,"extra"],[4,27,"gauge44"],[0,49,"extra"],[3,36,"gauge44"],[5,24,"gauge44"],[6,20,"gauge44"],[7,16,"gauge44"],[8,12,"gauge44"],[1,41,"extra"],[2,39,"extra"],[4,28,"gauge44"],[0,50,"extra"],[3,37,"extra"],[5,25,"gauge44"],[6,21,"gauge44"],[7,17,"gauge44"],[8,13,"gauge44"],[1,42,"extra"],[2,40,"extra"],[4,29,"gauge44"],[0,51,"extra"],[3,38,"extra"],[5,26,"gauge44"],[6,22,"gauge44"],[7,18,"gauge44"],[8,14,"gauge44"],[1,43,"extra"],[2,41,"extra"],[4,30,"gauge44"],[0,52,"extra"],[3,39,"extra"],[5,27,"gauge44"],[6,23,"gauge44"],[7,19,"gauge44"],[8,15,"gauge44"],[1,44,"extra"],[2,42,"extra"],[4,31,"gauge44"],[0,53,"extra"],[3,40,"extra"],[5,28,"gauge44"],[6,24,"gauge44"],[7,20,"gauge44"],[8,16,"gauge44"],[1,45,"extra"],[2,43,"extra"],[4,32,"gauge44"],[0,54,"extra"],[3,41,"extra"],[5,29,"gauge44"],[6,25,"gauge44"],[7,21,"gauge44"],[8,17,"gauge44"],[1,46,"extra"],[2,44,"extra"],[4,33,"gauge44"],[0,55,"extra"],[3,42,"extra"],[5,30,"gauge44"],[6,26,"gauge44"],[7,22,"gauge44"],[8,18,"gauge44"],[1,47,"extra"],[2,45,"extra"],[4,34,"gauge44"],[0,56,"extra"],[3,43,"extra"],[5,31,"gauge44"],[6,27,"gauge44"],[7,23,"gauge44"],[8,19,"gauge44"],[1,48,"extra"],[2,46,"extra"],[4,35,"gauge44"],[0,57,"extra"],[3,44,"extra"],[5,32,"gauge44"],[6,28,"gauge44"],[7,24,"gauge44"],[8,20,"gauge44"],[1,49,"extra"],[2,47,"extra"],[4,36,"gauge44"],[0,58,"extra"],[3,45,"extra"],[5,33,"gauge44"],[6,29,"gauge44"],[7,25,"gauge44"],[8,21,"gauge44"],[1,50,"extra"],[2,48,"extra"],[4,37,"extra"],[0,59,"extra"],[3,46,"extra"],[5,34,"gauge44"],[6,30,"gauge44"],[7,26,"gauge44"],[8,22,"gauge44"],[1,51,"extra"],[2,49,"extra"],[4,38,"extra"],[0,60,"extra"],[3,47,"extra"],[5,35,"gauge44"],[6,31,"gauge44"],[7,27,"gauge44"],[8,23,"gauge44"],[1,52,"extra"],[2,50,"extra"],[4,39,"extra"],[0,61,"extra"],[3,48,"extra"],[5,36,"gauge44"],[6,32,"gauge44"],[7,28,"gauge44"],[8,24,"gauge44"],[1,53,"extra"],[2,51,"extra"],[4,40,"extra"],[0,62,"extra"],[3,49,"extra"],[5,37,"extra"],[6,33,"gauge44"],[7,29,"gauge44"],[8,25,"gauge44"],[1,54,"extra"],[2,52,"extra"],[4,41,"extra"],[0,63,"extra"],[3,50,"extra"],[5,38,"extra"],[6,34,"gauge44"],[7,30,"gauge44"],[8,26,"gauge44"],[1,55,"extra"],[2,53,"extra"],[4,42,"extra"],[0,64,"extra"],[3,51,"extra"],[5,39,"extra"],[6,35,"gauge44"],[7,31,"gauge44"],[8,27,"gauge44"],[1,56,"extra"],[2,54,"extra"],[4,43,"extra"],[0,65,"extra"],[3,52,"extra"],[5,40,"extra"],[6,36,"gauge44"],[7,32,"gauge44"],[8,28,"gauge44"],[1,57,"extra"],[2,55,"extra"],[4,44,"extra"],[0,66,"extra"],[3,53,"extra"],[5,41,"extra"],[6,37,"extra"],[7,33,"gauge44"],[8,29,"gauge44"],[1,58,"extra"],[2,56,"extra"],[4,45,"extra"],[0,67,"extra"],[3,54,"extra"],[5,42,"extra"],[6,38,"extra"],[7,34,"gauge44"],[8,30,"gauge44"],[1,59,"extra"],[2,57,"extra"],[4,46,"extra"],[0,68,"extra"],[3,55,"extra"],[5,43,"extra"],[6,39,"extra"],[7,35,"gauge44"],[8,31,"gauge44"],[1,60,"extra"],[2,58,"extra"],[4,47,"extra"],[0,69,"extra"],[3,56,"extra"],[5,44,"extra"],[6,40,"extra"],[7,36,"gauge44"],[8,32,"gauge44"],[1,61,"extra"],[2,59,"extra"],[4,48,"extra"],[0,70,"extra"],[3,57,"extra"],[5,45,"extra"],[6,41,"extra"],[7,37,"extra"],[8,33,"gauge44"],[1,62,"extra"],[2,60,"extra"],[4,49,"extra"],[0,71,"extra"],[3,58,"extra"],[5,46,"extra"],[6,42,"extra"],[7,38,"extra"],[8,34,"gauge44"],[1,63,"extra"],[2,61,"extra"],[4,50,"extra"],[0,72,"extra"],[3,59,"extra"],[5,47,"extra"],[6,43,"extra"],[7,39,"extra"],[8,35,"gauge44"],[1,64,"extra"],[2,62,"extra"],[4,51,"extra"],[0,73,"extra"],[3,60,"extra"],[5,48,"extra"],[6,44,"extra"],[7,40,"extra"],[8,36,"gauge44"],[1,65,"extra"],[2,63,"extra"],[4,52,"extra"],[0,74,"gauge44"],[3,61,"extra"],[5,49,"extra"],[6,45,"extra"],[7,41,"extra"],[8,37,"extra"],[1,66,"extra"],[2,64,"extra"],[4,53,"extra"],[0,75,"gauge44"],[3,62,"extra"],[5,50,"extra"],[6,46,"extra"],[7,42,"extra"],[8,38,"extra"],[1,67,"extra"],[2,65,"extra"],[4,54,"extra"],[0,76,"gauge44"],[3,63,"extra"],[5,51,"extra"],[6,47,"extra"],[7,43,"extra"],[8,39,"extra"],[1,68,"extra"],[2,66,"extra"],[4,55,"extra"],[0,77,"gauge44"],[3,64,"extra"],[5,52,"extra"],[6,48,"extra"],[7,44,"extra"],[8,40,"extra"],[1,69,"extra"],[2,67,"extra"],[4,56,"extra"],[0,78,"gauge44"],[3,65,"gauge44"],[5,53,"extra"],[6,49,"extra"],[7,45,"extra"],[8,41,"extra"],[1,70,"extra"],[2,68,"extra"],[4,57,"extra"],[0,79,"gauge44"],[3,66,"gauge44"],[5,54,"extra"],[6,50,"extra"],[7,46,"extra"],[8,42,"gauge44"],[1,71,"extra"],[2,69,"extra"],[4,58,"extra"],[0,80,"gauge44"],[3,67,"gauge44"],[5,55,"extra"],[6,51,"extra"],[7,47,"gauge44"],[8,43,"gauge44"],[1,72,"extra"],[2,70,"gauge44"],[4,59,"extra"],[0,81,"gauge44"],[3,68,"gauge44"],[5,56,"gauge44"],[6,52,"gauge44"],[7,48,"gauge44"],[8,44,"gauge44"],[1,73,"extra"],[2,71,"gauge44"],[4,60,"extra"],[0,82,"gauge44"],[3,69,"gauge44"],[5,57,"gauge44"],[6,53,"gauge44"],[7,49,"gauge44"],[8,45,"gauge44"],[1,74,"gauge44"],[2,72,"gauge44"],[4,61,"gauge44"],[0,83,"gauge44"],[3,70,"gauge44"],[5,58,"gauge44"],[6,54,"gauge44"],[7,50,"gauge44"],[8,46,"gauge44"],[1,75,"gauge44"],[2,73,"gauge44"],[4,62,"gauge44"],[0,84,"gauge44"],[3,71,"gauge44"],[5,59,"gauge44"],[6,55,"gauge44"],[7,51,"gauge44"],[8,47,"gauge44"],[1,76,"gauge44"],[2,74,"gauge44"],[4,63,"gauge44"],[0,85,"gauge44"],[3,72,"gauge44"],[5,60,"gauge44"],[6,56,"gauge44"],[7,52,"gauge44"],[8,48,"gauge44"],[1,77,"gauge44"],[2,75,"gauge44"],[4,64,"gauge44"],[0,86,"gauge44"],[3,73,"gauge44"],[5,61,"gauge44"],[6,57,"gauge44"],[7,53,"gauge44"],[8,49,"gauge44"],[1,78,"gauge44"],[2,76,"gauge44"],[4,65,"gauge44"],[0,87,"gauge44"],[3,74,"gauge44"],[5,62,"gauge44"],[6,58,"gauge44"],[7,54,"gauge44"],[8,50,"gauge44"],[1,79,"gauge44"],[2,77,"gauge44"],[4,66,"gauge44"],[0,88,"gauge44"],[3,75,"gauge44"],[5,63,"gauge44"],[6,59,"gauge44"],[7,55,"gauge44"],[8,51,"gauge44"],[1,80,"gauge44"],[2,78,"gauge44"],[4,67,"gauge44"],[0,89,"gauge44"],[3,76,"gauge44"],[5,64,"gauge44"],[6,60,"gauge44"],[7,56,"gauge44"],[8,52,"gauge44"],[1,81,"gauge44"],[2,79,"gauge44"],[4,68,"gauge44"],[0,90,"gauge44"],[3,77,"gauge44"],[5,65,"gauge44"],[6,61,"gauge44"],[7,57,"gauge44"],[8,53,"gauge44"],[1,82,"gauge44"],[2,80,"gauge44"],[4,69,"gauge44"],[0,91,"gauge44"],[3,78,"gauge44"],[5,66,"gauge44"],[6,62,"gauge44"],[7,58,"gauge44"],[8,54,"gauge44"],[1,83,"gauge44"],[2,81,"gauge44"],[4,70,"gauge44"],[0,92,"gauge44"],[3,79,"gauge44"],[5,67,"gauge44"],[6,63,"gauge44"],[7,59,"gauge44"],[8,55,"gauge44"],[1,84,"gauge44"],[2,82,"gauge44"],[4,71,"gauge44"],[0,93,"gauge44"],[3,80,"gauge44"],[5,68,"gauge44"],[6,64,"gauge44"],[7,60,"gauge44"],[8,56,"gauge44"],[1,85,"gauge44"],[2,83,"gauge44"],[4,72,"gauge44"],[0,94,"gauge44"],[3,81,"gauge44"],[5,69,"gauge44"],[6,65,"gauge44"],[7,61,"gauge44"],[8,57,"gauge44"],[1,86,"gauge44"],[2,84,"gauge44"],[4,73,"gauge44"],[0,95,"gauge44"],[3,82,"gauge44"],[5,70,"gauge44"],[6,66,"gauge44"],[7,62,"gauge44"],[8,58,"gauge44"],[1,87,"gauge44"],[2,85,"gauge44"],[4,74,"gauge44"],[0,96,"gauge44"],[3,83,"gauge44"],[5,71,"gauge44"],[6,67,"gauge44"],[7,63,"gauge44"],[8,59,"gauge44"],[1,88,"gauge44"],[2,86,"gauge44"],[4,75,"gauge44"],[0,97,"gauge44"],[3,84,"gauge44"],[5,72,"gauge44"],[6,68,"gauge44"],[7,64,"gauge44"],[8,60,"gauge44"],[1,89,"gauge44"],[2,87,"gauge44"],[4,76,"gauge44"],[0,98,"gauge44"],[3,85,"gauge44"],[5,73,"gauge44"],[6,69,"gauge44"],[7,65,"gauge44"],[8,61,"gauge44"],[1,90,"gauge44"],[2,88,"gauge44"],[4,77,"gauge44"],[0,99,"gauge44"],[3,86,"gauge44"],[5,74,"gauge44"],[6,70,"gauge44"],[7,66,"gauge44"],[8,62,"gauge44"],[1,91,"gauge44"],[2,89,"gauge44"],[4,78,"gauge44"],[0,100,"gauge44"],[3,87,"gauge44"],[5,75,"gauge44"],[6,71,"gauge44"],[7,67,"gauge44"],[8,63,"gauge44"],[1,92,"gauge44"],[2,90,"gauge44"],[4,79,"gauge44"],[0,101,"gauge44"],[3,88,"gauge44"],[5,76,"gauge44"],[6,72,"gauge44"],[7,68,"gauge44"],[8,64,"gauge44"],[1,93,"gauge44"],[2,91,"gauge44"],[4,80,"gauge44"],[0,102,"gauge44"],[3,89,"gauge44"],[5,77,"gauge44"],[6,73,"gauge44"],[7,69,"gauge44"],[8,65,"gauge44"],[1,94,"gauge44"],[2,92,"gauge44"],[4,81,"gauge44"],[0,103,"gauge44"],[3,90,"gauge44"],[5,78,"gauge44"],[6,74,"gauge44"],[7,70,"gauge44"],[8,66,"gauge44"],[1,95,"gauge44"],[2,93,"gauge44"],[4,82,"gauge44"],[0,104,"gauge44"],[3,91,"gauge44"],[5,79,"gauge44"],[6,75,"gauge44"],[7,71,"gauge44"],[8,67,"gauge44"],[1,96,"gauge44"],[2,94,"gauge44"],[4,83,"gauge44"],[0,105,"gauge44"],[3,92,"gauge44"],[5,80,"gauge44"],[6,76,"gauge44"],[7,72,"gauge44"],[8,68,"gauge44"],[1,97,"gauge44"],[2,95,"gauge44"],[4,84,"gauge44"],[0,106,"gauge44"],[3,93,"gauge44"],[5,81,"gauge44"],[6,77,"gauge44"],[7,73,"gauge44"],[8,69,"gauge44"],[1,98,"gauge44"],[2,96,"gauge44"],[4,85,"gauge44"],[0,107,"gauge44"],[3,94,"gauge44"],[5,82,"gauge44"],[6,78,"gauge44"],[7,74,"gauge44"],[8,70,"gauge44"],[1,99,"gauge44"],[2,97,"gauge44"],[4,86,"gauge44"],[0,108,"gauge44"],[3,95,"gauge44"],[5,83,"gauge44"],[6,79,"gauge44"],[7,75,"gauge44"],[8,71,"gauge44"],[1,100,"gauge44"],[2,98,"gauge44"],[4,87,"gauge44"],[0,109,"gauge44"],[3,96,"gauge44"],[5,84,"gauge44"],[6,80,"gauge44"],[7,76,"gauge44"],[8,72,"gauge44"],[1,101,"gauge44"],[2,99,"gauge44"],[4,88,"gauge44"],[0,110,"gauge44"],[3,97,"gauge44"],[5,85,"gauge44"],[6,81,"gauge44"],[7,77,"gauge44"],[8,73,"gauge44"],[1,102,"gauge44"],[2,100,"gauge44"],[4,89,"gauge44"],[0,111,"gauge44"],[3,98,"gauge44"],[5,86,"gauge44"],[6,82,"gauge44"],[7,78,"gauge44"],[8,74,"gauge44"],[1,103,"gauge44"],[2,101,"gauge44"],[4,90,"gauge44"],[0,112,"gauge44"],[3,99,"gauge44"],[5,87,"gauge44"],[6,83,"gauge44"],[7,79,"gauge44"],[8,75,"gauge44"],[1,104,"gauge44"],[2,102,"gauge44"],[4,91,"gauge44"],[0,113,"gauge44"],[3,100,"gauge44"],[5,88,"gauge44"],[6,84,"gauge44"],[7,80,"gauge44"],[8,76,"gauge44"],[1,105,"gauge44"],[2,103,"gauge44"],[4,92,"gauge44"],[0,114,"gauge44"],[3,101,"gauge44"],[5,89,"gauge44"],[6,85,"gauge44"],[7,81,"gauge44"],[8,77,"gauge44"],[1,106,"gauge44"],[2,104,"gauge44"],[4,93,"gauge44"],[0,115,"gauge44"],[3,102,"gauge44"],[5,90,"gauge44"],[6,86,"gauge44"],[7,82,"gauge44"],[8,78,"gauge44"],[1,107,"gauge44"],[2,105,"gauge44"],[4,94,"gauge44"],[0,116,"gauge44"],[3,103,"gauge44"],[5,91,"gauge44"],[6,87,"gauge44"],[7,83,"gauge44"],[8,79,"gauge44"],[1,108,"gauge44"],[2,106,"gauge44"],[4,95,"gauge44"],[0,117,"gauge44"],[3,104,"gauge44"],[5,92,"gauge44"],[6,88,"gauge44"],[7,84,"gauge44"],[8,80,"gauge44"],[1,109,"gauge44"],[2,107,"gauge44"],[4,96,"gauge44"],[0,118,"gauge44"],[3,105,"gauge44"],[5,93,"gauge44"],[6,89,"gauge44"],[7,85,"gauge44"],[8,81,"gauge44"],[1,110,"gauge44"],[2,108,"gauge44"],[4,97,"gauge44"],[0,119,"gauge44"],[3,106,"gauge44"],[5,94,"gauge44"],[6,90,"gauge44"],[7,86,"gauge44"],[8,82,"gauge44"],[1,111,"gauge44"],[2,109,"gauge44"],[4,98,"gauge44"],[0,120,"gauge44"],[3,107,"gauge44"],[5,95,"gauge44"],[6,91,"gauge44"],[7,87,"gauge44"],[8,83,"gauge44"],[1,112,"gauge44"],[2,110,"gauge44"],[4,99,"gauge44"],[0,121,"gauge44"],[3,108,"gauge44"],[5,96,"gauge44"],[6,92,"gauge44"],[7,88,"gauge44"],[8,84,"gauge44"],[1,113,"gauge44"],[2,111,"gauge44"],[4,100,"gauge44"],[0,122,"gauge44"],[3,109,"gauge44"],[5,97,"gauge44"],[6,93,"gauge44"],[7,89,"gauge44"],[8,85,"gauge44"],[1,114,"gauge44"],[2,112,"gauge44"],[4,101,"gauge44"],[0,123,"gauge44"],[3,110,"gauge44"],[5,98,"gauge44"],[6,94,"gauge44"],[7,90,"gauge44"],[8,86,"gauge44"],[1,115,"gauge44"],[2,113,"gauge44"],[4,102,"gauge44"],[3,111,"gauge44"],[5,99,"gauge44"],[6,95,"gauge44"],[7,91,"gauge44"],[8,87,"gauge44"],[1,116,"gauge44"],[2,114,"gauge44"],[4,103,"gauge44"],[3,112,"gauge44"],[5,100,"gauge44"],[6,96,"gauge44"],[7,92,"gauge44"],[8,88,"gauge44"],[1,117,"gauge44"],[2,115,"gauge44"],[4,104,"gauge44"],[3,113,"gauge44"],[5,101,"gauge44"],[6,97,"gauge44"],[7,93,"gauge44"],[8,89,"gauge44"],[1,118,"gauge44"],[2,116,"gauge44"],[4,105,"gauge44"],[3,114,"gauge44"],[5,102,"gauge44"],[6,98,"gauge44"],[7,94,"gauge44"],[8,90,"gauge44"],[1,119,"gauge44"],[2,117,"gauge44"],[4,106,"gauge44"],[3,115,"gauge44"],[5,103,"gauge44"],[6,99,"gauge44"],[7,95,"gauge44"],[8,91,"gauge44"],[1,120,"gauge44"],[2,118,"gauge44"],[4,107,"gauge44"],[3,116,"gauge44"],[5,104,"gauge44"],[6,100,"gauge44"],[7,96,"gauge44"],[8,92,"gauge44"],[1,121,"gauge44"],[2,119,"gauge44"],[4,108,"gauge44"],[3,117,"gauge44"],[5,105,"gauge44"],[6,101,"gauge44"],[7,97,"gauge44"],[8,93,"gauge44"],[1,122,"gauge44"],[2,120,"gauge44"],[4,109,"gauge44"],[3,118,"gauge44"],[5,106,"gauge44"],[6,102,"gauge44"],[7,98,"gauge44"],[8,94,"gauge44"],[1,123,"gauge44"],[2,121,"gauge44"],[4,110,"gauge44"],[3,119,"gauge44"],[5,107,"gauge44"],[6,103,"gauge44"],[7,99,"gauge44"],[8,95,"gauge44"],[2,122,"gauge44"],[4,111,"gauge44"],[3,120,"gauge44"],[5,108,"gauge44"],[6,104,"gauge44"],[7,100,"gauge44"],[8,96,"gauge44"],[2,123,"gauge44"],[4,112,"gauge44"],[3,121,"gauge44"],[5,109,"gauge44"],[6,105,"gauge44"],[7,101,"gauge44"],[8,97,"gauge44"],[4,113,"gauge44"],[3,122,"gauge44"],[5,110,"gauge44"],[6,106,"gauge44"],[7,102,"gauge44"],[8,98,"gauge44"],[4,114,"gauge44"],[3,123,"gauge44"],[5,111,"gauge44"],[6,107,"gauge44"],[7,103,"gauge44"],[8,99,"gauge44"],[4,115,"gauge44"],[5,112,"gauge44"],[6,108,"gauge44"],[7,104,"gauge44"],[8,100,"gauge44"],[4,116,"gauge44"],[5,113,"gauge44"],[6,109,"gauge44"],[7,105,"gauge44"],[8,101,"gauge44"],[4,117,"gauge44"],[5,114,"gauge44"],[6,110,"gauge44"],[7,106,"gauge44"],[8,102,"gauge44"],[4,118,"gauge44"],[5,115,"gauge44"],[6,111,"gauge44"],[7,107,"gauge44"],[8,103,"gauge44"],[4,119,"gauge44"],[5,116,"gauge44"],[6,112,"gauge44"],[7,108,"gauge44"],[8,104,"gauge44"],[4,120,"gauge44"],[5,117,"gauge44"],[6,113,"gauge44"],[7,109,"gauge44"],[8,105,"gauge44"],[4,121,"gauge44"],[5,118,"gauge44"],[6,114,"gauge44"],[7,110,"gauge44"],[8,106,"gauge44"],[4,122,"gauge44"],[5,119,"gauge44"],[6,115,"gauge44"],[7,111,"gauge44"],[8,107,"gauge44"],[4,123,"gauge44"],[5,120,"gauge44"],[6,116,"gauge44"],[7,112,"gauge44"],[8,108,"gauge44"],[5,121,"gauge44"],[6,117,"gauge44"],[7,113,"gauge44"],[8,109,"gauge44"],[5,122,"gauge44"],[6,118,"gauge44"],[7,114,"gauge44"],[8,110,"gauge44"],[5,123,"gauge44"],[6,119,"gauge44"],[7,115,"gauge44"],[8,111,"gauge44"],[6,120,"gauge44"],[7,116,"gauge44"],[8,112,"gauge44"],[6,121,"gauge44"],[7,117,"gauge44"],[8,113,"gauge44"],[6,122,"gauge44"],[7,118,"gauge44"],[8,114,"gauge44"],[6,123,"gauge44"],[7,119,"gauge44"],[8,115,"gauge44"],[7,120,"gauge44"],[8,116,"gauge44"],[7,121,"gauge44"],[8,117,"gauge44"],[7,122,"gauge44"],[8,118,"gauge44"],[7,123,"gauge44"],[8,119,"gauge44"],[8,120,"gauge44"],[8,121,"gauge44"],[8,122,"gauge44"],[8,123,"gauge44"]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-LICENSE b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-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/shared-kernel-packing/vendor/pr2857/sources/PR2843-NOTICE b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-NOTICE new file mode 100644 index 0000000000..df85dcfd9c --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-NOTICE @@ -0,0 +1 @@ +Independent algorithms: Dugongue PR2827, with retained Tekalign PR2751 geometry and Mason Hale/PR2696 literal replay lineage. PR2833 dirt-entry construction and all source notices retain their credits. Paths/pins/comparator derivative prepared with substantial OpenAI Codex assistance. See source/*NOTICE and exact DERIVATION.json. diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-ORDER.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-ORDER.json new file mode 100644 index 0000000000..b5cc1c6e73 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2843-ORDER.json @@ -0,0 +1 @@ +[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[1,0],[0,9],[1,1],[0,10],[1,2],[2,0],[0,11],[1,3],[2,1],[0,12],[1,4],[2,2],[0,13],[3,0],[1,5],[2,3],[0,14],[3,1],[1,6],[2,4],[0,15],[3,2],[1,7],[2,5],[0,16],[3,3],[1,8],[2,6],[0,17],[3,4],[1,9],[2,7],[0,18],[3,5],[1,10],[2,8],[0,19],[3,6],[1,11],[2,9],[0,20],[3,7],[1,12],[2,10],[0,21],[3,8],[1,13],[2,11],[4,0],[0,22],[3,9],[1,14],[2,12],[4,1],[0,23],[3,10],[1,15],[2,13],[4,2],[0,24],[3,11],[1,16],[2,14],[4,3],[0,25],[3,12],[5,0],[1,17],[2,15],[4,4],[0,26],[3,13],[5,1],[1,18],[2,16],[4,5],[0,27],[3,14],[5,2],[1,19],[2,17],[4,6],[0,28],[3,15],[5,3],[1,20],[2,18],[4,7],[0,29],[3,16],[5,4],[6,0],[1,21],[2,19],[4,8],[0,30],[3,17],[5,5],[6,1],[1,22],[2,20],[4,9],[0,31],[3,18],[5,6],[6,2],[1,23],[2,21],[4,10],[0,32],[3,19],[5,7],[6,3],[1,24],[2,22],[4,11],[0,33],[3,20],[5,8],[6,4],[7,0],[1,25],[2,23],[4,12],[0,34],[3,21],[5,9],[6,5],[7,1],[1,26],[2,24],[4,13],[0,35],[3,22],[5,10],[6,6],[7,2],[1,27],[2,25],[4,14],[0,36],[3,23],[5,11],[6,7],[7,3],[1,28],[2,26],[4,15],[0,37],[3,24],[5,12],[6,8],[7,4],[8,0],[1,29],[2,27],[4,16],[0,38],[3,25],[5,13],[6,9],[7,5],[8,1],[1,30],[2,28],[4,17],[0,39],[3,26],[5,14],[6,10],[7,6],[8,2],[1,31],[2,29],[4,18],[0,40],[3,27],[5,15],[6,11],[7,7],[8,3],[1,32],[2,30],[4,19],[0,41],[3,28],[5,16],[6,12],[7,8],[8,4],[1,33],[2,31],[4,20],[0,42],[3,29],[5,17],[6,13],[7,9],[8,5],[1,34],[2,32],[4,21],[0,43],[3,30],[5,18],[6,14],[7,10],[8,6],[1,35],[2,33],[4,22],[0,44],[3,31],[5,19],[6,15],[7,11],[8,7],[1,36],[2,34],[4,23],[0,45],[3,32],[5,20],[6,16],[7,12],[8,8],[1,37],[2,35],[4,24],[0,46],[3,33],[5,21],[6,17],[7,13],[8,9],[1,38],[2,36],[4,25],[0,47],[3,34],[5,22],[6,18],[7,14],[8,10],[1,39],[2,37],[4,26],[0,48],[3,35],[5,23],[6,19],[7,15],[8,11],[1,40],[2,38],[4,27],[0,49],[3,36],[5,24],[6,20],[7,16],[8,12],[1,41],[2,39],[4,28],[0,50],[3,37],[5,25],[6,21],[7,17],[8,13],[1,42],[2,40],[4,29],[0,51],[3,38],[5,26],[6,22],[7,18],[8,14],[1,43],[2,41],[4,30],[0,52],[3,39],[5,27],[6,23],[7,19],[8,15],[1,44],[2,42],[4,31],[0,53],[3,40],[5,28],[6,24],[7,20],[8,16],[1,45],[2,43],[4,32],[0,54],[3,41],[5,29],[6,25],[7,21],[8,17],[1,46],[2,44],[4,33],[0,55],[3,42],[5,30],[6,26],[7,22],[8,18],[1,47],[2,45],[4,34],[0,56],[3,43],[5,31],[6,27],[7,23],[8,19],[1,48],[2,46],[4,35],[0,57],[3,44],[5,32],[6,28],[7,24],[8,20],[1,49],[2,47],[4,36],[0,58],[3,45],[5,33],[6,29],[7,25],[8,21],[1,50],[2,48],[4,37],[0,59],[3,46],[5,34],[6,30],[7,26],[8,22],[1,51],[2,49],[4,38],[0,60],[3,47],[5,35],[6,31],[7,27],[8,23],[1,52],[2,50],[4,39],[0,61],[3,48],[5,36],[6,32],[7,28],[8,24],[1,53],[2,51],[4,40],[0,62],[3,49],[5,37],[6,33],[7,29],[8,25],[1,54],[2,52],[4,41],[0,63],[3,50],[5,38],[6,34],[7,30],[8,26],[1,55],[2,53],[4,42],[0,64],[3,51],[5,39],[6,35],[7,31],[8,27],[1,56],[2,54],[4,43],[0,65],[3,52],[5,40],[6,36],[7,32],[8,28],[1,57],[2,55],[4,44],[0,66],[3,53],[5,41],[6,37],[7,33],[8,29],[1,58],[2,56],[4,45],[0,67],[3,54],[5,42],[6,38],[7,34],[8,30],[1,59],[2,57],[4,46],[0,68],[3,55],[5,43],[6,39],[7,35],[8,31],[1,60],[2,58],[4,47],[0,69],[3,56],[5,44],[6,40],[7,36],[8,32],[1,61],[2,59],[4,48],[0,70],[3,57],[5,45],[6,41],[7,37],[8,33],[1,62],[2,60],[4,49],[0,71],[3,58],[5,46],[6,42],[7,38],[8,34],[1,63],[2,61],[4,50],[0,72],[3,59],[5,47],[6,43],[7,39],[8,35],[1,64],[2,62],[4,51],[0,73],[3,60],[5,48],[6,44],[7,40],[8,36],[1,65],[2,63],[4,52],[0,74],[3,61],[5,49],[6,45],[7,41],[8,37],[1,66],[2,64],[4,53],[0,75],[3,62],[5,50],[6,46],[7,42],[8,38],[1,67],[2,65],[4,54],[0,76],[3,63],[5,51],[6,47],[7,43],[8,39],[1,68],[2,66],[4,55],[0,77],[3,64],[5,52],[6,48],[7,44],[8,40],[1,69],[2,67],[4,56],[0,78],[3,65],[5,53],[6,49],[7,45],[8,41],[1,70],[2,68],[4,57],[0,79],[3,66],[5,54],[6,50],[7,46],[8,42],[1,71],[2,69],[4,58],[0,80],[3,67],[5,55],[6,51],[7,47],[8,43],[1,72],[2,70],[4,59],[0,81],[3,68],[5,56],[6,52],[7,48],[8,44],[1,73],[2,71],[4,60],[0,82],[3,69],[5,57],[6,53],[7,49],[8,45],[1,74],[2,72],[4,61],[0,83],[3,70],[5,58],[6,54],[7,50],[8,46],[1,75],[2,73],[4,62],[0,84],[3,71],[5,59],[6,55],[7,51],[8,47],[1,76],[2,74],[4,63],[0,85],[3,72],[5,60],[6,56],[7,52],[8,48],[1,77],[2,75],[4,64],[0,86],[3,73],[5,61],[6,57],[7,53],[8,49],[1,78],[2,76],[4,65],[0,87],[3,74],[5,62],[6,58],[7,54],[8,50],[1,79],[2,77],[4,66],[0,88],[3,75],[5,63],[6,59],[7,55],[8,51],[1,80],[2,78],[4,67],[0,89],[3,76],[5,64],[6,60],[7,56],[8,52],[1,81],[2,79],[4,68],[0,90],[3,77],[5,65],[6,61],[7,57],[8,53],[1,82],[2,80],[4,69],[0,91],[3,78],[5,66],[6,62],[7,58],[8,54],[1,83],[2,81],[4,70],[0,92],[3,79],[5,67],[6,63],[7,59],[8,55],[1,84],[2,82],[4,71],[0,93],[3,80],[5,68],[6,64],[7,60],[8,56],[1,85],[2,83],[4,72],[0,94],[3,81],[5,69],[6,65],[7,61],[8,57],[1,86],[2,84],[4,73],[0,95],[3,82],[5,70],[6,66],[7,62],[8,58],[1,87],[2,85],[4,74],[0,96],[3,83],[5,71],[6,67],[7,63],[8,59],[1,88],[2,86],[4,75],[0,97],[3,84],[5,72],[6,68],[7,64],[8,60],[1,89],[2,87],[4,76],[0,98],[3,85],[5,73],[6,69],[7,65],[8,61],[1,90],[2,88],[4,77],[0,99],[3,86],[5,74],[6,70],[7,66],[8,62],[1,91],[2,89],[4,78],[0,100],[3,87],[5,75],[6,71],[7,67],[8,63],[1,92],[2,90],[4,79],[0,101],[3,88],[5,76],[6,72],[7,68],[8,64],[1,93],[2,91],[4,80],[0,102],[3,89],[5,77],[6,73],[7,69],[8,65],[1,94],[2,92],[4,81],[0,103],[3,90],[5,78],[6,74],[7,70],[8,66],[1,95],[2,93],[4,82],[0,104],[3,91],[5,79],[6,75],[7,71],[8,67],[1,96],[2,94],[4,83],[0,105],[3,92],[5,80],[6,76],[7,72],[8,68],[1,97],[2,95],[4,84],[0,106],[3,93],[5,81],[6,77],[7,73],[8,69],[1,98],[2,96],[4,85],[0,107],[3,94],[5,82],[6,78],[7,74],[8,70],[1,99],[2,97],[4,86],[0,108],[3,95],[5,83],[6,79],[7,75],[8,71],[1,100],[2,98],[4,87],[0,109],[3,96],[5,84],[6,80],[7,76],[8,72],[1,101],[2,99],[4,88],[0,110],[3,97],[5,85],[6,81],[7,77],[8,73],[1,102],[2,100],[4,89],[0,111],[3,98],[5,86],[6,82],[7,78],[8,74],[1,103],[2,101],[4,90],[0,112],[3,99],[5,87],[6,83],[7,79],[8,75],[1,104],[2,102],[4,91],[0,113],[3,100],[5,88],[6,84],[7,80],[8,76],[1,105],[2,103],[4,92],[0,114],[3,101],[5,89],[6,85],[7,81],[8,77],[1,106],[2,104],[4,93],[0,115],[3,102],[5,90],[6,86],[7,82],[8,78],[1,107],[2,105],[4,94],[0,116],[3,103],[5,91],[6,87],[7,83],[8,79],[1,108],[2,106],[4,95],[0,117],[3,104],[5,92],[6,88],[7,84],[8,80],[1,109],[2,107],[4,96],[0,118],[3,105],[5,93],[6,89],[7,85],[8,81],[1,110],[2,108],[4,97],[0,119],[3,106],[5,94],[6,90],[7,86],[8,82],[1,111],[2,109],[4,98],[0,120],[3,107],[5,95],[6,91],[7,87],[8,83],[1,112],[2,110],[4,99],[0,121],[3,108],[5,96],[6,92],[7,88],[8,84],[1,113],[2,111],[4,100],[0,122],[3,109],[5,97],[6,93],[7,89],[8,85],[1,114],[2,112],[4,101],[0,123],[3,110],[5,98],[6,94],[7,90],[8,86],[1,115],[2,113],[4,102],[3,111],[5,99],[6,95],[7,91],[8,87],[1,116],[2,114],[4,103],[3,112],[5,100],[6,96],[7,92],[8,88],[1,117],[2,115],[4,104],[3,113],[5,101],[6,97],[7,93],[8,89],[1,118],[2,116],[4,105],[3,114],[5,102],[6,98],[7,94],[8,90],[1,119],[2,117],[4,106],[3,115],[5,103],[6,99],[7,95],[8,91],[1,120],[2,118],[4,107],[3,116],[5,104],[6,100],[7,96],[8,92],[1,121],[2,119],[4,108],[3,117],[5,105],[6,101],[7,97],[8,93],[1,122],[2,120],[4,109],[3,118],[5,106],[6,102],[7,98],[8,94],[1,123],[2,121],[4,110],[3,119],[5,107],[6,103],[7,99],[8,95],[2,122],[4,111],[3,120],[5,108],[6,104],[7,100],[8,96],[2,123],[4,112],[3,121],[5,109],[6,105],[7,101],[8,97],[4,113],[3,122],[5,110],[6,106],[7,102],[8,98],[4,114],[3,123],[5,111],[6,107],[7,103],[8,99],[4,115],[5,112],[6,108],[7,104],[8,100],[4,116],[5,113],[6,109],[7,105],[8,101],[4,117],[5,114],[6,110],[7,106],[8,102],[4,118],[5,115],[6,111],[7,107],[8,103],[4,119],[5,116],[6,112],[7,108],[8,104],[4,120],[5,117],[6,113],[7,109],[8,105],[4,121],[5,118],[6,114],[7,110],[8,106],[4,122],[5,119],[6,115],[7,111],[8,107],[4,123],[5,120],[6,116],[7,112],[8,108],[5,121],[6,117],[7,113],[8,109],[5,122],[6,118],[7,114],[8,110],[5,123],[6,119],[7,115],[8,111],[6,120],[7,116],[8,112],[6,121],[7,117],[8,113],[6,122],[7,118],[8,114],[6,123],[7,119],[8,115],[7,120],[8,116],[7,121],[8,117],[7,122],[8,118],[7,123],[8,119],[8,120],[8,121],[8,122],[8,123]] \ No newline at end of file diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2848-CLAIM.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2848-CLAIM.json new file mode 100644 index 0000000000..16125d43c4 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2848-CLAIM.json @@ -0,0 +1,39 @@ +{ + "admission_result_sha256": "51b0e334b2f54b31739dcc8d1d7a0edb387abbac7c77296053591843893db17b", + "calls": 2232, + "comparison": { + "claim_sha256": "0adc0edfade0260c65e79867b6c8b96f58dfe29d38aa30cfb8f3d5e9c7e828d9", + "gain": "230463210106193/1000000000000000000000000", + "head": "47a7227c044cd0cabb1432a06c61dd5d60c07f5a", + "kappa": "17186582778417198986259999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "pr": 2843 + }, + "complex_lower": "1718658508304930004819/1000000000000000000000000", + "complex_upper": "85932925415246500241/50000000000000000000000", + "generated_admitted_package_manifest_sha256": "ea630c95e589a319f4c4a76b655dda5741dae67ef3d369ea95d406e92c4a0e4b", + "headline_formula": "complex_lower - 1/10^46 - 1/10^70", + "kappa": "17186585083049300048189999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017186585083049300048189999999999999999999998999999999999999999999999", + "live": 222208, + "native_receipt_sha256": "a56d2fe28812e93c5526564ef77f7e5e8d1cbb111efeb6c3b0f53c9ec01ca2bc", + "paid_profile": { + "1": 5374656, + "16": 1, + "2": 1450801, + "3": 615586, + "4": 285696, + "48": 89230, + "5": 90024, + "8": 17856 + }, + "physical": 222698, + "rank_mass": 16141824, + "release_receipt_sha256": "4e7929813abdd0e99ffaffde5e7bac03236560ff65ed9b4a25e3dc4e1bdc2ffc", + "replicas": 248, + "roles": 910656, + "schema_version": 1, + "scope": "Conditional finite supplier and full modern outer release. Inherited all-size compiler, source-access, hosting, precision/tape, recovery, ordinary recursion, BIT and analytic hypotheses remain. No fresh Lean kernel audit or selected-frontier change.", + "source_head": "e9307b48d7d1b690939935ecef0f8e524e6d92f4", + "source_manifest_sha256": "c8ec4d1b7be08d2ad30730a07392ad9cb6d0222f2c35bef43c9a80a39b16e41f", + "status": "PASS_CONDITIONAL_FINITE_T248_RELEASE" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/sources/PR2853-OUTER-CLAIM.json b/research/shared-kernel-packing/vendor/pr2857/sources/PR2853-OUTER-CLAIM.json new file mode 100644 index 0000000000..afaeb2cc19 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/sources/PR2853-OUTER-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017193776586975866590473384172607721814008956451425009430412460057503404071040423905924370921614016936349599996575798051733752076399828661071424528133116204108665576478204661464919617598343585484524702974017289809640608310940007596504547313171417642290767559750850327036443763958949276701315614084182582550782294614926854166678633518165095574636737913611722939423541165512669948579876694862940820794322681604047035649250603372674813493877135736770522694109132099158577487850859689383618416103013619426863008011594203958829773923918309467835785404794536680317802530438714723754082219296741326678063354545691266197656204485046940007194603764227886842657612702577257578902524058571682295826925682659917730305714815492526014996524819730258810160527078502095826534892562388431748401788169450709875893003253797487136842479124101169429105650760396697579174626680372202297456465619874841336521809586652402780111990386170172268373381842093293788010598379355684853890605248212741574284011514597757649218351744131074209720903563888742546518188979893906923159239618928523556755972597200527787486209886115453356488096913360689147838372739437326267972125792191920918825536672424513817139955549084830633129444135653843199862948309240531966991187940149380228286528014102762776155575447803552367005005534517354452699818957501259721372120542828957754277842675408852526958902205491479144856936386554518686702861962651880585424919584495474934784892039256289208222943383941527092570568397219339705279712429705426951822294004077902292782618818113902694452450291459939846428719161657151417208049935288685647694598005341935498511152918946247839959268670317549572412477693151973835249041678167828816827686753069808718673844160892815836102376757675036671018117066778433539739956663244138849798929700922384646175178750362230036206095408201215314251989510461803596671705632898242900785593975006517640755013867661549498301431681610793069670853314385776720226983596686726441370877445087824720595253572015639265264941101671404840359960081380843733908048006019122154575405156576095586845977194320757564357586250358409962743428564662035542609645007957479195198614633133624526616981357915749249122668331971690422289899472621447353255713838757067555955951769384517017145131540398127612264007701902090486661652880678411039240152421254959123182586150102956220415049232456104551435853722705332378116189133196894624473164964161901278464988044812290830287125207271322696356586817309654257541649542793451050763742999612659361815742594876874365619721197108394736060040665311340944580538964981258346873524367079294647209815778430967907073900857586430360872971473933612881754758496436326352000702257338896725815583758704393752256248604713672679221076879476083069636687621530504181022342124580618983319715908394692370795173629167220944795079202047435677777747836298580119166304268329679299693147333849102451075930795429135156954198334432354022675041138889869128019798693289176932374813976966998045997730255650851999384815082333308542575305739689999999999999999999998999999999999999999999999", + "kappa_rational": "17193776586975866590473384172607721814008956451425009430412460057503404071040423905924370921614016936349599996575798051733752076399828661071424528133116204108665576478204661464919617598343585484524702974017289809640608310940007596504547313171417642290767559750850327036443763958949276701315614084182582550782294614926854166678633518165095574636737913611722939423541165512669948579876694862940820794322681604047035649250603372674813493877135736770522694109132099158577487850859689383618416103013619426863008011594203958829773923918309467835785404794536680317802530438714723754082219296741326678063354545691266197656204485046940007194603764227886842657612702577257578902524058571682295826925682659917730305714815492526014996524819730258810160527078502095826534892562388431748401788169450709875893003253797487136842479124101169429105650760396697579174626680372202297456465619874841336521809586652402780111990386170172268373381842093293788010598379355684853890605248212741574284011514597757649218351744131074209720903563888742546518188979893906923159239618928523556755972597200527787486209886115453356488096913360689147838372739437326267972125792191920918825536672424513817139955549084830633129444135653843199862948309240531966991187940149380228286528014102762776155575447803552367005005534517354452699818957501259721372120542828957754277842675408852526958902205491479144856936386554518686702861962651880585424919584495474934784892039256289208222943383941527092570568397219339705279712429705426951822294004077902292782618818113902694452450291459939846428719161657151417208049935288685647694598005341935498511152918946247839959268670317549572412477693151973835249041678167828816827686753069808718673844160892815836102376757675036671018117066778433539739956663244138849798929700922384646175178750362230036206095408201215314251989510461803596671705632898242900785593975006517640755013867661549498301431681610793069670853314385776720226983596686726441370877445087824720595253572015639265264941101671404840359960081380843733908048006019122154575405156576095586845977194320757564357586250358409962743428564662035542609645007957479195198614633133624526616981357915749249122668331971690422289899472621447353255713838757067555955951769384517017145131540398127612264007701902090486661652880678411039240152421254959123182586150102956220415049232456104551435853722705332378116189133196894624473164964161901278464988044812290830287125207271322696356586817309654257541649542793451050763742999612659361815742594876874365619721197108394736060040665311340944580538964981258346873524367079294647209815778430967907073900857586430360872971473933612881754758496436326352000702257338896725815583758704393752256248604713672679221076879476083069636687621530504181022342124580618983319715908394692370795173629167220944795079202047435677777747836298580119166304268329679299693147333849102451075930795429135156954198334432354022675041138889869128019798693289176932374813976966998045997730255650851999384815082333308542575305739689999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "branch": "fine source-prime padding (PR1786, chafreaky; Trudgian's prime theorem; vendor/pr1786) with the gauge-free interiors (PR1758), the radix-distributed union schedule with per-visit tag work and the explicit Strassen boundary (tau=45/16); epsilon=1-1.0009765625e-3080 is a free parameter (outer/FINE-PADDING-COMPOSITION.md): kappa = C - 1/F - B, the fixed-grid maximum (epsilon q is 1.70e-3083 below q); the structured boundary of the previous package is not used; omega_C<=9/4 not used; recertified endpoint: the supplier native endpoint is certified to 1e-3000 (accept at the endpoint, reject at endpoint + 1e-3000, repaired fine engines in integer fixed point), and all free slacks are 1e-3080 or below", + "b": "certified complex_lower - 1e-3080 (see outer/B.json)", + "outer": "PR1673 capped phase-cell fusion (Vlado Vojdanovski)", + "supplier": "PR2833 construction (PR2802 base; dirt-entry rewrite of helpers 530/542) plus the dirt-entry rewrite of helpers 460, 462, 478, 480 (this package); PR1661 T74 pivot-566 stack with PR2226 anticipatory dirty borrowing, the PR2312 width exchange, frame refit and kernels, the PR2322 handoffs, the PR2435/PR2447 entrance raise, the PR2436 lifted-target aliases, and the PR2530 (zxv) eight source-partner aliases with an owner fill evacuated by the PR2559 (philippeVV) method; this package: six pre-life hostings (cold hosts 273, 275, 289, 291, 305, 321 host helpers 482, 483, 494, 495, 507, 519), a one-gate frame refit with the retired-lender alias 653<-563, and a new exact owner fill", + "retuned_slacks": "b = certified complex endpoint - 1e-3080, q = b - 1e-3080, r0=1e-3080, zeta=1e-3082, layout slack=1e-3080, stop=1e-3086, epsilon = 1 - (1025/1024)e-3080, floor grid 1e-3046, backoff 1e-3022; kappa = C - 1/F - B is the fixed-grid maximum (outer/RETUNED-SLACKS.md, outer/PROOF-GRID-MAX.md)", + "fixed_grid_maximum": "kappa = C - 1/F - B exactly (F = 1e3046, B = 1e-3022, C the certified complex endpoint); PR2180 / PR2161 (dataisfire) point re-derived at this endpoint; main-binding guard gaussian_above_main is the 63rd strict row" +} diff --git a/research/shared-kernel-packing/vendor/pr2857/vendor/ceiling.py b/research/shared-kernel-packing/vendor/pr2857/vendor/ceiling.py new file mode 100644 index 0000000000..6c0f54527d --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/ceiling.py @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Packing-independent ceiling for a complex local word under the hosted nine-stage coverage law. + +Model (all inputs explicit): + * per replica the template has `families` live data families and `stages` invocations, so + w = families / stages live families per call; on the selected T37/T16 line all helpers are + hosted on data families, so w = 2 * pairs * V / stages is fixed by the port count V; + * coverage identity (PR1012, re-checked here on the selected profile): paid rank mass equals + (m - 1) * W + centre * N, i.e. every live family keeps exactly one unpaid coordinate and every + call pays its centre path (`unpaid` > 1 is a what-if for a changed coverage law only); + * the local word fixes its own paid child profile `local` (per call); + * every remaining unit of mass is an idle/remainder child of rank at most R, where the outer + recipe's halving guard m^2 > 2 R^2 bounds R (R = 51 for m = 73). + +Lemma. For a >= 0, a child of rank r costs (r/m)^(1-a) = r * c(r), with c(r) = r^(-a) m^(a-1) +non-increasing in r. Hence, with idle mass M fixed and idle ranks <= R, every idle histogram has +moment >= the relaxation that puts all of M into (possibly fractional) rank-R children: + + relax(a) = [ sum_local n_r (r/m)^(1-a) + (M/R) (R/m)^(1-a) ] / w (per call). + +The moment is increasing in a. So relax(a*) > 1 certifies that no hosting, owner packing or +idle-remainder change of the given local word, template and outer recipe certifies a saving +>= a*. Under the retained reduction kappa < a/(1+a) when the complex side binds, so +a*/(1+a*) also bounds kappa. This is a bound for the stated model, not for other local words, +templates, coverage laws or outer recipes. + +Exact rational intervals: ln k from atanh chains, exp by Taylor with Lagrange remainder, +outward rounding to 2^-PREC. Standard library only. Douglas Colkitt, with Claude (Anthropic) +assistance. +""" +from fractions import Fraction as Q +from functools import lru_cache +from math import isqrt + +PREC = 256 + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def down(x): + return Q((x.numerator << PREC) // x.denominator, 1 << PREC) + + +def up(x): + return -down(-x) + + +@lru_cache(None) +def atanh(t): + """Enclosure of atanh(t) for rational 0 < t <= 1/3.""" + require(0 < t <= Q(1, 3), 'atanh range') + s, p, k = Q(0), t, 0 + while True: + term = p / (2 * k + 1) + s += term + p *= t * t + k += 1 + tail = p / ((2 * k + 1) * (1 - t * t)) + if tail < Q(1, 1 << (PREC + 8)): + return down(s), up(s + tail) + + +@lru_cache(None) +def ln(k): + """Enclosure of ln k for an integer k >= 1: ln k = ln(k-1) + 2 atanh(1/(2k-1)).""" + require(isinstance(k, int) and k >= 1, 'ln domain') + if k == 1: + return Q(0), Q(0) + lo, hi = ln(k - 1) + a, b = atanh(Q(1, 2 * k - 1)) + return down(lo + 2 * a), up(hi + 2 * b) + + +def exp(lo, hi): + """Enclosure of exp([lo, hi]) for 0 <= lo <= hi <= 1/2.""" + require(0 <= lo <= hi <= Q(1, 2), 'exp range') + def series(y, upper): + s, t, k = Q(1), Q(1), 0 + while True: + k += 1 + t = t * y / k + s += t + if t * y < Q(1, 1 << (PREC + 8)): + return up(s + 2 * t * y / (k + 1)) if upper else down(s) + return series(lo, False), series(hi, True) + + +def child_cost(r, m, a): + """Enclosure of (r/m)^(1-a) = (r/m) exp(a ln(m/r)).""" + lm, um = ln(m) + lr, ur = ln(r) + e = exp(max(Q(0), a * (lm - ur)), a * (um - lr)) + return down(Q(r, m) * e[0]), up(Q(r, m) * e[1]) + + +def max_idle_rank(m): + """Largest R with m^2 > 2 R^2 (outer halving guard).""" + R = isqrt((m * m - 1) // 2) + while 2 * (R + 1) ** 2 < m * m: + R += 1 + while 2 * R * R >= m * m: + R -= 1 + return R + + +def model(local, m, families, stages, centre, R=None, unpaid=1): + """Per-call quantities. local: {rank: count per call (Fraction ok)}.""" + R = max_idle_rank(m) if R is None else R + require(2 * R * R < m * m, 'idle rank cap violates the halving guard') + require(all(0 < r < m for r in local) and all(n >= 0 for n in local.values()), 'local profile') + w = Q(families, stages) + require(1 <= unpaid < m, 'unpaid coordinates per family') + total = (m - unpaid) * w + centre + local_mass = sum(r * Q(n) for r, n in local.items()) + idle = total - local_mass + require(idle >= 0, 'local word pays more mass than the coverage law allows') + return dict(R=R, w=w, total_mass=total, local_mass=local_mass, idle_mass=idle, deficit=unpaid * w - centre) + + +def relax(local, m, families, stages, centre, a, R=None, unpaid=1): + """Enclosure of the per-call relaxation moment at saving a.""" + q = model(local, m, families, stages, centre, R, unpaid) + lo = hi = Q(0) + for r, n in local.items(): + c = child_cost(r, m, a) + lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1] + c = child_cost(q['R'], m, a) + k = q['idle_mass'] / q['R'] + lo, hi = lo + k * c[0], hi + k * c[1] + return down(lo / q['w']), up(hi / q['w']) + + +def ceiling(local, m, families, stages, centre, grid=Q(1, 10 ** 15), R=None, unpaid=1): + """Grid bracket [a_lo, a_hi]: relax(a_lo) < 1 < relax(a_hi), certified. a_hi is the ceiling.""" + lo, hi = Q(0), Q(1, 20) + require(relax(local, m, families, stages, centre, hi, R, unpaid)[0] > 1, 'search window too small') + require(relax(local, m, families, stages, centre, lo, R, unpaid)[1] < 1, 'relaxation has no positive saving') + while hi - lo > grid: + mid = Q(int((lo + hi) / 2 / grid)) * grid + if mid <= lo: + mid = lo + grid + v = relax(local, m, families, stages, centre, mid, R, unpaid) + if v[1] < 1: + lo = mid + elif v[0] > 1: + hi = mid + else: + raise ValueError('enclosure too wide to separate the grid point') + return lo, hi diff --git a/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/CREDITS.md b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/CREDITS.md new file mode 100644 index 0000000000..f9775c75c6 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/CREDITS.md @@ -0,0 +1,67 @@ +# Attribution and overlap + +This derivative retains PR2802's actual native words and uses a new source-bound +application of elementary owner-block norm accounting to the precision invoice. +The T114 gain has a new checked literal owner allocation and complete +admission. It does not claim a new general tensor-isomorphism identity, a first +TI application to multiplication, or an improvement from covariance alone. + +## Direct native and allocation ancestry + +Marius-Paul Dumitrean's [PR2802](https://github.com/CrocSwap/integer-mult-bounds/pull/2802), +head `17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd`, supplies the retained retired7 +native words, frame refits and restoration; its NOTICE records substantial +Anthropic Claude/Claude Code assistance. Tekalign's PR2751 supplies joint +twelve-source recovery. PR2766 and PR2733 contribute frame-route/refit work; +Philippe Van Velzen's PR2679 contributes pre-life hosting and retired-lender +aliases; Mason Hale's PR2696 contributes the assignment; zxv's PR2530 supplies +source-partner loans; Jeremy Kothe's PR2588 supplies helper-label exchange; +Cinna Davis's PR2226 supplies anticipatory dirty borrowing. Their exact notices +and licenses remain authoritative. + +[PR2824](https://github.com/CrocSwap/integer-mult-bounds/pull/2824), by Dugongue, +is the preceding checked T94 tail-dilution construction. The succeeding admitted +T104 allocation and its authenticated native receipts are direct predecessors. +The native words and paid local mechanism are inherited; replica dilution does +not earn credit for a new word construction. Existing Rohan Arun and selected +icekylinx/source-frame/compiler lineage remains credited by retained notices. + +## Earlier tensor, gauge and response mechanisms + +| Source | Author | Relevant earlier contribution | +|---|---|---| +| [PR471](https://github.com/CrocSwap/integer-mult-bounds/pull/471) | Dugongue | Full-nine-axis two-sided monomial normalization, arbitrary dirty endpoints and restored same-owner spectators. | +| [PR476](https://github.com/CrocSwap/integer-mult-bounds/pull/476), [PR478](https://github.com/CrocSwap/integer-mult-bounds/pull/478) | Dugongue | Target transvections and interval correction/recovery, including overlapping factors. | +| [PR483](https://github.com/CrocSwap/integer-mult-bounds/pull/483) | Dugongue | Simultaneous response-packet cancellation and nested donor flags. | +| [PR492](https://github.com/CrocSwap/integer-mult-bounds/pull/492) | Dugongue | Equal nonzero-response relocation and stage-conditioned providers. | +| [PR498](https://github.com/CrocSwap/integer-mult-bounds/pull/498) | Dugongue | Rational-span intersections and paired rational whole-owner routing. | +| [PR508](https://github.com/CrocSwap/integer-mult-bounds/pull/508) | Dugongue | Joint gauge collapse; shared maxima require a complete reconstructed invoice. | +| [PR537](https://github.com/CrocSwap/integer-mult-bounds/pull/537) | Dugongue | Higher-dimensional response spaces, rank32 saturation, observational rewriting and contextual registry gluing. | +| [PR556](https://github.com/CrocSwap/integer-mult-bounds/pull/556) | Dugongue | Exact directed-cut frame optimization and eight costed structural transfers. | +| [PR563](https://github.com/CrocSwap/integer-mult-bounds/pull/563) | Dugongue | Contextual provider selection, partial-group penalties and finite pooling. | +| [PR2742](https://github.com/CrocSwap/integer-mult-bounds/pull/2742) | Jose Manuel (`jmbarrancoml`) | Actual native dirty-reader covariance, dyadic helper chart and phase-correct monomials; eight rank-eight descents remain. | + +PR2742 records substantial OpenAI Codex assistance and credits ywz65/PR2491 for +the full dirty reader, signed data permutation and framed interpretation; Ross +Richardson/PR2500 for the dyadic chart and typed cost audit; Cinna Davis/PR1391 +and PR1410 for order-four echo; Aaron Wang (`navinor`)/PR2595 for phase windows; +and Ali Romman/PR1719 for the Gaussian-dyadic compiler/interpreter. An unsigned +ERASE transport rule does not apply automatically to its mixed helper chart. + +PR2341 (bitplane), PR2378 (AAAmirinu) and PR2422 (bitplane) provide earlier +conditional whole-array tensor/monomial semantics. Their retained credits include +Jose Manuel, Gareth Davidson, AAAmirinu, DreamingOfClouds and Lemma G contributors, +plus Mathlib. These interfaces do not by themselves discharge the full physical +compiler. Relevant older R715 lineage also includes DreamingOfClouds/PR463, +Rohan Arun/PR467/470 and chafreaky/PR458/472/502. + +## This review's scope + +The current-source endpoint/block audit, finite allocations, directed arithmetic +and new Mathlib energy lemmas are distinct from inherited native evidence. +Authenticated reuse must be described explicitly. Current reader symmetries and +failed bounded gauge searches are research evidence, not additional kappa gains. +The finite-group and direct-sum mathematics is classical; no global novelty +claim is made. [FRONTIER.md](FRONTIER.md) records the bounded source coverage and +missing historical records. Exact source hashes and original notices take +precedence over summaries or mutable PR titles. diff --git a/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/LICENSE b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/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/shared-kernel-packing/vendor/pr2857/vendor/pr2839/blocknorm_certificate.py b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/blocknorm_certificate.py new file mode 100644 index 0000000000..b8656727d3 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/blocknorm_certificate.py @@ -0,0 +1,268 @@ +"""Physical-owner boundary certificate; retains the completed native phase audit. + +certify(hosted, local_dirs) is a finite premise checker for the separate universal +block-energy lemma. It does not replace frame/phase/primitive or release checks. +""" +import gzip, hashlib, json +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + + +def require(ok, message): + if not ok: + raise AssertionError('blocknorm: ' + message) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def read(path): + path = Path(path) + raw = gzip.decompress(path.read_bytes()) if path.suffix == '.gz' else path.read_bytes() + return json.loads(raw) + + +def replay_endpoint(events, v, helpers, back): + """Exact rows in the free warp algebra, plus private first-write discipline. + + Frame transports/centre children retain the separately audited native + coordinate interfaces. A warp prefixes a formal invertible operator; only + adjacent inverse pairs cancel. Thus no numerical sampling is used. + """ + n = 2*v + helpers + rows = {('L', i): {(i, ()): Q(1)} for i in range(n)} + live_z, allocated, freed, cleared_c = set(), set(), set(), Counter() + tags = {'phase', 'scalar', 'warp', 'center', 'climb', 'adapter', 'residual_adapter', 'zero_buffer'} + for index, event in enumerate(events): + tag = event[0] + require(tag in tags, 'unknown native event') + if tag == 'zero_buffer': + _, action, z = event + r = ('Z', z) + if action == 'alloc': + require(z not in allocated and r not in rows, 'zero buffer duplicate allocation') + allocated.add(z); live_z.add(z); rows[r] = {} + else: + require(action == 'free' and z in live_z and not rows[r], 'zero buffer release nonzero/unallocated') + live_z.remove(z); freed.add(z) + elif tag == 'scalar': + e = event[1]; op = e[0]; target = tuple(e[1]) + require(op in ('clear','copy','scale','add'), 'unknown scalar') + source = tuple(e[2]) if op in ('copy','add') else None + for r in [target] + ([source] if source else []): + require(r[0] in ('L','C','Z'), 'unknown register class') + if r[0] == 'L': require(0 <= r[1] < n, 'live role range') + if r[0] == 'C': require(0 <= r[1] < 8, 'centre role range') + if r[0] == 'Z': require(r[1] in live_z, 'zero buffer read/write before alloc or after free') + if op == 'clear': + rows[target] = {} + if target[0] == 'C': cleared_c[target[1]] += 1 + elif op == 'copy': + require(source in rows, 'source read before initialization') + # First private write must be an explicit clear, even if copy overwrites. + require(target in rows, 'private copy before first clear') + rows[target] = dict(rows[source]) + elif op == 'scale': + require(target in rows, 'scale before first clear') + q = Q(e[2], e[3]); rows[target] = {j:q*x for j,x in rows[target].items() if q*x} + else: + require(target in rows and source in rows, 'add read before first clear') + q = Q(e[3],e[4]); dest=rows[target] + require(target != source, 'aliased scalar add') + for j,x in rows[source].items(): + y=dest.get(j,Q(0))+q*x + if y: dest[j]=y + else: dest.pop(j,None) + elif tag == 'warp': + r, op = tuple(event[1]), event[2] + require(r in rows and (r[0] != 'Z' or r[1] in live_z), 'warp before initialization') + require(isinstance(op,int) and op != 0, 'invalid formal warp') + rows[r] = {(i, word[1:] if word and word[0] == -op else (op,)+word): x + for (i,word),x in rows[r].items()} + elif tag == 'center': + require(('C',event[1]) in rows, 'centre child before first clear') + require(not live_z and allocated == freed and len(allocated)==72, 'all72 private zero buffers released') + require(set(cleared_c)==set(range(8)) and all(cleared_c[k]==2 for k in range(8)), 'each centre first and terminal clear') + require(all(not row for r,row in rows.items() if r[0] in ('C','Z')), 'private work nonzero at boundary') + for i in range(n): + want={(i,()):Q(1)} + if back and i0 and live%896==0, 'live896T') + T=live//896 + stock_bits, stock_l2_bits=full_stock_l2(physical) + require(physical==live+8+408+72+2 and physical <= 2**20, 'physical stock bound') + ns=d['private_namespace'] + require(ns=={'centers':[live,live+8], 'reserved_tableau':[live+8,live+416], + 'zero_buffers':[live+416,live+488], 'coefficient':[live+488,live+490]}, 'private namespaces') + registry=d['local_providers']; require(set(local_dirs)==set(registry), 'complete provider directory map') + endpoint, localbits = certify_providers(registry, local_dirs) + require(localbits<=128, 'local prefix128 reserve') + calls=d['calls']; require(len(calls)==9*T, '9T calls') + bycall={}; stages=[Counter() for _ in range(T)]; foreign=0 + pairs=[0,0,0,1,1,2,2,3,3]; backwards={1,3,5,7} + for call in calls: + r,s=call['replica'],call['stage']; pid=call['provider_id'] + require(isinstance(r,int) and 0<=r=0, 'family-local helper route') + if route[0]==3: require(width==9 and len(route)==3, 'full-width helper route') + else: require(len(route)==5 and route[3]==width and len(route[4])==9-width and len(set(route[4]))==9-width and all(0<=x<9 for x in route[4]), 'residual spectator permutation') + foreign += (f//896 != r) + require(call['time'] not in bycall, 'serialized call times'); bycall[call['time']]=call + stages[r][s]+=1 + require(all(c==Counter(range(9)) for c in stages), 'every replica9 calls exactly') + kinds={'local_cover_sweep','idle_cover_sweep','bridge','terminal','terminal_Y_translations','bank_padding_cover_sweep','translate_every_live_family'} + seq=[[] for _ in range(T)]; active=[0]*T; bridges=[0]*T; globals_seen=[] + for event in d['execution_schedule']: + kind=event['kind']; require(kind in kinds, 'known schedule event') + if kind in ('bank_padding_cover_sweep','translate_every_live_family'): + globals_seen.append(kind); require(event['families']==([live,live] if kind=='bank_padding_cover_sweep' else [0,live]), 'family-local global sweep') + continue + r=event['replica']; require(0<=r=224] + need(widths==providers[pid]['widths']and len(widths)==408,'actual ordered provider frame widths');need(len(word['centers'])==8,'eight centres');providers[pid]['actual_paid_profile']={int(k):v for k,v in report['profile'].items()} + return read(PROVIDER/'inputs/PLAN.json.gz'),read(PROVIDER/'inputs/GLOBAL-TEMPLATE.json.gz'),providers,hashes + +def windows(template,order,T): + ranks={c['child']:c['rank']for c in template['idle_children']};pairs={e['stage']:e['pair']for e in template['recipe']if e['kind']=='local'} + blocks={};stage=None + for event in template['execution_schedule']: + if event['kind']in('bank_padding_cover_sweep','translate_every_live_family'):continue + if event['kind']=='local_cover_sweep':stage=event['stage'];blocks[stage]=[] + need(stage is not None,'source event before local call');blocks[stage].append(event) + need(set(blocks)==set(range(9)),'nine source stages') + progress=[0]*T;last={};result={} + for t,(stage,replica)in enumerate(order): + need(0<=replica0,'idle source position');start=last.get((replica,event['pair']),-1) + for child in event['child_indices']: + if child in ranks:result[replica,child]=(ranks[child],start,t) + elif kind in ('terminal_Y_translations','terminal'):pass # inherited terminal phase; no pending-window endpoints + else:raise ValueError('unknown source event kind') + need(progress==[9]*T,'complete replica source progression');return result + +def check(T,order,fill,dispatch,claimed,plan,template,providers): + need(type(T)is int and T>0,'positive T');N=9*T + need(len(order)==N and set(map(tuple,order))=={(s,r)for s in range(9)for r in range(T)},'complete T call coverage') + win=windows(template,order,T) + need(set(dispatch)==set(map(tuple,order))and all(p in providers for p in dispatch.values()),'provider dispatch coverage') + for s,r,pid in fill.get('dispatch_overrides',[]):need(dispatch.get((s,r))==pid,'final dispatch override binding') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'literal role columns') + need(len(fill['rows'])==N*408,'complete role count');helpers=[0]*N;families=[0]*N;occupied={};lastrow={} + for idx,row in enumerate(fill['rows']): + need(len(row)==6 and all(type(x)is int for x in row),'integer role shape');t,h,o,c,p,z=row + need(0<=tlastrow[key][0]:lastrow[key]=(z,idx,w) + need(helpers==[(1<<408)-1]*N,'all helper identities');idle=Counter() + for(o,c),(cap,_,_)in win.items(): + for p in range(112): + key=(o,c,p);mask=occupied.get(key,0);used=mask.bit_count();need(mask==(1<0,'positive T');P.require(len(order)==9*T,'complete new invocation count') + parent=P.build(T);geometry=P.check(parent,parent['replica_lift']['groups']) + sp=importlib.util.spec_from_file_location('retained_physical_source_windows',base/'vendor/build_parent.py');mod=importlib.util.module_from_spec(sp);sp.loader.exec_module(mod) + windows,schedule=mod.actual_windows(parent,order) + independent=P.expand_schedule(parent,order);P.require(schedule==independent,'independent literal source-event expansion') + dispatch={(s,r):pid for s,r,pid in dispatch_rows} + P.require(len(dispatch_rows)==len(order) and set(dispatch)==set(map(tuple,order)),'dispatch bijection') + P.require(set(dispatch.values())<=set(providers),'known provider') + for pid,d in providers.items(): + P.require(pid in plan['provider_registry'],'provider in retained registry') + plan['provider_registry'][pid].update(widths=d['widths'],actual_paid_profile={str(k):v for k,v in sorted({int(k):v for k,v in d['actual_paid_profile'].items()}.items())}) + widths={pid:d['widths']for pid,d in providers.items()};R=len(next(iter(widths.values()))) + P.require(all(len(w)==R for w in widths.values()),'same helper count') + pairs,sides=plan['pairs'],plan['sides'];helper_seen=collections.defaultdict(set);family_seen=collections.defaultdict(set);used=collections.defaultdict(set) + for z in roles: + tm=z['time'];P.require(0<=tmlen(cells):idle[cap-len(cells)]+=1 + paid=collections.Counter(idle) + for st,r in order:paid.update({int(k):v for k,v in providers[dispatch[st,r]]['actual_paid_profile'].items()}) + P.require(dict(paid)=={int(k):v for k,v in profile.items()},'entire actual paid profile') + P.require(73*896*T-sum(k*v for k,v in paid.items())==320*T,'full rank mass and deficit') + stage_template={c['stage']:c for c in plan['provider_calls']} + plan['provider_calls']=[];plan['per_call_widths']=[] + for tm,(st,r)in enumerate(order): + pid=dispatch[st,r];desc=plan['provider_registry'][pid];z=copy.deepcopy(stage_template[st]);orientation='forward'if st%2==0 else'backward' + P.require(z['orientation']==orientation,'source stage orientation') + z.update(replica=r,time=tm,provider=pid,local_program_sha256=desc['orientation_program_sha256'][orientation]);plan['provider_calls'].append(z) + plan['per_call_widths'].append(dict(stage=st,replica=r,time=tm,widths=desc['widths'])) + plan.update(T=T,live=896*T,deficit=320*T,order=order,windows=windows,profile=profile,assignment_sha256=P.sha(owners/'OWNERS.json.gz'),assignment_content_sha256=P.identity(roles),status=f'EXPLICIT_T{T}_STRICT_WINDOW_OWNER_FILL',mode=f'mixed-t{T}-exact-fill',solver_status='Literal fixed owner witness independently rechecked; no solver runs in adapter') + plan['replica_lift']=dict(replicas=T,parent_template_content_sha256=P.identity(parent),owners_file_sha256=P.sha(owners/'OWNERS.json.gz'),schedule_content_sha256=P.identity(schedule),source_replicas=37,groups=parent['replica_lift']['groups'],phase_recipe_unchanged=True) + # Discovery computes geometry/numerical expectations, but the descriptive + # reporting denominator is source metadata and must survive the reset. + preserved_expected={'gain_baseline_kappa':spec['expected']['gain_baseline_kappa']} + spec.update(name=f'mixed-t{T}-exact-fill',call_order=order,dispatch=dispatch_rows,providers={},expected=preserved_expected) + assembly_ast=ast.parse((base/'code/assemble.py').read_text(encoding='utf-8')) + read_expected={node.slice.value for node in ast.walk(assembly_ast) if isinstance(node,ast.Subscript) and isinstance(node.value,ast.Name) and node.value.id=='X' and isinstance(node.slice,ast.Constant) and isinstance(node.slice.value,str)} + discovery_computed={'complex_lower','conservative_complex_lower'} + P.require(read_expected-discovery_computed<=set(preserved_expected),'all noncomputed assembly X metadata retained') + # Fresh discovery/freezing and outer admission supply all expected values. + spec['geometry']=dict(replicas=T,stages=plan['L'],pairs=plan['K'],dimension=plan['M'],charged_prefix_bits=1<<(128+37+18+1330+1+4).bit_length(),parent_live=parent['live'],parent_physical=parent['physical'],parent_idle=geometry['parent_idle'],parent_helpers=504) + out.mkdir(parents=True) + for name,obj in [('GLOBAL-TEMPLATE.json.gz',parent),('OWNERS.json.gz',roles),('DISPATCH.json',dispatch_rows),('PROFILE.json',profile),('ORDER.json',order),('CONSTRUCTION.json',P.read(owners/'RESULT.json'))]:P.write_new(out/name,obj) + # Bind canonical output owner serialization while preserving exact role semantics. + output_owner=out/'OWNERS.json.gz' + P.require(P.read(output_owner)==roles,'serialized owner semantics') + # Canonical gzip may differ from emitter gzip. Bind the actual output file everywhere. + plan['assignment_sha256']=P.sha(output_owner);plan['replica_lift']['owners_file_sha256']=P.sha(output_owner) + P.write_new(out/'PLAN.json',plan) + spec['data']={'plan_sha256':P.sha(out/'PLAN.json'),'owners_sha256':P.sha(output_owner)} + P.write_new(out/'SPEC.json',spec) + receipt=dict(status='PASS_LITERAL_GENERAL_T_PARENT_PLAN_SPEC',geometry=spec['geometry'],groups=parent['replica_lift']['groups'],input_sha256=input_hash,template_content_sha256=P.identity(parent),new_sha256=P.sha(out/'GLOBAL-TEMPLATE.json.gz'),source_sha256=P.SOURCE_SHA,roles=len(roles),helpers_per_call=R,source_events_per_replica=30,global_tail=[30,31],schedule_content_sha256=P.identity(schedule),profile=dict(sorted(paid.items())),idle=dict(sorted(idle.items())),private_work_shared=514,source_programs_phase_recipes_unchanged=True,discovery_X_metadata=sorted(read_expected-discovery_computed),discovery_computed_X_keys=sorted(read_expected&discovery_computed),phase_scope='Reuses root fresh hash-bound native/phase admission; this adapter checks literal source geometry and complete paid owner profile.',scripts={Path(__file__).name:P.sha(__file__),Path(P.__file__).name:P.sha(P.__file__)}) + P.write_new(out/'PARENT-LIFT-RECEIPT.json',receipt) + for path,h in input_hash.items():P.require(P.sha(path)==h,'input unchanged after lift') + print('PASS_LITERAL_GENERAL_T_PARENT_PLAN_SPEC',json.dumps(spec['geometry'],sort_keys=True),flush=True) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/reconstruct_replica.py b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/reconstruct_replica.py new file mode 100644 index 0000000000..f00410bb45 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/reconstruct_replica.py @@ -0,0 +1,66 @@ +# SPDX-License-Identifier: Apache-2.0 +# Derived from Jeremy Kothe / Philippe Van Velzen / Tekalign owner verifier. +# Parameter extension with substantial OpenAI Codex assistance. +"""Borrow-word owner witness: literal verification of the shipped exact fill (new/borrow-fill/FILL.json.gz) and emission of +OWNERS/ORDER/DISPATCH/PROFILE/RESULT for lift_parent.py. The helper count per call is R' = 480-k and the per-call widths come from +new/BORROW-PROVIDERS.json; the same windows, bins and distinct-family rules as the pinned PR1297 owner construction are checked +literally (no window, bin, helper or family rule is relaxed). Idle remainders are whatever the exact bins leave (ranks priced +exactly by the profile). The fill itself is found offline by new/borrow-fill/solve_fill.py (not rerun here) and only verified. +""" +import argparse,collections,gzip,importlib.util,json +from pathlib import Path +assert __debug__, 'Assertions are required' +F=Path(__file__).resolve().parent +ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path,required=True);args=ap.parse_args();P=args.out.resolve();P.mkdir(parents=True,exist_ok=False) +def read(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def dump(p,x): + b=json.dumps(x,sort_keys=True,separators=(',',':')).encode();z=bytearray(gzip.compress(b,mtime=0));z[9]=255;p.write_bytes(bytes(z) if p.suffix=='.gz' else b) +plan=read(F/'inputs/PLAN.json');parent=read(F/'inputs/GLOBAL-TEMPLATE.json.gz');T=plan['T'] +OF=F/'new/borrow-fill/ORDER.json' +assert OF.exists(), 'explicit candidate order required' +if OF.exists(): # a free complete invocation order (666 calls; windows are recomputed from it below) with its explicit dispatch + order=read(OF);dispatch={(s,r):pid for s,r,pid in read(F/'new/borrow-fill/DISPATCH.json')} + Tnew=1+max(r for s,r in order) + assert type(Tnew) is int and Tnew>0 + assert len(order)==9*Tnew and sorted(map(tuple,order))==[(s,r) for s in range(9) for r in range(Tnew)],'order must cover every actual source replica and stage exactly once' + assert set(dispatch)==set(map(tuple,order)),'complete provider dispatch' +else: + order=[[s,r+T*g] for s,r in plan['order'] for g in range(2)] + dispatch={(s,r+T*g):pid for s,r,pid in read(F/'inputs/DISPATCH.json') for g in range(2)} +source=F/'vendor/build_parent.py';sp=importlib.util.spec_from_file_location('windows',source);mod=importlib.util.module_from_spec(sp);sp.loader.exec_module(mod);windows,schedule=mod.actual_windows(parent,order) +prov=read(F/'new/BORROW-PROVIDERS.json');widths={p:d['widths'] for p,d in prov.items()};paid={p:{int(k):v for k,v in d['actual_paid_profile'].items()} for p,d in prov.items()} +R=len(next(iter(widths.values())));assert all(len(w)==R for w in widths.values()) and set(widths)==set(dispatch.values()) +fill=read(F/'new/borrow-fill/FILL.json.gz');assert fill['columns']==['time','helper','owner_replica','child','port','offset'] +for s_,r_,p_ in fill['dispatch_overrides']:dispatch[s_,r_]=p_ # the single gauge44->extra provider upgrade of the pinned fill +pairs,sides=plan['pairs'],plan['sides'] +at={tuple(x):i for i,x in enumerate(order)} +roles=[] +for time,helper,rep,child,port,offset in fill['rows']: + stage,replica=order[time];w=widths[dispatch[stage,replica]][helper] + roles.append(dict(stage=stage,replica=replica,time=time,helper=helper,width=w,owner_replica=rep,child=child,port=port,offset=offset,copy=112*rep+port,family=rep*896+(2*pairs[str(child)]+sides[str(child)])*112+port)) +assert len(roles)==len(order)*R,(len(roles),len(order)*R) +helpers=collections.defaultdict(set);fams=collections.defaultdict(set);used=collections.defaultdict(set) +for z in roles: + call=(z['stage'],z['replica']);rep,child,port=z['owner_replica'],z['child'],z['port'] + cap,allowed=windows[f'{rep},{child}'] + assert z['time'] in allowed and 0<=port<112 and 0<=z['helper']=0 and z['offset']+z['width']<=cap and not used[rep,child,port]&cells + used[rep,child,port]|=cells +assert set(helpers)==set(map(tuple,order)) and all(s==set(range(R)) for s in helpers.values()) +idle=collections.Counter() +for key,(cap,times) in windows.items(): + r,ch=map(int,key.split(',')) + for port in range(112): + c=used[r,ch,port];assert c==set(range(len(c))),'gap in pending prefix' + if cap-len(c):idle[cap-len(c)]+=1 +H=collections.Counter(idle) +for sr in order: + for r,n in paid[dispatch[tuple(sr)]].items():H[int(r)]+=n +assert 73*(896*Tnew)-sum(r*n for r,n in H.items())==320*Tnew,'rank-mass deficit' +roles.sort(key=lambda r:(r['time'],r['helper'])) +dump(P/'OWNERS.json.gz',roles);dump(P/'ORDER.json',order);dump(P/'DISPATCH.json',[[s,r,dispatch[s,r]] for s,r in order]);dump(P/'PROFILE.json',dict(sorted(H.items()))) +dump(P/'RESULT.json',dict(status='PASS_EXACT_BORROW_WORD_REPLICA_OWNER_FILL',roles=len(roles),helpers_per_call=R,dispatch=dict(collections.Counter(dispatch.values())),idle=dict(sorted(idle.items())),scope='Literal strict windows, bin capacities, per-call helper widths and distinct physical families verified for the shipped fill; local programs are the borrow words; full parent binding, finite invoice and global admission run separately.')) +print('PASS_OWNER_VERIFY',dict(idle),dict(sorted(H.items())),flush=True) diff --git a/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/replica_parent.py b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/replica_parent.py new file mode 100644 index 0000000000..770fb1fe99 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/vendor/pr2839/replica_parent.py @@ -0,0 +1,192 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Explicit arbitrary-positive-replica lift of the authenticated T37 parent. + +This constructs dedicated source banks, not hosted helper assignments. Source +lineage: PR558/589, PR741/799/870 controller routes, PR1193 T37 bank envelope, +PR2679/2751/2766 replay. No provider/native source or phase recipe is modified. +""" +import argparse, copy, gzip, hashlib, json, os +from collections import Counter +from pathlib import Path + +SOURCE = Path(__file__).resolve().parent/'inputs/GLOBAL-TEMPLATE.json.gz' +REFERENCE = SOURCE.parent.parent/'GLOBAL-TEMPLATE.json.gz' +SOURCE_SHA = '21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e' +SOURCE_ID = '514e59314c8e2fa3c22d0a48083816f6686211090835e8f8775318c1c3e992d8' +M, STAGES, DATA_PER_REPLICA, HELPERS, BANK_PER_GROUP, PRIVATE = 73, 9, 896, 504, 4536, 514 + +def canonical(x): return json.dumps(x,sort_keys=True,separators=(',',':')).encode() +def identity(x): return hashlib.sha256(canonical(x)).hexdigest() +def sha(p): return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def read(p): + p=Path(p); raw=p.read_bytes() + return json.loads(gzip.decompress(raw) if p.suffix=='.gz' else raw) +def require(x,why): + if not x: raise ValueError(why) +def source(): + require(sha(SOURCE)==SOURCE_SHA,'source byte hash') + s=read(SOURCE); require(identity(s)==SOURCE_ID,'source content hash') + return s + +def grouping(T): + require(isinstance(T,int) and T>0,'positive integer T') + return [8]*(T//8)+([T%8] if T%8 else []) + +def build(T, groups=None, order=None): + s=source(); groups=grouping(T) if groups is None else list(groups) + require(sum(groups)==T and all(isinstance(q,int) and 1<=q<=8 for q in groups),'group partition') + olddata=37*896; data=T*896; live=data+len(groups)*BANK_PER_GROUP + t=copy.deepcopy({k:v for k,v in s.items() if k not in ('calls','bank_padding','local_programs')}) + # Programs are immutable and reused literally; there is no new phase oracle. + t['local_programs']=s['local_programs'] + t.update(version='arbitrary-T-dedicated-source-bank-envelope-v1',live=live,physical=live+PRIVATE) + templates={(c['stage'],c['replica']):c for c in s['calls'] if c['replica']<8} + location={}; off=0 + for g,q in enumerate(groups): + for lane in range(q): location[off+lane]=(g,lane) + off+=q + order=[(st,r) for st in range(9) for r in range(T)] if order is None else [tuple(x) for x in order] + require(len(order)==9*T and set(order)=={(st,r)for st in range(9)for r in range(T)},'call coverage') + require(all([st for st,r in order if r==rep]==list(range(9))for rep in range(T)),'per-replica stage order') + calls=[] + for st,r in order: + g,lane=location[r]; old=templates[st,lane] + c={k:copy.deepcopy(v) for k,v in old.items() if k!='owners'}; c['replica']=r + c['owners']=[[f-lane*896+r*896,copy.deepcopy(route)]for f,route in old['owners'][:224]] + c['owners'] += [[data+g*BANK_PER_GROUP+st*HELPERS+h,copy.deepcopy(route)]for h,(_,route) in enumerate(old['owners'][224:])] + calls.append(c) + t['calls']=calls + widths=[9 if len(route)==2 else route[2] for _,route in templates[0,0]['owners'][224:]] + children=[] + for g,q in enumerate(groups): + for st in range(9): + for h,w in enumerate(widths): + axes=list(range(q*w,M)) + children.append(dict(family=data+g*BANK_PER_GROUP+st*HELPERS+h,rank=len(axes),axis_indices=axes,orthogonal_axes=[1<=30] + project={r:[]for r in range(T)} + for e in result[:-2]:project[e['replica']].append(e['source_event']) + require(all(v==list(range(30))for v in project.values()),'all thirty literal events per source replica') + require([e['source_event']for e in result[-2:]]==[30,31],'two global source events') + return result + +def compare74(): + actual=read(REFERENCE);groups=actual['replica_lift']['groups'];order=[(c['stage'],c['replica'])for c in actual['calls']] + ours=build(74,groups,order) + ignore={'version','route_semantics'} + require({k:v for k,v in ours.items()if k not in ignore}=={k:v for k,v in actual.items()if k not in ignore},'actual T74 complete semantic identity') + require(ours['route_semantics']['data']==actual['route_semantics']['data'] and ours['route_semantics']['work']==actual['route_semantics']['work'],'T74 other route semantics unchanged') + return dict(status='PASS',reference_file_sha256=sha(REFERENCE),reference_content_sha256=identity(actual),identical_fields=[k for k in ours if k not in ignore],differences=['version label','helper route explanatory string only'],source_call_order_matched=True) + +def write_new(p,x): + p=Path(p);p.parent.mkdir(parents=True,exist_ok=True); lock=p.with_suffix(p.suffix+'.lock') + fd=os.open(lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY) + try: + os.write(fd,str(os.getpid()).encode());os.close(fd);fd=None + require(not p.exists(),'preserve existing output') + raw=canonical(x) + if p.suffix=='.gz': + b=bytearray(gzip.compress(raw,mtime=0));b[9]=255;raw=bytes(b) + with p.open('xb')as h:h.write(raw) + finally: + if fd is not None:os.close(fd) + lock.unlink() + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--T',type=int,default=80);ap.add_argument('--out',type=Path,required=True);ap.add_argument('--order',type=Path) + a=ap.parse_args();require(not a.out.exists(),'fresh output directory required');a.out.mkdir(parents=True) + order=read(a.order)if a.order else None + t=build(a.T,order=order);receipt=check(t,t['replica_lift']['groups']);receipt['T74_comparison']=compare74() + stages=[(c['stage'],c['replica'])for c in t['calls']];sched=expand_schedule(t,stages) + receipt.update(status='PASS_EXPLICIT_SOURCE_PARENT_GEOMETRY',source_file_sha256=SOURCE_SHA,source_content_sha256=SOURCE_ID,source_recipe_unchanged=True,source_events_per_replica=30,global_tail=[30,31],expanded_events=len(sched),phase_claim='Literal reuse of authenticated source local programs and phase recipes; this is not a fresh native phase replay.',scope='Dedicated parent only; final hosted owner assignment/invoice/admission remains separate.',script_sha256=sha(__file__)) + write_new(a.out/'GLOBAL-TEMPLATE.json.gz',t);write_new(a.out/'SOURCE-SCHEDULE.json.gz',sched) + receipt['template_content_sha256']=identity(t);receipt['template_file_sha256']=sha(a.out/'GLOBAL-TEMPLATE.json.gz');receipt['schedule_content_sha256']=identity(sched) + write_new(a.out/'RESULT.json',receipt) + require(sha(SOURCE)==SOURCE_SHA,'source unchanged after output') + print(json.dumps(receipt,sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/shared-kernel-packing/vendor/pr2857/verify.py b/research/shared-kernel-packing/vendor/pr2857/verify.py new file mode 100644 index 0000000000..0bf28ee1d9 --- /dev/null +++ b/research/shared-kernel-packing/vendor/pr2857/verify.py @@ -0,0 +1,214 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Fast, source-bound local verification for Yiyang (@Lyy-iiis). + +Prepared with substantial OpenAI Codex assistance. This wrapper authenticates +all LOCAL-PINS.json fixtures, imports only the pinned pure producer, and runs +the separate independent checker. It does not establish owner, native-phase, +packing, outer-moment, or full inherited-source-release admission. +""" +import sys +if not __debug__: + raise SystemExit('Refusing Python -O/-OO: fast verification requires active assertions in its independent checker.') +sys.dont_write_bytecode = True +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import subprocess +import tempfile + +os.environ['PYTHONDONTWRITEBYTECODE'] = '1' + + +def require(condition, message): + if not condition: + raise RuntimeError(message) + + +def sha_bytes(data): + return hashlib.sha256(data).hexdigest() + + +def sha_file(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() if hasattr(hashlib, 'file_digest') else sha_bytes(stream.read()) + + +def unique_object(pairs): + out = {} + for key, value in pairs: + require(key not in out, 'duplicate JSON key: ' + str(key)) + out[key] = value + return out + + +def checked_fixture(package, relative, expected): + require(isinstance(relative, str) and isinstance(expected, str), 'invalid pin entry types') + name = Path(relative) + require(not name.is_absolute() and '..' not in name.parts, 'unsafe fixture path: ' + relative) + path = (package / name).resolve() + require(package in path.parents and path.is_file(), 'fixture missing or outside package: ' + relative) + require(len(expected) == 64 and all(c in '0123456789abcdef' for c in expected), 'invalid SHA256 pin: ' + relative) + actual = sha_file(path) + require(actual == expected, 'fixture SHA256 mismatch: ' + relative) + return actual + + +def dump(path, value): + path.write_text(json.dumps(value, indent=2, sort_keys=True) + '\n') + + +def run_checker(checker, source, candidate, directory, expected_failure=None): + directory.mkdir() + receipt = directory / 'CHECK.json' + command = [sys.executable, '-I', '-B', str(checker), '--source-word', str(source), + '--candidate-word', str(candidate), '--out', str(receipt)] + process = subprocess.run(command, cwd=directory, capture_output=True, text=True, + env=dict(os.environ, PYTHONDONTWRITEBYTECODE='1')) + (directory / 'stdout.txt').write_text(process.stdout) + (directory / 'stderr.txt').write_text(process.stderr) + result = dict(command=command, returncode=process.returncode, + source_sha256=sha_file(source), candidate_sha256=sha_file(candidate)) + if expected_failure is None: + require(process.returncode == 0 and receipt.is_file(), 'independent checker failed: ' + str(directory)) + data = json.loads(receipt.read_text()) + require(data.get('status') == 'PASS_INDEPENDENT_FOUR_GROUP_LOCAL_DIFFERENTIAL_AUDIT', + 'unexpected independent checker status') + result.update(status='PASS', receipt=str(receipt)) + else: + lines = [line.strip() for line in process.stderr.splitlines() if line.strip()] + expected_last = 'AssertionError: ' + expected_failure + require(process.returncode != 0 and lines and lines[-1] == expected_last, + 'fault rejected for unexpected reason: ' + str(directory)) + require(not receipt.exists(), 'fault checker wrote a success receipt') + result.update(status='EXPECTED_REJECTION', failure=expected_failure, + scope='The independent checker rejects the altered literal structure; endpoint controls are retained separately.') + dump(directory / 'RUN.json', result) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--package', type=Path, default=Path(__file__).resolve().parent) + parser.add_argument('--work', type=Path, help='fresh directory outside the package for all receipts') + args = parser.parse_args() + package = args.package.resolve() + manifest = package / 'LOCAL-PINS.json' + manifest_bytes = manifest.read_bytes() + pins = json.loads(manifest_bytes, object_pairs_hook=unique_object) + require(isinstance(pins, dict) and pins, 'LOCAL-PINS.json must be a nonempty object') + # Every listed fixture is checked with explicit conditions, before imports or writes. + before = {name: checked_fixture(package, name, expected) for name, expected in sorted(pins.items())} + required = ['shared_kernel.py', 'check_four_kernels.py'] + for variant in ('base', 'extra'): + required += [f'sources/PR2833-WORD-{variant}.json.gz', f'words/WORD-{variant}.json.gz'] + require(all(name in pins for name in required), 'missing required producer/checker/word pins') + if args.work is None: + temporary_root = Path(tempfile.gettempdir()).resolve() + require(temporary_root != package and package not in temporary_root.parents, + 'temporary root is inside package; pass --work outside package') + work = Path(tempfile.mkdtemp(prefix='shared-kernel-fast-', dir=temporary_root)).resolve() + else: + work = args.work.resolve() + require(work != package and package not in work.parents, 'work directory must be outside package') + require(not work.exists(), 'work directory must be fresh') + work.mkdir(parents=True) + spec = importlib.util.spec_from_file_location('_pinned_shared_kernel_fast_verify', package / 'shared_kernel.py') + require(spec is not None and spec.loader is not None, 'cannot load pinned producer') + producer = importlib.util.module_from_spec(spec) + spec.loader.exec_module(producer) + checker = package / 'check_four_kernels.py' + positives = [] + source_controls = [] + sources = {} + candidates = {} + ledgers = {} + for variant in ('base', 'extra'): + source_path = package / f'sources/PR2833-WORD-{variant}.json.gz' + candidate_path = package / f'words/WORD-{variant}.json.gz' + source = json.loads(gzip.decompress(source_path.read_bytes())) + candidate = json.loads(gzip.decompress(candidate_path.read_bytes())) + original = copy.deepcopy(source) + changed, ledger = producer.apply(source) + require(source == original, 'pure producer mutated decoded source: ' + variant) + require(changed == candidate, 'derived word differs from pinned candidate: ' + variant) + sources[variant], candidates[variant], ledgers[variant] = source, candidate, ledger + derived_path = work / f'DERIVED-{variant}.json.gz' + derived_path.write_bytes(gzip.compress(json.dumps(changed, separators=(',', ':')).encode(), mtime=0)) + dump(work / f'PRODUCER-{variant}.json', dict(ledger=ledger, decoded_equal=True, + source_unchanged=True, source_sha256=sha_file(source_path), + pinned_candidate_sha256=sha_file(candidate_path), derived_sha256=sha_file(derived_path))) + positives.append(run_checker(checker, source_path, derived_path, work / f'positive-{variant}')) + bad_source = copy.deepcopy(source) + bad_source['report']['R'] += 1 + try: + producer.apply(bad_source) + except ValueError as error: + require(str(error) == 'unauthorized decoded source SHA256', 'unexpected bad-source producer failure') + else: + raise RuntimeError('producer accepted an unauthorized decoded source: ' + variant) + source_controls.append(dict(variant=variant, control='producer_bad_source', + rejected=True, reason='unauthorized decoded source SHA256')) + require(source == original, 'bad-source control mutated original decoded source') + # Three targeted faults in actual candidate words, without rerunning the larger native suite. + mutants = [] + missing = copy.deepcopy(candidates['base']) + bridge = ['add', 490, 478, -1, 1, [25]] + require(missing['A'].count(bridge) == 1, 'new A bridge is not unique') + missing['A'].remove(bridge) + mutants.append(('missing_new_A', 'base', missing, 'exact_twenty_insertions_no_hidden_scalar_changes')) + wrong_comp = copy.deepcopy(candidates['extra']) + require(wrong_comp['compensation'][-1][0] == 'add', 'last compensation gate shape') + wrong_comp['compensation'][-1][3] *= -1 + mutants.append(('wrong_compensation', 'extra', wrong_comp, 'exact_compensation_column_replacements')) + stale = copy.deepcopy(candidates['base']) + inverse_bridge = ['add', 490, 478, 1, 1, [256,128,64,32,16,8,4,2,1]] + require(stale['cleanup'].count(inverse_bridge) == 1, 'new cleanup inverse is not unique') + stale['cleanup'].remove(inverse_bridge) + mutants.append(('stale_cleanup_missing_new_inverse', 'base', stale, + 'exact_inverse_reverse_cleanup_excludes_prelude_targets_and_uses_private_buffers')) + negatives = [] + for name, variant, mutant, failure in mutants: + path = work / (name + '.json.gz') + path.write_bytes(gzip.compress(json.dumps(mutant, separators=(',', ':')).encode(), mtime=0)) + negatives.append(run_checker(checker, package / f'sources/PR2833-WORD-{variant}.json.gz', + path, work / name, expected_failure=failure)) + # Explicit SHA failure and optimization-rejection controls also work under normal Python. + try: + checked_fixture(package, 'shared_kernel.py', '0' * 64) + except RuntimeError as error: + require(str(error) == 'fixture SHA256 mismatch: shared_kernel.py', 'unexpected pin failure') + else: + raise RuntimeError('wrong producer SHA pin accepted') + optimized_work = work / 'optimized-must-not-exist' + optimized = subprocess.run([sys.executable, '-O', '-B', str(Path(__file__).resolve()), + '--package', str(package), '--work', str(optimized_work)], + cwd=work, capture_output=True, text=True, + env=dict(os.environ, PYTHONDONTWRITEBYTECODE='1')) + require(optimized.returncode != 0 and 'Refusing Python -O/-OO:' in optimized.stderr + and not optimized_work.exists(), 'optimized invocation was not rejected before output') + dump(work / 'OPTIMIZATION-REJECTION.json', dict(returncode=optimized.returncode, + stdout=optimized.stdout, stderr=optimized.stderr, output_created=False)) + after = {name: checked_fixture(package, name, expected) for name, expected in sorted(pins.items())} + require(before == after and manifest.read_bytes() == manifest_bytes, 'pinned package inputs changed during verification') + result = dict(status='PASS_FAST_SHARED_KERNEL_LOCAL_VERIFY', package=str(package), + manifest_sha256=sha_bytes(manifest_bytes), authenticated_fixture_count=len(pins), + imported_package_modules=['shared_kernel.py'], positives=positives, + word_faults=negatives, source_controls=source_controls, + incorrect_fixture_pin_rejected=True, optimized_mode_rejected_before_write=True, + all_pinned_inputs_unchanged=True, before=before, after=after, + remaining_admission=['constructive owner/layout verification', 'complete native phase/Gaussian and inherited-source release', + 'all returned-idle costs and exact full outer moment', 'selected-parent admission'], + scope='Fast local reproducibility and differential checks only; this wrapper does not certify the bound.') + dump(work / 'FAST-VERIFY.json', result) + print(json.dumps(dict(status=result['status'], fixtures=len(pins), positive_words=2, + actual_word_faults=3, receipt=str(work / 'FAST-VERIFY.json')), sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/shared-kernel-packing/vendor/pr2857/words/WORD-base.json.gz b/research/shared-kernel-packing/vendor/pr2857/words/WORD-base.json.gz new file mode 100644 index 0000000000..1d4697887b Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/words/WORD-base.json.gz differ diff --git a/research/shared-kernel-packing/vendor/pr2857/words/WORD-extra.json.gz b/research/shared-kernel-packing/vendor/pr2857/words/WORD-extra.json.gz new file mode 100644 index 0000000000..3f0289a7a4 Binary files /dev/null and b/research/shared-kernel-packing/vendor/pr2857/words/WORD-extra.json.gz differ