diff --git a/research/tensor-block-kappa/CLAIM.json b/research/tensor-block-kappa/CLAIM.json new file mode 100644 index 0000000000..5aa3b6d704 --- /dev/null +++ b/research/tensor-block-kappa/CLAIM.json @@ -0,0 +1,40 @@ +{ + "baseline_pr2802_kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "calls": 1026, + "comparison": "previous delivered T104 package", + "comparison_claim_sha256": "f26209f7903557cf3dddd8e6d99b4b2b2f99bbd4b5eb0e6161150830e94b02d0", + "comparison_kappa": "17177952226165877431979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "complex_lower": "858897637110708343289/500000000000000000000000", + "complex_upper": "1717795274221416686579/1000000000000000000000000", + "gain": "2580241447169/50000000000000000000000", + "helpers_per_call": 408, + "historical_pr2824": 2824, + "kappa": "17177952742214166865779999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177952742214166865779999999999999999999998999999999999999999999999", + "live": 102144, + "norm_certificate": { + "active_depth": 18, + "actual_prefix": 1453, + "charged_payload": 2048, + "conservative_prefix": 1511, + "full_stock_l2_bits": 1323, + "physical_row": 19547, + "row_ceiling": 20161 + }, + "physical": 102634, + "profile": { + "1": 2470608, + "2": 664848, + "3": 285126, + "32": 1, + "4": 131328, + "48": 40914, + "5": 41894, + "8": 8208 + }, + "rank_mass": 7420032, + "replicas": 114, + "roles": 418608, + "scope": "Complete conditional finite T114 release. Inherited all-size compiler, source-access, hosting, precision/tape, recovery, ordinary-recursion, bit-supplier and analytic-transfer contracts remain. The Mathlib theorem proves the sufficient block-energy bound, not an unconditional multiplication theorem.", + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA" +} diff --git a/research/tensor-block-kappa/CREDITS.md b/research/tensor-block-kappa/CREDITS.md new file mode 100644 index 0000000000..f9775c75c6 --- /dev/null +++ b/research/tensor-block-kappa/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/tensor-block-kappa/FRONTIER.md b/research/tensor-block-kappa/FRONTIER.md new file mode 100644 index 0000000000..608bcde134 --- /dev/null +++ b/research/tensor-block-kappa/FRONTIER.md @@ -0,0 +1,72 @@ +# T114 tensor-block precision and frontier scope + +**Status: complete T114 release PASSED.** The admitted conditional target is +`0.001717795274221416686578 - 10^-46 - 10^-70`, an exact +`51604828943380/10^24 = 5.160482894338e-11` increase over the admitted T104 target. +Independent finite allocation or moment checks alone do not establish complete admission. +Final status is controlled by the fresh release and kernel receipts, not this draft. + +The proposed change retains PR2802's actual two R408 native words. At complete +hosted boundaries, each caller has its prescribed data shear, every dirty helper +has only its own normalized residual transform, and shared private work is clear. +Grouping physical families by their owner replica therefore bounds amplification +by each replica's nine calls and nine bridges. The new precision invoice charges +2048 bits, including full regular-representation stock conversion and an additional partial-cover bit; it +replaces the previous amplification over all replicas. The actual T114 allocation, +all paid children, ordinary finite costs and outer inequalities still require +fresh source-bound admission. See [PROOF.md](PROOF.md). + +The candidate has 114 replicas, 1026 complete calls and 418608 whole-helper roles. +Its proposed complete profile is +`{1:2470608,2:664848,3:285126,4:131328,5:41894,8:8208,32:1,48:40914}`. +Live stock is 102144; physical stock is 102634, including eight private centres, +408 reserved helper slots, 72 private zero buffers and two coefficient fields. +Full regular-representation stock has 2645 bits, so its explicit square-root conversion charges 1323 bits. The conservative prefix is 1511<2048 and the ordinary row coefficient is 19547<20161. No zero-cost omitted helper, centre child or larger row ceiling is proposed. + +## Comparison and current source review + +The preceding T104 construction completed its changed-candidate release at +`0.001717795222616587743198 - 10^-46 - 10^-70`. Its original frontier and proof +notices are preserved verbatim, with original SHA256 digests, in +[the predecessor notice](provenance/TI-BLOCK-PREDECESSOR-NOTICES.json). +Those historical success statements apply to T104; they do not certify T114. + +The additional TI-focused source snapshot identifies canonical upstream +`CrocSwap/integer-mult-bounds`, main +`b6a42ba8bcdf5a88c0ab14019779b84614795746`, and maintainer priority revision 5. +Its selected conditional record remains `0.001672660197076918`, distinct from +stronger pending submissions. The tensor-keyword query at +2026-10-16T00:34:20.702Z returned 127 PR bodies with +`incomplete_results=false`; a tensor-plus-isomorphism query returned PR471, +PR508 and PR537. Actual relevant proofs, bodies and notices were inspected. +The review also traced 138 focused/keyword roots to 1514 explicit cited PR +numbers, with 1143 records available and 371 missing. This is a bounded +attribution survey, not a complete import graph, all-comments review or novelty +certificate. The full central TI dossier was searched and read in relevant +sections; its entire 2.7 MB appendix was not manually reread. + +Earlier whole-footprint normalization, restored spectators, target factoring, +response-kernel cancellation, coordinated gauges and contextual hosting already +appear in public work. [CREDITS.md](CREDITS.md) names the relevant sources. +The current application uses elementary direct-sum operator-norm accounting on +source-bound normalized endpoints. It claims neither a new general tensor +isomorphism identity nor that nobody previously used this viewpoint. + +PR2742's actual covariant dirty-reader action is useful reviewed overlap, but it +retains all eight rank-eight centre descents and is not substituted for the +current multiplier. The additionally checked 1344 current-reader covariances +and bounded gauge searches did not themselves produce a paid-profile gain. +Standalone TI/TI_SL decision results do not establish a cheaper native supplier. + +## Evidence and limits + +The new universal energy inequalities, exact endpoint/topology checks, literal +T114 owners and complete global release are separate evidence layers. Unchanged +native chains may be reused only under exact source/artifact/receipt guards; +reuse is not a fresh native rerun. The package's final validation must state +which layers ran freshly and which authenticated earlier checks were reused. + +The multiplication implication retains all inherited all-size compiler, +common-label/source-access, hosted-wrapper, precision/tape, recovery, ordinary +recursion, bit-supplier and analytic-transfer contracts. No unconditional faster +multiplication theorem, TI=TI_SL result or global optimality claim is made. diff --git a/research/tensor-block-kappa/LICENSE b/research/tensor-block-kappa/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/tensor-block-kappa/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/tensor-block-kappa/MANIFEST.json b/research/tensor-block-kappa/MANIFEST.json new file mode 100644 index 0000000000..d0b0092036 --- /dev/null +++ b/research/tensor-block-kappa/MANIFEST.json @@ -0,0 +1,193 @@ +{ + ".gitattributes": "769783a1399f134634fac029e86d9eed9a7f486f912a8541831f06486e586bc9", + "CLAIM.json": "5036537801ba253f861a5459d4e910c7044eb1ed09e599b2029996457284e33b", + "CREDITS.md": "d8eea66efb6796d3caeec985949724eab9df1eb214182b7db2ef84ba6e19b5e9", + "FRONTIER.md": "5ec0e4a26e3684eaca30a1fa02752255fae8eb9493a3ad674cecd48ddf61588d", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "MODULES.json": "127c0e4ffce8aad198a4c98ec69ebe3e1d3648290f7e32ec4a589c8f1e2c9bfb", + "PARENT-LIFT.md": "9fa28a213c33c313be0ebca6a479ede687b14cc5c752fe60419d1f38e6b16d48", + "PORTING.json": "5dbeb522e717b34b5e1624d1e1914bbe6bdd9c9d82fc3fc9b0615545e5932970", + "PR-BODY.md": "3fc8c7851ddb406541f170e1ac1e3ca3213341c755685240d7dcfdfe4196a1b4", + "PR-TITLE.txt": "cc8e70e17ab397e27e6e7c327149ab22ab66361d56e1128e1eecd3dcbcdc2931", + "PROOF.md": "3fa62afc4cee9315f236e8cae94484b40d2dedc271d654b08eb5eaf86a96a425", + "README.md": "7403371530e541e8580527df30faf305e7b1dad4044b63f3dc996d9b9dba7cc0", + "TASK.json": "2acfc2cafb40b83c1e603f281eca8fa2e5dce32b40bc34289a5cac78aeba02ba", + "VERIFY.json": "6d01e2f5e1d7aae12b2483a1a0f79d2d170fbd8bac24aa618ec63905f1ab2ade", + "admit_frontier_replica.py": "57630311eb90be3d417e7bdeaae03965fef46a97b4b38389ff66805c75276f80", + "blocknorm_certificate.py": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92", + "check_candidate.py": "d0c2fccee4df548d30f07494b46159ccbfbde2c2621cfca861e79838e537b7ca", + "data/DISPATCH.json": "164494966a463d2edce30fa3698d05928c093d00d8cda8568a670174fc81857f", + "data/FILL.json.gz": "27cdac384c88bbcb7c608c031cf1def6084aa4f1e411a9c90c9ed9449ab2e5ad", + "data/ORDER.json": "16d90ed352663d98d4c9829e7017724fa3a28d771f6ed4cea3cf6291715e9190", + "data/PROFILE.json": "2d1511e01dd683f9304dd626776bac47d0e575c7cdaaa920e1500fc044080311", + "expected/AXIOMS.json": "ed379ce180b7df7c0f2eb40d546c1c96a00c015c2e73ed3fb874b790152c12e8", + "independent_candidate_moment_retired7.py": "f6f38ef8e8fc1e634a2f89a45f3bf721f166a05313cec86c7a5cef9075e86be3", + "independent_candidate_owners_retired7.py": "77a848729159e271ba64f403dfd59dddb13044b17b2950fa56700f442e2fe461", + "lean/Check.lean": "68966f329982188c49a37c51753271ebc1c0afd321195e4aa595562275912aaa", + "lean/MultitapeToolkit.lean": "e83c0c37263543ceb3ffa42c02ae99075de9c73a0e039ec7872dae1f24a42716", + "lean/MultitapeToolkit/ReplicaTailGain.lean": "c043cc6740a79b8a29d1519cb9e11c8e9bc52d6937f4317f630a28dce074e1d1", + "lean/MultitapeToolkit/SuperiorKappa.lean": "c366b3ee3123d24e87239ba00ebc32c102f19198080bbc5acd09b0e241d2a324", + "lean/MultitapeToolkit/TensorBlockNorm.lean": "50c3c874e950dc9d9b8ca1b71dae313f6bf56d2e0e073de770b7f9f4f862f138", + "lean/lake-manifest.json": "ba2084428ea075a408191fd72f30bddaf19923c5e6ebd55e2bbe7528d4afef90", + "lean/lakefile.toml": "7882ef23598228f705e8abbecea6a1674f72f1386d297c4d24c73b75c89e595d", + "lean/lean-toolchain": "8152090414016dd5dc871752f8ce4ecdbd604d9845758e9b9047cb80101280b5", + "lift_parent.py": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "portable_frontier_cold.py": "e2c54f4884e4db6e2791b98787c469e96b18a6b9620e5abf890b2cc7b27d255c", + "portable_prepare_native.py": "cb32e36f3e435652b7fab857c94e0dbb925b56ce7bb5daeecc223b0fc6993012", + "provenance/ADMISSION-SOURCES.json": "01551eebe209088bea9e0f49e2035f85178f18f39362b44a5c49385f05692f25", + "provenance/PREDECESSOR-T104-SHARPENED-PREFIX-RESERVE.json": "4200c97d1370a56c589ec2bae844aa23be91d4a604f471e9a95211a1273c2521", + "provenance/PREDECESSOR-T104-SHARPENED-PREFIX-REVIEW.json": "8325455d38742d804d961bb64bd2bec8f60a63e77d22bfb1df0a0d2468284a53", + "provenance/TI-BLOCK-FULL-STOCK-REVIEW.json": "55067ad4649dad534afb382b43b63f4647501e57e2079a593c529f0ab09814dd", + "provenance/TI-BLOCK-PREDECESSOR-NOTICES.json": "450d369d0f58df7df65cfa4bfdaf23a9b60c5627cb636e69719e8c4231a9bf36", + "provenance/TI-BLOCK-REVIEW.json": "9186f938e78f39d4ef4aded2d483b4c51aacc69982e67e9db492cf1c13dc12d5", + "reconstruct_replica.py": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "references/CURRENT-PINS.json": "ddebe7be9a0933ab39f55f864ce33e5d4ebda0ad3d26257e56b4cbabccfca892", + "references/CURRENT-PRIMARY-BODIES.json": "65a6aaf3ab744bbfb539596372e6d25a3c9a13d01db69a40e08bdcba638629bd", + "references/CURRENT-RECENT-TITLES.json": "42977a2acfeec4b6372ee2c2a5f4743d6dff101d25c2847b6ea7029a485b2ab2", + "references/FINAL-FRONTIER-SUPPLEMENT.json": "2707cc4ba9280b596b3fd2d2e853945db5af383141002722490a7e2aaa10a6f8", + "references/PINS.json": "eba325ade41aed492ab9462cf13387b7fe608525b0170c6357c5920de2190754", + "references/PR2767-OUTER-CLAIM.json": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "references/PR2802-CLAIM.json": "a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51", + "references/PR2824-CLAIM.json": "7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52", + "references/PREDECESSOR-T104-CLAIM.json": "f26209f7903557cf3dddd8e6d99b4b2b2f99bbd4b5eb0e6161150830e94b02d0", + "references/PREDECESSOR-T94-CLAIM.json": "7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52", + "references/RECENT-PRS.json": "c56be4b596c83fe1a8c3d13172f34db8b90c85807822835647bc75606a26e045", + "replay.py": "ff899fcb325139b9322e9ccbfc65508f153956c25ae25f51c257fe1a274c61f9", + "replica_parent.py": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4", + "requirements.txt": "d0bb9e22d31263ae22e6bb9379e644a5e5489b12d2d639172c4bee162afe658f", + "validation/BLOCKNORM-CONTROLS.json": "88774b2f55700abc44fc2d79d1249dae4dd9d99d7661065487f4517f5adef31a", + "validation/BLOCKNORM.json": "638ad26b89724644cad5e78c663e37481256d6aaf02f6d2e5f18caeab9bfcc3c", + "validation/CANONICAL.json": "04066299d410246465444ad4338cd2ff21267c2db6bceb92acd10c0c19348b9e", + "validation/COMPLETE.json": "362628567fad604cbf8da18357c2a956676477695ce600649a40f5989b5d372a", + "validation/KERNEL.json": "4240f4038dbab3666a48fbb1f2cb34615e9c0596fa4c7505260f3d950abb31d2", + "validation/MOMENT.json": "f014146aad2eca1938299340bd911d247d1ac27665475afe700821a9121f5900", + "validation/NATIVE.json": "9eceed24bcb417c9457731dee853332085b3342a5f9370e45ad32084ede1503a", + "validation/OWNERS.json": "1727d89af1167fe7f0011867f60f7dee63ef80cfadf198651b0f17e1822f70f2", + "validation/ROOT-ROUTE.json": "b2a513e9f89e6d1a7dbe4301549fc023e4fc4edc62c7147e36d84e8e721d53f2", + "vendor/frontier/.gitattributes": "12ab6f9af287290f2f2404907fdd114faa5a085fe9eae713294537ff6b45132e", + "vendor/frontier/CLAIM.json": "a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51", + "vendor/frontier/DERIVATIVE-CODE.patch": "36fe5e24ecf22be987360647de1167185ffb92603bebb1959a065e56524586e1", + "vendor/frontier/DERIVATIVE-OVERLAY.tar.gz": "12335359418a2d75ff62ada3f868497590e025d5b39f6ee01f1a50f23c9768af", + "vendor/frontier/DOWNLOAD-MANIFEST.json": "fae7e9161707d3627c7ba444543b1bdd0d736df57b8495ea112bb221a2693497", + "vendor/frontier/GENERATOR-PINS.json": "8823d9ad809cdd2e469f21ae1982a379f302bb9bf177cff069ef99a52163c286", + "vendor/frontier/INPUT-PINS.json": "c59957b3a312c643e8de6fa12c57adc0683ef29d8d74b051d0087a7c64232d21", + "vendor/frontier/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/frontier/NOTICE": "982ccd0ddf67b74a1d9d6dcb2684561a83b2f5de5039b3dfdd98f26cce6b8358", + "vendor/frontier/OVERLAY-PINS.json": "496f1daf28d46a0b7aafe5a8968a2078b7bc9c2fa29089d16092c2f5041813bb", + "vendor/frontier/PROFILE.json": "9d71407ded0b17496b0f94ca896355933a850dc6fc8456e39b0a1f72995b1406", + "vendor/frontier/PROOF.md": "6ecefda5d853e3ede1ee06aab08de24dfde960d98178a71844340ed86ae0d9b9", + "vendor/frontier/README.md": "8ea1568d186bdf5086aa2efff6c24fe6b34a6d4790393e763a4ddf683541df69", + "vendor/frontier/RETIRED5-CODE.patch": "c94370f5e40631012709f038762126c88678f45e441a201d9156a56d53524ec8", + "vendor/frontier/RETIRED7-CODE.patch": "5fe86a963cf0e68ca9a48704910be58d76b48d966c2d6026edbce785796a0fcf", + "vendor/frontier/REUSE-PINS.json": "c33bf92fccb63f4d9a3ff6f7e025ac831ad012dd92d236b0f046bc4b1c6a29b2", + "vendor/frontier/SOURCE-FILES.json": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "vendor/frontier/SOURCE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "vendor/frontier/SOURCES.json": "ede36d6b940094ea7f27e9a8f7ba4d320ca99b97843e9de03ef68c5c93306ed5", + "vendor/frontier/TASK.json": "c725b9fb1acbbff8c4d0a72e63a4e81e7b0fd12926d5ddb37d0fd4a52b3f2e55", + "vendor/frontier/VERIFY.json": "e32cfbc20fcd9e1ed43b920fcdc9eacc8106c1e35f3b3d33303a700582657ac4", + "vendor/frontier/composition.py": "f202f8ce9730b778c9ee1213d63d444d117df5ff7d47933037a924723a37e3f4", + "vendor/frontier/evidence/ADMISSION.json": "b85b5b339353ae2a1935afa2963fcde7db9f66b41f205ddd632210257a8be168", + "vendor/frontier/evidence/INDEPENDENT.json": "f9e4500e5cb1ab1b9e8189de6dfbcca8dd9f7e2ea1a9ffce6801d6530797c0d2", + "vendor/frontier/evidence/NATIVE-BASE.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "vendor/frontier/evidence/NATIVE-EXTRA.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "vendor/frontier/evidence/OWNERS.json": "4df2066f097e4b59edf7d7af0e7e234413b9d2a09de4302d02adb3869972f672", + "vendor/frontier/evidence/PACKING-CAP.json": "59deb044b1b46953cbfd2fcedd3026a901d4524d7d05c592b8e1420501f6e652", + "vendor/frontier/evidence/PR2733-CLAIM.json": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "vendor/frontier/evidence/PR2745-CLAIM.json": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3", + "vendor/frontier/evidence/PR2751-CLAIM.json": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438", + "vendor/frontier/evidence/PR2766-CLAIM.json": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8", + "vendor/frontier/evidence/PR2767-OUTER-CLAIM.json": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "vendor/frontier/evidence/PUBLIC-WRAPPER.json": "70acee53d90097edfa3e7c99ad68311f236bade5ee71a446bcc8935e9e7e3192", + "vendor/frontier/evidence/RELEASE.json": "5839b3b3448d67d7a936fe962298d7d77cb83ee489321343af7769166f5d0142", + "vendor/frontier/evidence/retired5/ADMISSION-RESULT.json": "e441d6bfef1554491087a5b4701a8b23b331af3b57f77a38f3de4a47d940a6bf", + "vendor/frontier/evidence/retired5/ADMISSION-STAGES.json": "be3bf7f8fb4208bdea8dae25a8db0beda8d31cd5ac8a61279b22928ededb58bb", + "vendor/frontier/evidence/retired5/CERT2751.json": "d2f63d1167e0e1811f8b2b62ee50353184ca0ed86ab2c0bc96bf37edccf1eeff", + "vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43base.json": "da173b7590da4717880098dd6cef3c597e4dffccd163b3c85b3b8fbf3d242f3e", + "vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43extra.json": "da173b7590da4717880098dd6cef3c597e4dffccd163b3c85b3b8fbf3d242f3e", + "vendor/frontier/evidence/retired5/FULL-REPLAY-RESULT.json": "5d884e943ba270223218cac39e10b4355cd217802232c8363a03f2d15bb77bdf", + "vendor/frontier/evidence/retired5/FULL-REPLAY-STAGES.json": "80ac023ea6c8e152d538f873855c3b917f1fb80fc34c9f2d4db19ee9cab76de8", + "vendor/frontier/evidence/retired5/GENERATE-LOG.txt": "18a234b13f2b7e7b98c59f1be8799fbfde2284a2a64a0eaf9be0aa53115ef5fa", + "vendor/frontier/evidence/retired5/HOOK-RESULT.json": "76b67d54df3a6da3bb7f6fe3402f11d2926cb48353bf068dc34eeb560784771a", + "vendor/frontier/evidence/retired5/NATIVE-RECEIPT.json": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "vendor/frontier/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt": "cf06397f5fdaf50f8e44af4ff64d6a97865b79d5bc86024ba7c6f653698a6d8e", + "vendor/frontier/evidence/retired5/RELEASE-RECEIPT.json": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "vendor/frontier/evidence/retired5/RELEASE-VERIFY-RESULT.json": "6a4d591c2c827a899cb9a3682ef3f05fd97fc58842e68ae9aead5d14d3f62654", + "vendor/frontier/evidence/retired5/RELEASE-VERIFY-STAGES.json": "ed04eb3d4ec175b3b211cef890376529c1e9dc3f69974269106dbff9e52bcde0", + "vendor/frontier/evidence/retired5/RUNTIME-PATCHES.json": "a20936449a1d23f79c8c040d47039e563d2bcdfc534d1c1de7d25d221a7f483c", + "vendor/frontier/evidence/retired7/ADMISSION-RESULT.json": "259c1a9da2ebfceb4b4cea2732b5a6d144cc85d7d8a92f4474d29ee3a5c75fc2", + "vendor/frontier/evidence/retired7/ADMISSION-STAGES.json": "f86a0c1ff418c3da14f573dbf900eae96657a33b4d3829c7c5da8036890c9f87", + "vendor/frontier/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json": "ede02c0657d73229aa8943046aeb6c72f8300719f95b6a2f770935173287dca9", + "vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43base.json": "1b52cc644573f2b39a66be799c90b82e59c2b25341bbdcfa8d4ef0baea0fdd60", + "vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43extra.json": "1b52cc644573f2b39a66be799c90b82e59c2b25341bbdcfa8d4ef0baea0fdd60", + "vendor/frontier/evidence/retired7/FULL-REPLAY-RESULT.json": "3b480daeb9f2e09eeefe787d99eef9143a90ac5136faf5f9285affc65e90030d", + "vendor/frontier/evidence/retired7/FULL-REPLAY-STAGES.json": "9498e69c1c927751b3dadad8bfd887f9afff107424f0987ece9df9c17e1f5412", + "vendor/frontier/evidence/retired7/HOOK-RESULT.json": "95d8169d828b0c3b7ccc02f205aa63bb33e54da95b7279c58775711ceb88df8e", + "vendor/frontier/evidence/retired7/NATIVE-RECEIPT.json": "baba1153f79b8de0f52273194f8fb86df7c65b51bafc9bac1504074f7c6cb982", + "vendor/frontier/evidence/retired7/NATIVE-STANDALONE.json": "49ee5ec3f791392555a6218e5f5cc80bf004b706ba697a298f9701ea8c4765a0", + "vendor/frontier/evidence/retired7/OWNER-CHECK.json": "328db5dd09f5b40762a5f3fd7fefb1b9c4ad05cecb7882474cfa3450177ba935", + "vendor/frontier/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt": "59dec80790bee9a132d92ec64db08e93ee000994ac4e0188da7b1829dac8ccab", + "vendor/frontier/evidence/retired7/REGISTERED-HOOK-LOG.txt": "16ec70f1c8191c18aa8f6422f972519b99df01002ffde5b12ac4febe0be22f46", + "vendor/frontier/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt": "d9977346de4ceb88d152ac8e892fdb65af572933aa967fd726a7620fa3e29074", + "vendor/frontier/evidence/retired7/RELEASE-RECEIPT.json": "8698b42e6239cffcd92ae4a87605451d799b7b751bcf4a432fd851a548ceff48", + "vendor/frontier/evidence/retired7/RELEASE-VERIFY-RESULT.json": "4eee4b247783eceb62c785385e5d6965241655e963eabad33ee64a26964fcd49", + "vendor/frontier/evidence/retired7/RELEASE-VERIFY-STAGES.json": "8278e1e93057f1f7e19b9c4058a249597a80c78b8dfa0e15bb6f206aefaf5f6e", + "vendor/frontier/evidence/retired7/RESEARCH-TESTS-LOG.txt": "e7eb21fea3fd1e55b60ea4f7013b4bc13db048043e733c5b1c09273cf1a43f63", + "vendor/frontier/evidence/retired7/RUNTIME-PATCHES.json": "f9cf016d89b318398a0737cb304f1f9a32098589b9fb3b89ab79bb10e3f9bbe5", + "vendor/frontier/evidence/retired7/STAGES7.json": "ab5fd9336ae23174cdee523d7c46a5eda201e04ce5391170d00963783a3d71c8", + "vendor/frontier/evidence/retired7/VERIFY-RESULT.json": "7f404f3d4638142ba3a77fc2a18d34d4926abcae528ce0ed1af0c4b4dad71a0a", + "vendor/frontier/exact_moment.py": "f170292f7983773d4f142afdac4677c1615fb7b781dbabf395200aea886dcade", + "vendor/frontier/full_replay.py": "3f7ff263775253f73a87abc43a76f39f23e8bc0ce433a562d17f2c0705b5a02b", + "vendor/frontier/generate.py": "24b90102b48ed9adf2621412fbff594b9e231041ca385258794881054d67f7a3", + "vendor/frontier/independent_local.py": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20", + "vendor/frontier/independent_owners.py": "219e16a7f35c5c9e9640760c28ad49a17b546c9f32bdf57dd76c30b5dd096aa6", + "vendor/frontier/inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11", + "vendor/frontier/inputs/FILL.json.gz": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "vendor/frontier/inputs/FILL2751.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "vendor/frontier/inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "vendor/frontier/inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "vendor/frontier/inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "vendor/frontier/inputs/POSITIVE2462-base.json.gz": "3506c84203f126900326ff4d22aaceda819734e5f96fa4622d43fbb78b946ece", + "vendor/frontier/inputs/POSITIVE2462-extra.json.gz": "ec7103c196b32de7af79a6f43952cbe998c085a00f1a8e740f5556c774589099", + "vendor/frontier/inputs/PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "vendor/frontier/inputs/PROVIDERS2751.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "vendor/frontier/inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06", + "vendor/frontier/inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "vendor/frontier/inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7", + "vendor/frontier/inputs/WORD-base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "vendor/frontier/inputs/WORD-extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "vendor/frontier/inputs/WORD2751-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "vendor/frontier/inputs/WORD2751-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "vendor/frontier/inputs/alias5_43base.json": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "vendor/frontier/inputs/alias5_43extra.json": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "vendor/frontier/inputs/alias7_43base.json": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "vendor/frontier/inputs/alias7_43extra.json": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "vendor/frontier/inputs/hostmove2_43base.json": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "vendor/frontier/inputs/hostmove2_43extra.json": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "vendor/frontier/inputs/refit5_43base.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "vendor/frontier/inputs/refit5_43extra.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "vendor/frontier/inputs/refit5c_43base.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "vendor/frontier/inputs/refit5c_43extra.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "vendor/frontier/inputs/refit7_43base.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "vendor/frontier/inputs/refit7_43extra.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "vendor/frontier/inputs/refit7c_43base.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "vendor/frontier/inputs/refit7c_43extra.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "vendor/frontier/joint_engine.py": "1411acf2903cad468e3618eefec7032ea04232af740134416d42d74aa1ea4945", + "vendor/frontier/packing_cap.py": "b292694b0862db3393ce02e1e07a922ded6f746b18ab8faca69eb93ed7a2e522", + "vendor/frontier/requirements.txt": "f95b588f39c53b58fa36c3b65b65cc770e3a051a6a12555a9188808e771d1d13", + "vendor/frontier/retired7_controls.py": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904", + "vendor/frontier/test_integrity.py": "67f17c8df3614d582ac2c4d272ceba90d47116af4c6989a1a2e2b5f13e7bc2ee", + "vendor/frontier/vendor/GENERATOR-NOTICE.txt": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "vendor/frontier/vendor/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/frontier/vendor/UPSTREAM-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "vendor/frontier/vendor/UPSTREAM-VENDOR-SOURCES.json": "592a98f6a3bd7fbd0063d90c989e30c5cd534220797b5b0beb0388e1f8d498ec", + "vendor/frontier/vendor/audit_local_pr2679.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "vendor/frontier/vendor/ceiling.py": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "vendor/frontier/vendor/generate_words.py": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "vendor/frontier/vendor/gf_chart.py": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "vendor/frontier/vendor/target_transport.py": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "vendor/frontier/vendor/word_patch_pr2679.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "vendor/frontier/verify.py": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "vendor/frontier/verify_retired7.py": "1d3754ccf91029aa239affe0233de4821d960f654514ceeb3445d464933aba0f", + "vendor/frontier/workflow/admit.py": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "verify.py": "aabd12f5edfe846891e4dbe3e4d6a21617c6240bc06d89b0a1ef5f9f34df209b" +} diff --git a/research/tensor-block-kappa/MODULES.json b/research/tensor-block-kappa/MODULES.json new file mode 100644 index 0000000000..7bf2d366f4 --- /dev/null +++ b/research/tensor-block-kappa/MODULES.json @@ -0,0 +1,8 @@ +{ + "lean_version": "4.34.1", + "modules": [ + "MultitapeToolkit.ReplicaTailGain", + "MultitapeToolkit.SuperiorKappa", + "MultitapeToolkit.TensorBlockNorm" + ] +} diff --git a/research/tensor-block-kappa/PARENT-LIFT.md b/research/tensor-block-kappa/PARENT-LIFT.md new file mode 100644 index 0000000000..56ac2a2162 --- /dev/null +++ b/research/tensor-block-kappa/PARENT-LIFT.md @@ -0,0 +1,19 @@ +# Explicit arbitrary-replica dedicated parent extension + +This is a construction of the source envelope needed for a changed-T candidate. It is not an admitted improved multiplier or a new native phase proof. Full literal hosted-owner, finite invoice, analytic and outer admission remain necessary. + +Fix any positive T and any ordered partition q_0+...+q_(G-1)=T with 1<=q_g<=8. Number replicas consecutively within these groups; write r=b_g+lane, 0<=lane0` for `0.99 <= p < 1`; hence the complete +normalized moment `R(T,p)/(896*T*73^p)` strictly decreases as positive T grows. +The positive finite residue remains paid. This inequality does not construct +owners for arbitrary T. The application needs the actual T114 literal fill, +which has 418608 complete helper roles and proposed profile +`{1:2470608,2:664848,3:285126,4:131328,5:41894,8:8208,32:1,48:40914}`. +Its rank mass is 7420032 and deficit 36480. + +The proposed adjacent root bracket is +`[0.001717795274221416686578, 0.001717795274221416686579]`. +The proposed target is its lower endpoint minus `10^-46` minus `10^-70`. +Compared with the full admitted T104 target, the proposed exact gain is +`51604828943380/10^24`. Directed rational moment checks and the complete ordinary +and modern outer release must independently admit this target. No gain is +claimed from a component saving or a rounded PR title. + +The Mathlib proof covers these explicit inequalities, not the full inherited +all-size multiplication pipeline. Final transitive-axiom checks and adversarial +fixtures are separate from source-only indexing and historical artifacts. diff --git a/research/tensor-block-kappa/README.md b/research/tensor-block-kappa/README.md new file mode 100644 index 0000000000..3c1609d8d3 --- /dev/null +++ b/research/tensor-block-kappa/README.md @@ -0,0 +1,28 @@ +# Tensor block norm accounting: T114 + +Complete conditional finite release passed. The exact new κ is `0.0017177952742214166865779999999999999999999998999999999999999999999999`. It exceeds the previously delivered T104 value by `2580241447169/50000000000000000000000` (5.160482894338e-11). [CLAIM.json](CLAIM.json) gives exact fractions and scope. + +The tensor route is concrete: whole-family tensor-isomorphism adapters preserve completed helper norms, and exact native replay cancels all borrowed dirty responses. Each physical replica has nine active calls and nine bridges. Summed block energy therefore grows by at most 2^36, independently of the total call count. Arbitrarily correlated dirty inputs are permitted. This applies the credited earlier tensor normalization; it does not claim a new general tensor-isomorphism algorithm. + +The conservative bound includes the entire group-indexed stock: 1323 conversion bits, 37 retained input bits, 18 block-depth bits, one partial-cover bit and four arithmetic-margin bits. The measured local prefix is 70, giving 1453 total bits; the retained local reserve 128 gives 1511<2048. Every call and bridge remains charged. The row is 19547<20161. + +The literal allocation has 114 replicas, 1026 calls, 418608 helper roles, 102144 live families and 102634 physical families. Native providers and all charged children are unchanged. Fresh complete release checks cover owners, emitted controller, invoice, ordinary bootstrap and outer arithmetic. All four unchanged native chains and the retained parent were authenticated reuse from earlier fresh checks. + +Run the standard-library checks: + + python -B verify.py + python -B check_candidate.py --out /absolute/fresh-independent + +For a full replay, install requirements.txt separately, then run: + + python -B portable_frontier_cold.py --work /absolute/fresh-cold --jobs 4 + +The default regenerates native chains. Explicit reuse is separately labelled and fully hash-bound. From the separately installed pinned Lean 4.34.1/Mathlib environment: + + lake env python -B ../replay.py --out /absolute/fresh-kernel --cache-project . + +The fresh audit covers 67 defining-module declarations and 60 theorems, including generated helpers. Only propext, Classical.choice and Quot.sound occur; four actual ownership/axiom fixtures passed. The Lean block-energy and shear inequalities are universal sufficient results; actual endpoint/owner premises are separately source-bound finite checks. + +Inherited all-size compiler, source-access, hosting, precision/tape, exact-recovery, ordinary-recursion, bit-supplier and analytic-transfer hypotheses remain. This is a conditional constant improvement. See [PROOF.md](PROOF.md), [CREDITS.md](CREDITS.md), and [FRONTIER.md](FRONTIER.md) for proof scope, overlap and relevant PR attribution. + +Apache-2.0. Preserve all upstream notices. Prepared with substantial OpenAI Codex assistance: one primary and four distinct workers, at most three workers concurrently. No Jev was used. diff --git a/research/tensor-block-kappa/TASK.json b/research/tensor-block-kappa/TASK.json new file mode 100644 index 0000000000..8bec81927e --- /dev/null +++ b/research/tensor-block-kappa/TASK.json @@ -0,0 +1,9 @@ +{ + "date": "2026-10-15", + "purpose": "Improve the actual binding conditional complex supplier kappa, with a concrete complete certificate and honest pending-frontier comparison.", + "route": "Larger replica geometry retaining one explicitly charged finite residue tail.", + "team": {"primary": 1, "parallel_workers": 3, "tool_concurrency_limit": 4}, + "search": "Compiled OR-Tools CP-SAT; accepted output requires separate literal reconstruction and full admission. GPU assistance was not used.", + "formal_scope": "Universal Mathlib power-cost inequalities. Physical realization and all-size multiplication implications are separate certificate/contracts.", + "publication": "Source-only standalone package; no public posting or maintainer selected-result change." +} diff --git a/research/tensor-block-kappa/VERIFY.json b/research/tensor-block-kappa/VERIFY.json new file mode 100644 index 0000000000..1dd34cdebe --- /dev/null +++ b/research/tensor-block-kappa/VERIFY.json @@ -0,0 +1,27 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Exact source inventory and11 audit-report corruption controls.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/check_candidate.py" + ], + "checks": "Independent literal owners, seven geometry faults, adjacent directed-rational moment bracket, five pricing faults and exact full published PR2824/T94 comparison. Fresh external output.", + "timeout_seconds": 600 + } + ], + "inputs": [], + "python": "3.13", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/tensor-block-kappa/admit_frontier_replica.py b/research/tensor-block-kappa/admit_frontier_replica.py new file mode 100644 index 0000000000..a05bc9c24c --- /dev/null +++ b/research/tensor-block-kappa/admit_frontier_replica.py @@ -0,0 +1,393 @@ +#!/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. + +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 = { + '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 = { + '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='pr2802') + ap.add_argument('--comparison-profile', choices=sorted(COMPARISONS), default='pr2802') + 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/tensor-block-kappa/blocknorm_certificate.py b/research/tensor-block-kappa/blocknorm_certificate.py new file mode 100644 index 0000000000..b8656727d3 --- /dev/null +++ b/research/tensor-block-kappa/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=1,'positive reduced logarithm');e=0;y=x + while y>=2:y/=2;e+=1 + def core(z): + z=(z-1)/(z+1);need(0<=z<=Q(1,3),'atanh range');lo=2*sum((z**(2*j+1)/(2*j+1)for j in range(36)),Q(0));return lo,lo+2*z**73/(73*(1-z*z)) + a,b=core(y);c,d=core(Q(2));return a+e*c,b+e*d +def exponential(x): + need(0<=x0 for r,n in hist.items()),'positive paid profile') + # Binary floats nominate only a wide initial rational grid interval. + lo,hi=0.0,0.002 + for _ in range(60): + q=(lo+hi)/2;v=sum(n*r*math.exp(q*math.log(73/r))for r,n in hist.items())/(73*live) + if v<1:lo=q + else:hi=q + G=10**24;unit=10**12;mid=int(((lo+hi)/2)*10**12)*unit;L=mid-unit;H=mid+2*unit + while moment(hist,Q(L,G),live)[1]>=1:L-=unit + while moment(hist,Q(H,G),live)[0]<=1:H+=unit + while H-L>1: + m=(L+H)//2;ml,mh=moment(hist,Q(m,G),live) + if mh<1:L=m + elif ml>1:H=m + else:raise ValueError('enclosure too wide for adjacent rational bracket') + lower,upper=Q(L,G),Q(H,G);ll,lh=moment(hist,lower,live);ul,uh=moment(hist,upper,live);need(lh<1previous,'strict gain over full exact comparison rational') + rejected=[] + def reject(name,fn,reason): + try:fn() + except ValueError as e:need(str(e)==reason,'wrong control reason '+name);rejected.append(dict(name=name,reason=reason)) + else:raise ValueError('accepted control '+name) + def accepts(h,q,W=live): + need(W==live,'source-bound normalization');need(moment(h,q,W)[1]<1,'strict moment admission') + def bracket(x,y):need(x1,'old actual profile fails improved target');rejected.append(dict(name='unchanged_T74_profile_at_improved_target',reason='exact lower moment above one')) + need(logarithm(Q(1))==(0,0)and exponential(Q(0))==(1,1),'exact elementary controls');l2=logarithm(Q(2));need(logarithm(Q(4))==(2*l2[0],2*l2[1]),'exact logarithm scaling') + need(before=={str(p.resolve()):sha(p)for p in files}and sha(basepath)==basehash,'input drift') + result=dict(status='PASS_INDEPENDENT_EXACT_CANDIDATE_MOMENT',replicas=T,live=live,profile=hist,complex_lower=str(lower),complex_upper=str(upper),proposed_outer_target=str(target),strictly_above_full_comparison=True,best_claim_sha256=sha(a.best_claim),best_kappa_rational=best['kappa'],lower_moment_minus_one=display(ll-1,lh-1),upper_moment_minus_one=display(ul-1,uh-1),target_gain_over_comparison=display(target-previous,target-previous),controls=rejected,input_sha256={'owner_receipt':sha(a.owner_receipt),'best_claim':sha(a.best_claim)},baseline_profile_sha256=basehash,scope='Exact finite moment admission and comparison only; proposed outer target still requires all actual outer/native/global checks.') + write_receipt(a.out,result);print(json.dumps({k:result[k]for k in['status','replicas','live','complex_lower','complex_upper','proposed_outer_target','strictly_above_full_comparison']}),flush=True) +if __name__=='__main__':main() diff --git a/research/tensor-block-kappa/independent_candidate_owners_retired7.py b/research/tensor-block-kappa/independent_candidate_owners_retired7.py new file mode 100644 index 0000000000..16013201b1 --- /dev/null +++ b/research/tensor-block-kappa/independent_candidate_owners_retired7.py @@ -0,0 +1,111 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Independent integer-time and mask check of the actual parameterized-replica owner allocation with PR2802 retired7 providers. + +Chronology/mask method derives from Tekalign's PR2751 independent_owners.py; +Marius-Paul Dumitrean's PR2802 retired7 native construction and the retained +provider frame checker keep their +upstream attribution. No solver, producer, emitter or floating arithmetic is +imported. This checks finite geometry, not global native/outer admission. +""" +from pathlib import Path +from collections import Counter,defaultdict +import argparse,hashlib,gzip,json,sys,types +sys.dont_write_bytecode=True +def need(v,msg): + if not v:raise ValueError(msg) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p): + b=Path(p).read_bytes();return json.loads(gzip.decompress(b)if str(p).endswith('.gz')else b) +def inputs(PROVIDER): + provider_pins={'inputs/PLAN.json.gz':'afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa','inputs/GLOBAL-TEMPLATE.json.gz':'21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e','independent_local.py':'ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20','inputs/PROVIDERS.json':'391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4','inputs/WORD-base.json.gz':'dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66','inputs/WORD-extra.json.gz':'6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7'} + hashes={} + for n,pin in provider_pins.items(): + p=PROVIDER/n;need(sha(p)==pin,'pinned PR2802 provider source '+n);hashes[str(p)]=pin + L=types.ModuleType('retained_independent_frames');exec(compile((PROVIDER/'independent_local.py').read_bytes(),'pinned_PR2802_independent_local.py','exec'),L.__dict__);providers=read(PROVIDER/'inputs/PROVIDERS.json') + for tag,pid in [('base','gauge44'),('extra','extra')]: + word=read(PROVIDER/f'inputs/WORD-{tag}.json.gz');report,start,ends=L.check_frames(word);L.check_cleanup(word);L.algebra(word) + widths=[L.dm(ends[k])-L.dm(start[k])for k in sorted(start)if k>=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< + m == `MultitapeToolkit || (`MultitapeToolkit).isPrefixOf m) + let owns := fun name => + match env.getModuleIdxFor? name with + | none => false + | some index => ownedModules.contains (env.allImportedModuleNames[index.toNat]!) + let names := (env.constants.toList.filter (fun p => owns p.1)).map (fun p => p.1) + let names := names.toArray.qsort (fun a b => decide (a.toString < b.toString)) + unless names.size > 0 do + throwError "Empty toolkit declaration audit" + let permitted : Array Name := #[`propext, `Classical.choice, `Quot.sound] + let mut rows : Array Json := #[] + let mut theoremCount : Nat := 0 + for name in names do + let info ← getConstInfo name + let kind := match info with + | .thmInfo _ => "theorem" + | .defnInfo _ => "definition" + | .opaqueInfo _ => "opaque" + | .axiomInfo _ => "axiom" + | _ => "other" + if kind == "axiom" then + throwError "Toolkit declares an axiom: {name}" + if kind == "theorem" then theoremCount := theoremCount + 1 + let axioms ← collectAxioms name + for ax in axioms do + unless permitted.contains ax do + throwError "{name} depends on forbidden axiom {ax}" + let some index := env.getModuleIdxFor? name | throwError "Missing defining module: {name}" + let owner := env.allImportedModuleNames[index.toNat]! + rows := rows.push (Json.mkObj [ + ("name", toJson name.toString), ("module", toJson owner.toString), + ("kind", toJson kind), ("axioms", toJson (axioms.map Name.toString))]) + unless theoremCount > 0 do + throwError "No theorem reports in toolkit audit" + let report := Json.mkObj [ + ("modules", toJson (ownedModules.map Name.toString)), + ("declaration_names", toJson (names.map Name.toString)), ("rows", Json.arr rows)] + if let some path ← liftIO (IO.getEnv "MULTITAPE_TOOLKIT_AUDIT_PATH") then + liftIO (IO.FS.writeFile path report.compress) + logInfo m!"PASS_COMPLETE_MODULE_AXIOM_AUDIT: {names.size} declarations, {theoremCount} theorems, standard axioms only" + +def main : IO Unit := + IO.println "All toolkit modules and all their declarations passed the compile-time kernel/axiom audit." + diff --git a/research/tensor-block-kappa/lean/MultitapeToolkit.lean b/research/tensor-block-kappa/lean/MultitapeToolkit.lean new file mode 100644 index 0000000000..00486e78a6 --- /dev/null +++ b/research/tensor-block-kappa/lean/MultitapeToolkit.lean @@ -0,0 +1,3 @@ +import MultitapeToolkit.ReplicaTailGain +import MultitapeToolkit.SuperiorKappa +import MultitapeToolkit.TensorBlockNorm diff --git a/research/tensor-block-kappa/lean/MultitapeToolkit/ReplicaTailGain.lean b/research/tensor-block-kappa/lean/MultitapeToolkit/ReplicaTailGain.lean new file mode 100644 index 0000000000..8aff21db8c --- /dev/null +++ b/research/tensor-block-kappa/lean/MultitapeToolkit/ReplicaTailGain.lean @@ -0,0 +1,215 @@ +import Mathlib.Analysis.Complex.ExponentialBounds +import Mathlib.Tactic +set_option autoImplicit false +namespace MultitapeToolkit.ReplicaTailGain + +lemma rpow_one_sub (r t : ℝ) (hr : 0 < r) : + r ^ (1-t) = r * Real.exp (-t * Real.log r) := by + rw [Real.rpow_def_of_pos hr] + rw [show Real.log r * (1-t) = Real.log r + (-t * Real.log r) by ring, + Real.exp_add,Real.exp_log hr] + +lemma rpow_one_sub_lower (r t : ℝ) (hr : 0 < r) : + r * (1-t*Real.log r) ≤ r ^ (1-t) := by + rw [rpow_one_sub r t hr] + apply mul_le_mul_of_nonneg_left _ hr.le + linarith [Real.add_one_le_exp (-t*Real.log r)] + +lemma rpow_one_sub_upper (r t : ℝ) (hr : 0 < r) + (ht : 0 ≤ t) (htop : t ≤ 1/100) (hl : 0 ≤ Real.log r) (hu : Real.log r ≤ 4) : + r ^ (1-t) ≤ r*(1-t*Real.log r+t^2*(Real.log r)^2) := by + rw [rpow_one_sub r t hr] + apply mul_le_mul_of_nonneg_left _ hr.le + have hx : |-t*Real.log r| ≤ 1 := by + rw [abs_of_nonpos (by nlinarith : -t*Real.log r ≤ 0)] + nlinarith + have h := (abs_le.mp (Real.abs_exp_sub_one_sub_id_le hx)).2 + nlinarith + +lemma log_32 : Real.log 32 = 5*Real.log 2 := by + rw [show (32:ℝ) = 2^5 by norm_num,Real.log_pow] + norm_num + +lemma log_48 : Real.log 48 = 4*Real.log 2+Real.log 3 := by + rw [show (48:ℝ) = 2^4*3 by norm_num, + Real.log_mul (by norm_num : (2:ℝ)^4 ≠ 0) (by norm_num : (3:ℝ) ≠ 0),Real.log_pow] + norm_num + +/-- Strictly positive paid cost of the single residue tail in the actual +74-replica allocation, throughout the exponent interval used by the frontier. +This proves a power-cost fact; physical realization of a new allocation remains +an independent literal certificate obligation. -/ +theorem tail_power_positive (p : ℝ) (hp : 99/100 ≤ p) (hp1 : p < 1) : + 0 < 3*(3:ℝ)^p - 5*(5:ℝ)^p + 5*(32:ℝ)^p - 3*(48:ℝ)^p := by + let t := 1-p + have ht : 0 < t := by dsimp [t]; linarith + have htt : t ≤ 1/100 := by dsimp [t]; linarith + have hpt : p=1-t := by dsimp [t]; ring + have l2 : Real.log 2 ≤ 7/10 := by linarith [Real.log_two_lt_d9] + have l3 : 109/100 ≤ Real.log 3 := by linarith [Real.log_three_gt_d9] + have l3u : Real.log 3 ≤ 11/10 := by linarith [Real.log_three_lt_d9] + have l5 : 8/5 ≤ Real.log 5 := by linarith [Real.log_five_gt_d9] + have l5u : Real.log 5 ≤ 2 := by linarith [Real.log_five_lt_d9] + have l5z : 0 ≤ Real.log 5 := Real.log_nonneg (by norm_num) + have l48z : 0 ≤ Real.log 48 := Real.log_nonneg (by norm_num) + have l48u : Real.log 48 ≤ 4 := by rw [log_48]; linarith + have h3 := rpow_one_sub_lower 3 t (by norm_num) + have h32 := rpow_one_sub_lower 32 t (by norm_num) + have h5 := rpow_one_sub_upper 5 t (by norm_num) ht.le htt l5z (by linarith) + have h48 := rpow_one_sub_upper 48 t (by norm_num) ht.le htt l48z l48u + rw [←hpt] at h3 h32 h5 h48 + have s5 : (Real.log 5)^2 ≤ 4 := by nlinarith + have s48 : (Real.log 48)^2 ≤ 16 := by nlinarith + have e5 : t^2*(Real.log 5)^2 ≤ 4*t^2 := by nlinarith [mul_le_mul_of_nonneg_left s5 (sq_nonneg t)] + have e48 : t^2*(Real.log 48)^2 ≤ 16*t^2 := by nlinarith [mul_le_mul_of_nonneg_left s48 (sq_nonneg t)] + have ha : 30 ≤ 25*Real.log 5+144*Real.log 48-9*Real.log 3-160*Real.log 32 := by + rw [log_48,log_32] + linarith + have hat := mul_nonneg ht.le (sub_nonneg.mpr ha) + have hpos : 0 < 30*t-2404*t^2 := by + nlinarith [mul_nonneg ht.le (sub_nonneg.mpr htt)] + nlinarith + + +/-- Full paid child sum in the actual 74-replica predecessor. -/ +noncomputable def predecessorPower (p : ℝ) : ℝ := + 1591740 + 430902*(2:ℝ)^p + 204396*(3:ℝ)^p + 79920*(4:ℝ)^p + + 22532*(5:ℝ)^p + 5328*(8:ℝ)^p + (32:ℝ)^p + 26558*(48:ℝ)^p + +/-- Proposed complete periodic profile, for ten replicas. Physical ownership +is checked independently; this definition does not assume its realizability. -/ +noncomputable def tenReplicaPower (p : ℝ) : ℝ := + 215100 + 58230*(2:ℝ)^p + 27621*(3:ℝ)^p + 10800*(4:ℝ)^p + + 3045*(5:ℝ)^p + 720*(8:ℝ)^p + 3589*(48:ℝ)^p + +/-- Exact amortized invoice difference, including the predecessor's rank32 tail. -/ +theorem profile_difference (p : ℝ) : + predecessorPower p / 74 - tenReplicaPower p / 10 = + (3*(3:ℝ)^p-5*(5:ℝ)^p+5*(32:ℝ)^p-3*(48:ℝ)^p) / 370 := by + unfold predecessorPower tenReplicaPower + ring + +/-- The entire periodic paid profile strictly improves the normalized native +moment throughout the frontier exponent interval, for every positive number +of ten-replica blocks. No hosting or all-size implication is asserted here. -/ +theorem periodic_moment_strict (p : ℝ) (hp : 99/100 ≤ p) (hp1 : p < 1) + (k : ℕ) (hk : 0 < k) : + ((k:ℝ)*tenReplicaPower p) / ((8960*(k:ℝ))*(73:ℝ)^p) < + predecessorPower p / (66304*(73:ℝ)^p) := by + have hkR : (0:ℝ) simp + | succ t ih => + calc + energy (t+1) i ≤ (4:Real)^(cost t i) * energy t i := hstep t i + _ ≤ (4:Real)^(cost t i) * ((4:Real)^(∑ s ∈ Finset.range t, cost s i) * energy 0 i) := + mul_le_mul_of_nonneg_left ih (by positivity) + _ = (4:Real)^(∑ s ∈ Finset.range (t+1), cost s i) * energy 0 i := by + rw [Finset.sum_range_succ, pow_add] + ring + +/-- A direct-sum energy bound uniform in the number of blocks. In particular, +unitary actions on donor blocks cost zero even with correlated initial data. -/ +theorem total_energy_bound {I : Type*} [Fintype I] + (energy : Nat → I → Real) (cost : Nat → I → Nat) + (hinit : ∀ i, 0 ≤ energy 0 i) + (hstep : ∀ t i, energy (t+1) i ≤ (4:Real)^(cost t i) * energy t i) + (t depth : Nat) + (hdepth : ∀ i, (∑ s ∈ Finset.range t, cost s i) ≤ depth) : + (∑ i, energy t i) ≤ (4:Real)^depth * ∑ i, energy 0 i := by + calc + (∑ i, energy t i) ≤ ∑ i, (4:Real)^depth * energy 0 i := by + apply Finset.sum_le_sum + intro i hi + exact (block_energy_prefix energy cost hstep t i).trans + (mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (by norm_num) (hdepth i)) (hinit i)) + _ = (4:Real)^depth * ∑ i, energy 0 i := by rw [Finset.mul_sum] + +/-- Eighteen active block steps give the same squared-norm multiplier for any +number of replicas; all other completed actions must be block isometries. -/ +theorem eighteen_step_energy_bound {I : Type*} [Fintype I] + (energy : Nat → I → Real) (cost : Nat → I → Nat) + (hinit : ∀ i, 0 ≤ energy 0 i) + (hstep : ∀ t i, energy (t+1) i ≤ (4:Real)^(cost t i) * energy t i) + (t : Nat) (hdepth : ∀ i, (∑ s ∈ Finset.range t, cost s i) ≤ 18) : + (∑ i, energy t i) ≤ (2:Real)^36 * ∑ i, energy 0 i := by + convert total_energy_bound energy cost hinit hstep t 18 hdepth using 1 <;> norm_num + +/-- Numeric precision envelope after the topology and local-prefix checks. +The strict slack permits a conservative extra scratch bit. -/ +theorem hosted_prefix_reserve : + (70 + 37 + 18 + 1330 + 1 + 4 : Nat) < 2048 ∧ + (128 + 37 + 18 + 1330 + 1 + 4 : Nat) < 2048 := by + norm_num + +/-- A unit-coefficient shear costs at most a factor two in Hilbert norm, +expressed here through norms of the two summands. -/ +theorem shear_energy_bound {V : Type*} [SeminormedAddCommGroup V] (x y : V) : + ‖x+y‖^2 + ‖y‖^2 ≤ 4 * (‖x‖^2 + ‖y‖^2) := by + have h := norm_add_le x y + have hx := norm_nonneg x + have hy := norm_nonneg y + have hz := norm_nonneg (x+y) + have hs : ‖x+y‖^2 ≤ (‖x‖+‖y‖)^2 := by nlinarith + nlinarith [sq_nonneg (‖x‖-‖y‖)] + +end MultitapeToolkit.TensorBlockNorm diff --git a/research/tensor-block-kappa/lean/lake-manifest.json b/research/tensor-block-kappa/lean/lake-manifest.json new file mode 100644 index 0000000000..508eee4546 --- /dev/null +++ b/research/tensor-block-kappa/lean/lake-manifest.json @@ -0,0 +1,97 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": + [{"url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, + "scope": "", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean"}, + {"url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml"}, + {"url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml"}], + "name": "multitape-proof-toolkit", + "lakeDir": ".lake", + "fixedToolchain": false} + diff --git a/research/tensor-block-kappa/lean/lakefile.toml b/research/tensor-block-kappa/lean/lakefile.toml new file mode 100644 index 0000000000..16fac0a5aa --- /dev/null +++ b/research/tensor-block-kappa/lean/lakefile.toml @@ -0,0 +1,15 @@ +name = "replica-tail-gain" +version = "0.1.0" +defaultTargets = ["MultitapeToolkit", "multitape-toolkit-check"] + +[[require]] +name = "mathlib" +git = "https://github.com/leanprover-community/mathlib4.git" +rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + +[[lean_lib]] +name = "MultitapeToolkit" + +[[lean_exe]] +name = "multitape-toolkit-check" +root = "Check" diff --git a/research/tensor-block-kappa/lean/lean-toolchain b/research/tensor-block-kappa/lean/lean-toolchain new file mode 100644 index 0000000000..105359a4bc --- /dev/null +++ b/research/tensor-block-kappa/lean/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/research/tensor-block-kappa/lift_parent.py b/research/tensor-block-kappa/lift_parent.py new file mode 100644 index 0000000000..fc0375d424 --- /dev/null +++ b/research/tensor-block-kappa/lift_parent.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Construct a literal arbitrary-T source parent, PLAN and SPEC from exact owners. + +CLI: --package IMMUTABLE_SOURCE --owners RECONSTRUCTOR_OUTPUT --out FRESH_DIR. +Source lineage and arbitrary-group argument are in replica_parent.py / PARENT-LIFT.md. +This adapter mutates neither the source package nor owner input directory. +""" +import argparse, ast, collections, copy, importlib.util, json, sys +from pathlib import Path +sys.dont_write_bytecode=True +import replica_parent as P +assert __debug__, 'Assertions required' + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--package',type=Path,required=True);ap.add_argument('--owners',type=Path,required=True);ap.add_argument('--out',type=Path,required=True) + a=ap.parse_args();base=a.package.resolve();owners=a.owners.resolve();out=a.out.resolve() + P.require(not out.exists(),'fresh output required') + source_names=['inputs/PLAN.json','inputs/SPEC.json','inputs/GLOBAL-TEMPLATE.json.gz','new/BORROW-PROVIDERS.json','vendor/build_parent.py'] + input_names=['ORDER.json','OWNERS.json.gz','DISPATCH.json','PROFILE.json','RESULT.json'] + input_hash={str(base/n):P.sha(base/n)for n in source_names}|{str(owners/n):P.sha(owners/n)for n in input_names} + P.SOURCE=base/'inputs/GLOBAL-TEMPLATE.json.gz' + plan=P.read(base/'inputs/PLAN.json');spec=P.read(base/'inputs/SPEC.json');providers=P.read(base/'new/BORROW-PROVIDERS.json') + order=P.read(owners/'ORDER.json');dispatch_rows=P.read(owners/'DISPATCH.json');roles=P.read(owners/'OWNERS.json.gz');profile=P.read(owners/'PROFILE.json') + T=1+max(r for st,r in order);P.require(T>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/tensor-block-kappa/portable_frontier_cold.py b/research/tensor-block-kappa/portable_frontier_cold.py new file mode 100644 index 0000000000..a78ca63173 --- /dev/null +++ b/research/tensor-block-kappa/portable_frontier_cold.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Portable T114 block-norm replay: four fresh native chains by default. + +The pinned native preparer authenticates original491 source plus exact overlay506, +runs four native chains and the retained-parent check, then the admission driver +checks the actual T114 fill, required block-norm certificate and complete release. +The final exact target must also beat the complete delivered T104 rational; +the inherited exact PR2802 source/comparison pins remain enforced. +Explicit retained-only reuse and completed frontier-baseline reuse are separately +labelled. --prepare-only checks source preparation without issuing admission. +""" +import argparse, gzip, hashlib, json, os, platform, subprocess, sys, time +from fractions import Fraction +from pathlib import Path, PurePosixPath + +HERE=Path(__file__).resolve().parent +FRONTIER_HEAD='17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd' +BASELINE_PINS_SHA='fae7e9161707d3627c7ba444543b1bdd0d736df57b8495ea112bb221a2693497' +SOURCE_SHA='9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' +COMPARISON_SHA='a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51' +EXPECTED_REPLICAS=114 +EXPECTED_T114_KAPPA=Fraction('0.001717795274221416686578')-Fraction(1,10**46)-Fraction(1,10**70) +PREDECESSOR_T104_KAPPA=Fraction('0.001717795222616587743198')-Fraction(1,10**46)-Fraction(1,10**70) +COLD_STAGES={'literal-review','native-base','native-extra','native-retained-base','native-retained-extra','retained-parent','complete-admission'} +LF_ADAPTER=r'''"""Task-scoped Windows LF compatibility for authenticated generated source text. +No validation predicates or immutable source bytes are changed. +""" +from pathlib import Path +_original_write_text=Path.write_text + +def _write_text_lf(self,data,encoding=None,errors=None,newline=None): + return _original_write_text(self,data,encoding=encoding,errors=errors,newline='\n' if newline is None else newline) +Path.write_text=_write_text_lf +''' + +def need(ok,why): + if not ok:raise RuntimeError(why) +def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest() +def read(p): + p=Path(p);b=p.read_bytes();return json.loads(gzip.decompress(b)if p.suffix=='.gz'else b) +def tree(root,exclude=()): + result={} + for p in sorted(root.rglob('*')): + need(not p.is_symlink(),'unbound symlink: '+str(p)) + if p.is_file()and p.relative_to(root).as_posix()not in exclude:result[p.relative_to(root).as_posix()]=sha(p) + return result +def write(p,x): + lock=p.with_name(p.name+'.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 + p.write_text(json.dumps(x,sort_keys=True,indent=2)+'\n',encoding='utf-8',newline='\n') + finally: + if fd is not None:os.close(fd) + lock.unlink() + +def authenticate_vendor(directory,pins): + need(sha(pins)==BASELINE_PINS_SHA,'exact baseline Git/SHA inventory pin') + inventory=read(pins);need(inventory['head']==FRONTIER_HEAD,'exact current frontier head');records=inventory['files'];need(len(records)==124,'exact 124 frontier files') + expected={} + for r in records: + name=r['path'];parts=PurePosixPath(name) + need(name and not parts.is_absolute()and '..'not in parts.parts and '\\'not in name,'safe baseline relative file') + p=directory/name;raw=p.read_bytes() + need(len(raw)==r['bytes'] and sha(p)==r['sha256'],'baseline file bytes: '+name) + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==r['git_blob'],'baseline Git blob: '+name) + expected[name]=r['sha256'] + need(len(expected)==124 and tree(directory,('DOWNLOAD-MANIFEST.json',))==expected,'complete exact frontier file set') + return expected + +def authenticate_completed_baseline(root,vendor_claim): + result=read(root/'RESULT.json');native=read(root/'NATIVE-RECEIPT.json');source=root/'source';cache=root/'native-cache' + need(result['status']=='PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE' and result['explicit_native_cache_reuse'] is False,'local baseline must be a completed fresh cold replay') + need(Fraction(result['kappa'])==Fraction(vendor_claim['kappa']) and Fraction(result['complex_lower'])==Fraction(vendor_claim['complex_lower']),'complete baseline claim binding') + need(result['profile']=={str(k):v for k,v in vendor_claim['profile'].items()},'baseline full profile') + need(result['native_receipt_sha256']==sha(root/'NATIVE-RECEIPT.json'),'baseline native receipt binding') + need(native['status']=='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' and native['source_commit']=='local-joint12-pr2733' and native['manifest_sha256']==SOURCE_SHA,'complete native source binding') + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==506 and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'exact 506 derived frontier source files') + need(tree(cache)==native['cache_files'],'complete local native/parent cache file hashes') + stages=result['cold_stages'];need(len(stages)==7 and {s['name']for s in stages}==COLD_STAGES and all(s['exit_code']==0 for s in stages),'all fresh baseline stages') + for s in stages:need(sha(root/(s['name']+'.log'))==s['log_sha256'],'baseline stage log binding') + package=root/'admission/package';release=root/'admission/release/RELEASE-RECEIPT.json';receipt=read(release) + need(result['release_receipt_sha256']==sha(release) and receipt['status']=='PASS_RELEASE','completed baseline release receipt') + need(result['package_manifest_sha256']==sha(package/'MANIFEST.json')==receipt['manifest_sha256'],'baseline admitted package manifest binding') + need(tree(package,('MANIFEST.json',))==read(package/'MANIFEST.json'),'complete admitted baseline package') + need(Fraction(receipt['kappa_decimal'])==Fraction(result['kappa']),'baseline release rational') + return dict(result_sha256=sha(root/'RESULT.json'),native_receipt_sha256=sha(root/'NATIVE-RECEIPT.json'),source_manifest_sha256=SOURCE_SHA,cache_files=native['cache_files'],release_receipt_sha256=sha(release),scope='Explicit reuse of completed local fresh baseline; no native rerun by this invocation.') + +def authenticate_prepared_native(root): + result=read(root/'RESULT.json');receipt=read(root/'NATIVE-RECEIPT.json') + need(result['status']=='PASS_PORTABLE_NATIVE_PREPARATION','native producer PASS, without any intermediate T74 admission claim') + need(result['native_receipt_sha256']==sha(root/'NATIVE-RECEIPT.json'),'native producer receipt binding') + need(receipt['status']=='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' and receipt['source_commit']=='local-joint12-pr2733' and receipt['manifest_sha256']==SOURCE_SHA,'native producer source/protocol binding') + source=root/'source';cache=root/'native-cache' + need(sha(source/'MANIFEST.json')==SOURCE_SHA and len(read(source/'MANIFEST.json'))==506 and tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'),'exact506 derived source') + need(tree(cache)==receipt['cache_files'],'complete producer native/parent cache') + need(receipt['fresh_current_provider_count']==2,'both changed current providers freshly checked') + fresh=receipt['fresh_retained_native_count'];reused=receipt['reused_retained_native_count'] + need((fresh,reused)in ((2,0),(0,2)) and receipt['fresh_retained_parent']==(fresh==2) and receipt['reused_retained_parent']==(reused==2),'explicit retained fresh/reuse accounting') + if reused:need(receipt['retained_reuse_receipt_sha256']==sha(root/'RETAINED-REUSE.json'),'retained reuse receipt binding') + return dict(result_sha256=sha(root/'RESULT.json'),native_receipt_sha256=sha(root/'NATIVE-RECEIPT.json'),source_manifest_sha256=SOURCE_SHA,cache_files=receipt['cache_files'],fresh_current_provider_count=2,fresh_retained_native_count=fresh,reused_retained_native_count=reused,scope='Native preparation only; actual replica release checked separately.') + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--work',type=Path,required=True) + ap.add_argument('--package',type=Path,default=HERE) + ap.add_argument('--baseline-dir',type=Path) + ap.add_argument('--baseline-pins',type=Path) + ap.add_argument('--source',type=Path,help='Optional authenticated preobtained original PR2679 tree; otherwise pinned HTTPS download.') + ap.add_argument('--native-preparer',type=Path) + ap.add_argument('--blocknorm-checker',type=Path,help='Actual source-topology/block-norm certificate checker, hash-bound and required by admission.') + ap.add_argument('--reuse-retained-baseline',type=Path,help='Explicit unchanged retained2 native chains and retained-parent reuse; current2 providers still freshly checked.') + ap.add_argument('--reuse-frontier-baseline',type=Path,help='Explicit completed fresh PR2802 T74 cold baseline reuse; a native-only bundle is not a completed baseline.') + ap.add_argument('--fill',type=Path);ap.add_argument('--order',type=Path);ap.add_argument('--dispatch',type=Path) + ap.add_argument('--comparison-claim',type=Path) + ap.add_argument('--replica-helper-dir',type=Path);ap.add_argument('--reconstructor',type=Path);ap.add_argument('--admission-driver',type=Path) + ap.add_argument('--jobs',type=int,default=4) + ap.add_argument('--prepare-only',action='store_true');ap.add_argument('--check-only',action='store_true',help='Only authenticate vendored/input/reuse files; run no proof subprocesses.') + a=ap.parse_args();need(not sys.flags.optimize and 1<=a.jobs<=4,'enabled assertions/one to four jobs');sys.dont_write_bytecode=True + need(not (a.reuse_frontier_baseline and a.reuse_retained_baseline),'choose completed-baseline reuse or retained-only reuse') + package=a.package.resolve();vendor=(a.baseline_dir or package/'vendor/frontier').resolve();pins=(a.baseline_pins or package/'vendor/frontier/DOWNLOAD-MANIFEST.json').resolve() + fill=(a.fill or package/'data/FILL.json.gz').resolve();order=(a.order or package/'data/ORDER.json').resolve();dispatch=(a.dispatch or package/'data/DISPATCH.json').resolve() + comparison=(a.comparison_claim or package/'references/PR2802-CLAIM.json').resolve() + helper=(a.replica_helper_dir or package).resolve();reconstructor=(a.reconstructor or package/'reconstruct_replica.py').resolve();driver=(a.admission_driver or package/'admit_frontier_replica.py').resolve() + preparer=(a.native_preparer or package/'portable_prepare_native.py').resolve() + blocknorm=(a.blocknorm_checker or package/'blocknorm_certificate.py').resolve() + vendor_inventory=authenticate_vendor(vendor,pins) + need(sha(comparison)==COMPARISON_SHA and 'kappa'in read(comparison) and 'headline_kappa_source'not in read(comparison),'exact full PR2802 headline claim') + files=[fill,order,dispatch,comparison,reconstructor,driver,preparer,blocknorm,helper/'lift_parent.py',helper/'replica_parent.py'] + inputs={str(p):sha(p)for p in files};order_value=read(order);need(order_value,'nonempty literal owner order') + T=1+max(r for st,r in order_value);need(T==EXPECTED_REPLICAS and len(order_value)==9*T and set(map(tuple,order_value))=={(st,r)for st in range(9)for r in range(T)},'complete T114 candidate replica coverage') + reuse=a.reuse_frontier_baseline.resolve()if a.reuse_frontier_baseline else None + binding=authenticate_completed_baseline(reuse,read(vendor/'CLAIM.json'))if reuse else None + work=a.work.resolve();need(not work.exists(),'fresh external work directory') + for root in [package,vendor,helper]+[p.resolve()for p in (a.source,reuse,a.reuse_retained_baseline)if p]:need(not work.is_relative_to(root),'work/input tree separation') + if a.check_only: + print(json.dumps(dict(status='PASS_PORTABLE_INPUT_PREFLIGHT_NOT_ADMISSION',T=T,vendor_files=len(vendor_inventory),input_sha256=inputs,expected_T114_kappa=str(EXPECTED_T114_KAPPA),predecessor_T104_kappa=str(PREDECESSOR_T104_KAPPA),blocknorm_checker_sha256=inputs[str(blocknorm)],explicit_baseline_reuse=bool(reuse),baseline_binding={k:v for k,v in binding.items()if k!='cache_files'}if binding else None),sort_keys=True));return + work.mkdir(parents=True);shim=work/'process-lf-adapter';shim.mkdir();(shim/'sitecustomize.py').write_text(LF_ADAPTER,encoding='utf-8',newline='\n') + env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0',OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1') + env['PYTHONPATH']=str(shim)+(os.pathsep+env['PYTHONPATH']if env.get('PYTHONPATH')else'') + for name in ('PYTHONOPTIMIZE','WITNESS_SPEC','WITNESS_DISCOVER','WITNESS_RECORD'):env.pop(name,None) + stages=[];start=time.monotonic() + def run(name,script,*args): + begin=time.monotonic();command=[sys.executable,'-B',str(script),*map(str,args)];log=work/(name+'.log') + with log.open('w',encoding='utf-8')as f:r=subprocess.run(command,env=env,cwd=work,stdin=subprocess.DEVNULL,stdout=f,stderr=subprocess.STDOUT) + stages.append(dict(name=name,exit_code=r.returncode,command=command,script_sha256=sha(script),log_sha256=sha(log),seconds=time.monotonic()-begin));write(work/'STAGES.json',stages) + need(r.returncode==0,'failed '+name+'; see '+str(log));print('PASS',name,flush=True) + if reuse:baseline=reuse + else: + baseline=work/'native' # Leave absent: native producer requires fresh --work. + opts=[] + if a.source:opts+=['--source',a.source.resolve()] + if a.reuse_retained_baseline:opts+=['--reuse-retained-baseline',a.reuse_retained_baseline.resolve()] + if a.prepare_only:opts+=['--prepare-only'] + run('native-preparation',preparer,'--work',baseline,'--vendor-frontier',vendor,'--jobs',a.jobs,*opts) + if a.prepare_only: + prepared=read(baseline/'RESULT.json') + need(prepared['status']=='PASS_AUTHENTICATED_NATIVE_SOURCE_PREPARATION_ONLY' and prepared['native_receipt_issued'] is False and not (baseline/'NATIVE-RECEIPT.json').exists(),'prepare-only emits no native proof or admission') + need(authenticate_vendor(vendor,pins)==vendor_inventory and all(sha(Path(p))==h for p,h in inputs.items()),'unchanged prepared inputs') + receipt=dict(status='PREPARED_PORTABLE_REPLICA_NOT_ADMITTED',replicas=T,native_preparation_result_sha256=sha(baseline/'RESULT.json'),native_receipt_issued=False,admission_run=False,input_sha256=inputs,vendor_inventory_sha256=BASELINE_PINS_SHA,stages=stages,scope='Source preparation only; no native proof checks or replica admission.') + write(work/'RESULT.json',receipt);print(receipt['status'],flush=True);return + binding=authenticate_prepared_native(baseline) + args=['--source',baseline/'source','--fill',fill,'--order',order,'--dispatch',dispatch,'--native-cache',baseline/'native-cache','--native-receipt',baseline/'NATIVE-RECEIPT.json','--work',work/'candidate','--replica-helper-dir',helper,'--blocknorm-checker',blocknorm,'--reconstructor',reconstructor,'--comparison-claim',comparison,'--source-profile','pr2802','--comparison-profile','pr2802','--jobs',a.jobs] + if a.prepare_only:args+=['--prepare-only'] + run('replica-candidate',driver,*args) + result=read(work/'candidate/RESULT.json') + if a.prepare_only:need(result['status']=='PREPARED_REPLICA_SAME_WORD_DERIVATIVE_NOT_ADMITTED','prepared status') + else: + need(result['status']=='PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE','full candidate release status') + need(result['replicas']==EXPECTED_REPLICAS and Fraction(result['kappa'])==EXPECTED_T114_KAPPA,'complete exact T114 target binding') + need(Fraction(result['kappa'])>PREDECESSOR_T104_KAPPA,'strict gain over the complete exact T104 rational') + need(Fraction(result['kappa'])>Fraction(read(comparison)['kappa']),'strict exact full headline gain') + need(authenticate_vendor(vendor,pins)==vendor_inventory,'vendored baseline changed') + need(all(sha(Path(p))==h for p,h in inputs.items()),'input bytes changed') + need((authenticate_completed_baseline(baseline,read(vendor/'CLAIM.json'))if reuse else authenticate_prepared_native(baseline))==binding,'native/source/cache inputs changed') + receipt=dict(status='PREPARED_PORTABLE_REPLICA_NOT_ADMITTED'if a.prepare_only else'PASS_PORTABLE_REPLICA_COMPLETE_RELEASE',replicas=T,explicit_local_baseline_reuse=bool(reuse),fresh_native_preparation_run=not bool(reuse),explicit_retained_only_reuse=bool(a.reuse_retained_baseline),baseline_binding=binding,candidate_result_sha256=sha(work/'candidate/RESULT.json'),candidate_status=result['status'],kappa=result.get('kappa'),input_sha256=inputs,vendor_inventory_sha256=BASELINE_PINS_SHA,comparison_claim_sha256=COMPARISON_SHA,predecessor_T104_kappa=str(PREDECESSOR_T104_KAPPA),expected_T114_kappa=str(EXPECTED_T114_KAPPA),blocknorm_checker_sha256=inputs[str(blocknorm)],stages=stages,seconds=time.monotonic()-start,python=platform.python_version(),compatibility=dict(scope='Process-scoped UTF8/LF text adapter only; all upstream hash predicates remain unchanged.',adapter_sha256=sha(shim/'sitecustomize.py')),scope=result['scope']) + write(work/'RESULT.json',receipt);print(receipt['status'],result.get('kappa_decimal',''),flush=True) +if __name__=='__main__':main() + diff --git a/research/tensor-block-kappa/portable_prepare_native.py b/research/tensor-block-kappa/portable_prepare_native.py new file mode 100644 index 0000000000..49b156c86b --- /dev/null +++ b/research/tensor-block-kappa/portable_prepare_native.py @@ -0,0 +1,345 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Authenticate PR2802 and prepare native receipts, without a redundant T74 admission. + +Default: four fresh native chains and a fresh retained-parent check. Explicit +--reuse-retained-baseline reuses only unchanged, completely hash-bound retained +chains and their retained-parent receipt. Current providers always run freshly. +""" +import argparse +from concurrent.futures import ThreadPoolExecutor +import gzip +import hashlib +import importlib +import importlib.util +import json +import os +from pathlib import Path, PurePosixPath +import platform +import shutil +import subprocess +import sys +import tarfile +import threading +import time + +HEAD = '17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd' +DOWNLOAD_SHA = 'fae7e9161707d3627c7ba444543b1bdd0d736df57b8495ea112bb221a2693497' +DERIVED_SHA = '9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' +PROTOCOL_STATUS = 'PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE' +STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] +LF_SHIM = """from pathlib import Path +_original_write_text = Path.write_text +def _task_write_text(self, data, encoding=None, errors=None, newline=None): + return _original_write_text(self, data, encoding=encoding, errors=errors, + newline='\\n' if newline is None else newline) +Path.write_text = _task_write_text +""" + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n', + encoding='utf-8', newline='\n') + + +def safe(name): + p = PurePosixPath(name) + need(isinstance(name, str) and p.parts and not p.is_absolute() and + '..' not in p.parts and '\\' not in name and p.as_posix() == name, + 'unsafe path: ' + str(name)) + + +def tree(root, exclude=()): + result = {} + for p in sorted(root.rglob('*')): + need(not p.is_symlink(), 'symlink in authenticated tree: ' + str(p)) + name = p.relative_to(root).as_posix() + if p.is_file() and name not in exclude: + result[name] = sha(p) + return result + + +def authenticate_vendor(vendor): + manifest = vendor / 'DOWNLOAD-MANIFEST.json' + need(sha(manifest) == DOWNLOAD_SHA, 'pinned download manifest') + data = read(manifest) + need(data['head'] == HEAD and len(data['files']) == 124, '124 pinned vendor files') + expected = {} + for item in data['files']: + name = item['path'] + safe(name) + need(name not in expected, 'duplicate vendor path') + body = (vendor / name).read_bytes() + need(len(body) == item['bytes'] and hashlib.sha256(body).hexdigest() == item['sha256'], + 'vendor SHA256/size: ' + name) + blob = hashlib.sha1(('blob ' + str(len(body)) + '\0').encode() + body).hexdigest() + need(blob == item['git_blob'] and blob.startswith(item['diff_blob']), 'vendor Git blob: ' + name) + expected[name] = item['sha256'] + need(tree(vendor, ('DOWNLOAD-MANIFEST.json',)) == expected, 'complete vendor inventory') + return expected + + +def source_guard(source): + need(sha(source / 'MANIFEST.json') == DERIVED_SHA, 'derived source manifest') + pins = read(source / 'MANIFEST.json') + need(len(pins) == 506 and tree(source, ('MANIFEST.json',)) == pins, + 'complete506-file derived source inventory') + return pins + + +def bind_native(entry, word): + need(gzip.decompress((entry / 'local/FULL-WORD.json.gz').read_bytes()) == + gzip.decompress(word.read_bytes()), 'complete native word binding') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == STEPS and all(s['exit_code'] == 0 for s in stages), + 'five successful native stages') + + +def reuse_retained(baseline, source, cache, retained): + prior = read(baseline / 'NATIVE-RECEIPT.json') + need(prior['status'] == PROTOCOL_STATUS, 'completed baseline native protocol') + previous_source = baseline / 'source' + need(sha(previous_source / 'MANIFEST.json') == prior['manifest_sha256'] and + tree(previous_source, ('MANIFEST.json',)) == read(previous_source / 'MANIFEST.json'), + 'complete baseline source inventory') + oldcache = baseline / 'native-cache' + need(tree(oldcache) == prior['cache_files'], 'complete baseline cache inventory') + old = source / 'vendor/pr1297' + need(tree(old) == tree(previous_source / 'vendor/pr1297'), 'exact retained vendor source identity') + records = {} + for tag, word in retained.items(): + digest = sha(word) + entry = oldcache / digest + expected = {k[len(digest)+1:]: v for k, v in prior['cache_files'].items() + if k.startswith(digest + '/')} + need(expected and tree(entry) == expected, 'retained native exact pins: ' + tag) + bind_native(entry, word) + shutil.copytree(entry, cache / digest) + need(tree(cache / digest) == expected, 'retained native exact copy: ' + tag) + records[tag] = dict(word_sha256=digest, files=expected) + pm = sha(old / 'MANIFEST.json') + relative = '_receipts/' + pm + expected = {k[len(relative)+1:]: v for k, v in prior['cache_files'].items() + if k.startswith(relative + '/')} + receipt_dir = oldcache / relative + need(expected and tree(receipt_dir) == expected, 'retained parent exact pins') + receipt = read(receipt_dir / 'RECEIPT.json') + need(receipt['schema'] == 'parent-receipt/1' and + receipt['vendor_manifest_sha256'] == pm and + receipt['claim_sha256'] == sha(old / 'CLAIM.json') and + receipt['words'] == {tag: sha(w) for tag, w in retained.items()}, + 'retained parent source/claim/word binding') + need(set(receipt['files']) == {'RESULT.json', 'STAGES.json'}, 'complete retained parent receipt files') + parent_stages = read(receipt_dir / 'STAGES.json') + need(len(parent_stages) == 16 and all(s['exit_code'] == 0 for s in parent_stages), + 'sixteen successful retained parent stages') + need(all(sha(receipt_dir / name) == digest for name, digest in receipt['files'].items()), + 'retained parent receipt file hashes') + parent = read(receipt_dir / 'RESULT.json') + need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and + parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'retained parent PASS/claim') + shutil.copytree(receipt_dir, cache / relative) + need(tree(cache / relative) == expected, 'retained parent exact copy') + return dict(status='PASS_EXACT_HASH_BOUND_RETAINED_REUSE', + baseline_native_receipt_sha256=sha(baseline / 'NATIVE-RECEIPT.json'), + baseline_source_manifest_sha256=prior['manifest_sha256'], + baseline_source_commit=prior['source_commit'], + retained_vendor_manifest_sha256=pm, native_entries=records, + retained_parent_receipt_sha256=sha(cache / relative / 'RECEIPT.json')) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--work', type=Path, required=True, help='Fresh external output directory.') + ap.add_argument('--source', type=Path, help='Exact original491-file PR2679 source; otherwise use pinned upstream download.') + ap.add_argument('--vendor-frontier', type=Path, default=Path(__file__).resolve().parent / 'vendor/frontier') + ap.add_argument('--jobs', type=int, choices=range(1, 5), default=4) + ap.add_argument('--reuse-retained-baseline', type=Path, + help='Explicit unchanged retained2-native/parent reuse from a completed baseline.') + ap.add_argument('--prepare-only', action='store_true', + help='Authenticate/copy source and optional retained reuse; do not run native checks or issue a native receipt.') + args = ap.parse_args() + need(not sys.flags.optimize, 'assertions must remain enabled') + sys.dont_write_bytecode = True + vendor = args.vendor_frontier.resolve() + authenticate_vendor(vendor) + versions = {name: str(importlib.import_module(name).__version__) + for name in ('numpy', 'sympy', 'scipy', 'mpmath')} + pinned = dict(line.split('==') for line in (vendor / 'requirements.txt').read_text().splitlines() if line) + need(versions == pinned, 'install the exact pinned requirements.txt in the invoking Python environment') + work = args.work.resolve() + need(not work.exists(), 'fresh work directory required') + need(not work.is_relative_to(Path(__file__).resolve().parent) and not work.is_relative_to(vendor), + 'external work directory required') + for p in (args.source, args.reuse_retained_baseline): + need(p is None or (p.is_dir() and not work.is_relative_to(p.resolve())), 'input/work separation') + work.mkdir(parents=True) + lockpath = work / 'native.lock' + with lockpath.open('x', encoding='utf-8') as lock: + lock.write(str(os.getpid()) + '\n') + successful = False + try: + spec = importlib.util.spec_from_file_location('_pinned_full_replay', vendor / 'full_replay.py') + upstream = importlib.util.module_from_spec(spec) + spec.loader.exec_module(upstream) + write(work / 'INPUT-BINDING.json', dict(upstream_head=HEAD, download_manifest_sha256=DOWNLOAD_SHA, + vendor_files=124, preparer_sha256=sha(Path(__file__)), + source_pins_sha256=sha(vendor / 'SOURCE-FILES.json'), overlay_pins_sha256=sha(vendor / 'OVERLAY-PINS.json'))) + source = work / 'source' + pins = read(vendor / 'SOURCE-FILES.json') + upstream.source_copy(args.source.resolve() if args.source else None, source, pins, args.jobs) + overlay = read(vendor / 'OVERLAY-PINS.json') + need(sha(source / 'MANIFEST.json') == overlay['original_manifest_sha256'], 'original source manifest') + need(sha(vendor / 'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive') + with tarfile.open(vendor / 'DERIVATIVE-OVERLAY.tar.gz') as archive: + members = archive.getmembers() + need(set(m.name for m in members) == set(overlay['files']) and len(members) == len(overlay['files']), 'exact overlay paths') + for member in members: + safe(member.name) + need(member.isfile(), 'regular overlay member') + body = archive.extractfile(member).read() + need(hashlib.sha256(body).hexdigest() == overlay['files'][member.name], 'overlay member hash') + target = source / member.name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(body) + need(overlay['derived_manifest_sha256'] == DERIVED_SHA, 'pinned derived identity') + source_guard(source) + cache = work / 'native-cache' + cache.mkdir() + old = source / 'vendor/pr1297' + 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'))} + reuse = None + if args.reuse_retained_baseline: + reuse = reuse_retained(args.reuse_retained_baseline.resolve(), source, cache, retained) + write(work / 'RETAINED-REUSE.json', reuse) + runtime = work / 'runtime-adapter' + runtime.mkdir() + shim = runtime / 'sitecustomize.py' + shim.write_text(LF_SHIM, encoding='utf-8', newline='\n') + inherited = [str(Path(p or os.getcwd()).resolve()) for p in sys.path] + inherited.extend(os.environ.get('PYTHONPATH', '').split(os.pathsep)) + paths = list(dict.fromkeys([str(runtime), *[p for p in inherited if p]])) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', BW_IDLE='0', PYTHONPATH=os.pathsep.join(paths)) + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + write(work / 'ENVIRONMENT.json', dict(python=platform.python_version(), versions=versions, + lf_adapter_sha256=sha(shim), jobs=args.jobs, planned_fresh_current_provider_count=2, + planned_fresh_retained_native_count=0 if reuse else 2, + reused_retained_native_count=2 if reuse else 0, + reused_retained_parent=bool(reuse), scope='Task process environment; no global configuration changes.')) + if args.prepare_only: + source_guard(source) + authenticate_vendor(vendor) + write(work / 'RESULT.json', dict(status='PASS_AUTHENTICATED_NATIVE_SOURCE_PREPARATION_ONLY', + source_file_count=506, manifest_sha256=DERIVED_SHA, native_receipt_issued=False, + explicit_retained_reuse=bool(reuse))) + successful = True + print('PASS_AUTHENTICATED_NATIVE_SOURCE_PREPARATION_ONLY', flush=True) + return + stages = [] + mutex = threading.Lock() + started = time.monotonic() + + def run(name, script, *arguments): + begin = time.monotonic() + log = work / (name + '.log') + command = [sys.executable, '-B', str(script), *map(str, arguments)] + with log.open('w', encoding='utf-8', newline='\n') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + with mutex: + stages.append(dict(name=name, exit_code=result.returncode, command=command, + seconds=time.monotonic()-begin, script_sha256=sha(script), log_sha256=sha(log))) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + retained_driver = None + if not reuse: + layout = work / 'retained-layout' + layout.mkdir() + with tarfile.open(old / 'upstream-layout.tar.gz') as archive: + members = archive.getmembers() + for member in members: + safe(member.name) + need(member.isfile(), 'regular retained archive member') + archive.extractall(layout, filter='data') + retained_driver = layout / 'joint1148-round45/source/research/k8-eight-ends/replay_native.py' + need(retained_driver.is_file(), 'retained native driver') + jobs = {**words, **({'retained-' + tag: word for tag, word in retained.items()} if not reuse else {})} + + def fresh_native(tag): + word = jobs[tag] + entry = cache / sha(word) + driver = retained_driver if tag.startswith('retained-') else source / 'new/run_native_borrow.py' + run('native-' + tag, driver, word, entry) + bind_native(entry, word) + write(entry / 'CACHE.json', dict(word_sha256=sha(word), files=tree(entry))) + + with ThreadPoolExecutor(max_workers=args.jobs) as pool: + list(pool.map(fresh_native, jobs)) + pm = sha(old / 'MANIFEST.json') + receipts = cache / '_receipts' / pm + if not reuse: + 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') + parent_stages = read(work / 'retained-parent/STAGES.json') + need(len(parent_stages) == 16 and all(s['exit_code'] == 0 for s in parent_stages), + 'sixteen successful fresh retained parent stages') + need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' and + parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'fresh retained parent PASS/claim') + receipts.mkdir(parents=True) + for name in ('RESULT.json', 'STAGES.json'): + shutil.copy2(work / 'retained-parent' / name, receipts / name) + write(receipts / 'RECEIPT.json', dict(schema='parent-receipt/1', vendor_manifest_sha256=pm, + claim_sha256=sha(old / 'CLAIM.json'), words={tag: sha(word) for tag, word in retained.items()}, + files={name: sha(receipts / name) for name in ('RESULT.json', 'STAGES.json')})) + source_guard(source) + authenticate_vendor(vendor) + providers = {tag: dict(word_sha256=sha(word), complete_native_files=tree(cache / sha(word), ('CACHE.json',))) + for tag, word in words.items()} + result = dict(status=PROTOCOL_STATUS, source_commit='local-joint12-pr2733', manifest_sha256=DERIVED_SHA, + providers=providers, retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), + cache_files=tree(cache), fresh_current_provider_count=2, + fresh_retained_native_count=0 if reuse else 2, + reused_retained_native_count=2 if reuse else 0, + fresh_retained_parent=not bool(reuse), reused_retained_parent=bool(reuse), + retained_reuse_receipt_sha256=sha(work / 'RETAINED-REUSE.json') if reuse else None) + write(work / 'NATIVE-RECEIPT.json', result) + need(tree(cache) == result['cache_files'], 'final complete cache identity') + write(work / 'RESULT.json', dict(status='PASS_PORTABLE_NATIVE_PREPARATION', + native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'), source_file_count=506, + manifest_sha256=DERIVED_SHA, fresh_current_provider_count=2, + fresh_retained_native_count=result['fresh_retained_native_count'], + reused_retained_native_count=result['reused_retained_native_count'], + fresh_retained_parent=result['fresh_retained_parent'], reused_retained_parent=bool(reuse), + seconds=time.monotonic()-started, scope='Native preparation only; no T74 admission or T94 admission asserted.')) + successful = True + print('PASS_PORTABLE_NATIVE_PREPARATION', flush=True) + finally: + # The lock handle was closed immediately after its exclusive creation. + # Failures retain a closed diagnostic lock; there are no hidden retries. + if successful: + lockpath.unlink() + + +if __name__ == '__main__': + main() diff --git a/research/tensor-block-kappa/provenance/ADMISSION-SOURCES.json b/research/tensor-block-kappa/provenance/ADMISSION-SOURCES.json new file mode 100644 index 0000000000..427243a9c1 --- /dev/null +++ b/research/tensor-block-kappa/provenance/ADMISSION-SOURCES.json @@ -0,0 +1,30 @@ +[ + { + "name": "admit_frontier_replica.py", + "sha256": "57630311eb90be3d417e7bdeaae03965fef46a97b4b38389ff66805c75276f80" + }, + { + "name": "portable_frontier_cold.py", + "sha256": "e2c54f4884e4db6e2791b98787c469e96b18a6b9620e5abf890b2cc7b27d255c" + }, + { + "name": "portable_prepare_native.py", + "sha256": "cb32e36f3e435652b7fab857c94e0dbb925b56ce7bb5daeecc223b0fc6993012" + }, + { + "name": "lift_parent.py", + "sha256": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e" + }, + { + "name": "replica_parent.py", + "sha256": "48bdbf28f59d80edb266803ec61bf5e22e8fb5e5a0e2b88004b6039147589bd4" + }, + { + "name": "reconstruct_replica.py", + "sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15" + }, + { + "name": "blocknorm_certificate.py", + "sha256": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92" + } +] diff --git a/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-RESERVE.json b/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-RESERVE.json new file mode 100644 index 0000000000..a0313953aa --- /dev/null +++ b/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-RESERVE.json @@ -0,0 +1,18 @@ +{ + "local_reserve_bits": 128, + "patch_source_bindings": [ + { + "after_sha256": "d5692ff472096ad14ade860b9bf6a0c5d5e0e3e09cd0186720efe8083c09a282", + "before_sha256": "4255131a44bd94473fc55fe468c32d0b6435862955797fe22a2e8ebfce60942d", + "path": "lift_parent.py" + }, + { + "after_sha256": "216d49d694e4b88a773be0b539c7bf51e5ee6c2cccfba31017251b52ace7782d", + "before_sha256": "d3274dd18f2ef27efbd9b53155654164019d95cd96640de87470c7e9d92d00e5", + "path": "admit_frontier_replica.py" + } + ], + "previous_local_reserve_bits": 192, + "scope": "Measured actual scalar and Horner prefix must be <=128 for every provider and orientation; all actual invocation, bridge, input and margin charges remain. No per-replica norm bound is assumed.", + "status": "PASS_FRESH_COMPLETE_RELEASE_WITH_EXACT_NATIVE_PREFIX_GUARDS" +} diff --git a/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-REVIEW.json b/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-REVIEW.json new file mode 100644 index 0000000000..499be51638 --- /dev/null +++ b/research/tensor-block-kappa/provenance/PREDECESSOR-T104-SHARPENED-PREFIX-REVIEW.json @@ -0,0 +1,47 @@ +{ + "T104": { + "bridges": 936, + "calls": 936, + "charged_bound": 2041, + "live": 93184, + "max_child": 48, + "payload": 2048, + "physical": 93674, + "physical_row": 19545, + "required_prefix": 1983, + "row_limit": 20161 + }, + "T105_charged_payload": 4096, + "actual_exact_native_prefix_bits": { + "base/backward": 70, + "base/forward": 63, + "extra/backward": 70, + "extra/forward": 63 + }, + "inputs": { + "native/NATIVE-RECEIPT.json": "32c42af206f32dbcfb500579ac7e525a028e5caa0cc180c9890630ccbd03b44a", + "native/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "native/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "native/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "native/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "native/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "native/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "public/admit_frontier_replica.py": "216d49d694e4b88a773be0b539c7bf51e5ee6c2cccfba31017251b52ace7782d", + "public/lift_parent.py": "d5692ff472096ad14ade860b9bf6a0c5d5e0e3e09cd0186720efe8083c09a282", + "runtime/discovery/INDEPENDENT.json": "a5ad726e5a5029eb7cd59c4061b0e14700126f7156ed994afde05f3f31b8df1f", + "runtime/discovery/global/audit/PREFIX-AND-INVOICE.json": "8bcc3a4b2b5e23445231de04bdc2f367d00182da6ecdd762df08b2476195be70", + "runtime/package/code/assemble.py": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "runtime/package/code/invoice_allcold.py": "c4d9266e01b6e2921694e11828725a298731b81ab0bfc4ac56fcd40f9d59140c", + "runtime/package/code/witness.py": "5d5d68b896139e852a3dfc15ae179772181b495667e86ff03b241e1ebd416e81", + "runtime/package/independent_core.py": "ce646de11efcadb729d85e4b7f2bf0cb1275174b5d82935571aa14be27c06c93" + }, + "local_reserve": 128, + "max_local_bits": 70, + "negative_controls": { + "T105_payload2048": "REJECTED_BY_WITNESS_FORMULA", + "local129": "REJECTED_BY_BOTH_GUARDS" + }, + "remaining192": "Only assemble standalone upperbound192, dominated by invoice and independent128 guards; no charged-payload mismatch. Retained historical512bit source unchanged.", + "scope": "Exact scalar-prefix recount plus runtime guard/payload/charge review only. Full root-run release and kernel audit independently required.", + "status": "PASS_INDEPENDENT_PREFIX128_GUARD_REVIEW" +} diff --git a/research/tensor-block-kappa/provenance/TI-BLOCK-FULL-STOCK-REVIEW.json b/research/tensor-block-kappa/provenance/TI-BLOCK-FULL-STOCK-REVIEW.json new file mode 100644 index 0000000000..a76b557cab --- /dev/null +++ b/research/tensor-block-kappa/provenance/TI-BLOCK-FULL-STOCK-REVIEW.json @@ -0,0 +1,34 @@ +{ + "T": 114, + "charged_sum": 1511, + "charged_terms": [ + 128, + 37, + 18, + 1323, + 1, + 4 + ], + "conditions": [ + "Normalizedwholehelperendpoints areunitary onthefullregularrepresentation via completedprimitive/tensor andbijectioncontracts.", + "Partialcover sumbound andactualscalar/Horner envelope applybetweencompletedboundaries.", + "FreshT114schedule/ownership/finite/outeradmission andfinalkernel/axiomreceipts stillrequired." + ], + "conversion_bits": 1323, + "conversion_upper_bound_checked": "stock<2^(2*conversion_bits)", + "final_release_receipt_sha256": "0b6673fc8beefbc5198bdf612458928f2970b355aef8f1a709cb27237fa47d36", + "final_release_status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "group_order_bit_length": 2628, + "group_order_formula": "2^(36^2)*product(i=1..36,2^(2*i)-1)", + "measured_sum": 1453, + "norm_argument": "For arbitrary complex coordinates on allregularrepresentationcells, ||x||2<=sqrt(stock)||x||infty<2^1323||x||infty. Per-ownerreplica directsumgrowth2^18 follows separatelycheckedcompleteendpoint locality andnormalizedunitarity; noinputindependenceormixednormassumption. Retained37term isadditionalovercharge.", + "payload": 2048, + "physical": 102634, + "rejected_previous_proposal": "256payload notused; fullgroupstock nowexplicitlycharged.", + "row": 19547, + "source_invoice_role": "Retained actual group/stock and ordinary physical-row formulas, code/invoice_allcold.py", + "source_invoice_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "status": "PASS_INDEPENDENT_FULL_STOCK_PRECISION_ARITHMETIC_PENDING_GLOBAL_RELEASE", + "stock_bit_length": 2645, + "unchanged_row_ceiling": 20161 +} diff --git a/research/tensor-block-kappa/provenance/TI-BLOCK-PREDECESSOR-NOTICES.json b/research/tensor-block-kappa/provenance/TI-BLOCK-PREDECESSOR-NOTICES.json new file mode 100644 index 0000000000..a4ca01987e --- /dev/null +++ b/research/tensor-block-kappa/provenance/TI-BLOCK-PREDECESSOR-NOTICES.json @@ -0,0 +1,15 @@ +{ + "documents": { + "FRONTIER.md": { + "sha256": "f9e95378c3b6e44a7216c51a0653181a24f27161bd621a374d6f3d397b2a3407", + "utf8_text": "# Frontier comparison and certificate scope\n\nThe actual T104 allocation passes independent integer chronology, whole-owner masks and directed rational moment checks. The complete changed native/global/outer release **PASSES** (`PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`, with `PASS_RELEASE`). Finite allocation and moment admission alone do not establish the inherited all-size multiplication implication.\n\nAll changed T104 owner/source/controller/phase geometry, measured-prefix and ordinary finite invoices, outer arithmetic and strict release checks ran freshly. All unchanged native provider chains and retained parent evidence were reused only with authenticated source, artifact and receipt hashes. This is fresh changed-candidate admission with checked reuse, not a claim that unchanged native chains were rerun. Original full-result SHA256: `4caf2cd9d8f61728d718bb9f26709c6b7ed6e1d825daa2a9a4b9ea0f623ab0f3`. Original strict-release receipt SHA256: `5465eaa5fa836dd2679ad9030dd83147f8d50d5235470d431a42c6d48e09381b`. The exact admitted target is `0.001717795222616587743198 -10^-46 -10^-70`.\n\n## Current comparison\n\nOrdinary public repository HTML retrieved on 2026-10-16 at 00:03:35UTC identifies main `e24ccc79caa1943fb126c61b45032fefddf2d3f2`. Its pinned README and selected-result bytes remain unchanged: the maintainer-selected conditional record is `0.001672660197076918`, distinct from stronger pending submissions.\n\nFive updated-open-PR pages supplied 125 unique current titles. Actual primary bodies of [PR2824](https://github.com/CrocSwap/integer-mult-bounds/pull/2824), [PR2818](https://github.com/CrocSwap/integer-mult-bounds/pull/2818) and [PR2823](https://github.com/CrocSwap/integer-mult-bounds/pull/2823) were inspected. The highest complete-supplier claim found in this bounded refresh is PR2824, our preceding T94 construction, head `f1826afe1f487333f2c1e5bf862bae2211ce8dd9`. Its actual commit-pinned CLAIM was fetched at 00:12:38UTC and is byte-identical to the delivered T94 input: SHA256 `7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52`. See `references/PR2824-CLAIM.json` and `references/CURRENT-PINS.json`.\n\nPR2818, Jeremy Kothe's precision refinement at head `175822aee7a1858ec653f7f92d7a750aec2c2795`, explicitly retains PR2802's words, fill, order and dispatch. Its approximately `0.0017177949841186346638272299184281789` endpoint remains below the full T94 rational. Extra endpoint precision does not change that construction.\n\nPR2823, head `ca5eead6afd871614ceb635679edbcc3d04b9d8c`, supplies actual cold-host cancellation and bounded restoration obstructions. Its pinned README states that the full-width restoration component fails native transport and supplies no new kappa or admitted supplier. Staged/changed-basis recovery remains a lead requiring an actual paid profile and full admission. P104, BIT and other component titles do not supply a complete larger kappa in the inspected sources; their missing interfaces are not treated as free.\n\nA final ordinary-HTML supplement at 00:20:50UTC identified main `da4f4fec60a88d9187f8ffa02f0f787b8b2da527` and reviewed 25 updated-open-PR titles. Commit-pinned README and selected-result bytes fetched at 00:21:22UTC are unchanged. The new [PR2825](https://github.com/CrocSwap/integer-mult-bounds/pull/2825), head `b553e912bcddef550d9fae6033041ff683399ebe`, was inspected in its actual primary body: Ross Richardson's conditional BIT caller numerical envelope explicitly disclaims physical reserve, supplier admission and new kappa. No higher complete supplier was found in this supplement. `references/FINAL-FRONTIER-SUPPLEMENT.json` binds its limited coverage; the exact PR2824 comparison pin remains unchanged.\n\nREST quota remained exhausted after the preceding campaign; this refresh uses ordinary public HTML and pinned raw bytes. The earlier review's 723 open-PR bodies and 296 Discussion bodies, followed by 100 recent primary bodies, are historical coverage. This snapshot reviews 125 titles and only the three named primary bodies, plus pinned sources. No universal novelty or complete comment coverage is asserted.\n\n## Actual change and exact comparison\n\nThe new literal allocation has 104 replicas, 936 calls, 408 helpers per call and 381888 whole-owner roles. Its independently derived paid profile is\n`{1:2253888,2:606528,3:260115,4:119808,5:38219,8:7488,32:1,48:37325}`.\nLive stock is 93184; charged physical stock is 93674, including 72 private buffers. Rank mass is 6769152 and deficit 33280. The owner checker binds actual inherited provider frames and endpoints, source windows, distinct physical families, compact prefixes and every helper role; seven semantic corruptions are rejected.\n\nThe directed rational root bracket is\n`[1717795222616587743198/10^24,1717795222616587743199/10^24]`.\nThe proposed outer target is its lower endpoint minus `10^-46 +10^-70`. Its exact gain over the full published PR2824 rational is\n`62584575635791/10^24 =6.2584575635791e-11`.\nThe input is the entire exact published rational, not its rounded title. Pricing controls reject reversed endpoints, an inadmissible upper endpoint, changed normalization, one unpaid child and the unchanged T74 profile. The checker's retained historical field names mention PR2802; its recorded comparison hash and full rational here identify PR2824/T94 exactly.\n\nThe prior admitted current-provider audit measures 70 local prefix bits backward and 63 forward. A conservative 128-bit reserve makes the T104 formula `128+37+18*104+4=2041`, below 2048. The fresh admission explicitly checks this measured local-prefix bound. The ordinary 20161 row ceiling remains unchanged. The old 192-bit reserve would require 4096 and fail that ceiling; no unproved direct-sum improvement or uncharged larger ordinary budget is used.\n\n## Attribution and limits\n\nPR2802's retired7 native construction is Marius-Paul Dumitrean's work, with substantial Anthropic Claude/Claude Code assistance recorded in its NOTICE. Its native words, seven retired width-five helpers, frame refits and restoration remain inherited. Further credit belongs to Tekalign/PR2751's joint twelve-source recovery, PR2766's frame refit, PR2733's frame-route work, Philippe Van Velzen/PR2679's hosting and retired-lender aliases, Mason Hale/PR2696's assignment, zxv/PR2530's source-partner loans, Jeremy Kothe/PR2588's helper-label exchange, and Cinna Davis/PR2226's anticipatory borrowing. Existing licenses and notices remain with the pinned sources. PR2824 is the preceding checked T94 tail-dilution construction; this work increases its actual allocation to 104 and uses a smaller sufficient local reserve without changing native words.\n\nThe Mathlib-only proof certifies universal paid-cost/profile inequalities and their stated sufficient bounds. It does not formalize the whole inherited multiplication pipeline. Any multiplication implication retains the inherited all-size/compiler/source-access/hosting/precision/tape/recovery/ordinary-recursion/bit-supplier/analytic-transfer hypotheses. Historical vendored successes and their original execution-path strings are provenance inputs; only fresh source-bound checks can establish this candidate's release. PR2411 links Dan Brown and Kenny Daniel's complete asymptotic FinTM2 multiplication proof; no first-proof claim is made here.\n" + }, + "PROOF.md": { + "sha256": "e9f00cb3738e92e1933fecdeb1029c14aa89cc191b69f61ef113494d757a8424", + "utf8_text": "# Paid replica monotonicity and its T104 application\n\nFor 0.99 \u2264 p < 1 define D(p) = 3*3^p - 5*5^p + 5*32^p - 3*48^p. The retained Mathlib proof `tail_power_positive` establishes D(p)>0 by setting t=1-p and bounding the expression below by 30*t-2404*t\u00b2>0. The logarithmic and exponential estimates, constants and domain are kernel checked.\n\nThe complete ten-replica periodic sum for the credited PR2802 supplier is\n\n P(p) = 216720 + 58320*2^p + 25011*3^p + 11520*4^p\n + 3675*5^p + 720*8^p + 3589*48^p.\n\nThe full count expression is R(T,p) = T*P(p)/10 + D(p)/5. The positive residue D(p)/5 remains charged. The exact T74 predecessor identity and T94 application are inherited from the previous deliverable; they are retained with their proof source and attribution.\n\nThe new `frontier_replica_monotone` proves for all real 00 + 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/tensor-block-kappa/references/CURRENT-PINS.json b/research/tensor-block-kappa/references/CURRENT-PINS.json new file mode 100644 index 0000000000..c14bab0402 --- /dev/null +++ b/research/tensor-block-kappa/references/CURRENT-PINS.json @@ -0,0 +1,149 @@ +{ + "bodies": [ + { + "head": "ca5eead6afd871614ceb635679edbcc3d04b9d8c", + "html_sha256": "93ff862ed92386436e8afa6743fed2cc909f0d7c6efdb3416d1b3b761497454e", + "number": 2823 + }, + { + "head": "175822aee7a1858ec653f7f92d7a750aec2c2795", + "html_sha256": "65eef87e2080e4c9d6cf6a2f7de494f0fe529ffdbc8f5757f3f26e12b8e20691", + "number": 2818 + }, + { + "head": "f1826afe1f487333f2c1e5bf862bae2211ce8dd9", + "html_sha256": "8111fdc9afca4c4c9e001beed29ae33ed8f56e6a5f6cc7e028b1aef31e4203a0", + "number": 2824 + } + ], + "channel": "ordinary public HTML and commit-pinned raw HTTPS; no REST refresh", + "claim": { + "byte_identical_to_delivered_T94": true, + "head": "f1826afe1f487333f2c1e5bf862bae2211ce8dd9", + "path": "research/replica-tail-gain/CLAIM.json", + "pr": 2824, + "sha256": "7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/f1826afe1f487333f2c1e5bf862bae2211ce8dd9/research/replica-tail-gain/CLAIM.json" + }, + "coverage": "125 current open-PR titles; actual primary bodies2823/2818/2824; pinned main README and selected-result bytes; bounded review, not all current bodies or comments", + "final_supplement": "FINAL-FRONTIER-SUPPLEMENT.json", + "last_main": "da4f4fec60a88d9187f8ffa02f0f787b8b2da527", + "last_refresh_utc": "2026-10-16T00:21:22Z", + "main": "e24ccc79caa1943fb126c61b45032fefddf2d3f2", + "main_and_primary_retrievals": [ + { + "bytes": 298716, + "label": "pr2823", + "sha256": "93ff862ed92386436e8afa6743fed2cc909f0d7c6efdb3416d1b3b761497454e", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2823", + "utc": "2026-10-16T00:04:30.148Z" + }, + { + "bytes": 311474, + "label": "pr2818", + "sha256": "65eef87e2080e4c9d6cf6a2f7de494f0fe529ffdbc8f5757f3f26e12b8e20691", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2818", + "utc": "2026-10-16T00:04:30.665Z" + }, + { + "bytes": 297285, + "label": "pr2824", + "sha256": "8111fdc9afca4c4c9e001beed29ae33ed8f56e6a5f6cc7e028b1aef31e4203a0", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2824", + "utc": "2026-10-16T00:04:31.127Z" + }, + { + "bytes": 30263, + "label": "main-readme", + "sha256": "b9d94e1bc9ff9d1efe5b69e00963ee5d917cb376e36a453e0554742110ec0041", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e24ccc79caa1943fb126c61b45032fefddf2d3f2/README.md", + "utc": "2026-10-16T00:04:31.394Z" + }, + { + "bytes": 10725, + "label": "main-selected", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e24ccc79caa1943fb126c61b45032fefddf2d3f2/certificates/selected-result.json", + "utc": "2026-10-16T00:04:31.686Z" + } + ], + "raw_source_receipts": [ + { + "bytes": 182852, + "head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "path": "research/gmx-t74-borrow43-handoff/new/borrow/inputs/postcut_43base.json", + "pr": "2767", + "sha256": "d700ad92804e6565eb111850d4901c644e0fa28796bba3ef605b70a251a0aa1c", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e8b771ba132fe632796b28c1742a8d096c04519f/research/gmx-t74-borrow43-handoff/new/borrow/inputs/postcut_43base.json", + "utc": "2026-10-16T00:12:38.276Z" + }, + { + "bytes": 182840, + "head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "path": "research/gmx-t74-borrow43-handoff/new/borrow/inputs/postcut_43extra.json", + "pr": "2767", + "sha256": "604c15ef0955065c8a3a8376e7d3c77bc7d6af3c39e8647ad71f34bb66f0e989", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e8b771ba132fe632796b28c1742a8d096c04519f/research/gmx-t74-borrow43-handoff/new/borrow/inputs/postcut_43extra.json", + "utc": "2026-10-16T00:12:38.421Z" + }, + { + "bytes": 71221, + "head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "path": "research/gmx-t74-borrow43-handoff/new/borrow/words/BORROW-WORD-43base.json.gz", + "pr": "2767", + "sha256": "f619788dafe250ab5dba109fb942e1f40c17057f4107f591219fcfeed606b202", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e8b771ba132fe632796b28c1742a8d096c04519f/research/gmx-t74-borrow43-handoff/new/borrow/words/BORROW-WORD-43base.json.gz", + "utc": "2026-10-16T00:12:38.278Z" + }, + { + "bytes": 71218, + "head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "path": "research/gmx-t74-borrow43-handoff/new/borrow/words/BORROW-WORD-43extra.json.gz", + "pr": "2767", + "sha256": "8b9e5200a059ebd07fb19fb3c7f6dd0409b15e4a047425892ec9a391e3c8a921", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e8b771ba132fe632796b28c1742a8d096c04519f/research/gmx-t74-borrow43-handoff/new/borrow/words/BORROW-WORD-43extra.json.gz", + "utc": "2026-10-16T00:12:38.282Z" + }, + { + "bytes": 1374, + "head": "f1826afe1f487333f2c1e5bf862bae2211ce8dd9", + "path": "research/replica-tail-gain/CLAIM.json", + "pr": "2824", + "sha256": "7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/f1826afe1f487333f2c1e5bf862bae2211ce8dd9/research/replica-tail-gain/CLAIM.json", + "utc": "2026-10-16T00:12:38.444Z" + }, + { + "bytes": 6652, + "head": "ca5eead6afd871614ceb635679edbcc3d04b9d8c", + "path": "research/t74-cold-host-restoration/README.md", + "pr": "2823", + "sha256": "ea2d85d8dda495b92c63b7822ab97835fb964f1e2c58a91b048547ca1bcaeeef", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/ca5eead6afd871614ceb635679edbcc3d04b9d8c/research/t74-cold-host-restoration/README.md", + "utc": "2026-10-16T00:12:38.403Z" + }, + { + "bytes": 14, + "head": "ca5eead6afd871614ceb635679edbcc3d04b9d8c", + "path": "research/t74-cold-host-restoration/PROOF.md", + "pr": "2823", + "sha256": "d5558cd419c8d46bdc958064cb97f963d1ea793866414c025906ec15033512ed", + "status": 404, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/ca5eead6afd871614ceb635679edbcc3d04b9d8c/research/t74-cold-host-restoration/PROOF.md", + "utc": "2026-10-16T00:12:38.199Z" + } + ], + "titles_count": 125, + "titles_utc": "2026-10-16T00:03:35-00:03:38Z" +} diff --git a/research/tensor-block-kappa/references/CURRENT-PRIMARY-BODIES.json b/research/tensor-block-kappa/references/CURRENT-PRIMARY-BODIES.json new file mode 100644 index 0000000000..37120cfb52 --- /dev/null +++ b/research/tensor-block-kappa/references/CURRENT-PRIMARY-BODIES.json @@ -0,0 +1,20 @@ +[ + { + "body": "Change and mathematical scope The J-dim1 hosting lead predicts a gain only if the merged host can be restored below full width. This package resolves its free-operator cancellation and certifies why direct contiguous restoration fails on the pinned words. No new \u03ba or admitted supplier is claimed. An explicit inverse prelude and terminal undo restore 473\u2192277 in both orientations under the unchanged algebra/frame auditor. The resulting FULL9 buffer is rejected by the pinned native transport; this is a constructive local component. For 184 words (92 pairs, both orientations), all 131,788 direct insertion slots require rank at least eight. All 8,208 rank-eight gate orders in 720 commuting classes have explicit target-port end-frame witnesses. Enlarging other helper ends alone cannot remove those witnesses. A separate 992-variant entry-hyperplane census checks 368,218 slots; every variant requires rank nine. Exact rational duals over 1,163 patterns reject the conditional width-nine/\u2212H3 ledger, including batches of one, two and four. Ideal restored width-seven/eight ledgers leave less than 0.017959/0.005786 H1-equivalent extra net cost per call at the pinned comparison point. These budgets do not establish realizable words or chronological owners. Staged recovery, changed bases, changed scalar words and changed interfaces remain outside the obstruction. No complete native supplier, stock/precision, literal-owner or outer admission is provided. Task and overlap Task complex-new-helper-inventory , refined to the user-assigned cold-host restoration obligation. The full cost ledger, stopping decision, source pins and overlap coverage are in research/t74-cold-host-restoration/TASK.json . Publication base: cfddb8581e7e96d4f4cd9bfd279037014c8b296d , priority revision 5. Scientific inputs remain pinned to the J leads branch , based on #2802 at 17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd . Related borrowing sources: #2745 and #2767 . The submission refresh covered all 705 open PR records and 1,466 Discussion records. New #2818 at 175822aee7a1858ec653f7f92d7a750aec2c2795 has identical complete words and allocation data to #2802 and claims a finer endpoint. Its endpoint certificate was not rerun here; it adds no cold-host mechanism. The present obstruction remains applicable to those words. No matches in titles/bodies/discussion records is not a universal novelty claim. Validation Python 3.12, standard library only: python3 -B scripts/research_package.py --package research/t74-cold-host-restoration The replay authenticates the package and consumed sources, reconstructs all 184 words, checks the full finite censuses, executes the unchanged operator auditor, and checks 20 rational duals plus ten integer-pattern root brackets. It includes positive fixtures, semantic/frame/cost mutants, and expected native rejection. Imported bytecode uses a fresh cache namespace. Frozen predecessor evidence is unchanged. The registered replay and a second full replay from a read-only Git export both passed; the latter also planted valid stale bytecode and confirmed the package entrypoint ignores it. All 53 staged files preserve their checked bytes. Only README/TASK freshness metadata changed afterward; source and certificate bytes are identical. Credit Marius-Paul Dumitrean's J lead, #2802 and #1186 toolkit, with the assistance disclosed in those sources; tekuuu/ #2751 , DavidAriasC/ #2766 , mason-hale/ #2696 , Cinna Davis/ #2226 , philippeVV/ #2679 , Jeremy Kothe and the retained borrowing/native/owner/outer lineage. Original notices and exact source bytes are retained. This package was prepared with substantial OpenAI Codex assistance, including three parallel agents and a separate integration replay; no independent human or proof-assistant review is claimed. Open next questions See the package README: the smallest useful follow-up is staged or precomputed recovery for 473\u2192277 that avoids the target-port collision and supplies an actual paid profile within the width-eight budget. A profitable sub-full word must then pass native, stock/precision, literal-owner and outer checks.", + "head": "ca5eead6afd871614ceb635679edbcc3d04b9d8c", + "html_sha256": "93ff862ed92386436e8afa6743fed2cc909f0d7c6efdb3416d1b3b761497454e", + "number": 2823 + }, + { + "body": "Summary Conditional \u03ba = 0.001717794984118634663827229918428178904088584385462312200900\u2026 (3046 decimals; the exact value is kappa in research/gmx-t74-borrow43-handoff/outer/OUTER-CLAIM.json , SHA-256 of the decimal string 94b67ffa5832fb500a87936e1ac7b915eab03301cb73f014c29c3b4da9a3677d ). This package is PR2802's (mdumitrean, Marius-Paul Dumitrean) construction, unchanged: seven retired-lender aliases (606<-550, 635<-551, 637<-552, 638<-553, 639<-562, 667<-401, 669<-403) and two hostee moves (401->564, 403->565) on PR2751's (tekuuu) twelve-alias words with PR2766's (DavidAriasC) frame refit; its words, owner fill, order and dispatch are PR2802's (local profile {1:2382, 2:648, 3:268, 4:128, 5:26, 8:8}, leftover idle {1:17316, 3:6594, 5:9878, 32:1, 48:26558}). Our contribution is only the finer endpoint certificate (the supplier endpoint certified to 1e-3000 and the fixed-grid-maximum outer kappa C - 1/F - B, as PR2767 did over PR2766) and the integration into our verifier: the construction as one declared patch stage retired7 with tamper controls, our guards and private-buffer accounting, PR2768's (tekuuu) exact sparse native replay as the default native stage, and a stale-bytecode guard after PR2788 (jeremydiviney). Prepared by Jeremy Kothe (jeremykothe2), with AI assistance. Conditional final kappa = 0.0017177949841186346638272299184281789040\u2026(3046 digits) (supplier strict-assembly kappa 0.0017148492247218876758214032268877614551\u2026(2995 digits)). It exceeds PR2802 (exact kappa_decimal from its claim) by 2.29918E-25 only through the finer endpoint grid; the construction gain is PR2802's (exact gate in verify_release.py). grid_digits 2995, margin_digits 3005, bootstrap_steps 1116; 63 strict inequalities, 17 rejecting controls. Verification Fresh checkout of 175822aee7a1858ec653f7f92d7a750aec2c2795 . Manifest: ee9c141a4e65c2c3769384bf4458c9d38007c7bd806ca6795c8c2b49a60fc484 . PASS package manifest: 539 files Supplier: the package's own unchanged verify.py (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION , native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 171779498411863466382722991842... brackets the ledger's b = 1717794984118634663827229918428178904088\u2026(3078 digits)/1000000000000000000000000000000000000000\u2026(3081 digits). Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017177949841186346638272299184281789040\u2026(3046 digits) (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-3080, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 3000-digit rejection call). Full package-owned verification passed in 292.19 seconds. The fresh receipt binds the exact package manifest and score. See research/gmx-t74-borrow43-handoff/README.md for reproduction commands and proof qualifications. Credits PR2802 (mdumitrean, Marius-Paul Dumitrean): the construction, credited first: seven retired-lender aliases and two hostee moves, their words, owner fill, order, dispatch and certified frames (new/borrow/inputs/retired7_43*.json). Our contribution is only the finer 1e-3000 endpoint certificate and the verifier integration. PR2751 (tekuuu): the twelve-alias reassignment; PR2768 (tekuuu): the exact sparse native replay (new/fastnative/), with PR662 (Charles Bethin) tables and the PR1029 (Ali Romman) sparse evaluator. PR2766 (DavidAriasC): the frame refit of PR2751's words (priority over PR2767, which has the same construction value on a finer grid); PR2733 (mdumitrean) found the same refit concurrently. PR2788 (jeremydiviney): the stale-bytecode finding (code/pyc_guard.py, with a planted-.pyc control). GaugeFix: the Theorem 4.1 correction applied to outer/GAUGEFREE-INTERIORS.md and outer/check_gaugefree.py. PR2696 (mason-hale), PR2679 (philippeVV), PR2588 / PR2530 (zxv), PR2621 (themilkman216) and PR2559 (philippeVV): the lineage. Jeremy Kothe (jeremykothe2), with AI assistance: the 1e-3000 endpoint certificate and the integration. PR2696 (mason-hale): the concentrated eight-lender source-partner assignment (new/borrow/inputs/alias8_43*.json) and its construction. PR2679 (philippeVV): the six pre-life hostings, the frame refit and the retired-lender alias 653<-563 (new/borrow/inputs/prelife_43*.json, refit563_43*.json, alias1_43*.json; word_patch.py and rebuild_borrow.py stages and controls), the base package, and the owner-fill evacuation method of PR2559. PR2588 (jeremykothe2) and PR2530 (zxv): the words they build on (the eight source-partner aliases, the helper-label swap) and the realize flows. PR2621 (themilkman216): the priority re-ordering idea applied here to the call order. PR2733 (mdumitrean): concurrent independent work with the same composition (concentrated assignment plus pre-life hosting); our refinement is the 1e-3000 endpoint grid. Jeremy Kothe (jeremykothe2), with AI assistance: stacking PR2696's assignment with PR2679's hostings and alias, the priority-ordered window-optimal fill (the offset search for the order and the fill) and the integration. PR2530 (zxv): the eight source-partner aliases, the order, the words and the starting owner map (new/borrow/inputs/alias8_43*.json, new/borrow-fill/ORDER.json, DISPATCH.json, independent_core.py). PR2559 (philippeVV): the owner-fill evacuation method, and the portability fixes (line endings, receipts outside the package, re-derived controls, dependency declaration) reused here; philippeVV's audit of PR2474. Jeremy Kothe (jeremykothe2), with AI assistance: running the evacuation on PR2530's owner map (new/borrow-fill/FILL.json.gz) and the integration. PR2436 (tekuuu): the lifted-target aliases and the A-phase prelude mechanism that PR2530 extends. PR2322 (Vlado Vojdanovski): the handoff construction; PR2435/PR2447/PR2462/PR2474/PR2526 and PR2312 (ours): the entrance raise, the supplier chain and the borrowed words. PR2478 (mdumitrean) and PR2508 (ywz65): the cut-centre and helper-index guards. PR2309 (Dugongue) and PR2315 (thakrarsagar): private-stock accounting; PR2301 (navinor / Aaron Wang) and PR1959 (Josie Elliston): pooled-slot time binding; PR2161 / PR2180 (dataisfire): fixed-grid maximum; PR2168 / PR2184: exact-integer coarse exponential. PR2226 (Cinna Davis / 1337isnot1337 with OpenAI Codex): anticipatory dirty borrowing. PR1786 (chafreaky / Chafik Boukhalfa): fine source-prime padding, its proof and checks, vendored under vendor/pr1786; Tim Trudgian: effective prime number theorem (arXiv:1401.2689). PR1673 (Vlado Vojdanovski, with AI assistance): capped phase-cell fusion outer construction, its proof and exact evidence, vendored under vendor/pr1673. PR1758 (IdeaOuter and contributors): fractional-shift gauge-free interiors, accretive shallow-circuit lemma, per-visit tag accounting. Jeremy Kothe and contributors (PR1731 ledger lineage, radix-union schedule), LeverRank (independent schedule simulation), Gohberg, Semencul, Kailath, Kung, Morf, Bitmead, Anderson, Pan (structured Toeplitz-like algorithms of the retained alternative), Francois Le Gall et al. and Chafik Boukhalfa (PR1699). Supplier: PR1625 (mdumitrean), PR1661 (midhatn), pivot-554 kernel (PR1672 lineage) and the PR1319/PR1297/PR1274/PR1286 lineage as in earlier packages. PR1956 (Josie Elliston: the bootstrap-cutoff carry finding and repair), PR1897 (M6LI), PR1876, PR1875 and PR1828 (rohanarun): the endpoint and slack refinements that this package exceeds; rohanarun also PR1319 and PR1297; chafreaky PR1786; Vlado Vojdanovski PR1673; mdumitrean PR1625; midhatn; philippeVV PR1519 (odd-term Mercator finding); Kothe and the existing lineage. PR1964 (thakrarsagar / Sagar Thakrar): Lemma G label and adapter-rule checks and the X/Y/Z adapter mutants (code/lemmag_checks.py), Lemma G by DreamingOfClouds (PR509 / PR516). PR2161 / PR2180 (dataisfire, OpenAI Codex-assisted): the fixed-grid maximum point and its proof, re-derived at this endpoint; PR2044 (Kothe) free-epsilon refinement they stack on; PR1786 (chafreaky / Chafik Boukhalfa) and PR1673 (Vlado Vojdanovski) ledger formulas. PR2168 / PR2184 (dataisfire): exact-integer coarse exponential and its one-site derivation. PR2309, PR2302 and PR2265 are the records exceeded. PR2286 (thakrarsagar) side-condition audit and philippeVV (PR1897 / PR2044 comments): the text defects (minimum-margin claim, xi aside, HALO K0^2 branch, p^10 umbrella, vacuous or-True guards, stale xi digits) corrected in outer/FINE-PADDING-COMPOSITION.md section 4, outer/check_ledger.py, outer/struct_check.py and outer/check_gaugefree.py. Jeremy Kothe (jeremykothe2), with AI assistance: change of the lender of alias 651 to 530 and dropping of alias 653, the exact owner fill for the new width inventory, the exact frame re-solve of both borrowed words and the exact kernel search and pricing, new work in this package (new/borrow/inputs/refit_43*.json, kernel_43*.json, new/borrow-fill/FILL.json.gz). PR1625 (mdumitrean): the helper-donor kernel shape reused here at pivots 518 and 506. PR2309 (Dugongue): concurrent independent work, a 44th dirty alias with owner repacking that also borrows from lender 530; the leader this package exceeds. PR2301 (navinor / Aaron Wang) and PR1959 (Josie Elliston): the unbound pooled-slot time field, bound in code/audit_allcold.py here. PR2315 (thakrarsagar): the audit finding that the private cleanup buffers must be charged. PR2309 (Dugongue): the private-stock accounting (physical stock, CLEAR charges, warp routing reserve, adapter bound, controls) ported here.", + "head": "175822aee7a1858ec653f7f92d7a750aec2c2795", + "html_sha256": "65eef87e2080e4c9d6cf6a2f7de494f0fe529ffdbc8f5757f3f26e12b8e20691", + "number": 2818 + }, + { + "body": "The complete T94 allocation raises the conditional finite-supplier headline from PR2802's 0.001717794984118634663827 lower certificate to 0.0017177951600320121074069999999999999999999998999999999999999999999999. The exact gain is 8795668872179/50000000000000000000000. Increasing replicas 74 to 94 amortizes the same explicitly charged positive residue; 345,168 literal owner roles compose with the credited retired7 native construction. Both changed native providers freshly passed all five stages; unchanged retained providers/parent were reused only after exact source, word, full-cache and receipt checks. All changed T94 source events, owner geometry, physical invoice, ordinary bootstrap and modern outer/full release checks passed. Independent literal owners and directed rational moments passed seven geometry and five pricing corruptions. The Mathlib-only Lean 4.34.1 proof freshly passed kernel and complete 61-declaration transitive-axiom audit plus four real ownership/axiom fixtures. This retains inherited all-size/compiler/source-access/hosting/precision/tape/recovery/ordinary-recursion/bit-supplier/analytic-transfer hypotheses. The formal module certifies its universal paid-cost inequalities; finite release does not prove the full multiplication theorem. See FRONTIER.md for exact current pins, bounded overlap coverage and attribution. No selected-result record or public discussion was changed.", + "head": "f1826afe1f487333f2c1e5bf862bae2211ce8dd9", + "html_sha256": "8111fdc9afca4c4c9e001beed29ae33ed8f56e6a5f6cc7e028b1aef31e4203a0", + "number": 2824 + } +] diff --git a/research/tensor-block-kappa/references/CURRENT-RECENT-TITLES.json b/research/tensor-block-kappa/references/CURRENT-RECENT-TITLES.json new file mode 100644 index 0000000000..1381e15388 --- /dev/null +++ b/research/tensor-block-kappa/references/CURRENT-RECENT-TITLES.json @@ -0,0 +1,758 @@ +{ + "channel": "ordinary public HTML,not REST", + "main": "e24ccc79caa1943fb126c61b45032fefddf2d3f2", + "records": [ + { + "number": 2824, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "T94 retained-tail allocation on PR2802: conditional kappa 0.001717795160032012107407", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2824" + }, + { + "number": 2823, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Certify cold-host cancellation and fixed-word restoration obstructions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2823" + }, + { + "number": 2822, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Prove a ten-bit sufficient internal grid for the P104 physical dual", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2822" + }, + { + "number": 2464, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "KB1 supplier instantiation of the certified z4 typed echo: priced whole construction, exact moments and a < D/E, one hosting obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464" + }, + { + "number": 2821, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Prove exact numerical lifetimes for BIT validation prefix", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2821" + }, + { + "number": 2820, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Research audit: exact widths for all 255 P104 survivor projections (seed 67, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2820" + }, + { + "number": 2819, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Rank-9 realisations of the E8 pattern are B-form or the A2 family (classification; no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2819" + }, + { + "number": 2818, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Conditional \u03ba = 0.0017177949841186346638272: #2802's construction with a 1e-3000 certified endpoint", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2818" + }, + { + "number": 2478, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Verifier: audit_local.py accepts non-centre cut gates; additive guard and regression fixture (no new \u03ba)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2478" + }, + { + "number": 2817, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Research: transfer-coupled (5,1,1) 7q readout obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2817" + }, + { + "number": 2458, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Research: native binding for the P104 two-target correction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2458" + }, + { + "number": 2816, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Decoder floors, case (b) for every number of terms: one-sided P112 decoders cost \u2265 64 without corrections (unique optimum) and with \u2264 2 non-full corrections (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2816" + }, + { + "number": 2773, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "KB3c: 17-point cover audit - PR 2542's 'no 17-point set covers F2^7' against its own lemma table (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2773" + }, + { + "number": 2815, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Prove source-bound numerical lifetimes for BIT Layout", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2815" + }, + { + "number": 2814, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Research: transport terminal centre-error kernels through causal feedback", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2814" + }, + { + "number": 2409, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Tooling: 2.49\u00d7 faster production HPE audit via integer rows with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2409" + }, + { + "number": 2813, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Certify exact precision for the ADD-retimed P104 dual", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2813" + }, + { + "number": 2812, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Certify the QQ16 scratch sweep direction optimum", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2812" + }, + { + "number": 2811, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Price the rounded QQ16 pair with explicit Boolean circuits", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2811" + }, + { + "number": 2810, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Prove exact numerical peaks for BIT directory and ADD phases", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2810" + }, + { + "number": 2265, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Outer retune of #2260: #1673 capped phase-cell fusion outer on the selective-borrowing supplier, conditional \u03ba = 0.00168341258854\u2026", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2265" + }, + { + "number": 2757, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "P112 rank-57 cover with scoped rational decoder cost floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2757" + }, + { + "number": 2809, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Prove a fixed-tape lowering for the selected BIT caller", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2809" + }, + { + "number": 2808, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Implement the logical BIT outer borrowing wrapper", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2808" + }, + { + "number": 2807, + "source_html_sha256": "0d551d09c073f99cfcc5fdad8e96ee2165571e137bcb1dadfc0983156f0e0b32", + "title": "Bound finite dyadic registers for the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2807" + }, + { + "number": 1758, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Conditional \u03ba = 0.001679745508802299: gauge-free (fractional-shift) interiors, structured boundary solves and radix-distributed sparse-union schedule on PR1673's capped phase-cell fusion outer, pivot-566+554 T74 supplier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1758" + }, + { + "number": 2806, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Decoder floors, closures: punctured E8 units (Model C) for 48 \u2264 p \u2264 56, all m (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2806" + }, + { + "number": 2802, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Conditional \u03ba \u2248 0.001717794984118634663827: two hostee moves and seven retired-lender aliases on #2751's joint twelve-source words", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2802" + }, + { + "number": 2805, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Research: read-only transported shears for the native covariant reader", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2805" + }, + { + "number": 2530, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Conditional \u03ba \u2248 0.0017137379215475043 from source-partner lifetimes and physical rehosting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2530" + }, + { + "number": 2804, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Independent verification (no \u03ba): #2530's source-partner words exact through cleanup and endpoint; stock, endpoint enclosure and \u03ba composition reproduce; no defect found", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2804" + }, + { + "number": 2803, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Fix strict replay comparison of large JSON integers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2803" + }, + { + "number": 2260, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Improve conditional \u03ba to 0.0016805 with selective dirty borrowing and physical owner repacking", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2260" + }, + { + "number": 2244, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Paper-side line counts per dimension: Lagrangian bound v \u2264 T(2^k\u2032+1) with exact ladder D4/D6/E7/E8 and no-gos scoped to windows h \u2264 13 (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2244" + }, + { + "number": 2801, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Bound caller numerical state at selected BIT adapter callbacks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2801" + }, + { + "number": 2799, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Research: certify terminal X/Y readout kernels for selected centre errors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2799" + }, + { + "number": 2493, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Batch Discussion overlap reads with complete pagination", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2493" + }, + { + "number": 2798, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Prove the P112 right-extension COPY floor with charged auxiliary terms", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2798" + }, + { + "number": 2797, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Independently audit PR2493 overlap pagination and cache failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2797" + }, + { + "number": 2796, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Audit the selected BIT child coefficient's numerical lifetime", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2796" + }, + { + "number": 2795, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Prove five-root minimum for eight-source paired-call connectors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2795" + }, + { + "number": 2794, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Prove exact optimal QQ16 streaming sweep directions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2794" + }, + { + "number": 2793, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Research: prototype faster selected-record source binding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2793" + }, + { + "number": 2792, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Preserve assertion checks in historical replay children", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2792" + }, + { + "number": 2790, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Prove an operand-preserving eight-tape multiplier with paid copying and head return", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2790" + }, + { + "number": 2788, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Bind T74 width-cap arithmetic execution to authenticated source bytes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2788" + }, + { + "number": 2269, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Conditional \u03ba = 0.001696247139058474: capped phase-cell fusion outer (PR1673) on the T74 supplier with anticipatory dirty borrowing (PR2226, 43 high-helper aliases) on the T74 pivot-566+554 supplier: conditional kappa 0.0016962471390584742\u2026", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2269" + }, + { + "number": 2786, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Implement compatible-row padding for the logical BIT caller", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2786" + }, + { + "number": 2784, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Decoder floors, case (c): the A2 family of non-B-form rank-9 realisations (P112 \u2265 64, #968 P104 \u2265 56, E8 \u2265 72; no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2784" + }, + { + "number": 2782, + "source_html_sha256": "fb2b323425e72d92191bd0212d82074218de7ac02692ba4056730f8989ce1a32", + "title": "Research: positive half-integral Gram decoder barrier and exact paired-plane C5 gate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2782" + }, + { + "number": 2781, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Bound complete selected BIT adapter numerical lifetimes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2781" + }, + { + "number": 2780, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Prove paid return of every physical head for the clean six-tape multiplier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2780" + }, + { + "number": 2676, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Stop direct script trees on scheduler exceptions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2676" + }, + { + "number": 2162, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "\u2708\ufe0f Characteristic-2 shadows of rank-3 decoders: the anti-Fano bound by first-order jets, with a Lean-checked core (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2162" + }, + { + "number": 2779, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Research: partitioned independent-walks 7q readout obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2779" + }, + { + "number": 2778, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Bound numerical storage during selected BIT form construction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2778" + }, + { + "number": 2747, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "F-star residue (i): mixed anchor-repair-pivot lemma MX, tied-instance certificates, and a tied-domain search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2747" + }, + { + "number": 2776, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Realize all-size ordered shears on fourteen fixed tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2776" + }, + { + "number": 2639, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Decoder floors, closures: punctured E8 units (Model C) to p = 46 (all m) and p \u2264 56 (merged m \u2265 8), windows h = 10\u201311 (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2639" + }, + { + "number": 2775, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Prove complete clean six-tape multiplication and eight explicit applications", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2775" + }, + { + "number": 2774, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "F-star residue class (ii): non-3-dichromatic zero digraphs - matched-pivot floor, fixture dichromatic structure, smallest-first falsifier search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2774" + }, + { + "number": 2077, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Research: four helper placements improve selected T16 kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2077" + }, + { + "number": 2375, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Tooling: 3.09\u00d7 faster production frame-pair enumeration via eight-bit neighborhoods with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2375" + }, + { + "number": 2772, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Certify a whole-word internal grid for the physical P104 dual", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2772" + }, + { + "number": 2771, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Bound rounded native-line defects for the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2771" + }, + { + "number": 2411, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "[Lean] Link an end-to-end proof of multiplication below n log n", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2411" + }, + { + "number": 2770, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "research(bit): bound numerical callback word lifetimes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2770" + }, + { + "number": 2768, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Tooling: 3.57x faster complete T74 native replay with unchanged exact coverage", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2768" + }, + { + "number": 2767, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Conditional \u03ba = 0.001717256973467002: post-cut partner correction on #2696's lender assignment with #2679's pre-life hosting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2767" + }, + { + "number": 2769, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Park recursive numerical banks on two fixed tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2769" + }, + { + "number": 2357, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Tooling: 2.26\u00d7 faster production emitted-local audit via integer rows with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2357" + }, + { + "number": 2766, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Improve conditional \u03ba to 0.001717256973467 with credited routing-frame fusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2766" + }, + { + "number": 2765, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Certify masked E8 decoder padding transfers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2765" + }, + { + "number": 2764, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Research: dirty-parity collapse extends to eight queries (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2764" + }, + { + "number": 2763, + "source_html_sha256": "dec25c68242589a6516a064c8be602e2418a465ad2c3b0af5982b9c496397620", + "title": "Audit centre-source coefficients with an independent adjoint and sign control", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2763" + }, + { + "number": 2762, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Census round 2: screening results for the 16 uncovered open complex claims (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2762" + }, + { + "number": 2761, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Research: multi-connector / priced-shadow 7q readout obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2761" + }, + { + "number": 2760, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "docs(research): map selected BIT caller and storage obligations", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2760" + }, + { + "number": 2329, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Tooling: 3.15\u00d7 faster production Clifford zero_state via gate tables with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2329" + }, + { + "number": 2759, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Certify sharp numerical scratch bounds for BIT arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2759" + }, + { + "number": 2758, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Bound serialized continuation storage in the selected BIT evaluator", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2758" + }, + { + "number": 2276, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Tooling: 6.47\u00d7 faster production R420 mutants geometry cache with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2276" + }, + { + "number": 2263, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Tooling: 3.18\u00d7 faster production R420 xcheck.rref via integer elimination with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2263" + }, + { + "number": 2756, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Audit when exceptional repair can use independent batches", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2756" + }, + { + "number": 2753, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Complete all-size logical BIT caller and recursive storage bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2753" + }, + { + "number": 2733, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Improve conditional kappa to 0.00171625567823018 with composition and a frame refit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2733" + }, + { + "number": 2754, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Prove exact internal rounding for one P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2754" + }, + { + "number": 2752, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "fix(replay): support source-pin checks on older Git", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2752" + }, + { + "number": 2751, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Conditional kappa \u2248 0.00171714158635 via joint twelve-source recovery", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2751" + }, + { + "number": 2746, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Docs: correct attribution credit lines in merged research packages", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2746" + }, + { + "number": 2717, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "F-star proof-level lemmas: structural certificates, named-instance L8 reproduction, and a beyond-census falsifier search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2717" + }, + { + "number": 2749, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Bound count-tape storage for the first selected BIT node", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2749" + }, + { + "number": 2748, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Bind all non-cold k8 HPE wrapper events to Lean recipes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2748" + }, + { + "number": 2745, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Conditional \u03ba = 0.001716140425997441: #2696's lender assignment with #2679's pre-life hosting and a window-optimal fill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2745" + }, + { + "number": 2595, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "KB1b: the ERASE deferral is not necessary \u2014 legal per-call COPY/ERASE windows keep the typed-echo pair saving (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2595" + }, + { + "number": 2744, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Audit P104 consumer cost credits and the PR2725 stopping decision", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2744" + }, + { + "number": 2743, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Bound complete BIT node data content, including remainder peel", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2743" + }, + { + "number": 2742, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Construct a native covariant action on the full dirty reader", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2742" + }, + { + "number": 2741, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Prove the all-pair P104 consumer budget obstruction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2741" + }, + { + "number": 2740, + "source_html_sha256": "d33241243d00ee9b6a86c2d5e3b7005f5d52d0468a5683d1d7b5ee1ecd012139", + "title": "Research: rule out uniform dirty-padding exchange adapters", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2740" + }, + { + "number": 2738, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Prove exact Coxeter tariffs with arbitrary dirty workspace", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2738" + }, + { + "number": 2634, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "KB3b: seven-source singleton f(7) continued - parity closes L=19, beating templates closed, cover/walk dichotomy, resumable 20-cycle census (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2634" + }, + { + "number": 2542, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Research: seven-source singleton universal path \u2014 length 18 excluded, f(7) >= 20 (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2542" + }, + { + "number": 2518, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Research: polar-law screens at T >= 7 and a small-T overcomplete census (scoped negatives)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2518" + }, + { + "number": 2444, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Exact-search tooling for noncommuting words, and a complete six-distinct-value screen of the KB2 thirteen-call candidate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2444" + }, + { + "number": 2427, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Research (no kappa claim): classical Pappus/Desargues T=3 pairing-cost census \u2014 no cost < v falsifier; tight atoms through v = 6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2427" + }, + { + "number": 2255, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Audit: live-byte source-pin drift after merged replay-speed tooling (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2255" + }, + { + "number": 2737, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Name offending keys in research package checks and support PR-head pins", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2737" + }, + { + "number": 1076, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Tooling: batch exact rows for the quadratic-affine rank witness (8.4x faster check, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1076" + }, + { + "number": 2736, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Research: bound completed errors in the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2736" + }, + { + "number": 2705, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "KB1c: admission-ready evidence for the typed-window z4 typed-echo schedule (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2705" + }, + { + "number": 2735, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Prove the fixed dyadic Omega channel profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2735" + }, + { + "number": 2734, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "perf: copy and hash historical replay inputs in one pass", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2734" + }, + { + "number": 2257, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Tooling: 5.36\u00d7 faster production frameopt.close via one-basis modular closure with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2257" + }, + { + "number": 2724, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Decoder floors, case (b): nine terms outside col M (P112 \u2265 64, #968 P104 \u2265 56; no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2724" + }, + { + "number": 2665, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Demonstrate deterministic rounding residue in a P104 native collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2665" + }, + { + "number": 2731, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Certify sharp payload storage for selected BIT residuals", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2731" + }, + { + "number": 2361, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "ci: select affected verification inputs and preserve historical replays", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2361" + }, + { + "number": 2730, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Prove sharp mixed-grid cleanup for a physical P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2730" + }, + { + "number": 2235, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Add verified multitape foundations, compilers, dirty-frame callers and quadratic multiplication output", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2235" + }, + { + "number": 2729, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Certify P104 fusion overhead budgets at the selected saving", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2729" + }, + { + "number": 1175, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Conditional kappa 0.001675338871723469: whole-owner map at the packin\u2026", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1175" + }, + { + "number": 2728, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Formalize the selected BIT split-residual retractions and conjugation interface", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2728" + }, + { + "number": 2726, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Tighten completed P104 feedback with per-operand ideal norms", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2726" + }, + { + "number": 2725, + "source_html_sha256": "c060dd3ef75cf1f3ffac2fd99c08f97de22a4e80c011103a59ba3beca6b5f9d5", + "title": "Certify a two-register P104 endpoint ADD retiming", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2725" + } + ], + "unique_titles": 125, + "utc": "2026-10-16T00:03:35-00:03:38Z" +} diff --git a/research/tensor-block-kappa/references/FINAL-FRONTIER-SUPPLEMENT.json b/research/tensor-block-kappa/references/FINAL-FRONTIER-SUPPLEMENT.json new file mode 100644 index 0000000000..f18ea60674 --- /dev/null +++ b/research/tensor-block-kappa/references/FINAL-FRONTIER-SUPPLEMENT.json @@ -0,0 +1,175 @@ +{ + "channel": "ordinary public HTML and commit-pinned raw HTTPS", + "coverage": "Supplementary 25 updated-open-PR titles, actual new PR2825 primary body, and pinned new-main README/selected bytes; earlier 125-title and three-body coverage preserved.", + "main": "da4f4fec60a88d9187f8ffa02f0f787b8b2da527", + "primary_body": { + "body": "PR2821 leaves the first-range caller's child-entry, non-ADD and successful-return numerical lifetimes open. This source-bound proof closes those phases: child callbacks retain exactly 18 good / 19 fallback index Words above every Consumer.apply entry resident, including the fallback's zero half-width Word. Conditional on the unchanged credited component contracts, complete successful calls satisfy occupied non-LEFT numerical content <= (L_R+1)r + (L_I+1)i + max(37672r+34i, 20494r+41i). The two templates are charged once; r/i include RIGHT. The coordinatewise allowance is (37672 residues,41 indices) . Setup briefly reaches nine indices before retaining eight. The composed envelope is an upper bound, with no simultaneous/global sharpness claim. Validation at b553e912bcddef550d9fae6033041ff683399ebe : Registered CPython 3.12 replay: 386,856 caller trace events, 60 sampled callback entries, ten complete small Boolean primitive fixtures and 12 defect-control groups. Separate AI integer trace checker: 178,124 events, including all good ranks 1..42 and every ordered fallback endpoint pair; allocation/interior/return controls pass. All three commands pass in a read-only Git-free CPython 3.14 export with empty PATH. Source/proof bytes, typed receipts and effective stale-bytecode controls pass; selected-record bindings and post-commit metadata pass. The actual caller probe abstracts coefficient bodies and payload/record movement; the small primitive fixtures execute their complete payloads. Fixture metadata does not prove selected catalogue membership. The all-domain conclusion is the written conditional source proof, not a full GL64 execution, human/formal-kernel proof, physical reserve, supplier admission or new kappa. Next: join the nonnumerical/physical categories at the same chronological cuts and bind the larger recursive/outer consumer. Credit Jose Manuel/jmbarrancoml PR2697; Nick Petalas PR2759/2770/2778/2781/2801/2815; Arham Tahir PR2796; Ross Richardson PR2810/2821; David Arias and all retained source notices. New work by Ross Richardson with substantial OpenAI Codex assistance and a separate storage-lifetimes AI specialist, Apache-2.0. One new opt-in package; no predecessor or selected-frontier changes. Canonical investigation . Scientific base cfddb858 is deliberately retained; submission main fbdbcb53 at 2026-10-16 00:09 UTC had unchanged relevant guidance/selected/runner bytes and no package collision. Metadata overlap completely paginated 690 open PRs, 1467 Discussion records and 2105 local records at 00:09\u201300:12 UTC, no warnings; arbitrary diffs/unpublished work remain outside coverage. All six predecessor heads were rechecked unchanged. Hosted CI is a separate pending gate. Reproduce: python3.12 -I -B scripts/research_package.py --package research/selected-child-caller-lifetime . Task independent-moment , scope changed : the live PR2821 handoff replaces a redundant rank-root calculation with the missing caller-resident accounting implication. Exact runtime a53fdf4bcbe33c6732f0bec1badc8c023380f9d1 ; TASK and freshness , all exact dependency heads , and proof plus next questions provide the reviewable source boundary.", + "head": "b553e912bcddef550d9fae6033041ff683399ebe", + "number": 2825 + }, + "retrievals": [ + { + "label": "main", + "sha256": "28e53f8b7306fe8ad1ef88f89726df4e458bd1e89df129eadf0b01d9f8c46b02", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds", + "utc": "2026-10-16T00:20:50.183Z" + }, + { + "label": "pulls", + "sha256": "d723a9114f90b1338784f84737df449865ce971f407dff3b450964ad5e123be3", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc", + "utc": "2026-10-16T00:20:50.042Z" + }, + { + "label": "pr2825", + "sha256": "2fccc480b5a639884da695665fba6350d94e6c1807ab8b9fd54beb59e02e5854", + "status": 200, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2825", + "utc": "2026-10-16T00:21:22.515Z" + }, + { + "label": "README", + "sha256": "b9d94e1bc9ff9d1efe5b69e00963ee5d917cb376e36a453e0554742110ec0041", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/da4f4fec60a88d9187f8ffa02f0f787b8b2da527/README.md", + "utc": "2026-10-16T00:21:22.084Z" + }, + { + "label": "selected", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "status": 200, + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/da4f4fec60a88d9187f8ffa02f0f787b8b2da527/certificates/selected-result.json", + "utc": "2026-10-16T00:21:22.070Z" + } + ], + "titles": [ + { + "number": 2825, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2825", + "title": "Close the selected BIT caller numerical phase envelope" + }, + { + "number": 2824, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2824", + "title": "T94 retained-tail allocation on PR2802: conditional kappa 0.001717795160032012107407" + }, + { + "number": 2823, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2823", + "title": "Certify cold-host cancellation and fixed-word restoration obstructions" + }, + { + "number": 2822, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2822", + "title": "Prove a ten-bit sufficient internal grid for the P104 physical dual" + }, + { + "number": 2464, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464", + "title": "KB1 supplier instantiation of the certified z4 typed echo: priced whole construction, exact moments and a < D/E, one hosting obstruction (no new kappa)" + }, + { + "number": 2821, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2821", + "title": "Prove exact numerical lifetimes for BIT validation prefix" + }, + { + "number": 2820, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2820", + "title": "Research audit: exact widths for all 255 P104 survivor projections (seed 67, no new kappa)" + }, + { + "number": 2819, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2819", + "title": "Rank-9 realisations of the E8 pattern are B-form or the A2 family (classification; no \u03ba claim)" + }, + { + "number": 2818, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2818", + "title": "Conditional \u03ba = 0.0017177949841186346638272: #2802's construction with a 1e-3000 certified endpoint" + }, + { + "number": 2478, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2478", + "title": "Verifier: audit_local.py accepts non-centre cut gates; additive guard and regression fixture (no new \u03ba)" + }, + { + "number": 2817, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2817", + "title": "Research: transfer-coupled (5,1,1) 7q readout obstruction (no new kappa)" + }, + { + "number": 2458, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2458", + "title": "Research: native binding for the P104 two-target correction" + }, + { + "number": 2816, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2816", + "title": "Decoder floors, case (b) for every number of terms: one-sided P112 decoders cost \u2265 64 without corrections (unique optimum) and with \u2264 2 non-full corrections (no \u03ba claim)" + }, + { + "number": 2773, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2773", + "title": "KB3c: 17-point cover audit - PR 2542's 'no 17-point set covers F2^7' against its own lemma table (no new kappa)" + }, + { + "number": 2815, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2815", + "title": "Prove source-bound numerical lifetimes for BIT Layout" + }, + { + "number": 2814, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2814", + "title": "Research: transport terminal centre-error kernels through causal feedback" + }, + { + "number": 2409, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2409", + "title": "Tooling: 2.49\u00d7 faster production HPE audit via integer rows with identical receipts" + }, + { + "number": 2813, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2813", + "title": "Certify exact precision for the ADD-retimed P104 dual" + }, + { + "number": 2812, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2812", + "title": "Certify the QQ16 scratch sweep direction optimum" + }, + { + "number": 2811, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2811", + "title": "Price the rounded QQ16 pair with explicit Boolean circuits" + }, + { + "number": 2810, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2810", + "title": "Prove exact numerical peaks for BIT directory and ADD phases" + }, + { + "number": 2265, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2265", + "title": "Outer retune of #2260: #1673 capped phase-cell fusion outer on the selective-borrowing supplier, conditional \u03ba = 0.00168341258854\u2026" + }, + { + "number": 2757, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2757", + "title": "P112 rank-57 cover with scoped rational decoder cost floors" + }, + { + "number": 2809, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2809", + "title": "Prove a fixed-tape lowering for the selected BIT caller" + }, + { + "number": 2808, + "permalink": "https://github.com/CrocSwap/integer-mult-bounds/pull/2808", + "title": "Implement the logical BIT outer borrowing wrapper" + } + ], + "utc": "2026-10-16T00:20:50Z to 00:21:22Z" +} diff --git a/research/tensor-block-kappa/references/PINS.json b/research/tensor-block-kappa/references/PINS.json new file mode 100644 index 0000000000..ccbb655b9c --- /dev/null +++ b/research/tensor-block-kappa/references/PINS.json @@ -0,0 +1,73 @@ +{ + "baseline_historical": { + "files": 66, + "head": "e6df920cd0110e4b629e2ad84eddcb539001e174", + "manifest_sha256": "f8c288ab2f6e7faa89650d451168a16df8b6919c573f888a389f0d1c9e26cde4", + "pr": 2766, + "scope": "Historical source comparison, not the current native supplier or a required bundled input.", + "source_tree_url": "https://github.com/CrocSwap/integer-mult-bounds/tree/e6df920cd0110e4b629e2ad84eddcb539001e174/research/complex-routing-leaf-fusion" + }, + "coverage": { + "comments_complete": false, + "discussion_bodies": 296, + "fetched_unique_flat_comment_records": 631, + "limitation": "Comment fetching stopped on HTTP403/429. This is a bounded source comparison, not a novelty proof.", + "listed_discussion_comments_and_replies": 1140, + "open_pr_bodies": 723 + }, + "frontier": { + "ai_assistance_disclosed_upstream": "Anthropic Claude via Claude Code", + "author": "Marius-Paul Dumitrean", + "files": 124, + "head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "manifest": "../vendor/frontier/DOWNLOAD-MANIFEST.json", + "manifest_sha256": "fae7e9161707d3627c7ba444543b1bdd0d736df57b8495ea112bb221a2693497", + "pr": 2802, + "source_subtree": "research/t74-joint-twelve-retired7" + }, + "last_authenticated_main": "544a7e82810e30cab61c297cb2e2ea86127fe944", + "latest_normal_api_quota_check": { + "core_remaining": 0, + "limitation": "Normal endpoint still reported zero and a past reset; no further REST requests or bypass were used.", + "reported_reset_utc": "2026-10-15T23:02:16Z", + "rest_heads_newly_refreshed": false, + "retry_after": null, + "status": 200, + "utc": "2026-10-15T23:02:45.937Z" + }, + "main_pin_channel": "ordinary public repository HTML currentOid,2026-10-15T23:14:43.632Z", + "previous_authenticated_main": "84f8e607779b81c05edc962d4981d1f9b4b9bc9f", + "priority_revision_last_full_guidance_snapshot": 5, + "references": [ + { + "path": "PR2767-OUTER-CLAIM.json", + "sha256": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "source_head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "source_url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/e8b771ba132fe632796b28c1742a8d096c04519f/research/gmx-t74-borrow43-handoff/outer/OUTER-CLAIM.json", + "usage": "Exact full pending outer kappa rational used for strict candidate comparison." + }, + { + "path": "PR2802-CLAIM.json", + "sha256": "a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51", + "source_head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "source_url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/CLAIM.json", + "usage": "Current reviewed full pending outer kappa rational; author Marius-Paul Dumitrean." + } + ], + "repository": "CrocSwap/integer-mult-bounds", + "schema_version": 1, + "selected_result_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "snapshot_date_utc": "2026-10-15", + "supplemental_public_refresh": { + "bodies_fetched": 100, + "bodies_parsed": 100, + "channel": "ordinary public repository and PR HTML plus normal pinned raw", + "current_reviewed_highest_complete_supplier_pr": 2802, + "git_ls_remote": "Failed SEC_E_NO_CREDENTIALS; no config changes or credential attempts.", + "head_sha_fields": 100, + "main_readme_sha256": "b9d94e1bc9ff9d1efe5b69e00963ee5d917cb376e36a453e0554742110ec0041", + "recent_pr_records": "RECENT-PRS.json", + "recent_pr_records_sha256": "c56be4b596c83fe1a8c3d13172f34db8b90c85807822835647bc75606a26e045", + "selected_result_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + } +} diff --git a/research/tensor-block-kappa/references/PR2767-OUTER-CLAIM.json b/research/tensor-block-kappa/references/PR2767-OUTER-CLAIM.json new file mode 100644 index 0000000000..2bb218a750 --- /dev/null +++ b/research/tensor-block-kappa/references/PR2767-OUTER-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999", + "kappa_rational": "17172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999/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": "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/tensor-block-kappa/references/PR2802-CLAIM.json b/research/tensor-block-kappa/references/PR2802-CLAIM.json new file mode 100644 index 0000000000..2e64718924 --- /dev/null +++ b/research/tensor-block-kappa/references/PR2802-CLAIM.json @@ -0,0 +1,49 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717794984118634663827", + "complex_upper": "0.001717794984118634663828", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": "2751", + "comparison_head": "4cfbb0cc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2751, + "head": "4cfbb0cc", + "exact_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000" + }, + "comparisons": { + "2751": { + "kappa_source": "evidence/PR2751-CLAIM.json", + "exact_margin": "326698885104162859/500000000000000000000000", + "margin_float": 6.533977702083258e-07 + }, + "2766": { + "kappa_source": "evidence/PR2766-CLAIM.json", + "exact_margin": "538010651632355557/1000000000000000000000000", + "margin_float": 5.380106516323556e-07 + }, + "2767": { + "kappa_source": "evidence/PR2767-OUTER-CLAIM.json", + "exact_margin": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)", + "margin_float": 5.380106516323556e-07 + } + }, + "new_contribution": "two hostee moves (the hostees of B-warps 30/31 move from lenders 401/403 onto the free retired lenders 564/565) that free 401/403 for two more retired-lender aliases 667<-401 and 669<-403, on top of the five retired-lender aliases 606<-550, 635<-551, 637<-552, 638<-553, 639<-562", + "credited_refit": "the certified frame refit of PR2751's words (B1151 rank 6->5 plus A0-A11, B771-788, restore60; per call H1 -2, H2 +1) is PR2766's (DavidAriasC); PR2767 (jeremykothe2) reaches the same kappa by another route", + "local_predecessor": { + "package": "research/t74-joint-twelve-retired5 (local, unpublished; branch t74-joint-twelve-retired5 b295183e)", + "exact_kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "exact_margin": "385667783143020379/1000000000000000000000000", + "margin_float": 3.856677831430204e-07 + } +} diff --git a/research/tensor-block-kappa/references/PR2824-CLAIM.json b/research/tensor-block-kappa/references/PR2824-CLAIM.json new file mode 100644 index 0000000000..d3d320a2ce --- /dev/null +++ b/research/tensor-block-kappa/references/PR2824-CLAIM.json @@ -0,0 +1,29 @@ +{ + "calls": 846, + "comparison_head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "comparison_kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2802, + "complex_lower": "1717795160032012107407/1000000000000000000000000", + "complex_upper": "107362197502000756713/62500000000000000000000", + "gain": "8795668872179/50000000000000000000000", + "helpers_per_call": 408, + "kappa": "17177951600320121074069999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177951600320121074069999999999999999999998999999999999999999999999", + "live": 84224, + "physical": 84714, + "profile": { + "1": 2037168, + "2": 548208, + "3": 235104, + "32": 1, + "4": 108288, + "48": 33736, + "5": 34544, + "8": 6768 + }, + "rank_mass": 6118272, + "replicas": 94, + "roles": 345168, + "scope": "Complete conditional finite supplier and modern outer release. Inherited all-size compiler/source-access/hosting/precision/tape/recovery/ordinary-recursion/bit-supplier/analytic-transfer contracts remain. Mathlib proves the stated universal paid-cost inequalities, not the complete multiplication theorem.", + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA" +} diff --git a/research/tensor-block-kappa/references/PREDECESSOR-T104-CLAIM.json b/research/tensor-block-kappa/references/PREDECESSOR-T104-CLAIM.json new file mode 100644 index 0000000000..20bdb186ef --- /dev/null +++ b/research/tensor-block-kappa/references/PREDECESSOR-T104-CLAIM.json @@ -0,0 +1,34 @@ +{ + "calls": 936, + "comparison_claim_sha256": "7a3de63f42f72564fdc3bd69a7269b7c364f67526ef76b18063241da59bfef52", + "comparison_head": "f1826afe1f487333f2c1e5bf862bae2211ce8dd9", + "comparison_kappa": "17177951600320121074069999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2824, + "comparison_pr2802": { + "gain": "238497953079371/1000000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000" + }, + "complex_lower": "858897611308293871599/500000000000000000000000", + "complex_upper": "1717795222616587743199/1000000000000000000000000", + "gain": "62584575635791/1000000000000000000000000", + "helpers_per_call": 408, + "kappa": "17177952226165877431979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177952226165877431979999999999999999999998999999999999999999999999", + "live": 93184, + "physical": 93674, + "profile": { + "1": 2253888, + "2": 606528, + "3": 260115, + "32": 1, + "4": 119808, + "48": 37325, + "5": 38219, + "8": 7488 + }, + "rank_mass": 6769152, + "replicas": 104, + "roles": 381888, + "scope": "Complete conditional finite supplier and modern outer release. Inherited all-size compiler/source-access/hosting/precision/tape/recovery/ordinary-recursion/bit-supplier/analytic-transfer contracts remain. Mathlib proves universal paid-cost inequalities, not the complete multiplication theorem.", + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA" +} diff --git a/research/tensor-block-kappa/references/PREDECESSOR-T94-CLAIM.json b/research/tensor-block-kappa/references/PREDECESSOR-T94-CLAIM.json new file mode 100644 index 0000000000..d3d320a2ce --- /dev/null +++ b/research/tensor-block-kappa/references/PREDECESSOR-T94-CLAIM.json @@ -0,0 +1,29 @@ +{ + "calls": 846, + "comparison_head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "comparison_kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "comparison_pr": 2802, + "complex_lower": "1717795160032012107407/1000000000000000000000000", + "complex_upper": "107362197502000756713/62500000000000000000000", + "gain": "8795668872179/50000000000000000000000", + "helpers_per_call": 408, + "kappa": "17177951600320121074069999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177951600320121074069999999999999999999998999999999999999999999999", + "live": 84224, + "physical": 84714, + "profile": { + "1": 2037168, + "2": 548208, + "3": 235104, + "32": 1, + "4": 108288, + "48": 33736, + "5": 34544, + "8": 6768 + }, + "rank_mass": 6118272, + "replicas": 94, + "roles": 345168, + "scope": "Complete conditional finite supplier and modern outer release. Inherited all-size compiler/source-access/hosting/precision/tape/recovery/ordinary-recursion/bit-supplier/analytic-transfer contracts remain. Mathlib proves the stated universal paid-cost inequalities, not the complete multiplication theorem.", + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA" +} diff --git a/research/tensor-block-kappa/references/RECENT-PRS.json b/research/tensor-block-kappa/references/RECENT-PRS.json new file mode 100644 index 0000000000..9b37eb4a0e --- /dev/null +++ b/research/tensor-block-kappa/references/RECENT-PRS.json @@ -0,0 +1,811 @@ +{ + "channel": "ordinary public HTML, not REST", + "records": [ + { + "head": "bfd6b68d1cd01913c7619f6b4115da8e584286f5", + "html_sha256": "9c8d1cbba0ed1b79d267a2546939a8c09e001db6f0f080514b571f77efff9964", + "number": 2813, + "primary_body_normalized_sha256": "dee38a56a1fb1c6d6cd5ee77245c815ddc5b72b7af606a1c3cd032202a687ebd", + "title": "Certify exact precision for the ADD-retimed P104 dual", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2813" + }, + { + "head": "02884bd5c8ec2f82c10ad2ff0378921f0a5279b4", + "html_sha256": "194da079f3fd39fff700d06bd6bde9b3ddaa6a5bd1fa81f64e43c299aeba21a9", + "number": 2812, + "primary_body_normalized_sha256": "fb8fffe500293cbf0e2191cade885e42c977d4a51f7d7c9dce4d135f00f01e6c", + "title": "Certify the QQ16 scratch sweep direction optimum", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2812" + }, + { + "head": "3d07cfe7f5035bccf7975616b0f3bd53a3b78ca8", + "html_sha256": "32bf3872faa5d69984f5458fb9d678bf372090844eb8ca4975b17a0a6927890e", + "number": 2811, + "primary_body_normalized_sha256": "d569b00f3e01299c3472296f60bad575e11c4326dcf422f13a61be9114d63e58", + "title": "Price the rounded QQ16 pair with explicit Boolean circuits", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2811" + }, + { + "head": "8abae69a53337dd3d0965db3470ab249b0216f22", + "html_sha256": "e0b50c75ebcd82b152e51c386632e9feb5aa6a4728948e2b691a083b66e09593", + "number": 2810, + "primary_body_normalized_sha256": "3f2310a1bc178efedf456951340fe02e453bbe4595b2172f446e34d64fc15f2e", + "title": "Prove exact numerical peaks for BIT directory and ADD phases", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2810" + }, + { + "head": "6b09c565887c400ca01fafb067bc9d855f1ef9fc", + "html_sha256": "5f88867efcf9d69317d8ee2a2e6dbd2213bfd36d5c905894b29bd5db0bed0d65", + "number": 2265, + "primary_body_normalized_sha256": "95e1f89a958ebba9f285159b60b5df53374ae7c937b1ef095b797682030f8a57", + "title": "Outer retune of #2260: #1673 capped phase-cell fusion outer on the selective-borrowing supplier, conditional \u03ba = 0.00168341258854\u2026", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2265" + }, + { + "head": "18da668a4f248f5c0cf3fc94355068ead4db3476", + "html_sha256": "570610c0b143dcd93472ee3fda7df286a4bf97c3b469d6764707e4f6df61bc11", + "number": 2757, + "primary_body_normalized_sha256": "d672c5514e652e174c40b498a952d51492d0825b03c2fb680c3d069e0aa47479", + "title": "P112 rank-57 cover with scoped rational decoder cost floors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2757" + }, + { + "head": "38af8fb25f6adb5fa7da145cd9a03d41c39fd5d0", + "html_sha256": "81af4fd85424abcce7e1838e0c7bbf4b0fe88d06d55ca885b89e3a5cdcb6978f", + "number": 2809, + "primary_body_normalized_sha256": "f06b6b7d9be35d3fbb93fce7229b23999c51d65fc91600c0c74fc1c37021b07a", + "title": "Prove a fixed-tape lowering for the selected BIT caller", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2809" + }, + { + "head": "b00b58e0db823643364f705b530faac254e7b05b", + "html_sha256": "e7272e9048f8f11e0afc9e5502ba14e99159745e11f60a7c6b2c6bc568b51504", + "number": 2808, + "primary_body_normalized_sha256": "6e0adac06d3a8e90892438935e6ff735f7875017d7aff5e6b165215def31b358", + "title": "Implement the logical BIT outer borrowing wrapper", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2808" + }, + { + "head": "6fbab8c4b95cdf75dfcbb33806c31349408d73a2", + "html_sha256": "66f1b6ae084f2581045dcf48115c262cadf349e66bbb80b0f2ca3f00b51560f6", + "number": 2807, + "primary_body_normalized_sha256": "eb95a7fe60736211f83ecc98947a115e0cda73bb073d1fcd3a1ab39340c314c9", + "title": "Bound finite dyadic registers for the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2807" + }, + { + "head": "7c2634c42c5f583b94244bba8e985ea32c19bdf0", + "html_sha256": "e6e8dac8c5e0cbbb6e126e185152996d5221cf84cf330598695780b091afd172", + "number": 1758, + "primary_body_normalized_sha256": "a28cc328f8a9fd5b5d2ecc1d4bc64f62f2370fe77678d84ecfc913e5a11d723a", + "title": "Conditional \u03ba = 0.001679745508802299: gauge-free (fractional-shift) interiors, structured boundary solves and radix-distributed sparse-union schedule on PR1673's capped phase-cell fusion outer, pivot-566+554 T74 supplier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1758" + }, + { + "head": "dc7b871a06ccdf5e94523ef991f704bc111905a8", + "html_sha256": "5c5edadaf3be27986a36286fcddc35700261cbcae8f9001c2fcada124e10811f", + "number": 2806, + "primary_body_normalized_sha256": "c615620d295506eec22c2db5cf4fa1dde2c3acd037e39dd14be07854f9fa54b8", + "title": "Decoder floors, closures: punctured E8 units (Model C) for 48 \u2264 p \u2264 56, all m (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2806" + }, + { + "head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "html_sha256": "ddec7bad9c50c6f54a83334a38a83592c20fd1d2e738e3b7da1a27c24005ae85", + "number": 2802, + "primary_body_normalized_sha256": "e55360b7eb8ba17d94470223eab8150f269c221b38721462b45c78120015a43c", + "title": "Conditional \u03ba \u2248 0.001717794984118634663827: two hostee moves and seven retired-lender aliases on #2751's joint twelve-source words", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2802" + }, + { + "head": "65da5e0c269346b00c2f389debfcb3a34d7590c6", + "html_sha256": "7546b5afa319c83ba1510e7b3be463424de75deaf34272ff352455fb684d2ee5", + "number": 2805, + "primary_body_normalized_sha256": "97befe2362eff1252f8d38edb9546f324b1a842d23c78d759166dcb65be24d22", + "title": "Research: read-only transported shears for the native covariant reader", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2805" + }, + { + "head": "b4012098048e12500b2d33d2e84be281915a27ac", + "html_sha256": "6e62626b56fe0f35d0a9bf38924fb214dd2d770c28392faa1e52d251aa3254ef", + "number": 2530, + "primary_body_normalized_sha256": "ad56b87029a1719a4504edb032a191fb4942bd30a57abcc1d79271ff77b8d667", + "title": "Conditional \u03ba \u2248 0.0017137379215475043 from source-partner lifetimes and physical rehosting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2530" + }, + { + "head": "feb727ba471b5dc3f057f867804aa70ae58b2e71", + "html_sha256": "e328d7a598bb8c96873e42563787b8ec1e8e1abb8c05640641d8a2c360c5a4f8", + "number": 2804, + "primary_body_normalized_sha256": "22bf1ccb2ea4763d9c1c18369b6e56136d5e7b2178763f13287a3c435e434804", + "title": "Independent verification (no \u03ba): #2530's source-partner words exact through cleanup and endpoint; stock, endpoint enclosure and \u03ba composition reproduce; no defect found", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2804" + }, + { + "head": "b3c4a186ecd743bbb9605596628da4b881b90121", + "html_sha256": "6b72805f199c7980f21e1309da3de1d8dc8dba65c167d8993baebb4ac49e96d4", + "number": 2803, + "primary_body_normalized_sha256": "8e0ce0c5d833be361601c18e54b9313b7bf04e53e1724a6739033ac16e894536", + "title": "Fix strict replay comparison of large JSON integers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2803" + }, + { + "head": "fde6b107e26a14da5bac5b66913c914708ea6901", + "html_sha256": "6574d46fee029585ad2cd44766498acef1d3e2a4ea69da02c040f86f19bfc502", + "number": 2260, + "primary_body_normalized_sha256": "e50eaeed86f5520f801769d79657f0f1eb3fb4b86f885258c40ee40456c1d4fa", + "title": "Improve conditional \u03ba to 0.0016805 with selective dirty borrowing and physical owner repacking", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2260" + }, + { + "head": "8ef6fa81403973d3cacaf865bdabe9797a6c34a0", + "html_sha256": "b1a860839a486c410675b814c935ee7ccfbd0460f7dabdbaec4bdb2636a083d4", + "number": 2244, + "primary_body_normalized_sha256": "ba89992120019fbfd9ecb309277859e24a4d653b866c090e0dbfcb7c9edb3de7", + "title": "Paper-side line counts per dimension: Lagrangian bound v \u2264 T(2^k\u2032+1) with exact ladder D4/D6/E7/E8 and no-gos scoped to windows h \u2264 13 (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2244" + }, + { + "head": "e2564b80b86fb77610b4b78701e5446a76fbe962", + "html_sha256": "983ef5a8ace26073e3c64bd3d8bab9ecc1d492c304d770afd9c913a879fa23b5", + "number": 2801, + "primary_body_normalized_sha256": "55555bc2258cd3de667db1e5935c8633483accd7c5a89608bdd191380d45c07a", + "title": "Bound caller numerical state at selected BIT adapter callbacks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2801" + }, + { + "head": "3401bcfce70ad5b692cd4d89e92955229f56c819", + "html_sha256": "2d5beb0c42793aeb978a5ea671c8730b0764f7642ba9719278801b838c04c40c", + "number": 2799, + "primary_body_normalized_sha256": "4149a075c90d283de93c5bd454aaa84e5363df168e8669128ea4a2f4abbb44ed", + "title": "Research: certify terminal X/Y readout kernels for selected centre errors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2799" + }, + { + "head": "a459ee34fad0488691beba8441e0a31e103b91a5", + "html_sha256": "a5a64e2ffb15c2b5e9b85e82338c01e8ce3408c03b8392004baa9f3553325f5a", + "number": 2493, + "primary_body_normalized_sha256": "0773a0898f2517aae63028612003d156af45ca2887be2178172defd75a55668c", + "title": "Batch Discussion overlap reads with complete pagination", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2493" + }, + { + "head": "116fa79ddc306ac2ba6cfeb920deddddef1fc54b", + "html_sha256": "da7eca74a36af0b4e3a625301d21751c9ab0023d50cd7dbfb80371c6c077961a", + "number": 2798, + "primary_body_normalized_sha256": "cd99ca39ada26e4100747f2e8b9e4d1f4ed752d7fc3db40b06351bc8b8ece41e", + "title": "Prove the P112 right-extension COPY floor with charged auxiliary terms", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2798" + }, + { + "head": "be479fd575307f3f60a5f41fd92af37c2fcf0af0", + "html_sha256": "19e773ead34623995302768dfb4fdf132cfc4fc45cab84397b4c4a72a2f203d8", + "number": 2797, + "primary_body_normalized_sha256": "8102e85e49b4607a454da1501cb6e19e45bc5ae885e96985bde25522f49abd93", + "title": "Independently audit PR2493 overlap pagination and cache failures", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2797" + }, + { + "head": "f9a6245cfdcae0b920fcbc9c79c4fb73a2706605", + "html_sha256": "8bf3acd6f1099bb031c7a47653c426f712736335e0b49f11e3e1d0a92a8eb0ce", + "number": 2796, + "primary_body_normalized_sha256": "696c76078229d605d46d8e0306d978a167612323273d979d45471825c683c6f6", + "title": "Audit the selected BIT child coefficient's numerical lifetime", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2796" + }, + { + "head": "fad52f9528cfea1c3bcfc0094ff56abf945d31a7", + "html_sha256": "9b520f5dd54b64ddf866346744ac6740bcd9a2cdab9d8b5da6b5ec1145c436da", + "number": 2795, + "primary_body_normalized_sha256": "66d8404acf72dd317c4b0575a5baf9a7e92cff843d1801ba514936e2e7c5da00", + "title": "Prove five-root minimum for eight-source paired-call connectors", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2795" + }, + { + "head": "fea29bf8d84242a4bf91fd8b243c7229a8c94c52", + "html_sha256": "5df196f2769dc929ecbd949d235005acdf30f4d1aecbe29408354af55f69f310", + "number": 2794, + "primary_body_normalized_sha256": "667c76b240986151513d83cc65021c2e48d00cc9b6360205c69b0d87e4c1ade2", + "title": "Prove exact optimal QQ16 streaming sweep directions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2794" + }, + { + "head": "d8b59acaa5133a525e88be64f60b658acbb3525c", + "html_sha256": "57140c58e06b5bc2ec9cf5ad37f7f83d8e05a5f57e7a4af7714e4a801b952714", + "number": 2793, + "primary_body_normalized_sha256": "d4191056fc741942cfdce060858ed7c2502011f36d2870b5b1a91acfbf4eb24a", + "title": "Research: prototype faster selected-record source binding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2793" + }, + { + "head": "6f68ca122aa6bdbcc9f22b0125fb96d321fa98d3", + "html_sha256": "3edcb9001649939759d3349f694cdf50b8597a007a6e8cd30e6e1fd785ad114b", + "number": 2792, + "primary_body_normalized_sha256": "c2a6a962b993ce9b0735054f8f4d276e2addb6e9e4f3dd3e09430b14e709bc52", + "title": "Preserve assertion checks in historical replay children", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2792" + }, + { + "head": "1a9b88273535cbe93cb6cb7ca95f38fdcfe548f3", + "html_sha256": "bbc7498b0a21863766cecc3067a62330e57c510515dbe4ec081ff784c93487d0", + "number": 2790, + "primary_body_normalized_sha256": "bff479c92215898ae3779f71184fd47547d119292cd406a5199de41698e4336a", + "title": "Prove an operand-preserving eight-tape multiplier with paid copying and head return", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2790" + }, + { + "head": "626ce8eddf5569d270a3422954f9a3ce90f16942", + "html_sha256": "e8292712fed73998ebe28d712a3fdbf0459abbac76ffe54998331d6af2029926", + "number": 2406, + "primary_body_normalized_sha256": "b189ab19838c6e18f81ad988200eb3c688940aa443165b1e222f58c58e879f3c", + "title": "Research: cap T74 scalar and handoff frame refits at b < 0.0016972", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2406" + }, + { + "head": "e28e84c9826ca583814e965dcc36d8e549963d58", + "html_sha256": "5479622748740bb302475af9057e3a162b0e1c763187395bdd7dd9b09916c32f", + "number": 2788, + "primary_body_normalized_sha256": "9e62f3c9261ae8dead0a85f8a8c10fa3f4c706af2d4cc201b4dace6f3e8e7d30", + "title": "Bind T74 width-cap arithmetic execution to authenticated source bytes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2788" + }, + { + "head": "b479fc5567bc09ab9185bffe89b62594f36d74e5", + "html_sha256": "e306fee215095ff3f14f3de4c7c5cbfbda058d45f498244d7204525af5ef2254", + "number": 2269, + "primary_body_normalized_sha256": "11b769284f96dde31591ff877cdc29bc0a698e01cf211a3c7055ce658b38cf4d", + "title": "Conditional \u03ba = 0.001696247139058474: capped phase-cell fusion outer (PR1673) on the T74 supplier with anticipatory dirty borrowing (PR2226, 43 high-helper aliases) on the T74 pivot-566+554 supplier: conditional kappa 0.0016962471390584742\u2026", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2269" + }, + { + "head": "80df2062cef303c05ffe89bb54b87b6b371d1253", + "html_sha256": "03a02842d4d47d0858da75c1e0748f3c752d48cda9dc99062bbe0e4d74fb9e53", + "number": 2786, + "primary_body_normalized_sha256": "7a574a9e3564f83467382338dc9be1945228ab9ac84dd1271d1ef2a798befc5d", + "title": "Implement compatible-row padding for the logical BIT caller", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2786" + }, + { + "head": "6189e005a41b9de025e0426c1ae0ec2c0583d15d", + "html_sha256": "a905014b6ac3d040738f0509a5436ed1dca332964f027c19ad18af1907f87862", + "number": 2784, + "primary_body_normalized_sha256": "976db1fd6d343b1fa3a471b44e2ada79be6e387483fe6b1f061a18ee848f61a2", + "title": "Decoder floors, case (c): the A2 family of non-B-form rank-9 realisations (P112 \u2265 64, #968 P104 \u2265 56, E8 \u2265 72; no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2784" + }, + { + "head": "002a9983079a3244c10221b4e16d0cff7e70da40", + "html_sha256": "7d0b7f80cce5c91a51695c7212512e1f7d5a1d16d5e40d8098ad79bac33121d2", + "number": 2782, + "primary_body_normalized_sha256": "ff44851385753857987b2d45bd8174a1cedc41e900f26f413de439cb661b6f61", + "title": "Research: positive half-integral Gram decoder barrier and exact paired-plane C5 gate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2782" + }, + { + "head": "9fdbd4b0429dbfcb4569f7768b66d318deacab6b", + "html_sha256": "ebda95393bd02994f19d8645ccc34df5d8e0fbe7391a1228ab28fc5f8a6c3325", + "number": 2781, + "primary_body_normalized_sha256": "3498af7ebd0975b98f25178d06ee06d727fd77baeceb5499ce4ec9fe7d61ef0b", + "title": "Bound complete selected BIT adapter numerical lifetimes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2781" + }, + { + "head": "59f336094958b51b312e54deb85347e1b671172d", + "html_sha256": "6ea2536d3dbd7abe36bc70b5d784edc46874d635829883f577fb1713d23de789", + "number": 2780, + "primary_body_normalized_sha256": "855416663c3a643d2d756bb5fa4f763b323f5dd95e7bb6881193d22e8ff95ada", + "title": "Prove paid return of every physical head for the clean six-tape multiplier", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2780" + }, + { + "head": "3b8da2aba852254686c2cc1a7c67f8caa93d2fdb", + "html_sha256": "efe079c058fece5c4acbeaa79ac29b80d7f2a509e1d0a9413cb9451975cf3601", + "number": 2676, + "primary_body_normalized_sha256": "117c5319958af4b55588e95295454c3cc902c7c93f253f752fb67586efaf9dd8", + "title": "Stop direct script trees on scheduler exceptions", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2676" + }, + { + "head": "642bfaf4325f0c8294ab72e8911c3eab4fea354f", + "html_sha256": "ef2248f1f56d957340ba6bb5f1e43e72d2183abe57adba50fda7284bdb76ebc5", + "number": 2162, + "primary_body_normalized_sha256": "0391ae82ba3450ab827b43073a5e08198e423b00fba66cf56e478c009b18a427", + "title": "\u2708\ufe0f Characteristic-2 shadows of rank-3 decoders: the anti-Fano bound by first-order jets, with a Lean-checked core (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2162" + }, + { + "head": "1f2a413f9e27ce9609924f7ab196548c4cbe43d8", + "html_sha256": "277131b5977e17439056635febeb0f501f9739c24559f66bd4d577718e3fa01e", + "number": 2779, + "primary_body_normalized_sha256": "f6f56ccaf30fd1cfbae6f9f003a6fb612d50caf267831fc48f520967e075689a", + "title": "Research: partitioned independent-walks 7q readout obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2779" + }, + { + "head": "6dfdbaa004540f5d89f390a9a78fa38c46d225d6", + "html_sha256": "8c7a6bf1e9f8fe76bebf87d082a56ad19b09f555995a256ca48c6a1be878174f", + "number": 2778, + "primary_body_normalized_sha256": "b85160c3e155e49a233628e7361a851b0169fab6f75a81ba951d6aac2d7bd31f", + "title": "Bound numerical storage during selected BIT form construction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2778" + }, + { + "head": "a2bab9978c8149dc5965558ea9277da07bc750e7", + "html_sha256": "7428748c3b2e5eb6a6e63663aa7b79ffbd22595350ca18b17f3851ce0fe2591d", + "number": 2747, + "primary_body_normalized_sha256": "e2ab76e7cba279a9bd2fd709104655d46b63f719b9a12dc2591c4479cc0ea5a0", + "title": "F-star residue (i): mixed anchor-repair-pivot lemma MX, tied-instance certificates, and a tied-domain search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2747" + }, + { + "head": "7de16285a02ebb45cf46e7501baa7eafa78335e3", + "html_sha256": "80ece7cee96823c445edfe7a3e2b562d254685493661312c54035be27d150b09", + "number": 2776, + "primary_body_normalized_sha256": "8395a3ccafccccf5c5f9f845957f3f2a108316a4ce7b791a609e7f3aad6012a4", + "title": "Realize all-size ordered shears on fourteen fixed tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2776" + }, + { + "head": "b7b2a1e0ba3b1e5b52bc79ed93e42ea6f2bb8925", + "html_sha256": "366bc71199e31b5fc4fcaf3a98d66bbbacddbbc965b9e3cb0b25bc1307f4fdca", + "number": 2639, + "primary_body_normalized_sha256": "ade13d19b3e6e856f7bc7ca76fca914e645cde4ead669ccec6f69f7ae6df392e", + "title": "Decoder floors, closures: punctured E8 units (Model C) to p = 46 (all m) and p \u2264 56 (merged m \u2265 8), windows h = 10\u201311 (no \u03ba claim)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2639" + }, + { + "head": "539abe1401bbebe3aee8527342ee6010904fc2e5", + "html_sha256": "5d9f3f6bcc3ea7e6d5d4bb3c4eb976b3bab7dabd79f90dc4e5fba5c1252e1106", + "number": 2775, + "primary_body_normalized_sha256": "e24db0b1de5dec1a7d2a88a78b91bfe60a25fde64d745cbcdc03048818b97c69", + "title": "Prove complete clean six-tape multiplication and eight explicit applications", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2775" + }, + { + "head": "ceaf5acf976cee2f70a680f2d513f12baa634870", + "html_sha256": "efcf37a59dce960abf24fad7d65535b76d2cd7caa95d74935ad1ea82842c709a", + "number": 2774, + "primary_body_normalized_sha256": "f85f4eeea25f71fcb7d7236d22d7d16cda823b1bb711f99c59f08d312b1773ec", + "title": "F-star residue class (ii): non-3-dichromatic zero digraphs - matched-pivot floor, fixture dichromatic structure, smallest-first falsifier search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2774" + }, + { + "head": "407712103b605a662a89a56f9c42b93dca69126b", + "html_sha256": "ec2273841cec28aee2f90e41356752e14b3036dd0dd207bfcea4d1a930785f31", + "number": 2077, + "primary_body_normalized_sha256": "591685e1d1a7c32f6505ad35386adb889ccb0f45666781756ce9f2eb8030f0e4", + "title": "Research: four helper placements improve selected T16 kappa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2077" + }, + { + "head": "462593231536f771050da8f44390b3e4eba95783", + "html_sha256": "b7c6e4f4e043c09015de93e0d84e5b5b9f0a55a2b5c50a51468c8155a68d56b6", + "number": 2375, + "primary_body_normalized_sha256": "e06f3a0662a4d80c5ab9d8d0bec10661f81d685ff1bc4cf192c3a54e1af7d4cb", + "title": "Tooling: 3.09\u00d7 faster production frame-pair enumeration via eight-bit neighborhoods with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2375" + }, + { + "head": "69ba5a423246a1c9281bdd5c1f51240b454f2aa6", + "html_sha256": "69af827854a04e6431d605cfbd091aee2fb67918912a5d3e4c20201bcceb41f3", + "number": 2772, + "primary_body_normalized_sha256": "66a3fbfd3a01dbb9506c9993e630a230ac541e01c2a0466a05ba6347853c9e82", + "title": "Certify a whole-word internal grid for the physical P104 dual", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2772" + }, + { + "head": "e707681c3f6db70d0432501403e2122794a36ade", + "html_sha256": "0f571d70b0d9ecb2839154ebb26cf8290b2d818af3bac2d57de130ced72b1c63", + "number": 2771, + "primary_body_normalized_sha256": "b9320ff56d5a44cf331021a2f1992f1139c4dbc7abced15b7e36afdb3cb417a6", + "title": "Bound rounded native-line defects for the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2771" + }, + { + "head": "a768c79ee5fd45bcfa8fc7a566646a620a7f2ef5", + "html_sha256": "7ea3d64e648280fd9e4662efbde0085f0db6aae229029dbfb8da6e8709afcf85", + "number": 2411, + "primary_body_normalized_sha256": "aa54dc31c1a784e481c4693cb788199ccfc6c67e30c0aa9bc875fced13091426", + "title": "[Lean] Link an end-to-end proof of multiplication below n log n", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2411" + }, + { + "head": "687372b807f5ec635f6a748c2585fc0090a7dc2a", + "html_sha256": "71ab2451f1cfd9ced6f54a6ba8abf5e4fb13555ec69452f503706c5301796bf2", + "number": 2770, + "primary_body_normalized_sha256": "110e062ac5708988806747aa0a93a97e39c704e6612769b26e9a027442f5c8c7", + "title": "research(bit): bound numerical callback word lifetimes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2770" + }, + { + "head": "e7fd43cf1be63cd14a9b2b57b2889eaf25a1fde2", + "html_sha256": "b2602ec0a13dcb37f73748992128bb207ed1d2924d240ddac9a14aac9eeb30c8", + "number": 2768, + "primary_body_normalized_sha256": "d882bc72ce5848242efcf72036ac2d6b0dfe2f9abf4ad1d01b1c3c80600db359", + "title": "Tooling: 3.57x faster complete T74 native replay with unchanged exact coverage", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2768" + }, + { + "head": "e8b771ba132fe632796b28c1742a8d096c04519f", + "html_sha256": "58284a927461d09fbd8bed652866da723b2707e5630a9131fcdcb387fc14aecc", + "number": 2767, + "primary_body_normalized_sha256": "da02cd5316079b127b18b8fa1a98dcf87ccb0ca352d9493741c224ea10ca7671", + "title": "Conditional \u03ba = 0.001717256973467002: post-cut partner correction on #2696's lender assignment with #2679's pre-life hosting", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2767" + }, + { + "head": "d97f150d89e3f3eebdf625a468a445c9c0f1e6c9", + "html_sha256": "8e4dfc3b050ec2d160fddd8297c021bc3b28622973e32bcfb0e4215ec64aaace", + "number": 2769, + "primary_body_normalized_sha256": "5a7e3adc80f217c8b64477273839d705905f931e1e6694e3806c0263ded919ef", + "title": "Park recursive numerical banks on two fixed tapes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2769" + }, + { + "head": "3bc76f12b29732e901f13b19d341253379f04cb1", + "html_sha256": "867f3f1593ac4b705262faac7dd39835935043bb9fe34dcc338df6b8b706809b", + "number": 2357, + "primary_body_normalized_sha256": "5c728a73696a90f999a8f61fc4ccf22bef7dc7ffbd745e2f561bd4cdfb301458", + "title": "Tooling: 2.26\u00d7 faster production emitted-local audit via integer rows with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2357" + }, + { + "head": "e6df920cd0110e4b629e2ad84eddcb539001e174", + "html_sha256": "0c662e34c7edff2a2a44b8b0ed0f609f4d246686e7411011b757d85932f2f1ed", + "number": 2766, + "primary_body_normalized_sha256": "69faaccfc3e45e85e459276177e4193f28f6f58e6ed6f74c2da57188f9843eb8", + "title": "Improve conditional \u03ba to 0.001717256973467 with credited routing-frame fusion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2766" + }, + { + "head": "54d031fc3df0e5361d5840eb3863c9d134d60f23", + "html_sha256": "ad05b68fb2f61540aa5da9f138ba97d90558960883323849ff2019c1b2a31434", + "number": 2765, + "primary_body_normalized_sha256": "22ea54707d26cd6514ba1ef38c3f7100c61083f5390b481e21986f2a7477f0b3", + "title": "Certify masked E8 decoder padding transfers", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2765" + }, + { + "head": "d4d5f0f37929df97ea1e0f8d2bf0859f92407e55", + "html_sha256": "710f250a4a47504f838b190ddd4240c2b2d5e766314a47824ddf74334c313a34", + "number": 2764, + "primary_body_normalized_sha256": "fb6b6d3c991b2f9b47ad59809b5cba87f9bea4339ebb2a3cb153f117b2d53b15", + "title": "Research: dirty-parity collapse extends to eight queries (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2764" + }, + { + "head": "24b985e05d77a6005e3b18cdd4a7c33da9c0d260", + "html_sha256": "a9e97232a1c5f2b24cc8c5f36e91938e2b355b495f8882905993ae30cbc06fcc", + "number": 2763, + "primary_body_normalized_sha256": "b745c61ab1bd001bb0a0af85e8b6a07b5d2f277682d3a7a6802164512ca321d7", + "title": "Audit centre-source coefficients with an independent adjoint and sign control", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2763" + }, + { + "head": "0ed979edbedf04caf5ad3f2b6b1c30a136f74553", + "html_sha256": "2935c60887c56cef5e695dc720c88a3416a99b9e597e4572c9b2af09c0449438", + "number": 2762, + "primary_body_normalized_sha256": "dea8e602f87d51c747d11443f599e6215980a36513b3de86d39e145d64cda7f1", + "title": "Census round 2: screening results for the 16 uncovered open complex claims (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2762" + }, + { + "head": "cd4ff9427c3e35efb4de09bbf1137e7b68732ecf", + "html_sha256": "343065ade88ef48cb18840a5d179132d73e004353ea9f4a1988492249a5380ed", + "number": 2761, + "primary_body_normalized_sha256": "a103c96112396c850c77b36c45061824e383b4567239669c322f354143f95e62", + "title": "Research: multi-connector / priced-shadow 7q readout obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2761" + }, + { + "head": "982c54b986c9f44e7524e5faa9522b809e793ded", + "html_sha256": "7b7d11de6db7ea3181c9409e0e4bc7339497ba3b2ab4f58390b4bb51d30f4294", + "number": 2760, + "primary_body_normalized_sha256": "62611f160dae1281dee57d7e07167208c5bc9b0fd6187fe40ea7fdeabfc66de8", + "title": "docs(research): map selected BIT caller and storage obligations", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2760" + }, + { + "head": "68a7161a610f175dc8e7b22f95acd033191450d9", + "html_sha256": "2744e6eeeddfddd7bf134f871b97ea3bd6b0c1e9757a8de587efc4f5da3143ca", + "number": 2329, + "primary_body_normalized_sha256": "9e4ad3e758bc2bbb3d2f56fcea2f3589e4dd1c3223a828e52993e03102135835", + "title": "Tooling: 3.15\u00d7 faster production Clifford zero_state via gate tables with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2329" + }, + { + "head": "2fd8fbe0d2f57c4a8ebb7b7c9ae45df1fcf69be9", + "html_sha256": "d886530d69a88267aa529b672968985e79ba358406ca7d14f117c967c412f3cb", + "number": 2759, + "primary_body_normalized_sha256": "b05599ae63d84e35fe07ed9c47002e83bec1584937aefd0e01fc4f31d9a52977", + "title": "Certify sharp numerical scratch bounds for BIT arithmetic", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2759" + }, + { + "head": "ef041c010b32f037dddf2f67a96a53d435966746", + "html_sha256": "2c5df16c2c457e0ded7c1750a7a6df06c573c458f1c310ca68b1562e9587c729", + "number": 2758, + "primary_body_normalized_sha256": "63d656163058049d2dd0923d03a1bbddac50efb4bbe9edd0ad2284f6e37eb210", + "title": "Bound serialized continuation storage in the selected BIT evaluator", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2758" + }, + { + "head": "feb0b96b5c471be0a8c72e6ecb8f9e1f74b48991", + "html_sha256": "a343cb34252a711dbf4b5a579956784ebe681adb1d72e946ebced296450699cf", + "number": 2276, + "primary_body_normalized_sha256": "0883913efe0864328f750fc9b366bb621b102356e29fcd732ffaa8f2610d2225", + "title": "Tooling: 6.47\u00d7 faster production R420 mutants geometry cache with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2276" + }, + { + "head": "99cb4fbf2b55a5e8265e066a1e4793d92f9b5077", + "html_sha256": "2abf95ff1a3b1617a4a27af30977c50a21cc143311d1d631a3bd1709336f7fe1", + "number": 2263, + "primary_body_normalized_sha256": "434539a18dcc1dd9160145b4eeb9fb0caacfa9f193a300c4689b5912ef7cff57", + "title": "Tooling: 3.18\u00d7 faster production R420 xcheck.rref via integer elimination with identical receipts", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2263" + }, + { + "head": "fce2366c5dfd3d0ee52f9bb6322fb16006e72f7a", + "html_sha256": "b4e0c9347ac4092417a8bb1010fbc24ae4f7ff68a9e0166a4dc1747a6c3fe8b7", + "number": 2756, + "primary_body_normalized_sha256": "e79c744283f26b7af80572f33dd5754f26c301ff6ca822bbbbacc3b87ce20391", + "title": "Audit when exceptional repair can use independent batches", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2756" + }, + { + "head": "7dba5452a4071a856a0b11cebdcd2d3b6bcd7659", + "html_sha256": "d96ef986dc39d115907d5c6950e916bb63ddefde99b6bd14e3bc0408fbb63536", + "number": 2753, + "primary_body_normalized_sha256": "7d0db82029937ace97073ccbb14f0e59b173ff6afc4c44d45f1e8ace4eef0cda", + "title": "Complete all-size logical BIT caller and recursive storage bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2753" + }, + { + "head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a", + "html_sha256": "cdcbea7297472627aaaa4796cad98b3d1b4bd00381c9ba7aa51de53a8a98a6ca", + "number": 2733, + "primary_body_normalized_sha256": "dcf8e311ca340e7a15f7495dc1d90ca50e12cc3d8c1a2fb461dd23bf2b7339c0", + "title": "Improve conditional kappa to 0.00171625567823018 with composition and a frame refit", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2733" + }, + { + "head": "23d8aa7f11cd6a2e9d44a6ce4f6beebe1016492c", + "html_sha256": "8306d6cff77ad201e86b1912958f2f067cef0a7210591edc65ed513a90a7ce4a", + "number": 2754, + "primary_body_normalized_sha256": "270ec02886867c0d8f3403d3965e7080d233cdf76aefd80751b295758eb0c2b8", + "title": "Prove exact internal rounding for one P104 collector", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2754" + }, + { + "head": "73406fd73ebaf8361b51674fad5e0b02a26db075", + "html_sha256": "c4f8d5e1cdf5e607b5cc07440010843ec5f6367afe4f739028a20cbb9c59b7bc", + "number": 2752, + "primary_body_normalized_sha256": "ec739520c50f2b2bc03aaa258bb87b23f3b679fad6ee6cf7674544f563efed62", + "title": "fix(replay): support source-pin checks on older Git", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2752" + }, + { + "head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "html_sha256": "563ad7c07d1fe6eed01160a035b7b904fa87128a63f60775cf697b41fdfdbde7", + "number": 2751, + "primary_body_normalized_sha256": "ced8cc6eb24ad50cd3789a99448240c9c96ba8355fff0dd9e58e8b24f5b61ac2", + "title": "Conditional kappa \u2248 0.00171714158635 via joint twelve-source recovery", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2751" + }, + { + "head": "3011db354853d71bc92a781df94adbb90f7a9f50", + "html_sha256": "b313bb78ac811872cf8e8736b1ffe2a811489afde98aaf09a60284348f3d8ee1", + "number": 2746, + "primary_body_normalized_sha256": "dc37534b5e847b50b75ea6c4c9d0bdf9cc5b5ccb5304f14367a32de668cdbba3", + "title": "Docs: correct attribution credit lines in merged research packages", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2746" + }, + { + "head": "7aed56bd440a3d8cbca8028cf2cbd0888c07d9b3", + "html_sha256": "9a4c5aedbfd590ef63530a01d3681aa50275201786f328b081b9eb64b1db0aad", + "number": 2717, + "primary_body_normalized_sha256": "d167782af46b6250d7ba31ec0c09c7685f10857288905f9df5766d4e2fb89b1b", + "title": "F-star proof-level lemmas: structural certificates, named-instance L8 reproduction, and a beyond-census falsifier search (no kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2717" + }, + { + "head": "a18ba3bbfb549af66488a890edcb4a3744de90a3", + "html_sha256": "ca9f6f5836aa4d4ca4e89396ac491e03bd7447d301f93b584bf3e3326ce29698", + "number": 2749, + "primary_body_normalized_sha256": "b1255c0dc036a4c58fdcce61306717c3ee30894b969ececd1fae983a10507919", + "title": "Bound count-tape storage for the first selected BIT node", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2749" + }, + { + "head": "2af9c0fc46492a4ce56ac20ab14cc40e2f6544e0", + "html_sha256": "ee9f3f54e872707230bbc6dc4f3ee6678332cb0ade1c7ea5be5184c5d929817f", + "number": 2748, + "primary_body_normalized_sha256": "3f9feef29cc33f8181cb839f287c16286467f8cd93eab02d7333312f85d7c614", + "title": "Bind all non-cold k8 HPE wrapper events to Lean recipes", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2748" + }, + { + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "html_sha256": "b5c7b4d6af7a6e4af5d0f8b2ad8c2235131f3ddba00b7c9d2cce42a17369df6a", + "number": 2745, + "primary_body_normalized_sha256": "c2f35083aaad764d87d593e9b07b022b3781b626fd1681b66bd1511e841e7bac", + "title": "Conditional \u03ba = 0.001716140425997441: #2696's lender assignment with #2679's pre-life hosting and a window-optimal fill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2745" + }, + { + "head": "39019203274f25ae0176ef516fe86ac576ceae9b", + "html_sha256": "7d45e89e7f28366a6043250eb3fce025a95cdc7f1302a3b212510d9219c8e340", + "number": 2595, + "primary_body_normalized_sha256": "1a9cdef185a05d695096c73a244a94f89d850917cc37f9f699adaaf2f44dcde9", + "title": "KB1b: the ERASE deferral is not necessary \u2014 legal per-call COPY/ERASE windows keep the typed-echo pair saving (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2595" + }, + { + "head": "0166260409f55a56e7fefa48d859f7dd5b42b300", + "html_sha256": "537fc2a640def6fb6087bf282394c0686003d604904ff078d9a07be593bc97f9", + "number": 2744, + "primary_body_normalized_sha256": "2d6045b7ea171d9ff4df78c1ec517385dcdc0c8c7f9a02921c8fee4b5a918945", + "title": "Audit P104 consumer cost credits and the PR2725 stopping decision", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2744" + }, + { + "head": "c1e8065671f4f1854c5508f4bb18b85851074547", + "html_sha256": "19ffb926c6ba5aa680ac1a626ede87e151e7d14f0656170511bf5ec3db7e8d1c", + "number": 2743, + "primary_body_normalized_sha256": "82af68a7475d314c8d638fae58fd470a8b49525fe56dc1b1eda0b00199d23f2c", + "title": "Bound complete BIT node data content, including remainder peel", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2743" + }, + { + "head": "8571b04372f539b725e7f27d1ab00c506ca616fd", + "html_sha256": "addfa9b5cb541cc384d080ff7787f36a648ae7ad2f95e52c491012ac0ae96f18", + "number": 2742, + "primary_body_normalized_sha256": "457100a27b66c3ab8846be759bf92e32168b885baadb4bc6df62c61fccd42a68", + "title": "Construct a native covariant action on the full dirty reader", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2742" + }, + { + "head": "fbe941c06e00e7aef64c2d11cd9ad27b7a083209", + "html_sha256": "af0dbd17685045c37f807e3660081b701d3a0fca0b1ec3df85687005644f1a81", + "number": 2741, + "primary_body_normalized_sha256": "f4c6d4ea26e005b88362ca492f4217b0652f50910af9879ba8fe8d46dc242813", + "title": "Prove the all-pair P104 consumer budget obstruction", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2741" + }, + { + "head": "02c9e171c98b1b4de4d2107b0134cee4446e10e0", + "html_sha256": "da8adc43f4c6453ac51e2576ef7547d0c13e419aee5dbc1fdbab6183b4825208", + "number": 1155, + "primary_body_normalized_sha256": "98f6a1c6c2821c4e6eb438ba61ef19cb57d231650a889dc718dd8c90a457f6aa", + "title": "Research note: restoration coalescing across a recursion batch (read-free + composable-family boundary; no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1155" + }, + { + "head": "e786545de95c38cb69e8006970c851b444a0630e", + "html_sha256": "be3f2946a05ed595e5b2d2134a473fca70d812cdb7578a42d6931fdd7cb2915d", + "number": 2740, + "primary_body_normalized_sha256": "1bef1d1be08bc12a9489f4ab95b282c62fa6ebe5c8478f9e5e59ee2c519f39ac", + "title": "Research: rule out uniform dirty-padding exchange adapters", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2740" + }, + { + "head": "833b8e05bbed0d77419c1d05d057bfde34bac551", + "html_sha256": "1cb7a730712a42fb6143ada23af1bc6b3cc1c67d0e364d54c9da2dae816c54b6", + "number": 2738, + "primary_body_normalized_sha256": "0e2824f52a81d78a3c8beeafbc00fd757cc9a4ed5ebe3f9d4c8e42c744bde1ca", + "title": "Prove exact Coxeter tariffs with arbitrary dirty workspace", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2738" + }, + { + "head": "e2f30d93efbef5658334072aa855aa95e795e394", + "html_sha256": "e43411221bb147a850c04fb1827faeb46a137755d65072714ea3261671889756", + "number": 2634, + "primary_body_normalized_sha256": "bb4973a4793ec5d2fa28503daa47c1f3731574be47afeddcb38ba4ca3c0d7107", + "title": "KB3b: seven-source singleton f(7) continued - parity closes L=19, beating templates closed, cover/walk dichotomy, resumable 20-cycle census (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2634" + }, + { + "head": "3b6011d2400f50ab0ad9e105c7c55a18f3cef4cf", + "html_sha256": "cbf1142ae27b96a2c8b09b1b2e31970b9946648480d7b506b0927f7fb13085d4", + "number": 2542, + "primary_body_normalized_sha256": "2a9d304387d9915738119c2691bec67948b1fe06d77405f51bfbcb9689297ab3", + "title": "Research: seven-source singleton universal path \u2014 length 18 excluded, f(7) >= 20 (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2542" + }, + { + "head": "5ccad6aa04409ee2805d5638aa0fc84c76bbb881", + "html_sha256": "60884157ed2595224726d4828925b8cde53989a27818c3f4df5b1414e073a2d2", + "number": 2518, + "primary_body_normalized_sha256": "bc825bd7f502b9942c1a04ed1807991b686620d3bcf91f9eb1eb9536bb77e9d0", + "title": "Research: polar-law screens at T >= 7 and a small-T overcomplete census (scoped negatives)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2518" + }, + { + "head": "f364b97ff4700147fc06e622b79952b9fe6c4fa8", + "html_sha256": "a554300b963d5564807793b42006ec0c03fe62c9e2a6b56292f49b4e5dc02547", + "number": 2464, + "primary_body_normalized_sha256": "7d6f718fc96b5d8b0ea709f23bf7c15a5f2b6d4950fb37cac863a0225b8ac48f", + "title": "KB1 supplier instantiation of the certified z4 typed echo: priced whole construction, exact moments and a < D/E, one hosting obstruction (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2464" + }, + { + "head": "ba13eec9546a5ac4fca1df37209e3c42249b61c2", + "html_sha256": "ed16c89fdc3c331f3309782ed97bfa83c64787b101f0606fcda346372431a4ba", + "number": 2444, + "primary_body_normalized_sha256": "fdc24387acbfb0474fe2c4004195d8ce6fe9ce9fd69607eff1f074497faac72a", + "title": "Exact-search tooling for noncommuting words, and a complete six-distinct-value screen of the KB2 thirteen-call candidate", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2444" + }, + { + "head": "ad449e6aa736396c779535dbdea04a402aab03ca", + "html_sha256": "f16a4c9d64184239875a675abf103ba39367482598c10b622ec2c946befb20fa", + "number": 2427, + "primary_body_normalized_sha256": "0d469b72864f14efa6f6120a69c28ce0b498d1b048ddf930b07e86739707ba53", + "title": "Research (no kappa claim): classical Pappus/Desargues T=3 pairing-cost census \u2014 no cost < v falsifier; tight atoms through v = 6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2427" + }, + { + "head": "15836362a3cf17d245db8a01d930a12868c043bd", + "html_sha256": "6c48e5171e564d9102fdcc7fc58a4e978d1440a794010cc84d02cad84a625947", + "number": 2255, + "primary_body_normalized_sha256": "2c20677ba26abb5630e8a208670af4abea459918d66a037e9358071753cde29a", + "title": "Audit: live-byte source-pin drift after merged replay-speed tooling (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2255" + }, + { + "head": "9c2947f01495cf09c67b1faa55c4f2bd00cd9bc8", + "html_sha256": "4d603e295640f0a29ca2654f7a727e90a882693e4ea9bbe07a63ac1181c435be", + "number": 2737, + "primary_body_normalized_sha256": "cb20e700df30c3609e76e99c1d4001341b1e9cc1791bae432a98268924992923", + "title": "Name offending keys in research package checks and support PR-head pins", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2737" + }, + { + "head": "cced22b95fb5b485da05b8187c8a9754b6a8c85a", + "html_sha256": "74b1c434b84353ea078a17c2bce46c70ff5f8d27d1a9d31f322a51845ec8f2db", + "number": 1076, + "primary_body_normalized_sha256": "b16d26881c9fdf1c8d7cb7953eb50ca55f05dc9e940e0c07920b6ac609820a4e", + "title": "Tooling: batch exact rows for the quadratic-affine rank witness (8.4x faster check, no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1076" + }, + { + "head": "eba0d6111a773cd13f5c0afb4354af2c85d04c3a", + "html_sha256": "af92a4d833d533ab3513620e12d1c020c903a10da72141166d46d49ff385e9ae", + "number": 2736, + "primary_body_normalized_sha256": "cbbff2b6ff06e368f5d48bcbb25f86fbf71f995d48f1ffb88c8fcc733e5ad0f8", + "title": "Research: bound completed errors in the zero-retention QQ16 decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2736" + }, + { + "head": "124cab4118e39d30c2c24b41d753dabf612c8a8c", + "html_sha256": "db88137100a75d1fca13596e5eb0b4991b6e81171c24a961c0a8a48ac82ab956", + "number": 2705, + "primary_body_normalized_sha256": "9c733c539abd4bf3ae3f1524c800f76cdc1ff62fc68fc2d055d5099e08b92348", + "title": "KB1c: admission-ready evidence for the typed-window z4 typed-echo schedule (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2705" + }, + { + "head": "90a507b39063cfaebdf92794fcb9d18f358439a6", + "html_sha256": "d76bf0d06467658ba374372effc5eb3ae7e6f5fddc24b048b2f6201f78ff6fcc", + "number": 2735, + "primary_body_normalized_sha256": "9b49c1a624418cd5b27ebae649615915e569759948ef82633b018efe82a49fb4", + "title": "Prove the fixed dyadic Omega channel profile", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2735" + }, + { + "head": "f43a83977530a52092e9196b060eb3c64620b8c3", + "html_sha256": "7ec59c94066261552bc3b009647e71491343d8d1424834a3e3fe5cb797ba7997", + "number": 2396, + "primary_body_normalized_sha256": "bba4527c60fc097d420b8b4dbbbdabe583071b55f8f9c86bf0edb64805fd19ef", + "title": "Seven-source universal connector word in the singleton+DUO alphabet: 22 calls at 24 adds, batch 276 queries at 278 adds (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2396" + } + ], + "scope": "First100unique entries across five updated-open-PR pages. All100primary bodies and HTMLheadSha fields read; not complete Discussion/comment coverage.", + "source_review_sha256": "9f184c98dea0a231392687dde36e90a11d55e4ee7b68a46848f613929957de50", + "utc_interval": [ + "2026-10-15T23:15:22.880Z", + "2026-10-15T23:15:41.513Z" + ] +} diff --git a/research/tensor-block-kappa/replay.py b/research/tensor-block-kappa/replay.py new file mode 100644 index 0000000000..e757ec8a40 --- /dev/null +++ b/research/tensor-block-kappa/replay.py @@ -0,0 +1,169 @@ +"""Fresh serial Lean rebuild and complete defining-module axiom audit. Apache-2.0. + +No download, model, solver, GPU, or persistent process is launched. Install the +pinned Lean/Mathlib environment separately. Every compiler output goes outside +the immutable source package, under a new explicitly supplied output folder. +""" +from __future__ import annotations +import argparse, importlib.util, json, os, re, shutil, subprocess, sys +from pathlib import Path + +P = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +spec = importlib.util.spec_from_file_location("toolkit_checks", P / "verify.py") +checks = importlib.util.module_from_spec(spec) +spec.loader.exec_module(checks) + +def command(argv, *, cwd, env=None, timeout=180): + result = subprocess.run(argv, cwd=cwd, env=env, text=True, encoding="utf-8", + errors="replace", stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, timeout=timeout) + checks.need(result.returncode == 0, "command failed:\n" + result.stdout[-7000:]) + checks.need(not re.search(r"(?m)^.*\berror(?:\(|:)", result.stdout), "error-bearing compiler transcript") + return result.stdout + +def check_module_inventory(config): + modules = config["modules"] + checks.need(modules and len(modules) == len(set(modules)), "empty or duplicated module list") + checks.need(all(re.fullmatch(r"MultitapeToolkit(?:\.[A-Za-z][A-Za-z0-9]*)+", n) for n in modules), "invalid owned module name") + files = {p.relative_to(P / "lean").as_posix() for p in (P / "lean").rglob("*.lean") + if ".lake" not in p.relative_to(P / "lean").parts} + expected = {n.replace(".", "/") + ".lean" for n in modules} | {"MultitapeToolkit.lean", "Check.lean"} + checks.need(files == expected, "Lean source/module inventory mismatch") + lines = [line.strip() for line in (P / "lean/MultitapeToolkit.lean").read_text().splitlines() if line.strip()] + checks.need(lines == ["import " + n for n in modules], "aggregator import inventory mismatch") + return modules + +def dependency_paths(cache, pinned): + package_root = cache / ".lake/packages" + libraries = [] + for row in pinned["packages"]: + package = package_root / row["name"] + checks.need(package.is_dir(), "missing cached dependency: " + row["name"]) + # Trust only this explicitly supplied cached dependency for these two + # read-only Git commands. No global or repository configuration changes. + git = ["git", "-c", "safe.directory=" + str(package.resolve())] + actual = command(git + ["rev-parse", "HEAD"], cwd=package).strip() + checks.need(actual == row["rev"], "dependency revision mismatch: " + row["name"]) + dirty = command(git + ["status", "--porcelain", "--untracked-files=no"], cwd=package).strip() + checks.need(not dirty, "tracked dependency source drift: " + row["name"]) + lib = package / ".lake/build/lib/lean" + if row["name"] == "mathlib": + checks.need(lib.is_dir(), "missing compiled Mathlib cache") + if lib.is_dir(): + libraries.append(lib) + return libraries + +def actual_lean_audit_controls(lean, out, lib, env, modules, timeout): + """Real compiler fixtures; the rejected axioms never enter a positive build.""" + fixture = out / "fixtures/MultitapeToolkit" + fixture.mkdir(parents=True) + auditor = (P / "lean/Check.lean").read_text(encoding="utf-8-sig") + passed = [] + for suffix, body, required_error in [ + ("CoverageFixture", "def globallyNamedToolkitHelper : Nat := 0\nprivate theorem privateCoverage : True := True.intro\n", None), + ("UnusedPrivateAxiom", "private axiom unusedPrivateDependency : False\n", "Toolkit declares an axiom"), + ("PublicAxiom", "axiom publicDependency : False\n", "Toolkit declares an axiom"), + ("PrivateUnprovedTheorem", "private theorem missingProof : False := by sorry\n", "forbidden axiom")]: + module = "MultitapeToolkit." + suffix + source = fixture / (suffix + ".lean") + source.write_text(body, encoding="utf-8") + artifact = lib / "MultitapeToolkit" / (suffix + ".olean") + command([str(lean), "-j1", "-R", str(out / "fixtures"), str(source), "-o", str(artifact)], + cwd=out, env=env, timeout=timeout) + driver = out / (suffix + "Audit.lean") + driver.write_text(auditor.replace("import MultitapeToolkit\n", "import MultitapeToolkit\nimport " + module + "\n", 1), encoding="utf-8") + report = out / (suffix + ".json") + fixture_env = dict(env, MULTITAPE_TOOLKIT_AUDIT_PATH=str(report)) + result = subprocess.run([str(lean), "-j1", "-DmaxHeartbeats=4000000", str(driver)], cwd=out, + env=fixture_env, text=True, encoding="utf-8", errors="replace", + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout) + (out / (suffix + ".log")).write_text(result.stdout, encoding="utf-8") + if required_error: + checks.need(result.returncode != 0 and required_error in result.stdout, + "real Lean negative fixture failed for wrong reason: " + suffix + "\n" + result.stdout[-4000:]) + checks.need(not report.exists(), "rejected Lean fixture emitted a success report") + else: + checks.need(result.returncode == 0 and report.is_file(), "real ownership coverage fixture failed") + audit = json.loads(report.read_text()) + checks.validate_audit(audit["rows"], audit["declaration_names"], set(modules) | {module}) + owned = [r for r in audit["rows"] if r["module"] == module] + checks.need(any(r["name"] == "globallyNamedToolkitHelper" for r in owned), "global helper omitted") + checks.need(any(r["name"].startswith("_private.") and r["kind"] == "theorem" for r in owned), "private helper omitted") + passed.append(suffix) + return passed + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--lean", type=Path) + parser.add_argument("--cache-project", type=Path, default=P / "lean") + parser.add_argument("--timeout", type=int, default=180) + args = parser.parse_args() + checks.need(1 <= args.timeout <= 600, "bounded compiler timeout required") + initial_manifest_digest = checks.digest(P / "MANIFEST.json") + before = checks.inventory(P) + config = json.loads((P / "MODULES.json").read_text()) + modules = check_module_inventory(config) + pinned = json.loads((P / "lean/lake-manifest.json").read_text()) + candidate = args.lean or shutil.which("lean") + checks.need(candidate is not None, "Lean executable not found") + lean = Path(candidate).resolve() + checks.need(lean.is_file(), "Lean executable not found: " + str(lean)) + compiler_env = dict(os.environ) + compiler_env.pop("LEAN_SYSROOT", None) + version = command([str(lean), "--version"], cwd=P, env=compiler_env) + checks.need("version " + config["lean_version"] + "," in version, + "wrong Lean compiler; expected " + config["lean_version"]) + libraries = dependency_paths(args.cache_project.resolve(), pinned) + out = args.out.resolve() + checks.need(out != P and P not in out.parents, "outputs must be outside the package") + checks.need(not out.exists(), "fresh compiler output directory required") + out.mkdir(parents=True) + lib = out / "olean" + lib.mkdir() + env = dict(compiler_env, LEAN_PATH=os.pathsep.join(str(p) for p in [lib, *libraries])) + receipts = [] + for module in modules + ["MultitapeToolkit"]: + relative = Path(*module.split(".")).with_suffix(".lean") + source = P / "lean" / relative + artifact = (lib / relative).with_suffix(".olean") + artifact.parent.mkdir(parents=True, exist_ok=True) + log = command([str(lean), "-j1", "-DmaxHeartbeats=2000000", "-R", str(P / "lean"), + str(source), "-o", str(artifact)], cwd=P / "lean", env=env, timeout=args.timeout) + (out / (module + ".log")).write_text(log, encoding="utf-8") + receipts.append({"module": module, "source_sha256": checks.digest(source), + "artifact_sha256": checks.digest(artifact)}) + print("PASS_KERNEL " + module, flush=True) + report = out / "axioms.json" + env["MULTITAPE_TOOLKIT_AUDIT_PATH"] = str(report) + log = command([str(lean), "-j1", "-DmaxHeartbeats=4000000", str(P / "lean/Check.lean")], + cwd=P / "lean", env=env, timeout=args.timeout) + (out / "audit.log").write_text(log, encoding="utf-8") + checks.need(report.is_file(), "missing actual Lean declaration report") + audit = json.loads(report.read_text()) + checks.need(set(audit["modules"]) == set(modules) | {"MultitapeToolkit"}, "imported-module audit coverage mismatch") + checks.validate_audit(audit["rows"], audit["declaration_names"], set(modules)) + expected_audit = json.loads((P / "expected/AXIOMS.json").read_text()) + def normalize(rows): + return sorted((r["name"], r["module"], r["kind"], tuple(sorted(r["axioms"]))) for r in rows) + checks.need(normalize(audit["rows"]) == normalize(expected_audit["rows"]), + "actual declaration/axiom inventory differs from the pinned golden report") + checks.need(checks.inventory(P) == before and checks.digest(P / "MANIFEST.json") == initial_manifest_digest, "source changed during kernel audit") + private_count = sum(r["name"].startswith("_private.") for r in audit["rows"]) + controls = actual_lean_audit_controls(lean, out, lib, env, modules, args.timeout) + checks.need(checks.inventory(P) == before and checks.digest(P / "MANIFEST.json") == initial_manifest_digest, "source changed during audit controls") + result = {"status": "PASS_FRESH_KERNEL_AND_COMPLETE_AXIOM_AUDIT", + "lean_version": config["lean_version"], "dependency_revisions": {r["name"]: r["rev"] for r in pinned["packages"]}, + "modules": receipts, "declarations": len(audit["rows"]), + "theorems": sum(r["kind"] == "theorem" for r in audit["rows"]), + "private_declarations": private_count, + "actual_lean_ownership_and_axiom_controls": controls, + "allowed_axioms": sorted(checks.ALLOWED_AXIOMS), + "actual_axiom_report_sha256": checks.digest(report), + "manifest_sha256": checks.digest(P / "MANIFEST.json")} + (out / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + print(json.dumps(result, sort_keys=True)) + +if __name__ == "__main__": + main() diff --git a/research/tensor-block-kappa/replica_parent.py b/research/tensor-block-kappa/replica_parent.py new file mode 100644 index 0000000000..770fb1fe99 --- /dev/null +++ b/research/tensor-block-kappa/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/tensor-block-kappa/requirements.txt b/research/tensor-block-kappa/requirements.txt new file mode 100644 index 0000000000..6b53f208f8 --- /dev/null +++ b/research/tensor-block-kappa/requirements.txt @@ -0,0 +1,5 @@ +# Full cold finite admission; lightweight owner/moment checks use stdlib only. +numpy==2.5.4 +scipy==1.18.1 +sympy==1.14.0 +mpmath==1.3.0 diff --git a/research/tensor-block-kappa/validation/BLOCKNORM-CONTROLS.json b/research/tensor-block-kappa/validation/BLOCKNORM-CONTROLS.json new file mode 100644 index 0000000000..b9a55302bd --- /dev/null +++ b/research/tensor-block-kappa/validation/BLOCKNORM-CONTROLS.json @@ -0,0 +1,105 @@ +{ + "certificate": { + "active_calls_per_block": 9, + "actual_prefix_bits": 1452, + "block_width_families": 896, + "boundary_depth_bits": 18, + "bridges_per_block": 9, + "endpoint_replay": { + "extra": { + "backward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + }, + "forward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + } + }, + "gauge44": { + "backward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + }, + "forward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + } + } + }, + "foreign_helper_roles_checked": 360007, + "input_l2_bits": 37, + "live_families": 93184, + "local_actual_prefix_bits": 70, + "local_reserve_bits": 128, + "max_active_depth": 18, + "partial_cover_bits": 1, + "physical_families": 93674, + "physical_stock_bits": 2644, + "replicas": 104, + "required_reserve_bits": 1510, + "retained_payload_bits": 2048, + "scope": "Completed native frame/phase/physical-primitive audits remain mandatory. Finite charts plus exact free-warp rows instantiate the separate universal block-energy bound; no child deletion is asserted.", + "status": "PASS_TENSOR_BLOCK_NORM_CERTIFICATE", + "stock_l2_bits": 1322, + "stocknorm_bits": 1322, + "stocknorm_condition": "sqrt(|Sp(72,2)| * physical_families) <= 2^stock_l2_bits" + }, + "controls": [ + { + "name": "missing_first_C_clear", + "reason": "blocknorm: private copy before first clear" + }, + { + "name": "missing_terminal_C_clear", + "reason": "blocknorm: each centre first and terminal clear" + }, + { + "name": "missing_Z_allocation", + "reason": "blocknorm: zero buffer read/write before alloc or after free" + }, + { + "name": "missing_Z_release", + "reason": "blocknorm: all72 private zero buffers released" + }, + { + "name": "helper_dirty_response_added", + "reason": "blocknorm: all-column endpoint mismatch row 112" + }, + { + "name": "cross_replica_data", + "reason": "blocknorm: caller data block" + }, + { + "name": "helper_active_data_alias", + "reason": "blocknorm: distinct live-family embedding" + }, + { + "name": "helper_family_alias", + "reason": "blocknorm: distinct live-family embedding" + }, + { + "name": "cross_replica_bridge", + "reason": "blocknorm: single replica event" + }, + { + "name": "wrong_call_projection", + "reason": "blocknorm: schedule actual call" + } + ], + "hosted_sha256": "ebaa8c79d739afb02e29120208912ec96bab1f73186818a1d68094273aa29c4c", + "module_sha256": "e5bfbad8e8e6cb4206f7ba92d333780f423918d8f217b474302346169e991f92", + "status": "PASS_HOSTED_CERTIFICATE_AND10_CORRUPTION_CONTROLS" +} diff --git a/research/tensor-block-kappa/validation/BLOCKNORM.json b/research/tensor-block-kappa/validation/BLOCKNORM.json new file mode 100644 index 0000000000..73e34e9c9b --- /dev/null +++ b/research/tensor-block-kappa/validation/BLOCKNORM.json @@ -0,0 +1,58 @@ +{ + "active_calls_per_block": 9, + "actual_prefix_bits": 1453, + "block_width_families": 896, + "boundary_depth_bits": 18, + "bridges_per_block": 9, + "endpoint_replay": { + "extra": { + "backward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + }, + "forward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + } + }, + "gauge44": { + "backward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + }, + "forward": { + "all_arbitrary_columns": 632, + "centres_first_clear_and_terminal_zero": 8, + "coefficient_work_contract": "unchanged audited clear-before-and-after Horner macro", + "helper_to_data_response_zero": true, + "zero_buffers_allocated_and_cleared": 72 + } + } + }, + "foreign_helper_roles_checked": 394076, + "input_l2_bits": 37, + "live_families": 102144, + "local_actual_prefix_bits": 70, + "local_reserve_bits": 128, + "max_active_depth": 18, + "partial_cover_bits": 1, + "physical_families": 102634, + "physical_stock_bits": 2645, + "replicas": 114, + "required_reserve_bits": 1511, + "retained_payload_bits": 2048, + "scope": "Completed native frame/phase/physical-primitive audits remain mandatory. Finite charts plus exact free-warp rows instantiate the separate universal block-energy bound; no child deletion is asserted.", + "status": "PASS_TENSOR_BLOCK_NORM_CERTIFICATE", + "stock_l2_bits": 1323, + "stocknorm_bits": 1323, + "stocknorm_condition": "sqrt(|Sp(72,2)| * physical_families) <= 2^stock_l2_bits" +} diff --git a/research/tensor-block-kappa/validation/CANONICAL.json b/research/tensor-block-kappa/validation/CANONICAL.json new file mode 100644 index 0000000000..07af9dacf4 --- /dev/null +++ b/research/tensor-block-kappa/validation/CANONICAL.json @@ -0,0 +1,7 @@ +{ + "audit_log_sha256": "4e6763e05226ab203a230b1d751e32934dcd19f7f4beaaeeb1e1a5cffd7513ea", + "lean_version": "4.33.0", + "scope": "Five named statements checked; public4.34.1audit separatelycoversall67owned declarations.", + "source_sha256": "52a61d4d8ed0897f097001b9aac1d1ea46b57a0deec5598734b6badae134c420", + "status": "PASS_CANONICAL_SOURCE_FRESH_CHECK_AND_NAMED_AXIOM_PRINT" +} diff --git a/research/tensor-block-kappa/validation/COMPLETE.json b/research/tensor-block-kappa/validation/COMPLETE.json new file mode 100644 index 0000000000..52d52f69bc --- /dev/null +++ b/research/tensor-block-kappa/validation/COMPLETE.json @@ -0,0 +1,80 @@ +{ + "authenticated_unchanged_native_chains_reused": 4, + "complex_lower": "858897637110708343289/500000000000000000000000", + "dispatch_sha256": "164494966a463d2edce30fa3698d05928c093d00d8cda8568a670174fc81857f", + "fill_sha256": "27cdac384c88bbcb7c608c031cf1def6084aa4f1e411a9c90c9ed9449ab2e5ad", + "fresh_native_chains_this_run": 0, + "gain_over_delivered_T104": "2580241447169/50000000000000000000000", + "kappa": "17177952742214166865779999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177952742214166865779999999999999999999998999999999999999999999999", + "native_receipt_sha256": "32c42af206f32dbcfb500579ac7e525a028e5caa0cc180c9890630ccbd03b44a", + "order_sha256": "16d90ed352663d98d4c9829e7017724fa3a28d771f6ed4cea3cf6291715e9190", + "original_admission_receipt_sha256": "0b6673fc8beefbc5198bdf612458928f2970b355aef8f1a709cb27237fa47d36", + "package_manifest_sha256": "13866efbd0a423d165118db035bc7fc241222c1271a6849147680b8de7c3cf4c", + "profile": { + "1": 2470608, + "2": 664848, + "3": 285126, + "32": 1, + "4": 131328, + "48": 40914, + "5": 41894, + "8": 8208 + }, + "release_receipt_sha256": "6f720eaceb4558c1de2c8ae14101555117c194385a4cb98e214ac2d228b37dad", + "replicas": 114, + "scope": "Every changed owner/controller/invoice/bootstrap/outer/full-release stage passed freshly. Unchanged native chains and retained parent are fully authenticated earlier evidence, not newly executed native runs.", + "source_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "stages": [ + { + "exit_code": 0, + "log_sha256": "f7aa5005d22d41f8c0c6caa317d661b23c9d08ba5dbc544d7a394f53b122ab0f", + "name": "owners", + "script_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "seconds": 9.254727899999125 + }, + { + "exit_code": 0, + "log_sha256": "c5be0fe6aa0767bb51723d0c1995423b50f7ef354466da0c5c2f4e3ea2185acf", + "name": "parent-lift", + "script_sha256": "9a1edd7d4ab4a2f2ac8d15b42b7e40f93653d65026bac59e4c1ce80b486bd60e", + "seconds": 23.190377999999328 + }, + { + "exit_code": 0, + "log_sha256": "5e8a4aabcaf31cfea115804da83a0f2f144854c2d14c7a6c0a2426ef0924e14b", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 2.203320300002815 + }, + { + "exit_code": 0, + "log_sha256": "4c46d84cf8a3d4ec7a23f56069af1e761a42276b01027f400322d295af244fb9", + "name": "discovery", + "script_sha256": "cda0f3a63c5c92c0ff45f7f3a200567d7931fd421836e72ea3b8534f6ee24dcc", + "seconds": 164.76517970001441 + }, + { + "exit_code": 0, + "log_sha256": "3a39f2d4d9adc1f5e0c3e650dbb3d8cddddc87634a62703d80562e69eb44bc31", + "name": "outer-check_ledger.py", + "script_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "seconds": 0.12797729999874718 + }, + { + "exit_code": 0, + "log_sha256": "8bee2d9d60d68679afc9826dc217c3e79abf0ed0b8799794575c614c3b01a536", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.0910497999866493 + }, + { + "exit_code": 0, + "log_sha256": "dcc6c74a0b125e68be0ba4288f1d45839d272a3f075ccbbd0403c399a4a2903e", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 515.4566240999848 + } + ], + "status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/validation/KERNEL.json b/research/tensor-block-kappa/validation/KERNEL.json new file mode 100644 index 0000000000..8125902c54 --- /dev/null +++ b/research/tensor-block-kappa/validation/KERNEL.json @@ -0,0 +1,65 @@ +{ + "actual_axiom_report_sha256": "ed379ce180b7df7c0f2eb40d546c1c96a00c015c2e73ed3fb874b790152c12e8", + "actual_lean_ownership_and_axiom_controls": [ + "CoverageFixture", + "UnusedPrivateAxiom", + "PublicAxiom", + "PrivateUnprovedTheorem" + ], + "allowed_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "audited_snapshot_manifest_sha256": "ab8800661a9db54765ee8371b0cded44a16dc913397de303bdbbffcd4764c4b7", + "auditor_and_pinned_context_sha256": { + "MODULES.json": "127c0e4ffce8aad198a4c98ec69ebe3e1d3648290f7e32ec4a589c8f1e2c9bfb", + "expected/AXIOMS.json": "ed379ce180b7df7c0f2eb40d546c1c96a00c015c2e73ed3fb874b790152c12e8", + "lean/Check.lean": "68966f329982188c49a37c51753271ebc1c0afd321195e4aa595562275912aaa", + "lean/lake-manifest.json": "ba2084428ea075a408191fd72f30bddaf19923c5e6ebd55e2bbe7528d4afef90", + "lean/lakefile.toml": "7882ef23598228f705e8abbecea6a1674f72f1386d297c4d24c73b75c89e595d", + "lean/lean-toolchain": "8152090414016dd5dc871752f8ce4ecdbd604d9845758e9b9047cb80101280b5", + "replay.py": "ff899fcb325139b9322e9ccbfc65508f153956c25ae25f51c257fe1a274c61f9", + "verify.py": "aabd12f5edfe846891e4dbe3e4d6a21617c6240bc06d89b0a1ef5f9f34df209b" + }, + "declarations": 67, + "dependency_revisions": { + "Cli": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "LeanSearchClient": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "Qq": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "aesop": "355695d523e41d0554926416cba2a2b3544fbbc9", + "batteries": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "importGraph": "e928b72544873815af278d38681b31c0293588e3", + "mathlib": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "plausible": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "proofwidgets": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5" + }, + "lean_version": "4.34.1", + "modules": [ + { + "artifact_sha256": "5d65941f3aeca1126ce1053ee2791b00fa1b7e320fbdd8218a61bb478903e356", + "module": "MultitapeToolkit.ReplicaTailGain", + "source_sha256": "c043cc6740a79b8a29d1519cb9e11c8e9bc52d6937f4317f630a28dce074e1d1" + }, + { + "artifact_sha256": "e67b723e8f5738ea357c4eb06b732bc9f7b54628629c351bc40b869932b8f965", + "module": "MultitapeToolkit.SuperiorKappa", + "source_sha256": "c366b3ee3123d24e87239ba00ebc32c102f19198080bbc5acd09b0e241d2a324" + }, + { + "artifact_sha256": "fa21f48420bb445d04e79039e0a555fb44ba489ff007a2d2679873236005393f", + "module": "MultitapeToolkit.TensorBlockNorm", + "source_sha256": "50c3c874e950dc9d9b8ca1b71dae313f6bf56d2e0e073de770b7f9f4f862f138" + }, + { + "artifact_sha256": "79f9a79c905e393fc2a79cba54ba09c7f744f67035c7bc4af508b44e3499160d", + "module": "MultitapeToolkit", + "source_sha256": "e83c0c37263543ceb3ffa42c02ae99075de9c73a0e039ec7872dae1f24a42716" + } + ], + "original_kernel_receipt_sha256": "701569c10b1950094cbbcf12c0535aea20ea6f2cc31bcc18e641c8bc893ff552", + "private_declarations": 0, + "scope": "Fresh rebuild and full defining-module/transitive-axiom audit of exact final Lean bytes. Publication metadata differs from the audited snapshot.", + "status": "PASS_FRESH_KERNEL_AND_COMPLETE_AXIOM_AUDIT", + "theorems": 60 +} diff --git a/research/tensor-block-kappa/validation/MOMENT.json b/research/tensor-block-kappa/validation/MOMENT.json new file mode 100644 index 0000000000..219f20e9d1 --- /dev/null +++ b/research/tensor-block-kappa/validation/MOMENT.json @@ -0,0 +1,64 @@ +{ + "baseline_profile_sha256": "9d71407ded0b17496b0f94ca896355933a850dc6fc8456e39b0a1f72995b1406", + "best_claim_sha256": "f26209f7903557cf3dddd8e6d99b4b2b2f99bbd4b5eb0e6161150830e94b02d0", + "best_kappa_rational": "17177952226165877431979999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "complex_lower": "858897637110708343289/500000000000000000000000", + "complex_upper": "1717795274221416686579/1000000000000000000000000", + "controls": [ + { + "name": "reversed_bracket", + "reason": "ordered bracket" + }, + { + "name": "upper_endpoint_as_admissible_lower", + "reason": "strict moment admission" + }, + { + "name": "wrong_live_denominator", + "reason": "source-bound normalization" + }, + { + "name": "one_unpaid_rank_one_child", + "reason": "strict moment admission" + }, + { + "name": "unchanged_T74_profile_at_improved_target", + "reason": "exact lower moment above one" + } + ], + "input_sha256": { + "best_claim": "f26209f7903557cf3dddd8e6d99b4b2b2f99bbd4b5eb0e6161150830e94b02d0", + "owner_receipt": "ef6387cd5211df5ec35a74bdc562c3926a9a68b1f58a4b50cdb91367256a88d1" + }, + "live": 102144, + "lower_moment_minus_one": { + "denominator": 1461501637330902918203684832716283019655932542976, + "lower_numerator": -2650229102043193497745301, + "upper_numerator": -2650229102043189197771588 + }, + "profile": { + "1": 2470608, + "2": 664848, + "3": 285126, + "32": 1, + "4": 131328, + "48": 40914, + "5": 41894, + "8": 8208 + }, + "proposed_outer_target": "17177952742214166865779999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "replicas": 114, + "scope": "Exact finite moment admission and comparison only; proposed outer target still requires all actual outer/native/global checks.", + "status": "PASS_INDEPENDENT_EXACT_CANDIDATE_MOMENT", + "strictly_above_full_PR2802": true, + "target_gain_over_PR2802": { + "denominator": 1461501637330902918203684832716283019655932542976, + "lower_numerator": 75420541994931038803826419733524755516, + "upper_numerator": 75420541994931038803826419733524755517 + }, + "upper_moment_minus_one": { + "denominator": 1461501637330902918203684832716283019655932542976, + "lower_numerator": 1525391621012011676937252, + "upper_numerator": 1525391621012015976910965 + } +} diff --git a/research/tensor-block-kappa/validation/NATIVE.json b/research/tensor-block-kappa/validation/NATIVE.json new file mode 100644 index 0000000000..21f5d03758 --- /dev/null +++ b/research/tensor-block-kappa/validation/NATIVE.json @@ -0,0 +1,139 @@ +{ + "fresh_native_provider_count_this_run": 0, + "original_native_receipt": { + "cache_files": { + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/CACHE.json": "049a3aa224f0d20227892755e4889d8a68f2b8da6a82a1aa0f60dfe0900c90d7", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/STEPS.json": "4870d0ec8990641b5f47579e50838495acce2c7979b7248cf7e551ec5bd0061f", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/ledgers.log": "1738cccdc3cfc06ac0ac1a8e11946bfd8315378454c79b55e4ed9b619389d3b7", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local-replay.log": "bf0ca67473ceef66c2fe909567c9f8eced4feef671dbfb3c2690b3614b2cd003", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-REVIEW.json": "cd086d3dcee4eb388a7e9cb49920e3119d9b0feea1d1d2e40c384311472bd623", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/SCALAR-FRAME-AUDIT.json": "1d711e25e2e062ef3b391525ad71d4afe08d18e6b27eda5b5596763eee928f32", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/native.log": "a447b46b73402899e7ec61b4c1271fd78b976b235c3acaea5a68cb00aff802ca", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/phases.log": "75ffaddfec90036b04fabcf10e4965d0ded506f7e9365eb5817b988e10213e49", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/wrappers.log": "8b062d288daebce937e086c5d25c84cdd4d5f9234da53c5120d3ede5d547945d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "d8fd7226c65a2e2df30e9105f82b425243440e2a581366c9f14e3d241576bd47", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "d086055e7dd57910b91d6037048ad353525a7d41bf94d7afe6de24ae9a7704b3", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "017b24de3db9f9a0e618a6bcc83554656945589602a6c4ca839d860a984b932a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "654c322f61779c8900f4e7340b24b817671ea23bc20e2d4302918286cfe8d054", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "ea89a70674e54ba12b926b8963c170fb0652c499d8da373aceafc0c8d26c67bf", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "dcc30576df7c1bdc3c57597c7f702c1c7e120b5722b2807ef096fb110e0fe61b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "663d8c91ecc6474a034ee6e9d59e9959792a6826259ac20d9fdc8f0a6b7c4fba", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "032cb7089449a3365fa19ab166769d687fbf79b507822156fd2ebddba14a647f", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "676bb7bb8af7119b503a0f1fecd4c697ffca287ea8076f910e65ede7f45cf97b", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "df3f6d3fcce56069b4c4c64267de57e1f83d2b9751c8ebf213a7f5eb2fcd3266", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "a1176bd020a89e75aac91eaf9b4490d489db6abd352959bfe120a92b2c1bc2ba", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "3b9b12fe6da288a1aa8f13c9c70696a99e3a197b290ae8597604b2e12005164c", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/CACHE.json": "e20fb2ae1c250d25dd56595f4cb1a5ee593c5122be89fdd45d786cb31b67f7ee", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/STEPS.json": "83dbc827c8a3959448d57442facc377fc5ad1f2f1d713f76ff55c54c78850d9a", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/ledgers.log": "1738cccdc3cfc06ac0ac1a8e11946bfd8315378454c79b55e4ed9b619389d3b7", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local-replay.log": "bf0ca67473ceef66c2fe909567c9f8eced4feef671dbfb3c2690b3614b2cd003", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-REVIEW.json": "40f5238258c600c526d0f0cf29e56f94e19c974e0474fca031ecfa13f108f919", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/SCALAR-FRAME-AUDIT.json": "a8ebca94bf9a5601bebc04d4cbddd0aaca53db3bdd2549629eb8c4cef877aa0c", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/native.log": "966f9a503f35bc6c6678914e42decbcc94cf016efde887d952e4852bc6a45a29", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/phases.log": "8ae61dbf4f9f6b7b872eccb94aba7290961dcf6d1453ccd9fe980e81826fe670", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/wrappers.log": "8b062d288daebce937e086c5d25c84cdd4d5f9234da53c5120d3ede5d547945d", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "e9c058d4cd5ed40204ce0b26a8c21d7536061efc6e0cde4f79cdd76caa61d28f", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "d612868f9cb69a6278040294f7a54d802688a5c20cc0c4966c1294e14ae62b94", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "017b24de3db9f9a0e618a6bcc83554656945589602a6c4ca839d860a984b932a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "654c322f61779c8900f4e7340b24b817671ea23bc20e2d4302918286cfe8d054", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "61f8a3af0b0b20d1f5271b52e6e46f754634591c3c8b6703bc4e1a948898f0d6", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "8a525137fb19fbccab43be849d791322c0c995c3d874b9a48bff55cbe0c04fc3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "1f48ea5725a2188f06ec90cded6024fa81f364c2a4d2bd233ae1ad287b31b022", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "f1568dfe83f5e87b8f136e23a4d8b6ef1239c7fa7a527395cac1a9418963d9f3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "676bb7bb8af7119b503a0f1fecd4c697ffca287ea8076f910e65ede7f45cf97b" + }, + "fresh_current_provider_count": 2, + "manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "83dbc827c8a3959448d57442facc377fc5ad1f2f1d713f76ff55c54c78850d9a", + "ledgers.log": "1738cccdc3cfc06ac0ac1a8e11946bfd8315378454c79b55e4ed9b619389d3b7", + "local-replay.log": "bf0ca67473ceef66c2fe909567c9f8eced4feef671dbfb3c2690b3614b2cd003", + "local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "local/CLIFFORD-REVIEW.json": "40f5238258c600c526d0f0cf29e56f94e19c974e0474fca031ecfa13f108f919", + "local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "local/SCALAR-FRAME-AUDIT.json": "a8ebca94bf9a5601bebc04d4cbddd0aaca53db3bdd2549629eb8c4cef877aa0c", + "local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "966f9a503f35bc6c6678914e42decbcc94cf016efde887d952e4852bc6a45a29", + "phases.log": "8ae61dbf4f9f6b7b872eccb94aba7290961dcf6d1453ccd9fe980e81826fe670", + "wrappers.log": "8b062d288daebce937e086c5d25c84cdd4d5f9234da53c5120d3ede5d547945d" + }, + "word_sha256": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "4870d0ec8990641b5f47579e50838495acce2c7979b7248cf7e551ec5bd0061f", + "ledgers.log": "1738cccdc3cfc06ac0ac1a8e11946bfd8315378454c79b55e4ed9b619389d3b7", + "local-replay.log": "bf0ca67473ceef66c2fe909567c9f8eced4feef671dbfb3c2690b3614b2cd003", + "local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "local/CLIFFORD-REVIEW.json": "cd086d3dcee4eb388a7e9cb49920e3119d9b0feea1d1d2e40c384311472bd623", + "local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "local/SCALAR-FRAME-AUDIT.json": "1d711e25e2e062ef3b391525ad71d4afe08d18e6b27eda5b5596763eee928f32", + "local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "a447b46b73402899e7ec61b4c1271fd78b976b235c3acaea5a68cb00aff802ca", + "phases.log": "75ffaddfec90036b04fabcf10e4965d0ded506f7e9365eb5817b988e10213e49", + "wrappers.log": "8b062d288daebce937e086c5d25c84cdd4d5f9234da53c5120d3ede5d547945d" + }, + "word_sha256": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + } + }, + "retained_parent_receipt_sha256": "df3f6d3fcce56069b4c4c64267de57e1f83d2b9751c8ebf213a7f5eb2fcd3266", + "retained_reuse_receipt_sha256": "4dbba71b45b22962039c1ce593570a4155ad4ca5aef2a2a7c4c40107f644ca46", + "reused_retained_native_count": 2, + "reused_retained_parent": true, + "seconds": 306.1769065000117, + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" + }, + "original_native_receipt_sha256": "32c42af206f32dbcfb500579ac7e525a028e5caa0cc180c9890630ccbd03b44a", + "reuse_scope": "All four native chains and retained parent are unchanged, authenticated reuse from the predecessor campaign. Nested original receipt describes its historical run, not this invocation.", + "status": "PASS_AUTHENTICATED_UNCHANGED_NATIVE_SOURCE_AND_CACHE_REUSE", + "unchanged_native_providers_reused_this_run": 4 +} diff --git a/research/tensor-block-kappa/validation/OWNERS.json b/research/tensor-block-kappa/validation/OWNERS.json new file mode 100644 index 0000000000..30a86625f3 --- /dev/null +++ b/research/tensor-block-kappa/validation/OWNERS.json @@ -0,0 +1,71 @@ +{ + "calls": 1026, + "candidate_sha256": { + "DISPATCH": "164494966a463d2edce30fa3698d05928c093d00d8cda8568a670174fc81857f", + "FILL": "27cdac384c88bbcb7c608c031cf1def6084aa4f1e411a9c90c9ed9449ab2e5ad", + "ORDER": "16d90ed352663d98d4c9829e7017724fa3a28d771f6ed4cea3cf6291715e9190", + "PROFILE": "3d15a2138f0edda12a7959c14c7e2f4dd2e34476e861e6655a0ae35c2c4b75a0" + }, + "controls": [ + { + "name": "false_replica_count", + "reason": "complete T call coverage" + }, + { + "name": "missing_literal_helper_role", + "reason": "complete role count" + }, + { + "name": "unbound_provider_at_actual_call", + "reason": "provider dispatch coverage" + }, + { + "name": "unavailable_source_window", + "reason": "literal source window" + }, + { + "name": "same_call_physical_family_collision", + "reason": "same-call family collision" + }, + { + "name": "unpaid_hole_in_compact_pending_prefix", + "reason": "compact bin prefix" + }, + { + "name": "changed_total_paid_profile", + "reason": "complete claimed profile" + } + ], + "idle": { + "1": 26676, + "3": 10158, + "32": 1, + "48": 40914, + "5": 15218 + }, + "live": 102144, + "physical": 102634, + "profile": { + "1": 2470608, + "2": 664848, + "3": 285126, + "32": 1, + "4": 131328, + "48": 40914, + "5": 41894, + "8": 8208 + }, + "provider_source_sha256": { + "independent_local.py": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "inputs/PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "inputs/WORD-base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "inputs/WORD-extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + }, + "rank_mass": 7420032, + "replicas": 114, + "roles": 418608, + "scope": "PR2802 head17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd; finite literal whole-owner geometry, scalar endpoints and paid profile only; full native/global/outer admission remains separate.", + "status": "PASS_INDEPENDENT_T_OWNER_CHRONOLOGY_MASKS" +} diff --git a/research/tensor-block-kappa/validation/ROOT-ROUTE.json b/research/tensor-block-kappa/validation/ROOT-ROUTE.json new file mode 100644 index 0000000000..eb19e4a554 --- /dev/null +++ b/research/tensor-block-kappa/validation/ROOT-ROUTE.json @@ -0,0 +1,7 @@ +{ + "canonical_source_sha256": "52a61d4d8ed0897f097001b9aac1d1ea46b57a0deec5598734b6badae134c420", + "kernel_receipt_sha256": "701569c10b1950094cbbcf12c0535aea20ea6f2cc31bcc18e641c8bc893ff552", + "scope": "The final portable audit independently checks every defining-module declaration and its transitive axioms. The route controller default audit-output directory denied writes. Canonical DAG refresh also denied its existing refresh.lock; the authoritative DAG is unchanged and no alternate DAG or configuration change was made.", + "status": "PASS_EXACT_FINAL_BLOCK_ENERGY_KERNEL_AUDIT", + "theorem": "MultitapeToolkit.TensorBlockNorm.total_energy_bound" +} diff --git a/research/tensor-block-kappa/vendor/frontier/CLAIM.json b/research/tensor-block-kappa/vendor/frontier/CLAIM.json new file mode 100644 index 0000000000..2e64718924 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/CLAIM.json @@ -0,0 +1,49 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717794984118634663827", + "complex_upper": "0.001717794984118634663828", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": "2751", + "comparison_head": "4cfbb0cc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2751, + "head": "4cfbb0cc", + "exact_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000" + }, + "comparisons": { + "2751": { + "kappa_source": "evidence/PR2751-CLAIM.json", + "exact_margin": "326698885104162859/500000000000000000000000", + "margin_float": 6.533977702083258e-07 + }, + "2766": { + "kappa_source": "evidence/PR2766-CLAIM.json", + "exact_margin": "538010651632355557/1000000000000000000000000", + "margin_float": 5.380106516323556e-07 + }, + "2767": { + "kappa_source": "evidence/PR2767-OUTER-CLAIM.json", + "exact_margin": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)", + "margin_float": 5.380106516323556e-07 + } + }, + "new_contribution": "two hostee moves (the hostees of B-warps 30/31 move from lenders 401/403 onto the free retired lenders 564/565) that free 401/403 for two more retired-lender aliases 667<-401 and 669<-403, on top of the five retired-lender aliases 606<-550, 635<-551, 637<-552, 638<-553, 639<-562", + "credited_refit": "the certified frame refit of PR2751's words (B1151 rank 6->5 plus A0-A11, B771-788, restore60; per call H1 -2, H2 +1) is PR2766's (DavidAriasC); PR2767 (jeremykothe2) reaches the same kappa by another route", + "local_predecessor": { + "package": "research/t74-joint-twelve-retired5 (local, unpublished; branch t74-joint-twelve-retired5 b295183e)", + "exact_kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "exact_margin": "385667783143020379/1000000000000000000000000", + "margin_float": 3.856677831430204e-07 + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-CODE.patch b/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-CODE.patch new file mode 100644 index 0000000000..15b163674a --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-CODE.patch @@ -0,0 +1,137 @@ +--- a/audit_mixed.py ++++ b/audit_mixed.py +@@ -9,7 +9,7 @@ + for _nm,_mut in (('changed lifted target frame',lambda b_:b_['target_levels'].__setitem__('23',0)),): + _bad=copy.deepcopy(w);_mut(_bad) + try:A.local_inventory(_bad,r,None) +- except ValueError as _e:A.require(str(_e)=='target line30','target mutation rejection') ++ except ValueError as _e:A.require(str(_e)=='candidate exact source-partner target frames','target mutation rejection') + else:raise ValueError('accepted changed lifted target') + _pg=A.read(d/'LOCAL-PROGRAMS.json.gz');_bp=copy.deepcopy(_pg);_bp['forward'].remove(next(e for e in _bp['forward'] if e[0]=='center')) + try:A.local_inventory(w,r,_bp) +--- a/independent_core.py ++++ b/independent_core.py +@@ -69,8 +69,7 @@ + External ports/frames are independently checked by audit_mixed.py. + """ + levels = {int(t): f for t, f in word['target_levels'].items()} +- require(set(levels) == {11,23,29,32,34,35,45,48,50,59,63,71,73,76,81,84,87,90,92,108}, 'twenty source-partner target offsets') +- require(all(frames[f] in ((30,), (45,)) for f in levels.values()), 'target line30') ++ require({str(t): list(frames[f]) for t, f in levels.items()} == {'104': [45], '106': [45], '110': [45], '14': [45], '21': [45], '37': [45], '41': [45], '43': [45], '47': [45], '52': [45], '78': [45], '99': [45]}, 'candidate exact source-partner target frames') + require(all(current[V+t] == frames[levels.get(t, 0)] for t in range(V)), 'target centre level') + forward, backward = [], [] + for index, (register, frame_id) in enumerate(zip(word['centers'], word['center_frames'])): +@@ -90,7 +89,7 @@ + origin = destination + forward.extend(segments) + backward.extend(e[:2]+[e[3], e[2], e[4]] for e in reversed(segments)) +- require(Counter(e[4] for e in forward) == {1:8, 7:8}, 'sixteen centre children') ++ require(Counter(e[4] for e in forward) == {8:8}, 'candidate eight unsplit centre children') + return {'forward': forward, 'backward': backward} + + +--- a/new/borrow/lowfour_controls.py ++++ b/new/borrow/lowfour_controls.py +@@ -20,12 +20,13 @@ + ia=next(i for i,e in enumerate(pre) if e[0]=='add') + m=mut();m['A'][ia][3]=-m['A'][ia][3];expect('prelude correction sign flipped',m) + m=mut();m['A'][ia][3]*=2;expect('prelude correction coefficient doubled',m) +- m=mut();m['A'][ia][1],m['A'][ia+1][1]=m['A'][ia+1][1],m['A'][ia][1];expect('prelude correction targets swapped',m) ++ jb=next(j for j,e in enumerate(pre) if e[0]=='add' and e[1]!=pre[ia][1] and e[2:]!=pre[ia][2:] and e[-1]==pre[ia][-1]) ++ m=mut();m['A'][ia][1],m['A'][jb][1]=m['A'][jb][1],m['A'][ia][1];expect('prelude correction targets swapped',m) + iw=[i for i,e in enumerate(pre) if e[0]=='warp'];m=mut();del m['A'][iw[1]];m['prelude_events']-=1;expect('prelude return warp dropped',m) + m=mut();del m['A'][iw[0]];m['prelude_events']-=1;expect('prelude forward warp dropped',m) +- ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==135];m=mut() ++ target=pre[ia][1];ids=[i for i,e in enumerate(pre) if e[0]=='add' and e[1]==target];assert ids;m=mut() + for i in reversed(ids):del m['A'][i] +- m['prelude_events']-=len(ids);expect('all prelude corrections of target 135 dropped',m) ++ m['prelude_events']-=len(ids);expect('all prelude corrections of actual first target dropped',m) + m=mut();m['A'][0][-1]=[31];expect('prelude target scale at a different line',m) + m=mut();m['A'][iw[0]][2]=m['A'][iw[0]][2]+1 if abs(m['A'][iw[0]][2])i:r[0]-=1 + expect('source restoration gate dropped (cleanup re-derived)',rederive(m)) + # rewritten helper gate on the borrowed source removed +- j=next(i for i,g in enumerate(w0['B']) if g[0]=='add' and g[1]==33 and g[2]==250) ++ j=next(i for i,g in enumerate(w0['B']) if i>=w0['warps'][W33][0] and g[0]=='add' and g[1]==33) + m=mut();del m['B'][j] + for r in m['warps']: + if r[0]>j:r[0]-=1 +--- a/new/code/borrow/bw_audit_local.py ++++ b/new/code/borrow/bw_audit_local.py +@@ -179,6 +179,17 @@ + def phase_at(es,name):return es.index(['phase',name]) + def first_warp(es,sign=1,start=0):return ev_index(es,lambda e:e[0]=='warp' and (e[2]>0)==(sign>0),start) + def cleanup_warp(es):return first_warp(es,-1,phase_at(es,'full_frame_cleanup')) ++def incomplete_centre_descent(es): ++ # Split paths lose an intermediate step. An unsplit path is truncated at ++ # an actual nested rank-one frame, with its child rank repriced correctly. ++ # Thus the control cannot fail merely because a split no longer exists. ++ indices=[i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0] ++ if indices: ++ es.pop(indices[0]);return ++ e=next(e for e in es if e[0]=='center') ++ stop=next(f for f in range(len(frames)) if len(frames[f])==1 and contains(frames[f],frames[e[2]])) ++ e[3]=stop;e[4]=len(frames[e[2]])-1 ++ + mutations=[ + ('wrong_scale',lambda es:next(e for e in es if e[0]=='scalar' and e[1][0]=='scale')[1].__setitem__(2,3)), + ('missing_center',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center'))), +@@ -194,7 +205,7 @@ + ('wrapper_on_a_centre_register',lambda es:next(e for e in es if e[0]=='residual_adapter').__setitem__(2,['C',0])), + ] if entering else [])+([ + ('centre_step_not_nested',lambda es:next(e for e in es if e[0]=='center').__setitem__(3,next(f for f in range(len(frames)) if not contains(frames[f],frames[next(e for e in es if e[0]=='center')[2]]) and not contains(frames[next(e for e in es if e[0]=='center')[2]],frames[f])))), +- ('centre_descent_step_skipped',lambda es:es.pop(next(i for i,e in enumerate(es) if e[0]=='center' and e[3]!=0))), ++ ('centre_descent_incomplete',incomplete_centre_descent), + ] if levels else [])+([ + ('hpe_pre_wrapper_resolved_to_full_recipe',lambda es:next(e for e in es if e[0]=='residual_adapter' and e[1]=='pre' and len(e)==5).pop()), + ('hpe_post_wrapper_without_terminal_frame',lambda es:next(e for e in es if e[0]=='residual_adapter' and len(e)==5).pop()), +--- a/new/rebuild_borrow.py ++++ b/new/rebuild_borrow.py +@@ -74,10 +74,10 @@ + 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'] ++ 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']))==[696,697,698,700]==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'] ++ kok&={k_:v_ for k_,v_ in prev_l['start_extra'].items() if k_ not in('696','697','698','700')}==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] +@@ -102,10 +102,10 @@ + 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) ++ if rf2.exists(): # one-gate exact frame lowering (B 904, 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&=len(rpatch2['frames'])==1 and rpatch2['frames'][0][:2]==['B',904] and prev_r['B'][904][:5]==['add',515,563,1,1] ++ kok&=len(nr['B'][904][-1])==len(prev_r['B'][904][-1])-1 and all(x_==y_ for i_,(x_,y_) in enumerate(zip(nr['B'],prev_r['B'])) if i_!=904) + 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) +@@ -141,9 +141,9 @@ + 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) ++ if rpatch2: # control: the shipped word with the B 904 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(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)) ++ m=cp6.deepcopy(final);m['B'][904][-1]=prev_r['B'][904][-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(shipped),str(xf),str(RCP/f'CONTROLS-ALIAS1-43{wt}.json')],capture_output=True,text=True) diff --git a/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-OVERLAY.tar.gz b/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-OVERLAY.tar.gz new file mode 100644 index 0000000000..8e2ac23939 Binary files /dev/null and b/research/tensor-block-kappa/vendor/frontier/DERIVATIVE-OVERLAY.tar.gz differ diff --git a/research/tensor-block-kappa/vendor/frontier/DOWNLOAD-MANIFEST.json b/research/tensor-block-kappa/vendor/frontier/DOWNLOAD-MANIFEST.json new file mode 100644 index 0000000000..bb877f38cd --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/DOWNLOAD-MANIFEST.json @@ -0,0 +1,1122 @@ +{ + "head": "17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd", + "source_channel": "ordinary pinned raw; headSha from public PR HTML; all primary subtree paths and Git blob IDs checked against current public diff", + "files": [ + { + "path": ".gitattributes", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/.gitattributes", + "sha256": "12ab6f9af287290f2f2404907fdd114faa5a085fe9eae713294537ff6b45132e", + "git_blob": "f7e56e18b7b7b669a4f6b94e05816938be3f075e", + "diff_blob": "f7e56e18b7", + "bytes": 121, + "utc": "2026-10-15T23:07:26.793Z" + }, + { + "path": "CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/CLAIM.json", + "sha256": "a2fcbc8a3ad3095ecbd310a26c02e9d11c28e4d105669a08bbdfb39d7704db51", + "git_blob": "2e647189246376ee0ea855f50299f91483012371", + "diff_blob": "2e64718924", + "bytes": 2443, + "utc": "2026-10-15T23:07:26.792Z" + }, + { + "path": "composition.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/composition.py", + "sha256": "f202f8ce9730b778c9ee1213d63d444d117df5ff7d47933037a924723a37e3f4", + "git_blob": "bb455e907ddf8227cb5c8062825540eda219ba17", + "diff_blob": "bb455e907d", + "bytes": 6485, + "utc": "2026-10-15T23:07:27.973Z" + }, + { + "path": "DERIVATIVE-CODE.patch", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/DERIVATIVE-CODE.patch", + "sha256": "36fe5e24ecf22be987360647de1167185ffb92603bebb1959a065e56524586e1", + "git_blob": "15b163674a4370b1914752cec39f30db6fb23e72", + "diff_blob": "15b163674a", + "bytes": 11858, + "utc": "2026-10-15T23:07:26.793Z" + }, + { + "path": "DERIVATIVE-OVERLAY.tar.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/DERIVATIVE-OVERLAY.tar.gz", + "sha256": "12335359418a2d75ff62ada3f868497590e025d5b39f6ee01f1a50f23c9768af", + "git_blob": "8e2ac2393958b98a07bd4973d8a9b47720b19653", + "diff_blob": "8e2ac23939", + "bytes": 1726272, + "utc": "2026-10-15T23:07:27.069Z" + }, + { + "path": "evidence/ADMISSION.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/ADMISSION.json", + "sha256": "b85b5b339353ae2a1935afa2963fcde7db9f66b41f205ddd632210257a8be168", + "git_blob": "df8d10716f4198e3b03cd1e3a842c5d536c21806", + "diff_blob": "df8d10716f", + "bytes": 7481, + "utc": "2026-10-15T23:07:28.013Z" + }, + { + "path": "evidence/INDEPENDENT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/INDEPENDENT.json", + "sha256": "f9e4500e5cb1ab1b9e8189de6dfbcca8dd9f7e2ea1a9ffce6801d6530797c0d2", + "git_blob": "750227462f19d1f500b69e6b1eaf1175917723b6", + "diff_blob": "750227462f", + "bytes": 11397, + "utc": "2026-10-15T23:07:27.973Z" + }, + { + "path": "evidence/NATIVE-BASE.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/NATIVE-BASE.json", + "sha256": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "git_blob": "fd79ad2f2a6c4a7e7b23a6c25f7db39118064830", + "diff_blob": "fd79ad2f2a", + "bytes": 433, + "utc": "2026-10-15T23:07:27.965Z" + }, + { + "path": "evidence/NATIVE-EXTRA.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/NATIVE-EXTRA.json", + "sha256": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "git_blob": "930bbf3cd1476b396610274fc10545197564750a", + "diff_blob": "930bbf3cd1", + "bytes": 434, + "utc": "2026-10-15T23:07:28.197Z" + }, + { + "path": "evidence/OWNERS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/OWNERS.json", + "sha256": "4df2066f097e4b59edf7d7af0e7e234413b9d2a09de4302d02adb3869972f672", + "git_blob": "00ff9fe9e4e57d28d9f10257adf13f9cb468d7ea", + "diff_blob": "00ff9fe9e4", + "bytes": 499, + "utc": "2026-10-15T23:07:28.190Z" + }, + { + "path": "evidence/PACKING-CAP.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PACKING-CAP.json", + "sha256": "59deb044b1b46953cbfd2fcedd3026a901d4524d7d05c592b8e1420501f6e652", + "git_blob": "e304fa1a3aaaf03407104c51fae184d70cc4973b", + "diff_blob": "e304fa1a3a", + "bytes": 1136, + "utc": "2026-10-15T23:07:28.169Z" + }, + { + "path": "evidence/PR2733-CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PR2733-CLAIM.json", + "sha256": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "git_blob": "e97166d50158786e666c8e0d97d12f79a098df29", + "diff_blob": "e97166d501", + "bytes": 2775, + "utc": "2026-10-15T23:07:28.154Z" + }, + { + "path": "evidence/PR2745-CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PR2745-CLAIM.json", + "sha256": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3", + "git_blob": "abec1247c37e0bea60bb9feea293bb17b81a97a3", + "diff_blob": "abec1247c3", + "bytes": 11134, + "utc": "2026-10-15T23:07:28.380Z" + }, + { + "path": "evidence/PR2751-CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PR2751-CLAIM.json", + "sha256": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438", + "git_blob": "48ad23a430def28e485ee311ac92828ac9664a0c", + "diff_blob": "48ad23a430", + "bytes": 848, + "utc": "2026-10-15T23:07:28.381Z" + }, + { + "path": "evidence/PR2766-CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PR2766-CLAIM.json", + "sha256": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8", + "git_blob": "d352e67b80455a435b2527880bd5690806097a7d", + "diff_blob": "d352e67b80", + "bytes": 1490, + "utc": "2026-10-15T23:07:28.341Z" + }, + { + "path": "evidence/PR2767-OUTER-CLAIM.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PR2767-OUTER-CLAIM.json", + "sha256": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "git_blob": "2bb218a7506c0e29fdb466f0c9ffdf5c04665370", + "diff_blob": "2bb218a750", + "bytes": 11126, + "utc": "2026-10-15T23:07:28.381Z" + }, + { + "path": "evidence/PUBLIC-WRAPPER.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/PUBLIC-WRAPPER.json", + "sha256": "70acee53d90097edfa3e7c99ad68311f236bade5ee71a446bcc8935e9e7e3192", + "git_blob": "e705eabcffaf911a16e4e887f3713cb34306d199", + "diff_blob": "e705eabcff", + "bytes": 9845, + "utc": "2026-10-15T23:07:28.570Z" + }, + { + "path": "evidence/RELEASE.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/RELEASE.json", + "sha256": "5839b3b3448d67d7a936fe962298d7d77cb83ee489321343af7769166f5d0142", + "git_blob": "e44dc7c69b07aa44bc69b41f6c19e5369d58aee7", + "diff_blob": "e44dc7c69b", + "bytes": 2241, + "utc": "2026-10-15T23:07:28.532Z" + }, + { + "path": "evidence/retired5/ADMISSION-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-RESULT.json", + "sha256": "e441d6bfef1554491087a5b4701a8b23b331af3b57f77a38f3de4a47d940a6bf", + "git_blob": "51fc18760793c0b0d3f481a20ea598c94896399c", + "diff_blob": "51fc187607", + "bytes": 6368, + "utc": "2026-10-15T23:07:28.569Z" + }, + { + "path": "evidence/retired5/ADMISSION-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/ADMISSION-STAGES.json", + "sha256": "be3bf7f8fb4208bdea8dae25a8db0beda8d31cd5ac8a61279b22928ededb58bb", + "git_blob": "a5d5bc1130417950ec036e0ef89f94b1733b5d30", + "diff_blob": "a5d5bc1130", + "bytes": 3427, + "utc": "2026-10-15T23:07:28.530Z" + }, + { + "path": "evidence/retired5/CERT2751.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/CERT2751.json", + "sha256": "d2f63d1167e0e1811f8b2b62ee50353184ca0ed86ab2c0bc96bf37edccf1eeff", + "git_blob": "dde7a0f3d0b6db45dc35644499bb7c25e074d3bc", + "diff_blob": "dde7a0f3d0", + "bytes": 4168, + "utc": "2026-10-15T23:07:28.719Z" + }, + { + "path": "evidence/retired5/CONTROLS-ALIAS5-43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43base.json", + "sha256": "da173b7590da4717880098dd6cef3c597e4dffccd163b3c85b3b8fbf3d242f3e", + "git_blob": "9785264a786b64300369774323402bad46a998f2", + "diff_blob": "9785264a78", + "bytes": 4929, + "utc": "2026-10-15T23:07:28.728Z" + }, + { + "path": "evidence/retired5/CONTROLS-ALIAS5-43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/CONTROLS-ALIAS5-43extra.json", + "sha256": "da173b7590da4717880098dd6cef3c597e4dffccd163b3c85b3b8fbf3d242f3e", + "git_blob": "9785264a786b64300369774323402bad46a998f2", + "diff_blob": "9785264a78", + "bytes": 4929, + "utc": "2026-10-15T23:07:28.720Z" + }, + { + "path": "evidence/retired5/FULL-REPLAY-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-RESULT.json", + "sha256": "5d884e943ba270223218cac39e10b4355cd217802232c8363a03f2d15bb77bdf", + "git_blob": "d276ca96c521c23aec9fa2db320388c0b5741eb0", + "diff_blob": "d276ca96c5", + "bytes": 10855, + "utc": "2026-10-15T23:07:28.758Z" + }, + { + "path": "evidence/retired5/FULL-REPLAY-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/FULL-REPLAY-STAGES.json", + "sha256": "80ac023ea6c8e152d538f873855c3b917f1fb80fc34c9f2d4db19ee9cab76de8", + "git_blob": "384e4a8a7e38aed6b232599b6916a0050ff76a17", + "diff_blob": "384e4a8a7e", + "bytes": 3882, + "utc": "2026-10-15T23:07:28.903Z" + }, + { + "path": "evidence/retired5/GENERATE-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/GENERATE-LOG.txt", + "sha256": "18a234b13f2b7e7b98c59f1be8799fbfde2284a2a64a0eaf9be0aa53115ef5fa", + "git_blob": "58bf5e824477396a5b70e69d3ea64635d1257a28", + "diff_blob": "58bf5e8244", + "bytes": 9111, + "utc": "2026-10-15T23:07:28.904Z" + }, + { + "path": "evidence/retired5/HOOK-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/HOOK-RESULT.json", + "sha256": "76b67d54df3a6da3bb7f6fe3402f11d2926cb48353bf068dc34eeb560784771a", + "git_blob": "c2f514c451a9c65ddb32a83e08b5168abbb4eca2", + "diff_blob": "c2f514c451", + "bytes": 10668, + "utc": "2026-10-15T23:07:28.925Z" + }, + { + "path": "evidence/retired5/NATIVE-RECEIPT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/NATIVE-RECEIPT.json", + "sha256": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "git_blob": "b30f12f22ca6b894e8ae8fab2ac9e73c2872e03e", + "diff_blob": "b30f12f22c", + "bytes": 15939, + "utc": "2026-10-15T23:07:28.904Z" + }, + { + "path": "evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt", + "sha256": "cf06397f5fdaf50f8e44af4ff64d6a97865b79d5bc86024ba7c6f653698a6d8e", + "git_blob": "9119865da294e626d78994447b7d2744934fa9bd", + "diff_blob": "9119865da2", + "bytes": 3879, + "utc": "2026-10-15T23:07:29.176Z" + }, + { + "path": "evidence/retired5/RELEASE-RECEIPT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-RECEIPT.json", + "sha256": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "git_blob": "b4684a573d70a6ce21660fa372217fbdb628023b", + "diff_blob": "b4684a573d", + "bytes": 2241, + "utc": "2026-10-15T23:07:29.099Z" + }, + { + "path": "evidence/retired5/RELEASE-VERIFY-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-RESULT.json", + "sha256": "6a4d591c2c827a899cb9a3682ef3f05fd97fc58842e68ae9aead5d14d3f62654", + "git_blob": "7caccd3f8f49e669ca4d353abfbabe10a447c672", + "diff_blob": "7caccd3f8f", + "bytes": 3334, + "utc": "2026-10-15T23:07:29.074Z" + }, + { + "path": "evidence/retired5/RELEASE-VERIFY-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/RELEASE-VERIFY-STAGES.json", + "sha256": "ed04eb3d4ec175b3b211cef890376529c1e9dc3f69974269106dbff9e52bcde0", + "git_blob": "aff147d9edbec561e1329683e8e17a5bb0e8abdf", + "diff_blob": "aff147d9ed", + "bytes": 2196, + "utc": "2026-10-15T23:07:29.074Z" + }, + { + "path": "evidence/retired5/RUNTIME-PATCHES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired5/RUNTIME-PATCHES.json", + "sha256": "a20936449a1d23f79c8c040d47039e563d2bcdfc534d1c1de7d25d221a7f483c", + "git_blob": "2fea51a3dd614e34654cb0b713925a999a53add9", + "diff_blob": "2fea51a3dd", + "bytes": 1236, + "utc": "2026-10-15T23:07:29.349Z" + }, + { + "path": "evidence/retired7/ADMISSION-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-RESULT.json", + "sha256": "259c1a9da2ebfceb4b4cea2732b5a6d144cc85d7d8a92f4474d29ee3a5c75fc2", + "git_blob": "4ceb18a8494d9444ba59483257dd207d32ccb83c", + "diff_blob": "4ceb18a849", + "bytes": 6812, + "utc": "2026-10-15T23:07:29.316Z" + }, + { + "path": "evidence/retired7/ADMISSION-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/ADMISSION-STAGES.json", + "sha256": "f86a0c1ff418c3da14f573dbf900eae96657a33b4d3829c7c5da8036890c9f87", + "git_blob": "8b12d62f6fd80f03ef2d6ac2fefd589d59753fa1", + "diff_blob": "8b12d62f6f", + "bytes": 4125, + "utc": "2026-10-15T23:07:29.349Z" + }, + { + "path": "evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json", + "sha256": "ede02c0657d73229aa8943046aeb6c72f8300719f95b6a2f770935173287dca9", + "git_blob": "0205988129b4376b220054cb4b43badfe3a50a68", + "diff_blob": "0205988129", + "bytes": 1380, + "utc": "2026-10-15T23:07:29.349Z" + }, + { + "path": "evidence/retired7/CONTROLS-RETIRED7-43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43base.json", + "sha256": "1b52cc644573f2b39a66be799c90b82e59c2b25341bbdcfa8d4ef0baea0fdd60", + "git_blob": "45cecc552baa0f4b968bb05a425cdd6e77868e06", + "diff_blob": "45cecc552b", + "bytes": 4178, + "utc": "2026-10-15T23:07:29.509Z" + }, + { + "path": "evidence/retired7/CONTROLS-RETIRED7-43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/CONTROLS-RETIRED7-43extra.json", + "sha256": "1b52cc644573f2b39a66be799c90b82e59c2b25341bbdcfa8d4ef0baea0fdd60", + "git_blob": "45cecc552baa0f4b968bb05a425cdd6e77868e06", + "diff_blob": "45cecc552b", + "bytes": 4178, + "utc": "2026-10-15T23:07:29.481Z" + }, + { + "path": "evidence/retired7/FULL-REPLAY-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-RESULT.json", + "sha256": "3b480daeb9f2e09eeefe787d99eef9143a90ac5136faf5f9285affc65e90030d", + "git_blob": "5cced4b2db357d72c1d92cd15324b0fbbddceb64", + "diff_blob": "5cced4b2db", + "bytes": 12079, + "utc": "2026-10-15T23:07:29.518Z" + }, + { + "path": "evidence/retired7/FULL-REPLAY-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/FULL-REPLAY-STAGES.json", + "sha256": "9498e69c1c927751b3dadad8bfd887f9afff107424f0987ece9df9c17e1f5412", + "git_blob": "4d4b3a7915fc9e417faf04dbe54fd5c27e767f0f", + "diff_blob": "4d4b3a7915", + "bytes": 4767, + "utc": "2026-10-15T23:07:29.513Z" + }, + { + "path": "evidence/retired7/HOOK-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/HOOK-RESULT.json", + "sha256": "95d8169d828b0c3b7ccc02f205aa63bb33e54da95b7279c58775711ceb88df8e", + "git_blob": "e29b039fd33f34cd4c874b34a1202ceb16838126", + "diff_blob": "e29b039fd3", + "bytes": 16009, + "utc": "2026-10-15T23:07:29.709Z" + }, + { + "path": "evidence/retired7/NATIVE-RECEIPT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-RECEIPT.json", + "sha256": "baba1153f79b8de0f52273194f8fb86df7c65b51bafc9bac1504074f7c6cb982", + "git_blob": "a82fb1ff375d14db2f1db67c18f95877746bb139", + "diff_blob": "a82fb1ff37", + "bytes": 15623, + "utc": "2026-10-15T23:07:29.701Z" + }, + { + "path": "evidence/retired7/NATIVE-STANDALONE.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/NATIVE-STANDALONE.json", + "sha256": "49ee5ec3f791392555a6218e5f5cc80bf004b706ba697a298f9701ea8c4765a0", + "git_blob": "6646251c6ffad60be277f02d1654f6ead6fcb16a", + "diff_blob": "6646251c6f", + "bytes": 482, + "utc": "2026-10-15T23:07:29.749Z" + }, + { + "path": "evidence/retired7/OWNER-CHECK.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/OWNER-CHECK.json", + "sha256": "328db5dd09f5b40762a5f3fd7fefb1b9c4ad05cecb7882474cfa3450177ba935", + "git_blob": "d6c74e2ba08250c30574c035ac89a5a8f5532196", + "diff_blob": "d6c74e2ba0", + "bytes": 1298, + "utc": "2026-10-15T23:07:29.701Z" + }, + { + "path": "evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt", + "sha256": "59dec80790bee9a132d92ec64db08e93ee000994ac4e0188da7b1829dac8ccab", + "git_blob": "065d3aa6532a970ab13b0044a8ed4749abd65360", + "diff_blob": "065d3aa653", + "bytes": 4367, + "utc": "2026-10-15T23:07:29.938Z" + }, + { + "path": "evidence/retired7/REGISTERED-HOOK-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/REGISTERED-HOOK-LOG.txt", + "sha256": "16ec70f1c8191c18aa8f6422f972519b99df01002ffde5b12ac4febe0be22f46", + "git_blob": "4a2aa3c2d09d331f408cfb09e3d347cb682244ec", + "diff_blob": "4a2aa3c2d0", + "bytes": 18966, + "utc": "2026-10-15T23:07:29.885Z" + }, + { + "path": "evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt", + "sha256": "d9977346de4ceb88d152ac8e892fdb65af572933aa967fd726a7620fa3e29074", + "git_blob": "b5157e14f384f8133bd74fdbd6d1b703c5282ff7", + "diff_blob": "b5157e14f3", + "bytes": 4420, + "utc": "2026-10-15T23:07:29.895Z" + }, + { + "path": "evidence/retired7/RELEASE-RECEIPT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-RECEIPT.json", + "sha256": "8698b42e6239cffcd92ae4a87605451d799b7b751bcf4a432fd851a548ceff48", + "git_blob": "37735f2254fd26b5aa55826ab8cc995d181308ec", + "diff_blob": "37735f2254", + "bytes": 2236, + "utc": "2026-10-15T23:07:29.938Z" + }, + { + "path": "evidence/retired7/RELEASE-VERIFY-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-RESULT.json", + "sha256": "4eee4b247783eceb62c785385e5d6965241655e963eabad33ee64a26964fcd49", + "git_blob": "680f2d73e5a9dcb7c319e966cceaf36282dc5b74", + "diff_blob": "680f2d73e5", + "bytes": 3116, + "utc": "2026-10-15T23:07:30.091Z" + }, + { + "path": "evidence/retired7/RELEASE-VERIFY-STAGES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RELEASE-VERIFY-STAGES.json", + "sha256": "8278e1e93057f1f7e19b9c4058a249597a80c78b8dfa0e15bb6f206aefaf5f6e", + "git_blob": "3686810428862426cb5bd3dbe895bbdfc166919b", + "diff_blob": "3686810428", + "bytes": 2079, + "utc": "2026-10-15T23:07:30.127Z" + }, + { + "path": "evidence/retired7/RESEARCH-TESTS-LOG.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RESEARCH-TESTS-LOG.txt", + "sha256": "e7eb21fea3fd1e55b60ea4f7013b4bc13db048043e733c5b1c09273cf1a43f63", + "git_blob": "b0448692e46dbb256d4f5e51c834f2bab5f368eb", + "diff_blob": "b0448692e4", + "bytes": 400, + "utc": "2026-10-15T23:07:30.138Z" + }, + { + "path": "evidence/retired7/RUNTIME-PATCHES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/RUNTIME-PATCHES.json", + "sha256": "f9cf016d89b318398a0737cb304f1f9a32098589b9fb3b89ab79bb10e3f9bbe5", + "git_blob": "ce6e8881de73df6d90e548bf274de8d5320cb7aa", + "diff_blob": "ce6e8881de", + "bytes": 1156, + "utc": "2026-10-15T23:07:30.091Z" + }, + { + "path": "evidence/retired7/STAGES7.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/STAGES7.json", + "sha256": "ab5fd9336ae23174cdee523d7c46a5eda201e04ce5391170d00963783a3d71c8", + "git_blob": "1e3fe61a7dbde68163c817be0b57604bcd2e14eb", + "diff_blob": "1e3fe61a7d", + "bytes": 1534, + "utc": "2026-10-15T23:07:30.368Z" + }, + { + "path": "evidence/retired7/VERIFY-RESULT.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/evidence/retired7/VERIFY-RESULT.json", + "sha256": "7f404f3d4638142ba3a77fc2a18d34d4926abcae528ce0ed1af0c4b4dad71a0a", + "git_blob": "8b8cb29852ab4fa36750f4be4be0211b184150e7", + "diff_blob": "8b8cb29852", + "bytes": 437, + "utc": "2026-10-15T23:07:30.417Z" + }, + { + "path": "exact_moment.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/exact_moment.py", + "sha256": "f170292f7983773d4f142afdac4677c1615fb7b781dbabf395200aea886dcade", + "git_blob": "30dc8aa22939ea377d893462a863bc7c37b4e210", + "diff_blob": "30dc8aa229", + "bytes": 1522, + "utc": "2026-10-15T23:07:30.309Z" + }, + { + "path": "full_replay.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/full_replay.py", + "sha256": "3f7ff263775253f73a87abc43a76f39f23e8bc0ce433a562d17f2c0705b5a02b", + "git_blob": "d9718b8b5b173ab81efaee24c04e5c99b6e70e94", + "diff_blob": "d9718b8b5b", + "bytes": 12140, + "utc": "2026-10-15T23:07:30.349Z" + }, + { + "path": "generate.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/generate.py", + "sha256": "24b90102b48ed9adf2621412fbff594b9e231041ca385258794881054d67f7a3", + "git_blob": "dafca20149f2e24ef82e266ee08db494dbeb78f3", + "diff_blob": "dafca20149", + "bytes": 4265, + "utc": "2026-10-15T23:07:30.576Z" + }, + { + "path": "GENERATOR-PINS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/GENERATOR-PINS.json", + "sha256": "8823d9ad809cdd2e469f21ae1982a379f302bb9bf177cff069ef99a52163c286", + "git_blob": "53cbe5b14d7556b53e494144f4bf6b7531a24a33", + "diff_blob": "53cbe5b14d", + "bytes": 808, + "utc": "2026-10-15T23:07:27.246Z" + }, + { + "path": "independent_local.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/independent_local.py", + "sha256": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20", + "git_blob": "e0b556adc3d05c8f97e94992e0f872916154202d", + "diff_blob": "e0b556adc3", + "bytes": 7322, + "utc": "2026-10-15T23:07:31.227Z" + }, + { + "path": "independent_owners.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/independent_owners.py", + "sha256": "219e16a7f35c5c9e9640760c28ad49a17b546c9f32bdf57dd76c30b5dd096aa6", + "git_blob": "b196522f05f4249c06cc75feae42613acee5cb1e", + "diff_blob": "b196522f05", + "bytes": 5170, + "utc": "2026-10-15T23:07:30.617Z" + }, + { + "path": "INPUT-PINS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/INPUT-PINS.json", + "sha256": "c59957b3a312c643e8de6fa12c57adc0683ef29d8d74b051d0087a7c64232d21", + "git_blob": "db68544ada4ef515257e6f1e0dbb46991e7ca3d2", + "diff_blob": "db68544ada", + "bytes": 3893, + "utc": "2026-10-15T23:07:27.312Z" + }, + { + "path": "inputs/alias5_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/alias5_43base.json", + "sha256": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "git_blob": "be4b73559fd42d6a0be59940e02e7505a815a363", + "diff_blob": "be4b73559f", + "bytes": 245671, + "utc": "2026-10-15T23:07:35.446Z" + }, + { + "path": "inputs/alias5_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/alias5_43extra.json", + "sha256": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "git_blob": "adc0d05913357b8c7931a82434318ee5a275dcb4", + "diff_blob": "adc0d05913", + "bytes": 245659, + "utc": "2026-10-15T23:07:35.639Z" + }, + { + "path": "inputs/alias7_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/alias7_43base.json", + "sha256": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "git_blob": "0a198a786a5b06e462d175d0bda611b8f3145fbd", + "diff_blob": "0a198a786a", + "bytes": 82808, + "utc": "2026-10-15T23:07:35.444Z" + }, + { + "path": "inputs/alias7_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/alias7_43extra.json", + "sha256": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "git_blob": "902a5c32aba01004347461a2866f844f82f3f279", + "diff_blob": "902a5c32ab", + "bytes": 82796, + "utc": "2026-10-15T23:07:35.478Z" + }, + { + "path": "inputs/DISPATCH.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/DISPATCH.json.gz", + "sha256": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11", + "git_blob": "4f4c2138d6be71dc649b8ee746385f059c242f21", + "diff_blob": "4f4c2138d6", + "bytes": 1637, + "utc": "2026-10-15T23:07:30.736Z" + }, + { + "path": "inputs/FILL.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/FILL.json.gz", + "sha256": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "git_blob": "6441c0be4d116e1248d6cf0e163312e70db3a7e9", + "diff_blob": "6441c0be4d", + "bytes": 1268295, + "utc": "2026-10-15T23:07:31.639Z" + }, + { + "path": "inputs/FILL2751.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/FILL2751.json.gz", + "sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "git_blob": "17129e917b31b15625c53181d303b68e17ffed55", + "diff_blob": "17129e917b", + "bytes": 1263865, + "utc": "2026-10-15T23:07:32.944Z" + }, + { + "path": "inputs/GLOBAL-TEMPLATE.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/GLOBAL-TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "diff_blob": "114808c32b", + "bytes": 1124331, + "utc": "2026-10-15T23:07:31.585Z" + }, + { + "path": "inputs/hostmove2_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/hostmove2_43base.json", + "sha256": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "git_blob": "a20eeb8f4a07ee82abd38186ad8b5ee11cac56dc", + "diff_blob": "a20eeb8f4a", + "bytes": 83147, + "utc": "2026-10-15T23:07:35.808Z" + }, + { + "path": "inputs/hostmove2_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/hostmove2_43extra.json", + "sha256": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "git_blob": "e65144f5ec357d7f1940495d216c82921bfabea2", + "diff_blob": "e65144f5ec", + "bytes": 83135, + "utc": "2026-10-15T23:07:36.287Z" + }, + { + "path": "inputs/ORDER.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/ORDER.json", + "sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "git_blob": "c202d6ec222a257a64b2017eb1bbb0f9d2682669", + "diff_blob": "c202d6ec22", + "bytes": 4574, + "utc": "2026-10-15T23:07:31.424Z" + }, + { + "path": "inputs/PLAN.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/PLAN.json.gz", + "sha256": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "git_blob": "973f576bccc4b8021bfa9b4fff815b0949fe5932", + "diff_blob": "973f576bcc", + "bytes": 29584, + "utc": "2026-10-15T23:07:33.128Z" + }, + { + "path": "inputs/POSITIVE2462-base.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/POSITIVE2462-base.json.gz", + "sha256": "3506c84203f126900326ff4d22aaceda819734e5f96fa4622d43fbb78b946ece", + "git_blob": "0bc4e8c167de63931e5cc208527ad684573a373c", + "diff_blob": "0bc4e8c167", + "bytes": 70505, + "utc": "2026-10-15T23:07:33.297Z" + }, + { + "path": "inputs/POSITIVE2462-extra.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/POSITIVE2462-extra.json.gz", + "sha256": "ec7103c196b32de7af79a6f43952cbe998c085a00f1a8e740f5556c774589099", + "git_blob": "33f39e6826d181f4e0aead30b427e8de3c107a9a", + "diff_blob": "33f39e6826", + "bytes": 70509, + "utc": "2026-10-15T23:07:33.147Z" + }, + { + "path": "inputs/PROVIDERS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/PROVIDERS.json", + "sha256": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "git_blob": "b28e97eead8576399f069775aa72ba1e1078e62b", + "diff_blob": "b28e97eead", + "bytes": 5180, + "utc": "2026-10-15T23:07:33.110Z" + }, + { + "path": "inputs/PROVIDERS2751.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/PROVIDERS2751.json", + "sha256": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "git_blob": "26be26b6d25be67327ae77623c2eaa0a9fe463dc", + "diff_blob": "26be26b6d2", + "bytes": 1846, + "utc": "2026-10-15T23:07:33.476Z" + }, + { + "path": "inputs/refit5_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit5_43base.json", + "sha256": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "git_blob": "73fa6c445adff08869ece8e36e804ca8227b641a", + "diff_blob": "73fa6c445a", + "bytes": 4025, + "utc": "2026-10-15T23:07:35.789Z" + }, + { + "path": "inputs/refit5_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit5_43extra.json", + "sha256": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "git_blob": "73fa6c445adff08869ece8e36e804ca8227b641a", + "diff_blob": "73fa6c445a", + "bytes": 4025, + "utc": "2026-10-15T23:07:35.801Z" + }, + { + "path": "inputs/refit5c_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit5c_43base.json", + "sha256": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "git_blob": "6779edb0aafd7a7f8ebe29dd57ea91f2d64e9b56", + "diff_blob": "6779edb0aa", + "bytes": 2349, + "utc": "2026-10-15T23:07:36.423Z" + }, + { + "path": "inputs/refit5c_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit5c_43extra.json", + "sha256": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "git_blob": "6779edb0aafd7a7f8ebe29dd57ea91f2d64e9b56", + "diff_blob": "6779edb0aa", + "bytes": 2349, + "utc": "2026-10-15T23:07:36.633Z" + }, + { + "path": "inputs/refit7_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit7_43base.json", + "sha256": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "git_blob": "0095915f00d673b7d9c5085fcb728d624f96db53", + "diff_blob": "0095915f00", + "bytes": 573, + "utc": "2026-10-15T23:07:36.435Z" + }, + { + "path": "inputs/refit7_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit7_43extra.json", + "sha256": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "git_blob": "0095915f00d673b7d9c5085fcb728d624f96db53", + "diff_blob": "0095915f00", + "bytes": 573, + "utc": "2026-10-15T23:07:36.442Z" + }, + { + "path": "inputs/refit7c_43base.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit7c_43base.json", + "sha256": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "git_blob": "acd4d17dc2fb436c58171acaf3f140d25b1f6b2a", + "diff_blob": "acd4d17dc2", + "bytes": 488, + "utc": "2026-10-15T23:07:36.777Z" + }, + { + "path": "inputs/refit7c_43extra.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/refit7c_43extra.json", + "sha256": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "git_blob": "acd4d17dc2fb436c58171acaf3f140d25b1f6b2a", + "diff_blob": "acd4d17dc2", + "bytes": 488, + "utc": "2026-10-15T23:07:36.984Z" + }, + { + "path": "inputs/SOURCE-FILL.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/SOURCE-FILL.json.gz", + "sha256": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06", + "git_blob": "4a0d605902453ca2eb8bb2e318274022c136ab81", + "diff_blob": "4a0d605902", + "bytes": 1285267, + "utc": "2026-10-15T23:07:34.656Z" + }, + { + "path": "inputs/SOURCE-ORDER.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/SOURCE-ORDER.json", + "sha256": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "git_blob": "7141bd58cc465e28f0189345713ddd366c814ca4", + "diff_blob": "7141bd58cc", + "bytes": 5904, + "utc": "2026-10-15T23:07:33.517Z" + }, + { + "path": "inputs/SOURCE-PROVIDERS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/SOURCE-PROVIDERS.json", + "sha256": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7", + "git_blob": "d49a003505049499afb213c09e1011cb511ebbcc", + "diff_blob": "d49a003505", + "bytes": 1873, + "utc": "2026-10-15T23:07:33.536Z" + }, + { + "path": "inputs/WORD-base.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/WORD-base.json.gz", + "sha256": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "git_blob": "91bd9c68f209ac29e27cac566ff7a78339788553", + "diff_blob": "91bd9c68f2", + "bytes": 72444, + "utc": "2026-10-15T23:07:34.816Z" + }, + { + "path": "inputs/WORD-extra.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/WORD-extra.json.gz", + "sha256": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "git_blob": "6c4a9a4395cfd407b435833908f783db4b3c6a4b", + "diff_blob": "6c4a9a4395", + "bytes": 72443, + "utc": "2026-10-15T23:07:35.281Z" + }, + { + "path": "inputs/WORD2751-base.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/WORD2751-base.json.gz", + "sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "git_blob": "f1fc67a6eaf4bcc5dfa852b448aa2659070fa5f8", + "diff_blob": "f1fc67a6ea", + "bytes": 72468, + "utc": "2026-10-15T23:07:34.854Z" + }, + { + "path": "inputs/WORD2751-extra.json.gz", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/inputs/WORD2751-extra.json.gz", + "sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "git_blob": "f06e80c4dddb9741d0051cb85a57d356e673f687", + "diff_blob": "f06e80c4dd", + "bytes": 72468, + "utc": "2026-10-15T23:07:34.852Z" + }, + { + "path": "joint_engine.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/joint_engine.py", + "sha256": "1411acf2903cad468e3618eefec7032ea04232af740134416d42d74aa1ea4945", + "git_blob": "e76585f43f18c641ac551ed19d3c1be86d112e33", + "diff_blob": "e76585f43f", + "bytes": 7467, + "utc": "2026-10-15T23:07:36.767Z" + }, + { + "path": "LICENSE", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "diff_blob": "261eeb9e9f", + "bytes": 11357, + "utc": "2026-10-15T23:07:27.205Z" + }, + { + "path": "NOTICE", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/NOTICE", + "sha256": "982ccd0ddf67b74a1d9d6dcb2684561a83b2f5de5039b3dfdd98f26cce6b8358", + "git_blob": "4f946d97736bcc10e56fd3648f0035de3eda63f0", + "diff_blob": "4f946d9773", + "bytes": 1192, + "utc": "2026-10-15T23:07:27.213Z" + }, + { + "path": "OVERLAY-PINS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/OVERLAY-PINS.json", + "sha256": "496f1daf28d46a0b7aafe5a8968a2078b7bc9c2fa29089d16092c2f5041813bb", + "git_blob": "4c1a0ca6ee4bb4ea878cb21af85e11b218fe5833", + "diff_blob": "4c1a0ca6ee", + "bytes": 4260, + "utc": "2026-10-15T23:07:27.473Z" + }, + { + "path": "packing_cap.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/packing_cap.py", + "sha256": "b292694b0862db3393ce02e1e07a922ded6f746b18ab8faca69eb93ed7a2e522", + "git_blob": "fe937f866716fafa5b02b19dd0f191b00c1fd4f8", + "diff_blob": "fe937f8667", + "bytes": 3413, + "utc": "2026-10-15T23:07:36.804Z" + }, + { + "path": "PROFILE.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/PROFILE.json", + "sha256": "9d71407ded0b17496b0f94ca896355933a850dc6fc8456e39b0a1f72995b1406", + "git_blob": "c8b3bc89984bb71b5369a5d87bddbd98c055b32d", + "diff_blob": "c8b3bc8998", + "bytes": 116, + "utc": "2026-10-15T23:07:27.490Z" + }, + { + "path": "PROOF.md", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/PROOF.md", + "sha256": "6ecefda5d853e3ede1ee06aab08de24dfde960d98178a71844340ed86ae0d9b9", + "git_blob": "d2b1a96ba8ea6f20e87e12cf2817e0c3ce4c5f30", + "diff_blob": "d2b1a96ba8", + "bytes": 3777, + "utc": "2026-10-15T23:07:27.492Z" + }, + { + "path": "README.md", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/README.md", + "sha256": "8ea1568d186bdf5086aa2efff6c24fe6b34a6d4790393e763a4ddf683541df69", + "git_blob": "0d79a15325d582eb41655c21f3bbe021e5b2d470", + "diff_blob": "0d79a15325", + "bytes": 14109, + "utc": "2026-10-15T23:07:27.455Z" + }, + { + "path": "requirements.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/requirements.txt", + "sha256": "f95b588f39c53b58fa36c3b65b65cc770e3a051a6a12555a9188808e771d1d13", + "git_blob": "816d0c8e917cfe51c9c7f78f70761ec728f94534", + "diff_blob": "816d0c8e91", + "bytes": 55, + "utc": "2026-10-15T23:07:37.121Z" + }, + { + "path": "RETIRED5-CODE.patch", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/RETIRED5-CODE.patch", + "sha256": "c94370f5e40631012709f038762126c88678f45e441a201d9156a56d53524ec8", + "git_blob": "732313f3ca8d9137b2541aa3a035608d1494b51d", + "diff_blob": "732313f3ca", + "bytes": 21178, + "utc": "2026-10-15T23:07:27.680Z" + }, + { + "path": "retired7_controls.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/retired7_controls.py", + "sha256": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904", + "git_blob": "67a9818ac7a31236626d59f0e5c4bb9c74f028d5", + "diff_blob": "67a9818ac7", + "bytes": 5691, + "utc": "2026-10-15T23:07:37.323Z" + }, + { + "path": "RETIRED7-CODE.patch", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/RETIRED7-CODE.patch", + "sha256": "5fe86a963cf0e68ca9a48704910be58d76b48d966c2d6026edbce785796a0fcf", + "git_blob": "4cf31da68bdef7ed23f0b3918f8296bd17000d9e", + "diff_blob": "4cf31da68b", + "bytes": 33341, + "utc": "2026-10-15T23:07:27.635Z" + }, + { + "path": "REUSE-PINS.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/REUSE-PINS.json", + "sha256": "c33bf92fccb63f4d9a3ff6f7e025ac831ad012dd92d236b0f046bc4b1c6a29b2", + "git_blob": "ff0b83bf69653b7c4df308b0fbda39db5061e641", + "diff_blob": "ff0b83bf69", + "bytes": 22675, + "utc": "2026-10-15T23:07:27.647Z" + }, + { + "path": "SOURCE-FILES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/SOURCE-FILES.json", + "sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "git_blob": "7e8a64069e63f405f26ab045eabd3d9bf602e377", + "diff_blob": "7e8a64069e", + "bytes": 61747, + "utc": "2026-10-15T23:07:27.680Z" + }, + { + "path": "SOURCE-NOTICE", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/SOURCE-NOTICE", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "diff_blob": "380e979f0e", + "bytes": 2456, + "utc": "2026-10-15T23:07:27.822Z" + }, + { + "path": "SOURCES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/SOURCES.json", + "sha256": "ede36d6b940094ea7f27e9a8f7ba4d320ca99b97843e9de03ef68c5c93306ed5", + "git_blob": "aa59a560ca79c4e6e05252cd42b763e883ecb9f4", + "diff_blob": "aa59a560ca", + "bytes": 5192, + "utc": "2026-10-15T23:07:27.827Z" + }, + { + "path": "TASK.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/TASK.json", + "sha256": "c725b9fb1acbbff8c4d0a72e63a4e81e7b0fd12926d5ddb37d0fd4a52b3f2e55", + "git_blob": "61c622f03fcd274d0a491f0adcb0cf20c72c07eb", + "diff_blob": "61c622f03f", + "bytes": 6703, + "utc": "2026-10-15T23:07:27.828Z" + }, + { + "path": "test_integrity.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/test_integrity.py", + "sha256": "67f17c8df3614d582ac2c4d272ceba90d47116af4c6989a1a2e2b5f13e7bc2ee", + "git_blob": "eedb99e86ab7815f688f5550f0a426a32cdddfff", + "diff_blob": "eedb99e86a", + "bytes": 1844, + "utc": "2026-10-15T23:07:37.161Z" + }, + { + "path": "vendor/audit_local_pr2679.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/audit_local_pr2679.py", + "sha256": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "git_blob": "8224873d0497cf0b4c202f31b145fa273553d978", + "diff_blob": "8224873d04", + "bytes": 29363, + "utc": "2026-10-15T23:07:37.475Z" + }, + { + "path": "vendor/ceiling.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/ceiling.py", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "diff_blob": "6c0f54527d", + "bytes": 5903, + "utc": "2026-10-15T23:07:37.815Z" + }, + { + "path": "vendor/generate_words.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/generate_words.py", + "sha256": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "git_blob": "94bf0d8f29b9e70a6633a03cb8398d0fec76c60f", + "diff_blob": "94bf0d8f29", + "bytes": 15758, + "utc": "2026-10-15T23:07:38.128Z" + }, + { + "path": "vendor/GENERATOR-NOTICE.txt", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/GENERATOR-NOTICE.txt", + "sha256": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "git_blob": "b075f7180eb541df4bcd2f5df982cd4a6584426b", + "diff_blob": "b075f7180e", + "bytes": 7989, + "utc": "2026-10-15T23:07:37.130Z" + }, + { + "path": "vendor/gf_chart.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/gf_chart.py", + "sha256": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "git_blob": "11f5bfd882669ca30f62b5b4f7677f6bbbc438e2", + "diff_blob": "11f5bfd882", + "bytes": 939, + "utc": "2026-10-15T23:07:37.831Z" + }, + { + "path": "vendor/LICENSE", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "diff_blob": "261eeb9e9f", + "bytes": 11357, + "utc": "2026-10-15T23:07:37.505Z" + }, + { + "path": "vendor/target_transport.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/target_transport.py", + "sha256": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "git_blob": "89ee0168c62df976553af08ea6a5a7e802856a5a", + "diff_blob": "89ee0168c6", + "bytes": 2727, + "utc": "2026-10-15T23:07:37.813Z" + }, + { + "path": "vendor/UPSTREAM-NOTICE", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/UPSTREAM-NOTICE", + "sha256": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "git_blob": "46411b80b277d7dcd653a6d1999eaf12975b1103", + "diff_blob": "46411b80b2", + "bytes": 1439, + "utc": "2026-10-15T23:07:37.665Z" + }, + { + "path": "vendor/UPSTREAM-VENDOR-SOURCES.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/UPSTREAM-VENDOR-SOURCES.json", + "sha256": "592a98f6a3bd7fbd0063d90c989e30c5cd534220797b5b0beb0388e1f8d498ec", + "git_blob": "cd19eda259c09afee6e737096e6d00305c84fd13", + "diff_blob": "cd19eda259", + "bytes": 1227, + "utc": "2026-10-15T23:07:37.473Z" + }, + { + "path": "vendor/word_patch_pr2679.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/vendor/word_patch_pr2679.py", + "sha256": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "git_blob": "492a3ef8314796c82ecedf8bfcda525ff04c45e1", + "diff_blob": "492a3ef831", + "bytes": 3896, + "utc": "2026-10-15T23:07:38.317Z" + }, + { + "path": "verify_retired7.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/verify_retired7.py", + "sha256": "1d3754ccf91029aa239affe0233de4821d960f654514ceeb3445d464933aba0f", + "git_blob": "0f2c1ee50f9307a1ae5fbb5e71eac856cd930e4e", + "diff_blob": "0f2c1ee50f", + "bytes": 16670, + "utc": "2026-10-15T23:07:38.273Z" + }, + { + "path": "VERIFY.json", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/VERIFY.json", + "sha256": "e32cfbc20fcd9e1ed43b920fcdc9eacc8106c1e35f3b3d33303a700582657ac4", + "git_blob": "a4c9fb33d00b42db6accf43938e76d9c19e21c17", + "diff_blob": "a4c9fb33d0", + "bytes": 2019, + "utc": "2026-10-15T23:07:27.835Z" + }, + { + "path": "verify.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/verify.py", + "sha256": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "git_blob": "d8101f1a282fb4d4513a10fc307d7d748a1b588b", + "diff_blob": "d8101f1a28", + "bytes": 6694, + "utc": "2026-10-15T23:07:38.450Z" + }, + { + "path": "workflow/admit.py", + "url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/17b2ee6ef3cf1468e78a6267f0ecbc9a0e6f60dd/research/t74-joint-twelve-retired7/workflow/admit.py", + "sha256": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "git_blob": "282ff24766c57f93e8d49debacb02aead0861cbe", + "diff_blob": "282ff24766", + "bytes": 14803, + "utc": "2026-10-15T23:07:38.269Z" + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/GENERATOR-PINS.json b/research/tensor-block-kappa/vendor/frontier/GENERATOR-PINS.json new file mode 100644 index 0000000000..53cbe5b14d --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/GENERATOR-PINS.json @@ -0,0 +1,12 @@ +{ + "pr2679_manifest": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "vendor": { + "vendor/generate_words.py": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "vendor/gf_chart.py": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "vendor/target_transport.py": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "vendor/UPSTREAM-NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "vendor/GENERATOR-NOTICE.txt": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "vendor/UPSTREAM-VENDOR-SOURCES.json": "592a98f6a3bd7fbd0063d90c989e30c5cd534220797b5b0beb0388e1f8d498ec", + "vendor/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/INPUT-PINS.json b/research/tensor-block-kappa/vendor/frontier/INPUT-PINS.json new file mode 100644 index 0000000000..db68544ada --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/INPUT-PINS.json @@ -0,0 +1,41 @@ +{ + "inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11", + "inputs/FILL.json.gz": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa", + "inputs/POSITIVE2462-base.json.gz": "3506c84203f126900326ff4d22aaceda819734e5f96fa4622d43fbb78b946ece", + "inputs/POSITIVE2462-extra.json.gz": "ec7103c196b32de7af79a6f43952cbe998c085a00f1a8e740f5556c774589099", + "inputs/PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06", + "inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667", + "inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7", + "inputs/WORD-base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "inputs/WORD-extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "evidence/PR2733-CLAIM.json": "8e08f71a18e6a30259c1e2ea19b4069b9d3e3b656b38c57065ec2b9db367282b", + "evidence/PR2745-CLAIM.json": "62b395b95322e0a6786e0193e312d67de6b664c8c79fcfaab5bc7effe775a7c3", + "inputs/WORD2751-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "inputs/WORD2751-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "inputs/PROVIDERS2751.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66", + "inputs/FILL2751.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "inputs/refit5_43base.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "inputs/refit5_43extra.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "inputs/alias5_43base.json": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "inputs/alias5_43extra.json": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "inputs/refit5c_43base.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "inputs/refit5c_43extra.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "evidence/PR2751-CLAIM.json": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438", + "vendor/word_patch_pr2679.py": "9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce", + "evidence/PR2766-CLAIM.json": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8", + "evidence/PR2767-OUTER-CLAIM.json": "252b7bbdbef293f643633ff95ba7d1eabbe83e1eebcd1cb06f51834256bde1f3", + "vendor/audit_local_pr2679.py": "a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90", + "inputs/refit7_43base.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "inputs/refit7_43extra.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "inputs/hostmove2_43base.json": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "inputs/hostmove2_43extra.json": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "inputs/alias7_43base.json": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "inputs/alias7_43extra.json": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "inputs/refit7c_43base.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "inputs/refit7c_43extra.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "retired7_controls.py": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904" +} diff --git a/research/tensor-block-kappa/vendor/frontier/LICENSE b/research/tensor-block-kappa/vendor/frontier/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/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/tensor-block-kappa/vendor/frontier/NOTICE b/research/tensor-block-kappa/vendor/frontier/NOTICE new file mode 100644 index 0000000000..4f946d9773 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/NOTICE @@ -0,0 +1,14 @@ + +research/t74-joint-twelve-retired7 + +Prepared by Marius-Paul Dumitrean with substantial AI assistance (Anthropic Claude, via Claude Code). Apache-2.0. + +This package derives from PR2751 (Tekalign, @tekuuu, Apache-2.0, with substantial OpenAI Codex assistance) and retains its +source notices unchanged in SOURCE-NOTICE. It contains the local retired5 construction (five retired-lender aliases 606<-550, +635<-551, 637<-552, 638<-553, 639<-562 with their exact refits, certified frames and stage inputs; RETIRED5-CODE.patch; +evidence/retired5) and adds the retired7 stages: two hostee moves (the PR2226 borrows of warps 30/31 move from lenders 401/403 +onto 564/565) enabling the retired-lender aliases 667<-401 and 669<-403, with their exact refits, certified frames, stage +inputs, compacted owner fill, checker adaptations (RETIRED7-CODE.patch), retired7_controls.py, verify_retired7.py and +evidence/retired7. Re-used mechanism: PR2679's retired-lender alias 653<-563 (Philippe Van Velzen). Frame refit of PR2751's +words included in the certified frames: PR2766 (DavidAriasC). Vendored byte-identical: vendor/audit_local_pr2679.py and +vendor/word_patch_pr2679.py from the pinned PR2679 package. diff --git a/research/tensor-block-kappa/vendor/frontier/OVERLAY-PINS.json b/research/tensor-block-kappa/vendor/frontier/OVERLAY-PINS.json new file mode 100644 index 0000000000..4c1a0ca6ee --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/OVERLAY-PINS.json @@ -0,0 +1,43 @@ +{ + "original_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "derived_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "archive_sha256": "12335359418a2d75ff62ada3f868497590e025d5b39f6ee01f1a50f23c9768af", + "files": { + "MANIFEST.json": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "audit_mixed.py": "b8a319f580adf417384a13a996ca82ab674fae7917c2ae971aa4025bb2305e78", + "independent_core.py": "a747bf36a4c005398e71300005a5733bb9fa70fcdb0d00f306c894361c1b2a39", + "new/BORROW-PROVIDERS.json": "391075b1411a3976850c633f92f58c35ed3f046f09d55bd435d7545124543fd4", + "new/borrow-fill/FILL.json.gz": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "new/borrow-fill/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "new/borrow/inputs/alias1_43base.json": "20abad50afc6f75b01ba312687ef27c2ef3c41d8afc1429d8c8c8536384cf508", + "new/borrow/inputs/alias1_43extra.json": "df0739086556744574be9c574ae0cca3b1b7c1409d12647829999ffe9d3bed10", + "new/borrow/inputs/alias5_43base.json": "a9ef916e6afcba33345bce3fd0e33606f09f340e0378cf017e2994a9206b969d", + "new/borrow/inputs/alias5_43extra.json": "aeff3d1ffa74e4bffa892293f88a968e2c2b0330ad61128696a6bce7bc383b46", + "new/borrow/inputs/alias7_43base.json": "100558d0f0ffbb2df38668b3d2bc4e4e11d5f328f629f5b4d931b0f619d49700", + "new/borrow/inputs/alias7_43extra.json": "783ed700791b1dcd4bb35422f5fb8114a0c5d82773394b87a613e5f32da51250", + "new/borrow/inputs/alias8_43base.json": "564a2576b3748847cbf5f0e9d22e4d96d159d65f654b5e02e317b05c186775dd", + "new/borrow/inputs/alias8_43extra.json": "9e437b3f6bd36f0e96bf41435a3698ffd42a17fb372492b144097bd59637d53c", + "new/borrow/inputs/hostmove2_43base.json": "ee0f0de1ebe2f84e37e439f783a76f5d210fa1c34b3497a8d3c490296ee88e3b", + "new/borrow/inputs/hostmove2_43extra.json": "d06b7a56b457c16ea138e8265fc6f2d1b32711f0515a76137e86325a6f77a024", + "new/borrow/inputs/lowfour_43base.json": "9f80e059f3b68eaf2682b162110a75091df98e73eb8d70fb442e5c6fad3363e7", + "new/borrow/inputs/lowfour_43extra.json": "9a726ea6bfd3c7d1452377e4be70ab986195ee184f82eb754906def0d08606fc", + "new/borrow/inputs/prelife_43base.json": "77a9a5e0fdfefe861171e46d370d0797356d99e1302d0b2c676d7a619804216d", + "new/borrow/inputs/prelife_43extra.json": "4b2a805cb82d0c8036d7217979ffe1ff984d29b399066585c6b2502597a386f9", + "new/borrow/inputs/refit563_43base.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/inputs/refit563_43extra.json": "2f4a008bae24f8112dcb8a2fe27bb3fdecbe9478675f19ffc5b662153c606061", + "new/borrow/inputs/refit5_43base.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "new/borrow/inputs/refit5_43extra.json": "ff434b1820339f0f7c2c8ba7982edc4c236e522ea30aaa56890206c0fa96f642", + "new/borrow/inputs/refit5c_43base.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "new/borrow/inputs/refit5c_43extra.json": "cd8e6b7f8b8dacf21875f465e3df05bf827f12dd063fe1be7557c7281bff16f1", + "new/borrow/inputs/refit7_43base.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "new/borrow/inputs/refit7_43extra.json": "c1ca4637c3b88828d2628c87a20f93088769dbceb9f487cb75ce90ec1a0ff5f7", + "new/borrow/inputs/refit7c_43base.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "new/borrow/inputs/refit7c_43extra.json": "086dc27f17448ab9bddb2e890752cf13d5965a63cd79fcf25aa7f1c9402503df", + "new/borrow/lowfour_controls.py": "157d05da7842ba3939290e874cc9f784f351cbfc897275aa1f19a500532ce89d", + "new/borrow/retired7_controls.py": "21ebe527aa62be198b231190d404b84cc89961575caa27756cbd24dfe1db0904", + "new/borrow/words/BORROW-WORD-43base.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "new/code/borrow/bw_audit_local.py": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "new/rebuild_borrow.py": "ab499d468d49b115af3c1e08b891e43d273e7d4cbd359e0b22d532c5ed253124" + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/PROFILE.json b/research/tensor-block-kappa/vendor/frontier/PROFILE.json new file mode 100644 index 0000000000..c8b3bc8998 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/PROFILE.json @@ -0,0 +1,10 @@ +{ + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 +} diff --git a/research/tensor-block-kappa/vendor/frontier/PROOF.md b/research/tensor-block-kappa/vendor/frontier/PROOF.md new file mode 100644 index 0000000000..d2b1a96ba8 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/PROOF.md @@ -0,0 +1,25 @@ +# Changed recovery contract and complete moment + +The exact object is the two finite T74 words reconstructed by `generate.py`. The experiment uses a single explicit assignment, not a search over all assignments. Starting before PR2462's lowfour transformation is essential: applying the old lowfour patch first is a positive control reproducing its complete original words. + +The new `(removed helper, recovered source, partner)` assignments are: + +``` +(696,33,49), (697,55,101), (698,74,83), (700,85,98), +(680,49,33), (681,83,74), (682,98,85), (684,101,55), +(688,68,4), (689,80,88), (690,88,80), (692,31,12). +``` + +The last eight are PR2696's assignment. For each of the pairs33/49,55/101,74/83,85/98, let `(x,y)` denote the values after their last original uses, in their shared frame. The two added gates are `x += y/2` followed by `y -= x`, hence the linear map is `(x+y/2, y/2-x)`. For the actual predecessor state these restore the two original source values. The proof of that word-specific premise is the full arbitrary-input exact symbolic replay, not a claim that this map is the identity on arbitrary `(x,y)`. + +These restorations precede the new alias handoffs. Original operator IDs remain stable; twelve new chart transformations are appended. Removed-helper echoes are deleted only where they are target additions. For each new source, the generator computes the complete symbolic residual, transports its negative through precondition/compensation, and emits explicit initial correction gates and inverse source warps. Every residual must consist of a single new operator applied to its recovered source. Independent forward/dual propagation checks the resulting arbitrary-input identity, including dirty registers, and separately checks inverse cleanup. + +All lifted targets have frame `[45]`; their offsets are14,21,37,41,43,47,52,78,99,104,106,110. None is a target read by any cut gate. Actual frame propagation therefore leaves all eight centre children rank8. This changes the old-four recovery/target paths fixed in PR2720; its obstruction is respected within its stated domain. + +Apply the six PR2679 pre-life substitutions to the actual resulting state, refit the unique `515 += 563` gate (now B904), then alias653 into563. The complete generator checks semantic equality of both resulting words. The source-bound original checks and negative controls are rerun. No helper saving is inferred solely from nominal register labels. + +The complete local profile is `{1:2366,2:646,3:297,4:120,5:26,8:8}`. Compared with the PR2733 composition it changes by `4*(H8-H7-H1)` per local word. The same415-helper inventory admits the explicit complete allocation; `independent_owners.py` checks276390 roles, strict temporal windows, every physical cell, family masks and all remainders. There are666 call equivalents, giving global delta `2664*(H8-H7-H1)` and rank mass4816512 unchanged. + +At exponent `0 alias5 -> refit5c`. +2. **New here: two hostee moves that free two more lenders.** + - The hostees of B-warps 30 and 31 currently live on the lenders 401 and 403. Those lenders' own lives end in A, before + helpers 667 and 669 enter at B259 and B262. + - Each hostee moves onto a free retired lender: 401 -> 564 and 403 -> 565. Lenders 564 and 565 last act at B911 and B912, + before the hostees enter at B941 and B944. Each moved warp record is replaced in place, so op ids 30 and 31 are kept. + - This frees 401 and 403 for two more retired-lender aliases of PR2679's kind: **667<-401 and 669<-403**. + +**What makes the moves feasible.** An exact frame refit: the last gates of 564 and 565 are lowered from rank 6 to rank 5, which is +their exact propagated frame floor. The moved hostees enter at rank 5 already, so no follower raise is needed. The new aliases are +fixed-frame: lender frame dim 4 = follower entrance dim 4. The certified optimal frames of the final program also lower B1170/B1171, +the next gates of 504/505, from rank 6 to rank 5. + +**Exact claim.** The exact rational κ is `C - 10^-46 - 10^-70`, with `C = 0.001717794984118634663827` (in `CLAIM.json`). Larger κ is +better in `O(n (log n)^(1-κ))`. No selected frontier is edited, and PR2751's own directory is unchanged. + +| compared with | its exact κ (pinned in `evidence/`) | margin of this package | +|---|---|---| +| PR2751 (tekuuu) | `0.001717141586348426338109 - 10^-46 - 10^-70` | `+6.53397770208325718E-7` (exact `326698885104162859/500000000000000000000000`) | +| PR2766 (DavidAriasC) | `0.001717256973467002308270 - 10^-46 - 10^-70` | `+5.38010651632355557E-7` (exact `538010651632355557/1000000000000000000000000`) | +| PR2767 (jeremykothe2) | `0.0017172569734670023082709447…` (3000-digit outer claim) | `+5.38010651632355556055E-7` | +| retired5 (local, unpublished) | `0.001717409316335491643448 - 10^-46 - 10^-70` | `+3.85667783143E-7` | + +**What is new here, and what is credited.** +- The certified frames include PR2766's frame refit of PR2751's words, unchanged: B1151 rank 6 -> 5, plus A0-A11, B771-788 and + restore 60. PR2767 reaches the same κ by another route. +- The five retired-lender aliases are the retired5 construction, worth `+1.52342868489E-7` over PR2766/PR2767. +- The **new contribution of this package is the two hostee moves and the two aliases they enable**, worth `+3.85667783143E-7` over + retired5. + +## Reproduce + +From the repository root, with Python 3.12 and no third-party dependencies, run the registered hook. It completes in about two +minutes and is limited to 17 minutes: + +```sh +python3.12 -B scripts/research_package.py --package research/t74-joint-twelve-retired7 +``` + +It runs four commands: +- `verify.py`: PR2751's literal review, adapted below. It prints `PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY` and checks 271728 owner roles. +- `verify_retired7.py`: the seven-stage rebuild, the pinned PR2679 auditor on all eight states, 142 tamper controls, the literal owner + fill, the 80-digit root, and κ against PR2751, PR2766 and PR2767. +- `packing_cap.py`: the generic packing ceiling. +- `test_integrity.py`: relocation and fail-closed controls. + +Full cold release: install `requirements.txt`, then use a fresh directory outside the repository: + +```sh +python3 -B research/t74-joint-twelve-retired7/full_replay.py --source /path/to/pr2679/research/gmx-t74-borrow43-handoff --work /tmp/FRESH-retired7 +``` + +Without `--source`, the 491 pinned PR2679 files are downloaded and authenticated, exactly as in PR2751. The run then: +- applies this package's 36-file overlay: PR2751's 21 files, retired5's six stage inputs, the eight retired7 stage inputs and + `new/borrow/retired7_controls.py`; +- builds four fresh native providers and the retained-parent admission; +- runs the complete admission: owner reconstruction, parent lift, rebind, discovery/unpin/freeze at PR2751's 24-digit endpoint + precision, the outer ledger and the package's own `verify_release.py` (strict T74 replay and all controls). + +Expected result: `PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE 0.0017177949841186346638269999999999999999999998999999999999999999999999` (recorded cold run of the committed package: 411 s; see `evidence/retired7/FULL-REPLAY-RESULT.json`). +`--prepared-native-cache` is not supported: `REUSE-PINS.json` is PR2751's and describes PR2751's cache. + +To regenerate all four words (PR2751's two, then this package's two through the declared stages) from source: + +```sh +python3 -B research/t74-joint-twelve-retired7/generate.py --source /path/to/pr2679/research/gmx-t74-borrow43-handoff --out /tmp/FRESH-retired7-words +``` + +Expected: `PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS`. + +## Construction and cost + +**Census** (on the retired5 words, with PR2679's exact frame lattice `new/borrow/refit/search` and the `pairs.py` rule): +- 52 followers remain. 48 enter at rank 1 (width 8) and 4 at rank 4 with ceiling 5 (width 5): 667, 669, 670 and 671. There are 404 + lenders, and no direct pair or chain is feasible. +- Every rank-1 follower stays infeasible, because every lender's exact floor is at least rank 4. +- Every existing B-warp hosting is treated as movable. 24 hosted lenders (warps 1-4 and 22-41) end their own lives before B259, with + floor rank 4, and could take a rank-4 follower if their hostee moves to a free lender. Only two free lenders have floor <= 5 and + retire before the hostees enter: 564 and 565. +- That gives 192 augmenting paths and at most **two** extra aliases. +- Warps 30 and 31 are chosen because their hostees already enter at rank 5. Moves of warps 1-4 or 22-29 need a 16-gate raise closure + and price lower. + +**Stages.** These are new stages of `new/rebuild_borrow.py` inside the overlay, run after retired5's `refit5c`: +- `refit7_43*.json`: two frames per word. The last gates of 564/565 (B911/B912) go from dim 6 to 5, recorded with their previous frames. +- `hostmove2_43*.json`: two warp records replaced in place (op 30: 401 -> 564 at B941; op 31: 403 -> 565 at B944; dim 5, explicit + invertible `G`, `G(U)=E`), and 28 declared gate edits, which relabel the 14 hostee gates. Nothing else changes. +- `alias7_43*.json`: `alias_build.alias` 667<-401 and 669<-403, with dim 4 warps appended, 28 declared gate edits, and both helpers removed. +- `refit7c_43*.json`: the certified optimal frames of the final program, two frames (B1170/B1171, dim 6 -> 5), computed with the + #1186 exact frame toolkit (`optimal_frames`, borrow-word model, certified). + +Every one of the eight states passes the auditor. + +**Inventory and profile.** +- 408 helpers {4:26, 5:2, 7:62, 8:78, 9:240}, 72 private buffers, 666 calls and 271728 hosted roles. +- live 66304; physical 66794 = 66304+408+8+72+2. +- Local profile `{1:2382,2:648,3:268,4:128,5:26,8:8}` on both words, against `{1:2386,2:642,3:274,4:128,5:26,8:8}` for retired5. + +**Owner fill.** It is PR2751's fill with the seven removed helpers' roles dropped, renumbered and re-tiled as bin prefixes (`verify.py` +`compact`). The 1332 cells freed beyond retired5 become idle 5-remainders. +- Complete profile `{1:1603728,2:431568,3:185082,4:85248,5:27194,8:5328,32:1,48:26558}`; rank mass 4816512; idle `{1:17316,3:6594,5:9878,32:1,48:26558}`. +- The pattern relaxation of the owner fill (8/16/32/48 bins, the r8 model) has the same optimum as this realized compaction. +- The exact moment root lies strictly between `0.001717794984118634663827` and `0.001717794984118634663828`. +- The 80-digit root is `0.00171779498411863466382722991842817890408858438546231220090092725676198114516931`. + +**Packing ceiling.** The generic coverage-law ceiling (`packing_cap.py`, the pinned `ceiling.ceiling()`) is about `0.00175808593463`, +with realized fraction `0.9770824908`. It is a packing cap, not a sharp optimum. + +## Checker adaptations (diffs in `RETIRED7-CODE.patch`; the retired5 adaptations are in `RETIRED5-CODE.patch`) + +1. **`verify.py`.** The candidate profile and endpoint are re-pinned. The declared stage chain gains `refit7 -> hostmove2 -> alias7 -> refit7c`. + The compaction now removes seven helpers: the five retired5 ones plus 667 and 669. +2. **`verify_retired7.py`** (replaces `verify_retired5.py`). It adds the retired7 stage-structure checks and audits all eight states. + It also runs `retired7_controls.py`, 25 controls per word, on top of retired5's 46 per word. The owner fill size is R 408. +3. **`retired7_controls.py`** (new; also in the overlay as `new/borrow/retired7_controls.py`, called by `rebuild_borrow.py`). Every + mutant has its inverse-reverse cleanup re-derived, and a rejection for a stale-cleanup reason counts as a failure. The controls are: + - each lender refit undone, which must be rejected by `warp frame mismatch`; + - per move: warp lender reverted, move undone, warp before the new lender retires, and `G` wrong; + - PR2679's alias suite on each new alias: borrowed read sign flipped, read doubled, write sign flipped, warp dropped, `G` wrong, + warp after the follower's first gate, and helper kept with an entrance frame. "Warp after the first gate" replaces "warp before + lender retirement", because these lenders retire in A, which leaves no B position before retirement; + - one certified frame corrupted. +4. **`workflow/admit.py`.** + - The derived-source pin is `9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451`, with 506 files instead of 497. + - The physical stock is 66794 instead of 66796 (R 408). +5. **`new/rebuild_borrow.py`** (overlay). It has the four stages with exact structure checks, and the retired7 controls call. + +`generate.py`, `packing_cap.py` and `test_integrity.py` change only the stage list, the expected candidate values and the markers. +`independent_owners.py` is unchanged from retired5: it reads `R` from the providers. + +## Verification and controls + +**Full cold release.** `evidence/retired7/FULL-REPLAY-*.json`. +- All four native providers are fresh, with five stages each. +- The retained-parent admission passed. +- The complete admission passed: owners, parent lift, rebind, discovery, outer ledger and independent derivation. +- The package's own `verify_release.py` returned `PASS_RELEASE`. Its `rebuild-borrow-words` stage includes the retired5 and + retired7 stage checks and controls. + +**Registered hook.** It repeats the seven-stage rebuild with the vendored, byte-identical PR2679 auditor and all 142 tamper controls, +plus the literal owner fill and the exact arithmetic. + +**Precision.** The endpoint is certified at `10^-24`: accept at `C`, reject at `C+10^-24`, with exact rationals. That is 16 orders of +magnitude below the `3.86e-7` margin over retired5. κ = `C - 10^-46 - 10^-70` exactly. + +## Scope and inherited obligations + +Finite exact admission is conditional evidence, not a formal proof of the complete multiplication theorem. The following remain +inherited from PR2751 and its lineage unchanged: +- all-size compiler and machine realization; +- common labels and source access; +- physical hosting and routing; +- precision and fixed-tape contracts; +- exact recovery and analytic transfer; +- recurrence; +- the bit-supplier and modern outer obligations. + +No new discharge of those universal obligations is claimed. The selected accepted result and this pending derivative are distinct. +The census searched retired-lender aliases, with every existing B-warp hosting movable onto a free retired lender. No optimality is +claimed over other mechanisms. + +## Credits + +- **Tekalign (@tekuuu), PR2751:** the joint twelve-source construction, words, fill transform, independent checkers and full replay (the parent). +- **Cinna Davis (1337isnot1337), PR2226:** anticipatory dirty borrowing. Warps 30/31 are its borrows: helpers 603 and 605 borrow + from lenders 401 and 403, as adapted to the T74 words. +- **Philippe Van Velzen (philippeVV), PR2679 (and PR2559):** the six pre-life hostings, the one-gate frame refit and the retired-lender + alias 653<-563, which is the mechanism re-used for all seven aliases; also the exact refit/search frame tools and the alias builder. +- **Jeremy Kothe (jeremykothe2), PR2673/PR2745:** + - the priority call order and window-optimal owner fill; + - the composition of PR2696 with PR2679; + - the gmx-t74-borrow43 package machinery, entrance raises and BORROW-WORD lineage (PR2588, PR2575, PR2526, PR2474, PR2462, PR2447, + PR2435), including the T74 adaptation of PR2226's borrows and the base-word lenders 564/565. +- **Mason Hale, PR2696:** the eight-lender assignment. +- **DavidAriasC, PR2766:** the frame refit of PR2751's words, which is included in the certified frames. +- **Vlado Vojdanovski (Vlado-V), PR2322:** the coherent handoff. +- **Our PR1625:** the pivot-kernel shape. **Our PR1186:** the exact frame toolkit. **Our retired5 package:** the five aliases. + +All notices and the lineage these packages retain are kept: see `SOURCE-NOTICE`, PR2751's `README.md` and `PROOF.md`. + +## Open next questions + +1. **Gate-level edits.** Can a gate-level (kernel) edit make the 48 rank-1-entrance followers alias-feasible? Every lender's exact floor is at least rank 4. +2. **Followers 670 and 671.** Both still lack a lender: the only free floor-5 lenders (564/565) are used by the moves. A third free + lender would need a frame floor of at most 5 and retirement before B941. +3. **Stacking with PR2767.** Do these stages stack with PR2767's post-cut partner correction, or with other post-PR2751 constructions? + +Prepared by Marius-Paul Dumitrean with substantial AI assistance (Anthropic Claude, via Claude Code). Apache-2.0. diff --git a/research/tensor-block-kappa/vendor/frontier/RETIRED5-CODE.patch b/research/tensor-block-kappa/vendor/frontier/RETIRED5-CODE.patch new file mode 100644 index 0000000000..732313f3ca --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/RETIRED5-CODE.patch @@ -0,0 +1,260 @@ +--- research/t74-joint-twelve/verify.py ++++ research/t74-joint-twelve-retired5/verify.py +@@ -15,6 +15,30 @@ + import exact_moment as M + HERE=Path(__file__).resolve().parent +-PROFILE={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +-LOW=F('0.001717141586348426338109') ++PROFILE={1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} ++LOW=F('0.001717409316335491643448') ++PROFILE2751={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} ++LOW2751=F('0.001717141586348426338109') ++ALIASES=[(606,550),(635,551),(637,552),(638,553),(639,562)] # retired5 ++import importlib.util as _iu ++_s=_iu.spec_from_file_location('word_patch_pr2679',Path(__file__).resolve().parent/'vendor/word_patch_pr2679.py');WP=_iu.module_from_spec(_s);_s.loader.exec_module(WP) ++def refit_apply(w0,p): ++ w=copy.deepcopy(w0) ++ for sec,i,fr in p['frames']: ++ need(w[sec][i][:-1]==w0[sec][i][:-1],'refit changes a gate');w[sec][i][-1]=fr ++ w['report']['local_profile']=p['local_profile'];return w ++def compact(fill,old_words,new_words,old_prov,new_prov,order,dispatch): ++ live=lambda w:[r for r in range(224,704) if r not in set(w['removed'])] ++ L0=live(old_words['gauge44']);L1=live(new_words['gauge44']);need(L0==live(old_words['extra']) and L1==live(new_words['extra']),'live helper sets') ++ gone=set(L0)-set(L1);need(set(L1)<=set(L0) and sorted(gone)==sorted(h for h,_ in ALIASES),'removed helpers') ++ i1={r:i for i,r in enumerate(L1)};bins={} ++ for pid in ('gauge44','extra'):need([old_prov[pid]['widths'][L0.index(r)] for r in L1]==new_prov[pid]['widths'],'renumbered widths') ++ for t,h,o,c,p,off in fill['rows']: ++ if L0[h] in gone:continue ++ bins.setdefault((o,c,p),[]).append([t,i1[L0[h]],o,c,p,off]) ++ rows=[] ++ for key,rs in bins.items(): ++ rs.sort(key=lambda x:x[5]);pos=0 ++ for x in rs:x[5]=pos;pos+=new_prov[dispatch[tuple(order[x[0]])]]['widths'][x[1]];rows.append(x) ++ rows.sort(key=lambda x:(x[0],x[1]));return dict(fill,rows=rows) + def need(ok,msg): + if not ok:raise ValueError(msg) +@@ -29,6 +53,6 @@ + need(F(claim['complex_lower'])==LOW and F(claim['complex_upper'])==LOW+F(1,10**24),'claim bracket') + need(F(claim['kappa'])==LOW-F(1,10**46)-F(1,10**70),'claim outer endpoint') +- for name in ('PR2733','PR2745'): +- previous=json.loads((HERE/'evidence'/f'{name}-CLAIM.json').read_text()) ++ for name in ('PR2733','PR2745','PR2751','PR2766','PR2767'): ++ previous=json.loads((HERE/'evidence'/(f'{name}-OUTER-CLAIM.json' if name=='PR2767' else f'{name}-CLAIM.json')).read_text()) + need(F(claim['kappa'])>F(previous['kappa']),'strict improvement over '+name) + words={} +@@ -49,6 +73,16 @@ + dispatch={(s,r):p for s,r,p in rd('DISPATCH.json.gz')} + need(order==rd('SOURCE-ORDER.json'),'source order') +- constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),providers,rd('SOURCE-FILL.json.gz'),order,dispatch,words) +- need(constructed==fill,'complete deterministic fill') ++ # retired5: PR2751's own construction (its words, providers and fill) is reproduced first ... ++ words51={'gauge44':rd('WORD2751-base.json.gz'),'extra':rd('WORD2751-extra.json.gz')};prov51=rd('PROVIDERS2751.json');fill51=rd('FILL2751.json.gz') ++ constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),prov51,rd('SOURCE-FILL.json.gz'),order,dispatch,words51) ++ need(constructed==fill51,'complete deterministic PR2751 fill') ++ # ... then the declared stages turn its words into the candidate words exactly ... ++ for tag,pid in [('base','gauge44'),('extra','extra')]: ++ w=refit_apply(words51[pid],rd('refit5_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias5_43'+tag+'.json'));w=refit_apply(w,rd('refit5c_43'+tag+'.json')) ++ need(w==words[pid],'declared stages reproduce the candidate word '+tag) ++ d2=dict(dispatch) ++ for s,r,p in fill['dispatch_overrides']:d2[s,r]=p ++ # ... and the candidate fill is PR2751's fill with the five removed helpers' roles dropped, renumbered and re-tiled as bin prefixes ++ need(compact(fill51,words51,words,prov51,providers,order,d2)==fill,'complete deterministic candidate fill') + owner=I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,fill,providers,dispatch,PROFILE) + bad=copy.deepcopy(fill);bad['rows'][0][5]=999 +@@ -57,6 +91,5 @@ + else:raise ValueError('accepted out-of-bin placement') + _,a=M.moment_bounds(PROFILE,LOW);b,_=M.moment_bounds(PROFILE,LOW+F(1,10**24));need(a<6630466304,'PR2733 rejects candidate endpoint') +- return {'status':'PASS_JOINT_TWELVE_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} ++ x,_=M.moment_bounds(PROFILE2751,LOW);need(x>66304,'PR2751 rejects candidate endpoint') ++ return {'status':'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} + if __name__=='__main__':print(json.dumps(run(),indent=2)) +--- research/t74-joint-twelve/independent_owners.py ++++ research/t74-joint-twelve-retired5/independent_owners.py +@@ -67,11 +67,12 @@ + need(set(dispatch)==set(map(tuple,order)),'dispatch coverage') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns') +- need(len(fill['rows'])==666*415,'role count') +- need(all(len(p['widths'])==415 for p in providers.values()),'helper widths') ++ R=len(next(iter(providers.values()))['widths']) # retired5: helper count from the providers (was 415) ++ need(len(fill['rows'])==666*R,'role count') ++ need(all(len(p['widths'])==R for p in providers.values()),'helper widths') + helper_bits=[0]*666;family_bits=[0]*666;occupied={} + for row in fill['rows']: + need(len(row)==6 and all(type(v) is int for v in row),'role shape') + t,h,o,c,port,offset=row +- need(0<=t<666 and 0<=h<415 and 0<=port<112,'role bounds') ++ need(0<=t<666 and 0<=h previous, ++ need(kappa == C-Q(1,10**70)-Q(1,10**46) and kappa > previous and kappa > Q('17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000'), # retired5: also strictly above PR2751 + 'candidate must strictly improve pinned COMPOSED before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') +--- research/t74-joint-twelve/generate.py ++++ research/t74-joint-twelve-retired5/generate.py +@@ -45,5 +45,15 @@ + w,_=AB.alias(w,653,563);lp,wi=AB.profile(w);w['report'].update(local_profile=lp,width_inventory=wi) + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') +- need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated word equality') +- print('PASS_REGENERATED_JOINT_TWELVE_BOTH_WORDS') ++ need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') ++ # retired5: the declared stages refit5 -> alias5 -> refit5c turn the regenerated PR2751 word into the candidate word ++ for st in ('refit5','alias5','refit5c'): ++ p_=rd(HERE/f'inputs/{st}_43{tag}.json') ++ if st=='alias5':w=W.apply_lowfour(w,p_) ++ else: ++ w=copy.deepcopy(w) ++ for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st=='refit5c','refit gate');w[sec][i][-1]=frame ++ w['report']['local_profile']=p_['local_profile'] ++ f=out/f'WORD-retired5-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired5-{tag}.json') ++ need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') ++ print('PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS') + if __name__=='__main__':main() +--- research/t74-joint-twelve/packing_cap.py ++++ research/t74-joint-twelve-retired5/packing_cap.py +@@ -11,7 +11,7 @@ + sys.dont_write_bytecode = True + ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +-IDLE = {1:17316,3:6594,5:5216,32:1,48:26558} +-CANDIDATE = {1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +-ENDPOINT = Q('0.001717141586348426338109') ++IDLE = {1:17316,3:6594,5:8546,32:1,48:26558} ++CANDIDATE = {1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} ++ENDPOINT = Q('0.001717409316335491643448') + + def need(ok, message): +@@ -28,7 +28,7 @@ + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} +- need(local == {1:2366,2:646,3:297,4:120,5:26,8:8}, 'complete local profile') ++ need(local == {1:2386,2:642,3:274,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) +- need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5223, 'coverage identity') ++ need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5198, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') +--- research/t74-joint-twelve/test_integrity.py ++++ research/t74-joint-twelve-retired5/test_integrity.py +@@ -10,9 +10,9 @@ + def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + def main(): +- with tempfile.TemporaryDirectory(prefix='joint-twelve-controls-') as t: ++ with tempfile.TemporaryDirectory(prefix='joint-twelve-retired5-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) +- r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') ++ r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') +--- PR2751 overlay: new/rebuild_borrow.py ++++ retired5 overlay: new/rebuild_borrow.py +@@ -1,3 +1,3 @@ +-"""rebuild_borrow.py: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), ++"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls]: 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)""" +@@ -121,4 +121,35 @@ + (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') ++ A5=[(606,550),(635,551),(637,552),(638,553),(639,562)];H5=[h_ for h_,_ in A5];L5=[L_ for _,L_ in A5] ++ def regs_(e_):return e_[1:3] if e_[0]=='add' else e_[1:2] ++ def frames_only(x,y): # same gate lists in A/B/restore, every other field equal (report aside); returns the changed (section,index) set ++ assert all(len(x[k_])==len(y[k_]) and all(a_[:-1]==b_[:-1] for a_,b_ in zip(x[k_],y[k_])) for k_ in ('A','B','restore')) ++ assert all(x[k_]==y[k_] for k_ in x if k_ not in ('A','B','restore','report')) and set(x)==set(y) ++ return {(k_,i_) for k_ in ('A','B','restore') for i_,(a_,b_) in enumerate(zip(x[k_],y[k_])) if a_!=b_} ++ r5f=D/'inputs'/f'refit5_43{wt}.json';r5patch=None ++ if r5f.exists(): # retired5: exact minimal-change refit for five retired-lender aliases (refit/search: lenders' last gates to their exact floors, followers' first gates to their exact ceilings) ++ r5patch=json.loads(r5f.read_text());prev_r5=chain[-1];chain.append(refit_apply(prev_r5,r5patch));steps.append('refit5');nr5=chain[-1] ++ try:ch5=frames_only(prev_r5,nr5);kok&=ch5=={(s_,i_) for s_,i_,_ in r5patch['frames']} ++ except AssertionError:kok=False ++ lastL={L_:max(p_ for p_,e_ in enumerate(prev_r5['B']) if L_ in regs_(e_)) for L_ in L5};firstH={h_:min(p_ for p_,e_ in enumerate(prev_r5['B']) if h_ in regs_(e_)) for h_ in H5} ++ kok&=all(lastL[L_]66304,'PR2751 rejects candidate endpoint') +- return {'status':'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} ++ return {'status':'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} + if __name__=='__main__':print(json.dumps(run(),indent=2)) +diff --git a/packing_cap.py b/packing_cap.py +index 435b62e..fe937f8 100644 +--- a/packing_cap.py ++++ b/packing_cap.py +@@ -11,7 +11,7 @@ HERE = Path(__file__).resolve().parent + sys.dont_write_bytecode = True + ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +-IDLE = {1:17316,3:6594,5:8546,32:1,48:26558} +-CANDIDATE = {1: 1606392, 2: 427572, 3: 189078, 4: 85248, 5: 25862, 8: 5328, 32: 1, 48: 26558} +-ENDPOINT = Q('0.001717409316335491643448') ++IDLE = {1:17316,3:6594,5:9878,32:1,48:26558} ++CANDIDATE = {1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} ++ENDPOINT = Q('0.001717794984118634663827') + + def need(ok, message): +@@ -28,7 +28,7 @@ def calculate(profile_path=None): + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} +- need(local == {1:2386,2:642,3:274,4:128,5:26,8:8}, 'complete local profile') ++ need(local == {1:2382,2:648,3:268,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) +- need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5198, 'coverage identity') ++ need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5188, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') +diff --git a/generate.py b/generate.py +index 7c6f2dc..dafca20 100644 +--- a/generate.py ++++ b/generate.py +@@ -46,14 +46,14 @@ def main(): + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') +- # retired5: the declared stages refit5 -> alias5 -> refit5c turn the regenerated PR2751 word into the candidate word +- for st in ('refit5','alias5','refit5c'): ++ # retired5 + retired7: the declared stages refit5 -> alias5 -> refit5c -> refit7 -> hostmove2 -> alias7 -> refit7c turn the regenerated PR2751 word into the candidate word ++ for st in ('refit5','alias5','refit5c','refit7','hostmove2','alias7','refit7c'): + p_=rd(HERE/f'inputs/{st}_43{tag}.json') +- if st=='alias5':w=W.apply_lowfour(w,p_) ++ if st in ('alias5','hostmove2','alias7'):w=W.apply_lowfour(w,p_) + else: + w=copy.deepcopy(w) +- for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st=='refit5c','refit gate');w[sec][i][-1]=frame ++ for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st in ('refit5c','refit7','refit7c'),'refit gate');w[sec][i][-1]=frame + w['report']['local_profile']=p_['local_profile'] +- f=out/f'WORD-retired5-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired5-{tag}.json') ++ f=out/f'WORD-retired7-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired7-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') +- print('PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS') ++ print('PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS') + if __name__=='__main__':main() +diff --git a/test_integrity.py b/test_integrity.py +index 85d1f86..eedb99e 100644 +--- a/test_integrity.py ++++ b/test_integrity.py +@@ -10,9 +10,9 @@ def need(ok,msg): + def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} + def main(): +- with tempfile.TemporaryDirectory(prefix='joint-twelve-retired5-controls-') as t: ++ with tempfile.TemporaryDirectory(prefix='joint-twelve-retired7-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) +- r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_PLUS_FIVE_ALIASES_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') ++ r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') +diff --git a/workflow/admit.py b/workflow/admit.py +index 37dc6e3..282ff24 100644 +--- a/workflow/admit.py ++++ b/workflow/admit.py +@@ -23,5 +23,5 @@ import time + + SOURCE_COMMIT = 'local-joint12-pr2733' +-SOURCE_MANIFEST = '0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3' # retired5 derived source: PR2751 overlay + five retired-lender aliases ++SOURCE_MANIFEST = '9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' # retired7 derived source: PR2751 overlay + five retired-lender aliases + two hostee moves and two aliases + PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' + PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +@@ -70,5 +70,5 @@ def main(): + need(sha(source / 'MANIFEST.json') == SOURCE_MANIFEST, 'COMPOSED manifest pin') + source_files = read(source / 'MANIFEST.json') +- need(len(source_files) == 497 and tree(source, ('MANIFEST.json',)) == source_files, ++ need(len(source_files) == 506 and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + native_receipt = read(a.native_receipt) +@@ -170,5 +170,5 @@ def main(): + natives['extra'] / 'local', work / 'rebound') + spec = read(work / 'rebound/SPEC.json') +- need(spec['expected']['physical'] == 66796, 'complete physical cost including 72 buffers (R 410)') ++ need(spec['expected']['physical'] == 66794, 'complete physical cost including 72 buffers (R 408)') + layout = work / 'layout' + layout.mkdir() +diff --git a/verify_retired5.py b/verify_retired7.py +index 720b3e1..0f2c1ee 100644 +--- a/verify_retired5.py ++++ b/verify_retired7.py +@@ -2,8 +2,10 @@ + # SPDX-License-Identifier: Apache-2.0 + # Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +-"""Bounded replay of the five retired-lender aliases on PR2751's words (read-only, standard library only). ++# retired7 extension of verify_retired5.py (same author). ++"""Bounded replay of retired7 on PR2751's words: the five retired-lender aliases (retired5 stages) plus two hostee moves that free ++two more retired lenders (retired7 stages refit7 -> hostmove2 -> alias7 -> refit7c). Read-only, standard library only. + +-1. Rebuilds both candidate words from PR2751's words through the three declared stages (refit5, alias5, refit5c) and checks +- each stage's declared structure exactly. ++1. Rebuilds both candidate words from PR2751's words through the seven declared stages (refit5, alias5, refit5c, refit7, hostmove2, ++ alias7, refit7c) and checks each stage's declared structure exactly. + 2. Runs the pinned PR2679 BORROW-WORD auditor (vendor/audit_local_pr2679.py, byte-identical) on every state. + 3. Tamper controls, each rejected by that auditor for a real reason: every lender refit undone (warp frame mismatch), every +@@ -21,4 +23,6 @@ sys.dont_write_bytecode = True + sys.path.insert(0, str(HERE)) + ALIASES = [(606, 550), (635, 551), (637, 552), (638, 553), (639, 562)] ++MOVES = [(30, 401, 564, 911), (31, 403, 565, 912)] # retired7: (warp op, old lender, new lender, new lender's last B gate) ++NEW7 = [(667, 401), (669, 403)] + H5 = [h for h, _ in ALIASES]; L5 = [L for _, L in ALIASES] + def need(ok, msg): +@@ -45,5 +49,5 @@ def main(): + need(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == digest, 'vendored source pin ' + name) + AU = load('audit_local_pr2679', HERE / 'vendor/audit_local_pr2679.py'); WP = load('word_patch_pr2679', HERE / 'vendor/word_patch_pr2679.py') +- import independent_owners as I, exact_moment as M ++ import independent_owners as I, exact_moment as M, retired7_controls as R7 + tmp = Path(tempfile.mkdtemp(prefix='retired5-')) + def audit(w, name): +@@ -72,6 +76,30 @@ def main(): + need(all(s2[k] == s1[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias5 changes nothing else') + s3 = refit_apply(s2, p3); ch3 = frames_only(s2, s3); need(ch3 == {(s, i) for s, i, _ in p3['frames']}, 'refit5c declared frames') +- need(s3 == final, 'declared stages rebuild the candidate word ' + tag) +- for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('candidate', s3))): ++ p4, p5, p6, p7 = (rd(f'inputs/{n}_43{tag}.json') for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')) ++ s4 = refit_apply(s3, p4); ch4 = frames_only(s3, s4); need(ch4 == {('B', g) for _, _, _, g in MOVES} == {(s, i) for s, i, _ in p4['frames']}, 'refit7 declared frames') ++ need(all(len(s3['B'][g][-1]) == 6 and len(s4['B'][g][-1]) == 5 and L1 in regs(s3['B'][g]) and max(p for p, e in enumerate(s3['B']) if L1 in regs(e)) == g for _, _, L1, g in MOVES), 'new lenders: last gates lowered 6 -> 5') ++ need(not any(L1 in regs(e) for _, _, L1, _ in MOVES for e in s3['restore']) and p4['previous_frames'] == [[s, i, s3[s][i][-1]] for s, i, _ in p4['frames']], 'new lenders retired; previous frames recorded') ++ s5 = WP.apply_lowfour(s4, p5) ++ need(WP.kernel_gate_edit(s4['B'], s5['B']) == p5['declared_gate_edit'] and s5['removed'] == s4['removed'] and s5['start_extra'] == s4['start_extra'], 'hostmove2 declared edit') ++ for i, (a, b) in enumerate(zip(s4['B'], s5['B'])): ++ c = list(a) ++ for op, L0, L1, _ in MOVES: ++ if i >= s4['warps'][op - 1][0]: c = [L1 if (j in (1, 2) if c[0] == 'add' else j == 1) and x == L0 else x for j, x in enumerate(c)] ++ need(c[:-1] == b[:-1], 'hostmove2 is exactly the relabel of the hostees from their warp positions') ++ need([i for i, (x, y) in enumerate(zip(s4['warps'], s5['warps'])) if x != y] == [op - 1 for op, _, _, _ in MOVES] and len(s5['warps']) == len(s4['warps']), 'hostmove2 replaces exactly warps 30 and 31 in place') ++ need(all(s4['warps'][op - 1][1] == L0 and s5['warps'][op - 1][1] == L1 and len(s5['warps'][op - 1][3]) == len(s5['warps'][op - 1][4]) == 5 and s5['warps'][op - 1][0] > g for op, L0, L1, g in MOVES), 'moved warps: new lenders, dim 5, after the lenders retire') ++ need([[m['pos'], m['L_new'], m['G'], m['U'], m['E']] for m in p5['moves']] == [s5['warps'][op - 1] for op, _, _, _ in MOVES] and [m['old_record'] for m in p5['moves']] == [s4['warps'][op - 1] for op, _, _, _ in MOVES], 'hostmove2 records') ++ need(all(not any(L0 in regs(e) for e in s5['B'] + s5['restore']) for _, L0, _, _ in MOVES), 'old lenders untouched after their A lives') ++ need(all(s5[k] == s4[k] for k in ('A', 'restore', 'helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'hostmove2 changes nothing else') ++ s6 = WP.apply_lowfour(s5, p6); H7 = [h for h, _ in NEW7]; L7 = [L for _, L in NEW7] ++ need(WP.kernel_gate_edit(s5['B'], s6['B']) == p6['declared_gate_edit'] and s6['removed'] == s5['removed'] + H7, 'alias7 declared edit and removed helpers') ++ need(s6['warps'][:len(s5['warps'])] == s5['warps'] and [x[1] for x in s6['warps'][len(s5['warps']):]] == L7 and all(len(x[3]) == len(x[4]) == 4 for x in s6['warps'][-2:]), 'alias7 warps') ++ need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p6['aliases']] == s6['warps'][-2:] and [a['h'] for a in p6['aliases']] == H7 and s6['A'] == s5['A'] and s6['restore'] == s5['restore'], 'alias7 records') ++ need(all(max([p for p, e in enumerate(s5['B']) if L in regs(e)], default=-1) < min(p for p, e in enumerate(s5['B']) if h in regs(e)) for h, L in NEW7) and not any(L in regs(e) for L in L7 for e in s5['restore']), 'alias7 lenders retired before their followers enter') ++ need(s6['start_extra'] == {k: v for k, v in s5['start_extra'].items() if int(k) not in H7} and not any(h in regs(e) for h in H7 for e in s6['B'] + s6['restore']), 'alias7 helpers fully removed') ++ need(all(s6[k] == s5[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias7 changes nothing else') ++ s7 = refit_apply(s6, p7); ch7 = frames_only(s6, s7); need(ch7 == {(s, i) for s, i, _ in p7['frames']}, 'refit7c declared frames') ++ need(s7 == final, 'declared stages rebuild the candidate word ' + tag) ++ for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('retired5', s3), ('refit7', s4), ('hostmove2', s5), ('alias7', s6), ('candidate', s7))): + r = audit(w, f'{tag}-{name}'); need(r is None, f'auditor rejects {tag} {name}: {r}') + c = {} +@@ -99,5 +127,7 @@ def main(): + need(r is not None and not r.split(': ', 1)[-1].startswith(('explicit cleanup differs', 'warp operator id')), f'{tag} {h}<-{L} {nm}: not rejected for a real reason: {r}') + sec, i, fr = p3['frames'][len(p3['frames']) // 2]; m = copy.deepcopy(final); m[sec][i][-1] = [1]; r = audit(m, f'{tag}-refit5c-tamper'); c['certified frame corrupted'] = r; need(r is not None, f'{tag} refit5c tamper accepted') +- out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), local_profile=final['report']['local_profile']) ++ ok7, c7 = R7.controls(final, p4, p5, p6, p7, lambda w: audit(w, f'{tag}-r7'), WP); need(ok7, f'{tag} retired7 controls: ' + json.dumps({k: v['reason'] for k, v in c7.items() if not v['real_reason']})[:300]) ++ c.update({k: v['reason'] for k, v in c7.items()}) ++ out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), refit7_frames=len(ch4), hostmove2_gate_edits=len(p5['declared_gate_edit']), alias7_gate_edits=len(p6['declared_gate_edit']), refit7c_frames=len(ch7), retired7_controls=len(c7), local_profile=final['report']['local_profile']) + out['controls'][tag] = {k: v[:90] for k, v in c.items()} + # literal owner check of the complete candidate fill +@@ -106,5 +136,5 @@ def main(): + profile = {int(k): v for k, v in rd('CLAIM.json')['profile'].items()} + owner = I.check(rd('inputs/PLAN.json.gz'), rd('inputs/GLOBAL-TEMPLATE.json.gz'), order, fill, providers, dispatch, profile) +- need(owner['roles'] == 666 * 410 and owner['helpers_per_call'] == 410, 'owner fill size') ++ need(owner['roles'] == 666 * 408 and owner['helpers_per_call'] == 408, 'owner fill size') + # exact endpoint and kappa + claim = rd('CLAIM.json'); C = F(claim['complex_lower']) +@@ -122,5 +152,5 @@ def main(): + k = F(rd(rel)['kappa']); need(K > k, 'strict improvement over ' + name); d = K - k + margins[name] = dict(decimal=str(Decimal(d.numerator) / Decimal(d.denominator))[:40], exact=str(d) if len(str(d)) < 120 else 'K - kappa(' + rel + ')') +- out.update(status='PASS_T74_JOINT_TWELVE_RETIRED5_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), ++ out.update(status='PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), + complex_lower=str(C), root_80_digits=str(+z)[:82], kappa=str(K), margins=margins, + scope='Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py).') +diff --git a/new/rebuild_borrow.py b/new/rebuild_borrow.py +index d7cac67..157c371 100644 +--- a/new/rebuild_borrow.py ++++ b/new/rebuild_borrow.py +@@ -1,3 +1,3 @@ +-"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls]: rebuild the k=43 BORROW-WORDs from borrow/inputs (canonical words, block certificate, #2226-style witnesses), ++"""rebuild_borrow.py [retired5: + refit5/alias5/refit5c stages and controls; retired7: + refit7/hostmove2/alias7/refit7c stages and controls]: 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)""" +@@ -152,4 +152,48 @@ for canon,wt,h in CASES: + try:chc=frames_only(prev_c5,nc5);kok&=chc=={(s_,i_) for s_,i_,_ in r5cpatch['frames']} + except AssertionError:kok=False ++ M7=[(30,401,564,911),(31,403,565,912)];N7=[(667,401),(669,403)];H7=[h_ for h_,_ in N7];L7=[L_ for _,L_ in N7] # retired7: hostee moves (warp op, old lender, new lender, new lender's last B gate) and two new aliases ++ def relabel_ok(x,y,pairs): # y's B section is x's with old->new lender relabelled from each pair's start, nothing else ++ for i_,(a_,b_) in enumerate(zip(x,y)): ++ c_=list(a_) ++ for st_,o_,n_ in pairs: ++ if i_>=st_: ++ if c_[0]=='add':c_[1]=n_ if c_[1]==o_ else c_[1];c_[2]=n_ if c_[2]==o_ else c_[2] ++ elif c_[1]==o_:c_[1]=n_ ++ if c_[:-1]!=b_[:-1]:return False ++ return len(x)==len(y) ++ r7f=D/'inputs'/f'refit7_43{wt}.json';r7patch=None ++ if r7f.exists(): # retired7: the free retired lenders 564/565 get their last gates (B911/B912) at the exact frame floor, dim 6 -> 5 ++ r7patch=json.loads(r7f.read_text());prev_r7=chain[-1];chain.append(refit_apply(prev_r7,r7patch));steps.append('refit7');nr7=chain[-1] ++ try:ch7=frames_only(prev_r7,nr7);kok&=ch7=={('B',g_) for _,_,_,g_ in M7}=={(s_,i_) for s_,i_,_ in r7patch['frames']} ++ except AssertionError:kok=False ++ kok&=all(len(prev_r7['B'][g_][-1])==6 and len(nr7['B'][g_][-1])==5 and L1_ in regs_(prev_r7['B'][g_]) and max(p_ for p_,e_ in enumerate(prev_r7['B']) if L1_ in regs_(e_))==g_ for _,_,L1_,g_ in M7) ++ kok&=not any(L1_ in regs_(e_) for _,_,L1_,_ in M7 for e_ in prev_r7['restore']) and r7patch['previous_frames']==[[s_,i_,prev_r7[s_][i_][-1]] for s_,i_,_ in r7patch['frames']] ++ h7f=D/'inputs'/f'hostmove2_43{wt}.json';h7patch=None ++ if h7f.exists(): # retired7: the hostees of warps 30/31 (lenders 401/403, whose own lives end in A) move onto 564/565; warp records replaced in place ++ h7patch=json.loads(h7f.read_text());prev_h7=chain[-1];chain.append(word_patch.apply_lowfour(prev_h7,h7patch));steps.append('hostmove2');nh7=chain[-1] ++ kok&=word_patch.kernel_gate_edit(prev_h7['B'],nh7['B'])==h7patch['declared_gate_edit'] and nh7['removed']==prev_h7['removed'] and nh7['start_extra']==prev_h7['start_extra'] ++ kok&=relabel_ok(prev_h7['B'],nh7['B'],[(prev_h7['warps'][op_-1][0],L0_,L1_) for op_,L0_,L1_,_ in M7]) ++ kok&=[i_ for i_,(x_,y_) in enumerate(zip(prev_h7['warps'],nh7['warps'])) if x_!=y_]==[op_-1 for op_,_,_,_ in M7] and len(nh7['warps'])==len(prev_h7['warps']) ++ kok&=all(prev_h7['warps'][op_-1][1]==L0_ and nh7['warps'][op_-1][1]==L1_ and len(nh7['warps'][op_-1][3])==len(nh7['warps'][op_-1][4])==5 for op_,L0_,L1_,_ in M7) ++ kok&=[[m_['pos'],m_['L_new'],m_['G'],m_['U'],m_['E']] for m_ in h7patch['moves']]==[nh7['warps'][op_-1] for op_,_,_,_ in M7] and [m_['old_record'] for m_ in h7patch['moves']]==[prev_h7['warps'][op_-1] for op_,_,_,_ in M7] ++ kok&=all(not any(L0_ in regs_(e_) for e_ in nh7['B']+nh7['restore']) for _,L0_,_,_ in M7) and all(nh7['warps'][op_-1][0]>g_ for op_,_,_,g_ in M7) ++ kok&=all(nh7[k_]==prev_h7[k_] for k_ in ('A','restore','helper_final','compensation','initial_corrections','precondition','cut','target_levels','centers','center_frames','ports','prelude_events')) ++ a7f=D/'inputs'/f'alias7_43{wt}.json';a7patch=None ++ if a7f.exists(): # retired7: retired-lender aliases 667<-401 and 669<-403 (the PR2679 kind) after the hostee moves ++ a7patch=json.loads(a7f.read_text());prev_a7=chain[-1];chain.append(word_patch.apply_lowfour(prev_a7,a7patch));steps.append('alias7');na7=chain[-1] ++ kok&=word_patch.kernel_gate_edit(prev_a7['B'],na7['B'])==a7patch['declared_gate_edit'] and na7['removed']==prev_a7['removed']+H7 ++ kok&=relabel_ok(prev_a7['B'],na7['B'],[(min(p_ for p_,e_ in enumerate(prev_a7['B']) if h_ in regs_(e_)),h_,L_) for h_,L_ in N7]) ++ kok&=na7['warps'][:len(prev_a7['warps'])]==prev_a7['warps'] and [x_[1] for x_ in na7['warps'][len(prev_a7['warps']):]]==L7 and all(len(x_[3])==len(x_[4])==4 for x_ in na7['warps'][-2:]) ++ kok&=[[a_['pos'],a_['L'],a_['G'],a_['U'],a_['E']] for a_ in a7patch['aliases']]==na7['warps'][-2:] and [a_['h'] for a_ in a7patch['aliases']]==H7 ++ kok&=all(max([p_ for p_,e_ in enumerate(prev_a7['B']) if L_ in regs_(e_)],default=-1) None (accepted) or the rejection reason; returns (all_ok, results)""" ++ def rederive(m): ++ m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(w0)); m2['A'] = A; return m2 ++ res = {} ++ def expect(name, m, reason=None, fresh=True): ++ r = audit(rederive(m) if fresh else m) ++ ok = r is not None and not r.split(': ', 1)[-1].startswith(VACUOUS) and (reason is None or reason in r) ++ res[name] = dict(rejected=r is not None, reason=(r or '')[:160], real_reason=ok) ++ need = audit(w0); assert need is None, ('unmutated final word rejected', need) ++ for sec, i, fr in p7['previous_frames']: ++ m = copy.deepcopy(w0); m[sec][i][-1] = fr; expect(f'refit7 {sec}{i} lender refit undone', m, 'warp frame mismatch') ++ for mv in ph['moves']: ++ k = mv['op'] - 1; tag = f"move{mv['op']} {mv['L_old']}->{mv['L_new']}" ++ m = copy.deepcopy(w0); m['warps'][k][1] = mv['L_old']; expect(tag + ' warp lender reverted', m) ++ m = copy.deepcopy(w0); m['warps'][k] = copy.deepcopy(mv['old_record']); relabel(m, mv['old_pos'], mv['L_new'], mv['L_old']); expect(tag + ' move undone', m) ++ m = copy.deepcopy(w0); m['warps'][k][0] = mv['pos'] - 400; expect(tag + ' warp before lender retirement', m) ++ m = copy.deepcopy(w0); m['warps'][k][2][0] ^= m['warps'][k][2][1]; expect(tag + ' G wrong', m) ++ for a in pa['aliases']: ++ h, L = a['h'], a['L']; op = next(i for i, r in enumerate(w0['warps']) if r[1] == L and r[0] == a['pos']); tag = f'{h}<-{L}' ++ reads = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] ++ writes = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] ++ m = copy.deepcopy(w0); m['B'][reads[0]][3] *= -1; expect(tag + ' borrowed read sign flipped', m) ++ m = copy.deepcopy(w0); m['B'][reads[0]][3] *= 2; expect(tag + ' borrowed read doubled', m) ++ if writes: m = copy.deepcopy(w0); m['B'][writes[0]][3] *= -1; expect(tag + ' borrowed write sign flipped', m) ++ m = copy.deepcopy(w0); del m['warps'][op] ++ for e in m['A'][:m['prelude_events']]: ++ if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 ++ expect(tag + ' warp dropped', m) ++ m = copy.deepcopy(w0); m['warps'][op][2][0] ^= m['warps'][op][2][1]; expect(tag + ' G wrong', m) ++ m = copy.deepcopy(w0); m['warps'][op][0] = a['pos'] + 1; expect(tag + " warp after the follower's first gate", m) ++ m = copy.deepcopy(w0); m['start_extra'][str(h)] = a['E']; expect(f'{h} kept with an entrance frame', m) ++ sec, i, fr = pc['frames'][0]; m = copy.deepcopy(w0); m[sec][i][-1] = [1]; expect('refit7c certified frame corrupted', m, fresh=False) ++ return all(r['real_reason'] for r in res.values()), res ++if __name__ == '__main__': ++ here = Path(__file__).resolve().parent; sys.path.insert(0, str(here)) ++ import audit_local as al, word_patch as WP ++ w0 = json.loads(gzip.decompress(Path(sys.argv[1]).read_bytes())); D = Path(sys.argv[2]); tag = sys.argv[3]; tmp = Path(tempfile.mkdtemp()) ++ p = {n: json.loads((D / f'{n}_43{tag}.json').read_text()) for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')} ++ def audit(w): ++ q = tmp / 'm.json.gz'; q.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode())) ++ try: ++ with contextlib.redirect_stdout(io.StringIO()): al.run(q, tmp / 'm.out.json', None, None) ++ return None ++ except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as e: ++ return (type(e).__name__ + ': ' + str(e))[:200] ++ ok, res = controls(w0, p['refit7'], p['hostmove2'], p['alias7'], p['refit7c'], audit, WP) ++ Path(sys.argv[4]).write_text(json.dumps(dict(all_rejected_for_real_reasons=ok, controls=res), indent=1) + '\n') ++ print(('ALL RETIRED7 CONTROLS REJECTED' if ok else 'RETIRED7 CONTROL FAILURE'), sum(r['real_reason'] for r in res.values()), 'of', len(res)); sys.exit(0 if ok else 1) diff --git a/research/tensor-block-kappa/vendor/frontier/REUSE-PINS.json b/research/tensor-block-kappa/vendor/frontier/REUSE-PINS.json new file mode 100644 index 0000000000..ff0b83bf69 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/REUSE-PINS.json @@ -0,0 +1,200 @@ +{ + "cache_files": { + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/CACHE.json": "134bdacc4a766dbc67df01704d4a279e29c0bea56350c75b2a0436b9ba8666d0", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/STEPS.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CANONICAL-WORD.json.gz": "dacaaa72961e8bcfefa5f5125aa79b2bae33d4faead01a651bd44a8ea5ab2412", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CLIFFORD-RECIPES.json": "a9641c6cbc4e05677e7559bf1764468f3dbcd9efe0ae710205590c381f6b5f08", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/CLIFFORD-REVIEW.json": "9622789fd43d2c3e14d98ae3df48765d1faeb8f5664136f48384dcd603e215fe", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/FULL-WORD.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/INDEPENDENT-LOCAL-REPLAY.json": "1ca177b1b78a0faaaaeeb05d44ccef50810d20d9f5607b3fa7dd493067f69ef1", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/SCALAR-FRAME-AUDIT.json": "abbfa5baf5228072679d6ac08b873115ef3a00c39e6632e110d1f94a5f7657da", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/WARP-RECIPE-CHECKS.json": "32c3480dd0f953237f567a5e1c66eb15de9cee5b57c219b571bcc9cb993042dd", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/native.log": "8ac1d92e1e84f39a5865ae78d0894249995335c1734a450a53ce65998b59d57b", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/phases.log": "4f02722e71e03c4998f7c5b625ed5a7afdc7500ebfb0aa7e6f53b177cc08a645", + "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/CACHE.json": "069df513a95cdc93095aaecf5714ea2183c1735cc5bec65bd38e469adccdbff6", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/STEPS.json": "4637ff6d5767aae404ccc9251bef35e5961afa2ba2fd846527b93dca05c5fd2d", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/ledgers.log": "8a5910fbfadd88e164b84d65115ca356a932df55501dbbc9e102333b17688e77", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CANONICAL-WORD.json.gz": "c0fc324db76506cd9f0f88d830f28b8d18a0870a6dbcd31362e01f2683ffc065", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CLIFFORD-RECIPES.json": "d3efa2a7199bb2113f8232bb0e78deb8144f44856d6b03a1069e75d775245d6b", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/CLIFFORD-REVIEW.json": "76a38ecba56ecdb28bc60ea8558a535533e5da6ead2de4fce92e80949e93ee0a", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/FULL-WORD.json.gz": "4f980df67440c0d0b87186b88a816301896f277068bec0295b67a5c06f43e8bd", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/INDEPENDENT-LOCAL-REPLAY.json": "1503f00082d7f94f6ac1765a143fcdf6e780f9e4a19d4cb018ce8f1930b009f4", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/LOCAL-CHECKS.json": "d9743b22c746403097ac2e4430f8c0c3edca6a325a1b14c7978fb94b2047b890", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/LOCAL-PROGRAMS.json.gz": "5f89cf546f6d5969a065256404a3c902c52217f3b79bddd740e33058907cdf16", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/RESIDUAL-ADAPTERS.json": "82f5e5cf37c8ec3cce707e7d152b23f6fff2fddd771ff43317b5a446ef81fc00", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/SCALAR-FRAME-AUDIT.json": "dd659103a97b2313c947f4ab6a44ef5dc6244e9cef57864d2cc1cc7d232ae6d7", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/WARP-RECIPE-CHECKS.json": "9ccdb18e1c1eb5a8f386d17b08a36e6b4338a34b15e49e9509acd2e866c12ee8", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local/WRAPPER-CHECKS.json": "727c9a1dd1c85a6ced726f1ff03ff7399bd6a20db5ce53faf452ad242da73a5c", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/native.log": "99f4a9ed755532566debf2ec91da35981093f02538691889ca4201c266ae7194", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/phases.log": "27e8e39b604d3422bf02ad3512aa1301b1686fc81e3ab3b56d6e501129f58037", + "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "78a3b23d31d62f6fec7bfd448c0062dcacabd0e0e416957ce506839e94fb0eb7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "6b18a21ef3bfb8e96d26d60f2db702eb9e4e5fd4aae5f5113380074235ed85c4", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "16fa3177ea9496dea606f56623dfd69a1799075ec8bb9bba6258e35b7d865481", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "e6d01761d6a48c6d0e861194ba13515002e3d9ea6ac1b531b359bff5b2ed2459", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "b23f983d52700ff84a5d2303916f6e9a909937d301e4a308204702e756e9635c", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "633faa7fd015f93a5b6193598c45e70c41838655b4ad60b5ea98dbdedf601390", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "9f1805608ebc5fc68a4758cc781f37deb26490a800077357b7a91f1436a38872", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "03b6a2503949708d090f5338006662172324fe66502452e8da0c3b1454b27262", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "88c98295140810288ff552fdc8cfc3741b11ee6d80ce01e8d2c8f2c9b7a73e31", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "c7b917a0a452672d08f817a57eea0db1cf237c142371936e9f483f28f4428e54", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "a9c86b5209f35cad3be26f74f70a4962c48f3cb7021c696621beb1794d5c1278", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "e00871b9295253310a4145ebb4786af72a347a0a6015590c4779a29e20826608", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "2a58e55283a5d74adf38a8c4b78f21793b619ee885ccf64dc18af7b0d5f8a96d", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/CACHE.json": "41cc27c91f3610959ef3166a90484bd65bce0c663b420ecee0fd42725af2ca2c", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/STEPS.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CANONICAL-WORD.json.gz": "dd1f277eafbde7fbc68c51fad396a64e8afe389a8529bbe61e187014a8a48215", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CLIFFORD-RECIPES.json": "3fad1a9ae138ddb89442753cb2ef3c0666c58f40d5488d503fbf75f7f480d4d3", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/CLIFFORD-REVIEW.json": "255cf6f3d1105e9c60e2b589e3445a6b7e69af575abcfe4f6a0aba971fdb4195", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/FULL-WORD.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/INDEPENDENT-LOCAL-REPLAY.json": "26adad9d1cd317e8e6c2f5db0f42e5f35ef4220e84280c80ac273aa2a329903a", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/SCALAR-FRAME-AUDIT.json": "10347acf893d70592ca4af8ee1cdf58a06510a444992feffcddf5c03bdf63e42", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/WARP-RECIPE-CHECKS.json": "95bc1e29bae8210542423d7b0d6b4c07b29d3948a2c987507a97cf085f963252", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/native.log": "0da891ab0e4bfeb32b3b73fbc03b0456ffb06e159906b2013938ad65e13b0585", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/phases.log": "cb01cc9d0f1831fc202ee5ab21ed9ccbcef52a3c369b7ca1390b64d99f070ecc", + "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/CACHE.json": "29b075f5e59eaea78a3d8386f8be8485fdac4629404087ca57f8d8a6505fb18f", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/STEPS.json": "6bec0227ce64490c9e6384464d9a8a778c54755a67f3a276c279faafb7a02981", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/ledgers.log": "8a5910fbfadd88e164b84d65115ca356a932df55501dbbc9e102333b17688e77", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CANONICAL-WORD.json.gz": "52c263e6936b4dd1eb009617e5df5fd0f39cae44e06683904194223d34052262", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CLIFFORD-RECIPES.json": "afc22bbc53821f3d4412afa81fa787be68672395a3432fed3c3740bb7708f4bb", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/CLIFFORD-REVIEW.json": "8793f34c12e30884e17caefc7c898f83fe06ec6a07578c9783fed325d6db48a4", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/FULL-WORD.json.gz": "56252cf9c875ca56f5dee42c38c838fa0320662ff7f724a15f06145ff5cd5854", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/INDEPENDENT-LOCAL-REPLAY.json": "4139c7bd22c3cf55e58749f81b0013b7e824fdd82c3c701921a23fb2391db990", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/LOCAL-CHECKS.json": "d9743b22c746403097ac2e4430f8c0c3edca6a325a1b14c7978fb94b2047b890", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/LOCAL-PROGRAMS.json.gz": "5f89cf546f6d5969a065256404a3c902c52217f3b79bddd740e33058907cdf16", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/RESIDUAL-ADAPTERS.json": "ba41be347d33fad9b5d6af16457e92dd9ee507dc4589bafc63a903986e733d2c", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/SCALAR-FRAME-AUDIT.json": "a96f78833f2e7285ed8248510bf091c86c2918d3df4413307b83136231bdd406", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/WARP-RECIPE-CHECKS.json": "0fa3b603d74af3c9853df200e0ae3a0e71f910e1c3620415b7072f5553d7b918", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local/WRAPPER-CHECKS.json": "727c9a1dd1c85a6ced726f1ff03ff7399bd6a20db5ce53faf452ad242da73a5c", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/native.log": "d4d096f7186024d29f919438ae4a25d50f157f642a2b84f6202851b1d768ee03", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/phases.log": "e6dbb20f1bdc7a8b014b307066e8598a365aae6e65701ab16b3a3c242a2bb907", + "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "56cbbc829163f32f3b2a3b6c413b8202aff367cfacd57fb88a1b9b7cf0c3470d", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "a5c02d0d6347aefd558e287fa581362a9b89adfd7eaf4a1c003dae47e1b1874e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "d0eb80da0f54f7444421c577a688e28cebc23d4abd8e431f5bf38526d3335d77", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "303767d1ff2550e4a10443b0d5ed705a8461c76f06bb7074762c02a0f54f339b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e6bafd6741e865e85b9ad8941b87b7c4e4c4a7debb78cd256e12a4b39ec3b586", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "32096efe8e8b986247bb8f434cee48cd29e209d2602125683ca91dbac242fa44", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "1f91b781e43e70b24ff14f2007cb767d30a9520411d222e49d7870981043dfb2", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "8945a81137262aa1ee8e2cf159dbd59838b58adf4b2f66a812a92406088111ed", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "44ae449a4ab0ea50c4bd377b38c12e4c73b5858391304e38d7f8bf46171b8866", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "458754a81eeabcd677a30b4c3e5a8393d7535bc21e02d4b0c75f3732d362c944", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "providers": { + "base": { + "R": 415, + "complete_native_files": { + "STEPS.json": "658d1d341816ee5227c55977047354f3c26280b961d5c967eff0ef02fb1f0486", + "ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "local/CANONICAL-WORD.json.gz": "dd1f277eafbde7fbc68c51fad396a64e8afe389a8529bbe61e187014a8a48215", + "local/CLIFFORD-RECIPES.json": "3fad1a9ae138ddb89442753cb2ef3c0666c58f40d5488d503fbf75f7f480d4d3", + "local/CLIFFORD-REVIEW.json": "255cf6f3d1105e9c60e2b589e3445a6b7e69af575abcfe4f6a0aba971fdb4195", + "local/FULL-WORD.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "local/INDEPENDENT-LOCAL-REPLAY.json": "26adad9d1cd317e8e6c2f5db0f42e5f35ef4220e84280c80ac273aa2a329903a", + "local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12", + "local/SCALAR-FRAME-AUDIT.json": "10347acf893d70592ca4af8ee1cdf58a06510a444992feffcddf5c03bdf63e42", + "local/WARP-RECIPE-CHECKS.json": "95bc1e29bae8210542423d7b0d6b4c07b29d3948a2c987507a97cf085f963252", + "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native.log": "0da891ab0e4bfeb32b3b73fbc03b0456ffb06e159906b2013938ad65e13b0585", + "phases.log": "cb01cc9d0f1831fc202ee5ab21ed9ccbcef52a3c369b7ca1390b64d99f070ecc", + "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa" + }, + "fresh_stage_seconds": 316.8524922529905, + "paid_profile": { + "1": 2374, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 8 + }, + "widths": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "word_sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a", + "zero_buffers": 72 + }, + "extra": { + "R": 415, + "complete_native_files": { + "STEPS.json": "5e1bac16f35af9fb4a6adbcf76d948052fbec016bb7e8740fc121b5754eecebb", + "ledgers.log": "7d7708ba7086ade02c653315c0bda82f2b32f92ccf30f49fdf4c7f40ecc39fe6", + "local/CANONICAL-WORD.json.gz": "dacaaa72961e8bcfefa5f5125aa79b2bae33d4faead01a651bd44a8ea5ab2412", + "local/CLIFFORD-RECIPES.json": "a9641c6cbc4e05677e7559bf1764468f3dbcd9efe0ae710205590c381f6b5f08", + "local/CLIFFORD-REVIEW.json": "9622789fd43d2c3e14d98ae3df48765d1faeb8f5664136f48384dcd603e215fe", + "local/FULL-WORD.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "local/INDEPENDENT-LOCAL-REPLAY.json": "1ca177b1b78a0faaaaeeb05d44ccef50810d20d9f5607b3fa7dd493067f69ef1", + "local/LOCAL-CHECKS.json": "91d4117ece180666bcbda47204aad48c6b1d16f9d16bbc75f7b25493ae51674f", + "local/LOCAL-PROGRAMS.json.gz": "63e43ef535377b6e44cd264f126d8aded95441bd263e0d047eb168d6c46409bf", + "local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352", + "local/SCALAR-FRAME-AUDIT.json": "abbfa5baf5228072679d6ac08b873115ef3a00c39e6632e110d1f94a5f7657da", + "local/WARP-RECIPE-CHECKS.json": "32c3480dd0f953237f567a5e1c66eb15de9cee5b57c219b571bcc9cb993042dd", + "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "native.log": "8ac1d92e1e84f39a5865ae78d0894249995335c1734a450a53ce65998b59d57b", + "phases.log": "4f02722e71e03c4998f7c5b625ed5a7afdc7500ebfb0aa7e6f53b177cc08a645", + "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa" + }, + "fresh_stage_seconds": 320.795613839, + "paid_profile": { + "1": 2374, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 8 + }, + "widths": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "word_sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127", + "zero_buffers": 72 + } + }, + "retained_parent_receipt_sha256": "a9c86b5209f35cad3be26f74f70a4962c48f3cb7021c696621beb1794d5c1278", + "scope": "Both changed PR2679 native providers freshly executed all five stages. Exact retained PR1297 native providers and full parent-admission receipt reused from the authenticated earlier cache; all cache files pinned.", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/SOURCE-FILES.json b/research/tensor-block-kappa/vendor/frontier/SOURCE-FILES.json new file mode 100644 index 0000000000..7e8a64069e --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/SOURCE-FILES.json @@ -0,0 +1,501 @@ +{ + "base_url": "https://raw.githubusercontent.com/philippeVV/integer-mult-bounds/2e2cf56521df8a2b816b2689144765ee00b69a24/research/gmx-t74-borrow43-handoff/", + "commit": "2e2cf56521df8a2b816b2689144765ee00b69a24", + "count": 491, + "files": { + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "ADMISSION-DERIVATION.patch": "7021000d75635fc5806af821640c02f9d7cbbbe1cf314dacfcc743fc6875fdd8", + "CLAIM.json": "bc893bde9d0605e793844dca14e8f8e175b839b890c6f9c15e3a147f6db0cb36", + "CONSTRUCTION.json": "ff5c0516714e3220468b84583ec0bb25d39c0832a179268b929699e5b1bd5508", + "DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "EXACT-ARITHMETIC-DERIVATION.json": "c0d40deaa495a7365e91aa5d9e6a846f91e0cb6daff98bb3b7f2acef84d64ec4", + "GLOBAL-TEMPLATE.json.gz": "1d31424c4e27e26a35a9932ca778e43f1f3577589275422cc642aa68b31112db", + "NOTICE": "a91b93a731f116ae55b3644c88232b4d996e58bb810e2559dec013f9788f5e4b", + "ORDER.json": "e37e607973be543331ce19a3ee49f79ea22cda484a3dcdcf897719412db221be", + "OWNERS.json.gz": "e5a46f423debb846c49f8ed97202ba3919d417e237e22cb7b805c1df592e0e1d", + "PARENT-LIFT-RECEIPT.json": "cea858499dceda9dd6a77ebd1b39cf4598b237b1701cc01841481f2ebc4b5d33", + "PLAN.json": "abc47a9fffdb2079de0386a50c43b0f71f705f59fe71d3f9683031b4357560ce", + "PRICE.json": "c5ec535fd9edbdec7b64edd5a8b862edb1a7f173d411dacb279172659573e16a", + "PROFILE.json": "0dd9a8afa9eb343a12cab29bca16b2579c2ab4bec50ab7a1c539b20ae5d265ac", + "README.md": "7bbef7c9ebf7a1dbee4df8956a54fe799a0e2682935c6d919388be22e8254f5a", + "RELEASE.json": "2a4f17684f0e2666313b8e13c90e92640880164a8dc2a9d9396fe375aae0ece4", + "SOURCE-PIN-REFINEMENT.json": "8c0bad79978decd6f8aba0932c0a94c7f61c64bf9ce5a19a36f67cc1390bf74f", + "SOURCE-PIN.json": "66faac1fd4e79bb6d9fc774fd8ba63522ad3309456be1c81405794b284c55c83", + "SPEC.json": "81676590c26018aa95082e3252f394ac99c61c0c4e5578f59501401700e38033", + "audit_fast.py": "26950da76589b13cd9c452fdee1b0c354806977f881299bd94073f00e4646fcd", + "audit_mixed.py": "defdb5f1d33dd6b0eee9b84c00b5cc01e5283ec41308b520df714e1caffb9916", + "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/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": "c4bcd06a6f761e8b298f23ff3da81053cf47a7126fa1322f732a685cdb58b517", + "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": "392dd6da6e6da7ceadab046e7b6ad656f46ea5693e7ebc3291707d74fde99c87", + "new/CHAIN.json": "f18804a71bef7005e892b0b7baac818d5362fff685fe5b5aadfe8de6e442446d", + "new/EDITS-1.json": "dffa640c04d71111d3e4bdd7f5a991450ba07049a1d434edeef84791c0cc2d05", + "new/EDITS.json": "d5f9a0444dddcccd35c0217f60dbd6863486241629a747c3bbe4140b3d55eea1", + "new/PLAN.json": "a31260c7718bda6c0ed55ea1a4ee6873dfcdfef9bec033c5f0416c5e704bf292", + "new/PROFILE.json": "4b002d61fc50861df1c85e517b0466a063ad9a85464cec247a99ab5c92bbf38f", + "new/SPEC.json": "7485e560bd810d6eac962b16295f730545a0341dd2ab1f072a0682c376fa1ff9", + "new/borrow-fill/DISPATCH.json": "fd8132ec8957b908ee6d871216848f18bafc6bd9304acd6185519ee26d97b1ca", + "new/borrow-fill/FILL.json.gz": "8f324b0e4e57f2089d805b34dd10e814e868211a018cf8ebb8538ba9c40778d7", + "new/borrow-fill/ORDER.json": "e48b51a7d6a315971fff8b8e51748251750ff4ed8fe30b8b023de1a1a8019783", + "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/alias1_43base.json": "3b7bb0fea555d65a3b53c408ad3caab1d322b0a1635bdd14cfb45cf76693a345", + "new/borrow/inputs/alias1_43extra.json": "42e509a4ffa5c55d8bb1541bb483f3b6e81e04e2fc6df0cfb85796f9dc9e58e1", + "new/borrow/inputs/alias8_43base.json": "8210fbaa107744fe09fa02d3abdd5982b68a8af4710d4c3c3d604f8ade18f8e4", + "new/borrow/inputs/alias8_43extra.json": "e5fcc94a2511d73749f9cd1b4e4eaec0602bebf85b8c58144bebc9c4206b30f6", + "new/borrow/inputs/blocks.json": "ddfac1dae1fe7cc0a91e7c7205c6d9d0c07c682880aa34eed83bf4ad7384da9f", + "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": "0c901b689b4d12c1f50a61ec5b99e6cc38f1bbd524f036203e5a250d44c0f21a", + "new/borrow/inputs/prelife_43extra.json": "ae67d2bc3873a3f08d7cb46bfbd4e4d54f9e7f471b695b28f69907c6b18a69b3", + "new/borrow/inputs/refit563_43base.json": "0662e4800279890f565c0ee5668ed97e8ea25d6ea4a8697b4c1d9a4715716cc7", + "new/borrow/inputs/refit563_43extra.json": "0662e4800279890f565c0ee5668ed97e8ea25d6ea4a8697b4c1d9a4715716cc7", + "new/borrow/inputs/refit_43base.json": "19a97e80b0ee3146e0244e6bc36bd365d89e9c1cd0f885c4e06be4193606a323", + "new/borrow/inputs/refit_43extra.json": "1349d54f704847fdcd4a00e323cdc9e1118fac7fedb0c7573e9b2b3f0169a7eb", + "new/borrow/inputs/witness_43_base.json": "65ee52604e2e49a30c1e978b7ce829482a694a20a8744f37b9bf40dad1ff3a2e", + "new/borrow/inputs/witness_43_extra.json": "19c652db80d5215c958c63b5d6f2de96d9cf34a0e4d56dab5c13e556c57f7467", + "new/borrow/lowfour_controls.py": "cc2d102a3cf1cc1063ea39ab7b22c4231445dfd485705661b1da38bcc6da8066", + "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": "b85e6c60f0ba84464d1a60b54d01d2086126f3b909e8e67ea41ccf5e22d61178", + "new/borrow/words/BORROW-WORD-43extra.json.gz": "62d74e9fa845dc669544a732cb2e49a6263679b99e3aef85f4f212cc8aada4fc", + "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/gauge44-word-566.json.gz": "eeb6a236ed0ea8873b8800947d0cd19c36a6fcfdf857fc42913cb45cd984f219", + "new/pivotcheck.py": "6eb1752f077df108c908974413fc71abc751356b07c6e650e75d2075f1a51391", + "new/rebind.py": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af", + "new/rebuild.py": "7391a7228d6b5afc2f88afd5d5a987565d78a100386c1f03b8696bcde2e8ef3e", + "new/rebuild_borrow.py": "9cef11a627dc197d68845efec25ec22c9af69a132978d8db13f6cfc0d1841b30", + "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": "2a6ed1fe7f601146af00ddcde61776a9db8d787d3e43c13f4c0436b529a4180e", + "outer/CLASSICAL-BOUNDARY.md": "6647d5a71d9f6c3f628ac71a7be2e63bcb0cac9618cd4fee7493dcc4ef02529a", + "outer/FINE-PADDING-COMPOSITION.md": "d20d8e5f84a9e33cc9996f875be06c24c74ea53874cc76564953785ff29c5c6c", + "outer/GAUGEFREE-INTERIORS.md": "a3f67d945eada51cc93c69438b1fa3173dd6dd0f7bb4e76cbf5116fcc496edd9", + "outer/INDEPENDENT.json": "dd27ba85431ba0b4297ab906166adb4ad5ca5883af1ec9173e056cf3d5231b21", + "outer/LEDGER.json": "31d72437d30aa6a8b8a327700196f0ce6e7b327d37239578fd5d9248f6888e9b", + "outer/OUTER-CLAIM.json": "df0d5121f0955f2c9743621e3a259c4a34d9177aa818cf5a21dc1edd849fad64", + "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": "2957d2aafc56e3b757c5734bb29c3258cdf0ab167bd06ee0daf95281b5207e10", + "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": "4dbb80917a2324b5f7bd89485963a009e54db98f99e91469811e1d36101bea95", + "verify_manifest.py": "723d726dbbe5b65a49caecae0f1aab664a1413fb639abfd3e826a5a538e14e5b", + "verify_release.py": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800" + }, + "manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "package": "research/gmx-t74-borrow43-handoff", + "repo": "philippeVV/integer-mult-bounds" +} diff --git a/research/tensor-block-kappa/vendor/frontier/SOURCE-NOTICE b/research/tensor-block-kappa/vendor/frontier/SOURCE-NOTICE new file mode 100644 index 0000000000..380e979f0e --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/SOURCE-NOTICE @@ -0,0 +1,14 @@ +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. + +The preceding paragraphs are inherited source notices, not attribution of this derivative. +This joint twelve-source construction, generator, independent replay, hosting composition and package: Tekalign (@tekuuu), with substantial OpenAI Codex assistance. No independent human review claimed. +Credits: Cinna Davis/PR2226 anticipatory dirty borrowing; Tekalign/PR2436 four lifted targets; Jeremy Kothe/PR2462,2588,2673 source pipeline, source-label swap and order/fill; zxv/PR2530 eight aliases; Mason Hale/PR2696 concentrated source-partner assignment and independent local interpreter; Philippe Van Velzen/PR2559,2679 evacuation, six pre-life hosts and refit/alias; themilkman216/PR2621 priority order; Marius-Paul Dumitrean/PR2733 independent concentrated/pre-life composition; Vlado Vojdanovski/PR2322 generator utilities. PR2720's fixed-old-path cut obstruction motivates the changed premise. The retained owner/native/bit/modern outer lineage and their notices remain in the pinned source. New work Apache-2.0. diff --git a/research/tensor-block-kappa/vendor/frontier/SOURCES.json b/research/tensor-block-kappa/vendor/frontier/SOURCES.json new file mode 100644 index 0000000000..aa59a560ca --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/SOURCES.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "base_commit": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "00c96932e109c701310f4910057bae2d6cec0c0f", + "sha256": "2d47ee25f6900efa3bac76f66f59cc6d6e077ed1e7301497ab332668ad288d4c" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "0515a31cd888a18e5830987da12d4051f552c8cc", + "sha256": "e3e85885c27919c4f603954ef25339e9c1be4bd107f829921078b8134b366044" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "889b95d936746df124872133ae1e7cc339adcb92", + "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/current-status.md", + "usage": "provenance", + "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", + "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" + }, + { + "path": "research/t74-joint-twelve/README.md", + "usage": "provenance", + "git_blob": "77ab0d3121069a8aa365bf0f6c35ee8e5ac15ac8", + "sha256": "d8501fbc11b3dc87fc618122c83f10a56cd4457c7abdab792e2f9506bab4666e" + }, + { + "path": "research/t74-joint-twelve/CLAIM.json", + "usage": "provenance", + "git_blob": "48ad23a430def28e485ee311ac92828ac9664a0c", + "sha256": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438" + }, + { + "path": "research/t74-joint-twelve/verify.py", + "usage": "provenance", + "git_blob": "bae5b71ecc554b787deab407b1beb394124cf86a", + "sha256": "d97bcc7208abd7e2f6f836c5558dae93e92ebbf6b17b0f413bc6e78ac68d62fc" + }, + { + "path": "research/t74-joint-twelve/independent_owners.py", + "usage": "provenance", + "git_blob": "93270b725a4efd56b283b02f9abf7a5d0e66c55f", + "sha256": "4e0785a659b4a6516581f15476c054de1581aa4b3763ce45b1fd20e45c2bb5af" + }, + { + "path": "research/t74-joint-twelve/workflow/admit.py", + "usage": "provenance", + "git_blob": "4606a5024ee5fe12ecaf18d983f010ebd944acdd", + "sha256": "f0d510b46a5f05b033b13fecb706389ab374b783bd46ef30e7386195d9e56d3e" + }, + { + "path": "research/t74-joint-twelve/generate.py", + "usage": "provenance", + "git_blob": "82ca3d20a5e2fd8c4b67b19e9b9ecd5fca423853", + "sha256": "55d87e7490a7011d881e48f3ab946b7f8b95e0b1b3e91987a8ff8129f18d5869" + }, + { + "path": "research/t74-joint-twelve/packing_cap.py", + "usage": "provenance", + "git_blob": "dd97566afb7ac6686606b50dc644fd14a559d301", + "sha256": "86b768616359b43a4a4fe4135370c7713f9436b5009553bb8e7b984367f54593" + }, + { + "path": "research/t74-joint-twelve/test_integrity.py", + "usage": "provenance", + "git_blob": "73c4e96005f0699a05642dcc39308d4b279e2707", + "sha256": "f2cabdb261761ebfa6f9b6ed2f3aae1a0853c79bc6ddc2808c6e8bbe5b46e68b" + }, + { + "path": "research/t74-joint-twelve/full_replay.py", + "usage": "provenance", + "git_blob": "d9718b8b5b173ab81efaee24c04e5c99b6e70e94", + "sha256": "3f7ff263775253f73a87abc43a76f39f23e8bc0ce433a562d17f2c0705b5a02b" + }, + { + "path": "research/t74-joint-twelve/OVERLAY-PINS.json", + "usage": "provenance", + "git_blob": "ec223bdbe25510166f6bad3bf21d039512dc5177", + "sha256": "c5aab657b189d1324b75c2a35dd21063877229ebfd58b4b64261fdf0e5861e75" + }, + { + "path": "research/t74-joint-twelve/DERIVATIVE-OVERLAY.tar.gz", + "usage": "provenance", + "git_blob": "46f7ce76d81b9c46fde6b0fb204bcad4763e1a87", + "sha256": "16468f7428c6e01522fcb15a8e3040d13de6cb8856428e32dcfbce8dbe46b8ec" + }, + { + "path": "research/t74-joint-twelve/inputs/WORD-base.json.gz", + "usage": "provenance", + "git_blob": "f1fc67a6eaf4bcc5dfa852b448aa2659070fa5f8", + "sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a" + }, + { + "path": "research/t74-joint-twelve/inputs/WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "f06e80c4dddb9741d0051cb85a57d356e673f687", + "sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127" + }, + { + "path": "research/t74-joint-twelve/inputs/PROVIDERS.json", + "usage": "provenance", + "git_blob": "26be26b6d25be67327ae77623c2eaa0a9fe463dc", + "sha256": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66" + }, + { + "path": "research/t74-joint-twelve/inputs/FILL.json.gz", + "usage": "provenance", + "git_blob": "17129e917b31b15625c53181d303b68e17ffed55", + "sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1" + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/TASK.json b/research/tensor-block-kappa/vendor/frontier/TASK.json new file mode 100644 index 0000000000..61c622f03f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/TASK.json @@ -0,0 +1,82 @@ +{ + "schema_version": 1, + "task_id": "selected-packing", + "priority_revision": 5, + "base_commit": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "original_card": { + "id": "selected-packing", + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ], + "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." + ], + "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.", + "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." + }, + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "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." + ], + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ] + }, + "task_classification": "Explicit coordinator assignment (joint retired-lender / lender assignment on our local retired5 words, every existing hosting movable), not a random card draw.", + "scope_status": "changed", + "actual_scope": "Extended retired-lender census on the retired5 words (PR2751 + five retired-lender aliases) treating every existing B-warp hosting as movable; two hostee moves (warps 30/31: 401->564, 403->565) with exact refits enable two more PR2679-type aliases 667<-401, 669<-403; certified frames; compacted owner fill; complete release through PR2751's own full replay.", + "scope_change_reason": "No retired lender with frame floor <= 5 retires before the four remaining rank-4 followers enter, but 24 hosted lenders do once their hostees move to the two free floor-5 lenders 564/565, which retire before the hostees enter; an exact one-rank refit of those lenders' last gates makes the moves and two more aliases feasible.", + "bottleneck_link": "Removing two more width-5 helpers per call frees 1332 hosted cells as idle 5-remainders while the certified frames merge jumps (local {1:-4,2:+6,3:-6}); the paid moment drops and the complex endpoint rises by 3.86e-7 over retired5 (6.53e-7 over PR2751, 5.38e-7 over PR2766/PR2767).", + "stop_rule": "One explicit pair of hostee moves and two aliases on both providers after an exact augmenting-path census (192 paths, at most two extra aliases); no exhaustive search over other mechanisms claimed. Stop after complete release and handoff.", + "declared_milestone": "Integrated conditional kappa, subject to the inherited all-size/interface/analytic assumptions.", + "obligation_ledger": { + "native_words": "Two new words; fresh five-stage native runs passed; PR2679/PR2751 and retired5 stage controls retained and the new refit7/hostmove2/alias7/refit7c stages carry their own tamper controls (retired7_controls.py).", + "physical_hosting": "Complete literal owner fill (271728 roles, R 408) checked by reconstruct.py and the independent integer-chronology/bit-mask checker.", + "supplier_and_outer": "Discovery/unpin/freeze, strict T74 replay and the package's own verify_release.py passed in the full cold release.", + "inherited": "All universal obligations of PR2751 and its lineage are inherited unchanged." + }, + "family_expansion_decision": "Explicit request to improve the latest pending construction; the retired-lender alias family (PR2679) is extended by an exact refit census on the new words, not reopened unchanged.", + "outcome": "completed", + "evidence": "Full cold release (four fresh native providers, retained parent, complete admission, PASS_RELEASE) and registered hook (seven-stage rebuild, pinned PR2679 auditor on eight states, 142 tamper controls, literal owner fill, exact 1e-24 bracket, 80-digit root, kappa above PR2751, PR2766, PR2767). Evidence in evidence/retired7.", + "author": "Marius-Paul Dumitrean (@mdumitrean)", + "ai_assistance": "Substantial AI assistance (Anthropic Claude, via Claude Code) in the census, augmenting-path search, pricing, stage construction, checker adaptations, certification runs and documentation. No independent human review or formal theorem claimed.", + "open_questions": [ + { + "question": "Can a gate-level (kernel) edit make the rank-1-entrance followers alias-feasible?", + "why_it_matters": "The 48 rank-1 followers are width-8 helpers (about 1e-6 relaxed value each), but every lender's exact frame floor is at least rank 4.", + "first_step": "Price single-gate kernel edits that lower one candidate lender's retirement frame floor below rank 2, with the auditor and native chain.", + "blocked_by": "No retired lender reaches rank <= 1 under any refit of the fixed gate lists." + }, + { + "question": "Can a third free floor-5 lender be opened for followers 670 and 671?", + "why_it_matters": "Each further width-5 alias of this kind priced about +1.9e-7 here.", + "first_step": "Search frame refits or gate moves that lower a free lender's floor to rank 5 with retirement before B941.", + "blocked_by": "Only 564 and 565 are free lenders with floor <= 5; both now host the moved warps." + }, + { + "question": "Do the retired5 and retired7 stages stack with PR2767's post-cut partner correction?", + "why_it_matters": "Both improve PR2751 independently; a stack could add their gains.", + "first_step": "Apply the seven stages to PR2767's words and re-run the census and the certified frames.", + "blocked_by": "PR2767's words differ from PR2751's; the stage inputs are word-specific." + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/VERIFY.json b/research/tensor-block-kappa/vendor/frontier/VERIFY.json new file mode 100644 index 0000000000..a4c9fb33d0 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/VERIFY.json @@ -0,0 +1,50 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Literal review: PR2751 construction reproduced, the seven declared stages (retired5 refit5/alias5/refit5c, retired7 refit7/hostmove2/alias7/refit7c) rebuild both candidate words, candidate fill = declared compaction (seven removed helpers), independent symbolic/frame/cleanup checks with six mutations, literal owner fill (R 408) with one mutation, exact adjacent root bracket, claim binding and strict improvement over PR2733, PR2745, PR2751, PR2766 and PR2767." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify_retired7.py" + ], + "timeout_seconds": 300, + "checks": "Seven-stage structure, the pinned PR2679 auditor on all eight states, 142 tamper controls (retired5: lender refit undone by warp frame mismatch, follower raise undone, 35 alias mutations, corrupted certified frame; retired7: new-lender refit undone by warp frame mismatch, 4 controls per hostee move, the PR2679 alias suite per new alias, corrupted certified frame; every mutant re-derives its cleanup and must be rejected for a real reason), literal owner fill (R 408), 80-digit root and kappa = C - 1e-46 - 1e-70 above PR2751, PR2766 and PR2767." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/packing_cap.py" + ], + "timeout_seconds": 120, + "checks": "Pinned generic coverage-law ceiling and realized fraction for the candidate, not a sharp packing optimum." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_integrity.py" + ], + "timeout_seconds": 300, + "checks": "Git-free read-only relocation; altered claim/input and optimized execution refusals." + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/composition.py b/research/tensor-block-kappa/vendor/frontier/composition.py new file mode 100644 index 0000000000..bb455e907d --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/composition.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Deterministic PR2673 priority-fill / PR2679 pre-life-word composition. + +No solver and no native execution. Match helper indices in increasing order +within each width queue, delete seven surplus width-4 roles per call, then +compact each physical bin. Helper indices are width-registry positions, not +register identities. Final whole-call geometry is checked separately by both +literal implementations in verify.py; full_replay.py binds actual natives. + +Credit Jeremy Kothe's PR2673 fill and PR2621's priority scheduling idea, +PR2679's pre-life/refit words, PR2588/PR2530 and retained supplier lineage. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys +sys.dont_write_bytecode = True + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def transform(old, new, fill, order, initial_dispatch, words): + """Reconstruct the full candidate and mapping from authenticated inputs.""" + need(set(old) == set(new) == set(words) == {'gauge44', 'extra'}, 'provider identities') + need(len(order) == 666 and len(set(map(tuple, order))) == 666, 'composition call count') + need(len(fill['rows']) == 281052, 'source role count') + dispatch = dict(initial_dispatch) + for s, r, pid in fill['dispatch_overrides']: + need((s, r) in dispatch and pid in new, 'source dispatch override') + dispatch[s, r] = pid + need(set(dispatch) == set(map(tuple, order)), 'source dispatch coverage') + maps, dropped, bindings = {}, {}, {} + for pid in sorted(new): + oldq, newq = defaultdict(list), defaultdict(list) + for i, width in enumerate(old[pid]['widths']): + oldq[width].append(i) + for i, width in enumerate(new[pid]['widths']): + newq[width].append(i) + need(len(old[pid]['widths']) == 422 and len(new[pid]['widths']) == 415, 'old/new helper counts') + need(set(oldq) == set(newq) == {4, 5, 7, 8, 9}, 'width support') + need({w:len(oldq[w])-len(newq[w]) for w in oldq} == {4:7, 5:0, 7:0, 8:0, 9:0}, 'seven surplus width-4 roles') + maps[pid] = {i:j for w in sorted(newq) for i,j in zip(oldq[w], newq[w])} + dropped[pid] = sorted(set(range(422)) - set(maps[pid])) + need(len(maps[pid]) == 415 and set(maps[pid].values()) == set(range(415)), 'new helper bijection') + need(all(old[pid]['widths'][i] == new[pid]['widths'][j] for i,j in maps[pid].items()), 'width-preserving bijection') + need(len(dropped[pid]) == 7 and all(old[pid]['widths'][i] == 4 for i in dropped[pid]), 'deleted widths') + # This binds declared widths/report to the raw word, without claiming + # that reading its report proves the actual native program semantics. + word = words[pid] + remaining = [r for r in range(224, 704) if r not in set(word['removed'])] + final = {int(k):v for k,v in word['helper_final'].items()} + extra = {int(k):v for k,v in word['start_extra'].items()} + actual = [len(final.get(r, range(9))) - len(extra.get(r, [])) for r in remaining] + need(actual == new[pid]['widths'], 'raw-word ordered width binding') + need(word['report']['local_profile'] == new[pid]['actual_paid_profile'], 'raw-word reported profile binding') + bindings[pid] = dict(helpers=len(remaining), + width_inventory=dict(sorted(Counter(actual).items()))) + rows, removed, bins, oldbins, per_call = [], [], defaultdict(list), defaultdict(list), defaultdict(set) + for i, row in enumerate(fill['rows']): + need(len(row) == 6 and all(type(v) is int for v in row), 'source role shape') + t, h, owner, child, port, offset = row + need(0 <= t < 666 and 0 <= h < 422, 'source role bounds') + need(h not in per_call[t], 'source duplicate helper') + per_call[t].add(h) + pid = dispatch[tuple(order[t])] + oldbins[owner, child, port].append(old[pid]['widths'][h]) + if h not in maps[pid]: + removed.append((owner, child, port)) + continue + bins[owner, child, port].append(len(rows)) + rows.append([t, maps[pid][h], owner, child, port, offset]) + need(set(per_call) == set(range(666)) and all(x == set(range(422)) for x in per_call.values()), 'source helper coverage') + need(len(removed) == 4662 and len(set(removed)) == 4662, '4662 distinct affected bins') + need(all(sorted(oldbins[key]) == [4, 9, 9, 9] for key in removed), 'source deletion-bin patterns') + for indices in bins.values(): + offset = 0 + for i in sorted(indices, key=lambda j:rows[j][5]): + row = rows[i] + row[5] = offset + offset += new[dispatch[tuple(order[row[0]])]]['widths'][row[1]] + need(len(rows) == 276390, 'composed role count') + candidate = dict(fill, rows=rows) + mapping = dict(keep_maps=maps, dropped=dropped) + report = dict(status='PASS_DETERMINISTIC_WIDTH_QUEUE_COMPOSITION', removed_roles=4662, + affected_bins=4662, source_bin_widths=[4, 9, 9, 9], remaining_bin_widths=[9, 9, 9], + roles=len(rows), calls=666, helpers_per_call=415, width_bindings=bindings, + fill_canonical_sha256=hashlib.sha256(canonical(candidate)).hexdigest()) + return candidate, mapping, report + + +def check(data): + obj = data['objects'] + original_order = obj['source/pr2673/ORDER.json'] + initial = {(s,r):p for s,r,p in obj['source/pr2673/DISPATCH.json.gz']} + need(initial == data['dispatch'], 'unchanged source dispatch') + candidate, mapping, report = transform( + obj['source/pr2673/PROVIDERS.json'], data['providers'], + obj['source/pr2673/FILL.json.gz'], original_order, initial, + {'gauge44':obj['source/pr2679/WORD-base.json.gz'], 'extra':obj['source/pr2679/WORD-extra.json.gz']}) + need(data['candidate_order'] == original_order, 'unchanged priority order') + need(candidate == data['candidate_fill'], 'complete deterministic candidate equality') + need(json.loads(canonical(mapping)) == obj['candidate/MAPPING.json'], 'complete deterministic mapping equality') + report['mapping_canonical_sha256'] = hashlib.sha256(canonical(json.loads(canonical(mapping)))).hexdigest() + return report diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/ADMISSION.json b/research/tensor-block-kappa/vendor/frontier/evidence/ADMISSION.json new file mode 100644 index 0000000000..df8d10716f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/ADMISSION.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "1717141586348426338109/1000000000000000000000000", + "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "gain": "6257252193655137/6250000000000000000000", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "native_receipt_sha256": "c33bf92fccb63f4d9a3ff6f7e025ac831ad012dd92d236b0f046bc4b1c6a29b2", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "32": 1, + "4": 79920, + "48": 26558, + "5": 22532, + "8": 5328 + }, + "release_receipt_sha256": "5839b3b3448d67d7a936fe962298d7d77cb83ee489321343af7769166f5d0142", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/reconstruct.py", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/owners" + ], + "exit_code": 0, + "log_sha256": "ea77455da769b04c89d99695cb56a77c635a8ff46c760b826bf79e9689baa3db", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 7.02489157000673 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/lift_parent.py", + "--owners", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/owners", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 10.359581939002965 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/new/rebind.py", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "2bebde6c85961ee26457f1a7d2fe6e6672a95aeebcd81194c7ecf30804f6346b", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 1.542834171996219 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/layout/packing74/replay.py", + "--data", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/layout/packing74/candidate", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/discovery", + "--local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "7259104fe82131c1dd33d27a26f074197ddae0190425675ba761a62c8155de98", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 117.20071977899352 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "b148cd9ee46327427df78e9e351d4d7144b62dc180fae092d82c8e51bf62b2cd", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.08087540300039109 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "edfd0610e9edc82ff330651fed281fb6e5f3b8dec5a3e48feea760009ae3c21a", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.07375459698960185 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/package/verify_release.py", + "--main", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/source-fixed", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/admission/release", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "94711a507533c0e2cb36f1f9fb66dfb4f06957aa76f4f83b667e1e4e5260661f", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 395.8588478729944 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/INDEPENDENT.json b/research/tensor-block-kappa/vendor/frontier/evidence/INDEPENDENT.json new file mode 100644 index 0000000000..750227462f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/INDEPENDENT.json @@ -0,0 +1,662 @@ +{ + "source_checker_sha256": "ab384bca6be86e5cef39b88c313113a33b4c225534f833d8fcd97b9de58cfd53", + "providers": { + "base": { + "profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "section_profiles": { + "A": { + "1": 924, + "2": 24, + "4": 56 + }, + "cut": { + "8": 8 + }, + "B": { + "1": 1078, + "2": 510, + "4": 64, + "3": 226, + "5": 26 + }, + "restore": { + "1": 47, + "2": 38, + "3": 8 + }, + "ends": { + "1": 317, + "2": 74, + "3": 63 + } + }, + "inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "center_paths": [ + { + "center": 92, + "start_rank": 8, + "target_offsets": [ + 12, + 100, + 103, + 17, + 72, + 94, + 70, + 62, + 101, + 54, + 18, + 40, + 0, + 57, + 98, + 48, + 45, + 107, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 57, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 72, + 94, + 70, + 62, + 83, + 73, + 59, + 30, + 0, + 57, + 80, + 67, + 8, + 95, + 68, + 5, + 96, + 64 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 81, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 12, + 100, + 103, + 17, + 101, + 54, + 18, + 40, + 83, + 73, + 59, + 30, + 27, + 7, + 13, + 16, + 15, + 42 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 224, + "start_rank": 8, + "target_offsets": [ + 27, + 7, + 98, + 48, + 45, + 107, + 80, + 67, + 8, + 95, + 13, + 16, + 15, + 42, + 68, + 5, + 96, + 64, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 11, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 56, + 31, + 38, + 77, + 91, + 10, + 36, + 20, + 32, + 85, + 24, + 35, + 3, + 88, + 66, + 26, + 53, + 105 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 240, + "start_rank": 8, + "target_offsets": [ + 91, + 10, + 102, + 55, + 19, + 39, + 84, + 74, + 60, + 29, + 36, + 20, + 53, + 105, + 69, + 4, + 97, + 65, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 9, + "start_rank": 8, + "target_offsets": [ + 56, + 31, + 38, + 77, + 89, + 79, + 84, + 74, + 60, + 29, + 111, + 46, + 3, + 88, + 66, + 26, + 51, + 44, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 256, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 89, + 79, + 102, + 55, + 19, + 39, + 111, + 46, + 32, + 85, + 24, + 35, + 51, + 44, + 69, + 4, + 97, + 65 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + } + ], + "cleanup": 4540, + "algebra": { + "forward": "PASS", + "dual": "PASS" + }, + "rejecting_controls": [ + "drop_anticipatory", + "reverse_anticipatory", + "drop_source_restoration" + ] + }, + "extra": { + "profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "section_profiles": { + "A": { + "1": 924, + "2": 24, + "4": 56 + }, + "cut": { + "8": 8 + }, + "B": { + "1": 1078, + "2": 510, + "4": 64, + "3": 226, + "5": 26 + }, + "restore": { + "1": 47, + "2": 38, + "3": 8 + }, + "ends": { + "1": 317, + "2": 74, + "3": 63 + } + }, + "inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "center_paths": [ + { + "center": 92, + "start_rank": 8, + "target_offsets": [ + 12, + 100, + 103, + 17, + 72, + 94, + 70, + 62, + 101, + 54, + 18, + 40, + 0, + 57, + 98, + 48, + 45, + 107, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 57, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 72, + 94, + 70, + 62, + 83, + 73, + 59, + 30, + 0, + 57, + 80, + 67, + 8, + 95, + 68, + 5, + 96, + 64 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 81, + "start_rank": 8, + "target_offsets": [ + 6, + 82, + 93, + 58, + 12, + 100, + 103, + 17, + 101, + 54, + 18, + 40, + 83, + 73, + 59, + 30, + 27, + 7, + 13, + 16, + 15, + 42 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 224, + "start_rank": 8, + "target_offsets": [ + 27, + 7, + 98, + 48, + 45, + 107, + 80, + 67, + 8, + 95, + 13, + 16, + 15, + 42, + 68, + 5, + 96, + 64, + 49, + 34, + 108, + 22 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 11, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 56, + 31, + 38, + 77, + 91, + 10, + 36, + 20, + 32, + 85, + 24, + 35, + 3, + 88, + 66, + 26, + 53, + 105 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 240, + "start_rank": 8, + "target_offsets": [ + 91, + 10, + 102, + 55, + 19, + 39, + 84, + 74, + 60, + 29, + 36, + 20, + 53, + 105, + 69, + 4, + 97, + 65, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 9, + "start_rank": 8, + "target_offsets": [ + 56, + 31, + 38, + 77, + 89, + 79, + 84, + 74, + 60, + 29, + 111, + 46, + 3, + 88, + 66, + 26, + 51, + 44, + 50, + 33, + 109, + 23 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + }, + { + "center": 256, + "start_rank": 8, + "target_offsets": [ + 75, + 1, + 28, + 86, + 89, + 79, + 102, + 55, + 19, + 39, + 111, + 46, + 32, + 85, + 24, + 35, + 51, + 44, + 69, + 4, + 97, + 65 + ], + "reader_lines": [ + [] + ], + "paid_degrees": [ + 8 + ] + } + ], + "cleanup": 4540, + "algebra": { + "forward": "PASS", + "dual": "PASS" + }, + "rejecting_controls": [ + "drop_anticipatory", + "reverse_anticipatory", + "drop_source_restoration" + ] + } + }, + "status": "PASS_INDEPENDENT_LOCAL_COMPOSITION_WITH_CONTROLS" +} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-BASE.json b/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-BASE.json new file mode 100644 index 0000000000..fd79ad2f2a --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-BASE.json @@ -0,0 +1,27 @@ +[ + { + "step": "native", + "exit_code": 0, + "seconds": 1.093574318991159 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 1.2534982020006282 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 36.74402106899652 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 6.469144934992073 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 284.8359740910091 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-EXTRA.json b/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-EXTRA.json new file mode 100644 index 0000000000..930bbf3cd1 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/NATIVE-EXTRA.json @@ -0,0 +1,27 @@ +[ + { + "step": "native", + "exit_code": 0, + "seconds": 1.1837458390073152 + }, + { + "step": "ledgers", + "exit_code": 0, + "seconds": 1.2502824249968398 + }, + { + "step": "local-replay", + "exit_code": 0, + "seconds": 38.17951157900097 + }, + { + "step": "wrappers", + "exit_code": 0, + "seconds": 6.418584338010987 + }, + { + "step": "phases", + "exit_code": 0, + "seconds": 281.4837235180021 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/OWNERS.json b/research/tensor-block-kappa/vendor/frontier/evidence/OWNERS.json new file mode 100644 index 0000000000..00ff9fe9e4 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/OWNERS.json @@ -0,0 +1,26 @@ +{ + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 276390, + "calls": 666, + "helpers_per_call": 415, + "windows": 1332, + "window_sha256": "d301aa0d102381aecc3dd746c424d55ea6f4ade9f87b833c8db6d643e205c846", + "idle": { + "1": 17316, + "3": 6594, + "5": 5216, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "rank_mass": 4816512 +} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/PACKING-CAP.json b/research/tensor-block-kappa/vendor/frontier/evidence/PACKING-CAP.json new file mode 100644 index 0000000000..e304fa1a3a --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PACKING-CAP.json @@ -0,0 +1,25 @@ +{ + "status": "PASS_FIXED_WORD_PACKING_CEILING", + "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "local_per_call": { + "1": "2366", + "2": "646", + "3": "297", + "4": "120", + "5": "26", + "8": "8" + }, + "dimension": 73, + "families": 896, + "stages": 9, + "centre_rank_per_call": 64, + "max_idle_rank": 51, + "complex_cap_bracket": [ + "1750373331783/1000000000000000", + "218796666473/125000000000000" + ], + "complex_cap_upper_decimal": "0.001750373331784", + "realized_fraction_lower": "1717141586348426338109/1750373331784000000000", + "realized_fraction_decimal": "0.98101448140683022362961556380933079811273967260851", + "scope": "Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/PR2733-CLAIM.json b/research/tensor-block-kappa/vendor/frontier/evidence/PR2733-CLAIM.json new file mode 100644 index 0000000000..e97166d501 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PR2733-CLAIM.json @@ -0,0 +1,75 @@ +{ + "status": "PASS_COMPLETE_CONDITIONAL_COMPOSITION", + "kappa": "17161404259974415161889999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017161404259974415161889999999999999999999998999999999999999999999999", + "complex_lower": "1716140425997441516189/1000000000000000000000000", + "complex_upper": "171614042599744151619/100000000000000000000000", + "global_profile": { + "1": 1595736, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "7": 2664, + "8": 2664, + "32": 1, + "48": 26558 + }, + "local_profile": { + "1": 2370, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "7": 4, + "8": 4 + }, + "comparison": { + "pr": 2696, + "head": "5a42add713e09a8798a84d0be7a8276626d9e785", + "kappa": "1715599770234969498857/1000000000000000000000000" + }, + "gain": "5406557624720173319999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "gain_percent": "0.0315140962275816123491750493328909085601430052934617650373906", + "helpers": 415, + "calls": 666, + "roles": 276390, + "private_zero_buffers": 72, + "live": 66304, + "physical": 66801, + "rank_mass": 4816512, + "full_receipt": "evidence/full/RESULT.json", + "full_receipt_sha256": "5fdf5db9538e113011ed8f9a6b824658fa21e0444f51e9256521d0c9ad585c68", + "source2679_head": "2e2cf56521df8a2b816b2689144765ee00b69a24", + "source2679_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba", + "source2696_head": "5a42add713e09a8798a84d0be7a8276626d9e785", + "candidate_manifest_sha256": "f9b8b8cbed9e55b32d821c50ab76fef0afb1466f29d11204254fb50d2533e680", + "coverage": { + "current_stages": 18, + "retained_parent_stages": 18, + "strict_steps": 8, + "supplier_inequalities": 47, + "modern_inequalities": 63, + "modern_negative_controls": 17, + "evidence_replays": 19, + "admission_controls": 114, + "bit_controls": 12, + "current_controller_mutations": 25, + "independent_owner_controls": 8, + "geometry_controls": 6, + "prelife_mutations_per_provider": 78, + "alias_mutations_per_provider": 7, + "native_recipe_mutations_per_provider": 13, + "dirty_columns_each_orientation": 639, + "native_operator_count": 65, + "native_physical_classes": 166, + "native_columns_per_class": 512, + "ordinary_sufficient_stages": 37 + }, + "native_and_parent_receipt_reuse": false, + "inherited_parent_geometry_reuse": true, + "selected_main_changed": false, + "human_review": false, + "proof_assistant_verified": false, + "scope": "Finite conditional construction and exact outer inequalities; inherited all-size, machine, analytic and bit assumptions remain." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/PR2745-CLAIM.json b/research/tensor-block-kappa/vendor/frontier/evidence/PR2745-CLAIM.json new file mode 100644 index 0000000000..abec1247c3 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PR2745-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017161404259974415161896013041594543449983294017148473346276661102545764922636862044436515522027985344855150098983775041629263547163125251675447485565747834806239987578441798524484107323821701155622513700644347867401071725594568449315612515905509495884766777581839230346402338825584407497351281622158523841356428865401099338720394236958852711790336260146409872571430665117721061110787229662189541453346975519235175074214477852592724575176166998622326679703333110937366407386120214229951631808518138363267905219813176599566097495754886721517267608875850230494908103506213162350791792331441348765518613305970280449654319065477042690202246342215539071518651408763289495785152089370669825080936842027153325568738439807598194885970251801409980086488948376188447193890829832107433406905825705915805396663182725240672176836077304022063208695113974303331915673309845548803340773541582855377159749875816944631212718991851923170152142435905798890231819219511903192222342830815515007978720397740590172699682116121332914982675237191807778248656942621543376826831174051827492854427715467348053277451337090533404165485527518485679836878102147066380869160639898847390703384489759823584393568428907697605006663034567580331614359947761732591931622309384133441737507681841821011957259754052851823112401129848773767009687002041129258012185486237367939005884767039702540144053399361647325610251525609642619783749057193121726684680919138377929721804998916785273913752644037950482372045322071573538992195433777074257109555074353721999902013276517157169940561568178386620728836049772478450854453389987158727572804602321996019260738152156757161348267887911191286780813615476385696509733698463920053360075825699816566817800871673208690336294749647427947527499679407036440023012434171281046642426063654970939957181652265529443590787097461531801386011463743969975862780264085637768256289418782679823530263960075114664371507347732276812969864267561045514124389130733313432877811559115885025512526570171968931566958796992173385070063858597422249224774059391355832669440787433006251720806671766291989349470710554806666610191428287150962949669966874896220499275076889892936459607089678667559585864417586998756676345103422137383436139164074064413916005285172972434222534980758037678651337185451875937225517472532035922749947894047044307464181536443210914044182443803479301179986710313174104876273478382938568847726302351705419077804666452283789684993513210200088330639281177607666875663921738211690621348879356694620400978434606801942412927215162093602305185615637438642656133240614451101846652516809817309035289035489847973460879066277497551043498065469308439704045371771254463714675858553654131998769759361591778931496023325741201834604057378735990243836231494186018058285686722518542636221903820347998951060107655579200518923393481166710944469301744664814911217117960681084006650202202241059630268904883784070678343948707778708019904797605161781920696887549836082383733184920473162729765214804978776850316187016051529352187958399999999999999999999998999999999999999999999999", + "kappa_rational": "17161404259974415161896013041594543449983294017148473346276661102545764922636862044436515522027985344855150098983775041629263547163125251675447485565747834806239987578441798524484107323821701155622513700644347867401071725594568449315612515905509495884766777581839230346402338825584407497351281622158523841356428865401099338720394236958852711790336260146409872571430665117721061110787229662189541453346975519235175074214477852592724575176166998622326679703333110937366407386120214229951631808518138363267905219813176599566097495754886721517267608875850230494908103506213162350791792331441348765518613305970280449654319065477042690202246342215539071518651408763289495785152089370669825080936842027153325568738439807598194885970251801409980086488948376188447193890829832107433406905825705915805396663182725240672176836077304022063208695113974303331915673309845548803340773541582855377159749875816944631212718991851923170152142435905798890231819219511903192222342830815515007978720397740590172699682116121332914982675237191807778248656942621543376826831174051827492854427715467348053277451337090533404165485527518485679836878102147066380869160639898847390703384489759823584393568428907697605006663034567580331614359947761732591931622309384133441737507681841821011957259754052851823112401129848773767009687002041129258012185486237367939005884767039702540144053399361647325610251525609642619783749057193121726684680919138377929721804998916785273913752644037950482372045322071573538992195433777074257109555074353721999902013276517157169940561568178386620728836049772478450854453389987158727572804602321996019260738152156757161348267887911191286780813615476385696509733698463920053360075825699816566817800871673208690336294749647427947527499679407036440023012434171281046642426063654970939957181652265529443590787097461531801386011463743969975862780264085637768256289418782679823530263960075114664371507347732276812969864267561045514124389130733313432877811559115885025512526570171968931566958796992173385070063858597422249224774059391355832669440787433006251720806671766291989349470710554806666610191428287150962949669966874896220499275076889892936459607089678667559585864417586998756676345103422137383436139164074064413916005285172972434222534980758037678651337185451875937225517472532035922749947894047044307464181536443210914044182443803479301179986710313174104876273478382938568847726302351705419077804666452283789684993513210200088330639281177607666875663921738211690621348879356694620400978434606801942412927215162093602305185615637438642656133240614451101846652516809817309035289035489847973460879066277497551043498065469308439704045371771254463714675858553654131998769759361591778931496023325741201834604057378735990243836231494186018058285686722518542636221903820347998951060107655579200518923393481166710944469301744664814911217117960681084006650202202241059630268904883784070678343948707778708019904797605161781920696887549836082383733184920473162729765214804978776850316187016051529352187958399999999999999999999998999999999999999999999999/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": "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/tensor-block-kappa/vendor/frontier/evidence/PR2751-CLAIM.json b/research/tensor-block-kappa/vendor/frontier/evidence/PR2751-CLAIM.json new file mode 100644 index 0000000000..48ad23a430 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PR2751-CLAIM.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE", + "complex_lower": "0.001717141586348426338109", + "complex_upper": "0.001717141586348426338110", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": 2733, + "comparison_head": "2761b52b17590b8cf94f2e410004a8252d5592dc", + "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.", + "latest_comparison": { + "pr": 2745, + "head": "4f485de05544884fa0f2edf6063bb9259decad30", + "exact_claim": "evidence/PR2745-CLAIM.json" + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/PR2766-CLAIM.json b/research/tensor-block-kappa/vendor/frontier/evidence/PR2766-CLAIM.json new file mode 100644 index 0000000000..d352e67b80 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PR2766-CLAIM.json @@ -0,0 +1,26 @@ +{ + "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA", + "complex_lower": "0.001717256973467002308270", + "complex_upper": "0.001717256973467002308271", + "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999", + "profile": { + "1": 1591740, + "2": 430902, + "3": 204396, + "4": 79920, + "5": 22532, + "8": 5328, + "32": 1, + "48": 26558 + }, + "comparison_pr": 2751, + "comparison_head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69", + "comparison_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "absolute_gain": "115387118575970161/1000000000000000000000000", + "relative_gain": "1153871185759701610000000000000000000000000000000000000000000000/17171415863484263381089999999999999999999998999999999999999999999999", + "relative_gain_percent_decimal": "0.006719720697076920262999344663512072867487887126182086416724216655132904", + "credited_refit_pr": 2733, + "credited_refit_head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a", + "scope": "New composition of the credited PR2733 frame refit with PR2751 joint twelve-source recovery. Complete finite native, supplier and modern outer release passed; inherited universal hypotheses and selected frontier unchanged." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/PR2767-OUTER-CLAIM.json b/research/tensor-block-kappa/vendor/frontier/evidence/PR2767-OUTER-CLAIM.json new file mode 100644 index 0000000000..2bb218a750 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PR2767-OUTER-CLAIM.json @@ -0,0 +1,10 @@ +{ + "kappa": "0.0017172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999", + "kappa_rational": "17172569734670023082709447969069152126118769780965028281008777096022519916744024507755781541393565107541777345616367652506197068005633337706659261256966375316821124413350346601705176280553912235149970753181426298001293678362122690855686275720239412792316093597276141944155457489339446224311536862711549926054504931270560356314999015644110485022254405640527426463064952462185589768355732358008424134781124147412002557999341130922954560743011637806547436549181955782473753496979703362588896807515818466546937711049279980942794048991491326287505803399514341852820837943067785939680385921588672688420201433278727269345703864690376991542653902864701881652568311532870078191785893592410790571289085509481502003170258982906991486560315611931860697467696290292055253082068400551006212099824229936930413663128901131121759917302246165771388714185911541104549988804338712295071202096399100335791126922173037775327463059771433440926266880163896249389966745756271553563709591781001439768394342152913377499665536820868707787226505884376108228421715755450623096661691184454221995927505823408578749208545463740410015863275806178269842001719301762674785169518465683571440572993799589490631487105886295095493149586094319859314875095378861401422556789940186941047005736880403188010645106677026296918442629431903843644855362525736842630354486796094857852734997386028457768569824115555112581868166739336167277381787859006062432028767244521059628397246359398320786429319939420672411083838467729316208932075333803830898035322664949004091568509869438186415465161733566756555736356233923851918780823353640473134174987172652099048421354257100239255942629158502164301318171598492065833037847549681946684768605491450323194076412999983215955509460578326463064191168457600338240713840193411472575547950797115245206022145794895788468041089449169787357317266308048623204566140235628233017090878916323527128156264726328354041412616033952419944700431126936863322584716859502347695311920748466005526768515925854102406706307520896865670601578650767111842955685088409462542848610347972939615154323284480230135034841876444061631325858729157683020840589884429004551623552818746676680914576485067803186939296066606405395766033283905684054983159064863223300983125666776604195695852034071159764621179219686754472092896427897404874394357914200560727383691925322278679456774883229095577135736844500900384756502718708923562610023580899942766723533449198010932258174758894762374984951419979309148647906675840732792544402297243181446952503231023897790927353688424025440209475595384587082902426402767980019136142593982138839226181846487690619361976037727824614860473865262796331567734540250992369604076843182445798287538318092729802017130103545991079143478304625081199840311512857747798081094366427632011938791580334466991754850298586038018016640436196908298039209188887977906075656186932051633274060946735331678245512576959516444591775914847982031747835727960828045213036341689251316473265483110696205040246018249882524641792097396874190897482609999999999999999999998999999999999999999999999/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": "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/tensor-block-kappa/vendor/frontier/evidence/PUBLIC-WRAPPER.json b/research/tensor-block-kappa/vendor/frontier/evidence/PUBLIC-WRAPPER.json new file mode 100644 index 0000000000..e705eabcff --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/PUBLIC-WRAPPER.json @@ -0,0 +1,221 @@ +{ + "cold_seconds": 543.6799636979995, + "cold_stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/verify.py" + ], + "exit_code": 0, + "log_sha256": "fdbe439b439749750ed8d662d003744807c114453487bc07699dd997bbeb3786", + "name": "literal-review", + "script_sha256": "3dfcdde58f1695878668f140efc512fc06c2a30c70c78b65334a15e81844f213", + "seconds": 8.92684423099854 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/workflow/admit.py", + "--source", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/source", + "--fill", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/inputs/FILL.json.gz", + "--order", + "/home/zoe/MP/maths/mult/integer-mult-joint12/research/t74-joint-twelve/inputs/ORDER.json", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache", + "--native-receipt", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/NATIVE-RECEIPT.json", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "77e1a3852e31ca96cc7b7050bfe6f4876bb74db16aa8bbb901c92872344cd014", + "name": "complete-admission", + "script_sha256": "f0d510b46a5f05b033b13fecb706389ab374b783bd46ef30e7386195d9e56d3e", + "seconds": 534.4106610509916 + } + ], + "complex_lower": "1717141586348426338109/1000000000000000000000000", + "environment": { + "executable": "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.5.4", + "scipy": "1.18.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": true, + "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1", + "gain": "6257252193655137/6250000000000000000000", + "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "native_receipt_sha256": "c2559bc69911798aeb62a49aef185c0aaf28e48ad2b08041b76ee8478d27dd5c", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1593072, + "2": 430236, + "3": 204396, + "32": 1, + "4": 79920, + "48": 26558, + "5": 22532, + "8": 5328 + }, + "release_receipt_sha256": "7e6114c63c133769c21ea79bb13a5cd96fe6ba0ef6a9389ea91ed1f1d206a5a4", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf", + "stages": [ + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/reconstruct.py", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/owners" + ], + "exit_code": 0, + "log_sha256": "ea77455da769b04c89d99695cb56a77c635a8ff46c760b826bf79e9689baa3db", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 7.053403829995659 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/lift_parent.py", + "--owners", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/owners", + "--out", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 10.136882726001204 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/new/rebind.py", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127/local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "2bebde6c85961ee26457f1a7d2fe6e6672a95aeebcd81194c7ecf30804f6346b", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 1.5739846880023833 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/layout/packing74/replay.py", + "--data", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/layout/packing74/candidate", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/discovery", + "--local", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache/ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "7259104fe82131c1dd33d27a26f074197ddae0190425675ba761a62c8155de98", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 116.71028798099724 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "b148cd9ee46327427df78e9e351d4d7144b62dc180fae092d82c8e51bf62b2cd", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.07842145599715877 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "edfd0610e9edc82ff330651fed281fb6e5f3b8dec5a3e48feea760009ae3c21a", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.05850559000100475 + }, + { + "command": [ + "/home/zoe/MP/maths/mult/seed39-runtime/bin/python", + "-B", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/package/verify_release.py", + "--main", + "/home/zoe/MP/maths/mult/t74-joint12-experiment", + "--work", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/admission/release", + "--native-cache", + "/home/zoe/MP/maths/mult/t74-joint12-experiment/public-wrapper/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "94711a507533c0e2cb36f1f9fb66dfb4f06957aa76f4f83b667e1e4e5260661f", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 397.45473003099323 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/RELEASE.json b/research/tensor-block-kappa/vendor/frontier/evidence/RELEASE.json new file mode 100644 index 0000000000..e44dc7c69b --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/RELEASE.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017171415863484263381089999999999999999999998999999999999999999999999", + "manifest_sha256": "132012fcd14ae053c0ad8525537af3a5d2297ce6a3dcda64b65e46abc79f7f8a", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 1717141586348426338109/1000000... brackets the ledger's b = 171714158634842633810899999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017171415863484263381089999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 395.76 +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-RESULT.json new file mode 100644 index 0000000000..51fc187607 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-RESULT.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "214676164541936455431/125000000000000000000000", + "fill_sha256": "3501f6bd9d56d9da9fdc912d957d08077434525a804bb647df1e630fc30b6a3f", + "gain": "1268890338050127259/1000000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "native_receipt_sha256": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "release_receipt_sha256": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-STAGES.json new file mode 100644 index 0000000000..a5d5bc1130 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/ADMISSION-STAGES.json @@ -0,0 +1,111 @@ +[ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CERT2751.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CERT2751.json new file mode 100644 index 0000000000..dde7a0f3d0 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CERT2751.json @@ -0,0 +1,199 @@ +{ + "target": "PR2751 (tekuuu, head 4cfbb0cc) words + five retired-lender aliases 606<-550, 635<-551, 637<-552, 638<-553, 639<-562", + "census": { + "followers": 57, + "lenders": 409, + "live_pairs": 3747, + "fixed_ok": 0, + "refit_ok": 35, + "helpers": [ + 606, + 635, + 637, + 638, + 639 + ], + "lenders_ok": [ + 550, + 551, + 552, + 553, + 562, + 564, + 565 + ] + }, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "literal_fill": { + "checkers": [ + "PR2745-package reconstruct.py + lift_parent.py (construction run)", + "independent_owners.py (R 410) in verify.py and verify_retired5.py", + "reconstruct.py inside the complete admission" + ], + "root80": "0.0017174093163354916434484584775411722292820274055897657035793607344277615998944" + }, + "stages": [ + { + "stage": "literal-review", + "exit_code": 0, + "seconds": 3.1 + }, + { + "stage": "native-extra", + "exit_code": 0, + "seconds": 105.6 + }, + { + "stage": "native-base", + "exit_code": 0, + "seconds": 106.5 + }, + { + "stage": "native-retained-base", + "exit_code": 0, + "seconds": 86.9 + }, + { + "stage": "native-retained-extra", + "exit_code": 0, + "seconds": 87.1 + }, + { + "stage": "retained-parent", + "exit_code": 0, + "seconds": 67.4 + }, + { + "stage": "complete-admission", + "exit_code": 0, + "seconds": 209.5 + }, + { + "stage": "admission:owners", + "exit_code": 0, + "seconds": 2.6 + }, + { + "stage": "admission:parent-lift", + "exit_code": 0, + "seconds": 3.4 + }, + { + "stage": "admission:rebind", + "exit_code": 0, + "seconds": 0.5 + }, + { + "stage": "admission:discovery", + "exit_code": 0, + "seconds": 42.9 + }, + { + "stage": "admission:outer-check_ledger.py", + "exit_code": 0, + "seconds": 0.0 + }, + { + "stage": "admission:outer-independent_check.py", + "exit_code": 0, + "seconds": 0.0 + }, + { + "stage": "admission:release", + "exit_code": 0, + "seconds": 159.6 + }, + { + "stage": "release:verify:fine-engine-oracle", + "exit_code": 0 + }, + { + "stage": "release:verify:retained-provider-and-parent-admission", + "exit_code": 0 + }, + { + "stage": "release:verify:rebuild-words-566", + "exit_code": 0 + }, + { + "stage": "release:verify:reconstruct-owners", + "exit_code": 0 + }, + { + "stage": "release:verify:lift-parent", + "exit_code": 0 + }, + { + "stage": "release:verify:rebuild-borrow-words", + "exit_code": 0 + }, + { + "stage": "release:verify:audit-local-566-base", + "exit_code": 0 + }, + { + "stage": "release:verify:audit-local-566-extra", + "exit_code": 0 + }, + { + "stage": "release:verify:rebind-566", + "exit_code": 0 + }, + { + "stage": "release:verify:lemmag-labels", + "exit_code": 0 + }, + { + "stage": "release:verify:strict-t74", + "exit_code": 0 + }, + { + "stage": "release:verify:geometry-controls", + "exit_code": 0 + } + ], + "result": { + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE", + "release": "PASS_RELEASE", + "complex_lower": "214676164541936455431/125000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "precision": "endpoint certified at 1e-24 (accept at C, reject at C+1e-24); kappa = C - 1e-46 - 1e-70 exactly", + "margins": { + "PR2751": "267729987065305339/1000000000000000000000000", + "PR2766": "76171434244667589/500000000000000000000000", + "PR2767": "1.5234286848933516942947e-07" + }, + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "cold_seconds": 473.9 + }, + "package": { + "path": "research/t74-joint-twelve-retired5", + "overlay_sha256": "4305a3b9e98145d00417ae1b27caa4d9c7eed263a29ad52389fa5ffd33714ef0", + "derived_manifest": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "claim_sha256": "405e5840859b64209687b2c58d0097d9bbbdc0e007da88d91a001ccd093a79f1" + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43base.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43base.json new file mode 100644 index 0000000000..9785264a78 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43base.json @@ -0,0 +1,180 @@ +{ + "all_rejected": true, + "controls": { + "606<-550 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 63", + "real_reason": true + }, + "606<-550 warp dropped": { + "rejected": true, + "reason": "frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "real_reason": true + }, + "606<-550 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "606<-550 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "real_reason": true + }, + "606 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "635<-551 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 warp dropped": { + "rejected": true, + "reason": "frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "635<-551 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "635<-551 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "real_reason": true + }, + "635 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "637<-552 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 35", + "real_reason": true + }, + "637<-552 warp dropped": { + "rejected": true, + "reason": "frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "637<-552 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "637<-552 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "real_reason": true + }, + "637 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "638<-553 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "638<-553 warp dropped": { + "rejected": true, + "reason": "frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "638<-553 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "638<-553 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "real_reason": true + }, + "638 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "639<-562 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "639<-562 warp dropped": { + "rejected": true, + "reason": "frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "639<-562 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "639<-562 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "real_reason": true + }, + "639 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43extra.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43extra.json new file mode 100644 index 0000000000..9785264a78 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/CONTROLS-ALIAS5-43extra.json @@ -0,0 +1,180 @@ +{ + "all_rejected": true, + "controls": { + "606<-550 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 11", + "real_reason": true + }, + "606<-550 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 63", + "real_reason": true + }, + "606<-550 warp dropped": { + "rejected": true, + "reason": "frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "real_reason": true + }, + "606<-550 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "606<-550 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "real_reason": true + }, + "606 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "635<-551 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "635<-551 warp dropped": { + "rejected": true, + "reason": "frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "635<-551 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "635<-551 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "real_reason": true + }, + "635 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "637<-552 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "637<-552 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 35", + "real_reason": true + }, + "637<-552 warp dropped": { + "rejected": true, + "reason": "frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "637<-552 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "637<-552 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "real_reason": true + }, + "637 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "638<-553 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "638<-553 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "638<-553 warp dropped": { + "rejected": true, + "reason": "frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "638<-553 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "638<-553 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "real_reason": true + }, + "638 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "639<-562 borrowed read sign flipped": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed read doubled": { + "rejected": true, + "reason": "target map failed 45", + "real_reason": true + }, + "639<-562 borrowed write sign flipped": { + "rejected": true, + "reason": "target map failed 32", + "real_reason": true + }, + "639<-562 warp dropped": { + "rejected": true, + "reason": "frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "real_reason": true + }, + "639<-562 G wrong": { + "rejected": true, + "reason": "G(from)!=to", + "real_reason": true + }, + "639<-562 warp before lender retirement": { + "rejected": true, + "reason": "warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "real_reason": true + }, + "639 kept with an entrance frame": { + "rejected": true, + "reason": "start_extra/helper_final must name remaining helpers", + "real_reason": true + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-RESULT.json new file mode 100644 index 0000000000..d276ca96c5 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-RESULT.json @@ -0,0 +1,295 @@ +{ + "cold_seconds": 473.86783904209733, + "cold_stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/verify.py" + ], + "exit_code": 0, + "log_sha256": "f29e2b1e3f365895dbbb150a0c809a8fa8f6bd31fefe2a95d156b9ab38b1d1ac", + "name": "literal-review", + "script_sha256": "9e2255942bf283cc7402f3f2dfe9b1068004d83e54aa093680697bce5fa002e4", + "seconds": 3.138666331768036 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + ], + "exit_code": 0, + "log_sha256": "d4978b408406e14a9589e8f130cafe93ca108c61e7a1988021582d627e9ecd88", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 105.63651245832443 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + ], + "exit_code": 0, + "log_sha256": "e46f44d5369c79f4b7479bc9834993bf11a8c0a2c6c04ad6c354e4ed149533fc", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 106.45441208221018 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/gauge44-word.json.gz", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 86.9097792096436 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/extra-word.json.gz", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 87.08368291519582 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/vendor/pr1297/verify.py", + "--work", + "$WORK/retained-parent", + "--base-native-from", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 67.37584125064313 + }, + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/workflow/admit.py", + "--source", + "$WORK/source", + "--fill", + "$PACKAGE/inputs/FILL.json.gz", + "--order", + "$PACKAGE/inputs/ORDER.json", + "--native-cache", + "$WORK/native-cache", + "--native-receipt", + "$WORK/NATIVE-RECEIPT.json", + "--work", + "$WORK/admission", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "78e003fec9be06b771f97b231364c81db916f005cd61b3e4676375b18b3d42d8", + "name": "complete-admission", + "script_sha256": "68c8eda7343ba8119cfe98f464aeaf27ba61d913a2088ac4aaa74ac3b1a26ea8", + "seconds": 209.51657162606716 + } + ], + "complex_lower": "214676164541936455431/125000000000000000000000", + "environment": { + "executable": "$PYTHON", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.4.4", + "scipy": "1.17.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": false, + "fill_sha256": "3501f6bd9d56d9da9fdc912d957d08077434525a804bb647df1e630fc30b6a3f", + "gain": "1268890338050127259/1000000000000000000000000", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "native_receipt_sha256": "a6699f7c413a023c54002383427a406c5abab01e24044ea2d0bf477f2847358b", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1606392, + "2": 427572, + "3": 189078, + "32": 1, + "4": 85248, + "48": 26558, + "5": 25862, + "8": 5328 + }, + "release_receipt_sha256": "4d7e7d7c9fc4409cb1349ccba8cb7684cf728c62c256eb035a312a4effb3e417", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "stages": [ + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/reconstruct.py", + "--out", + "$WORK/admission/owners" + ], + "exit_code": 0, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.603047166019678 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/lift_parent.py", + "--owners", + "$WORK/admission/owners", + "--out", + "$WORK/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.375074163079262 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/new/rebind.py", + "$WORK/admission/package", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local", + "$WORK/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.45554850064218044 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/layout/packing74/replay.py", + "--data", + "$WORK/admission/layout/packing74/candidate", + "--work", + "$WORK/admission/discovery", + "--local", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "47e527508e79492bac115ed986f64952061d62d4e0e398493a5503177efa715c", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 42.93201891891658 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "3600dc9da6e2d8a7890ba25d653b5c4a5d8665258138b4a1fbc513cd10d1ce9d", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04852970875799656 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "be184bf84423d7099020df8eac83ab5d4f21a6d98e30df2941e7d6f55233c5da", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023921916261315346 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/admission/package/verify_release.py", + "--main", + "$SCRATCH/t51", + "--work", + "$WORK/admission/release", + "--native-cache", + "$WORK/native-cache", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "feda4a5293171f0bf66be05056d778b9ea7697cbb60e26d4b029d9cc757fb9ad", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 159.62109053879976 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-STAGES.json new file mode 100644 index 0000000000..384e4a8a7e --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/FULL-REPLAY-STAGES.json @@ -0,0 +1,114 @@ +[ + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/verify.py" + ], + "exit_code": 0, + "log_sha256": "f29e2b1e3f365895dbbb150a0c809a8fa8f6bd31fefe2a95d156b9ab38b1d1ac", + "name": "literal-review", + "script_sha256": "9e2255942bf283cc7402f3f2dfe9b1068004d83e54aa093680697bce5fa002e4", + "seconds": 3.138666331768036 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "$WORK/native-cache/4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + ], + "exit_code": 0, + "log_sha256": "d4978b408406e14a9589e8f130cafe93ca108c61e7a1988021582d627e9ecd88", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 105.63651245832443 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/new/run_native_borrow.py", + "$WORK/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "$WORK/native-cache/a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + ], + "exit_code": 0, + "log_sha256": "e46f44d5369c79f4b7479bc9834993bf11a8c0a2c6c04ad6c354e4ed149533fc", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 106.45441208221018 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/gauge44-word.json.gz", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 86.9097792096436 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "$WORK/source/vendor/pr1297/extra-word.json.gz", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 87.08368291519582 + }, + { + "command": [ + "$PYTHON", + "-B", + "$WORK/source/vendor/pr1297/verify.py", + "--work", + "$WORK/retained-parent", + "--base-native-from", + "$WORK/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "$WORK/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 67.37584125064313 + }, + { + "command": [ + "$PYTHON", + "-B", + "$PACKAGE/workflow/admit.py", + "--source", + "$WORK/source", + "--fill", + "$PACKAGE/inputs/FILL.json.gz", + "--order", + "$PACKAGE/inputs/ORDER.json", + "--native-cache", + "$WORK/native-cache", + "--native-receipt", + "$WORK/NATIVE-RECEIPT.json", + "--work", + "$WORK/admission", + "--jobs", + "2" + ], + "exit_code": 0, + "log_sha256": "78e003fec9be06b771f97b231364c81db916f005cd61b3e4676375b18b3d42d8", + "name": "complete-admission", + "script_sha256": "68c8eda7343ba8119cfe98f464aeaf27ba61d913a2088ac4aaa74ac3b1a26ea8", + "seconds": 209.51657162606716 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/GENERATE-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/GENERATE-LOG.txt new file mode 100644 index 0000000000..58bf5e8244 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/GENERATE-LOG.txt @@ -0,0 +1,270 @@ +wrote $OUT/gen-out2/canonical-base.json.gz 1901 4504 42 78 +BUILT base newops 12 targets {126: [45], 153: [45], 218: [45], 164: [45], 133: [45], 149: [45], 222: [45], 159: [45], 155: [45], 190: [45], 216: [45], 211: [45]} file $OUT/gen-out2/joint/eight-alias-base.json.gz +warps 58 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 646 independent inputs +free-algebra dual PASS 646 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "eight-alias-base.json.gz", + "content_sha256": "3b3f4257310076afeb608d249a1b070ea256c6764a2a865b533876873d4d2f25", + "compressed_sha256": "fe6107728d9534ea7514c01ad1c055ed5ef281eb6f1636c3c51345e532517065", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 58, + "independent_inputs": 646, + "warps": 58, + "corrections": 0, + "restored_cold": 78, + "zero_buffers": 78, + "entering": 134, + "local_profile": { + "1": 2359, + "2": 632, + "3": 318, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5251, + "width_inventory": { + "4": 33, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 646, + "elapsed_seconds": 0.35123725049197674, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 65 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 639 independent inputs +free-algebra dual PASS 639 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-base.json.gz", + "content_sha256": "f5dc7b45551de05ac239bab283dd6b73c365c7f1a132d480c70d878eb9a41de1", + "compressed_sha256": "675cd7471865da6e762af662d0aad46c73751051a2451d4aa52bc675ea79ed89", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 65, + "independent_inputs": 639, + "warps": 65, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 133, + "local_profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5223, + "width_inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 639, + "elapsed_seconds": 0.3255330827087164, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 70 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 634 independent inputs +free-algebra dual PASS 634 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-retired5-base.json.gz", + "content_sha256": "9e290bc9f46951a66869d90036e771c6071f52198437879be33c08c05d7ad7d5", + "compressed_sha256": "30583d34f5668a0e3ff808ed49893656b027bb83e75da132f2cbd01b439cd8dd", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 70, + "independent_inputs": 634, + "warps": 70, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 128, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5198, + "width_inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 634, + "elapsed_seconds": 0.33066937513649464, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +wrote $OUT/gen-out2/canonical-extra.json.gz 1901 4504 42 78 +BUILT extra newops 12 targets {126: [45], 153: [45], 218: [45], 164: [45], 133: [45], 149: [45], 222: [45], 159: [45], 155: [45], 190: [45], 216: [45], 211: [45]} file $OUT/gen-out2/joint/eight-alias-extra.json.gz +warps 58 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 646 independent inputs +free-algebra dual PASS 646 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "eight-alias-extra.json.gz", + "content_sha256": "f4d06b9b54a124eb82083ad7720c547f9624b053283081f06e3c9dd1fc00c63f", + "compressed_sha256": "0fa262b62c1e954f6b3305c6da479e8d2d126d910c981809ed226f0d02348961", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 58, + "independent_inputs": 646, + "warps": 58, + "corrections": 0, + "restored_cold": 78, + "zero_buffers": 78, + "entering": 134, + "local_profile": { + "1": 2359, + "2": 632, + "3": 318, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5251, + "width_inventory": { + "4": 33, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 646, + "elapsed_seconds": 0.32189466804265976, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 65 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 639 independent inputs +free-algebra dual PASS 639 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-extra.json.gz", + "content_sha256": "57a1598881750f3ba3d262bb577142b723208d687f29bec848381ac8bf9487f6", + "compressed_sha256": "b7cd725e8486d0cf600aa9c3a50588c4f02bc481de404db8e7d32be3fcefcbd9", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 65, + "independent_inputs": 639, + "warps": 65, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 133, + "local_profile": { + "1": 2366, + "2": 646, + "3": 297, + "4": 120, + "5": 26, + "8": 8 + }, + "local_mass": 5223, + "width_inventory": { + "4": 26, + "5": 9, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 639, + "elapsed_seconds": 0.3282842505723238, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +warps 70 PASS static K_G checks +frames/profile PASS +free-algebra forward PASS 634 independent inputs +free-algebra dual PASS 634 independent inputs +{ + "status": "PASS_INDEPENDENT_EXACT_BORROWING_WORD", + "input_file": "WORD-retired5-extra.json.gz", + "content_sha256": "69b82b55690b5107021947b14ab81b9bb169848667063920cc5c72d17d1d9f91", + "compressed_sha256": "e2e99424ff650e90b254981e358885ff515b43e650cd7930ba660d02e807d83d", + "v": 112, + "h": 9, + "R": 480, + "removed_helpers": 70, + "independent_inputs": 634, + "warps": 70, + "corrections": 36, + "restored_cold": 72, + "zero_buffers": 72, + "entering": 128, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + }, + "local_mass": 5198, + "width_inventory": { + "4": 26, + "5": 4, + "7": 62, + "8": 78, + "9": 240 + }, + "orientations": { + "forward": "PASS", + "dual": "PASS" + }, + "base": null, + "checked_columns": 634, + "elapsed_seconds": 0.33145875111222267, + "scope": "Exact free-operator-algebra replay (every remaining input is an independent column): K_G warps with G invertible, G(from)=to, symplectic form fixing L_0/L_FULL and sending L_from to L_to (rank 0), literal frame chain with warps, relaxed fixed initial compensation, derived inverse-reverse cleanup at FULL with inverse warps and private zero buffers. No Clifford phase/Gaussian product, no owner admission, no repricing." +} +PASS_REGENERATED_JOINT_TWELVE_RETIRED5_BOTH_WORDS +exit 0 diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/HOOK-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/HOOK-RESULT.json new file mode 100644 index 0000000000..c2f514c451 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/HOOK-RESULT.json @@ -0,0 +1,151 @@ +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED5_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 273060 + }, + "complex_lower": "214676164541936455431/125000000000000000000000", + "root_80_digits": "0.00171740931633549164344845847754117222928202740558976570357936073442776159989441", + "kappa": "17174093163354916434479999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "2.67729987065305339E-7", + "exact": "267729987065305339/1000000000000000000000000" + }, + "PR2766": { + "decimal": "1.52342868489335178E-7", + "exact": "76171434244667589/500000000000000000000000" + }, + "PR2767": { + "decimal": "1.52342868489335177055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/NATIVE-RECEIPT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..b30f12f22c --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/NATIVE-RECEIPT.json @@ -0,0 +1,127 @@ +{ + "cache_files": { + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/CACHE.json": "3a8e1a43fdffa349ce9118cfdd8aaef605b69ccfc1ae1af8f35d71c3aa9a197e", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/STEPS.json": "96a871833ed290b21e6adf82bb9b3f48d2713180a1b0ccfb2d2c1b5dc0ef7ab0", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CANONICAL-WORD.json.gz": "a43a2d003b1f5599738510bbfcd0b99df5dbcb8c6365bba9e444dee8cd87ebfc", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CLIFFORD-RECIPES.json": "4da93cfd42d30cab4e4ab0b1e7fbf531584a667e738fa3fdbcf6d6f1ef40bcbb", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/CLIFFORD-REVIEW.json": "362cc95a9464f00a42c114e979207ebe1faacc4e361e50c2336ba66b14dc8b36", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/FULL-WORD.json.gz": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/INDEPENDENT-LOCAL-REPLAY.json": "3fe075d088dad87ff4476300a6aa3526c001b2825a9048b31e0ae5c218145b08", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/RESIDUAL-ADAPTERS.json": "af733093f55c810dfc709d1862c786708c600f45b0319a53879c05fbca3e7fbd", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/SCALAR-FRAME-AUDIT.json": "d5313b030f3fa5220d35f89f8f8fc86b2e6602cabd379d7bd5f36ed44bfe350e", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/WARP-RECIPE-CHECKS.json": "77bf18ae4cb3a8bedf850660a29eb51310bc55d527729f773c5d77c4594faf63", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/native.log": "7524fe7dcc731a784dd413eac9cec1315cfbf106e6b01bf50821575711f544f2", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/phases.log": "9d87e97edbc1e9f7c7efe52ae5157d71c043a7a87c04e38658497dce98ffb6bb", + "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "6575f1c713149ac6ff3bf393c52d5e6dbc2eb452400c170431fb1a4edeb1f96b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "5a490ae4444dd0d46b6e1896b2c4aaa08c47b450b2cac39db73e7cf82a661c0d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "129d7ec37b2ff33d6986f23a6aab15ad8a5be3f3162d757c54d46d139885f8d9", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "f2f24a52e5ae920e4af9322ad0d94c9ea88ca408f1a1027e2433792255986b91", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "521b0a7de15c7b843436cf267cf3b33d157ad4ef1b1a94ef24e13668e5b058df", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "215f3f3acc8c02be35ec408984e6d9e7261c41a4c089af2671fe133323b1d869", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "ff50f7fe4101be80eb824b0ca5353edda38fc569a97db317a26a2768aa6d145f", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "5e3d10375a0a5540e8f2082797953fc02c1322a008c35f6c5149e2e752932635", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "d4e22101ed0a9e7af148b8fa2fa82f3e3133b2b6d4c9f07a73be071f5607ff6b", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/CACHE.json": "578d98897d675277781be661ed0515d24c7c4fe880ed593bf2fc8e2cfcf7e8fd", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/STEPS.json": "38cae98ac7b55cd316360467d1af056d7bd02caee0e9f85cad2995ddb7934ede", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CANONICAL-WORD.json.gz": "af947314ca54dcb046c8e7b5c9f6b5e599ccff6bae47f7e61752b168c67364ea", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CLIFFORD-RECIPES.json": "0bc2e47fcdceb7c4ade7a4e63547dae76b903b1b413eda2b83fa145343b22685", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/CLIFFORD-REVIEW.json": "62c6b6edc9f5a5a6f3607c26d883a68b01132bd1702c4e40d058797877045f41", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/FULL-WORD.json.gz": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/INDEPENDENT-LOCAL-REPLAY.json": "a8853fd4a8c875cd032634de84f3079e4ff7acdf32e9cbe71b5d9f57a0515cf6", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/RESIDUAL-ADAPTERS.json": "fc9a31c8e7e76d6ee300c63fe67bffd5e36f29a495f4298877947eddbf7598e8", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/SCALAR-FRAME-AUDIT.json": "ca4d2e2f61247d608939b9447842fc2862c32864134e2cc15194b60d7698ffc5", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/WARP-RECIPE-CHECKS.json": "b458da602728252c4e45dc66278b1769364f1dc192d01e6d4b4c3e6d8a1ef8ba", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/native.log": "0914ca423784c0625f4468df4f2a7e78089a6bc8b38865ec27196dcd33d6266f", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/phases.log": "b4ce593a37eb15ad871d51fcab31c4ccdbcd079ebab95bc534cc2a5b1b1c31a6", + "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "6636a564339c2fd6b2b2a668029c8d3e422a460a5bc8418deab1de523a8c7cf2", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "3d4f52362da2e9cc28995cd46268c82ae803076a94a3270161102c1d0170e07a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "8c3dead2f3403ac3da93d75b553a57a5551228ed393ee837c380a0de9872c71c", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "fc0c6c4182159069af394f13210a0db0c98cb0182c2293bc8477f65ac077eb42", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "a4afe4dea39737eb033756d09217457ead4be1794e6f4f75730722c22bd0d615", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "93da0be182661d2c88fd25dd3107a05687829f75f225ad9ea537cd2b94874002", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "0288172f1fdef2dabf82a8367fdb2f15bfbba62caea2a953d91b03b0dd9c97b3", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "38cae98ac7b55cd316360467d1af056d7bd02caee0e9f85cad2995ddb7934ede", + "ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "af947314ca54dcb046c8e7b5c9f6b5e599ccff6bae47f7e61752b168c67364ea", + "local/CLIFFORD-RECIPES.json": "0bc2e47fcdceb7c4ade7a4e63547dae76b903b1b413eda2b83fa145343b22685", + "local/CLIFFORD-REVIEW.json": "62c6b6edc9f5a5a6f3607c26d883a68b01132bd1702c4e40d058797877045f41", + "local/FULL-WORD.json.gz": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b", + "local/INDEPENDENT-LOCAL-REPLAY.json": "a8853fd4a8c875cd032634de84f3079e4ff7acdf32e9cbe71b5d9f57a0515cf6", + "local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "local/RESIDUAL-ADAPTERS.json": "fc9a31c8e7e76d6ee300c63fe67bffd5e36f29a495f4298877947eddbf7598e8", + "local/SCALAR-FRAME-AUDIT.json": "ca4d2e2f61247d608939b9447842fc2862c32864134e2cc15194b60d7698ffc5", + "local/WARP-RECIPE-CHECKS.json": "b458da602728252c4e45dc66278b1769364f1dc192d01e6d4b4c3e6d8a1ef8ba", + "local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "native.log": "0914ca423784c0625f4468df4f2a7e78089a6bc8b38865ec27196dcd33d6266f", + "phases.log": "b4ce593a37eb15ad871d51fcab31c4ccdbcd079ebab95bc534cc2a5b1b1c31a6", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "a4f4c149731fda76873a6c68870c6b7372c32bae4617a15435d58745ed29629b" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "96a871833ed290b21e6adf82bb9b3f48d2713180a1b0ccfb2d2c1b5dc0ef7ab0", + "ledgers.log": "d03c0543d9f276345119cbda2dcd5fd4976a48f9bd53280009661077d4d9daa1", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "a43a2d003b1f5599738510bbfcd0b99df5dbcb8c6365bba9e444dee8cd87ebfc", + "local/CLIFFORD-RECIPES.json": "4da93cfd42d30cab4e4ab0b1e7fbf531584a667e738fa3fdbcf6d6f1ef40bcbb", + "local/CLIFFORD-REVIEW.json": "362cc95a9464f00a42c114e979207ebe1faacc4e361e50c2336ba66b14dc8b36", + "local/FULL-WORD.json.gz": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8", + "local/INDEPENDENT-LOCAL-REPLAY.json": "3fe075d088dad87ff4476300a6aa3526c001b2825a9048b31e0ae5c218145b08", + "local/LOCAL-CHECKS.json": "c7f4119c675aaa4c682b176ca70c0f1f528dd401b90016c4fee58d08d7ee0de8", + "local/LOCAL-PROGRAMS.json.gz": "7cebc9c7c6c3d544318d25418f30008a9a7a97b5e6d3ee5c627435f280452cbe", + "local/RESIDUAL-ADAPTERS.json": "af733093f55c810dfc709d1862c786708c600f45b0319a53879c05fbca3e7fbd", + "local/SCALAR-FRAME-AUDIT.json": "d5313b030f3fa5220d35f89f8f8fc86b2e6602cabd379d7bd5f36ed44bfe350e", + "local/WARP-RECIPE-CHECKS.json": "77bf18ae4cb3a8bedf850660a29eb51310bc55d527729f773c5d77c4594faf63", + "local/WRAPPER-CHECKS.json": "67ae6599bbae4acbff806cf163fb628a2fc475c718053f63667248e13d21af2f", + "native.log": "7524fe7dcc731a784dd413eac9cec1315cfbf106e6b01bf50821575711f544f2", + "phases.log": "9d87e97edbc1e9f7c7efe52ae5157d71c043a7a87c04e38658497dce98ffb6bb", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "4fb7e28a5c4166c7c81ec8448df35674a8546f86a55c932cefde6c63ee5c2cf8" + } + }, + "retained_parent_receipt_sha256": "ff50f7fe4101be80eb824b0ca5353edda38fc569a97db317a26a2768aa6d145f", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..9119865da2 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,13 @@ +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-RECEIPT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..b4684a573d --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017174093163354916434479999999999999999999998999999999999999999999999", + "manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 214676164541936455431/12500000... brackets the ledger's b = 171740931633549164344799999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017174093163354916434479999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 159.58 +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-RESULT.json new file mode 100644 index 0000000000..7caccd3f8f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-RESULT.json @@ -0,0 +1,98 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "171446487838083/100000000000000000", + "kappa_decimal": "0.00171446487838083", + "manifest_sha256": "fdb18c58ebd9e88d71d636ae7722f053a53041dafdc673873c0abe8af5f5c83c", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 273060, + "prefix_bits": 1443, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19545, + "row_limit": 20161, + "controls": { + "admission": 114, + "bit": 12, + "controller": 15, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.7939643766731024, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.1763007901608944 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4441820420324802, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.665369501337409, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.473093580454588, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 97.6485572103411, + "log_sha256": "9fde2d3b4e631660ebb5848638bb4e7bd6697fa665b2ae0560cd36c3b7e431e3" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.5301409177482128, + "log_sha256": "2b03816ce8bbfde22d7aade223f5b504ff5dd05b5fd8f789d25f1ee965152ab5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.5267670825123787, + "log_sha256": "37d013a62a467be5fceb14c22e9e7ca30259dbc78378633fb65304f1fd59686b" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.4506230838596821, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.428194791078568, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 43.606457874178886, + "log_sha256": "8c2319cf48a02955e33740c7dd082c3b8eb08f445f13bdf921a1e5d3d339d66f" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.23889125138521194, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-STAGES.json new file mode 100644 index 0000000000..aff147d9ed --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RELEASE-VERIFY-STAGES.json @@ -0,0 +1,74 @@ +[ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.7939643766731024, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.1763007901608944 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4441820420324802, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.665369501337409, + "log_sha256": "17b03ca75295619857e9f46d9612a0f64fae67e6a94e05061acf2d34d3685afd" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.473093580454588, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 97.6485572103411, + "log_sha256": "9fde2d3b4e631660ebb5848638bb4e7bd6697fa665b2ae0560cd36c3b7e431e3" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.5301409177482128, + "log_sha256": "2b03816ce8bbfde22d7aade223f5b504ff5dd05b5fd8f789d25f1ee965152ab5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.5267670825123787, + "log_sha256": "37d013a62a467be5fceb14c22e9e7ca30259dbc78378633fb65304f1fd59686b" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.4506230838596821, + "log_sha256": "268b3cee5b4109b8bdb83816ad31e5342a1ae2e2b1c7bb5a5be650cd5b2ad59f" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.428194791078568, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 43.606457874178886, + "log_sha256": "8c2319cf48a02955e33740c7dd082c3b8eb08f445f13bdf921a1e5d3d339d66f" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.23889125138521194, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } +] \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RUNTIME-PATCHES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RUNTIME-PATCHES.json new file mode 100644 index 0000000000..2fea51a3dd --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired5/RUNTIME-PATCHES.json @@ -0,0 +1,32 @@ +[ + { + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-RESULT.json new file mode 100644 index 0000000000..4ceb18a849 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-RESULT.json @@ -0,0 +1,168 @@ +{ + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "fill_sha256": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "gain": "827279060596573819/500000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "native_receipt_sha256": "5b017e61828c567bc3093df8a3e7e57230cac97c9177bd6154d2cf80ed99ba4e", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "32": 1, + "4": 85248, + "48": 26558, + "5": 27194, + "8": 5328 + }, + "release_receipt_sha256": "bc68e064840769ee819bbba0213cd7cad3c82f8b60dbe3e1c49c2e079cc33445", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } + ], + "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-STAGES.json new file mode 100644 index 0000000000..8b12d62f6f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/ADMISSION-STAGES.json @@ -0,0 +1,111 @@ +[ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json new file mode 100644 index 0000000000..0205988129 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CENSUS-AND-AUGMENTING-PATHS.json @@ -0,0 +1,66 @@ +{ + "words": "retired5 candidate words (PR2751 + five retired-lender aliases)", + "rule": "new/borrow/refit/search pairs.py: lender last event before the follower first B gate, lender untouched later, dim lo(lender last) <= dim hi(follower first); chains counted", + "helper_status": { + "touched-before-B": 286, + "restored-cold": 72, + "follower": 52 + }, + "follower_hist": { + "(1, 1, 8)": 48, + "(4, 5, 5)": 4 + }, + "lenders": 404, + "lender_lo_hist": { + "(6, 'gate', False)": 124, + "(8, 'gate', True)": 70, + "(8, 'gate', False)": 194, + "(7, 'gate', False)": 14, + "(5, 'gate', False)": 2 + }, + "direct_pairs": 0, + "chain_edges": 0, + "augmenting_paths": 192, + "paths_by_follower": { + "667": 48, + "669": 48, + "670": 48, + "671": 48 + }, + "paths_by_free_lender": { + "564": 96, + "565": 96 + }, + "movable_hosted_warps": [ + 1, + 2, + 3, + 4, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41 + ], + "max_extra_aliases": 2, + "certified_singles": { + "warps 30/31/32/41 (hostee entrance already rank 5), any follower 667/669/670/671": "local {1:-2,2:+3,3:-3}, +1.928e-7 realized over retired5", + "warp 1 (hostee raise closure 16 gates)": "local {1:+2,2:+11,3:-15,4:+4}, -3.30e-7" + }, + "chosen": "warps 30 (401->564) and 31 (403->565); aliases 667<-401, 669<-403: local {1:-4,2:+6,3:-6}, +3.857e-7 over retired5" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43base.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43base.json new file mode 100644 index 0000000000..45cecc552b --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43base.json @@ -0,0 +1,130 @@ +{ + "all_rejected_for_real_reasons": true, + "controls": { + "refit7 B911 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "refit7 B912 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move30 401->564 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move30 401->564 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "move31 403->565 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move31 403->565 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667<-401 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "669<-403 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 26", + "real_reason": true + }, + "669<-403 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669<-403 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "669<-403 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "refit7c certified frame corrupted": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))", + "real_reason": true + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43extra.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43extra.json new file mode 100644 index 0000000000..45cecc552b --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/CONTROLS-RETIRED7-43extra.json @@ -0,0 +1,130 @@ +{ + "all_rejected_for_real_reasons": true, + "controls": { + "refit7 B911 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "refit7 B912 lender refit undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move30 401->564 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move30 401->564 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "real_reason": true + }, + "move30 401->564 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "move31 403->565 warp lender reverted": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 move undone": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "real_reason": true + }, + "move31 403->565 warp before lender retirement": { + "rejected": true, + "reason": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "real_reason": true + }, + "move31 403->565 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "667<-401 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667<-401 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "667<-401 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "667 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "669<-403 borrowed read sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed read doubled": { + "rejected": true, + "reason": "RuntimeError: target map failed 3", + "real_reason": true + }, + "669<-403 borrowed write sign flipped": { + "rejected": true, + "reason": "RuntimeError: target map failed 26", + "real_reason": true + }, + "669<-403 warp dropped": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669<-403 G wrong": { + "rejected": true, + "reason": "RuntimeError: G(from)!=to", + "real_reason": true + }, + "669<-403 warp after the follower's first gate": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "real_reason": true + }, + "669 kept with an entrance frame": { + "rejected": true, + "reason": "RuntimeError: start_extra/helper_final must name remaining helpers", + "real_reason": true + }, + "refit7c certified frame corrupted": { + "rejected": true, + "reason": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))", + "real_reason": true + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-RESULT.json new file mode 100644 index 0000000000..5cced4b2db --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-RESULT.json @@ -0,0 +1,295 @@ +{ + "cold_seconds": 410.72115191817284, + "cold_stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/verify.py" + ], + "exit_code": 0, + "log_sha256": "2c74f838e832460b1cc61ba99ae2b041c8ada28597985d1190c703f81d5eb19b", + "name": "literal-review", + "script_sha256": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "seconds": 3.4852952491492033 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/extra-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.01782804168761 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/gauge44-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.23545237630606 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + ], + "exit_code": 0, + "log_sha256": "f9d3dd98f95cd1b5358cb889c34965e40b4422712ed3682ff507175f74ba2b42", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 107.73961633443832 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + ], + "exit_code": 0, + "log_sha256": "c9003f19404118e12ef149d3bfbbeae7ffa0fd3b7e18ad408ff172625619880a", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 109.27364500053227 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/verify.py", + "--work", + "/r10/agents/F-lenders/full7/work/retained-parent", + "--base-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 70.37898799963295 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/workflow/admit.py", + "--source", + "/r10/agents/F-lenders/full7/work/source", + "--fill", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/FILL.json.gz", + "--order", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/ORDER.json", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--native-receipt", + "/r10/agents/F-lenders/full7/work/NATIVE-RECEIPT.json", + "--work", + "/r10/agents/F-lenders/full7/work/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "eba644f08e808bfd8acb0cac6376f6064d095516bc7773d0337bf416bc406d5c", + "name": "complete-admission", + "script_sha256": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "seconds": 227.28487924858928 + } + ], + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "environment": { + "executable": "~/Desktop/dev/aigent/agi/.venv/bin/python", + "python": "3.14.7", + "versions": { + "mpmath": "1.3.0", + "numpy": "2.4.4", + "scipy": "1.17.1", + "sympy": "1.14.0" + } + }, + "explicit_native_cache_reuse": false, + "fill_sha256": "2f2a25a8d82b424b1e643a8a5167361fcc5ab33cfbc6f186f4cb7ddcaf9df7d9", + "gain": "827279060596573819/500000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "native_receipt_sha256": "5b017e61828c567bc3093df8a3e7e57230cac97c9177bd6154d2cf80ed99ba4e", + "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7", + "package_manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } + ], + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "32": 1, + "4": 85248, + "48": 26558, + "5": 27194, + "8": 5328 + }, + "release_receipt_sha256": "bc68e064840769ee819bbba0213cd7cad3c82f8b60dbe3e1c49c2e079cc33445", + "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.", + "source_commit": "local-joint12-pr2733", + "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1", + "source_manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "stages": [ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/reconstruct.py", + "--out", + "/r10/agents/F-lenders/full7/work/admission/owners" + ], + "exit_code": 0, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e", + "name": "owners", + "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa", + "seconds": 2.8202367927879095 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/lift_parent.py", + "--owners", + "/r10/agents/F-lenders/full7/work/admission/owners", + "--out", + "/r10/agents/F-lenders/full7/work/admission/parent-data" + ], + "exit_code": 0, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4", + "name": "parent-lift", + "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e", + "seconds": 3.6723769158124924 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/new/rebind.py", + "/r10/agents/F-lenders/full7/work/admission/package", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local", + "/r10/agents/F-lenders/full7/work/admission/rebound" + ], + "exit_code": 0, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551", + "name": "rebind", + "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b", + "seconds": 0.48127808421850204 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/replay.py", + "--data", + "/r10/agents/F-lenders/full7/work/admission/layout/packing74/candidate", + "--work", + "/r10/agents/F-lenders/full7/work/admission/discovery", + "--local", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local", + "--discover" + ], + "exit_code": 0, + "log_sha256": "e8a25bdfe9b7c18669ed861d9520feaefa205a770ecf1a371887e75d90e61cae", + "name": "discovery", + "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955", + "seconds": 41.42458229139447 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/check_ledger.py" + ], + "exit_code": 0, + "log_sha256": "8397d0e4725bf04344ef102d28f38f1c23cf63dd3eb604f58451be5fa409b761", + "name": "outer-check_ledger.py", + "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e", + "seconds": 0.04806916229426861 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/outer/independent_check.py" + ], + "exit_code": 0, + "log_sha256": "7bdaae980b79d0d12e70ae4a1c65124027691f76122267fb3850a82c42b3e2f6", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.023633752018213272 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/admission/package/verify_release.py", + "--main", + "/r10/agents/F-lenders/full7", + "--work", + "/r10/agents/F-lenders/full7/work/admission/release", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "287380b9122f9d4bb25d0680bbfc33360fa0e5222d6ecfa54057e6fecb2b5295", + "name": "release", + "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "seconds": 178.32332853972912 + } + ], + "status": "PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-STAGES.json new file mode 100644 index 0000000000..4d4b3a7915 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/FULL-REPLAY-STAGES.json @@ -0,0 +1,114 @@ +[ + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/verify.py" + ], + "exit_code": 0, + "log_sha256": "2c74f838e832460b1cc61ba99ae2b041c8ada28597985d1190c703f81d5eb19b", + "name": "literal-review", + "script_sha256": "f80db78605024a9681ebf87b26afc0642a7b68e93ef12376258ea7425e4e610d", + "seconds": 3.4852952491492033 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/extra-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-extra", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.01782804168761 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/gauge44-word.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e" + ], + "exit_code": 0, + "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514", + "name": "native-retained-base", + "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6", + "seconds": 89.23545237630606 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43extra.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + ], + "exit_code": 0, + "log_sha256": "f9d3dd98f95cd1b5358cb889c34965e40b4422712ed3682ff507175f74ba2b42", + "name": "native-extra", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 107.73961633443832 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/new/run_native_borrow.py", + "/r10/agents/F-lenders/full7/work/source/new/borrow/words/BORROW-WORD-43base.json.gz", + "/r10/agents/F-lenders/full7/work/native-cache/dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + ], + "exit_code": 0, + "log_sha256": "c9003f19404118e12ef149d3bfbbeae7ffa0fd3b7e18ad408ff172625619880a", + "name": "native-base", + "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "seconds": 109.27364500053227 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/r10/agents/F-lenders/full7/work/source/vendor/pr1297/verify.py", + "--work", + "/r10/agents/F-lenders/full7/work/retained-parent", + "--base-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "--extra-native-from", + "/r10/agents/F-lenders/full7/work/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905" + ], + "exit_code": 0, + "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24", + "name": "retained-parent", + "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345", + "seconds": 70.37898799963295 + }, + { + "command": [ + "~/Desktop/dev/aigent/agi/.venv/bin/python", + "-B", + "/wt-claim7/research/t74-joint-twelve-retired7/workflow/admit.py", + "--source", + "/r10/agents/F-lenders/full7/work/source", + "--fill", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/FILL.json.gz", + "--order", + "/wt-claim7/research/t74-joint-twelve-retired7/inputs/ORDER.json", + "--native-cache", + "/r10/agents/F-lenders/full7/work/native-cache", + "--native-receipt", + "/r10/agents/F-lenders/full7/work/NATIVE-RECEIPT.json", + "--work", + "/r10/agents/F-lenders/full7/work/admission", + "--jobs", + "4" + ], + "exit_code": 0, + "log_sha256": "eba644f08e808bfd8acb0cac6376f6064d095516bc7773d0337bf416bc406d5c", + "name": "complete-admission", + "script_sha256": "5c379eea79464eb85c936442be405cdc4dd1ce435de9331a989a9f133b7704c3", + "seconds": 227.28487924858928 + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/HOOK-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/HOOK-RESULT.json new file mode 100644 index 0000000000..e29b039fd3 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/HOOK-RESULT.json @@ -0,0 +1,211 @@ +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728 + }, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "root_80_digits": "0.00171779498411863466382722991842817890408858438546231220090092725676198114516931", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "6.53397770208325718E-7", + "exact": "326698885104162859/500000000000000000000000" + }, + "PR2766": { + "decimal": "5.38010651632355557E-7", + "exact": "538010651632355557/1000000000000000000000000" + }, + "PR2767": { + "decimal": "5.38010651632355556055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-RECEIPT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-RECEIPT.json new file mode 100644 index 0000000000..a82fb1ff37 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-RECEIPT.json @@ -0,0 +1,127 @@ +{ + "cache_files": { + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/CACHE.json": "f365738d4a566219463896730ddc6442e9a3692eec745021d9dc049ff1a21b79", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/STEPS.json": "1575294f54a7cd088abbca743e87b79931ca736b71bd2326859522d55a1f4501", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/CLIFFORD-REVIEW.json": "dc9166e75871d21e7d7e23508b204a1d77205fa24684112cd12752d26f9ed89b", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/SCALAR-FRAME-AUDIT.json": "9ebdc3ef10740edd0be047ba35d9f8508d567737a28c555f5747210ad5bf2edb", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/native.log": "66ab85b104998334f95b0078b8e6fe859d5d6005f39308d78e8e77e3b38da795", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/phases.log": "c4eeb90b233202d2cbb5a8d98b7e659b252f6603795132f07c30d15be19d9a8c", + "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "7158575db76d8c0016aa45b8c51d33a5cd65485fd6d75ee559f1e4f6492fbf94", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "0500d5d2f2b977db012398e5a1d7aee1a48d5ba45b47d8eccfbe526e9e2c671c", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "a9d93d0bb1b3d01bb4966bd660d91094f4ba7d6e52ee19aa3550866abfd6085d", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "fcbc50a1ca25c8cd8776c32efc03728c529c52ab7c5e83453a034ff0a5884732", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "9ae59372e93cf456e807ff2cbd824457f92e30f36728ec943800ca1bf7d838df", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "6c3a02ede486e8157693db43b4b117335751e31c4749f13f3c281d671861666e", + "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "8e23031a5729041e46882e654b8ea1dba44fc01682cc3bbc354d7e0a126a1d75", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "7bbf85e49e334b5bf56227d3f0ea536ad7a60a1497316c1322108ea98b4eb924", + "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "531ad818e1982231b906cb2a1ff4648a8f119ef4043ac1e8abda216c63d51017", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/CACHE.json": "de531be30d5b8266573f0a20391ff5d9c246986e3dca04f3ee4808ac9f5c5fc0", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/STEPS.json": "b9a277e320cfc24843057bc977b8c855cb579340d1c396281ea2af44134a9724", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/CLIFFORD-REVIEW.json": "8838336b5dac50f7a6b1271f4653fc0e09f6aa1d1cc8104edfadfdb3a9c3cd2d", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/SCALAR-FRAME-AUDIT.json": "80a20a57c2f389c35dd1871a927febfa8b970493c6f1fa2882e758b8427f3819", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/native.log": "9743caaa1bcf00835cb3da5614f08f2bcc5954211201cdb8016dfd72fe986ed3", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/phases.log": "cb955c070e5e839c3822dabd9bf38e5c99367a7835eeb1fd9c3f20c8c5b2b81b", + "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66/wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "1491080d42c36a4a9ebdb8405f03acc9f01b475a643dacab7fdbaba0b3aab0bf", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "eae11302beadc4c53cbecd4121491dbea883b13c53aaca14905416eb506df070", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "5c3679733c9b5790c7e8ef7fe980ae0725ec92f111c4c5178896cbe42a659ee6", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "72e3af5880fe75aebdb880cd46e2ad75d50b3f58818e0a999f13ee5d5ace04cc", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "5fb0494d5f2dfeb1372dcff4940380703f3f927ae24f38009ee511825a5dbebc", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "7f2738850affa652cc3245a29580bc9d3ed4a040fe5a80049b1975b5b337b94c", + "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5" + }, + "manifest_sha256": "9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451", + "providers": { + "base": { + "complete_native_files": { + "STEPS.json": "b9a277e320cfc24843057bc977b8c855cb579340d1c396281ea2af44134a9724", + "ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "f64b300ef79ee2b641ae45c454ad88fcdf686e2230787f0a43a3eb6e5c446959", + "local/CLIFFORD-RECIPES.json": "385718b0e596adcd34f35f90ebbf09524051114d4478e5b3cf0b06f9c9cf7fc4", + "local/CLIFFORD-REVIEW.json": "8838336b5dac50f7a6b1271f4653fc0e09f6aa1d1cc8104edfadfdb3a9c3cd2d", + "local/FULL-WORD.json.gz": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66", + "local/INDEPENDENT-LOCAL-REPLAY.json": "d058f12ccdfa23e4448bec7240c2560a7924d769d2bf24b2724eabea6cbb9554", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "cb24ff72025d5d6a91e41507f4e80460b0600605236a0904c70f72134b3ca53f", + "local/SCALAR-FRAME-AUDIT.json": "80a20a57c2f389c35dd1871a927febfa8b970493c6f1fa2882e758b8427f3819", + "local/WARP-RECIPE-CHECKS.json": "1a3007ae1b53a2479c6e6667fd7ae8f79886be702aa0b1ee96a97ff300e9bfe8", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "9743caaa1bcf00835cb3da5614f08f2bcc5954211201cdb8016dfd72fe986ed3", + "phases.log": "cb955c070e5e839c3822dabd9bf38e5c99367a7835eeb1fd9c3f20c8c5b2b81b", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "dca8becca633ffc5e998985631bcbcab1123b27ca7f10ac6a96b1ec21ce69a66" + }, + "extra": { + "complete_native_files": { + "STEPS.json": "1575294f54a7cd088abbca743e87b79931ca736b71bd2326859522d55a1f4501", + "ledgers.log": "83766b5e8869ad38321c719055ec63e1c3e9c7afdd78d980dc5f3d151c09104f", + "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402", + "local/CANONICAL-WORD.json.gz": "ebdada36842012ee9922947577a26a137bb9bd1cefe2d7f8d622019fccf38052", + "local/CLIFFORD-RECIPES.json": "eb462f07e0518ea8ecf6acff889eaf595ebce372b59b978104f107701786424d", + "local/CLIFFORD-REVIEW.json": "dc9166e75871d21e7d7e23508b204a1d77205fa24684112cd12752d26f9ed89b", + "local/FULL-WORD.json.gz": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7", + "local/INDEPENDENT-LOCAL-REPLAY.json": "1b5b6d58ce5b12688eea7b5f69cd3e5b0776d80130886cbe35fa350144e1dfb2", + "local/LOCAL-CHECKS.json": "d53000e5127eb5311cf118760469ed5c0c1ab7b12c9198b90c124ee4adc21125", + "local/LOCAL-PROGRAMS.json.gz": "88573170cf4258fe520638bbf3d76ee94cc56126dd650189ab6c7774289b5898", + "local/RESIDUAL-ADAPTERS.json": "53c2a9d31a75c8aa34f314d67afb8c5b16026aa31e745b1ba13d5103f55c4f35", + "local/SCALAR-FRAME-AUDIT.json": "9ebdc3ef10740edd0be047ba35d9f8508d567737a28c555f5747210ad5bf2edb", + "local/WARP-RECIPE-CHECKS.json": "3182c6c967a63b55b98ef19024517fd3955f20cf1d099ca8bcad066185c6665c", + "local/WRAPPER-CHECKS.json": "00c62303b0981544f84bacef519b0917212dbe90b11853e10f0bb3074b4aa156", + "native.log": "66ab85b104998334f95b0078b8e6fe859d5d6005f39308d78e8e77e3b38da795", + "phases.log": "c4eeb90b233202d2cbb5a8d98b7e659b252f6603795132f07c30d15be19d9a8c", + "wrappers.log": "074b32c21888efe76c0fbe8d55e9436fd23e0bd4b23c3d8e382350736bdc554b" + }, + "word_sha256": "6bcb3c2c73eaf7558ddc6ef6b484334f8d96b9d2b227e265483b657de00f4bb7" + } + }, + "retained_parent_receipt_sha256": "8e23031a5729041e46882e654b8ea1dba44fc01682cc3bbc354d7e0a126a1d75", + "source_commit": "local-joint12-pr2733", + "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-STANDALONE.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-STANDALONE.json new file mode 100644 index 0000000000..6646251c6f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/NATIVE-STANDALONE.json @@ -0,0 +1,25 @@ +{ + "runner": "new/run_native_borrow.py (PR2745 copy with PR2751 pinned bw_audit_local.py overlay 08d5864d)", + "words": { + "base": { + "steps": [ + "PASS native 0.4", + "PASS ledgers 0.5", + "PASS local-replay 10.1", + "PASS wrappers 2.0", + "PASS phases 94.9" + ], + "rc": "rc 0" + }, + "extra": { + "steps": [ + "PASS native 0.4", + "PASS ledgers 0.5", + "PASS local-replay 10.0", + "PASS wrappers 2.0", + "PASS phases 94.1" + ], + "rc": "rc 0" + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/OWNER-CHECK.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/OWNER-CHECK.json new file mode 100644 index 0000000000..d6c74e2ba0 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/OWNER-CHECK.json @@ -0,0 +1,65 @@ +{ + "removed": [ + 667, + 669 + ], + "dropped_roles": 1332, + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728, + "calls": 666, + "helpers_per_call": 408, + "windows": 1332, + "window_sha256": "d301aa0d102381aecc3dd746c424d55ea6f4ade9f87b833c8db6d643e205c846", + "idle": { + "1": 17316, + "3": 6594, + "5": 9878, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "rank_mass": 4816512 + }, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "idle": { + "1": 17316, + "3": 6594, + "5": 9878, + "8": 0, + "16": 0, + "32": 1, + "48": 26558 + }, + "profile": { + "1": 1603728, + "2": 431568, + "3": 185082, + "4": 85248, + "5": 27194, + "8": 5328, + "32": 1, + "48": 26558 + }, + "root80": "0.0017177949841186346638272299184281789040885843854623122009009272567619811451693129", + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.001717794984118634663827", + "margin_over_candidate": "3.85667783143e-7" +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..065d3aa653 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,18 @@ +wrote /55/_ntn26sn71d4_4mtlsn7_v200000gn/T/tmpfv9jr2nd/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS base rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +wrote /55/_ntn26sn71d4_4mtlsn7_v200000gn/T/tmpxwxk_b0g/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS extra rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW +rc 0 diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REGISTERED-HOOK-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REGISTERED-HOOK-LOG.txt new file mode 100644 index 0000000000..4a2aa3c2d0 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/REGISTERED-HOOK-LOG.txt @@ -0,0 +1,252 @@ +CHECK Literal review: PR2751 construction reproduced, the seven declared stages (retired5 refit5/alias5/refit5c, retired7 refit7/hostmove2/alias7/refit7c) rebuild both candidate words, candidate fill = declared compaction (seven removed helpers), independent symbolic/frame/cleanup checks with six mutations, literal owner fill (R 408) with one mutation, exact adjacent root bracket, claim binding and strict improvement over PR2733, PR2745, PR2751, PR2766 and PR2767. +{ + "status": "PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY", + "roles": 271728, + "local_mutations_rejected": 6, + "owner_mutations_rejected": 1, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "complex_upper": "429448746029658665957/250000000000000000000000", + "scope": "Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate." +} +CHECK Seven-stage structure, the pinned PR2679 auditor on all eight states, 142 tamper controls (retired5: lender refit undone by warp frame mismatch, follower raise undone, 35 alias mutations, corrupted certified frame; retired7: new-lender refit undone by warp frame mismatch, 4 controls per hostee move, the PR2679 alias suite per new alias, corrupted certified frame; every mutant re-derives its cleanup and must be rejected for a real reason), literal owner fill (R 408), 80-digit root and kappa = C - 1e-46 - 1e-70 above PR2751, PR2766 and PR2767. +{ + "words": { + "base": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "extra": { + "refit5_frames": 26, + "alias5_gate_edits": 70, + "refit5c_frames": 32, + "refit7_frames": 2, + "hostmove2_gate_edits": 28, + "alias7_gate_edits": 28, + "refit7c_frames": 2, + "retired7_controls": 25, + "local_profile": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + } + }, + "controls": { + "base": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + }, + "extra": { + "lender 550 refit undone": "RuntimeError: warp frame mismatch (66, 550, (390, 66, 36, 16, 8, 1), (406, 66, 36, 8, 1))", + "lender 551 refit undone": "RuntimeError: warp frame mismatch (67, 551, (385, 66, 34, 16, 9, 6), (385, 66, 36, 22, 9))", + "lender 552 refit undone": "RuntimeError: warp frame mismatch (68, 552, (258, 130, 68, 37, 17, 8), (258, 130, 85, 37, ", + "lender 553 refit undone": "RuntimeError: warp frame mismatch (69, 553, (258, 130, 67, 34, 22, 15), (258, 130, 67, 45,", + "lender 562 refit undone": "RuntimeError: warp frame mismatch (70, 562, (260, 131, 66, 36, 16, 9), (276, 131, 66, 36, ", + "follower 606 raise undone": "RuntimeError: frame not monotone (600, (409, 80, 40, 5, 2), (80, 40, 5, 2))", + "follower 635 raise undone": "RuntimeError: frame not monotone (551, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 637 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 638 raise undone": "RuntimeError: frame not monotone (632, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "follower 639 raise undone": "RuntimeError: frame not monotone (633, (257, 129, 76, 42, 30), (257, 129, 102, 30))", + "606<-550 borrowed read sign flipped": "RuntimeError: target map failed 11", + "606<-550 borrowed read doubled": "RuntimeError: target map failed 11", + "606<-550 borrowed write sign flipped": "RuntimeError: target map failed 63", + "606<-550 warp dropped": "RuntimeError: frame not monotone (550, (406, 66, 36, 8, 1), (409, 80, 40, 5, 2))", + "606<-550 G wrong": "RuntimeError: G(from)!=to", + "606<-550 warp before lender retirement": "RuntimeError: warp frame mismatch (66, 550, (102,), (406, 66, 36, 8, 1))", + "606<-550 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "635<-551 borrowed read sign flipped": "RuntimeError: target map failed 32", + "635<-551 borrowed read doubled": "RuntimeError: target map failed 32", + "635<-551 borrowed write sign flipped": "RuntimeError: target map failed 32", + "635<-551 warp dropped": "RuntimeError: frame not monotone (551, (385, 66, 36, 22, 9), (257, 129, 76, 42, 30))", + "635<-551 G wrong": "RuntimeError: G(from)!=to", + "635<-551 warp before lender retirement": "RuntimeError: warp frame mismatch (67, 551, (102,), (385, 66, 36, 22, 9))", + "635<-551 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "637<-552 borrowed read sign flipped": "RuntimeError: target map failed 32", + "637<-552 borrowed read doubled": "RuntimeError: target map failed 32", + "637<-552 borrowed write sign flipped": "RuntimeError: target map failed 35", + "637<-552 warp dropped": "RuntimeError: frame not monotone (552, (258, 130, 85, 37, 8), (257, 129, 76, 42, 30))", + "637<-552 G wrong": "RuntimeError: G(from)!=to", + "637<-552 warp before lender retirement": "RuntimeError: warp frame mismatch (68, 552, (85,), (258, 130, 85, 37, 8))", + "637<-552 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "638<-553 borrowed read sign flipped": "RuntimeError: target map failed 32", + "638<-553 borrowed read doubled": "RuntimeError: target map failed 32", + "638<-553 borrowed write sign flipped": "RuntimeError: target map failed 45", + "638<-553 warp dropped": "RuntimeError: frame not monotone (553, (258, 130, 67, 45, 22), (257, 129, 76, 42, 30))", + "638<-553 G wrong": "RuntimeError: G(from)!=to", + "638<-553 warp before lender retirement": "RuntimeError: warp frame mismatch (69, 553, (85,), (258, 130, 67, 45, 22))", + "638<-553 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "639<-562 borrowed read sign flipped": "RuntimeError: target map failed 45", + "639<-562 borrowed read doubled": "RuntimeError: target map failed 45", + "639<-562 borrowed write sign flipped": "RuntimeError: target map failed 32", + "639<-562 warp dropped": "RuntimeError: frame not monotone (562, (276, 131, 66, 36, 9), (257, 129, 76, 42, 30))", + "639<-562 G wrong": "RuntimeError: G(from)!=to", + "639<-562 warp before lender retirement": "RuntimeError: warp frame mismatch (70, 562, (75,), (276, 131, 66, 36, 9))", + "639<-562 helper kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "certified frame corrupted": "RuntimeError: frame not monotone (197, (44, 30), (1,))", + "refit7 B911 lender refit undone": "RuntimeError: warp frame mismatch (30, 564, (258, 130, 76, 44, 24, 1), (258, 130, 84, 44, ", + "refit7 B912 lender refit undone": "RuntimeError: warp frame mismatch (31, 565, (258, 130, 74, 43, 25, 6), (258, 130, 74, 45, ", + "move30 401->564 warp lender reverted": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (258, 130, 84, 44, 1))", + "move30 401->564 move undone": "RuntimeError: warp frame mismatch (30, 401, (264, 136, 85, 51), (265, 137, 75, 45))", + "move30 401->564 warp before lender retirement": "RuntimeError: warp frame mismatch (30, 564, (120,), (258, 130, 84, 44, 1))", + "move30 401->564 G wrong": "RuntimeError: G(from)!=to", + "move31 403->565 warp lender reverted": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (258, 130, 74, 45, 31))", + "move31 403->565 move undone": "RuntimeError: warp frame mismatch (31, 403, (264, 136, 85, 51), (265, 137, 75, 45))", + "move31 403->565 warp before lender retirement": "RuntimeError: warp frame mismatch (31, 565, (120,), (258, 130, 74, 45, 31))", + "move31 403->565 G wrong": "RuntimeError: G(from)!=to", + "667<-401 borrowed read sign flipped": "RuntimeError: target map failed 3", + "667<-401 borrowed read doubled": "RuntimeError: target map failed 3", + "667<-401 borrowed write sign flipped": "RuntimeError: target map failed 3", + "667<-401 warp dropped": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667<-401 G wrong": "RuntimeError: G(from)!=to", + "667<-401 warp after the follower's first gate": "RuntimeError: frame not monotone (401, (265, 137, 75, 45), (264, 136, 85, 51))", + "667 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "669<-403 borrowed read sign flipped": "RuntimeError: target map failed 3", + "669<-403 borrowed read doubled": "RuntimeError: target map failed 3", + "669<-403 borrowed write sign flipped": "RuntimeError: target map failed 26", + "669<-403 warp dropped": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669<-403 G wrong": "RuntimeError: G(from)!=to", + "669<-403 warp after the follower's first gate": "RuntimeError: frame not monotone (403, (265, 137, 75, 45), (264, 136, 85, 51))", + "669 kept with an entrance frame": "RuntimeError: start_extra/helper_final must name remaining helpers", + "refit7c certified frame corrupted": "RuntimeError: frame not monotone (381, (258, 130, 85, 45), (1,))" + } + }, + "status": "PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT", + "owner": { + "status": "PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL", + "roles": 271728 + }, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "root_80_digits": "0.00171779498411863466382722991842817890408858438546231220090092725676198114516931", + "kappa": "17177949841186346638269999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "margins": { + "PR2751": { + "decimal": "6.53397770208325718E-7", + "exact": "326698885104162859/500000000000000000000000" + }, + "PR2766": { + "decimal": "5.38010651632355557E-7", + "exact": "538010651632355557/1000000000000000000000000" + }, + "PR2767": { + "decimal": "5.38010651632355556055203093084787388122", + "exact": "K - kappa(evidence/PR2767-OUTER-CLAIM.json)" + } + }, + "scope": "Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py)." +} +CHECK Pinned generic coverage-law ceiling and realized fraction for the candidate, not a sharp packing optimum. +{ + "status": "PASS_FIXED_WORD_PACKING_CEILING", + "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "local_per_call": { + "1": "2382", + "2": "648", + "3": "268", + "4": "128", + "5": "26", + "8": "8" + }, + "dimension": 73, + "families": 896, + "stages": 9, + "centre_rank_per_call": 64, + "max_idle_rank": 51, + "complex_cap_bracket": [ + "1758085934629/1000000000000000", + "175808593463/100000000000000" + ], + "complex_cap_upper_decimal": "0.00175808593463", + "realized_fraction_lower": "1717794984118634663827/1758085934630000000000", + "realized_fraction_decimal": "0.97708249083976386253139135041007810556867284138782", + "scope": "Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used." +} +CHECK Git-free read-only relocation; altered claim/input and optimized execution refusals. +PASS_JOINT_TWELVE_RELOCATED_READ_ONLY_AND_INTEGRITY_CONTROLS +PASS_REGISTERED_RESEARCH_PACKAGE research/t74-joint-twelve-retired7 outcome=completed +rc 0 diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt new file mode 100644 index 0000000000..b5157e14f3 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-REBUILD-BORROW-WORDS-LOG.txt @@ -0,0 +1,17 @@ +wrote /r10/agents/F-lenders/full7/work/admission/release/verify/tmp/tmp5q5z4d_j/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS base rejected 10 of 10 +ALIAS5-CONTROLS base rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS base rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD base cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD base helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING base raised 24 bound True dim1 tamper rejected True +gauge44 {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +wrote /r10/agents/F-lenders/full7/work/admission/release/verify/tmp/tmpws2cgamq/w.json.gz 1901 4504 42 78 +REFIT5-CONTROLS extra rejected 10 of 10 +ALIAS5-CONTROLS extra rc 0 ['ALL CONTROLS REJECTED'] +RETIRED7-CONTROLS extra rc 0 ['ALL RETIRED7 CONTROLS REJECTED 25 of 25'] +CUT-CENTRE-GUARD extra cut gates 176 violations 0 negative control rejected True +HELPER-INDEX-GUARD extra helper_final keys 72 violations 0 negative control (key -1) rejected True +ENTRANCE-WIDTH-BINDING extra raised 24 bound True dim1 tamper rejected True +extra {'rebuild_plus_patches_equals_shipped': True, 'patches': ['refit', 'kernel', 'handoff', 'entrance', 'lowfour', 'alias8', 'prelife', 'refit563', 'alias1', 'refit5', 'alias5', 'refit5c', 'refit7', 'hostmove2', 'alias7', 'refit7c'], 'kernel_edit_exact': True, 'prior_state_audit_rc': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'audit_rc': 0, 'controls_rc': 0, 'lowfour_controls_rc': 0, 'prelife_controls_ok': True, 'refit563_undone_rejected_by_warp_frame_mismatch': True, 'alias1_controls_rc': 0, 'refit5_undone_controls': {'lender550_refit_undone': True, 'lender551_refit_undone': True, 'lender552_refit_undone': True, 'lender553_refit_undone': True, 'lender562_refit_undone': True, 'follower606_raise_undone': True, 'follower635_raise_undone': True, 'follower637_raise_undone': True, 'follower638_raise_undone': True, 'follower639_raise_undone': True}, 'alias5_controls_rc': 0, 'refit5c_tamper_rejected': True, 'retired7_controls_rc': 0, 'kernel_controls_rejected': {'kernel_sign_flipped': True, 'kernel_read_dropped': True, 'kernel_coefficient_doubled': True, 'kernel_read_moved_to_neighbour_register': True, 'alias8_sign_flipped': True, 'alias8_coefficient_doubled': True, 'alias8_warp_dropped': True, 'entrance_start_frame_dropped': True, 'entrance_start_frame_widened': True, 'handoff_sign_flipped': True, 'handoff_coefficient_doubled': True}, 'refit_tamper_rejected': True, 'cut_centre_guard_violations': 0, 'cut_centre_guard_negative_control_rejected': True, 'helper_index_guard_violations': 0, 'helper_index_guard_negative_control_rejected': True, 'entrance_widths_bound_to_providers': True, 'dim1_delivery_rejected': True, 'raised_buffers': 24} +PASS_REBUILD_BORROW diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-RECEIPT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-RECEIPT.json new file mode 100644 index 0000000000..37735f2254 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017177949841186346638269999999999999999999998999999999999999999999999", + "manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 1717794984118634663827/1000000... brackets the ledger's b = 171779498411863466382699999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017177949841186346638269999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 178.29 +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-RESULT.json new file mode 100644 index 0000000000..680f2d73e5 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-RESULT.json @@ -0,0 +1,98 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "1714849224721887/1000000000000000000", + "kappa_decimal": "0.001714849224721887", + "manifest_sha256": "9f55bb569df4ccd8109481ce2d3431d45afc3865e737a47ccb33f2da456d1d55", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 271728, + "prefix_bits": 1443, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19545, + "row_limit": 20161, + "controls": { + "admission": 114, + "bit": 12, + "controller": 15, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.803630419075489, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.18620125018060207 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4626617915928364, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.719976831227541, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.5223765429109335, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 119.44411616958678, + "log_sha256": "f5a192c4bc04d9f0e5dfd66d7637bd407e1b2246b97b3834897addc53628dfd6" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.6294267904013395, + "log_sha256": "4f0c4a586307535773c34b72711598f9a4f87eb530567d16b41c59ac69779af5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.6089366264641285, + "log_sha256": "005e1643b19a9951e0c5715153a44c62abdf540719ec725ae8230081c5f42335" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.5283321235328913, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.94623183272779, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 39.691487001255155, + "log_sha256": "920307b299933c8879b991b2293674236e8cbab497bbf2bfc1bb3af8bdaa4821" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.24792424961924553, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-STAGES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-STAGES.json new file mode 100644 index 0000000000..3686810428 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RELEASE-VERIFY-STAGES.json @@ -0,0 +1,74 @@ +[ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 0.803630419075489, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.18620125018060207 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.4626617915928364, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 2.719976831227541, + "log_sha256": "428588251ab1741a8a8ffc8ceb82234c35b3e3b2cc565d0f83ae861fcacddb0e" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 3.5223765429109335, + "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 119.44411616958678, + "log_sha256": "f5a192c4bc04d9f0e5dfd66d7637bd407e1b2246b97b3834897addc53628dfd6" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.6294267904013395, + "log_sha256": "4f0c4a586307535773c34b72711598f9a4f87eb530567d16b41c59ac69779af5" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.6089366264641285, + "log_sha256": "005e1643b19a9951e0c5715153a44c62abdf540719ec725ae8230081c5f42335" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 0.5283321235328913, + "log_sha256": "4a3b55e95ba8de46777dbfea80494c9610870aca2bdda18a98bc1d4dde62e551" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 13.94623183272779, + "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 39.691487001255155, + "log_sha256": "920307b299933c8879b991b2293674236e8cbab497bbf2bfc1bb3af8bdaa4821" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.24792424961924553, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RESEARCH-TESTS-LOG.txt b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RESEARCH-TESTS-LOG.txt new file mode 100644 index 0000000000..b0448692e4 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RESEARCH-TESTS-LOG.txt @@ -0,0 +1,13 @@ +le> +AssertionError: invalid fixture +Traceback (most recent call last): + File "", line 1, in +AssertionError: invalid fixture +....CHECK Scoped test fixture +PASS_REGISTERED_RESEARCH_PACKAGE research/fixture outcome=partial +CHECK Scoped test fixture +................sss...... +---------------------------------------------------------------------- +Ran 69 tests in 5.817s + +OK (skipped=3) diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RUNTIME-PATCHES.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RUNTIME-PATCHES.json new file mode 100644 index 0000000000..ce6e8881de --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/RUNTIME-PATCHES.json @@ -0,0 +1,32 @@ +[ + { + "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": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce", + "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800", + "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" + ] + ] + } +] diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/STAGES7.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/STAGES7.json new file mode 100644 index 0000000000..1e3fe61a7d --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/STAGES7.json @@ -0,0 +1,136 @@ +{ + "base": { + "refit7": 2, + "hostmove2_edits": 28, + "alias2_edits": 28, + "refit7c": [ + [ + "B", + 1170 + ], + [ + "B", + 1171 + ] + ], + "profiles": { + "refit7": { + "1": 2388, + "2": 646, + "3": 268, + "4": 130, + "5": 26, + "8": 8 + }, + "hostmove2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 28, + "8": 8 + }, + "alias2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "retired7": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "audits": { + "refit7": [ + 0, + "PASS" + ], + "hostmove2": [ + 0, + "PASS" + ], + "alias2": [ + 0, + "PASS" + ], + "retired7": [ + 0, + "PASS" + ] + } + }, + "extra": { + "refit7": 2, + "hostmove2_edits": 28, + "alias2_edits": 28, + "refit7c": [ + [ + "B", + 1170 + ], + [ + "B", + 1171 + ] + ], + "profiles": { + "refit7": { + "1": 2388, + "2": 646, + "3": 268, + "4": 130, + "5": 26, + "8": 8 + }, + "hostmove2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 28, + "8": 8 + }, + "alias2": { + "1": 2386, + "2": 646, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + }, + "retired7": { + "1": 2382, + "2": 648, + "3": 268, + "4": 128, + "5": 26, + "8": 8 + } + }, + "audits": { + "refit7": [ + 0, + "PASS" + ], + "hostmove2": [ + 0, + "PASS" + ], + "alias2": [ + 0, + "PASS" + ], + "retired7": [ + 0, + "PASS" + ] + } + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/evidence/retired7/VERIFY-RESULT.json b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/VERIFY-RESULT.json new file mode 100644 index 0000000000..8b8cb29852 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/evidence/retired7/VERIFY-RESULT.json @@ -0,0 +1,9 @@ +{ + "status": "PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY", + "roles": 271728, + "local_mutations_rejected": 6, + "owner_mutations_rejected": 1, + "complex_lower": "1717794984118634663827/1000000000000000000000000", + "complex_upper": "429448746029658665957/250000000000000000000000", + "scope": "Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate." +} diff --git a/research/tensor-block-kappa/vendor/frontier/exact_moment.py b/research/tensor-block-kappa/vendor/frontier/exact_moment.py new file mode 100644 index 0000000000..30dc8aa229 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/exact_moment.py @@ -0,0 +1,51 @@ +# SPDX-License-Identifier: Apache-2.0 +# Tekalign with substantial OpenAI Codex assistance. +from fractions import Fraction as F +DIMENSION=73 +def require(condition, message): + if not condition: + raise ValueError(message) + + +def log_reduced(x): + """Forty atanh terms with their positive geometric tail.""" + require(1 <= x <= 2, 'log reduction range') + t = (x - 1) / (x + 1) + lower = sum((2 * t ** (2 * j + 1) / (2 * j + 1) + for j in range(40)), F(0)) + tail = 2 * t ** 81 / (81 * (1 - t * t)) + return lower, lower + tail + + +def log_bounds(x): + require(x >= 1, 'positive logarithm range') + power = 0 + while x >= 2: + x /= 2 + power += 1 + a, b = log_reduced(x) + c, d = log_reduced(F(2)) + return a + power * c, b + power * d + + +def exp_bounds(x): + """Taylor terms 0..15; later term ratios are bounded by x/17.""" + require(0 <= x < F(1, 100), 'exponential argument range') + term, lower = F(1), F(1) + for n in range(1, 16): + term = term * x / n + lower += term + tail = term * x / 16 / (1 - x / 17) + return lower, lower + tail + + +def moment_bounds(profile, exponent): + lower = upper = F(0) + for rank, count in sorted(profile.items()): + log_lo, log_hi = log_bounds(F(DIMENSION, rank)) + exp_lo, _ = exp_bounds(exponent * log_lo) + _, exp_hi = exp_bounds(exponent * log_hi) + weight = F(count * rank, DIMENSION) + lower += weight * exp_lo + upper += weight * exp_hi + return lower, upper diff --git a/research/tensor-block-kappa/vendor/frontier/full_replay.py b/research/tensor-block-kappa/vendor/frontier/full_replay.py new file mode 100644 index 0000000000..d9718b8b5b --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/full_replay.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Cold reproduction of the joint twelve-source/pre-life composition. + +Default: authenticated source download, fresh native providers and retained +parent admission, then the complete original supplier/release verifier. An +explicit --prepared-native-cache must match every published reuse file hash. +All large/generated artifacts remain under a fresh external --work directory. +""" +import argparse +from concurrent.futures import ThreadPoolExecutor +from fractions import Fraction as Q +import gzip +import hashlib +import importlib +import json +import os +from pathlib import Path, PurePosixPath +import platform +import shutil +import subprocess +import sys +import tarfile +import threading +import time +from urllib.parse import quote +from urllib.request import Request, urlopen + +HERE = Path(__file__).resolve().parent +REPOSITORY = HERE.parents[1] +STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +def tree(root, exclude=()): + result = {} + for path in sorted(root.rglob('*')): + need(not path.is_symlink(), 'unauthenticated 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 safe(name): + path = PurePosixPath(name) + need(isinstance(name, str) and '\\' not in name and path.parts and not path.is_absolute() + and '..' not in path.parts and path.as_posix() == name, 'unsafe source path') + + +def download(url, expected): + for attempt in range(3): + try: + req = Request(url, headers={'User-Agent': 'integer-mult-prelife-priority/1', 'Accept-Encoding': 'identity'}) + with urlopen(req, timeout=90) as response: + body = response.read() + need(hashlib.sha256(body).hexdigest() == expected, 'download hash mismatch') + return body + except (OSError, RuntimeError): + if attempt == 2: + raise + time.sleep(attempt + 1) + + +def source_copy(source, destination, pins, jobs): + destination.mkdir() + entries = {'MANIFEST.json': pins['manifest_sha256'], **pins['files']} + need(len(pins['files']) == pins['count'] == 491, 'source file count') + + def copy(item): + name, digest = item + safe(name) + target = destination / name + target.parent.mkdir(parents=True, exist_ok=True) + if source: + need(not (source / name).is_symlink(), 'source symlink') + body = (source / name).read_bytes() + need(hashlib.sha256(body).hexdigest() == digest, 'source bytes: ' + name) + else: + body = download(pins['base_url'] + quote(name, safe='/'), digest) + target.write_bytes(body) + + with ThreadPoolExecutor(max_workers=min(jobs, 8)) as pool: + for _ in pool.map(copy, sorted(entries.items())): + pass + need(read(destination / 'MANIFEST.json') == pins['files'] + and tree(destination) == entries, 'complete source authentication') + + +def bind_native(entry, word): + need(gzip.decompress((entry / 'local/FULL-WORD.json.gz').read_bytes()) == gzip.decompress(word.read_bytes()), + 'native complete word binding') + stages = read(entry / 'STEPS.json') + need([s['step'] for s in stages] == STEPS and all(s['exit_code'] == 0 for s in stages), 'native stage coverage') + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--source', type=Path, help='Exact original PR2679 package directory; otherwise download pinned files.') + ap.add_argument('--work', type=Path, required=True) + ap.add_argument('--prepared-native-cache', type=Path, help='Explicit reuse of the complete published pinned cache.') + ap.add_argument('--jobs', type=int, default=4) + a = ap.parse_args() + need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required') + versions = {} + for name in ('numpy', 'sympy', 'scipy', 'mpmath'): + try: + versions[name] = str(importlib.import_module(name).__version__) + except ImportError as exc: + raise RuntimeError('install requirements.txt in this Python environment before full replay') from exc + need(versions['sympy'] == '1.14.0', 'pinned predecessor evidence requires sympy==1.14.0') + work = a.work.resolve() + need(not work.exists() and not work.is_relative_to(REPOSITORY), 'fresh external work required') + for path in (a.source, a.prepared_native_cache): + need(path is None or (path.is_dir() and not work.is_relative_to(path.resolve())), 'input/work separation') + pins, reuse, claim = read(HERE / 'SOURCE-FILES.json'), read(HERE / 'REUSE-PINS.json'), read(HERE / 'CLAIM.json') + work.mkdir(parents=True) + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0', + OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1') + for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'): + env.pop(name, None) + stages, lock = [], threading.Lock() + started = time.monotonic() + + def run(name, script, *args): + begin = time.monotonic() + log = work / (name + '.log') + command = [sys.executable, '-B', str(script), *map(str, args)] + with log.open('w') as output: + result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL, + stdout=output, stderr=subprocess.STDOUT) + with lock: + stages.append(dict(name=name, command=command, exit_code=result.returncode, + script_sha256=sha(script), seconds=time.monotonic()-begin, log_sha256=sha(log))) + write(work / 'STAGES.json', stages) + need(result.returncode == 0, 'failed ' + name + '; see ' + str(log)) + print('PASS', name, flush=True) + + run('literal-review', HERE / 'verify.py') + source = work / 'source' + source_copy(a.source.resolve() if a.source else None, source, pins, a.jobs) + overlay = read(HERE / 'OVERLAY-PINS.json') + need(sha(source/'MANIFEST.json') == overlay['original_manifest_sha256'], 'overlay base manifest') + need(sha(HERE/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive') + with tarfile.open(HERE/'DERIVATIVE-OVERLAY.tar.gz') as archive: + members=archive.getmembers() + need(set(m.name for m in members)==set(overlay['files']) and len(members)==len(overlay['files']), 'exact overlay paths') + for member in members: + safe(member.name);need(member.isfile(), 'regular overlay file') + body=archive.extractfile(member).read() + need(hashlib.sha256(body).hexdigest()==overlay['files'][member.name], 'overlay member hash') + (source/member.name).write_bytes(body) + need(sha(source/'MANIFEST.json')==overlay['derived_manifest_sha256'] and + tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'), 'complete derived source tree') + pins=dict(pins,commit='local-joint12-pr2733',manifest_sha256=overlay['derived_manifest_sha256']) + cache = work / 'native-cache' + if a.prepared_native_cache: + need(tree(a.prepared_native_cache.resolve()) == reuse['cache_files'], 'published complete cache pins') + shutil.copytree(a.prepared_native_cache.resolve(), cache) + native_receipt = reuse + else: + cache.mkdir() + layout = work / 'retained-layout' + layout.mkdir() + old = source / 'vendor/pr1297' + 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()), 'retained archive paths') + archive.extractall(layout, filter='data') + retained_driver = layout / 'joint1148-round45/source/research/k8-eight-ends/replay_native.py' + words = {'base': source / 'new/borrow/words/BORROW-WORD-43base.json.gz', + 'extra': source / 'new/borrow/words/BORROW-WORD-43extra.json.gz', + 'retained-base': old / 'gauge44-word.json.gz', 'retained-extra': old / 'extra-word.json.gz'} + + def fresh_native(tag): + word = words[tag] + entry = cache / sha(word) + script = retained_driver if tag.startswith('retained-') else source / 'new/run_native_borrow.py' + run('native-' + tag, script, word, entry) + bind_native(entry, word) + write(entry / 'CACHE.json', dict(word_sha256=sha(word), files=tree(entry))) + + with ThreadPoolExecutor(max_workers=min(a.jobs, 4)) as pool: + for _ in pool.map(fresh_native, words): + pass + run('retained-parent', old / 'verify.py', '--work', work / 'retained-parent', + '--base-native-from', cache / sha(words['retained-base']), + '--extra-native-from', cache / sha(words['retained-extra'])) + parent = read(work / 'retained-parent/RESULT.json') + need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION' + and parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'fresh retained parent admission') + pm = sha(old / 'MANIFEST.json') + receipts = cache / '_receipts' / pm + receipts.mkdir(parents=True) + for name in ('RESULT.json', 'STAGES.json'): + shutil.copy2(work / 'retained-parent' / name, receipts / name) + write(receipts / 'RECEIPT.json', dict(schema='parent-receipt/1', vendor_manifest_sha256=pm, + claim_sha256=sha(old / 'CLAIM.json'), words={tag:sha(words['retained-'+tag]) for tag in ('base','extra')}, + files={name:sha(receipts / name) for name in ('RESULT.json','STAGES.json')})) + providers = {tag:dict(word_sha256=sha(words[tag]), complete_native_files=tree(cache / sha(words[tag]), ('CACHE.json',))) + for tag in ('base','extra')} + native_receipt = dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE', + source_commit=pins['commit'], manifest_sha256=pins['manifest_sha256'], providers=providers, + retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), cache_files=tree(cache)) + write(work / 'NATIVE-RECEIPT.json', native_receipt) + run('complete-admission', HERE / 'workflow/admit.py', '--source', source, + '--fill', HERE / 'inputs/FILL.json.gz', '--order', HERE / 'inputs/ORDER.json', + '--native-cache', cache, '--native-receipt', work / 'NATIVE-RECEIPT.json', + '--work', work / 'admission', '--jobs', a.jobs) + result = read(work / 'admission/RESULT.json') + need(result['status'] == 'PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE' + and Q(result['kappa']) == Q(claim['kappa']) and Q(result['complex_lower']) == Q(claim['complex_lower']), + 'published complete claim binding') + need(result['profile'] == {str(k):v for k,v in read(HERE / 'CLAIM.json')['profile'].items()}, 'published complete profile binding') + result.update(status='PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache), + source_files_sha256=sha(HERE / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'), + cold_stages=stages, cold_seconds=time.monotonic()-started, + environment=dict(python=platform.python_version(), executable=sys.executable, versions=versions)) + write(work / 'RESULT.json', result) + print(result['status'], result['kappa_decimal'], flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/tensor-block-kappa/vendor/frontier/generate.py b/research/tensor-block-kappa/vendor/frontier/generate.py new file mode 100644 index 0000000000..dafca20149 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/generate.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Rebuild the changed twelve-alias word and PR2679 pre-life/refit composition. +Pristine source is authenticated; only a fresh output directory is written. +""" +from pathlib import Path +import argparse,copy,gzip,hashlib,json,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import joint_engine as J +ASSIGNMENTS=[(696,33,49),(697,55,101),(698,74,83),(700,85,98),(680,49,33),(681,83,74),(682,98,85),(684,101,55),(688,68,4),(689,80,88),(690,88,80),(692,31,12)] +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(p): + b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def wr(p,w):p.write_bytes(gzip.compress((json.dumps(w,sort_keys=True,separators=(',',':'))+'\n').encode(),mtime=0)) +def main(): + need(__debug__,'assertions must be enabled') + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args() + source=a.source.resolve();out=a.out.resolve();pins=rd(HERE/'GENERATOR-PINS.json') + sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() + need(sha(source/'MANIFEST.json')==pins['pr2679_manifest'],'PR2679 source manifest') + need(all(sha(source/k)==v for k,v in rd(source/'MANIFEST.json').items()),'complete source files') + need(all(sha(HERE/k)==v for k,v in pins['vendor'].items()),'vendor sources') + need(not out.exists() and not out.is_relative_to(source),'fresh separate output required');out.mkdir(parents=True) + S=source/'new/borrow';sys.path[:0]=[str(S),str(S/'prelife/search')] + import build_word,word_patch as W,prelife2 as P,repair2,alias_build as AB,audit_local as AU + for canon,tag,h in [('gauge44','base','eeb6a236'),('extra','extra','cd417b90')]: + f=out/f'canonical-{tag}.json.gz';build_word.main(str(S/f'inputs/{canon}.canonical.json.gz'),str(S/'inputs/blocks.json'),str(S/f'inputs/witness_43_{tag}.json'),str(f),h);w=rd(f) + patch=rd(S/f'inputs/refit_43{tag}.json') + for sec,i,frame in patch['frames']:w[sec][i][-1]=frame + w['report']['local_profile']=patch['local_profile'];w['cleanup']=W.derive_cleanup(w,W.restored_of(w)) + w=W.apply_kernel(w,rd(S/f'inputs/kernel_43{tag}.json')) + for name in ['handoff','entrance']:w=W.apply_handoff(w,rd(S/f'inputs/{name}_43{tag}.json')) + need(W.apply_lowfour(w,rd(S/f'inputs/lowfour_43{tag}.json'))==rd(HERE/f'inputs/POSITIVE2462-{tag}.json.gz'),'complete PR2462 positive reconstruction') + w['prelude_events']=0;w=J.make(source,out/'joint',tag,seed=w,assignments=ASSIGNMENTS) + patch=rd(S/f'inputs/prelife_43{tag}.json') + for pair in patch['pairs']: + host,borrower=pair['h'],pair['L'];E=next(x[4] for x in patch['fields']['warps'][58:] if x[1]==host) + P.TRACE,_=repair2.run(copy.deepcopy(w),None);w=P.build(w,borrower,host,E) + indices=[i for i,g in enumerate(w['B']) if g[:5]==['add',515,563,1,1]];need(len(indices)==1,'unique refit gate') + w['B'][indices[0]][-1]=rd(S/f'inputs/refit563_43{tag}.json')['frames'][0][-1] + w,_=AB.alias(w,653,563);lp,wi=AB.profile(w);w['report'].update(local_profile=lp,width_inventory=wi) + f=out/f'WORD-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD2751-{tag}.json.gz'),'complete regenerated PR2751 word equality') + # retired5 + retired7: the declared stages refit5 -> alias5 -> refit5c -> refit7 -> hostmove2 -> alias7 -> refit7c turn the regenerated PR2751 word into the candidate word + for st in ('refit5','alias5','refit5c','refit7','hostmove2','alias7','refit7c'): + p_=rd(HERE/f'inputs/{st}_43{tag}.json') + if st in ('alias5','hostmove2','alias7'):w=W.apply_lowfour(w,p_) + else: + w=copy.deepcopy(w) + for sec,i,frame in p_['frames']:need(w[sec][i][:-1]==rd(f)[sec][i][:-1] or st in ('refit5c','refit7','refit7c'),'refit gate');w[sec][i][-1]=frame + w['report']['local_profile']=p_['local_profile'] + f=out/f'WORD-retired7-{tag}.json.gz';wr(f,w);AU.run(f,out/f'audit-retired7-{tag}.json') + need(rd(f)==rd(HERE/f'inputs/WORD-{tag}.json.gz'),'complete regenerated candidate word equality') + print('PASS_REGENERATED_JOINT_TWELVE_RETIRED7_BOTH_WORDS') +if __name__=='__main__':main() diff --git a/research/tensor-block-kappa/vendor/frontier/independent_local.py b/research/tensor-block-kappa/vendor/frontier/independent_local.py new file mode 100644 index 0000000000..e0b556adc3 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/independent_local.py @@ -0,0 +1,161 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Mason Hale/Codex PR2696 literal replay, extended by Tekalign/Codex. +Adds anticipatory corrections, checks six pre-life hosts and checks all twelve +source-recovery assertions at operator IDs47 through58. +""" +import json,gzip,hashlib +from collections import Counter,defaultdict +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +@lru_cache(None) +def span(vs): + s={0} + for v in vs:s|={x^v for x in tuple(s)} + return frozenset(s) +def S(vs):return span(tuple(vs)) +def rank(vs):return len(S(vs)).bit_length()-1 +def dm(s):return len(s).bit_length()-1 +FULL=S([1<>i&1:a^=c + return a +def regs(g):return g[1:3] if g[0]=='add' else g[1:2] +def nt(r):return not 112<=r<224 +def load(p):return json.loads(gzip.decompress(p.read_bytes())) +def chronological(w): + d=defaultdict(list) + for op,(p,r,*_) in enumerate(w['warps'],1):d[p].append(['warp',r,op]) + b=[] + for i in range(len(w['B'])+1): + b+=d[i] + if i0 else (new,old) + assert frozenset(im(cols,x) for x in S(a))==S(b) + cur[r]=S(new) + for g in w['A']: + if g[0]=='warp':warp(*g[1:]) + else: + for r in regs(g):climb(r,g[-1]) + bysection['A']=dict(counts);prev=counts.copy() + lev={int(k):S(v) for k,v in w['target_levels'].items()} + assert all(cur[112+t]==lev.get(t,S([])) for t in range(112)) + paths=[] + for r,vs in zip(w['centers'],w['center_frames']): + s=S(vs);assert cur[r]==s + targets=[g[1]-112 for g in w['cut'] if g[2]==r] + frames=sorted({lev.get(t,S([])) for t in targets},key=lambda s:-len(s)) + ds=[] + for f in frames: + assert f<=s + d=dm(s)-dm(f) + if d:counts[d]+=1;ds.append(d) + s=f + paths.append({'center':r,'start_rank':rank(vs),'target_offsets':targets,'reader_lines':[sorted(f-{0}) for f in frames],'paid_degrees':ds}) + bysection['cut']=dict(counts-prev);prev=counts.copy() + ops=defaultdict(list) + for op,rec in enumerate(w['warps'],1):ops[rec[0]].append((op,rec)) + for i in range(len(w['B'])+1): + for op,(_,r,cols,old,new) in ops[i]:warp(r,op,old,new) + if i=224) + assert counts==Counter({int(k):v for k,v in w['report']['local_profile'].items()}) + assert inventory==Counter({int(k):v for k,v in w['report']['width_inventory'].items()}) + return {'profile':dict(sorted(counts.items())),'section_profiles':bysection,'inventory':dict(sorted(inventory.items())),'center_paths':paths},start,ends + +def check_cleanup(w): + restored=set(map(int,w['helper_final'])) + cold=lambda r:r+704 if r in restored else r + forward=w['A'][w['prelude_events']:]+chronological(w)+w['restore'] + expected=[] + for g in reversed(forward): + if g[0]=='warp':expected.append(['warp',cold(g[1]),-g[2]]) + elif nt(g[1]): + if g[0]=='add':expected.append(['add',cold(g[1]),cold(g[2]),-g[3],g[4]]) + else:expected.append(['scale',cold(g[1]),g[3],g[2]]) + assert expected==[g[:-1] for g in w['cleanup']] + assert all(S(g[-1])==FULL for g in w['cleanup']) + return len(expected) + +def algebra(w): + # A monomial records its operations oldest-first; appending an inverse + # cancels the newest symbol. No native/generator/audit modules imported. + live=set(range(704))-set(w['removed']);cold=set(map(int,w['helper_final'])) + assert all(112<=x['target']<224 and x['source'] in {273,275,289,291,305,321} for x in w['initial_corrections']) + program=[['correction',x] for x in w['initial_corrections']]+w['precondition']+w['compensation']+w['A']+w['cut']+chronological(w)+w['restore'] + result={} + for dual in [False,True]: + rows={r:{(r,()):F(1)} for r in live} + rows.update({704+r:{} for r in cold}) + def apply(g): + op=g[0] + if op=='correction': + x=g[1];t,s=x['target'],x['source'];q=F(x['coefficient']) + ops=list(reversed(x['operator_word'])) + if dual: + t,s,q=s,t,-q + ops=[-(abs(v)+1000)*(1 if v>0 else -1) for v in x['operator_word']] + for (r,word),c in list(rows[s].items()): + for v in ops:word=word[:-1] if word and word[-1]==-v else word+(v,) + key=(r,word);value=rows[t].get(key,F(0))+q*c + if value:rows[t][key]=value + else:rows[t].pop(key,None) + elif op=='add': + t,s=g[1:3];q=F(g[3],g[4]);assert t!=s + if dual:t,s,q=s,t,-q + for term,c in list(rows[s].items()): + v=rows[t].get(term,F(0))+q*c + if v:rows[t][term]=v + else:rows[t].pop(term,None) + elif op=='scale': + q=F(g[2],g[3]);q=1/q if dual else q + rows[g[1]]={term:q*c for term,c in rows[g[1]].items()} + elif op=='warp': + d=g[2] + if not dual and 460 else -1) + rows[g[1]]={(r,word[:-1] if word and word[-1]==-d else word+(d,)):c for (r,word),c in rows[g[1]].items()} + else:raise AssertionError(op) + for g in program:apply(g) + if not dual: + assert all(rows[112+t]=={(112+t,()):F(1),(t,()):F(1)} for t in range(112)) + assert all(rows[r]=={(r,()):F(1)} for r in cold) + assert all(not any(var in cold-{r} for (var,word) in rows[r]) for r in live) + for g in w['cleanup']:apply(g) + for r in live: + exp={(r,()):F(1)} + if dual and r<112:exp[(112+r,())]=F(-1) + if not dual and 112<=r<224:exp[(r-112,())]=F(1) + assert rows[r]==exp,(dual,r,rows[r]) + assert all(not rows[704+r] for r in cold) + result['dual' if dual else 'forward']='PASS' + return result diff --git a/research/tensor-block-kappa/vendor/frontier/independent_owners.py b/research/tensor-block-kappa/vendor/frontier/independent_owners.py new file mode 100644 index 0000000000..b196522f05 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/independent_owners.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Independent integer-time chronology and bit-mask whole-fill verification. + +No retained window code, donor generator, solver or native checker is imported. +Credit PR2679's pre-life/refit words, PR2673/PR2621 priority scheduling, +PR2588's swapped words, PR2559's evacuation, PR2530's source-partner +fill and the PR2462/PR2322/PR2436 lineage; +Hao Yan and the retained controller authors supply the underlying schedule. +This checks a finite hosting witness, not native circuitry or an exponent. +""" +import argparse +import sys +sys.dont_write_bytecode=True +import gzip +import hashlib +import json +from collections import Counter +from pathlib import Path + + +def need(ok, why): + if not ok: + raise RuntimeError(why) + + +def windows(template, order): + 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,'event before first call') + blocks[stage].append(event) + progression=[0]*74;last={};result={} + for t,(stage,replica) in enumerate(order): + need(0<=replica<74 and stage==progression[replica],'order chronology') + progression[replica]+=1 + for j,event in enumerate(blocks[stage]): + kind=event['kind'] + if kind=='local_cover_sweep': + need(j==0,'local call position') + last[replica,pairs[stage]]=t + elif kind=='bridge': + last[replica,event['src']]=last[replica,event['dst']]=t + elif kind=='idle_cover_sweep': + need(j>0,'idle 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) + need(progression==[9]*74,'complete replica progression') + return result + + +def check(plan, template, order, fill, providers, initial_dispatch, expected_profile): + need(len(order)==666 and len(set(map(tuple,order)))==666,'call coverage') + win=windows(template,order) + dispatch=dict(initial_dispatch) + for s,r,pid in fill['dispatch_overrides']: + need((s,r) in dispatch and pid in providers,'dispatch override') + dispatch[s,r]=pid + need(set(dispatch)==set(map(tuple,order)),'dispatch coverage') + need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns') + R=len(next(iter(providers.values()))['widths']) # retired5: helper count from the providers (was 415) + need(len(fill['rows'])==666*R,'role count') + need(all(len(p['widths'])==R for p in providers.values()),'helper widths') + helper_bits=[0]*666;family_bits=[0]*666;occupied={} + for row in fill['rows']: + need(len(row)==6 and all(type(v) is int for v in row),'role shape') + t,h,o,c,port,offset=row + need(0<=t<666 and 0<=h 5, the exact propagated floor) and raises each follower's first gate (606, 635, 637, 638, 639: dim 4 -> 5, the exact ceiling), with their meet/join closures; gates unchanged", + "frames": [ + [ + "B", + 901, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 902, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 903, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 909, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 910, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "B", + 947, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 948, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 949, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 951, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 952, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1024, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1025, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1026, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1027, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1028, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1029, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1030, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1031, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1032, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1033, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1034, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1035, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1040, + [ + 257, + 129, + 67, + 37, + 17, + 15 + ] + ], + [ + "B", + 1041, + [ + 257, + 129, + 68, + 34, + 22, + 8 + ] + ], + [ + "B", + 1042, + [ + 257, + 129, + 76, + 40, + 28, + 2 + ] + ], + [ + "B", + 1043, + [ + 257, + 129, + 73, + 42, + 27, + 5 + ] + ] + ], + "local_profile": { + "1": 2401, + "2": 639, + "3": 278, + "4": 129, + "5": 26, + "8": 8 + }, + "refit_log": [ + { + "h": 606, + "L": 550, + "lowered": [ + [ + 11940, + 6, + 5 + ] + ], + "raised": [ + [ + 11993, + 4, + 5 + ], + [ + 11994, + 4, + 5 + ], + [ + 11995, + 4, + 5 + ], + [ + 11997, + 4, + 5 + ], + [ + 11998, + 4, + 5 + ] + ] + }, + { + "h": 635, + "L": 551, + "lowered": [ + [ + 11941, + 6, + 5 + ] + ], + "raised": [ + [ + 12082, + 4, + 5 + ], + [ + 12083, + 4, + 5 + ], + [ + 12084, + 4, + 5 + ], + [ + 12085, + 4, + 5 + ], + [ + 12086, + 4, + 5 + ], + [ + 12087, + 4, + 5 + ], + [ + 12088, + 4, + 5 + ], + [ + 12089, + 4, + 5 + ], + [ + 12090, + 4, + 5 + ], + [ + 12091, + 4, + 5 + ], + [ + 12092, + 4, + 5 + ], + [ + 12093, + 4, + 5 + ], + [ + 12098, + 5, + 6 + ], + [ + 12099, + 5, + 6 + ], + [ + 12100, + 5, + 6 + ], + [ + 12101, + 5, + 6 + ] + ] + }, + { + "h": 637, + "L": 552, + "lowered": [ + [ + 11948, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 638, + "L": 553, + "lowered": [ + [ + 11949, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 639, + "L": 562, + "lowered": [ + [ + 11942, + 6, + 5 + ] + ], + "raised": [] + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit5_43extra.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit5_43extra.json new file mode 100644 index 0000000000..73fa6c445a --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit5_43extra.json @@ -0,0 +1,473 @@ +{ + "kind": "FRAME_REFIT_FOR_FIVE_ALIASES", + "credit": "exact minimal-change frame refit for the five retired-lender aliases (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): new/borrow/refit/search lowers each lender's last gate (550, 551, 552, 553, 562: dim 6 -> 5, the exact propagated floor) and raises each follower's first gate (606, 635, 637, 638, 639: dim 4 -> 5, the exact ceiling), with their meet/join closures; gates unchanged", + "frames": [ + [ + "B", + 901, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 902, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 903, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 909, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 910, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "B", + 947, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 948, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 949, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 951, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 952, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1024, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1025, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1026, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1027, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1028, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1029, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1030, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1031, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1032, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1033, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1034, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1035, + [ + 257, + 129, + 76, + 42, + 30 + ] + ], + [ + "B", + 1040, + [ + 257, + 129, + 67, + 37, + 17, + 15 + ] + ], + [ + "B", + 1041, + [ + 257, + 129, + 68, + 34, + 22, + 8 + ] + ], + [ + "B", + 1042, + [ + 257, + 129, + 76, + 40, + 28, + 2 + ] + ], + [ + "B", + 1043, + [ + 257, + 129, + 73, + 42, + 27, + 5 + ] + ] + ], + "local_profile": { + "1": 2401, + "2": 639, + "3": 278, + "4": 129, + "5": 26, + "8": 8 + }, + "refit_log": [ + { + "h": 606, + "L": 550, + "lowered": [ + [ + 11940, + 6, + 5 + ] + ], + "raised": [ + [ + 11993, + 4, + 5 + ], + [ + 11994, + 4, + 5 + ], + [ + 11995, + 4, + 5 + ], + [ + 11997, + 4, + 5 + ], + [ + 11998, + 4, + 5 + ] + ] + }, + { + "h": 635, + "L": 551, + "lowered": [ + [ + 11941, + 6, + 5 + ] + ], + "raised": [ + [ + 12082, + 4, + 5 + ], + [ + 12083, + 4, + 5 + ], + [ + 12084, + 4, + 5 + ], + [ + 12085, + 4, + 5 + ], + [ + 12086, + 4, + 5 + ], + [ + 12087, + 4, + 5 + ], + [ + 12088, + 4, + 5 + ], + [ + 12089, + 4, + 5 + ], + [ + 12090, + 4, + 5 + ], + [ + 12091, + 4, + 5 + ], + [ + 12092, + 4, + 5 + ], + [ + 12093, + 4, + 5 + ], + [ + 12098, + 5, + 6 + ], + [ + 12099, + 5, + 6 + ], + [ + 12100, + 5, + 6 + ], + [ + 12101, + 5, + 6 + ] + ] + }, + { + "h": 637, + "L": 552, + "lowered": [ + [ + 11948, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 638, + "L": 553, + "lowered": [ + [ + 11949, + 6, + 5 + ] + ], + "raised": [] + }, + { + "h": 639, + "L": 562, + "lowered": [ + [ + 11942, + 6, + 5 + ] + ], + "raised": [] + } + ] +} diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43base.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43base.json new file mode 100644 index 0000000000..6779edb0aa --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43base.json @@ -0,0 +1,297 @@ +{ + "kind": "FRAME_REFIT_CERTIFIED_OPTIMAL_ALIASED", + "credit": "certified optimal frames of the aliased program (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): our #1186 toolkit optimal_frames on the borrow-word model of new/borrow/audit_local.py; gates, warps, start/final frames, compensation and widths unchanged", + "frames": [ + [ + "A", + 0, + [] + ], + [ + "A", + 1, + [] + ], + [ + "A", + 2, + [] + ], + [ + "A", + 3, + [] + ], + [ + "A", + 4, + [] + ], + [ + "A", + 5, + [] + ], + [ + "A", + 6, + [] + ], + [ + "A", + 7, + [] + ], + [ + "A", + 8, + [] + ], + [ + "A", + 9, + [] + ], + [ + "A", + 10, + [] + ], + [ + "A", + 11, + [] + ], + [ + "B", + 771, + [ + 392, + 64, + 33, + 17, + 3 + ] + ], + [ + "B", + 773, + [ + 395, + 64, + 33, + 18, + 4 + ] + ], + [ + "B", + 776, + [ + 259, + 132, + 76, + 33, + 18 + ] + ], + [ + "B", + 778, + [ + 260, + 131, + 76, + 33, + 18 + ] + ], + [ + "B", + 783, + [ + 390, + 65, + 33, + 19, + 13 + ] + ], + [ + "B", + 788, + [ + 257, + 134, + 64, + 33, + 30 + ] + ], + [ + "B", + 941, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 942, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 943, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 944, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 945, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 946, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 950, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1148, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 1149, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 1150, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 1151, + [ + 259, + 148, + 66, + 36, + 9 + ] + ], + [ + "B", + 1168, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 1169, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "restore", + 60, + [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + ] + ], + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43extra.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43extra.json new file mode 100644 index 0000000000..6779edb0aa --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit5c_43extra.json @@ -0,0 +1,297 @@ +{ + "kind": "FRAME_REFIT_CERTIFIED_OPTIMAL_ALIASED", + "credit": "certified optimal frames of the aliased program (retired5: Marius-Paul Dumitrean, with substantial AI assistance, Anthropic Claude via Claude Code): our #1186 toolkit optimal_frames on the borrow-word model of new/borrow/audit_local.py; gates, warps, start/final frames, compensation and widths unchanged", + "frames": [ + [ + "A", + 0, + [] + ], + [ + "A", + 1, + [] + ], + [ + "A", + 2, + [] + ], + [ + "A", + 3, + [] + ], + [ + "A", + 4, + [] + ], + [ + "A", + 5, + [] + ], + [ + "A", + 6, + [] + ], + [ + "A", + 7, + [] + ], + [ + "A", + 8, + [] + ], + [ + "A", + 9, + [] + ], + [ + "A", + 10, + [] + ], + [ + "A", + 11, + [] + ], + [ + "B", + 771, + [ + 392, + 64, + 33, + 17, + 3 + ] + ], + [ + "B", + 773, + [ + 395, + 64, + 33, + 18, + 4 + ] + ], + [ + "B", + 776, + [ + 259, + 132, + 76, + 33, + 18 + ] + ], + [ + "B", + 778, + [ + 260, + 131, + 76, + 33, + 18 + ] + ], + [ + "B", + 783, + [ + 390, + 65, + 33, + 19, + 13 + ] + ], + [ + "B", + 788, + [ + 257, + 134, + 64, + 33, + 30 + ] + ], + [ + "B", + 941, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 942, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 943, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 944, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 945, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 946, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 950, + [ + 409, + 80, + 40, + 5, + 2 + ] + ], + [ + "B", + 1148, + [ + 406, + 66, + 36, + 8, + 1 + ] + ], + [ + "B", + 1149, + [ + 385, + 66, + 36, + 22, + 9 + ] + ], + [ + "B", + 1150, + [ + 276, + 131, + 66, + 36, + 9 + ] + ], + [ + "B", + 1151, + [ + 259, + 148, + 66, + 36, + 9 + ] + ], + [ + "B", + 1168, + [ + 258, + 130, + 85, + 37, + 8 + ] + ], + [ + "B", + 1169, + [ + 258, + 130, + 67, + 45, + 22 + ] + ], + [ + "restore", + 60, + [ + 256, + 128, + 64, + 33, + 17, + 8, + 4, + 3 + ] + ] + ], + "local_profile": { + "1": 2386, + "2": 642, + "3": 274, + "4": 128, + "5": 26, + "8": 8 + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43base.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43base.json new file mode 100644 index 0000000000..0095915f00 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43base.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_FOR_TWO_HOSTEE_MOVES","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): new/borrow/refit/search lowers the last gates of the free retired lenders 564 (B911) and 565 (B912) from dim 6 to their exact propagated floor dim 5 (meet closure: no other gate changes); gates unchanged","frames":[["B",911,[258,130,84,44,1]],["B",912,[258,130,74,45,31]]],"local_profile":{"1":2388,"2":646,"3":268,"4":130,"5":26,"8":8},"previous_frames":[["B",911,[258,130,76,44,24,1]],["B",912,[258,130,74,43,25,6]]]} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43extra.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43extra.json new file mode 100644 index 0000000000..0095915f00 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit7_43extra.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_FOR_TWO_HOSTEE_MOVES","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): new/borrow/refit/search lowers the last gates of the free retired lenders 564 (B911) and 565 (B912) from dim 6 to their exact propagated floor dim 5 (meet closure: no other gate changes); gates unchanged","frames":[["B",911,[258,130,84,44,1]],["B",912,[258,130,74,45,31]]],"local_profile":{"1":2388,"2":646,"3":268,"4":130,"5":26,"8":8},"previous_frames":[["B",911,[258,130,76,44,24,1]],["B",912,[258,130,74,43,25,6]]]} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43base.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43base.json new file mode 100644 index 0000000000..acd4d17dc2 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43base.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_CERTIFIED_OPTIMAL_RETIRED7","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): certified optimal frames of the aliased program (our #1186 toolkit optimal_frames on the borrow-word model, certified=True); gates, warps, start/final frames, compensation and widths unchanged","frames":[["B",1170,[258,130,84,44,1]],["B",1171,[258,130,74,45,31]]],"local_profile":{"1":2382,"2":648,"3":268,"4":128,"5":26,"8":8}} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43extra.json b/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43extra.json new file mode 100644 index 0000000000..acd4d17dc2 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/inputs/refit7c_43extra.json @@ -0,0 +1 @@ +{"kind":"FRAME_REFIT_CERTIFIED_OPTIMAL_RETIRED7","credit":"retired7: Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code): certified optimal frames of the aliased program (our #1186 toolkit optimal_frames on the borrow-word model, certified=True); gates, warps, start/final frames, compensation and widths unchanged","frames":[["B",1170,[258,130,84,44,1]],["B",1171,[258,130,74,45,31]]],"local_profile":{"1":2382,"2":648,"3":268,"4":128,"5":26,"8":8}} \ No newline at end of file diff --git a/research/tensor-block-kappa/vendor/frontier/joint_engine.py b/research/tensor-block-kappa/vendor/frontier/joint_engine.py new file mode 100644 index 0000000000..e76585f43f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/joint_engine.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Restore retired source pairs before handoff; generate twelve joint aliases. + +Derived from PR2462 (Jeremy Kothe), PR2436 lifted-target work (Tekalign), +and PR2322 generator utilities (Vlado Vojdanovski), all with AI assistance. +This derivative: OpenAI Codex at the user's direction. See README for scope. +""" +import sys,json,gzip,copy,importlib.util +from pathlib import Path +from fractions import Fraction as Q +from collections import defaultdict,Counter +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE/'vendor')) +import generate_words as G +import gf_chart as C +from target_transport import step + +def mod(name,path): + spec=importlib.util.spec_from_file_location(name,path);module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);return module + +def paid_lifted(w): + src=Path(G.__file__).read_text();src=src[src.index('def paid_profile('):src.index('\ndef build(')] + src=src.replace("for event in word['A']:\n gate(event)","""for event in word['A']: + if event[0]=='warp': + _,r,op,U,V=event + cols=word['warps'][abs(op)-1][2] + if op<0: + back={mapped(cols,x):x for x in range(512)};cols=[back[1<len(a):a.append(x) + for x in F: + if len(b)len(b):b.append(x) + assert len(a)==len(b)==4 + cols=C.gf_change(a,b,9);E=[C.gf_linear(cols,x) for x in U] if hasattr(C,'gf_linear') else [G.mapped(cols,x) for x in U] + op=len(w['warps'])+len(newrecords)+1;newrecords.append([first,r,cols,list(U),E]);replace[h]=r + nw['removed'].append(h);del nw['start_extra'][str(h)];nw['helper_final'].pop(str(h),None) + # Keep preexisting operator IDs stable; extra warps are appended to the table. + newB=[];position={} + for i in range(len(w['B'])+1): + newB.extend(before[i]);position[i]=len(newB) + if ilen(w['warps']),(t,r,op,q) + groups[r,op[0]][t]=-q + prelude=[];targetlines={} + for (r,op),coeff in groups.items(): + for g in nw['precondition']+nw['compensation']:coeff=step(coeff,g,set(range(112,224))) + record=nw['warps'][op-1];line=[G.mapped(record[2],w['ports'][r])] + for t in coeff: + assert t not in targetlines or targetlines[t]==line,(t,r,op,line,targetlines.get(t),dict(groups)) + targetlines[t]=line + prelude.append(['warp',r,op,[w['ports'][r]],line]) + for t,q in sorted(coeff.items()):prelude.append(['add',t,r,q.numerator,q.denominator,line]) + prelude.append(['warp',r,-op,line,[w['ports'][r]]]) + lifts=[] + for t,line in sorted(targetlines.items()): + key=str(t-112);old=nw['target_levels'].get(key,[]);assert not old or G.basis(old)==G.basis(line) + if not old:lifts.append(['scale',t,1,1,line]);nw['target_levels'][key]=line + nw['A']=lifts+prelude+nw['A'];nw['prelude_events']+=len(lifts)+len(prelude) + tmp=copy.deepcopy(nw);tmp['A']=tmp['A'][nw['prelude_events']:];nw['cleanup']=WP.derive_cleanup(tmp,WP.restored_of(w)) + pp,iv=paid_lifted(nw);nw['report']['local_profile']=pp;nw['report']['width_inventory']=iv + out=BASE/f'eight-alias-{tag}.json.gz';out.write_bytes(gzip.compress(json.dumps(nw,separators=(',',':')).encode())) + print('BUILT',tag,'newops',len(newrecords),'targets',targetlines,'file',out,flush=True) + AU2.run(out,BASE/f'eight-alias-{tag}-audit.json') + return nw diff --git a/research/tensor-block-kappa/vendor/frontier/packing_cap.py b/research/tensor-block-kappa/vendor/frontier/packing_cap.py new file mode 100644 index 0000000000..fe937f8667 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/packing_cap.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Uses Douglas Colkitt's exact ceiling engine (Claude-assisted), pinned unchanged. +# Adapter by Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Fixed-word coverage-law ceiling; separate from physical and outer admission.""" +import argparse, hashlib, importlib.util, json, sys +from fractions import Fraction as Q +from decimal import Decimal, localcontext +from pathlib import Path +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" +IDLE = {1:17316,3:6594,5:9878,32:1,48:26558} +CANDIDATE = {1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} +ENDPOINT = Q('0.001717794984118634663827') + +def need(ok, message): + if not ok: + raise ValueError(message) + +def calculate(profile_path=None): + path = HERE / 'vendor/ceiling.py' + need(hashlib.sha256(path.read_bytes()).hexdigest() == ENGINE_SHA, 'ceiling source pin') + spec = importlib.util.spec_from_file_location('packing_ceiling', path) + engine = importlib.util.module_from_spec(spec); spec.loader.exec_module(engine) + h = {int(r): n for r,n in json.loads((profile_path or HERE/'PROFILE.json').read_text()).items()} + need(h == CANDIDATE and sum(r*n for r,n in h.items()) == 4816512, + 'complete candidate histogram and rank mass') + local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)} + need(local == {1:2382,2:648,3:268,4:128,5:26,8:8}, 'complete local profile') + model = engine.model(local,73,896,9,64) + need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5188, 'coverage identity') + lo,hi = engine.ceiling(local,73,896,9,64) + need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection') + c = Q(json.loads((HERE/'CLAIM.json').read_text())['complex_lower']) + need(c == ENDPOINT, 'certified candidate endpoint') + with localcontext() as ctx: + ctx.prec = 50 + dec = lambda x: str(Decimal(x.numerator)/Decimal(x.denominator)) + return dict(status='PASS_FIXED_WORD_PACKING_CEILING',source_sha256=ENGINE_SHA, + local_per_call={str(r):str(n) for r,n in local.items()}, + dimension=73,families=896,stages=9,centre_rank_per_call=64,max_idle_rank=model['R'], + complex_cap_bracket=[str(lo),str(hi)],complex_cap_upper_decimal=dec(hi), + realized_fraction_lower=str(c/hi),realized_fraction_decimal=dec(c/hi), + scope='Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used.') + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--output',type=Path) + ap.add_argument('--profile',type=Path,default=HERE/'PROFILE.json');a=ap.parse_args() + text=json.dumps(calculate(a.profile),indent=2)+'\n' + if a.output: + a.output.parent.mkdir(parents=True,exist_ok=True);a.output.write_text(text) + print(text,end='') +if __name__=='__main__': main() diff --git a/research/tensor-block-kappa/vendor/frontier/requirements.txt b/research/tensor-block-kappa/vendor/frontier/requirements.txt new file mode 100644 index 0000000000..816d0c8e91 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/requirements.txt @@ -0,0 +1,4 @@ +numpy==2.5.4 +sympy==1.14.0 +scipy==1.18.1 +mpmath==1.3.0 diff --git a/research/tensor-block-kappa/vendor/frontier/retired7_controls.py b/research/tensor-block-kappa/vendor/frontier/retired7_controls.py new file mode 100644 index 0000000000..67a9818ac7 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/retired7_controls.py @@ -0,0 +1,73 @@ +# SPDX-License-Identifier: Apache-2.0 +# Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +"""retired7 tamper controls on a final BORROW-WORD (each mutant gets its inverse-reverse cleanup re-derived from its own forward +word; a rejection by a stale-cleanup/operator-id reason counts as a FAILURE): + refit7: each new lender's last-gate refit undone must be rejected by 'warp frame mismatch'; + hostmove2: per moved hostee - warp lender reverted, move undone (hostee back on its old lender, which now hosts the new alias), + warp before the new lender retires, G wrong; + alias7 (the PR2679 alias suite per new alias): borrowed read sign flipped, read doubled, write sign flipped, warp dropped, + G wrong, warp after the follower's first gate (the lender's own life ended in A, so 'before retirement' has no B position), + helper kept with an entrance frame; + refit7c: one certified frame corrupted. +usage: retired7_controls.py WORD INPUT_DIR TAG OUT (INPUT_DIR holds refit7/hostmove2/alias7/refit7c_43TAG.json; audit_local.py and +word_patch.py are imported from this directory)""" +import copy, contextlib, gzip, io, json, sys, tempfile +from pathlib import Path +VACUOUS = ('explicit cleanup differs', 'warp operator id') +def regs(e): return e[1:3] if e[0] == 'add' else e[1:2] +def relabel(m, start, a, b): + for i in range(start, len(m['B'])): + e = m['B'][i] + if e[0] == 'add': + if e[1] == a: e[1] = b + if e[2] == a: e[2] = b + elif e[1] == a: e[1] = b +def controls(w0, p7, ph, pa, pc, audit, WP): + """audit(word) -> None (accepted) or the rejection reason; returns (all_ok, results)""" + def rederive(m): + m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(w0)); m2['A'] = A; return m2 + res = {} + def expect(name, m, reason=None, fresh=True): + r = audit(rederive(m) if fresh else m) + ok = r is not None and not r.split(': ', 1)[-1].startswith(VACUOUS) and (reason is None or reason in r) + res[name] = dict(rejected=r is not None, reason=(r or '')[:160], real_reason=ok) + need = audit(w0); assert need is None, ('unmutated final word rejected', need) + for sec, i, fr in p7['previous_frames']: + m = copy.deepcopy(w0); m[sec][i][-1] = fr; expect(f'refit7 {sec}{i} lender refit undone', m, 'warp frame mismatch') + for mv in ph['moves']: + k = mv['op'] - 1; tag = f"move{mv['op']} {mv['L_old']}->{mv['L_new']}" + m = copy.deepcopy(w0); m['warps'][k][1] = mv['L_old']; expect(tag + ' warp lender reverted', m) + m = copy.deepcopy(w0); m['warps'][k] = copy.deepcopy(mv['old_record']); relabel(m, mv['old_pos'], mv['L_new'], mv['L_old']); expect(tag + ' move undone', m) + m = copy.deepcopy(w0); m['warps'][k][0] = mv['pos'] - 400; expect(tag + ' warp before lender retirement', m) + m = copy.deepcopy(w0); m['warps'][k][2][0] ^= m['warps'][k][2][1]; expect(tag + ' G wrong', m) + for a in pa['aliases']: + h, L = a['h'], a['L']; op = next(i for i, r in enumerate(w0['warps']) if r[1] == L and r[0] == a['pos']); tag = f'{h}<-{L}' + reads = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] + writes = [i for i, g in enumerate(w0['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] + m = copy.deepcopy(w0); m['B'][reads[0]][3] *= -1; expect(tag + ' borrowed read sign flipped', m) + m = copy.deepcopy(w0); m['B'][reads[0]][3] *= 2; expect(tag + ' borrowed read doubled', m) + if writes: m = copy.deepcopy(w0); m['B'][writes[0]][3] *= -1; expect(tag + ' borrowed write sign flipped', m) + m = copy.deepcopy(w0); del m['warps'][op] + for e in m['A'][:m['prelude_events']]: + if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 + expect(tag + ' warp dropped', m) + m = copy.deepcopy(w0); m['warps'][op][2][0] ^= m['warps'][op][2][1]; expect(tag + ' G wrong', m) + m = copy.deepcopy(w0); m['warps'][op][0] = a['pos'] + 1; expect(tag + " warp after the follower's first gate", m) + m = copy.deepcopy(w0); m['start_extra'][str(h)] = a['E']; expect(f'{h} kept with an entrance frame', m) + sec, i, fr = pc['frames'][0]; m = copy.deepcopy(w0); m[sec][i][-1] = [1]; expect('refit7c certified frame corrupted', m, fresh=False) + return all(r['real_reason'] for r in res.values()), res +if __name__ == '__main__': + here = Path(__file__).resolve().parent; sys.path.insert(0, str(here)) + import audit_local as al, word_patch as WP + w0 = json.loads(gzip.decompress(Path(sys.argv[1]).read_bytes())); D = Path(sys.argv[2]); tag = sys.argv[3]; tmp = Path(tempfile.mkdtemp()) + p = {n: json.loads((D / f'{n}_43{tag}.json').read_text()) for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')} + def audit(w): + q = tmp / 'm.json.gz'; q.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode())) + try: + with contextlib.redirect_stdout(io.StringIO()): al.run(q, tmp / 'm.out.json', None, None) + return None + except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as e: + return (type(e).__name__ + ': ' + str(e))[:200] + ok, res = controls(w0, p['refit7'], p['hostmove2'], p['alias7'], p['refit7c'], audit, WP) + Path(sys.argv[4]).write_text(json.dumps(dict(all_rejected_for_real_reasons=ok, controls=res), indent=1) + '\n') + print(('ALL RETIRED7 CONTROLS REJECTED' if ok else 'RETIRED7 CONTROL FAILURE'), sum(r['real_reason'] for r in res.values()), 'of', len(res)); sys.exit(0 if ok else 1) diff --git a/research/tensor-block-kappa/vendor/frontier/test_integrity.py b/research/tensor-block-kappa/vendor/frontier/test_integrity.py new file mode 100644 index 0000000000..eedb99e86a --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/test_integrity.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Git-free read-only replay and fail-closed input/claim/optimization controls.""" +import hashlib,json,os,shutil,subprocess,sys,tempfile +from pathlib import Path +HERE=Path(__file__).resolve().parent +def need(ok,msg): + if not ok:raise RuntimeError(msg) +def hashes(root):return {str(p.relative_to(root)):hashlib.sha256(p.read_bytes()).hexdigest() for p in root.rglob('*') if p.is_file()} +def main(): + with tempfile.TemporaryDirectory(prefix='joint-twelve-retired7-controls-') as t: + p=Path(t)/'package';shutil.copytree(HERE,p);before=hashes(p) + def run(script='verify.py',flags=()): + return subprocess.run([sys.executable,'-I','-B',*flags,str(p/script)],cwd=t,env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1'),text=True,capture_output=True,timeout=300) + r=run();need(r.returncode==0 and 'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY' in r.stdout,'relocated positive: '+r.stderr);need(hashes(p)==before,'read-only replay') + r=run(flags=('-O',));need(r.returncode!=0 and 'run without -O' in r.stderr,'optimized verification refusal') + r=run('generate.py',('-O',));need(r.returncode!=0 and 'assertions must be enabled' in r.stderr,'optimized generator refusal') + f=p/'CLAIM.json';b=f.read_bytes();c=json.loads(b);c['kappa']='1';f.write_text(json.dumps(c));r=run();need(r.returncode!=0 and 'claim outer endpoint' in r.stderr,'claim corruption rejection');f.write_bytes(b) + f=p/'inputs/WORD-base.json.gz';b=f.read_bytes();f.write_bytes(b+b'corruption');r=run();need(r.returncode!=0 and 'input digest' in r.stderr,'word authentication rejection');f.write_bytes(b) + need(hashes(p)==before,'controls restore exact files') + print('PASS_JOINT_TWELVE_RELOCATED_READ_ONLY_AND_INTEGRITY_CONTROLS') +if __name__=='__main__':main() diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/GENERATOR-NOTICE.txt b/research/tensor-block-kappa/vendor/frontier/vendor/GENERATOR-NOTICE.txt new file mode 100644 index 0000000000..b075f7180e --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/GENERATOR-NOTICE.txt @@ -0,0 +1,129 @@ +Generator for PR2312 width exchange plus coherent four-handoff transformation +========================================================================== + +generate_words.py is new portable code prepared with substantial AI +assistance, under the repository Apache-2.0 license. It directly transforms +the pinned PR2312 width-exchange BORROW-WORDs and regenerates cleanup. The existing source +builder is not copied or imported at runtime. The independent native chain, +rather than the generator or its hashes, proves all-column circuit correctness +and exact physical Clifford phases. + +PR2312 width exchange is credited to Jeremy Kothe (@jeremykothe2), with +AI assistance: alias 651 is re-lent from lender 530 and alias 653 is dropped, +freeing register 554 for cold restoration and changing two width-8 helpers +to width 7. The exact frame re-solve of both borrowed words and the owner +fill for that source width inventory retain the source's credit to Jeremy +Kothe, with AI assistance. This generator consumes the resulting complete +source words; it does not reapply their kernels or width exchange. + +Consumed PR2312 source head: + fb76f799ccf078f51780076ebed3fd26b1db11c0 +Package: + research/gmx-t74-borrow43-width-exchange +Manifest SHA-256: + c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313 + +The two helper-donor kernels at pivots 518 and 506 are retained from +PR2302. Their kernel shape is credited to mdumitrean (PR1625); their search, +exact pricing and frame re-solve are credited to Jeremy Kothe +(@jeremykothe2), with AI assistance, as stated by the source. The PR2302 +source and this necessary derivative generator were prepared with AI +assistance. This generator composes the four block-616 handoffs after those +kernels, preserving all kernel scalar gates and their re-solved frames. + +Predecessor PR2302 source head: + d520b92d7bf18efcb7d84f12757face6fe9541f1 +Package: + research/gmx-t74-borrow43-k518-506 +Manifest SHA-256: + 74634d13d27026e2867973b58dfef5e31958d92c54454b29e52292b7fc2e1f0d + +WildIdeas is credited for the exact frame refits retained from PR2288. +The source's additional frame-solver credit to Jeremy Kothe, with AI +assistance, is retained. The predecessor's full credit and licensing notice +is reproduced below. + +Anticipatory dirty borrowing is credited first to Cinna Davis +(@1337isnot1337), PR2226, with substantial OpenAI Codex assistance. The +retired-register K_G handoff and inverse-reverse FULL cleanup with proper-ended +private zero buffers derive from that construction and its PR2288 realization. +PR2288 source head: 614c74a63b0f6d4a24c7740d7ddb90d37861b3c7. + +This code is licensed under Apache-2.0, inherited from the repository. +The original repository LICENSE and NOTICE remain in the predecessor source; +the consumed package NOTICE is reproduced verbatim below, along with the +additional PR2226 notice. The PR2312 and PR2302 package NOTICE files are byte-identical to the +PR2288 package NOTICE reproduced here. + +--- PR2288 package NOTICE (verbatim) --- + +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. + + +--- PR2226 native-chain notice (verbatim) --- + +# Credit: anticipatory dirty borrowing (PR2226) + +The construction realised by this native chain is **PR2226, "anticipatory dirty borrowing"**, by Cinna Davis +(@1337isnot1337), prepared with substantial OpenAI Codex assistance (Apache-2.0): the logical reference change +K_G of a lender register (a monomial Clifford: a permutation of the 512 columns with phase mod 4), the initial +compensation terms c K_G z, the early cold tail, the exact cold restoration and the private zero buffers of the +FULL-frame cleanup. `vendor/pr2226_operators.py`, `vendor/pr2226_replay.py` and `vendor/PR2226-NOTICE.md` are byte copies +of PR2226's `operators.py`, `replay.py` and `NOTICE.md`. `bw_gauss.py` is a port of `operators.py` (change, monomial, +apply_mono, coord, frame, check) and adds a decoder from a serialized `clifford_exact` monomial to its exact 512 x 512 +Gaussian matrix. + +What this chain adds (the P3 native realisation, with the Borrow campaign's explicit chronological BORROW-WORD as input): +warp events and zero buffers in `LOCAL-PROGRAMS`, warp recipes in `CLIFFORD-RECIPES.json` (lowered with the unchanged +`lower_child`, rank zero, then compared with the exact numpy column product), logical K_G recipes in +`RESIDUAL-ADAPTERS.json`, an independent local replay in both orientations that checks every warp product on all 512 +columns, and the negative controls listed in `INDEPENDENT-LOCAL-REPLAY.json`, `WRAPPER-CHECKS.json`, `WARP-RECIPE-CHECKS.json` +and `bw_tamper.py`. + +Lineage retained: icekylinx (PR425/433/514, scalar and wrapper machinery), DreamingOfClouds (PR458/484/593 hyperplane/cold-HPE +extensions), the clifford_exact compiler (vendor531), and the owners named in the package README. `vendor/clifford/clifford_exact.py` +is a byte copy. + + +Reproduction and equality +======================== + +Run: + python3 generate_words.py --source-root FETCHED_REPOSITORY --out NEW_DIRECTORY + +The generator checks the pinned source manifest and both consumed compressed +source-word hashes. It writes base.json.gz, extra.json.gz and GENERATION.json. +Canonical JSON hashes cover every output field, including frames, scalar +gates, operators, endpoints, cleanup and invoices. These hashes determine +regenerated circuit equality. The compressed container hashes are recorded +for provenance; Python/zlib changes can produce different gzip streams for +the same circuit. The OS header byte is normalized to 255. In the recorded generation +environment both output containers also exactly match the composed +word hashes. Recompression alone does not require repeating native phases. + +The four binary G maps are explicit construction constants, checked for +invertibility and the measured source-to-handoff chart identity on each run. +The native replay independently lowers their exact physical representatives. +Two old warp-basis representatives are rewritten only after verifying equal +GF(2) spans, preserving the frozen input serialization. No JSON patch file or +unrecorded local dependency is needed. + +Composition binding +=================== + +The source-manifest and source-word constants bind the consumed PR2312 +inputs. The canonical JSON target hashes cover every composed output field. +The literal base tag names PR2312 width exchange plus coherent joint616; +SOURCE_COMMIT and SOURCE_MANIFEST identify the consumed source. +This generation receipt does not establish native phases, owner admission, +or a new exponent; those require their separate independently replayed +native and global receipts. diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/LICENSE b/research/tensor-block-kappa/vendor/frontier/vendor/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/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/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-NOTICE b/research/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-NOTICE new file mode 100644 index 0000000000..46411b80b2 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-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/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-VENDOR-SOURCES.json b/research/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-VENDOR-SOURCES.json new file mode 100644 index 0000000000..cd19eda259 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/UPSTREAM-VENDOR-SOURCES.json @@ -0,0 +1,26 @@ +{ + "vendor/gf_chart.py": { + "sha256": "871936fa81af695d5bdc029803af81228300c405f5ff8d153e130530dddca4f6", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/census.py", + "mode": "four unchanged gf_* functions" + }, + "vendor/target_transport.py": { + "sha256": "9f92e1699167f46d0f0e59b540a9940ee1addcb5357ca65cf1dbf7acdbe7ad86", + "source_commit": "19d9366de79dc3125429c3912e4040331d125a27", + "source_path": "research/complex-structure-seed39/nonzero-lender-evidence/target_transport.py", + "mode": "unchanged full file" + }, + "vendor/generate_words.py": { + "sha256": "340532e035fa3c4d7d2f92aeb80f0efbb44a53c4e3deeb0c6bf7d6ae2fccd0c7", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/generate_words.py", + "mode": "unchanged full file" + }, + "vendor/GENERATOR-NOTICE.txt": { + "sha256": "d4cbc432b79ee2d54a83bcadf260bb89e910262b8c19e763e08b7eb3a5e8215c", + "source_commit": "002304ef01c4416a127916169ae6d94c1bee052b", + "source_path": "research/t74-joint-owner-hillclimb/GENERATOR-NOTICE.txt", + "mode": "unchanged full file" + } +} diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/audit_local_pr2679.py b/research/tensor-block-kappa/vendor/frontier/vendor/audit_local_pr2679.py new file mode 100644 index 0000000000..8224873d04 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/audit_local_pr2679.py @@ -0,0 +1,501 @@ +"""Independent exact scalar/frame audit of the changed forward supplier. + +This does not import a generator, builder, stored compensation, or price. +All claimed endpoint matrices are derived from the input word's gates. +Optional --main checks the transported boundary against the pinned parent. +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. +""" +import argparse,gzip,json,hashlib,time +from pathlib import Path +from fractions import Fraction as F +from collections import Counter + +def require(x,label): + if not x:raise RuntimeError(label) + +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 registers(e):return e[1:3] if e[0]=='add' else e[1:2] + +def apply(e,rows,dual=False): + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + dst=rows[t] + for k,x in list(rows[s].items()): + a=dst.get(k,F(0))+q*x + if a:dst[k]=a + else:dst.pop(k,None) + elif e[0]=='scale': + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + else:raise RuntimeError('unknown scalar primitive') + +def invert(e): + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def check_parent_interface(word,main): + # Read only the retained boundary data. No builder or local checker is imported. + relative="research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz" + path=main/relative;raw=path.read_bytes() + require(hashlib.sha256(raw).hexdigest()=="66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",'parent canonical input pin') + parent=json.loads(gzip.decompress(raw)) + tau=lambda x:x^(43 if (x&43).bit_count()%2 else 0) + ports=parent['ports'];v=word['report']['v'] + require(len(ports)==len(set(ports))==v,'parent port count') + require(set(map(tau,word['ports']))==set(ports),'transported source/target ports') + moved={i:ports.index(tau(p)) for i,p in enumerate(word['ports'])} + centers=[moved.get(r,r) for r in word['centers']] + actual=[list(basis([tau(x) for x in frame])) for frame in word['center_frames']] + expected=[parent['frames'][f] for f in parent['center_frames']] + require(len(centers)==len(set(centers))==len(actual)==8,'eight distinct centre carriers') + require(actual==expected and all(len(f)==8 for f in actual),'ordered centre frame interface') + return dict(parent_path=relative,parent_file_sha256=hashlib.sha256(raw).hexdigest(), + transport_tau=43,ordered_frame_bases_match=True,all_ports_match=True, + transported_centers=centers,source_centers=[r for r in centers if r=2*v} + for e in w['precondition']:apply(e,dirt) + compensation=[['add',y,k,-a.numerator,a.denominator,[]] for y in range(v,2*v) for k,a in sorted(dirt[y].items())] + entering=set(map(int,w.get('start_extra',{})));lowends=set(map(int,w.get('helper_final',{}))) + coldends=lowends-entering + require(not any(e[2] in entering for e in compensation),'nonzero entrance response') + require(not any(r in entering|coldends for e in w['precondition']+compensation for r in registers(e)), 'pre-wrapper touch of residual helper') + require(all(e[-1]==[] for e in w['precondition']+compensation),'nonzero frame precondition') + early=w.get('early_cleanup',[]);earlyids={i for i,U in early} + require(len(earlyids)==len(early),'duplicate early cleanup gate') + tail=[w['cleanup'][i][:-1]+[U] for i,U in early] + cleanup=[e for i,e in enumerate(w['cleanup']) if i not in earlyids] + prefix=w['precondition']+compensation+main + program=prefix+tail+cleanup + for dual in (False,True): + actual=ident() + for e in program:apply(e,actual,dual) + expected=ident() + for t in range(v):expected[t if dual else v+t][v+t if dual else t]=F(-1 if dual else 1) + bad=[i for i in range(n) if actual[i]!=expected[i]] + require(not bad,'all-column endpoint failure '+str((dual,bad[:8]))) + print('endpoint', 'dual' if dual else 'forward','PASS',flush=True) + full=basis([1<>=1;i+=1 + return y + +def ginv(cols,h): + # inverse columns over F2 (None if singular), Gauss-Jordan on (G | I) column-wise + piv={}; + for i in range(h): + a=cols[i];b=1<>s&1:a^=piv[s][0];b^=piv[s][1] + if a:return None + pre.append(b) + return pre # pre[t] = G^{-1}(e_t) + +def gtrans(cols,h): + # transpose: column j of G^T = row j of G + return [sum(((cols[i]>>j)&1)< E (used for B-phase warps and for A-phase prelude warps)""" + inv=ginv(cols,h);require(inv is not None,'G not invertible') + require(all(gmul(cols,inv[t])==1<(Gx, (G+G^-T)x + G^-T z) + GiT=gtrans(inv,h) # G^{-T}: columns j = row j of G^{-1} + # G^{-T}(z): via columns GiT + def M(vec): + x=vec&((1<>h + gx=gmul(cols,x);S=gx^gmul(GiT,x) # (G + G^{-T}) x + return gx|((S^gmul(GiT,z))<>h)|((vec&((1<0)-(op<0))*(abs(op)+dsym)) + walg_add(rows[src],row,-c) + return + if e[0]=='warp': + op=e[2];s=(op>0)-(op<0) + if dual:op=s*(abs(op)+dsym) # dual orientation: K_G^{-T} is a distinct free symbol + rows[e[1]]=walg_warp(rows[e[1]],op);return + if e[0]=='add': + t,s=e[1:3];q=F(e[3],e[4]);require(t!=s,'self add') + if dual:t,s,q=s,t,-q + walg_add(rows[t],rows[s],q) + else: + t=e[1];q=F(e[2],e[3]);require(q!=0,'zero scale') + if dual:q=1/q + rows[t]={k:q*x for k,x in rows[t].items()} + +def invert_item(e,full): + if e[0]=='warp':return ['warp',e[1],-e[2]] + r=list(e) + if r[0]=='add':r[3]=-r[3] + else:r[2],r[3]=r[3],r[2] + return r + +def run_borrow(path,out,main,base,w,data,begin): + v,h,R=w['report']['v'],w['report']['h'],w['report']['R'];n=2*v+R + require((v,h)==(112,9),'wrong source geometry') + require(main is None,'--main parent interface is not available for coordinate-changed BORROW-WORD; use --base') + full=basis([1<=2*v,'correction source must be a remaining helper') + require(s not in entering,'correction source has nonzero entrance frame') + require(len(word)>=1 and all(1<=abs(o)<=K for o in word),'correction operator word') + require(c!=0 and c.denominator&(c.denominator-1)==0,'correction coefficient') + # the source is the lender of the operator it is read through + require(all(warps[abs(o)-1][1]==s for o in word),'correction source is not the lender of its operator') + # --- 4. frames: literal chain, monotone, paid profile --------------------------------------- + end=[full]*v+[basis([x for x in range(1,1<0 else list(to_),list(to_) if op_>0 else list(fr_),h) + require(cur[r_]==basis(fr_),'prelude warp frame mismatch '+str((r_,op_))) + cur[r_]=basis(to_) + else: + for q in registers(e):climb(q,e[-1]) + for e in Aord: + for q in registers(e):climb(q,e[-1]) + lev={int(t):basis(U) for t,U in w.get('target_levels',{}).items()} + require(all(cur[v+t]==lev.get(t,()) for t in range(v)),'target centre levels') + for q,U in zip(w['centers'],w['center_frames']): + U=basis(U);require(cur[q]==U,'center frame') + served={lev.get(e[1]-v,()) for e in w['cut'] if e[2]==q} + for T in sorted(served,key=lambda x:-len(x)): + require(contained(T,U),'center path not nested') + if T!=U:paid[len(U)-len(T)]+=1 + U=T + byposition={} + for op,rec in enumerate(warps,1):byposition.setdefault(rec[0],[]).append(op) + B=w['B'];forward=[] # chronological program of the (recorded) non-target word + for e in Aord:forward.append(e) + for p in range(len(B)+1): + for op in byposition.get(p,[]): + _,lender,cols,U,E=warps[op-1] + require(cur[lender]==basis(U),'warp frame mismatch '+str((op,lender,cur[lender],basis(U)))) + cur[lender]=basis(E);forward.append(['warp',lender,op]) + if p 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/tensor-block-kappa/vendor/frontier/vendor/generate_words.py b/research/tensor-block-kappa/vendor/frontier/vendor/generate_words.py new file mode 100644 index 0000000000..94bf0d8f29 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/generate_words.py @@ -0,0 +1,335 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Construct four coherent handoffs on the pinned PR2312 width-exchange words. + +This is a direct circuit transformation, using Python's standard library only. +It moves the twelve block-616 correction gates, replaces four retired helper +roles by the source lenders (1,4,6,12), installs their explicit invertible chart +maps, and derives inverse-reverse cleanup from the changed non-target word. +The source and resulting word content are hash-bound. Hash equality is a +reproduction check; the independent all-column native chain proves correctness. +The input retains PR2312's width exchange (alias 651 re-lent from 530 and +alias 653 dropped), exact frame re-solve and the pivot-518/506 kernels. +Width exchange and its source frame/owner work are credited to Jeremy Kothe +(jeremykothe2), with AI assistance. The helper-donor kernels retain credit: +PR1625 shape by mdumitrean; PR2302 search, exact pricing and frame re-solve +by Jeremy Kothe (jeremykothe2), with AI assistance. This derivative was also +prepared with substantial AI assistance. See GENERATOR-NOTICE.txt for +inherited attribution and licensing. +""" +import argparse +import copy +import gzip +import hashlib +import json +import platform +import zlib +from collections import Counter, defaultdict +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PACKAGE = Path('research/gmx-t74-borrow43-width-exchange') +SOURCE_COMMIT = 'fb76f799ccf078f51780076ebed3fd26b1db11c0' +SOURCE_MANIFEST = 'c545968fb8cf6e550b82ba631e92fd756484db75e621aee211347749cff55313' +SOURCE_WORDS = { + 'base': '4244149b59b287344b0e91aa50c6fa2a2491ee6c7a76d61cd352684a8182d005', + 'extra': '01d510cc4ba912567f6b02ea50b6b0e741ed231a3608de9c36e7eeccbdaf6cda', +} +TARGET_WORDS = { + 'base': '93c32c9dc8ca18394b7f3afac2cb4fa8582a6cb77399441b5107b396e63ca0f9', + 'extra': 'aae6592eaa4cf8638f21d50c44d09d4f8a6bb079ddcf5e377711a10ee2ddb526', +} +TARGET_SEMANTICS = { + 'base': '3659c066d5cc2413a6f59bae8d5886e05feb8148333516f65365ad5235e14f2a', + 'extra': '9369702d158c34d594481a1789a2bddc029d03007253620cf3834ec60a88b1a5', +} +HIGH = (619, 621, 622, 623) +LOW = (616, 617, 618, 620) +LENDERS = (1, 4, 6, 12) +COMMON5 = (260, 132, 75, 42, 25) +COMMON4 = (260, 132, 75, 51) +# Literal G(e_i) columns of the four new rank-zero K_G handoffs. Each map is +# independently checked below, then physically lowered by the native auditor. +G_COLUMNS = ( + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 16, 32, 64, 135, 263), + (1, 2, 4, 54, 72, 8, 130, 16, 284), + (1, 2, 4, 8, 57, 66, 143, 16, 272), +) +PROFILE = {1: 2335, 2: 512, 3: 426, 4: 120, 5: 38, 8: 8} +WIDTHS = {4: 33, 5: 9, 7: 38, 8: 114, 9: 240} + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def semantic_sha(value): + # JSON object keys are strings; normalize integer invoice keys before sorting. + value = json.loads(json.dumps(value)) + return sha(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()) + + +def basis(vectors): + """Canonical reduced GF(2) row basis, independent of set iteration order.""" + piv = {} + for value in vectors: + while value: + bit = value.bit_length() - 1 + if bit in piv: + value ^= piv[bit] + else: + piv[bit] = value + break + for bit in sorted(piv): + for higher in piv: + if higher > bit and (piv[higher] >> bit) & 1: + piv[higher] ^= piv[bit] + return tuple(piv[bit] for bit in sorted(piv, reverse=True)) + + +def incident(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def mapped(columns, vector): + result = 0 + for bit, column in enumerate(columns): + if (vector >> bit) & 1: + result ^= column + return result + + +def derive_cleanup(word): + """PR2226/PR2288 inverse-reverse cleanup, retaining proper-end buffers.""" + v = word['report']['v'] + n = 2 * v + word['report']['R'] + restored = set(map(int, word['helper_final'])) + full = list(basis(1 << bit for bit in range(word['report']['h']))) + buffer = lambda role: role + n if role in restored else role + by_position = defaultdict(list) + for operator, record in enumerate(word['warps'], 1): + by_position[record[0]].append((record[1], operator)) + forward = list(word['A']) + for position in range(len(word['B']) + 1): + forward.extend(['warp', role, operator] + for role, operator in by_position[position]) + if position < len(word['B']): + forward.append(word['B'][position]) + forward += word['restore'] + cleanup = [] + for gate in reversed(forward): + if gate[0] == 'warp': + cleanup.append(['warp', buffer(gate[1]), -gate[2], full]) + elif not v <= gate[1] < 2 * v: + if gate[0] == 'add': + cleanup.append(['add', buffer(gate[1]), buffer(gate[2]), + -gate[3], gate[4], full]) + else: + cleanup.append(['scale', buffer(gate[1]), gate[3], gate[2], full]) + return cleanup + + +def paid_profile(word): + """Recount literal native climbs, cut copies and retained helper widths.""" + v, h, helpers = (word['report'][key] for key in ('v', 'h', 'R')) + n = 2 * v + helpers + cur = [(port,) for port in word['ports']] + [()] * (v + helpers) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + full = basis(1 << bit for bit in range(h)) + ends = [full] * v + [basis(x for x in range(1, 1 << h) + if (x & port).bit_count() % 2 == 0) + for port in word['ports']] + [full] * helpers + for role, frame in word['helper_final'].items(): + ends[int(role)] = basis(frame) + paid = Counter() + + def climb(role, frame): + frame = basis(frame) + require(basis(cur[role] + frame) == frame, 'Nonmonotone frame chain') + degree = len(frame) - len(cur[role]) + if degree: + paid[degree] += 1 + cur[role] = frame + + def gate(event): + for role in incident(event): + climb(role, event[-1]) + + for event in word['A']: + gate(event) + levels = {int(t): basis(frame) for t, frame in word['target_levels'].items()} + require(all(cur[v+t] == levels.get(t, ()) for t in range(v)), 'Cut target frame') + for role, frame in zip(word['centers'], word['center_frames']): + frame = basis(frame) + require(cur[role] == frame, 'Cut producer frame') + readers = {levels.get(event[1]-v, ()) for event in word['cut'] + if event[2] == role} + for reader in sorted(readers, key=lambda x: -len(x)): + require(basis(reader + frame) == frame, 'Unnested private copy') + if reader != frame: + paid[len(frame)-len(reader)] += 1 + frame = reader + by_position = defaultdict(list) + for record in word['warps']: + by_position[record[0]].append(record) + for position in range(len(word['B']) + 1): + for _, role, columns, old, new in by_position[position]: + require(cur[role] == basis(old), 'Handoff source frame') + require(len(basis(columns)) == h, 'Singular chart map') + require(basis(mapped(columns, x) for x in old) == basis(new), + 'Chart map does not carry the measured source frame') + cur[role] = basis(new) + if position < len(word['B']): + gate(word['B'][position]) + for event in word['restore']: + gate(event) + live = set(range(n)) - set(word['removed']) + for role in live: + climb(role, ends[role]) + widths = Counter(len(ends[role]) - len(basis(word['start_extra'].get(str(role), []))) + for role in live if role >= 2 * v) + return dict(sorted(paid.items())), dict(sorted(widths.items())) + + +def build(source): + word = copy.deepcopy(source) + require(word['report']['v'] == 112 and word['report']['h'] == 9 + and word['report']['R'] == 480, 'Unexpected source geometry') + roles = set(LOW + HIGH) + prep = [i for i, event in enumerate(word['B']) + if set(incident(event)) <= roles] + # The only internal gates before source acquisition are the twelve M gates. + first = next(i for i, event in enumerate(word['B']) + if event[0] == 'add' and event[1] in roles + and event[2] not in roles and len(event[-1]) >= 6) + prep = [i for i in prep if i < first] + require(len(prep) == 12 and prep == list(range(prep[0], prep[0]+12)), + 'Expected twelve consecutive block-616 correction gates') + lo, hi = prep[0], prep[-1] + 1 + require(all(not roles.intersection(incident(event)) + for event in word['B'][hi:first]), 'Block is not idle before relocation') + require(all(basis(word['B'][i][-1]) == basis(COMMON5) for i in prep), + 'Unexpected correction chart') + require(all(event[0] == 'add' and event[1] in LOW and event[2] in HIGH + for event in (word['B'][i] for i in prep)), 'Unexpected correction payload') + require(all(basis(word['start_extra'][str(role)]) == basis(COMMON5) + for role in HIGH), 'Unexpected removed helper entrance') + require(not any(record[0] in range(lo, hi+1) or record[0] == first + for record in word['warps']), 'Warp inside relocation boundary') + replace = dict(zip(HIGH, LENDERS)) + moved = [event[:-1] + [list(COMMON4)] for event in word['B'][lo:hi]] + word['B'] = word['B'][:lo] + word['B'][hi:first] + moved + word['B'][first:] + handoff = first - len(moved) + for event in word['B']: + for index in range(1, 3 if event[0] == 'add' else 2): + event[index] = replace.get(event[index], event[index]) + for record in word['warps']: + if hi <= record[0] < first: + record[0] -= len(moved) + # Preserve the already-audited literal basis representatives emitted by + # the original builder. These replacements span precisely the same U. + rewrite = {(384, 134, 120, 30): (384, 134, 102, 30), + (448, 56, 21, 11): (448, 38, 21, 11)} + old = tuple(record[3]) + if old in rewrite: + require(basis(old) == basis(rewrite[old]), 'Basis serialization changed U') + record[3] = list(rewrite[old]) + # Measure each retired source at the chronological handoff, without trusting + # a lender chart copied from a generated target artifact. + cur = [(port,) for port in word['ports']] + [()] * (112 + 480) + for role, frame in word['start_extra'].items(): + cur[int(role)] = basis(frame) + for event in source['A']: + for role in incident(event): + cur[role] = basis(event[-1]) + old_warps = defaultdict(list) + for record in source['warps']: + old_warps[record[0]].append(record) + for position in range(first): + for record in old_warps[position]: + cur[record[1]] = basis(record[4]) + for role in incident(source['B'][position]): + cur[role] = basis(source['B'][position][-1]) + for role, columns in zip(LENDERS, G_COLUMNS): + require(len(cur[role]) == 4, 'Retired lender must be rank 4') + require(max(i for i, event in enumerate(source['B']) + if role in incident(event)) < first, 'Source lender still live') + old_literal = (384, 131, 75, 51) if role == 4 else cur[role] + new_literal = (384, 132, 75, 51) + require(basis(old_literal) == cur[role] + and basis(new_literal) == basis(COMMON4), + 'Literal handoff representative changed its subspace') + word['warps'].append([handoff, role, list(columns), + list(old_literal), list(new_literal)]) + for role in HIGH: + del word['start_extra'][str(role)] + word['removed'] = sorted(set(word['removed']).union(HIGH)) + word['base'] = 'PR2312-width-exchange-plus-coherent-joint616' + profile, widths = paid_profile(word) + require(profile == PROFILE and widths == WIDTHS, 'Unexpected generated invoice') + word['report']['local_profile'] = profile + word['report']['width_inventory'] = widths + word['cleanup'] = derive_cleanup(word) + return word, dict(old_correction_interval=[lo, hi], old_first_input=first, + relocated_correction_interval=[handoff, handoff+12], + removed_roles=list(HIGH), lenders=list(LENDERS)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, required=True, + help='Repository root containing the pinned PR2312 package') + parser.add_argument('--out', '--output', type=Path, required=True, + help='Destination for base.json.gz, extra.json.gz and GENERATION.json') + args = parser.parse_args() + package = args.source_root.resolve() / PACKAGE + manifest_bytes = (package / 'MANIFEST.json').read_bytes() + require(sha(manifest_bytes) == SOURCE_MANIFEST, 'Unpinned upstream manifest') + manifest = json.loads(manifest_bytes) + args.out.mkdir(parents=True, exist_ok=True) + reports = {} + for kind in ('base', 'extra'): + relative = f'new/borrow/words/BORROW-WORD-43{kind}.json.gz' + raw = (package / relative).read_bytes() + require(sha(raw) == SOURCE_WORDS[kind] == manifest[relative], + 'Unpinned '+kind+' source word') + word, changes = build(json.loads(gzip.decompress(raw))) + content = json.dumps(word, separators=(',', ':')).encode() + canonical_hash = semantic_sha(word) + require(canonical_hash == TARGET_SEMANTICS[kind], + 'Generated '+kind+' circuit differs from the frozen audited input') + compressed = bytearray(gzip.compress(content, compresslevel=9, mtime=0)) + compressed[9] = 255 # Normalize the Python 3.11/3.12 gzip OS header byte. + compressed = bytes(compressed) + destination = args.out / (kind+'.json.gz') + destination.write_bytes(compressed) + reports[kind] = dict(source_word_sha256=sha(raw), output=destination.name, + output_sha256=sha(compressed), content_sha256=sha(content), + canonical_json_sha256=canonical_hash, + frozen_container_sha256=TARGET_WORDS[kind], + container_matches_frozen=sha(compressed) == TARGET_WORDS[kind], + local_profile=word['report']['local_profile'], + width_inventory=word['report']['width_inventory'], + changes=changes) + print('PASS_GENERATED_AUDITED_WORD_SEMANTICS', kind, canonical_hash, flush=True) + receipt = dict(status='PASS_SOURCE_BOUND_EXACT_WORD_GENERATION', + source_commit=SOURCE_COMMIT, source_manifest_sha256=SOURCE_MANIFEST, + generator_sha256=sha(Path(__file__).read_bytes()), words=reports, + compression_environment=dict(python=platform.python_version(), + zlib=zlib.ZLIB_RUNTIME_VERSION), + equality='Canonical JSON of every field; gzip container hashes are metadata', + scope='Exact source-bound reproduction of the independently audited words. ' + 'Circuit correctness, physical phases and the global owner invoice ' + 'are established by their separate native and global receipts.') + (args.out / 'GENERATION.json').write_text(json.dumps(receipt, indent=2)+'\n') + + +if __name__ == '__main__': + main() diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/gf_chart.py b/research/tensor-block-kappa/vendor/frontier/vendor/gf_chart.py new file mode 100644 index 0000000000..11f5bfd882 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/gf_chart.py @@ -0,0 +1,35 @@ +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +# Exact GF(2) chart utilities extracted from PR2436 census.py; unchanged functions. + +def gf_rank(xs): + b = {} + for x in xs: + while x: + j = x.bit_length() + if j not in b: + b[j] = x + break + x ^= b[j] + return len(b) + +def gf_extend(xs, h): + out = list(xs) + for j in range(h): + if gf_rank(out + [1 << j]) > len(out): + out.append(1 << j) + assert len(out) == h + return out + +def gf_linear(cols, x): + out = 0 + for j, c in enumerate(cols): + if x >> j & 1: + out ^= c + return out + +def gf_change(source, target, h): + a, b = gf_extend(source, h), gf_extend(target, h) + back = {gf_linear(a, x): x for x in range(1 << h)} + assert len(back) == 1 << h + return [gf_linear(b, back[1 << j]) for j in range(h)] diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/target_transport.py b/research/tensor-block-kappa/vendor/frontier/vendor/target_transport.py new file mode 100644 index 0000000000..89ee0168c6 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/target_transport.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Exact target-vector transport; no physical/native admission is implied. + +For a final correction c, compute the unique simultaneous correction at every +boundary of a target-affine gate word. Non-target source terms cancel from the +difference. Transport through target mixing, not only target scales. +""" +from fractions import Fraction as Q + + +def need(ok, msg): + if not ok: + raise RuntimeError(msg) + + +def step(c, gate, targets, inverse=False): + out=dict(c) + kind=gate[0] + if kind not in ('add','scale'): + return out + t=gate[1] + if kind=='add': + s=gate[2] + need(not (s in targets and t not in targets), 'non-target reads target') + if t in targets and s in targets: + a=Q(gate[3],gate[4])*(-1 if inverse else 1) + out[t]=out.get(t,Q(0))+a*out.get(s,Q(0)) + elif t in targets: + a=Q(gate[2],gate[3]);need(a!=0,'zero target scale') + out[t]=out.get(t,Q(0))*(1/a if inverse else a) + return {t:a for t,a in out.items() if a} + + +def suffix_corrections(gates, final, targets): + need(set(final)<=set(targets),'correction outside targets') + c={t:Q(a) for t,a in final.items() if a} + vectors=[c] + for g in reversed(gates): + c=step(c,g,targets,inverse=True) + vectors.append(c) + return list(reversed(vectors)) + + +def verify_transport(gates, final, targets): + vectors=suffix_corrections(gates,final,targets) + need(len(vectors)==len(gates)+1,'missing boundary') + for i,g in enumerate(gates): + need(step(vectors[i],g,targets)==vectors[i+1],f'transport boundary {i}') + need(vectors[-1]=={t:Q(a) for t,a in final.items() if a},'wrong final') + return vectors + + +def controls(): + # A correction on source target 11 is mixed into target 10 by an ADD; + # a scalar-only backward transport would miss this exact obstruction. + targets={10,11};gates=[['add',10,11,3,2,[]],['scale',11,-2,1,[]]] + final={10:Q(5),11:Q(4)} + v=verify_transport(gates,final,targets) + need(v[0]=={10:Q(8),11:Q(-2)},'known noncommuting two-target example') + wrong=dict(v[0]);wrong[10]=Q(5) + for g in gates:wrong=step(wrong,g,targets) + need(wrong!=final,'ignored-mixing control accepted') + try:step({10:Q(1)},['add',0,10,1,1,[]],targets) + except RuntimeError:pass + else:raise RuntimeError('target read into non-target not rejected') + return {'noncommuting_target_mix':'rejected_scalar_only_transport','non_target_read':'rejected'} + + +if __name__=='__main__': + need(__debug__,'assertions must remain enabled') + controls() + print('PASS_EXACT_TARGET_TRANSPORT_CONTROLS') diff --git a/research/tensor-block-kappa/vendor/frontier/vendor/word_patch_pr2679.py b/research/tensor-block-kappa/vendor/frontier/vendor/word_patch_pr2679.py new file mode 100644 index 0000000000..492a3ef831 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/vendor/word_patch_pr2679.py @@ -0,0 +1,65 @@ +"""word_patch.py: exact structural edits of a BORROW-WORD (kernel edits found on the borrowed words, applied on top of the pinned rebuild). +apply_kernel(word, patch) replaces the sections listed in patch['sections'] (B, warps, and frame-only A/restore changes) and re-derives the explicit inverse-reverse cleanup exactly as build_word.py does; +kernel_gate_edit(old_B, new_B) returns the gate-level edit (frames ignored) that turns the old B section into the new one, so the edit declared in the patch can be checked.""" +import copy,difflib,json +V=112;N=704;FULL=[256,128,64,32,16,8,4,2,1] +def _key(g):return json.dumps(g[:-1]) +def kernel_gate_edit(old_B,new_B): + """[('delete',i,gate) | ('insert',i_new,gate)] between the two B sections, ignoring the trailing frame of every gate""" + ka=[_key(g) for g in old_B];kb=[_key(g) for g in new_B];ed=[] + for t,i1,i2,j1,j2 in difflib.SequenceMatcher(None,ka,kb,autojunk=False).get_opcodes(): + if t in('delete','replace'):ed+=[['delete',i,old_B[i][:-1]] for i in range(i1,i2)] + if t in('insert','replace'):ed+=[['insert',j,new_B[j][:-1]] for j in range(j1,j2)] + return ed +def derive_cleanup(w,restored): + byp={} + for op,rec in enumerate(w['warps'],1):byp.setdefault(rec[0],[]).append((op,rec)) + fw=list(w['A']) + for p in range(len(w['B'])+1): + for op,rec in sorted(byp.get(p,[]),key=lambda x:x[0]):fw.append(['warp',rec[1],op]) + if p=N}|{g[2]-N for g in w['cleanup'] if g[0]=='add' and g[2]>=N} +def apply_kernel(w,patch): + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['sections'].items():r[k]=copy.deepcopy(v) + r['report']['local_profile']=patch['local_profile'] + r['cleanup']=derive_cleanup(r,rs) + return r + +def apply_handoff(w,patch): + """coherent multi-helper handoff edit (retired-source replacement of high roles): replace the listed top-level fields and the report, re-derive the cleanup from the changed word""" + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + r['cleanup']=derive_cleanup(r,rs) + return r + +def apply_lowfour(w,patch): + """four low aliases through lifted-target compensation (PR2436 mechanism): replace the listed fields; the A section starts with the + explicit prelude (patch fields['prelude_events'] leading items); the inverse-reverse cleanup is derived WITHOUT the prelude.""" + r=copy.deepcopy(w);rs=restored_of(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + t=copy.deepcopy(r);t['A']=r['A'][r['prelude_events']:] + r['cleanup']=derive_cleanup(t,rs) + return r + +def apply_prelife(w,patch): + """pre-life hosting (this package): a cold host h, after it has restored itself and retired, hosts the whole life of a dim-0-start + helper L through one B warp; h stops being cold, so the restored (private-buffer) set of the derived cleanup is the NEW helper_final + key set (not the input word's). Replace the listed fields and the report; re-derive the inverse-reverse cleanup without the prelude.""" + r=copy.deepcopy(w) + for k,v in patch['fields'].items():r[k]=copy.deepcopy(v) + r['report']=copy.deepcopy(patch['report']) + t=copy.deepcopy(r);t['A']=r['A'][r.get('prelude_events',0):] + r['cleanup']=derive_cleanup(t,{int(q) for q in r['helper_final']}) + return r diff --git a/research/tensor-block-kappa/vendor/frontier/verify.py b/research/tensor-block-kappa/vendor/frontier/verify.py new file mode 100644 index 0000000000..d8101f1a28 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/verify.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Read-only finite replay: words, corrections, cleanup, hosting and exact moment. +No assertion-optimized execution; full native/outer release is separate. +""" +import copy,gzip,hashlib,json +from pathlib import Path +from fractions import Fraction as F +import sys +sys.path.insert(0,str(Path(__file__).resolve().parent)) +import composition as C +import independent_local as L +import independent_owners as I +import exact_moment as M +HERE=Path(__file__).resolve().parent +PROFILE={1: 1603728, 2: 431568, 3: 185082, 4: 85248, 5: 27194, 8: 5328, 32: 1, 48: 26558} +LOW=F('0.001717794984118634663827') +PROFILE2751={1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558} +LOW2751=F('0.001717141586348426338109') +ALIASES=[(606,550),(635,551),(637,552),(638,553),(639,562)] # retired5 +NEW7=[(667,401),(669,403)] # retired7: retired-lender aliases enabled by moving the hostees of warps 30/31 onto 564/565 +import importlib.util as _iu +_s=_iu.spec_from_file_location('word_patch_pr2679',Path(__file__).resolve().parent/'vendor/word_patch_pr2679.py');WP=_iu.module_from_spec(_s);_s.loader.exec_module(WP) +def refit_apply(w0,p): + w=copy.deepcopy(w0) + for sec,i,fr in p['frames']: + need(w[sec][i][:-1]==w0[sec][i][:-1],'refit changes a gate');w[sec][i][-1]=fr + w['report']['local_profile']=p['local_profile'];return w +def compact(fill,old_words,new_words,old_prov,new_prov,order,dispatch): + live=lambda w:[r for r in range(224,704) if r not in set(w['removed'])] + L0=live(old_words['gauge44']);L1=live(new_words['gauge44']);need(L0==live(old_words['extra']) and L1==live(new_words['extra']),'live helper sets') + gone=set(L0)-set(L1);need(set(L1)<=set(L0) and sorted(gone)==sorted([h for h,_ in ALIASES]+[h for h,_ in NEW7]),'removed helpers') + i1={r:i for i,r in enumerate(L1)};bins={} + for pid in ('gauge44','extra'):need([old_prov[pid]['widths'][L0.index(r)] for r in L1]==new_prov[pid]['widths'],'renumbered widths') + for t,h,o,c,p,off in fill['rows']: + if L0[h] in gone:continue + bins.setdefault((o,c,p),[]).append([t,i1[L0[h]],o,c,p,off]) + rows=[] + for key,rs in bins.items(): + rs.sort(key=lambda x:x[5]);pos=0 + for x in rs:x[5]=pos;pos+=new_prov[dispatch[tuple(order[x[0]])]]['widths'][x[1]];rows.append(x) + rows.sort(key=lambda x:(x[0],x[1]));return dict(fill,rows=rows) +def need(ok,msg): + if not ok:raise ValueError(msg) +def rd(name): + p=HERE/'inputs'/name;b=p.read_bytes();return json.loads(gzip.decompress(b) if p.suffix=='.gz' else b) +def run(): + need(__debug__,'run without -O: inherited independent local checker uses assertions') + pins=json.loads((HERE/'INPUT-PINS.json').read_text()) + for path,digest in pins.items():need(hashlib.sha256((HERE/path).read_bytes()).hexdigest()==digest,'input digest '+path) + claim=json.loads((HERE/'CLAIM.json').read_text()) + need({int(k):v for k,v in claim['profile'].items()}==PROFILE,'claim profile') + need(F(claim['complex_lower'])==LOW and F(claim['complex_upper'])==LOW+F(1,10**24),'claim bracket') + need(F(claim['kappa'])==LOW-F(1,10**46)-F(1,10**70),'claim outer endpoint') + for name in ('PR2733','PR2745','PR2751','PR2766','PR2767'): + previous=json.loads((HERE/'evidence'/(f'{name}-OUTER-CLAIM.json' if name=='PR2767' else f'{name}-CLAIM.json')).read_text()) + need(F(claim['kappa'])>F(previous['kappa']),'strict improvement over '+name) + words={} + for tag,pid in [('base','gauge44'),('extra','extra')]: + w=rd('WORD-'+tag+'.json.gz');words[pid]=w + L.check_frames(w);L.check_cleanup(w);L.algebra(w) + need(set(int(t)+112 for t in w['target_levels']).isdisjoint(g[1] for g in w['cut']),'lifted targets avoid every cut read') + for label in ['drop_anticipatory','reverse_anticipatory','reverse_recovery']: + bad=copy.deepcopy(w) + if label=='drop_anticipatory':bad['initial_corrections'].pop() + elif label=='reverse_anticipatory':bad['initial_corrections'][0]['coefficient']=str(-F(bad['initial_corrections'][0]['coefficient'])) + else: + j=next(i for i,g in enumerate(bad['B']) if g[:5]==['add',49,33,-1,1]);bad['B'][j][3]=1 + try:L.algebra(bad) + except AssertionError:pass + else:raise ValueError('accepted mutation '+label) + order,fill,providers=rd('ORDER.json'),rd('FILL.json.gz'),rd('PROVIDERS.json') + dispatch={(s,r):p for s,r,p in rd('DISPATCH.json.gz')} + need(order==rd('SOURCE-ORDER.json'),'source order') + # retired5: PR2751's own construction (its words, providers and fill) is reproduced first ... + words51={'gauge44':rd('WORD2751-base.json.gz'),'extra':rd('WORD2751-extra.json.gz')};prov51=rd('PROVIDERS2751.json');fill51=rd('FILL2751.json.gz') + constructed,_,_=C.transform(rd('SOURCE-PROVIDERS.json'),prov51,rd('SOURCE-FILL.json.gz'),order,dispatch,words51) + need(constructed==fill51,'complete deterministic PR2751 fill') + # ... then the declared stages turn its words into the candidate words exactly ... + for tag,pid in [('base','gauge44'),('extra','extra')]: + w=refit_apply(words51[pid],rd('refit5_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias5_43'+tag+'.json'));w=refit_apply(w,rd('refit5c_43'+tag+'.json')) + w=refit_apply(w,rd('refit7_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('hostmove2_43'+tag+'.json'));w=WP.apply_lowfour(w,rd('alias7_43'+tag+'.json'));w=refit_apply(w,rd('refit7c_43'+tag+'.json')) # retired7 + need(w==words[pid],'declared stages reproduce the candidate word '+tag) + d2=dict(dispatch) + for s,r,p in fill['dispatch_overrides']:d2[s,r]=p + # ... and the candidate fill is PR2751's fill with the seven removed helpers' roles dropped, renumbered and re-tiled as bin prefixes + need(compact(fill51,words51,words,prov51,providers,order,d2)==fill,'complete deterministic candidate fill') + owner=I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,fill,providers,dispatch,PROFILE) + bad=copy.deepcopy(fill);bad['rows'][0][5]=999 + try:I.check(rd('PLAN.json.gz'),rd('GLOBAL-TEMPLATE.json.gz'),order,bad,providers,dispatch,PROFILE) + except (ValueError,RuntimeError):pass + else:raise ValueError('accepted out-of-bin placement') + _,a=M.moment_bounds(PROFILE,LOW);b,_=M.moment_bounds(PROFILE,LOW+F(1,10**24));need(a<6630466304,'PR2751 rejects candidate endpoint') + return {'status':'PASS_JOINT_TWELVE_RETIRED7_FINITE_REPLAY','roles':owner['roles'],'local_mutations_rejected':6,'owner_mutations_rejected':1,'complex_lower':str(LOW),'complex_upper':str(LOW+F(1,10**24)),'scope':'Independent local symbolic identity, actual frame bill, cleanup, exact hosting and moment only. Native/strict supplier/outer release is separate.'} +if __name__=='__main__':print(json.dumps(run(),indent=2)) diff --git a/research/tensor-block-kappa/vendor/frontier/verify_retired7.py b/research/tensor-block-kappa/vendor/frontier/verify_retired7.py new file mode 100644 index 0000000000..0f2c1ee50f --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/verify_retired7.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Marius-Paul Dumitrean, with substantial AI assistance (Anthropic Claude, via Claude Code). +# retired7 extension of verify_retired5.py (same author). +"""Bounded replay of retired7 on PR2751's words: the five retired-lender aliases (retired5 stages) plus two hostee moves that free +two more retired lenders (retired7 stages refit7 -> hostmove2 -> alias7 -> refit7c). Read-only, standard library only. + +1. Rebuilds both candidate words from PR2751's words through the seven declared stages (refit5, alias5, refit5c, refit7, hostmove2, + alias7, refit7c) and checks each stage's declared structure exactly. +2. Runs the pinned PR2679 BORROW-WORD auditor (vendor/audit_local_pr2679.py, byte-identical) on every state. +3. Tamper controls, each rejected by that auditor for a real reason: every lender refit undone (warp frame mismatch), every + follower raise undone, the PR2679 alias suite (7 mutations per alias, cleanup re-derived), one certified frame corrupted. +4. Literal owner check of the complete fill (independent_owners.py, integer chronology and bit-mask bins). +5. Exact endpoint: rational adjacent bracket of the moment root at 1e-24, an 80-digit decimal root, and + kappa = C - 10^-46 - 10^-70 strictly above the pinned exact claims of PR2751, PR2766 and PR2767. +""" +import contextlib, copy, gzip, hashlib, importlib.util, io, json, sys, tempfile +from decimal import Decimal, getcontext +from fractions import Fraction as F +from pathlib import Path +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +sys.path.insert(0, str(HERE)) +ALIASES = [(606, 550), (635, 551), (637, 552), (638, 553), (639, 562)] +MOVES = [(30, 401, 564, 911), (31, 403, 565, 912)] # retired7: (warp op, old lender, new lender, new lender's last B gate) +NEW7 = [(667, 401), (669, 403)] +H5 = [h for h, _ in ALIASES]; L5 = [L for _, L in ALIASES] +def need(ok, msg): + if not ok: raise ValueError(msg) +def rd(name): + p = HERE / name; b = p.read_bytes(); return json.loads(gzip.decompress(b) if p.suffix == '.gz' else b) +def load(name, path): + s = importlib.util.spec_from_file_location(name, path); m = importlib.util.module_from_spec(s); s.loader.exec_module(m); return m +def regs(e): return e[1:3] if e[0] == 'add' else e[1:2] +def refit_apply(w0, p): + w = copy.deepcopy(w0) + for sec, i, fr in p['frames']: + need(w[sec][i][:-1] == w0[sec][i][:-1], 'refit changes a gate'); w[sec][i][-1] = fr + w['report']['local_profile'] = p['local_profile']; return w +def frames_only(x, y): + need(set(x) == set(y) and all(x[k] == y[k] for k in x if k not in ('A', 'B', 'restore', 'report')), 'non-frame field changed') + need(all(len(x[k]) == len(y[k]) and all(a[:-1] == b[:-1] for a, b in zip(x[k], y[k])) for k in ('A', 'B', 'restore')), 'gate changed') + return {(k, i) for k in ('A', 'B', 'restore') for i, (a, b) in enumerate(zip(x[k], y[k])) if a != b} +def main(): + need(__debug__, 'run without -O: the pinned auditor and these checks use assertions') + pins = rd('INPUT-PINS.json') + for path, digest in pins.items(): need(hashlib.sha256((HERE / path).read_bytes()).hexdigest() == digest, 'input digest ' + path) + for name, digest in (('vendor/audit_local_pr2679.py', AUDITOR_SHA), ('vendor/word_patch_pr2679.py', WORD_PATCH_SHA)): + need(hashlib.sha256((HERE / name).read_bytes()).hexdigest() == digest, 'vendored source pin ' + name) + AU = load('audit_local_pr2679', HERE / 'vendor/audit_local_pr2679.py'); WP = load('word_patch_pr2679', HERE / 'vendor/word_patch_pr2679.py') + import independent_owners as I, exact_moment as M, retired7_controls as R7 + tmp = Path(tempfile.mkdtemp(prefix='retired5-')) + def audit(w, name): + p = tmp / (name + '.json.gz'); p.write_bytes(gzip.compress(json.dumps(w, separators=(',', ':')).encode(), mtime=0)) + try: + with contextlib.redirect_stdout(io.StringIO()): AU.run(p, tmp / (name + '.out.json'), None, None) + return None + except (AssertionError, RuntimeError, ValueError, KeyError, IndexError) as exc: + return (type(exc).__name__ + ': ' + str(exc))[:200] + def rederive(m, ref): + m2 = copy.deepcopy(m); A = m2['A']; m2['A'] = A[m2['prelude_events']:]; m2['cleanup'] = WP.derive_cleanup(m2, WP.restored_of(ref)); m2['A'] = A; return m2 + out = dict(words={}, controls={}) + for tag in ('base', 'extra'): + w0 = rd(f'inputs/WORD2751-{tag}.json.gz'); final = rd(f'inputs/WORD-{tag}.json.gz') + p1, p2, p3 = rd(f'inputs/refit5_43{tag}.json'), rd(f'inputs/alias5_43{tag}.json'), rd(f'inputs/refit5c_43{tag}.json') + s1 = refit_apply(w0, p1); ch1 = frames_only(w0, s1); need(ch1 == {(s, i) for s, i, _ in p1['frames']}, 'refit5 declared frames') + lastL = {L: max(p for p, e in enumerate(w0['B']) if L in regs(e)) for L in L5}; firstH = {h: min(p for p, e in enumerate(w0['B']) if h in regs(e)) for h in H5} + need(all(lastL[L] < firstH[h] for h, L in ALIASES) and not any(L in regs(e) for L in L5 for e in w0['restore']), 'lenders retired before their followers enter') + need(all(len(s1['B'][p][-1]) == len(w0['B'][p][-1]) - 1 == 5 for p in lastL.values()), 'lender last gates lowered 6 -> 5') + need(all(len(s1['B'][p][-1]) == len(w0['B'][p][-1]) + 1 == 5 for p in firstH.values()), 'follower first gates raised 4 -> 5') + s2 = WP.apply_lowfour(s1, p2) + need(WP.kernel_gate_edit(s1['B'], s2['B']) == p2['declared_gate_edit'] and sorted(set(s2['removed']) - set(s1['removed'])) == H5, 'alias5 declared edit and removed helpers') + need(s2['warps'][:len(s1['warps'])] == s1['warps'] and [x[1] for x in s2['warps'][len(s1['warps']):]] == L5 and all(len(x[3]) == len(x[4]) == 5 for x in s2['warps'][-5:]), 'alias5 warps') + need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p2['aliases']] == s2['warps'][-5:] and s2['A'] == s1['A'] and s2['restore'] == s1['restore'], 'alias5 records') + need(s2['start_extra'] == {k: v for k, v in s1['start_extra'].items() if int(k) not in H5} and not any(h in regs(e) for h in H5 for e in s2['B'] + s2['restore']), 'helpers fully removed') + need(all(s2[k] == s1[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias5 changes nothing else') + s3 = refit_apply(s2, p3); ch3 = frames_only(s2, s3); need(ch3 == {(s, i) for s, i, _ in p3['frames']}, 'refit5c declared frames') + p4, p5, p6, p7 = (rd(f'inputs/{n}_43{tag}.json') for n in ('refit7', 'hostmove2', 'alias7', 'refit7c')) + s4 = refit_apply(s3, p4); ch4 = frames_only(s3, s4); need(ch4 == {('B', g) for _, _, _, g in MOVES} == {(s, i) for s, i, _ in p4['frames']}, 'refit7 declared frames') + need(all(len(s3['B'][g][-1]) == 6 and len(s4['B'][g][-1]) == 5 and L1 in regs(s3['B'][g]) and max(p for p, e in enumerate(s3['B']) if L1 in regs(e)) == g for _, _, L1, g in MOVES), 'new lenders: last gates lowered 6 -> 5') + need(not any(L1 in regs(e) for _, _, L1, _ in MOVES for e in s3['restore']) and p4['previous_frames'] == [[s, i, s3[s][i][-1]] for s, i, _ in p4['frames']], 'new lenders retired; previous frames recorded') + s5 = WP.apply_lowfour(s4, p5) + need(WP.kernel_gate_edit(s4['B'], s5['B']) == p5['declared_gate_edit'] and s5['removed'] == s4['removed'] and s5['start_extra'] == s4['start_extra'], 'hostmove2 declared edit') + for i, (a, b) in enumerate(zip(s4['B'], s5['B'])): + c = list(a) + for op, L0, L1, _ in MOVES: + if i >= s4['warps'][op - 1][0]: c = [L1 if (j in (1, 2) if c[0] == 'add' else j == 1) and x == L0 else x for j, x in enumerate(c)] + need(c[:-1] == b[:-1], 'hostmove2 is exactly the relabel of the hostees from their warp positions') + need([i for i, (x, y) in enumerate(zip(s4['warps'], s5['warps'])) if x != y] == [op - 1 for op, _, _, _ in MOVES] and len(s5['warps']) == len(s4['warps']), 'hostmove2 replaces exactly warps 30 and 31 in place') + need(all(s4['warps'][op - 1][1] == L0 and s5['warps'][op - 1][1] == L1 and len(s5['warps'][op - 1][3]) == len(s5['warps'][op - 1][4]) == 5 and s5['warps'][op - 1][0] > g for op, L0, L1, g in MOVES), 'moved warps: new lenders, dim 5, after the lenders retire') + need([[m['pos'], m['L_new'], m['G'], m['U'], m['E']] for m in p5['moves']] == [s5['warps'][op - 1] for op, _, _, _ in MOVES] and [m['old_record'] for m in p5['moves']] == [s4['warps'][op - 1] for op, _, _, _ in MOVES], 'hostmove2 records') + need(all(not any(L0 in regs(e) for e in s5['B'] + s5['restore']) for _, L0, _, _ in MOVES), 'old lenders untouched after their A lives') + need(all(s5[k] == s4[k] for k in ('A', 'restore', 'helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'hostmove2 changes nothing else') + s6 = WP.apply_lowfour(s5, p6); H7 = [h for h, _ in NEW7]; L7 = [L for _, L in NEW7] + need(WP.kernel_gate_edit(s5['B'], s6['B']) == p6['declared_gate_edit'] and s6['removed'] == s5['removed'] + H7, 'alias7 declared edit and removed helpers') + need(s6['warps'][:len(s5['warps'])] == s5['warps'] and [x[1] for x in s6['warps'][len(s5['warps']):]] == L7 and all(len(x[3]) == len(x[4]) == 4 for x in s6['warps'][-2:]), 'alias7 warps') + need([[a['pos'], a['L'], a['G'], a['U'], a['E']] for a in p6['aliases']] == s6['warps'][-2:] and [a['h'] for a in p6['aliases']] == H7 and s6['A'] == s5['A'] and s6['restore'] == s5['restore'], 'alias7 records') + need(all(max([p for p, e in enumerate(s5['B']) if L in regs(e)], default=-1) < min(p for p, e in enumerate(s5['B']) if h in regs(e)) for h, L in NEW7) and not any(L in regs(e) for L in L7 for e in s5['restore']), 'alias7 lenders retired before their followers enter') + need(s6['start_extra'] == {k: v for k, v in s5['start_extra'].items() if int(k) not in H7} and not any(h in regs(e) for h in H7 for e in s6['B'] + s6['restore']), 'alias7 helpers fully removed') + need(all(s6[k] == s5[k] for k in ('helper_final', 'compensation', 'initial_corrections', 'precondition', 'cut', 'target_levels', 'centers', 'center_frames', 'ports', 'prelude_events')), 'alias7 changes nothing else') + s7 = refit_apply(s6, p7); ch7 = frames_only(s6, s7); need(ch7 == {(s, i) for s, i, _ in p7['frames']}, 'refit7c declared frames') + need(s7 == final, 'declared stages rebuild the candidate word ' + tag) + for j, (name, w) in enumerate((('pr2751', w0), ('refit5', s1), ('alias5', s2), ('retired5', s3), ('refit7', s4), ('hostmove2', s5), ('alias7', s6), ('candidate', s7))): + r = audit(w, f'{tag}-{name}'); need(r is None, f'auditor rejects {tag} {name}: {r}') + c = {} + for L, p in lastL.items(): + m = copy.deepcopy(final); m['B'][p][-1] = w0['B'][p][-1]; r = audit(m, f'{tag}-lender{L}'); c[f'lender {L} refit undone'] = r; need(r is not None and 'warp frame mismatch' in r, f'{tag} lender {L} refit undone not rejected by warp frame mismatch: {r}') + for h, p in firstH.items(): + m = copy.deepcopy(final); m['B'][p][-1] = w0['B'][p][-1]; r = audit(m, f'{tag}-follower{h}'); c[f'follower {h} raise undone'] = r; need(r is not None, f'{tag} follower {h} raise undone accepted') + for a in p2['aliases']: + h, L = a['h'], a['L']; op = next(i for i, x in enumerate(final['warps']) if x[1] == L and x[0] == a['pos']) + reads = [i for i, g in enumerate(final['B']) if i >= a['pos'] and g[0] == 'add' and g[2] == L] + writes = [i for i, g in enumerate(final['B']) if i >= a['pos'] and g[0] == 'add' and g[1] == L] + muts = [] + m = copy.deepcopy(final); m['B'][reads[0]][3] *= -1; muts.append(('borrowed read sign flipped', m)) + m = copy.deepcopy(final); m['B'][reads[0]][3] *= 2; muts.append(('borrowed read doubled', m)) + if writes: m = copy.deepcopy(final); m['B'][writes[0]][3] *= -1; muts.append(('borrowed write sign flipped', m)) + m = copy.deepcopy(final); del m['warps'][op] + for e in m['A'][:m['prelude_events']]: + if e[0] == 'warp' and abs(e[2]) > op + 1: e[2] -= 1 if e[2] > 0 else -1 + muts.append(('warp dropped', m)) + m = copy.deepcopy(final); m['warps'][op][2][0] ^= m['warps'][op][2][1]; muts.append(('G wrong', m)) + m = copy.deepcopy(final); m['warps'][op][0] = a['pos'] - 400; muts.append(('warp before lender retirement', m)) + m = copy.deepcopy(final); m['start_extra'][str(h)] = a['E']; muts.append(('helper kept with an entrance frame', m)) + for nm, m in muts: + r = audit(rederive(m, final), f'{tag}-{h}-{nm.replace(" ", "_")}'); c[f'{h}<-{L} {nm}'] = r + need(r is not None and not r.split(': ', 1)[-1].startswith(('explicit cleanup differs', 'warp operator id')), f'{tag} {h}<-{L} {nm}: not rejected for a real reason: {r}') + sec, i, fr = p3['frames'][len(p3['frames']) // 2]; m = copy.deepcopy(final); m[sec][i][-1] = [1]; r = audit(m, f'{tag}-refit5c-tamper'); c['certified frame corrupted'] = r; need(r is not None, f'{tag} refit5c tamper accepted') + ok7, c7 = R7.controls(final, p4, p5, p6, p7, lambda w: audit(w, f'{tag}-r7'), WP); need(ok7, f'{tag} retired7 controls: ' + json.dumps({k: v['reason'] for k, v in c7.items() if not v['real_reason']})[:300]) + c.update({k: v['reason'] for k, v in c7.items()}) + out['words'][tag] = dict(refit5_frames=len(ch1), alias5_gate_edits=len(p2['declared_gate_edit']), refit5c_frames=len(ch3), refit7_frames=len(ch4), hostmove2_gate_edits=len(p5['declared_gate_edit']), alias7_gate_edits=len(p6['declared_gate_edit']), refit7c_frames=len(ch7), retired7_controls=len(c7), local_profile=final['report']['local_profile']) + out['controls'][tag] = {k: v[:90] for k, v in c.items()} + # literal owner check of the complete candidate fill + order, fill, providers = rd('inputs/ORDER.json'), rd('inputs/FILL.json.gz'), rd('inputs/PROVIDERS.json') + dispatch = {(s, r): p for s, r, p in rd('inputs/DISPATCH.json.gz')} + profile = {int(k): v for k, v in rd('CLAIM.json')['profile'].items()} + owner = I.check(rd('inputs/PLAN.json.gz'), rd('inputs/GLOBAL-TEMPLATE.json.gz'), order, fill, providers, dispatch, profile) + need(owner['roles'] == 666 * 408 and owner['helpers_per_call'] == 408, 'owner fill size') + # exact endpoint and kappa + claim = rd('CLAIM.json'); C = F(claim['complex_lower']) + need(F(claim['complex_upper']) == C + F(1, 10 ** 24) and C.denominator <= 10 ** 24 and (C * 10 ** 24).denominator == 1, 'endpoint is a 1e-24 grid point') + _, a = M.moment_bounds(profile, C); b, _ = M.moment_bounds(profile, C + F(1, 10 ** 24)); need(a < 66304 < b, 'exact adjacent root bracket') + getcontext().prec = 90 + def g(z): return sum(Decimal(n) * (Decimal(r) / 73) ** (1 - z) for r, n in profile.items()) - 66304 + def dg(z): return sum(-Decimal(n) * (Decimal(r) / 73) ** (1 - z) * (Decimal(r) / 73).ln() for r, n in profile.items()) + z = Decimal(C.numerator) / Decimal(C.denominator) + for _ in range(8): z -= g(z) / dg(z) + need(F(str(z)) >= C and F(str(z)) < C + F(1, 10 ** 24), '80-digit root inside the certified bracket') + K = F(claim['kappa']); need(K == C - F(1, 10 ** 46) - F(1, 10 ** 70), 'claim kappa = C - 1e-46 - 1e-70') + margins = {} + for name, rel in (('PR2751', 'evidence/PR2751-CLAIM.json'), ('PR2766', 'evidence/PR2766-CLAIM.json'), ('PR2767', 'evidence/PR2767-OUTER-CLAIM.json')): + k = F(rd(rel)['kappa']); need(K > k, 'strict improvement over ' + name); d = K - k + margins[name] = dict(decimal=str(Decimal(d.numerator) / Decimal(d.denominator))[:40], exact=str(d) if len(str(d)) < 120 else 'K - kappa(' + rel + ')') + out.update(status='PASS_T74_JOINT_TWELVE_RETIRED7_STAGES_AUDITOR_CONTROLS_OWNERS_ENDPOINT', owner=dict(status=owner['status'], roles=owner['roles']), + complex_lower=str(C), root_80_digits=str(+z)[:82], kappa=str(K), margins=margins, + scope='Finite construction replay only: word stages, the pinned PR2679 auditor and its controls, the literal owner fill and exact moment arithmetic. Native providers, strict supplier and outer release are the full replay (full_replay.py).') + print(json.dumps(out, indent=1)) +AUDITOR_SHA = 'a38940094f7d19cd6376aafdd4734fa68eabc9aff4c98c3c4a3e9540328b1c90' +WORD_PATCH_SHA = '9b3287f189c4f29c1a8bdb1ba01fdcfe14a57d87b50fa4f2f646fb2346ab01ce' +if __name__ == '__main__': + main() diff --git a/research/tensor-block-kappa/vendor/frontier/workflow/admit.py b/research/tensor-block-kappa/vendor/frontier/workflow/admit.py new file mode 100644 index 0000000000..282ff24766 --- /dev/null +++ b/research/tensor-block-kappa/vendor/frontier/workflow/admit.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Tekalign (@tekuuu), with substantial OpenAI Codex assistance. +"""Prepare and fully admit a composed-word COMPOSED order/fill derivative. + +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-pr2733' +SOURCE_MANIFEST = '9c72b4301057a6c204c40bb6584eb74b779e06618bcd98d706d726c3e2c92451' # retired7 derived source: PR2751 overlay + five retired-lender aliases + two hostee moves and two aliases +PARENT_MANIFEST = 'e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4' +PRECISION = dict(endpoint_digits=24, grid_digits=18, margin_digits=28, bootstrap_steps=12) +NATIVE_STAGES = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases'] + + +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): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n') + + +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', 'native-cache', 'native-receipt', 'work'): + ap.add_argument('--' + name, type=Path, required=True) + ap.add_argument('--jobs', type=int, default=4) + ap.add_argument('--prepare-only', action='store_true') + a = ap.parse_args() + 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) == 506 and tree(source, ('MANIFEST.json',)) == source_files, + 'complete COMPOSED source inventory and hashes') + 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) + 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")]) + write(work / 'RUNTIME-PATCHES.json', patches) + shutil.copy2(a.fill, package / 'new/borrow-fill/FILL.json.gz') + shutil.copy2(a.order, package / 'new/borrow-fill/ORDER.json') + run('owners', package / 'reconstruct.py', '--out', work / 'owners') + run('parent-lift', package / 'lift_parent.py', '--owners', work / 'owners', '--out', work / 'parent-data') + for name in ('PLAN.json', 'OWNERS.json.gz', 'DISPATCH.json', 'PROFILE.json', 'CONSTRUCTION.json', + 'GLOBAL-TEMPLATE.json.gz', 'SPEC.json'): + shutil.copy2(work / 'parent-data' / name, package / name) + shutil.copy2(work / 'owners/ORDER.json', package / 'ORDER.json') + spec = read(package / 'SPEC.json') + spec['outer_refinement'] = PRECISION + spec['expected']['live'] = 66304 + # COMPOSED's pre-life mechanism changes which helper labels retain width8. + # Preserve its declared spot set; rebind and the original strict verifier + # still check the actual native widths, including every other helper. + source_spots = read(source / 'new/SPEC.json')['width_spot_helpers'] + need(source_spots == [278, 281, 284, 289], 'COMPOSED source spot-width pins') + spec['width_spot_helpers'] = source_spots + write(package / 'new/SPEC.json', spec) + run('rebind', package / 'new/rebind.py', package, natives['base'] / 'local', + natives['extra'] / 'local', work / 'rebound') + spec = read(work / 'rebound/SPEC.json') + need(spec['expected']['physical'] == 66794, 'complete physical cost including 72 buffers (R 408)') + layout = work / '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()), 'retained archive paths') + archive.extractall(layout, filter='data') + runtime = layout / 'packing74' + runtime.mkdir() + for name in ('replay.py', 'freeze_spec.py', 'audit_mixed.py', 'independent_core.py', 'geometry_controls.py', 'audit_fast.py'): + shutil.copy2(package / name, runtime / name) + for name in ('code', 'construction', 'inputs'): + shutil.copytree(package / name, runtime / name) + shutil.copytree(work / 'rebound', runtime / 'candidate') + shutil.copytree(natives['extra'], runtime / 'native-extra') + data = runtime / 'candidate' + result = dict(status='PREPARED_COMPOSED_SAME_WORD_DERIVATIVE_NOT_ADMITTED', source_commit=SOURCE_COMMIT, + source_manifest_sha256=SOURCE_MANIFEST, native_receipt_sha256=sha(a.native_receipt), + fill_sha256=sha(package / 'new/borrow-fill/FILL.json.gz'), + order_sha256=sha(package / 'new/borrow-fill/ORDER.json'), profile=read(work / 'rebound/PROFILE.json'), + patches=patches, scope='Prepared only; source/native/parent inputs authenticated and literal owner fill reconstructed.') + write(work / 'RESULT.json', result) + if a.prepare_only: + print(result['status'], flush=True) + return + run('discovery', runtime / 'replay.py', '--data', data, '--work', work / 'discovery', + '--local', natives['base'] / 'local', '--discover') + supplier = read(work / 'discovery/RESULT.json') + for name in ('PLAN.json', 'PROFILE.json', 'SPEC.json'): + shutil.copy2(data / name, package / 'new' / name) + spec = read(package / 'new/SPEC.json') + original_claim = read(source / 'CLAIM.json') + claim = dict(status='CONDITIONAL_CANDIDATE_EXPECTED_BY_REPLAY', kappa=supplier['kappa'], + kappa_decimal=supplier['kappa_decimal'], baseline_pr=2679, baseline_head=SOURCE_COMMIT, + baseline_kappa=read(source / 'outer/OUTER-CLAIM.json')['kappa'], outer_refinement=PRECISION, + scope=original_claim['scope'], kappa_layers=original_claim['kappa_layers'], + headline_kappa_source='outer/OUTER-CLAIM.json', + verification='Candidate discovered from literal fill; full original verification must pass separately.') + write(package / 'CLAIM.json', claim) + C = Q(spec['expected']['complex_lower']) + write(package / 'outer/B.json', dict(b=str(C-Q(1,10**104)), b_above_endpoint=str(C+Q(1,10**24)), + profile=spec['expected']['global_profile'], live=spec['expected']['live'])) + for name in ('check_ledger.py', 'independent_check.py'): + run('outer-' + name, package / 'outer' / name) + ledger = read(package / 'outer/LEDGER.json') + row = ledger['rows']['struct_boundary_radix_union']['kappa'] + kappa = Q(row['rational']) + previous = Q('0.0017161404259974415161889999999999999999999998999999999999999999999999') + need(kappa == C-Q(1,10**70)-Q(1,10**46) and kappa > previous and kappa > Q('17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000'), # retired5: also strictly above PR2751 + 'candidate must strictly improve pinned COMPOSED before full release') + outer_claim = read(source / 'outer/OUTER-CLAIM.json') + outer_claim.update(kappa=row['decimal'], kappa_rational=row['rational'], + baseline_head=SOURCE_COMMIT, 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) + 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') + result.update(status='PASS_COMPOSED_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/tensor-block-kappa/verify.py b/research/tensor-block-kappa/verify.py new file mode 100644 index 0000000000..45a1f05225 --- /dev/null +++ b/research/tensor-block-kappa/verify.py @@ -0,0 +1,79 @@ +"""Source inventory and independently replayed finite controls. Apache-2.0.""" +from __future__ import annotations +from hashlib import sha256 +import json +from pathlib import Path + +ALLOWED_AXIOMS = {"propext", "Classical.choice", "Quot.sound"} + +def need(condition, message): + if not condition: + raise ValueError(message) + +def digest(path): + return sha256(Path(path).read_bytes()).hexdigest() + +def inventory(root): + root = Path(root) + pins = json.loads((root / "MANIFEST.json").read_text(encoding="utf-8")) + actual = {p.relative_to(root).as_posix() for p in root.rglob("*") + if p.is_file() and ".lake" not in p.relative_to(root).parts + and "__pycache__" not in p.relative_to(root).parts + and p.relative_to(root).as_posix() != "MANIFEST.json"} + need(actual == set(pins), "exact package source inventory differs") + for name, expected in pins.items(): + p = root / name + need(not p.is_symlink() and p.resolve().is_relative_to(root.resolve()), "external source: " + name) + need(digest(p) == expected, "source hash differs: " + name) + return pins + +def validate_audit(rows, expected_names, expected_modules): + need(isinstance(rows, list) and rows, "empty declaration audit") + names = [r.get("name") for r in rows] + need(len(names) == len(set(names)), "duplicate declaration reports") + need(set(names) == set(expected_names), "missing or unexpected declaration reports") + need(all(r.get("module") in expected_modules for r in rows), "foreign defining module") + need(set(r["module"] for r in rows) == set(expected_modules), "missing defining module coverage") + for row in rows: + need(row.get("kind") in {"theorem", "definition", "opaque", "axiom", "other"}, "missing declaration kind") + need(row["kind"] != "axiom", "package declares its own axiom: " + row["name"]) + need(isinstance(row.get("axioms"), list), "missing axiom list") + need(set(row["axioms"]) <= ALLOWED_AXIOMS, "unapproved dependency: " + row["name"]) + need(any(r["kind"] == "theorem" for r in rows), "no actual theorem audit") + +def audit_controls(): + good = [{"name": "MultitapeToolkit.fixture", "module": "MultitapeToolkit.Model", "kind": "theorem", "axioms": ["propext"]}, + {"name": "_private.MultitapeToolkit.Model.0.helper", "module": "MultitapeToolkit.Model", "kind": "theorem", "axioms": []}] + expected = [r["name"] for r in good] + modules = {"MultitapeToolkit.Model"} + validate_audit(good, expected, modules) + cases = [([], "zero reports"), (good[:1], "missing report"), + (good + [good[0]], "duplicate report"), + (good + [dict(good[0], name="MultitapeToolkit.extra")], "unexpected report"), + ([dict(good[0], axioms=["sorryAx"]), good[1]], "unproved theorem"), + ([dict(good[0], axioms=["arbitraryOracle"]), good[1]], "unproved oracle"), + ([dict(r, kind="definition") for r in good], "no theorem"), + ([dict(good[0], axioms=None), good[1]], "absent axiom list"), + ([dict(good[0], kind="axiom", axioms=[]), good[1]], "forged empty own axiom"), + ([dict(good[0], module="Foreign.Model"), good[1]], "foreign ownership"), + ([dict(good[0], module="MultitapeToolkit.Trace"), good[1]], "unexpected module")] + for rows, label in cases: + try: + validate_audit(rows, expected, modules) + except (ValueError, TypeError): + continue + raise ValueError("accepted audit corruption: " + label) + return len(cases) + + +def main(): + import argparse + parser=argparse.ArgumentParser(description=__doc__) + parser.parse_args() + root=Path(__file__).resolve().parent + pins=inventory(root) + controls=audit_controls() + print(json.dumps(dict(status="PASS_SOURCE_INVENTORY_AND_AUDIT_CONTROLS",files=len(pins),audit_corruptions_rejected=controls,kernel_checked=False))) + +if __name__=="__main__": + main()