diff --git a/research/completed-prefix-outer/FREEZE.json b/research/completed-prefix-outer/FREEZE.json new file mode 100644 index 0000000000..bf1a9832f5 --- /dev/null +++ b/research/completed-prefix-outer/FREEZE.json @@ -0,0 +1,426 @@ +{ + "current_main_context": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "excluded": [ + "TERMINAL-SLOT-DECODER.md", + "check_terminal_slot_decoder.py", + "cover-algebra/PAST-CATALYST-REVIEW.md (different theorem family)" + ], + "files": [ + { + "bytes": 11357, + "path": "LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "bytes": 3453, + "path": "NOTICE.md", + "sha256": "d855a42b10cd5336df93972926010486fe0bcaa60fe3c8e1c9e6b9e8ddd927c9" + }, + { + "bytes": 5571, + "path": "PORTABILITY.json", + "sha256": "a02005447ef7bb64bf3828d969feb783d7d7c32001e960496c03130928fdf847" + }, + { + "bytes": 13666, + "path": "PORTABILITY.patch", + "sha256": "895b8cd673a24e6535de177dd92f5d5babd5fc5b3041b060d5aeb735f8ff752a" + }, + { + "bytes": 10017, + "path": "README.md", + "sha256": "3e0b684dc44aa5ff5c2a1acddcce0be2126bd78f7cd37e6f4aa465b49bf7243e" + }, + { + "bytes": 8876, + "path": "SOURCE-LINK-CHECK.json", + "sha256": "8a72074e7439326dc01eac70fbd07ba25b537b85e84f351c45aba59de4807568" + }, + { + "bytes": 19652, + "path": "SOURCES.json", + "sha256": "05790ba7eccfc00b68fb39c78bd69c20a983225fd5f070b5f083200196acc631" + }, + { + "bytes": 12032, + "path": "VALIDATION.json", + "sha256": "67d9d1e44b2afbff176c0f052695a6a337b5aadcd138b35776e18c55e5aee473" + }, + { + "bytes": 4922, + "path": "context/current-main/certificates/selected-result.json", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "bytes": 12204, + "path": "context/current-main/docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md", + "sha256": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b" + }, + { + "bytes": 84805, + "path": "frozen/CANONICAL-WORD.json.gz", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "bytes": 23232, + "path": "frozen/lanes/circuit-interface/INTERFACE.json", + "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" + }, + { + "bytes": 1270, + "path": "frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.json", + "sha256": "702efab9eba9236e9e4a7d2b45b4439332eccf3b2dcaa1ce235f4613bbcaf36d" + }, + { + "bytes": 2633, + "path": "frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.md", + "sha256": "ba7b2b0cb0fae5421e74991f3acaba543066743fcddca2e01a1e43e9d339904d" + }, + { + "bytes": 4104, + "path": "frozen/lanes/coherent-port/review_twiddle_pass_proofs.py", + "sha256": "1827aa705a2b68b478a9ffe09762b742123f558fa390c43fbf768fc54fe0d1e8" + }, + { + "bytes": 5376, + "path": "frozen/lanes/interface-proof/completed-prefix-review/REVIEW.json", + "sha256": "98011bafa57f35c697b0dd844671ecbef38f01753fa5692b04b4d441fe64f440" + }, + { + "bytes": 11703, + "path": "frozen/lanes/interface-proof/completed-prefix-review/REVIEW.md", + "sha256": "a936dd2febec8db2202e649218abc26127c30d9463bb7eaffb0e3363e6ec92a6" + }, + { + "bytes": 13761, + "path": "frozen/lanes/interface-proof/completed-prefix-review/review_prefix.py", + "sha256": "3719007502f72faa1df065bdb6d97c96a963cbedd34b22bd5c1108b85290eea6" + }, + { + "bytes": 13588, + "path": "frozen/lanes/schur-selection/PAST-CATALYST-v2.md", + "sha256": "566cfb7794202a2462a41da8abef69066c51a06ab7802c01f76b996e58e976e5" + }, + { + "bytes": 5319, + "path": "frozen/lanes/schur-selection/PAST-GAUGE-FUSION.md", + "sha256": "a84b77d2ef0d0747713063a7bd08e211b5a75eabbba6ff085a3967676fc12c6f" + }, + { + "bytes": 2691, + "path": "frozen/lanes/source-domain/OPPOSITE-PREFIX-REVIEW.json", + "sha256": "9b1d87077f32405f16989b73ae2b007497fbca815614b8e837fbc4c125a9784b" + }, + { + "bytes": 4204, + "path": "frozen/lanes/source-domain/OPPOSITE-PREFIX-REVIEW.md", + "sha256": "f63e6c6a85f3d4f0b27dd2832336720f2d2b829e0c0b682ed81f64d767de396d" + }, + { + "bytes": 6650, + "path": "frozen/lanes/source-domain/review_opposite_prefix.py", + "sha256": "1f035096e67dfbb78b56a163207329e375bf744c51bea6f58b0aae8be98cce5f" + }, + { + "bytes": 2405, + "path": "frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.json", + "sha256": "e1d740c7ebb02ad4d0d37c6dd38f237feb53a4ec20b539f846dcd72a25708dde" + }, + { + "bytes": 9195, + "path": "frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.md", + "sha256": "406e3cae0f69be8dd5c737b56e4af25b9aeb59de65d04dcb5355c67b2b5b371c" + }, + { + "bytes": 3686, + "path": "frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.json", + "sha256": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664" + }, + { + "bytes": 20628, + "path": "frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.md", + "sha256": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5" + }, + { + "bytes": 2870, + "path": "frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.json", + "sha256": "cb9145582e5bcf0771f331809ec96036cbd9d55f17986938c3abd31b603a2d5b" + }, + { + "bytes": 7010, + "path": "frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.md", + "sha256": "30bc7581255af6cd571a410f5e4c76b51eaa2f4956f9343a0ab133fa0d1e52ff" + }, + { + "bytes": 15915, + "path": "frozen/lanes/temporal-reuse/OUTER-ENCODING-INTERFACE.md", + "sha256": "d0e91321c459403b38dbbfd9a34d3117e9724d793b08dc0e69e3d8f138f6b84d" + }, + { + "bytes": 10876, + "path": "frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.json", + "sha256": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7" + }, + { + "bytes": 9123, + "path": "frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.md", + "sha256": "8f3ac9bc6133397ce98c88b0f6999c1eac9f6169d10fe21b2f0ab9d2275caee7" + }, + { + "bytes": 1264, + "path": "frozen/lanes/temporal-reuse/TWIDDLE-PASS-CHECKS.json", + "sha256": "67645d4a06901f6388238ac4edc15a3d1f4b9ec5af10696f30f14dff22cc0b1e" + }, + { + "bytes": 5804, + "path": "frozen/lanes/temporal-reuse/TWIDDLE-PASS-COST.md", + "sha256": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99" + }, + { + "bytes": 9526, + "path": "frozen/lanes/temporal-reuse/check_accumulated_twiddle_code.py", + "sha256": "4de3ef39be0b90f367062930df69f7db3fe250c34e6d39ac30db2e6872b2b3ab" + }, + { + "bytes": 12413, + "path": "frozen/lanes/temporal-reuse/check_completed_prefix_codes.py", + "sha256": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186" + }, + { + "bytes": 3151, + "path": "frozen/lanes/temporal-reuse/check_fixed_past_outer.py", + "sha256": "dcc6b830b9c6af85f0ccd5444d3519d632ba57ebd24753990d2c69f8c5f6e95a" + }, + { + "bytes": 6948, + "path": "frozen/lanes/temporal-reuse/check_past_catalyst_layout.py", + "sha256": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef" + }, + { + "bytes": 4432, + "path": "frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py", + "sha256": "1acf63009c7a1aaf589d7bf249c61a05e4a379ae5e8d2876df8bb6c805740be0" + }, + { + "bytes": 9644, + "path": "portable/check_accumulated_twiddle_code.py", + "sha256": "cc611e8033736c3f43fac2aeb277e01a695e91116cb386ce449679fde620df06" + }, + { + "bytes": 12347, + "path": "portable/check_completed_prefix_codes.py", + "sha256": "288db5fa5ff950748df284ed24323de3dad0922d0304679b3f5993decca0b877" + }, + { + "bytes": 3277, + "path": "portable/check_fixed_past_outer.py", + "sha256": "996e15224de66c698df37eaa5cae888e454baed6bacce82b5518e08aceba6aac" + }, + { + "bytes": 6884, + "path": "portable/check_past_catalyst_layout.py", + "sha256": "7b2620bb165dbe813fead8e97baa68037cd239d48be00a4e580a61215da0d516" + }, + { + "bytes": 4548, + "path": "portable/check_twiddle_pass_cost.py", + "sha256": "9904c441ee62410330c7d359797bd3659b9989c6b301961eaa1bcace4b0d7ca8" + }, + { + "bytes": 6784, + "path": "portable/review_opposite_prefix.py", + "sha256": "06e80d803af9a317a7abc702c8917044b4b3b6e067174b509bc589693d78fe03" + }, + { + "bytes": 13699, + "path": "portable/review_prefix.py", + "sha256": "7aa72c10c019d4b225a4d0908df17335cffb9a16b7caac1d8543fe2acdecb52a" + }, + { + "bytes": 4378, + "path": "portable/review_twiddle_pass_proofs.py", + "sha256": "5eccf649ddcc2619ac5f140810073b06ef83c0981f9b36fb20c2374b33f80126" + }, + { + "bytes": 4367, + "path": "replay.py", + "sha256": "719e95208a7d0a85a7b5283ab7743da3eb0c01060acc9aa1a73fbe85a19e5636" + }, + { + "bytes": 65761, + "path": "sources/upstream/CONTRIBUTORS.md", + "sha256": "c37caf0a5783aef24f981cb0110bd1764bc5ec9535a58bc62af7170c10b3a8ae" + }, + { + "bytes": 11357, + "path": "sources/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "bytes": 24973, + "path": "sources/upstream/NOTICE", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "bytes": 10725, + "path": "sources/upstream/certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "bytes": 85147, + "path": "sources/upstream/research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "bytes": 1964, + "path": "sources/upstream/research/gauge44-slots-t16/NOTICE.md", + "sha256": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf" + }, + { + "bytes": 6406, + "path": "sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610" + }, + { + "bytes": 950, + "path": "sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md", + "sha256": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816" + }, + { + "bytes": 6406, + "path": "sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md", + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610" + }, + { + "bytes": 2245, + "path": "sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md", + "sha256": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + { + "bytes": 11357, + "path": "sources/upstream/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "bytes": 541, + "path": "sources/upstream/upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + { + "bytes": 11311, + "path": "sources/upstream/upstream/build/sections/02-streams.tex", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + { + "bytes": 19884, + "path": "sources/upstream/upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + { + "bytes": 46811, + "path": "sources/upstream/upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + { + "bytes": 33854, + "path": "sources/upstream/upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + { + "bytes": 3686, + "path": "validation/normal/1-COMPLETED-PREFIX-CODES.json", + "sha256": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664" + }, + { + "bytes": 10876, + "path": "validation/normal/2-PAST-CATALYST-LAYOUT.json", + "sha256": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7" + }, + { + "bytes": 1264, + "path": "validation/normal/3-TWIDDLE-PASS-CHECKS.json", + "sha256": "dad8ca501fdedd1958482d446b398458bf91494ac189c870e6237caf50eea6f0" + }, + { + "bytes": 2405, + "path": "validation/normal/4-ACCUMULATED-TWIDDLE-CODE.json", + "sha256": "eb46150d267d770c3cafba5d990a8341bebfedea532d1af82bcb843c6a099ff3" + }, + { + "bytes": 2691, + "path": "validation/normal/5-OPPOSITE-PREFIX-REVIEW.json", + "sha256": "9b1d87077f32405f16989b73ae2b007497fbca815614b8e837fbc4c125a9784b" + }, + { + "bytes": 5376, + "path": "validation/normal/6-REVIEW.json", + "sha256": "b4382e422a55e78f35bdc309c2cf679d317d32dd17bfc39e158cc97f8431c09d" + }, + { + "bytes": 1270, + "path": "validation/normal/7-TWIDDLE-PASS-PROOF-REVIEW.json", + "sha256": "54eb4b7dd5dd9fad115ec7cf173fa596ed259d569377c23c12d2c205968d05da" + }, + { + "bytes": 2870, + "path": "validation/normal/8-FIXED-PAST-OUTER-CLOSURE.json", + "sha256": "cb9145582e5bcf0771f331809ec96036cbd9d55f17986938c3abd31b603a2d5b" + }, + { + "bytes": 3817, + "path": "validation/normal/REPLAY.json", + "sha256": "a6aa7532f469d953dff9a8184d986c1405419ed2cdfccc6b2472809fb6cba205" + }, + { + "bytes": 3686, + "path": "validation/optimized/1-COMPLETED-PREFIX-CODES.json", + "sha256": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664" + }, + { + "bytes": 10876, + "path": "validation/optimized/2-PAST-CATALYST-LAYOUT.json", + "sha256": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7" + }, + { + "bytes": 1264, + "path": "validation/optimized/3-TWIDDLE-PASS-CHECKS.json", + "sha256": "dad8ca501fdedd1958482d446b398458bf91494ac189c870e6237caf50eea6f0" + }, + { + "bytes": 2405, + "path": "validation/optimized/4-ACCUMULATED-TWIDDLE-CODE.json", + "sha256": "eb46150d267d770c3cafba5d990a8341bebfedea532d1af82bcb843c6a099ff3" + }, + { + "bytes": 2691, + "path": "validation/optimized/5-OPPOSITE-PREFIX-REVIEW.json", + "sha256": "9b1d87077f32405f16989b73ae2b007497fbca815614b8e837fbc4c125a9784b" + }, + { + "bytes": 5376, + "path": "validation/optimized/6-REVIEW.json", + "sha256": "b4382e422a55e78f35bdc309c2cf679d317d32dd17bfc39e158cc97f8431c09d" + }, + { + "bytes": 1270, + "path": "validation/optimized/7-TWIDDLE-PASS-PROOF-REVIEW.json", + "sha256": "54eb4b7dd5dd9fad115ec7cf173fa596ed259d569377c23c12d2c205968d05da" + }, + { + "bytes": 2870, + "path": "validation/optimized/8-FIXED-PAST-OUTER-CLOSURE.json", + "sha256": "cb9145582e5bcf0771f331809ec96036cbd9d55f17986938c3abd31b603a2d5b" + }, + { + "bytes": 3817, + "path": "validation/optimized/REPLAY.json", + "sha256": "5e30cc0cd4dc562357e96efdb3988addbd7b3386b98d7cebc2c54b526c1ea40b" + } + ], + "fixed_past_status": "Conditional supplement; scalar check only in prior campaign; no distinct prior independent closure review.", + "historical_source": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "package": "completed-prefix-outer", + "publication_status": "No commit, push, merge, PR write, or external message performed by this packaging worker.", + "schema": 1, + "status": "READY_FOR_INDEPENDENT_REVIEW" +} diff --git a/research/completed-prefix-outer/LICENSE b/research/completed-prefix-outer/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/completed-prefix-outer/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/completed-prefix-outer/NOTICE.md b/research/completed-prefix-outer/NOTICE.md new file mode 100644 index 0000000000..171b47ec4e --- /dev/null +++ b/research/completed-prefix-outer/NOTICE.md @@ -0,0 +1,51 @@ +# Attribution and license + +The completed-prefix, changed opposite DIF, address-layout, and twiddle +results were prepared in the centre-encoding campaign under the user's +direction, with substantial OpenAI Codex assistance. Separate agents +prepared the retained reviews. This is not independent human peer review. +The publication package preserves the original proof, checker, and review +bytes. The executable copies change source access, output paths, and CLI +arguments only. [PORTABILITY.patch](PORTABILITY.patch) records those edits. + +The transform and stream primitives are consumed from the OpenAI +manuscript, *Integer multiplication below n log n*. Its +[source README](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/upstream/README.md) +identifies OpenAI as the author. The copied Sections 02, 04, 05, and 06 +retain that source and its Apache-2.0 license. The repository +[NOTICE](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/NOTICE) +retains Douglas Colkitt's project notice and the source-specific community +credits, including icekylinx's bulk recursion, controlled tensor basis, +and precision framework. These are inherited premises and primitives. + +The historical port list and scalar interface retain the supplier lineage. +The [Gauge44 notice](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/research/gauge44-slots-t16/NOTICE.md) +credits @icekylinx for the source gauge and its construction. The +[T16 notice](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/research/gauge44-slots-t16/t16/NOTICE.md) +credits Hao Yan @FanPUYen for the replica integration, Jeremy Kothe +@jeremykothe2 for the accepted X4 word from +[PR #799](https://github.com/CrocSwap/integer-mult-bounds/pull/799), and +Chafik Boukhalfa @chafreaky for the frame and owner work in +[PR #741](https://github.com/CrocSwap/integer-mult-bounds/pull/741) and +[PR #685](https://github.com/CrocSwap/integer-mult-bounds/pull/685). +It retains Rohan Arun @rohanarun for the native recurrence correction, +plus DreamingOfClouds, eumemic, Jeremy Diviney, jaymosley07, and the full +preceding controller, hosting, and verification lineage. These credits +come from the source notices and +[contributor ledger](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/CONTRIBUTORS.md). +They are not inferred from a PR submitter account. + +The local circuit-interface port receipt, the two Schur context notes, +and the temporal-reuse proofs are consumed campaign sources. The +coherent-port lane supplied the conditional disjoint-layer product +identity used as background to the accumulated-twiddle result. The +interface-proof, source-domain, and coherent-port reviews retain their +scope and source hashes. [SOURCES.json](SOURCES.json) identifies every +copied file. The Schur notes are context for the interface review; this +package does not repeat their source extraction or native rank invoice. + +The [repository license](LICENSE), [manuscript license](sources/upstream/upstream/LICENSE), +[complete repository notice](sources/upstream/NOTICE), and source-specific +Gauge44 notices are included without edits. Apache-2.0 applies. Existing +source notices and assistance disclosures remain in force. No source +license, contributor credit, or prior claim is replaced by this package. diff --git a/research/completed-prefix-outer/PORTABILITY.json b/research/completed-prefix-outer/PORTABILITY.json new file mode 100644 index 0000000000..4ea2dd3229 --- /dev/null +++ b/research/completed-prefix-outer/PORTABILITY.json @@ -0,0 +1,147 @@ +[ + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.json", + "mathematical_functions_unchanged": [ + "exact_dif_check", + "inverse", + "line_normalizer_check", + "multiply", + "need", + "one_round", + "opposite_check", + "opposite_round", + "prefix_matrix", + "reverse3", + "selected_bit_check", + "unit" + ], + "portable": "portable/check_completed_prefix_codes.py", + "portable_sha256": "288db5fa5ff950748df284ed24323de3dad0922d0304679b3f5993decca0b877", + "source": "frozen/lanes/temporal-reuse/check_completed_prefix_codes.py", + "source_sha256": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.json", + "mathematical_functions_unchanged": [ + "need", + "permutation_inverse", + "reserve_check", + "rotation_check", + "swap" + ], + "portable": "portable/check_past_catalyst_layout.py", + "portable_sha256": "7b2620bb165dbe813fead8e97baa68037cd239d48be00a4e580a61215da0d516", + "source": "frozen/lanes/temporal-reuse/check_past_catalyst_layout.py", + "source_sha256": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/temporal-reuse/TWIDDLE-PASS-CHECKS.json", + "mathematical_functions_unchanged": [ + "add", + "matmul", + "multiply", + "need", + "scale", + "sum_ring" + ], + "portable": "portable/check_twiddle_pass_cost.py", + "portable_sha256": "9904c441ee62410330c7d359797bd3659b9989c6b301961eaa1bcace4b0d7ca8", + "source": "frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py", + "source_sha256": "1acf63009c7a1aaf589d7bf249c61a05e4a379ae5e8d2876df8bb6c805740be0" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.json", + "mathematical_functions_unchanged": [ + "butterfly", + "conjugate", + "need", + "output_code", + "parity_class", + "plus", + "put", + "row_product", + "square_norm", + "times", + "twiddle", + "word" + ], + "portable": "portable/check_accumulated_twiddle_code.py", + "portable_sha256": "cc611e8033736c3f43fac2aeb277e01a695e91116cb386ce449679fde620df06", + "source": "frozen/lanes/temporal-reuse/check_accumulated_twiddle_code.py", + "source_sha256": "4de3ef39be0b90f367062930df69f7db3fe250c34e6d39ac30db2e6872b2b3ab" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/source-domain/OPPOSITE-PREFIX-REVIEW.json", + "mathematical_functions_unchanged": [ + "direct_phase", + "layout", + "path_phase", + "require", + "reverse" + ], + "portable": "portable/review_opposite_prefix.py", + "portable_sha256": "06e80d803af9a317a7abc702c8917044b4b3b6e067174b509bc589693d78fe03", + "source": "frozen/lanes/source-domain/review_opposite_prefix.py", + "source_sha256": "1f035096e67dfbb78b56a163207329e375bf744c51bea6f58b0aae8be98cce5f" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/interface-proof/completed-prefix-review/REVIEW.json", + "mathematical_functions_unchanged": [ + "check_rotation", + "column", + "exact_dif", + "exchange", + "gadd", + "gmul", + "layout_names", + "matrix", + "need", + "padd", + "pmul", + "reserve_views", + "reverse", + "selected_offsets", + "twiddle_control" + ], + "portable": "portable/review_prefix.py", + "portable_sha256": "7aa72c10c019d4b225a4d0908df17335cffb9a16b7caac1d8543fe2acdecb52a", + "source": "frozen/lanes/interface-proof/completed-prefix-review/review_prefix.py", + "source_sha256": "3719007502f72faa1df065bdb6d97c96a963cbedd34b22bd5c1108b85290eea6" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.json", + "mathematical_functions_unchanged": [ + "add", + "matmul", + "mul", + "need", + "scale" + ], + "portable": "portable/review_twiddle_pass_proofs.py", + "portable_sha256": "5eccf649ddcc2619ac5f140810073b06ef83c0981f9b36fb20c2374b33f80126", + "source": "frozen/lanes/coherent-port/review_twiddle_pass_proofs.py", + "source_sha256": "1827aa705a2b68b478a9ffe09762b742123f558fa390c43fbf768fc54fe0d1e8" + }, + { + "edits": "Source paths, output path, and CLI arguments only. Git reads use the pinned file copies.", + "expected": "frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.json", + "mathematical_functions_unchanged": [ + "add", + "multiply", + "need", + "product", + "scalar" + ], + "portable": "portable/check_fixed_past_outer.py", + "portable_sha256": "996e15224de66c698df37eaa5cae888e454baed6bacce82b5518e08aceba6aac", + "source": "frozen/lanes/temporal-reuse/check_fixed_past_outer.py", + "source_sha256": "dcc6b830b9c6af85f0ccd5444d3519d632ba57ebd24753990d2c69f8c5f6e95a" + } +] diff --git a/research/completed-prefix-outer/PORTABILITY.patch b/research/completed-prefix-outer/PORTABILITY.patch new file mode 100644 index 0000000000..1a84bffeda --- /dev/null +++ b/research/completed-prefix-outer/PORTABILITY.patch @@ -0,0 +1,312 @@ +--- frozen/lanes/temporal-reuse/check_completed_prefix_codes.py ++++ portable/check_completed_prefix_codes.py +@@ -5,11 +5,10 @@ + from pathlib import Path + import argparse + import json +-import subprocess +- +- +-HERE = Path(__file__).resolve().parent +-ROOT = HERE.parents[3] ++ ++ ++PACKAGE = Path(__file__).resolve().parents[1] ++HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" + REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" + PINS = { + "upstream/build/sections/02-streams.tex": +@@ -252,12 +251,12 @@ + + def main(): + parser = argparse.ArgumentParser() +- parser.add_argument("--repo", type=Path, default=ROOT / "worktrees/k5-centre-sharing") +- parser.add_argument("--out", type=Path, default=HERE / "COMPLETED-PREFIX-CODES.json") ++ parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") ++ parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + source = {} + for path, pin in PINS.items(): +- raw = subprocess.check_output(["git", "-C", str(args.repo), "show", REVISION+":"+path]) ++ raw = (args.sources / path).read_bytes() + need(sha256(raw).hexdigest() == pin, "Source hash: "+path) + source[path] = raw + assembly = json.loads(source["research/community-frontier1094-audit/ASSEMBLY.json"]) +--- frozen/lanes/temporal-reuse/check_past_catalyst_layout.py ++++ portable/check_past_catalyst_layout.py +@@ -5,11 +5,10 @@ + from pathlib import Path + import argparse + import json +-import subprocess + + +-HERE = Path(__file__).resolve().parent +-ROOT = HERE.parents[3] ++PACKAGE = Path(__file__).resolve().parents[1] ++HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" + REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" + PINS = { + "upstream/build/sections/02-streams.tex": +@@ -112,12 +111,12 @@ + + def main(): + parser = argparse.ArgumentParser() +- parser.add_argument("--repo", type=Path, default=ROOT / "worktrees/k5-centre-sharing") +- parser.add_argument("--out", type=Path, default=HERE / "PAST-CATALYST-LAYOUT.json") ++ parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") ++ parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + sources = {} + for path, digest in PINS.items(): +- raw = subprocess.check_output(["git", "-C", str(args.repo), "show", REVISION+":"+path]) ++ raw = (args.sources / path).read_bytes() + need(sha256(raw).hexdigest() == digest, "Source hash: "+path) + sources[path] = raw + assembly = json.loads(sources["research/community-frontier1094-audit/ASSEMBLY.json"]) +--- frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py ++++ portable/check_twiddle_pass_cost.py +@@ -4,14 +4,13 @@ + from hashlib import sha256 + from pathlib import Path + import gzip ++import argparse + import json +-import subprocess + +-HERE = Path(__file__).resolve().parent +-ROOT = HERE.parents[3] +-REPO = ROOT / "worktrees/k5-centre-sharing" ++PACKAGE = Path(__file__).resolve().parents[1] ++HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" + REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +-WORD = ROOT / "work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz" ++WORD = PACKAGE / "frozen/CANONICAL-WORD.json.gz" + WORD_HASH = "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + + +@@ -56,6 +55,10 @@ + + + def main(): ++ parser = argparse.ArgumentParser(description=__doc__) ++ parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") ++ parser.add_argument("--out", type=Path, required=True) ++ args = parser.parse_args() + raw = WORD.read_bytes() + need(sha256(raw).hexdigest() == WORD_HASH, "The actual port source changed") + ports = json.loads(gzip.decompress(raw))["ports"] +@@ -89,7 +92,7 @@ + need(0 <= k < u//2 and (2*r//u)*k == r//2, "The current-round tail is invalid") + tail_cases += 1 + source_path = "upstream/build/sections/06-transforms.tex" +- source = subprocess.check_output(["git", "-C", str(REPO), "show", REVISION+":"+source_path]) ++ source = (args.sources / source_path).read_bytes() + need(b"\\frac{2r}{u_i}\\,b_i k_i" in source and b"0\\leq k_i (x-J^T y,y,h,0)", + "corrected_map_forward": "(x,y,h,c) -> (x,y+Jx,h,0)", + "corrected_program_checks": { + "backward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198814, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + }, + "forward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198766, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + } + }, + "corrected_program_payload_sha256": "fa60b4af013dd8b8db289845e3ed597720ff955751ad270c3d58236b64080877", + "dirty_correction_site": "After entry adapters and before A; targets and all helpers in H have canonical frame zero.", + "full_input_columns": 712, + "full_output_rows": 712, + "identities": [ + "R R^T = 56 I8", + "P = R^T R/4", + "P^2 = 14 P", + "J = I112-P", + "J^2+12J-13I112=0", + "J^-1 = (12I112+J)/13" + ], + "map": "(x,y,h,c) -> (x, y + J x - R^T H h/4, h, 0)", + "not_claimed": [ + "Native centre-free supplier admission", + "Free endpoint J^-1", + "Changed global controller", + "Kappa improvement" + ], + "ports": [ + 11, + 19, + 35, + 67, + 131, + 259, + 13, + 21, + 37, + 69, + 133, + 261, + 41, + 73, + 137, + 265, + 49, + 81, + 145, + 273, + 161, + 289, + 193, + 321, + 385, + 14, + 22, + 38, + 70, + 134, + 262, + 26, + 74, + 138, + 266, + 50, + 146, + 274, + 98, + 162, + 290, + 194, + 322, + 386, + 28, + 44, + 140, + 268, + 84, + 148, + 276, + 100, + 164, + 292, + 196, + 324, + 388, + 56, + 88, + 152, + 280, + 104, + 168, + 296, + 200, + 328, + 392, + 112, + 176, + 304, + 208, + 336, + 400, + 224, + 352, + 416, + 448, + 508, + 506, + 502, + 494, + 478, + 446, + 382, + 254, + 505, + 501, + 493, + 477, + 445, + 381, + 253, + 499, + 491, + 475, + 443, + 379, + 251, + 487, + 471, + 439, + 375, + 247, + 463, + 431, + 367, + 239, + 415, + 351, + 223, + 319, + 191 + ], + "program_sha256": "9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3", + "scope": "Exact scalar interface only. Native endpoint mixing and a changed controller are not admitted.", + "status": "PASS_CENTRE_FREE_SCALAR_INTERFACE", + "target_endpoint": "T_q = F C_q^-1; distinct q have distinct frames", + "word_sha256": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c" +} diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json new file mode 100644 index 0000000000..da8c1ac34a --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json @@ -0,0 +1,30 @@ +{ + "material_findings": [], + "not_claimed": [ + "owner admission", + "one-use mode-history admission", + "native endpoint decoder", + "complete supplier cost", + "general native-child lower bound" + ], + "not_replayed": [ + "producer 17-block free-algebra run", + "producer route reconstruction and schedule coefficients" + ], + "resolved_wording_finding": "The final proof keeps the line and source-map factors on its expanded scalar terms.", + "sources": { + "coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md": "bc7b4ceb58af5a55669c784ac3cb23ede1811e6e39179aff9b0e119fcf472cc7", + "coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md": "1783100d3333c83828b47bb89f267db54b791f4c4fe952b5a62fbdb5087c902f", + "encoded-controller/ORIGINAL-PAIRED-CONTROLLER.json": "75b24a3be7ba9bb32501196bc660b5438ea25436b94da83ff55b136c89212496", + "encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "encoded-controller/check_original_paired_controller.py": "bbf3381992ee67b9650ef15b26d5d84f3f00d7bdca0d11977399ed85f27a338f" + }, + "status": "PASS_BOUNDED_INDEPENDENT_PROOF_REVIEW", + "verified_by_independent_reasoning": [ + "ordered three-step joint inverse assuming the stated source and response coefficients", + "data-side Q H=A^-1 H and G Q^-1=-G A without a mode-side A", + "physical endpoint conjugation and zero feedback after the bank signs", + "integer 2912 witness assuming the producer-checked distinct routes and source schedule", + "mode-only reuse contradiction under the stated unchanged data word" + ] +} diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md new file mode 100644 index 0000000000..596083dd1d --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md @@ -0,0 +1,100 @@ +# Independent proof review of the original paired controller + +Status: PASS in the scope below. + +This review reads the final proof in +`../encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md`, with SHA-256 +`412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1`. +The related producer receipt has SHA-256 +`75b24a3be7ba9bb32501196bc660b5438ea25436b94da83ff55b136c89212496`. +The producer checker has SHA-256 +`bbf3381992ee67b9650ef15b26d5d84f3f00d7bdca0d11977399ed85f27a338f`. + +This is a separate proof review. It does not repeat the producer's +17-block free-algebra run or its route reconstruction. The local native +contract is the contract checked in +`ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md`. + +## Ordered algebra + +Let Q act equally on the paired data replicas. Let A be the specified +port-dependent monomial map, and let T=QA. Then T squared is I and +A commutes with Q. For the defined H_s and G_s, the relations +T H_s=H_s and G_s T=-G_s hold without moving A through R, K, or a +mode gauge. In particular, + +```text +A^-1=TQ, +Q H_s=A^-1 H_s, +G_s Q^-1=-G_s A. +``` + +These are data-side identities. They do not define an action of A on +the centre modes. The proof retains this distinction. + +Write L for the response map and Tq for the query map. The relation +Tq L=0 gives the exact inverse of the stated joint map. Direct +substitution gives + +```text +D1=D'-LPV=D-L(I-P)U, +-V-Tq D1=U, +D1+L(I-P)U=D. +``` + +This uses only the stated ordered products. It does not interchange a +query and a response coefficient. + +At the physical boundary, let B and C have the stated data-bank +monomial blocks. Then WL=BL and Tq W^-1=Tq C. Substitution into the +logical map gives the displayed physical matrix. Its two rectangular +factors have zero product because + +```text +(Tq C)(BL)=Tq(CB)L=0. +``` + +Here CB is a scalar sign on each data bank. Such signs can change the +bank coefficients but leave every G_s H_t product zero. Thus the same +inverse applies to the physical matrix. This statement does not make +the remaining H and G accesses native-free. + +## Mode-only reuse limit + +The proof uses the producer's exact source schedule and the fact that +the 112 stage-one port routes are distinct involutions. Under those +stated facts, its witness is exact. With R_s=R D_s, + +```text +h=(56I-R_1^*R_1)R_0^*e_k delta_identity, +R_1h=0, +[R_0h]_identity=(3136-224)e_k=2912e_k. +``` + +The identity coefficient 224I follows from the distinct-route condition: +only equal port indices remain, and each root column has squared norm +4. A constant native payload has Q=I. The paired input (h,-h) therefore +has zero stage-one projected query and a nonzero stage-zero projected +query. The stated schedule makes all its later ordinary query sources +zero. Earlier response errors cannot change this, since every later +query annihilates every earlier response image. + +Any invertible map on the full mode state preserves a nonzero mode +signal. A local call with a zero query also preserves that signal up to +its invertible mode sign and gauge. Thus mode-only operations cannot +restore the initial zero mode state for this input. The proof correctly +excludes a new data read, a changed data word, and a mixed data/mode +terminal from this result. + +## Review boundary + +The ordered inverse, the data-side boundary identities, and the +conditional 2912 witness argument pass this review. The exact source +rows and route-distinctness checks remain producer dependencies. This +review does not claim an independent free-engine or route replay, +owner admission, one-use mode-history admission, a native implementation +of the endpoint decoder, or a complete supplier cost. + +The final proof now describes its 100352 expanded scalar terms with +their line and source-map factors. It does not describe these terms as +an implementation by scalar monomial operations alone. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json new file mode 100644 index 0000000000..b93fef9ec4 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json @@ -0,0 +1,35 @@ +{ + "actual_port_routes": 1008, + "affine_translation_checks": 265216, + "checker_sha256": "e79e104b2497e80427c2040c940942e9654c24e4736b981ec11f09eafb768f95", + "exact_line_spatial_columns": 57344, + "formal_ordered_operator_checks": 9, + "pins": { + "canonical_gzip": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "core": "f271842a741584389e166e700e262f161b0dd570ce8c7a540f2717e90ead5205", + "geometry": "498d85807dd3032de01b5da72a67717f02ee0ecf068e8c47f67d4f21034cd896", + "interface": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "lines": "500c09dfc1d27ffd107341adf4c3c6874ee2c84e1a8afad91d931ed9e88fd1d7", + "original_phases": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "program": "42aeb0902d8b2330f9050718c6d949993111a9fd898acad599ec867bb63a2b20" + }, + "proof_sha256": "1783100d3333c83828b47bb89f267db54b791f4c4fe952b5a62fbdb5087c902f", + "scope": "Independent literal wrapper, ordered endpoint, inherited line kernel and route covariance review. The full-mode core is a pinned dependency; no new full-core replay, paired owner admission, mode endpoint closure, terminal H/G access, full supplier invoice or kappa improvement is claimed.", + "status": "PASS_INDEPENDENT_ORIGINAL_PAIRED_GAP_NATIVE_COMPONENT", + "wrapper_counts": { + "backward": { + "ADDs": 2688, + "added_scalar_subtotal": 34048, + "core_dependent_scalar_subtotal": 442884, + "native_rank": 11044, + "translations": 448 + }, + "forward": { + "ADDs": 2688, + "added_scalar_subtotal": 25088, + "core_dependent_scalar_subtotal": 433924, + "native_rank": 11044, + "translations": 448 + } + } +} diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md new file mode 100644 index 0000000000..fe63433f9d --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md @@ -0,0 +1,184 @@ +# Original complex paired phase graphs + +This review checks a local construction in the original complex native +frames. It does not use the Walsh change of frame. Two copies of the +reviewed full-mode core have identical port labels and native axes. +Their ordinary helper inputs and their sixteen mode inputs are arbitrary. +Their active data and mode roles must be separate during the paired call. +An ordinary helper owner may be reused only through complete restored +jobs, with the correct consecutive native frames and no intervening +scalar use. Admission of such reuse is part of the owner schedule; the +local wrapper check does not supply it. + +The reviewed payload is +`../residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP-PROGRAMS.json.gz`, +with decompressed SHA256 +`42aeb0902d8b2330f9050718c6d949993111a9fd898acad599ec867bb63a2b20`. +It retains two copies of the full-mode payload +`f271842a741584389e166e700e262f161b0dd570ce8c7a540f2717e90ead5205`. +This review uses the prior exact core contract. It does not repeat the +complete native-event or 1408-column replay of that producer. + +## The fixed pair at every tensor size + +At port p let Q_p be the tensor power of the inherited C_p. Put + +```text +L_p = Q_p^2, +A_p = [[0,I],[L_p,0]], +T_p = Q_p A_p = [[0,Q_p],[Q_p^-1,0]]. +``` + +The exact inherited line identity is C_p squared equals the translation +X_p, with no scalar phase. Thus L_p translates every tensor coordinate by +p. It is an involution. It follows that T_p squared is I. This uses two +replicas for every tensor size. It is not a tensor power of a two-replica +map. All powers of the common full transform commute with these line +transforms and translations. + +Extend R and K by the identity on the replica index, and set K=R^T/4. +A acts on the port fields. No action of A on eight mode fields is defined +or used. In particular, this proof does not exchange R A with A R or +A K with K A. + +## The four physical boundary graphs + +The input frames of (x,y,u) are (Q,I,I). Their output frames are +(F,F Q^-1,F). A physical ADD between different frame types is interpreted +in this order; it is not treated as a scalar ADD on logical contents. + +For the forward word, use the following physical graphs in order: + +```text +u -= R A X; run both full-mode cores; +u += R X; Y += A K u. +``` + +The first graph gives u=z-R T x. The raw core gives + +```text +x'=x, y1=y+(I-KR)x-Ku, u1=-u-2Rx. +``` + +The last two graphs therefore give + +```text +v=-z-Gx, y'=y+x+Hv, x'=x, +G=R(I-T), H=(I+T)K. +``` + +For the backward word, use these physical graphs in order: + +```text +X -= 8 Q^2 A K u; u -= R Y/8; +run both full-mode cores; +u += R Q^2 A Y/8. +``` + +The first graph reads the old mode z, before the second graph changes it. +Their logical effects are x-=8 T K z and u=z-Ry/8. The raw backward map is + +```text +x1=x-(I+KR)y-8Ku, y1=y, u1=-u-Ry/4. +``` + +The output graph uses Q squared A Q inverse equals T. The result is + +```text +x'=x-y-8Hz, y'=y, v=-z-Gy/8. +``` + +These substitutions use only T squared equals I for the later feedback +statement. The local endpoint derivation does not need a scalar formula +for RK. It is valid when source, target and mode values are correlated. + +The literal graph expansions are as follows. Each R and K acts after the +displayed translation on a port, in the indicated replica. + +| Graph | Replica 0 | Replica 1 | +| --- | --- | --- | +| F input mode | u0 -= R X1 | u1 -= R L X0 | +| F output mode | u0 += R X0 | u1 += R X1 | +| F output target | Y0 += K u1 | Y1 += L K u0 | +| B input target | X0 -= 8 L K u1 | X1 -= 8 K u0 | +| B input mode | u0 -= R Y0/8 | u1 -= R Y1/8 | +| B output mode | u0 += R L Y1/8 | u1 += R Y0/8 | + +Translate each relevant source or target array, perform its ADD group, +then translate that same array again. Thus each orientation has 448 +literal translation maps and 2688 added scalar ADDs. It has no added +native child. The scalar subtotals are 433924 for the forward pair and +442884 for the backward pair. They exclude execution of the translation +maps, the retained native wrappers, and a global owner schedule. Each +pair retains native rank 11044 and restores 944 ordinary helper inputs, +subject to the pinned core contract. + +## Exact port routes and phases + +Use full-cover fields. At owner d, Q_p is C_(d p) tensored the required +number of times. An actual port route has the form + +```text +M_(g,a) f(d,z) = f(dg,z+d a), g p=p. +``` + +The owner-dependent translation by d p commutes with this route: the +source translation is d g p=d p, and address translations commute. +Since C_(d p) is a fixed linear combination of I and that translation, +the same statement holds for Q_p, at every tensor size, with no extra +phase. It follows for A and T. This argument includes the exact inherited +entry and exit translations a. It does not replace the cover route by +an address permutation at one fixed owner. + +The checker reconstructs all 1008 actual routes from the pinned retained +geometry and binds their labels and translations to the original complex +DATA-PHASES ledger. It checks each route's inverse and fixed port line. +It also checks the inherited positive line kernel on all 57344 spatial +columns, then checks its square, fourth power, and inverse. A global-phase +change and omission of the required L factor are rejected. + +For the routed maps + +```text +G_s=R D_s(I-T), H_t=(I+T)D_t^-1 K, +``` + +G_s H_t is zero for every pair of stages. The cancellation occurs before +R or K and does not require equal routed centre images. Any ordinary +bank operation which is identical in both replicas and commutes with T +can be inserted between these maps. The actual per-port scalar bank +shears have this property. A gate that mixes distinct ports needs its +own check and is not covered by this statement. + +## Verification boundary + +The independent checker imports no producer code. It checks the literal +boundary event order, coefficients and frame records, a free ordered +operator calculation for both endpoint maps, the exact line kernels, +the route covariance, and the stated component counts. It uses the +existing full-mode core as a pinned dependency. + +The earlier complementary-gap proof used a Walsh retarget and a scalar +replica normalization. The earlier original-complex phase-gap word had +the residual R(I-Q squared)K. This construction replaces that residual +with zero by a port-dependent monomial replica normalization in the +original frames. It does not prove that a final odd H or G read is free. +In particular, the old mode transport identities of the form Q H equals +H A inverse and G Q equals minus A inverse G used a common mode action A. +They do not follow for the present port-dependent A and are not used. + +To insert the graphs around an unchanged global core, let E be its +monomial input view from global fields to local input fields, and let O +be its output view from local output fields to global fields. The added +graphs are E inverse P E before that core and O S O inverse after it. +This keeps the original core views unchanged. It adds explicit view +maps, which require a separate count. It also requires the stated mode +views at their actual physical locations. The local (I,F) mode contract +alone does not supply a persistent nine-call mode path. + +The physical paired-owner schedule, promoted-role replacement, arbitrary +mode closure, recursive admission, precision, and complete supplier +invoice remain separate. No kappa improvement is claimed here. + +Research and verification: OpenAI Codex under the user's direction, with +substantial AI assistance. No independent human review is claimed. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md new file mode 100644 index 0000000000..2af643bf06 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md @@ -0,0 +1,47 @@ +# Layer phases in the spectator terminal product + +This addendum keeps the bytes of SPECTATOR-TERMINAL-PRODUCT.md fixed. +Its proof hash is +588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54. + +Suppose the complete endpoint for layer j is E_j=T_j in that note. +Let S_j be a monomial operator on the active coordinates of layer j, +tensored with identity on z and on every other layer. It must not have +a coefficient that depends on z. Then S_k commutes with T_j for k!=j. +With S_all=prod_j S_j, the exact identity is + +```text +(S_m T_m S_m^-1) ... (S_1 T_1 S_1^-1) + = S_all (T_m ... T_1) S_all^-1. +``` + +Thus the inverse is S_all M^-1 Q_all^-1 S_all^-1. It still contains +only one native C_D call after the stated gather. All the S factors +can be included in the monomial wrappers. They still have an execution +cost. This claim uses disjoint support, not only the fact that a map +fixes the address bit z: a z-dependent diagonal phase need not commute +with the z flip in T_j. + +The actual conversion in the retained layer proof has +S_j=i^(sum of the current selected bits). It has the required support. +The source identity is H0=b S C S, with b=(1-i)/2, in +`upstream/build/sections/05-layers.tex` at commit +`bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. If a native routine returns +E_j C_j, the converted routine returns + +```text +(S_j E_j S_j^-1) H0_j. +``` + +This places the code before the current outer twiddle. It does not +place the code after a complete Fourier round. The current DIF twiddle +depends on the branch that H0_j just produced and on unprocessed bits. +It is not supported only on layer j and cannot be included in the +commuting S_j factors above. The established current-twiddle limitation +therefore still applies. + +To use the one-C_D terminal, a construction must prove a complete-round +portwise endpoint after the twiddle, implement an exact typed encoded +twiddle, or return the raw H0_j operation. The affine spectator +realization and the terminal product identity do not prove any of +these three statements. No all-size improvement is claimed here. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json new file mode 100644 index 0000000000..145c2ad3af --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json @@ -0,0 +1,22 @@ +{ + "actual_ports": 112, + "checker_sha256": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "controller_proof_sha256": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "inherited_controller_witness_coefficient": 2912, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "layer_counts": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "nonzero_kernel_entries_checked": 28224, + "omitted_control_rejections": 672, + "proof_sha256": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "scope": "Exact terminal operator product and controls. The inherited controller witness is proof-bound, not replayed here. Whole-layer content, native layout, cost, owner admission and full supplier improvement remain open.", + "spectator_columns_checked": 1344, + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "wrong_odd_inverse_order_rejections": 672 +} diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md new file mode 100644 index 0000000000..82433d113b --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md @@ -0,0 +1,159 @@ +# One spectator bit and a whole-layer terminal product + +This note gives an exact terminal factorization. It is conditional on a +portwise endpoint for each complete layer. The retained paired controller +does not have that endpoint. Replacing two fields by two slices of one +existing address bit does not change that content fact. + +## Exact product + +Let z be one fixed address bit. Both z slices contain arbitrary data. +For a fixed port, let the operators Q_1,...,Q_m commute. Suppose + +```text +Q_j^2 = X_(v_j), Q_j^4 = I. +``` + +Here X_(v_j) translates active address coordinates and fixes z. Define +the affine pullback A_j and the involution T_j by + +```text +(A_j f)(x,z)=f(x+z v_j,z+1), +T_j=Q_j A_j=[[0,Q_j],[Q_j^-1,0]]. (1) +``` + +The matrix uses the order z=0,z=1. Thus A_j^2=X_(v_j), and A_j +commutes with Q_j. These statements do not require either slice to be +zero. A_j can be applied as a literal affine map on the same field. + +Let E=T_m ... T_1, with T_1 applied first. Put + +```text +epsilon_j=(-1)^(m-j), +U=prod_j Q_j^epsilon_j, +V=sum_j v_j, +V_minus=sum_(epsilon_j=-1) v_j, +S=[[0,I],[I,0]], D_V=diag(I,X_V). +``` + +All vector sums are binary. Direct multiplication of the two by two +matrices gives + +```text +E=diag(U,U^-1) S^m + = Q_all X_(V_minus) D_V S^m, +Q_all=prod_j Q_j. (2) +``` + +For the first equality, the upper entry acquires alternating exponents +when it passes each off-diagonal factor. For the second, use +Q_j^-1=Q_j X_(v_j), so U=Q_all X_(V_minus) and +U^-1=U X_V. There is no omitted scalar phase. + +The factor M=X_(V_minus) D_V S^m is one affine address map. All Q_j +commute with M. Its exact inverse is + +```text +M^-1=S^m D_V X_(V_minus), +E^-1=M^-1 Q_all^-1. (3) +``` + +The displayed order is material when m is odd: S D_V and D_V S differ +by X_V. An implementation can retain (3) without a reordering rule. + +## Native consequence and admission conditions + +In the actual original complex line, C_q=alpha I+beta X_q, with +alpha=(1+i)/2 and beta=(1-i)/2. A layer with f_j tensor columns has +Q_j=C_(q_j)^tensor(f_j). If all layer columns have disjoint coordinate +supports, their D=sum_j f_j line directions are orthonormal. A binary +gather P gives + +```text +Q_all=P^-1 C^tensor(D) P, +Q_all^-1=P^-1 [(-i)^D Z_all C^tensor(D) Z_all] P. (4) +``` + +Thus (3) needs one native C_D call, one gather and its inverse, two sign +passes, one Gaussian-unit scale, and one affine map. It needs no new +zero field. All other coordinates, including z, remain spectators of +the native call. The native call and each map must be priced. + +Equation (4) is an operator identity. It is not an admission of an +all-size child with D coordinates. In particular, a gather of all +completed outer offsets must satisfy the actual complete-row contract, +the chunk and guard conditions, and the volume and depth conditions. +The terminal cost is conditionally + +```text +S(V,D) + cost(P,P^-1,Z_all,Z_all,M^-1,unit scale). +``` + +S includes all child work, helper restoration and precision costs. No +argument here sets the chunk width to one or discards inactive ranges. +A proof that this cost is below the outer multiplication bound remains +separate from (2). + +The theorem also permits a known port permutation between complete +layers, provided it transports each Q_j and v_j covariantly and fixes z. +One follows each port through those permutations and applies (2) on +that path. Scalar bank maps on identical port types also commute with +the factors. A sum that mixes different port types, such as R or K, +does not satisfy this condition merely because the address supports of +two layers are disjoint. + +The coordinates in (1)--(4) are the actual endpoint coordinates. If an +interface instead gives P_past^-1 E P_past, that conjugation must be +kept in the terminal word and priced. A completed Fourier factor on z +is not an affine address change and is not silently removed here. + +## Why the unchanged paired controller is not an application + +Slicing one field at z defines an exact vector-space isomorphism to two +fields. A linear raw core that preserves z acts equally on the two +slices. Under this isomorphism, (1) is exactly the previously emitted +two-replica operator. All arbitrary input values in both slices remain. + +Consequently the retained nine-stage word still has the reviewed joint +map + +```text +V_modes=-U_modes-T_query D_data, +D_data'=D_data-L U_modes-L P T_query D_data. +``` + +It is not a product of independent T_j maps on the old fields. For a +specific witness, the reviewed regular-cover vector + +```text +h=(56I-R_1^*R_1) R_0^* e_k delta_identity +``` + +satisfies R_1 h=0, while the identity coefficient of R_0 h is 2912 e_k. +Use a constant active payload times the z-odd vector (1,-1), with all +initial mode values zero. The stage-zero mode query is nonzero, the +stage-one query is zero, and every later ordinary source coefficient +for this input is zero. Invertible mode-only transport cannot restore +the zero mode input. The same witness applies whether the two entries +are separate fields or z slices of one field. + +This does not exclude a changed controller, an extra data read, a mixed +data/mode terminal, or a different invariant input domain. It identifies +the required new equality: the complete admitted layer must produce the +portwise code in (1), or another code with a proved terminal factorization. +The affine spectator realization alone does not supply that equality. + +## Checks + +Run `python3 -I -O -B check_spectator_terminal_product.py` in this +directory. Expected output is `PASS_SPECTATOR_TERMINAL_PRODUCT`. +The checker uses all 112 actual line labels and exact Gaussian +fractions. It verifies (2)--(3) for one through six disjoint layers, +both spectator slices and every nonzero kernel entry. Translation +covariance then gives every active input column. It rejects an omitted +controlled translation and a wrong order for the odd product inverse. +It pins the paired controller proof used for the content witness. + +This is a terminal operator theorem and a scoped content check. It is +not a new supplier, a native whole-layer layout proof, or a complete +kappa improvement. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/check_spectator_terminal_product.py b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/check_spectator_terminal_product.py new file mode 100644 index 0000000000..a10c84d7df --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/coherent-port/check_spectator_terminal_product.py @@ -0,0 +1,148 @@ +#!/usr/bin/env python3 +"""Check the exact spectator terminal product on the actual port labels.""" + +from fractions import Fraction as F +from pathlib import Path +import hashlib +import json + + +HERE = Path(__file__).resolve().parent +INTERFACE = HERE.parent / "circuit-interface" / "INTERFACE.json" +INTERFACE_SHA = "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" +CONTROLLER = HERE.parent / "encoded-controller" / "ORIGINAL-PAIRED-CONTROLLER.md" +CONTROLLER_SHA = "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1" +ZERO, ONE = (F(0), F(0)), (F(1), F(0)) + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def mul(a, b): + return (a[0] * b[0] - a[1] * b[1], + a[0] * b[1] + a[1] * b[0]) + + +def line(state, v, inverse=False): + sign = -1 if inverse else 1 + coefficients = ((0, (F(1, 2), F(sign, 2))), + (v, (F(1, 2), F(-sign, 2)))) + out = {} + for (x, z), value in state.items(): + for shift, coefficient in coefficients: + key = (x ^ shift, z) + out[key] = add(out.get(key, ZERO), mul(value, coefficient)) + return {key: value for key, value in out.items() if value != ZERO} + + +def involution(state, v): + out = {} + for (x, z), value in state.items(): + part = line({(x, z ^ 1): value}, v, inverse=(z == 0)) + for key, coefficient in part.items(): + out[key] = add(out.get(key, ZERO), coefficient) + return {key: value for key, value in out.items() if value != ZERO} + + +def affine(state, total, negative, parity, inverse=False, + omit_control=False, wrong_inverse_order=False): + out = {} + for (x, z), value in state.items(): + if inverse and not wrong_inverse_order: + x ^= negative + if z and not omit_control: + x ^= total + z ^= parity + else: + z ^= parity + if z and not omit_control: + x ^= total + x ^= negative + out[(x, z)] = value + return out + + +def main(): + need(sha(INTERFACE) == INTERFACE_SHA, "Changed source interface") + need(sha(CONTROLLER) == CONTROLLER_SHA, "Changed controller proof") + source = json.loads(INTERFACE.read_bytes()) + ports = source["ports"] + need(len(ports) == 112 and len(set(ports)) == 112, + "Wrong actual port labels") + need(all(q.bit_count() % 2 for q in ports), "Even actual port label") + checked = entries = control_rejections = order_rejections = 0 + for q in ports: + for m in range(1, 7): + vectors = [q << (9 * j) for j in range(m)] + total = negative = 0 + for j, v in enumerate(vectors): + total ^= v + if (m - 1 - j) % 2: + negative ^= v + for z in (0, 1): + initial = {(0, z): ONE} + actual = initial + for v in vectors: + actual = involution(actual, v) + expected = affine(initial, total, negative, m % 2) + for v in vectors: + expected = line(expected, v) + need(actual == expected, "Whole-layer product mismatch") + inverse = actual + for v in vectors: + inverse = line(inverse, v, inverse=True) + inverse = affine(inverse, total, negative, m % 2, + inverse=True) + need(inverse == initial, "Ordered inverse mismatch") + omitted = affine(initial, total, negative, m % 2, + omit_control=True) + for v in vectors: + omitted = line(omitted, v) + if z ^ (m % 2): + need(omitted != actual, "Control omission did not reject") + control_rejections += 1 + if m % 2: + wrong = actual + for v in vectors: + wrong = line(wrong, v, inverse=True) + wrong = affine(wrong, total, negative, m % 2, + inverse=True, wrong_inverse_order=True) + need(wrong != initial, "Inverse order control did not reject") + order_rejections += 1 + checked += 1 + entries += len(actual) + need(56 * 56 - 4 * 56 == 2912, "Wrong retained-controller witness") + receipt = { + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "interface_sha256": sha(INTERFACE), + "controller_proof_sha256": sha(CONTROLLER), + "proof_sha256": sha(HERE / "SPECTATOR-TERMINAL-PRODUCT.md"), + "checker_sha256": sha(Path(__file__)), + "actual_ports": len(ports), + "layer_counts": list(range(1, 7)), + "spectator_columns_checked": checked, + "nonzero_kernel_entries_checked": entries, + "omitted_control_rejections": control_rejections, + "wrong_odd_inverse_order_rejections": order_rejections, + "inherited_controller_witness_coefficient": 2912, + "scope": "Exact terminal operator product and controls. The inherited controller witness is proof-bound, not replayed here. Whole-layer content, native layout, cost, owner admission and full supplier improvement remain open." + } + (HERE / "SPECTATOR-TERMINAL-PRODUCT.json").write_text( + json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(receipt["status"]) + print(json.dumps({"columns": checked, "kernel entries": entries}, + sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md new file mode 100644 index 0000000000..4e1805f6b0 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md @@ -0,0 +1,205 @@ +# The original complex paired controller + +The original complex paired local words have an exact nine-call joint +map. Their error injections do not change any later centre query. This +removes the centre feedback matrix, but it does not restore the arbitrary +mode inputs by itself. The retained source schedule also gives an exact +limit on mode reuse without another data read. + +This note uses the emitted local pair in +`../residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md`. Its +decompressed payload hash is recorded in the accompanying JSON file. +The old ordinary schedule and its source and response rows come from +`NILPOTENT-CONTROLLER.json`. The new proof does not use the mode-side +phase transport identities from the Walsh version of that note. + +## Local and global maps + +Let Q be the original port line operator, extended equally to the two +replicas. Set + +```text +L_line=Q^2, A=[[0,I],[L_line,0]], +T=QA=[[0,Q],[Q^-1,0]]. +``` + +A is a port-dependent monomial map. It is not a map on the centre +indices. We have `T^2=I`, `AQ=QA`, and `A^-1=L_line A`. With the actual +stage routes and one-use mode gauges, set + +```text +G_s=N_s^-1 R D_s(I-T), +H_s=(I+T)D_s^-1 K N_s. +``` + +The actual routes commute with T. Thus `G_s H_t=0` for every s,t. +The two local maps are + +```text +F_s: x'=x, v=-z-G_s x, y'=y+x+H_s v, +B_s: y'=y, v=-z-G_s y/8, x'=x-y-8H_s z. +``` + +All modes and data inputs are arbitrary. Each paired local call restores +its 944 other helper inputs. Global owner admission is a separate check. + +Let D contain the eight paired old data banks. Let U and V contain the +nine paired mode cohorts before and after the controller. Let P select +the five forward cohorts and Q_mode select the four backward cohorts. +For the exact source rows a_s and response columns b_s, put + +```text +L_s=b_s tensor H_s, +T_query,s=beta_s a_s tensor G_s, +beta_s=1 for F and 1/8 for B. +``` + +The factor 8 for a backward response is already in b_s. The complete +joint map, including the retained ordinary terminal, is + +```text +V=-U-T_query D, +D'=D-LU-LP T_query D, +T_query L=0. (1) +``` + +For each later query, every earlier data error has a factor `G_s H_t` +and vanishes. This proves the first line. Propagation of the target +errors through the ordinary bank word proves the second line. The +checker verifies all 17 arbitrary input blocks in the free operator +algebra, with no relation between distinct R D_s row spaces. + +The three output operations + +```text +D1=D'-LPV, +U=-V-T_query D1, +D=D1+LQ_mode U (2) +``` + +restore every input. There are 28 projected H blocks and 28 projected +G blocks. On a paired implementation their direct expansions have +100352 scalar terms with their explicit line and source-map factors, +and 144 mode negations. This is a finite algebraic expression. It does not price +the odd native line in any of those terms. + +## The actual physical endpoint + +Let W be Q on the four logical X banks and I on the four Y banks. The +raw old-data input is `xi=W D`. After the retained line-square +translations and signed exchanges, the physical output is + +```text +(F W D', F V). +``` + +Here F is the common complete native transform. Mode preparation and +completion are the stated one-use histories. Conjugation by F changes +their N_s maps by the known monomial adapters. + +There is a valid phase transport identity on the data side: + +```text +Q H_s=A^-1 H_s, G_s Q^-1=-G_s A. (3) +``` + +It follows from `T H_s=H_s`, `G_s T=-G_s`, and `AQ=QA`. It does not +move A through R, K or N_s. Define the data-bank monomial maps + +```text +B=diag(A^-1 on X, I on Y), +C=diag(-A on X, I on Y). +``` + +Then `W L=B L` and `T_query W^-1=T_query C`. After removal of the common +output F, the exact physical code on `(xi,U)` is + +```text +[[I-BLP T_query C, -BL], + [-T_query C, -I]]. (4) +``` + +Also `T_query C B L=0`, because CB is a bank sign and commutes with T. +Thus the same three-step decoder applies to `L_phys=BL` and +`T_phys=T_query C`. This records the physical endpoint without a false +centre action for A. The projected maps H and G still contain T. A +paired terminal that consists only of these even data maps has not +removed that access obligation. + +## A limit on cyclic mode reuse + +Keep the retained ordinary data word. Permit any finite collection of +mode cohorts. A local call can use any cohort after an invertible mode +change. Permit arbitrary invertible mode maps between calls and at the +terminal, including maps with cover and payload coefficients. Do not add +a new data-to-mode read. All local injections still have image in some +H_s, so every later G_t annihilates them. + +For the initial X0 bank, the exact ordinary source coefficients are + +```text +(a_0 X0, ..., a_8 X0)=(1,1,0,0,0,0,0,0,0). (5) +``` + +Every mode query inserted at stage s is followed by invertible mode +transport. Its inclusion into the full mode state is injective. Call +that inclusion C_s. Mode restoration on all X0 inputs would require + +```text +C_0 G_0 + (1/8) C_1 G_1=0 (6) +``` + +up to invertible signs and mode gauges. In particular, (6) requires +`ker G_1` to be a subset of `ker G_0`. + +That inclusion fails on the actual regular cover. Write +`R_s=R D_s`, with all 112 ports retained. Then +`R_s R_s^*=56I`. For any centre coordinate e_k, define the integer +cover vector + +```text +h=(56I-R_1^* R_1) R_0^* e_k delta_identity. +``` + +We have `R_1 h=0`. The 112 stage-1 port routes are distinct involutions. +Hence the identity coefficient in `R_0 R_1^* R_1 R_0^*` is + +```text +sum_p ||r_p||^2 r_p r_p^*=4 R R^*=224I. +``` + +It follows that `[R_0 h]_identity=(56^2-224)e_k=2912e_k`, which is +nonzero. There is no odd denominator in h. + +Make the native payload constant and use paired X0 input `(h,-h)`. +The original Q fixes a constant payload, so T is the replica swap on +this input. Therefore `G_1(h,-h)=0`, but +`G_0(h,-h)=2N_0^-1(R_0h,-R_0h)` is nonzero. All other data and initial +mode inputs can be zero. After F0, the mode state has a nonzero signal. +B1 reads zero, and every later ordinary source is zero for this input. +The signal then passes only through invertible mode maps. It cannot +become zero at the output. + +This excludes restoration by mode reuse and mode-only routing for the +stated ordinary source word. It does not exclude a changed data word, +another ordinary-to-mode read, a local injection outside the common +plus image, a mixed data/mode terminal, or a restricted zero-mode +supplier with a different contract. The argument also does not give a +native-child lower bound for a repair. + +## Verification and remaining work + +Run `python3 -I -O -B check_original_paired_controller.py` from this +directory. The expected status is +`PASS_ORIGINAL_PAIRED_GLOBAL_MAP_AND_REUSE_LIMIT`. + +The checker pins the emitted paired payload, verifies (1)--(2) with the +existing free algebra, checks the physical identities (3), reconstructs +all 112 actual routes, and checks the integer witness coefficient. It +also checks (5) from the full schedule. This is a content and route +check. It does not admit the paired owner schedule or implement the +remaining projected boundary queries. + +No complete supplier, kappa improvement, or unrestricted controller +obstruction is claimed. The result identifies a specific missing read: +the part of the first-stage query that the next-stage query cannot see. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md new file mode 100644 index 0000000000..6c500b5e1d --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md @@ -0,0 +1,178 @@ +# A paired involution for the original complex phase + +The original complex line phases admit a two-replica involution. Its +extra maps are translations and cross-replica ADDs. It does not require +the Walsh retarget. The emitted local word retains both original cores +and restores all 944 ordinary helper inputs. It has 16 arbitrary mode +inputs, whose new values are part of the stated output contract. + +This result removes a local phase-normalization requirement from the +complementary-gap controller. It does not give free access to the final +odd-phase queries or injections. The paired owner schedule, mode jobs, +complete decoder, and supplier invoice are separate requirements. No +complete kappa improvement is claimed. + +## Exact phase and operator order + +Let `Q=diag_p(C_p^tensor(lambda))`. On one port, the original native line +has `C_p^2=X_p` exactly. Thus `L=Q^2` is a list of translations, and +`L^2=I`. Pair two replicas with the same stage and address chart. Put + + A = [[0,I],[L,0]], + T = Q A = [[0,Q],[Q^-1,0]]. (1) + +Here Q denotes the same diagonal port operator on both replicas. A acts +on port arrays, not on the eight centre indices. It is a monomial map. +Since A commutes with Q and `A^2=L`, we have `T^2=I`. Also `L A=A^-1`. +None of these statements moves A through R or K. + +Use `K=R^T/4`, `RR^T=56I`, with R and K extended by the replica identity. +The pinned raw core has these local physical frames: + +| Role | Input | Output | +| --- | --- | --- | +| X_p | C_p | F | +| Y_p | I | F C_p^-1 | +| mode u_k | I | F | + +The common F commutes with each Q_p and each translation L_p. After its +common output F is removed, the exact raw content maps are + + F_core: y'=y+(I-KR)x-Ku, u'=-u-2Rx, x'=x; + B_core: x'=x-(I+KR)y-8Ku, u'=-u-Ry/4, y'=y. (2) + +The signs in the backward core are required. + +## The forward physical word + +Start with arbitrary mode content z. Apply the following physical +operations before both cores: + + u -= R A X_physical. + +Because the input X frame is Q, the core mode input is `u=z-RTx`. +After both cores, first apply `u += R X_physical`. The new logical mode +and target then satisfy + + v=-z-R(I-T)x, + y_1=y+x+Kv. + +Next apply `Y_physical += A K U_physical`. The target frame converts this +term to `Q A K v=T K v`. Hence the complete map is + + x'=x, + v=-z-Gx, + y'=y+x+Hv, + G=R(I-T), H=(I+T)K. (3) + +The emitter implements the first graph as `u0-=R X1` and +`u1-=R L X0`. It implements the last graph as `Y0+=K v1` and +`Y1+=L K v0`. The translated source or target is translated once before +its ADDs and once after them. This restores its physical address view. +There is no common action of A on the eight mode fields. + +## The backward physical word + +Before both backward cores, apply, in this order, + + X_physical -= 8 L A K z, + u = z-RY_physical/8. + +The first line changes logical x by `-8 T K z`. Substitution in (2) +gives `x'=x-y-8(I+T)Kz` and `u'=-z-Ry/8`. After both cores, apply + + u += R L A Y_physical/8. + +Since `L A Q^-1=T`, this adds `RTy/8`. Therefore + + x'=x-y-8Hz, + y'=y, + v=-z-Gy/8. (4) + +The emitter uses `X0-=8L K z1`, `X1-=8K z0`, and the two common-frame +mode preloads. Its final graph is `u0+=R L Y1/8`, `u1+=R Y0/8`. +These are pointwise physical ADDs and literal translations. + +## Changing charts and one-shot mode gauges + +At cover class g, the port phase is `C_(g p)^tensor(lambda)`. Each actual +stage route fixes p. Orthogonal address covariance therefore implies +that every D_s commutes with Q, L, A, and T. The pair must use the same +cover class and stage view in this statement. + +Let N_s be the one-shot mode gauge from +`history-encoding/ONE-SHOT-MODE-PROOF.md`. Its input action and its full-F +conjugate are monomial. Applying the phase-gap graphs inside that active +core, before the mode output adapter, gives the routed maps + + G_s=N_s^-1 R D_s(I-T), + H_t=(I+T)D_t^-1 K N_t. + +Their cross-products vanish for every s,t: + + G_s H_t + =N_s^-1 R D_s (I-T)(I+T) D_t^-1 K N_t=0. (5) + +This is a typed composition consequence of the local endpoint table and +the reviewed one-shot adapters. It does not replace a global native +replay of those adapters and graphs. It makes no equal-chart assumption +and does not identify the distinct centre row spaces. + +The frozen `encoded-controller/NILPOTENT-CONTROLLER.md` now applies to +(3)--(5) at the operator level. Its output decoder restores all arbitrary +data and mode inputs when its H and G boundary operations are available. +The two-replica change has not made those boundary operations monomial. + +## Local invoice and checks + +The two cores are the unchanged payload with decompressed SHA256 +`f271842a741584389e166e700e262f161b0dd570ce8c7a540f2717e90ead5205`. +The generated paired payload has decompressed SHA256 +`42aeb0902d8b2330f9050718c6d949993111a9fd898acad599ec867bb63a2b20`. + +| Item per pair | Forward | Backward | +| --- | ---: | ---: | +| Extra physical ADDs | 2,688 | 2,688 | +| Extra translation maps | 448 | 448 | +| Extra real scalar primitives | 25,088 | 34,048 | +| Complete explicit scalar primitives | 433,924 | 442,884 | +| Retained native events | 10,112 | 10,112 | +| Paid native rank | 11,044 | 11,044 | +| Extra native children | 0 | 0 | + +The scalar invoice excludes address-map implementation, owner access, +mode preparation and completion, old-owner backfills, and the global +decoder. It is not a complete real-primitive supplier invoice. + +The producer checks both raw core maps on all 704 input columns, then +checks both paired maps on all 1,408 arbitrary input columns. It checks +all 944 ordinary helper outputs. Its free-line algebra uses only +`C_p^4=I`; it does not commute a port line through R or K. Omitting the +input graphs or the translations fails the map check. The native identity +`C_p^2=X_p` gives the all-tensor-depth interpretation. + +Run from the workspace: + + python3 -I -B work/centre-encoding-campaign-20261014/lanes/residual-syndrome/physical-algebra/emit_original_paired_gap.py + +Expected first output: + + PASS_EXACT_ORIGINAL_COMPLEX_PAIRED_PHASE_GAP + +Both pregraphs must precede both cores, and both postgraphs must follow +both cores. A serial execution of the cores is valid only if its borrowed +owners do not change the other replica's protected data or modes. The +selected asynchronous schedule is not admitted by this local check. + +## Credit and scope + +The history-encoding lane supplied the raw full-mode core and the +original physical phase-gap graphs. The coherent-port lane supplied the +complementary-gap and two-replica Walsh argument. The encoded-controller +lane supplied the all-stage nilpotent decoder. The coordinating agent +supplied (1), which uses the original complex translations. This lane +emitted the ordered physical graphs and checked their complete local +maps. Independent review is recorded separately. + +This work used substantial OpenAI Codex assistance under the user's +direction. It does not change the selected frontier. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json new file mode 100644 index 0000000000..aa1d2a0356 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json @@ -0,0 +1,12 @@ +{ + "free_group_cases": 64, + "input_sha256": { + "SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "SPECTATOR-TERMINAL-PRODUCT.md": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "check_spectator_terminal_product.py": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0" + }, + "new_corollary_condition": "A layer conjugation must act as identity on z, or explicitly commute with other T factors. Fixing the z address alone is not enough.", + "review": "The general alternating-exponent proof was checked directly. Finite checks use independent formal fourth-root generators, not the producer kernel code.", + "scope": "Equations (1)-(4) and their ordering; no native admission or full-layer endpoint review.", + "status": "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER" +} diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/review_terminal_product.py b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/review_terminal_product.py new file mode 100644 index 0000000000..cd4b0d4117 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/frozen/lanes/schur-selection/spectator/review_terminal_product.py @@ -0,0 +1,56 @@ +"""Check the terminal order in the free commuting fourth-root group.""" + +from hashlib import sha256 +from pathlib import Path +import json + + +HERE = Path(__file__).resolve().parent +OTHER = HERE.parents[1] / "coherent-port" +PINS = { + "SPECTATOR-TERMINAL-PRODUCT.md":"588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "check_spectator_terminal_product.py":"43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "SPECTATOR-TERMINAL-PRODUCT.json":"3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", +} + + +def need(value, message): + if not value: + raise ValueError(message) + + +def main(): + for name,pin in PINS.items(): + need(sha256((OTHER/name).read_bytes()).hexdigest() == pin,"Frozen terminal input: "+name) + count = 0 + for m in range(1,33): + epsilon = [1 if (m-j) % 2 == 0 else -1 for j in range(1,m+1)] + for initial_z in range(2): + exponents = [0]*m + z = initial_z + for j in range(m): + exponents[j] = (1 if z else -1) % 4 + z ^= 1 + diagonal = [(sign if not z else -sign) % 4 for sign in epsilon] + affine = [(1+2*int(sign == -1)+2*z) % 4 for sign in epsilon] + need(exponents == diagonal == affine,"Product in the free fourth-root group") + # Apply Q_all^-1, then X_Vminus, D_V, and S^m. + decoded = [(value-1+2*int(sign == -1)+2*z) % 4 + for value,sign in zip(exponents,epsilon)] + need(decoded == [0]*m and z ^ (m % 2) == initial_z,"Exact inverse order") + if m % 2: + wrong = [(value-1+2*int(sign == -1)+2*(z^1)) % 4 + for value,sign in zip(exponents,epsilon)] + need(wrong != [0]*m,"Wrong inverse order negative control") + count += 1 + result = {"status":"PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER", + "input_sha256":PINS,"free_group_cases":count, + "review":"The general alternating-exponent proof was checked directly. Finite checks use independent formal fourth-root generators, not the producer kernel code.", + "scope":"Equations (1)-(4) and their ordering; no native admission or full-layer endpoint review.", + "new_corollary_condition":"A layer conjugation must act as identity on z, or explicitly commute with other T factors. Fixing the z address alone is not enough."} + (HERE/"TERMINAL-PRODUCT-REVIEW.json").write_text(json.dumps(result,indent=2,sort_keys=True)+"\n") + print(result["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/replay.py b/research/completed-prefix-outer/annexes/spectator-terminal/replay.py new file mode 100644 index 0000000000..684c4c24a1 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/replay.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 +"""Run the two frozen spectator terminal checks in private source copies.""" + +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import time + + +HERE = Path(__file__).resolve().parent +JOBS = [ + ("kernel", "lanes/coherent-port/check_spectator_terminal_product.py", + "lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json", + "PASS_SPECTATOR_TERMINAL_PRODUCT"), + ("order", "lanes/schur-selection/spectator/review_terminal_product.py", + "lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json", + "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER"), +] + + +def need(value, reason): + if not value: + raise ValueError(reason) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def verify_sources(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + for item in manifest["files"]: + raw = (HERE / item["path"]).read_bytes() + need(len(raw) == item["bytes"] and digest(raw) == item["sha256"], + "Frozen source differs: " + item["path"]) + return manifest + + +def run_one(job, optimized, output): + label, script, receipt, status = job + mode = "optimized" if optimized else "normal" + destination = output / mode / label + destination.mkdir(parents=True) + expected = (HERE / "frozen" / receipt).read_bytes() + with tempfile.TemporaryDirectory(prefix="spectator-", dir=output) as temporary: + workspace = Path(temporary) / "source" + shutil.copytree(HERE / "frozen", workspace) + result_path = workspace / receipt + result_path.unlink() + command = [sys.executable, "-I", "-B"] + (["-O"] if optimized else []) + command.append(str(workspace / script)) + environment = dict(os.environ) + environment.update({name: "1" for name in [ + "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", + "VECLIB_MAXIMUM_THREADS", "NUMEXPR_NUM_THREADS"]}) + started = time.monotonic() + result = subprocess.run(command, cwd=workspace, env=environment, + capture_output=True, text=True, check=False) + (destination / "stdout.txt").write_text(result.stdout + result.stderr) + need(result.returncode == 0, label + " failed; see " + str(destination / "stdout.txt")) + need(result_path.is_file(), label + " did not produce a new receipt") + raw = result_path.read_bytes() + need(raw == expected, label + " receipt differs from the frozen receipt") + need(json.loads(raw)["status"] == status, label + " status differs") + (destination / result_path.name).write_bytes(raw) + return {"id": label, "mode": mode, "status": status, + "seconds": round(time.monotonic() - started, 3), + "fresh_receipt_created": True, + "frozen_receipt_byte_equal": True, "receipt_sha256": digest(raw)} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", required=True, type=Path) + args = parser.parse_args() + output = args.out.resolve() + need(not output.is_relative_to(HERE), "Output must be outside the annex") + need(not output.exists(), "Output directory must not exist") + need(shutil.disk_usage(output.parent).free >= 3 * 1024 ** 3, "Keep at least 3 GiB free") + sources = verify_sources() + output.mkdir() + results = [] + for optimized in (False, True): + for job in JOBS: + print(("optimized" if optimized else "normal") + " " + job[0], flush=True) + results.append(run_one(job, optimized, output)) + normal = {item["id"]: item["receipt_sha256"] for item in results if item["mode"] == "normal"} + need(all(item["receipt_sha256"] == normal[item["id"]] for item in results), "Mode receipts differ") + verify_sources() + receipt = { + "status": "PASS_SPECTATOR_TERMINAL_ANNEX", + "source_files": len(sources["files"]), + "source_manifest_sha256": digest((HERE / "SOURCES.json").read_bytes()), + "runner_sha256": digest(Path(__file__).read_bytes()), + "python": sys.version, + "jobs": results, + "normal_optimized_equal": True, + "frozen_sources_unchanged": True, + "scope": "Exact terminal kernels and independent formal product order. Complete portwise layer endpoints, native gather admission, the controller witness, full costs, precision, and recursive admission are not established by this replay." + } + (output / "REPLAY.json").write_text(json.dumps(receipt, indent=2) + "\n") + print(receipt["status"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/LICENSE b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/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/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/NOTICE b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/NOTICE.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/NOTICE.md new file mode 100644 index 0000000000..30d0c8cd3c --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/NOTICE.md @@ -0,0 +1,24 @@ +# Gauge44 attribution and scope + +New contributions by icekylinx, with OpenAI GPT-6 Astra assistance. +Local review and packaging used OpenAI Codex. Apache-2.0 applies; +the license is included. The full original PR635 notice is preserved as +UPSTREAM-NOTICE.md and construction/UPSTREAM-NOTICE.md. + +The new contribution is the changed source-branch gauge and retired-row +completion, source-carried coordinate totals, exact 44-cold-end realization, +and explicit all72 whole-family assignment using concave capacity matching +with integer majorization certificates. The center-carrier generalization +retains the exact ordered common frames and complete native local contract. +Independent local, price, interface and owner fixed-point checks are included. + +The construction retains the credited PR635 K-triangle and porting machinery, +earlier joint-prefix/HPE/frame ancestry and icekylinx's prior factory work. +#645 used the same cited PR543 bit supplier as PR635. This package (research/gauge44-leaver8) cites the merged PR589 bit supplier instead, with a derived rank-mass deficit (PROOF-NOTE-BIT.md); #645's retained PR543-based evidence is historical. It builds #645's word without K-triangles (PartialK) and stacks earlier community jp8 layers on it (G44Stack), adds the p6n ends (NoTriReopen), entrance promotions (BlockInvert) a read-set exchange (BRoute), chafreaky's #741 frames, JointXF's joint exchange, NewBArch's triangle-hybrid B rewrite and LeaverSAT's eight k8 leaver cells (with LeaverSAT2's frame re-optimisation); see README. All-size, realization, +hosting, precision/tape, analytic-transfer and bit H1-H5 assumptions remain +conditional. No upstream license, credit, source pin or AI disclosure is +replaced by this notice. + +PR641 and PR642 were checked as concurrent reported frontier comparisons. +Their endpoints and owner maps are not included here. See CONSTRUCTION.md, +hosting/PROOF.md, independent/ and README.md for the exact contribution scope. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..ebc24a0168 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and scope + +Four verified provider types are offered to every call: PR571's prefix word with twelve multi-cut cold kernels (PR568's unchanged constructor), the same word with forty width-five entrance promotions (PR569's unchanged frame constructor) before those kernels, PR575's plain joint-prefix provider, and PR568's eight-cold provider. A window MILP with an exact per-pattern model chooses the dispatch and a literal owner map. PR583's six source-bound kernel frame coalescences (its unchanged constructor and negative controls) are applied to every PR571-prefix provider word (ck and atm3), followed by two further coalescences that each first move one addition past two commuting additions (package code/build_gate_moves.py, extending PR583's constructor); a final hyperplane_end step (package code/build_hpe.py) then runs 46 single-gate cleanups h -= p right after part B at the dim-8 join U of their registers, so 46 width-8 entering helpers per call end at U with width 7; each such gate commutes with every earlier cleanup gate on its registers (for 8 of them the partner's one earlier gate x -= p only reads p), and the reordered program is replayed exactly. A window MILP (exact windows, RINS around an LP vertex) gives the dispatch ck 45 / atm3 21 / jp8 6 and the literal owner map. + +Pinned external sources (unchanged; `verify.py` checks their manifests and every file it uses): +- PR568 (`research/complex-multicold`, commit `71c99ac935a33bb7b59a1b4a7af8725a939b0b90`). +- PR571 (`research/structural-gain`, commit `b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3`). +- PR569 (`research/larger-gain`, commit `897213a855b7fb8a1b8b0e552a2f5c42e6c1b326`). +- PR575 (`research/complex-joint-prefix`, commit `eac6f7e378ab622dac50a2fd4b7ef6eab014de44`). +- PR583 (`research/kernel-frame-coalescing`, commit `89be768f0157f5a3d8e4db69cf1748768605eac9`). + +Provider construction is described as typed steps in `data/SPEC.json` (`build`); `verify.py` runs only allowlisted step types with their paired omission audits and checks every input and output content hash. `code/` holds the spec-driven global admission scripts adapted from PR571's `frontier-composition/global-code/` (OpenAI Codex assisted, Apache-2.0): every expected value is read from `data/SPEC.json` and compared only after independent recomputation. `code/generated_identity.py` and `code/generated_identity_controls.py`, and the decompressed-content artifact identities in the bind, audit, invoice, assembly and phase-timing scripts, are taken unchanged from PR586 by chafreaky (`research/promoted-kernel-coalescing`, commit `4846fee5b06af770e9b3a10c36200f673d656725`, OpenAI Codex assisted, Apache-2.0), including its proof-content and reference/metadata mutation controls; the normalization of descriptive width metadata after frame changes follows the same PR. + +In PR601, the owner map was nominated by a HiGHS window MILP (adapted from PR569's `global/nominate_width7.py`) with lazy cross-time Hall cuts; this package's re-solved map is described below. Neither is an admission dependency. + +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. (The PR601 package this one starts from states: "Prepared by Claude Code (Anthropic) research agents.") Apache-2.0 applies; LICENSE is included. All notices, licenses, source pins and AI disclosures of the pinned sources and their ancestry are retained in those packages and are not replaced by this notice. All inherited conditional assumptions remain conditional. + +**This package (complex-571-cold14, DreamingOfClouds).** It starts from PR601 (jeremykothe2, `research/complex-571-hpem46`, commit `529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550`). Everything above is kept unchanged except the following: +- every provider chain (ck, atm3, jp8) gains the typed step `cold_end` (`code/build_cold_end.py`, `code/cold_end_controls.py`; recipes `data/recipes/*-cold_end.json.gz`); +- the generalised native chain and the global admission scripts accept cold helpers that end below FULL (with `0:U` wrappers), a refactored exact cleanup, and check the wrapper order; +- `data/PLAN.json` / `data/OWNERS.json.gz` (dispatch and literal owner map) come from a relocate/swap/ejection-chain/provider-flip annealing search started from PR601's map, refined by an exact pattern-restricted owner model (CP-SAT) with a literal edge-colouring expansion (not an admission dependency); +- `data/SPEC.json` holds the expected values, recorded by a discovery run and then checked by a strict run. + +The cold-end construction (a row-plus-column cone condition for low-frame ends, a rank-0 dirt-spread premix and multi-gate lower-frame cleanup) builds on PR591 / PR592 / PR593 / PR601 (jeremykothe2) and our PR599 (Lean: multi-gate and cold hyperplane-end tails). DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Build on this at your own risk. + +**This package (complex-571-cold14-b3, jeremykothe2).** It is PR604's `complex-571-cold14` (DreamingOfClouds) with ColdBeyond's second cold end per block (two new `cold_end` A-gate primitives, `PROOF-NOTE.md`), ColdSupply's E1 entering pair and reviewed controls, a free dispatch (jp8 ×60, atm3 ×12) and a literal owner map from an exact per-time-Hall window MIP. All other construction, code, controls and proofs are PR604's and earlier contributors', unchanged. + +**This package (complex-571-cold14-k492).** It is complex-571-cold14-b3 with these changes: +- **K-triangle base words.** The leaver-read K-triangle skeleton atom and its read schedule (`data/TRI-SCHEDULE.json`) are by AtomScout, a Claude Code research agent. `code/construct_k_triangle.py` is PR531's `code/construct_504.py` (icekylinx, OpenAI Codex / GPT assisted, Apache-2.0; pinned source `direct_delivery`) extended with that atom. +- **Ported chains.** The PR604/B3 chains are ported stage by stage onto the K-triangle words by `code/build_port_stage.py` (Port480, a Claude Code research agent). `code/build_frame_regroup.py` extends PR583's `build_frames.py` (chafreaky). +- **Helper count R.** The generalisation of the global scripts to the provider helper count R is by GlobalR (a Claude Code research agent), with AtomReviewer's fixes (PROOF-NOTE-R.md). +- **Owner map.** The owner map, the cold_end recipes on the K-triangle words and the package assembly are by Stack492, Port480 and ColdBeyond (Claude Code research agents). + +Build on this at your own risk. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md new file mode 100644 index 0000000000..16b0507070 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md @@ -0,0 +1,9 @@ +# Construction delta notice + +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. + +`construct_gauge_xcentre.py` modifies PR635's credited `construct_k_triangle.py`, which in turn extends icekylinx's PR531/PR514/PR425 factory lineage. Its original source comments are retained. The K-triangle schedule and the upstream porting, JP8 frame, kernel and HPE procedures are reused from the pinned source checkouts and are not new contributions of this delta. + +The new source-copy exchanges, complementary factory basis, carrier assignment, exact cold44 constructor and compact reproduction driver are described in `../CONSTRUCTION.md`. + +`UPSTREAM-NOTICE.md` is the complete unmodified notice from the pinned PR635 package. `LICENSE` is that package's Apache-2.0 license. All further notices and source credits of the referenced upstream packages remain applicable and are retained in the source checkouts rather than vendored again here. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..ebc24a0168 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and scope + +Four verified provider types are offered to every call: PR571's prefix word with twelve multi-cut cold kernels (PR568's unchanged constructor), the same word with forty width-five entrance promotions (PR569's unchanged frame constructor) before those kernels, PR575's plain joint-prefix provider, and PR568's eight-cold provider. A window MILP with an exact per-pattern model chooses the dispatch and a literal owner map. PR583's six source-bound kernel frame coalescences (its unchanged constructor and negative controls) are applied to every PR571-prefix provider word (ck and atm3), followed by two further coalescences that each first move one addition past two commuting additions (package code/build_gate_moves.py, extending PR583's constructor); a final hyperplane_end step (package code/build_hpe.py) then runs 46 single-gate cleanups h -= p right after part B at the dim-8 join U of their registers, so 46 width-8 entering helpers per call end at U with width 7; each such gate commutes with every earlier cleanup gate on its registers (for 8 of them the partner's one earlier gate x -= p only reads p), and the reordered program is replayed exactly. A window MILP (exact windows, RINS around an LP vertex) gives the dispatch ck 45 / atm3 21 / jp8 6 and the literal owner map. + +Pinned external sources (unchanged; `verify.py` checks their manifests and every file it uses): +- PR568 (`research/complex-multicold`, commit `71c99ac935a33bb7b59a1b4a7af8725a939b0b90`). +- PR571 (`research/structural-gain`, commit `b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3`). +- PR569 (`research/larger-gain`, commit `897213a855b7fb8a1b8b0e552a2f5c42e6c1b326`). +- PR575 (`research/complex-joint-prefix`, commit `eac6f7e378ab622dac50a2fd4b7ef6eab014de44`). +- PR583 (`research/kernel-frame-coalescing`, commit `89be768f0157f5a3d8e4db69cf1748768605eac9`). + +Provider construction is described as typed steps in `data/SPEC.json` (`build`); `verify.py` runs only allowlisted step types with their paired omission audits and checks every input and output content hash. `code/` holds the spec-driven global admission scripts adapted from PR571's `frontier-composition/global-code/` (OpenAI Codex assisted, Apache-2.0): every expected value is read from `data/SPEC.json` and compared only after independent recomputation. `code/generated_identity.py` and `code/generated_identity_controls.py`, and the decompressed-content artifact identities in the bind, audit, invoice, assembly and phase-timing scripts, are taken unchanged from PR586 by chafreaky (`research/promoted-kernel-coalescing`, commit `4846fee5b06af770e9b3a10c36200f673d656725`, OpenAI Codex assisted, Apache-2.0), including its proof-content and reference/metadata mutation controls; the normalization of descriptive width metadata after frame changes follows the same PR. + +In PR601, the owner map was nominated by a HiGHS window MILP (adapted from PR569's `global/nominate_width7.py`) with lazy cross-time Hall cuts; this package's re-solved map is described below. Neither is an admission dependency. + +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. (The PR601 package this one starts from states: "Prepared by Claude Code (Anthropic) research agents.") Apache-2.0 applies; LICENSE is included. All notices, licenses, source pins and AI disclosures of the pinned sources and their ancestry are retained in those packages and are not replaced by this notice. All inherited conditional assumptions remain conditional. + +**This package (complex-571-cold14, DreamingOfClouds).** It starts from PR601 (jeremykothe2, `research/complex-571-hpem46`, commit `529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550`). Everything above is kept unchanged except the following: +- every provider chain (ck, atm3, jp8) gains the typed step `cold_end` (`code/build_cold_end.py`, `code/cold_end_controls.py`; recipes `data/recipes/*-cold_end.json.gz`); +- the generalised native chain and the global admission scripts accept cold helpers that end below FULL (with `0:U` wrappers), a refactored exact cleanup, and check the wrapper order; +- `data/PLAN.json` / `data/OWNERS.json.gz` (dispatch and literal owner map) come from a relocate/swap/ejection-chain/provider-flip annealing search started from PR601's map, refined by an exact pattern-restricted owner model (CP-SAT) with a literal edge-colouring expansion (not an admission dependency); +- `data/SPEC.json` holds the expected values, recorded by a discovery run and then checked by a strict run. + +The cold-end construction (a row-plus-column cone condition for low-frame ends, a rank-0 dirt-spread premix and multi-gate lower-frame cleanup) builds on PR591 / PR592 / PR593 / PR601 (jeremykothe2) and our PR599 (Lean: multi-gate and cold hyperplane-end tails). DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Build on this at your own risk. + +**This package (complex-571-cold14-b3, jeremykothe2).** It is PR604's `complex-571-cold14` (DreamingOfClouds) with ColdBeyond's second cold end per block (two new `cold_end` A-gate primitives, `PROOF-NOTE.md`), ColdSupply's E1 entering pair and reviewed controls, a free dispatch (jp8 ×60, atm3 ×12) and a literal owner map from an exact per-time-Hall window MIP. All other construction, code, controls and proofs are PR604's and earlier contributors', unchanged. + +**This package (complex-571-cold14-k492).** It is complex-571-cold14-b3 with these changes: +- **K-triangle base words.** The leaver-read K-triangle skeleton atom and its read schedule (`data/TRI-SCHEDULE.json`) are by AtomScout, a Claude Code research agent. `code/construct_k_triangle.py` is PR531's `code/construct_504.py` (icekylinx, OpenAI Codex / GPT assisted, Apache-2.0; pinned source `direct_delivery`) extended with that atom. +- **Ported chains.** The PR604/B3 chains are ported stage by stage onto the K-triangle words by `code/build_port_stage.py` (Port480, a Claude Code research agent). `code/build_frame_regroup.py` extends PR583's `build_frames.py` (chafreaky). +- **Helper count R.** The generalisation of the global scripts to the provider helper count R is by GlobalR (a Claude Code research agent), with AtomReviewer's fixes (PROOF-NOTE-R.md). +- **Owner map.** The owner map, the cold_end recipes on the K-triangle words and the package assembly are by Stack492, Port480 and ColdBeyond (Claude Code research agents). + +Build on this at your own risk. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md new file mode 100644 index 0000000000..403f4afffb --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +Apache-2.0. New construction and integration: Hao Yan (@FanPUYen), 2026. +Prepared with substantial OpenAI Codex assistance, including separately tasked +AI agents for owner construction, independent mathematical/code checking and +native verification. These are not claims of independent human peer review. + +The exact local supplier is Jeremy Kothe's accepted PR799 X4 word, layered on +Chafik Boukhalfa's PR741 frame changes and PR685 owner construction. Chafik's +PR795 fixed-inventory optimality result motivated changing the replica count. +The original owner bytes, scalar program, local frame and width inventory, +native phase and wrapper implementations retain their existing authorship. + +Credit icekylinx for the source gauge and supplier/admission pipeline; +DreamingOfClouds for the PR589 bit transport and inherited cold-end work; +eumemic for the PR555 bit supplier and earlier supplier work; Rohan Arun for +the native exact-complex recurrence correction; Jeremy Diviney, jaymosley07, +and the other retained owner/allocation contributors; and the complete +PR514/PR484/PR507/PR558 controller, physical hosting and verification lineage. +This list is cumulative credit, not approval of every claim in those PRs. + +All original notices and licenses remain in the referenced source packages: + +- `research/gauge44-frames-x/{NOTICE,UPSTREAM-NOTICE}.md` +- `research/complex-sw4-frame8/PROVENANCE.md` +- `research/e8-bit-p111-tuned/tune/README.md` +- the repository `CONTRIBUTORS.md` and source-package licenses. + +The verifier copies pinned global source files into an external replay +directory and applies an explicit checked edit list. Original attribution +comments are preserved in those generated derivatives. No original source +file or historical certificate is rewritten. + +The optional ancestry-reuse coverage guard addresses the omission issue +identified by Lucas (@ljste) in PR838 and the related PR847 integration by +Chinmay (@chinmayarvind23). Its fixed inventories were read from the accepted +PR741 source; no pending implementation is imported. Charles Bethin's +concurrent PR850 strengthens the fixed-inventory owner-profile theorem and +was checked for overlap before publication; that inventory is changed here. diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/LICENSE b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/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/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/README.md b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/README.md new file mode 100644 index 0000000000..c8cb3c3857 --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/README.md @@ -0,0 +1,17 @@ +# [Integer multiplication below n log n](paper.pdf) + +**Author:** OpenAI + +**Date:** September 23, 2026 + +## Citation + +```bibtex +@misc{OAI:Integer-multiplication-below-n-log-n-September-23-2026, + author = {{OpenAI}}, + title = {{Integer multiplication below $n\log n$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Integer-multiplication-below-n-log-n-September-23-2026/paper.pdf}{OAI:Integer-multiplication-below-n-log-n-September-23-2026}}, + year = {2026} +} +``` diff --git a/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/build/sections/05-layers.tex b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/build/sections/05-layers.tex new file mode 100644 index 0000000000..5ce8b3c83c --- /dev/null +++ b/research/completed-prefix-outer/annexes/spectator-terminal/sources/upstream/upstream/build/sections/05-layers.tex @@ -0,0 +1,996 @@ +\section{Fast simultaneous synthetic butterfly layers} +\label{sec:fast-butterfly-layers} + +We now apply the complex network to a common butterfly layer on several +axes. The array has complete address set +\[ + [P]\times[2^K]^D\times[S],\qquad 1\le D\le d, +\] +with $P,S\ge1$, in lexicographic order. Its $D$ consecutive $K$-bit +chunks each select the bit at one common offset $0\le\rho0,\quad 0<\epsilon<1. +\] +The exponents and comparison constants are fixed, and we impose their +further restrictions in Proposition~\ref{prop:simultaneous-layer}. +Two consequences explain the layout. The polynomial length $r$ grows +faster than every fixed power of $p$, so a scan of a record pays for +polynomial work on its address. Also $K/\log p\to\infty$, which will +make the exceptional set in a packed change of address bits small enough +to repair by sorting. We will obtain cost $O(Vd^{\lambda'})$, with +$\lambda'<1$ and $V$ the logical bit volume, whereas separate butterfly +factors would require $D$ whole-array passes. + +We first construct tensor products of the auxiliary two-point kernel +$C$ from Proposition~\ref{prop:complex-motif-interface}. Its phase +frames express a $C$ tensor product using smaller groups of +selected bits, separated by binary changes of basis. We implement those +changes by moving whole address chunks. Splitting complete rows among +the network's wire roles then reduces the volume of each recursive +call. Finally, we bound the intermediate dyadic values and convert the +completed $C$ layer to the normalized $H_0$ layer. The entire layer is +evaluated exactly before one final truncation. + +\subsection{Phase frames for a simultaneous butterfly layer} +\label{subsec:phase-frames} + +Hold the unselected address bits fixed and regard the stored complex +values on one wire role as a function of the selected bits. The phase +identities below express an edge's residual operator as a product of +two-point kernels on selected directions. + +Put +\[ + H_0=\frac12\begin{pmatrix}1&1\\1&-1\end{pmatrix},\qquad + H=\sqrt2 H_0,\qquad \mathsf S=\operatorname{diag}(1,i),\qquad + Z=\operatorname{diag}(1,-1). +\] +For the bit-flip matrix $X=\bigl(\begin{smallmatrix}0&1\\1&0\end{smallmatrix}\bigr)$, +define +\begin{equation}\label{eq:phase-C} + C=H\mathsf SH=aI+bX,\qquad a=\frac{1+i}{2},\quad b=\frac{1-i}{2}. +\end{equation} +Direct multiplication gives +\begin{equation}\label{eq:phase-basic-identities} + H_0=b\mathsf SC\mathsf S,\qquad C^2=X,\qquad C^4=I,\qquad + C^{-1}=bI+aX=-iZCZ. +\end{equation} +In particular, $C=iZC^{-1}Z$. These identities use only Gaussian dyadic +coefficients. The Hadamard matrices in the definition of +$\mathcal C_U$ are used to prove identities; they need not be executed +by the machine. + +Consider an edge from label $U_-$ to label $U_+$, and choose an +orthonormal basis $v_1,\ldots,v_{\rho_{\rm edge}}$ of its residual. +Proposition~\ref{prop:complex-motif-interface} gives the frame change +\[ + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\prod_{j=1}^{\rho_{\rm edge}}(aI+bX_{v_j})^{\epsilon_j}, + \qquad \epsilon_j\in\{1,-1\}. +\] +Here $(X_vf)(x)=f(x+v)$, and we write $C_v=aI+bX_v$. +The number of directional kernels is precisely +$\rho_{\rm edge}$, including on decreasing edges. The next step puts those directions +into coordinate positions without performing a general transpose. + +\paragraph{Implementing an arbitrary residual basis.} +For $M\in\operatorname{GL}(m,\mathbb F_2)$, let $\mathcal P_M$ be the +address permutation that moves the value at $x$ to $Mx$. Thus +$(\mathcal P_Mf)(x)=f(M^{-1}x)$, and +\begin{equation}\label{eq:phase-conjugation} + \mathcal P_MX_v\mathcal P_M^{-1}=X_{Mv}. +\end{equation} +Extend $v_1,\ldots,v_{\rho_{\rm edge}}$ to a basis of $\mathbb F_2^m$ and take these vectors as +the first $\rho_{\rm edge}$ columns of $M$. The displayed edge identity +then becomes +\begin{equation}\label{eq:phase-edge-coordinate} + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\mathcal P_M\left(\prod_{j=1}^{\rho_{\rm edge}}C_{e_j}^{\epsilon_j}\right) + \mathcal P_M^{-1}, +\end{equation} +where $e_j$ is the $j$th standard basis vector. The matrix $M$ need not +preserve the dot product: equation~\eqref{eq:phase-conjugation} only +uses its invertibility. + +For the array layout used below, take a group of $e=mf$ consecutive +axis chunks and divide it into $m$ consecutive slots of $f$ chunks, +numbered in physical order. +Number the chunks within each slot by $j=0,\ldots,f-1$, starting at +its least significant end. Write $x_{h,j}$ for the selected bit in +chunk $j$ of slot $h$, where $1\le h\le m$. Column $j$ is the vector +$(x_{1,j},\ldots,x_{m,j})$. A frame on this group is the tensor +product of the same phase frame +$\mathcal C_U$ of Proposition~\ref{prop:complex-motif-interface} +on these $f$ columns. + +To implement \eqref{eq:phase-edge-coordinate} on the group, first apply +$\mathcal P_M^{-1}$ separately to each column. For each +$1\le h\le\rho_{\rm edge}$, apply $(C^{\epsilon_h})^{\otimes f}$ to the +$f$ bits $x_{h,0},\ldots,x_{h,f-1}$. This is one child operation +on the $f$ axes in slot $h$. Finally apply $\mathcal P_M$ to every +column. A negative directional kernel still requires only one +forward child, because +\begin{equation}\label{eq:phase-inverse-child} + (C^{-1})^{\otimes f} + =(-i)^f Z^{\otimes f}C^{\otimes f}Z^{\otimes f}. +\end{equation} +The rightmost phase is applied first. All inverse wrappers are address +signs and constant fourth-root phases, so they add no recursive calls. + +Gaussian elimination expresses any $M\in\operatorname{GL}(m,\mathbb F_2)$ +as a product of at most $m(m-1)+3m$ elementary row additions: one clears +at most $m-1$ other entries per pivot, and each row swap is three row +additions. Reversing the elimination gives the required product since +each row addition is an involution. The number is a constant because +$m$ is fixed. Adding row $h'$ to row $h$ in every column applies +$x_{h,j}\leftarrow x_{h,j}\mathbin\oplus x_{h',j}$ for every +$0\le j1$, these segments +are disjoint, and the highest one ends immediately below $j_{f-1}$. +Write their initial values in $y$ and $z$ as +\[ + u_i=2g_i+a_i,\qquad w_i=2h_i+b_i, + \qquad a_i,b_i\in\{0,1\}. +\] +The values $g_i,h_i\in\{0,\ldots,2^{K-1}-1\}$ are the guard values. The +control for this pair of segments is the selected bit $c_i=x_{j_i}$. + +Apply each line of \eqref{eq:eight-packed-additions} simultaneously to all +these segment pairs. Physically, a line updating $y$ by sign $\varepsilon$ +and testing parity $b$ of $z$ is the single cyclic shift +\begin{equation} +\label{eq:packed-cyclic-shift} + y\longleftarrow y+ + \varepsilon\sum_{i=0}^{f-2}2^{j_i} + [\,x_{j_i}=1\,][\,z_{j_i}=b\,] + \pmod{2^L}. +\end{equation} +For a line updating $z$, interchange $y$ and $z$ in this formula. +The shift offset never depends on its target chunk, so each line is a +bijection of the rectangle. Let $S_0$ be their composition. It fixes +the spectator coordinates. + +Let $\mathcal B$ consist of the addresses for which +at least one used guard value, in either $y$ or $z$, fails +\begin{equation} +\label{eq:packed-guard-interval} + 10\le g\le 2^{K-1}-11. +\end{equation} +At an address outside $\mathcal B$, each segment initially lies in +$[20,2^K-21]$. Even displacement eight keeps it inside +$[0,2^K-1]$. Inductively, each packed addition therefore agrees with all +the independent segment additions: no segment carries into or borrows +from the next segment. When $f>1$, the bits below $j_0$ and above the +highest used segment are untouched as well. By +\eqref{eq:eight-packed-result}, $S_0$ +then agrees with the ideal permutation $T_0$ that performs the required +XORs at $j_0,\ldots,j_{f-2}$ and fixes all other address coordinates. + +There are exactly twenty excluded values for each guard in +\eqref{eq:packed-guard-interval}. Since its complete range has +$2^{K-1}$ values, the union bound over the $2(f-1)$ guards gives +\begin{equation} +\label{eq:packed-bad-fraction} + |\mathcal B|\le\delta_{\rm bad}M. +\end{equation} +Indeed, the complete $y,z$ ranges give the same guard distribution at +each choice of spectator coordinates. No record value enters this count. + +The ideal map $T_0$ preserves all guard values and therefore preserves +$\mathcal B$. Both $T_0$ and $S_0$ are bijections, and they agree off +$\mathcal B$. Taking complements in the finite rectangle gives +\[ + S_0(\mathcal B^c)=T_0(\mathcal B^c)=\mathcal B^c, + \qquad S_0(\mathcal B)=\mathcal B. +\] +Thus $T_0S_0^{-1}$ fixes $\mathcal B^c$ and permutes $\mathcal B$. +It remains to implement the rotations and this correction on tapes. + +For one rotation, move its target to the rightmost of the three chunk +positions if necessary. Let $P^{\rm sw}$ be the product of the record +field lengths before the earlier exchanged chunk, let $G^{\rm sw}$ +be the product between the exchanged chunks, and let $B^{\rm sw}$ be +$R$ times the product after the later one. Empty products are one. +The bit array has exactly the shape +\[ + [P^{\rm sw}]\times[2^L]\times[G^{\rm sw}] + \times[2^L]\times[B^{\rm sw}]. +\] +The third chunk lies inside one collapsed spectator interval. +Pass only $L$ and these three positive canonical lengths to +Lemma~\ref{lem:chunk-swap}. Each length is at most $V$, so the local +descriptor has $O(A_{\rm rect})$ bits. The swap costs $O(VL^\tau)$, including +its own padding and cleanup. + +The equal chunk lengths leave the field-length list unchanged by a +completed swap. Keep the permutation of the logical names $x,y,z$ in +finite local state. With the target now after its two controls, collapse +the remaining intervals to obtain +\[ + [\Lambda_0]\times[2^L]_{\rm control\,1}\times[\Lambda_1] + \times[2^L]_{\rm control\,2}\times[\Lambda_2] + \times[2^L]_{\rm target}\times[B_{\rm rot}], +\] +where $B_{\rm rot}$ includes the payload and every displayed spectator +length is positive. Their product with the chunk lengths is $V$. +Together with $K,f,\rho$ and the finite name permutation, these fixed +canonical lengths form an $O(A_{\rm rect})$-bit local descriptor. The offset +routine receives the two current $L$-bit logical control values. A scan +of at most $f\le L$ selected positions evaluates +\eqref{eq:packed-cyclic-shift} in $L^{O(1)}$ time, without reading the +target or spectator values. Lemma~\ref{lem:ordered-affine-streams} +therefore gives an $O(V)$ rotation: its offset work is absorbed by the +$2^L$ nonempty target blocks in each fiber. Undo the swap after the +rotation. The local descriptors and name permutation are updated at +completed swap boundaries; the primitives use their own descriptors +inside padded layouts. +There are at most sixteen swaps and eight rotations in $S_0$. + +To implement the correction, scan the stream with a record-rank counter. +All chunk names are back in their original positions. Dividing the +current rank through the fixed seven field lengths recovers the three +chunk values and their mixed-radix record strides. The strides exclude +the $R$ payload bits. All involved integers have $O(A_{\rm rect})$ bits, so +schoolbook arithmetic, descriptor copying, and resets take at most +$O(A_{\rm rect}^3)$ per record. Test membership in $\mathcal B$ and extract just +those records. For a current exceptional address $q$, compute +$q'=T_0(S_0^{-1}(q))$ by reversing the eight modular additions with +negated offsets, then applying the selected XORs directly. Each reversed +mask uses the current controls of that reversed line. There are at most +$f\le L\le A_{\rm rect}$ selected positions, so this calculation also fits +$O(A_{\rm rect}^3)$ time. + +If $q_h,q'_h$ are the current and destination values of chunk +$h\in\{x,y,z\}$ and $\sigma_h$ is its record stride, the fixed +spectator coordinates give +\[ + \operatorname{rank}(q')=\operatorname{rank}(q)+ + \sum_{h\in\{x,y,z\}}(q'_h-q_h)\sigma_h. +\] +The differences are signed. Attach this destination rank, padded to +$\lceil\log_2M\rceil\le A_{\rm rect}$ bits, to the extracted record, and mark its +hole on a fixed track of the full stream. Hold the full stream untouched +while stable binary radix sorting scans only the extracted records and +keys, least significant key bit first. Since $T_0S_0^{-1}$ permutes +$\mathcal B$, these keys are distinct and are exactly the ranks of the +marked holes. One forward full-stream scan reinserts the sorted records. +This implements $T_0$ everywhere. + +Finally apply the two-bit XOR to $x_{j_{f-1}},y_{j_{f-1}}$ by +Lemma~\ref{lem:elementary-streams}, splitting those chunks at the +selected positions and collapsing the other intervals. Its descriptor +again has a fixed number of positive lengths, each at most $V$. +This costs $O(V)$ and supplies the omitted selected position. When +$f=1$, $S_0,T_0$ are identities, $\mathcal B$ is empty, and this last +step is the entire algorithm. + +The movement costs $O(V(L^\tau+1))$. A fixed number of full record scans +costs $O(MA_{\rm rect}^3+V)$, and the at most $A_{\rm rect}$ radix passes cost +$O(|\mathcal B|A_{\rm rect}(R+A_{\rm rect}))$; skip them when the extracted bank is empty. +The initial descriptor has a fixed number of canonical integers of +$O(A_{\rm rect})$ bits, so its preparation is covered by $O(MA_{\rm rect}^3)$. +All counters, positioning, rewinds, and cleanup are included. +Equation~\eqref{eq:packed-bad-fraction} proves +\eqref{eq:packed-rectangle-time} on a fixed number of tapes. +After division by $V=MR$, its additional terms are bounded by +$A_{\rm rect}^3/R$ and +$80(f-1)2^{-K}A_{\rm rect}(1+A_{\rm rect}/R)$. Under the stated family bounds +the first tends to zero, and the second is +$O(p^2 2^{-K}(1+A_{\rm rect}/R))=o(1)$. This proves the final assertion. +\end{proof} + +\paragraph{Application to a fixed binary change of basis.} +An invertible matrix over $\mathbb F_2$ of fixed order $m\ge3$ is a +product of a fixed number of elementary row additions; a row exchange +is three such additions. In one invocation of the finite network on +$e=mf$ axes, slot $h$ consists of $f$ consecutive $K$-bit axis chunks. +It therefore has address-bit width $L=fK$, and its selected bits +$x_{h,j}$ occupy positions $\rho+jK$ for $0\le j1$. +For these fixed choices +there are a cutoff $p_0$, one fixed finite-alphabet multitape procedure, +and an implicit time constant with the following guarantee. The cutoff +and time constant may depend on the fixed rational parameters +and these constants. For every choice of positive integers $p,d,r$ +with $p\ge p_0$ and +\[ + a_dp^\epsilon\le d\le b_dp^\epsilon,\qquad + 2^{a_rp/d}\le r\le 2^{b_rp/d}, +\] +put $K=\lfloor d^c\rfloor$, and let $1\le D\le d$, $P,S\ge1$, and +$0\le\rho0$ +and $C_w>1$, and choose the layer constants once as +\[ + C_M=C_\ell+1,\qquad + C_{\rm desc}=32(C_\ell+C_w+1). +\] +Use these constants and $C_w$ in +Proposition~\ref{prop:simultaneous-layer}. These fixed choices determine +a cutoff $p_1$, one fixed-tape procedure, and an implicit time constant +with the following guarantee. For every choice of positive integers +$p,d,r$ with $p\geq p_1$ and +\[ + a_dp^\epsilon\leq d\leq b_dp^\epsilon,\qquad + 2^{a_rp/d}\leq r\leq2^{b_rp/d}, +\] +suppose $d\geq2$ and $r=2^\ell$ with an integer $2\leq\ell0$. Thus all participating axes in a +common round have current length $u_i=2^{h+1}$. +The branch bit written at position $h$ is frequency bit $a_i-1-h$; +its frequency significance can differ between long and short axes. +The descriptor locates that named slot after $L$, so the physical +move has not changed which pair the current butterfly uses. The +opposite procedure executes this schedule in reverse order and, +when present, ends with the extra leading round on the long axes. + +For a position $h$ in the remaining chunks, the selected bit has +offset $(h-b)\bmod K$, counted from the least significant bit, in +each of the $D$ consecutive chunks with the same chunk index $j$. +Let $n_P$ and $n_S$ be the numbers of record-address bits before and +after that group. Every combination of those bits occurs, so the +layer sees the complete address set +\[ + [P]\times[2^K]^D\times[S],\qquad + P=2^{n_P},\quad S=2^{n_S},\quad + n_P+DK+n_S=\sum_i a_i\leq D\ell=O(p). +\] +Thus its record count is $PS2^{DK}=M$ and +$\log_2(2M)\leq(C_\ell+1)p=C_Mp$. +The current transform parameters supply $p,d,r,K,w$, and the round +determines $D,P,S$ and the selected offset $\rho$. Encode these values +as the header $\mathcal E$ of Proposition~\ref{prop:simultaneous-layer}. +The same fixed descriptor bound covers every axis choice and round. +Indeed $|\Gamma(v)|\leq2\log_2v+1$, and +$\ell+n_P+n_S\leq d\ell\leq C_\ell p$. Also +$d,D\leq\max\{C_\ell,1\}p$, $K,\rho+1\leq p$, and $w\leq C_wp$. +Adding the nine code lengths therefore gives +\[ + |\mathcal E| + \leq 2C_\ell p+12\log_2p+ + 4\log_2\max\{C_\ell,1\}+2\log_2C_w+9 + \leq C_{\rm desc}p. +\] +The last inequality uses $p\geq1$, $\log_2p\leq p$, and +$\log_2x\leq x$ for $x\geq1$. +This is the descriptor passed to the layer; the longer +table locating named slots remains separate for the transform's address +calculations. +The simultaneous-layer procedure therefore applies at cost +$O(Tpd^{\lambda'})$ per round and $O(Tp\ell d^{\lambda'})$ in total. + +In a round on prefix slots, process the participating bits individually. +Temporarily move one such bit immediately before the polynomial +suffix. In each now adjacent pair, buffer the first record and scan +it with the second, writing the half-sums and half-differences to two +work tapes. Append the half-sum record and then the half-difference +record, and reverse the bit move after +all pairs are processed. Including head returns, the work is +$O(rp)$ per pair and $O(Tp)$ for the moves and scans at coefficient +width $O(p)$. +That width suffices without truncating between axes: after $s\leq D$ +individual $H_0$ factors, the coefficients are exact dyadics on the +$2^{-(p+s)}$ grid and still lie in the disk. A temporary sum has +modulus at most two and needs only a constant number of extra integer +bits. Hence +$p+D+O(1)=O(p)$ bits per component suffice, since $D\leq d$ and +$d\ell=O(p)$. Complete the combined monomial exactly and apply +$Q_p$ once at the end of the round. Write the resulting disk-grid +numerators in the supplied $w$-bit component format. Their magnitudes +are at most $2^p$, so this takes one linear scan within the same bound. +In an opposite round on prefix slots the +inverse monomial comes first and preserves the grid and disk, so the +same width bound holds for its individual factors. There are at +most $b+1\leq K$ rounds on prefix slots, giving cost $O(TpdK)$. + +For each output record of a forward butterfly round, the descriptor +locates the new branch bit $b_i$ and the lower named slots that encode +$k_i$. Read their current values to compute +\eqref{eq:combined-twiddle}. Before an opposite round at position +$h$, all lower positions have already been processed in reverse. +Those slots again index the lower inputs of that level, while slot +$h$ still gives $b_i$. They therefore encode the same $k_i$ needed +by the inverse monomial before its +butterfly. The binary descriptions of the addresses, exponent, and +layout have polynomial length in $p$. Ordinary +fixed-tape arithmetic therefore computes the exponent in +$\operatorname{poly}(p)$ time per polynomial record. Each record +contains $\Theta(rp)$ bits, and $r$ dominates every fixed power of +$p$, so this work fits within its scan cost. The same bound covers +scans of the polynomially many round and layout descriptors. +Growing lists reside on tapes; a fixed number of counter and work +tapes suffices for every number of axes. + +To implement the monomial, write $E=er+s$ with $0\leq s1$. +Let $w$ be an integer with $p+2\leq w\leq C_wp$. +The input supplies $\Gamma(p)\Gamma(r)\Gamma(w)$ and two disk grid +polynomials $f,g\in\mathcal R_r$ in the component format of +Proposition~\ref{prop:simultaneous-layer} with width $w$. +One can compute the exact Gaussian integer +numerators of $fg$, and then return $Q_p(fg/r)$ in that same format, in time +$O(rp\log(rp))$ on a fixed number of tapes. The output is a disk +grid polynomial with error less than $\sqrt2\,2^{-p}$ from $fg/r$. +\end{lemma} +\begin{proof} +The supplied power of two $r$ determines $\ell=\log_2r$. +Write +\[ + f=2^{-p}(a+ib),\qquad g=2^{-p}(c+ie), +\] +where $a,b,c,e\in\mathbb Z[y]$ have degree less than $r$ and +coefficients of absolute value at most $2^p$. Set $B_0=2^{4p}$ +and, for $u\in\{a,b,c,e\}$, define the signed evaluation integer +\[ + A_u=u(B_0)=\sum_{j=0}^{r-1}u_jB_0^j. +\] +The bound +\[ + |A_u|\leq2^p\frac{B_0^r-1}{B_0-1} (x-J^T y,y,h,0)", + "corrected_map_forward": "(x,y,h,c) -> (x,y+Jx,h,0)", + "corrected_program_checks": { + "backward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198814, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + }, + "forward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198766, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + } + }, + "corrected_program_payload_sha256": "fa60b4af013dd8b8db289845e3ed597720ff955751ad270c3d58236b64080877", + "dirty_correction_site": "After entry adapters and before A; targets and all helpers in H have canonical frame zero.", + "full_input_columns": 712, + "full_output_rows": 712, + "identities": [ + "R R^T = 56 I8", + "P = R^T R/4", + "P^2 = 14 P", + "J = I112-P", + "J^2+12J-13I112=0", + "J^-1 = (12I112+J)/13" + ], + "map": "(x,y,h,c) -> (x, y + J x - R^T H h/4, h, 0)", + "not_claimed": [ + "Native centre-free supplier admission", + "Free endpoint J^-1", + "Changed global controller", + "Kappa improvement" + ], + "ports": [ + 11, + 19, + 35, + 67, + 131, + 259, + 13, + 21, + 37, + 69, + 133, + 261, + 41, + 73, + 137, + 265, + 49, + 81, + 145, + 273, + 161, + 289, + 193, + 321, + 385, + 14, + 22, + 38, + 70, + 134, + 262, + 26, + 74, + 138, + 266, + 50, + 146, + 274, + 98, + 162, + 290, + 194, + 322, + 386, + 28, + 44, + 140, + 268, + 84, + 148, + 276, + 100, + 164, + 292, + 196, + 324, + 388, + 56, + 88, + 152, + 280, + 104, + 168, + 296, + 200, + 328, + 392, + 112, + 176, + 304, + 208, + 336, + 400, + 224, + 352, + 416, + 448, + 508, + 506, + 502, + 494, + 478, + 446, + 382, + 254, + 505, + 501, + 493, + 477, + 445, + 381, + 253, + 499, + 491, + 475, + 443, + 379, + 251, + 487, + 471, + 439, + 375, + 247, + 463, + 431, + 367, + 239, + 415, + 351, + 223, + 319, + 191 + ], + "program_sha256": "9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3", + "scope": "Exact scalar interface only. Native endpoint mixing and a changed controller are not admitted.", + "status": "PASS_CENTRE_FREE_SCALAR_INTERFACE", + "target_endpoint": "T_q = F C_q^-1; distinct q have distinct frames", + "word_sha256": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c" +} diff --git a/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.json b/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.json new file mode 100644 index 0000000000..6c1d0e1821 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.json @@ -0,0 +1,46 @@ +{ + "checker_sha256": "1827aa705a2b68b478a9ffe09762b742123f558fa390c43fbf768fc54fe0d1e8", + "independent_exact_checks": [ + "Two-point conjugation with independent Gaussian and polynomial roots", + "Unit products", + "Both Pauli phases", + "All odd native weights through7" + ], + "not_repeated": [ + "Upstream source and layout audit", + "The256-column finite example", + "The producer checker", + "Native or recursive decoder construction" + ], + "parity_signs": { + "1": [ + -1, + 1 + ], + "3": [ + 1, + -1 + ], + "5": [ + -1, + 1 + ], + "7": [ + 1, + -1 + ] + }, + "proof_pins": { + "ACCUMULATED-TWIDDLE-CODE.md": "406e3cae0f69be8dd5c737b56e4af25b9aeb59de65d04dcb5355c67b2b5b371c", + "TWIDDLE-PASS-COST.md": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99" + }, + "proof_review": [ + "Separate full-stream pass depth", + "Ordered J E H0 placement", + "Invertible joint parity blocks", + "Complete-word support bound", + "One-native-tensor support consequence under scalar monomial wrappers" + ], + "scope": "Fixed complete-stream pass grammar and the stated stable-port endpoint. No general native decoder lower bound.", + "status": "PASS_SCOPED_TWIDDLE_PROOF_REVIEW" +} diff --git a/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.md b/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.md new file mode 100644 index 0000000000..bb931f7d8b --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/coherent-port/TWIDDLE-PASS-PROOF-REVIEW.md @@ -0,0 +1,49 @@ +# Bounded review of the twiddle pass proofs + +The proofs in `../temporal-reuse/TWIDDLE-PASS-COST.md` and +`../temporal-reuse/ACCUMULATED-TWIDDLE-CODE.md` pass in their stated +implementation models. The receipt pins the reviewed bytes. + +The separate-round proof uses a legal tail value with `t^2=-1`. +The ordered conjugate of `diag(1,t)` has four nonzero entries. The +products `(1+t)(1-t)=2` show that none can be lost through a zero +divisor. Independent tensor choices give `2^f` input dependencies. +A pointwise binary ADD can at most double the support on one path. +Thus f depths are required when each depth is a complete-stream pass. +The cost conclusion uses the stated outer size relations and the +requirement to transport each round separately. + +The complete-word proof retains the order `J E H0`. The current code +does not move past its own twiddle. For an odd port q, the two native +branches `C_all C_q` and `C_all C_q^-1` conjugate `Z_q` to opposite +signs of itself. The signs are preserve/flip for actual weights three +and seven. Diagonal twiddles preserve these parity classes. Later +rounds use other offsets, so the whole encoded word permutes the joint +parity classes and acts invertibly in each block. + +Each raw FFT output row has a nonzero restriction to every relevant +input parity block. Right multiplication by an invertible block cannot +turn such a row into zero. This gives the stated complete-word +`2^(f*l)` support bound. It yields the full-pass cost conclusion but +does not give a lower bound for recursive or unequal-volume native +subcalls. + +The reported ten-entry finite decoder cannot be one native C tensor +between native or scalar monomial maps: such maps preserve scalar row +support, and a native tensor has a power-of-two row support. This +review checks that implication. It does not repeat the source's +256-column finite calculation. An arbitrary real two-by-two map on +each complex coefficient is outside that monomial-wrapper statement. + +`review_twiddle_pass_proofs.py` performs an independent exact check in +the ring with distinct generators `i^2=t^2=-1`. It checks the +two-point conjugate, both native inverse orders, unit products, both +Pauli signs, and the parity signs for all odd weights through seven. +It imports no producer. It uses explicit failure checks under +optimized Python. + +The review does not repeat the upstream source-layout audit, the +producer's finite matrix replay, or native decoder admission. The +quoted outer twiddle and size relations are premises of this bounded +proof review. No general decoder impossibility, recursive cost bound, +or new multiplication exponent is claimed. diff --git a/research/completed-prefix-outer/frozen/lanes/coherent-port/review_twiddle_pass_proofs.py b/research/completed-prefix-outer/frozen/lanes/coherent-port/review_twiddle_pass_proofs.py new file mode 100644 index 0000000000..b90a7c206b --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/coherent-port/review_twiddle_pass_proofs.py @@ -0,0 +1,96 @@ +"""Check the small ordered identities used by two scoped twiddle proofs.""" + +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import json + + +HERE = Path(__file__).resolve().parent +SOURCE = HERE.parent / "temporal-reuse" +PINS = { + "TWIDDLE-PASS-COST.md": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99", + "ACCUMULATED-TWIDDLE-CODE.md": "406e3cae0f69be8dd5c737b56e4af25b9aeb59de65d04dcb5355c67b2b5b371c", +} + + +def need(value, label): + if not value: + raise ValueError(label) + + +def add(x, y): + return tuple(a + b for a, b in zip(x, y)) + + +def scale(c, x): + return tuple(c * a for a in x) + + +def mul(x, y): + out = [F(0)] * 4 + for j, a in enumerate(x): + for k, b in enumerate(y): + sign = -1 if ((j & k & 1) + bool(j & k & 2)) % 2 else 1 + out[j ^ k] += sign * a * b + return tuple(out) + + +ZERO = (F(0),) * 4 +ONE = (F(1), F(0), F(0), F(0)) +I = (F(0), F(1), F(0), F(0)) +T = (F(0), F(0), F(1), F(0)) + + +def matmul(a, b): + return [[add(mul(a[i][0], b[0][j]), mul(a[i][1], b[1][j])) for j in range(2)] for i in range(2)] + + +def main(): + for name, pin in PINS.items(): + need(sha256((SOURCE / name).read_bytes()).hexdigest() == pin, "Proof pin") + alpha, beta = scale(F(1, 2), add(ONE, I)), scale(F(1, 2), add(ONE, scale(-1, I))) + c, ci = [[alpha, beta], [beta, alpha]], [[beta, alpha], [alpha, beta]] + ident, z = [[ONE, ZERO], [ZERO, ONE]], [[ONE, ZERO], [ZERO, scale(-1, ONE)]] + need(matmul(c, ci) == ident == matmul(ci, c), "Exact inverse over the four-dimensional ring") + need(mul(T, T) == scale(-1, ONE), "The polynomial root stays separate from i") + need(mul(add(ONE, T), add(ONE, scale(-1, T))) == scale(2, ONE), "Both twiddle sums are units") + conjugate = matmul(matmul(c, [[ONE, ZERO], [ZERO, T]]), ci) + diagonal = scale(F(1, 2), add(ONE, T)) + off = scale(F(1, 2), mul(I, add(ONE, scale(-1, T)))) + need(conjugate == [[diagonal, off], [scale(-1, off), diagonal]], "Exact ordered twiddle conjugation") + need(all(value != ZERO for row in conjugate for value in row), "All four coefficients are nonzero") + xz = [[ZERO, scale(-1, ONE)], [ONE, ZERO]] + need(matmul(matmul(c, z), ci) == [[scale(-1, mul(I, value)) for value in row] for row in xz], + "Positive C line Pauli phase") + need(matmul(matmul(ci, z), c) == [[mul(I, value) for value in row] for row in xz], + "Negative C line Pauli phase") + signs = {} + for weight in (1, 3, 5, 7): + phase = ONE + for _ in range(weight): + phase = mul(phase, scale(-1, I)) + plus, minus = mul(scale(-1, I), phase), mul(I, phase) + need(plus in (ONE, scale(-1, ONE)) and minus == scale(-1, plus), "Opposite parity signs") + signs[str(weight)] = [int(plus[0]), int(minus[0])] + need(signs["3"] == signs["7"] == [1, -1], "Actual port-weight signs") + receipt = { + "status": "PASS_SCOPED_TWIDDLE_PROOF_REVIEW", + "proof_pins": PINS, + "checker_sha256": sha256(Path(__file__).read_bytes()).hexdigest(), + "independent_exact_checks": ["Two-point conjugation with independent Gaussian and polynomial roots", + "Unit products", "Both Pauli phases", "All odd native weights through7"], + "parity_signs": signs, + "proof_review": ["Separate full-stream pass depth", "Ordered J E H0 placement", + "Invertible joint parity blocks", "Complete-word support bound", + "One-native-tensor support consequence under scalar monomial wrappers"], + "not_repeated": ["Upstream source and layout audit", "The256-column finite example", + "The producer checker", "Native or recursive decoder construction"], + "scope": "Fixed complete-stream pass grammar and the stated stable-port endpoint. No general native decoder lower bound.", + } + (HERE / "TWIDDLE-PASS-PROOF-REVIEW.json").write_text(json.dumps(receipt, sort_keys=True, indent=2) + "\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.json b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.json new file mode 100644 index 0000000000..7af11046fe --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.json @@ -0,0 +1,50 @@ +{ + "actual_chunk_offset_cases": 1732, + "actual_odd_port_hypotheses_checked": 112, + "all_size_proof_review": "PASS; exact statement and hypotheses are in REVIEW.md", + "arithmetic": "Integer exponents in the exact polynomial ring; Gaussian rational two-term polynomials", + "axis_log_lengths": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "checker_sha256": "3719007502f72faa1df065bdb6d97c96a963cbedd34b22bd5c1108b85290eea6", + "early_late_three_or_more_group_cases": 60, + "exact_forward_and_opposite_entries": 174760, + "git_pins": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "git_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "nonadjacent_rotation_cases": 360, + "nonmonomial_twiddle_unit_entries": 8, + "old_reverse_opposite_twiddle_control": 128, + "producer_imports": false, + "research_pins": { + "circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "schur-selection/PAST-CATALYST-v2.md": "566cfb7794202a2462a41da8abef69066c51a06ab7802c01f76b996e58e976e5", + "schur-selection/PAST-GAUGE-FUSION.md": "a84b77d2ef0d0747713063a7bd08e211b5a75eabbba6ff085a3967676fc12c6f", + "temporal-reuse/COMPLETED-PREFIX-CODES.json": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "temporal-reuse/COMPLETED-PREFIX-CODES.md": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5", + "temporal-reuse/PAST-CATALYST-LAYOUT.json": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "temporal-reuse/PAST-CATALYST-LAYOUT.md": "8f3ac9bc6133397ce98c88b0f6999c1eac9f6169d10fe21b2f0ab9d2275caee7", + "temporal-reuse/check_completed_prefix_codes.py": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186", + "temporal-reuse/check_past_catalyst_layout.py": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef" + }, + "scope": "Outer exact opposite and completed-prefix composition; conditional address packing. No native supplier, cover redesign, growing-bank decoder bound, compact invoice, or recursive encoded-child closure.", + "selected_margins": { + "epsilon_minus_kappa": "1635654921950317604269246176697592893315360642164647696163717235784796569190497511406755693461406225762418838586331730835704915263244133189022659330234814818810892219059957239485707752007657731284696774507602551594083331891078337774583028045958975578287492520966716631023415709897216606029214103869146078792163164507055296177461882843051065083293106678283624262730067538295610766368389669754871598780028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000", + "groups": "2463090156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "startup": "1081110357609925260614972695003107315707432353068338487603991699409949621702495690156909535160235873839601108223405260050123543294943053402137660198994397070489620108165140795187785639656314293544597085375410582291108751565224554246715990585636803213137497296463685876362653172078415927035174159499690912068352607880037991076665304643497436633279437216679436871538992416375313119280028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000" + }, + "status": "PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW" +} diff --git a/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.md b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.md new file mode 100644 index 0000000000..60501990c4 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/REVIEW.md @@ -0,0 +1,222 @@ +# Independent review of completed-prefix codes and past-coordinate layout + +The two source notes pass within their stated scope. They give an exact +opposite DIF procedure, an outer composition rule for physical completed +coordinates, and a conditional address wrapper for a fixed past-space +native word. They do not give that native word or its recursive closure. + +The reviewed notes are `temporal-reuse/COMPLETED-PREFIX-CODES.md` and +`temporal-reuse/PAST-CATALYST-LAYOUT.md`. Their exact hashes, both producer +hashes, both receipt hashes, and six Git source hashes are in `REVIEW.json`. +The Git revision is `3ae9a6f3ac74ded022ab3b4872a7357a621af6fb`. +The source files were read directly from Git. No frozen source changed. + +## Exact opposite and completed coordinates + +Let an axis have length `2^a`, with input bits `x_h` and output bits `z_h` +in their physical positions. Use the proposed low-to-high opposite +procedure. Its exact matrix entry has magnitude `2^-a` and phase + +\[ +r\sum_h x_hz_h+ +\sum_{hv` are multiples of `2r`. +The scalar is the required normalized transform scalar. This proves +`F_plus B^-1` over the actual polynomial quotient ring, for every axis +length. It does not rely on a finite-field example. Different axes +tensor together, and each long or short axis uses its own `a`. + +The source layout L only relocates named slots. Applying this new word +in that layout, then restoring L, gives +`F_plus B^-1 L^-1`. No extra physical bit reversal is needed. The +butterfly at physical position h is unchanged from the retained +opposite schedule. Only its monomial exponent and its position relative +to the butterfly change. The same statement holds if all axes are +short; the header value ell still defines L. + +After the new opposite round at h, every later twiddle uses only higher +physical slots. The forward source has the corresponding property with +lower unprocessed slots. Thus the remaining exact operator is identity +on every completed slot in both procedures. A code confined to those +physical slots commutes with the remaining exact transform. Arbitrary +row values and arbitrary correlations between rows are permitted. + +The layer and monomial are contractions in the source norm. The monomial +is a signed coefficient permutation, so it commutes with componentwise +truncation toward zero. There is still one truncation per round. The +original unencoded disk and error bounds therefore apply to this new +opposite procedure. A proposed encoded procedure needs the separate +code-growth allowance described below; this review does not transfer +the unencoded error bound to it without that allowance. + +The current named-slot table computes the new exponent with polynomial +work in p per polynomial record. The source record size absorbs that +work. The same two-piece monomial scan applies. The layer slots, number +of rounds, chunk movement, and time order remain unchanged. + +## What the decoder bound does and does not cover + +For a fixed h-bit completed prefix, the code dimension `w=2^h` is fixed. +Suppose each whole-layer endpoint leaves a member of one fixed finite +alphabet in `GL_w(Z[i,1/2])`, and the program supplies its inverse. The +product order is the actual chronological order. The matrices need not +commute. All entries of the product and inverse have `O(ell)` bits, +including denominator exponents, because the number of factors is +`O(ell)` and the dimension and alphabet are fixed. + +One can form the inverse as the reverse product of the supplied inverses. +No new division or field extension is required. A fixed number of row +buffers and direct shift-and-add arithmetic then apply it in +`O(V ell)` time. Polynomial controller setup is absorbed by the full +polynomial-record stream. The code and inverse norms require `O(ell)` +extra integer, grid, and error-control bits. Since `ell=o(p)`, this does +not change the width exponent. It does require a new finite precision +allowance. The exact selected margins for this order and the startup +order are checked from the pinned assembly. + +This theorem has fixed matrix dimension. The whole-axis row construction +is a different lemma. It provides enough completed row bits for all +`W^k0` recursive row classes, but it does not prove an `O(V ell)` decoder +for an arbitrary code on that growing bank. Nor does it prove that bound +for arbitrary codes on `Theta(d)` past payload bits. Repeating a +`Theta(d)`-factor decoder for every round would still cost +`O(V ell d)`. A finite-order tensor code can avoid that cost only after +its physical endpoint and composition law have been proved. + +Completing one whole synthetic axis first is valid in either direction: +different-axis transform factors commute. It costs `O(V ell)` and +supplies `Theta(ell)` completed bits. The required row digits number +`ceil(ceil(log_m d) log_2 W)=O(log d)`. They fit for all sufficiently +large source parameters. Padding the complete row range to a multiple +of `W^k0` increases volume by less than two. Every split `u=Wg+w` +retains the same full remaining suffix and has exact child volume +`V/W`. Padded rows must remain until the code is inverted and they are +zero again. The extra truncation or exact-grid choice for the first axis +is part of the new allowance, not the old finite certificate. + +## Current-twiddle criterion + +The criterion in the source note is correct for codes with complex +scalar entries which fix the lower unprocessed index and the polynomial +payload. At a nonterminal selected axis, set one lower input bit to one. +Its diagonal twiddle has eigenvalues 1 and +`z=y^(-2r/u)`. The intertwining equation forces every nonzero entry in +one output row of the code to come from the same branch value. Repeating +this for every selected axis forces a unique branch address in that row. +Dense mixing within the completed row index at that address remains +allowed. + +Allowing a record permutation in the replacement monomial does not +remove the restriction. The conjugate satisfies +`(D'-I)(D'-zI)=0`. A permutation cycle of length at least three puts +the three terms in different positions. A two-cycle leaves the nonzero +off-diagonal term `-(1+z)D'`. Here `1+z` is a unit: `z^(u/2)=-1`, and +the finite geometric sum gives an inverse with denominator two. Thus +the conjugate must be diagonal. This argument is valid in the quotient +ring even though that ring has zero divisors. + +An odd line `C_q=aI+bX_q` mixes two branch addresses when q has a current +coordinate. Its conjugated one-coordinate twiddle has four unit entries +in the `2 x 2` block over `C[y]/(y^2+1)`. The inverse line has the same +property. Diagonal H0 phases do not change support. In the paired code, +the replica exchange does not remove these entries. Independent tensor +copies give `2^lambda` dependencies. A pure address permutation is a +counterexample to an overbroad rejection: it passes with a changed +twiddle exponent. Terminal axes of length two, codes with polynomial +entries, and a new arithmetic twiddle algorithm are outside the stated +necessity theorem. Cancellation in a complete encoded endpoint is also +not excluded by testing one factor. + +## Physical past-block wrapper + +For complete fields X and Z of length L, the three specified disjoint +interchanges send `X=A B, Z=C D` to `X=B A, Z=D C`. Taking +`c=(L-rho) mod L` puts every old selected position `jK` at `jK+rho`. +Conjugating a native word by this permutation therefore gives exactly +its action on the old selected coordinates, provided that the native +word fixes Z and all unselected positions. The conclusion applies to +every linear value map on the selected coordinates, not only to an XOR +mask. All address bits and arbitrary data outside that support return +to their required positions after the literal inverse wrapper. + +The temporary adjacent-block exchange is also valid on arbitrary +values. With three or more chunk groups, a neighbor distinct from the +active group and the reserve exists. At the `64:9` split, the past block +and its equally sized spectator fit inside an inactive group. Before +that reserve group becomes active, the initial bit exchanges are undone +and a new reserve is made in a fully completed group. Displaced future +bits keep their named-slot identities in the descriptor. Their changed +physical location does not make them completed bits, and every current +native word must fix them. The twiddle still reads their logical names. + +The entire address rectangle remains complete. No zero-address or +clean-value premise is used. Six rotation interchanges, two adjacency +interchanges, and the fixed slot-order permutation have the source +`O(V ((eK)^tau+1))` node bound. The one-time named-bit placement and +restoration use `O(Vd)` work. The exact selected inequalities give both +the startup margin and asymptotically three chunk groups. The literal +map counts, descriptors, and compact precision guards still need a new +finite invoice. This review adds no native Fourier children and grants +no new productive field. + +## Exact remaining supplier obligation + +A useful new whole-layer interface must prove its physical map to be +`A_P tensor H_current`, with P a fixed completed physical space, and +must restore all required arbitrary helper inputs. Its declared +recursive child must implement `E_V F E_U^-1` at each parent edge. +Every parent scalar gate needs equal physical codes on its operands. +All preparation, address maps, helper conversions, native children, +padding retention, final decoding, precision, and stack work must be +priced with the active child dimension and volume actually used. + +The selected cover does not satisfy this condition merely because its +local nine-dimensional space can be packed into past positions. +The separate, pinned Schur notes prove that closure under the retained +stage routes expands the common line span to all 73 coordinates. +They also give an active-rank lower count of 1,615,856 for the prescribed +local-nine gauge visits, versus productive active mass 917,504. Adjacent +gauge-only fusion does not reduce that count because an owner's active +visit masks are disjoint. These scoped results do not rule out a new +cover, exterior gauge, content factorization, or typed child family. +Their proof and count review is separate; this review uses them only to +state the unresolved interface, not as a newly reproduced native bill. + +## Checks and reproduction + +Both producers were run with `-I -O -B` into new output paths. Their +outputs match the frozen receipts. The independent `review_prefix.py` +imports neither producer. It checks exact forward and opposite phase +entries for axis widths one through eight in the polynomial-ring +convention; actual long/short/all-short chunk offsets; nonadjacent +rotation and literal inverse maps; early and late reserve placement +with three, four, or five groups; and exact Gaussian-rational twiddle +unit entries. The finite checks validate the formulas. The all-size +claims use the proofs above and the pinned stream lemmas. + +Run from the workspace root: + +```text +python3 -I -O -B work/centre-encoding-campaign-20261014/lanes/interface-proof/completed-prefix-review/review_prefix.py +``` + +Expected output: + +```text +PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW +Exact DIF phases, current twiddle, selected offsets, full guard and reserve restoration +``` + +This external review needs the pinned workspace files. It is not a +portable repository test. It was prepared with OpenAI Codex assistance. +No complete encoded supplier or kappa improvement is certified. diff --git a/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/review_prefix.py b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/review_prefix.py new file mode 100644 index 0000000000..8d7567b58c --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/interface-proof/completed-prefix-review/review_prefix.py @@ -0,0 +1,282 @@ +"""Check exact DIF phases and physical prefix placement without producer imports.""" + +import argparse +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path +import subprocess + + +REV = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +FILES = { + "temporal-reuse/COMPLETED-PREFIX-CODES.md": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5", + "temporal-reuse/check_completed_prefix_codes.py": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186", + "temporal-reuse/COMPLETED-PREFIX-CODES.json": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "temporal-reuse/PAST-CATALYST-LAYOUT.md": "8f3ac9bc6133397ce98c88b0f6999c1eac9f6169d10fe21b2f0ab9d2275caee7", + "temporal-reuse/check_past_catalyst_layout.py": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef", + "temporal-reuse/PAST-CATALYST-LAYOUT.json": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "schur-selection/PAST-CATALYST-v2.md": "566cfb7794202a2462a41da8abef69066c51a06ab7802c01f76b996e58e976e5", + "schur-selection/PAST-GAUGE-FUSION.md": "a84b77d2ef0d0747713063a7bd08e211b5a75eabbba6ff085a3967676fc12c6f", +} +GIT_FILES = { + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def reverse(value, width): + return sum(((value >> i) & 1) << (width-1-i) for i in range(width)) + + +def column(width, source, opposite): + """Return monomial exponents; the common coefficient is 1/2**width.""" + r = 1 << width + states = {source: 0} + order = range(width) if opposite else range(width-1, -1, -1) + for h in order: + following = {} + for address, exponent in states.items(): + old = (address >> h) & 1 + for new in (0, 1): + target = (address & ~(1 << h)) | (new << h) + phase = exponent+r*old*new + if opposite: + tail = reverse(address >> (h+1), width-h-1) + phase += (2*r >> (width-h))*new*tail + else: + tail = address & ((1 << h)-1) + phase -= (2*r >> (h+1))*new*tail + need(target not in following, "Two paths reached one basis entry") + following[target] = phase % (2*r) + states = following + return states + + +def exact_dif(): + count = 0 + old_opposite_counterexample = None + for width in range(1, 9): + r = 1 << width + for source in range(r): + for opposite in (False, True): + out = column(width, source, opposite) + for target, phase in out.items(): + expected = (2*target*reverse(source, width) if opposite + else -2*reverse(target, width)*source) % (2*r) + need(phase == expected, "Exact polynomial DIF endpoint") + count += 1 + if width > 1: + # In the retained reverse-arithmetic order, the later h=1 twiddle + # reads the already completed physical bit0. + old_opposite_counterexample = ((2*r >> 2)*1*1) % (2*r) + need(old_opposite_counterexample != 0, "Old opposite schedule control") + return count, old_opposite_counterexample + + +def layout_names(lengths, chunk, ell): + bottom = (ell-1) % chunk + prefix = [(axis, ell-1) for axis, width in enumerate(lengths) if width == ell] + prefix += [(axis, bit) for bit in range(bottom-1, -1, -1) + for axis in range(len(lengths))] + groups = [[(axis, bit) for axis in range(len(lengths)) + for bit in range(high, high-chunk, -1)] + for high in range(ell-2, bottom-1, -chunk)] + result = prefix+sum(groups, []) + need(len(result) == len(set(result)) == sum(lengths), "All named slots occur once") + return result, bottom, len(prefix) + + +def selected_offsets(): + cases = 0 + for ell in range(3, 13): + for chunk in range(1, ell): + for lengths in ([ell, ell-1], [ell-1, ell, ell-1], [ell]*4, [ell-1]*3): + names, bottom, head = layout_names(lengths, chunk, ell) + for bit in range(bottom, ell-1): + expected_offset = (bit-bottom) % chunk + group = (ell-2-bit)//chunk + for axis in range(len(lengths)): + position = names.index((axis, bit))-head + need(position//(len(lengths)*chunk) == group, + "Current axes are not in one chunk group") + need(chunk-1-(position % chunk) == expected_offset, + "Physical selected offset differs") + # The new opposite tail consists only of higher named slots. + for axis, width in enumerate(lengths): + need(all(names.index((axis, v)) != names.index((axis, bit)) + for v in range(bit+1, width)), "Tail includes current bit") + cases += 1 + return cases + + +def exchange(order, a, b, width): + need(a+width <= b or b+width <= a, "Overlapping fields") + for offset in range(width): + order[a+offset], order[b+offset] = order[b+offset], order[a+offset] + + +def check_rotation(): + total = 0 + for chunks in range(1, 9): + for width in range(1, 10): + length = chunks*width + # Separate X and Z by an unrelated three-bit field. + z = length+3 + for rho in range(width): + order = list(range(2*length+3)) + cut = (length-rho) % length + operations = [] if cut == 0 else [ + (0, z+length-cut, cut), (cut, z, length-cut), (0,z,length)] + for operation in operations: + exchange(order, *operation) + for old in range(0,length,width): + need(order[old+rho] == old, "Past selected name not at rho") + need(order[length:z] == list(range(length,z)), "Gap is not fixed") + # The selected-label identity gives conjugacy for every linear + # value map on these bits, not only their joint XOR. + active = [order[p] for p in range(rho,length,width)] + need(active == list(range(0,length,width)), "Ordered selected embedding") + for operation in reversed(operations): + exchange(order, *operation) + need(order == list(range(2*length+3)), "Literal inverse does not restore all names") + total += 1 + return total + + +def reserve_views(): + count = 0 + for copies in range(1,5): + for width in range(2,7): + active, past = 64*copies, 9*copies + group, length = active*width, past*width + for groups in (3,4,5): + total = groups*group + source = [j*width+width-1 for j in range(past)] + names = list(range(total)) + early = [(x,(groups-1)*group+j*width) for j,x in enumerate(source)] + for a,b in early: + exchange(names,a,b,1) + need([names[(groups-1)*group+j*width] for j in range(past)] == source, + "Completed names not in early reserve") + for current in range(groups-1): + neighbor = current-1 if current else 1 + need(neighbor not in (current, groups-1), "No distinct adjacent block") + before = names[:] + target = neighbor*group if neighbor > current else (neighbor+1)*group-length + exchange(names,target,(groups-1)*group,length) + need(names[target:target+length] == before[(groups-1)*group:(groups-1)*group+length], + "Past block not adjacent to active block") + exchange(names,target,(groups-1)*group,length) + need(names == before, "Temporary adjacent placement does not restore") + for a,b in reversed(early): + exchange(names,a,b,1) + need(names == list(range(total)), "Early reserve does not restore future names") + late = [(x,j*width) for j,x in enumerate(source)] + for a,b in late: + exchange(names,a,b,1) + need(names[group:] == list(range(group,total)), "Late reserve changes unfinished group") + for a,b in reversed(late): + exchange(names,a,b,1) + need(names == list(range(total)), "Late reserve inverse") + count += 1 + return count + + +def gadd(a,b): + return tuple(x+y for x,y in zip(a,b)) + + +def gmul(a,b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +ZERO = (F(0),F(0)) +ONE = (F(1),F(0)) + + +def padd(a,b): + return gadd(a[0],b[0]),gadd(a[1],b[1]) + + +def pmul(a,b): + low, high = gmul(a[0],b[0]),gmul(a[1],b[1]) + return (low[0]-high[0],low[1]-high[1]),gadd(gmul(a[0],b[1]),gmul(a[1],b[0])) + + +def matrix(a,b): + return [[padd(pmul(a[i][0],b[0][j]),pmul(a[i][1],b[1][j])) + for j in range(2)] for i in range(2)] + + +def twiddle_control(): + zero,one,y = (ZERO,ZERO),(ONE,ZERO),(ZERO,ONE) + a,b = ((F(1,2),F(1,2)),ZERO),((F(1,2),F(-1,2)),ZERO) + c,ci = [[a,b],[b,a]],[[b,a],[a,b]] + need(matrix(c,ci) == [[one,zero],[zero,one]], "Exact complex line inverse") + conjugates = [matrix(matrix(c,[[one,zero],[zero,y]]),ci), + matrix(matrix(ci,[[one,zero],[zero,y]]),c)] + for transformed in conjugates: + for row in transformed: + for u,v in row: + # In C[y]/(y^2+1), u+v*y is a unit when u^2+v^2 !=0. + need(gadd(gmul(u,u),gmul(v,v)) != ZERO, "Conjugate entry is not a unit") + permutation = [[zero,one],[one,zero]] + need(matrix(matrix(permutation,[[one,zero],[zero,y]]),permutation) + == [[y,zero],[zero,one]], "Permutation countercontrol") + return 8 + + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument("--workspace",type=Path,default=Path(__file__).resolve().parents[5]) + parser.add_argument("--out",type=Path,default=Path(__file__).with_name("REVIEW.json")) + args=parser.parse_args() + root=args.workspace.resolve(); lane=root/"work/centre-encoding-campaign-20261014/lanes" + for path,digest in FILES.items(): + need(sha256((lane/path).read_bytes()).hexdigest()==digest,"Research pin: "+path) + sources={} + for path,digest in GIT_FILES.items(): + raw=subprocess.check_output(["git","-C",str(root/"worktrees/k5-centre-sharing"),"show",REV+":"+path]) + need(sha256(raw).hexdigest()==digest,"Git source pin: "+path) + sources[path]=raw + assembly=json.loads(sources["research/community-frontier1094-audit/ASSEMBLY.json"]) + selected=json.loads(sources["certificates/selected-result.json"]) + need(selected["kappa"]==assembly["kappa"],"Selected assembly") + epsilon,c,kappa=map(F,[assembly["outer"]["epsilon_positive"],assembly["outer"]["c_positive"],assembly["kappa"]]) + need(epsilon-kappa>F(99,100) and 1-epsilon-kappa>0 and 1-epsilon*(1+c)>0, + "Selected asymptotic margins") + ports=json.loads((lane/"circuit-interface/INTERFACE.json").read_bytes())["ports"] + need(len(ports)==112 and len(set(ports))==112 + and all(0v coefficient is a multiple of 2r +and vanishes. Thus the exact matrix is F_plus B_inverse. The proof uses +the quotient ring directly and does not depend on a finite-field sample. + +For several axes, the exponents add and the scales multiply. A twiddle +for one axis is constant on each butterfly pair of another axis. The +axis steps therefore admit the stated parallel grouping. A later step +uses only its current slot and the higher slots. It does not use a lower +completed slot. A code on completed physical slots consequently commutes +with every later exact round. + +## Layout and numerical contract + +The new opposite visits named positions in increasing h, just as the +retained opposite does. For a chunk round, all axes use the same physical +offset `(h-b) mod K` in consecutive K-bit chunks. The butterflies do not +require equal current recursive lengths. The new exponent uses the +separate value `2^(a_i-h)` for each axis. This distinction is required +when long and short axes participate in the same round. + +The same prefix slots, chunk order, descriptor table, and L_inverse work +apply. Conjugating the new logical gate sequence by the retained L, then +restoring L, gives F_plus B_inverse L_inverse. No physical bit reversal is +inserted. An axis list with no long axes satisfies the same argument. + +Each new round is a normalized parallel butterfly followed by a signed +coefficient permutation. It is a contraction in the source norm. The +permutation commutes with componentwise truncation toward zero, so the +existing one-truncation-per-round proof applies. There are at most ell +rounds. The source error bound remains `sqrt(2) ell 2^-p`. Prefix rounds +use the existing exact dyadic width bound before their one truncation. +The exponent calculation still takes polynomial work in p per record; +the source lower bound on r absorbs this work in its linear record scan. +No layer call, chunk move, prefix move, or output width changes. The +source asymptotic time bound and convolution error proof therefore remain +valid for this changed opposite. + +This conclusion does not supply the precision proof for a code carried +through these rounds. Such a code can have a different norm and can need +additional precision. + +## Executed checks + +`review_opposite_prefix.py` is independent of the producer. It ran with +`python3 -I -O -B`. It checked 9,455 exact bit-coefficient identities and +27,988 complete matrix entries by root exponents in the polynomial ring. +The cases include unequal axis lengths. It also checked 455 retained +layouts and 3,510 common chunk rounds, including all-short axis lists. +The all-size conclusion rests on the proof above; these finite checks +protect its conventions. + +The checker rejects use of one common recursive length for long and +short axes. It also distinguishes F_plus B_inverse from F_plus. The +receipt is `OPPOSITE-PREFIX-REVIEW.json`. This review does not cover the +other theorems in the producer note. diff --git a/research/completed-prefix-outer/frozen/lanes/source-domain/review_opposite_prefix.py b/research/completed-prefix-outer/frozen/lanes/source-domain/review_opposite_prefix.py new file mode 100644 index 0000000000..e291939cd0 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/source-domain/review_opposite_prefix.py @@ -0,0 +1,128 @@ +"""Review the changed opposite transform with exact root exponents.""" + +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import subprocess + + +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +SOURCE = "upstream/build/sections/06-transforms.tex" +SOURCE_PIN = "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" +PROOF_PIN = "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5" + + +def require(ok, reason): + if not ok: + raise ValueError(reason) + + +def reverse(value, width): + return sum(((value >> j) & 1) << (width - 1 - j) for j in range(width)) + + +def path_phase(widths, x, y, r, common_width=False): + phase, offset = 0, 0 + for width in widths: + xx = (x >> offset) & ((1 << width) - 1) + yy = (y >> offset) & ((1 << width) - 1) + for h in range(width): + branch = (yy >> h) & 1 + phase += r * ((xx >> h) & 1) * branch + tail = sum(((xx >> v) & 1) << (width - 1 - v) for v in range(h + 1, width)) + denominator = 1 << ((max(widths) if common_width else width) - h) + phase += (2 * r // denominator) * branch * tail + offset += width + return phase % (2 * r) + + +def direct_phase(widths, x, y, r): + phase, offset = 0, 0 + for width in widths: + mask = (1 << width) - 1 + phase += (2 * r // (1 << width)) * reverse((x >> offset) & mask, width) * ((y >> offset) & mask) + offset += width + return phase % (2 * r) + + +def layout(widths, chunk, ell): + bottom = (ell - 1) % chunk + initial = [(i, h) for i, width in enumerate(widths) for h in range(width - 1, -1, -1)] + prefix = [(i, ell - 1) for i, width in enumerate(widths) if width == ell] + prefix += [(i, h) for h in range(bottom - 1, -1, -1) for i in range(len(widths))] + remaining = [slot for slot in initial if slot not in set(prefix)] + count = (ell - 1) // chunk + blocks = {(i, j): remaining[(i * count + j) * chunk:(i * count + j + 1) * chunk] + for i in range(len(widths)) for j in range(count)} + physical = prefix + [slot for j in range(count) for i in range(len(widths)) for slot in blocks[i, j]] + require(sorted(physical) == sorted(initial), "the retained L is a slot permutation") + positions = {slot: k for k, slot in enumerate(physical)} + checks = 0 + for h in range(bottom, ell - 1): + axis_positions = [positions[i, h] for i in range(len(widths))] + require(all(axis_positions[i + 1] - axis_positions[i] == chunk for i in range(len(widths) - 1)), + "the opposite round has consecutive equal-width chunks") + require(all((positions[i, h] - len(prefix)) % chunk == chunk - 1 - (h - bottom) % chunk + for i in range(len(widths))), "the common selected offset is unchanged") + checks += 1 + return checks + + +def main(args): + raw = subprocess.check_output(["git", "-C", str(args.repo), "show", REVISION + ":" + SOURCE]) + require(sha256(raw).hexdigest() == SOURCE_PIN, "original all-size transform source") + require(sha256(args.proof.read_bytes()).hexdigest() == PROOF_PIN, "reviewed proof snapshot") + entry_cases, coefficient_cases, layout_cases, round_cases = [], 0, 0, 0 + # This checks polynomial coefficients, without a finite-field specialization. + for width in range(1, 31): + r = 1 << width + for h in range(width): + for v in range(width): + direct = (2 * r // (1 << width)) * (1 << h) * (1 << (width - 1 - v)) + path = r if h == v else ((2 * r // (1 << (width - h))) * (1 << (width - 1 - v)) if h < v else 0) + require((direct - path) % (2 * r) == 0, "exact all-bit coefficient identity") + coefficient_cases += 1 + for widths in [(a,) for a in range(1, 7)] + [(3, 2), (3, 3), (4, 3), (2, 2, 1)]: + n, r = 1 << sum(widths), 1 << max(widths) + for x in range(n): + for y in range(n): + require(path_phase(widths, x, y, r) == direct_phase(widths, x, y, r), + "an exact polynomial-ring matrix entry differs") + entry_cases.append(dict(axis_log_lengths=widths, entries=n*n, normalization_denominator=n, root_modulus=2*r)) + for ell in range(2, 15): + for chunk in range(1, ell): + for widths in ((ell, ell), (ell - 1, ell - 1), (ell, ell - 1), + (ell - 1, ell, ell - 1), (ell, ell, ell - 1, ell - 1)): + round_cases += layout(widths, chunk, ell) + layout_cases += 1 + controls = [] + widths, r, n = (3, 2), 8, 32 + wrong = next((dict(x=x, y=y, correct=direct_phase(widths, x, y, r), + wrong=path_phase(widths, x, y, r, True)) + for x in range(n) for y in range(n) + if path_phase(widths, x, y, r, True) != direct_phase(widths, x, y, r)), None) + require(wrong is not None, "wrong common recursive length control") + controls.append(dict(name="same_twiddle_length_on_long_and_short_axes", witness=wrong)) + require(reverse(1, 3) != 1, "nontrivial bit reversal") + require(direct_phase((3,), 1, 1, 8) != 2, "wrong endpoint without input bit reversal") + controls.append(dict(name="omit_input_bit_reversal_in_endpoint_formula", x=1, y=1, + correct=direct_phase((3,), 1, 1, 8), wrong=2)) + result = dict(status="PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW", + revision=REVISION, source_path=SOURCE, source_sha256=SOURCE_PIN, + proof_sha256=PROOF_PIN, exact_bit_coefficient_cases=coefficient_cases, + exact_ring_entry_cases=entry_cases, layout_cases=layout_cases, + common_chunk_round_checks=round_cases, controls=controls, + proof_scope="All-size opposite schedule, exact F_plus B_inverse endpoint, retained L layout, long/short axes, and the original contraction/truncation/asymptotic cost proof", + not_claimed=["A changed encoded supplier", "A recursively closed past-space code", "An improved kappa", "The other theorems in the reviewed note"]) + args.out.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + print(json.dumps(dict(status=result["status"], coefficient_cases=coefficient_cases, + exact_entries=sum(c["entries"] for c in entry_cases), layout_cases=layout_cases, + common_chunk_rounds=round_cases), sort_keys=True)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + for name in ("repo", "proof", "out"): + parser.add_argument("--" + name, type=Path, required=True) + main(parser.parse_args()) diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.json b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.json new file mode 100644 index 0000000000..596e9841fe --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.json @@ -0,0 +1,89 @@ +{ + "active_source_coordinates": [ + 0, + 1, + 3 + ], + "actual_port": 11, + "actual_port_pin": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "arbitrary_replica_slices": 2, + "arithmetic": "Exact Gaussian integer pairs; theta is a separate signed permutation on polynomial coefficients; unitary-rescaled word denominators 8,32 and decoder denominator 256", + "axes": 3, + "bits_per_axis": 2, + "checker_sha256": "4de3ef39be0b90f367062930df69f7db3fe250c34e6d39ac30db2e6872b2b3ab", + "decoder_first_row_numerators_over_256": [ + [ + 0, + 128, + 0 + ], + [ + 21, + -128, + 0 + ], + [ + 42, + -64, + 0 + ], + [ + 47, + 64, + 0 + ], + [ + 59, + 64, + 0 + ], + [ + 62, + 64, + 0 + ], + [ + 171, + -64, + 0 + ], + [ + 174, + -64, + 0 + ], + [ + 186, + -64, + 0 + ], + [ + 191, + 64, + 0 + ] + ], + "decoder_nonzero_entries_per_row": 10, + "decoder_rows_checked": 256, + "decoder_squared_magnitude_counts": { + "1/16": 8, + "1/4": 2 + }, + "encoded_parity_class_counts": { + "1": 256 + }, + "formal_Gaussian_columns": 256, + "no_twiddle_control": "All 256 decoder rows have four entries of squared magnitude 1/4", + "ordinary_DIF_entries_checked": 65536, + "polynomial_coefficient_positions": 2, + "real_input_columns": 512, + "scope": "Stable port q, common exact T endpoint, current-bit H0 conversion, and the actual two-round length-four DIF twiddle. Other six local axes factor as the identity in the residual. This rejects one native C_r between monomial maps for this terminal residual. It does not bound arbitrary native-child words, changed layouts, changed endpoints, or a general multiplication algorithm.", + "source_H0_normalization": "Each literal H0 is H/2. Both complete source words equal one eighth of the unitary-rescaled word used here. This common factor cancels in U_raw U_code^-1.", + "source_pins": { + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "source_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "status": "PASS_EXACT_ACCUMULATED_TWIDDLE_CODE", + "unitary_Gram_entries_checked": 131072 +} diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.md new file mode 100644 index 0000000000..0eb025b14d --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/ACCUMULATED-TWIDDLE-CODE.md @@ -0,0 +1,226 @@ +# A complete-round code need not have a one-child terminal decoder + +## Exact result + +Assume that each complete native layer has the stable, portwise left +code + +``` +T = [[0,Q],[Q^-1,0]], Q = C_q^tensor(f). +``` + +The two slices can be two replicas or one fixed physical spectator bit. +They contain arbitrary input. This assumption is more favourable than +an endpoint with changing port labels or a dense data code. + +Even under this assumption, the actual synthetic FFT twiddles prevent +the accumulated code from being only a product of disjoint Q factors. +For the actual port `q=11`, two length-four DIF rounds give a terminal +decoder with ten nonzero entries in every row. Two entries have absolute +value `1/2`; eight have absolute value `1/4`. Thus this decoder is not +one native C tensor between monomial maps. + +The independent integer-Gaussian checker verifies all 256 formal complex +coefficient inputs of this example, or 512 real input columns. It keeps +the polynomial fourth root separate from the Gaussian unit i. It +verifies the ordinary DIF transform against its Fourier entries, both +complete unitary rescalings, and all 256 coefficient decoder rows. No +producer checker is imported. + +This does not exclude a decoder with several native children, a new +endpoint, a different outer transform, or a different recursive layout. +It invalidates the direct use of the disjoint-layer product theorem for +this accumulated FFT code. + +## The side of the H0 conversion + +Use the actual source conventions + +``` +C = ((1+i)I+(1-i)X)/2, +S = diag(1,i), +H0 = ((1-i)/2) S C S. +``` + +Let `C_all` be the tensor product on all current bits and let `S_all` +be the corresponding diagonal phase. T commutes with `C_all`, because +its Q factors and its line-square translations are functions of +commuting translations. Converting a native endpoint `C_all T` gives + +``` +H0_encoded = E H0, E = S_all T S_all^-1. +``` + +The actual current twiddle J follows the butterfly. The implemented +round is therefore `J E H0`. It is not `E J H0`. Codes on distinct bit +offsets commute with later raw butterflies, but this fact does not move +E past its own current twiddle. + +The small check retains this order exactly. The ordinary butterfly is +rescaled to a unitary matrix for the finite matrix calculation. The two +complete words have the same scalar rescaling, so it cancels in the +terminal decoder `U_raw U_code^-1`. In the three-axis, two-round example, +each source word is one eighth of the unitary rescaling used in the +checker. No normalization is omitted from the decoder. + +## A parity invariant for the complete word + +This invariant applies to any odd nonzero port q, not only to the small +example. Let `Z_q` multiply a current address by +`(-1)^(q dot x)`, and let `w` be the Hamming weight of q. Direct Pauli +conjugation gives + +``` +C_all Z_q C_all^-1 = (-i)^w X_q Z_q, +C_q Z_q C_q^-1 = -i X_q Z_q, +C_q^-1 Z_q C_q = i X_q Z_q. +``` + +Because w is odd, each of `C_all C_q` and `C_all C_q^-1` +conjugates `Z_q` to `Z_q` or `-Z_q`. The two signs are opposite. +The S phases commute with `Z_q`. Hence the encoded butterfly maps each +q-parity subspace to a single q-parity subspace. It does not mix the two +subspaces. + +For the actual weights three and seven, the plus-Q branch preserves +the parity and the minus-Q branch flips it. In the two-slice T word, +the exact class update is + +``` +z_out = z_in+1, +p_out = p_in+1-z_in (mod 2). +``` + +For a general odd weight there is one further fixed parity offset. +This does not change the subspace conclusion. For f tensor columns the +same rule holds for each of the f parity bits, with the same slice bit. + +Every twiddle is diagonal in the address bits, with a unit polynomial +coefficient. It preserves these parity subspaces. Later rounds act on +different bit offsets. Therefore a complete stable-port encoded word +permutes the joint parity classes for all completed offsets and the +slice bit. Each block is invertible. + +Suppose there are l complete bit rounds and f tensor columns. There +are `2^(f*l)` parity classes for each fixed slice. The ordinary raw FFT +has a nonzero unit entry from every input address to every output +address in that slice, up to its common dyadic normalization. For any +output row, its restriction to each parity block is a nonzero row. +Right multiplication by an invertible block cannot make that row zero. +Consequently the required terminal decoder has a nonzero entry in +each of these `2^(f*l)` input parity classes. + +This is a full-word statement. It does not assume that separate +per-round decoder words are used. + +## Exact two-round example + +The selected port list begins with `q=11`, supported on source axes +0, 1, and 3. The other six local axes factor out of the residual. It is +therefore enough to use three length-four axes and one arbitrary slice +bit, which gives 128 record addresses. Two polynomial coefficient +positions give 256 complex coefficient inputs. + +Write each length-four address as `x_low+2*x_high`. In the first DIF +round, apply the three high-bit H0 factors and then their output code +`S T S^-1`. Apply the actual twiddle + +``` +theta^(-sum_j b_high,j * x_low,j). +``` + +Then apply the three low-bit H0 factors and their output code. The +length-two twiddle is the identity. The corresponding uncoded word has +entries proportional to + +``` +theta^(-sum_j x_j * reverse_2(y_j)). +``` + +This calibration also fixes the DIF bit order. The polynomial fourth +root is `theta=y^(r/2)` and satisfies `theta^2=-1`. It is not identified +with the Gaussian unit i used in the native C kernel. On each pair of +coefficient positions separated by r/2, multiplication by theta is the +signed permutation `(a,b)->(-b,a)`. Thus the two-position check applies +to every such coefficient pair for any even record length r. + +The checker uses pairs of integers for every Gaussian number. The +unitary ordinary word has denominator 8; the encoded word has +denominator 32. Their decoder has denominator 256. Its first scalar +coefficient row has the following nonzero real numerators. Bits 0 +through 5 give the three addresses, bit 6 gives the slice, and bit 7 +gives the coefficient position: + +``` +0:128, 21:-128, 42:-64, 47:64, 59:64, +62:64, 171:-64, 174:-64, 186:-64, 191:64. +``` + +Every row has the same support and magnitude counts. With both twiddles +removed, the same checker gives four entries of equal magnitude in +every decoder row. That control isolates the effect of the actual +twiddle. + +## Why one native tensor is insufficient + +A native tensor of total rank r has exactly `2^r` nonzero entries per +complex address row. Each coefficient is a common power of `(1+i)` +times a Gaussian unit. On the real coefficient tape, the row support +is `2^r` when r is even and `2^(r+1)` when r is odd. Either count is a +power of two. The native frame adapters are monomial, so they do not +change the row support count. + +The example's coefficient matrix is real. Each scalar coefficient row +has exactly ten nonzero entries, +at ten distinct input record addresses. Left and right monomial maps +cannot turn this support count into a power of two. This rejects one +native C tensor between such maps, even if the maps permute scalar +coefficient addresses. It does not reject a sum or a product with +additional native children. + +## Consequence for a terminal pass program + +In a program of complete comparable-volume stream passes, a monomial, +COPY, SCALE, or CLEAR does not increase the number of input dependencies +of one output entry. A binary pointwise ADD can at most double that +number at one dependency depth. The complete parity lower bound +therefore requires at least `f*l` ADD depths for a terminal decoder in +this grammar. + +If each such pass scans volume comparable to V, this costs +`Omega(V*f*l)`. On the common rounds of the selected outer layout, +`f=Theta(d/73)` and `l=Theta(p/d)`, so the bound is `Omega(Vp)`. +It does not fit a positive saving below Vp. + +This cost statement does not apply to a recursive native child as if +that child were one free ADD pass. It does not cover varying-volume +subcalls, a new packed algorithm, or a different code that mixes the +parity classes before the terminal point. + +## Evidence and remaining obligations + +The packet is `check_accumulated_twiddle_code.py` and +`ACCUMULATED-TWIDDLE-CODE.json`. The receipt pins the actual port list +and the current selected-bit layer and transform sources. Run: + +``` +python3 -I -O -B work/centre-encoding-campaign-20261014/lanes/temporal-reuse/check_accumulated_twiddle_code.py +``` + +Expected status: + +``` +PASS_EXACT_ACCUMULATED_TWIDDLE_CODE +``` + +The all-size statements still assume a fixed port label, a common +physical slice convention, and the stated complete-layer T endpoint. +They do not infer those premises from a local centre identity. A +changing role assignment or a different encoded endpoint needs a new +proof. The opposite transform and any new decoder construction remain +separate tasks. + +The coherent-port lane supplied the conditional disjoint-layer product +identity. This packet checks why that identity alone does not give the +terminal code of the actual twiddled word. OpenAI Codex assisted this +work under the user's direction. No human review is claimed. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.json b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.json new file mode 100644 index 0000000000..ebcf9f8036 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.json @@ -0,0 +1,84 @@ +{ + "dif": { + "both_code_inverse_orders": true, + "completed_slots": [ + 2, + 5 + ], + "exact_transform_entries": 4096, + "later_round_commutators": 4, + "noncommuting_code_fusion_entries": 4096, + "prime": 97, + "record_dimension": 64, + "root": 8, + "root_order": 16 + }, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "not_claimed": [ + "A new complete supplier", + "A recursive encoded-child contract", + "A kappa improvement", + "A general circuit lower bound" + ], + "paired_current_line": { + "H0_diagonal_conjugation_checked": true, + "actual_ports": 112, + "all_size_statement": "The tensor support is 2^lambda by the exact unit proof.", + "current_line_is_not_a_twiddle_normalizer": true, + "line_square_is_a_permutation": true, + "paired_replica_columns": 114688, + "spatial_columns": 57344 + }, + "reversed_label_opposite": [ + { + "all_operator_entries": 4096, + "axis_log_lengths": [ + 3, + 3 + ], + "physical_bit_reversal_operations": 0, + "record_dimension": 64, + "remaining_round_commutators": 2, + "required_operator": "F_plus B_inverse" + }, + { + "all_operator_entries": 1024, + "axis_log_lengths": [ + 3, + 2 + ], + "physical_bit_reversal_operations": 0, + "record_dimension": 32, + "remaining_round_commutators": 2, + "required_operator": "F_plus B_inverse" + } + ], + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "scope": "Exact finite conventions and negative controls; all-size theorems are proved in the note.", + "selected_offset_endpoint": { + "all_addresses": 262144, + "chunk_width": 3, + "copies": 2, + "offset": 1, + "slots": 3, + "third_slot_and_other_offsets_fixed": true + }, + "source_sha256": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "status": "PASS_COMPLETED_PREFIX_CODES", + "whole_axis_row_prefix": { + "applies_to_both_transform_directions": true, + "axis_bits_available": "ell or ell-1", + "ell": "Theta(p/d)", + "margin_lower_bound": "99/100", + "one_axis_work_and_layout": "O(V ell)", + "padding_volume_factor": "less than two", + "row_bits_needed": "ceil(ceil(log_m d) log_2 W)=O(log d)", + "strict_margin_epsilon_minus_kappa": "1635654921950317604269246176697592893315360642164647696163717235784796569190497511406755693461406225762418838586331730835704915263244133189022659330234814818810892219059957239485707752007657731284696774507602551594083331891078337774583028045958975578287492520966716631023415709897216606029214103869146078792163164507055296177461882843051065083293106678283624262730067538295610766368389669754871598780028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000" + } +} diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.md new file mode 100644 index 0000000000..cbb65ac2b1 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.md @@ -0,0 +1,442 @@ +# Physical prefix codes and the current twiddle + +There is a nonmonomial code family which passes through the actual +remaining forward transform without a decoder. The code acts only on +frequency bits that the forward DIF procedure has already written. It +must act on those bits in the physical record coordinates. A scalar +matrix in a moving owner chart is not sufficient. + +The same property holds for a changed opposite procedure defined below. +The record layout, layer calls, cost order, and error bound of that +procedure are unchanged. This note does not supply a centre-saving +native layer or a recursively closed encoded child. + +The main application boundary is precise. The selected supplier's +charts act only on the current selected bit offsets. A code on those +bits is not yet a code on completed bits: it must first pass the current +twiddle. An exact criterion below permits a changed monomial twiddle +and rejects an individual odd-line code and the paired code `T=QA`. +It does not reject every complete encoded supplier. + +## Exact commutation + +Use the named slots and forward schedule in Section 06 of the pinned +source from [OUTER-ENCODING-INTERFACE.md](OUTER-ENCODING-INTERFACE.md). +After some complete rounds, let `P` be any fixed set of slots which +already contain frequency bits. Let `Z` contain the remaining slots +and the polynomial coefficient payload. In these logical slot +coordinates the rest of the forward computation is + +```text +I_P tensor T_Z. +``` + +To prove this statement, inspect one subsequent round. Its butterfly +changes one unprocessed slot in each participating axis. It does not +change or read `P`. Its twiddle exponent is + +```text +-sum_i (2r/u_i) b_i k_i modulo 2r. +``` + +Here `b_i` is the bit that this round has just written and `k_i` uses +only the lower, still unprocessed slots of axis `i`. No earlier branch +bit enters the exponent. Thus the butterfly and the twiddle both act +as the identity on `P`. Induction proves the factorization. Physical +layout permutations preserve the statement if the descriptor carries +the named slots with them. + +Consequently, for any linear map `A` on the `P` index, + +```text +(A tensor I_Z)(I_P tensor T_Z) + = (I_P tensor T_Z)(A tensor I_Z). +``` + +The equality holds over the polynomial coefficient ring, with arbitrary +data in all rows. It does not need a zero cache or independent values +in different rows. If `A` is invertible, it can remain until the end of +the forward transform and then be decoded. It need not preserve the +coordinatewise product, since decoding occurs before that product. + +At most two initial parallel rounds give a completed frequency bit on +every axis: one possible extra round on the long axes, then one common +round. Any fixed number `h` of these bits is then available when `d` +is large enough. These initial rounds can be evaluated by individual +butterfly kernels in `O(Vd)` time. The selected exact margin +`1-epsilon-kappa>0` permits this startup cost. Moving the fixed `h` +named bits to a physical prefix and restoring that prefix costs +`O(Vh)=O(V)` by the elementary stream moves. + +## Scalar role codes are already cheap + +A fixed scalar matrix on a fixed number of role streams is not a +new recursive interface. If those output streams have the same full +frame and the inverse has a fixed scalar word, apply that word at the +end of each invocation. Its `O(V)` work is already a node overhead. +There is no need to carry this code through the outer transform. + +The following fusion statement records what a physical prefix allows. +It does not turn a fixed scalar role code into a structural advance. + +## Fuse a finite alphabet of fixed-bank codes + +Fix `h` and put `w=2^h`. Let each subsequent layer leave a code `A_j` +on these same `h` completed slots. Assume all `A_j` belong to a fixed +finite alphabet in `GL_w(Z[i,1/2])`, and that the inverse of each +alphabet element is supplied over that ring. The codes can differ +between layers and need not commute with each other. They must be +fixed by the program, not by the input values. + +Since each code commutes with every later exact forward round, the +complete exact endpoint is + +```text +(A_last ... A_2 A_1 tensor I) T_forward. +``` + +There are `ell=Theta(p/d)` rounds. A common power of two clears all +denominators in the alphabet and its inverses. Matrix multiplication +then shows that every entry of the product and its inverse has +numerator bit length and denominator exponent `O(ell)`. For example, +if all row sums of absolute values are at most `M`, the product row +sum is at most `M^ell`. The fixed matrix dimension contributes only +a fixed factor to this bound. + +Generate the fused inverse before the data scan. This uses polynomial +work in `ell`, which the complete polynomial-record stream absorbs. +Apply that inverse with a fixed number of row buffers. A direct +shift-and-add multiplication by an `O(ell)`-bit fixed coefficient +costs `O(p ell)` per `Theta(p)`-bit component. There are a fixed +number `w^2` of coefficients. Thus the terminal decoder costs + +```text +O(V ell)=O(V p^(1-epsilon+o(1))). +``` + +It needs `O(ell)` extra exact grid and integer bits. An approximate +implementation also needs `O(ell)` extra precision for the product's +inverse norm. These bits are `o(p)` and do not change the record-width +exponent. They must be included in the new finite precision proof. +The selected condition `epsilon-kappa>0` makes this decoder smaller +than the target `V p^(1-kappa)` by a strict power. This uses the +dimension margin, rather than the different terminal tensor margin. + +The fused matrices need not be added as new physical field families. +They are fixed controller coefficients. The finite row buffers are +ordinary work streams in the outer machine and are charged in the +linear scans. They give no productive supplier credit. A proposed +native layer must still establish its own private and borrowed-state +contract. + +The input values in the `w` rows remain arbitrary. If a fixed role +count is not a power of two, embed its matrix as a block in `w` +rows and act as the identity on the other rows. This does not assert +that the existing recursive row allocation can use only these `h` +bits. It gives an endpoint type for a complete layer. Recursive +children and padding remain separate construction obligations. + +## Interface test for a proposed supplier + +A proposed whole-layer supplier can use this theorem if its physical +data map, in the outer layout, is + +```text +(A_j on the fixed completed prefix) tensor H_current +``` + +and its other fields satisfy the required arbitrary-state contract. +It must prove that `A_j` has no action on the active address bits, +lower unprocessed bits, or polynomial payload. Merely writing its +logical query operators as a matrix over a regular cover does not +prove this condition. A change from owner coordinates back to the +outer coordinates can act on the active payload, and the twiddle +depends on those coordinates. + +The current archive endpoint has active chart routes and residual +line frames. No physical completed-prefix factorization has been +proved for it. This theorem does not remove those obligations. + +The opposite procedure in the existing source is reverse arithmetic. +Its completed lower input bits can enter later twiddle exponents. +The forward proof therefore does not apply to that schedule as written. +The next section gives a different schedule with the same endpoint and +the same physical slot order. It permits completed-bit codes in both +directions. A new encoded supplier must still pass its current twiddle. + +## An opposite procedure with completed slots + +For one axis of length `t=2^a`, let `B=B_t` reverse the `a` address +bits. The plus-sign DIF procedure in its usual high-to-low slot order +has exact operator `B F_t^+`. This follows from the proof of synthetic +DIF in Section 06 with all root exponents negated. + +Now run that procedure with the physical bit names reversed. This is +a change of names in its gates, not an executed record permutation. +Its exact matrix in the original physical address order is + +```text +B (B F_t^+) B = F_t^+ B = F_t^+ B^-1. +``` + +That is exactly the required opposite consumer of the stored forward +order. At physical stage `h=0,1,...,a-1`, its operations are + +```text +H0 on physical slot h; +multiply the record by y^E, +E = (2r/2^(a-h)) x_h sum_(v=h+1)^(a-1) 2^(a-1-v) x_v mod 2r. +``` + +The selected slot increases from low to high, as in the retained +opposite schedule. After the butterfly, `x_h` is the new branch bit. +The displayed sum contains only unprocessed higher physical slots. +No previously completed lower slot occurs. Thus any code on completed +slots commutes with every later exact round. + +For several axes, add the displayed exponents over participating axes. +Different-axis butterflies and twiddles commute by the same argument +as in Section 06. Long axes have `a_i=ell`, short axes have +`a_i=ell-1`. At stage `h`, include exactly those axes with `h0` admits this cost. These bits can supply a fixed +positive fraction of the current layer dimension as past coordinates. +Their use as a native catalyst needs a separate supplier construction. + +## A whole completed axis supplies every recursive row digit + +There is also a row allocation which works in either direction without +changing the opposite schedule. Complete one whole synthetic axis +first. Transform factors on distinct axes commute, so this gives the +same exact full transform in either direction. The axis has +`a=ell` or `ell-1` bits. All later operations on other axes act as +the identity on its index. + +Individual butterflies and monomials on this axis cost `O(V ell)`. +Moving its `a` bits into one row prefix and restoring them costs the +same order by the elementary digit-move lemma. The new index may be +any arbitrary row value; the argument uses no independence assumption. +If the axis and the remaining axes are truncated separately after +each round, there are at most `2ell` truncations rather than `ell`. +The transform error bound then has an extra factor at most two. +One extra fractional bit covers this factor. This is a new precision +allowance; the original finite guard is not silently reused. One can +instead evaluate the first axis exactly on the `2^(-p-a)` grid and +truncate once at its end, since `a=O(ell)=o(p)` and all its rounds +are contractions. Neither option changes the time exponent. + +For a finite supplier with row radix `W`, dimension divisor `m`, and +depth at most `k0=ceil(log_m d)`, it is sufficient that + +```text +a >= ceil(k0 log_2 W). +``` + +The right side is `O(log d)`. The left side is +`Theta(p/d)=p^(1-epsilon+o(1))`, so the inequality holds for all +sufficiently large `p`. Add zero rows to the next multiple of +`W^k0`; the volume increases by less than two. Split the row field +by `u=Wg+w` at each recursive node, as in Section 05. Every resulting +role retains the full remaining active suffix. The original child +volume and fixed-tape stack arguments therefore still apply. + +This padding is done once. If an encoded procedure mixes original and +padded rows, retain the padded rows until its code has been inverted. +Only then discard the rows which are again zero. Ordinary unchanged +layers leave them zero at each layer boundary. Physical work fields +required by the supplier retain their original contracts and costs; +the row argument creates no extra productive credit. + +The added time is `O(V ell)=O(V p^(1-epsilon+o(1)))`. The selected +exact certificate gives `epsilon-kappa>99/100`, so this is strictly +below `V p^(1-kappa)`. No numerical threshold is asserted. Thus row +placement itself is not an obstruction to a whole-layer past-space +interface. The current twiddle and recursive child type remain +separate conditions. + +## Exact criterion at the current twiddle + +Fix one common round in which each selected axis has current length +at least four. Let `w` be a row-prefix index, `b` the current branch +bits, and `k` the still unprocessed bits. Suppose an invertible code +`E` acts on `(w,b)`, has complex scalar matrix entries, and fixes `k` +and the polynomial coefficient suffix. This includes the scalar, +cover, and complex-line operations under consideration here. + +For fixed `k`, let `D(k)` be the actual recordwise twiddle. To carry +`E` past the round, the replacement twiddle must be + +```text +D'(k) = E D(k) E^-1. +``` + +There is a recordwise monomial `D'(k)` for every `k` if and only if +each output row of `E` has nonzero entries in only one branch address +`b`. Different input row-prefix values at that same `b` may mix +densely. Invertibility then assigns exactly the full input-block rank +to each branch address. The new exponent is the old exponent at that +unique input branch address. + +For necessity, set one lower bit of axis `i` to one and all other +lower bits to zero. This gives a diagonal `D_i` with entries `1` and +`z_i=y^(-2r/u_i)`, according to `b_i`. From `E D_i=D'_i E`, a +nonzero complex entry in an output row determines its diagonal +`D'_i` entry. A row containing both values of `b_i` would force +`1=z_i`, which is false in `C[y]/(y^r+1)`. Do this for every axis. +For sufficiency, each row has one branch address, so that branch's +twiddle factor can be factored out of the entire row. + +Even an additional record permutation does not relax this criterion. +Indeed `D_i` satisfies `(D_i-I)(D_i-z_i I)=0`. Its conjugate does too. +In a monomial matrix, a permutation cycle of length at least three +would put nonzero entries of this polynomial in three different +positions of a row. A two-cycle would have off-diagonal term +`-(1+z_i)D'_i`. The coefficient `1+z_i` is a unit: `z_i` has +power-of-two order at least four and `z_i^(u_i/2)=-1`, so a finite +geometric sum gives its inverse with denominator two. Both cycle +cases are impossible. Thus the conjugate is diagonal. This statement +concerns record permutations with invertible polynomial monomial +weights, not arbitrary extra arithmetic. + +This is a restriction on changing only the monomial twiddle. A new +native or arithmetic twiddle algorithm is outside its scope. Axes +at current length two have no lower bits and are also outside the +necessity statement. + +## The actual odd line and paired code do not pass this test + +For an actual port `q`, put `C_q=aI+bX_q`, where +`a=(1+i)/2` and `b=(1-i)/2`. Each row uses both branch addresses +`x` and `x+q`. Pick any coordinate in the support of `q` and a +nonterminal common round in the retained layout, where these are +current selected coordinates. The criterion excludes a recordwise +replacement twiddle for `C_q` or `C_q^-1`. + +The conversion from `C^tensor(D)` to `H0^tensor(D)` is +`b^D S_D C^tensor(D) S_D`, as stated in Section 05. The diagonal +`S_D` changes the two coefficients by nonzero phases and does not +change their branch support. The same test therefore applies after +the actual butterfly conversion. At a cover vertex `g`, replace +`q` by the nonzero vector `gq`; some current coordinate still differs. + +For the paired candidate, write + +```text +T = [[0,Q],[Q^-1,0]], Q=C_q^tensor(lambda), T^2=I. +``` + +Its two block rows still mix branch addresses. In particular, + +```text +T diag(D,D) T = diag(Q D Q^-1, Q^-1 D Q). +``` + +For a one-line factor with `D=diag(1,t)` and `t^2=-1`, both entries +in each row of either conjugate are nonzero units. The identity +`(1-t)(1+t)=2` proves this in the polynomial ring. In `lambda` +independent copies, one column has `2^lambda` nonzero record +dependencies. Row-prefix permutations and the `S_D` phases cannot +remove them. Involutivity by itself does not give a cheap past code. + +The associated `A=[[0,I],[Q^2,0]]` is a record permutation and does +pass the criterion, with a changed address exponent. No cited native +packet is claimed to return the complete endpoint `A` alone. Also, +this test on one factor does not exclude cancellation in a complete +encoded endpoint. If a new construction places the full support of +every relevant `q` in already completed coordinates, these line maps +commute with the current twiddle. Such a construction is outside the +obstruction. Its actual cover, routes, and recursive child dimensions +must satisfy that placement; changing a name does not establish it. + +## Recursive children remain a separate boundary + +Using old certified children inside a changed top-level layer does +not improve the recursive exponent. A replacement child must also +compose inside its parent word. If the old transition from frame `U` +to frame `V` is `F`, and the proposed field codes are `E_U,E_V`, the +required physical transition is + +```text +E_V F E_U^-1. +``` + +It is not in general the child map `E_child F`. The parent scalar +accesses must have equal codes on their source and target fields, +and each routed frame transition must have the displayed type and +a complete native cost. A code on address bits completed only by +the *outer* round need not commute with these intervening parent +operations. The whole-axis row allocation does not prove this +condition. A fixed scalar role-only code with common full endpoints +can instead be removed by the cheap per-invocation inverse described +above; that special case needs no new recursion theorem. + +## Exact check and scope + +`check_completed_prefix_codes.py` uses no producer imports. It reads +the pinned Sections 02, 05, 06, selected certificate, and assembly. It constructs an +actual two-axis length-eight DIF example over the exact field `F_97`, +with `y` of order sixteen and `2^-1` as the butterfly scale. It checks +every matrix entry for all remaining rounds and a nonmonomial code +on the two completed high slots. It also checks two noncommuting +codes inserted at different rounds and both inverse orders. The new +opposite is compared with all entries of `F_plus B^-1` for axis +lengths `(8,8)` and `(8,4)`, including completed-slot commutators. +The checker tests all 57,344 local spatial columns for the 112 actual +ports, both paired orientations, and the actual diagonal `H0` phases. +It also tests all 262,144 addresses of a small selected-offset chart +and its inverse, including untouched chunk bits and the third slot. +The finite +example verifies the implementation convention; the all-size +commutation and cost claims follow from the proof above. + +Run: + +```text +python3 -I -O -B check_completed_prefix_codes.py +``` + +Expected first line: + +```text +PASS_COMPLETED_PREFIX_CODES +``` + +The result gives an exact opposite schedule and a usable completed +row prefix. It also gives a precise current-twiddle obstruction for +the odd-line and paired-code proposals. It does not claim that an +existing changed native word has a recursively closed encoded +endpoint, or that a full new multiplication construction has been +completed. It was prepared with OpenAI Codex assistance. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.json b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.json new file mode 100644 index 0000000000..ab0fb1d605 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.json @@ -0,0 +1,212 @@ +{ + "assembly_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "decoded_round_error": "n 2^(number_of_past_bits/2) eta", + "h_powers": [ + [ + [ + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ], + [ + [ + [ + "1/2", + "1/2" + ], + [ + "1/2", + "1/2" + ] + ], + [ + [ + "1/2", + "1/2" + ], + [ + "-1/2", + "-1/2" + ] + ] + ], + [ + [ + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ], + [ + [ + [ + "-1/2", + "1/2" + ], + [ + "-1/2", + "1/2" + ] + ], + [ + [ + "-1/2", + "1/2" + ], + [ + "1/2", + "-1/2" + ] + ] + ], + [ + [ + [ + "-1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ] + ] + ], + [ + [ + [ + "-1/2", + "-1/2" + ], + [ + "-1/2", + "-1/2" + ] + ], + [ + [ + "-1/2", + "-1/2" + ], + [ + "1/2", + "1/2" + ] + ] + ], + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + ], + [ + [ + [ + "1/2", + "-1/2" + ], + [ + "1/2", + "-1/2" + ] + ], + [ + [ + "1/2", + "-1/2" + ], + [ + "-1/2", + "1/2" + ] + ] + ], + [ + [ + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "native_supplier_hypothesis_verified": false, + "odd_power_row_norm": "2^(number_of_past_bits/2)", + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "scalar_identity": "S C S = (1+i) H0", + "scope": "Exact scalar normalization and selected outer inequalities; the closure proof is conditional.", + "status": "PASS_FIXED_PAST_OUTER_NORMALIZATION", + "tensor_period": 8, + "terminal_decoder_cost": "O(V d)" +} diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.md new file mode 100644 index 0000000000..c2e2208eed --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/FIXED-PAST-OUTER-CLOSURE.md @@ -0,0 +1,168 @@ +# Close a fixed-past supplier at the outer consumer + +This note states the outer contract for the fixed-past construction +family under investigation. The outer steps are explicit. The native +supplier and its recursive cost are hypotheses, not conclusions. + +Use the selected parameter family and sources pinned in +[COMPLETED-PREFIX-CODES.md](COMPLETED-PREFIX-CODES.md). Let `A` be the +current active selected bits and `P` be one fixed set of completed +named bits, disjoint from `A` and from every later active selected +bit. The number `|P|` is `O(d)`. Let + +```text +H0 = (1/2) [[1,1],[1,-1]], +S = diag(1,i), +h = S C S = (1+i) H0. +``` + +The scalar identity uses the actual complex `C` of the source. +It gives `h^2=iI` and `h^8=I`. Put `h_P=h^tensor(|P|)`. + +## Required native contract + +For every size admitted by the recursion, the proposed whole-layer +procedure must compute + +```text +h_P tensor H0_A +``` + +on every productive row, in the same physical named coordinates. +It must satisfy its stated contract on all other arbitrary fields. +The past block must be the same in every common outer round. The +procedure must include its preparation, coordinate maps, phases, +storage, restoration, children, and finite guard. Its recursive +invoice must already be proved. + +For a procedure that returns `C_P tensor C_A`, the ordinary phase +conversion gives the required map: apply `S` on all selected bits +before and after it, and use scalar `b^|A|`, where `b=(1-i)/2`. +Do not use `b^(|P|+|A|)`. The latter would normalize the past factor +to `H0_P` and introduce an unnecessary repeated scale. The ratio +between the two choices is + +```text +(1+i)^|P| = 2^floor(|P|/2) i^floor(|P|/2) (1+i)^(|P| mod 2). +``` + +It is one exact power-of-two scaling and at most one fixed complex +scaling. Its width and prefix effect must be included in the guard. +This identity changes no native child dimension. + +The contract does not follow merely by projecting an old child +rank onto the active coordinates. In particular, all old rank-zero +routes must still have legal and priced transitions after a past +frame is omitted. A row-dependent change of chart is not a proof +of that condition. + +## Exact outer endpoint + +In the forward procedure, select the completed bits after the initial +one or two rounds. In the changed opposite procedure from the cited +note, select them after its first common round. In both cases every +remaining common round has butterfly and twiddle supported outside +`P`. Therefore `h_P` commutes with each such exact round. + +If `n` common rounds use the native contract, the resulting operator +is exactly + +```text +h_P^n T, +``` + +where `T` is the required unencoded transform, including the retained +record layout. The initial preparation rounds are included in `T`. +In the opposite direction, evaluate the final long-only round +individually. Its selected slots are disjoint from `P`, so it commutes +with the carried code too. This costs `O(Vd)`. + +Decode `h_P^n` once before each forward pointwise product and once +after the opposite procedure. Because `h_P^2=i^|P| I`, an even power +needs only a scalar fourth-root phase. An odd power needs one past +Walsh tensor and a scalar phase. Individual selected-bit kernels, +with the two `S` phases, implement that tensor in `O(V|P|)` time. +Every underlying bit has its complete two-element range. Thus the +decoder works on arbitrary productive rows, not on a special input +subspace. + +After decoding, the source's pointwise polynomial product and its +normalization are used unchanged. No nonmonomial code is passed +directly to that product. The opposite procedure consumes the exact +stored order described in the cited note. + +## Error and precision + +The past tensor is not a contraction in the coefficient maximum +norm. For every integer `j`, however, + +```text +||h_P^j||_infinity <= 2^(|P|/2). +``` + +For even `j`, it is a scalar phase times the identity. For odd `j`, +each row has `2^|P|` entries of modulus `2^(-|P|/2)`. This proves +the displayed bound, independently of the number of rounds. + +Suppose each implemented complete round has additive error at most +`eta` in that norm. The remaining exact active rounds are +contractions and commute with `h_P`. After the final exact decoder, +the error injected in round `j` is multiplied by a past power +`h_P^-j` and an active contraction. Consequently the total decoded +error from the `n` rounds is at most + +```text +n 2^(|P|/2) eta. +``` + +An `O(d)` extra fractional-bit reserve therefore covers the code's +condition number. The factor `n` is the usual transform round count. +The encoded values need `O(d)` extra integer bits. An exact odd-power +decoder adds at most `|P|` dyadic denominator levels, so its exact +temporary width also increases by `O(d)`. Since `d=o(p)`, all these +widths remain `Theta(p)`. + +The native procedure must supply its own prefix and approximation +bound for inputs of this guarded magnitude. That is a material +hypothesis. Once that bound is supplied, the displayed calculation +propagates its error to the unchanged outer consumer. It does not +reuse the old finite guard without a check. + +## Layout and time + +The initial individual rounds and the terminal decoder cost +`O(Vd)`. The selected exact margin `1-epsilon-kappa>0` admits this +term. The opposite procedure has the same named-slot order and +asymptotic layer/layout invoice as before; its changed monomial is +an exact signed coefficient shift. + +If row-role codes must use completed coordinates too, a separate +completed whole axis supplies all recursive row digits at cost +`O(V ell)`, with `ell=Theta(p/d)`. Its precision allowance is stated +in the cited note. Exclude that axis from the active and past +payload coordinates; no bit serves both roles. The selected +inequality `epsilon-kappa>0` admits this additional term. + +[PAST-CATALYST-LAYOUT.md](PAST-CATALYST-LAYOUT.md) gives a physical +common-offset wrapper when the fixed-past native word fixes the +required spectator block. For the proposed active/past ratio +`64:9`, it uses no extra address bits or complex children. It adds +a fixed number of admitted bit interchanges per invocation and +`O(d)` single-bit placements per complete transform. The updated +finite compact-engine and hosting invoice is still required. + +Thus a supplier meeting the native contract has an explicit outer +path through both transform directions, the product, and final +decoding. Its extra top-level work has the already admitted orders +`O(Vd)` and `O(V ell)`. There is no additional factor of the number +of rounds multiplying the `O(Vd)` decoder term. + +This is a conditional closure theorem for an actual construction +family. It resolves the outer consumer, offset, and opposite-order +questions. It does not prove that the retained cover preserves a +proper past subspace, that an active child profile improves, or that +an encoded child composes recursively. The campaign's fixed-past +lane is checking those remaining requirements. No supplier or +kappa improvement is claimed here. + +Prepared with OpenAI Codex assistance. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/OUTER-ENCODING-INTERFACE.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/OUTER-ENCODING-INTERFACE.md new file mode 100644 index 0000000000..aede9af544 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/OUTER-ENCODING-INTERFACE.md @@ -0,0 +1,325 @@ +# Encoded endpoints at the multiplication interface + +The outer algorithm does not require the natural order of Fourier +coefficients. It already retains two record permutations. It does require +the correct coordinatewise product before the opposite transform. A +general invertible code cannot pass through that product without work. + +There is a useful change of interface. A fixed tensor-word code can be +decoded once at the end of a complete transform within the selected +asymptotic budget. This statement does not permit a decoder at every +butterfly layer. The unresolved construction problem is to carry the code +through the intervening layers and twiddles, with a bounded final word. + +## 1. Source boundary + +The source snapshot is commit +`3ae9a6f3ac74ded022ab3b4872a7357a621af6fb` of +`CrocSwap/integer-mult-bounds`. The selected certificate is still +[PR1094](https://github.com/CrocSwap/integer-mult-bounds/pull/1094), with +`kappa = 836330098538459/500000000000000000`. This note does not change +that selection. The checker pins the certificate, its review, the +selected replay archive, and the following source files. + +- [The simultaneous layer](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/upstream/build/sections/05-layers.tex) + uses the finite supplier for `C` tensor powers. It obtains rows from + existing data by a radix split. Every productive role can contain an + arbitrary input. The exact child contract acts on every role. The + padding rows can be removed only after their correct output is zero. +- [The synthetic transform](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/upstream/build/sections/06-transforms.tex) + places a twiddle after each forward parallel layer. The stored forward + map is `L B F^-`; its opposite consumes that order as + `F^+ B^-1 L^-1`. The common record permutation passes through the + coordinatewise polynomial product. +- [The source transform](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/upstream/build/sections/07-resampling.tex) + retains a permutation `R`. Its convolution identity explicitly uses + the same permutation on both forward outputs. +- [The final assembly](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/upstream/build/sections/08-assembly.tex) + transforms both operands, multiplies corresponding complex + coefficients, then uses the opposite transform and fixed scales. +- [The selected outer engine](https://github.com/CrocSwap/integer-mult-bounds/blob/3ae9a6f3ac74ded022ab3b4872a7357a621af6fb/research/complex-sw4-frame8/vendor/main/research/complex-k492-owner-repair/vendor/multicold/engines/outer.py) + gives the current balanced-prefix parameters and strict margins. The + older numerical constants in the upstream exposition are not the + selected numerical parameters. + +The local names `X` and `Y` are supplier role banks. They are not the two +integer operands. Mixing these banks mixes records of one transformed +operand. The same record code would then act separately on both integer +operands. + +All results below are exact identities before truncation. The selected +all-size, compiler, hosting, precision, tape, analytic, and bit-supplier +assumptions remain in force. A changed complete program also needs its +own precision and cost proof. + +## 2. The unchanged product allows only a common monomial code + +Let `a,b` be arbitrary vectors in `C^n`. Let `E,F` be invertible linear +codes on the two operands. Suppose an invertible linear map `D` satisfies + +```text +D ((E a) pointwise-multiply (F b)) = a pointwise-multiply b +``` + +for every `a,b`. Then there are a permutation matrix `P` and invertible +diagonal matrices `D_alpha,D_beta` such that + +```text +E = D_alpha P, F = D_beta P, +D = P^-1 (D_alpha D_beta)^-1. +``` + +To prove necessity, take distinct coordinate vectors `e_i,e_j`. Their +product is zero. Since `D` is injective, each row `r` satisfies +`E_ri F_rj=0` for `i != j`. Both rows are nonzero. If their supports +contain `i` and `j`, this equation forces `i=j`. Thus each row has one +nonzero entry and the two row supports agree. Invertibility makes their +common support map a permutation. The case `i=j` gives the stated `D`. +Substitution proves sufficiency. + +The result permits different scalar codes on the two operands. If the +same code is used on both, its scales are squared at the product. Merely +applying `E^-1` after the product is generally incorrect. Reciprocal +operand scales or an explicit product scale can correct them. + +The same conclusion holds if the final decoder mixes polynomial +coefficients, provided it is invertible and the operand codes act by +the same complex scalar matrix on each coefficient. Use constant +polynomials in the necessity proof. This is the actual coefficientwise +supplier setting. The ring `C[y]/(y^r+1)` has zero divisors; this note does +not classify all linear codes over that ring. In particular, a common +ring automorphism, such as a permitted `y -> y^k`, is a separate +compatible operation with its own implementation cost. + +There is also a coupled-operand version. Suppose an invertible linear +map on `(a,b)` supplies `n` pairs of linear forms `(u_j,v_j)`, and an +invertible linear decoder maps their `n` products to all `a_i b_i`. +Then each pair is, up to nonzero scales, `(a_i,b_i)` or `(b_i,a_i)`, with +one permutation of `i`. Indeed each `u_j v_j` is in the span of the +`a_i b_i`. Its quadratic-form rank is at most two. A nonzero sum of +`k` different `a_i b_i` has rank `2k`. Thus `k=1`; unique factorization +of polynomials gives the two stated factors. This also excludes an +arbitrary borrowed input from either factor. There is no claim for +extra products, a restricted input subspace, or a nonlinear decoder. + +## 3. Two actual failures of direct product compatibility + +For an odd nonzero binary line `q`, the intrinsic line operator is + +```text +C_q = a I + b X_q, a=(1+i)/2, b=(1-i)/2. +``` + +The inputs `delta_0` and `delta_q` have disjoint support, but + +```text +(C_q delta_0) pointwise-multiply (C_q delta_q) + = (delta_0+delta_q)/2. +``` + +The same failure holds for `C_q^-1`. No invertible linear opposite +consumer can map this nonzero product to zero. By contrast, `C_q^2=X_q` +and `C_q^4=I` are permutations. The diagonal `S` factors that convert +`C` into the outer `H_0` layer do not change this support test. The +checker verifies the test for all 112 actual supplier ports. + +The proposed archive controller has a second witness. Use its frozen +[ordered rules](../encoded-controller/QQ16-ARCHIVE-CONTROLLER.md). +In the sector constant in both cover and address, fix one query +coordinate and write each bank as `(u,a,t)` along the three disjoint +port sets `(U,A,T)`. The actual Gram identities are +`R_U K_U=12I`, `R_A P_A=I`, and `R_T P_T=I`. The full nine-call word, +with its retained ordinary terminal, has + +```text +final X_A,0 = P_A (12 u_0+a_0+t_0). +``` + +Take one operand supported on `K_U e_k` in original `X_U,0`, and the +other on `P_A e_k` in original `X_A,0`. Their original coordinatewise +product is zero because `U` and `A` are disjoint. At the displayed +output their product is `12 (P_A e_k)^2`, entry by entry, and is nonzero. +For `k=0`, the first A port gives `3/4`. The independently reconstructed +24-coordinate endpoint agrees with every entry of the frozen receipt, +for both the base and exposed-driver variants. + +This is a compatibility test of the proposed logical endpoint. It does +not certify the new whole global native program. Conversely, lack of +that native certification is not used as a reason to reject the logical +code. The displayed code itself does not preserve the unchanged +product. A new product algorithm or an explicit decoder remains possible. + +## 4. An odd line code does not pass through the actual twiddle as a rename + +Take one axis at current synthetic length four and fix its lower index +bit to one. The actual twiddle in Section 06 is `diag(1,t)`, where +`t=y^(-r/2)` and `t^2=-1`. On a `q` orbit with that axis in `q`, direct +multiplication gives + +```text +C diag(1,t) C^-1 = (1/2) [[1+t, i(1-t)], + [-i(1-t), 1+t]]. +``` + +All four entries are units in the polynomial ring, since +`(1-t)(1+t)=2`. For `lambda` independent tensor columns, choose the same +legal lower-bit setting in one axis per column and zero in the other +axes. The conjugated twiddle has `2^lambda` nonzero record entries in +each row of this subcube. The entries are products of units, so zero +divisors do not remove the support. + +A monomial operation preserves the support size of a dependency row. +A binary ADD can at most double it along a dependency path. Therefore +a fixed finite word of monomial operations and binary ADDs cannot +implement these transported twiddles for all positive `lambda`; the +maximum ADD depth must be at least `lambda`. This includes arbitrary +borrowed inputs, since the exact target rows must have zero coefficients +on those inputs. It is not a native-child lower bound or a lower bound +against recursive or size-dependent programs. It isolates the failure +of the proposed free frame transport. + +## 5. A terminal decoder can be affordable + +Here is a sufficient interface theorem. Let the complete stored forward +transform be `T_-`, and let `T_+` be its correct opposite consumer, +including the retained layout permutations. Suppose new complete +procedures compute `E_- T_-` and `E_+ T_+`. Suppose: + +1. Both codes have explicit inverses as fixed finite tensor words. + Their number of scalar gates, charts, and tensor factors is + independent of the transform size. Their fixed-width scalar maps + are dyadic units; their binary charts have a fixed-size base matrix. + A tensor factor acts on at most `O(d)` selected bits. +2. All address and source accesses have the retained stream interface. + Charts on full `K`-bit chunks use the admitted packed coordinate-map + engine. Selected-bit-only charts can use elementary split/merge + kernels. The data record width is `Theta(p)` and `dK=o(p)`. +3. The encoded procedures satisfy the required contract on every other + physical field. The inverse words preserve arbitrary borrowed state. + The number of complete transforms is fixed. + +Then decode each forward result once, perform the original pointwise +product, run the encoded opposite, and decode once more. This gives the +same exact multiplication computation. The added time is + +```text +O(V (d + (dK)^tau)), +``` + +where `V` is logical bit volume and `tau=1-a` is the retained bit +exponent. The added exact denominator depth and logarithmic prefix +norm are `O(d)`. These are extra precision obligations, not free gates. + +For the time bound, apply each tensor `C` or `C^-1` by the individual +selected-bit kernel in Section 05. Each kernel includes its split, +arithmetic, merge, counters, and cleanup, and costs `O(V)` per bit. +The fixed number of full-chunk binary charts costs +`O(V((dK)^tau+1))` by the same retained coordinate-map interface used +by the supplier. The scalar scans cost `O(V)`. A selected-bit-only +linear chart can instead be factored into `O(d)` two-bit operations. +Split into its four bit classes, permute those streams, and merge; +the complete ranges give the same residual address order in each +stream. These are `O(V)` operations under the same record and counter +bounds. No array access is free in either argument. + +Each exact tensor kernel adds a bounded denominator depth and a bounded +logarithmic norm. Each fixed scalar word adds a constant. Hence `O(d)` +extra exact grid bits suffice for the decoder. If approximate transforms +are used, their error target must also include this inverse norm. An +extra `O(d)` fractional-bit reserve suffices for that bound. Since +`d=o(p)`, the record width remains `Theta(p)` and the exponent is +unchanged. A new finite guard and final rounding proof are still needed +for a concrete program. This theorem does not silently reuse the old +finite guard value. + +For the selected parameters, `d=p^(epsilon+o(1))` and +`K=p^(epsilon c+o(1))`. The exact certificate gives + +```text +1-epsilon-kappa > 5/10^19, +a-kappa > 28/10^7, +1-epsilon(1+c) > 0. +``` + +Thus both terms in the added invoice are +`o(V p^(1-kappa))`, even with fixed logarithmic factors. This is an +asymptotic conclusion. The first margin is very small and gives no +practical threshold. + +There are two limits. First, the supplier returns one parallel layer, +not a complete transform. The full synthetic transform has +`ell=log2(r)=Theta(p/d)` rounds. Here `K` is the packed chunk width; +it is not the number of rounds. A direct decoder after every round +has an `O(V ell d)=O(Vp)` tensor-kernel term. This particular upper +bound does not prove the selected target `O(Vp^(1-kappa))`. This is +a failed invoice, not a lower bound. Second, transporting a code +across many rounds may make its inverse word grow with `ell`, or +make a tensor factor act on `Theta(p)` bits. Mere invertibility does +not meet hypothesis 1. A bounded propagation law or a different +complete-transform construction is needed. + +The archive controller has an explicit finite logical inverse. That is +a reason to pursue such propagation. It does not yet supply it, and +Sections 3 and 4 explain why the unchanged consumer does not do so. + +## 6. The selected roles cannot all be removed from the ledger + +The original selected replay gives `W=14336` productive families, +`m=73`, and paid rank mass `1041408`. Its rank mass deficit is `5120`. +For a positive saving `b`, the moment condition for `W-k` productive +families requires + +```text +sum_r h_r (r/m)^(1-b) < W-k. +``` + +Since every paid `r` is strictly between zero and `m`, this implies +`sum_r r h_r < m(W-k)`. This necessary condition uses the complete +recursive profile, not only a local child count. + +Grant the removal of every rank-eight child for free: there are +`1152=144*8`, with total rank mass `9216`. The remaining mass is +`1032192`, and `mW-1032192=14336`. Consequently `k` can be at most +`196`. There are `8*8*16=1024` A families in the eight banks of sixteen +replicas; A and T together use `2048`. Discarding all these A outputs +therefore fails even this favorable unchanged-profile screen. + +This statement does not cover a different child profile, a different +row layout, partial subspace productivity, or children omitted because +a new source is known to be zero. Those changes need a new supplier +and invoice. Arbitrary old selected inputs cannot be declared zero. + +## Verification and next construction target + +Run: + +```text +python3 -I -O -B check_outer_encoding_interface.py +``` + +Expected first line: + +```text +PASS_OUTER_ENCODING_INTERFACE +``` + +The checker uses exact rational arithmetic. It reads pinned Git objects +and pinned campaign evidence. It rebuilds the complete archive sector +from numerical local block matrices and the source schedule, then +compares both full endpoints and inverses. It checks the actual Gram +identities, all 112 odd-line witnesses, the exact twiddle identity in +`Q[i,t]/(i^2+1,t^2+1)`, the selected asymptotic margins, and the full +rank-mass screen. It does not import a producer checker. The general +classification and stream-cost theorem are proofs in this note; a +finite computation does not replace them. + +The next positive target is precise: construct a bounded-size family of +codes which contains a useful centre-saving endpoint, has a proved +transport rule through the actual butterfly and twiddle rounds, and +has a fixed tensor-word terminal decoder. Then the outer assembly can +pay that decoder once. The present archive endpoint and odd line frame +policies do not yet meet this target. No new supplier, kappa improvement, +or general multiplication lower bound is claimed. + +This work uses the selected community construction and the campaign's +archive controller. It was prepared with OpenAI Codex assistance. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.json b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.json new file mode 100644 index 0000000000..abc845bb97 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.json @@ -0,0 +1,1016 @@ +{ + "added_native_children": 0, + "chunk_group_margin": "2463090156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "extra_address_bits": 0, + "fixed_slot_order_maps": "At most the fixed number of native slots", + "initial_and_final_bit_moves": "O(d) per transform", + "interchanges_for_nonadjacent_past_block": 2, + "interchanges_per_offset_alignment": 6, + "not_claimed": [ + "The fixed-past cover condition", + "The active child profile", + "The selected finite compact-engine invoice", + "Recursive encoded-child closure", + "A kappa improvement" + ], + "per_invocation_time": "O(V ((eK)^tau+1)) under the cited chunk-swap interface", + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "rotation_cases": [ + [ + 1, + 1, + 0 + ], + [ + 1, + 2, + 0 + ], + [ + 1, + 2, + 1 + ], + [ + 1, + 3, + 0 + ], + [ + 1, + 3, + 1 + ], + [ + 1, + 3, + 2 + ], + [ + 1, + 4, + 0 + ], + [ + 1, + 4, + 1 + ], + [ + 1, + 4, + 2 + ], + [ + 1, + 4, + 3 + ], + [ + 1, + 5, + 0 + ], + [ + 1, + 5, + 1 + ], + [ + 1, + 5, + 2 + ], + [ + 1, + 5, + 3 + ], + [ + 1, + 5, + 4 + ], + [ + 1, + 6, + 0 + ], + [ + 1, + 6, + 1 + ], + [ + 1, + 6, + 2 + ], + [ + 1, + 6, + 3 + ], + [ + 1, + 6, + 4 + ], + [ + 1, + 6, + 5 + ], + [ + 1, + 7, + 0 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 7, + 4 + ], + [ + 1, + 7, + 5 + ], + [ + 1, + 7, + 6 + ], + [ + 2, + 1, + 0 + ], + [ + 2, + 2, + 0 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 0 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 3, + 2 + ], + [ + 2, + 4, + 0 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 4, + 2 + ], + [ + 2, + 4, + 3 + ], + [ + 2, + 5, + 0 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 5, + 2 + ], + [ + 2, + 5, + 3 + ], + [ + 2, + 5, + 4 + ], + [ + 2, + 6, + 0 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 6, + 2 + ], + [ + 2, + 6, + 3 + ], + [ + 2, + 6, + 4 + ], + [ + 2, + 6, + 5 + ], + [ + 2, + 7, + 0 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 7, + 2 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 7, + 4 + ], + [ + 2, + 7, + 5 + ], + [ + 2, + 7, + 6 + ], + [ + 3, + 1, + 0 + ], + [ + 3, + 2, + 0 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 3, + 0 + ], + [ + 3, + 3, + 1 + ], + [ + 3, + 3, + 2 + ], + [ + 3, + 4, + 0 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 4, + 2 + ], + [ + 3, + 4, + 3 + ], + [ + 3, + 5, + 0 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 5, + 2 + ], + [ + 3, + 5, + 3 + ], + [ + 3, + 5, + 4 + ], + [ + 3, + 6, + 0 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 6, + 2 + ], + [ + 3, + 6, + 3 + ], + [ + 3, + 6, + 4 + ], + [ + 3, + 6, + 5 + ], + [ + 3, + 7, + 0 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 7, + 2 + ], + [ + 3, + 7, + 3 + ], + [ + 3, + 7, + 4 + ], + [ + 3, + 7, + 5 + ], + [ + 3, + 7, + 6 + ], + [ + 4, + 1, + 0 + ], + [ + 4, + 2, + 0 + ], + [ + 4, + 2, + 1 + ], + [ + 4, + 3, + 0 + ], + [ + 4, + 3, + 1 + ], + [ + 4, + 3, + 2 + ], + [ + 4, + 4, + 0 + ], + [ + 4, + 4, + 1 + ], + [ + 4, + 4, + 2 + ], + [ + 4, + 4, + 3 + ], + [ + 4, + 5, + 0 + ], + [ + 4, + 5, + 1 + ], + [ + 4, + 5, + 2 + ], + [ + 4, + 5, + 3 + ], + [ + 4, + 5, + 4 + ], + [ + 4, + 6, + 0 + ], + [ + 4, + 6, + 1 + ], + [ + 4, + 6, + 2 + ], + [ + 4, + 6, + 3 + ], + [ + 4, + 6, + 4 + ], + [ + 4, + 6, + 5 + ], + [ + 4, + 7, + 0 + ], + [ + 4, + 7, + 1 + ], + [ + 4, + 7, + 2 + ], + [ + 4, + 7, + 3 + ], + [ + 4, + 7, + 4 + ], + [ + 4, + 7, + 5 + ], + [ + 4, + 7, + 6 + ], + [ + 5, + 1, + 0 + ], + [ + 5, + 2, + 0 + ], + [ + 5, + 2, + 1 + ], + [ + 5, + 3, + 0 + ], + [ + 5, + 3, + 1 + ], + [ + 5, + 3, + 2 + ], + [ + 5, + 4, + 0 + ], + [ + 5, + 4, + 1 + ], + [ + 5, + 4, + 2 + ], + [ + 5, + 4, + 3 + ], + [ + 5, + 5, + 0 + ], + [ + 5, + 5, + 1 + ], + [ + 5, + 5, + 2 + ], + [ + 5, + 5, + 3 + ], + [ + 5, + 5, + 4 + ], + [ + 5, + 6, + 0 + ], + [ + 5, + 6, + 1 + ], + [ + 5, + 6, + 2 + ], + [ + 5, + 6, + 3 + ], + [ + 5, + 6, + 4 + ], + [ + 5, + 6, + 5 + ], + [ + 5, + 7, + 0 + ], + [ + 5, + 7, + 1 + ], + [ + 5, + 7, + 2 + ], + [ + 5, + 7, + 3 + ], + [ + 5, + 7, + 4 + ], + [ + 5, + 7, + 5 + ], + [ + 5, + 7, + 6 + ], + [ + 6, + 1, + 0 + ], + [ + 6, + 2, + 0 + ], + [ + 6, + 2, + 1 + ], + [ + 6, + 3, + 0 + ], + [ + 6, + 3, + 1 + ], + [ + 6, + 3, + 2 + ], + [ + 6, + 4, + 0 + ], + [ + 6, + 4, + 1 + ], + [ + 6, + 4, + 2 + ], + [ + 6, + 4, + 3 + ], + [ + 6, + 5, + 0 + ], + [ + 6, + 5, + 1 + ], + [ + 6, + 5, + 2 + ], + [ + 6, + 5, + 3 + ], + [ + 6, + 5, + 4 + ], + [ + 6, + 6, + 0 + ], + [ + 6, + 6, + 1 + ], + [ + 6, + 6, + 2 + ], + [ + 6, + 6, + 3 + ], + [ + 6, + 6, + 4 + ], + [ + 6, + 6, + 5 + ], + [ + 6, + 7, + 0 + ], + [ + 6, + 7, + 1 + ], + [ + 6, + 7, + 2 + ], + [ + 6, + 7, + 3 + ], + [ + 6, + 7, + 4 + ], + [ + 6, + 7, + 5 + ], + [ + 6, + 7, + 6 + ] + ], + "scope": "Exact address wrappers conditional on a native word that fixes the spectator fields.", + "source_sha256": { + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "startup_margin": "1081110357609925260614972695003107315707432353068338487603991699409949621702495690156909535160235873839601108223405260050123543294943053402137660198994397070489620108165140795187785639656314293544597085375410582291108751565224554246715990585636803213137497296463685876362653172078415927035174159499690912068352607880037991076665304643497436633279437216679436871538992416375313119280028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000", + "status": "PASS_PAST_CATALYST_LAYOUT", + "two_reserve_cases": [ + [ + 1, + 2, + 64, + 9 + ], + [ + 1, + 3, + 64, + 9 + ], + [ + 1, + 4, + 64, + 9 + ], + [ + 1, + 5, + 64, + 9 + ], + [ + 1, + 6, + 64, + 9 + ], + [ + 1, + 7, + 64, + 9 + ], + [ + 2, + 2, + 128, + 18 + ], + [ + 2, + 3, + 128, + 18 + ], + [ + 2, + 4, + 128, + 18 + ], + [ + 2, + 5, + 128, + 18 + ], + [ + 2, + 6, + 128, + 18 + ], + [ + 2, + 7, + 128, + 18 + ], + [ + 3, + 2, + 192, + 27 + ], + [ + 3, + 3, + 192, + 27 + ], + [ + 3, + 4, + 192, + 27 + ], + [ + 3, + 5, + 192, + 27 + ], + [ + 3, + 6, + 192, + 27 + ], + [ + 3, + 7, + 192, + 27 + ], + [ + 4, + 2, + 256, + 36 + ], + [ + 4, + 3, + 256, + 36 + ], + [ + 4, + 4, + 256, + 36 + ], + [ + 4, + 5, + 256, + 36 + ], + [ + 4, + 6, + 256, + 36 + ], + [ + 4, + 7, + 256, + 36 + ] + ] +} diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.md new file mode 100644 index 0000000000..6e35311fc7 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/PAST-CATALYST-LAYOUT.md @@ -0,0 +1,203 @@ +# Place completed coordinates at the current native offset + +This note gives an address wrapper for a possible past-coordinate +supplier. It resolves the common-offset requirement. It does not +construct the supplier, establish its cover, or price its full +recursive profile. + +Suppose a finite native word uses `a f` active coordinates and `p f` +past coordinates. Each coordinate has a complete `K`-bit chunk. +Only one bit per chunk is selected. The desired current offset is +`rho`, with `0<=rho0`, where +`ell=Theta(p/d)` and `K=d^c` up to rounding. Hence `q` tends to +infinity, and the three-group requirement holds for all sufficiently +large inputs. This statement gives no numerical threshold. Handle +the bounded remaining size range by a separate direct base procedure. + +The total added one-time placement work is `O(Vd)`. The selected +strict inequality `1-epsilon-kappa>0` permits this order. The per-call +rotation and placement work has the node bound above. A selected +compact-engine construction still needs an exact updated descriptor, +map, guard, and hosting invoice; this note does not certify that +invoice. + +## Keep the row field separate + +Past payload coordinates cannot also serve as row-index digits. +If the row code must itself be on completed coordinates, the separate +whole-axis construction in `COMPLETED-PREFIX-CODES.md` gives enough +row bits for every recursive depth at cost `O(V ell)`. Exclude that +axis from the chosen past payload coordinates and active axes. +The remaining axes provide the `p f` completed bits above. This +changes the available active dimension by a fixed number of axes; +a full supplier construction must state its integer grouping and +base-case policy. No coordinate is duplicated. + +## What this enables, and what remains open + +If a native family keeps a fixed past subspace and needs only the +common-offset access described here, the physical offset no longer +requires individual moves of `Theta(d)` bits in every round. The +wrapper gives the needed exact access through existing bit +interchanges. + +It does not show that the actual full orthogonal cover keeps the +chosen past subspace. It does not change a Fourier child of rank +`r` into a child on the active projection for free. It does not prove +that a changed child composes in its parent. Those are separate +mathematical and native-interface conditions. In particular, no +new exponent or complete multiplication supplier is claimed. + +## Exact checks + +Run: + +```text +python3 -I -O -B check_past_catalyst_layout.py +``` + +Expected first line: + +```text +PASS_PAST_CATALYST_LAYOUT +``` + +The checker uses no producer imports. It checks all bit positions +for 168 combinations of chunk count, width, and offset. It checks +the selected-mask pullback and the inverse permutation, including +the spectator field. It also checks 24 exact early/late reserve +placements at the proposed `64:9` split. These finite checks verify +the literal permutation formulas. The all-size cost and restoration +claims follow from the proof and the pinned interchange lemma. + +This note was prepared with OpenAI Codex assistance. It remains a +conditional native-layout result and is not a selected supplier. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-CHECKS.json b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-CHECKS.json new file mode 100644 index 0000000000..4cb3043d91 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-CHECKS.json @@ -0,0 +1,46 @@ +{ + "actual_ports": 112, + "canonical_word_sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "checker_sha256": "1acf63009c7a1aaf589d7bf249c61a05e4a379ae5e8d2876df8bb6c805740be0", + "proof_sha256": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99", + "scope": "Exact ring controls for the separate full-stream monomial/binary-ADD pass argument. No lower bound on recursive, unequal-volume, or fused multi-round implementations.", + "source_path": "upstream/build/sections/06-transforms.tex", + "source_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "source_sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "status": "PASS_EXACT_CURRENT_TWIDDLE_PASS_CONTROLS", + "tail_cases": 153, + "tensor_support": [ + { + "nonzero_entries": 2, + "width": 1 + }, + { + "nonzero_entries": 4, + "width": 2 + }, + { + "nonzero_entries": 8, + "width": 3 + }, + { + "nonzero_entries": 16, + "width": 4 + }, + { + "nonzero_entries": 32, + "width": 5 + }, + { + "nonzero_entries": 64, + "width": 6 + }, + { + "nonzero_entries": 128, + "width": 7 + }, + { + "nonzero_entries": 256, + "width": 8 + } + ] +} diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-COST.md b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-COST.md new file mode 100644 index 0000000000..e092c3c045 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/TWIDDLE-PASS-COST.md @@ -0,0 +1,124 @@ +# The cost of separate twiddle transport passes + +This note extends the earlier support test to every nonterminal +synthetic Fourier round. It rules out a specific implementation model: +separate whole-stream monomial and binary ADD passes which keep a +fixed finite number of complete streams. It does not rule out a +recursive native construction, unequal-volume subcalls, a fused +multi-round algorithm, or a different encoded Fourier contract. + +## An exact witness in each round + +Section 06 at source revision +`3ae9a6f3ac74ded022ab3b4872a7357a621af6fb` uses a current transform +length u and the twiddle + + diag(1,y^(-2r k/u)), 0 <= k < u/2. + +For every power of two u>=4, choose k=u/4. This is a legal value of +the unprocessed tail. Set + + t=y^(-r/2), t^2=-1. + +The choice of t is independent of u. It is an identity in the actual +ring R_r, not an evaluation at an assumed complex root. + +For C=((1+i)I+(1-i)X)/2, direct multiplication gives + + C diag(1,t) C^-1 + = 1/2 [[1+t, i(1-t)],[-i(1-t),1+t]]. + +Both 1+t and 1-t are units, since their product is 2. All four +displayed entries are therefore units. The argument is valid even +though R_r has zero divisors. + +Take any nonzero supplier port q. In each tensor column choose one +coordinate in its support. Give that axis the tail k=u/4, and give +the other axes in that column tail zero. On the two-element orbit +{0,q} of the selected current bits, the combined twiddle is exactly +diag(1,t). This can be done independently in each of f columns. +The conjugated twiddle then has 2^f nonzero record entries in every +row of the resulting subcube. They are products of the units above. + +The H0 conversion phases are diagonal and commute with the twiddle. +Conjugation by these phases does not change support. The same is true +of the extra characteristic Z phase in the even-width line. A paired +or spectator T code first permutes the two line-orbit branches and +possibly exchanges the replica slice. That replaces diag(1,t) by +diag(t,1) on the affected slice and gives the same support count. +Thus the witness applies to the current paired T and characteristic +even-width T candidates as a test of separate twiddle transport. + +Each nonzero record entry is multiplication by a nonzero polynomial. +In the negacyclic coefficient representation, every scalar output +coefficient has a nonzero dependency from at least one coefficient +of that record. Thus the same 2^f lower bound applies to a scalar +dependency row. Moving polynomial coefficients with a monomial +permutation does not avoid it. + +## The implementation model + +Start with a fixed finite number of complete streams of comparable +volume, with arbitrary input and borrowed values. Allow the following +operations in a pass: + +* An arbitrary known permutation and unit phase on scalar entries. +* A pointwise binary scalar update, after such permutations. +* A copy, a zero initialization, or an individual scalar rescale. + +The number of streams is fixed as f grows. A pass is charged for the +complete stream that it reads or writes. This is the model of adding +whole-stream boundary sweeps to the retained finite local interface. +The model does not include a recursive native child as one free pass. + +A scalar dependency row begins with support at most one. A monomial, +copy, initialization, or rescale does not increase this support. A +binary update can at most double the largest support on a path to +that output. Hence the transported twiddle requires at least f binary +update stages on one dependency path. In this full-pass model, each +stage costs a fixed positive fraction of the current volume V. The +time for the round is therefore Omega(V f). + +Borrowed inputs do not invalidate the argument. Exact output rows +must have zero coefficient on them, and adding a dependency on a +borrowed input cannot reduce the required depth from the genuine +inputs. The argument also permits any known address-dependent phase +or polynomial-coefficient permutation in a monomial pass. + +## Full transform cost + +The actual outer family has d=Theta(p^epsilon) axes and +ell=Theta(p/d) rounds. Long axes have ell bits and short axes have +ell-1 bits. At least ell-2 rounds have a nontrivial current twiddle +on all these axes. Apart from fixed remainders and startup rows, the +local tensor width in a group is f=Theta(d), since the motif size m +is fixed. Restricting to positive even f changes this by less than +two and has the same order. + +Consequently, separate transport of the new code through each current +twiddle in this model has total time + + Omega(V sum_round f) = Omega(V d ell) = Omega(V p). + +It is not a lower-order cost relative to V p^(1-kappa) for any fixed +positive kappa. The earlier fixed-word support test alone did not +state this full-transform conclusion. The conclusion here needs the +full-pass model and separate transport at each round. + +A code may instead be allowed to leave this portwise family after a +twiddle. It may then depend on unprocessed coordinates and polynomial +coefficient shifts. A later ordinary butterfly need not commute with +that code. A fused procedure which handles that changed code remains +an escape. So does a native construction that uses smaller-volume +children. Neither is ruled out by this support argument. + +The independent exact controls in TWIDDLE-PASS-CHECKS.json verify the +two-point identity, its inverse, the unit products, all actual port +hypotheses, tensor support through width eight, and the legal tail +choice at successive power-of-two lengths. The all-size argument is +the proof above. No complete new native word, owner program, or +supplier bound is claimed. + +OpenAI Codex assisted this work. Publication is on hold. Before any +future PR description, read +`/Users/aliromman/Projects/IntegerMultiplicationBounds/PR-DESCRIPTION-STANDARD.md`. diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_accumulated_twiddle_code.py b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_accumulated_twiddle_code.py new file mode 100644 index 0000000000..dbcaf62813 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_accumulated_twiddle_code.py @@ -0,0 +1,211 @@ +"""Check a complete two-round encoded DIF word over Gaussian integers.""" + +from collections import Counter +from hashlib import sha256 +from pathlib import Path +import json +import subprocess + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +LANES = HERE.parent +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +SOURCE_PINS = { + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", +} +R_PIN = "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" +ZERO = (0, 0) +UNITS = ((1, 0), (0, 1), (-1, 0), (0, -1)) +HIGH, LOW = (1, 3, 5), (0, 2, 4) +DIMENSION = 256 + + +def need(condition, reason): + if not condition: + raise ValueError(reason) + + +def plus(a, b): + return a[0] + b[0], a[1] + b[1] + + +def times(a, b): + return a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0] + + +def conjugate(a): + return a[0], -a[1] + + +def square_norm(a): + return a[0] * a[0] + a[1] * a[1] + + +def put(row, index, coefficient): + value = plus(row.get(index, ZERO), coefficient) + if value != ZERO: + row[index] = value + else: + row.pop(index, None) + + +def butterfly(column, axes): + result = {} + mask = sum(1 << axis for axis in axes) + for address, coefficient in column.items(): + current = sum(((address >> axis) & 1) << j for j, axis in enumerate(axes)) + for output in range(8): + target = (address & ~mask) | sum(((output >> j) & 1) << axis for j, axis in enumerate(axes)) + sign = -1 if (current & output).bit_count() % 2 else 1 + put(result, target, (sign * coefficient[0], sign * coefficient[1])) + return result + + +def output_code(column, axes): + # This is twice S*T*S^-1. T sends z=0 through Q^-1 and z=1 through Q. + result = {} + mask = sum(1 << axis for axis in axes) + for address, coefficient in column.items(): + inverse = ((address >> 6) & 1) == 0 + diagonal = (1, -1) if inverse else (1, 1) + translated = (1, 1) if inverse else (1, -1) + target = address ^ 64 + put(result, target, times(diagonal, coefficient)) + target ^= mask + phase = UNITS[((target & mask).bit_count() - (address & mask).bit_count()) % 4] + put(result, target, times(times(translated, phase), coefficient)) + return result + + +def twiddle(column): + result = {} + for address, coefficient in column.items(): + power = -sum(((address >> high) & 1) * ((address >> low) & 1) + for high, low in zip(HIGH, LOW)) + # The polynomial root theta is independent of the Gaussian unit i. + # On the two coefficient positions, theta maps (a,b) to (-b,a). + shifted = ((address >> 7) & 1) + power + target = (address & 127) | ((shifted % 2) << 7) + sign = -1 if (shifted // 2) % 2 else 1 + put(result, target, (sign * coefficient[0], sign * coefficient[1])) + return result + + +def word(coded, use_twiddle=True): + rows = [{} for _ in range(DIMENSION)] + for source in range(DIMENSION): + column = butterfly({source: (1, 0)}, HIGH) + if coded: + column = output_code(column, HIGH) + if use_twiddle: + column = twiddle(column) + column = butterfly(column, LOW) + if coded: + column = output_code(column, LOW) + for target, coefficient in column.items(): + rows[target][source] = coefficient + # Two rounds give denominator 8 for raw H, and 32 with the two Q maps. + return rows + + +def row_product(first, second): + answer = [] + for right in second: + value = ZERO + for column, a in first.items(): + if column in right: + value = plus(value, times(a, conjugate(right[column]))) + answer.append(value) + return answer + + +def parity_class(address): + return ((sum((address >> bit) & 1 for bit in HIGH) % 2), + (sum((address >> bit) & 1 for bit in LOW) % 2), (address >> 6) & 1) + + +def main(): + for path, pin in SOURCE_PINS.items(): + raw = subprocess.check_output(["git", "-C", str(ROOT / "worktrees/k5-centre-sharing"), + "show", REVISION + ":" + path]) + need(sha256(raw).hexdigest() == pin, "Physical source pin") + raw = (LANES / "circuit-interface/INTERFACE.json").read_bytes() + need(sha256(raw).hexdigest() == R_PIN, "Actual port pin") + ports = json.loads(raw)["ports"] + need(ports[0] == 11 and set(q.bit_count() for q in ports) == {3, 7}, "Actual odd port types") + # 2*H0=(1-i) S C S holds entry by entry for the source C and S conventions. + C = (((1, 1), (1, -1)), ((1, -1), (1, 1))) + for target in range(2): + for source in range(2): + rhs = times((1, -1), times(UNITS[target], times(C[target][source], UNITS[source]))) + need(rhs == ((-2 if target and source else 2), 0), "H/S/C conversion side") + + ordinary, encoded = word(False), word(True) + for target, row in enumerate(ordinary): + expected = {} + for source in range(DIMENSION): + if ((source >> 6) & 1) != ((target >> 6) & 1): + continue + power = 0 + for low, high in zip(LOW, HIGH): + x = ((source >> low) & 1) + 2 * ((source >> high) & 1) + reversed_y = ((target >> high) & 1) + 2 * ((target >> low) & 1) + power -= x * reversed_y + shifted = ((source >> 7) & 1) + power + if shifted % 2 == ((target >> 7) & 1): + expected[source] = (-1 if (shifted // 2) % 2 else 1, 0) + need(row == expected, "The ordinary word is not the unitary rescaling of the source DIF transform") + for rows, denominator in ((ordinary, 8), (encoded, 32)): + for index, row in enumerate(rows): + gram = row_product(row, rows) + need(gram == [(denominator * denominator, 0) if j == index else ZERO + for j in range(DIMENSION)], "Exact unitary normalization") + encoded_classes = Counter(len({parity_class(source) for source in row}) for row in encoded) + need(encoded_classes == {1: 256}, "The complete code mixes a parity class") + # U_raw U_code^* is the terminal decoder, with common denominator 8*32. + histograms, first_row = Counter(), None + for index, row in enumerate(ordinary): + decoder = row_product(row, encoded) + histogram = Counter(square_norm(value) for value in decoder if value != ZERO) + need(sum(map(square_norm, decoder)) == 256 ** 2, "Decoder row norm") + need(histogram == {16384: 2, 4096: 8}, "Decoder support or magnitude pattern") + need(all(value[1] == 0 for value in decoder), "The physical coefficient decoder has an imaginary part") + classes = {parity_class(j)[:2] for j, value in enumerate(decoder) if value != ZERO} + need(len(classes) == 4, "A required parity sector is missing") + histograms[str(sorted(histogram.items()))] += 1 + if index == 0: + first_row = [[j, value[0], value[1]] for j, value in enumerate(decoder) if value != ZERO] + raw_without, encoded_without = word(False, False), word(True, False) + for row in raw_without: + control = row_product(row, encoded_without) + need(Counter(square_norm(value) for value in control if value != ZERO) == {16384: 4}, + "The no-twiddle control does not reduce to four uniform entries") + receipt = { + "status": "PASS_EXACT_ACCUMULATED_TWIDDLE_CODE", + "checker_sha256": sha256(Path(__file__).read_bytes()).hexdigest(), + "source_revision": REVISION, "source_pins": SOURCE_PINS, "actual_port_pin": R_PIN, + "actual_port": 11, "active_source_coordinates": [0, 1, 3], + "axes": 3, "bits_per_axis": 2, "arbitrary_replica_slices": 2, + "polynomial_coefficient_positions": 2, "formal_Gaussian_columns": 256, + "real_input_columns": 512, + "arithmetic": "Exact Gaussian integer pairs; theta is a separate signed permutation on polynomial coefficients; unitary-rescaled word denominators 8,32 and decoder denominator 256", + "source_H0_normalization": "Each literal H0 is H/2. Both complete source words equal one eighth of the unitary-rescaled word used here. This common factor cancels in U_raw U_code^-1.", + "ordinary_DIF_entries_checked": 65536, + "unitary_Gram_entries_checked": 131072, + "encoded_parity_class_counts": dict(encoded_classes), + "decoder_rows_checked": 256, + "decoder_nonzero_entries_per_row": 10, + "decoder_squared_magnitude_counts": {"1/4": 2, "1/16": 8}, + "decoder_first_row_numerators_over_256": first_row, + "no_twiddle_control": "All 256 decoder rows have four entries of squared magnitude 1/4", + "scope": "Stable port q, common exact T endpoint, current-bit H0 conversion, and the actual two-round length-four DIF twiddle. Other six local axes factor as the identity in the residual. This rejects one native C_r between monomial maps for this terminal residual. It does not bound arbitrary native-child words, changed layouts, changed endpoints, or a general multiplication algorithm.", + } + (HERE / "ACCUMULATED-TWIDDLE-CODE.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(receipt["status"]) + print("256 coefficient decoder rows: 10 nonzero entries each; the no-twiddle control has 4.") + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_completed_prefix_codes.py b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_completed_prefix_codes.py new file mode 100644 index 0000000000..d7e47f0085 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_completed_prefix_codes.py @@ -0,0 +1,303 @@ +"""Check the physical prefix and twiddle conventions from pinned sources.""" + +from hashlib import sha256 +from fractions import Fraction +from pathlib import Path +import argparse +import json +import subprocess + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +PINS = { + "upstream/build/sections/02-streams.tex": + "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/05-layers.tex": + "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": + "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "certificates/selected-result.json": + "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} +INTERFACE_PIN = "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" +MODULUS = 97 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def unit(n): + return [[int(i == j) for j in range(n)] for i in range(n)] + + +def multiply(a, b): + cols = list(zip(*b)) + return [[sum(x*y for x, y in zip(row, col)) % MODULUS + for col in cols] for row in a] + + +def inverse(a): + n = len(a) + rows = [list(row)+one for row, one in zip(a, unit(n))] + for j in range(n): + pivot = next(i for i in range(j, n) if rows[i][j]) + rows[j], rows[pivot] = rows[pivot], rows[j] + z = pow(rows[j][j], -1, MODULUS) + rows[j] = [v*z % MODULUS for v in rows[j]] + for i in range(n): + if i != j and rows[i][j]: + z = rows[i][j] + rows[i] = [(a-z*b) % MODULUS + for a, b in zip(rows[i], rows[j])] + need([row[:n] for row in rows] == unit(n), "Inverse elimination") + return [row[n:] for row in rows] + + +def one_round(h, root): + rows = unit(64) + half = pow(2, -1, MODULUS) + for axis in range(2): + bit = 3*axis+h + for x in range(64): + if not (x >> bit) & 1: + y = x ^ (1 << bit) + a, b = rows[x], rows[y] + rows[x] = [(u+v)*half % MODULUS for u, v in zip(a, b)] + rows[y] = [(u-v)*half % MODULUS for u, v in zip(a, b)] + for x in range(64): + exponent = 0 + for axis in range(2): + value = (x >> (3*axis)) & 7 + exponent -= (16 >> (h+1))*((value >> h) & 1)*(value & ((1 << h)-1)) + z = pow(root, exponent % 16, MODULUS) + rows[x] = [v*z % MODULUS for v in rows[x]] + return rows + + +def prefix_matrix(a): + out = [[0]*64 for _ in range(64)] + for target in range(64): + selected = ((target >> 2) & 1) + 2*((target >> 5) & 1) + rest = target & ~(4+32) + for old in range(4): + source = rest + 4*(old & 1) + 32*(old >> 1) + out[target][source] = a[selected][old] + return out + + +def reverse3(x): + return ((x & 1) << 2) + (x & 2) + (x >> 2) + + +def exact_dif_check(root): + rounds = [one_round(h, root) for h in (2, 1, 0)] + full = multiply(rounds[2], multiply(rounds[1], rounds[0])) + direct = [] + for x in range(64): + j0, j1 = reverse3(x & 7), reverse3(x >> 3) + direct.append([pow(root, (-2*(j0*(k & 7)+j1*(k >> 3))) % 16, + MODULUS)*pow(64, -1, MODULUS) % MODULUS + for k in range(64)]) + need(full == direct, "Stored DIF order differs from the direct transform") + a, b = unit(4), unit(4) + a[0][1] = 1 + b[1][2] = 1 + need(multiply(a, b) != multiply(b, a), "The two codes must not commute") + pa, pb = prefix_matrix(a), prefix_matrix(b) + for gate in (pa, pb): + for step in rounds[1:]: + need(multiply(gate, step) == multiply(step, gate), + "A past prefix does not commute with a later round") + encoded = multiply(rounds[2], multiply(pb, multiply(rounds[1], + multiply(pa, rounds[0])))) + fused = multiply(pb, pa) + need(encoded == multiply(fused, full), "The accumulated code has the wrong order") + fi = inverse(fused) + need(multiply(fi, fused) == unit(64), "Left code inverse") + need(multiply(fused, fi) == unit(64), "Right code inverse") + need(multiply(fi, encoded) == full, "Terminal code decode") + return {"record_dimension": 64, "prime": MODULUS, "root_order": 16, + "root": root, "exact_transform_entries": 4096, + "completed_slots": [2, 5], "later_round_commutators": 4, + "noncommuting_code_fusion_entries": 4096, + "both_code_inverse_orders": True} + + +def opposite_round(lengths, h, root): + n = 1 << sum(lengths) + offsets = [0, lengths[0]] + rows = unit(n) + half = pow(2, -1, MODULUS) + for width, offset in zip(lengths, offsets): + if h >= width: + continue + bit = offset+h + for x in range(n): + if not (x >> bit) & 1: + y = x ^ (1 << bit) + a, b = rows[x], rows[y] + rows[x] = [(u+v)*half % MODULUS for u, v in zip(a, b)] + rows[y] = [(u-v)*half % MODULUS for u, v in zip(a, b)] + for x in range(n): + exponent = 0 + for width, offset in zip(lengths, offsets): + if h >= width: + continue + value = (x >> offset) & ((1 << width)-1) + tail = sum(((value >> v) & 1) << (width-1-v) + for v in range(h+1, width)) + exponent += (16 >> (width-h))*((value >> h) & 1)*tail + z = pow(root, exponent % 16, MODULUS) + rows[x] = [v*z % MODULUS for v in rows[x]] + return rows + + +def opposite_check(root): + results = [] + for lengths in ((3, 3), (3, 2)): + n = 1 << sum(lengths) + offsets = [0, lengths[0]] + rounds = [opposite_round(lengths, h, root) for h in range(max(lengths))] + full = unit(n) + for step in rounds: + full = multiply(step, full) + direct = [] + for x in range(n): + row = [] + for k in range(n): + exponent = 0 + for width, offset in zip(lengths, offsets): + output = (x >> offset) & ((1 << width)-1) + source = (k >> offset) & ((1 << width)-1) + frequency = sum(((source >> v) & 1) << (width-1-v) + for v in range(width)) + exponent += (16 >> width)*output*frequency + row.append(pow(root, exponent % 16, MODULUS) + *pow(n, -1, MODULUS) % MODULUS) + direct.append(row) + need(full == direct, "Reversed-label plus DIF is not F_plus B") + code = unit(n) + for x in range(n): + if not (x & 1): + code[x][x ^ 1] = 1 + for step in rounds[1:]: + need(multiply(code, step) == multiply(step, code), + "A completed opposite slot enters a later round") + results.append({"axis_log_lengths": list(lengths), "record_dimension": n, + "all_operator_entries": n*n, + "remaining_round_commutators": len(rounds)-1, + "required_operator": "F_plus B_inverse", + "physical_bit_reversal_operations": 0}) + return results + + +def line_normalizer_check(ports, root): + imaginary = pow(root, 4, MODULUS) + half = pow(2, -1, MODULUS) + a, b = (1+imaginary)*half % MODULUS, (1-imaginary)*half % MODULUS + need((a*b) % MODULUS == half, "The intrinsic C coefficients differ") + columns = 0 + for q in ports: + need(q and q.bit_count() % 2, "A source port is not an odd line") + axis = (q & -q).bit_length()-1 + for x in range(512): + z = x ^ q + dx = imaginary if (x >> axis) & 1 else 1 + dz = imaginary if (z >> axis) & 1 else 1 + diagonal = a*b*(dx+dz) % MODULUS + off = (b*b*dx+a*a*dz) % MODULUS + off_inverse = (a*a*dx+b*b*dz) % MODULUS + need(diagonal and off and off_inverse, + "The paired transported twiddle lost a required entry") + phase = pow(imaginary, (z.bit_count()-x.bit_count()) % 4, MODULUS) + need(off*phase % MODULUS and off_inverse*phase % MODULUS, + "H0 boundary phases removed the witness") + columns += 1 + return {"actual_ports": len(ports), "spatial_columns": columns, + "paired_replica_columns": 2*columns, + "H0_diagonal_conjugation_checked": True, + "current_line_is_not_a_twiddle_normalizer": True, + "line_square_is_a_permutation": True, + "all_size_statement": "The tensor support is 2^lambda by the exact unit proof."} + + +def selected_bit_check(): + slots, copies, width, offset = 3, 2, 3, 1 + selected = [width*j+offset for j in range(slots*copies)] + cases = 0 + for x in range(1 << (slots*copies*width)): + y = x + for j in range(copies): + src, dst = selected[j], selected[copies+j] + y ^= ((x >> src) & 1) << dst + changed = x ^ y + allowed = sum(1 << selected[copies+j] for j in range(copies)) + need(not (changed & ~allowed), "A chart changed an unselected bit") + restored = y + for j in range(copies): + src, dst = selected[j], selected[copies+j] + restored ^= ((y >> src) & 1) << dst + need(restored == x, "Selected chart inverse") + cases += 1 + return {"slots": slots, "copies": copies, "chunk_width": width, + "offset": offset, "all_addresses": cases, + "third_slot_and_other_offsets_fixed": True} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--repo", type=Path, default=ROOT / "worktrees/k5-centre-sharing") + parser.add_argument("--out", type=Path, default=HERE / "COMPLETED-PREFIX-CODES.json") + args = parser.parse_args() + source = {} + for path, pin in PINS.items(): + raw = subprocess.check_output(["git", "-C", str(args.repo), "show", REVISION+":"+path]) + need(sha256(raw).hexdigest() == pin, "Source hash: "+path) + source[path] = raw + assembly = json.loads(source["research/community-frontier1094-audit/ASSEMBLY.json"]) + selected = json.loads(source["certificates/selected-result.json"]) + need(assembly["kappa"] == selected["kappa"], "Selected exponent binding") + epsilon = Fraction(assembly["outer"]["epsilon_positive"]) + kappa = Fraction(assembly["kappa"]) + need(0 < 1-epsilon and epsilon-kappa > Fraction(99, 100), + "The whole-axis prefix invoice has no strict margin") + interface_path = HERE.parent / "circuit-interface/INTERFACE.json" + raw = interface_path.read_bytes() + need(sha256(raw).hexdigest() == INTERFACE_PIN, "Interface hash") + ports = json.loads(raw)["ports"] + root = next(x for x in range(2, MODULUS) + if pow(x, 16, MODULUS) == 1 and pow(x, 8, MODULUS) == MODULUS-1) + receipt = { + "status": "PASS_COMPLETED_PREFIX_CODES", + "revision": REVISION, "source_sha256": PINS, + "interface_sha256": INTERFACE_PIN, + "dif": exact_dif_check(root), + "reversed_label_opposite": opposite_check(root), + "paired_current_line": line_normalizer_check(ports, root), + "selected_offset_endpoint": selected_bit_check(), + "whole_axis_row_prefix": { + "one_axis_work_and_layout": "O(V ell)", + "ell": "Theta(p/d)", + "row_bits_needed": "ceil(ceil(log_m d) log_2 W)=O(log d)", + "axis_bits_available": "ell or ell-1", + "strict_margin_epsilon_minus_kappa": str(epsilon-kappa), + "margin_lower_bound": "99/100", + "applies_to_both_transform_directions": True, + "padding_volume_factor": "less than two", + }, + "scope": "Exact finite conventions and negative controls; all-size theorems are proved in the note.", + "not_claimed": ["A new complete supplier", "A recursive encoded-child contract", + "A kappa improvement", "A general circuit lower bound"], + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_fixed_past_outer.py b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_fixed_past_outer.py new file mode 100644 index 0000000000..69aaec1915 --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_fixed_past_outer.py @@ -0,0 +1,84 @@ +"""Check the exact normalization for the conditional past interface.""" + +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import json +import subprocess + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +ASSEMBLY = "research/community-frontier1094-audit/ASSEMBLY.json" +ASSEMBLY_PIN = "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" +ZERO, ONE, I = (Q(0), Q(0)), (Q(1), Q(0)), (Q(0), Q(1)) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def product(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def multiply(a, b): + return [[add(product(a[i][0], b[0][j]), product(a[i][1], b[1][j])) + for j in range(2)] for i in range(2)] + + +def scalar(z, a): + return [[product(z, x) for x in row] for row in a] + + +def main(): + identity = [[ONE, ZERO], [ZERO, ONE]] + alpha, beta = (Q(1, 2), Q(1, 2)), (Q(1, 2), Q(-1, 2)) + c = [[alpha, beta], [beta, alpha]] + s = [[ONE, ZERO], [ZERO, I]] + h0 = [[(Q(1, 2), Q(0)), (Q(1, 2), Q(0))], + [(Q(1, 2), Q(0)), (Q(-1, 2), Q(0))]] + h = scalar((Q(1), Q(1)), h0) + need(multiply(s, multiply(c, s)) == h, "S C S normalization") + need(scalar(beta, h) == h0, "Active H0 normalization") + powers = [identity] + for _ in range(8): + powers.append(multiply(h, powers[-1])) + need(powers[2] == scalar(I, identity), "h squared") + need(powers[4] == scalar((Q(-1), Q(0)), identity), "h fourth power") + need(powers[8] == identity, "h eighth power") + for j, matrix in enumerate(powers): + for row in matrix: + norms = [x*x+y*y for x, y in row] + need(norms == [Q(1, 2), Q(1, 2)] if j % 2 else sorted(norms) == [0, 1], + "The exact odd/even row support differs") + raw = subprocess.check_output(["git", "-C", str(ROOT / "worktrees/k5-centre-sharing"), + "show", REVISION+":"+ASSEMBLY]) + need(sha256(raw).hexdigest() == ASSEMBLY_PIN, "Selected assembly source") + assembly = json.loads(raw) + epsilon, kappa = Q(assembly["outer"]["epsilon_positive"]), Q(assembly["kappa"]) + need(1-epsilon-kappa > 0 and epsilon-kappa > 0, "Outer cost margins") + receipt = { + "status": "PASS_FIXED_PAST_OUTER_NORMALIZATION", + "revision": REVISION, "assembly_sha256": ASSEMBLY_PIN, + "h_powers": [[[[str(z) for z in v] for v in row] for row in a] for a in powers], + "scalar_identity": "S C S = (1+i) H0", + "tensor_period": 8, + "odd_power_row_norm": "2^(number_of_past_bits/2)", + "decoded_round_error": "n 2^(number_of_past_bits/2) eta", + "terminal_decoder_cost": "O(V d)", + "native_supplier_hypothesis_verified": False, + "scope": "Exact scalar normalization and selected outer inequalities; the closure proof is conditional.", + } + (HERE / "FIXED-PAST-OUTER-CLOSURE.json").write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_past_catalyst_layout.py b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_past_catalyst_layout.py new file mode 100644 index 0000000000..f9503e73cf --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_past_catalyst_layout.py @@ -0,0 +1,153 @@ +"""Check the bit permutations used by the past-coordinate layout.""" + +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import subprocess + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +PINS = { + "upstream/build/sections/02-streams.tex": + "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": + "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": + "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": + "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "research/community-frontier1094-audit/ASSEMBLY.json": + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def swap(fields, a, b, width): + need(a+width <= b or b+width <= a, "Swap fields overlap") + fields[a:a+width], fields[b:b+width] = fields[b:b+width], fields[a:a+width] + + +def permutation_inverse(labels): + out = [0]*len(labels) + for position, label in enumerate(labels): + out[label] = position + return out + + +def rotation_check(): + cases = [] + for chunks in range(1, 7): + for width in range(1, 8): + length = chunks*width + for offset in range(width): + cut = (length-offset) % length + labels = list(range(2*length)) + if cut: + swap(labels, 0, 2*length-cut, cut) + swap(labels, cut, length, length-cut) + swap(labels, 0, length, length) + expected = (list(range(cut, length))+list(range(cut)) + +list(range(2*length-cut, 2*length)) + +list(range(length, 2*length-cut))) + need(labels == expected, "Three-swap rotation identity") + location = permutation_inverse(labels) + old_selected = [j*width for j in range(chunks)] + new_selected = [j*width+offset for j in range(chunks)] + need([location[x] for x in old_selected] == new_selected, + "Selected offsets differ") + mask_old = sum(1 << x for x in old_selected) + mask_new = sum(1 << x for x in new_selected) + pulled_mask = sum(((mask_new >> position) & 1) << label + for position, label in enumerate(labels)) + need(pulled_mask == mask_old, "Conjugated selected translation") + need(not (pulled_mask >> length), "Spectator field is changed") + for i in range(2*length): + need(labels[location[i]] == i, "Inverse placement") + cases.append([chunks, width, offset]) + return cases + + +def reserve_check(): + cases = [] + for copies in range(1, 5): + active, past = 64*copies, 9*copies + for width in range(2, 8): + group = active*width + length = past*width + need(2*length < group, "The reserve does not fit") + total = 4*group + sources = [j*width+width-1 for j in range(past)] + early_targets = [3*group+j*width for j in range(past)] + late_targets = [j*width for j in range(past)] + labels = list(range(total)) + for source, target in zip(sources, early_targets): + swap(labels, source, target, 1) + location = permutation_inverse(labels) + need([location[x] for x in sources] == early_targets, "Early past placement") + spectator = range(3*group+length, 3*group+2*length) + need(all(labels[x] == x for x in spectator), "Early spectator is not disjoint") + for source, target in reversed(list(zip(sources, early_targets))): + swap(labels, source, target, 1) + need(labels == list(range(total)), "Early placement does not restore") + for source, target in zip(sources, late_targets): + swap(labels, source, target, 1) + location = permutation_inverse(labels) + need([location[x] for x in sources] == late_targets, "Late past placement") + need(all(labels[x] == x for x in range(group, total)), + "Late placement changes an uncompleted group") + for source, target in reversed(list(zip(sources, late_targets))): + swap(labels, source, target, 1) + need(labels == list(range(total)), "Late placement does not restore") + cases.append([copies, width, active, past]) + return cases + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--repo", type=Path, default=ROOT / "worktrees/k5-centre-sharing") + parser.add_argument("--out", type=Path, default=HERE / "PAST-CATALYST-LAYOUT.json") + args = parser.parse_args() + sources = {} + for path, digest in PINS.items(): + raw = subprocess.check_output(["git", "-C", str(args.repo), "show", REVISION+":"+path]) + need(sha256(raw).hexdigest() == digest, "Source hash: "+path) + sources[path] = raw + assembly = json.loads(sources["research/community-frontier1094-audit/ASSEMBLY.json"]) + epsilon = Fraction(assembly["outer"]["epsilon_positive"]) + c = Fraction(assembly["outer"]["c_positive"]) + kappa = Fraction(assembly["kappa"]) + need(1-epsilon*(1+c) > 0, "There are not asymptotically many chunk groups") + need(1-epsilon-kappa > 0, "The finite initial digit moves are too expensive") + receipt = { + "status": "PASS_PAST_CATALYST_LAYOUT", + "revision": REVISION, "source_sha256": PINS, + "rotation_cases": rotation_check(), + "two_reserve_cases": reserve_check(), + "interchanges_per_offset_alignment": 6, + "interchanges_for_nonadjacent_past_block": 2, + "fixed_slot_order_maps": "At most the fixed number of native slots", + "added_native_children": 0, + "extra_address_bits": 0, + "initial_and_final_bit_moves": "O(d) per transform", + "per_invocation_time": "O(V ((eK)^tau+1)) under the cited chunk-swap interface", + "chunk_group_margin": str(1-epsilon*(1+c)), + "startup_margin": str(1-epsilon-kappa), + "scope": "Exact address wrappers conditional on a native word that fixes the spectator fields.", + "not_claimed": ["The fixed-past cover condition", "The active child profile", + "The selected finite compact-engine invoice", "Recursive encoded-child closure", + "A kappa improvement"], + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py new file mode 100644 index 0000000000..403f07257d --- /dev/null +++ b/research/completed-prefix-outer/frozen/lanes/temporal-reuse/check_twiddle_pass_cost.py @@ -0,0 +1,107 @@ +"""Check exact twiddle transport identities and the actual port hypotheses.""" + +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import gzip +import json +import subprocess + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +REPO = ROOT / "worktrees/k5-centre-sharing" +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +WORD = ROOT / "work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz" +WORD_HASH = "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +# The coefficient order is 1, i, t, i*t, with i^2=t^2=-1. +def add(a, b): + return tuple(x+y for x, y in zip(a, b)) + + +def multiply(a, b): + result = [F(0)]*4 + for j, x in enumerate(a): + for k, y in enumerate(b): + result[j ^ k] += (-1 if (j & k).bit_count() & 1 else 1)*x*y + return tuple(result) + + +def scale(a, c): + return tuple(c*x for x in a) + + +def matmul(a, b): + return [[sum_ring([multiply(a[i][k], b[k][j]) for k in range(len(b))]) + for j in range(len(b[0]))] for i in range(len(a))] + + +def sum_ring(values): + result = ZERO + for value in values: + result = add(result, value) + return result + + +ZERO = (F(0),)*4 +ONE = (F(1), F(0), F(0), F(0)) +I = (F(0), F(1), F(0), F(0)) +T = (F(0), F(0), F(1), F(0)) + + +def main(): + raw = WORD.read_bytes() + need(sha256(raw).hexdigest() == WORD_HASH, "The actual port source changed") + ports = json.loads(gzip.decompress(raw))["ports"] + need(len(ports) == 112 and len(set(ports)) == 112, "The actual port count differs") + need(all(0 < p < 512 and p.bit_count() in (3, 7) for p in ports), "A port fails the orbit hypothesis") + a, b = scale(add(ONE, I), F(1, 2)), scale(add(ONE, scale(I, -1)), F(1, 2)) + c, inverse = [[a, b], [b, a]], [[b, a], [a, b]] + identity = [[ONE, ZERO], [ZERO, ONE]] + need(matmul(c, inverse) == identity and matmul(inverse, c) == identity, "The line inverse differs") + actual = matmul(matmul(c, [[ONE, ZERO], [ZERO, T]]), inverse) + diagonal = scale(add(ONE, T), F(1, 2)) + off = scale(multiply(I, add(ONE, scale(T, -1))), F(1, 2)) + expected = [[diagonal, off], [scale(off, -1), diagonal]] + need(actual == expected, "The conjugated twiddle identity differs") + need(multiply(add(ONE, T), add(ONE, scale(T, -1))) == scale(ONE, 2), "The unit product differs") + for row in actual: + for value in row: + need(value != ZERO, "A two-point entry vanished") + tensor_checks = [] + for width in range(1, 9): + entries = [ONE] + for _ in range(width): + entries = [multiply(value, factor) for value in entries for factor in actual[0]] + need(len(entries) == 2**width and all(value != ZERO for value in entries), "A tensor row lost support") + tensor_checks.append({"width": width, "nonzero_entries": len(entries)}) + tail_cases = 0 + for r_exponent in range(1, 18): + r = 2**r_exponent + for u_exponent in range(2, r_exponent+2): + u, k = 2**u_exponent, 2**(u_exponent-2) + need(0 <= k < u//2 and (2*r//u)*k == r//2, "The current-round tail is invalid") + tail_cases += 1 + source_path = "upstream/build/sections/06-transforms.tex" + source = subprocess.check_output(["git", "-C", str(REPO), "show", REVISION+":"+source_path]) + need(b"\\frac{2r}{u_i}\\,b_i k_i" in source and b"0\\leq k_i> axis) & 1) << j for j, axis in enumerate(axes)) + for output in range(8): + target = (address & ~mask) | sum(((output >> j) & 1) << axis for j, axis in enumerate(axes)) + sign = -1 if (current & output).bit_count() % 2 else 1 + put(result, target, (sign * coefficient[0], sign * coefficient[1])) + return result + + +def output_code(column, axes): + # This is twice S*T*S^-1. T sends z=0 through Q^-1 and z=1 through Q. + result = {} + mask = sum(1 << axis for axis in axes) + for address, coefficient in column.items(): + inverse = ((address >> 6) & 1) == 0 + diagonal = (1, -1) if inverse else (1, 1) + translated = (1, 1) if inverse else (1, -1) + target = address ^ 64 + put(result, target, times(diagonal, coefficient)) + target ^= mask + phase = UNITS[((target & mask).bit_count() - (address & mask).bit_count()) % 4] + put(result, target, times(times(translated, phase), coefficient)) + return result + + +def twiddle(column): + result = {} + for address, coefficient in column.items(): + power = -sum(((address >> high) & 1) * ((address >> low) & 1) + for high, low in zip(HIGH, LOW)) + # The polynomial root theta is independent of the Gaussian unit i. + # On the two coefficient positions, theta maps (a,b) to (-b,a). + shifted = ((address >> 7) & 1) + power + target = (address & 127) | ((shifted % 2) << 7) + sign = -1 if (shifted // 2) % 2 else 1 + put(result, target, (sign * coefficient[0], sign * coefficient[1])) + return result + + +def word(coded, use_twiddle=True): + rows = [{} for _ in range(DIMENSION)] + for source in range(DIMENSION): + column = butterfly({source: (1, 0)}, HIGH) + if coded: + column = output_code(column, HIGH) + if use_twiddle: + column = twiddle(column) + column = butterfly(column, LOW) + if coded: + column = output_code(column, LOW) + for target, coefficient in column.items(): + rows[target][source] = coefficient + # Two rounds give denominator 8 for raw H, and 32 with the two Q maps. + return rows + + +def row_product(first, second): + answer = [] + for right in second: + value = ZERO + for column, a in first.items(): + if column in right: + value = plus(value, times(a, conjugate(right[column]))) + answer.append(value) + return answer + + +def parity_class(address): + return ((sum((address >> bit) & 1 for bit in HIGH) % 2), + (sum((address >> bit) & 1 for bit in LOW) % 2), (address >> 6) & 1) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + for path, pin in SOURCE_PINS.items(): + raw = (args.sources / path).read_bytes() + need(sha256(raw).hexdigest() == pin, "Physical source pin") + raw = (LANES / "circuit-interface/INTERFACE.json").read_bytes() + need(sha256(raw).hexdigest() == R_PIN, "Actual port pin") + ports = json.loads(raw)["ports"] + need(ports[0] == 11 and set(q.bit_count() for q in ports) == {3, 7}, "Actual odd port types") + # 2*H0=(1-i) S C S holds entry by entry for the source C and S conventions. + C = (((1, 1), (1, -1)), ((1, -1), (1, 1))) + for target in range(2): + for source in range(2): + rhs = times((1, -1), times(UNITS[target], times(C[target][source], UNITS[source]))) + need(rhs == ((-2 if target and source else 2), 0), "H/S/C conversion side") + + ordinary, encoded = word(False), word(True) + for target, row in enumerate(ordinary): + expected = {} + for source in range(DIMENSION): + if ((source >> 6) & 1) != ((target >> 6) & 1): + continue + power = 0 + for low, high in zip(LOW, HIGH): + x = ((source >> low) & 1) + 2 * ((source >> high) & 1) + reversed_y = ((target >> high) & 1) + 2 * ((target >> low) & 1) + power -= x * reversed_y + shifted = ((source >> 7) & 1) + power + if shifted % 2 == ((target >> 7) & 1): + expected[source] = (-1 if (shifted // 2) % 2 else 1, 0) + need(row == expected, "The ordinary word is not the unitary rescaling of the source DIF transform") + for rows, denominator in ((ordinary, 8), (encoded, 32)): + for index, row in enumerate(rows): + gram = row_product(row, rows) + need(gram == [(denominator * denominator, 0) if j == index else ZERO + for j in range(DIMENSION)], "Exact unitary normalization") + encoded_classes = Counter(len({parity_class(source) for source in row}) for row in encoded) + need(encoded_classes == {1: 256}, "The complete code mixes a parity class") + # U_raw U_code^* is the terminal decoder, with common denominator 8*32. + histograms, first_row = Counter(), None + for index, row in enumerate(ordinary): + decoder = row_product(row, encoded) + histogram = Counter(square_norm(value) for value in decoder if value != ZERO) + need(sum(map(square_norm, decoder)) == 256 ** 2, "Decoder row norm") + need(histogram == {16384: 2, 4096: 8}, "Decoder support or magnitude pattern") + need(all(value[1] == 0 for value in decoder), "The physical coefficient decoder has an imaginary part") + classes = {parity_class(j)[:2] for j, value in enumerate(decoder) if value != ZERO} + need(len(classes) == 4, "A required parity sector is missing") + histograms[str(sorted(histogram.items()))] += 1 + if index == 0: + first_row = [[j, value[0], value[1]] for j, value in enumerate(decoder) if value != ZERO] + raw_without, encoded_without = word(False, False), word(True, False) + for row in raw_without: + control = row_product(row, encoded_without) + need(Counter(square_norm(value) for value in control if value != ZERO) == {16384: 4}, + "The no-twiddle control does not reduce to four uniform entries") + receipt = { + "status": "PASS_EXACT_ACCUMULATED_TWIDDLE_CODE", + "checker_sha256": sha256(Path(__file__).read_bytes()).hexdigest(), + "source_revision": REVISION, "source_pins": SOURCE_PINS, "actual_port_pin": R_PIN, + "actual_port": 11, "active_source_coordinates": [0, 1, 3], + "axes": 3, "bits_per_axis": 2, "arbitrary_replica_slices": 2, + "polynomial_coefficient_positions": 2, "formal_Gaussian_columns": 256, + "real_input_columns": 512, + "arithmetic": "Exact Gaussian integer pairs; theta is a separate signed permutation on polynomial coefficients; unitary-rescaled word denominators 8,32 and decoder denominator 256", + "source_H0_normalization": "Each literal H0 is H/2. Both complete source words equal one eighth of the unitary-rescaled word used here. This common factor cancels in U_raw U_code^-1.", + "ordinary_DIF_entries_checked": 65536, + "unitary_Gram_entries_checked": 131072, + "encoded_parity_class_counts": dict(encoded_classes), + "decoder_rows_checked": 256, + "decoder_nonzero_entries_per_row": 10, + "decoder_squared_magnitude_counts": {"1/4": 2, "1/16": 8}, + "decoder_first_row_numerators_over_256": first_row, + "no_twiddle_control": "All 256 decoder rows have four entries of squared magnitude 1/4", + "scope": "Stable port q, common exact T endpoint, current-bit H0 conversion, and the actual two-round length-four DIF twiddle. Other six local axes factor as the identity in the residual. This rejects one native C_r between monomial maps for this terminal residual. It does not bound arbitrary native-child words, changed layouts, changed endpoints, or a general multiplication algorithm.", + } + args.out.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(receipt["status"]) + print("256 coefficient decoder rows: 10 nonzero entries each; the no-twiddle control has 4.") + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/portable/check_completed_prefix_codes.py b/research/completed-prefix-outer/portable/check_completed_prefix_codes.py new file mode 100644 index 0000000000..1969bb5590 --- /dev/null +++ b/research/completed-prefix-outer/portable/check_completed_prefix_codes.py @@ -0,0 +1,302 @@ +"""Check the physical prefix and twiddle conventions from pinned sources.""" + +from hashlib import sha256 +from fractions import Fraction +from pathlib import Path +import argparse +import json + + +PACKAGE = Path(__file__).resolve().parents[1] +HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +PINS = { + "upstream/build/sections/02-streams.tex": + "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/05-layers.tex": + "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": + "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "certificates/selected-result.json": + "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} +INTERFACE_PIN = "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" +MODULUS = 97 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def unit(n): + return [[int(i == j) for j in range(n)] for i in range(n)] + + +def multiply(a, b): + cols = list(zip(*b)) + return [[sum(x*y for x, y in zip(row, col)) % MODULUS + for col in cols] for row in a] + + +def inverse(a): + n = len(a) + rows = [list(row)+one for row, one in zip(a, unit(n))] + for j in range(n): + pivot = next(i for i in range(j, n) if rows[i][j]) + rows[j], rows[pivot] = rows[pivot], rows[j] + z = pow(rows[j][j], -1, MODULUS) + rows[j] = [v*z % MODULUS for v in rows[j]] + for i in range(n): + if i != j and rows[i][j]: + z = rows[i][j] + rows[i] = [(a-z*b) % MODULUS + for a, b in zip(rows[i], rows[j])] + need([row[:n] for row in rows] == unit(n), "Inverse elimination") + return [row[n:] for row in rows] + + +def one_round(h, root): + rows = unit(64) + half = pow(2, -1, MODULUS) + for axis in range(2): + bit = 3*axis+h + for x in range(64): + if not (x >> bit) & 1: + y = x ^ (1 << bit) + a, b = rows[x], rows[y] + rows[x] = [(u+v)*half % MODULUS for u, v in zip(a, b)] + rows[y] = [(u-v)*half % MODULUS for u, v in zip(a, b)] + for x in range(64): + exponent = 0 + for axis in range(2): + value = (x >> (3*axis)) & 7 + exponent -= (16 >> (h+1))*((value >> h) & 1)*(value & ((1 << h)-1)) + z = pow(root, exponent % 16, MODULUS) + rows[x] = [v*z % MODULUS for v in rows[x]] + return rows + + +def prefix_matrix(a): + out = [[0]*64 for _ in range(64)] + for target in range(64): + selected = ((target >> 2) & 1) + 2*((target >> 5) & 1) + rest = target & ~(4+32) + for old in range(4): + source = rest + 4*(old & 1) + 32*(old >> 1) + out[target][source] = a[selected][old] + return out + + +def reverse3(x): + return ((x & 1) << 2) + (x & 2) + (x >> 2) + + +def exact_dif_check(root): + rounds = [one_round(h, root) for h in (2, 1, 0)] + full = multiply(rounds[2], multiply(rounds[1], rounds[0])) + direct = [] + for x in range(64): + j0, j1 = reverse3(x & 7), reverse3(x >> 3) + direct.append([pow(root, (-2*(j0*(k & 7)+j1*(k >> 3))) % 16, + MODULUS)*pow(64, -1, MODULUS) % MODULUS + for k in range(64)]) + need(full == direct, "Stored DIF order differs from the direct transform") + a, b = unit(4), unit(4) + a[0][1] = 1 + b[1][2] = 1 + need(multiply(a, b) != multiply(b, a), "The two codes must not commute") + pa, pb = prefix_matrix(a), prefix_matrix(b) + for gate in (pa, pb): + for step in rounds[1:]: + need(multiply(gate, step) == multiply(step, gate), + "A past prefix does not commute with a later round") + encoded = multiply(rounds[2], multiply(pb, multiply(rounds[1], + multiply(pa, rounds[0])))) + fused = multiply(pb, pa) + need(encoded == multiply(fused, full), "The accumulated code has the wrong order") + fi = inverse(fused) + need(multiply(fi, fused) == unit(64), "Left code inverse") + need(multiply(fused, fi) == unit(64), "Right code inverse") + need(multiply(fi, encoded) == full, "Terminal code decode") + return {"record_dimension": 64, "prime": MODULUS, "root_order": 16, + "root": root, "exact_transform_entries": 4096, + "completed_slots": [2, 5], "later_round_commutators": 4, + "noncommuting_code_fusion_entries": 4096, + "both_code_inverse_orders": True} + + +def opposite_round(lengths, h, root): + n = 1 << sum(lengths) + offsets = [0, lengths[0]] + rows = unit(n) + half = pow(2, -1, MODULUS) + for width, offset in zip(lengths, offsets): + if h >= width: + continue + bit = offset+h + for x in range(n): + if not (x >> bit) & 1: + y = x ^ (1 << bit) + a, b = rows[x], rows[y] + rows[x] = [(u+v)*half % MODULUS for u, v in zip(a, b)] + rows[y] = [(u-v)*half % MODULUS for u, v in zip(a, b)] + for x in range(n): + exponent = 0 + for width, offset in zip(lengths, offsets): + if h >= width: + continue + value = (x >> offset) & ((1 << width)-1) + tail = sum(((value >> v) & 1) << (width-1-v) + for v in range(h+1, width)) + exponent += (16 >> (width-h))*((value >> h) & 1)*tail + z = pow(root, exponent % 16, MODULUS) + rows[x] = [v*z % MODULUS for v in rows[x]] + return rows + + +def opposite_check(root): + results = [] + for lengths in ((3, 3), (3, 2)): + n = 1 << sum(lengths) + offsets = [0, lengths[0]] + rounds = [opposite_round(lengths, h, root) for h in range(max(lengths))] + full = unit(n) + for step in rounds: + full = multiply(step, full) + direct = [] + for x in range(n): + row = [] + for k in range(n): + exponent = 0 + for width, offset in zip(lengths, offsets): + output = (x >> offset) & ((1 << width)-1) + source = (k >> offset) & ((1 << width)-1) + frequency = sum(((source >> v) & 1) << (width-1-v) + for v in range(width)) + exponent += (16 >> width)*output*frequency + row.append(pow(root, exponent % 16, MODULUS) + *pow(n, -1, MODULUS) % MODULUS) + direct.append(row) + need(full == direct, "Reversed-label plus DIF is not F_plus B") + code = unit(n) + for x in range(n): + if not (x & 1): + code[x][x ^ 1] = 1 + for step in rounds[1:]: + need(multiply(code, step) == multiply(step, code), + "A completed opposite slot enters a later round") + results.append({"axis_log_lengths": list(lengths), "record_dimension": n, + "all_operator_entries": n*n, + "remaining_round_commutators": len(rounds)-1, + "required_operator": "F_plus B_inverse", + "physical_bit_reversal_operations": 0}) + return results + + +def line_normalizer_check(ports, root): + imaginary = pow(root, 4, MODULUS) + half = pow(2, -1, MODULUS) + a, b = (1+imaginary)*half % MODULUS, (1-imaginary)*half % MODULUS + need((a*b) % MODULUS == half, "The intrinsic C coefficients differ") + columns = 0 + for q in ports: + need(q and q.bit_count() % 2, "A source port is not an odd line") + axis = (q & -q).bit_length()-1 + for x in range(512): + z = x ^ q + dx = imaginary if (x >> axis) & 1 else 1 + dz = imaginary if (z >> axis) & 1 else 1 + diagonal = a*b*(dx+dz) % MODULUS + off = (b*b*dx+a*a*dz) % MODULUS + off_inverse = (a*a*dx+b*b*dz) % MODULUS + need(diagonal and off and off_inverse, + "The paired transported twiddle lost a required entry") + phase = pow(imaginary, (z.bit_count()-x.bit_count()) % 4, MODULUS) + need(off*phase % MODULUS and off_inverse*phase % MODULUS, + "H0 boundary phases removed the witness") + columns += 1 + return {"actual_ports": len(ports), "spatial_columns": columns, + "paired_replica_columns": 2*columns, + "H0_diagonal_conjugation_checked": True, + "current_line_is_not_a_twiddle_normalizer": True, + "line_square_is_a_permutation": True, + "all_size_statement": "The tensor support is 2^lambda by the exact unit proof."} + + +def selected_bit_check(): + slots, copies, width, offset = 3, 2, 3, 1 + selected = [width*j+offset for j in range(slots*copies)] + cases = 0 + for x in range(1 << (slots*copies*width)): + y = x + for j in range(copies): + src, dst = selected[j], selected[copies+j] + y ^= ((x >> src) & 1) << dst + changed = x ^ y + allowed = sum(1 << selected[copies+j] for j in range(copies)) + need(not (changed & ~allowed), "A chart changed an unselected bit") + restored = y + for j in range(copies): + src, dst = selected[j], selected[copies+j] + restored ^= ((y >> src) & 1) << dst + need(restored == x, "Selected chart inverse") + cases += 1 + return {"slots": slots, "copies": copies, "chunk_width": width, + "offset": offset, "all_addresses": cases, + "third_slot_and_other_offsets_fixed": True} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + source = {} + for path, pin in PINS.items(): + raw = (args.sources / path).read_bytes() + need(sha256(raw).hexdigest() == pin, "Source hash: "+path) + source[path] = raw + assembly = json.loads(source["research/community-frontier1094-audit/ASSEMBLY.json"]) + selected = json.loads(source["certificates/selected-result.json"]) + need(assembly["kappa"] == selected["kappa"], "Selected exponent binding") + epsilon = Fraction(assembly["outer"]["epsilon_positive"]) + kappa = Fraction(assembly["kappa"]) + need(0 < 1-epsilon and epsilon-kappa > Fraction(99, 100), + "The whole-axis prefix invoice has no strict margin") + interface_path = HERE.parent / "circuit-interface/INTERFACE.json" + raw = interface_path.read_bytes() + need(sha256(raw).hexdigest() == INTERFACE_PIN, "Interface hash") + ports = json.loads(raw)["ports"] + root = next(x for x in range(2, MODULUS) + if pow(x, 16, MODULUS) == 1 and pow(x, 8, MODULUS) == MODULUS-1) + receipt = { + "status": "PASS_COMPLETED_PREFIX_CODES", + "revision": REVISION, "source_sha256": PINS, + "interface_sha256": INTERFACE_PIN, + "dif": exact_dif_check(root), + "reversed_label_opposite": opposite_check(root), + "paired_current_line": line_normalizer_check(ports, root), + "selected_offset_endpoint": selected_bit_check(), + "whole_axis_row_prefix": { + "one_axis_work_and_layout": "O(V ell)", + "ell": "Theta(p/d)", + "row_bits_needed": "ceil(ceil(log_m d) log_2 W)=O(log d)", + "axis_bits_available": "ell or ell-1", + "strict_margin_epsilon_minus_kappa": str(epsilon-kappa), + "margin_lower_bound": "99/100", + "applies_to_both_transform_directions": True, + "padding_volume_factor": "less than two", + }, + "scope": "Exact finite conventions and negative controls; all-size theorems are proved in the note.", + "not_claimed": ["A new complete supplier", "A recursive encoded-child contract", + "A kappa improvement", "A general circuit lower bound"], + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/portable/check_fixed_past_outer.py b/research/completed-prefix-outer/portable/check_fixed_past_outer.py new file mode 100644 index 0000000000..38635b4d01 --- /dev/null +++ b/research/completed-prefix-outer/portable/check_fixed_past_outer.py @@ -0,0 +1,87 @@ +"""Check the exact normalization for the conditional past interface.""" + +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import json + + +PACKAGE = Path(__file__).resolve().parents[1] +HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +ASSEMBLY = "research/community-frontier1094-audit/ASSEMBLY.json" +ASSEMBLY_PIN = "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" +ZERO, ONE, I = (Q(0), Q(0)), (Q(1), Q(0)), (Q(0), Q(1)) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def product(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def multiply(a, b): + return [[add(product(a[i][0], b[0][j]), product(a[i][1], b[1][j])) + for j in range(2)] for i in range(2)] + + +def scalar(z, a): + return [[product(z, x) for x in row] for row in a] + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + identity = [[ONE, ZERO], [ZERO, ONE]] + alpha, beta = (Q(1, 2), Q(1, 2)), (Q(1, 2), Q(-1, 2)) + c = [[alpha, beta], [beta, alpha]] + s = [[ONE, ZERO], [ZERO, I]] + h0 = [[(Q(1, 2), Q(0)), (Q(1, 2), Q(0))], + [(Q(1, 2), Q(0)), (Q(-1, 2), Q(0))]] + h = scalar((Q(1), Q(1)), h0) + need(multiply(s, multiply(c, s)) == h, "S C S normalization") + need(scalar(beta, h) == h0, "Active H0 normalization") + powers = [identity] + for _ in range(8): + powers.append(multiply(h, powers[-1])) + need(powers[2] == scalar(I, identity), "h squared") + need(powers[4] == scalar((Q(-1), Q(0)), identity), "h fourth power") + need(powers[8] == identity, "h eighth power") + for j, matrix in enumerate(powers): + for row in matrix: + norms = [x*x+y*y for x, y in row] + need(norms == [Q(1, 2), Q(1, 2)] if j % 2 else sorted(norms) == [0, 1], + "The exact odd/even row support differs") + raw = (args.sources / ASSEMBLY).read_bytes() + need(sha256(raw).hexdigest() == ASSEMBLY_PIN, "Selected assembly source") + assembly = json.loads(raw) + epsilon, kappa = Q(assembly["outer"]["epsilon_positive"]), Q(assembly["kappa"]) + need(1-epsilon-kappa > 0 and epsilon-kappa > 0, "Outer cost margins") + receipt = { + "status": "PASS_FIXED_PAST_OUTER_NORMALIZATION", + "revision": REVISION, "assembly_sha256": ASSEMBLY_PIN, + "h_powers": [[[[str(z) for z in v] for v in row] for row in a] for a in powers], + "scalar_identity": "S C S = (1+i) H0", + "tensor_period": 8, + "odd_power_row_norm": "2^(number_of_past_bits/2)", + "decoded_round_error": "n 2^(number_of_past_bits/2) eta", + "terminal_decoder_cost": "O(V d)", + "native_supplier_hypothesis_verified": False, + "scope": "Exact scalar normalization and selected outer inequalities; the closure proof is conditional.", + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/portable/check_past_catalyst_layout.py b/research/completed-prefix-outer/portable/check_past_catalyst_layout.py new file mode 100644 index 0000000000..221e2d8b8a --- /dev/null +++ b/research/completed-prefix-outer/portable/check_past_catalyst_layout.py @@ -0,0 +1,152 @@ +"""Check the bit permutations used by the past-coordinate layout.""" + +from fractions import Fraction +from hashlib import sha256 +from pathlib import Path +import argparse +import json + + +PACKAGE = Path(__file__).resolve().parents[1] +HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +PINS = { + "upstream/build/sections/02-streams.tex": + "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": + "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": + "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": + "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "research/community-frontier1094-audit/ASSEMBLY.json": + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def swap(fields, a, b, width): + need(a+width <= b or b+width <= a, "Swap fields overlap") + fields[a:a+width], fields[b:b+width] = fields[b:b+width], fields[a:a+width] + + +def permutation_inverse(labels): + out = [0]*len(labels) + for position, label in enumerate(labels): + out[label] = position + return out + + +def rotation_check(): + cases = [] + for chunks in range(1, 7): + for width in range(1, 8): + length = chunks*width + for offset in range(width): + cut = (length-offset) % length + labels = list(range(2*length)) + if cut: + swap(labels, 0, 2*length-cut, cut) + swap(labels, cut, length, length-cut) + swap(labels, 0, length, length) + expected = (list(range(cut, length))+list(range(cut)) + +list(range(2*length-cut, 2*length)) + +list(range(length, 2*length-cut))) + need(labels == expected, "Three-swap rotation identity") + location = permutation_inverse(labels) + old_selected = [j*width for j in range(chunks)] + new_selected = [j*width+offset for j in range(chunks)] + need([location[x] for x in old_selected] == new_selected, + "Selected offsets differ") + mask_old = sum(1 << x for x in old_selected) + mask_new = sum(1 << x for x in new_selected) + pulled_mask = sum(((mask_new >> position) & 1) << label + for position, label in enumerate(labels)) + need(pulled_mask == mask_old, "Conjugated selected translation") + need(not (pulled_mask >> length), "Spectator field is changed") + for i in range(2*length): + need(labels[location[i]] == i, "Inverse placement") + cases.append([chunks, width, offset]) + return cases + + +def reserve_check(): + cases = [] + for copies in range(1, 5): + active, past = 64*copies, 9*copies + for width in range(2, 8): + group = active*width + length = past*width + need(2*length < group, "The reserve does not fit") + total = 4*group + sources = [j*width+width-1 for j in range(past)] + early_targets = [3*group+j*width for j in range(past)] + late_targets = [j*width for j in range(past)] + labels = list(range(total)) + for source, target in zip(sources, early_targets): + swap(labels, source, target, 1) + location = permutation_inverse(labels) + need([location[x] for x in sources] == early_targets, "Early past placement") + spectator = range(3*group+length, 3*group+2*length) + need(all(labels[x] == x for x in spectator), "Early spectator is not disjoint") + for source, target in reversed(list(zip(sources, early_targets))): + swap(labels, source, target, 1) + need(labels == list(range(total)), "Early placement does not restore") + for source, target in zip(sources, late_targets): + swap(labels, source, target, 1) + location = permutation_inverse(labels) + need([location[x] for x in sources] == late_targets, "Late past placement") + need(all(labels[x] == x for x in range(group, total)), + "Late placement changes an uncompleted group") + for source, target in reversed(list(zip(sources, late_targets))): + swap(labels, source, target, 1) + need(labels == list(range(total)), "Late placement does not restore") + cases.append([copies, width, active, past]) + return cases + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + sources = {} + for path, digest in PINS.items(): + raw = (args.sources / path).read_bytes() + need(sha256(raw).hexdigest() == digest, "Source hash: "+path) + sources[path] = raw + assembly = json.loads(sources["research/community-frontier1094-audit/ASSEMBLY.json"]) + epsilon = Fraction(assembly["outer"]["epsilon_positive"]) + c = Fraction(assembly["outer"]["c_positive"]) + kappa = Fraction(assembly["kappa"]) + need(1-epsilon*(1+c) > 0, "There are not asymptotically many chunk groups") + need(1-epsilon-kappa > 0, "The finite initial digit moves are too expensive") + receipt = { + "status": "PASS_PAST_CATALYST_LAYOUT", + "revision": REVISION, "source_sha256": PINS, + "rotation_cases": rotation_check(), + "two_reserve_cases": reserve_check(), + "interchanges_per_offset_alignment": 6, + "interchanges_for_nonadjacent_past_block": 2, + "fixed_slot_order_maps": "At most the fixed number of native slots", + "added_native_children": 0, + "extra_address_bits": 0, + "initial_and_final_bit_moves": "O(d) per transform", + "per_invocation_time": "O(V ((eK)^tau+1)) under the cited chunk-swap interface", + "chunk_group_margin": str(1-epsilon*(1+c)), + "startup_margin": str(1-epsilon-kappa), + "scope": "Exact address wrappers conditional on a native word that fixes the spectator fields.", + "not_claimed": ["The fixed-past cover condition", "The active child profile", + "The selected finite compact-engine invoice", "Recursive encoded-child closure", + "A kappa improvement"], + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/completed-prefix-outer/portable/check_twiddle_pass_cost.py b/research/completed-prefix-outer/portable/check_twiddle_pass_cost.py new file mode 100644 index 0000000000..98ef9c5e6f --- /dev/null +++ b/research/completed-prefix-outer/portable/check_twiddle_pass_cost.py @@ -0,0 +1,110 @@ +"""Check exact twiddle transport identities and the actual port hypotheses.""" + +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import gzip +import argparse +import json + +PACKAGE = Path(__file__).resolve().parents[1] +HERE = PACKAGE / "frozen/lanes" / "temporal-reuse" +REVISION = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +WORD = PACKAGE / "frozen/CANONICAL-WORD.json.gz" +WORD_HASH = "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +# The coefficient order is 1, i, t, i*t, with i^2=t^2=-1. +def add(a, b): + return tuple(x+y for x, y in zip(a, b)) + + +def multiply(a, b): + result = [F(0)]*4 + for j, x in enumerate(a): + for k, y in enumerate(b): + result[j ^ k] += (-1 if (j & k).bit_count() & 1 else 1)*x*y + return tuple(result) + + +def scale(a, c): + return tuple(c*x for x in a) + + +def matmul(a, b): + return [[sum_ring([multiply(a[i][k], b[k][j]) for k in range(len(b))]) + for j in range(len(b[0]))] for i in range(len(a))] + + +def sum_ring(values): + result = ZERO + for value in values: + result = add(result, value) + return result + + +ZERO = (F(0),)*4 +ONE = (F(1), F(0), F(0), F(0)) +I = (F(0), F(1), F(0), F(0)) +T = (F(0), F(0), F(1), F(0)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + raw = WORD.read_bytes() + need(sha256(raw).hexdigest() == WORD_HASH, "The actual port source changed") + ports = json.loads(gzip.decompress(raw))["ports"] + need(len(ports) == 112 and len(set(ports)) == 112, "The actual port count differs") + need(all(0 < p < 512 and p.bit_count() in (3, 7) for p in ports), "A port fails the orbit hypothesis") + a, b = scale(add(ONE, I), F(1, 2)), scale(add(ONE, scale(I, -1)), F(1, 2)) + c, inverse = [[a, b], [b, a]], [[b, a], [a, b]] + identity = [[ONE, ZERO], [ZERO, ONE]] + need(matmul(c, inverse) == identity and matmul(inverse, c) == identity, "The line inverse differs") + actual = matmul(matmul(c, [[ONE, ZERO], [ZERO, T]]), inverse) + diagonal = scale(add(ONE, T), F(1, 2)) + off = scale(multiply(I, add(ONE, scale(T, -1))), F(1, 2)) + expected = [[diagonal, off], [scale(off, -1), diagonal]] + need(actual == expected, "The conjugated twiddle identity differs") + need(multiply(add(ONE, T), add(ONE, scale(T, -1))) == scale(ONE, 2), "The unit product differs") + for row in actual: + for value in row: + need(value != ZERO, "A two-point entry vanished") + tensor_checks = [] + for width in range(1, 9): + entries = [ONE] + for _ in range(width): + entries = [multiply(value, factor) for value in entries for factor in actual[0]] + need(len(entries) == 2**width and all(value != ZERO for value in entries), "A tensor row lost support") + tensor_checks.append({"width": width, "nonzero_entries": len(entries)}) + tail_cases = 0 + for r_exponent in range(1, 18): + r = 2**r_exponent + for u_exponent in range(2, r_exponent+2): + u, k = 2**u_exponent, 2**(u_exponent-2) + need(0 <= k < u//2 and (2*r//u)*k == r//2, "The current-round tail is invalid") + tail_cases += 1 + source_path = "upstream/build/sections/06-transforms.tex" + source = (args.sources / source_path).read_bytes() + need(b"\\frac{2r}{u_i}\\,b_i k_i" in source and b"0\\leq k_i> j) & 1) << (width - 1 - j) for j in range(width)) + + +def path_phase(widths, x, y, r, common_width=False): + phase, offset = 0, 0 + for width in widths: + xx = (x >> offset) & ((1 << width) - 1) + yy = (y >> offset) & ((1 << width) - 1) + for h in range(width): + branch = (yy >> h) & 1 + phase += r * ((xx >> h) & 1) * branch + tail = sum(((xx >> v) & 1) << (width - 1 - v) for v in range(h + 1, width)) + denominator = 1 << ((max(widths) if common_width else width) - h) + phase += (2 * r // denominator) * branch * tail + offset += width + return phase % (2 * r) + + +def direct_phase(widths, x, y, r): + phase, offset = 0, 0 + for width in widths: + mask = (1 << width) - 1 + phase += (2 * r // (1 << width)) * reverse((x >> offset) & mask, width) * ((y >> offset) & mask) + offset += width + return phase % (2 * r) + + +def layout(widths, chunk, ell): + bottom = (ell - 1) % chunk + initial = [(i, h) for i, width in enumerate(widths) for h in range(width - 1, -1, -1)] + prefix = [(i, ell - 1) for i, width in enumerate(widths) if width == ell] + prefix += [(i, h) for h in range(bottom - 1, -1, -1) for i in range(len(widths))] + remaining = [slot for slot in initial if slot not in set(prefix)] + count = (ell - 1) // chunk + blocks = {(i, j): remaining[(i * count + j) * chunk:(i * count + j + 1) * chunk] + for i in range(len(widths)) for j in range(count)} + physical = prefix + [slot for j in range(count) for i in range(len(widths)) for slot in blocks[i, j]] + require(sorted(physical) == sorted(initial), "the retained L is a slot permutation") + positions = {slot: k for k, slot in enumerate(physical)} + checks = 0 + for h in range(bottom, ell - 1): + axis_positions = [positions[i, h] for i in range(len(widths))] + require(all(axis_positions[i + 1] - axis_positions[i] == chunk for i in range(len(widths) - 1)), + "the opposite round has consecutive equal-width chunks") + require(all((positions[i, h] - len(prefix)) % chunk == chunk - 1 - (h - bottom) % chunk + for i in range(len(widths))), "the common selected offset is unchanged") + checks += 1 + return checks + + +def main(args): + raw = (args.sources / SOURCE).read_bytes() + require(sha256(raw).hexdigest() == SOURCE_PIN, "original all-size transform source") + require(sha256(args.proof.read_bytes()).hexdigest() == PROOF_PIN, "reviewed proof snapshot") + entry_cases, coefficient_cases, layout_cases, round_cases = [], 0, 0, 0 + # This checks polynomial coefficients, without a finite-field specialization. + for width in range(1, 31): + r = 1 << width + for h in range(width): + for v in range(width): + direct = (2 * r // (1 << width)) * (1 << h) * (1 << (width - 1 - v)) + path = r if h == v else ((2 * r // (1 << (width - h))) * (1 << (width - 1 - v)) if h < v else 0) + require((direct - path) % (2 * r) == 0, "exact all-bit coefficient identity") + coefficient_cases += 1 + for widths in [(a,) for a in range(1, 7)] + [(3, 2), (3, 3), (4, 3), (2, 2, 1)]: + n, r = 1 << sum(widths), 1 << max(widths) + for x in range(n): + for y in range(n): + require(path_phase(widths, x, y, r) == direct_phase(widths, x, y, r), + "an exact polynomial-ring matrix entry differs") + entry_cases.append(dict(axis_log_lengths=widths, entries=n*n, normalization_denominator=n, root_modulus=2*r)) + for ell in range(2, 15): + for chunk in range(1, ell): + for widths in ((ell, ell), (ell - 1, ell - 1), (ell, ell - 1), + (ell - 1, ell, ell - 1), (ell, ell, ell - 1, ell - 1)): + round_cases += layout(widths, chunk, ell) + layout_cases += 1 + controls = [] + widths, r, n = (3, 2), 8, 32 + wrong = next((dict(x=x, y=y, correct=direct_phase(widths, x, y, r), + wrong=path_phase(widths, x, y, r, True)) + for x in range(n) for y in range(n) + if path_phase(widths, x, y, r, True) != direct_phase(widths, x, y, r)), None) + require(wrong is not None, "wrong common recursive length control") + controls.append(dict(name="same_twiddle_length_on_long_and_short_axes", witness=wrong)) + require(reverse(1, 3) != 1, "nontrivial bit reversal") + require(direct_phase((3,), 1, 1, 8) != 2, "wrong endpoint without input bit reversal") + controls.append(dict(name="omit_input_bit_reversal_in_endpoint_formula", x=1, y=1, + correct=direct_phase((3,), 1, 1, 8), wrong=2)) + result = dict(status="PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW", + revision=REVISION, source_path=SOURCE, source_sha256=SOURCE_PIN, + proof_sha256=PROOF_PIN, exact_bit_coefficient_cases=coefficient_cases, + exact_ring_entry_cases=entry_cases, layout_cases=layout_cases, + common_chunk_round_checks=round_cases, controls=controls, + proof_scope="All-size opposite schedule, exact F_plus B_inverse endpoint, retained L layout, long/short axes, and the original contraction/truncation/asymptotic cost proof", + not_claimed=["A changed encoded supplier", "A recursively closed past-space code", "An improved kappa", "The other theorems in the reviewed note"]) + args.out.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + print(json.dumps(dict(status=result["status"], coefficient_cases=coefficient_cases, + exact_entries=sum(c["entries"] for c in entry_cases), layout_cases=layout_cases, + common_chunk_rounds=round_cases), sort_keys=True)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--sources", type=Path, default=PACKAGE / "sources/upstream") + parser.add_argument("--proof", type=Path, default=PACKAGE / "frozen/lanes/temporal-reuse/COMPLETED-PREFIX-CODES.md") + parser.add_argument("--out", type=Path, required=True) + main(parser.parse_args()) diff --git a/research/completed-prefix-outer/portable/review_prefix.py b/research/completed-prefix-outer/portable/review_prefix.py new file mode 100644 index 0000000000..21495a8d1d --- /dev/null +++ b/research/completed-prefix-outer/portable/review_prefix.py @@ -0,0 +1,283 @@ +"""Check exact DIF phases and physical prefix placement without producer imports.""" + +import argparse +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path + + +PACKAGE = Path(__file__).resolve().parents[1] +REV = "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb" +FILES = { + "temporal-reuse/COMPLETED-PREFIX-CODES.md": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5", + "temporal-reuse/check_completed_prefix_codes.py": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186", + "temporal-reuse/COMPLETED-PREFIX-CODES.json": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "temporal-reuse/PAST-CATALYST-LAYOUT.md": "8f3ac9bc6133397ce98c88b0f6999c1eac9f6169d10fe21b2f0ab9d2275caee7", + "temporal-reuse/check_past_catalyst_layout.py": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef", + "temporal-reuse/PAST-CATALYST-LAYOUT.json": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "schur-selection/PAST-CATALYST-v2.md": "566cfb7794202a2462a41da8abef69066c51a06ab7802c01f76b996e58e976e5", + "schur-selection/PAST-GAUGE-FUSION.md": "a84b77d2ef0d0747713063a7bd08e211b5a75eabbba6ff085a3967676fc12c6f", +} +GIT_FILES = { + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def reverse(value, width): + return sum(((value >> i) & 1) << (width-1-i) for i in range(width)) + + +def column(width, source, opposite): + """Return monomial exponents; the common coefficient is 1/2**width.""" + r = 1 << width + states = {source: 0} + order = range(width) if opposite else range(width-1, -1, -1) + for h in order: + following = {} + for address, exponent in states.items(): + old = (address >> h) & 1 + for new in (0, 1): + target = (address & ~(1 << h)) | (new << h) + phase = exponent+r*old*new + if opposite: + tail = reverse(address >> (h+1), width-h-1) + phase += (2*r >> (width-h))*new*tail + else: + tail = address & ((1 << h)-1) + phase -= (2*r >> (h+1))*new*tail + need(target not in following, "Two paths reached one basis entry") + following[target] = phase % (2*r) + states = following + return states + + +def exact_dif(): + count = 0 + old_opposite_counterexample = None + for width in range(1, 9): + r = 1 << width + for source in range(r): + for opposite in (False, True): + out = column(width, source, opposite) + for target, phase in out.items(): + expected = (2*target*reverse(source, width) if opposite + else -2*reverse(target, width)*source) % (2*r) + need(phase == expected, "Exact polynomial DIF endpoint") + count += 1 + if width > 1: + # In the retained reverse-arithmetic order, the later h=1 twiddle + # reads the already completed physical bit0. + old_opposite_counterexample = ((2*r >> 2)*1*1) % (2*r) + need(old_opposite_counterexample != 0, "Old opposite schedule control") + return count, old_opposite_counterexample + + +def layout_names(lengths, chunk, ell): + bottom = (ell-1) % chunk + prefix = [(axis, ell-1) for axis, width in enumerate(lengths) if width == ell] + prefix += [(axis, bit) for bit in range(bottom-1, -1, -1) + for axis in range(len(lengths))] + groups = [[(axis, bit) for axis in range(len(lengths)) + for bit in range(high, high-chunk, -1)] + for high in range(ell-2, bottom-1, -chunk)] + result = prefix+sum(groups, []) + need(len(result) == len(set(result)) == sum(lengths), "All named slots occur once") + return result, bottom, len(prefix) + + +def selected_offsets(): + cases = 0 + for ell in range(3, 13): + for chunk in range(1, ell): + for lengths in ([ell, ell-1], [ell-1, ell, ell-1], [ell]*4, [ell-1]*3): + names, bottom, head = layout_names(lengths, chunk, ell) + for bit in range(bottom, ell-1): + expected_offset = (bit-bottom) % chunk + group = (ell-2-bit)//chunk + for axis in range(len(lengths)): + position = names.index((axis, bit))-head + need(position//(len(lengths)*chunk) == group, + "Current axes are not in one chunk group") + need(chunk-1-(position % chunk) == expected_offset, + "Physical selected offset differs") + # The new opposite tail consists only of higher named slots. + for axis, width in enumerate(lengths): + need(all(names.index((axis, v)) != names.index((axis, bit)) + for v in range(bit+1, width)), "Tail includes current bit") + cases += 1 + return cases + + +def exchange(order, a, b, width): + need(a+width <= b or b+width <= a, "Overlapping fields") + for offset in range(width): + order[a+offset], order[b+offset] = order[b+offset], order[a+offset] + + +def check_rotation(): + total = 0 + for chunks in range(1, 9): + for width in range(1, 10): + length = chunks*width + # Separate X and Z by an unrelated three-bit field. + z = length+3 + for rho in range(width): + order = list(range(2*length+3)) + cut = (length-rho) % length + operations = [] if cut == 0 else [ + (0, z+length-cut, cut), (cut, z, length-cut), (0,z,length)] + for operation in operations: + exchange(order, *operation) + for old in range(0,length,width): + need(order[old+rho] == old, "Past selected name not at rho") + need(order[length:z] == list(range(length,z)), "Gap is not fixed") + # The selected-label identity gives conjugacy for every linear + # value map on these bits, not only their joint XOR. + active = [order[p] for p in range(rho,length,width)] + need(active == list(range(0,length,width)), "Ordered selected embedding") + for operation in reversed(operations): + exchange(order, *operation) + need(order == list(range(2*length+3)), "Literal inverse does not restore all names") + total += 1 + return total + + +def reserve_views(): + count = 0 + for copies in range(1,5): + for width in range(2,7): + active, past = 64*copies, 9*copies + group, length = active*width, past*width + for groups in (3,4,5): + total = groups*group + source = [j*width+width-1 for j in range(past)] + names = list(range(total)) + early = [(x,(groups-1)*group+j*width) for j,x in enumerate(source)] + for a,b in early: + exchange(names,a,b,1) + need([names[(groups-1)*group+j*width] for j in range(past)] == source, + "Completed names not in early reserve") + for current in range(groups-1): + neighbor = current-1 if current else 1 + need(neighbor not in (current, groups-1), "No distinct adjacent block") + before = names[:] + target = neighbor*group if neighbor > current else (neighbor+1)*group-length + exchange(names,target,(groups-1)*group,length) + need(names[target:target+length] == before[(groups-1)*group:(groups-1)*group+length], + "Past block not adjacent to active block") + exchange(names,target,(groups-1)*group,length) + need(names == before, "Temporary adjacent placement does not restore") + for a,b in reversed(early): + exchange(names,a,b,1) + need(names == list(range(total)), "Early reserve does not restore future names") + late = [(x,j*width) for j,x in enumerate(source)] + for a,b in late: + exchange(names,a,b,1) + need(names[group:] == list(range(group,total)), "Late reserve changes unfinished group") + for a,b in reversed(late): + exchange(names,a,b,1) + need(names == list(range(total)), "Late reserve inverse") + count += 1 + return count + + +def gadd(a,b): + return tuple(x+y for x,y in zip(a,b)) + + +def gmul(a,b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +ZERO = (F(0),F(0)) +ONE = (F(1),F(0)) + + +def padd(a,b): + return gadd(a[0],b[0]),gadd(a[1],b[1]) + + +def pmul(a,b): + low, high = gmul(a[0],b[0]),gmul(a[1],b[1]) + return (low[0]-high[0],low[1]-high[1]),gadd(gmul(a[0],b[1]),gmul(a[1],b[0])) + + +def matrix(a,b): + return [[padd(pmul(a[i][0],b[0][j]),pmul(a[i][1],b[1][j])) + for j in range(2)] for i in range(2)] + + +def twiddle_control(): + zero,one,y = (ZERO,ZERO),(ONE,ZERO),(ZERO,ONE) + a,b = ((F(1,2),F(1,2)),ZERO),((F(1,2),F(-1,2)),ZERO) + c,ci = [[a,b],[b,a]],[[b,a],[a,b]] + need(matrix(c,ci) == [[one,zero],[zero,one]], "Exact complex line inverse") + conjugates = [matrix(matrix(c,[[one,zero],[zero,y]]),ci), + matrix(matrix(ci,[[one,zero],[zero,y]]),c)] + for transformed in conjugates: + for row in transformed: + for u,v in row: + # In C[y]/(y^2+1), u+v*y is a unit when u^2+v^2 !=0. + need(gadd(gmul(u,u),gmul(v,v)) != ZERO, "Conjugate entry is not a unit") + permutation = [[zero,one],[one,zero]] + need(matrix(matrix(permutation,[[one,zero],[zero,y]]),permutation) + == [[y,zero],[zero,one]], "Permutation countercontrol") + return 8 + + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument("--sources",type=Path,default=PACKAGE / "sources/upstream") + parser.add_argument("--lanes",type=Path,default=PACKAGE / "frozen/lanes") + parser.add_argument("--out",type=Path,required=True) + args=parser.parse_args() + lane=args.lanes.resolve() + for path,digest in FILES.items(): + need(sha256((lane/path).read_bytes()).hexdigest()==digest,"Research pin: "+path) + sources={} + for path,digest in GIT_FILES.items(): + raw=(args.sources / path).read_bytes() + need(sha256(raw).hexdigest()==digest,"Git source pin: "+path) + sources[path]=raw + assembly=json.loads(sources["research/community-frontier1094-audit/ASSEMBLY.json"]) + selected=json.loads(sources["certificates/selected-result.json"]) + need(selected["kappa"]==assembly["kappa"],"Selected assembly") + epsilon,c,kappa=map(F,[assembly["outer"]["epsilon_positive"],assembly["outer"]["c_positive"],assembly["kappa"]]) + need(epsilon-kappa>F(99,100) and 1-epsilon-kappa>0 and 1-epsilon*(1+c)>0, + "Selected asymptotic margins") + ports=json.loads((lane/"circuit-interface/INTERFACE.json").read_bytes())["ports"] + need(len(ports)==112 and len(set(ports))==112 + and all(0 2^-15** +community release and preserves the earlier **2^-30 checkpoint** credits. It +covers submissions recorded on October 8, 2026, including earlier work on the +2^-59 family and parallel contributions. The final witness is contributed by +**Rohan Arun (@rohanarun), PR #49**, with its full dependency chain retained. It is not a ranking of contributors or a determination of priority. +Descriptions below summarize the submitted work; inclusion does not imply that a +PR's mathematics has been independently verified or its code incorporated. + +## Reviewed community release + +The [follow-up maintainer review](docs/research/community-followup-review.md) +accepts the PR #49 circuit increment conditionally on the original #109 framework +and the [PR #39 audit](docs/research/community-final-audit.md). It composes Rohan +Arun's order search and matching with Chafik Boukhalfa's reordered sums and exact +recovery, and RaD/hipotures's alternating producers and physical compiler. + +PR #45 by Alejandro Zarzuelo Urdiales and PR #26 by Ryan S are also incorporated. +Their pinned Lean builds, axiom audits and finite checks pass within their +stated scope; neither formalizes the whole multiplication theorem. +The [README contributor list](README.md#attribution) highlights incorporated +work, and the [integration record](docs/research/community-followup-integration.md) +preserves the reviewed heads. Earlier and parallel contributions remain credited. + +## The historical 2^-34 to 2^-30 interval + +The local complex-compression checkpoint was committed at `1c09a58` on October 8 +at 01:10 UTC. eumemic's related complex construction in [#3](https://github.com/CrocSwap/integer-mult-bounds/pull/3) +was submitted at 02:23 UTC, and Rohan Arun's [#8](https://github.com/CrocSwap/integer-mult-bounds/pull/8) +provides another geometric complex candidate. These parallel contributions deserve +recognition alongside the local implementation. dleen's [#4](https://github.com/CrocSwap/integer-mult-bounds/pull/4) +adds retained totals and sharing; eumemic's [#5](https://github.com/CrocSwap/integer-mult-bounds/pull/5) +and [#6](https://github.com/CrocSwap/integer-mult-bounds/pull/6) claim stronger savings +through resampling and circuit changes. They were submitted before this release, +but are not dependencies silently imported into its proof. + +Zhihao Chen's [#7](https://github.com/CrocSwap/integer-mult-bounds/pull/7) predates +this checkpoint's ternary implementation and contains the same F3 five-subset +motif, rational form and fixed-alphabet direction, with a different producer and +a stronger claimed bound. The checkpoint explicitly makes no priority claim for +that motif. Rohan Arun's [#9](https://github.com/CrocSwap/integer-mult-bounds/pull/9) +then refines its templates. Their submissions are credited even though this +checkpoint retains its separately checked producer and conservative assembly. + +## Contributors and submitted work + +Names follow the authors' supplied attribution where available; otherwise GitHub +handles are used. PR links preserve the full descriptions, co-credits and review +history. The [snapshot](docs/research/contribution-snapshot.json) pins every listed +submission, including closed PRs. The [review index](docs/research/contribution-review.md) +tracks acceptance separately. + +| Contributor | Submissions | Contribution described in submissions | +| --- | --- | --- | +| Aurel Prosz (Paureel) | [#1](https://github.com/CrocSwap/integer-mult-bounds/pull/1) | Parameter refinement and a scoped fixed-exponent supremum; later two-stage topology and paid endpoint-copy work are credited by the incoming integration chain. | +| Bortlesboat | [#2](https://github.com/CrocSwap/integer-mult-bounds/pull/2) | Aligned pair groups and exact producer/frame checks; this supplies an ingredient used by later submissions. | +| eumemic | [#3](https://github.com/CrocSwap/integer-mult-bounds/pull/3), [#5](https://github.com/CrocSwap/integer-mult-bounds/pull/5), [#6](https://github.com/CrocSwap/integer-mult-bounds/pull/6), [#13](https://github.com/CrocSwap/integer-mult-bounds/pull/13), [#15](https://github.com/CrocSwap/integer-mult-bounds/pull/15) | Parallel complex-network compression, Gaussian resampling, cheaper centers, auxiliary source frames and later producer/batching refinements. | +| dleen | [#4](https://github.com/CrocSwap/integer-mult-bounds/pull/4) | Composition of shared exclusions, retained totals and stage sharing, with additional complex-network headroom. | +| Zhihao Chen (jacklightChen) | [#7](https://github.com/CrocSwap/integer-mult-bounds/pull/7), [#16](https://github.com/CrocSwap/integer-mult-bounds/pull/16), [#21](https://github.com/CrocSwap/integer-mult-bounds/pull/21), [#23](https://github.com/CrocSwap/integer-mult-bounds/pull/23), [#29](https://github.com/CrocSwap/integer-mult-bounds/pull/29) | Ternary five-subset construction, nested controlled bases, translated frames, semantic/bulk assembly and two-stage integration. | +| Rohan Arun (rohanarun) | [#8](https://github.com/CrocSwap/integer-mult-bounds/pull/8), [#9](https://github.com/CrocSwap/integer-mult-bounds/pull/9), [#11](https://github.com/CrocSwap/integer-mult-bounds/pull/11), [#12](https://github.com/CrocSwap/integer-mult-bounds/pull/12), [#14](https://github.com/CrocSwap/integer-mult-bounds/pull/14), [#17](https://github.com/CrocSwap/integer-mult-bounds/pull/17), [#19](https://github.com/CrocSwap/integer-mult-bounds/pull/19), [#25](https://github.com/CrocSwap/integer-mult-bounds/pull/25), [#28](https://github.com/CrocSwap/integer-mult-bounds/pull/28), [#31](https://github.com/CrocSwap/integer-mult-bounds/pull/31), [#37](https://github.com/CrocSwap/integer-mult-bounds/pull/37), [#39](https://github.com/CrocSwap/integer-mult-bounds/pull/39), [#40](https://github.com/CrocSwap/integer-mult-bounds/pull/40), [#42](https://github.com/CrocSwap/integer-mult-bounds/pull/42), [#44](https://github.com/CrocSwap/integer-mult-bounds/pull/44), [#47](https://github.com/CrocSwap/integer-mult-bounds/pull/47), [#49](https://github.com/CrocSwap/integer-mult-bounds/pull/49) | Parallel geometric complex construction; ternary template and matching work; dimension, corner and composition refinements; exact checks and review packages; both-fixed compositions, weighted matching and hill-climbed summand/leave-one-out orders. | +| icekylinx | [#10](https://github.com/CrocSwap/integer-mult-bounds/pull/10), [#18](https://github.com/CrocSwap/integer-mult-bounds/pull/18), [#24](https://github.com/CrocSwap/integer-mult-bounds/pull/24), [#32](https://github.com/CrocSwap/integer-mult-bounds/pull/32), [#36](https://github.com/CrocSwap/integer-mult-bounds/pull/36) | Recursive batching, partial swaps, endpoint gauges, structured projector blocks and copied retained-center schedules. | +| RaD project (hipotures) | [#20](https://github.com/CrocSwap/integer-mult-bounds/pull/20), [#41](https://github.com/CrocSwap/integer-mult-bounds/pull/41) | Attributed research record and semantic precision, routing, phase-cell inverse and bulk-transfer work used by subsequent submissions; alternating pair-block producers and independent physical timeline/compiler checks. | +| Dominik Scholz (DominikScholz) | [#22](https://github.com/CrocSwap/integer-mult-bounds/pull/22), [#27](https://github.com/CrocSwap/integer-mult-bounds/pull/27), [#30](https://github.com/CrocSwap/integer-mult-bounds/pull/30), [#33](https://github.com/CrocSwap/integer-mult-bounds/pull/33), [#35](https://github.com/CrocSwap/integer-mult-bounds/pull/35), [#38](https://github.com/CrocSwap/integer-mult-bounds/pull/38) | Parameter and interface composition, near-balanced geometry, smaller two-stage dimensions and fixed local bases. | +| Ryan S (princezuda) | [#26](https://github.com/CrocSwap/integer-mult-bounds/pull/26) | Incorporated Lean checks of historical certificates and algebraic frame/movement/guard contracts; independent paired-circuit checker. Full multiplication is outside its formalized scope. | +| James Chang (jamesyc) | [#34](https://github.com/CrocSwap/integer-mult-bounds/pull/34) | Reversed two-stage geometry, exact controls and balanced assembly. | +| Chafik Boukhalfa (chafreaky) | [#43](https://github.com/CrocSwap/integer-mult-bounds/pull/43), [#46](https://github.com/CrocSwap/integer-mult-bounds/pull/46), [#48](https://github.com/CrocSwap/integer-mult-bounds/pull/48) | Changed-graph/fixed-basis composition, independent finite checkers, exact rational data recovery and reordered exclusion sums. | +| Alejandro Zarzuelo Urdiales (alejandrozu) | [#45](https://github.com/CrocSwap/integer-mult-bounds/pull/45) | Incorporated Gaussian parity and canonical arithmetic proofs, finite tensor execution, actual-profile precision accounting and mixed-center image/decoder checks. | + +The incoming two-stage work also credits **Swapnil Jain** for linked two-stage +batching development, alongside Aurel Prosz's topology and endpoint correction; +see [#29](https://github.com/CrocSwap/integer-mult-bounds/pull/29) and +[#36](https://github.com/CrocSwap/integer-mult-bounds/pull/36) for their pinned +external sources. The imported source notices and the completed audit record the scope in which +that development is used by the released composition. Zhihao's pinned note explicitly +credits Swapnil's research as the route to two-stage topology and macro batching. +Swapnil's later parallel repository is now [retained and checked](research/swapnil-parallel/README.md): +round-six network histograms are reproduced, both rounds' finite arithmetic is +cross-checked, and ten Lean declarations pass an axiom audit. This does not +replace the selected construction or independently prove his global transfer stack. + +Closed [#11](https://github.com/CrocSwap/integer-mult-bounds/pull/11) records +matching/prime-power generalizations and bounded negative screens without a new +headline. Closed [#30](https://github.com/CrocSwap/integer-mult-bounds/pull/30) +preserves a concurrent near-balanced construction overtaken by another submitted +bound. Both remain credited. Review, replication, bug reports and documented +negative results are also welcome contributions. + +## Attribution as integration proceeds + +- Keep original authorship, licenses, source pins and substantial AI-assistance + disclosures when importing code or proofs. +- Credit an idea's supplied source as well as the person who checks, improves or + integrates it. Preserve explicit predecessor credits rather than crediting only + the final PR in a chain. +- Record incorporated results, parallel work and pending review distinctly. + A merged file is not a claim of external mathematical acceptance. +- Retain acknowledgements when a bound is superseded, a PR closes, or a duplicate + implementation is not imported. Do not infer joint authorship of a proof from + a general acknowledgement. +- Corrections to names, contribution descriptions, omitted work and source links + are welcome through an issue or PR. This is a dated record, not an exhaustive + account of everyone who has helped outside the repository. + +Douglas Colkitt's local research and integration work used OpenAI Codex. +The original manuscript and the underlying Harvey–van der Hoeven analytic work +retain their existing attribution. Contributor-specific AI disclosures and +licenses remain attached to their original submissions; acknowledgement here +neither replaces those notices nor asserts independent human review. + +## Follow-ups after the checkpoint snapshot + +PRs #40–#49 were reviewed as a composed circuit and separate formal packages. +The [follow-up credit ledger](docs/research/community-followup-review.md#credit-for-the-composed-increment) +distinguishes each contribution, including parallel improvements. The original +39-PR snapshot remains an immutable historical record; the later reviewed heads +are recorded separately in the follow-up review and integration record. + +## Additional public parallel efforts + +- **Pranav Balakrishnan** ([pranavbalakri](https://github.com/pranavbalakri/integer-mult-bounds-improvement)) explored complex scratch sharing and announced a margin above 2^-31. The repository and [announcement](https://x.com/pranavbalakri/status/2108023898688401719) are recorded; a complete proof audit is outside this acknowledgement. +- **Kenny Daniel** ([platypii](https://github.com/platypii/integer-mult-bounds-lean), [announcement](https://x.com/platypii/status/2108110520876421162)) is developing a separate Lean formalization. Its end-to-end theorem remains work in progress. +- **mjones / @_numinit** [announced a parallel witness](https://x.com/_numinit/status/2108033292674990308) with a patch and Nix flake planned. No linked artifact or incorporated-code claim has been verified here. + +The [announcement ledger](docs/research/contributor-announcements.md) and +[source receipt](docs/research/contributor-social-sources.json) distinguish +verified posts, profile associations and unresolved account identities. + +- **Michiel Kosters** ([research repository](https://github.com/michielkosters/mathematics_ai/tree/2e0aa64ca09c87fc94f8575f59493f70cf929d71/problems/integer-multiplication-109); Douglas associates @one_line_proof) developed a parallel weighted-hypergraph/coordinate-frame candidate, compressed centers and aligned bit pairing. Our [review](research/parallel-announcements/README.md) reproduces the finite certificate with its transfer/precision limitations explicit. +- **Abe / @abe_asfaw**, via a suggestion supplied by Douglas, identified the redundant complex center and its historical 26.5% numerical gain. We [checked the scalar identity, counts and assembly arithmetic](research/parallel-announcements/README.md), and credit this parallel observation alongside the already preserved rank-h center research. +- **Jacob Sussman** ([jacobalansussman](https://github.com/jacobalansussman/wht-power-saving-lean/tree/fdfb7815c15ec43af0fb54818a6a57ae4025126b)) published a separate Lean 4 development on the Fourier side (OpenAI's family 130, not this project's multiplication theorem): a proof of #130's general frame lemma for that RAM model, and a kernel check of #193's complex word, rebuilt from the published data, inside a five-stage layout. It was built with AI agents (Claude) and makes no κ claim. Nothing in it has been replayed or reviewed here. + +## Circuit, precision and verification batch through #932 + +[Individual review and scope](docs/research/community-batch932-review.md). +The selected κ is unchanged; finite candidates retain their integration obligations. + +- **Aaron Wang / navinor (#921/#891/#867):** concurrent isolated tests, exact R439 phase-B class survey and historical source-provenance reconciliation. +- **just-mn (#903):** exact cached-pivot data-corner replay and differential controls. +- **Gareth Davidson / bitplane (#849/#837/#866/#915/#926/#813):** exact dyadic audit acceleration, bidirectional Horner, fractional-grid audit, restored target/two-sided compensation and independent outer Bernstein certificates. +- **Philipp / mightyOil (#883/#882/#879):** optimal scoped X4 pair compilation, grid-bounded JP8 synthesis and independent physical-layout verification. +- **Stephen Shore / nightangelflowerwin-ops (#916):** full historical X4 invoice/assembly admission for #883's primitive refinement. +- **dd-hemant (#816):** signed CK target forests and exact class floor, credited as the mechanism predecessor to #932. +- **ToikY (#901):** restored X4 target pairs with full scalar replay. +- **Ross Richardson (#932):** signed forests on the X4 compensation panel, complete cost and exact class floor. +- **martinxxx9 (#884):** shorter frame521 R439 circuit, literal cleanup and improved positive bounds. + +These contributions retain their original assistance notices and predecessor +credit, including Oscar Fennell, Sricharan Vagvala, Scott Woolsey Biggart, Sagar +Thakrar and Romain Hedouin. Parallel work is credited independently of selection. + +## Research and audits in batch #1047 + +[Individual contributions and scope](docs/research/community-batch1047-review.md). Parallel and corroborating contributions retain separate credit. + +- **ToikY / ToikY:** [#1000](https://github.com/CrocSwap/integer-mult-bounds/pull/1000), [#988](https://github.com/CrocSwap/integer-mult-bounds/pull/988), [#971](https://github.com/CrocSwap/integer-mult-bounds/pull/971), [#972](https://github.com/CrocSwap/integer-mult-bounds/pull/972). +- **woklerx / woklerx:** [#995](https://github.com/CrocSwap/integer-mult-bounds/pull/995), [#1009](https://github.com/CrocSwap/integer-mult-bounds/pull/1009), [#992](https://github.com/CrocSwap/integer-mult-bounds/pull/992), [#966](https://github.com/CrocSwap/integer-mult-bounds/pull/966), [#998](https://github.com/CrocSwap/integer-mult-bounds/pull/998), [#1020](https://github.com/CrocSwap/integer-mult-bounds/pull/1020), [#1035](https://github.com/CrocSwap/integer-mult-bounds/pull/1035), [#994](https://github.com/CrocSwap/integer-mult-bounds/pull/994). +- **Charles Bethin / cbethin:** [#1010](https://github.com/CrocSwap/integer-mult-bounds/pull/1010). +- **Ross Richardson / RossRichardson:** [#939](https://github.com/CrocSwap/integer-mult-bounds/pull/939). +- **mightyOil / mightyOil:** [#875](https://github.com/CrocSwap/integer-mult-bounds/pull/875). +- **D Lam / DLamdata:** [#979](https://github.com/CrocSwap/integer-mult-bounds/pull/979). +- **ellipsi2 / ellipsi2:** [#772](https://github.com/CrocSwap/integer-mult-bounds/pull/772). +- **ArnavSwiggy / ArnavSwiggy:** [#920](https://github.com/CrocSwap/integer-mult-bounds/pull/920). + +### Circuit and verifier checkpoint + +- **Cinna Davis / 1337isnot1337:** [#973](https://github.com/CrocSwap/integer-mult-bounds/pull/973). +- **woklerx / woklerx:** [#986](https://github.com/CrocSwap/integer-mult-bounds/pull/986), [#1002](https://github.com/CrocSwap/integer-mult-bounds/pull/1002), [#989](https://github.com/CrocSwap/integer-mult-bounds/pull/989), [#1040](https://github.com/CrocSwap/integer-mult-bounds/pull/1040), [#1047](https://github.com/CrocSwap/integer-mult-bounds/pull/1047). +- **ToikY / ToikY:** [#1001](https://github.com/CrocSwap/integer-mult-bounds/pull/1001). +- **Gareth Davidson / bitplane:** [#980](https://github.com/CrocSwap/integer-mult-bounds/pull/980), [#1006](https://github.com/CrocSwap/integer-mult-bounds/pull/1006). +- **martinxxx9 / martinxxx9:** [#976](https://github.com/CrocSwap/integer-mult-bounds/pull/976). + +### Construction and phase-verification checkpoint + +- **jeremykothe2 / jeremykothe2:** [#1004](https://github.com/CrocSwap/integer-mult-bounds/pull/1004), [#1005](https://github.com/CrocSwap/integer-mult-bounds/pull/1005), [#1018](https://github.com/CrocSwap/integer-mult-bounds/pull/1018), [#1022](https://github.com/CrocSwap/integer-mult-bounds/pull/1022), [#1028](https://github.com/CrocSwap/integer-mult-bounds/pull/1028), [#1031](https://github.com/CrocSwap/integer-mult-bounds/pull/1031), [#1042](https://github.com/CrocSwap/integer-mult-bounds/pull/1042). +- **Alexander Schwartzman / AlexS-scale:** [#1030](https://github.com/CrocSwap/integer-mult-bounds/pull/1030). +- **Cinna Davis / 1337isnot1337:** [#1019](https://github.com/CrocSwap/integer-mult-bounds/pull/1019). +- **Tekalign / tekuuu:** [#991](https://github.com/CrocSwap/integer-mult-bounds/pull/991). +- **Ali Romman / aliromman:** [#1029](https://github.com/CrocSwap/integer-mult-bounds/pull/1029). +- **thakrarsagar / thakrarsagar:** [#1041](https://github.com/CrocSwap/integer-mult-bounds/pull/1041). + +Rohan Arun receives explicit mechanism credit for #987’s slot search and first two slots; Hao Yan for #858’s T16 controller. Earlier construction and verification work by Chafik Boukhalfa, Jonathan Capalbo, icekylinx, DreamingOfClouds, eumemic and the full retained lineage remains credited. These are cumulative contributions, not transferred authorship. + +## Packing, independent audits and finite circuits in batch #1099 + +[Individual scope and attribution](docs/research/community-batch1099-review.md). Parallel contributions retain their own credit. + +- **rohanarun / rohanarun:** [#987](https://github.com/CrocSwap/integer-mult-bounds/pull/987), [#1056](https://github.com/CrocSwap/integer-mult-bounds/pull/1056), [#1063](https://github.com/CrocSwap/integer-mult-bounds/pull/1063), [#1082](https://github.com/CrocSwap/integer-mult-bounds/pull/1082), [#1094](https://github.com/CrocSwap/integer-mult-bounds/pull/1094). +- **jeremykothe2 / jeremykothe2:** [#1050](https://github.com/CrocSwap/integer-mult-bounds/pull/1050), [#1053](https://github.com/CrocSwap/integer-mult-bounds/pull/1053), [#1055](https://github.com/CrocSwap/integer-mult-bounds/pull/1055), [#1061](https://github.com/CrocSwap/integer-mult-bounds/pull/1061), [#1065](https://github.com/CrocSwap/integer-mult-bounds/pull/1065), [#1068](https://github.com/CrocSwap/integer-mult-bounds/pull/1068), [#1074](https://github.com/CrocSwap/integer-mult-bounds/pull/1074), [#1087](https://github.com/CrocSwap/integer-mult-bounds/pull/1087). +- **Cinna Davis / 1337isnot1337:** [#1090](https://github.com/CrocSwap/integer-mult-bounds/pull/1090). +- **David Breslauer / davidNbreslauer:** [#1072](https://github.com/CrocSwap/integer-mult-bounds/pull/1072). +- **thakrarsagar / thakrarsagar:** [#1049](https://github.com/CrocSwap/integer-mult-bounds/pull/1049), [#1051](https://github.com/CrocSwap/integer-mult-bounds/pull/1051), [#1069](https://github.com/CrocSwap/integer-mult-bounds/pull/1069), [#1059](https://github.com/CrocSwap/integer-mult-bounds/pull/1059), [#1023](https://github.com/CrocSwap/integer-mult-bounds/pull/1023), [#1045](https://github.com/CrocSwap/integer-mult-bounds/pull/1045), [#1062](https://github.com/CrocSwap/integer-mult-bounds/pull/1062). +- **steph4n / steph4n-gh:** [#1052](https://github.com/CrocSwap/integer-mult-bounds/pull/1052). +- **Josie Elliston / JosieElliston:** [#1091](https://github.com/CrocSwap/integer-mult-bounds/pull/1091). +- **flemhhh / flemhhh:** [#1048](https://github.com/CrocSwap/integer-mult-bounds/pull/1048) (reviewed; corrections pending). +- **woklerx / woklerx:** [#1096](https://github.com/CrocSwap/integer-mult-bounds/pull/1096), [#1099](https://github.com/CrocSwap/integer-mult-bounds/pull/1099), [#1077](https://github.com/CrocSwap/integer-mult-bounds/pull/1077), [#1008](https://github.com/CrocSwap/integer-mult-bounds/pull/1008), [#1017](https://github.com/CrocSwap/integer-mult-bounds/pull/1017). +- **ToikY / ToikY:** [#1092](https://github.com/CrocSwap/integer-mult-bounds/pull/1092), [#1016](https://github.com/CrocSwap/integer-mult-bounds/pull/1016), [#1003](https://github.com/CrocSwap/integer-mult-bounds/pull/1003). +- **martinxxx9 / martinxxx9:** [#1046](https://github.com/CrocSwap/integer-mult-bounds/pull/1046), [#1088](https://github.com/CrocSwap/integer-mult-bounds/pull/1088), [#1089](https://github.com/CrocSwap/integer-mult-bounds/pull/1089). +- **Adam Gall / adamgall:** [#1098](https://github.com/CrocSwap/integer-mult-bounds/pull/1098). +- **Gareth Davidson / bitplane:** [#1097](https://github.com/CrocSwap/integer-mult-bounds/pull/1097). +- **Ali Romman / aliromman:** [#1034](https://github.com/CrocSwap/integer-mult-bounds/pull/1034). +- **bbMisk / bbMisk:** [#1027](https://github.com/CrocSwap/integer-mult-bounds/pull/1027). + +Selected progression: Jeremy Kothe and Rohan Arun; T16 controller: Hao Yan. Independent current-owner/pricing checks: Josie Elliston and Sagar Thakrar. Earlier frame, geometry, native, bit and formalization contributors retain the full prior attribution. + +## Frozen 100-PR reconciliation: remaining historical contributions + +The [92-PR review](docs/research/community-reconciliation92-review.md) records individual contributions, replays, limitations and retained source trees. This includes parallel improvements, formal arithmetic, reproducibility tools and negative research; credit does not imply every historical claim was accepted. + +- **DaysSky (@DaysSky)**: [#162](https://github.com/CrocSwap/integer-mult-bounds/pull/162). +- **Dominik Scholz (@DominikScholz)**: [#22](https://github.com/CrocSwap/integer-mult-bounds/pull/22), [#27](https://github.com/CrocSwap/integer-mult-bounds/pull/27), [#33](https://github.com/CrocSwap/integer-mult-bounds/pull/33), [#35](https://github.com/CrocSwap/integer-mult-bounds/pull/35), [#38](https://github.com/CrocSwap/integer-mult-bounds/pull/38), [#63](https://github.com/CrocSwap/integer-mult-bounds/pull/63), [#68](https://github.com/CrocSwap/integer-mult-bounds/pull/68), [#81](https://github.com/CrocSwap/integer-mult-bounds/pull/81). +- **Joel Pulikkan (@GamingPuzzled)**: [#125](https://github.com/CrocSwap/integer-mult-bounds/pull/125). +- **Joseph Demarest (@JosephDemarest)**: [#83](https://github.com/CrocSwap/integer-mult-bounds/pull/83). +- **SovereignSteak (@SovereignSteak)**: [#102](https://github.com/CrocSwap/integer-mult-bounds/pull/102), [#122](https://github.com/CrocSwap/integer-mult-bounds/pull/122). +- **Thomas Marchand (@Th0rgal)**: [#106](https://github.com/CrocSwap/integer-mult-bounds/pull/106), [#121](https://github.com/CrocSwap/integer-mult-bounds/pull/121), [#133](https://github.com/CrocSwap/integer-mult-bounds/pull/133), [#145](https://github.com/CrocSwap/integer-mult-bounds/pull/145), [#146](https://github.com/CrocSwap/integer-mult-bounds/pull/146). +- **Alejandro Zarzuelo Urdiales (@alejandrozu)**: [#70](https://github.com/CrocSwap/integer-mult-bounds/pull/70), [#75](https://github.com/CrocSwap/integer-mult-bounds/pull/75). +- **Andrey Mas (@an664)**: [#128](https://github.com/CrocSwap/integer-mult-bounds/pull/128). +- **chafreaky (@chafreaky)**: [#66](https://github.com/CrocSwap/integer-mult-bounds/pull/66), [#71](https://github.com/CrocSwap/integer-mult-bounds/pull/71), [#79](https://github.com/CrocSwap/integer-mult-bounds/pull/79), [#84](https://github.com/CrocSwap/integer-mult-bounds/pull/84), [#88](https://github.com/CrocSwap/integer-mult-bounds/pull/88), [#91](https://github.com/CrocSwap/integer-mult-bounds/pull/91), [#141](https://github.com/CrocSwap/integer-mult-bounds/pull/141), [#182](https://github.com/CrocSwap/integer-mult-bounds/pull/182), [#189](https://github.com/CrocSwap/integer-mult-bounds/pull/189). +- **eumemic (@eumemic)**: [#5](https://github.com/CrocSwap/integer-mult-bounds/pull/5), [#6](https://github.com/CrocSwap/integer-mult-bounds/pull/6), [#13](https://github.com/CrocSwap/integer-mult-bounds/pull/13), [#15](https://github.com/CrocSwap/integer-mult-bounds/pull/15), [#114](https://github.com/CrocSwap/integer-mult-bounds/pull/114), [#117](https://github.com/CrocSwap/integer-mult-bounds/pull/117), [#129](https://github.com/CrocSwap/integer-mult-bounds/pull/129), [#131](https://github.com/CrocSwap/integer-mult-bounds/pull/131), [#137](https://github.com/CrocSwap/integer-mult-bounds/pull/137), [#142](https://github.com/CrocSwap/integer-mult-bounds/pull/142), [#143](https://github.com/CrocSwap/integer-mult-bounds/pull/143), [#154](https://github.com/CrocSwap/integer-mult-bounds/pull/154). +- **Abhinav Ramachandran (@geckods)**: [#138](https://github.com/CrocSwap/integer-mult-bounds/pull/138). +- **gupt1156 (@gupt1156)**: [#87](https://github.com/CrocSwap/integer-mult-bounds/pull/87). +- **Andrzej Marszałek (@hipotures)**: [#41](https://github.com/CrocSwap/integer-mult-bounds/pull/41). +- **huxint (@huxint)**: [#77](https://github.com/CrocSwap/integer-mult-bounds/pull/77), [#188](https://github.com/CrocSwap/integer-mult-bounds/pull/188). +- **Avi Eisenberg (@ikeboy)**: [#110](https://github.com/CrocSwap/integer-mult-bounds/pull/110). +- **Zhihao Chen (@jacklightChen)**: [#7](https://github.com/CrocSwap/integer-mult-bounds/pull/7), [#16](https://github.com/CrocSwap/integer-mult-bounds/pull/16), [#21](https://github.com/CrocSwap/integer-mult-bounds/pull/21), [#23](https://github.com/CrocSwap/integer-mult-bounds/pull/23), [#29](https://github.com/CrocSwap/integer-mult-bounds/pull/29), [#97](https://github.com/CrocSwap/integer-mult-bounds/pull/97). +- **James Chang (@jamesyc)**: [#34](https://github.com/CrocSwap/integer-mult-bounds/pull/34), [#124](https://github.com/CrocSwap/integer-mult-bounds/pull/124). +- **maxime-fleury (@maxime-fleury)**: [#92](https://github.com/CrocSwap/integer-mult-bounds/pull/92), [#94](https://github.com/CrocSwap/integer-mult-bounds/pull/94). +- **rohanarun (@rohanarun)**: [#14](https://github.com/CrocSwap/integer-mult-bounds/pull/14), [#17](https://github.com/CrocSwap/integer-mult-bounds/pull/17), [#19](https://github.com/CrocSwap/integer-mult-bounds/pull/19), [#25](https://github.com/CrocSwap/integer-mult-bounds/pull/25), [#28](https://github.com/CrocSwap/integer-mult-bounds/pull/28), [#31](https://github.com/CrocSwap/integer-mult-bounds/pull/31), [#40](https://github.com/CrocSwap/integer-mult-bounds/pull/40), [#42](https://github.com/CrocSwap/integer-mult-bounds/pull/42), [#44](https://github.com/CrocSwap/integer-mult-bounds/pull/44), [#47](https://github.com/CrocSwap/integer-mult-bounds/pull/47), [#65](https://github.com/CrocSwap/integer-mult-bounds/pull/65), [#67](https://github.com/CrocSwap/integer-mult-bounds/pull/67), [#78](https://github.com/CrocSwap/integer-mult-bounds/pull/78), [#80](https://github.com/CrocSwap/integer-mult-bounds/pull/80), [#82](https://github.com/CrocSwap/integer-mult-bounds/pull/82), [#85](https://github.com/CrocSwap/integer-mult-bounds/pull/85), [#86](https://github.com/CrocSwap/integer-mult-bounds/pull/86), [#89](https://github.com/CrocSwap/integer-mult-bounds/pull/89), [#93](https://github.com/CrocSwap/integer-mult-bounds/pull/93), [#95](https://github.com/CrocSwap/integer-mult-bounds/pull/95), [#98](https://github.com/CrocSwap/integer-mult-bounds/pull/98), [#100](https://github.com/CrocSwap/integer-mult-bounds/pull/100), [#103](https://github.com/CrocSwap/integer-mult-bounds/pull/103), [#107](https://github.com/CrocSwap/integer-mult-bounds/pull/107), [#108](https://github.com/CrocSwap/integer-mult-bounds/pull/108), [#109](https://github.com/CrocSwap/integer-mult-bounds/pull/109), [#111](https://github.com/CrocSwap/integer-mult-bounds/pull/111), [#113](https://github.com/CrocSwap/integer-mult-bounds/pull/113), [#116](https://github.com/CrocSwap/integer-mult-bounds/pull/116), [#118](https://github.com/CrocSwap/integer-mult-bounds/pull/118), [#123](https://github.com/CrocSwap/integer-mult-bounds/pull/123), [#178](https://github.com/CrocSwap/integer-mult-bounds/pull/178), [#185](https://github.com/CrocSwap/integer-mult-bounds/pull/185), [#187](https://github.com/CrocSwap/integer-mult-bounds/pull/187). diff --git a/research/completed-prefix-outer/sources/upstream/LICENSE b/research/completed-prefix-outer/sources/upstream/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/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/completed-prefix-outer/sources/upstream/NOTICE b/research/completed-prefix-outer/sources/upstream/NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/completed-prefix-outer/sources/upstream/certificates/selected-result.json b/research/completed-prefix-outer/sources/upstream/certificates/selected-result.json new file mode 100644 index 0000000000..ae6a99f28a --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/certificates/selected-result.json @@ -0,0 +1,222 @@ +{ + "status": "Maintainer-reviewed conditional finite construction; see the integration receipt for publication and PR resolution status", + "kappa": "836330098538459/500000000000000000", + "decimal": "0.001672660197076918", + "source_prs": [ + 1094, + 1087, + 1082, + 1074, + 1068, + 1065, + 1063, + 1061, + 1056, + 1055, + 1053, + 1050, + 1042, + 1031, + 1028, + 1022, + 1018, + 1005, + 1004, + 987, + 942, + 890, + 870, + 869, + 858, + 799, + 741, + 699, + 685, + 676, + 664, + 660, + 659, + 656, + 655, + 653, + 658, + 649, + 645, + 635, + 589, + 555, + 545, + 626, + 623, + 622, + 620, + 617, + 615, + 604, + 601, + 596, + 592, + 591, + 593, + 599, + 588, + 543, + 584, + 586, + 583, + 582, + 579, + 576, + 575, + 574, + 571, + 569, + 568, + 567, + 564, + 562, + 561, + 559, + 558, + 552, + 550, + 548, + 541, + 535, + 510, + 503, + 531, + 523, + 493, + 514, + 507, + 484, + 496, + 505, + 522, + 520, + 472, + 458, + 445, + 442, + 425, + 433, + 370, + 361, + 315 + ], + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "proof": "docs/research/community-batch1099-review.md", + "proof_supplements": { + "research/e8-bit-r420/README.md": "9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f", + "research/complex-571-free4fc8/NOTICE.md": "a4c084abdc1c7a9ac683eeb11124335d51cff8a6deba6ee92ba5a12bceaa2c97", + "research/complex-multicold/proof/CONSTRUCTION.md": "27ece5e1c11b90d97a808b56eff897b998c10e61016db95867f84e6e6aef132f", + "research/complex-multicold/vendor/pr559/PROOF.md": "d5d498edc56fdef8c5798af7f5ec66948bd2f66c553b9efe366cdaab01bd3453", + "research/structural-gain/frontier-composition/README.md": "70f0f791cbe3b2603f85d85bb9055aa0ee1df6dc06ba82fc1921356948312887", + "research/complex-joint-prefix/proof/CONSTRUCTION.md": "a92e610e7a598d99c612d1b63d1a03a49c0cd1e15ddd29fa55c465ddd8c18105", + "research/kernel-frame-coalescing/PROOF.md": "fa8b2f36b9590ee80ff45d3f7724f8c7de8ad29a29f366d5133010c77e41fe1b", + "research/complex-571-hpeq5/README.md": "4000b37f6c07c09d971dc4010ceb137c13340f3a8809d3272046ccaf746c3e2b", + "research/hyperplane-end-lean/PROOF.md": "1cbce5cf0ff0152f71e8ae7bef25841d1ce13010af248ff7209182d2328c21c9", + "docs/research/community-hyperplane599-review.md": "3298cd0d451541508af232cac72efbd7c10580e6c6ad493a855ab0faa01ade8c", + "research/complex-571-cold14-b3/README.md": "1945785785c153c7d0e8d4c071adabe626c1091b71721ff85d2d67191b376b96", + "research/complex-571-cold14-b3/PROOF-NOTE.md": "1cf592cbc8ab8e21d2dd8c1e945a5c64c6d5cde1216fb06e05a36c1c6ec6613d", + "scripts/verify_cold617_interface.py": "95d7a9094c05ad975fb72f5ab7605593003245a503c8456764987e512028fa6a", + "docs/research/community-cold617-review.md": "b3f2bcbae1249f1f651032022ce1e6e2bfb3f563ce580bf53671f50a074d7046", + "research/complex-k492-owner-repair/README.md": "ee5a1ace4828f7a073be97e95c2d931988774dd3a29a877e65abdf429aeec902", + "research/complex-k492-owner-repair/PROOF-NOTE.md": "337d70fe7abd9afca1d90954c23bde87f4dc27888cc1a6b4bb80506fd6fbf8c5", + "research/complex-k492-owner-repair/PROOF-NOTE-R.md": "22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed", + "docs/research/community-k492-review.md": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47", + "scripts/verify_frontier626.py": "2207bd0ef04a19ef276869085afdedad80a0938fa75db5e1aa7ab73fd3429444", + "scripts/verify_frontier626_bindings.py": "cda63ff41c6d6e2e352c7bf75b84e690c0ce57e4ec6c0355573bb5d9b1f98280", + "scripts/verify_frontier588_bindings.py": "6d1932eea7b1936598118ea8e607b09c29b6e31b749ec41bbe0744ea4f0b606d", + "scripts/verify_hpe_lean_binding.py": "52aa1d23641e4c716b43c98f6b883ad042087dd03a9d01369e8e6a735b07aa03", + "research/hyperplane-end-lean/HyperplaneEnd/Exact.lean": "eebf3a3982af7ab9be45777b272a6aaa523206fa7667ceb6df63ad6589fd8183", + "docs/research/community-frontier741-review.md": "4634694fa75ea9e749ecf19d3db3e4d82effe3b61a2efdf08ac5a97275fb676a", + "research/complex-sw4-frame8/PROVENANCE.md": "c7648719b01dd93af2c3a2c6e951a54711d13892dc4bd4339d16edb4c37c9bf0", + "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d", + "scripts/verify_frontier741.py": "215ee6a12de8dc2392e6811a1b8f2140035f6b2d2a0d2100ff4bd2fdcb8bb39b", + "scripts/verify_frontier741_bindings.py": "eff455167e2fd0bc9a67d35241d0e69d8edc58f3a23e776dcfe8f500ca8e8d67", + "docs/research/community-frontier799-review.md": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052", + "scripts/verify_frontier799.py": "19fe1b32079095160dc00fe2f7df75e0fcbc82cff37f7159b755c8a63bd5ce99", + "scripts/verify_frontier799_bindings.py": "43897b3c99212d6134870898a1840f32898aa1b3679b299e654901568ad7e19b", + "research/gauge44-frames-x/PROOF-NOTE-FRAMES-X4.md": "39c50420ebb6e8813706a49b2cf759f277c4afac9f6780fc0a7ac6a5fb86e036", + "docs/research/community-frontier890-review.md": "cd03b7c2c6c09db2cfa89ae40133ae44e1deb6e32ec5ddd23aacecc9c50f2fea", + "scripts/verify_frontier890.py": "88ea38dbef62dd7c0dd46e212618520cc89213edddb2032800e5509993958175", + "scripts/verify_replay_coverage.py": "babe5941d7e6dac4248613ef01f950ee7bb6199e7355021aea4cf854fd1b91c5", + "scripts/verify_frontier741_bridge_coverage.py": "9a14f26762b6126eb54ed43db90371773374fe98733ada80ee871a74afa3b836", + "certificates/replay-coverage/pr741-sw4-v1.json": "7acd5033bc78e3f473718269edaa267c2785d84fbe95ccf6815a33dcf58c2756", + "research/complex-t21-owners/PROOF.md": "78721b32fceb34b21b8e77c95381c38c60276e72e6d9c2e9c6262cb347457def", + "research/complex-t21-owner-bound/PROOF.md": "2aa0aa6ec1d87402138564c38749b5ca0f058c16817efdf58a2685d2d90cb417", + "research/gauge44-barch/PROOF-NOTE-BARCH.md": "c24f211b09358b25d6cf47dd18e4bbd8bcf4ecf279e6f1c6c90613cfa230818d", + "research/complex-double-replica-owners/PROOF.md": "db99599e3966bec253c577c23915e2a2899c4c4e8568044efc11c7918b137bbc", + "docs/research/community-batch952-review.md": "04db59dfc2c31453229b6061bbf59547e71ce3abdc0ce0f6779144bb0dde127b", + "scripts/verify_frontier942.py": "27c6713532d9f53f55dfff4884d55a2d9ae74b68156e37a44596c0418fbed5b7", + "research/complex-t37-owners/PROOF.md": "09b39ad0d5f1f59f54dcff15c16640f7a7acf27e6597660acaf957b95c7e8510", + "research/complex-t37-owners/ALL-T-PROOF.md": "4c0c71ccd0afb850538af1b467e5208b7eb3edd0260fded84e02a8c01dfc868b", + ".github/workflows/t37-owners.yml": "c13acc2902c007237103072b7ec10caf5ca21c1b319d27934f194af2f7d87026", + "docs/research/community-batch1047-review.md": "a6271faf5db0afe3ff7d24a34a3be7a959cdc33ee37784572fba014ee5358787", + "scripts/verify_frontier1042.py": "700fdcaeb6e8f57f6e63c71c2dd1652fc5b183e8d706cd092779bdc0d271e854", + "docs/research/community-batch1099-review.md": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "scripts/verify_frontier1094.py": "c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949", + "research/community-batch1099-audit/check_frontier1094.py": "2608ef213260a43d09a40b3429742f7a5f280861b54acae66400a7c29a123f51" + }, + "review": "docs/research/community-batch1099-review.md", + "validation": "docs/research/community-batch1099-integration.json", + "reproduce": "make frontier1094-verify", + "scope": "Finite composition under inherited all-size/compiler, common-label/mutable-source, whole-call hosting, precision/tape, analytic and bit H1-H5 assumptions. Not a full Lean multiplication theorem.", + "previous_kappa": "1672188119205421/1000000000000000000", + "previous_record": "certificates/checkpoints/frontier1042.json", + "audited_source_head": "0fc329d0bec93ca7cd288eaea1295172e8789810", + "reviewed_dependency_heads": { + "588": "6d0e53b66c29abd17981881a09eaff41ac862d85", + "543": "2065fe4f72a914d907f1046603f5a36f17018535", + "568": "71c99ac935a33bb7b59a1b4a7af8725a939b0b90", + "569": "1424da81263a5305b35e4cf74ef686c275f03f3f", + "571": "b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3", + "575": "eac6f7e378ab622dac50a2fd4b7ef6eab014de44", + "583": "89be768f0157f5a3d8e4db69cf1748768605eac9", + "586": "4846fee5b06af770e9b3a10c36200f673d656725", + "591": "f622547244bf6d895a571a7b035142ba66279806", + "592": "1f471c445c06a45a32e2c47e8d74c8264b68356b", + "593": "fdb6dcc6d7bc29764c5b6b4d32b7fa050acf74a4", + "596": "7732dd5e46863ff294b5e443661cb9d99abf4e01", + "599": "bc13c8a3e000442606bd2dbe8583a17649ba6c32", + "601": "529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550", + "604": "1b795c5d7dea746ba310572585c0ef067574b4a6", + "615": "bf8a49a34350599763cced8592db81dc62c2c1c0", + "617": "904d62855723c00f8acef9a287a10768598fdeb2", + "622": "f69477f4f6d3c7eb1f740b166881bffed4ffa9f6", + "623": "e39a615ca601ce5d62abeb24f3fcdb8644ca1005", + "626": "660de893d27bb7abd1d5b01b1640207528a5c851", + "589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46", + "741": "e516b1463606840a15f80aac1995d64ce0092e89", + "799": "80e6463157cfc80b85af09e7e2f14748fe2dac60", + "858": "ae2e25fee91540c83ceee5a60e3b07422ce21c7d", + "869": "73e86f69bf9a391e3c334999f7bbe3825dc42759", + "870": "b734850dc348800942f0ffd1f0723fdec7539b2b", + "890": "4b3bd8cbe8e3e81c44161017c9b72c905a8040a8", + "942": "1960cfa919a0945d0ca4cb14ea96237000037903", + "1004": "1974578f82a30158dd5fcdcdf226b83df8e7196f", + "1005": "779e80aef469bc3a28b19f1adde199871a9a22e3", + "1018": "eac7547cb191f875d5f5ea5f9bbb1d2b8c51c4ef", + "1022": "58618bcbfe88a252467755fc283c04c3db5ca4fd", + "1028": "be4bd89cb4483dcee43257200cd27601f938f13d", + "1031": "e900534f0beda892c726723524203b97471fb9a3", + "1042": "7e8ef087c02a77038a28a337a7ee3a77039cac0d", + "1094": "0fc329d0bec93ca7cd288eaea1295172e8789810", + "1087": "589d1cedf5ef5f231182f4ec86408616311a8af0", + "1082": "0c2e294ec204e83846d27344f829d15ed9ee7cc6", + "1074": "052afc128954f7b6a2b3c409eb4d72248e4020f2", + "1068": "cc71375eae4e8754da0f5d940cb519d66625fb2e", + "1065": "387d935e354a931d636e2c5e6ee63a6910f78a1b", + "1063": "d9377d32e0c97e41338e704c3960fd6f2fa73806", + "1061": "223f581afb1d63d5f8476a69040617e11bcd50e4", + "1056": "d0201efbd68c4acc9832b84bcc986c8781b83c4f", + "1055": "a8ea308976f1709eef0a328463f010cf51469277", + "1053": "6f92ce8884929c9fd4730c86a28e2e3735de02af", + "1050": "c87242f846cfab8c0b97fd889b5fecb0eacef939", + "987": "5142511af0437572aca71b35d1987cd2b47bb5e3" + } +} diff --git a/research/completed-prefix-outer/sources/upstream/research/community-frontier1094-audit/ASSEMBLY.json b/research/completed-prefix-outer/sources/upstream/research/community-frontier1094-audit/ASSEMBLY.json new file mode 100644 index 0000000000..5fd676df06 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/community-frontier1094-audit/ASSEMBLY.json @@ -0,0 +1,345 @@ +{ + "status": "PASS_GAUGE44_NATIVE_EXACT_GLOBAL_ASSEMBLY", + "kappa": "836330098538459/500000000000000000", + "kappa_decimal": "0.001672660197076918", + "complex_lower": "67018507072324140917/40000000000000000000000", + "complex_decimal": "0.001675462676808103522925", + "bit_lower": "1733427039589844234749/1000000000000000000000000", + "bit_decimal": "0.001733427039589844234749", + "binding": "complex", + "gain_over_pr635_percent": "2.225753072846734155686237293080565286991751430561837568524869952894006", + "complex_profile": { + "1": 349604, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1152, + "48": 4866 + }, + "provider_counts": { + "gauge44": 144 + }, + "surcharge_model": { + "complex": false, + "bit": true + }, + "conservative_complex_lower": "1675462673946628390003/1000000000000000000000000", + "conservative_complex_decimal": "0.001675462673946628390003", + "conservative_kappa": "104541262139063/62500000000000000", + "conservative_kappa_decimal": "0.001672660194225008", + "conservative_moments": [ + { + "side": "conservative_complex", + "surcharge": true, + "endpoint": "1675462673946628390003/1000000000000000000000000", + "accept": true, + "mercator": [ + "-9477943787127246252114078401047446902088349/3369993333393829974333376885877453834204643052817571560137951281152", + "-37911775148508985008456313604189787608353395/13479973333575319897333507543509815336818572211270286240551805124608" + ], + "base_two": [ + "-14062260903435109658771/5000000000000000000000000000000000000000000000", + "-28124511806870219317401/10000000000000000000000000000000000000000000000" + ] + }, + { + "side": "conservative_complex", + "surcharge": true, + "endpoint": "418865668486657097501/250000000000000000000000", + "accept": false, + "mercator": [ + "785122817737487251360323365382501180303679/6739986666787659948666753771754907668409286105635143120275902562304", + "1570245635474974502720646730765002360607359/13479973333575319897333507543509815336818572211270286240551805124608" + ], + "base_two": [ + "29121704837234194839/250000000000000000000000000000000000000000000", + "1164878193489367793701/10000000000000000000000000000000000000000000000" + ] + } + ], + "conservative_bootstrap": [ + { + "exponent": "1672719936901733723941013678754606046077578825189978511794824059037242793668975202328129659991/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "2742737044894666061983645782720007294031171810021488205175940962757206331024797671870340009/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "4785575320504" + }, + { + "exponent": "1675458078593085218312040660818153764816233104573318346297481252562039366001553167060724596064338254398640072154860452679089426701487866530027/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "4595353543171690956663719172288555376892426681653702518747437960633998446832939275403935661745601359927845139547320910573298512133469973/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1704765476910090189" + }, + { + "exponent": "1675462666247285054830442970288416897030906497822964321770204104752241064441971590857087666732381866167177964126563572213205210286771447648612054886738219829723627595016989839870190733879919/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "7699343335172554354248909156340703499177035678229795895247758935558028409142912333267618133832822035873436427786794789713228552351387945113261780170276372404983010160129809266120081/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "607288598888548790921228" + }, + { + "exponent": "1675462673933728427631015964717263684197943281973496759641273321854676680565638975150449678698528843599367004823064750102366777359345125457905262786558290059054631287442458769941662955873102918023405251635883578323072818311236251497950243/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "12899962371981359820062369173666715026503240358726678145323319434361024849550321301471156400632995176935249897633222640654874542094737213441709940945368712557541230058337044126897081976594748364116421676927181688763748502049757/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "216334415105865784879411203134" + }, + { + "exponent": "1675462673946606776597547753757284468914397348111672791536762618650746006847119006092287439220975223568432626917668165205209921472872117804273807041934415238338810525338012084376652944279070588792188733715069029648364515985850564644058847673533039191645232667825478722147025414307379271/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "21613405449570780041584457212648888327208463237381349253993152880993907712560779024776431567373082331834794790078527127882195726192958065584761661189474661987915623347055720929411207811266284930970351635484014149435355941152326466960808354767332174521277852974585692620729/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "77064807811065157671403130893305387" + }, + { + "exponent": "1675462673946628353790543236906837018994268067942761233727427353818691210464251050376758476302106776989352719214605910694555958443797426439860448154703028630733183575665927368014487684549879669285828463034853831749901954212088671168864170425089292905036474832925101921361968931044466640582512201309590690137287164584230136330974172187/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "36212454087630489034377341929057238766272572646181308789535748949623241523697893223010647280785394089305444041556202573560139551845296971369266816424334072631985512315450120330714171536965146168250098045787911328831135829574910707094963525167074898078638031068955533359417487798690409309862712835415769863669025827813/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "27452796172306184037585992127352896661365" + }, + { + "exponent": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "60672615155830892504866159425812143481842807745708742390039720572742681899922994299723138147627539676157163558630049165342230540303990435022760921983655619602865954469864532501692650664396192418996918742426594989159115524057826701297449314614012679279474573170653301881712099856009097193307827108038289389824500519357700940684138332222665251616554008955511446561/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "9779509468522638102470520685957791421407368732" + } + ], + "conservative_outer": { + "bit_positive": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "60675290618504839133256162425812143481842807745708742390039720572742681899922994299723138147627539676157163558630049165342230540303990435022760921983655619602865954469864532501692650664396192418996918742426594989159115524057826701297449314614012679279474573170653301881712099856009097193307827108038289389824500519357700940684138332222665251616554008955511446561/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "29574537326053371609997/1000000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "leaf_saving_above_bit": "60673615155830892504866159425812143481842807745708742390039720572742681899922994299723138147627539676157163558630049165342230540303990435022760921983655619602865954469864532501692650664396192418996918742426594989159115524057826701297449314614012679279474573170653301881712099856009097193307827108038289389824500519357700940684138332222665251616554008955511446561/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "30338483040589392880823022037615453236082270616691945382876378443563595241219107110140996331131869915084282056176876955131439112988436587462215118761287505810997954474010282595226722466243626344965957678562633098387138765110170924053735498191482281813035989136012036928176770453431377943352031841919288685815056951851742432052679341610813268107336320339423500615248383445991044488553439/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "837731336973314194971285679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499162268663026685805028714320771926366195018023537615453236082270616691945382876378443563595241219107110140996331131869915084282056176876955131439112988436587462215118761287505810997954474010282595226722466243626344965957678562633098387138765110170924053735498191482281813035989136012036928176770453431377943352031841919288685815056951851742432052679341610813268107336320339423500615248383445991044488553439/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "lambda_above_tau": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "60676966081178785761646104750521524977003674489546316577896238729934936191180604260002565404945639753162863835491901537802554383140431804973595579753115315612430931708942548846073047798441722554464417049775930592966696527139084274702460155498488621452773275721338687869032820381435926540005945395938433380727307211530592902394748507722145893915613324817179223895748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "1675462673946628389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "30338483040589392880823022037615453236082270616691945382876378443563595241219107110140996331131869915084282056176876955131439112988436587462215118761287505810997954474010282595226722466243626344965957678562633098387138765110170924053735498191482281813035989136012036928176770453431377943352031841919288685815056951851742432052679341610813268107336320339423500615248383445991044488553439/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "lambda_prime_below_one": "837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "499999999999999999999999500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561", + "epsilon_below_one": "837731336973314194971660679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561", + "guard_width": "837731336973314194971660679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561", + "K_geometry": "375837731336973314194971285679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561000000000000000000000000", + "K_dominates_log": "837731336973314194971284841496736660490787005176705318690283924401331592232576857638707021450726275766237447232463371304022828084819454176738475971293619589414740012677825482625589507741108478692279088531710847665316637548159833145239206200847507638579362888947282828357888064599486154554105042582557758068684896334851164745562886400180099487236006473446138583635095732339918110198019723890329294934947176248383445991044488553439/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561000000000000000000000000", + "record_suffix": "837731336973314194971660679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561", + "phase_local": "6701850695786513559772784596093252097125660840538397146037708030084487974552442208533761854762192525995250472914540281898432853691581315490818402180374563477179234181348812941948603826423036500525692031268005463250554933798221401456529234845076311170203214401606906855666636140647401896056867649408538112465220673441416143944857487737217902462867251082170445706883741489963953605891281039768391983515073103248383445991044488553439/4006701850695786513559769285433824589070439855811699076374111341835066464436936988972451491238070247143118872029350945040679325743550584984358948487096092507300302279049909699953512016364207917739238186220270050989240272338571498935212902889879118632607570116014468141745495712086911903704574585836372548976453183745264645690513479544385186060543578565267113493855141309437284611995078012932432071644091572488000000000000000000000000", + "phase_boundary": "1340370139157302711954156249033580840773776191179136046748634562031316425002851030572568864305994811500152849433784249354972258851113328003659612503500557636937410941421052979138990735056702309135143055051964671858337062941022253286206922941781405084147121590032393459270066471117878932397198980310498931302673677229699591534073852229069054028004398868479650622770693940136264009828870693822734668241815112848383445991044488553439/801340370139157302711953857086764917814087971162339815274822268367013292887387397794490298247614049428623774405870189008135865148710116996871789697419218501460060455809981939990702403272841583547847637244054010197848054467714299787042580577975823726521514023202893628349099142417382380740914917167274509795290636749052929138102695908877037212108715713053422698771028261887456922399015602586486414328818314497600000000000000000000000", + "gamma_sublinear": "1/2000000000000000000000000", + "cell_above_band": "999999999999999999999998499162268663026685805028839320771926366195018023537615453236082270616691945382876378443563595241219107110140996331131869915084282056176876955131439112988436587462215118761287505810997954474010282595226722466243626344965957678562633098387138765110170924053735498191482281813035989136012036928176770453431377943352031841919288685815056951851742432052679341610813268107336320339423500615248383445991044488553439/2003350925347893256779884642716912294535219927905849538187055670917533232218468494486225745619035123571559436014675472520339662871775292492179474243548046253650151139524954849976756008182103958869619093110135025494620136169285749467606451444939559316303785058007234070872747856043455951852287292918186274488226591872632322845256739772192593030271789282633556746927570654718642305997539006466216035822045786244000000000000000000000000", + "prime_interval_packing": "837731336973314194971660679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561", + "alpha_positive": "1675462673946628389942820520724810294295768981764089865454201653784639646849700479195143426209507168656096450901331501388938546028642577221607036858305183001952524893916537976814591553267098196097052366065467221320350679869597200046852067435737336714525627390755800546544852075463474117625928272129126380125332864492931876059747829448328357055183327131835325315527759412000494609582771340444338250446393737248383445991044488553439/1001675462673946628389942321358456147267609963952924769093527835458766616109234247243112872809517561785779718007337736260169831435887646246089737121774023126825075569762477424988378004091051979434809546555067512747310068084642874733803225722469779658151892529003617035436373928021727975926143646459093137244113295936316161422628369886096296515135894641316778373463785327359321152998769503233108017911022893122000000000000000000000000", + "alpha_below_one": "999999999999999999999999500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561/1001675462673946628389942321358456147267609963952924769093527835458766616109234247243112872809517561785779718007337736260169831435887646246089737121774023126825075569762477424988378004091051979434809546555067512747310068084642874733803225722469779658151892529003617035436373928021727975926143646459093137244113295936316161422628369886096296515135894641316778373463785327359321152998769503233108017911022893122000000000000000000000000", + "alpha_below_one_fourth": "248743402994540028707542759818889226522606722006467102407927757210907014380458861331583074776169883277788833050933102563653519312943268984300827243585200598704316367546702818270279909469495896662605334272701410965507166341291121483403954363181707577823447504860148458312548629929968519863909983342644157930902991119586108479597344642075745771728790333197359268050418572427829793640109604467832666227309329543251616554008955511446561/1001675462673946628389942321358456147267609963952924769093527835458766616109234247243112872809517561785779718007337736260169831435887646246089737121774023126825075569762477424988378004091051979434809546555067512747310068084642874733803225722469779658151892529003617035436373928021727975926143646459093137244113295936316161422628369886096296515135894641316778373463785327359321152998769503233108017911022893122000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "short_record_fallback": "499160865075440791612030839141788690924313551030703512359372709471704575676772232577248094260989590037124504420170767295913424395564055810616345848851484588498495175856013482386559165475957975482129857812683169917049954841730039197886969440433134408492287411163213241915241893218288769289749867046000978510649085546885466934071333612987355001884424573153735198140914060592289673183685157704266276297823882807293425672956078579891508733380331018934747653825458606878394857095709300967766342628398188061433053411250283018550645637717355055870511629895689026320730284519098577019400372566147845856229282283208382297047707332277635636080477329802927434434911917397449496552209987061104759599326402594219284685820997872598597672318472668203165761779861005463966059247505832169126857485094758726721/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000", + "artificial_boundary": "28053614805566292108478159785983790723483461431407074648677111636095477644882649552071365118054486140996321840904116774601777284617981690881475978151515893889871787367004960260662786368527017985630042972329166544491891330922891824082972344084135076025172661632954328838633452924534088735062149841251872424403589359177586854163813702525025392958590762464691737095285903179340238871128184299137447612134462078058254849662026866534339683/4006701850695786513559769285433824589070439855811699076374111341835066464436936988972451491238070247143118872029350945040679325743550584984358948487096092507300302279049909699953512016364207917739238186220270050989240272338571498935212902889879118632607570116014468141745495712086911903704574585836372548976453183745264645690513479544385186060543578565267113493855141309437284611995078012932432071644091572488000000000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "2226550473268848047591768981247454579988104071528736217216604556349070533969263077329737024694750709563249371306397463241431971338498982128353241339380412573780475242829435083727484830774531058228243510071063000960333606144278249066762170330727039178281661627209910710903733835291494167953250660523509999247681949190104130051652348636356006036022468189794675561323369113127340521818044091436187211724887657/31302358208560832137185697542451754602112811373528899034172744858086456753413570226347277275297423805805616187729304258130307232371488945190304285055438222713283611555077419530886812627845374357337798329845859773353439627645089835431350803827180614317246641531363032357386685250678999247691988951846660538878540498009880044457136558940509266097996707541149324170743291479978786031211546976034625559719465410062500000000000000", + "coordinate_movement_above_kappa": "2802479721620389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "35624306734570231788154108728798594051736031339477803013081126137667399160200154620152170838679606594231097051043355742994781456500265770230528816561525714168924191347486080100927263103390451405662178756363730481608964043274409663630827823678771391962677510089094069565942023177699895823264047496552930441394289130393697922745726263996753048428101923089394150591987173917373768688512206078227378833589247000553439/500837731336973314194971160679228073633804981976462384546763917729383308054617123621556436404758780892889859003668868130084915717943823123044868560887011563412537784881238712494189002045525989717404773277533756373655034042321437366901612861234889829075946264501808517718186964010863987963071823229546568622056647968158080711314184943048148257567947320658389186731892663679660576499384751616554008955511446561000000000000000000000000", + "bulk_exposure_above_kappa": "2802479721620389942324709381495160866743837574187856518157192254291257609960279427257318100077005700276861852372460323842836441369950834657769459696009564977239078016344380397134045530135467498307349335603807581003081257573405010840884475942173298702550685385987320720525426829346698118287900143990902806692172891961710610175499480642299059315861667777334748383445991044488553439/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "56999191277951173045035090948774158019621830426153670698360529878618476286305080162517646275749213406038291015584771390112528381349855998662719933419577674877216753678648656904711117478825949564653316453045935290828166662259480854671744658853750968074181461710309212390617867996498239835615253837578626434172035842618697571241588810905770706373917617711423035980691517403396237697965429356014776066148168507753439/801340370139157302711953857086764917814087971162339815274822268367013292887387397794490298247614049428623774405870189008135865148710116996871789697419218501460060455809981939990702403272841583547847637244054010197848054467714299787042580577975823726521514023202893628349099142417382380740914917167274509795290636749052929138102695908877037212108715713053422698771028261887456922399015602586486414328818314497600000000000000000000000", + "scalar_work_above_kappa": "284997959740681213118432234628513507010403687350696259341340836448763298964757619281082717604491686065315026637359871626035162246412151768606091846572131922432337418544382809478405564150137929927225451884322786589166327931433573559108190900720199779930223612336604069187160212730347242634028121475186050357134667439685360488530789311268625724462618360346397813460204514587635907132133144319080346546776664584553439/4006701850695786513559769285433824589070439855811699076374111341835066464436936988972451491238070247143118872029350945040679325743550584984358948487096092507300302279049909699953512016364207917739238186220270050989240272338571498935212902889879118632607570116014468141745495712086911903704574585836372548976453183745264645690513479544385186060543578565267113493855141309437284611995078012932432071644091572488000000000000000000000000", + "dimension_above_kappa": "31197641791439167865040790430817093445478957607718555545815359213442279463803034330001793258671839271524120836965446451432942138934908518051127686283060759415069629784302993042893662614984060726389686500928671284874803882425973165528982802317097634749515528799364006820894976376530911463211744883444833629074710162513629954790545390249594863953655641095206681865279176709815889530111822137092714962098578681373687211724887657/31302358208560832137185697542451754602112811373528899034172744858086456753413570226347277275297423805805616187729304258130307232371488945190304285055438222713283611555077419530886812627845374357337798329845859773353439627645089835431350803827180614317246641531363032357386685250678999247691988951846660538878540498009880044457136558940509266097996707541149324170743291479978786031211546976034625559719465410062500000000000000" + }, + "conservative_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "model_controls": [ + "native_complex_endpoint_rejected_with_old_surcharge", + "omitting_bit_surcharge_would_fail_next_endpoint_rejection" + ], + "native_correction_gain": "2.85191E-12", + "template_sha256": "9c4c51425251389ee9a747c465814cd07c64812c15b7aeef704dad7d65395a74", + "input_sha256": { + "owner_audit": "30bafff060afcfb3644e951214d66cfaffe58242881c652e28003958b42127cc", + "fresh_invoice": "212cf4ee3b16081bf66f300fa18b4070d25c17210c21c78c2967892c91870d12", + "package:inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "bit_supplier": { + "pr": 589, + "repository": "CrocSwap/integer-mult-bounds", + "commit": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46", + "merged_as": "b3eb785ac5b4b1ca2beea0f80db078a505626a90", + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "git_blob_sha1": "e293ddc557742637f9f679f083a1a282d87b1b13", + "word": { + "v": 111, + "decoder_constant": 63, + "copy_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ] + }, + "derived_deficit": 10272, + "deficit_formula": "T(2Kv-L*cst), L=9 T=32 K=4 M=64", + "replay_scope": "Cited unchanged supplier; this assembly reprices its full profile and does not rebuild its bit circuit." + }, + "moments": [ + { + "side": "bit", + "surcharge": true, + "endpoint": "1733427039589844234749/1000000000000000000000000", + "accept": true, + "mercator": [ + "-43100600330766044577088869872467188970742291/26959946667150639794667015087019630673637144422540572481103610249216", + "-43100600330766044577088869872467188970742289/26959946667150639794667015087019630673637144422540572481103610249216" + ], + "base_two": [ + "-799345163337715793503/500000000000000000000000000000000000000000000", + "-3197378653350863173989/2000000000000000000000000000000000000000000000" + ] + }, + { + "side": "bit", + "surcharge": true, + "endpoint": "6933708158359376939/4000000000000000000000", + "accept": false, + "mercator": [ + "22502934905675809315035333485365686073718547/13479973333575319897333507543509815336818572211270286240551805124608", + "5625733726418952328758833371341421518429637/3369993333393829974333376885877453834204643052817571560137951281152" + ], + "base_two": [ + "8346798366759439729359/5000000000000000000000000000000000000000000000", + "16693606733518879458833/10000000000000000000000000000000000000000000000" + ] + }, + { + "side": "complex", + "surcharge": false, + "endpoint": "67018507072324140917/40000000000000000000000", + "accept": true, + "mercator": [ + "-35161575700336957412970835679936878918177631/26959946667150639794667015087019630673637144422540572481103610249216", + "-35161575700336957412970835679936878918177629/26959946667150639794667015087019630673637144422540572481103610249216" + ], + "base_two": [ + "-163027/125000000000000000000000000000", + "-260843/200000000000000000000000000000" + ] + }, + { + "side": "complex", + "surcharge": false, + "endpoint": "837731338404051761463/500000000000000000000000", + "accept": false, + "mercator": [ + "43802465867485534890178553907434323023222757/26959946667150639794667015087019630673637144422540572481103610249216", + "43802465867485534890178553907434323023222759/26959946667150639794667015087019630673637144422540572481103610249216" + ], + "base_two": [ + "1624723/1000000000000000000000000000000", + "406181/250000000000000000000000000000" + ] + } + ], + "bootstrap": [ + { + "exponent": "2676351903605968510955225199374139336419692211991205809803291212685832779316802617926399111/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "4388379286997125724770519885577770614671108008794190196708787314167220683197382073600889/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "4785575287428" + }, + { + "exponent": "107229317213090343809558513333591284579279399862953574758040118663735837979673222607810293919010512865815663359806135729869323361652475213/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "294102628281657641315436797399702095132937046425241959881336264162020326777392189706080989487134184336640193864270130676638347524787/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1704765459304159860" + }, + { + "exponent": "4289184432918425945204602612810811814242177218571549743614845366342624240747502661971213062645949901457815846541829576632569723585538319837683356531863935997754461046639237713138409679/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "19710319073483390538004735557012804093428450256385154633657375759252497338028786937354050098542184153458170423367430276414461680162316643468136064002245538953360762286861590321/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "607288590542446415285737" + }, + { + "exponent": "171567378103828844589295714015277247208277763194683861086506039620411038425241223225415374750246673707197993416981116984785025248834072957802186876854129419662928338294140179682651151779349930844098048754952574172587583050727264357/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "1320956158224012017344647641921489285316138913493960379588961574758776774584625249753326292802006583018883015214974751165927042197813123145870580337071661705859820317348848220650069155901951245047425827412416949272735643/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "216334411393790970429839007220" + }, + { + "exponent": "6862695124205903501391156875228590725366338670593798130778146011247213048799329248276386353883527829505727811814785950491330293597981298780354995034957137345602662361138997814404555486275586374750298102671091066436586235588225737165500314750679738457912869234305574310420604631/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "88528509632166076285068641631428606201869221853988752786951200670751723613646116472170494272188185214049508669706402018701219645004965042862654397337638861002185595444513724413625249701897328908933563413764411774262834499685249320261542087130765694425689579395369/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "77064806225479172206224871399132079" + }, + { + "exponent": "274507804968239675262983012766557017278150386312268407171634736048569145063436078292308834161068093358180970305987390168436997280846699807340390028600235262791714958423212022381294505311826715320340799973882750272976631732616603410592302985180390981719778700426281993988599893959139653519462414098149103287619172127213213373/163840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "5933048548885638014482168417655731592828365263951430854936563921707691165838931906641819029694012609831563002719153300192659609971399764737208285041576787977618705494688173284679659200026117249727023368267383396589407697014819609018280221299573718006011400106040860346480537585901850896712380827872786786627/163840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "27452795513701194724472919763925196307643" + }, + { + "exponent": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "gap": "397624056133934612790045917604701917406215620419844115427082799655527875330373276202813015439178645161780564981523433953754464728175629739795987771170132335610054962043286727909210625262956284518441881092272459809674959821447510830927360669573314438695315588844257812872604553551784716471645774666643540006532795343845359798288152210341205493240883041/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "9779509200503493187646549135972282547372018449" + } + ], + "outer": { + "bit_positive": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "397641590046133342377293758884701917406215620419844115427082799655527875330373276202813015439178645161780564981523433953754464728175629739795987771170132335610054962043286727909210625262956284518441881092272459809674959821447510830927360669573314438695315588844257812872604553551784716471645774666643540006532795343845359798288152210341205493240883041/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "1182981492927675859083/40000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "leaf_saving_above_bit": "397630609733934612790045917604701917406215620419844115427082799655527875330373276202813015439178645161780564981523433953754464728175629739795987771170132335610054962043286727909210625262956284518441881092272459809674959821447510830927360669573314438695315588844257812872604553551784716471645774666643540006532795343845359798288152210341205493240883041/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "5490156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "198826285179166035982270402440760912569765432916163173011623993612143517821071211018606852191713992207614079677746277798232070583522833346464040131120337992175287685033872193822269702576516098972493031335510966948552961468842663143003870659826835771836826867061459333121863581460303513978010014728768218218549926026148013255604069572375258901260643232347789658794506759116959/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "5490156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "3271309843900635206376277372575335265400775894323080760912569765432916163173011623993612143517821071211018606852191713992207614079677746277798232070583522833346464040131120337992175287685033872193822269702576516098972493031335510966948552961468842663143003870659826835771836826867061459333121863581460303513978010014728768218218549926026148013255604069572375258901260643232347789658794506759116959/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "lambda_above_tau": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "397652570358332071964541202523111871272873243126085230725165393439907455486257849120013359911303314788504362168507994775109302947610648216362034016705404159980315166055515557776875015207994241231713971881647196853390441379566418558467550994613492991184484661483588239558165858236195872213832902062089988221816323698070693154748145677545861647881084752847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "10980312198729587247443638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "198826285179166035982270402440760912569765432916163173011623993612143517821071211018606852191713992207614079677746277798232070583522833346464040131120337992175287685033872193822269702576516098972493031335510966948552961468842663143003870659826835771836826867061459333121863581460303513978010014728768218218549926026148013255604069572375258901260643232347789658794506759116959/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "lambda_prime_below_one": "5490156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3276800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "3276799999999999999999996723200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041", + "epsilon_below_one": "5490156099364793623725085024664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041", + "guard_width": "5490156099364793623725085024664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041", + "K_geometry": "2463090156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "K_dominates_log": "5490156099364793623722621934508635234430481954291814422695635342978159907749288576153289398342101800605386759951803828863596938929105913915760137030556844399813758100950245530658058779006258926515722472711168934899700790934191609567546011024188672367963077893134633070826316136809200493713908255366563547481323107134813242084964051983866715512614148977550767246752612371721782716464394501526273347789658794506759116959/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "record_suffix": "5490156099364793623725085024664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041", + "phase_local": "43921248794918348989797397907161777428999221693545688034707277312565017696667920620868284773594603323475138794609805883410298381184881969328135642945897010974565477183107879585431044983769153569759834554675556242092249571585614840927675280742290030366935983274346782667968528067378985161860863185144438949635253004033435714555114569800830622723385661970923954937928109745287255104902847187707560347789658794506759116959/26258321248794918348989774465797317876793792845415353912699441876536670694615907008051102851857431430311851145182466288062339087362578029777614143435331817333228287678951037296062597698519729022449421842379387871208220055749315912264411576308249258694855969034721385313825305385063508325335025091348317571888175919882169854254251600591790815893955167443420997928789914854141217682729643945927064328000000000000000000000000", + "phase_boundary": "8784249758983669797956853749307475993964945361262557875153776083228462003942314179986003287649459073994222648636775433539028491122458147236820894680443144391935334022278042735352886167985935610222360651165259275516204972132885029398414234142883074482160755497238531607724220016572324893840790106490381439094517098297552311153834096368177907559251707234125611905996226432313108921187690446056097947789658794506759116959/5251664249758983669797954893159463575358758569083070782539888375307334138923181401610220570371486286062370229036493257612467817472515605955522828687066363466645657535790207459212519539703945804489884368475877574241644011149863182452882315261649851738971193806944277062765061077012701665067005018269663514377635183976433970850850320118358163178791033488684199585757982970828243536545928789185412865600000000000000000000000", + "gamma_sublinear": "1/2000000000000000000000000", + "cell_above_band": "6553599999999999999999990164109843900635206376278191775335265400775894323080760912569765432916163173011623993612143517821071211018606852191713992207614079677746277798232070583522833346464040131120337992175287685033872193822269702576516098972493031335510966948552961468842663143003870659826835771836826867061459333121863581460303513978010014728768218218549926026148013255604069572375258901260643232347789658794506759116959/13129160624397459174494887232898658938396896422707676956349720938268335347307953504025551425928715715155925572591233144031169543681289014888807071717665908666614143839475518648031298849259864511224710921189693935604110027874657956132205788154124629347427984517360692656912652692531754162667512545674158785944087959941084927127125800295895407946977583721710498964394957427070608841364821972963532164000000000000000000000000", + "prime_interval_packing": "5490156099364793623725085024664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041", + "alpha_positive": "10980312198729587247446887759173369833654587632030253510125869910061996734737664582541145880521030589586779907760089836655982859251359636117528066447034011053349717969829907538482771093972386732693452770134652835927207759598680642618993049555346009224959207233307797298989489269747741160592044673906260033503313092406045023866414125957718702257010079405175508345491969139373993057669887742409314347789658794506759116959/6564580312198729587247443616449329469198448211353838478174860469134167673653976752012775712964357857577962786295616572015584771840644507444403535858832954333307071919737759324015649424629932255612355460594846967802055013937328978066102894077062314673713992258680346328456326346265877081333756272837079392972043979970542463563562900147947703973488791860855249482197478713535304420682410986481766082000000000000000000000000", + "alpha_below_one": "6553599999999999999999996728690156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/6564580312198729587247443616449329469198448211353838478174860469134167673653976752012775712964357857577962786295616572015584771840644507444403535858832954333307071919737759324015649424629932255612355460594846967802055013937328978066102894077062314673713992258680346328456326346265877081333756272837079392972043979970542463563562900147947703973488791860855249482197478713535304420682410986481766082000000000000000000000000", + "alpha_below_one_fourth": "1630164765850952809564414016353158997465957465206429366033589247373479921678756523420652782360568433804903916666144053167240210100909767224983355898261204572273418261964609923465429585063510677170395412378577089114586545724733563873906730469710232659203538857436778784815092097296721529172847023535363588209507681900229570867024310911029207291115187885808636862203877709244452112112932858878032206152210341205493240883041/6564580312198729587247443616449329469198448211353838478174860469134167673653976752012775712964357857577962786295616572015584771840644507444403535858832954333307071919737759324015649424629932255612355460594846967802055013937328978066102894077062314673713992258680346328456326346265877081333756272837079392972043979970542463563562900147947703973488791860855249482197478713535304420682410986481766082000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "short_record_fallback": "21438795909359212103616200334166424291758762958701354720819225409175913045478560967720640553831252868642841942253167261842634503755898200369741797654839235623990958395123196106347054256327521388059237907738555946116433881290788510172566978075812588267011140451521149354923953941516451675932972669173688634010916300353904340905724906488218546839456978701394526050828652398406301750429825860648483042370608582747954568848698913366833278528173238328138005355037693658990720351480360064483574940413515507656771079955155236699697879613531021952974589189172911760811581583760662741175548267502730611041487528161453816002373253929599277616955065382186662816403849986402330301408647863401260251417675068508475184504597426026825094537163396209229472942008595502577513065441407681/21510816767012797111492423242381162804669475098964257925283382785258840633029351020995463456241607827711468458133476383180668180367423921993821506302223824759380613266596689752934480034627362015190566373277194544093773869669839595327005963311717792722826009833243758849085690171444026020114452554832541754890793713567473544605082911204795036380328073169650481503264698248512485525692124320503451097497600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000", + "artificial_boundary": "183852169990359346791918231787649011312444723634488255975589738809965682587684973326699526516110961923459937180623299751035499065844803681645771170859812299632587468036912086617932281548765711786234360762509239914564143864527718190385744313548514975552314851432112198104074453651496454623199693415276059973921029359691768089653102262800296482965336684891718205351875279066317532744711374863634584926956631023616479722649123/26258321248794918348989774465797317876793792845415353912699441876536670694615907008051102851857431430311851145182466288062339087362578029777614143435331817333228287678951037296062597698519729022449421842379387871208220055749315912264411576308249258694855969034721385313825305385063508325335025091348317571888175919882169854254251600591790815893955167443420997928789914854141217682729643945927064328000000000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "1081110357609925260614972695003107315707432353068338487603991699409949621702495690156909535160235873839601108223405260050123543294943053402137660198994397070489620108165140795187785639656314293544597085375410582291108751565224554246715990585636803213137497296463685876362653172078415927035174159499690912068352607880037991076665304643497436633279437216679436871538992416375313119280028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000", + "coordinate_movement_above_kappa": "18366331166297442643638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "2162217432929694421865151766284406406750130106912571298288744311389664676321154553325443063932615265500273427465417372291961078797500186482021598196220864724502073562794321721495909271487916272123066364573090867158733602102942139828942948119826567895117657735931242412552142115993658721131807652121245405597008729738085996882098827505544799292706887688962943315453243734011269470907847537475759121116959/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "bulk_exposure_above_kappa": "18366331166297442643638409953866657622706241115298082593784379580155884572917200344472124669626723797186984560821354838219435018476566046245535271824370260204012228829867664389945037956713272090789374737043715481558118907727540190325040178552489169072639330426685561304684411155742187127395446448215283528354225333356459993467204656154640201711847789658794506759116959/6553600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "3459549862061604734603119000288135185599048930594577483413534350681604222364149381513734506124898314107794757333503684352109330751431850564586790435014141209089617692592490675721252039075493424376582867023583565908064103981211604925002136822590731750882654491687665464187325922487757833574016643520874500079031859194131586174097193077741723252642212348978267561300034633661645214043882264684510538316959/5251664249758983669797954893159463575358758569083070782539888375307334138923181401610220570371486286062370229036493257612467817472515605955522828687066363466645657535790207459212519539703945804489884368475877574241644011149863182452882315261649851738971193806944277062765061077012701665067005018269663514377635183976433970850850320118358163178791033488684199585757982970828243536545928789185412865600000000000000000000000", + "scalar_work_above_kappa": "17297762439468648070474769496327908826654183049869310124744628103128959380156094215522176556175917499254688942593091012993690684926702934111948840982142423711356755077106292854124908226676316381747425559828839019234256124016085899282966816318741812879042619886422844681629286525091481699624245885116918174553945240058617871955413092514508912158619008722475059516999137563265653140828252688244525655116959/26258321248794918348989774465797317876793792845415353912699441876536670694615907008051102851857431430311851145182466288062339087362578029777614143435331817333228287678951037296062597698519729022449421842379387871208220055749315912264411576308249258694855969034721385313825305385063508325335025091348317571888175919882169854254251600591790815893955167443420997928789914854141217682729643945927064328000000000000000000000000", + "dimension_above_kappa": "1635654921950317604269246176697592893315360642164647696163717235784796569190497511406755693461406225762418838586331730835704915263244133189022659330234814818810892219059957239485707752007657731284696774507602551594083331891078337774583028045958975578287492520966716631023415709897216606029214103869146078792163164507055296177461882843051065083293106678283624262730067538295610766368389669754871598780028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000" + }, + "controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "scope": "Conditional native exact-complex witness after complete conservative admission, moment and outer checks; PR559 exact-cover recurrence correction only, bit bad-residue surcharge and H1-H5 retained. The new source-branch gauge and retired-basis completion, the gauge44-barch U8 local word and all 72 cold helper ends, and explicit all144 whole-owner dispatch with a two-copy remainder trade are composed with the cited unchanged merged PR589 bit supplier (PR555 punctured R439 word; derived bit deficit T(2Kv-L*cst)), replacing the PR543 supplier of PR635; This is a new T16 composition of the accepted PR799 and PR589 suppliers. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape and analytic transfer remain assumptions. No unconditional theorem or full Lean certification." +} diff --git a/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/NOTICE.md b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/NOTICE.md new file mode 100644 index 0000000000..30d0c8cd3c --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/NOTICE.md @@ -0,0 +1,24 @@ +# Gauge44 attribution and scope + +New contributions by icekylinx, with OpenAI GPT-6 Astra assistance. +Local review and packaging used OpenAI Codex. Apache-2.0 applies; +the license is included. The full original PR635 notice is preserved as +UPSTREAM-NOTICE.md and construction/UPSTREAM-NOTICE.md. + +The new contribution is the changed source-branch gauge and retired-row +completion, source-carried coordinate totals, exact 44-cold-end realization, +and explicit all72 whole-family assignment using concave capacity matching +with integer majorization certificates. The center-carrier generalization +retains the exact ordered common frames and complete native local contract. +Independent local, price, interface and owner fixed-point checks are included. + +The construction retains the credited PR635 K-triangle and porting machinery, +earlier joint-prefix/HPE/frame ancestry and icekylinx's prior factory work. +#645 used the same cited PR543 bit supplier as PR635. This package (research/gauge44-leaver8) cites the merged PR589 bit supplier instead, with a derived rank-mass deficit (PROOF-NOTE-BIT.md); #645's retained PR543-based evidence is historical. It builds #645's word without K-triangles (PartialK) and stacks earlier community jp8 layers on it (G44Stack), adds the p6n ends (NoTriReopen), entrance promotions (BlockInvert) a read-set exchange (BRoute), chafreaky's #741 frames, JointXF's joint exchange, NewBArch's triangle-hybrid B rewrite and LeaverSAT's eight k8 leaver cells (with LeaverSAT2's frame re-optimisation); see README. All-size, realization, +hosting, precision/tape, analytic-transfer and bit H1-H5 assumptions remain +conditional. No upstream license, credit, source pin or AI disclosure is +replaced by this notice. + +PR641 and PR642 were checked as concurrent reported frontier comparisons. +Their endpoints and owner maps are not included here. See CONSTRUCTION.md, +hosting/PROOF.md, independent/ and README.md for the exact contribution scope. diff --git a/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..ebc24a0168 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and scope + +Four verified provider types are offered to every call: PR571's prefix word with twelve multi-cut cold kernels (PR568's unchanged constructor), the same word with forty width-five entrance promotions (PR569's unchanged frame constructor) before those kernels, PR575's plain joint-prefix provider, and PR568's eight-cold provider. A window MILP with an exact per-pattern model chooses the dispatch and a literal owner map. PR583's six source-bound kernel frame coalescences (its unchanged constructor and negative controls) are applied to every PR571-prefix provider word (ck and atm3), followed by two further coalescences that each first move one addition past two commuting additions (package code/build_gate_moves.py, extending PR583's constructor); a final hyperplane_end step (package code/build_hpe.py) then runs 46 single-gate cleanups h -= p right after part B at the dim-8 join U of their registers, so 46 width-8 entering helpers per call end at U with width 7; each such gate commutes with every earlier cleanup gate on its registers (for 8 of them the partner's one earlier gate x -= p only reads p), and the reordered program is replayed exactly. A window MILP (exact windows, RINS around an LP vertex) gives the dispatch ck 45 / atm3 21 / jp8 6 and the literal owner map. + +Pinned external sources (unchanged; `verify.py` checks their manifests and every file it uses): +- PR568 (`research/complex-multicold`, commit `71c99ac935a33bb7b59a1b4a7af8725a939b0b90`). +- PR571 (`research/structural-gain`, commit `b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3`). +- PR569 (`research/larger-gain`, commit `897213a855b7fb8a1b8b0e552a2f5c42e6c1b326`). +- PR575 (`research/complex-joint-prefix`, commit `eac6f7e378ab622dac50a2fd4b7ef6eab014de44`). +- PR583 (`research/kernel-frame-coalescing`, commit `89be768f0157f5a3d8e4db69cf1748768605eac9`). + +Provider construction is described as typed steps in `data/SPEC.json` (`build`); `verify.py` runs only allowlisted step types with their paired omission audits and checks every input and output content hash. `code/` holds the spec-driven global admission scripts adapted from PR571's `frontier-composition/global-code/` (OpenAI Codex assisted, Apache-2.0): every expected value is read from `data/SPEC.json` and compared only after independent recomputation. `code/generated_identity.py` and `code/generated_identity_controls.py`, and the decompressed-content artifact identities in the bind, audit, invoice, assembly and phase-timing scripts, are taken unchanged from PR586 by chafreaky (`research/promoted-kernel-coalescing`, commit `4846fee5b06af770e9b3a10c36200f673d656725`, OpenAI Codex assisted, Apache-2.0), including its proof-content and reference/metadata mutation controls; the normalization of descriptive width metadata after frame changes follows the same PR. + +In PR601, the owner map was nominated by a HiGHS window MILP (adapted from PR569's `global/nominate_width7.py`) with lazy cross-time Hall cuts; this package's re-solved map is described below. Neither is an admission dependency. + +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. (The PR601 package this one starts from states: "Prepared by Claude Code (Anthropic) research agents.") Apache-2.0 applies; LICENSE is included. All notices, licenses, source pins and AI disclosures of the pinned sources and their ancestry are retained in those packages and are not replaced by this notice. All inherited conditional assumptions remain conditional. + +**This package (complex-571-cold14, DreamingOfClouds).** It starts from PR601 (jeremykothe2, `research/complex-571-hpem46`, commit `529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550`). Everything above is kept unchanged except the following: +- every provider chain (ck, atm3, jp8) gains the typed step `cold_end` (`code/build_cold_end.py`, `code/cold_end_controls.py`; recipes `data/recipes/*-cold_end.json.gz`); +- the generalised native chain and the global admission scripts accept cold helpers that end below FULL (with `0:U` wrappers), a refactored exact cleanup, and check the wrapper order; +- `data/PLAN.json` / `data/OWNERS.json.gz` (dispatch and literal owner map) come from a relocate/swap/ejection-chain/provider-flip annealing search started from PR601's map, refined by an exact pattern-restricted owner model (CP-SAT) with a literal edge-colouring expansion (not an admission dependency); +- `data/SPEC.json` holds the expected values, recorded by a discovery run and then checked by a strict run. + +The cold-end construction (a row-plus-column cone condition for low-frame ends, a rank-0 dirt-spread premix and multi-gate lower-frame cleanup) builds on PR591 / PR592 / PR593 / PR601 (jeremykothe2) and our PR599 (Lean: multi-gate and cold hyperplane-end tails). DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Build on this at your own risk. + +**This package (complex-571-cold14-b3, jeremykothe2).** It is PR604's `complex-571-cold14` (DreamingOfClouds) with ColdBeyond's second cold end per block (two new `cold_end` A-gate primitives, `PROOF-NOTE.md`), ColdSupply's E1 entering pair and reviewed controls, a free dispatch (jp8 ×60, atm3 ×12) and a literal owner map from an exact per-time-Hall window MIP. All other construction, code, controls and proofs are PR604's and earlier contributors', unchanged. + +**This package (complex-571-cold14-k492).** It is complex-571-cold14-b3 with these changes: +- **K-triangle base words.** The leaver-read K-triangle skeleton atom and its read schedule (`data/TRI-SCHEDULE.json`) are by AtomScout, a Claude Code research agent. `code/construct_k_triangle.py` is PR531's `code/construct_504.py` (icekylinx, OpenAI Codex / GPT assisted, Apache-2.0; pinned source `direct_delivery`) extended with that atom. +- **Ported chains.** The PR604/B3 chains are ported stage by stage onto the K-triangle words by `code/build_port_stage.py` (Port480, a Claude Code research agent). `code/build_frame_regroup.py` extends PR583's `build_frames.py` (chafreaky). +- **Helper count R.** The generalisation of the global scripts to the provider helper count R is by GlobalR (a Claude Code research agent), with AtomReviewer's fixes (PROOF-NOTE-R.md). +- **Owner map.** The owner map, the cold_end recipes on the K-triangle words and the package assembly are by Stack492, Port480 and ColdBeyond (Claude Code research agents). + +Build on this at your own risk. diff --git a/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md new file mode 100644 index 0000000000..16b0507070 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md @@ -0,0 +1,9 @@ +# Construction delta notice + +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. + +`construct_gauge_xcentre.py` modifies PR635's credited `construct_k_triangle.py`, which in turn extends icekylinx's PR531/PR514/PR425 factory lineage. Its original source comments are retained. The K-triangle schedule and the upstream porting, JP8 frame, kernel and HPE procedures are reused from the pinned source checkouts and are not new contributions of this delta. + +The new source-copy exchanges, complementary factory basis, carrier assignment, exact cold44 constructor and compact reproduction driver are described in `../CONSTRUCTION.md`. + +`UPSTREAM-NOTICE.md` is the complete unmodified notice from the pinned PR635 package. `LICENSE` is that package's Apache-2.0 license. All further notices and source credits of the referenced upstream packages remain applicable and are retained in the source checkouts rather than vendored again here. diff --git a/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..ebc24a0168 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and scope + +Four verified provider types are offered to every call: PR571's prefix word with twelve multi-cut cold kernels (PR568's unchanged constructor), the same word with forty width-five entrance promotions (PR569's unchanged frame constructor) before those kernels, PR575's plain joint-prefix provider, and PR568's eight-cold provider. A window MILP with an exact per-pattern model chooses the dispatch and a literal owner map. PR583's six source-bound kernel frame coalescences (its unchanged constructor and negative controls) are applied to every PR571-prefix provider word (ck and atm3), followed by two further coalescences that each first move one addition past two commuting additions (package code/build_gate_moves.py, extending PR583's constructor); a final hyperplane_end step (package code/build_hpe.py) then runs 46 single-gate cleanups h -= p right after part B at the dim-8 join U of their registers, so 46 width-8 entering helpers per call end at U with width 7; each such gate commutes with every earlier cleanup gate on its registers (for 8 of them the partner's one earlier gate x -= p only reads p), and the reordered program is replayed exactly. A window MILP (exact windows, RINS around an LP vertex) gives the dispatch ck 45 / atm3 21 / jp8 6 and the literal owner map. + +Pinned external sources (unchanged; `verify.py` checks their manifests and every file it uses): +- PR568 (`research/complex-multicold`, commit `71c99ac935a33bb7b59a1b4a7af8725a939b0b90`). +- PR571 (`research/structural-gain`, commit `b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3`). +- PR569 (`research/larger-gain`, commit `897213a855b7fb8a1b8b0e552a2f5c42e6c1b326`). +- PR575 (`research/complex-joint-prefix`, commit `eac6f7e378ab622dac50a2fd4b7ef6eab014de44`). +- PR583 (`research/kernel-frame-coalescing`, commit `89be768f0157f5a3d8e4db69cf1748768605eac9`). + +Provider construction is described as typed steps in `data/SPEC.json` (`build`); `verify.py` runs only allowlisted step types with their paired omission audits and checks every input and output content hash. `code/` holds the spec-driven global admission scripts adapted from PR571's `frontier-composition/global-code/` (OpenAI Codex assisted, Apache-2.0): every expected value is read from `data/SPEC.json` and compared only after independent recomputation. `code/generated_identity.py` and `code/generated_identity_controls.py`, and the decompressed-content artifact identities in the bind, audit, invoice, assembly and phase-timing scripts, are taken unchanged from PR586 by chafreaky (`research/promoted-kernel-coalescing`, commit `4846fee5b06af770e9b3a10c36200f673d656725`, OpenAI Codex assisted, Apache-2.0), including its proof-content and reference/metadata mutation controls; the normalization of descriptive width metadata after frame changes follows the same PR. + +In PR601, the owner map was nominated by a HiGHS window MILP (adapted from PR569's `global/nominate_width7.py`) with lazy cross-time Hall cuts; this package's re-solved map is described below. Neither is an admission dependency. + +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. (The PR601 package this one starts from states: "Prepared by Claude Code (Anthropic) research agents.") Apache-2.0 applies; LICENSE is included. All notices, licenses, source pins and AI disclosures of the pinned sources and their ancestry are retained in those packages and are not replaced by this notice. All inherited conditional assumptions remain conditional. + +**This package (complex-571-cold14, DreamingOfClouds).** It starts from PR601 (jeremykothe2, `research/complex-571-hpem46`, commit `529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550`). Everything above is kept unchanged except the following: +- every provider chain (ck, atm3, jp8) gains the typed step `cold_end` (`code/build_cold_end.py`, `code/cold_end_controls.py`; recipes `data/recipes/*-cold_end.json.gz`); +- the generalised native chain and the global admission scripts accept cold helpers that end below FULL (with `0:U` wrappers), a refactored exact cleanup, and check the wrapper order; +- `data/PLAN.json` / `data/OWNERS.json.gz` (dispatch and literal owner map) come from a relocate/swap/ejection-chain/provider-flip annealing search started from PR601's map, refined by an exact pattern-restricted owner model (CP-SAT) with a literal edge-colouring expansion (not an admission dependency); +- `data/SPEC.json` holds the expected values, recorded by a discovery run and then checked by a strict run. + +The cold-end construction (a row-plus-column cone condition for low-frame ends, a rank-0 dirt-spread premix and multi-gate lower-frame cleanup) builds on PR591 / PR592 / PR593 / PR601 (jeremykothe2) and our PR599 (Lean: multi-gate and cold hyperplane-end tails). DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Build on this at your own risk. + +**This package (complex-571-cold14-b3, jeremykothe2).** It is PR604's `complex-571-cold14` (DreamingOfClouds) with ColdBeyond's second cold end per block (two new `cold_end` A-gate primitives, `PROOF-NOTE.md`), ColdSupply's E1 entering pair and reviewed controls, a free dispatch (jp8 ×60, atm3 ×12) and a literal owner map from an exact per-time-Hall window MIP. All other construction, code, controls and proofs are PR604's and earlier contributors', unchanged. + +**This package (complex-571-cold14-k492).** It is complex-571-cold14-b3 with these changes: +- **K-triangle base words.** The leaver-read K-triangle skeleton atom and its read schedule (`data/TRI-SCHEDULE.json`) are by AtomScout, a Claude Code research agent. `code/construct_k_triangle.py` is PR531's `code/construct_504.py` (icekylinx, OpenAI Codex / GPT assisted, Apache-2.0; pinned source `direct_delivery`) extended with that atom. +- **Ported chains.** The PR604/B3 chains are ported stage by stage onto the K-triangle words by `code/build_port_stage.py` (Port480, a Claude Code research agent). `code/build_frame_regroup.py` extends PR583's `build_frames.py` (chafreaky). +- **Helper count R.** The generalisation of the global scripts to the provider helper count R is by GlobalR (a Claude Code research agent), with AtomReviewer's fixes (PROOF-NOTE-R.md). +- **Owner map.** The owner map, the cold_end recipes on the K-triangle words and the package assembly are by Stack492, Port480 and ColdBeyond (Claude Code research agents). + +Build on this at your own risk. diff --git a/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md new file mode 100644 index 0000000000..403f4afffb --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +Apache-2.0. New construction and integration: Hao Yan (@FanPUYen), 2026. +Prepared with substantial OpenAI Codex assistance, including separately tasked +AI agents for owner construction, independent mathematical/code checking and +native verification. These are not claims of independent human peer review. + +The exact local supplier is Jeremy Kothe's accepted PR799 X4 word, layered on +Chafik Boukhalfa's PR741 frame changes and PR685 owner construction. Chafik's +PR795 fixed-inventory optimality result motivated changing the replica count. +The original owner bytes, scalar program, local frame and width inventory, +native phase and wrapper implementations retain their existing authorship. + +Credit icekylinx for the source gauge and supplier/admission pipeline; +DreamingOfClouds for the PR589 bit transport and inherited cold-end work; +eumemic for the PR555 bit supplier and earlier supplier work; Rohan Arun for +the native exact-complex recurrence correction; Jeremy Diviney, jaymosley07, +and the other retained owner/allocation contributors; and the complete +PR514/PR484/PR507/PR558 controller, physical hosting and verification lineage. +This list is cumulative credit, not approval of every claim in those PRs. + +All original notices and licenses remain in the referenced source packages: + +- `research/gauge44-frames-x/{NOTICE,UPSTREAM-NOTICE}.md` +- `research/complex-sw4-frame8/PROVENANCE.md` +- `research/e8-bit-p111-tuned/tune/README.md` +- the repository `CONTRIBUTORS.md` and source-package licenses. + +The verifier copies pinned global source files into an external replay +directory and applies an explicit checked edit list. Original attribution +comments are preserved in those generated derivatives. No original source +file or historical certificate is rewritten. + +The optional ancestry-reuse coverage guard addresses the omission issue +identified by Lucas (@ljste) in PR838 and the related PR847 integration by +Chinmay (@chinmayarvind23). Its fixed inventories were read from the accepted +PR741 source; no pending implementation is imported. Charles Bethin's +concurrent PR850 strengthens the fixed-inventory owner-profile theorem and +was checked for overlap before publication; that inventory is changed here. diff --git a/research/completed-prefix-outer/sources/upstream/upstream/LICENSE b/research/completed-prefix-outer/sources/upstream/upstream/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/upstream/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/completed-prefix-outer/sources/upstream/upstream/README.md b/research/completed-prefix-outer/sources/upstream/upstream/README.md new file mode 100644 index 0000000000..c8cb3c3857 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/upstream/README.md @@ -0,0 +1,17 @@ +# [Integer multiplication below n log n](paper.pdf) + +**Author:** OpenAI + +**Date:** September 23, 2026 + +## Citation + +```bibtex +@misc{OAI:Integer-multiplication-below-n-log-n-September-23-2026, + author = {{OpenAI}}, + title = {{Integer multiplication below $n\log n$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Integer-multiplication-below-n-log-n-September-23-2026/paper.pdf}{OAI:Integer-multiplication-below-n-log-n-September-23-2026}}, + year = {2026} +} +``` diff --git a/research/completed-prefix-outer/sources/upstream/upstream/build/sections/02-streams.tex b/research/completed-prefix-outer/sources/upstream/upstream/build/sections/02-streams.tex new file mode 100644 index 0000000000..088fceea18 --- /dev/null +++ b/research/completed-prefix-outer/sources/upstream/upstream/build/sections/02-streams.tex @@ -0,0 +1,208 @@ +\section{The machine model and elementary streams} +\label{sec:streams} + +A machine has one fixed finite alphabet and one fixed finite number of +one-dimensional tapes. A step reads and writes at most one cell on each +tape and moves each head by at most one cell. Fixed tracks and finitely +many work tapes change time by a fixed factor. We distinguish moving one +digit in a fixed radix, which needs a bounded number of scans, from +interchanging fields whose numbers of digits grow. The latter permutation +will be realized in Section~\ref{sec:tape-interchange} by computing XOR +combinations of intermediate data streams. The present section supplies +the elementary scans it uses. Every scan includes its counters and the +return of its tape heads. + +\subsection{Array order and elementary scans} + +For a positive integer $a$ write $[a]=\{0,\ldots,a-1\}$. +An array with address set $[a_1]\times\cdots\times[a_t]$ is stored in +lexicographic order, with the first coordinate most significant. Its +entries are bits unless a record width is specified. A trailing record +of $B$ bits can equivalently be regarded as a final address field $[B]$. +An address is implicit in an entry's position in this ordered stream; it +is not stored beside every data bit. +The \emph{logical volume} $V$ is the number of stored data bits. Work +tapes and duplicate streams are charged in time but do not increase $V$ +in recurrences. All the fields discussed below are nonempty. A call +with an empty array is handled directly. + +An address permutation $f$ moves the entry at $x$ to $f(x)$. Thus its +action on an array $A$ is $(fA)(f(x))=A(x)$. Adjacent fields which are +irrelevant to an operation may be replaced by a single field whose length +is their product. In particular, the elementary procedures below have a +fixed number of formal address fields even when a surrounding algorithm +has a growing list of coordinates. Lengths and positions are supplied in +canonical binary on descriptor tapes; no additional tape head is attached to an +address coordinate. Each elementary call receives a fixed number of +collapsed canonical lengths. Constructing them from a longer surrounding +list is work of the caller; recursive calls below construct their own +collapsed descriptors within their stated bounds. + +When one address field is designated as a row field, collapse the fields +before it to a prefix $[P]$ and those after it to a suffix $[B]$. If the +row field has range $[R]$, a \emph{row} at prefix $p$ and row index $r$ +is the complete consecutive block $\{p\}\times\{r\}\times[B]$. +Every row therefore contains $B$ bits in the same suffix order. + +For headers that concatenate a list of positive integer parameters, we use +the self-delimiting code +\begin{equation} + b_v=\lfloor\log_2v\rfloor+1,\qquad + \Gamma(v)=0^{b_v-1}\operatorname{bin}_{b_v}(v),\qquad + |\Gamma(v)|=2b_v-1\quad(v\ge1). + \label{eq:integer-descriptor-code} +\end{equation} +The initial zeroes specify how many further bits follow the first one, +so concatenated codes can be read in order. We use this code when an +interface specifies a header; elementary calls still receive the fixed +number of canonical binary lengths described above. + +\begin{lemma}[Elementary stream operations] +\label{lem:elementary-streams} +Fix a radix $q\ge2$. Each of the following operations on an array of +volume $V$ takes $O(V)$ steps on a fixed number of one-dimensional tapes: +\begin{enumerate} +\item any fixed permutation of the pair of digit values at two specified +radix-$q$ positions, whether or not the positions are adjacent; +\item moving one specified radix-$q$ digit to another position, preserving +the order of the intervening positions; +\item splitting on a specified radix-$q$ digit, applying a fixed +pointwise map to aligned streams, and merging them back; +\item for positive integers $P,R,B$, within each prefix of an array on +$[P]\times[R]\times[B]$, splitting +whole rows cyclically into a fixed number $W$ of streams, and, when $W$ +divides $R$, merging those streams in any fixed order of the row classes. +\end{enumerate} +The bounds include shape preparation, counter initialization and resets, +and returning or clearing the visited portions of work tapes. Their +constants may depend on the fixed radix, the fixed pointwise map, and the +fixed number of row classes. +\end{lemma} + +\begin{proof} +For the first operation split into $q^2$ streams according to the two +specified digits. With these digits fixed, the order of all remaining +digits is unchanged by the permutation. Enumerate output addresses in +their required order and read the stream prescribed by the two preimage +digits. For a digit move use $q$ streams instead. The same observation +shows that splitting on one digit gives streams with the same remaining +address set in the same order. Scan their aligned entries, apply the +fixed pointwise map, and merge according to the output digit; this proves +the third operation. For the fourth, write $r=Wg+w$, where +$0\le w0$, write each chunk as $m$ +consecutive $b=e/m$ digit fields, giving vectors $H,D$ over +$\mathbb Z/q^b\mathbb Z$. We first construct the shear $H\leftarrow H+D$. + +Split whole rows cyclically into $W$ role streams within each prefix +preceding the row field. Write the original row number as +$r=Wg+(w-1)$ with $1\le w\le W$; stream $w$ has row number $g$. +These streams have exactly the same remaining shape, including the +full ranges of $H$ and $D$. Each has +logical volume $V/W$, and its row count is divisible by $W^{k-1}$. + +For a rational matrix $M$, let $\Phi_M$ act on an array by moving its +entry at address $(H,D)$ to $(H+MD,D)$, with every spectator unchanged. +Thus $\Phi_M$ is the array permutation induced by that address map. +Its inverse is $\Phi_{-M}$ and +$\Phi_{M'}\Phi_M=\Phi_{M'+M}$. On every circuit edge apply +$\Phi_{A_e}$ to that role stream; implement it by +Lemma~\ref{lem:matrix-shear}, recursively interchanging each pivot pair +of $b$-digit fields. Execute each circuit gate pointwise at matching +addresses of its role streams. + +The row split supplies the common address set used in the +frame identity~\eqref{eq:common-frame-identity}. Here the frame at a +vertex with matrix $M$ is the address permutation $\Phi_M$, and every +edge changes it by $\Phi_{M'-M}$. The same invariant proof applies +because a common address permutation commutes with every pointwise +bit gate. For the physical input arrays $f_w$, the logical arrays are +$g_w=\Phi_{-M_{\mathrm{in}(w)}}f_w$; this only specifies their +interpretation, with no initial tape operation. The logical circuit +routes $g_w$ to role $\rho(w)$. Thus its physical output satisfies +\[ + f'_{\rho(w)} + =\Phi_{M_{\mathrm{out}(\rho(w))}} + \Phi_{-M_{\mathrm{in}(w)}}f_w + =\Phi_{I_m}f_w, +\] +by~\eqref{eq:finite-shear-contract}. Merge by returning row $g$ of +output role $\rho(w)$ to the original row $Wg+(w-1)$ within the same +preceding prefix. This undoes $\rho$ and restores row order. The result +is $H\leftarrow H+D$ on every original row, including rows assigned +to scratch roles, whose initial values were arbitrary. + +To interchange the two full chunks, perform +\[ + D\leftarrow D-H,\qquad H\leftarrow H+D,\qquad D\leftarrow H-D, +\] +componentwise. Only the middle shear uses the circuit. The other two +updates target the later group and have linear cost. The transformation +sends $(H,D)$ to $(D,H)$. + +The number of recursive calls is the sum of the edge ranks, exactly $s$. +Each acts on one role stream of volume $V/W$, retaining all other +fields as spectators. Splitting, +merging, gates, and triangular operations have total cost $O(V)$ because +their number is fixed. Below we verify that scheduling the recursive +calls on fixed tapes also costs $O(V)$ at this node. Thus if $F_k$ is a +uniform upper bound for time divided by logical volume, then +\begin{equation} +\label{eq:swap-recurrence} + F_0=O(1),\qquad F_k\le(s/W)F_{k-1}+O(1). +\end{equation} +For $a=s/W1$, it is $O(a^k)$. +Hence $F_k=O(e^\tau)$. + +\paragraph{A fixed-tape depth-first schedule.} +Here we complete the implementation assertion used in +\eqref{eq:swap-recurrence}. Reserve $W$ role tapes, a fixed set of +I/O and elementary-operation work tapes, one parking stack tape, and a +separate descriptor stack. Although $W$ is large, it is fixed. +At a call boundary all reusable work tapes, other than the current I/O +and local descriptor, are empty and their heads are at their origins. +The parking and descriptor heads are at the tops of their stacks. + +Before a recursive call, append the $W-1$ inactive role streams to the +parking stack in a fixed order, with separators. Copy the active stream +to the child I/O area, and erase the parent role tapes while traversing +their current contents. Push the parent descriptor and its finite +program counter to the descriptor stack. The role and work tapes are +now available to the child, using the same tapes at every depth. +On return, copy the child output into the designated active role. +Pop the inactive streams in reverse order. To recover a stream in its +original direction, prepare its destination to the known length and +write the popped symbols from the destination's right end toward its +left end. Erase the popped stack cells as they are left. This uses +linear time and ends with the parking head at the previously saved top. +No scan passes through a parked ancestor. Cleanup is always limited to +the region visited by the current call; a reused tape is not swept to +the largest position ever visited by an ancestor. + +Each push, pop, copy, positioning operation, or erasure moves $O(V)$ +symbols at a parent node. There are only the fixed number $s$ of child +calls. This gives precisely the additional $O(V)$ term claimed above, +even though each child itself has volume $V/W$. Temporary storage is +therefore not substituted for logical volume in the factor $s/W$. + +For completeness, descriptor processing also fits this term when the +payload is one bit. Let $V_0$ be the volume at the root of one +power-width call with width $e_0=m^{k_0}$, and $V_j=V_0/W^j$ the volume +of any depth-$j$ child. Here $j\le k_0=\log_m e_0$. The root row +count is at least $W^{k_0}$, so at depth $j$ it is still at least one. +Both original chunk ranges remain present: digits outside the current +subchunks become spectators rather than being removed. Hence +\[ + V_j\ge q^{2e_0},\qquad + j\log W\le(\log_m e_0)\log W=O(e_0)=O(\log V_j). +\] +It follows that +$\log V_0=\log V_j+j\log W=O(\log(2V_j))$. +A local descriptor lists the row field, at most the current $m+m$ +fields, and a fixed number of intervals formed from intervening +spectator fields. Computing products of their lengths, subdividing +target fields, copying lengths, and storing the current instruction take +$(\log(2V_0))^{O(1)}=O(V_j)$ time at that child, since every fixed +power of $\log(2V_j)$ is $O(V_j)$. Before descending, +construct the child's descriptor by retaining its two target fields and +combining each consecutive group of spectator fields into one interval. +The ancestor's subdivision need not remain active in the child. Stack entries contain +finite instructions and binary integers, not new alphabet symbols. +These observations establish one finite machine for every recursion +depth and every choice of spectator lengths. + +\end{proof} + + +We use the rational value $\tau=1-2^{-50}$ established in +\eqref{eq:explicit-motif-exponents}. Its verification uses fixed integer +comparisons and the displayed exponential inequality; it needs no +real-arithmetic oracle. + + +\subsection{Removing width and row restrictions} + +We have proved the fast operation for power widths with enough rows. +Rows for a general array can be supplied by a few of its own high digits. +Their movement will cost less than the final bound. + +\begin{lemma}[Arbitrary-width interchange] +\label{lem:chunk-swap} +There exist fixed $0<\tau<1$ and one fixed finite-alphabet multitape +procedure with the following property. For positive integers $P,G,B$ +and $u\ge1$, it transforms an arbitrary bit array on +\[ + [P]\times[2^u]\times[G]\times[2^u]\times[B] +\] +by the address permutation +\[ + (p,h,g,d,z)\longmapsto(p,d,g,h,z) +\] +in $O(Vu^\tau)$ steps, where $V=PG B\,2^{2u}$. +The integers specifying the shape are part of the input. The time +includes their processing, all padding and unpadding, and fixed-tape +workspace cleanup. In particular, $B=1$ is allowed. +\end{lemma} + +\begin{proof} +First suppose the two ranges are $[q^e]$, where $q$ is the fixed prime +already chosen. Set +\[ + k=\lceil\log_m e\rceil,\qquad + \rho=\left\lceil\frac{k\log W}{2\log q}\right\rceil. +\] +For all sufficiently large $e$, $1\le\rho0,\quad 0<\epsilon<1. +\] +The exponents and comparison constants are fixed, and we impose their +further restrictions in Proposition~\ref{prop:simultaneous-layer}. +Two consequences explain the layout. The polynomial length $r$ grows +faster than every fixed power of $p$, so a scan of a record pays for +polynomial work on its address. Also $K/\log p\to\infty$, which will +make the exceptional set in a packed change of address bits small enough +to repair by sorting. We will obtain cost $O(Vd^{\lambda'})$, with +$\lambda'<1$ and $V$ the logical bit volume, whereas separate butterfly +factors would require $D$ whole-array passes. + +We first construct tensor products of the auxiliary two-point kernel +$C$ from Proposition~\ref{prop:complex-motif-interface}. Its phase +frames express a $C$ tensor product using smaller groups of +selected bits, separated by binary changes of basis. We implement those +changes by moving whole address chunks. Splitting complete rows among +the network's wire roles then reduces the volume of each recursive +call. Finally, we bound the intermediate dyadic values and convert the +completed $C$ layer to the normalized $H_0$ layer. The entire layer is +evaluated exactly before one final truncation. + +\subsection{Phase frames for a simultaneous butterfly layer} +\label{subsec:phase-frames} + +Hold the unselected address bits fixed and regard the stored complex +values on one wire role as a function of the selected bits. The phase +identities below express an edge's residual operator as a product of +two-point kernels on selected directions. + +Put +\[ + H_0=\frac12\begin{pmatrix}1&1\\1&-1\end{pmatrix},\qquad + H=\sqrt2 H_0,\qquad \mathsf S=\operatorname{diag}(1,i),\qquad + Z=\operatorname{diag}(1,-1). +\] +For the bit-flip matrix $X=\bigl(\begin{smallmatrix}0&1\\1&0\end{smallmatrix}\bigr)$, +define +\begin{equation}\label{eq:phase-C} + C=H\mathsf SH=aI+bX,\qquad a=\frac{1+i}{2},\quad b=\frac{1-i}{2}. +\end{equation} +Direct multiplication gives +\begin{equation}\label{eq:phase-basic-identities} + H_0=b\mathsf SC\mathsf S,\qquad C^2=X,\qquad C^4=I,\qquad + C^{-1}=bI+aX=-iZCZ. +\end{equation} +In particular, $C=iZC^{-1}Z$. These identities use only Gaussian dyadic +coefficients. The Hadamard matrices in the definition of +$\mathcal C_U$ are used to prove identities; they need not be executed +by the machine. + +Consider an edge from label $U_-$ to label $U_+$, and choose an +orthonormal basis $v_1,\ldots,v_{\rho_{\rm edge}}$ of its residual. +Proposition~\ref{prop:complex-motif-interface} gives the frame change +\[ + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\prod_{j=1}^{\rho_{\rm edge}}(aI+bX_{v_j})^{\epsilon_j}, + \qquad \epsilon_j\in\{1,-1\}. +\] +Here $(X_vf)(x)=f(x+v)$, and we write $C_v=aI+bX_v$. +The number of directional kernels is precisely +$\rho_{\rm edge}$, including on decreasing edges. The next step puts those directions +into coordinate positions without performing a general transpose. + +\paragraph{Implementing an arbitrary residual basis.} +For $M\in\operatorname{GL}(m,\mathbb F_2)$, let $\mathcal P_M$ be the +address permutation that moves the value at $x$ to $Mx$. Thus +$(\mathcal P_Mf)(x)=f(M^{-1}x)$, and +\begin{equation}\label{eq:phase-conjugation} + \mathcal P_MX_v\mathcal P_M^{-1}=X_{Mv}. +\end{equation} +Extend $v_1,\ldots,v_{\rho_{\rm edge}}$ to a basis of $\mathbb F_2^m$ and take these vectors as +the first $\rho_{\rm edge}$ columns of $M$. The displayed edge identity +then becomes +\begin{equation}\label{eq:phase-edge-coordinate} + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\mathcal P_M\left(\prod_{j=1}^{\rho_{\rm edge}}C_{e_j}^{\epsilon_j}\right) + \mathcal P_M^{-1}, +\end{equation} +where $e_j$ is the $j$th standard basis vector. The matrix $M$ need not +preserve the dot product: equation~\eqref{eq:phase-conjugation} only +uses its invertibility. + +For the array layout used below, take a group of $e=mf$ consecutive +axis chunks and divide it into $m$ consecutive slots of $f$ chunks, +numbered in physical order. +Number the chunks within each slot by $j=0,\ldots,f-1$, starting at +its least significant end. Write $x_{h,j}$ for the selected bit in +chunk $j$ of slot $h$, where $1\le h\le m$. Column $j$ is the vector +$(x_{1,j},\ldots,x_{m,j})$. A frame on this group is the tensor +product of the same phase frame +$\mathcal C_U$ of Proposition~\ref{prop:complex-motif-interface} +on these $f$ columns. + +To implement \eqref{eq:phase-edge-coordinate} on the group, first apply +$\mathcal P_M^{-1}$ separately to each column. For each +$1\le h\le\rho_{\rm edge}$, apply $(C^{\epsilon_h})^{\otimes f}$ to the +$f$ bits $x_{h,0},\ldots,x_{h,f-1}$. This is one child operation +on the $f$ axes in slot $h$. Finally apply $\mathcal P_M$ to every +column. A negative directional kernel still requires only one +forward child, because +\begin{equation}\label{eq:phase-inverse-child} + (C^{-1})^{\otimes f} + =(-i)^f Z^{\otimes f}C^{\otimes f}Z^{\otimes f}. +\end{equation} +The rightmost phase is applied first. All inverse wrappers are address +signs and constant fourth-root phases, so they add no recursive calls. + +Gaussian elimination expresses any $M\in\operatorname{GL}(m,\mathbb F_2)$ +as a product of at most $m(m-1)+3m$ elementary row additions: one clears +at most $m-1$ other entries per pivot, and each row swap is three row +additions. Reversing the elimination gives the required product since +each row addition is an involution. The number is a constant because +$m$ is fixed. Adding row $h'$ to row $h$ in every column applies +$x_{h,j}\leftarrow x_{h,j}\mathbin\oplus x_{h',j}$ for every +$0\le j1$, these segments +are disjoint, and the highest one ends immediately below $j_{f-1}$. +Write their initial values in $y$ and $z$ as +\[ + u_i=2g_i+a_i,\qquad w_i=2h_i+b_i, + \qquad a_i,b_i\in\{0,1\}. +\] +The values $g_i,h_i\in\{0,\ldots,2^{K-1}-1\}$ are the guard values. The +control for this pair of segments is the selected bit $c_i=x_{j_i}$. + +Apply each line of \eqref{eq:eight-packed-additions} simultaneously to all +these segment pairs. Physically, a line updating $y$ by sign $\varepsilon$ +and testing parity $b$ of $z$ is the single cyclic shift +\begin{equation} +\label{eq:packed-cyclic-shift} + y\longleftarrow y+ + \varepsilon\sum_{i=0}^{f-2}2^{j_i} + [\,x_{j_i}=1\,][\,z_{j_i}=b\,] + \pmod{2^L}. +\end{equation} +For a line updating $z$, interchange $y$ and $z$ in this formula. +The shift offset never depends on its target chunk, so each line is a +bijection of the rectangle. Let $S_0$ be their composition. It fixes +the spectator coordinates. + +Let $\mathcal B$ consist of the addresses for which +at least one used guard value, in either $y$ or $z$, fails +\begin{equation} +\label{eq:packed-guard-interval} + 10\le g\le 2^{K-1}-11. +\end{equation} +At an address outside $\mathcal B$, each segment initially lies in +$[20,2^K-21]$. Even displacement eight keeps it inside +$[0,2^K-1]$. Inductively, each packed addition therefore agrees with all +the independent segment additions: no segment carries into or borrows +from the next segment. When $f>1$, the bits below $j_0$ and above the +highest used segment are untouched as well. By +\eqref{eq:eight-packed-result}, $S_0$ +then agrees with the ideal permutation $T_0$ that performs the required +XORs at $j_0,\ldots,j_{f-2}$ and fixes all other address coordinates. + +There are exactly twenty excluded values for each guard in +\eqref{eq:packed-guard-interval}. Since its complete range has +$2^{K-1}$ values, the union bound over the $2(f-1)$ guards gives +\begin{equation} +\label{eq:packed-bad-fraction} + |\mathcal B|\le\delta_{\rm bad}M. +\end{equation} +Indeed, the complete $y,z$ ranges give the same guard distribution at +each choice of spectator coordinates. No record value enters this count. + +The ideal map $T_0$ preserves all guard values and therefore preserves +$\mathcal B$. Both $T_0$ and $S_0$ are bijections, and they agree off +$\mathcal B$. Taking complements in the finite rectangle gives +\[ + S_0(\mathcal B^c)=T_0(\mathcal B^c)=\mathcal B^c, + \qquad S_0(\mathcal B)=\mathcal B. +\] +Thus $T_0S_0^{-1}$ fixes $\mathcal B^c$ and permutes $\mathcal B$. +It remains to implement the rotations and this correction on tapes. + +For one rotation, move its target to the rightmost of the three chunk +positions if necessary. Let $P^{\rm sw}$ be the product of the record +field lengths before the earlier exchanged chunk, let $G^{\rm sw}$ +be the product between the exchanged chunks, and let $B^{\rm sw}$ be +$R$ times the product after the later one. Empty products are one. +The bit array has exactly the shape +\[ + [P^{\rm sw}]\times[2^L]\times[G^{\rm sw}] + \times[2^L]\times[B^{\rm sw}]. +\] +The third chunk lies inside one collapsed spectator interval. +Pass only $L$ and these three positive canonical lengths to +Lemma~\ref{lem:chunk-swap}. Each length is at most $V$, so the local +descriptor has $O(A_{\rm rect})$ bits. The swap costs $O(VL^\tau)$, including +its own padding and cleanup. + +The equal chunk lengths leave the field-length list unchanged by a +completed swap. Keep the permutation of the logical names $x,y,z$ in +finite local state. With the target now after its two controls, collapse +the remaining intervals to obtain +\[ + [\Lambda_0]\times[2^L]_{\rm control\,1}\times[\Lambda_1] + \times[2^L]_{\rm control\,2}\times[\Lambda_2] + \times[2^L]_{\rm target}\times[B_{\rm rot}], +\] +where $B_{\rm rot}$ includes the payload and every displayed spectator +length is positive. Their product with the chunk lengths is $V$. +Together with $K,f,\rho$ and the finite name permutation, these fixed +canonical lengths form an $O(A_{\rm rect})$-bit local descriptor. The offset +routine receives the two current $L$-bit logical control values. A scan +of at most $f\le L$ selected positions evaluates +\eqref{eq:packed-cyclic-shift} in $L^{O(1)}$ time, without reading the +target or spectator values. Lemma~\ref{lem:ordered-affine-streams} +therefore gives an $O(V)$ rotation: its offset work is absorbed by the +$2^L$ nonempty target blocks in each fiber. Undo the swap after the +rotation. The local descriptors and name permutation are updated at +completed swap boundaries; the primitives use their own descriptors +inside padded layouts. +There are at most sixteen swaps and eight rotations in $S_0$. + +To implement the correction, scan the stream with a record-rank counter. +All chunk names are back in their original positions. Dividing the +current rank through the fixed seven field lengths recovers the three +chunk values and their mixed-radix record strides. The strides exclude +the $R$ payload bits. All involved integers have $O(A_{\rm rect})$ bits, so +schoolbook arithmetic, descriptor copying, and resets take at most +$O(A_{\rm rect}^3)$ per record. Test membership in $\mathcal B$ and extract just +those records. For a current exceptional address $q$, compute +$q'=T_0(S_0^{-1}(q))$ by reversing the eight modular additions with +negated offsets, then applying the selected XORs directly. Each reversed +mask uses the current controls of that reversed line. There are at most +$f\le L\le A_{\rm rect}$ selected positions, so this calculation also fits +$O(A_{\rm rect}^3)$ time. + +If $q_h,q'_h$ are the current and destination values of chunk +$h\in\{x,y,z\}$ and $\sigma_h$ is its record stride, the fixed +spectator coordinates give +\[ + \operatorname{rank}(q')=\operatorname{rank}(q)+ + \sum_{h\in\{x,y,z\}}(q'_h-q_h)\sigma_h. +\] +The differences are signed. Attach this destination rank, padded to +$\lceil\log_2M\rceil\le A_{\rm rect}$ bits, to the extracted record, and mark its +hole on a fixed track of the full stream. Hold the full stream untouched +while stable binary radix sorting scans only the extracted records and +keys, least significant key bit first. Since $T_0S_0^{-1}$ permutes +$\mathcal B$, these keys are distinct and are exactly the ranks of the +marked holes. One forward full-stream scan reinserts the sorted records. +This implements $T_0$ everywhere. + +Finally apply the two-bit XOR to $x_{j_{f-1}},y_{j_{f-1}}$ by +Lemma~\ref{lem:elementary-streams}, splitting those chunks at the +selected positions and collapsing the other intervals. Its descriptor +again has a fixed number of positive lengths, each at most $V$. +This costs $O(V)$ and supplies the omitted selected position. When +$f=1$, $S_0,T_0$ are identities, $\mathcal B$ is empty, and this last +step is the entire algorithm. + +The movement costs $O(V(L^\tau+1))$. A fixed number of full record scans +costs $O(MA_{\rm rect}^3+V)$, and the at most $A_{\rm rect}$ radix passes cost +$O(|\mathcal B|A_{\rm rect}(R+A_{\rm rect}))$; skip them when the extracted bank is empty. +The initial descriptor has a fixed number of canonical integers of +$O(A_{\rm rect})$ bits, so its preparation is covered by $O(MA_{\rm rect}^3)$. +All counters, positioning, rewinds, and cleanup are included. +Equation~\eqref{eq:packed-bad-fraction} proves +\eqref{eq:packed-rectangle-time} on a fixed number of tapes. +After division by $V=MR$, its additional terms are bounded by +$A_{\rm rect}^3/R$ and +$80(f-1)2^{-K}A_{\rm rect}(1+A_{\rm rect}/R)$. Under the stated family bounds +the first tends to zero, and the second is +$O(p^2 2^{-K}(1+A_{\rm rect}/R))=o(1)$. This proves the final assertion. +\end{proof} + +\paragraph{Application to a fixed binary change of basis.} +An invertible matrix over $\mathbb F_2$ of fixed order $m\ge3$ is a +product of a fixed number of elementary row additions; a row exchange +is three such additions. In one invocation of the finite network on +$e=mf$ axes, slot $h$ consists of $f$ consecutive $K$-bit axis chunks. +It therefore has address-bit width $L=fK$, and its selected bits +$x_{h,j}$ occupy positions $\rho+jK$ for $0\le j1$. +For these fixed choices +there are a cutoff $p_0$, one fixed finite-alphabet multitape procedure, +and an implicit time constant with the following guarantee. The cutoff +and time constant may depend on the fixed rational parameters +and these constants. For every choice of positive integers $p,d,r$ +with $p\ge p_0$ and +\[ + a_dp^\epsilon\le d\le b_dp^\epsilon,\qquad + 2^{a_rp/d}\le r\le 2^{b_rp/d}, +\] +put $K=\lfloor d^c\rfloor$, and let $1\le D\le d$, $P,S\ge1$, and +$0\le\rho0$ +and $C_w>1$, and choose the layer constants once as +\[ + C_M=C_\ell+1,\qquad + C_{\rm desc}=32(C_\ell+C_w+1). +\] +Use these constants and $C_w$ in +Proposition~\ref{prop:simultaneous-layer}. These fixed choices determine +a cutoff $p_1$, one fixed-tape procedure, and an implicit time constant +with the following guarantee. For every choice of positive integers +$p,d,r$ with $p\geq p_1$ and +\[ + a_dp^\epsilon\leq d\leq b_dp^\epsilon,\qquad + 2^{a_rp/d}\leq r\leq2^{b_rp/d}, +\] +suppose $d\geq2$ and $r=2^\ell$ with an integer $2\leq\ell0$. Thus all participating axes in a +common round have current length $u_i=2^{h+1}$. +The branch bit written at position $h$ is frequency bit $a_i-1-h$; +its frequency significance can differ between long and short axes. +The descriptor locates that named slot after $L$, so the physical +move has not changed which pair the current butterfly uses. The +opposite procedure executes this schedule in reverse order and, +when present, ends with the extra leading round on the long axes. + +For a position $h$ in the remaining chunks, the selected bit has +offset $(h-b)\bmod K$, counted from the least significant bit, in +each of the $D$ consecutive chunks with the same chunk index $j$. +Let $n_P$ and $n_S$ be the numbers of record-address bits before and +after that group. Every combination of those bits occurs, so the +layer sees the complete address set +\[ + [P]\times[2^K]^D\times[S],\qquad + P=2^{n_P},\quad S=2^{n_S},\quad + n_P+DK+n_S=\sum_i a_i\leq D\ell=O(p). +\] +Thus its record count is $PS2^{DK}=M$ and +$\log_2(2M)\leq(C_\ell+1)p=C_Mp$. +The current transform parameters supply $p,d,r,K,w$, and the round +determines $D,P,S$ and the selected offset $\rho$. Encode these values +as the header $\mathcal E$ of Proposition~\ref{prop:simultaneous-layer}. +The same fixed descriptor bound covers every axis choice and round. +Indeed $|\Gamma(v)|\leq2\log_2v+1$, and +$\ell+n_P+n_S\leq d\ell\leq C_\ell p$. Also +$d,D\leq\max\{C_\ell,1\}p$, $K,\rho+1\leq p$, and $w\leq C_wp$. +Adding the nine code lengths therefore gives +\[ + |\mathcal E| + \leq 2C_\ell p+12\log_2p+ + 4\log_2\max\{C_\ell,1\}+2\log_2C_w+9 + \leq C_{\rm desc}p. +\] +The last inequality uses $p\geq1$, $\log_2p\leq p$, and +$\log_2x\leq x$ for $x\geq1$. +This is the descriptor passed to the layer; the longer +table locating named slots remains separate for the transform's address +calculations. +The simultaneous-layer procedure therefore applies at cost +$O(Tpd^{\lambda'})$ per round and $O(Tp\ell d^{\lambda'})$ in total. + +In a round on prefix slots, process the participating bits individually. +Temporarily move one such bit immediately before the polynomial +suffix. In each now adjacent pair, buffer the first record and scan +it with the second, writing the half-sums and half-differences to two +work tapes. Append the half-sum record and then the half-difference +record, and reverse the bit move after +all pairs are processed. Including head returns, the work is +$O(rp)$ per pair and $O(Tp)$ for the moves and scans at coefficient +width $O(p)$. +That width suffices without truncating between axes: after $s\leq D$ +individual $H_0$ factors, the coefficients are exact dyadics on the +$2^{-(p+s)}$ grid and still lie in the disk. A temporary sum has +modulus at most two and needs only a constant number of extra integer +bits. Hence +$p+D+O(1)=O(p)$ bits per component suffice, since $D\leq d$ and +$d\ell=O(p)$. Complete the combined monomial exactly and apply +$Q_p$ once at the end of the round. Write the resulting disk-grid +numerators in the supplied $w$-bit component format. Their magnitudes +are at most $2^p$, so this takes one linear scan within the same bound. +In an opposite round on prefix slots the +inverse monomial comes first and preserves the grid and disk, so the +same width bound holds for its individual factors. There are at +most $b+1\leq K$ rounds on prefix slots, giving cost $O(TpdK)$. + +For each output record of a forward butterfly round, the descriptor +locates the new branch bit $b_i$ and the lower named slots that encode +$k_i$. Read their current values to compute +\eqref{eq:combined-twiddle}. Before an opposite round at position +$h$, all lower positions have already been processed in reverse. +Those slots again index the lower inputs of that level, while slot +$h$ still gives $b_i$. They therefore encode the same $k_i$ needed +by the inverse monomial before its +butterfly. The binary descriptions of the addresses, exponent, and +layout have polynomial length in $p$. Ordinary +fixed-tape arithmetic therefore computes the exponent in +$\operatorname{poly}(p)$ time per polynomial record. Each record +contains $\Theta(rp)$ bits, and $r$ dominates every fixed power of +$p$, so this work fits within its scan cost. The same bound covers +scans of the polynomially many round and layout descriptors. +Growing lists reside on tapes; a fixed number of counter and work +tapes suffices for every number of axes. + +To implement the monomial, write $E=er+s$ with $0\leq s1$. +Let $w$ be an integer with $p+2\leq w\leq C_wp$. +The input supplies $\Gamma(p)\Gamma(r)\Gamma(w)$ and two disk grid +polynomials $f,g\in\mathcal R_r$ in the component format of +Proposition~\ref{prop:simultaneous-layer} with width $w$. +One can compute the exact Gaussian integer +numerators of $fg$, and then return $Q_p(fg/r)$ in that same format, in time +$O(rp\log(rp))$ on a fixed number of tapes. The output is a disk +grid polynomial with error less than $\sqrt2\,2^{-p}$ from $fg/r$. +\end{lemma} +\begin{proof} +The supplied power of two $r$ determines $\ell=\log_2r$. +Write +\[ + f=2^{-p}(a+ib),\qquad g=2^{-p}(c+ie), +\] +where $a,b,c,e\in\mathbb Z[y]$ have degree less than $r$ and +coefficients of absolute value at most $2^p$. Set $B_0=2^{4p}$ +and, for $u\in\{a,b,c,e\}$, define the signed evaluation integer +\[ + A_u=u(B_0)=\sum_{j=0}^{r-1}u_jB_0^j. +\] +The bound +\[ + |A_u|\leq2^p\frac{B_0^r-1}{B_0-1} 1, + } + need(all(controls.values()), "A negative control failed") + receipt = { + "status": "PASS_FIXED_PAST_INDEPENDENT_BOUNDED_CHECK", + "proof_sha256": PROOF_PIN, + "checker_sha256": sha256(Path(__file__).read_bytes()).hexdigest(), + "arithmetic": "Exact rational pairs for Gaussian numbers; standard library only", + "tensor_widths": [0, 1, 2, 3, 4, 5], + "power_range": [-9, 9], + "tensor_power_cases": tensor_cases, + "decoded_error_propagator_cases": propagation_cases, + "negative_controls": controls, + "native_supplier_verified": False, + "recursive_invoice_verified": False, + "scope": "Finite exact checks of the identities in the written conditional proof. The general bound uses the written tensor and commutation arguments.", + } + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2) + "\n") + print(receipt["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/1-COMPLETED-PREFIX-CODES.json b/research/publication-reviews/completed-prefix-outer/cold-replay/1-COMPLETED-PREFIX-CODES.json new file mode 100644 index 0000000000..ebcf9f8036 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/1-COMPLETED-PREFIX-CODES.json @@ -0,0 +1,84 @@ +{ + "dif": { + "both_code_inverse_orders": true, + "completed_slots": [ + 2, + 5 + ], + "exact_transform_entries": 4096, + "later_round_commutators": 4, + "noncommuting_code_fusion_entries": 4096, + "prime": 97, + "record_dimension": 64, + "root": 8, + "root_order": 16 + }, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "not_claimed": [ + "A new complete supplier", + "A recursive encoded-child contract", + "A kappa improvement", + "A general circuit lower bound" + ], + "paired_current_line": { + "H0_diagonal_conjugation_checked": true, + "actual_ports": 112, + "all_size_statement": "The tensor support is 2^lambda by the exact unit proof.", + "current_line_is_not_a_twiddle_normalizer": true, + "line_square_is_a_permutation": true, + "paired_replica_columns": 114688, + "spatial_columns": 57344 + }, + "reversed_label_opposite": [ + { + "all_operator_entries": 4096, + "axis_log_lengths": [ + 3, + 3 + ], + "physical_bit_reversal_operations": 0, + "record_dimension": 64, + "remaining_round_commutators": 2, + "required_operator": "F_plus B_inverse" + }, + { + "all_operator_entries": 1024, + "axis_log_lengths": [ + 3, + 2 + ], + "physical_bit_reversal_operations": 0, + "record_dimension": 32, + "remaining_round_commutators": 2, + "required_operator": "F_plus B_inverse" + } + ], + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "scope": "Exact finite conventions and negative controls; all-size theorems are proved in the note.", + "selected_offset_endpoint": { + "all_addresses": 262144, + "chunk_width": 3, + "copies": 2, + "offset": 1, + "slots": 3, + "third_slot_and_other_offsets_fixed": true + }, + "source_sha256": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "status": "PASS_COMPLETED_PREFIX_CODES", + "whole_axis_row_prefix": { + "applies_to_both_transform_directions": true, + "axis_bits_available": "ell or ell-1", + "ell": "Theta(p/d)", + "margin_lower_bound": "99/100", + "one_axis_work_and_layout": "O(V ell)", + "padding_volume_factor": "less than two", + "row_bits_needed": "ceil(ceil(log_m d) log_2 W)=O(log d)", + "strict_margin_epsilon_minus_kappa": "1635654921950317604269246176697592893315360642164647696163717235784796569190497511406755693461406225762418838586331730835704915263244133189022659330234814818810892219059957239485707752007657731284696774507602551594083331891078337774583028045958975578287492520966716631023415709897216606029214103869146078792163164507055296177461882843051065083293106678283624262730067538295610766368389669754871598780028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000" + } +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/1-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/1-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/1-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/1-stdout.txt new file mode 100644 index 0000000000..bd13574bae --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/1-stdout.txt @@ -0,0 +1 @@ +PASS_COMPLETED_PREFIX_CODES diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/2-PAST-CATALYST-LAYOUT.json b/research/publication-reviews/completed-prefix-outer/cold-replay/2-PAST-CATALYST-LAYOUT.json new file mode 100644 index 0000000000..abc845bb97 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/2-PAST-CATALYST-LAYOUT.json @@ -0,0 +1,1016 @@ +{ + "added_native_children": 0, + "chunk_group_margin": "2463090156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "extra_address_bits": 0, + "fixed_slot_order_maps": "At most the fixed number of native slots", + "initial_and_final_bit_moves": "O(d) per transform", + "interchanges_for_nonadjacent_past_block": 2, + "interchanges_per_offset_alignment": 6, + "not_claimed": [ + "The fixed-past cover condition", + "The active child profile", + "The selected finite compact-engine invoice", + "Recursive encoded-child closure", + "A kappa improvement" + ], + "per_invocation_time": "O(V ((eK)^tau+1)) under the cited chunk-swap interface", + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "rotation_cases": [ + [ + 1, + 1, + 0 + ], + [ + 1, + 2, + 0 + ], + [ + 1, + 2, + 1 + ], + [ + 1, + 3, + 0 + ], + [ + 1, + 3, + 1 + ], + [ + 1, + 3, + 2 + ], + [ + 1, + 4, + 0 + ], + [ + 1, + 4, + 1 + ], + [ + 1, + 4, + 2 + ], + [ + 1, + 4, + 3 + ], + [ + 1, + 5, + 0 + ], + [ + 1, + 5, + 1 + ], + [ + 1, + 5, + 2 + ], + [ + 1, + 5, + 3 + ], + [ + 1, + 5, + 4 + ], + [ + 1, + 6, + 0 + ], + [ + 1, + 6, + 1 + ], + [ + 1, + 6, + 2 + ], + [ + 1, + 6, + 3 + ], + [ + 1, + 6, + 4 + ], + [ + 1, + 6, + 5 + ], + [ + 1, + 7, + 0 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 7, + 4 + ], + [ + 1, + 7, + 5 + ], + [ + 1, + 7, + 6 + ], + [ + 2, + 1, + 0 + ], + [ + 2, + 2, + 0 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 0 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 3, + 2 + ], + [ + 2, + 4, + 0 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 4, + 2 + ], + [ + 2, + 4, + 3 + ], + [ + 2, + 5, + 0 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 5, + 2 + ], + [ + 2, + 5, + 3 + ], + [ + 2, + 5, + 4 + ], + [ + 2, + 6, + 0 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 6, + 2 + ], + [ + 2, + 6, + 3 + ], + [ + 2, + 6, + 4 + ], + [ + 2, + 6, + 5 + ], + [ + 2, + 7, + 0 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 7, + 2 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 7, + 4 + ], + [ + 2, + 7, + 5 + ], + [ + 2, + 7, + 6 + ], + [ + 3, + 1, + 0 + ], + [ + 3, + 2, + 0 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 3, + 0 + ], + [ + 3, + 3, + 1 + ], + [ + 3, + 3, + 2 + ], + [ + 3, + 4, + 0 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 4, + 2 + ], + [ + 3, + 4, + 3 + ], + [ + 3, + 5, + 0 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 5, + 2 + ], + [ + 3, + 5, + 3 + ], + [ + 3, + 5, + 4 + ], + [ + 3, + 6, + 0 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 6, + 2 + ], + [ + 3, + 6, + 3 + ], + [ + 3, + 6, + 4 + ], + [ + 3, + 6, + 5 + ], + [ + 3, + 7, + 0 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 7, + 2 + ], + [ + 3, + 7, + 3 + ], + [ + 3, + 7, + 4 + ], + [ + 3, + 7, + 5 + ], + [ + 3, + 7, + 6 + ], + [ + 4, + 1, + 0 + ], + [ + 4, + 2, + 0 + ], + [ + 4, + 2, + 1 + ], + [ + 4, + 3, + 0 + ], + [ + 4, + 3, + 1 + ], + [ + 4, + 3, + 2 + ], + [ + 4, + 4, + 0 + ], + [ + 4, + 4, + 1 + ], + [ + 4, + 4, + 2 + ], + [ + 4, + 4, + 3 + ], + [ + 4, + 5, + 0 + ], + [ + 4, + 5, + 1 + ], + [ + 4, + 5, + 2 + ], + [ + 4, + 5, + 3 + ], + [ + 4, + 5, + 4 + ], + [ + 4, + 6, + 0 + ], + [ + 4, + 6, + 1 + ], + [ + 4, + 6, + 2 + ], + [ + 4, + 6, + 3 + ], + [ + 4, + 6, + 4 + ], + [ + 4, + 6, + 5 + ], + [ + 4, + 7, + 0 + ], + [ + 4, + 7, + 1 + ], + [ + 4, + 7, + 2 + ], + [ + 4, + 7, + 3 + ], + [ + 4, + 7, + 4 + ], + [ + 4, + 7, + 5 + ], + [ + 4, + 7, + 6 + ], + [ + 5, + 1, + 0 + ], + [ + 5, + 2, + 0 + ], + [ + 5, + 2, + 1 + ], + [ + 5, + 3, + 0 + ], + [ + 5, + 3, + 1 + ], + [ + 5, + 3, + 2 + ], + [ + 5, + 4, + 0 + ], + [ + 5, + 4, + 1 + ], + [ + 5, + 4, + 2 + ], + [ + 5, + 4, + 3 + ], + [ + 5, + 5, + 0 + ], + [ + 5, + 5, + 1 + ], + [ + 5, + 5, + 2 + ], + [ + 5, + 5, + 3 + ], + [ + 5, + 5, + 4 + ], + [ + 5, + 6, + 0 + ], + [ + 5, + 6, + 1 + ], + [ + 5, + 6, + 2 + ], + [ + 5, + 6, + 3 + ], + [ + 5, + 6, + 4 + ], + [ + 5, + 6, + 5 + ], + [ + 5, + 7, + 0 + ], + [ + 5, + 7, + 1 + ], + [ + 5, + 7, + 2 + ], + [ + 5, + 7, + 3 + ], + [ + 5, + 7, + 4 + ], + [ + 5, + 7, + 5 + ], + [ + 5, + 7, + 6 + ], + [ + 6, + 1, + 0 + ], + [ + 6, + 2, + 0 + ], + [ + 6, + 2, + 1 + ], + [ + 6, + 3, + 0 + ], + [ + 6, + 3, + 1 + ], + [ + 6, + 3, + 2 + ], + [ + 6, + 4, + 0 + ], + [ + 6, + 4, + 1 + ], + [ + 6, + 4, + 2 + ], + [ + 6, + 4, + 3 + ], + [ + 6, + 5, + 0 + ], + [ + 6, + 5, + 1 + ], + [ + 6, + 5, + 2 + ], + [ + 6, + 5, + 3 + ], + [ + 6, + 5, + 4 + ], + [ + 6, + 6, + 0 + ], + [ + 6, + 6, + 1 + ], + [ + 6, + 6, + 2 + ], + [ + 6, + 6, + 3 + ], + [ + 6, + 6, + 4 + ], + [ + 6, + 6, + 5 + ], + [ + 6, + 7, + 0 + ], + [ + 6, + 7, + 1 + ], + [ + 6, + 7, + 2 + ], + [ + 6, + 7, + 3 + ], + [ + 6, + 7, + 4 + ], + [ + 6, + 7, + 5 + ], + [ + 6, + 7, + 6 + ] + ], + "scope": "Exact address wrappers conditional on a native word that fixes the spectator fields.", + "source_sha256": { + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "startup_margin": "1081110357609925260614972695003107315707432353068338487603991699409949621702495690156909535160235873839601108223405260050123543294943053402137660198994397070489620108165140795187785639656314293544597085375410582291108751565224554246715990585636803213137497296463685876362653172078415927035174159499690912068352607880037991076665304643497436633279437216679436871538992416375313119280028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000", + "status": "PASS_PAST_CATALYST_LAYOUT", + "two_reserve_cases": [ + [ + 1, + 2, + 64, + 9 + ], + [ + 1, + 3, + 64, + 9 + ], + [ + 1, + 4, + 64, + 9 + ], + [ + 1, + 5, + 64, + 9 + ], + [ + 1, + 6, + 64, + 9 + ], + [ + 1, + 7, + 64, + 9 + ], + [ + 2, + 2, + 128, + 18 + ], + [ + 2, + 3, + 128, + 18 + ], + [ + 2, + 4, + 128, + 18 + ], + [ + 2, + 5, + 128, + 18 + ], + [ + 2, + 6, + 128, + 18 + ], + [ + 2, + 7, + 128, + 18 + ], + [ + 3, + 2, + 192, + 27 + ], + [ + 3, + 3, + 192, + 27 + ], + [ + 3, + 4, + 192, + 27 + ], + [ + 3, + 5, + 192, + 27 + ], + [ + 3, + 6, + 192, + 27 + ], + [ + 3, + 7, + 192, + 27 + ], + [ + 4, + 2, + 256, + 36 + ], + [ + 4, + 3, + 256, + 36 + ], + [ + 4, + 4, + 256, + 36 + ], + [ + 4, + 5, + 256, + 36 + ], + [ + 4, + 6, + 256, + 36 + ], + [ + 4, + 7, + 256, + 36 + ] + ] +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/2-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/2-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/2-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/2-stdout.txt new file mode 100644 index 0000000000..7d1906111f --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/2-stdout.txt @@ -0,0 +1 @@ +PASS_PAST_CATALYST_LAYOUT diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/3-TWIDDLE-PASS-CHECKS.json b/research/publication-reviews/completed-prefix-outer/cold-replay/3-TWIDDLE-PASS-CHECKS.json new file mode 100644 index 0000000000..9f058581fc --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/3-TWIDDLE-PASS-CHECKS.json @@ -0,0 +1,46 @@ +{ + "actual_ports": 112, + "canonical_word_sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "checker_sha256": "9904c441ee62410330c7d359797bd3659b9989c6b301961eaa1bcace4b0d7ca8", + "proof_sha256": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99", + "scope": "Exact ring controls for the separate full-stream monomial/binary-ADD pass argument. No lower bound on recursive, unequal-volume, or fused multi-round implementations.", + "source_path": "upstream/build/sections/06-transforms.tex", + "source_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "source_sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "status": "PASS_EXACT_CURRENT_TWIDDLE_PASS_CONTROLS", + "tail_cases": 153, + "tensor_support": [ + { + "nonzero_entries": 2, + "width": 1 + }, + { + "nonzero_entries": 4, + "width": 2 + }, + { + "nonzero_entries": 8, + "width": 3 + }, + { + "nonzero_entries": 16, + "width": 4 + }, + { + "nonzero_entries": 32, + "width": 5 + }, + { + "nonzero_entries": 64, + "width": 6 + }, + { + "nonzero_entries": 128, + "width": 7 + }, + { + "nonzero_entries": 256, + "width": 8 + } + ] +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/3-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/3-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/3-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/3-stdout.txt new file mode 100644 index 0000000000..e85518e78b --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/3-stdout.txt @@ -0,0 +1 @@ +PASS_EXACT_CURRENT_TWIDDLE_PASS_CONTROLS diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/4-ACCUMULATED-TWIDDLE-CODE.json b/research/publication-reviews/completed-prefix-outer/cold-replay/4-ACCUMULATED-TWIDDLE-CODE.json new file mode 100644 index 0000000000..546fc009ea --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/4-ACCUMULATED-TWIDDLE-CODE.json @@ -0,0 +1,89 @@ +{ + "active_source_coordinates": [ + 0, + 1, + 3 + ], + "actual_port": 11, + "actual_port_pin": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "arbitrary_replica_slices": 2, + "arithmetic": "Exact Gaussian integer pairs; theta is a separate signed permutation on polynomial coefficients; unitary-rescaled word denominators 8,32 and decoder denominator 256", + "axes": 3, + "bits_per_axis": 2, + "checker_sha256": "cc611e8033736c3f43fac2aeb277e01a695e91116cb386ce449679fde620df06", + "decoder_first_row_numerators_over_256": [ + [ + 0, + 128, + 0 + ], + [ + 21, + -128, + 0 + ], + [ + 42, + -64, + 0 + ], + [ + 47, + 64, + 0 + ], + [ + 59, + 64, + 0 + ], + [ + 62, + 64, + 0 + ], + [ + 171, + -64, + 0 + ], + [ + 174, + -64, + 0 + ], + [ + 186, + -64, + 0 + ], + [ + 191, + 64, + 0 + ] + ], + "decoder_nonzero_entries_per_row": 10, + "decoder_rows_checked": 256, + "decoder_squared_magnitude_counts": { + "1/16": 8, + "1/4": 2 + }, + "encoded_parity_class_counts": { + "1": 256 + }, + "formal_Gaussian_columns": 256, + "no_twiddle_control": "All 256 decoder rows have four entries of squared magnitude 1/4", + "ordinary_DIF_entries_checked": 65536, + "polynomial_coefficient_positions": 2, + "real_input_columns": 512, + "scope": "Stable port q, common exact T endpoint, current-bit H0 conversion, and the actual two-round length-four DIF twiddle. Other six local axes factor as the identity in the residual. This rejects one native C_r between monomial maps for this terminal residual. It does not bound arbitrary native-child words, changed layouts, changed endpoints, or a general multiplication algorithm.", + "source_H0_normalization": "Each literal H0 is H/2. Both complete source words equal one eighth of the unitary-rescaled word used here. This common factor cancels in U_raw U_code^-1.", + "source_pins": { + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "source_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "status": "PASS_EXACT_ACCUMULATED_TWIDDLE_CODE", + "unitary_Gram_entries_checked": 131072 +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/4-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/4-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/4-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/4-stdout.txt new file mode 100644 index 0000000000..8a76ec2a0e --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/4-stdout.txt @@ -0,0 +1,2 @@ +PASS_EXACT_ACCUMULATED_TWIDDLE_CODE +256 coefficient decoder rows: 10 nonzero entries each; the no-twiddle control has 4. diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/5-OPPOSITE-PREFIX-REVIEW.json b/research/publication-reviews/completed-prefix-outer/cold-replay/5-OPPOSITE-PREFIX-REVIEW.json new file mode 100644 index 0000000000..e8f6ab4e3d --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/5-OPPOSITE-PREFIX-REVIEW.json @@ -0,0 +1,122 @@ +{ + "common_chunk_round_checks": 3510, + "controls": [ + { + "name": "same_twiddle_length_on_long_and_short_axes", + "witness": { + "correct": 4, + "wrong": 2, + "x": 16, + "y": 8 + } + }, + { + "correct": 8, + "name": "omit_input_bit_reversal_in_endpoint_formula", + "wrong": 2, + "x": 1, + "y": 1 + } + ], + "exact_bit_coefficient_cases": 9455, + "exact_ring_entry_cases": [ + { + "axis_log_lengths": [ + 1 + ], + "entries": 4, + "normalization_denominator": 2, + "root_modulus": 4 + }, + { + "axis_log_lengths": [ + 2 + ], + "entries": 16, + "normalization_denominator": 4, + "root_modulus": 8 + }, + { + "axis_log_lengths": [ + 3 + ], + "entries": 64, + "normalization_denominator": 8, + "root_modulus": 16 + }, + { + "axis_log_lengths": [ + 4 + ], + "entries": 256, + "normalization_denominator": 16, + "root_modulus": 32 + }, + { + "axis_log_lengths": [ + 5 + ], + "entries": 1024, + "normalization_denominator": 32, + "root_modulus": 64 + }, + { + "axis_log_lengths": [ + 6 + ], + "entries": 4096, + "normalization_denominator": 64, + "root_modulus": 128 + }, + { + "axis_log_lengths": [ + 3, + 2 + ], + "entries": 1024, + "normalization_denominator": 32, + "root_modulus": 16 + }, + { + "axis_log_lengths": [ + 3, + 3 + ], + "entries": 4096, + "normalization_denominator": 64, + "root_modulus": 16 + }, + { + "axis_log_lengths": [ + 4, + 3 + ], + "entries": 16384, + "normalization_denominator": 128, + "root_modulus": 32 + }, + { + "axis_log_lengths": [ + 2, + 2, + 1 + ], + "entries": 1024, + "normalization_denominator": 32, + "root_modulus": 8 + } + ], + "layout_cases": 455, + "not_claimed": [ + "A changed encoded supplier", + "A recursively closed past-space code", + "An improved kappa", + "The other theorems in the reviewed note" + ], + "proof_scope": "All-size opposite schedule, exact F_plus B_inverse endpoint, retained L layout, long/short axes, and the original contraction/truncation/asymptotic cost proof", + "proof_sha256": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5", + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "source_path": "upstream/build/sections/06-transforms.tex", + "source_sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "status": "PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW" +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/5-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/5-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/5-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/5-stdout.txt new file mode 100644 index 0000000000..6776e1724e --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/5-stdout.txt @@ -0,0 +1 @@ +{"coefficient_cases": 9455, "common_chunk_rounds": 3510, "exact_entries": 27988, "layout_cases": 455, "status": "PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW"} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/6-REVIEW.json b/research/publication-reviews/completed-prefix-outer/cold-replay/6-REVIEW.json new file mode 100644 index 0000000000..0af0c17bf3 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/6-REVIEW.json @@ -0,0 +1,50 @@ +{ + "actual_chunk_offset_cases": 1732, + "actual_odd_port_hypotheses_checked": 112, + "all_size_proof_review": "PASS; exact statement and hypotheses are in REVIEW.md", + "arithmetic": "Integer exponents in the exact polynomial ring; Gaussian rational two-term polynomials", + "axis_log_lengths": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "checker_sha256": "7aa72c10c019d4b225a4d0908df17335cffb9a16b7caac1d8543fe2acdecb52a", + "early_late_three_or_more_group_cases": 60, + "exact_forward_and_opposite_entries": 174760, + "git_pins": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "git_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "nonadjacent_rotation_cases": 360, + "nonmonomial_twiddle_unit_entries": 8, + "old_reverse_opposite_twiddle_control": 128, + "producer_imports": false, + "research_pins": { + "circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "schur-selection/PAST-CATALYST-v2.md": "566cfb7794202a2462a41da8abef69066c51a06ab7802c01f76b996e58e976e5", + "schur-selection/PAST-GAUGE-FUSION.md": "a84b77d2ef0d0747713063a7bd08e211b5a75eabbba6ff085a3967676fc12c6f", + "temporal-reuse/COMPLETED-PREFIX-CODES.json": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "temporal-reuse/COMPLETED-PREFIX-CODES.md": "c0050de40211bf06ddb386192795d7d2a4ebb0452aa61b1c8139b92f7041cdf5", + "temporal-reuse/PAST-CATALYST-LAYOUT.json": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "temporal-reuse/PAST-CATALYST-LAYOUT.md": "8f3ac9bc6133397ce98c88b0f6999c1eac9f6169d10fe21b2f0ab9d2275caee7", + "temporal-reuse/check_completed_prefix_codes.py": "0f290084228332cbcbfe1bf1b02d160f0e3c9a264968632ea0ae77e88ac19186", + "temporal-reuse/check_past_catalyst_layout.py": "412640c14d27ccfffa4eea24af9b321e13bc54b9a491766c8d96654536b577ef" + }, + "scope": "Outer exact opposite and completed-prefix composition; conditional address packing. No native supplier, cover redesign, growing-bank decoder bound, compact invoice, or recursive encoded-child closure.", + "selected_margins": { + "epsilon_minus_kappa": "1635654921950317604269246176697592893315360642164647696163717235784796569190497511406755693461406225762418838586331730835704915263244133189022659330234814818810892219059957239485707752007657731284696774507602551594083331891078337774583028045958975578287492520966716631023415709897216606029214103869146078792163164507055296177461882843051065083293106678283624262730067538295610766368389669754871598780028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000", + "groups": "2463090156099364793623722627424664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041/3282290156099364793623721808224664734599224105676919239087430234567083836826988376006387856482178928788981393147808286007792385920322253722201767929416477166653535959868879662007824712314966127806177730297423483901027506968664489033051447038531157336856996129340173164228163173132938540666878136418539696486021989985271231781781450073973851986744395930427624741098739356767652210341205493240883041000000000000000000000000", + "startup": "1081110357609925260614972695003107315707432353068338487603991699409949621702495690156909535160235873839601108223405260050123543294943053402137660198994397070489620108165140795187785639656314293544597085375410582291108751565224554246715990585636803213137497296463685876362653172078415927035174159499690912068352607880037991076665304643497436633279437216679436871538992416375313119280028939340626181/1641145078049682396811860904112332367299612052838459619543715117283541918413494188003193928241089464394490696573904143003896192960161126861100883964708238583326767979934439831003912356157483063903088865148711741950513753484332244516525723519265578668428498064670086582114081586566469270333439068209269848243010994992635615890890725036986925993372197965213812370549369678383826105170602746620441520500000000000000000" + }, + "status": "PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW" +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/6-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/6-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/6-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/6-stdout.txt new file mode 100644 index 0000000000..94759b209b --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/6-stdout.txt @@ -0,0 +1,2 @@ +PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW +Exact DIF phases, current twiddle, selected offsets, full guard and reserve restoration diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/7-TWIDDLE-PASS-PROOF-REVIEW.json b/research/publication-reviews/completed-prefix-outer/cold-replay/7-TWIDDLE-PASS-PROOF-REVIEW.json new file mode 100644 index 0000000000..653cf5018c --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/7-TWIDDLE-PASS-PROOF-REVIEW.json @@ -0,0 +1,46 @@ +{ + "checker_sha256": "5eccf649ddcc2619ac5f140810073b06ef83c0981f9b36fb20c2374b33f80126", + "independent_exact_checks": [ + "Two-point conjugation with independent Gaussian and polynomial roots", + "Unit products", + "Both Pauli phases", + "All odd native weights through7" + ], + "not_repeated": [ + "Upstream source and layout audit", + "The256-column finite example", + "The producer checker", + "Native or recursive decoder construction" + ], + "parity_signs": { + "1": [ + -1, + 1 + ], + "3": [ + 1, + -1 + ], + "5": [ + -1, + 1 + ], + "7": [ + 1, + -1 + ] + }, + "proof_pins": { + "ACCUMULATED-TWIDDLE-CODE.md": "406e3cae0f69be8dd5c737b56e4af25b9aeb59de65d04dcb5355c67b2b5b371c", + "TWIDDLE-PASS-COST.md": "796b04dfb5882c0b49f98b5d6fd73580bf73929ccb663c784e1d24ad60ca4b99" + }, + "proof_review": [ + "Separate full-stream pass depth", + "Ordered J E H0 placement", + "Invertible joint parity blocks", + "Complete-word support bound", + "One-native-tensor support consequence under scalar monomial wrappers" + ], + "scope": "Fixed complete-stream pass grammar and the stated stable-port endpoint. No general native decoder lower bound.", + "status": "PASS_SCOPED_TWIDDLE_PROOF_REVIEW" +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/7-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/7-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/7-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/7-stdout.txt new file mode 100644 index 0000000000..21aef9802c --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/7-stdout.txt @@ -0,0 +1 @@ +PASS_SCOPED_TWIDDLE_PROOF_REVIEW diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/8-FIXED-PAST-OUTER-CLOSURE.json b/research/publication-reviews/completed-prefix-outer/cold-replay/8-FIXED-PAST-OUTER-CLOSURE.json new file mode 100644 index 0000000000..ab0fb1d605 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/8-FIXED-PAST-OUTER-CLOSURE.json @@ -0,0 +1,212 @@ +{ + "assembly_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "decoded_round_error": "n 2^(number_of_past_bits/2) eta", + "h_powers": [ + [ + [ + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ], + [ + [ + [ + "1/2", + "1/2" + ], + [ + "1/2", + "1/2" + ] + ], + [ + [ + "1/2", + "1/2" + ], + [ + "-1/2", + "-1/2" + ] + ] + ], + [ + [ + [ + "0", + "1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "1" + ] + ] + ], + [ + [ + [ + "-1/2", + "1/2" + ], + [ + "-1/2", + "1/2" + ] + ], + [ + [ + "-1/2", + "1/2" + ], + [ + "1/2", + "-1/2" + ] + ] + ], + [ + [ + [ + "-1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ] + ] + ], + [ + [ + [ + "-1/2", + "-1/2" + ], + [ + "-1/2", + "-1/2" + ] + ], + [ + [ + "-1/2", + "-1/2" + ], + [ + "1/2", + "1/2" + ] + ] + ], + [ + [ + [ + "0", + "-1" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ] + ] + ], + [ + [ + [ + "1/2", + "-1/2" + ], + [ + "1/2", + "-1/2" + ] + ], + [ + [ + "1/2", + "-1/2" + ], + [ + "-1/2", + "1/2" + ] + ] + ], + [ + [ + [ + "1", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "1", + "0" + ] + ] + ] + ], + "native_supplier_hypothesis_verified": false, + "odd_power_row_norm": "2^(number_of_past_bits/2)", + "revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "scalar_identity": "S C S = (1+i) H0", + "scope": "Exact scalar normalization and selected outer inequalities; the closure proof is conditional.", + "status": "PASS_FIXED_PAST_OUTER_NORMALIZATION", + "tensor_period": 8, + "terminal_decoder_cost": "O(V d)" +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/8-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/8-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/8-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-replay/8-stdout.txt new file mode 100644 index 0000000000..ee0b74cc8b --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/8-stdout.txt @@ -0,0 +1 @@ +PASS_FIXED_PAST_OUTER_NORMALIZATION diff --git a/research/publication-reviews/completed-prefix-outer/cold-replay/REPLAY.json b/research/publication-reviews/completed-prefix-outer/cold-replay/REPLAY.json new file mode 100644 index 0000000000..a97e68493a --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-replay/REPLAY.json @@ -0,0 +1,95 @@ +{ + "checked_source_files": 47, + "checks": [ + { + "allowed_metadata_changes": [], + "checker": "portable/check_completed_prefix_codes.py", + "matches_frozen_mathematical_result": true, + "receipt": "1-COMPLETED-PREFIX-CODES.json", + "receipt_sha256": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "seconds": 0.717287, + "status": "PASS_COMPLETED_PREFIX_CODES" + }, + { + "allowed_metadata_changes": [], + "checker": "portable/check_past_catalyst_layout.py", + "matches_frozen_mathematical_result": true, + "receipt": "2-PAST-CATALYST-LAYOUT.json", + "receipt_sha256": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "seconds": 0.091126, + "status": "PASS_PAST_CATALYST_LAYOUT" + }, + { + "allowed_metadata_changes": [ + "checker_sha256" + ], + "checker": "portable/check_twiddle_pass_cost.py", + "matches_frozen_mathematical_result": true, + "receipt": "3-TWIDDLE-PASS-CHECKS.json", + "receipt_sha256": "dad8ca501fdedd1958482d446b398458bf91494ac189c870e6237caf50eea6f0", + "seconds": 0.118151, + "status": "PASS_EXACT_CURRENT_TWIDDLE_PASS_CONTROLS" + }, + { + "allowed_metadata_changes": [ + "checker_sha256" + ], + "checker": "portable/check_accumulated_twiddle_code.py", + "matches_frozen_mathematical_result": true, + "receipt": "4-ACCUMULATED-TWIDDLE-CODE.json", + "receipt_sha256": "eb46150d267d770c3cafba5d990a8341bebfedea532d1af82bcb843c6a099ff3", + "seconds": 1.041318, + "status": "PASS_EXACT_ACCUMULATED_TWIDDLE_CODE" + }, + { + "allowed_metadata_changes": [], + "checker": "portable/review_opposite_prefix.py", + "matches_frozen_mathematical_result": true, + "receipt": "5-OPPOSITE-PREFIX-REVIEW.json", + "receipt_sha256": "9b1d87077f32405f16989b73ae2b007497fbca815614b8e837fbc4c125a9784b", + "seconds": 0.257923, + "status": "PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW" + }, + { + "allowed_metadata_changes": [ + "checker_sha256" + ], + "checker": "portable/review_prefix.py", + "matches_frozen_mathematical_result": true, + "receipt": "6-REVIEW.json", + "receipt_sha256": "b4382e422a55e78f35bdc309c2cf679d317d32dd17bfc39e158cc97f8431c09d", + "seconds": 0.560587, + "status": "PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW" + }, + { + "allowed_metadata_changes": [ + "checker_sha256" + ], + "checker": "portable/review_twiddle_pass_proofs.py", + "matches_frozen_mathematical_result": true, + "receipt": "7-TWIDDLE-PASS-PROOF-REVIEW.json", + "receipt_sha256": "54eb4b7dd5dd9fad115ec7cf173fa596ed259d569377c23c12d2c205968d05da", + "seconds": 0.105238, + "status": "PASS_SCOPED_TWIDDLE_PROOF_REVIEW" + }, + { + "allowed_metadata_changes": [], + "checker": "portable/check_fixed_past_outer.py", + "matches_frozen_mathematical_result": true, + "receipt": "8-FIXED-PAST-OUTER-CLOSURE.json", + "receipt_sha256": "cb9145582e5bcf0771f331809ec96036cbd9d55f17986938c3abd31b603a2d5b", + "seconds": 0.086292, + "status": "PASS_FIXED_PAST_OUTER_NORMALIZATION" + } + ], + "complete_kappa_change": false, + "current_main_context": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51", + "current_selected_4470_compatibility_established": false, + "execution": "Sequential standard-library Python; no Git, network, or producer imports in review checkers", + "fixed_past_distinct_prior_review": false, + "fixed_past_supplier_verified": false, + "historical_revision": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "optimized": true, + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "status": "PASS_COMPLETED_PREFIX_OUTER_PACKAGE" +} diff --git a/research/publication-reviews/completed-prefix-outer/cold-stderr.txt b/research/publication-reviews/completed-prefix-outer/cold-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/publication-reviews/completed-prefix-outer/cold-stdout.txt b/research/publication-reviews/completed-prefix-outer/cold-stdout.txt new file mode 100644 index 0000000000..b3febed1f1 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/cold-stdout.txt @@ -0,0 +1,9 @@ +PASS_COMPLETED_PREFIX_CODES +PASS_PAST_CATALYST_LAYOUT +PASS_EXACT_CURRENT_TWIDDLE_PASS_CONTROLS +PASS_EXACT_ACCUMULATED_TWIDDLE_CODE +PASS_INDEPENDENT_REVERSED_LABEL_OPPOSITE_REVIEW +PASS_INDEPENDENT_COMPLETED_PREFIX_AND_PAST_LAYOUT_REVIEW +PASS_SCOPED_TWIDDLE_PROOF_REVIEW +PASS_FIXED_PAST_OUTER_NORMALIZATION +PASS_COMPLETED_PREFIX_OUTER_PACKAGE diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/INTEGRITY.json b/research/publication-reviews/completed-prefix-outer/spectator-review/INTEGRITY.json new file mode 100644 index 0000000000..aa17be7b70 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/INTEGRITY.json @@ -0,0 +1,90 @@ +{ + "PATH": "/nonexistent", + "aggregate_seconds": 3.637, + "all_source_checks_current": true, + "annex_bytes_including_manifest": 260971, + "annex_files_including_manifest": 32, + "annex_manifest_sha256": "427e4bebc440bde21e4da7d8b78d45e4208ef8dd309110bc387ce7c5c43baaea", + "cold_copy_identical_to_final_annex": true, + "cold_copy_unchanged_after_replay": true, + "cold_replay_command": "/opt/homebrew/bin/python3 -I -B /private/tmp/spectator-terminal-annex-independent-20261022/package/replay.py --out /private/tmp/spectator-terminal-annex-independent-20261022/replay", + "cold_replay_receipt_sha256": "f8107599a6d20d0815f6e379d122df9d8df43eff6a2a392d24bb758e7eb8534e", + "cwd": "/private/tmp", + "jobs": 4, + "local_links": [ + { + "document": "README.md", + "target": "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md" + }, + { + "document": "README.md", + "target": "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md" + }, + { + "document": "README.md", + "target": "frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json" + }, + { + "document": "README.md", + "target": "SOURCES.json" + }, + { + "document": "README.md", + "target": "sources/upstream/upstream/build/sections/05-layers.tex" + }, + { + "document": "README.md", + "target": "frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md" + }, + { + "document": "README.md", + "target": "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md" + }, + { + "document": "README.md", + "target": "NOTICE.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/upstream/README.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/upstream/LICENSE" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/NOTICE" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/research/gauge44-slots-t16/NOTICE.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md" + }, + { + "document": "NOTICE.md", + "target": "sources/upstream/LICENSE" + } + ], + "manifest_listed_files": 31, + "no_network_or_old_parent_suite": true, + "parent_freeze_sha256": "951ff644e69a705e7d51a4f6d2b7665cf426fd1abc48e79f51cffb60061f6749", + "platform": "macOS-26.6.1-arm64-arm-64bit-Mach-O", + "prior_accepted_review_changed": false, + "proofs_or_claims_changed": false, + "source_inputs": 24, + "status": "PASS_FINAL_SPECTATOR_ANNEX_AND_PRESERVATION", + "unchanged_parent_package_files": 83, + "unchanged_prior_review_files": 40 +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/PRE-REPLAY-HASHES.json b/research/publication-reviews/completed-prefix-outer/spectator-review/PRE-REPLAY-HASHES.json new file mode 100644 index 0000000000..2c219b6ff5 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/PRE-REPLAY-HASHES.json @@ -0,0 +1,34 @@ +{ + "ANNEX-MANIFEST.json": "427e4bebc440bde21e4da7d8b78d45e4208ef8dd309110bc387ce7c5c43baaea", + "BASE-PRESERVATION.json": "5e6289ef5fabac8fc1ebae3a0a16c6f24ad279c7b17f50ecdeb874b97e6fc920", + "NOTICE.md": "b3065aed5f40f7814cb764048348466642721a69eaf49e2664769cc8fd9e3a9c", + "README.md": "2bbd5fc1f864b917d8c0c54625cc726ee27afee3b3c513475bdd1cff422edddb", + "RESULT.json": "8a43d3490eeba71beeee6b7d41f60f365b2147e9f847ee854ed1c77e6f60f0c3", + "SOURCES.json": "501bedb96246adeea7bac12fdda5722867d64273bad431d809896468930eeb2e", + "frozen/lanes/circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json": "1b49ecef67df37b784eb14c7b98f28600818f65627105656eef67f95c150343b", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md": "bc7b4ceb58af5a55669c784ac3cb23ede1811e6e39179aff9b0e119fcf472cc7", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json": "e79603bee7c4077b3637f9b7891bac59719183e922a71d5994aaf9d405d5322f", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md": "1783100d3333c83828b47bb89f267db54b791f4c4fe952b5a62fbdb5087c902f", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md": "e972b41bcaf4597fd9f1cf4fdac6a6e093d862a67b57ee8aad58303687227441", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "frozen/lanes/coherent-port/check_spectator_terminal_product.py": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md": "dd94a6e2220306aa76da329886921f1efc0420e6064fe9d056bc4c2286e693b3", + "frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8", + "frozen/lanes/schur-selection/spectator/review_terminal_product.py": "f55eb2b8c0242b36f744232cbf0a4f922ad5248e59119f3fc99116a0ed7f8264", + "replay.py": "c0da160282cb87a874fd097d83d4c3d21780d7c082e62bf8c885869fc11ab679", + "sources/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/upstream/NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "sources/upstream/research/gauge44-slots-t16/NOTICE.md": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf", + "sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816", + "sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5", + "sources/upstream/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/upstream/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "sources/upstream/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "sources/upstream/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "validation/REPLAY.json": "585b4dec9132e6408f109fc82547d6801f828ee6786f5bd55fa89a5d0ef77756" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/PREEXISTING-REVIEW-HASHES.json b/research/publication-reviews/completed-prefix-outer/spectator-review/PREEXISTING-REVIEW-HASHES.json new file mode 100644 index 0000000000..f301fab24f --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/PREEXISTING-REVIEW-HASHES.json @@ -0,0 +1,42 @@ +{ + "FIXED-PAST-INDEPENDENT.json": "761235b37c5b4455eccad947fe2685e42e62070aad5fac5de9ba6577fcf4dfcc", + "HISTORICAL-WORD-CHECK.json": "5e9f829b55018578c92550daf30ea76c2544d86c79ba66cfbeb3742ab64fe072", + "INITIAL-REVIEW.json": "52993370c421e69ff4484207d4975db31235376b5ef666b2c5b762b24f22861b", + "INITIAL-REVIEW.md": "59332de12ef292fe356426bf465363717188317cc3027a7682b414788d10866c", + "INITIAL-REVIEWED-PACKAGE-HASHES.json": "a41196f9a3742e62cb3b4f437c580e918d29236d7f707e6f5a3647e77d0311b4", + "PR-DESCRIPTION-CHECK.json": "1e47a02fb686aa2d731530e34dc18a752e65a9b6fcc420e472bb9cec264c9471", + "README-DELTA-CHECK.json": "7783b56cc8b17d939073aeb68eecb404a6c8ead386175b6cc0f5435c7c654fc5", + "README-DELTA.patch": "e63b3f417f88fc39aff669ce9dd1c7710c4986530f5b2fb543fc2b006aa2fe3d", + "REVIEW.json": "233f73cb3ed8820dfb87710f97f2d96c4c82fce183f524065887f4c481cb9daf", + "REVIEW.md": "770042d5158debc71618aa2600ba877dffd43d8bf5fd56f475ca0938e13b7182", + "REVIEWED-PACKAGE-HASHES.json": "90726c82af8c88dd9c11582d69de64ba609463de873d612222759ae84a90ee12", + "SOURCE-AND-REPLAY-CHECKS.json": "cb0aef6c81e6a19e937026497a32d80cc22807d8be25196a66e473df0989d7ef", + "check_fixed_past_independent.py": "05710e937b1c21c0d316360d8cc46d7014804ccac2c2eadaefdca2a03575e9d9", + "cold-replay/1-COMPLETED-PREFIX-CODES.json": "56c880b4b6ad30e0658d650b6cd566d6e18e4a10e0cc9054ee395667a8ca0664", + "cold-replay/1-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/1-stdout.txt": "ecacc19d20ee86b290470c8e977ba542cb6658b9a5ac19d6f0a4d879ab3cc950", + "cold-replay/2-PAST-CATALYST-LAYOUT.json": "501edd6edcfc34c429a9b26cacf7c84a56291f876d729325ef03a47c368677e7", + "cold-replay/2-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/2-stdout.txt": "a547dfe00dc74afa6126ac68d429e4501113f46385ccf611a7c22dbd994403b0", + "cold-replay/3-TWIDDLE-PASS-CHECKS.json": "dad8ca501fdedd1958482d446b398458bf91494ac189c870e6237caf50eea6f0", + "cold-replay/3-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/3-stdout.txt": "44772a85d3a7f4b882ef35d89e396e894f0fe6a78087bed52d43b4e2594b21ab", + "cold-replay/4-ACCUMULATED-TWIDDLE-CODE.json": "eb46150d267d770c3cafba5d990a8341bebfedea532d1af82bcb843c6a099ff3", + "cold-replay/4-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/4-stdout.txt": "2e84596bd056a2c5826af91827f29350e8c3a957db2fa0b48606dad6d7cce914", + "cold-replay/5-OPPOSITE-PREFIX-REVIEW.json": "9b1d87077f32405f16989b73ae2b007497fbca815614b8e837fbc4c125a9784b", + "cold-replay/5-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/5-stdout.txt": "b183f2af086e5ec790550ffc25abe05582ba2a1d5482c5f3294168bc14db47c4", + "cold-replay/6-REVIEW.json": "b4382e422a55e78f35bdc309c2cf679d317d32dd17bfc39e158cc97f8431c09d", + "cold-replay/6-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/6-stdout.txt": "d5e616292b1879ff3f2e6954a4d9b8da854cec606ab1d56c43f3dcb103b5797a", + "cold-replay/7-TWIDDLE-PASS-PROOF-REVIEW.json": "54eb4b7dd5dd9fad115ec7cf173fa596ed259d569377c23c12d2c205968d05da", + "cold-replay/7-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/7-stdout.txt": "89c35ce3664ccfa401dc0a83a83f46e27325b694908570e54a0366d381e3ed1a", + "cold-replay/8-FIXED-PAST-OUTER-CLOSURE.json": "cb9145582e5bcf0771f331809ec96036cbd9d55f17986938c3abd31b603a2d5b", + "cold-replay/8-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-replay/8-stdout.txt": "4b1d8f4287c3491ac5539cf5e12b0eebd089d816c88b0946014fb1eb972ac10b", + "cold-replay/REPLAY.json": "07a7f9dab0041944a1d4f95b6847332f69fb3998ee824247a0b9b7afe384f7b6", + "cold-stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "cold-stdout.txt": "a2940d28fd322d2c0f0349958ff8560a8a2e3ede60d053c443f7a9b21790f630" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/PROOF-REVIEW.md b/research/publication-reviews/completed-prefix-outer/spectator-review/PROOF-REVIEW.md new file mode 100644 index 0000000000..8eea3dd66f --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/PROOF-REVIEW.md @@ -0,0 +1,128 @@ +# Spectator terminal proof review + +The conditional operator theorem and its phase addendum pass this proof +review. Execution and final package integrity are recorded separately. +This note adds no construction, search, or kappa claim. + +## Product and order + +The theorem uses one fixed spectator bit z with two arbitrary input +slices. Each Q_j acts on the active coordinates in the same way on both +slices. The Q_j commute, satisfy Q_j^2=X_(v_j), and have fourth power I. +The translations fix z. The theorem does not require the T_j to commute. + +With T_j=[[0,Q_j],[Q_j^-1,0]], direct multiplication gives alternating +exponents in the chronological product E=T_m ... T_1. For +epsilon_j=(-1)^(m-j), put U=prod Q_j^epsilon_j. Then +E=diag(U,U^-1) S^m. Since Q_j^-1=Q_j X_(v_j), the binary vector sums +V and V_minus give + +```text +E = Q_all X_(V_minus) D_V S^m = Q_all M, +E^-1 = S^m D_V X_(V_minus) Q_all^-1. +``` + +Every Q_j commutes with M: it commutes with the other Q factors and +their squares, and it acts equally on the two slices. The inverse +retains its displayed order. In an odd product, S and D_V need not +commute. Moving the slice flip across the controlled translation can +change the result by X_V. + +This argument applies to every finite positive number of factors and +all widths that satisfy the operator premises. Its justification is +the ordered matrix identity, not an extrapolation of finite cases. +No slice is initialized or discarded. + +## One native factor, conditional admission + +For the actual original line, C_q=alpha I+beta X_q. Directions from +disjoint coordinate supports are independent. The actual odd port +labels have unit binary norm. A binary gather can therefore identify +the D selected directions with D distinct coordinate bits, giving +Q_all=P^-1 C^tensor(D) P. The source identity +C^-1=-i Z C Z gives the inverse factor with two sign passes and the +Gaussian unit (-i)^D. + +This proves one C_D operator factor. It does not prove an admitted +all-size child on those coordinates. The complete-row, chunk, guard, +volume, depth, helper-restoration, and precision contracts remain +premises. The gather, inverse gather, signs, unit scale, affine map, +and native child all have costs. The note does not set chunk width to +one, discard inactive ranges, or prove that the total cost fits an +outer supplier bound. + +Port permutations can be followed only when they transport the line +operators and translation vectors covariantly and fix z. A scalar bank +map may cross the factors only for identical port types. This does +not permit the actual R or K to mix different types without proof. +An endpoint conjugation by a past transform must remain in the word. +A Fourier operation on z is not an affine address map. + +## Phase and twiddle addendum + +The separate addendum is required. For each layer j, S_j is a monomial +operator on that layer's active coordinates, with identity action on +z and on all other layers. Its coefficient cannot depend on z. +These premises imply S_k T_j=T_j S_k for k different from j and give + +```text +(S_m T_m S_m^-1) ... (S_1 T_1 S_1^-1) + = S_all E S_all^-1. +``` + +The inverse has ordered wrappers S_all M^-1 Q_all^-1 S_all^-1. +Each wrapper still has a cost. Fixing the address value of z is +insufficient: a z-dependent diagonal phase can fail to commute with +the slice flip. + +The exact retained layer source has H0=b S C S. Thus a native endpoint +E_j C_j becomes (S_j E_j S_j^-1) H0_j. The code is placed before the +current outer twiddle. That twiddle depends on both the current branch +and unprocessed bits, so it is not one of the disjoint-support S_j +operators. The existing current-twiddle limitation remains in force. + +An application must prove a complete-round portwise endpoint after +the twiddle, implement a valid encoded twiddle, or return the raw H0 +operation. The spectator product does not supply any of these. + +## Unchanged paired controller + +The retained controller proof has a mixed data/mode endpoint. An exact +isomorphism between two fields and two productive slices preserves +that endpoint. It cannot turn it into independent portwise T factors. + +The inherited witness uses the source schedule (1,1,0,...,0) on the +initial X0 bank and distinct involutive stage-one routes. Under those +facts, h=(56I-R_1^*R_1)R_0^*e_k delta_identity satisfies R_1h=0, while +the identity coefficient of R_0h is (56^2-224)e_k=2912e_k. A constant +active payload and the z-odd input (h,-h) give a nonzero first query +and zero later queries. Invertible mode-only maps cannot remove that +signal. This conditional proof transfers to the slice representation. + +The terminal checker verifies the scalar 2912 calculation and pins +the controller proof. It does not reconstruct the route witness or +rerun the source schedule. The separate controller proof review also +retains those producer dependencies. Their status must remain explicit. +No general controller obstruction or native-child lower bound follows. + +## Finite checks and their limits + +The actual-label checker uses exact Gaussian fractions for 112 ports, +one through six disjoint layers, and both slices. Its translation +covariance gives all active input columns from the origin kernels. +It checks 1344 slice cases and 28224 nonzero kernel entries. It rejects +672 omitted-control cases and 672 wrong odd-inverse-order cases. + +The independent checker uses formal commuting fourth-root generators. +It imports no producer kernel and checks 64 cases: lengths one through +32 and both initial slices. It separately checks the alternating +exponents, affine factor, inverse order, and odd-order failure control. +It is independent evidence for the ordered identity. It is not an +independent replay of native layout, the controller witness, or a +complete layer endpoint. + +The accepted claim is a conditional terminal factorization with a +necessary phase qualification. A complete portwise layer endpoint, +native admission, final physical layout, helper host, finite invoice, +and recursive precision remain separate obligations. No complete +supplier or kappa improvement is established. diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW-FILES.json b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW-FILES.json new file mode 100644 index 0000000000..f384cc349b --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW-FILES.json @@ -0,0 +1,19 @@ +{ + "INTEGRITY.json": "3c26483cb15761d2d3808bcb227df74af0e841e476e13ae1290f7d54cfa53b0d", + "PRE-REPLAY-HASHES.json": "5db646a5117eb2762ed44457880601be4c6617931e8b887b613b658d65a020d6", + "PREEXISTING-REVIEW-HASHES.json": "5bc00103afa37f1549c7236b0872e0484406c01dd8120abf098a84793c031e3a", + "PROOF-REVIEW.md": "0d7631b6e89c2fe3c8b7e76f143a341bec042d2cbc0698988bf8ca3c276316e8", + "REVIEW.json": "77e7abb74f9fe2318e9e368afbc1f9fd9e682834d904a847ca8d4454a5b9817d", + "REVIEW.md": "d2cbacc7ac816ea86d9547c735e4b67f815233c3dac636ec9d3938de79c5d42a", + "REVIEWED-ANNEX-MANIFEST.json": "427e4bebc440bde21e4da7d8b78d45e4208ef8dd309110bc387ce7c5c43baaea", + "SOURCE-CHECKS.json": "c876a09cb476efa45ba6385bec6cbaf2af431c5872dec3145166168f0de71de8", + "cold-replay/REPLAY.json": "f8107599a6d20d0815f6e379d122df9d8df43eff6a2a392d24bb758e7eb8534e", + "cold-replay/normal/kernel/SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "cold-replay/normal/kernel/stdout.txt": "04a06970df7586575f00caaa13f9851b3da424f8d41d24f0403833c41d5081c8", + "cold-replay/normal/order/TERMINAL-PRODUCT-REVIEW.json": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8", + "cold-replay/normal/order/stdout.txt": "0a97d50013cacd8131fc11d2de871c176da03930e13f69eb46686a0519b2a427", + "cold-replay/optimized/kernel/SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "cold-replay/optimized/kernel/stdout.txt": "04a06970df7586575f00caaa13f9851b3da424f8d41d24f0403833c41d5081c8", + "cold-replay/optimized/order/TERMINAL-PRODUCT-REVIEW.json": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8", + "cold-replay/optimized/order/stdout.txt": "0a97d50013cacd8131fc11d2de871c176da03930e13f69eb46686a0519b2a427" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.json b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.json new file mode 100644 index 0000000000..32f63092c7 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.json @@ -0,0 +1,82 @@ +{ + "accepted_claims": [ + "Ordered spectator terminal factorization for every positive layer count under the full active-operator and arbitrary-slice premises.", + "One gathered C_D operator factor for disjoint native directions, with all child admission and execution costs still due.", + "Layer phase conjugation under disjoint active support and identity action on z; the current twiddle does not meet this condition.", + "The slice isomorphism preserves the mixed content endpoint of the unchanged paired controller." + ], + "actions": { + "commit": false, + "frontier_change": false, + "merge": false, + "new_research": false, + "package_edits_by_reviewer": false, + "pr": false, + "push": false + }, + "annex_bytes_including_manifest": 260971, + "annex_files_including_manifest": 32, + "annex_manifest_sha256": "427e4bebc440bde21e4da7d8b78d45e4208ef8dd309110bc387ce7c5c43baaea", + "archival_link_limitations": [ + "The unchanged upstream README links to paper.pdf, which is absent in this annex and its accepted parent copy. Exact manuscript sections are retained; no annex proof or checker consumes that PDF. The 16-link check covers new README/NOTICE links only." + ], + "clarifications_before_cold_freeze": [ + "The new README explicitly states that Q_j acts on the active coordinates identically on both spectator slices." + ], + "cold_replay": { + "PATH": "/nonexistent", + "aggregate_seconds": 3.637, + "all_receipts_byte_equal": true, + "all_sources_unchanged": true, + "command": "/opt/homebrew/bin/python3 -I -B /private/tmp/spectator-terminal-annex-independent-20261022/package/replay.py --out /private/tmp/spectator-terminal-annex-independent-20261022/replay", + "cwd": "/private/tmp", + "exact_copy_matches_final_annex": true, + "fresh_receipts_created": true, + "independent_formal_cases": 64, + "jobs": 4, + "kernel_nonzero_entries": 28224, + "kernel_slice_cases": 1344, + "normal_optimized_equal": true, + "omitted_control_rejections": 672, + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "status": "PASS_SPECTATOR_TERMINAL_ANNEX", + "wrong_inverse_order_rejections": 672 + }, + "cold_replay_sha256": "f8107599a6d20d0815f6e379d122df9d8df43eff6a2a392d24bb758e7eb8534e", + "inherited_not_replayed": [ + "Controller source schedule and route-distinctness reconstruction for the 2912 witness.", + "Original paired native contract and full native phase replay.", + "The previously accepted parent-package suite." + ], + "integrity_sha256": "3c26483cb15761d2d3808bcb227df74af0e841e476e13ae1290f7d54cfa53b0d", + "not_established": [ + "A complete-round portwise layer endpoint after the twiddle.", + "An exact typed encoded twiddle or a new raw H0 supplier.", + "All-size gather, complete-row, chunk, guard, volume, depth, child restoration, or precision admission.", + "A complete helper host, finite or recursive invoice, integer recovery, or complete supplier.", + "A kappa improvement or transfer to the current selected construction.", + "Publication, rendered PR checks, independent human review, or formal-kernel verification." + ], + "package": "completed-prefix-outer/annexes/spectator-terminal", + "preservation": { + "existing_acceptance_changed": false, + "parent_freeze_sha256": "951ff644e69a705e7d51a4f6d2b7665cf426fd1abc48e79f51cffb60061f6749", + "parent_package_files_unchanged": 83, + "preexisting_review_files_unchanged": 40 + }, + "proof_review_sha256": "0d7631b6e89c2fe3c8b7e76f143a341bec042d2cbc0698988bf8ca3c276316e8", + "review_date": "2026-10-22", + "review_md_sha256": "d2cbacc7ac816ea86d9547c735e4b67f815233c3dac636ec9d3938de79c5d42a", + "reviewer": "Independent OpenAI Codex agent /root/tagged_reset_package", + "source_checks_sha256": "c876a09cb476efa45ba6385bec6cbaf2af431c5872dec3145166168f0de71de8", + "source_inputs": 24, + "source_verification": { + "addendum_layer_source_git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "campaign_files": 13, + "exact_historical_git_files": 11, + "frozen_source_or_checker_edits": false, + "new_local_links_checked": 16 + }, + "status": "ACCEPT_CONDITIONAL_SPECTATOR_TERMINAL_ANNEX", + "unresolved_material_findings": [] +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.md b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.md new file mode 100644 index 0000000000..4a1a27d690 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEW.md @@ -0,0 +1,113 @@ +# Independent spectator annex review + +Accepted for the conditional terminal operator theorem and its required +phase qualification. No material finding remains. This review does not +establish a complete portwise layer, native admission, or a kappa gain. +It is separate from the previously accepted completed-prefix review. + +The annex is `completed-prefix-outer/annexes/spectator-terminal`. Its +`ANNEX-MANIFEST.json` has SHA256 +`427e4bebc440bde21e4da7d8b78d45e4208ef8dd309110bc387ce7c5c43baaea`. +It lists 31 files; the manifest makes 32 files and 260971 bytes in total. +The [saved manifest](REVIEWED-ANNEX-MANIFEST.json), +[source check](SOURCE-CHECKS.json), and [integrity record](INTEGRITY.json) +bind this verdict to the exact annex. + +## Proof scope + +The [proof review](PROOF-REVIEW.md) checks the full terminal argument, +the phase and current-twiddle addendum, the two exact checkers, and the +retained controller and local native proof dependencies. + +For arbitrary data in both slices of one fixed spectator bit, commuting +active operators Q_j with square translations and fourth power I give +the ordered factorization E=Q_all M. The T_j need not commute. The +inverse retains M^-1 Q_all^-1 in that order. The written matrix proof +applies to every positive layer count and all stated tensor widths. + +With disjoint native line directions, one gather reduces Q_all to a +single C_D tensor. Its inverse retains the exact phase (-i)^D and both +sign passes. This is an operator factorization. It does not admit a +child on arbitrary gathered coordinates or discharge its row, chunk, +guard, volume, depth, restoration, and precision contracts. All maps +and the child retain their execution costs. + +The phase addendum is mandatory. Each layer conjugation must act on +its own active coordinates and as identity on the spectator bit and +all other layers. A coefficient that depends on the spectator bit can +break the commutation even when the address value is fixed. The actual +H0=b S C S conversion places the code before the current twiddle. +That twiddle does not have the required disjoint support. A complete +round endpoint, an exact typed encoded twiddle, or a raw H0 layer is +still needed. + +The unchanged paired controller has a mixed data/mode endpoint. An +isomorphism to productive slices preserves that content map. The 2912 +witness against mode-only restoration remains an inherited conditional +argument. The exact source schedule, route distinctness, raw native +contract, and their old replays were not re-established here. The new +annex correctly keeps this boundary explicit. + +## Fresh replay + +The final annex was copied to an unrelated directory. From +`/private/tmp`, with `PATH=/nonexistent`, the command was: + +```sh +/opt/homebrew/bin/python3 -I -B /private/tmp/spectator-terminal-annex-independent-20261022/package/replay.py --out /private/tmp/spectator-terminal-annex-independent-20261022/replay +``` + +It returned `PASS_SPECTATOR_TERMINAL_ANNEX`. Both unchanged checkers +passed in normal and optimized Python: four sequential runs, with +3.637 seconds of accumulated checker time. The runtime was Python +3.14.7 on macOS 26.6.1 arm64, using only the standard library. More +than 3 GiB of disk remained free. The [replay receipt](cold-replay/REPLAY.json) +and its nested receipts and logs are retained. + +Each run used a private source copy with its expected output removed +before execution. Every newly produced receipt equals its frozen +receipt byte for byte, and both Python modes agree. The actual-label +checker covers 112 labels, 1344 slice cases, and 28224 nonzero kernel +entries. Its 672 omitted-control and 672 wrong-order controls reject. +The independent formal checker covers 64 cases at product lengths +one through 32. It uses no producer kernel code. + +These checks support exact order and conventions. The all-width +conclusion rests on the written proof. No controller, route, complete +native phase, or accepted parent-package suite was rerun. + +## Source and preservation checks + +All 24 source inputs match their originals: 13 campaign files and 11 +historical Git objects. The latter also match the accepted parent +copies. The layer source at historical commits bce54fb3 and 3ae9a6f3 +is byte-identical, with Git blob +`5ce8b3c83c455f221bb84858a97230b0285644aa` and SHA256 +`20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594`. +The source, license, and notice files remain unchanged. All 16 local +links in the annex README and NOTICE resolve. +The retained upstream README links to an unbundled `paper.pdf`, as +does the accepted parent copy. The exact source sections are present; +no proof or checker in this annex consumes that PDF. Frozen source +text was preserved. The link check is not a claim that every archival +source-internal link resolves. + +All 32 annex files match the final manifest and the cold copy before +and after execution. All 83 pre-existing parent-package files retain +their hashes. The parent freeze remains +`951ff644e69a705e7d51a4f6d2b7665cf426fd1abc48e79f51cffb60061f6749`. +All 40 pre-existing review files also retain their hashes; their +[baseline](PREEXISTING-REVIEW-HASHES.json) is saved. This review does not +replace or broaden the earlier acceptance. + +The README now states explicitly that each Q_j acts identically on +both spectator slices. This clarification was included in the exact +cold copy. No mathematical repair or source-code adaptation was needed. + +No material dependency gap remains within the conditional claim. +A complete supplier, full finite and recursive invoice, helper host, +precision bound, integer recovery, and current selected-construction +application remain unproved here. Publication and rendered PR checks +belong to the coordinator. No commit, push, PR, merge, or frontier +change was made. OpenAI Codex supplied this separate agent review; +it is not independent human review or formal verification. diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEWED-ANNEX-MANIFEST.json b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEWED-ANNEX-MANIFEST.json new file mode 100644 index 0000000000..3cf7afabfe --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/REVIEWED-ANNEX-MANIFEST.json @@ -0,0 +1,37 @@ +{ + "schema": "spectator-terminal-annex-manifest-v1", + "source_commit_context": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "files": { + "SOURCES.json": "501bedb96246adeea7bac12fdda5722867d64273bad431d809896468930eeb2e", + "RESULT.json": "8a43d3490eeba71beeee6b7d41f60f365b2147e9f847ee854ed1c77e6f60f0c3", + "BASE-PRESERVATION.json": "5e6289ef5fabac8fc1ebae3a0a16c6f24ad279c7b17f50ecdeb874b97e6fc920", + "README.md": "2bbd5fc1f864b917d8c0c54625cc726ee27afee3b3c513475bdd1cff422edddb", + "replay.py": "c0da160282cb87a874fd097d83d4c3d21780d7c082e62bf8c885869fc11ab679", + "NOTICE.md": "b3065aed5f40f7814cb764048348466642721a69eaf49e2664769cc8fd9e3a9c", + "validation/REPLAY.json": "585b4dec9132e6408f109fc82547d6801f828ee6786f5bd55fa89a5d0ef77756", + "frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json": "e79603bee7c4077b3637f9b7891bac59719183e922a71d5994aaf9d405d5322f", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md": "1783100d3333c83828b47bb89f267db54b791f4c4fe952b5a62fbdb5087c902f", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json": "1b49ecef67df37b784eb14c7b98f28600818f65627105656eef67f95c150343b", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md": "e972b41bcaf4597fd9f1cf4fdac6a6e093d862a67b57ee8aad58303687227441", + "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md": "bc7b4ceb58af5a55669c784ac3cb23ede1811e6e39179aff9b0e119fcf472cc7", + "frozen/lanes/coherent-port/check_spectator_terminal_product.py": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "frozen/lanes/circuit-interface/INTERFACE.json": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md": "dd94a6e2220306aa76da329886921f1efc0420e6064fe9d056bc4c2286e693b3", + "frozen/lanes/schur-selection/spectator/review_terminal_product.py": "f55eb2b8c0242b36f744232cbf0a4f922ad5248e59119f3fc99116a0ed7f8264", + "frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8", + "sources/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/upstream/NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "sources/upstream/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "sources/upstream/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "sources/upstream/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "sources/upstream/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "sources/upstream/research/gauge44-slots-t16/NOTICE.md": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf", + "sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5", + "sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816" + } +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/SOURCE-CHECKS.json b/research/publication-reviews/completed-prefix-outer/spectator-review/SOURCE-CHECKS.json new file mode 100644 index 0000000000..ddb391a570 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/SOURCE-CHECKS.json @@ -0,0 +1,183 @@ +{ + "files": [ + { + "bytes": 6185, + "path": "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md", + "sha256": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 943, + "path": "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json", + "sha256": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/SPECTATOR-TERMINAL-PRODUCT.json", + "source_type": "exact_campaign_file" + }, + { + "bytes": 5726, + "path": "frozen/lanes/coherent-port/check_spectator_terminal_product.py", + "sha256": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/check_spectator_terminal_product.py", + "source_type": "exact_campaign_file" + }, + { + "bytes": 2071, + "path": "frozen/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md", + "sha256": "e972b41bcaf4597fd9f1cf4fdac6a6e093d862a67b57ee8aad58303687227441", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/SPECTATOR-TERMINAL-CONJUGATION.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 2609, + "path": "frozen/lanes/schur-selection/spectator/review_terminal_product.py", + "sha256": "f55eb2b8c0242b36f744232cbf0a4f922ad5248e59119f3fc99116a0ed7f8264", + "source_path": "work/centre-encoding-campaign-20261014/lanes/schur-selection/spectator/review_terminal_product.py", + "source_type": "exact_campaign_file" + }, + { + "bytes": 866, + "path": "frozen/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json", + "sha256": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8", + "source_path": "work/centre-encoding-campaign-20261014/lanes/schur-selection/spectator/TERMINAL-PRODUCT-REVIEW.json", + "source_type": "exact_campaign_file" + }, + { + "bytes": 23232, + "path": "frozen/lanes/circuit-interface/INTERFACE.json", + "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "source_path": "work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json", + "source_type": "exact_campaign_file" + }, + { + "bytes": 7399, + "path": "frozen/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md", + "sha256": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "source_path": "work/centre-encoding-campaign-20261014/lanes/encoded-controller/ORIGINAL-PAIRED-CONTROLLER.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 3807, + "path": "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md", + "sha256": "bc7b4ceb58af5a55669c784ac3cb23ede1811e6e39179aff9b0e119fcf472cc7", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 1619, + "path": "frozen/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json", + "sha256": "1b49ecef67df37b784eb14c7b98f28600818f65627105656eef67f95c150343b", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/ORIGINAL-PAIRED-CONTROLLER-PROOF-REVIEW.json", + "source_type": "exact_campaign_file" + }, + { + "bytes": 7579, + "path": "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md", + "sha256": "1783100d3333c83828b47bb89f267db54b791f4c4fe952b5a62fbdb5087c902f", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 1701, + "path": "frozen/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json", + "sha256": "e79603bee7c4077b3637f9b7891bac59719183e922a71d5994aaf9d405d5322f", + "source_path": "work/centre-encoding-campaign-20261014/lanes/coherent-port/ORIGINAL-PAIRED-GAP-NATIVE-REVIEW.json", + "source_type": "exact_campaign_file" + }, + { + "bytes": 7037, + "path": "frozen/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md", + "sha256": "dd94a6e2220306aa76da329886921f1efc0420e6064fe9d056bc4c2286e693b3", + "source_path": "work/centre-encoding-campaign-20261014/lanes/residual-syndrome/physical-algebra/ORIGINAL-PAIRED-GAP.md", + "source_type": "exact_campaign_file" + }, + { + "bytes": 46811, + "path": "sources/upstream/upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "source_path": "upstream/build/sections/05-layers.tex", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 33854, + "path": "sources/upstream/upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "source_path": "upstream/build/sections/06-transforms.tex", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 11357, + "path": "sources/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "source_path": "LICENSE", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 24973, + "path": "sources/upstream/NOTICE", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "source_path": "NOTICE", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 11357, + "path": "sources/upstream/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "source_path": "upstream/LICENSE", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 541, + "path": "sources/upstream/upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "source_path": "upstream/README.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 1964, + "path": "sources/upstream/research/gauge44-slots-t16/NOTICE.md", + "sha256": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf", + "source_path": "research/gauge44-slots-t16/NOTICE.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 6406, + "path": "sources/upstream/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "source_path": "research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 950, + "path": "sources/upstream/research/gauge44-slots-t16/construction/NOTICE.md", + "sha256": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816", + "source_path": "research/gauge44-slots-t16/construction/NOTICE.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 6406, + "path": "sources/upstream/research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md", + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "source_path": "research/gauge44-slots-t16/construction/UPSTREAM-NOTICE.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + }, + { + "bytes": 2245, + "path": "sources/upstream/research/gauge44-slots-t16/t16/NOTICE.md", + "sha256": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5", + "source_path": "research/gauge44-slots-t16/t16/NOTICE.md", + "source_type": "exact_git_object_and_accepted_parent_copy" + } + ], + "layer_source_identity": { + "bytes": 46811, + "evidence": "The independent annex reviewer read the exact bce54 Git object. It equals the accepted parent package source at 3ae9a6f3ac74ded022ab3b4872a7357a621af6fb and the current local source byte for byte.", + "git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "path": "sources/upstream/upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f" + }, + "scope": "Exact source bytes only. No old controller, route, native, or parent-package suite was rerun.", + "source_manifest_sha256": "501bedb96246adeea7bac12fdda5722867d64273bad431d809896468930eeb2e", + "status": "PASS_SPECTATOR_SOURCE_CLOSURE" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/REPLAY.json b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/REPLAY.json new file mode 100644 index 0000000000..1834ba2679 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/REPLAY.json @@ -0,0 +1,48 @@ +{ + "status": "PASS_SPECTATOR_TERMINAL_ANNEX", + "source_files": 24, + "source_manifest_sha256": "501bedb96246adeea7bac12fdda5722867d64273bad431d809896468930eeb2e", + "runner_sha256": "c0da160282cb87a874fd097d83d4c3d21780d7c082e62bf8c885869fc11ab679", + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "jobs": [ + { + "id": "kernel", + "mode": "normal", + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "seconds": 1.697, + "fresh_receipt_created": true, + "frozen_receipt_byte_equal": true, + "receipt_sha256": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900" + }, + { + "id": "order", + "mode": "normal", + "status": "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER", + "seconds": 0.043, + "fresh_receipt_created": true, + "frozen_receipt_byte_equal": true, + "receipt_sha256": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8" + }, + { + "id": "kernel", + "mode": "optimized", + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "seconds": 1.829, + "fresh_receipt_created": true, + "frozen_receipt_byte_equal": true, + "receipt_sha256": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900" + }, + { + "id": "order", + "mode": "optimized", + "status": "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER", + "seconds": 0.068, + "fresh_receipt_created": true, + "frozen_receipt_byte_equal": true, + "receipt_sha256": "70898079acdaa070adebad6eef835056c39ffdf2fecc061d1437fe7c2dbe82a8" + } + ], + "normal_optimized_equal": true, + "frozen_sources_unchanged": true, + "scope": "Exact terminal kernels and independent formal product order. Complete portwise layer endpoints, native gather admission, the controller witness, full costs, precision, and recursive admission are not established by this replay." +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/SPECTATOR-TERMINAL-PRODUCT.json b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/SPECTATOR-TERMINAL-PRODUCT.json new file mode 100644 index 0000000000..145c2ad3af --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/SPECTATOR-TERMINAL-PRODUCT.json @@ -0,0 +1,22 @@ +{ + "actual_ports": 112, + "checker_sha256": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "controller_proof_sha256": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "inherited_controller_witness_coefficient": 2912, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "layer_counts": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "nonzero_kernel_entries_checked": 28224, + "omitted_control_rejections": 672, + "proof_sha256": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "scope": "Exact terminal operator product and controls. The inherited controller witness is proof-bound, not replayed here. Whole-layer content, native layout, cost, owner admission and full supplier improvement remain open.", + "spectator_columns_checked": 1344, + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "wrong_odd_inverse_order_rejections": 672 +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/stdout.txt b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/stdout.txt new file mode 100644 index 0000000000..c4b84e2257 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/kernel/stdout.txt @@ -0,0 +1,2 @@ +PASS_SPECTATOR_TERMINAL_PRODUCT +{"columns": 1344, "kernel entries": 28224} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/TERMINAL-PRODUCT-REVIEW.json b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/TERMINAL-PRODUCT-REVIEW.json new file mode 100644 index 0000000000..aa1d2a0356 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/TERMINAL-PRODUCT-REVIEW.json @@ -0,0 +1,12 @@ +{ + "free_group_cases": 64, + "input_sha256": { + "SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "SPECTATOR-TERMINAL-PRODUCT.md": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "check_spectator_terminal_product.py": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0" + }, + "new_corollary_condition": "A layer conjugation must act as identity on z, or explicitly commute with other T factors. Fixing the z address alone is not enough.", + "review": "The general alternating-exponent proof was checked directly. Finite checks use independent formal fourth-root generators, not the producer kernel code.", + "scope": "Equations (1)-(4) and their ordering; no native admission or full-layer endpoint review.", + "status": "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/stdout.txt b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/stdout.txt new file mode 100644 index 0000000000..e6ea524ba1 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/normal/order/stdout.txt @@ -0,0 +1 @@ +PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/SPECTATOR-TERMINAL-PRODUCT.json b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/SPECTATOR-TERMINAL-PRODUCT.json new file mode 100644 index 0000000000..145c2ad3af --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/SPECTATOR-TERMINAL-PRODUCT.json @@ -0,0 +1,22 @@ +{ + "actual_ports": 112, + "checker_sha256": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0", + "controller_proof_sha256": "412f71ddff2294e1013033220d9eab809d37c14f1cbced36727e175c72f0d0a1", + "inherited_controller_witness_coefficient": 2912, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "layer_counts": [ + 1, + 2, + 3, + 4, + 5, + 6 + ], + "nonzero_kernel_entries_checked": 28224, + "omitted_control_rejections": 672, + "proof_sha256": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "scope": "Exact terminal operator product and controls. The inherited controller witness is proof-bound, not replayed here. Whole-layer content, native layout, cost, owner admission and full supplier improvement remain open.", + "spectator_columns_checked": 1344, + "status": "PASS_SPECTATOR_TERMINAL_PRODUCT", + "wrong_odd_inverse_order_rejections": 672 +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/stdout.txt b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/stdout.txt new file mode 100644 index 0000000000..c4b84e2257 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/kernel/stdout.txt @@ -0,0 +1,2 @@ +PASS_SPECTATOR_TERMINAL_PRODUCT +{"columns": 1344, "kernel entries": 28224} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/TERMINAL-PRODUCT-REVIEW.json b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/TERMINAL-PRODUCT-REVIEW.json new file mode 100644 index 0000000000..aa1d2a0356 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/TERMINAL-PRODUCT-REVIEW.json @@ -0,0 +1,12 @@ +{ + "free_group_cases": 64, + "input_sha256": { + "SPECTATOR-TERMINAL-PRODUCT.json": "3eda58b1b4b3e86e7dd739c1bceeedf75cc0e176f49f54e0078bcd53de09c900", + "SPECTATOR-TERMINAL-PRODUCT.md": "588446b16cfcda173ce78092d6ef53ecec41ba5de54f7fae5191e836c326fb54", + "check_spectator_terminal_product.py": "43191fd9133470757d097f3374672173cd52b6627e1dd47d690780c6030e40b0" + }, + "new_corollary_condition": "A layer conjugation must act as identity on z, or explicitly commute with other T factors. Fixing the z address alone is not enough.", + "review": "The general alternating-exponent proof was checked directly. Finite checks use independent formal fourth-root generators, not the producer kernel code.", + "scope": "Equations (1)-(4) and their ordering; no native admission or full-layer endpoint review.", + "status": "PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER" +} diff --git a/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/stdout.txt b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/stdout.txt new file mode 100644 index 0000000000..e6ea524ba1 --- /dev/null +++ b/research/publication-reviews/completed-prefix-outer/spectator-review/cold-replay/optimized/order/stdout.txt @@ -0,0 +1 @@ +PASS_INDEPENDENT_TERMINAL_PRODUCT_ORDER