From 4bfdb52e72c701f27966041f66a35ec8278929ed Mon Sep 17 00:00:00 2001 From: ross Date: Wed, 21 Oct 2026 09:50:29 +1100 Subject: [PATCH] Prove scalar cubic caller query and pure-layer bounds --- .../CORE-SNAPSHOT.json | 112 ++ .../FROZEN-SHA256.json | 26 + research/cubic-scalar-caller-bounds/LICENSE | 201 ++++ .../cubic-scalar-caller-bounds/ORIGINS.json | 107 ++ research/cubic-scalar-caller-bounds/README.md | 103 ++ .../SOURCE-AUDIT.md | 55 + .../cubic-scalar-caller-bounds/SOURCES.json | 50 + research/cubic-scalar-caller-bounds/TASK.json | 96 ++ .../cubic-scalar-caller-bounds/VERIFY.json | 47 + .../cubic-scalar-caller-bounds/controls.py | 474 +++++++++ .../cubic/CHECKS.json.gz | Bin 0 -> 9882 bytes .../cubic/ORIGINS.json | 50 + .../cubic/OUTPUT-INVENTORY.json | 67 ++ .../cubic/PACKAGE-FILES.json | 19 + .../cubic-scalar-caller-bounds/cubic/PROOF.md | 413 ++++++++ .../cubic/VALIDATION.json | 46 + .../cubic-scalar-caller-bounds/cubic/check.py | 235 +++++ .../cubic/frozen/CUBIC-FOUR-CALL-GATE.json | 986 ++++++++++++++++++ .../cubic/frozen/INDEPENDENT-REVIEW.md | 37 + .../cubic/frozen/README.md | 302 ++++++ .../cubic/frozen/WIDE-MIXED-CUBIC-GATES.json | 396 +++++++ .../cubic/frozen/cubic_gate.py | 179 ++++ .../cubic/frozen/wide_gate.py | 212 ++++ .../independent/CHECKS.json.gz | Bin 0 -> 3156 bytes .../independent/PROOF-INDEPENDENT.md | 43 + .../independent/check.py | 199 ++++ .../reviews/CONTROL-VALIDATION.json | 23 + .../reviews/CONTROLS.json | 621 +++++++++++ .../reviews/CROSS-REVIEW-CUBIC.md | 96 ++ .../reviews/CROSS-REVIEW-INVENTORY.json | 20 + .../reviews/GIT-SOURCE-CHECKS.json | 50 + .../reviews/REVIEW.md | 39 + .../reviews/SNAPSHOT-REVIEW.json | 69 ++ .../reviews/SOURCE-CLOSURE.json | 366 +++++++ research/cubic-scalar-caller-bounds/verify.py | 160 +++ 35 files changed, 5899 insertions(+) create mode 100644 research/cubic-scalar-caller-bounds/CORE-SNAPSHOT.json create mode 100644 research/cubic-scalar-caller-bounds/FROZEN-SHA256.json create mode 100644 research/cubic-scalar-caller-bounds/LICENSE create mode 100644 research/cubic-scalar-caller-bounds/ORIGINS.json create mode 100644 research/cubic-scalar-caller-bounds/README.md create mode 100644 research/cubic-scalar-caller-bounds/SOURCE-AUDIT.md create mode 100644 research/cubic-scalar-caller-bounds/SOURCES.json create mode 100644 research/cubic-scalar-caller-bounds/TASK.json create mode 100644 research/cubic-scalar-caller-bounds/VERIFY.json create mode 100644 research/cubic-scalar-caller-bounds/controls.py create mode 100644 research/cubic-scalar-caller-bounds/cubic/CHECKS.json.gz create mode 100644 research/cubic-scalar-caller-bounds/cubic/ORIGINS.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/OUTPUT-INVENTORY.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/PACKAGE-FILES.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/PROOF.md create mode 100644 research/cubic-scalar-caller-bounds/cubic/VALIDATION.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/check.py create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/CUBIC-FOUR-CALL-GATE.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/INDEPENDENT-REVIEW.md create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/README.md create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/WIDE-MIXED-CUBIC-GATES.json create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/cubic_gate.py create mode 100644 research/cubic-scalar-caller-bounds/cubic/frozen/wide_gate.py create mode 100644 research/cubic-scalar-caller-bounds/independent/CHECKS.json.gz create mode 100644 research/cubic-scalar-caller-bounds/independent/PROOF-INDEPENDENT.md create mode 100644 research/cubic-scalar-caller-bounds/independent/check.py create mode 100644 research/cubic-scalar-caller-bounds/reviews/CONTROL-VALIDATION.json create mode 100644 research/cubic-scalar-caller-bounds/reviews/CONTROLS.json create mode 100644 research/cubic-scalar-caller-bounds/reviews/CROSS-REVIEW-CUBIC.md create mode 100644 research/cubic-scalar-caller-bounds/reviews/CROSS-REVIEW-INVENTORY.json create mode 100644 research/cubic-scalar-caller-bounds/reviews/GIT-SOURCE-CHECKS.json create mode 100644 research/cubic-scalar-caller-bounds/reviews/REVIEW.md create mode 100644 research/cubic-scalar-caller-bounds/reviews/SNAPSHOT-REVIEW.json create mode 100644 research/cubic-scalar-caller-bounds/reviews/SOURCE-CLOSURE.json create mode 100644 research/cubic-scalar-caller-bounds/verify.py diff --git a/research/cubic-scalar-caller-bounds/CORE-SNAPSHOT.json b/research/cubic-scalar-caller-bounds/CORE-SNAPSHOT.json new file mode 100644 index 0000000000..c45a5fa6b9 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/CORE-SNAPSHOT.json @@ -0,0 +1,112 @@ +{ + "created_utc": "2026-10-20T22:49:01.350815+00:00", + "files": { + "FROZEN-SHA256.json": { + "bytes": 2263, + "sha256": "f600e53d5e26cb292fb67add38e1e0d469d10f44cec934c87a76f27691ee4e11" + }, + "LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "ORIGINS.json": { + "bytes": 7297, + "sha256": "d6014bb28325fa9350fc8a1da43e6b44f602e6b0140842cd84949f56d18a5d95" + }, + "README.md": { + "bytes": 5311, + "sha256": "0cbaa565d458ff4189726aa7641228a755e734c337bae9f04512c5976ca6001f" + }, + "SOURCE-AUDIT.md": { + "bytes": 3461, + "sha256": "791f19b5db7b548147c5205f710d5966f171453642866fb465cdabacc390891a" + }, + "SOURCES.json": { + "bytes": 2087, + "sha256": "db6de9ebf4d14dc0f2e9bed640ee2472293f9164aa64195d4e89001a4ae9ca5f" + }, + "TASK.json": { + "bytes": 6843, + "sha256": "92f1f1a388104008cdd86140f9225280e9e8faa7a4bad6d4eb83c268431c2801" + }, + "VERIFY.json": { + "bytes": 1275, + "sha256": "0a3e05e39a482f5638600eeb30e5509abb4efccaa8d1fdf9c5c9ee3f068027ac" + }, + "controls.py": { + "bytes": 23965, + "sha256": "2c6c1e6f86416dc68e390fcc540922f2804a361ddae05aed9a9a61f9d513c200" + }, + "cubic/CHECKS.json.gz": { + "bytes": 9882, + "sha256": "88623b95217b8ec844b0de70d9937ec5a98504c726d061b632d21cc428dd824c" + }, + "cubic/ORIGINS.json": { + "bytes": 2624, + "sha256": "a5592d309bfeb934bd47fcc261dd2c2434261681f3c5ccf4e4d52e21cba85ebc" + }, + "cubic/OUTPUT-INVENTORY.json": { + "bytes": 2059, + "sha256": "37d3d3b7cad7e5d5a4afa1cafdffea493c165cb6374b6a7aa8e71baed1c15779" + }, + "cubic/PACKAGE-FILES.json": { + "bytes": 513, + "sha256": "0ff946050b61903995d1902e4c6ae4e34f7528080ba0e2fa2e22cbefa05c8668" + }, + "cubic/PROOF.md": { + "bytes": 17694, + "sha256": "d29a6316a0075be95265cfa3336700c690357923687f0a732edc90de3506461e" + }, + "cubic/VALIDATION.json": { + "bytes": 1304, + "sha256": "2a1046a45c852b305d39d59ac7da1769c1e9cb5a24ae30c8632dcf93de3c24d0" + }, + "cubic/check.py": { + "bytes": 16773, + "sha256": "57c4c002d8bff4ee863a6d8ef359df5532b18b5d3d0fa3b16525f265f16734f1" + }, + "cubic/frozen/CUBIC-FOUR-CALL-GATE.json": { + "bytes": 18149, + "sha256": "2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029" + }, + "cubic/frozen/INDEPENDENT-REVIEW.md": { + "bytes": 2095, + "sha256": "5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100" + }, + "cubic/frozen/README.md": { + "bytes": 12653, + "sha256": "aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c" + }, + "cubic/frozen/WIDE-MIXED-CUBIC-GATES.json": { + "bytes": 8806, + "sha256": "9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa" + }, + "cubic/frozen/cubic_gate.py": { + "bytes": 11521, + "sha256": "0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd" + }, + "cubic/frozen/wide_gate.py": { + "bytes": 11982, + "sha256": "beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496" + }, + "independent/CHECKS.json.gz": { + "bytes": 3156, + "sha256": "32604d0af7774963dde86bc56ad45390a34d71b6711cb85ae56353198f6a7eca" + }, + "independent/PROOF-INDEPENDENT.md": { + "bytes": 2297, + "sha256": "ba27dd69a518336abc2bf3ad70dc234884be39a6f6c4e18c50a057532ef04fa2" + }, + "independent/check.py": { + "bytes": 10963, + "sha256": "bd6dd0d297f259756f6ea3c1555a05b5232ad568fd8d16d079f8b397876c8cdc" + }, + "verify.py": { + "bytes": 5559, + "sha256": "15681d12b313b4e62350d488bf06fbe5b588be3fed6df007faa90086339f188b" + } + }, + "manifest_sha256": "a8b4d059e673ed3e65de4fa9d1eaa2fe4ecd557eff157fd6c06c3c322da8bac4", + "schema": "core_snapshot.v1", + "scope": "Complete candidate core; snapshot and subsequent review reports excluded to avoid circular hashes." +} diff --git a/research/cubic-scalar-caller-bounds/FROZEN-SHA256.json b/research/cubic-scalar-caller-bounds/FROZEN-SHA256.json new file mode 100644 index 0000000000..86aa79a1e6 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/FROZEN-SHA256.json @@ -0,0 +1,26 @@ +{ + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "0cbaa565d458ff4189726aa7641228a755e734c337bae9f04512c5976ca6001f", + "SOURCE-AUDIT.md": "791f19b5db7b548147c5205f710d5966f171453642866fb465cdabacc390891a", + "SOURCES.json": "db6de9ebf4d14dc0f2e9bed640ee2472293f9164aa64195d4e89001a4ae9ca5f", + "TASK.json": "92f1f1a388104008cdd86140f9225280e9e8faa7a4bad6d4eb83c268431c2801", + "VERIFY.json": "0a3e05e39a482f5638600eeb30e5509abb4efccaa8d1fdf9c5c9ee3f068027ac", + "controls.py": "2c6c1e6f86416dc68e390fcc540922f2804a361ddae05aed9a9a61f9d513c200", + "cubic/CHECKS.json.gz": "88623b95217b8ec844b0de70d9937ec5a98504c726d061b632d21cc428dd824c", + "cubic/ORIGINS.json": "a5592d309bfeb934bd47fcc261dd2c2434261681f3c5ccf4e4d52e21cba85ebc", + "cubic/OUTPUT-INVENTORY.json": "37d3d3b7cad7e5d5a4afa1cafdffea493c165cb6374b6a7aa8e71baed1c15779", + "cubic/PACKAGE-FILES.json": "0ff946050b61903995d1902e4c6ae4e34f7528080ba0e2fa2e22cbefa05c8668", + "cubic/PROOF.md": "d29a6316a0075be95265cfa3336700c690357923687f0a732edc90de3506461e", + "cubic/VALIDATION.json": "2a1046a45c852b305d39d59ac7da1769c1e9cb5a24ae30c8632dcf93de3c24d0", + "cubic/check.py": "57c4c002d8bff4ee863a6d8ef359df5532b18b5d3d0fa3b16525f265f16734f1", + "cubic/frozen/CUBIC-FOUR-CALL-GATE.json": "2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029", + "cubic/frozen/INDEPENDENT-REVIEW.md": "5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100", + "cubic/frozen/README.md": "aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c", + "cubic/frozen/WIDE-MIXED-CUBIC-GATES.json": "9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa", + "cubic/frozen/cubic_gate.py": "0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd", + "cubic/frozen/wide_gate.py": "beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496", + "independent/CHECKS.json.gz": "32604d0af7774963dde86bc56ad45390a34d71b6711cb85ae56353198f6a7eca", + "independent/PROOF-INDEPENDENT.md": "ba27dd69a518336abc2bf3ad70dc234884be39a6f6c4e18c50a057532ef04fa2", + "independent/check.py": "bd6dd0d297f259756f6ea3c1555a05b5232ad568fd8d16d079f8b397876c8cdc", + "verify.py": "15681d12b313b4e62350d488bf06fbe5b588be3fed6df007faa90086339f188b" +} diff --git a/research/cubic-scalar-caller-bounds/LICENSE b/research/cubic-scalar-caller-bounds/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/cubic-scalar-caller-bounds/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/cubic-scalar-caller-bounds/ORIGINS.json b/research/cubic-scalar-caller-bounds/ORIGINS.json new file mode 100644 index 0000000000..6a3fabcf34 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/ORIGINS.json @@ -0,0 +1,107 @@ +{ + "LICENSE": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "README.md": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "0cbaa565d458ff4189726aa7641228a755e734c337bae9f04512c5976ca6001f" + }, + "SOURCE-AUDIT.md": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "791f19b5db7b548147c5205f710d5966f171453642866fb465cdabacc390891a" + }, + "SOURCES.json": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "db6de9ebf4d14dc0f2e9bed640ee2472293f9164aa64195d4e89001a4ae9ca5f" + }, + "TASK.json": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "92f1f1a388104008cdd86140f9225280e9e8faa7a4bad6d4eb83c268431c2801" + }, + "VERIFY.json": { + "provenance": "C09 cubic integration documentation, licence or current-base metadata", + "sha256": "0a3e05e39a482f5638600eeb30e5509abb4efccaa8d1fdf9c5c9ee3f068027ac" + }, + "controls.py": { + "adaptation": "Two cubic science stages; fixed historical receipt dispatch for independent engine; cubic source and mathematical control probes. All generic loader/typed-record/coverage/output controls retained.", + "adapted_from_sha256": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671", + "provenance": "Adapted reviewed C09a wrapper/control pattern", + "sha256": "2c6c1e6f86416dc68e390fcc540922f2804a361ddae05aed9a9a61f9d513c200" + }, + "cubic/CHECKS.json.gz": { + "original_sha256": "ed54e928ba5278c58db459a3c69de1cc6c59070f384e254c518d67fff66f31dd", + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/CHECKS.json.gz", + "sha256": "88623b95217b8ec844b0de70d9937ec5a98504c726d061b632d21cc428dd824c" + }, + "cubic/ORIGINS.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/ORIGINS.json", + "sha256": "a5592d309bfeb934bd47fcc261dd2c2434261681f3c5ccf4e4d52e21cba85ebc" + }, + "cubic/OUTPUT-INVENTORY.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/OUTPUT-INVENTORY.json", + "sha256": "37d3d3b7cad7e5d5a4afa1cafdffea493c165cb6374b6a7aa8e71baed1c15779" + }, + "cubic/PACKAGE-FILES.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/PACKAGE-FILES.json", + "sha256": "0ff946050b61903995d1902e4c6ae4e34f7528080ba0e2fa2e22cbefa05c8668" + }, + "cubic/PROOF.md": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/PROOF.md", + "sha256": "d29a6316a0075be95265cfa3336700c690357923687f0a732edc90de3506461e" + }, + "cubic/VALIDATION.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/VALIDATION.json", + "sha256": "2a1046a45c852b305d39d59ac7da1769c1e9cb5a24ae30c8632dcf93de3c24d0" + }, + "cubic/check.py": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/check.py", + "sha256": "57c4c002d8bff4ee863a6d8ef359df5532b18b5d3d0fa3b16525f265f16734f1" + }, + "cubic/frozen/CUBIC-FOUR-CALL-GATE.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/CUBIC-FOUR-CALL-GATE.json", + "sha256": "2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029" + }, + "cubic/frozen/INDEPENDENT-REVIEW.md": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/INDEPENDENT-REVIEW.md", + "sha256": "5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100" + }, + "cubic/frozen/README.md": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/README.md", + "sha256": "aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c" + }, + "cubic/frozen/WIDE-MIXED-CUBIC-GATES.json": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/WIDE-MIXED-CUBIC-GATES.json", + "sha256": "9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa" + }, + "cubic/frozen/cubic_gate.py": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/cubic_gate.py", + "sha256": "0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd" + }, + "cubic/frozen/wide_gate.py": { + "provenance": "Unchanged frozen C09 cubic component: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic/frozen/wide_gate.py", + "sha256": "beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496" + }, + "independent/CHECKS.json.gz": { + "original_sha256": "ce4da1d81691dbfd67e5d98c60316f296a23101a0aa6cb1dce335397a32d4ba8", + "provenance": "Complete independent scientific receipt: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic-review/INDEPENDENT-CHECKS.json.gz", + "sha256": "32604d0af7774963dde86bc56ad45390a34d71b6711cb85ae56353198f6a7eca" + }, + "independent/PROOF-INDEPENDENT.md": { + "adaptation": "Summary documentation, with installed package-relative reproduction command; no mathematical checker or receipt changes.", + "provenance": "New integration contract summary with installed command, based on the unchanged independent review", + "sha256": "ba27dd69a518336abc2bf3ad70dc234884be39a6f6c4e18c50a057532ef04fa2", + "source_origin": "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic-review/REVIEW.md", + "source_sha256": "f534a901b72248c7ef74f2c1adb7afee9342482fdd10033b4e9999e26d887ed7" + }, + "independent/check.py": { + "provenance": "Unchanged complete independent rational engine: /Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-cubic-review/independent_check.py", + "sha256": "bd6dd0d297f259756f6ea3c1555a05b5232ad568fd8d16d079f8b397876c8cdc" + }, + "verify.py": { + "adaptation": "Two cubic science stages; fixed historical receipt dispatch for independent engine; cubic source and mathematical control probes. All generic loader/typed-record/coverage/output controls retained.", + "adapted_from_sha256": "9566d768b7929e25e8ad62b96f27986827c7ae4d94a5faa25d296f58391d9a3e", + "provenance": "Adapted reviewed C09a wrapper/control pattern", + "sha256": "15681d12b313b4e62350d488bf06fbe5b588be3fed6df007faa90086339f188b" + } +} diff --git a/research/cubic-scalar-caller-bounds/README.md b/research/cubic-scalar-caller-bounds/README.md new file mode 100644 index 0000000000..596f6343b2 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/README.md @@ -0,0 +1,103 @@ +# Cubic scalar caller bounds + +Scalar bank words in the full algebra `Q[N]/(N^3-1)` need at least five paid +queries on three independent banks when their directions are constant rational +rank-one nilpotents. This three-bank bound permits arbitrary scalar-polynomial +coefficients. For the narrower paid alphabet `E_ij(±N)` and `E_ij(±N^2)`, with +arbitrary constant `GL_n(Q)` bridges, the complete target `N I_n` requires + +``` +3 | n, +k >= n + ceil((n+1)/3), +max(0,2n-k) <= a,b <= min(k,2(k-n)), +``` + +where `a+b=k` counts the two powers. A homogeneous word needs `k>=2n`. +Three matching layers are impossible. Four layers are impossible if each is +pure in one power; four internally mixed layers remain open. These are +necessary bounds, with no positive scalar synthesis claimed. + +[The proof](cubic/PROOF.md) gives the all-word arguments, including the strict +equality case and completed four-pure-layer proof. The power-balance interval +adds a useful screen: at `n=3,k=5` both powers must occur, and at `n=6,k=9` +each must occur between three and six times. [The independent check](independent/PROOF-INDEPENDENT.md) +uses ordinary rational matrices and imports none of the candidate arithmetic. + +The full algebra premise matters. A primitive-only operator satisfying +`N^2+N+I=0` does not automatically inherit this full-ring obstruction. Fresh +checks retain augmentation, all arbitrary input columns and an excluded +four-factor word with operator-dependent directions. The wide two-power +proof is not extended to arbitrary polynomial coefficients. + +## Conditional cost screen + +For the stipulated optimistic OPEN profile on `n` banks of twelve fields and +`k` calls in `s` legal matching layers, the complete histogram is +`H={1:8k,2:40k,3:16k,5:12(ns-2k)}`, with `m=2+5s` and `W=12n`. +Inactive banks remain charged. The deficit `mW-mass=24n-16k` is conditional +on an actual matching schedule (`k<=s floor(n/2)`) and that profile. The +query bounds make three- and six-bank cases fail every positive exponent +under strict child contraction. A positive optimistic deficit at a larger +width does not supply a caller or its missing costs. + +Constant bridges are free only in the lower-bound relaxation. Native source +access, admission, scalar/address work, restored helper endpoints, precision, +ownership, storage and tape execution remain separate. No selected result or +new kappa is claimed. + +## Reproduction + +Run `python3.12 -B scripts/research_package.py --package research/cubic-scalar-caller-bounds`. +`VERIFY.json` lists direct standard-library commands for a Git-free read-only +export: + +``` +python3.12 -I -O -B verify.py --stage cubic +python3.12 -I -O -B verify.py --stage independent +python3.12 -I -B controls.py --package . +``` + +Every executed component and expected receipt is authenticated. The wrapper +executes captured source with optimization disabled and uses fresh external +scratch. Both complete historical receipts are compared with exact JSON types +and no omitted fields. The independent stage retains its full implementation; +the wrapper supplies only the fixed historical-receipt argument. Retained +mathematical code is never imported through a filesystem or bytecode cache. + +The candidate executes 27 actual defects and named-guard deletions; the +independent stage executes twelve more. Normal and optimized Python 3.12 +component receipts agree completely. Finite examples check identities and +sensitivity; the universal bounds are written proofs, not a finite search or +formal-kernel result. Compact integration controls separately test source +execution, complete typed records, stage coverage and real production gates. + +## Sources and related work + +Current guidance and the exact task card are pinned to +`12fa8c5c844be21bfefb38a19503fbd867a11244`, priority 7. The historical cubic +lane retains scientific snapshot `20ecf2891d80b5acf18d980b2164fb44ea7faa90` +and unchanged sources and receipts. This assigned scope does not solve the +current installed QQ16 caller task. Original notes mention a quadratic +continuation; that context is preserved, but no quadratic-caller files or +claims are included. + +Normalization, rank and specialization methods retain credit to eumemic's +PR288 source and Ali Romman's PR468. [PR4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023) +uses a distinct order-four/quartic unary-query alphabet. +[PR4081](https://github.com/CrocSwap/integer-mult-bounds/pull/4081) treats an +actual Gaussian Clifford satisfying a primitive cubic relation and fixed +response interfaces. Neither is identified with this full cubic-ring +constant-direction model. `SOURCE-AUDIT.md` gives exact links and boundaries; +the methods are not claimed as new. + +Ross Richardson with substantial OpenAI Codex assistance in the proof, +checker, integration and separate mathematical review contexts. Apache-2.0. +AI review is distinct from independent human acceptance and formal proof. + +## Open next questions + +Specify one bounded four-layer mixed-power alphabet and test its complete +full-ring target against the power-balance constraints. Before applying a +bound to a native operator, prove the required algebra representation rather +than merely order three. Wider synthesis or supplier construction still needs +that bridge and a complete favorable invoice; `TASK.json` records the gates. diff --git a/research/cubic-scalar-caller-bounds/SOURCE-AUDIT.md b/research/cubic-scalar-caller-bounds/SOURCE-AUDIT.md new file mode 100644 index 0000000000..ec86c9bde1 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/SOURCE-AUDIT.md @@ -0,0 +1,55 @@ +# Source credit and contribution boundary + +The preserved local cubic-caller lane supplies the original three-bank, +interaction-rank and layer arguments and exact receipts. Its earlier independent +review sharpened the interaction rank to equality. The new proof completes the +equality-case and four-pure-layer derivations, records the power-balance +interval and separates the alphabets and targets. It adds actual production +predicate controls and a separately implemented rational-matrix check. All six +original files remain byte-for-byte unchanged under `cubic/frozen/`. + +Historical scripts execute from captured authenticated buffers with +`compile(...,dont_inherit=True,optimize=0)`. Both complete `receipt()` functions +run; old path-writing `main()` functions do not. Every typed field of both old +receipts is compared. The independent checker is unchanged; the wrapper adds +the fixed path to the authenticated historical receipt. No arithmetic has been +replaced or shortened. Top-level `ORIGINS.json` distinguishes the wrapper and +control adaptations from these unchanged components. + +Group-algebra normalization, image/row-space rank and specialization have +prior use in eumemic's +[retained PR288 source](https://github.com/CrocSwap/integer-mult-bounds/blob/20ecf2891d80b5acf18d980b2164fb44ea7faa90/research/abelian-cayley-metric-scope/sources/pr288-README.md) +and Ali Romman's +[PR468](https://github.com/CrocSwap/integer-mult-bounds/blob/07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea/research/bit-three-register-lower-bound/README.md). +These different group-algebra and register models are credited, not invoked +as unproved reductions or rerun as large searches. The method is not claimed +as new. + +[PR4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023), retained as +`research/fixed-support-unary-query-bounds/README.md`, proves a different +order-four carrier theorem with swap-algebra bridges and a separate quartic +result. The present gates are scalar cubic shears with constant rational +bank directions. No alphabet reduction is asserted. + +[PR4081](https://github.com/CrocSwap/integer-mult-bounds/pull/4081), retained as +`research/skew-cubic-response-gates/README.md`, proves a rank boundary for an +actual Gaussian Clifford satisfying `U^2+U+I=0` and distinct skew-response +tariffs. Its README leaves a complete three-power caller outside that gate. +A primitive-only operator may lose augmentation, so the full-ring bound here +cannot simply be applied to it. Its similarly named source file is different +from the historical `cubic-caller/cubic_gate.py` preserved here. + +Current guidance, task catalogue and related README files are pinned in +`SOURCES.json` to `12fa8c5c844be21bfefb38a19503fbd867a11244`, with explicit +older method pins. These are provenance and scope context, not runtime +mathematical inputs. The package has no E8 root data, Clifford compiler or +quadratic-caller dependency. Historical quadratic references are context only. + +The current task-card scope change follows the explicit user assignment. +Bounded source searches and live overlap reconciliation are recorded by the +parent externally; they are not exhaustive novelty certificates. No selected +record, native supplier or multiplication bound is changed. + +Ross Richardson with substantial OpenAI Codex assistance. Written all-word +proofs, finite matrices, automated gates, independent AI review, human +acceptance and formal-kernel proof remain distinct evidence levels. diff --git a/research/cubic-scalar-caller-bounds/SOURCES.json b/research/cubic-scalar-caller-bounds/SOURCES.json new file mode 100644 index 0000000000..08d178dcd2 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/SOURCES.json @@ -0,0 +1,50 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "docs/research/research-family-status.md", + "usage": "provenance", + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f" + }, + { + "path": "research/fixed-support-unary-query-bounds/README.md", + "git_blob": "29e1f2ba643e36ef43d566d32242bf6950b2ab27", + "sha256": "58f4675f0b6694177bba3a2c8de7bf7d9445f6e87437356e2cf1e33bb090f3d4", + "usage": "provenance" + }, + { + "path": "research/abelian-cayley-metric-scope/sources/pr288-README.md", + "usage": "provenance", + "git_blob": "dc04f533bd0f3b185969bb259e876a73714f7285", + "sha256": "c091e98c415e2a80bb28402b789363eb97dd3492061ca8875e421ae437de7482", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/abelian-cayley-metric-scope/sources/pr288-README.md" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "provenance", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "pin": "head:07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea:research/bit-three-register-lower-bound/README.md" + }, + { + "path": "research/skew-cubic-response-gates/README.md", + "usage": "provenance", + "git_blob": "83ddd8f53075f8b346ebd601022f09998c8a1422", + "sha256": "00e559ae7e58141172ebe71b7182095f6adce72895d935e2124eb75e9fd789e9" + } + ] +} diff --git a/research/cubic-scalar-caller-bounds/TASK.json b/research/cubic-scalar-caller-bounds/TASK.json new file mode 100644 index 0000000000..baa6fecd67 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove full Q[N]/(N^3-1) scalar caller query and layer obstructions with constant rational bank directions, and record the necessary power-balance constraints.", + "scope_change_reason": "Explicit user assignment to finish the preserved cubic scalar-caller contribution. This lower-bound alphabet is separate from the current installed QQ16 caller task.", + "bottleneck_link": "A scalar three-power factorization must satisfy the full augmentation component and constant-direction constraints before a native caller or complete favorable invoice can be claimed.", + "budget_minutes": 240, + "stop_rule": "Preserve both complete historical receipts, finish the equality and four-pure-layer proofs, and independently verify exact finite matrices and actual predicate defects. No broad mixed-layer synthesis or native caller search.", + "outcome": "partial", + "evidence": "Written all-word query/layer proofs, complete source-bound finite receipts, and a separately implemented rational-matrix check. No full supplier or formal-kernel claim.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance, including separate AI mathematical review contexts; no independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Can four internally mixed layers meet the full cubic target while respecting the power-balance bounds?", + "why_it_matters": "The pure-layer obstruction does not cover this changed coefficient structure.", + "first_step": "State a bounded exact alphabet and test its complete target and augmentation before any native lowering.", + "blocked_by": "No positive scalar factorization or complete native bridge/source/precision bill is supplied." + }, + { + "question": "Which concrete operator interface faithfully realizes the full cubic algebra used by the theorem?", + "why_it_matters": "A primitive-only operator can annihilate N^2+N+I and need not inherit a full-ring lower bound.", + "first_step": "Prove an injective algebra representation or restate the target model for the actual quotient.", + "blocked_by": "Order three alone is not full-ring faithfulness." + } + ] +} diff --git a/research/cubic-scalar-caller-bounds/VERIFY.json b/research/cubic-scalar-caller-bounds/VERIFY.json new file mode 100644 index 0000000000..9912a489aa --- /dev/null +++ b/research/cubic-scalar-caller-bounds/VERIFY.json @@ -0,0 +1,47 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "cubic" + ], + "timeout_seconds": 120, + "checks": "Both complete historical typed receipts, all full-ring input columns, primitive-field identities, matching invoices and 27 actual defects with same-guard deletions." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent" + ], + "timeout_seconds": 120, + "checks": "Independent ordinary rational matrices for every normalization prefix, full-ring target and inverse, projectors, interaction and layer defects; 12 actual predicate/deletion controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py", + "--package", + "{package}" + ], + "timeout_seconds": 90, + "checks": "Captured-source execution, complete typed records, exact two-stage dispatch, source mutations, real compact mathematical controls and exclusive output behavior." + } + ] +} diff --git a/research/cubic-scalar-caller-bounds/controls.py b/research/cubic-scalar-caller-bounds/controls.py new file mode 100644 index 0000000000..d8a6fd9858 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/controls.py @@ -0,0 +1,474 @@ +#!/usr/bin/env python3 +"""Compact source, complete-record and real semantic controls for C09 cubic calls. + +Adapted from the reviewed C07 wrapper controls. All mutations are disposable. +Substantial OpenAI Codex assistance; Apache-2.0. +""" +import argparse +import copy +import gzip +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import types + +STAGES = ('cubic', 'independent') + +def require(ok, message): + if not ok: + raise ValueError(message) + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def load_module(path, raw=None, name="reviewed_controls_module"): + source = path.read_bytes() if raw is None else raw + module = types.ModuleType(name) + module.__file__ = str(path) + exec(compile(source, str(path), "exec", dont_inherit=True, optimize=0), module.__dict__) + return module + +def reject(label, action, expected, records, exact=True): + try: + action() + except (ValueError, AssertionError) as error: + message = str(error) + require(message == expected if exact else expected in message, + "wrong rejection for " + label + ": " + message) + records.append({"name": label, "intended_gate": expected}) + else: + raise ValueError("control accepted: " + label) + +def fixture(root, files, originals=None): + root.mkdir(parents=True) + hashes, origins = {}, {} + for name, raw in files.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + hashes[name] = sha(raw) + origins[name] = {"sha256": sha(raw)} + if originals and name in originals: + origins[name]["original_sha256"] = sha(originals[name]) + (root / "FROZEN-SHA256.json").write_text(json.dumps(hashes)) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + return root + +def loader_checks(v, temporary): + positive = ( + b"import json, sys\nfrom pathlib import Path\n" + b"assert __debug__ and sys.flags.optimize == 0, 'CHILD_OPTIMIZATION'\n" + b"assert __file__ == sys.argv[0], 'SCRIPT_FILE_ARGUMENT'\n" + b"Path(sys.argv[-1]).write_text(json.dumps(sys.argv[1:-1]))\n" + ) + files = { + "script with spaces.py": positive, + "direct.py": b"assert False, 'DIRECT_ASSERT'\n", + "nested.py": b"def inner():\n assert False, 'NESTED_ASSERT'\ninner()\n", + "notfinite.json": b'{"a":NaN}', + } + root = fixture(temporary / "loader", files) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + output = temporary / "literal argument result.json" + frozen.run("script with spaces.py", ["argument with spaces", output]) + require(json.loads(output.read_text()) == ["argument with spaces"], "preserved script arguments") + for name, marker in (("direct.py", "DIRECT_ASSERT"), ("nested.py", "NESTED_ASSERT")): + reject(name, lambda name=name: frozen.run(name, []), + "AssertionError: " + marker, rejected, exact=False) + # This disposable source is changed only after Frozen.raw has returned. + # The script passed to the interpreter must remain the captured old bytes. + original_path, calls = frozen.path, {"count": 0} + def changed_path(name): + path = original_path(name) + calls["count"] += 1 + if calls["count"] == 2: + path.write_bytes(b"raise RuntimeError('REOPENED_CHANGED_SOURCE')\n") + return path + frozen.path = changed_path + try: + frozen.run("script with spaces.py", ["captured bytes", output]) + require(calls["count"] == 2 and json.loads(output.read_text()) == ["captured bytes"], + "captured authenticated source execution") + finally: + frozen.path = original_path + (root / "script with spaces.py").write_bytes(positive) + (root / "direct.py").write_bytes(b"PASS = True\n") + reject("changed_executable_source", lambda: frozen.run("direct.py", []), + "changed frozen input: direct.py", rejected) + (root / "direct.py").unlink() + reject("missing_executable_source", lambda: frozen.run("direct.py", []), + "missing regular input: direct.py", rejected) + reject("unregistered_source", lambda: frozen.run("absent.py", []), + "unregistered input: absent.py", rejected) + reject("absolute_path", lambda: frozen.path("/etc/passwd"), "unsafe package path", rejected) + reject("parent_escape", lambda: frozen.path("../outside"), "unsafe package path", rejected) + (root / "link.py").symlink_to(root / "nested.py") + reject("symlink_input", lambda: frozen.path("link.py"), + "missing regular input: link.py", rejected) + outside = temporary / "external" + outside.mkdir() + (outside / "data.json").write_text("{}") + (root / "outside").symlink_to(outside, target_is_directory=True) + reject("ancestor_symlink_escape", lambda: frozen.path("outside/data.json"), + "input escapes package", rejected) + reject("direct_runtime_requirement", lambda: v.require(False, "DIRECT_RUNTIME_GATE"), + "DIRECT_RUNTIME_GATE", rejected) + return {"rejections": rejected, "captured_source_survives_disposable_path_change": True, + "child_assertions_enabled": True, "file_and_argument_semantics_preserved": True} + +def record_checks(v, temporary): + value = {"integer": 1, "boolean": True, "nested": {"ordered": [1, 2, 3]}} + raw = json.dumps(value).encode() + root = fixture(temporary / "record", {"expected.json": raw}) + frozen, rejected = v.Frozen(root), [] + frozen.compare("expected.json", raw) + mutations = { + "boolean_for_integer": dict(value, integer=True), + "float_for_integer": dict(value, integer=1.0), + "integer_for_boolean": dict(value, boolean=1), + "nested_omission": dict(value, nested={}), + "ordered_list_reorder": dict(value, nested={"ordered": [1, 3, 2]}), + "ordered_list_truncate": dict(value, nested={"ordered": [1, 2]}), + } + for label, changed in mutations.items(): + reject(label, lambda changed=changed: frozen.compare("expected.json", json.dumps(changed).encode()), + "complete typed record mismatch: expected.json", rejected) + reject("duplicate_json_key", lambda: v.data(b'{"a":1,"a":2}'), + "duplicate JSON key: a", rejected) + reject("nested_duplicate_json_key", lambda: v.data(b'{"n":{"a":1,"a":2}}'), + "duplicate JSON key: a", rejected) + for value_ in ("NaN", "Infinity", "-Infinity"): + reject("nonfinite_" + value_, lambda value_=value_: v.data(value_.encode()), + "nonfinite JSON constant: " + value_, rejected) + (root / "expected.json").unlink() + reject("missing_expected_record", lambda: frozen.compare("expected.json", raw), + "missing regular input: expected.json", rejected) + require(not (root / "expected.json").exists(), "missing expected record regenerated") + (root / "expected.json").write_bytes(raw) + saved = v.require + try: + v.require = lambda ok, message: None if message.startswith("complete typed record mismatch:") else saved(ok, message) + try: + reject("deleted_record_gate", + lambda: frozen.compare("expected.json", json.dumps(mutations["boolean_for_integer"]).encode()), + "complete typed record mismatch: expected.json", []) + except ValueError as error: + require(str(error) == "control accepted: deleted_record_gate", "record check-deletion sensitivity") + else: + raise ValueError("record check deletion not detected") + finally: + v.require = saved + return {"rejections": rejected, "named_record_gate_deletion_detected": True} + +def compression_checks(v, temporary): + name, plain = "original.json.gz", b'{"original":[1,2,3]}\n' + root = fixture(temporary / "compression", {name: gzip.compress(plain, mtime=0)}, {name: plain}) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + changed = gzip.compress(b'{"original":[1,2,4]}\n', mtime=0) + (root / name).write_bytes(changed) + reject("changed_compressed_input", frozen.check_all, + "changed frozen input: " + name, rejected) + frozen.hashes[name] = sha(changed) + reject("changed_container_origin", frozen.check_all, + "origin digest mismatch: " + name, rejected) + frozen.origins[name]["sha256"] = sha(changed) + reject("changed_original_after_transport_rebinding", frozen.check_all, + "original decoded bytes changed: " + name, rejected) + same = gzip.compress(plain, mtime=17) + (root / name).write_bytes(same) + frozen.hashes[name] = frozen.origins[name]["sha256"] = sha(same) + frozen.check_all() + saved = frozen.origins + frozen.origins = {} + reject("omitted_origin", frozen.check_all, "frozen/origin inventory mismatch", rejected) + frozen.origins = saved + return {"rejections": rejected, "equivalent_recompression_accepted": True} + +def deletion(v, action, gate): + saved = v.require + try: + v.require = lambda ok, message: None if message == gate else saved(ok, message) + try: + reject('deleted_'+gate, action, gate, []) + except ValueError as error: + require(str(error) == 'control accepted: deleted_'+gate, 'intended check deletion') + else: + raise ValueError('deleted gate still rejected: '+gate) + finally: + v.require = saved + +def real_records(v, package): + frozen, records = v.Frozen(package), [] + names = sorted(set().union(*(v.expected_records(stage) for stage in STAGES))) + def leaves(value, path=()): + if isinstance(value, dict): + for key in sorted(value): + yield from leaves(value[key], path+(key,)) + elif isinstance(value, list): + for i, child in enumerate(value): + yield from leaves(child, path+(i,)) + else: + yield path, value + for name in names: + raw = frozen.raw(name) + value = v.data(raw) + frozen.compare(name, json.dumps(value).encode()) + path, old = max(leaves(value), key=lambda item: len(item[0])) + require(len(path) > 1, 'real nested record coverage') + changed, omitted = copy.deepcopy(value), copy.deepcopy(value) + parent, other = changed, omitted + for key in path[:-1]: + parent, other = parent[key], other[key] + parent[path[-1]] = not old if type(old) is bool else old+1 if type(old) is int else {'changed': True} + del other[path[-1]] + rejected = [] + for label, candidate in (('deep_field_changed', changed), ('deep_field_omitted', omitted)): + reject(label, lambda candidate=candidate: frozen.compare(name, json.dumps(candidate).encode()), + 'complete typed record mismatch: '+name, rejected) + records.append({'record': name, 'sha256': sha(raw), 'nested_path': list(path), 'rejections': rejected}) + require(len(records) == 2, 'two complete scientific records') + return records + +def coverage_checks(v, temporary): + require(set(v.STAGES) == set(STAGES), 'exact two science stages') + rejected, counts = [], {} + for stage in STAGES: + names = sorted(v.expected_records(stage)) + v.check_coverage(stage, names) + counts[stage] = len(names) + for label, changed in (('omitted', []), ('duplicated', names+names), + ('extra', names+['extra.json'])): + reject(stage+'_'+label, + lambda stage=stage, changed=changed: v.check_coverage(stage, changed), + 'complete stage record coverage changed: '+stage, rejected) + require(counts == dict.fromkeys(STAGES, 1), 'two singleton complete records') + + class Tiny: + def __init__(self, omit=False): + self.compared, self.scripts, self.omit = [], [], omit + def run(self, script, arguments): + self.scripts.append(script) + expected_length = 4 if script == v.STAGES['independent'][0] else 2 + require(len(arguments) == expected_length and arguments[0] == '--output', + 'exact declared output argument') + if expected_length == 4: + require(arguments[2] == '--historical-receipt' and + arguments[3] == self.path('cubic/frozen/CUBIC-FOUR-CALL-GATE.json'), + 'fixed historical receipt argument') + output = Path(arguments[1]) + require(output.is_relative_to(temporary), 'external dispatch scratch') + output.write_text('{}') + def path(self, name): + require(name == 'cubic/frozen/CUBIC-FOUR-CALL-GATE.json', 'fixed scientific dependency') + return temporary/name + def compare(self, name, raw): + require(raw == b'{}', 'generated fixture reaches complete comparison') + if not self.omit: + self.compared.append(name) + for stage in STAGES: + scratch = temporary/('dispatch-'+stage) + scratch.mkdir() + tiny = Tiny() + v.replay(tiny, scratch, stage) + v.check_coverage(stage, tiny.compared) + require(tiny.scripts == [v.STAGES[stage][0]], 'one declared checker selected') + scratch = temporary/'dispatch-omitted-comparison' + scratch.mkdir() + tiny = Tiny(True) + v.replay(tiny, scratch, 'cubic') + action = lambda: v.check_coverage('cubic', tiny.compared) + gate = 'complete stage record coverage changed: cubic' + reject('omitted_actual_compare', action, gate, rejected) + deletion(v, action, gate) + return {'rejections': rejected, 'stage_counts': counts, + 'actual_dispatch_tested_with_tiny_receipts': True, + 'executed_check_deletions': 1} + +def output_checks(v, package, temporary): + rejected, argv = [], sys.argv + existing = temporary/'existing output.json' + existing.write_text('preserved') + def invoke(output): + sys.argv = ['verify.py', '--stage', 'cubic', '--output', str(output)] + v.main() + try: + reject('relative_output', lambda: invoke(Path('relative.json')), + 'output must be absolute', rejected) + reject('existing_output', lambda: invoke(existing), 'output already exists', rejected) + reject('internal_output', lambda: invoke(package/'forbidden.json'), + 'output must be external', rejected) + original_replay = v.replay + race_output = temporary/'racing output.json' + def racing_replay(frozen, scratch, stage): + frozen.compared.extend(sorted(v.expected_records(stage))) + race_output.write_text('race winner preserved') + v.replay = racing_replay + try: + try: + invoke(race_output) + except FileExistsError: + require(race_output.read_text() == 'race winner preserved', + 'exclusive creation preserves racing output') + rejected.append({'name': 'output created during replay', + 'intended_gate': 'exclusive output creation FileExistsError'}) + else: + raise ValueError('racing output overwritten') + finally: + v.replay = original_replay + finally: + sys.argv = argv + require(existing.read_text() == 'preserved', 'existing output retained') + return {'rejections': rejected, 'early_output_guards': True, + 'exclusive_output_creation_exercised': True} + +def child(package): + v = load_module(package/'verify.py') + v.Frozen(package).check_all() + with tempfile.TemporaryDirectory(prefix='C09 cubic compact controls ') as directory: + temporary = Path(directory) + result = {'loader': loader_checks(v, temporary), 'record_gate': record_checks(v, temporary), + 'compression': compression_checks(v, temporary), + 'coverage': coverage_checks(v, temporary), + 'sources': source_checks(v, package, temporary), + 'scientific': scientific_checks(v, package), + 'output': output_checks(v, package, temporary), + 'real_records': real_records(v, package)} + v.Frozen(package).check_all() + return {'parent_optimization': sys.flags.optimize, **result} + + +def source_checks(v, package, temporary): + frozen, rejected = v.Frozen(package), [] + cubic = load_module(package/'cubic/check.py', frozen.raw('cubic/check.py')) + for name, source in [('direct', b"assert False, 'HISTORICAL_DIRECT_ASSERT'\n"), + ('nested', b"def f():\n assert False, 'HISTORICAL_NESTED_ASSERT'\nf()\n")]: + marker = 'HISTORICAL_'+name.upper()+'_ASSERT' + reject('captured_'+name+'_assertion', + lambda source=source, name=name: cubic.capture_module('disposable_'+name, source), + marker, rejected) + source_dir = temporary/'cubic inputs' + blobs = {name: frozen.raw('cubic/'+name) for name in cubic.PINS} + for name, raw in blobs.items(): + target = source_dir/name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(raw) + argv = sys.argv + try: + sys.argv = ['check.py', '--inputs', str(source_dir), '--output', str(temporary/'unused.json')] + for name, raw in blobs.items(): + (source_dir/name).write_bytes(raw+b' ') + try: + reject('changed_component_'+name, cubic.main, + 'authenticated captured source bytes', rejected) + finally: + (source_dir/name).write_bytes(raw) + independent = load_module(package/'independent/check.py', frozen.raw('independent/check.py')) + wrong = temporary/'wrong historical receipt.json' + wrong.write_bytes(blobs['frozen/CUBIC-FOUR-CALL-GATE.json']+b' ') + sys.argv = ['independent/check.py', '--historical-receipt', str(wrong), + '--output', str(temporary/'unused-independent.json')] + reject('changed_independent_historical_input', independent.main, + 'historical input authentication', rejected) + finally: + sys.argv = argv + return {'rejections': rejected, 'historical_assertions_execute_with_optimization_zero': True, + 'all_mutations_in_disposable_bytes_or_directory': True, + 'no_path_import_or_pyc_execution': True, + 'full_scientific_stages_replayed': False} + + +def scientific_checks(v, package): + frozen, rejected = v.Frozen(package), [] + cubic = load_module(package/'cubic/check.py', frozen.raw('cubic/check.py')) + historical = cubic.capture_module('authenticated_cubic_control_source', + frozen.raw('cubic/frozen/cubic_gate.py')) + target = cubic.lift([[historical.N if i == j else historical.Z for j in range(3)] for i in range(3)]) + false = cubic.lift([[(1,2,1) if i == j else historical.Z for j in range(3)] for i in range(3)]) + cubic.equal(target, target, 'complete full-cubic target on all columns') + invoice = cubic.invoice(3,5,5)['H'] + missing_idle = dict(invoice); missing_idle[5] = 0 + cases = [ + ('discard actual augmentation component', 'complete full-cubic target on all columns', + lambda: cubic.equal(false, target, 'complete full-cubic target on all columns')), + ('admit identity as a query direction', 'rank-one square-zero bank direction', + lambda: cubic.accept_nilpotent(historical, cubic.eye(3))), + ('omit actual inactive-bank progress', 'all inactive-bank idle charges', + lambda: cubic.accept_invoice(missing_idle, invoice)), + ] + for name, guard, probe in cases: + result = cubic.rejection(name, probe, guard) + require(result['named_guard_deleted'] == 'ACCEPTED', 'actual cubic production gate deletion') + rejected.append({'name': name, 'intended_gate': guard}) + independent = load_module(package/'independent/check.py', frozen.raw('independent/check.py')) + A = [[independent.Q(0),independent.Q(1)],[independent.Q(0),independent.Q(0)]] + B = [[independent.Q(0),independent.Q(0)],[independent.Q(-1),independent.Q(0)]] + I = independent.eye(2) + pair = independent.mul(independent.add(I,B),independent.add(I,A)) + literal = independent.mul(independent.sub(I,A),independent.sub(I,B)) + independent.equal(independent.mul(pair,literal),I,'literal two-layer inverse') + wrong = independent.mul(independent.sub(I,B),independent.sub(I,A)) + row = independent.control('reverse actual pair inverse', 'literal two-layer inverse', + lambda deleted: independent.equal(independent.mul(pair,wrong),I,'literal two-layer inverse',deleted)) + require(row['same_guard_deletion'] == 'accept','independent inverse gate deletion') + rejected.append({'name': row['name'], 'intended_gate': row['rejected']}) + return {'rejections': rejected, 'executed_check_deletions': 4, + 'actual_mathematical_mutations_after_authentication': True, + 'deletion_scope': 'the same named production predicate', + 'full_scientific_stages_replayed': False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--package', type=Path, required=True) + parser.add_argument('--output', type=Path) + parser.add_argument('--child', action='store_true') + args = parser.parse_args() + package = args.package.resolve() + if args.output: + require(args.output.is_absolute(), 'control output must be absolute') + require(not args.output.exists(), 'control output already exists') + require(not args.output.resolve().is_relative_to(package), 'control output must be external') + if args.child: + print(json.dumps(child(package), sort_keys=True)) + return + names = ['verify.py', 'FROZEN-SHA256.json', 'ORIGINS.json', + 'cubic/check.py', 'independent/check.py'] + before = {name: sha((package/name).read_bytes()) for name in names} + results = [] + for optimized in (False, True): + command = [sys.executable, '-I', '-B']+(['-O'] if optimized else []) + command += [str(Path(__file__).resolve()), '--package', str(package), '--child'] + completed = subprocess.run(command, capture_output=True, text=True) + require(completed.returncode == 0, completed.stdout+completed.stderr) + results.append(json.loads(completed.stdout)) + require(before == {name: sha((package/name).read_bytes()) for name in names}, + 'reviewed source changed during controls') + comparable = [{k: value for k, value in row.items() if k != 'parent_optimization'} + for row in results] + require(comparable[0] == comparable[1], 'normal and optimized controls differ') + count = sum(len(row.get('rejections', [])) for row in results[0].values() + if isinstance(row, dict)) + count += sum(len(row['rejections']) for row in results[0]['real_records']) + deletions = 1+sum(row.get('executed_check_deletions', 0) + for row in results[0].values() if isinstance(row, dict)) + result = {'status': 'PASS_C09_CUBIC_COMPACT_SOURCE_RECORD_AND_SEMANTIC_CONTROLS', + 'source_hashes': before, 'control_source_sha256': sha(Path(__file__).read_bytes()), + 'runs': results, 'normal_and_optimized_receipts_equal_except_mode': True, + 'intended_rejections_per_mode': count, + 'executed_check_deletions_per_mode': deletions, + 'full_scientific_receipts_compared': 2, + 'full_scientific_stages_replayed': False, 'no_new_kappa': True} + if args.output: + with args.output.open('x') as destination: + destination.write(json.dumps(result, sort_keys=True, indent=2)+'\n') + print(json.dumps({key: result[key] for key in ('status', 'intended_rejections_per_mode', + 'executed_check_deletions_per_mode', 'full_scientific_receipts_compared')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/cubic-scalar-caller-bounds/cubic/CHECKS.json.gz b/research/cubic-scalar-caller-bounds/cubic/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..c81319f81f6af21060647b50b5c6aba26083cfdf GIT binary patch literal 9882 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 M0nM~BPcy3l0OHeWasU7T literal 0 HcmV?d00001 diff --git a/research/cubic-scalar-caller-bounds/cubic/ORIGINS.json b/research/cubic-scalar-caller-bounds/cubic/ORIGINS.json new file mode 100644 index 0000000000..302e67e1c4 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/ORIGINS.json @@ -0,0 +1,50 @@ +{ + "inputs": [ + { + "bytes": 12653, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/README.md", + "path": "frozen/README.md", + "role": "historical_exact_source_or_receipt", + "sha256": "aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c" + }, + { + "bytes": 2095, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/INDEPENDENT-REVIEW.md", + "path": "frozen/INDEPENDENT-REVIEW.md", + "role": "historical_exact_source_or_receipt", + "sha256": "5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100" + }, + { + "bytes": 11521, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/cubic_gate.py", + "path": "frozen/cubic_gate.py", + "role": "historical_exact_source_or_receipt", + "sha256": "0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd" + }, + { + "bytes": 11982, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/wide_gate.py", + "path": "frozen/wide_gate.py", + "role": "historical_exact_source_or_receipt", + "sha256": "beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496" + }, + { + "bytes": 18149, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/CUBIC-FOUR-CALL-GATE.json", + "path": "frozen/CUBIC-FOUR-CALL-GATE.json", + "role": "historical_exact_source_or_receipt", + "sha256": "2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029" + }, + { + "bytes": 8806, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/cubic-caller/WIDE-MIXED-CUBIC-GATES.json", + "path": "frozen/WIDE-MIXED-CUBIC-GATES.json", + "role": "historical_exact_source_or_receipt", + "sha256": "9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa" + } + ], + "schema": "c09_cubic_origins.v1", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Cubic full-ring scalar word and pure-layer obstructions only. Historical README and review contain quadratic references; those are preserved provenance and not replayed or claimed here.", + "source_execution": "Both historical Python sources are executed unchanged from captured authenticated bytes with optimize=0. receipt() recomputes and compares every field; main path I/O is not invoked." +} diff --git a/research/cubic-scalar-caller-bounds/cubic/OUTPUT-INVENTORY.json b/research/cubic-scalar-caller-bounds/cubic/OUTPUT-INVENTORY.json new file mode 100644 index 0000000000..1857d026dd --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/OUTPUT-INVENTORY.json @@ -0,0 +1,67 @@ +{ + "complete_receipt_raw_sha256": "ed54e928ba5278c58db459a3c69de1cc6c59070f384e254c518d67fff66f31dd", + "files": [ + { + "bytes": 16773, + "path": "check.py", + "sha256": "57c4c002d8bff4ee863a6d8ef359df5532b18b5d3d0fa3b16525f265f16734f1" + }, + { + "bytes": 17694, + "path": "PROOF.md", + "sha256": "d29a6316a0075be95265cfa3336700c690357923687f0a732edc90de3506461e" + }, + { + "bytes": 2624, + "path": "ORIGINS.json", + "sha256": "a5592d309bfeb934bd47fcc261dd2c2434261681f3c5ccf4e4d52e21cba85ebc" + }, + { + "bytes": 9882, + "path": "CHECKS.json.gz", + "sha256": "88623b95217b8ec844b0de70d9937ec5a98504c726d061b632d21cc428dd824c" + }, + { + "bytes": 1304, + "path": "VALIDATION.json", + "sha256": "2a1046a45c852b305d39d59ac7da1769c1e9cb5a24ae30c8632dcf93de3c24d0" + }, + { + "bytes": 513, + "path": "PACKAGE-FILES.json", + "sha256": "0ff946050b61903995d1902e4c6ae4e34f7528080ba0e2fa2e22cbefa05c8668" + }, + { + "bytes": 18149, + "path": "frozen/CUBIC-FOUR-CALL-GATE.json", + "sha256": "2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029" + }, + { + "bytes": 2095, + "path": "frozen/INDEPENDENT-REVIEW.md", + "sha256": "5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100" + }, + { + "bytes": 12653, + "path": "frozen/README.md", + "sha256": "aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c" + }, + { + "bytes": 8806, + "path": "frozen/WIDE-MIXED-CUBIC-GATES.json", + "sha256": "9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa" + }, + { + "bytes": 11521, + "path": "frozen/cubic_gate.py", + "sha256": "0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd" + }, + { + "bytes": 11982, + "path": "frozen/wide_gate.py", + "sha256": "beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496" + } + ], + "schema": "c09_cubic_output_inventory.v1", + "self_excluded": "OUTPUT-INVENTORY.json" +} diff --git a/research/cubic-scalar-caller-bounds/cubic/PACKAGE-FILES.json b/research/cubic-scalar-caller-bounds/cubic/PACKAGE-FILES.json new file mode 100644 index 0000000000..8e21c7e20b --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/PACKAGE-FILES.json @@ -0,0 +1,19 @@ +{ + "excluded": "External scratch runs, logs and optional independent reviews are not package inputs.", + "files": [ + "check.py", + "PROOF.md", + "ORIGINS.json", + "CHECKS.json.gz", + "VALIDATION.json", + "PACKAGE-FILES.json", + "OUTPUT-INVENTORY.json", + "frozen/CUBIC-FOUR-CALL-GATE.json", + "frozen/INDEPENDENT-REVIEW.md", + "frozen/README.md", + "frozen/WIDE-MIXED-CUBIC-GATES.json", + "frozen/cubic_gate.py", + "frozen/wide_gate.py" + ], + "schema": "c09_cubic_package_files.v1" +} diff --git a/research/cubic-scalar-caller-bounds/cubic/PROOF.md b/research/cubic-scalar-caller-bounds/cubic/PROOF.md new file mode 100644 index 0000000000..1623c01706 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/PROOF.md @@ -0,0 +1,413 @@ +# Cubic scalar caller bounds with constant rational bank directions + +This contribution proves lower bounds for scalar bank words in the full +algebra `R=Q[N]/(N^3-1)`. It establishes no positive caller or native +implementation. In three banks at least five paid queries are necessary, +even under a larger scalar-polynomial query alphabet. In n banks the mixed +first/second-power alphabet requires + +``` +3 divides n, +k >= n + ceil((n+1)/3), +a,b <= 2(k-n), +``` + +where a,b count the two powers. A homogeneous alphabet requires `k>=2n`. +Three matching layers cannot suffice, and four layers cannot suffice when +each layer is pure in one power. Four internally mixed layers are not +excluded by the last argument. + +The scientific snapshot is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +The unchanged historical proofs, scripts and receipts are under `frozen/`; +`ORIGINS.json` supplies their exact byte pins. The original scalar algebra +lane supplied these proofs and finite witnesses, with the historical +independent review strengthening the exact interaction rank and checking +the three-bank and three-layer arguments. This version completes the +four-pure-layer review, spells out the equality case, supplies fresh +defect-sensitive gates and independent regular-action checks, and records +the query-balance corollary. Prepared with substantial OpenAI Codex +assistance; Apache-2.0 ancestry. Historical quadratic references are retained +as provenance only and are outside this contribution. + +## 1. Full algebra, paid alphabet, and augmentation + +Every one of the n bank inputs is independent. The desired operator is +`N I_n`, optionally preceded by a final constant bank permutation. The paid +alphabet is + +``` +E_ij(s N^e) = I + s N^e e_i e_j^T, +i != j, s in {1,-1}, e in {1,2}. +``` + +Arbitrary constant `GL_n(Q)` bridges may occur between paid queries and are +free in this lower-bound relaxation. Thus the result also applies to the +smaller constant integral ADD/swap/sign bridge model. Allowing free bridges +in the proof is not permission to omit their physical cost from a supplier. +The target includes all n fields; additional fields with a different restored +endpoint would change this model and are not silently included. + +The assertion is an identity in the full algebra R. Its regular action on +the basis `(1,N,N^2)` is injective: the first column of multiplication by a +polynomial gives its three coefficients. A faithful action merely on the +three group elements would not by itself guarantee injectivity of the +whole algebra. In particular, a fixed native operator satisfying +`N^2+N+I=0` has lost the augmentation component and is not automatically +covered by a full-ring lower bound for universal words. + +Let W(N) be a complete word and `B=W(1)` its augmentation. If the word has +the stated target, `B^-1 W(N)=N I_n`, including when the original target has +a final constant bank permutation. To justify normalization with arbitrary +bridges, suppose the current augmentation is B_0. A paid query updates it +to `E_ij(s) B_0`. Since `(e_i e_j^T)^2=0`, + +``` +E_ij(s)^-1 E_ij(sN^e) = I+s(N^e-1)e_i e_j^T. +``` + +Consequently the new normalized factor is + +``` +I+(N^e-1) u v^T, +u v^T = s B_0^-1 e_i e_j^T B_0, +u,v rational, v^T u=0. +``` + +A free constant bridge changes W and B on the same left side and leaves +`B^-1 W` unchanged. This proves the normal form by induction without moving +noncommuting paid factors past each other. Each normalized factor has +determinant one and inverse obtained by negating its perturbation. Therefore +`det(N I_n)=N^n=1` in the full ring is necessary, which is exactly `3 | n`. + +Specializing to a primitive cube root `zeta`, with +`zeta^2+zeta+1=0`, gives a necessary condition for a full-ring identity. +The obstruction proofs may use this condition. A positive identity at +zeta alone would not establish the full-ring target. + +## 2. Three banks require five queries, even with polynomial coefficients + +Consider four invertible factors + +``` +C_i=I+alpha_i u_i v_i^T, +alpha_i in Q(zeta), u_i,v_i in Q^3, v_i^T u_i=0, +C_4 C_3 C_2 C_1=zeta I_3. +``` + +This is a relaxation of the mixed alphabet and permits arbitrary +scalar-polynomial coefficients. The image of the product minus identity is +contained in the span of the four u_i. Since `(zeta-1)I_3` has rank three, +some three u_i are rationally independent. Every three-subset of four +cyclic positions is consecutive. A central invertible product is unchanged +by cyclic rotation: `AB=zeta I` implies `BA=A^-1(AB)A=zeta I`. +Rotate so that the independent directions occur first in application order, +then apply a constant rational change of basis sending them to e_1,e_2,e_3. + +For `P=C_3 C_2 C_1`, the first three factors change only rows one, two, +three respectively. Each individual C_i has its own diagonal entry one +because the corresponding v_i has zero entry there; later row updates can +change accumulated diagonal entries. The resulting identities are + +``` +P_11=1, det P[{1,2},{1,2}]=1. +``` + +Indeed, before the third row changes the leading two-square block is +`[[1,a],[b,1+ba]]`, of determinant one. But +`P=zeta C_4^-1=zeta(I-alpha_4 u v^T)`. With rational `c_i=u_i v_i`, the +one- and two-dimensional principal determinants give + +``` +alpha_4 c_1 = 1-zeta^-1, +alpha_4(c_1+c_2) = 1-zeta^-2. +``` + +The first right side is nonzero, so division is legitimate. The resulting +ratio is + +`(c_1+c_2)/c_1 = (1-zeta^-2)/(1-zeta^-1) = -zeta`, + +contradicting rationality. Three factors are covered by padding an identity; +fewer than three already fail the image-rank requirement. Hence at least +five are necessary in the stated larger constant-direction alphabet. + +The rational-direction premise is essential. The retained source exhibits +four factors whose directions depend on N and whose product really is +`N I_3` in the full ring. This audit replays that excluded word and its +literal inverse independently as nine-dimensional rational matrices. +Every factor's perturbation has coefficient-span dimension greater than +one, and the actual constant-direction admission predicate rejects it. +It is an exact scope counterexample, not a four-query construction in the +allowed alphabet. + +## 3. Exact interaction rank for the mixed alphabet + +Let k normalized factors act on n banks. Put +`t=zeta-1`, `t_2=zeta^2-1` and `alpha_i in {t,t_2}`. Write + +``` +U=[u_1 ... u_k], V=[v_1^T; ...; v_k^T], +B=VU=L_0+U_0, D=diag(alpha_1,...,alpha_k), +G=(D^-1-L_0)^-1. +``` + +Here L_0 and U_0 are the strict lower and strict upper parts of B. Its +diagonal vanishes by `v_i^T u_i=0`. Since D is invertible and L_0 strictly +lower triangular, G exists. Expanding the finite lower-triangular resolvent +orders exactly the chronological chains of queries and yields + +`W=I+U G V`. + +For the central target, `U G V=t I_n`; hence U and V have rank n and k>=n. +The k-square matrix `E=G V U/t` satisfies `E^2=E` and has image `im(GV)`, +of dimension n. Therefore + +``` +C=B-tG^-1=tG^-1(E-I) +``` + +has rank exactly `r=k-n`, not merely an upper bound. The identities +`t/t=1` and `t/t_2=-zeta` give the rational split + +``` +C=A+zeta H, +A=U_0-diag(1 on first-power positions), +H=L_0+diag(1 on second-power positions). +``` + +A is upper triangular and H lower triangular. Their nonzero diagonal +supports partition all k query positions. Conjugating the cyclotomic field +preserves rank. Since A and H are linear combinations of C and its +conjugate, both have rank at most 2r. If a,b count the two powers, the +principal triangular submatrices on their respective diagonal supports +have nonzero determinant, so + +``` +a <= rank A <= 2r, +b <= rank H <= 2r, +k=a+b <= 4r. +``` + +The target assumption matters. For an arbitrary noncentral fixture the +correct identity is + +`U G C = (W-zeta I) U`. + +The finite certificate retains this entire defect and checks it exactly. +Dropping it on that actual fixture fails the production predicate; the +checker does not pretend its fixture solves the central target. + +## 4. The equality k=4r is impossible + +Suppose equality held. It would force `a=b=2r` and +`rank A=rank H=2r`. Let S be the sum of the column spaces of C and its +conjugate, and T the sum of their row spaces. Both have dimension at most +2r. A and H have column spaces contained in S and row spaces contained in T; +their ranks force equality in all four inclusions. Thus A and H have the +same image and the same kernel over Q(zeta). + +It remains to justify the projectors rather than assume diagonalizability. +The only eigenvalues of the upper triangular A are -1 and 0. The algebraic +multiplicity of -1 is a, while `rank A=a`; therefore its zero eigenspace has +dimension `k-a`, equal to the algebraic multiplicity of zero. All Jordan +blocks at zero have size one. Jordan blocks at -1 may be nontrivial. On +those blocks `(I+A)^k` vanishes; on the zero eigenspace it is identity. +Consequently + +`P_A=I-(I+A)^k` + +is exactly the projection onto `im A` along `ker A`. The exponent k suffices +for every Jordan block. In the same way the lower triangular H has only +eigenvalues 1 and 0, zero is semisimple, and + +`P_H=I-(I-H)^k` + +projects onto `im H` along `ker H`. The common image and kernel force the +unique projections to be equal. But taking diagonals in these triangular +polynomials makes diag(P_A) the first-power indicator and diag(P_H) its +complement. They cannot be equal in characteristic zero for k>0. + +Thus `k<4(k-n)`, equivalently `3(k-n)>=n+1`, so + +`k >= n+ceil((n+1)/3)`. + +The fresh finite projector fixtures include nontrivial size-two Jordan +blocks at -1 and 1. Their zero eigenspaces remain semisimple. Replacing the +fourth power by the first really fails the same image/kernel projection +predicate. These fixtures validate the polynomial formulas; they do not +purport to realize the contradictory common-image/common-kernel premise. + +The separate type bounds give a useful immediate screening corollary: + +``` +max(0,2n-k) <= a,b <= min(k,2(k-n)). +``` + +For a homogeneous word this yields `k>=2n`. At n=3 and k=5 both powers must +occur; at n=6 and k=9 each power must occur between three and six times. +These are necessary composition constraints, not syntheses. The wide proof +uses the special two-coefficient split and does not extend to unrelated +polynomial coefficients merely because the three-bank proof does. + +## 5. Three square-zero matching layers cannot suffice + +In a matching layer, disjoint pair-query perturbations annihilate one +another in both orders. After full augmentation normalization its combined +perturbation A satisfies `A^2=0`, including a layer mixing t and t_2. +Constant bridges between complete layers only conjugate these matrices and +preserve square-zero. Arbitrary mixing inside a declared layer is outside +this premise unless square-zero is separately established. + +For two such perturbations define `P=(I+A_2)(I+A_1)`. Its inverse is +`(I-A_1)(I-A_2)`. Square-zero matrices have zero trace, and cyclicity of +trace gives + +`tr P=n+tr(A_2 A_1)=tr P^-1`. + +If `(I+A_3)P=zeta I`, then `P=zeta(I-A_3)` and +`P^-1=zeta^-1(I+A_3)`. The two traces would be `n zeta` and +`n zeta^-1`, a contradiction for positive n in characteristic zero. +This argument even allows operator-dependent square-zero matrices. Its +strength comes from the layer condition, not rationality of individual +query directions. + +## 6. Four pure layers cannot suffice + +Assume four square-zero normalized layers have central product zeta I. +For any adjacent two-layer product P, write the complementary product as +`Q=zeta P^-1`. Both P and Q have trace equal to that of their inverses. +Thus `(zeta-zeta^-1) tr P=0`, and every adjacent pair must have trace zero. +Cyclic rotations preserve the central target and justify applying this to +every adjacent pair in the four-cycle. + +If two neighbors are both of type `I+t A`, their pair trace is +`n+t^2 tr(BA)=n-3 zeta s` for rational s. It cannot vanish. The analogous +second-power trace is `n-3 zeta^2 s`, also nonzero. Hence pure types must +alternate. Cyclic rotation alone puts the product in the form + +``` +(I+t_2 D)(I+t C)(I+t_2 B)(I+t A)=zeta I, +A^2=B^2=C^2=D^2=0, +``` + +with rational A,B,C,D. No change of generator or conjugation of the central +target is required. Split the equality +`(I+t_2D)(I+tC)=zeta(I-tA)(I-t_2B)` into rational and zeta coefficients. +Using `t t_2=3` gives + +``` +C-D = I+2A+B+3AB, +I-C-2D+3DC = A-B. +``` + +Set `G=2A+B+3AB`, substitute `C=D+I+G`, and use `D^2=0`. The second +equation becomes `D G=A+AB`. Right multiplication by B and `B^2=0` give +`2DAB=AB`. Left multiplication by D and `D^2=0` force `DAB=0`, then `AB=0`. +The first pair would therefore have trace +`n+3 tr(BA)=n`, contradicting its required zero trace. This holds for every +positive n, with no rank assumption on the square-zero rational matrices. + +The finite check carries the target defect explicitly. Writing the two +coefficient defects as + +``` +e = I-C-2D+3DC-(A-B), +f = C-D-(I+2A+B+3AB), +``` + +the identity valid for arbitrary square-zero fixture matrices is + +`D(2A+B+3AB)-(A+AB) = (e+f-3Df)/3`. + +Only under the hypothetical central target may e=f=0 be substituted. The +fresh fixture has a nonzero target defect and nonzero DC; omitting the +defect or changing the coefficient sign fails the actual production gate. +An internally mixed layer has additional independent coefficient matrices, +so this proof does not exclude four such layers. + +## 7. Complete conditional optimistic invoice + +Consider n banks of twelve independent fields, k OPEN calls arranged in s +legal matching layers. The source-bound optimistic profile stipulated for +this scalar screen is + +``` +W=12n, m=2+5s, +H_1=8k, H_2=40k, H_3=16k, +H_5=12(ns-2k). +``` + +Every inactive bank in every layer pays its rank-five idle progress. This +per-layer expression requires an actual matching arrangement, in particular +`k<=s floor(n/2)`. It does not assert that arbitrary constant bridges have +native admission. The complete mass and zero-exponent deficit are + +``` +mass = 60ns+16k, +D=mW-mass=24n-16k. +``` + +At n=3 the five-query lower bound yields D<=-8 for every legal layering. +The sequential five-call fixture has `m=27,W=36`, +`H={1:40,2:200,3:80,5:60}`, mass 980 versus stock mass 972. At n=6 the +nine-query lower bound gives D<=0. For positive exponent beta and strict +child contraction, each normalized child contribution +`r*(m/r)^beta` is greater than its rank r. Thus both cases fail every +positive supplier exponent even with the omitted costs treated favorably. +The chosen idle granularity is explicitly per layer; a more detailed +schedule is not inferred from this aggregate count. + +For larger n a positive value of this optimistic D does not establish a +positive exponent or any caller. For example, n=9,k=13 gives D=8 while +leaving source-code transport, native gauges, scalar bridges, all additional +ordinary/private roles, owner stock, precision, address/tape work, and full +arbitrary-input endpoints unpaid. These obligations remain separate. + +## 8. Finite replay, controls, and evidence limits + +Run with Python 3.12 and a fresh absolute output path outside the package and +any overridden input directory: + +``` +python3.12 -I -B check.py --output /absolute/external/new.json.gz +python3.12 -I -O -B check.py --output /absolute/external/new-optimized.json.gz +``` + +Only the standard library is used. Both historical scripts are captured and +authenticated, then compiled unchanged with `optimize=0`. Their complete +`receipt()` functions execute, preserving every original mathematical guard, +and every typed output field is compared with its original frozen receipt. +The old `main()` path I/O is not used. No bytecode cache, ambient Git access, +numerical package, nominee search, or sibling import is required. Output +creation is exclusive and never overwrites an existing path. + +The fresh independent regular-action stage uses ordinary rational matrix +arithmetic, distinct from the source's cyclic polynomial convolution. It +checks all nine rational input columns of every three-bank normalization +fixture, the excluded four-factor word, and its literal inverse. The receipt +stores the entire rational matrices. A polynomial that agrees with N at +primitive roots but augments to four is rejected by this full-ring gate. + +Fresh cyclotomic fixtures retain all interaction matrices, coefficient +splits and target defects, the nontrivial Jordan projector fixtures, the +four-pure-layer coefficient remainders, and the literal two-layer inverse. +They are exact diagnostics for the written arguments, not solutions of +the impossible central factorizations and not an exhaustive search. + +The 27 executed semantic defects comprise eight augmentation/power changes, +four omitted factors, four inadmissible operator-dependent directions, one +augmentation-component omission, one fake identity direction, two interaction +defects, two truncated projector powers, two pure-layer coefficient/defect +changes, one reversed inverse order, one invalid square-zero layer, and one +omitted idle invoice. Each must fail at its named production predicate with +a concrete matrix or rank witness. The identical defective candidate then +runs with only that predicate deleted, outside the rejection catch, and +must be accepted. Historical inequality-only controls are preserved but +are not counted as these new rejection/deletion checks. + +Normal and optimized Python 3.12 receipts are compared completely. These +finite certificates support the stated algebraic identities and sensitivity; +the universal query and layer bounds are the written proofs above. There is +no formal-kernel claim, positive scalar synthesis, native Clifford admission, +or new multiplication bound. The separate primitive-only Clifford response, +quartic caller, and quadratic positive-caller models are not republished. diff --git a/research/cubic-scalar-caller-bounds/cubic/VALIDATION.json b/research/cubic-scalar-caller-bounds/cubic/VALIDATION.json new file mode 100644 index 0000000000..97b0c03f11 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/VALIDATION.json @@ -0,0 +1,46 @@ +{ + "actual_semantic_rejections": 27, + "checker_sha256": "57c4c002d8bff4ee863a6d8ef359df5532b18b5d3d0fa3b16525f265f16734f1", + "executed_named_guard_deletions": 27, + "historical_sources_compile_optimize": 0, + "normal_and_optimized_full_bytes_equal": true, + "normal_flags": [ + "-I", + "-B" + ], + "optimized_flags": [ + "-I", + "-O", + "-B" + ], + "output_rejections": [ + { + "case": "relative", + "exit_code": 1, + "guard": "absolute output required" + }, + { + "case": "inside_package", + "exit_code": 1, + "guard": "external output required" + }, + { + "case": "existing", + "exit_code": 1, + "guard": "new output required" + }, + { + "case": "symlink", + "exit_code": 1, + "guard": "new output required" + } + ], + "proof_sha256": "d29a6316a0075be95265cfa3336700c690357923687f0a732edc90de3506461e", + "python": "3.12.12", + "receipt_gzip_bytes": 9882, + "receipt_gzip_sha256": "88623b95217b8ec844b0de70d9937ec5a98504c726d061b632d21cc428dd824c", + "receipt_raw_bytes": 109363, + "receipt_raw_sha256": "ed54e928ba5278c58db459a3c69de1cc6c59070f384e254c518d67fff66f31dd", + "schema": "c09_cubic_validation.v1", + "scope": "Finite exact fixtures and complete historical typed receipts; universal bounds are written proofs." +} diff --git a/research/cubic-scalar-caller-bounds/cubic/check.py b/research/cubic-scalar-caller-bounds/cubic/check.py new file mode 100644 index 0000000000..d162dd6213 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/check.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +"""Exact full-cubic scalar word and pure-layer obstruction certificates. + +Apache-2.0; substantial OpenAI Codex assistance. No native caller is claimed. +""" +import argparse +from fractions import Fraction as F +import gzip +import hashlib +import json +from pathlib import Path +import sys +import types + +PINS={ + 'frozen/README.md':'aa52e6b495e6d65d963ba4334759f4a53883e0a9b2016c0aef4e678e04bf1f3c', + 'frozen/INDEPENDENT-REVIEW.md':'5eba8852555ebd888f82686b24aa130f36dad45c79edf551079117ceb6c2d100', + 'frozen/cubic_gate.py':'0747f9ca9a81b7c839b62ad867a0a93c0a2944b52b40436e3acc4ce91b6245fd', + 'frozen/wide_gate.py':'beaecc74e3ceb660a8f80f740c126588af0a07496c40b475bc12204c0c92d496', + 'frozen/CUBIC-FOUR-CALL-GATE.json':'2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029', + 'frozen/WIDE-MIXED-CUBIC-GATES.json':'9e034e5e7653c579a7cc9972884db5592bf34ab1de50a0225ff0efe40081aefa', +} +DISABLED=set() +class AuditError(ValueError): + def __init__(self,guard,witness=None):self.guard,self.witness=guard,witness;super().__init__(guard) +def need(test,guard,witness=None): + if not test and guard not in DISABLED:raise AuditError(guard,witness) +def sha(x):return hashlib.sha256(x).hexdigest() +def serial(x): + if isinstance(x,F):return str(x) + if isinstance(x,dict):return {str(k):serial(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [serial(v) for v in x] + return x +def typed(a,b): + if type(a) is not type(b):return False + if isinstance(a,dict):return a.keys()==b.keys() and all(typed(a[k],b[k]) for k in a) + if isinstance(a,list):return len(a)==len(b) and all(typed(x,y) for x,y in zip(a,b)) + return a==b +def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':')).encode() +def capture_module(name,raw): + m=types.ModuleType(name);m.__file__='';sys.modules[name]=m + exec(compile(raw,m.__file__,'exec',dont_inherit=True,optimize=0),m.__dict__) + return m + +def rejection(name,thunk,guard): + global DISABLED + try:thunk() + except AuditError as error: + need(error.guard==guard,'intended control guard: '+name,{'actual':error.guard,'expected':guard});witness=error.witness + else:raise AuditError('mutation unexpectedly accepted: '+name) + before=DISABLED + try: + DISABLED=before|{guard};thunk() + finally:DISABLED=before + return {'name':name,'guard':guard,'witness':witness,'named_guard_deleted':'ACCEPTED'} +def mismatch(A,B): + if len(A)!=len(B):return {'row_counts':[len(A),len(B)]} + for i,(a,b) in enumerate(zip(A,B)): + if len(a)!=len(b):return {'row':i,'column_counts':[len(a),len(b)]} + for j,(x,y) in enumerate(zip(a,b)): + if x!=y:return {'output_row':i,'input_column':j,'actual':serial(x),'expected':serial(y)} + return None +def equal(A,B,guard): + w=mismatch(A,B);need(w is None,guard,w) + +# Independent rational regular-action engine. Polynomial multiplication is +# realized as ordinary matrix multiplication, not the source convolution code. +def eye(n):return [[F(i==j) for j in range(n)] for i in range(n)] +def zeros(n,m):return [[F(0) for _ in range(m)] for _ in range(n)] +def mm(A,B):return [[sum(x*y for x,y in zip(row,col)) for col in zip(*B)] for row in A] +def plus(A,B):return [[x+y for x,y in zip(a,b)] for a,b in zip(A,B)] +def minus(A,B):return [[x-y for x,y in zip(a,b)] for a,b in zip(A,B)] +def inverse(A): + n=len(A);W=[list(map(F,row))+extra for row,extra in zip(A,eye(n))] + for j in range(n): + p=next((i for i in range(j,n) if W[i][j]),None);need(p is not None,'independent invertible scalar bridge') + W[j],W[p]=W[p],W[j];scale=W[j][j];W[j]=[x/scale for x in W[j]] + for i in range(n): + if i!=j: + scale=W[i][j];W[i]=[x-scale*y for x,y in zip(W[i],W[j])] + result=[row[n:] for row in W];equal(mm(A,result),eye(n),'independent exact scalar inverse');return result +def lift(poly): + n=len(poly);out=zeros(3*n,3*n) + for i,row in enumerate(poly): + for j,c in enumerate(row): + for a in range(3): + for b in range(3):out[3*i+a][3*j+b]=F(c[(a-b)%3]) + return out +def scalar_lift(A):return lift([[(F(x),F(0),F(0)) for x in row] for row in A]) +def raw_word(word): + W=eye(9);B=eye(3) + for event in word: + if event['op']=='FREE':C=[[F(x) for x in row] for row in event['matrix']];W=mm(scalar_lift(C),W);B=mm(C,B) + else: + i,j,s,e=event['dst'],event['src'],event['sign'],event.get('power',1) + need(i!=j and s in (-1,1) and e in (1,2),'declared actual paid cubic alphabet') + T=eye(9) + for b in range(3):T[3*i+(b+e)%3][3*j+b]+=s + W=mm(T,W);C=eye(3);C[i][j]+=s;B=mm(C,B) + return W,B,mm(scalar_lift(inverse(B)),W) +def accept_direction(g,D): + rank=g.coeff_span(D) + need(rank==1,'constant rational bank direction',{'coefficient_span_rank':rank}) +def accept_nilpotent(g,A): + rank=g.rankq(A);square=g.qmm(A,A) + need(rank==1 and square==zeros(3,3),'rank-one square-zero bank direction',{'rank':rank,'square':serial(square)}) +def regular_audit(g,report): + controls=[];fixtures=[] + for index,record in enumerate(report['normalization_fixtures']): + W,B,P=raw_word(record['word']);expected=lift(record['normalized_full_ring_matrix']) + equal(P,expected,'complete augmentation-normalized regular operator') + for A in record['constant_rank1_directions']: + A=[[F(x) for x in row] for row in A] + accept_nilpotent(g,A) + accept_direction(g,g.matsub(g.transvection(A),g.eye())) + controls.append(rejection('fixture'+str(index)+':omit_final_augmentation',lambda W=W,expected=expected:equal(W,expected,'complete augmentation-normalized regular operator'),'complete augmentation-normalized regular operator')) + wrong=json.loads(json.dumps(record['word'])) + first=next(e for e in wrong if e['op']=='PAID');first['power']=3-first.get('power',1) + wrongP=raw_word(wrong)[2] + controls.append(rejection('fixture'+str(index)+':change_query_power',lambda wrongP=wrongP,expected=expected:equal(wrongP,expected,'complete augmentation-normalized regular operator'),'complete augmentation-normalized regular operator')) + fixtures.append({'ordinary_rational_columns':9,'augmentation':B,'raw_regular_operator':W,'normalized_regular_operator':P}) + target=lift([[g.N if i==j else g.Z for j in range(3)] for i in range(3)]) + polyword=report['controls']['excluded_N_dependent_four_factor_word'];word=[lift(T) for T in polyword] + def product(factors): + P=eye(9) + for T in factors:P=mm(T,P) + return P + P=product(word);equal(P,target,'complete full-cubic target on all columns') + literal_inverse=[minus(eye(9),minus(T,eye(9))) for T in reversed(word)] + equal(mm(product(literal_inverse),P),eye(9),'literal inverse on all regular columns') + for j in range(4): + omitted=product(word[:j]+word[j+1:]) + controls.append(rejection('excluded_word_omit_factor'+str(j),lambda omitted=omitted:equal(omitted,target,'complete full-cubic target on all columns'),'complete full-cubic target on all columns')) + D=g.matsub([[tuple(map(F,c)) for c in row] for row in polyword[j]],g.eye()) + controls.append(rejection('operator_dependent_direction'+str(j),lambda D=D:accept_direction(g,D),'constant rational bank direction')) + bad=(F(1),F(2),F(1));badmatrix=lift([[bad if i==j else g.Z for j in range(3)] for i in range(3)]) + controls.append(rejection('omit_eigenvalue_one_component',lambda:equal(badmatrix,target,'complete full-cubic target on all columns'),'complete full-cubic target on all columns')) + controls.append(rejection('replace_paid_direction_by_identity',lambda:accept_nilpotent(g,eye(3)),'rank-one square-zero bank direction')) + return {'basis_order':'bank0*(1,N,N2), bank1*(1,N,N2), bank2*(1,N,N2)','normalization_fixtures':fixtures,'excluded_operator_dependent_word':word,'excluded_word_full_operator':P,'excluded_word_literal_inverse':product(literal_inverse),'primitive_only_false_target_regular_operator':badmatrix,'primitive_only_false_target_augmentation':4,'controls':controls} + +# This fresh finite stage exposes all coefficient matrices rather than +# inferring a central solution from intentionally noncentral fixtures. +def field_audit(w): + controls=[];n,k=3,5 + uc=[[F(0) for _ in range(k)] for _ in range(n)];vr=[[F(0) for _ in range(n)] for _ in range(k)] + for h in range(k): + j=h%n;uc[j][h]=1;uc[(j+1)%n][h]=h+1;vr[h][(j+2)%n]=F((-1)**h) + U,V=w.const(uc),w.const(vr);B=w.mm(V,U);L=[[B[i][j] if i>j else w.Z for j in range(k)] for i in range(k)];up=[[B[i][j] if i0 and k>0 and s>0 and k<=s*(n//2),'matching-layer invoice domain') + H={1:8*k,2:40*k,3:16*k,5:12*(n*s-2*k)};m=2+5*s;stock=12*n + mass=sum(r*c for r,c in H.items());need(m*stock-mass==24*n-16*k,'complete optimistic invoice identity') + return {'n':n,'k':k,'layers':s,'m':m,'W':stock,'H':H,'mass':mass,'D':m*stock-mass} +def accept_invoice(actual,expected):need(actual==expected,'all inactive-bank idle charges',{'actual':actual,'expected':expected}) +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--inputs',type=Path,default=Path(__file__).resolve().parent);ap.add_argument('--output',type=Path,required=True);a=ap.parse_args() + need(a.output.is_absolute(),'absolute output required') + for parent in (Path(__file__).resolve().parent,a.inputs.resolve()):need(not a.output.resolve().is_relative_to(parent),'external output required') + need(not a.output.exists() and not a.output.is_symlink(),'new output required') + raw={p:(a.inputs/p).read_bytes() for p in PINS};need({p:sha(v) for p,v in raw.items()}==PINS,'authenticated captured source bytes') + g=capture_module('c09_frozen_cubic',raw['frozen/cubic_gate.py']);w=capture_module('c09_frozen_wide',raw['frozen/wide_gate.py']) + oldc=json.loads(json.dumps(g.receipt()));oldw=json.loads(json.dumps(w.receipt())) + need(typed(oldc,json.loads(raw['frozen/CUBIC-FOUR-CALL-GATE.json'])),'complete typed historical cubic receipt') + need(typed(oldw,json.loads(raw['frozen/WIDE-MIXED-CUBIC-GATES.json'])),'complete typed historical wide receipt') + regular=regular_audit(g,oldc);field=field_audit(w) + invoices=[invoice(*x) for x in [(3,5,5),(6,9,4),(9,13,4)]] + H=invoices[0]['H'];accept_invoice(H,invoice(3,5,5)['H']);wrong=dict(H);wrong[5]=0 + controls=regular['controls']+field['controls']+[rejection('omit_all_idle_banks',lambda:accept_invoice(wrong,H),'all inactive-bank idle charges')] + balances=[] + for n in (3,6,9,12,24,48): + k=n+(n+3)//3;r=k-n + balances.append({'n':n,'minimum_mixed_k':k,'r':r,'each_power_count_minimum':max(0,k-2*r),'each_power_count_maximum':min(k,2*r),'homogeneous_k_minimum':2*n,'determinant_requires_multiple_of_three':True}) + result={'schema':'c09_cubic_scalar_gates.v1','status':'PASS_FULL_CUBIC_SCALAR_WORD_AND_PURE_LAYER_OBSTRUCTIONS','scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','checker_sha256':sha(Path(__file__).read_bytes()),'input_sha256':PINS,'complete_historical_receipts':{'cubic':oldc,'wide':oldw},'independent_full_regular_action':regular,'fresh_cyclotomic_coefficient_certificates':field,'conditional_complete_optimistic_invoices':invoices,'alphabet_balance_corollary':balances,'production_controls':controls,'actual_semantic_rejections':len(controls),'executed_named_guard_deletions':len(controls),'source_execution':{'unchanged_captured_modules':['cubic_gate.py','wide_gate.py'],'optimize':0,'receipt_functions_replayed_completely':True},'limits':['The theorem concerns identity in full Q[N]/(N^3-1), not any fixed nonfaithful operator representation.','n3 arbitrary-polynomial coefficient bound and wide mixed N/N2 bounds have different alphabets.','Four pure layers are excluded; four internally mixed layers are not excluded here.','Finite exact fixtures validate identities and controls, not the all-word quantifiers.','No positive scalar synthesis, native frame admission, source-code transport, owner stock, precision, physical runtime or new kappa claim.','Quadratic continuation is preserved only as historical context and is outside this contribution.']} + encoded=(json.dumps(serial(result),sort_keys=True,indent=2)+'\n').encode() + if a.output.suffix=='.gz':encoded=gzip.compress(encoded,mtime=0) + with a.output.open('xb') as f:f.write(encoded) + print(json.dumps({'status':result['status'],'controls':len(controls),'sha256':sha(encoded)},sort_keys=True)) +if __name__=='__main__':main() diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/CUBIC-FOUR-CALL-GATE.json b/research/cubic-scalar-caller-bounds/cubic/frozen/CUBIC-FOUR-CALL-GATE.json new file mode 100644 index 0000000000..64a25779a9 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/CUBIC-FOUR-CALL-GATE.json @@ -0,0 +1,986 @@ +{ + "attribution": "Stabilizer lane supplies the actual common2 order3 Clifford lead and owns its native diagonal-code binding. This lane proves the scalar query lower bound and complete favorable mass gate independently of that native construction.", + "coefficient_ring": "Z[N]/(N^3-1); rational constants are allowed in the lower-bound relaxation. No primitive-component equality is promoted to a full-ring equality.", + "controls": { + "each_direction_coefficient_span_rank": [ + 2, + 2, + 2, + 2 + ], + "excluded_N_dependent_four_factor_word": [ + [ + [ + [ + "1", + "0", + "0" + ], + [ + "-1", + "0", + "1" + ], + [ + "0", + "1", + "-1" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ] + ] + ], + [ + [ + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "1", + "-1", + "0" + ], + [ + "1", + "0", + "0" + ], + [ + "-1", + "0", + "1" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ] + ] + ], + [ + [ + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "1", + "-1" + ], + [ + "1", + "-1", + "0" + ], + [ + "1", + "0", + "0" + ] + ] + ], + [ + [ + [ + "2", + "0", + "-1" + ], + [ + "0", + "-1", + "1" + ], + [ + "-1", + "1", + "0" + ] + ], + [ + [ + "1", + "0", + "-1" + ], + [ + "1", + "-1", + "1" + ], + [ + "-1", + "1", + "0" + ] + ], + [ + [ + "1", + "0", + "-1" + ], + [ + "0", + "-1", + "1" + ], + [ + "0", + "1", + "0" + ] + ] + ] + ], + "fake_rank3_one_call_rejected": true, + "full_ring_inverse_all3_inputs": true, + "primitive_only_false_identity": { + "actual_polynomial": [ + "1", + "2", + "1" + ], + "augmentation": "4" + } + }, + "coverage": "Written all-word proof; no finite covering/search claim. Normalization and controls are finite exact cubic-ring matrix certificates on all three independent columns.", + "five_call_favorable_invoice": { + "D": -8, + "H": { + "1": 40, + "2": 200, + "3": 80, + "5": 60 + }, + "W": 36, + "all_positive_exponent_verdict": "FAIL: already mass>mW at exponent0; every positive contracting-child moment is larger.", + "banks": 3, + "calls": 5, + "formula": "For k calls and3 banks, m=2+5k,W=36,H1=8k,H2=40k,H3=16k,H5=12k. Every call uses two banks; the third takes its fresh5 idle. D=72-16k.", + "m": 27, + "mass": 980, + "optimistic_assumptions": "Source diagonal code, native gauge, private/owner, scalar/address, precision and tape costs all omitted favorably. No native admission is inferred.", + "public_ports_per_bank": 12, + "stock_rank_mass": 972 + }, + "independent_review": { + "outcome": "PASS", + "reviewer": "/root/stabilizer_escape_1019", + "scope": "Written cyclic-rotation, independent-direction, multiplication-order and principal-minor proof, including mixed N/N^2; no native-bank-code claim. See INDEPENDENT-REVIEW.md." + }, + "model": "Three arbitrary input fields; paid one-direction shears Eij(+-N) or Eij(+-N^2); any explicit constant scalar GL3(Q) bridges, ADDs, swaps and signs. Eij(N^e-1) for e=1,2 is included by a free inverse ADD. A final constant bank permutation is allowed. No bank-direction vector may depend on N.", + "no_new_kappa": true, + "normal_form": "Normalize the complete word by its N=1 constant value. Every query becomes I+(N^e-1)u_i v_i^T, e=1 or2, with constant rational u_i,v_i and v_i^T u_i=0. The normal-form fixture checks use the full cubic ring. The written proof further allows arbitrary scalar-polynomial coefficients with constant bank directions.", + "normalization_fixtures": [ + { + "augmentation": [ + [ + "1", + "1", + "0" + ], + [ + "0", + "1", + "0" + ], + [ + "0", + "0", + "1" + ] + ], + "constant_rank1_directions": [ + [ + [ + "0", + "1", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ] + ], + "normalized_full_ring_matrix": [ + [ + [ + "1", + "0", + "0" + ], + [ + "-1", + "1", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ] + ] + ], + "paid_calls": 1, + "word": [ + { + "dst": 0, + "op": "PAID", + "sign": 1, + "src": 1 + } + ] + }, + { + "augmentation": [ + [ + "0", + "1", + "1" + ], + [ + "1", + "1", + "-1" + ], + [ + "1", + "1", + "-2" + ] + ], + "constant_rank1_directions": [ + [ + [ + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "-2", + "-2", + "2" + ], + [ + "1", + "1", + "-1" + ], + [ + "-1", + "-1", + "1" + ] + ] + ], + "normalized_full_ring_matrix": [ + [ + [ + "3", + "-2", + "0" + ], + [ + "2", + "-2", + "0" + ], + [ + "1", + "-3", + "2" + ] + ], + [ + [ + "-1", + "1", + "0" + ], + [ + "0", + "1", + "0" + ], + [ + "0", + "1", + "-1" + ] + ], + [ + [ + "1", + "-1", + "0" + ], + [ + "1", + "-1", + "0" + ], + [ + "1", + "-1", + "1" + ] + ] + ], + "paid_calls": 2, + "word": [ + { + "matrix": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "op": "FREE" + }, + { + "dst": 0, + "op": "PAID", + "sign": -1, + "src": 2 + }, + { + "matrix": [ + [ + 0, + 1, + 0 + ], + [ + 1, + 0, + 0 + ], + [ + 0, + 0, + -1 + ] + ], + "op": "FREE" + }, + { + "dst": 2, + "op": "PAID", + "sign": 1, + "src": 1 + } + ] + }, + { + "augmentation": [ + [ + "5", + "2", + "0" + ], + [ + "2", + "1", + "0" + ], + [ + "4", + "2", + "1" + ] + ], + "constant_rank1_directions": [ + [ + [ + "0", + "0", + "0" + ], + [ + "1", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "-1" + ], + [ + "0", + "0", + "2" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ], + [ + "2", + "1", + "0" + ] + ], + [ + [ + "2", + "1", + "0" + ], + [ + "-4", + "-2", + "0" + ], + [ + "0", + "0", + "0" + ] + ] + ], + "normalized_full_ring_matrix": [ + [ + [ + "0", + "0", + "1" + ], + [ + "-1", + "1", + "0" + ], + [ + "1", + "-1", + "0" + ] + ], + [ + [ + "1", + "1", + "-2" + ], + [ + "3", + "-2", + "0" + ], + [ + "-2", + "2", + "0" + ] + ], + [ + [ + "-1", + "0", + "1" + ], + [ + "-1", + "1", + "0" + ], + [ + "1", + "0", + "0" + ] + ] + ], + "paid_calls": 4, + "word": [ + { + "dst": 1, + "op": "PAID", + "sign": 1, + "src": 0 + }, + { + "matrix": [ + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 0 + ], + [ + 0, + 0, + 1 + ] + ], + "op": "FREE" + }, + { + "dst": 0, + "op": "PAID", + "sign": -1, + "src": 2 + }, + { + "matrix": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 0 + ], + [ + 0, + 1, + 1 + ] + ], + "op": "FREE" + }, + { + "dst": 2, + "op": "PAID", + "sign": 1, + "src": 1 + }, + { + "dst": 0, + "op": "PAID", + "sign": 1, + "src": 1 + } + ] + }, + { + "augmentation": [ + [ + "2", + "4", + "-1" + ], + [ + "0", + "1", + "2" + ], + [ + "1", + "1", + "-2" + ] + ], + "constant_rank1_directions": [ + [ + [ + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0" + ], + [ + "0", + "0", + "0" + ] + ], + [ + [ + "-2", + "-2", + "2" + ], + [ + "1", + "1", + "-1" + ], + [ + "-1", + "-1", + "1" + ] + ], + [ + [ + "-4", + "-8", + "0" + ], + [ + "2", + "4", + "0" + ], + [ + "-1", + "-2", + "0" + ] + ], + [ + [ + "-7", + "-7", + "14" + ], + [ + "3", + "3", + "-6" + ], + [ + "-2", + "-2", + "4" + ] + ] + ], + "normalized_full_ring_matrix": [ + [ + [ + "7", + "5", + "-11" + ], + [ + "10", + "5", + "-15" + ], + [ + "-7", + "18", + "-11" + ] + ], + [ + [ + "-3", + "-2", + "5" + ], + [ + "-4", + "-2", + "7" + ], + [ + "3", + "-8", + "5" + ] + ], + [ + [ + "2", + "1", + "-3" + ], + [ + "3", + "1", + "-4" + ], + [ + "-1", + "5", + "-3" + ] + ] + ], + "paid_calls": 4, + "word": [ + { + "matrix": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "op": "FREE" + }, + { + "dst": 0, + "op": "PAID", + "power": 2, + "sign": -1, + "src": 2 + }, + { + "matrix": [ + [ + 0, + 1, + 0 + ], + [ + 1, + 0, + 0 + ], + [ + 0, + 0, + -1 + ] + ], + "op": "FREE" + }, + { + "dst": 2, + "op": "PAID", + "power": 1, + "sign": 1, + "src": 1 + }, + { + "matrix": [ + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 0 + ], + [ + 0, + 0, + 1 + ] + ], + "op": "FREE" + }, + { + "dst": 0, + "op": "PAID", + "power": 2, + "sign": 1, + "src": 1 + }, + { + "dst": 1, + "op": "PAID", + "power": 1, + "sign": -1, + "src": 2 + } + ] + } + ], + "proof": [ + "Specialize a putative full-ring identity to a primitive cubic root zeta. Target zeta I3 has rank(target-I)=3, so the query column directions span Q^3.", + "For at most four factors, pad identities if necessary. Some three directions are independent and form a cyclic consecutive triple. Since the target is central and all factors invertible, cyclically rotate the application order so these are the first three.", + "Conjugate their constant rational directions to e1,e2,e3. The product P=C3 C2 C1 has P11=1 and leading principal2x2 determinant1: each factor changes only its own row and has diagonal pivot1.", + "The fourth inverse gives P=zeta(I-alpha u v^T), with u,v constant rational. Thus alpha c1=1-zeta^-1 and alpha(c1+c2)=1-zeta^-2, where c_i=u_i v_i are rational.", + "The ratio (c1+c2)/c1=(1-zeta^-2)/(1-zeta^-1)=-zeta is irrational, a contradiction. For the requested common coefficient alpha=zeta-1, the first equation alone already forces c1=zeta^-1.", + "The same principal-minor ratio excludes four calls even if each query may use a scalar polynomial in N, including mixtures of N and N^2, as long as its bank direction remains constant. Operator-dependent directions are outside the theorem." + ], + "remaining": [ + "A native/operator-dependent bank-direction word with its actual paid cost is outside this scalar model.", + "More than3 public banks changes determinant, stock, arity and clearing constraints and requires a new complete invoice.", + "No five-call synthesis is needed for this three-bank route because the favorable five-call mass already fails." + ], + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "PASS_FOUR_QUERY_CUBIC_CONSTANT_DIRECTION_OBSTRUCTION" +} diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/INDEPENDENT-REVIEW.md b/research/cubic-scalar-caller-bounds/cubic/frozen/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..04b28495af --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/INDEPENDENT-REVIEW.md @@ -0,0 +1,37 @@ +# Independent mathematical review + +Reviewer: `/root/stabilizer_escape_1019`, separate live specialist lane. +Review received in the same original research round. This records mathematical +review, not a formal-kernel proof or hosted check. + +For the three-bank principal-minor proof, the reviewer checked that a central +target permits cyclic rotation, that every three-subset of four cyclic factors +is consecutive, and that the rank test supplies an independent rational +three-subset. The reviewer confirmed the row order in `C_3 C_2 C_1`, both +principal minors, and the irrational ratio `-ζ`. The review explicitly includes +mixed `N/N^2` and any scalar-polynomial coefficient with constant directions. +It makes no assertion about commutation of actual native bank codes. + +For the general mixed-alphabet bound, the reviewer strengthened the displayed +rank estimate to an equality: `GVU/t` is a rank-`n` projection, hence +`rank(B-tG^-1)=k-n`. The reviewer checked that equality `k=4r` forces both +coefficient matrices to have the same joint row and column spaces, that zero +is semisimple when rank equals the nonzero diagonal multiplicity, and that +the two spectral projections then contradict their complementary diagonals. + +The reviewer also passed the three-layer trace gate: square-zero layer +perturbations give `tr P=tr P^-1`, whereas the central target would force +`nζ=nζ^-1`. + +The four-pure-layer coefficient argument was sent for independent review +separately. Its current review status is recorded when the package freezes. + +For the quadratic continuation, the reviewer independently passed the +all-word optimality proof. Pulling scalar bridges left gives `W=iB`, with `B` +real invertible. The reviewer checked +`G+conj(G)=G(conj(G)^-1+G^-1)conj(G)=-2GLconj(G)`, the consequence +`UGLconj(G)V=I_n`, and `n<=rank L<=k-1`. The odd-bank determinant obstruction +also passes. This proof uses no augmentation and omits no eigencomponent. + +The reviewer retained the actual native bent-query source-code deposits as a +separate unresolved model. They are outside these ideal scalar-layer premises. diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/README.md b/research/cubic-scalar-caller-bounds/cubic/frozen/README.md new file mode 100644 index 0000000000..80afe8b39c --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/README.md @@ -0,0 +1,302 @@ +# Cubic caller: constant scalar bank directions + +The positive quadratic continuation is in [QUADRATIC.md](QUADRATIC.md): an exact n+1-query scalar caller for every even n when N^2=-I, with native source-code transport still open. + +This package also proves scoped lower bounds for a proposed exact common operator +`N` with `N^3=I`, over characteristic zero. There is no positive caller or new +κ claim. The actual rank-two Clifford lead and its native source-code deposits +belong to the stabilizer lane. None of the scalar arguments removes those +deposits or changes their charge. + +The scientific checkout pin is +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`. This is local work in the originally +clocked round `kappa-changed-endpoints-20261019T0153Z`. The primary checkout and +the predecessor `mixed-carrier-caller/` and `coded-bit-boundary/` packages are +not modified. + +The written results are: + +* Three banks require at least five paid queries, even if the coefficient of + each rank-one query is any scalar polynomial in `N`, provided its bank + direction is constant rational. +* In `n` banks, using the actual mixed alphabet `E_ij(±N)` and `E_ij(±N^2)` with + arbitrary constant rational scalar bridges requires + `k >= n + ceil((n+1)/3)` paid queries. +* Three matching layers cannot give `N I_n`, even before restricting the + directions to be rational. +* Four layers cannot give `N I_n` if every layer is pure: its nonconstant + coefficient is all `N-1` or all `N^2-1`. A layer mixing both coefficients is + outside this last obstruction. + +These are all-word written proofs. The scripts supply exact finite identity +checks and negative controls; they are not exhaustive searches or kernel +formalizations. The independent review is recorded in +[INDEPENDENT-REVIEW.md](INDEPENDENT-REVIEW.md). + +## Exact model and normalization + +All `n` public inputs are independent. The desired word equals `N I_n`, or a +constant bank permutation times `N I_n`, over the **full** ring +`Q[N]/(N^3-1)`. A positive construction would therefore have to retain the +eigenvalue-one component. Allowing rational constants relaxes the requested +integer scalar bridge model, so a lower bound in this model also holds for +constant integral ADD/swap/sign words. + +A paid query is `E_ij(s N^e)`, `i != j`, `s=±1`, `e=1 or 2`. Constant +`GL_n(Q)` operations may appear anywhere between paid queries. Normalize a +word `W(N)` by its full augmentation `B=W(1)`: `B^-1 W(N)`. If the word achieves +the desired output, this normalization gives `N I_n`, including when the +original target has a final bank permutation. Pulling the constant operations +through one query yields + +``` +I + (N^e-1) u_i v_i^T, +u_i,v_i in Q^n, v_i^T u_i=0. +``` + +The sign is absorbed into either vector. For example, immediately before a +query the augmentation is `B_0`; its normalized direction is +`s B_0^-1 e_i e_j^T B_0`. The updated augmentation is +`E_ij(s) B_0`. This proves the normal form for arbitrary bridges, without a +commutation assumption. The saved fixtures check this statement on the full +cubic ring for both query powers. + +Every factor has the literal inverse obtained by negating its nilpotent +perturbation. Its determinant is one. Thus `3 | n` is a further necessary +condition for the target, independent of the lower bounds below. + +A full-ring identity necessarily holds after the specialization `N=ζ`, where +`ζ^2+ζ+1=0`. The lower bounds may use this necessary condition. They do not +infer a positive full-ring identity from a primitive-component identity. + +## Three banks, four queries: arbitrary polynomial coefficients + +Suppose `C_4 C_3 C_2 C_1 = ζ I_3`, where +`C_i=I+α_i u_i v_i^T`, the direction vectors are rational, and `v_i^T u_i=0`. +Here `α_i` may be any element of `Q(ζ)`; in particular the proof includes +mixed `ζ-1` and `ζ^2-1` queries. + +The image of the product minus identity is contained in the span of the four +column directions. Since `ζ I_3-I_3` has rank three, some three of them are +independent over `Q`. Any three-element subset of four cyclic positions is +consecutive in cyclic order. Cyclically rotating invertible factors preserves +a central product: if `AB=ζI`, then `BA=A^-1(AB)A=ζI`. Rotate the application +order so that the independent directions occur first. A constant rational +change of basis then makes those directions `e_1,e_2,e_3` respectively. + +Set `P=C_3 C_2 C_1`, with factors acting from right to left. `C_1` changes only +row one and has first diagonal entry one. `C_2` changes only row two and has +second diagonal entry one. `C_3` changes only row three. Consequently + +``` +P_11=1, det P[{1,2},{1,2}]=1. +``` + +For clarity, before row three is changed the leading block is +`[[1,a],[b,1+ab]]`; its determinant is one regardless of the other entries. +But `P=ζ C_4^-1=ζ(I-α_4 u v^T)`. Write `c_i=u_i v_i`, which is rational. The +two principal minors force + +``` +α_4 c_1 = 1-ζ^-1, +α_4(c_1+c_2) = 1-ζ^-2. +``` + +The first right side is nonzero. Taking the ratio gives +`(c_1+c_2)/c_1 = -ζ`, contradicting rationality. This also covers three factors +by padding an identity; fewer than three already fail the image-rank test. + +The constant-direction hypothesis is essential. `cubic_gate.py` checks an +explicit four-factor identity `N I_3` on the full cubic ring whose directions +depend on `N`. It checks all three independent columns and the literal +inverse, and verifies that each perturbation has coefficient-span dimension +greater than one, so it is outside the one-query constant-direction model. +Another negative control agrees with `N` at primitive roots but has value four +at `N=1`; the full-ring checker rejects it. + +## General mixed-alphabet rank bound + +Let `k` queries act on `n` banks, and specialize to `N=ζ`. Put `t=ζ-1` and +`t_2=ζ^2-1`. The normalized factors are +`I+α_i u_i v_i^T`, `α_i in {t,t_2}`. All vector entries are rational. Define + +``` +U=[u_1 ... u_k], V=[v_1^T; ...; v_k^T], +B=VU, D=diag(α_1,...,α_k), +B=L_0+U_0, G=(D^-1-L_0)^-1, +``` + +where `L_0,U_0` are the strict lower and upper triangular parts of `B`. +The diagonal of `B` vanishes. Expanding in chronological order gives the exact +resolvent identity + +``` +W = I + U G V. +``` + +For the desired central target, `UGV=tI_n`, so `U,V` both have rank `n` and +`k>=n`. Moreover `G V U/t` is a rank-`n` idempotent. It follows that + +``` +C = B-tG^-1 = U_0+ζL_0-diag(t/α_i) +``` + +has rank exactly `r=k-n` over `Q(ζ)`. The identities +`t/t=1` and `t/t_2=-ζ` give `C=A+ζH`, with rational matrices + +``` +A=U_0-diag(1 on N-query positions), +H=L_0+diag(1 on N^2-query positions). +``` + +Thus `A` is upper triangular, `H` is lower triangular, and their nonzero +diagonal supports partition all `k` positions. Complex conjugation preserves +the rank of `C`. Each of `A,H` is a linear combination of `C` and its conjugate, +so each has rank at most `2r`. If there are `a` first-power and `b` second-power +queries, their triangular principal minors give + +``` +a<=rank A<=2r, b<=rank H<=2r, k=a+b<=4r. +``` + +Equality `k=4r` is impossible. It would force both `A,H` to have rank `2r` and +to share the joint row space and the joint column space of `C` and its +conjugate; each joint space has dimension at most `2r`. Hence `A,H` have the +same image and kernel. Their ranks equal their nonzero-diagonal counts, so +zero is a semisimple eigenvalue of each. The unique projection onto the image +along the kernel is + +``` +P_A=I-(I+A)^k, P_H=I-(I-H)^k. +``` + +The formulas annihilate the generalized nonzero eigenspaces and preserve the +zero eigenspaces before subtraction from identity; the exponent `k` suffices +for every possible Jordan block. Both therefore have the same image and +kernel, and uniqueness gives `P_A=P_H`. But their diagonals are respectively +the indicator of first-power positions and its complement, an immediate +contradiction. This proves + +``` +k < 4(k-n), k >= n+ceil((n+1)/3). +``` + +The separate inequalities `a,b<=2(k-n)` are also useful for any prescribed +alphabet balance. In particular, a homogeneous alphabet requires `k>=2n`. +This general theorem is narrower than the three-bank theorem: unrelated +polynomial query coefficients need not have the displayed complementary +triangular split. + +| Banks `n` | Necessary calls `k` | Favorable mass deficit `24n-16k` | +|---:|---:|---:| +| 3 | 5 | -8 | +| 6 | 9 | 0 | +| 9 | 13 | 8 | +| 12 | 17 | 16 | +| 24 | 33 | 48 | +| 48 | 65 | 112 | + +In particular, six-bank/eight-call and nine-bank/eleven-call proposals fail +before any native bank-code transport is considered. Four-layer wider models +are not eliminated merely by this table. + +## Three matching layers + +Assume a layer consists of disjoint pair queries, and scalar bridges occur +only between complete layers. All pair perturbations within a layer annihilate +one another in both orders. The augmented-normalized layer is `I+A_l` with +`A_l^2=0`, also when its pair queries mix the two powers. Constant conjugation +by a bridge preserves this square-zero property. + +For `P=(I+A_2)(I+A_1)`, direct multiplication gives + +``` +tr P = n+tr(A_2 A_1) = tr P^-1. +``` + +If `(I+A_3)P=ζI`, then `P=ζ(I-A_3)`, forcing the two traces to be `nζ` and +`nζ^-1`. They cannot agree in characteristic zero. This gate even allows +operator-dependent square-zero perturbations. It does not cover arbitrary +scalar mixing inside a nominal layer: that mixing may invalidate the +square-zero layer premise and the claimed reuse of a fresh block. + +## Four pure layers + +Suppose four normalized square-zero layers give `ζI`. For either adjacent pair +`P`, the complementary two-layer product is `ζP^-1`. Both products have equal +trace to their own inverse, so `(ζ-ζ^-1) tr P=0`, and `tr P=0`. + +If two neighboring layers have the same pure coefficient, their pair trace is +`n-3ζ s` or `n-3ζ^2 s` for rational `s`. Neither can vanish for positive `n`. +The layer types must therefore alternate. By cyclic rotation and generator +conjugation, write the putative word as + +``` +(I+t_2 D)(I+t C)(I+t_2 B)(I+t A) = ζI, +A^2=B^2=C^2=D^2=0, +``` + +with all four matrices rational. Compare the rational and `ζ` coefficients of +`(I+t_2D)(I+tC)=ζ(I-tA)(I-t_2B)`. Using `tt_2=3` gives + +``` +C-D = I+2A+B+3AB, +D(2A+B+3AB) = A+AB. +``` + +Multiply the second equation on the right by `B`: `2DAB=AB`. Applying `D` and +using `D^2=0` forces `DAB=0` and then `AB=0`. The first two-layer product now +has trace `n+3tr BA=n`, contradicting its required trace zero. This proves the +four-pure-layer obstruction for every positive `n`, without a rank assumption. + +The finite certificate checks both coefficient formulas and their explicit +target-defect remainder, rather than pretending an arbitrary fixture solves +the central target. Layers that mix `t` and `t_2` retain additional coefficient +matrices, so this proof does not apply to them. + +## Complete optimistic invoice and native scope + +For `n` banks of twelve independent fields and `k` OPEN calls in `s` legal +matching layers, the optimistic parameters are + +``` +W=12n, m=2+5s, +H_1=8k, H_2=40k, H_3=16k, +H_5=12(ns-2k), +mass=60ns+16k, D=mW-mass=24n-16k. +``` + +Every inactive bank at each layer pays a fresh-rank-five idle. This is the +per-layer invoice; adjacent idle blocks have not been coalesced. Nonnegative +`H_5` requires actual disjoint query pairs in each layer. A scalar bridge must +also have an actual native admission/charge before the optimistic invoice can +be promoted to a construction. + +For three banks and five sequential calls this is `m=27,W=36`, +`H={1:40,2:200,3:80,5:60}`, mass `980`, stock rank mass `972`, so `D=-8`. +It fails already at exponent zero; every positive exponent makes each +contracting-child contribution strictly larger. Source diagonal-code, +native-gauge, private/helper/owner, scalar/address, precision and tape costs +have all been omitted favorably. The six-bank lower bound gives `D=0`, also +failing every positive exponent irrespective of layering. + +The root lane owns the wider positive-exponent budget screen. The remaining +four-layer mixed-coefficient scalar problem is mathematically distinct from +actual supplier admission: even a factorization there would still require +source-code transport, full arbitrary-input native endpoints, restoration, +literal inverse and all added costs. + +## Reproduce + +From this directory run: + +``` +python3 cubic_gate.py +python3 -O cubic_gate.py +python3 wide_gate.py +python3 -O wide_gate.py +``` + +The scripts compare newly computed results to the saved JSON receipts; ordinary +readback does not overwrite them. `--write` explicitly regenerates a receipt. +No external package, network access, PR, hosted CI, or publication is involved. diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/WIDE-MIXED-CUBIC-GATES.json b/research/cubic-scalar-caller-bounds/cubic/frozen/WIDE-MIXED-CUBIC-GATES.json new file mode 100644 index 0000000000..f6c9dd9089 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/WIDE-MIXED-CUBIC-GATES.json @@ -0,0 +1,396 @@ +{ + "cases": [ + { + "favorable_mass_deficit_at_that_call_count": -8, + "minimum_calls_from_written_bound": 5, + "n": 3 + }, + { + "favorable_mass_deficit_at_that_call_count": 0, + "minimum_calls_from_written_bound": 9, + "n": 6 + }, + { + "favorable_mass_deficit_at_that_call_count": 8, + "minimum_calls_from_written_bound": 13, + "n": 9 + }, + { + "favorable_mass_deficit_at_that_call_count": 16, + "minimum_calls_from_written_bound": 17, + "n": 12 + }, + { + "favorable_mass_deficit_at_that_call_count": 48, + "minimum_calls_from_written_bound": 33, + "n": 24 + }, + { + "favorable_mass_deficit_at_that_call_count": 112, + "minimum_calls_from_written_bound": 65, + "n": 48 + } + ], + "coefficient_ring": "The proposed word must be valid over Z[N]/(N^3-1), or its rational extension. The lower bound uses the necessary specialization to Q(zeta). No positive primitive-component identity is promoted to a full-ring identity.", + "coverage": "Written all-word/all-n proofs, with finite exact identity and negative-control fixtures. No exhaustive search, formal-kernel proof, positive scalar caller, or native admission is claimed.", + "finite_identity_checks": [ + { + "coefficient_split": true, + "defect_identity": true, + "k": 5, + "n": 3, + "not_a_central_factorization": true, + "r_if_central": 2, + "rank_C": 5, + "rank_U": 3, + "rank_V": 3, + "resolvent_identity": true, + "target_defect_rank": 3, + "types": [ + 1, + 2, + 1, + 2, + 1 + ] + }, + { + "coefficient_split": true, + "defect_identity": true, + "k": 8, + "n": 6, + "not_a_central_factorization": true, + "r_if_central": 2, + "rank_C": 8, + "rank_U": 6, + "rank_V": 6, + "resolvent_identity": true, + "target_defect_rank": 6, + "types": [ + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2 + ] + }, + { + "coefficient_split": true, + "defect_identity": true, + "k": 11, + "n": 9, + "not_a_central_factorization": true, + "r_if_central": 2, + "rank_C": 11, + "rank_U": 9, + "rank_V": 9, + "resolvent_identity": true, + "target_defect_rank": 9, + "types": [ + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1 + ] + }, + { + "coefficient_split": true, + "defect_identity": true, + "k": 17, + "n": 12, + "not_a_central_factorization": true, + "r_if_central": 5, + "rank_C": 17, + "rank_U": 12, + "rank_V": 12, + "resolvent_identity": true, + "target_defect_rank": 12, + "types": [ + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1 + ] + } + ], + "four_pure_layer_gate": { + "proof": "Every adjacent two-layer product must have trace0. Equal-type neighboring layers have trace n-3*zeta*s or n-3*zeta^2*s with rational s, impossible. Types must alternate. Coefficient comparison gives D(2A+B+3AB)=A+AB; multiply right by B and use D^2=0 to force AB=0, contradicting the first pair trace0.", + "scope": "Mixed N and N^2 coefficients within a layer are outside this pure-layer argument.", + "statement": "No four layers, each entirely I+(zeta-1)A_l or entirely I+(zeta^2-1)A_l with rational A_l^2=0, multiply to zeta I_n for n>0." + }, + "general_bound": { + "statement": "k>=n+ceil((n+1)/3)", + "strict_rank_form": "For r=k-n, k<4r.", + "written_proof": "README.md, general interaction-matrix argument. Valid for every finite n and k in the stated model, not a search result." + }, + "independent_review": { + "four_pure_layer_gate": "See INDEPENDENT-REVIEW.md", + "general_rank_gate": "PASS", + "record": "INDEPENDENT-REVIEW.md", + "reviewer": "/root/stabilizer_escape_1019", + "three_layer_trace_gate": "PASS" + }, + "layer_controls": [ + { + "central_target_forced_trace_difference": [ + "3", + "6" + ], + "layer_squarezero_ranks": [ + 1, + 1, + 1 + ], + "n": 3, + "trace_inverse_two_layers": [ + "0", + "0" + ], + "trace_two_layers": [ + "0", + "0" + ] + }, + { + "central_target_forced_trace_difference": [ + "6", + "12" + ], + "layer_squarezero_ranks": [ + 3, + 3, + 3 + ], + "n": 6, + "trace_inverse_two_layers": [ + "0", + "3" + ], + "trace_two_layers": [ + "0", + "3" + ] + }, + { + "central_target_forced_trace_difference": [ + "12", + "24" + ], + "layer_squarezero_ranks": [ + 6, + 6, + 6 + ], + "n": 12, + "trace_inverse_two_layers": [ + "0", + "6" + ], + "trace_two_layers": [ + "0", + "6" + ] + } + ], + "model": "n independent banks; each paid query is Eij(+-N) or Eij(+-N^2); constant rational GL_n bridges are free. Equivalently normalized directions u_i,v_i are constant rational and v_i^T u_i=0. Arbitrary operator-dependent directions, or unrelated polynomial query coefficients, are outside this wide bound.", + "no_new_kappa": true, + "projection_control": { + "complementary_diagonals": true, + "lower_projection": [ + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "2", + "0" + ], + [ + "1", + "0" + ] + ] + ], + "upper_projection": [ + [ + [ + "1", + "0" + ], + [ + "-2", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "-3", + "0" + ] + ], + [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + ], + "warning": "This fixture does not assert equal row/column spaces. Their equality is the contradictory hypothesis in the written all-word proof." + }, + "pure_four_layer_control": { + "coefficient_identity": true, + "forced_hypothetical_relation": "If target defect vanishes, D(2A+B+3AB)=A+AB, so 2DAB=AB; D^2=0 forces AB=0.", + "n": 3, + "pure_coefficients_in_application_order": [ + "N-1", + "N^2-1", + "N-1", + "N^2-1" + ], + "target_defect_omission_rejected": true, + "warning": "The finite fixture does not solve the target. It checks the algebra used in the written all-n obstruction." + }, + "remaining": [ + "Four matching layers with mixed N/N^2 coefficients inside a layer are not excluded by these gates.", + "A four-layer construction must still give every bank its full native endpoint, source-code transport, literal inverse and complete scalar/native/idle invoice." + ], + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "PASS_WRITTEN_WIDE_MIXED_CUBIC_RANK_AND_THREE_LAYER_GATES", + "three_matching_layer_gate": { + "proof": "For P=(I+A2)(I+A1), tr(P)=tr(P^-1). The target gives P=zeta(I-A3), hence tr(P)=n*zeta and tr(P^-1)=n*zeta^-1, a contradiction.", + "scope": "Constant scalar bridges may occur between layers. Arbitrary mixing inside a nominal layer is outside the squarezero-layer premise unless that premise is separately proved.", + "statement": "No three normalized layers I+A_l with A_l^2=0 can multiply to zeta I_n in characteristic0." + } +} diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/cubic_gate.py b/research/cubic-scalar-caller-bounds/cubic/frozen/cubic_gate.py new file mode 100644 index 0000000000..49d62f44f5 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/cubic_gate.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +"""Full cubic-ring checks for the written four-query constant-direction gate. + +No native lift is assumed. The exclusion is a written all-word proof; these +finite checks verify its normalization and deliberately excluded controls. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from fractions import Fraction as Q +from pathlib import Path +import argparse +import json +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +Z=(Q(0),)*3 +O=(Q(1),Q(0),Q(0)) +N=(Q(0),Q(1),Q(0)) +N2=(Q(0),Q(0),Q(1)) + +def need(b,m): + if not b:raise ValueError(m) +def plus(a,b):return tuple(x+y for x,y in zip(a,b)) +def neg(a):return tuple(-x for x in a) +def sub(a,b):return plus(a,neg(b)) +def scale(a,c):return tuple(c*x for x in a) +def mul(a,b):return tuple(sum(a[i]*b[j] for i in range(3) for j in range(3) if (i+j)%3==k) for k in range(3)) +def addall(xs): + a=Z + for x in xs:a=plus(a,x) + return a +def eye():return [[O if i==j else Z for j in range(3)] for i in range(3)] +def mm(a,b):return [[addall(mul(x,y) for x,y in zip(r,c)) for c in zip(*b)] for r in a] +def matplus(a,b):return [[plus(x,y) for x,y in zip(r,s)] for r,s in zip(a,b)] +def matsub(a,b):return [[sub(x,y) for x,y in zip(r,s)] for r,s in zip(a,b)] +def aug(a):return [[sum(x) for x in r] for r in a] +def qmm(a,b):return [[sum(x*y for x,y in zip(r,c)) for c in zip(*b)] for r in a] +def qeye():return [[Q(i==j) for j in range(3)] for i in range(3)] +def const(a):return [[(Q(x),Q(0),Q(0)) for x in r] for r in a] +def inv(a): + w=[list(map(Q,r))+[Q(i==j) for j in range(3)] for i,r in enumerate(a)] + for j in range(3): + p=next(i for i in range(j,3) if w[i][j]) + w[p],w[j]=w[j],w[p];c=w[j][j];w[j]=[x/c for x in w[j]] + for i in range(3): + if i!=j: + c=w[i][j];w[i]=[x-c*y for x,y in zip(w[i],w[j])] + need([r[:3] for r in w]==qeye(),'exact scalar inverse') + return [r[3:] for r in w] +def rankq(rows): + b={} + for r in rows: + r=list(map(Q,r)) + for k,v in sorted(b.items()): + c=r[k];r=[x-c*y for x,y in zip(r,v)] + k=next((k for k,x in enumerate(r) if x),None) + if k is not None:b[k]=[x/r[k] for x in r] + return len(b) +def shear(i,j,a): + e=eye();e[i][j]=plus(e[i][j],a);return e +def transvection(A,a=sub(N,O)): + return [[plus(O if i==j else Z,scale(a,A[i][j])) for j in range(3)] for i in range(3)] +def coeff_span(T): + return rankq([[T[i][j][k] for i in range(3) for j in range(3)] for k in range(3)]) +def serial(a):return [[[str(c) for c in x] for x in r] for r in a] + +def normal_form(word): + W=eye();B=qeye();P=eye();directions=[] + for g in word: + if g['op']=='FREE': + C=g['matrix'];W=mm(const(C),W);B=qmm(C,B) + else: + i,j,s,e=g['dst'],g['src'],g['sign'],g.get('power',1) + need(i!=j and s in(-1,1) and e in(1,2),'actual declared mixed paid shear') + gN=N if e==1 else N2 + W=mm(shear(i,j,scale(gN,s)),W) + A=[[Q(s*(a==i)*(b==j)) for b in range(3)] for a in range(3)] + A=qmm(qmm(inv(B),A),B) + need(rankq(A)==1 and qmm(A,A)==[[Q(0)]*3 for _ in range(3)],'constant rank1 nilpotent direction') + C=transvection(A,sub(gN,O)) + need(aug(C)==qeye(),'exact N1 augmentation of normalized query') + P=mm(C,P);directions.append(A) + E=qeye();E[i][j]+=s;B=qmm(E,B) + need(mm(const(inv(B)),W)==P,'full Z[N]/(N3-1) scalar-bridge normal form') + return {'paid_calls':len(directions),'word':word,'augmentation':[[str(x) for x in r] for r in B], + 'constant_rank1_directions':[[[str(x) for x in r] for r in A] for A in directions], + 'normalized_full_ring_matrix':serial(P)} + +def controls(): + # Four transvections do exist if their bank directions depend on N. This + # word is an excluded control, not four allowed Eij(+-N) queries. + t=sub(N,O) + vs=[(Z,neg(N2),neg(N)),(neg(O),Z,neg(N2)),(neg(N),neg(O),Z),(N2,N,O)] + us=[(1,0,0),(0,1,0),(0,0,1),(1,1,1)] + word=[];P=eye() + for u,v in zip(us,vs): + T=[[plus(O if i==j else Z,scale(mul(t,v[j]),u[i])) for j in range(3)] for i in range(3)] + D=matsub(T,eye()) + need(mm(D,D)==[[Z]*3 for _ in range(3)],'excluded control has literal unipotent inverse') + need(coeff_span(D)>1,'N-dependent direction control is outside a one-query constant-direction class') + P=mm(T,P);word.append(T) + goal=[[N if i==j else Z for j in range(3)] for i in range(3)] + need(P==goal,'excluded four-factor word checked on full cubic ring including eigen1') + for T in reversed(word):P=mm(matsub(eye(),matsub(T,eye())),P) + need(P==eye(),'literal inverse all three independent columns of excluded control') + # Primitive-root-only checking would miss this false full-ring equality. + bad=plus(N,plus(O,plus(N,N2))) + # a+bN+cN2 maps to (a-c)+(b-c)zeta. + prim=lambda x:(x[0]-x[2],x[1]-x[2]) + need(prim(bad)==prim(N) and bad!=N and sum(bad)==4,'eigen1 omission control rejected') + # Treating the whole bank I3 direction as a single paid shear would make + # N I3 cost1; it is neither rank1 nor nilpotent. + fake=qeye() + need(rankq(fake)==3 and qmm(fake,fake)!=[[Q(0)]*3 for _ in range(3)],'rank3 fake query rejected') + return {'excluded_N_dependent_four_factor_word':[serial(T) for T in word], + 'each_direction_coefficient_span_rank':[coeff_span(matsub(T,eye())) for T in word], + 'full_ring_inverse_all3_inputs':True,'primitive_only_false_identity':{'actual_polynomial':[str(x) for x in bad],'augmentation':str(sum(bad))}, + 'fake_rank3_one_call_rejected':True} + +def receipt(): + need(mul(N,N)==N2 and mul(N2,N)==O,'exact full cubic ring') + fixtures=[ + [{'op':'PAID','dst':0,'src':1,'sign':1}], + [{'op':'FREE','matrix':[[1,1,0],[0,1,1],[0,0,1]]}, + {'op':'PAID','dst':0,'src':2,'sign':-1}, + {'op':'FREE','matrix':[[0,1,0],[1,0,0],[0,0,-1]]}, + {'op':'PAID','dst':2,'src':1,'sign':1}], + [{'op':'PAID','dst':1,'src':0,'sign':1}, + {'op':'FREE','matrix':[[1,0,1],[1,1,0],[0,0,1]]}, + {'op':'PAID','dst':0,'src':2,'sign':-1}, + {'op':'FREE','matrix':[[1,1,0],[0,1,0],[0,1,1]]}, + {'op':'PAID','dst':2,'src':1,'sign':1}, + {'op':'PAID','dst':0,'src':1,'sign':1}]] + fixtures.append([ + {'op':'FREE','matrix':[[1,1,0],[0,1,1],[0,0,1]]}, + {'op':'PAID','dst':0,'src':2,'sign':-1,'power':2}, + {'op':'FREE','matrix':[[0,1,0],[1,0,0],[0,0,-1]]}, + {'op':'PAID','dst':2,'src':1,'sign':1,'power':1}, + {'op':'FREE','matrix':[[1,0,1],[1,1,0],[0,0,1]]}, + {'op':'PAID','dst':0,'src':1,'sign':1,'power':2}, + {'op':'PAID','dst':1,'src':2,'sign':-1,'power':1}]) + k=5;m=2+5*k;W=36;H={1:8*k,2:40*k,3:16*k,5:12*k} + mass=sum(r*n for r,n in H.items()) + need(m*W-mass==-8 and all(0mW at exponent0; every positive contracting-child moment is larger.', + 'optimistic_assumptions':'Source diagonal code, native gauge, private/owner, scalar/address, precision and tape costs all omitted favorably. No native admission is inferred.'}, + 'remaining':['A native/operator-dependent bank-direction word with its actual paid cost is outside this scalar model.', + 'More than3 public banks changes determinant, stock, arity and clearing constraints and requires a new complete invoice.', + 'No five-call synthesis is needed for this three-bank route because the favorable five-call mass already fails.'], + 'attribution':'Stabilizer lane supplies the actual common2 order3 Clifford lead and owns its native diagonal-code binding. This lane proves the scalar query lower bound and complete favorable mass gate independently of that native construction.'} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args() + out=receipt();out=json.loads(json.dumps(out)) + p=HERE/'CUBIC-FOUR-CALL-GATE.json' + if args.write:p.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(p.read_bytes())==out,'saved cubic gate differs') + print(out['status']) + print('All-word constant-direction lower bound5; full cubic-ring controls; favorable3bank5call D=-8.') + +if __name__=='__main__':main() diff --git a/research/cubic-scalar-caller-bounds/cubic/frozen/wide_gate.py b/research/cubic-scalar-caller-bounds/cubic/frozen/wide_gate.py new file mode 100644 index 0000000000..5cbac98027 --- /dev/null +++ b/research/cubic-scalar-caller-bounds/cubic/frozen/wide_gate.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Exact witnesses accompanying written mixed-cubic caller lower bounds. + +These are finite identity/negative-control checks, not an exhaustive search. +The all-n claims are proved in README.md. Apache-2.0; OpenAI Codex assistance. +""" +from fractions import Fraction as Q +from pathlib import Path +import argparse +import json +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +Z=(Q(0),Q(0));O=(Q(1),Q(0));N=(Q(0),Q(1)) +N2=(Q(-1),Q(-1)) + +def need(b,m): + if not b:raise ValueError(m) +def add(a,b):return (a[0]+b[0],a[1]+b[1]) +def neg(a):return (-a[0],-a[1]) +def sub(a,b):return add(a,neg(b)) +def mul(a,b): + return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]-a[1]*b[1]) +def conj(a):return (a[0]-a[1],-a[1]) +def kinv(a): + b=conj(a);d=mul(a,b) + need(d[1]==0 and d[0]!=0,'nonzero exact cyclotomic inverse') + return (b[0]/d[0],b[1]/d[0]) +def scale(a,s):return (a[0]*s,a[1]*s) +def total(xs): + a=Z + for x in xs:a=add(a,x) + return a +def eye(n):return [[O if i==j else Z for j in range(n)] for i in range(n)] +def zero(n,m):return [[Z for j in range(m)] for i in range(n)] +def const(a):return [[(Q(x),Q(0)) for x in r] for r in a] +def mm(a,b):return [[total(mul(x,y) for x,y in zip(r,c)) for c in zip(*b)] for r in a] +def ma(a,b):return [[add(x,y) for x,y in zip(r,s)] for r,s in zip(a,b)] +def ms(a,b):return [[sub(x,y) for x,y in zip(r,s)] for r,s in zip(a,b)] +def scalar(a,s):return [[mul(x,s) for x in r] for r in a] +def mc(a):return [[conj(x) for x in r] for r in a] +def trace(a):return total(a[i][i] for i in range(len(a))) +def rank(a): + b={} + for r in a: + r=list(r) + for j,v in sorted(b.items()): + c=r[j];r=[sub(x,mul(c,y)) for x,y in zip(r,v)] + j=next((j for j,x in enumerate(r) if x!=Z),None) + if j is not None: + c=kinv(r[j]);b[j]=[mul(x,c) for x in r] + return len(b) +def inv(a): + n=len(a);w=[list(r)+s for r,s in zip(a,eye(n))] + for j in range(n): + p=next(i for i in range(j,n) if w[i][j]!=Z) + w[p],w[j]=w[j],w[p];c=kinv(w[j][j]);w[j]=[mul(x,c) for x in w[j]] + for i in range(n): + if i!=j: + c=w[i][j];w[i]=[sub(x,mul(c,y)) for x,y in zip(w[i],w[j])] + need([r[:n] for r in w]==eye(n),'field inverse exact') + return [r[n:] for r in w] +def power(a,k): + b=eye(len(a)) + for _ in range(k):b=mm(b,a) + return b +def ser(a):return [[[str(x) for x in c] for c in r] for r in a] + +def interaction_fixture(n,k): + uc=[[Q(0) for j in range(k)] for i in range(n)] + vr=[[Q(0) for j in range(n)] for i in range(k)] + for i in range(k): + j=i%n;uc[j][i]=1;uc[(j+1)%n][i]=i+1 + vr[i][(j+2)%n]=Q((-1)**i) + U=const(uc);V=const(vr) + need(rank(U)==rank(V)==n,'full-rank rational directions fixture') + B=mm(V,U);need(all(B[i][i]==Z for i in range(k)),'nilpotent direction diagonals') + lo=[[B[i][j] if i>j else Z for j in range(k)] for i in range(k)] + up=[[B[i][j] if ik-n and rank(defect)>0,'noncentral-word negative control') + return {'n':n,'k':k,'types':types,'rank_U':rank(U),'rank_V':rank(V), + 'rank_C':rank(C),'r_if_central':k-n,'target_defect_rank':rank(defect), + 'resolvent_identity':True,'coefficient_split':True,'defect_identity':True, + 'not_a_central_factorization':True} + +def negmat(a):return [[neg(x) for x in r] for r in a] + +def projection_control(): + A=const([[-1,2,0,0],[0,0,0,0],[0,0,-1,3],[0,0,0,0]]) + B=const([[0,0,0,0],[1,1,0,0],[0,0,0,0],[0,0,2,1]]) + pa=ms(eye(4),power(ma(eye(4),A),4)) + pb=ms(eye(4),power(ms(eye(4),B),4)) + need(rank(A)==rank(B)==2,'diagonal-count rank equality fixture') + for p,m in ((pa,A),(pb,B)): + need(mm(p,p)==p and mm(p,m)==m and mm(m,p)==m,'unique image-kernel projection') + need(rank(p)==rank(m),'projection rank agreement') + need([pa[i][i] for i in range(4)]==[O,Z,O,Z],'upper projection support') + need([pb[i][i] for i in range(4)]==[Z,O,Z,O],'lower projection support') + need(pa!=pb,'complementary spectral projections cannot agree') + return {'upper_projection':ser(pa),'lower_projection':ser(pb),'complementary_diagonals':True, + 'warning':'This fixture does not assert equal row/column spaces. Their equality is the contradictory hypothesis in the written all-word proof.'} + +def layer_control(n): + layers=[] + for h in range(3): + D=zero(n,n) + for j in range(0,n-1,2): + dst,src=(j,j+1) if h%2==0 else (j+1,j) + D[dst][src]=scale(sub(N if (h+j)%3 else N2,O),Q((-1)**(h+j//2))) + # A constant conjugation is allowed between matching layers. + C=eye(n) + for j in range(n-1):C[j][j+1]=(Q(h+j+1),Q(0)) + D=mm(mm(inv(C),D),C) + need(mm(D,D)==zero(n,n),'whole matching-layer normalized perturbation squarezero') + layers.append(D) + P=mm(ma(eye(n),layers[1]),ma(eye(n),layers[0])) + Pi=mm(ms(eye(n),layers[0]),ms(eye(n),layers[1])) + need(mm(P,Pi)==eye(n),'literal two-layer inverse') + need(trace(P)==trace(Pi),'two-squarezero-layer reciprocal trace') + forced=sub(scale(N,n),scale(N2,n)) + need(forced!=Z,'nonreal cubic central trace contradiction') + return {'n':n,'layer_squarezero_ranks':[rank(x) for x in layers], + 'trace_two_layers':list(map(str,trace(P))), + 'trace_inverse_two_layers':list(map(str,trace(Pi))), + 'central_target_forced_trace_difference':list(map(str,forced))} + +def pure_four_layer_control(): + n=3 + A=const([[0,1,0],[0,0,0],[0,0,0]]) + B=const([[0,0,0],[-1,0,0],[0,0,0]]) + C=const([[0,0,0],[0,0,1],[0,0,0]]) + D=const([[0,0,0],[0,0,0],[1,0,0]]) + for m in (A,B,C,D):need(mm(m,m)==zero(n,n),'pure layer fixture squarezero') + t=sub(N,O);t2=sub(N2,O);I=eye(n) + Qm=mm(ma(I,scalar(D,t2)),ma(I,scalar(C,t))) + target=scalar(mm(ms(I,scalar(A,t)),ms(I,scalar(B,t2))),N) + F=ma(ma(ma(I,scalar(A,(Q(2),Q(0)))),B),scalar(mm(A,B),(Q(3),Q(0)))) + G=ms(F,I);M=ma(A,mm(A,B)) + q0=ma(ms(ms(I,C),scalar(D,(Q(2),Q(0)))),scalar(mm(D,C),(Q(3),Q(0)))) + q1=ms(C,D) + need(Qm==ma(q0,scalar(q1,N)),'pure left-pair rational/primitive coefficient formula') + need(target==ma(ms(A,B),scalar(F,N)),'pure right-inverse coefficient formula') + e=ms(q0,ms(A,B));f=ms(q1,F) + rhs=scalar(ms(ma(e,f),scalar(mm(D,f),(Q(3),Q(0)))),(Q(1,3),Q(0))) + need(ms(mm(D,G),M)==rhs,'target-defect-aware alternating four-layer identity') + need(mm(G,B)==scalar(mm(A,B),(Q(2),Q(0))) and mm(M,B)==mm(A,B),'right multiplication gives forced D eigenvalue1/2') + need(rank(ms(Qm,target))>0,'noncentral four-pure-layer fixture rejected') + return {'n':n,'pure_coefficients_in_application_order':['N-1','N^2-1','N-1','N^2-1'], + 'coefficient_identity':True,'target_defect_omission_rejected':True, + 'forced_hypothetical_relation':'If target defect vanishes, D(2A+B+3AB)=A+AB, so 2DAB=AB; D^2=0 forces AB=0.', + 'warning':'The finite fixture does not solve the target. It checks the algebra used in the written all-n obstruction.'} + +def receipt(): + need(mul(N,N)==N2 and mul(N2,N)==O,'exact primitive specialization') + cases=[] + for n in (3,6,9,12,24,48): + k=n+(n+3)//3 + need(3*(k-n)>=n+1 and 3*(k-1-n)=n+ceil((n+1)/3)','strict_rank_form':'For r=k-n, k<4r.', + 'written_proof':'README.md, general interaction-matrix argument. Valid for every finite n and k in the stated model, not a search result.'}, + 'three_matching_layer_gate':{'statement':'No three normalized layers I+A_l with A_l^2=0 can multiply to zeta I_n in characteristic0.', + 'scope':'Constant scalar bridges may occur between layers. Arbitrary mixing inside a nominal layer is outside the squarezero-layer premise unless that premise is separately proved.', + 'proof':'For P=(I+A2)(I+A1), tr(P)=tr(P^-1). The target gives P=zeta(I-A3), hence tr(P)=n*zeta and tr(P^-1)=n*zeta^-1, a contradiction.'}, + 'four_pure_layer_gate':{'statement':'No four layers, each entirely I+(zeta-1)A_l or entirely I+(zeta^2-1)A_l with rational A_l^2=0, multiply to zeta I_n for n>0.', + 'proof':'Every adjacent two-layer product must have trace0. Equal-type neighboring layers have trace n-3*zeta*s or n-3*zeta^2*s with rational s, impossible. Types must alternate. Coefficient comparison gives D(2A+B+3AB)=A+AB; multiply right by B and use D^2=0 to force AB=0, contradicting the first pair trace0.', + 'scope':'Mixed N and N^2 coefficients within a layer are outside this pure-layer argument.'}, + 'cases':cases, + 'finite_identity_checks':[interaction_fixture(n,k) for n,k in ((3,5),(6,8),(9,11),(12,17))], + 'projection_control':projection_control(), + 'layer_controls':[layer_control(n) for n in (3,6,12)], + 'pure_four_layer_control':pure_four_layer_control(), + 'coverage':'Written all-word/all-n proofs, with finite exact identity and negative-control fixtures. No exhaustive search, formal-kernel proof, positive scalar caller, or native admission is claimed.', + 'independent_review':{'reviewer':'/root/stabilizer_escape_1019','general_rank_gate':'PASS','three_layer_trace_gate':'PASS','four_pure_layer_gate':'See INDEPENDENT-REVIEW.md','record':'INDEPENDENT-REVIEW.md'}, + 'remaining':['Four matching layers with mixed N/N^2 coefficients inside a layer are not excluded by these gates.', + 'A four-layer construction must still give every bank its full native endpoint, source-code transport, literal inverse and complete scalar/native/idle invoice.']} + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');a=ap.parse_args() + out=receipt();p=HERE/'WIDE-MIXED-CUBIC-GATES.json' + if a.write:p.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else:need(json.loads(p.read_bytes())==out,'saved wide gate differs') + print(out['status']) + print('Written k>=n+ceil((n+1)/3); three matching layers excluded; four mixed layers remain open.') + +if __name__=='__main__':main() diff --git a/research/cubic-scalar-caller-bounds/independent/CHECKS.json.gz b/research/cubic-scalar-caller-bounds/independent/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..577c697bb9e43e44737b87e66106ae91472a62fe GIT binary patch literal 3156 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 literal 0 HcmV?d00001 diff --git a/research/cubic-scalar-caller-bounds/independent/PROOF-INDEPENDENT.md b/research/cubic-scalar-caller-bounds/independent/PROOF-INDEPENDENT.md new file mode 100644 index 0000000000..eedef79b3a --- /dev/null +++ b/research/cubic-scalar-caller-bounds/independent/PROOF-INDEPENDENT.md @@ -0,0 +1,43 @@ +# Independent ordinary rational-matrix check + +This component retains the complete separately implemented C09 review checker. +It imports no candidate or historical arithmetic. Its only mathematical input +is the authenticated original `CUBIC-FOUR-CALL-GATE.json`; the wrapper supplies +that fixed path. The source itself is unchanged. + +The full three-cycle acts on `(1,N,N^2)` and injectively represents the whole +cubic algebra. The checker reconstructs every prefix of all four normalization +fixtures on all nine rational input columns, including evolving augmentation. +It verifies the excluded operator-dependent four-factor target and literal +inverse, and rejects a matrix with the right primitive value but wrong +augmentation. + +A distinct two-dimensional rational matrix is used only for necessary primitive +specialization. This engine reconstructs the full interaction resolvent and +noncentral target defect, pure-layer coefficient formulas and their remainder, +the reversed literal pair inverse, and polynomial projectors with nontrivial +Jordan blocks. The fixtures do not purport to realize the impossible common +image/kernel equality case in the written obstruction. + +Twelve actual algebraic defects must fail their named predicates. Each same +mutant then runs with only that predicate removed outside the rejection handler. +The complete receipt retains every matrix and prefix. Normal and optimized +Python 3.12 records are identical. + +These finite checks support identities and sensitivity. The universal query +and layer bounds are the written arguments in `../cubic/PROOF.md`, not a finite +enumeration. This independent implementation is an AI mathematical review +context, not independent human acceptance, formal-kernel verification or a +native caller. Prepared with substantial OpenAI Codex assistance. + +From the installed package root, the standalone command is + +``` +python3.12 -B independent/check.py \ + --historical-receipt /absolute/package/cubic/frozen/CUBIC-FOUR-CALL-GATE.json \ + --output /absolute/external/new-independent.json +``` + +The normal package command is `python3.12 -I -O -B verify.py --stage independent`. +This contract summary is new integration documentation; the unchanged original +review is pinned separately in top-level `ORIGINS.json` as documentary provenance. diff --git a/research/cubic-scalar-caller-bounds/independent/check.py b/research/cubic-scalar-caller-bounds/independent/check.py new file mode 100644 index 0000000000..bec808849a --- /dev/null +++ b/research/cubic-scalar-caller-bounds/independent/check.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Separate rational-matrix audit; imports no candidate/source arithmetic.""" +import argparse +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path + +HISTORICAL_SHA='2050478b6fc2082775bc2eead709ee2f771c1fd2eca26a8cca4ad25eff142029' + +def need(ok,why): + if not ok:raise ValueError(why) +def eye(n):return [[Q(i==j) for j in range(n)] for i in range(n)] +def zero(n,m=None):return [[Q(0) for _ in range(n if m is None else m)] for _ in range(n)] +def add(A,B):return [[a+b for a,b in zip(x,y)] for x,y in zip(A,B)] +def neg(A):return [[-a for a in x] for x in A] +def sub(A,B):return add(A,neg(B)) +def scale(A,c):return [[c*a for a in x] for x in A] +def mul(A,B):return [[sum(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 power(A,k): + R=eye(len(A)) + for _ in range(k):R=mul(A,R) + return R +def inv(A): + n=len(A);M=[list(x)+y for x,y in zip(A,eye(n))] + for j in range(n): + q=next((q for q in range(j,n) if M[q][j]),None) + need(q is not None,'nonsingular rational matrix') + M[j],M[q]=M[q],M[j];v=M[j][j];M[j]=[x/v for x in M[j]] + for i in range(n): + if i!=j: + v=M[i][j];M[i]=[x-v*y for x,y in zip(M[i],M[j])] + return [r[n:] for r in M] +def kron(A,B): + return [[A[i][j]*B[a][b] for j in range(len(A[0])) for b in range(len(B[0]))] + for i in range(len(A)) for a in range(len(B))] +def diagblocks(blocks): + n=sum(len(b) for b in blocks);M=zero(n);r=0 + for b in blocks: + for i,row in enumerate(b): + for j,v in enumerate(row):M[r+i][r+j]=v + r+=len(b) + return M +def trace(A):return sum(A[i][i] for i in range(len(A))) +def serial(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):serial(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [serial(v) for v in x] + return x +def equal(A,B,label,deleted=()): + if label not in deleted:need(A==B,label) +def control(name,label,fn): + try:fn(()) + except ValueError as exc:need(str(exc)==label,'unintended independent control failure') + else:raise ValueError('independent mutant survived: '+name) + fn((label,)) + return {'name':name,'rejected':label,'same_guard_deletion':'accept'} +def liftfull(poly): + # C is the full 3-cycle, so 1,C,C² are linearly independent operators. + C=[[Q(0),Q(0),Q(1)],[Q(1),Q(0),Q(0)],[Q(0),Q(1),Q(0)]] + out=zero(3*len(poly));powers=[eye(3),C,power(C,2)] + for i,row in enumerate(poly): + for j,coefficient in enumerate(row): + for k,c in enumerate(coefficient): + for a in range(3): + for b in range(3):out[3*i+a][3*j+b]+=Q(c)*powers[k][a][b] + return out + +def audit(source): + controls=[];fixtures=[] + C=[[Q(0),Q(0),Q(1)],[Q(1),Q(0),Q(0)],[Q(0),Q(1),Q(0)]] + for j,fixture in enumerate(source['normalization_fixtures']): + W=eye(9);B=eye(3);P=eye(9);prefixes=[] + for event in fixture['word']: + if event['op']=='FREE': + F=[[Q(v) for v in r] for r in event['matrix']] + W=mul(kron(F,eye(3)),W);B=mul(F,B) + else: + R=zero(3);R[event['dst']][event['src']]=Q(event['sign']) + e=event.get('power',1) + direction=mul(mul(inv(B),R),B) + P=mul(add(eye(9),kron(direction,sub(power(C,e),eye(3)))),P) + W=mul(add(eye(9),kron(R,power(C,e))),W) + B=mul(add(eye(3),R),B) + normalized=mul(kron(inv(B),eye(3)),W) + equal(P,normalized,'chronological augmentation identity') + prefixes.append(P) + expected=liftfull(fixture['normalized_full_ring_matrix']) + equal(P,expected,'all full-ring normalization columns') + controls.append(control('omit_augmentation_'+str(j),'all full-ring normalization columns', + lambda deleted,W=W,expected=expected:equal(W,expected,'all full-ring normalization columns',deleted))) + fixtures.append({'all_prefixes':prefixes,'final_full_regular_operator':P,'augmentation':B}) + + def product(matrices): + result=eye(9) + for matrix in matrices:result=mul(matrix,result) + return result + excluded=[liftfull(T) for T in source['controls']['excluded_N_dependent_four_factor_word']] + for T in excluded:equal(power(sub(T,eye(9)),2),zero(9),'excluded factor square-zero perturbation') + target=kron(eye(3),C) + excluded_product=product(excluded) + equal(excluded_product,target,'full-ring excluded-word endpoint') + inverse_word=product([sub(scale(eye(9),2),T) for T in reversed(excluded)]) + equal(mul(inverse_word,excluded_product),eye(9),'excluded literal inverse') + controls.append(control('omit_excluded_factor','full-ring excluded-word endpoint', + lambda d:equal(product(excluded[1:]),target,'full-ring excluded-word endpoint',d))) + false_primitive=add(add(eye(9),scale(target,2)),power(target,2)) + controls.append(control('discard_augmentation_component','full-ring excluded-word endpoint', + lambda d:equal(false_primitive,target,'full-ring excluded-word endpoint',d))) + + # This ordinary 2x2 rational representation is used ONLY for the necessary + # primitive specialization. It is not confused with the full 3-cycle above. + J=[[Q(0),Q(-1)],[Q(1),Q(-1)]] + equal(add(add(power(J,2),J),eye(2)),zero(2),'primitive relation') + t=sub(J,eye(2));t2=sub(power(J,2),eye(2)) + A=[[Q(0),Q(1),Q(0)],[Q(0),Q(0),Q(0)],[Q(0),Q(0),Q(0)]] + B=[[Q(0),Q(0),Q(0)],[Q(-1),Q(0),Q(0)],[Q(0),Q(0),Q(0)]] + C0=[[Q(0),Q(0),Q(0)],[Q(0),Q(0),Q(1)],[Q(0),Q(0),Q(0)]] + D=[[Q(0),Q(0),Q(0)],[Q(0),Q(0),Q(0)],[Q(0),Q(1),Q(0)]] + for M in (A,B,C0,D):equal(mul(M,M),zero(3),'square-zero layer') + I=eye(3);I6=eye(6) + left=mul(add(I6,kron(D,t2)),add(I6,kron(C0,t))) + right=mul(kron(I,J),mul(sub(I6,kron(A,t)),sub(I6,kron(B,t2)))) + G=add(add(scale(A,2),B),scale(mul(A,B),3)) + q0=add(sub(sub(I,C0),scale(D,2)),scale(mul(D,C0),3)) + q1=sub(C0,D) + equal(left,add(kron(q0,eye(2)),kron(q1,J)),'left pair coefficients') + equal(right,add(kron(sub(A,B),eye(2)),kron(add(I,G),J)),'right inverse coefficients') + e=sub(q0,sub(A,B));f=sub(q1,add(I,G)) + lhs=sub(mul(D,G),add(A,mul(A,B))) + rhs=scale(sub(add(e,f),scale(mul(D,f),3)),Q(1,3)) + equal(lhs,rhs,'noncentral pure-layer defect identity') + controls.append(control('delete_target_defect','noncentral pure-layer defect identity', + lambda d:equal(lhs,zero(3),'noncentral pure-layer defect identity',d))) + controls.append(control('wrong_cross_sign','left pair coefficients', + lambda d:equal(left,add(kron(q0,eye(2)),kron(add(C0,D),J)),'left pair coefficients',d))) + pair=mul(add(I,B),add(I,A));literal=mul(sub(I,A),sub(I,B)) + equal(mul(pair,literal),I,'literal two-layer inverse') + need(trace(pair)==trace(literal),'reciprocal pair trace') + controls.append(control('reverse_inverse_order','literal two-layer inverse', + lambda d:equal(mul(pair,mul(sub(I,B),sub(I,A))),I,'literal two-layer inverse',d))) + + projections=[] + for label,M,sign in [('upper',[[-1,1,2,0],[0,-1,0,3],[0,0,0,0],[0,0,0,0]],1), + ('lower',[[0,0,0,0],[0,0,0,0],[1,0,1,0],[0,2,1,1]],-1)]: + M=[[Q(x) for x in r] for r in M];base=add(eye(4),scale(M,sign));P=sub(eye(4),power(base,4)) + def projection(QP,deleted=(),M=M): + ok=mul(QP,QP)==QP and mul(QP,M)==M and mul(M,QP)==M + equal(ok,True,'spectral projector equations',deleted) + projection(P) + wrong=sub(eye(4),base) + controls.append(control('truncate_'+label,'spectral projector equations',lambda d,wrong=wrong,projection=projection:projection(wrong,d))) + projections.append({'kind':label,'matrix':M,'projector':P}) + + # Reconstruct chronological interaction with ordinary 10x10 rational blocks. + n,k=3,5;U=zero(n,k);V=zero(k,n) + for q in range(k): + j=q%n;U[j][q]=1;U[(j+1)%n][q]=q+1;V[q][(j+2)%n]=(-1)**q + interaction=mul(V,U);L=[[interaction[i][j] if i>j else Q(0) for j in range(k)] for i in range(k)] + upper=[[interaction[i][j] if i