diff --git a/research/moving-anchor-no-q-ceiling/.gitattributes b/research/moving-anchor-no-q-ceiling/.gitattributes new file mode 100644 index 0000000000..db9fd8e6aa --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/.gitattributes @@ -0,0 +1,5 @@ +* -text whitespace=cr-at-eol +# Preserve the documented extra LF in the original design source captures. +evidence/design/inputs/5113-README.md whitespace=cr-at-eol,-blank-at-eof +evidence/design/inputs/5113-PROOF.md whitespace=cr-at-eol,-blank-at-eof +evidence/design/inputs/5113-TASK.json whitespace=cr-at-eol,-blank-at-eof diff --git a/research/moving-anchor-no-q-ceiling/ARCHIVE-FILES.json b/research/moving-anchor-no-q-ceiling/ARCHIVE-FILES.json new file mode 100644 index 0000000000..4640faae48 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/ARCHIVE-FILES.json @@ -0,0 +1,39 @@ +{ + "CAPTURE-RELATIONS.json": "50b14d4cacea2a1783357e2267e062b527cb54d2ff613ddffe01907846cfda8e", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "SOURCE-REQUESTS.json": "af43cadcd1198412c6c792315b7e16203f6ebeeb7958111d564245346476ebc8", + "evidence/design/CONTRACT-AND-SCREEN.md": "c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570", + "evidence/design/FILES.json": "5058ed0d6a776115dad19c3e4cb0390e2003001b4d302ab47a98cd291dbb7050", + "evidence/design/RESULT.json": "6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6", + "evidence/design/SOURCES.json": "3aab2a0264aa1669db86765d9719741c7b491ff04bfc10b620f8ccabed83c617", + "evidence/design/inputs/5113-PROOF.md": "267396bf9a90c38b655d621aad38e22366ccc6e6a9ea5aad8cf2f6394cd21a9a", + "evidence/design/inputs/5113-README.md": "b1aa039cd1f5d3195c06eef864370ab3dbe3be464adfbf6c2a16252071f2cd25", + "evidence/design/inputs/5113-TASK.json": "70e22ec1c73710e8db9d159baa1cf4150ea00ec3f70f880027818f5f23a2b963", + "evidence/pair-inventory/FILES.json": "61e252b8e08e2c3c0be08f5acd8c929b5f82f7db2d48db0402bd6d0051bde777", + "evidence/pair-inventory/REPORT.md": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2", + "evidence/pair-inventory/SOURCES.json": "8b1df698f598a648850cfbc27253a6cd16820b5a2770e3f35527a4b15ae365e2", + "evidence/pair-inventory/source/research__coded-native-caller__PHYSICAL.md": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078", + "evidence/pair-inventory/source/research__common-code-moving-stages__PROOF.md": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "evidence/pair-inventory/source/research__common-code-moving-stages__README.md": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "evidence/pair-inventory/source/research__common-code-moving-stages__SOURCES.json": "6b7fcc10c07f03f98318cd08ddacc2f7bb156c98628672ff7890d0ac9403f4d6", + "evidence/pair-inventory/source/research__common-code-moving-stages__TASK.json": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "evidence/pair-inventory/source/research__native-center-free-code__README.md": "fede7462b9f0048f8c8a8756bd2bdac6389448c2fbfa12541a564d1088198cad", + "evidence/review/CHECK-RESULT-OPTIMIZED.json": "591b6ff2768ad407b3cd2b65221df544c4324726ff06b25ef9da202695b4fe55", + "evidence/review/CHECK-RESULT.json": "591b6ff2768ad407b3cd2b65221df544c4324726ff06b25ef9da202695b4fe55", + "evidence/review/FILES.json": "84100648e369d6a4d4c3694a3208371971485fb5d21c4551240c13ca93f51049", + "evidence/review/HANDOFF-1166-PROPOSED.md": "ccd8582b07b083bcadfe8f5dbd574e7f96babe885ed6f53a3af91ad933baf771", + "evidence/review/PR-BODY-PROPOSED.md": "b95c3fc4668e556f6394e527e2ec9605fbc71553a237b30121f22ce389f2b297", + "evidence/review/REVIEW.md": "5138bae4f6099d26f07b4c3706f45c82f01f42928b08c9e06bd7ab5b5c2d4df7", + "evidence/review/SOURCES.json": "54933502ced16333e7299ba2df6406478a5c260f3fa3a7857a87d6a1f5939aa9", + "evidence/review/check_ceiling.py": "7e4e49a07b45b1ba54588e93fab434dd061ec4b987ac18e7687ff159eaec8d79", + "evidence/review/frozen/DESIGN-CONTRACT.md": "c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570", + "evidence/review/frozen/DESIGN-RESULT.json": "6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6", + "evidence/review/frozen/INVENTORY-REPORT.md": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2", + "evidence/review/frozen/INVENTORY-SOURCES.json": "8b1df698f598a648850cfbc27253a6cd16820b5a2770e3f35527a4b15ae365e2", + "evidence/review/frozen/research__coded-native-caller__PHYSICAL.md": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078", + "evidence/review/frozen/research__common-code-moving-stages__PROOF.md": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "evidence/review/frozen/research__common-code-moving-stages__README.md": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "evidence/review/frozen/research__common-code-moving-stages__SOURCES.json": "6b7fcc10c07f03f98318cd08ddacc2f7bb156c98628672ff7890d0ac9403f4d6", + "evidence/review/frozen/research__common-code-moving-stages__TASK.json": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "evidence/review/frozen/research__native-center-free-code__README.md": "fede7462b9f0048f8c8a8756bd2bdac6389448c2fbfa12541a564d1088198cad" +} diff --git a/research/moving-anchor-no-q-ceiling/CAPTURE-RELATIONS.json b/research/moving-anchor-no-q-ceiling/CAPTURE-RELATIONS.json new file mode 100644 index 0000000000..1c70571c50 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/CAPTURE-RELATIONS.json @@ -0,0 +1,29 @@ +[ + { + "design_capture": "evidence/design/inputs/5113-README.md", + "design_capture_sha256": "b1aa039cd1f5d3195c06eef864370ab3dbe3be464adfbf6c2a16252071f2cd25", + "original_head": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "original_path": "research/common-code-moving-stages/README.md", + "raw_sha256": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "raw_snapshot": "evidence/review/frozen/research__common-code-moving-stages__README.md", + "relationship": "design_capture = raw_upstream_bytes + exactly one LF byte; preserved, not silently normalized or repinned" + }, + { + "design_capture": "evidence/design/inputs/5113-PROOF.md", + "design_capture_sha256": "267396bf9a90c38b655d621aad38e22366ccc6e6a9ea5aad8cf2f6394cd21a9a", + "original_head": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "original_path": "research/common-code-moving-stages/PROOF.md", + "raw_sha256": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "raw_snapshot": "evidence/review/frozen/research__common-code-moving-stages__PROOF.md", + "relationship": "design_capture = raw_upstream_bytes + exactly one LF byte; preserved, not silently normalized or repinned" + }, + { + "design_capture": "evidence/design/inputs/5113-TASK.json", + "design_capture_sha256": "70e22ec1c73710e8db9d159baa1cf4150ea00ec3f70f880027818f5f23a2b963", + "original_head": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "original_path": "research/common-code-moving-stages/TASK.json", + "raw_sha256": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "raw_snapshot": "evidence/review/frozen/research__common-code-moving-stages__TASK.json", + "relationship": "design_capture = raw_upstream_bytes + exactly one LF byte; preserved, not silently normalized or repinned" + } +] diff --git a/research/moving-anchor-no-q-ceiling/LICENSE b/research/moving-anchor-no-q-ceiling/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/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/moving-anchor-no-q-ceiling/NOTICE.md b/research/moving-anchor-no-q-ceiling/NOTICE.md new file mode 100644 index 0000000000..f810af5748 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/NOTICE.md @@ -0,0 +1 @@ +Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. Credit Cinna Davis / 1337isnot1337 for #5113 common-code moving stages and its stage-word theorem; Dillon for #4933 normalizers/coded ABI; Dugongue for #4929 helper-clean producer; Astra for the terminal-anchor design; the separate inventory and independent ceiling reviewers; Cao Yifan, Cayden Burkart, JoyboyBrian, zxv, Jacob Alan Sussman and all retained native/helper/compiler/precision contributors. Original source and scientific evidence remains byte-exact. No new κ, complete supplier, all-p caller or proof-kernel acceptance is claimed. diff --git a/research/moving-anchor-no-q-ceiling/PACKAGE-FILES.json b/research/moving-anchor-no-q-ceiling/PACKAGE-FILES.json new file mode 100644 index 0000000000..5676999486 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/PACKAGE-FILES.json @@ -0,0 +1,47 @@ +{ + ".gitattributes": "be0951a2461824a4f8b71adc9ae26b48176f49cc6d33610001106f0594045e71", + "ARCHIVE-FILES.json": "64df5503b39b6e687511d947441f21a67892a5b07e7b8f09c396174d902662f1", + "CAPTURE-RELATIONS.json": "50b14d4cacea2a1783357e2267e062b527cb54d2ff613ddffe01907846cfda8e", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "b5b9b4acda2f1f9255486b3e59485b607a925c1e99a48686996aab83c8745cc6", + "README.md": "40673b8a0561c2fcd690ab7d10ac44269361b5fd3d788b84e44dbbf44374e1aa", + "SOURCE-REQUESTS.json": "af43cadcd1198412c6c792315b7e16203f6ebeeb7958111d564245346476ebc8", + "SOURCES.json": "cc222a6fa36af0da3b6b0e1b3a35f4b5719cc0627a32e422fa6c96560cdf8819", + "TASK.json": "df97a2bfff4f348666c78d6c99b93435d235ea130f271955a7f2a88f95e27874", + "VERIFY.json": "a07c185bab000ade470a7c568748321d2a2e71832c4ce568a3a7a9e8c7ce46a8", + "evidence/design/CONTRACT-AND-SCREEN.md": "c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570", + "evidence/design/FILES.json": "5058ed0d6a776115dad19c3e4cb0390e2003001b4d302ab47a98cd291dbb7050", + "evidence/design/RESULT.json": "6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6", + "evidence/design/SOURCES.json": "3aab2a0264aa1669db86765d9719741c7b491ff04bfc10b620f8ccabed83c617", + "evidence/design/inputs/5113-PROOF.md": "267396bf9a90c38b655d621aad38e22366ccc6e6a9ea5aad8cf2f6394cd21a9a", + "evidence/design/inputs/5113-README.md": "b1aa039cd1f5d3195c06eef864370ab3dbe3be464adfbf6c2a16252071f2cd25", + "evidence/design/inputs/5113-TASK.json": "70e22ec1c73710e8db9d159baa1cf4150ea00ec3f70f880027818f5f23a2b963", + "evidence/pair-inventory/FILES.json": "61e252b8e08e2c3c0be08f5acd8c929b5f82f7db2d48db0402bd6d0051bde777", + "evidence/pair-inventory/REPORT.md": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2", + "evidence/pair-inventory/SOURCES.json": "8b1df698f598a648850cfbc27253a6cd16820b5a2770e3f35527a4b15ae365e2", + "evidence/pair-inventory/source/research__coded-native-caller__PHYSICAL.md": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078", + "evidence/pair-inventory/source/research__common-code-moving-stages__PROOF.md": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "evidence/pair-inventory/source/research__common-code-moving-stages__README.md": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "evidence/pair-inventory/source/research__common-code-moving-stages__SOURCES.json": "6b7fcc10c07f03f98318cd08ddacc2f7bb156c98628672ff7890d0ac9403f4d6", + "evidence/pair-inventory/source/research__common-code-moving-stages__TASK.json": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "evidence/pair-inventory/source/research__native-center-free-code__README.md": "fede7462b9f0048f8c8a8756bd2bdac6389448c2fbfa12541a564d1088198cad", + "evidence/review/CHECK-RESULT-OPTIMIZED.json": "591b6ff2768ad407b3cd2b65221df544c4324726ff06b25ef9da202695b4fe55", + "evidence/review/CHECK-RESULT.json": "591b6ff2768ad407b3cd2b65221df544c4324726ff06b25ef9da202695b4fe55", + "evidence/review/FILES.json": "84100648e369d6a4d4c3694a3208371971485fb5d21c4551240c13ca93f51049", + "evidence/review/HANDOFF-1166-PROPOSED.md": "ccd8582b07b083bcadfe8f5dbd574e7f96babe885ed6f53a3af91ad933baf771", + "evidence/review/PR-BODY-PROPOSED.md": "b95c3fc4668e556f6394e527e2ec9605fbc71553a237b30121f22ce389f2b297", + "evidence/review/REVIEW.md": "5138bae4f6099d26f07b4c3706f45c82f01f42928b08c9e06bd7ab5b5c2d4df7", + "evidence/review/SOURCES.json": "54933502ced16333e7299ba2df6406478a5c260f3fa3a7857a87d6a1f5939aa9", + "evidence/review/check_ceiling.py": "7e4e49a07b45b1ba54588e93fab434dd061ec4b987ac18e7687ff159eaec8d79", + "evidence/review/frozen/DESIGN-CONTRACT.md": "c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570", + "evidence/review/frozen/DESIGN-RESULT.json": "6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6", + "evidence/review/frozen/INVENTORY-REPORT.md": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2", + "evidence/review/frozen/INVENTORY-SOURCES.json": "8b1df698f598a648850cfbc27253a6cd16820b5a2770e3f35527a4b15ae365e2", + "evidence/review/frozen/research__coded-native-caller__PHYSICAL.md": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078", + "evidence/review/frozen/research__common-code-moving-stages__PROOF.md": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "evidence/review/frozen/research__common-code-moving-stages__README.md": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "evidence/review/frozen/research__common-code-moving-stages__SOURCES.json": "6b7fcc10c07f03f98318cd08ddacc2f7bb156c98628672ff7890d0ac9403f4d6", + "evidence/review/frozen/research__common-code-moving-stages__TASK.json": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "evidence/review/frozen/research__native-center-free-code__README.md": "fede7462b9f0048f8c8a8756bd2bdac6389448c2fbfa12541a564d1088198cad", + "verify.py": "95c579308991dc686285f0076ae4baab28da5a3d96b5fce4e5f3a77ae8a75578" +} diff --git a/research/moving-anchor-no-q-ceiling/README.md b/research/moving-anchor-no-q-ceiling/README.md new file mode 100644 index 0000000000..130f7b7c63 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/README.md @@ -0,0 +1,76 @@ +# A source-bound p=3 moving-anchor no-Q ceiling + +Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance. This is a source-pinned research package, with unchanged design, inventory and independent-verification evidence. + +**Even granting both main banks independent rank-24 Gaussian targets and all added finite work free, the declared three-FULL invoice loses strictly for every C>0.** This is a ceiling for that fixed optimistic source-bound offer. It is not a universal obstruction to moving coordinates, a complete physical caller, all-p source admission or a new κ result. + +## Exact contract and proof + +For distinct nonanchor blocks s,t, #5113 defines `E_s=P_s D_0` and `E_t=P_t D_0`. Append the terminal anchor stage `E_0=D_0`. The exact source-premise word is + +``` +E_0 E_t E_s = D_0 P_t D_0 P_s D_0 = P_t P_s D_0 D_s D_t. +``` + +Removing the explicit coordinate permutation leaves **24 Gaussian axes in ambient 25**, with **no Q factor**. The eight anchor axes are coordinates within each arbitrary field, not eight owner arrays. Three forward triangular FULLs give one pure bank of 112 X owners; Y remains code-coupled and its independent target is unproved. The screen grants both existing banks anyway: **224 persistent main owners**, plus three disjoint 408-helper inventories, **1224 helper owners**, each rewarded once. No new 224-owner bank appears at every FULL; owned scratch has no productive credit. + +The complete cheaper source profiles per FULL are + +``` +P0={1:2201,2:412,3:510,4:127,5:40} +H ={4:28,7:7,8:47,9:326}. +T =3H+224H24 +P =3P0. +``` + +After cancelling 84H4, the signed moment is + +``` +M=21H7+141H8+978H9+224H24 + -6603H1-1236H2-1530H3-297H4-120H5. +``` + +Both remaining rank masses are exactly 15453. Every positive rank is at least 7; every negative rank is at most 5. With `H_r(C)=r^(1-C)`, for every C>0, + +``` +M(C) <=15453*(7^(-C)-5^(-C)) <0. +``` + +At C=0 the rank-mass margin is exactly 0. The retained moment route 00. No emitter or further caller expansion is warranted by this schedule. This is not a universal obstruction to moving-coordinate or coded recursive families. + +## Exact source and ownership gate + +Source: Cinna Davis / 1337isnot1337, PR5113, `b893ba6bd6c77c6e7efc48acb6f448218df671b7`, package `research/common-code-moving-stages`. Its parent is `d87301c0faee971d492091ce8b7314233ec51c6b`; the only current-head change is the explicit failed forward lower-left block in PROOF.md section4. The verifier, RESULT and retained input bytes are unchanged. The monitor authenticated PROOF/TASK/README and reported exact-head ownership at09:42–09:48UTC. Canonical discussion4930 comment19142768 is a released bounded claim with no replies; PR comments remained empty. The author continues unspecified larger-K work, so a broad caller search is not cleared. + +The monitor found no precise owner of this isolated terminal-anchor word/inventory question in its bounded current coverage through5117. This is not exhaustive novelty evidence. Dillon's active whole-p2 code transport, both paid-IDLE pairs, all four banks, commonD1D3Q, port intertwiners and packaged unary query theorem are excluded. No public write was performed. Current main is `bf5519aa000c0dac09e0c3fd2706558c4af6a481`; the monitor verified all nine guidance/selected blob hashes unchanged from the prior81e9 pin. + +## Constructive hypothesis and exact algebra + +Use three existing eight-axis blocks V0,Vs,Vt, plus the central Q axis: ambient25. V0 is the common anchor; it is not eight new owner arrays. Let Ps and Pt exchange V0 with their respective blocks, and let Dj be the Gaussian product on blockj. Source moving stages are Es=PsD0, Et=PtD0. Choose a terminal anchor stage E0=D0, whose inserted moving permutation is identity. + +The exact target-word identity is + + E0 Et Es = D0 Pt D0 Ps D0 + = Pt Ps D0 Ds Dt. + +The proof uses D0Pt=PtDt, D0Ps=PsDs and disjoint-block commutation. After explicitly removing PtPs, all three existing eight-axis blocks receive one Gaussian. There are24Gaussian axes, not25: the central Q in the source FULL's off-diagonal code is not a free diagonal target. This avoids adding a fourth eight-axis anchor block. It does not prove a complete FULL caller. + +For the scalar diagonal word W=PtPsD0DsDt, the same-basis inverse transpose is W^(-T)=PtPs(D0DsDt)^(-T). A valid inverse-transpose partner must use that physical permutation and inverse-transpose Gaussian orientation, with the actual conjugate charts. Neither a scalar transpose substitution nor an unchanged backward chart is certified here. We implement no backward partner. + +## Actual main endpoint and mandatory stock + +Each source transported forward FULL has exact main endpoint + + Ftilde_j = diag(Ej,Ej) L(C0 Q^(-1)). + +On arbitrary independent X,Y, a product of three such forward endpoints gives the top bank X'=WX. The lower bank contains WY plus code-dependent terms from X. Thus one bank of112owners has the indicated diagonal word. The second bank is not an autonomous Gaussian target without a new consumer/restoration proof. This is the precise partial-productive-subspace hypothesis; no full-code inverse or paid-IDLE construction is substituted. + +The persistent main inventory is112X plus112Y, not224new main owners per FULL. Use three disjoint source helper inventories,408 per invocation, for1224independent helper inputs and outputs, each counted once. All actual source chart changes, absolute phases and helper-autonomy premises remain inherited from the pinned PR4929/PR4933 lineage. Owned source scratch is not productive stock. + +The source helper target profile per invocation is {4:28,7:7,8:47,9:326}; the paid profile is {1:2201,2:412,3:510,4:127,5:40}. The parallel inventory worker authenticated these from the5113retained source. The eight anchor axes occur within every owner's address domain; they are not eight extra independent owner rewards. + +The two nonanchor FULLs insert224Ps/Pt maps each,448total. The terminal anchor FULL inserts0moving maps because P0=I; its inherited native/wrapper bill remains. Normalizing both main outputs can require224further whole-field inverse-PtPs maps. Finite-tape movement, chart normalization, stock, precision, arbitrary-Y cleanup and all terminal-consumer work are optimistically free in the rejection screen below, not claimed to be physically free. + +## Complete optimistic moment and exact proof + +Use Hr(C)=r^(1-C), H0=0. Grant even the unrealized second main bank a rank24Gaussian output, with every helper retained once. This upper relaxation is strictly stronger than the actual one-bank endpoint. Its target and paid profiles are + + T = 84H4 +21H7 +141H8 +978H9 +224H24, + P = 6603H1 +1236H2 +1530H3 +381H4 +120H5. + +After cancelling84H4, + + M = 21H7 +141H8 +978H9 +224H24 + -6603H1 -1236H2 -1530H3 -297H4 -120H5. + +Positive and negative rank mass both equal15453. Every positive rank is at least7, and every negative rank is at most5. Since Hr=r*r^(-C), for every C>0, + + M(C) <= 15453*7^(-C) -15453*5^(-C) <0. + +This is an exact symbolic bound, not a floating-point certificate or a sampled range. It covers the required comparison domain [.0030217758,.00339999] and all positive C. AtC=0 the rank-mass margin is exactly0. The actual one-bank target loses another112H24 and is therefore worse. No compiler reserve, paid tail or added outer charge can improve this upper bound. A free rank25 grant would change the problem and is not supplied by this diagonal word. Paying224H1 to add Q increases the reward by224(H25-H24), strictly less than224H1 for C>0, so that direct augmentation also loses margin. + +For scale only, noncertifying70-digit decimal diagnostics give M(.0030217758) approximately-89.2937410696 and M(.00339999) approximately-100.4114321133. A monotonic endpoint enclosure preview T(Clo)-P(Chi) is approximately-85.5877944347. The exact rank-separation proof is the decision evidence; these numbers are not needed for it. + +## Cheapest test, controls and stopping rule + +The smallest discriminating gate is already reached: verify the three-block permutation/Gaussian identity and exact integer profile/rank-mass arithmetic. Before any future execution, independent review should authenticate the native profiles, distinguish24from25targetaxes, ensure224persistentmainowners rather than672, and confirm1224helpers counted once. Controls should reject a freeQrank bonus, omitted helper work, treating axes as owner arrays, and dropping the terminal FULL's native bill. + +The exact negative upper bound stops this terminal-anchor schedule before a native emitter, all-input fixture, recursive caller or compiler retuning. An alternative would need a genuinely changed paid/target profile or a different consumer contract, not a different placement of the same grant. We make no claim about such alternatives. The partial one-bank consumer is likewise unfunded even with free cleanup. + +Credit Cinna Davis for5113's common physical code, moving endpoints and stage-word theorem; Dillon for4933normalizers/coded ABI; Dugongue/mdumitrean for4929helper-clean producer; Cayden Burkart, JoyboyBrian, Cao Yifan, zxv, Jacob Alan Sussman and the retained native/compiler/precision lineage. The terminal-anchor question and the explicit complete optimistic rejection here were developed with OpenAI Codex assistance. No newkappa, full supplier, external post or proof-kernel acceptance is claimed. diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/FILES.json b/research/moving-anchor-no-q-ceiling/evidence/design/FILES.json new file mode 100644 index 0000000000..0957a8eb76 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/FILES.json @@ -0,0 +1,8 @@ +{ + "CONTRACT-AND-SCREEN.md": "c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570", + "RESULT.json": "6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6", + "SOURCES.json": "3aab2a0264aa1669db86765d9719741c7b491ff04bfc10b620f8ccabed83c617", + "inputs/5113-PROOF.md": "267396bf9a90c38b655d621aad38e22366ccc6e6a9ea5aad8cf2f6394cd21a9a", + "inputs/5113-README.md": "b1aa039cd1f5d3195c06eef864370ab3dbe3be464adfbf6c2a16252071f2cd25", + "inputs/5113-TASK.json": "70e22ec1c73710e8db9d159baa1cf4150ea00ec3f70f880027818f5f23a2b963" +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/RESULT.json b/research/moving-anchor-no-q-ceiling/evidence/design/RESULT.json new file mode 100644 index 0000000000..121bdfd188 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/RESULT.json @@ -0,0 +1,67 @@ +{ + "status": "STOP_TERMINAL_ANCHOR_THREE_STAGE_RELAXATION", + "source_pr": 5113, + "source_head": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "main_source_owners": 224, + "fresh_helper_owners": 1224, + "actual_unmixed_main_bank_owners": 112, + "unrealized_main_target_grant": 224, + "ambient_axes": 25, + "granted_main_target_rank": 24, + "full_calls": 3, + "inserted_moving_main_maps": 448, + "boundary_normalization_maps_maximum": 224, + "native_paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "native_helper_profile": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "optimistic_target_profile": { + "4": 84, + "7": 21, + "8": 141, + "9": 978, + "24": 224 + }, + "paid_profile": { + "1": 6603, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "signed_moment_profile": { + "1": -6603, + "2": -1236, + "3": -1530, + "4": -297, + "5": -120, + "7": 21, + "8": 141, + "9": 978, + "24": 224 + }, + "positive_rank_mass": 15453, + "negative_rank_mass": 15453, + "minimum_positive_rank": 7, + "maximum_negative_rank": 5, + "exact_upper_bound": "15453*(7^(-C)-5^(-C))", + "strictly_negative_for": "every C>0", + "comparison_domain": [ + "0.0030217758", + "0.00339999" + ], + "new_kappa": null, + "native_emitter_executed": false, + "compiler_executed": false, + "finite_overhead_for_screen": "optimistically zero, actual obligations remain", + "independent_review": "pending root-assigned review" +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/SOURCES.json b/research/moving-anchor-no-q-ceiling/evidence/design/SOURCES.json new file mode 100644 index 0000000000..0284a3ac66 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/SOURCES.json @@ -0,0 +1,29 @@ +{ + "sources": [ + { + "source_commit": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "source_path": "research/common-code-moving-stages/PROOF.md", + "snapshot": "inputs/5113-PROOF.md", + "sha256": "267396bf9a90c38b655d621aad38e22366ccc6e6a9ea5aad8cf2f6394cd21a9a", + "authentication": "all_upstream_pr_monitor exact-head source read; current parent delta PROOF section4 only" + }, + { + "source_commit": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "source_path": "research/common-code-moving-stages/TASK.json", + "snapshot": "inputs/5113-TASK.json", + "sha256": "70e22ec1c73710e8db9d159baa1cf4150ea00ec3f70f880027818f5f23a2b963", + "authentication": "all_upstream_pr_monitor exact-head source read; current parent delta PROOF section4 only" + }, + { + "source_commit": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "source_path": "research/common-code-moving-stages/README.md", + "snapshot": "inputs/5113-README.md", + "sha256": "b1aa039cd1f5d3195c06eef864370ab3dbe3be464adfbf6c2a16252071f2cd25", + "authentication": "all_upstream_pr_monitor exact-head source read; current parent delta PROOF section4 only" + } + ], + "governing_main": "bf5519aa000c0dac09e0c3fd2706558c4af6a481", + "guidance_check": "monitor verified all nine guidance and selected blob SHAs unchanged from81e9 at09:43UTC", + "inventory_report": "coded-port-adapter-ceiling-20261023/outputs/moving-anchor-inventory-20261023/REPORT.md", + "inventory_report_sha256": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2" +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-PROOF.md b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-PROOF.md new file mode 100644 index 0000000000..03f68f4f04 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-PROOF.md @@ -0,0 +1,180 @@ +# A common owner code with moving Gaussian stages + +Cinna Davis; substantial OpenAI Codex assistance. Apache-2.0. + +This is a changed local interface and a rejected direct caller substitution. +It is not a supplier, a multiplication theorem or a kappa improvement. +The normalizer and coded-producer premises are Dillon's PR4933 and +Dugongue's PR4929, respectively. Their complete native word is not replayed +here. The proof below states exactly where those premises are used. + +## 1. Stage-local normalizers cannot give a common code + +Let the binary label space be a direct sum `Z + V_s + V_t + W`, where +`Z` is the shared central block and `V_s,V_t` are distinct fresh blocks. +At stage s each invertible label map `G_i,s` is supported on `Z+V_s`: +it preserves this subspace and is identity on its displayed complement. +Require `G_i,s Z = L_i,s`, with `L_i,s` distinct for different owners i. +The signed monomial normalizer K_i,s has this label map. Arbitrary +nonzero phases do not change the following necessary condition. + +For a fixed scalar owner matrix A, write the physical code block as + + C_s[i,j] = A[i,j] K_i,s^-1 K_j,s. + +Suppose `A[i,j] != 0` and `i != j`. If `C_s[i,j]=C_t[i,j]`, equality of +the nonzero monomial matrices implies equality of their label maps: + + H = G_i,s^-1 G_j,s = G_i,t^-1 G_j,t. + +The first expression preserves `Z+V_s`; the second preserves `Z+V_t`. +Both inverses have the same properties. Thus H preserves their +intersection Z bijectively. It follows that + + G_j,s Z = G_i,s H Z = G_i,s Z, + +contradicting the distinct-line premise. This rules out a common code +within this stage-local monomial class, for any choice of its normalizers. +It does not enumerate just the particular source normalizers. It applies +to arbitrary positive digit-column width by taking Z to have that width +and each fresh block eight times that width. + +For the actual 112 source ports the 112 binary lines are distinct and A +has zero diagonal and 5,824 nonzero ordered off-diagonal blocks. All +5,824 therefore obstruct common-code equality. In the pinned source +choice, block (0,1), coefficient -1/2, maps input label 1 to label 22 at +the anchor stage and 5,632 at the fresh stage in the 17-bit embedding. +Different output labels suffice irrespective of phase. + +The hypotheses matter. Equal-line owner pairs can have identical +normalizers and hence common identity relative maps. Equal stages have +the same code. The global construction below deliberately moves +spectators and lies outside the stage-local premise. + +## 2. A constructive escape by moving coordinates + +Add one common eight-axis anchor block V_0, distinct from all fresh stage +blocks V_s. Let P_s exchange V_0 and V_s and fix the central axis and +all other labels. These are real, self-inverse coordinate permutations. +Let K_i,0 be the pinned real signed anchor normalizers. Instead of the +stage-local normalizers `K_i,s=P_s K_i,0 P_s^-1`, use the intertwiners + + K'_i,s = P_s K_i,0. + +They still take the central line to the actual stage-s port line, but +move the inactive fresh labels into the anchor. Their relative maps are + + (K'_i,s)^-1 K'_j,s = K_i,0^-1 K_j,0. + +Thus they give the same physical owner code C_0 at every stage, including +all signed phases. This is an exact constructive common code once +spectator motion is allowed. It is not a centralizing-normalizer theorem: +the K'_i,s generally intertwine two stage Gaussians rather than commute +with the stage-s Gaussian. + +Here is the resulting concrete endpoint without assuming any new native +semantics. Let Q be the central Gaussian, D_0 the product on the eight +anchor axes, `D_s=P_s D_0 P_s^-1`, and +`C_s=P_s C_0 P_s^-1`. All P_s commute with Q. The inherited PR4933 ABI is + + F_s = diag(D_s,D_s) L(C_s Q^-1), + B_s = diag(D_s,D_s) U(-Q C_s), + +where L(T)=[[I,0],[T,I]] and U(T)=[[I,T],[0,I]]. Append P_s to both +main input banks, before this ABI. Direct block multiplication gives + + F_s diag(P_s,P_s) = diag(E_s,E_s) L(C_0 Q^-1), + B_s diag(P_s,P_s) = diag(E_s,E_s) U(-Q C_0), + E_s = P_s D_0. + +These equations require no commutation of C_0 with Q or P_s. Their +source maps are invertible on every arbitrary main input. They introduce +no CLEAR or claimed independent helper input. The source producer's +autonomous helper outputs remain its inherited premise. The inserted +permutations act on the 224 main fields only. This gives a complete +local input/output contract, not a complete controller. + +Every construction here lifts to arbitrary digit-column width: swap +entire blocks columnwise; lift the source signed K_i columnwise with its +correct accumulated phase; execute the owner scalar coefficients once +on the owner factor. No tensor power of a sum of owner blocks is used. + +## 3. Noncommuting E_s words retain distinct-stage Gaussian ranks + +Consider distinct nonzero stage labels s_1,...,s_k in chronological +order. Write `P_word=P_s_k ... P_s_1`. Moving coordinate permutations +to the left gives the exact formula + + E_s_k ... E_s_1 + = P_word D_0 D_s_1 ... D_s_(k-1). + +One proof proceeds inductively. In the normal form P_word D_support, +left multiplication by `P_s D_0` adds the D block at +`P_word^-1(0)`. For distinct previous swaps this block is the most +recent preceding stage label, or 0 for the empty word. This gives the +displayed support and leaves each Gaussian exponent equal to one. +The D blocks commute because their coordinates are disjoint. + +After removing the explicit monomial P_word, the word therefore has +8k Gaussian axes; adjoining Q or Q^-1 adds one. This is the exact +Gaussian support rank of this operator, not proof that the operator is +an admitted recursive target. P_word removal, ambient width, spectator +multiplicity and completion still require a supplier bill. + +The E_s themselves do not commute. Distinctness also matters: the word +E_1^3 has only eight odd Gaussian axes after monomial removal rather +than 24, since `E_1^2=D_1 D_0` and D_0^2 is monomial. The checker tests +all 1,956 distinct ordered nonempty words on six stages and this +repeat control. Those checks corroborate the induction; they do not +establish arbitrary k by enumeration. + +## 4. The direct controller substitution still fails + +The inherited relation is `[C_0,D_0 Q]=0`. Since `E_s Q=P_s D_0 Q`, + + [C_0,E_s Q]=0 iff [C_0,P_s]=0. + +Indeed multiply the commutation equation on the right by +`(D_0 Q)^-1`, using its commutation with C_0. But +`P_s C_0 P_s^-1=C_s`, and Section 1 shows `C_s != C_0`. +For the source choice their binary maps differ in every one of the +5,824 nonzero code blocks. This also gives an actual failed block +identity, rather than only an unavailable sufficient hypothesis. +Put `F_standard(E)=diag(E,E)L(Q^-1)` and +`G(C)=diag(C,Q^-1 C Q)`. The proposed forward gauge is + + diag(C,I) F_tilde diag(I,C) = G(C) F_standard(E). + +Its lower-left block difference is + + E C Q^-1 - Q^-1 C E = Q^-1 (E Q C - C E Q), + +where E commutes with Q. This is nonzero by the preceding argument. +Thus PR4933's local forward gauge identity itself fails for E_s. Their physical +common code and their rank-preserving products do not by themselves +license that caller substitution. A different caller must prove its +own full block identities. This is a stop gate, not a universal +obstruction to moving-coordinate callers or coded recursive families. + +## 5. Obligation and cost ledger + +| Obligation | Status | +|---|---| +| Source arbitrary-input coded native ABI and helper autonomy | Inherited PR4929/PR4933 premise, exact source pointers retained | +| Stage-local common-code exclusion | Proved above for the stated support/line contract | +| Global common code and transported F/B endpoints | Exact construction and block proof above | +| Distinct-stage product ranks | Proved above; finite independent arithmetic check supplied | +| Extra coordinate permutations | 224 whole-main-field P_s maps per transported FULL; finite-tape price unknown | +| Anchor space | Eight additional label axes, with every added spectator and completion charge unpriced | +| Original native child/helper profiles | Source profiles retained as local premises; no complete new supplier invoice | +| Center deletion | Existing center-free producer property, not new independent credit | +| Complete coded controller, restoration and terminal decoding | Unknown; direct inherited gauge fails Section 4 | +| Precision, routing, recursive compiler, BIT and outer transfer | Unknown for this interface | + +For n fresh eight-axis stages plus Q, the original ambient width +8n+1 becomes 8(n+1)+1. Those eight new axes are never free stock or +productive main Gaussian credit. The preserved rank of a target word +does not remove this change in its surrounding width. Unknown costs +are not zero. The next construction must justify its full completed +moment before a larger search or claimed kappa gain. + diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-README.md b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-README.md new file mode 100644 index 0000000000..58a970607a --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-README.md @@ -0,0 +1,76 @@ +# Common code through moving Gaussian stages + +**Changed local interface and a rejected direct controller substitution; no new κ.** + +An explicit coordinate transport makes the center-free producer's physical +owner code identical at every stage. The price is a moving Gaussian stage +`E_s=P_s D_0`, 224 additional main-field coordinate permutations per FULL, +and eight extra anchor axes. Distinct-stage products retain exactly eight +Gaussian axes per stage after a specified output permutation. The inherited +controller's commutation condition nevertheless fails. This package preserves +the construction and identifies that next algebraic obligation. + +The [proof](PROOF.md) first excludes a common code for **any** stage-local +monomial normalizers with the specified distinct port-line images. Its proof +uses support intersection, not exhaustive normalizer enumeration. It then +constructs global intertwiners `K'_i,s=P_s K_i,0`, proves their common-code +and arbitrary-input F/B endpoints, and derives the exact noncommuting stage +word formula. All 5,824 actual nonzero owner blocks disagree between two +stage-local codes but agree under the global transport, including signed +phases. The preserved Gaussian ranks do not admit the new jobs or price +spectator completion. + +The decisive gate is `[C_0,E_s Q]=0 iff [C_0,P_s]=0`. The latter fails on +all 5,824 nonzero blocks in the source fixture. A direct reuse of PR4933's +local gauge is therefore rejected. This does not exclude another caller, +a recursively coded family, or transport that changes the boundary contract. +No complete moment is asserted; unknown costs remain unknown. + +Reproduce with CPython 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/common-code-moving-stages +python3.12 -I -O -B research/common-code-moving-stages/verify.py +``` + +The replay authenticates all live source hashes, checks the 112 normalizers, +57,344 exact phase congruences, all 5,824 nonzero code blocks, both normalizer +inverse orders and all 1,956 distinct ordered words on six fresh stages. +A separate address-array calculation over F_65537 checks the word formula +on two deterministic vectors per word, using the actual one-axis Gaussian +coefficients. This corroborates the written all-width proof; a finite vector +check alone is not that proof. Equal-line/same-stage positive controls, +noncommuting-order and repeated-stage rank controls retain the scope boundary. +The normal and optimized registered commands are read-only. RESULT.json is +regenerated only by the explicit authoring option `--write-result`. + +Canonical base is `81e9bd69e4a5b00ba9c713a1620e36d576d5522e`, priority revision 7; +selected conditional κ remains 0.00302015. SOURCES.json pins the exact source +bytes; TASK.json retains the changed-card decision, overlap coverage and next +questions. The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768) +was claimed before the checks. No native-word regeneration, complete +controller/compiler/BIT/outer replay, Lean proof, independent human review +or selected-frontier change is claimed. + +## Open next questions + +1. Can the transported F/B endpoints be consumed by a changed caller without + assuming `[C_0,E_s Q]=0`? Start with one complete arbitrary-input pair and + its actual thin queries; charge every added oracle call and both returns. + Stop if the negative bank still requires an unpriced Q-conjugated code. +2. Can an anchor be recycled with a proved boundary and unchanged target rank? + Start with one actual source target word and all its spectator labels. + The new eight-axis anchor and its completion costs currently remain open. +3. If a caller survives, derive its complete completed moment, rounding, + movement and compiler invoice before another construction search. The + preserved 8k target rank alone grants no recursive saving. + +Credit Dillon/PR4933 for physical signed normalizers and the coded ABI; +Dugongue/mdumitrean/PR4929 for the center-free producer and code; +Cayden Burkart/PR4940 and JoyboyBrian/PR4936 for the caller and physical-pair +question; Cao Yifan/PR4610; Cinna Davis/PR4694/4698/4470; zxv; +Jacob Alan Sussman; and the full inherited native/compiler/precision lineage. +Their archived mathematics is retained as a source premise. New work by +Cinna Davis, with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. No global novelty claim for coordinate transport is intended. + diff --git a/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-TASK.json b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-TASK.json new file mode 100644 index 0000000000..225af89297 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/design/inputs/5113-TASK.json @@ -0,0 +1,87 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 7, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a common physical code by moving stage coordinates, prove its distinct-stage product ranks, and test the inherited controller commutation gate.", + "scope_change_reason": "The PR4933 coded caller leaves terminal code admission open. Instead of another fixed center invoice or terminal support test, change the spectator/coordinate contract and expose its exact F/B endpoint.", + "bottleneck_link": "A common code might enable global caller absorption of the existing center-free producer, but transported stages must satisfy a new caller theorem and pay anchor completion.", + "budget_minutes": 60, + "stop_rule": "Reject direct reuse of the inherited gauge if [C_0,E_s Q] is nonzero. Preserve a scoped construction rather than expand an unpriced compiler or call it a higher kappa.", + "outcome": "partial", + "evidence": "PROOF.md and RESULT.json: common transported code on all 5824 actual nonzero blocks, stage-local support exclusion, exact moving F/B endpoints, distinct-word Gaussian rank formula, and failed inherited commutation gate.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance for reasoning, code, verification and prose; no subagents or independent human review.", + "open_questions": [ + { + "question": "Can a changed caller consume the moving F/B stages without assuming their failed code commutation?", + "why_it_matters": "This would supply a real consumer for the common physical code.", + "first_step": "Prove all blocks of one arbitrary-input thick/thin pair and charge its query/restoration bill.", + "blocked_by": "The inherited gauge requires a commutator that is nonzero." + }, + { + "question": "Can the eight anchor axes be recycled or completed within a favorable full invoice?", + "why_it_matters": "Their added width and spectator completion are nonzero costs.", + "first_step": "Bind one actual target word and the input/output state of every anchor coordinate.", + "blocked_by": "No full completed moment, routing or precision bound is supplied." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768", + "overlap": { + "canonical_main": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "open_prs": 320, + "discussion_records": 4233, + "local_records": 6824, + "specific_terms": [ + "common code", + "simultaneous centralizer", + "stage-local" + ], + "scope": "Complete cached open-PR/discussion pagination and local note inventory; bodies and notes only, no novelty guarantee." + } +} + diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/FILES.json b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/FILES.json new file mode 100644 index 0000000000..be32a9ba00 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/FILES.json @@ -0,0 +1,10 @@ +{ + "REPORT.md": "5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2", + "SOURCES.json": "8b1df698f598a648850cfbc27253a6cd16820b5a2770e3f35527a4b15ae365e2", + "source/research__coded-native-caller__PHYSICAL.md": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078", + "source/research__common-code-moving-stages__PROOF.md": "46b427b0834aa513bba6244e3b44a089597fdb0546d0fda8c5e41130e6881eeb", + "source/research__common-code-moving-stages__README.md": "d7f06eeaf50479bd5d8ea5f9976ca061b08b8eeeee905e586d84f0774d14fd8d", + "source/research__common-code-moving-stages__SOURCES.json": "6b7fcc10c07f03f98318cd08ddacc2f7bb156c98628672ff7890d0ac9403f4d6", + "source/research__common-code-moving-stages__TASK.json": "2c6e6098ac0a8840fe4b1f981046bad365009c58c9126df11703c6fe3c4cd360", + "source/research__native-center-free-code__README.md": "fede7462b9f0048f8c8a8756bd2bdac6389448c2fbfa12541a564d1088198cad" +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/REPORT.md b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/REPORT.md new file mode 100644 index 0000000000..deb3c261b1 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/REPORT.md @@ -0,0 +1,177 @@ +# Moving-anchor pair: isolated inventory and price typing + +Read/derive only, at #5113 `b893ba6bd6c77c6e7efc48acb6f448218df671b7`. +The released TASK question 2 is the scope: one anchor/spectator boundary for +one distinct-stage pair. Dillon's active p2/IDLE/port-intertwiner work, the +author's unspecified larger-K mechanism and Astra's new consumer hypothesis +are not taken here. No native word, factory, compiler or physical fixture was +executed. The retained source/proof premises have not been independently +replayed. Six exact-head source files are preserved in `source/`. + +## Axes are not owners + +Let q be the central axis, and let 0,s,t be disjoint eight-axis blocks. +All statements lift columnwise to f digits per axis. A field is an arbitrary +function of every address coordinate, including all 8f anchor bits. The new +anchor creates no new owner array and no extra independent Gaussian output. +It enlarges the surrounding address volume by 2^(8f) relative to a comparable +two-fresh-block field without the anchor. Those arbitrary fibres cannot be +discarded, reset to zero, or counted as eight extra productive owners. + +One main bank contains 112 arbitrary owner fields. A FULL has two banks, +224 main owners. Two sequential FULLs with the same main owners and fresh +independent native helper banks have 224+2*408=1040 original owner fields. +The eight extra axes are present within these fields; they are not another +eight fields. Under source helper autonomy, the 816 helpers retain independent +outputs once, on their source requested axes, with every other coordinate +including the anchor treated as an arbitrary spectator. If a different helper +reuse is proposed, this disjoint inventory no longer applies automatically. + +## Literal pair and its exact boundary + +Use D_b for the product of the eight actual Gaussian kernels on block b, +and P_s for the real coordinate swap (0,s). The source defines + + E_s=P_s D_0, E_t=P_t D_0. + +For s,t distinct and nonzero, + + W=E_t E_s=P_t P_s D_0 D_s. + +This is an identity of literal operators, not merely of frame labels. The +Gaussian factors have their inherited actual phases; the coordinate swaps +have no added phase. They act on whole blocks at each column. The pair +contains no Q factor. + +At each of the eight corresponding bit positions, the output coordinate +permutation P_t P_s sends label positions 0->s, s->t, t->0, fixing q and all +other labels. Before that permutation, D_0 D_s acts on blocks 0 and s and +leaves block t untouched. Therefore applying the explicit output permutation +(P_t P_s)^-1 leaves the exact rank-16 Gaussian D_0 D_s. It does not return +the anchor as identity: anchor inputs have been transformed. The last fresh +block t and q are spectators. Rank is 16, not 17, and no new reward follows +from the eight anchor axes alone. + +For the pure diagonal word there is also a useful two-sided boundary fact: +with L=P_t P_s P_t, which swaps s and t, + + L W P_t = P_t D_0 D_s P_t = D_t D_s. + +This returns the anchor identically for arbitrary anchor-dependent input, +using one input and one output coordinate permutation per affected field. +It proves that an extra H8 completion is not forced by this isolated diagonal +word alone. It is NOT a zero-cost recycling theorem or a full FULL-pair +identity. Its input chart is changed, its two boundary permutations must be +paid, and it does not remove the enlarged address volume or prove that a +larger caller accepts those charts. Nor does it straighten the coupled code +blocks of the actual FULLs. + +The source moving FULLs are + + Ftilde_s=diag(E_s,E_s) L(C0 Q^-1), + Btilde_s=diag(E_s,E_s) U(-Q C0). + +Their entry is the inherited source ABI with P_s appended on both main banks. +All main arrays remain arbitrary and helper autonomy is inherited pointwise +over their spectators. For two forward FULLs, X_out=W X_in is pure on all +112 original X owners. But + + Y_out=W Y_in + (W C0 Q^-1 + E_t C0 Q^-1 E_s) X_in. + +Thus the other 112 owners are not independent Gaussian jobs merely because +their diagonal block is W. For two backward FULLs the analogous pure bank +is Y; mixed orientations need their own full block calculation. This report +does not enter the active p2 caller question. + +## Paid and finite ledger + +The source center-free native price and helper reward are + + P=2201H1+412H2+510H3+127H4+40H5, + H=28H4+7H7+47H8+326H9. + +These are inherited local profiles, not a newly admitted moving-stage supplier. +Two FULLs pay at least 2P and retain at most their two disjoint helper banks +2H, with all those helper inputs distinct. No removed rank-eight center call +is credited again. Unknown closure costs are not subtracted from this bill. + +Known field-level operations over two FULLs are: + +| Item | Count/status | +|---|---| +| Added moving-coordinate P_s/P_t maps | 448 main-field maps: 224 per FULL | +| Four inherited port wrappers | 896 monomial field maps: 448 per FULL | +| Backward convention, if used | At most 448 further monomial maps per backward FULL; retained upper bound | +| Existing center-free dyadic precompensation | 13,192 ADDs: 6,596 per FULL, in addition to the original native work | +| Source Gaussian children | 2P; no changed recursive tariff proved | +| Owned allocation/cleanup introduced by coordinate transport | None: it permutes original fields, not COPY/CLEAR buffers | +| Pair output permutation removal | Two block swaps per affected field in the displayed product; actual fusion/tape price not supplied | +| Optional pure-W two-sided boundary | Two further coordinate maps per affected field; 448 maps if applied to both 112-owner banks | +| Anchor allocation, routing and spectator-volume completion | Unknown full supplier/whole-job cost | +| Coupled-bank correction, terminal decoding and paid restoration | Unknown; inherited direct gauge fails in #5113 | + +The counts above distinguish known operation counts from a complete TM or +compiler tariff. They are not all exact minima or a license to add the upper +bounds as a proved lower bound. Coordinate maps require actual indexed +movement and fixed-tape treatment. Transport itself introduces no denominator +13, but any later C0^-1 decoder still needs its actual rational implementation, +precision and complete ordinary bill. All original native/internal movement, +rounding and helper allocation remain inherited; no such cost is zeroed. + +## Strong optimistic pair screen, without a caller claim + +The source does bind the diagonal pair W to rank 16. Give the proposal the +unrealized favorable grant that BOTH main banks become independent rank-16 +jobs with all code cleanup, output permutations and other costs free. Its +optimistic moment is + + M(theta)=224*16^theta + 2H(theta) - 2P(theta), + theta=1-C. + +The paid rank mass is 2*5263=10526; the granted reward mass is +224*16+2*3471=10526. After cancellation, + + M(theta)= -4402 H1 -824 H2 -1020 H3 -198 H4 -80 H5 + +14 H7 +94 H8 +652 H9 +224 H16. + +Every positive coefficient has rank strictly greater than 5 and every negative +coefficient has rank at most 5. Therefore M(theta)/5^theta is strictly +increasing in theta: each positive term has positive derivative, each negative +term below rank 5 also has positive derivative, and the rank-5 derivative is +zero. Since M(1)=0, M(theta)<0 for 0<=theta<1. In particular the optimistic +pair grant loses for every 00 with q_j=0 and use T_(ej+q) T_(e0+ej). Here T_v(x)=x+(v dot x)v; both v have even weight, hence T_v is orthogonal. Such j exists because q is not the all-ones vector. + +For row j of G put z_j=(wt(row_j G)-1)/2 modulo 2. Define K=Z_z P_G. It is a real signed permutation. The full Gaussian R has entries alpha*(-i)^wt(x+y), with alpha=(1+i)^9/2^9. Orthogonality gives + +wt(G^-1 d)-wt(d) = 2 z dot d (mod 4). + +Indeed the degree-two coefficients vanish modulo four because distinct columns of G^-1 have even dot product; the linear coefficient is the weight of that column minus one. Therefore K R K^-1=R exactly, including absolute phase. K also maps the central line to span(q), and its orthogonal complement to q-perp, at the canonical-frame Lagrangian level. All these statements tensor to every positive digit-column count. + +Let Q be the central C gate, D the product of the other eight C gates, so R=DQ. Let E_i and S_i be the actual retained entrance-line and exit-hyperplane frame operators. With the operator convention that rightmost applies first, use + +input X: E_i K_i Q^-1 +input Y: K_i +output X: K_i^-1 +output Y: D K_i^-1 S_i^-1. + +All four wrappers are monomial. Their Lagrangian incidences prove this for every port, and the scratch verifier checks exact tableaus and absolute phases at every one of the 112 source ports. With A from PR4929, define C_ij= A_ij K_i^-1 K_j. Then the full main endpoint is + +F = diag(D,D) [[I,0],[C Q^-1,I]]. + +C is a physically implementable fixed owner recoding: apply K_i to each owner, apply A among the owners at common physical coordinates, and apply K_i^-1. Its inverse uses A^-1=(A+12I)/13. Since each K_i is real orthogonal and A is real symmetric, C^T=C. Since K_i commutes with R, C commutes with R. The polynomial C^2+12C-13I=0 follows by similarity. The 408 independent helper jobs and every paid Gaussian child are unchanged. + +For the actual raw inverse transpose, F^-T=diag(D^-1,D^-1) [[I,-Q^-1 C],[0,I]], since Q,D are symmetric. Multiply both outputs by D^2, then conjugate the physical X bank by Q^2 (input Q^-2 and output Q^2). These are explicit monomial powers. The result is + +B = diag(D,D) [[I,-Q C],[0,I]]. + +The old source convention using Y-only Q^2 conjugation cannot simply be copied for noncommuting C. The X-only convention above is exact. + +For a prior code B0 commuting with the current D, set G(B0)=diag(B0,Q^-1 B0 Q). The following two constructive local identities hold without requiring C and Q to commute: + +(post X C) F (pre Y C) = G(C B0) F_standard G(B0)^-1, +(post X C^-1) B (pre Y C^-1) = G(C^-1 B0) B_standard G(B0)^-1. + +They use [C,DQ]=0 and [B0,D]=0. Every additional operation on the left is physically cheap fixed recoding. For disjoint fresh blocks, codes from earlier stages commute with the current D. These identities do not yet settle interstage ADD/IDLE compatibility, terminal gauges, productive jobs, or the complete moment. + +## Literal recoding and complete local bill + +The source code has an exact factorization A=I-MM^T/4 with M a 112-by-8 matrix having entries 0,+1,-1 and M^T M=56I. Each mode column has 56 nonzero entries, and each owner row has four. The mode columns are emitted in NORMALIZERS.json and all 12,544 entries are checked against the pinned CODE.json. This factorization is used here as a constructive scalar program, without relying on any common physical address chart for separate Gaussian mode transformations. + +To execute A on arbitrary independent owner fields x, allocate eight owned zero fields t. Compute t=M^T x with 448 signed ADDs; update x-=M t/4 with 448 scaled ADDs; clear the eight owned temporaries. Reading x is finished before any x is updated. Hence no input field is overwritten before its last source read. For A^-1 use the same program with coefficient -1/52, since A^-1=I-MM^T/52. Both are exact rational linear programs. The helper fields of the native producer are never used as scratch, copied as free credit, or erased. + +Conjugating this scalar program by the 112 K_i and their inverses implements C or C^-1. This pays 224 monomial field maps, 896 scalar ADDs and 16 owned CLEARs per recoding, with eight owned fields reusable sequentially. The two additional recodings in either local gauge identity therefore cost at most 448 monomial maps, 1,792 scalar ADDs and 32 CLEARs, with no recursive Gaussian child. The four actual port normalizers contribute 448 monomial maps per native invocation. The displayed backward conversion contributes at most 448 further monomial maps (112 input X powers, 112 output X powers and 224 output D-squares); fusing maps can reduce this upper bound but is not assumed. + +These are field-level operation counts. A lifted K_i is an explicit binary map on nine f-bit address blocks together with signs given by block parity. Its constants, indexed movement and phase passes use the retained native monomial implementation. It is therefore a fixed finite O(V polylog p) nonrecursive operation under that caller's precision/address ABI, not a zero-work instruction. Each fixed rational ADD is likewise charged at its actual scalar precision. In particular the inverse denominator 52 must be implemented and rounded; no free exact real-division oracle is assumed. This lemma makes no independent TM tariff or outer-budget claim. + +The maximum exact component-l1 prefix bound for the scalar A program, including its temporaries, is 57. For A^-1 it is 56 (the output-only bound is 69/13). Signed monomial maps preserve component magnitude. A fixed local sequence has a fixed suffix bound obtained by multiplying elementary bounds 1+|coefficient|; owned CLEAR has bound one. This gives a finite bound for local rounding propagation. The number of local uses, compiler precision and complete outer error allocation still belong to the caller theorem. + +The normalized producer still has its exact PR4929 paid profile + + {1:2201, 2:412, 3:510, 4:127, 5:40} + +and independent helper profile + + {4:28, 7:7, 8:47, 9:326}. + +No productive main ranks are asserted merely from the coupled central ABI. Those depend on the completed caller, its initial/final gauges and every paid correction. + +## Universal scope and reproducible evidence + +PR4929 supplies the arbitrary-input logical identity over Q[FreeGroup72] for its emitted center-free word with ground-chart helper pre-compensation. Its normalized main endpoint is L(A), its raw dual is L(A)^-T, and every one of the 408 helper endpoints is autonomous. This proof is an inherited premise with exact source pins, not a consequence of this normalizer checker. The present wrappers and owner recodings act exclusively on the 224 main fields; new scratch is explicitly owned. Thus the helper block remains autonomous and its independent inputs, requested transforms and paid profile remain unchanged. + +For every f>=1, assign the shared native letters their actual consistent invertible lifted operators. Evaluation of the source free-group algebra is a homomorphism and gives the source logical identity. Independently lift each K_i as its f-fold tensor product, retaining spectator coordinates; its signed-permutation word, the two direct frame identities and its commutation with R lift by operator composition. In every compiled monomial word, P and X act columnwise on the f-bit blocks, D sums its Z4 polynomial over the f columns, and a one-column scalar phase i^gamma becomes i^(f*gamma). Reusing the one-column global phase unchanged would be incorrect. Finally form the owner matrix C_f with entries A_ij K_i,f^-1 K_j,f. One does not tensor the whole 224-by-224 owner matrix and does not assert that tensor powers preserve sums. Instead the finite scalar owner program is evaluated directly in the algebra of these lifted address operators. This proves the central ABI and local gauge identities at every positive width. + +Run `python3 -I -B research/coded-native-caller/normalizers.py` or its optimized `-O` form. The checker authenticates the decompressed actual native payload, CODE.json and retained Clifford source before executing the latter. It verifies all 112 real signed normalizers, 57,344 explicit weight-congruence addresses, 896 forward/backward monomial wrappers and eight exact frame/block identities per port, including absolute phase. Each emitted wrapper is separately lowered to a literal P/D/X/phase-only word and checked against its defining expression by exact tableau and absolute-phase state. No C gate remains in an emitted wrapper. The independent incoming-column and outgoing-row identities imply all 5,824 nonzero off-diagonal code blocks, without sampling those pairs. It also executes the eight-mode recoding on all 112 arbitrary-input basis columns in both directions. Omitting the essential signed phase is rejected at every affected port. The default command compares a regenerated mathematical receipt and performs no writes; `--write` is the explicit authoring path. + +Source pins: canonical main 624de9dc66858af0945e5f8a0942488d62280d43, `research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz`, decompressed SHA-256 cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd; PR4929 head 361f5d4100640177d6a983dd2f336021c75bfd5e, `research/native-center-free-code/CODE.json`, SHA-256 8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0; canonical `research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py`, SHA-256 2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962. Gzip container bytes are not substituted for decompressed source identity. + +Credit Dugongue's PR4929 for the coded producer and stable code; Cinna Davis's PR4694/4698 and the original cache/helper construction; Cao Yifan's PR4610 native word; the retained zxv, Jacob Alan Sussman, Cinna Davis and Clifford/native/compiler lineage. The exact canonical-frame implementation and phase conventions are retained source material. The constructive real centralizing normalizers, their explicit lifted words, X-only raw-dual convention and costed local code gauges are the additions here. New work is Apache-2.0 and has substantial OpenAI Codex assistance; no formal-kernel or independent human acceptance is asserted. diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__PROOF.md b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__PROOF.md new file mode 100644 index 0000000000..60fecc67b7 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__PROOF.md @@ -0,0 +1,179 @@ +# A common owner code with moving Gaussian stages + +Cinna Davis; substantial OpenAI Codex assistance. Apache-2.0. + +This is a changed local interface and a rejected direct caller substitution. +It is not a supplier, a multiplication theorem or a kappa improvement. +The normalizer and coded-producer premises are Dillon's PR4933 and +Dugongue's PR4929, respectively. Their complete native word is not replayed +here. The proof below states exactly where those premises are used. + +## 1. Stage-local normalizers cannot give a common code + +Let the binary label space be a direct sum `Z + V_s + V_t + W`, where +`Z` is the shared central block and `V_s,V_t` are distinct fresh blocks. +At stage s each invertible label map `G_i,s` is supported on `Z+V_s`: +it preserves this subspace and is identity on its displayed complement. +Require `G_i,s Z = L_i,s`, with `L_i,s` distinct for different owners i. +The signed monomial normalizer K_i,s has this label map. Arbitrary +nonzero phases do not change the following necessary condition. + +For a fixed scalar owner matrix A, write the physical code block as + + C_s[i,j] = A[i,j] K_i,s^-1 K_j,s. + +Suppose `A[i,j] != 0` and `i != j`. If `C_s[i,j]=C_t[i,j]`, equality of +the nonzero monomial matrices implies equality of their label maps: + + H = G_i,s^-1 G_j,s = G_i,t^-1 G_j,t. + +The first expression preserves `Z+V_s`; the second preserves `Z+V_t`. +Both inverses have the same properties. Thus H preserves their +intersection Z bijectively. It follows that + + G_j,s Z = G_i,s H Z = G_i,s Z, + +contradicting the distinct-line premise. This rules out a common code +within this stage-local monomial class, for any choice of its normalizers. +It does not enumerate just the particular source normalizers. It applies +to arbitrary positive digit-column width by taking Z to have that width +and each fresh block eight times that width. + +For the actual 112 source ports the 112 binary lines are distinct and A +has zero diagonal and 5,824 nonzero ordered off-diagonal blocks. All +5,824 therefore obstruct common-code equality. In the pinned source +choice, block (0,1), coefficient -1/2, maps input label 1 to label 22 at +the anchor stage and 5,632 at the fresh stage in the 17-bit embedding. +Different output labels suffice irrespective of phase. + +The hypotheses matter. Equal-line owner pairs can have identical +normalizers and hence common identity relative maps. Equal stages have +the same code. The global construction below deliberately moves +spectators and lies outside the stage-local premise. + +## 2. A constructive escape by moving coordinates + +Add one common eight-axis anchor block V_0, distinct from all fresh stage +blocks V_s. Let P_s exchange V_0 and V_s and fix the central axis and +all other labels. These are real, self-inverse coordinate permutations. +Let K_i,0 be the pinned real signed anchor normalizers. Instead of the +stage-local normalizers `K_i,s=P_s K_i,0 P_s^-1`, use the intertwiners + + K'_i,s = P_s K_i,0. + +They still take the central line to the actual stage-s port line, but +move the inactive fresh labels into the anchor. Their relative maps are + + (K'_i,s)^-1 K'_j,s = K_i,0^-1 K_j,0. + +Thus they give the same physical owner code C_0 at every stage, including +all signed phases. This is an exact constructive common code once +spectator motion is allowed. It is not a centralizing-normalizer theorem: +the K'_i,s generally intertwine two stage Gaussians rather than commute +with the stage-s Gaussian. + +Here is the resulting concrete endpoint without assuming any new native +semantics. Let Q be the central Gaussian, D_0 the product on the eight +anchor axes, `D_s=P_s D_0 P_s^-1`, and +`C_s=P_s C_0 P_s^-1`. All P_s commute with Q. The inherited PR4933 ABI is + + F_s = diag(D_s,D_s) L(C_s Q^-1), + B_s = diag(D_s,D_s) U(-Q C_s), + +where L(T)=[[I,0],[T,I]] and U(T)=[[I,T],[0,I]]. Append P_s to both +main input banks, before this ABI. Direct block multiplication gives + + F_s diag(P_s,P_s) = diag(E_s,E_s) L(C_0 Q^-1), + B_s diag(P_s,P_s) = diag(E_s,E_s) U(-Q C_0), + E_s = P_s D_0. + +These equations require no commutation of C_0 with Q or P_s. Their +source maps are invertible on every arbitrary main input. They introduce +no CLEAR or claimed independent helper input. The source producer's +autonomous helper outputs remain its inherited premise. The inserted +permutations act on the 224 main fields only. This gives a complete +local input/output contract, not a complete controller. + +Every construction here lifts to arbitrary digit-column width: swap +entire blocks columnwise; lift the source signed K_i columnwise with its +correct accumulated phase; execute the owner scalar coefficients once +on the owner factor. No tensor power of a sum of owner blocks is used. + +## 3. Noncommuting E_s words retain distinct-stage Gaussian ranks + +Consider distinct nonzero stage labels s_1,...,s_k in chronological +order. Write `P_word=P_s_k ... P_s_1`. Moving coordinate permutations +to the left gives the exact formula + + E_s_k ... E_s_1 + = P_word D_0 D_s_1 ... D_s_(k-1). + +One proof proceeds inductively. In the normal form P_word D_support, +left multiplication by `P_s D_0` adds the D block at +`P_word^-1(0)`. For distinct previous swaps this block is the most +recent preceding stage label, or 0 for the empty word. This gives the +displayed support and leaves each Gaussian exponent equal to one. +The D blocks commute because their coordinates are disjoint. + +After removing the explicit monomial P_word, the word therefore has +8k Gaussian axes; adjoining Q or Q^-1 adds one. This is the exact +Gaussian support rank of this operator, not proof that the operator is +an admitted recursive target. P_word removal, ambient width, spectator +multiplicity and completion still require a supplier bill. + +The E_s themselves do not commute. Distinctness also matters: the word +E_1^3 has only eight odd Gaussian axes after monomial removal rather +than 24, since `E_1^2=D_1 D_0` and D_0^2 is monomial. The checker tests +all 1,956 distinct ordered nonempty words on six stages and this +repeat control. Those checks corroborate the induction; they do not +establish arbitrary k by enumeration. + +## 4. The direct controller substitution still fails + +The inherited relation is `[C_0,D_0 Q]=0`. Since `E_s Q=P_s D_0 Q`, + + [C_0,E_s Q]=0 iff [C_0,P_s]=0. + +Indeed multiply the commutation equation on the right by +`(D_0 Q)^-1`, using its commutation with C_0. But +`P_s C_0 P_s^-1=C_s`, and Section 1 shows `C_s != C_0`. +For the source choice their binary maps differ in every one of the +5,824 nonzero code blocks. This also gives an actual failed block +identity, rather than only an unavailable sufficient hypothesis. +Put `F_standard(E)=diag(E,E)L(Q^-1)` and +`G(C)=diag(C,Q^-1 C Q)`. The proposed forward gauge is + + diag(C,I) F_tilde diag(I,C) = G(C) F_standard(E). + +Its lower-left block difference is + + E C Q^-1 - Q^-1 C E = Q^-1 (E Q C - C E Q), + +where E commutes with Q. This is nonzero by the preceding argument. +Thus PR4933's local forward gauge identity itself fails for E_s. Their physical +common code and their rank-preserving products do not by themselves +license that caller substitution. A different caller must prove its +own full block identities. This is a stop gate, not a universal +obstruction to moving-coordinate callers or coded recursive families. + +## 5. Obligation and cost ledger + +| Obligation | Status | +|---|---| +| Source arbitrary-input coded native ABI and helper autonomy | Inherited PR4929/PR4933 premise, exact source pointers retained | +| Stage-local common-code exclusion | Proved above for the stated support/line contract | +| Global common code and transported F/B endpoints | Exact construction and block proof above | +| Distinct-stage product ranks | Proved above; finite independent arithmetic check supplied | +| Extra coordinate permutations | 224 whole-main-field P_s maps per transported FULL; finite-tape price unknown | +| Anchor space | Eight additional label axes, with every added spectator and completion charge unpriced | +| Original native child/helper profiles | Source profiles retained as local premises; no complete new supplier invoice | +| Center deletion | Existing center-free producer property, not new independent credit | +| Complete coded controller, restoration and terminal decoding | Unknown; direct inherited gauge fails Section 4 | +| Precision, routing, recursive compiler, BIT and outer transfer | Unknown for this interface | + +For n fresh eight-axis stages plus Q, the original ambient width +8n+1 becomes 8(n+1)+1. Those eight new axes are never free stock or +productive main Gaussian credit. The preserved rank of a target word +does not remove this change in its surrounding width. Unknown costs +are not zero. The next construction must justify its full completed +moment before a larger search or claimed kappa gain. diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__README.md b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__README.md new file mode 100644 index 0000000000..5c78fb365e --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__README.md @@ -0,0 +1,75 @@ +# Common code through moving Gaussian stages + +**Changed local interface and a rejected direct controller substitution; no new κ.** + +An explicit coordinate transport makes the center-free producer's physical +owner code identical at every stage. The price is a moving Gaussian stage +`E_s=P_s D_0`, 224 additional main-field coordinate permutations per FULL, +and eight extra anchor axes. Distinct-stage products retain exactly eight +Gaussian axes per stage after a specified output permutation. The inherited +controller's commutation condition nevertheless fails. This package preserves +the construction and identifies that next algebraic obligation. + +The [proof](PROOF.md) first excludes a common code for **any** stage-local +monomial normalizers with the specified distinct port-line images. Its proof +uses support intersection, not exhaustive normalizer enumeration. It then +constructs global intertwiners `K'_i,s=P_s K_i,0`, proves their common-code +and arbitrary-input F/B endpoints, and derives the exact noncommuting stage +word formula. All 5,824 actual nonzero owner blocks disagree between two +stage-local codes but agree under the global transport, including signed +phases. The preserved Gaussian ranks do not admit the new jobs or price +spectator completion. + +The decisive gate is `[C_0,E_s Q]=0 iff [C_0,P_s]=0`. The latter fails on +all 5,824 nonzero blocks in the source fixture. A direct reuse of PR4933's +local gauge is therefore rejected. This does not exclude another caller, +a recursively coded family, or transport that changes the boundary contract. +No complete moment is asserted; unknown costs remain unknown. + +Reproduce with CPython 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/common-code-moving-stages +python3.12 -I -O -B research/common-code-moving-stages/verify.py +``` + +The replay authenticates all live source hashes, checks the 112 normalizers, +57,344 exact phase congruences, all 5,824 nonzero code blocks, both normalizer +inverse orders and all 1,956 distinct ordered words on six fresh stages. +A separate address-array calculation over F_65537 checks the word formula +on two deterministic vectors per word, using the actual one-axis Gaussian +coefficients. This corroborates the written all-width proof; a finite vector +check alone is not that proof. Equal-line/same-stage positive controls, +noncommuting-order and repeated-stage rank controls retain the scope boundary. +The normal and optimized registered commands are read-only. RESULT.json is +regenerated only by the explicit authoring option `--write-result`. + +Canonical base is `81e9bd69e4a5b00ba9c713a1620e36d576d5522e`, priority revision 7; +selected conditional κ remains 0.00302015. SOURCES.json pins the exact source +bytes; TASK.json retains the changed-card decision, overlap coverage and next +questions. The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768) +was claimed before the checks. No native-word regeneration, complete +controller/compiler/BIT/outer replay, Lean proof, independent human review +or selected-frontier change is claimed. + +## Open next questions + +1. Can the transported F/B endpoints be consumed by a changed caller without + assuming `[C_0,E_s Q]=0`? Start with one complete arbitrary-input pair and + its actual thin queries; charge every added oracle call and both returns. + Stop if the negative bank still requires an unpriced Q-conjugated code. +2. Can an anchor be recycled with a proved boundary and unchanged target rank? + Start with one actual source target word and all its spectator labels. + The new eight-axis anchor and its completion costs currently remain open. +3. If a caller survives, derive its complete completed moment, rounding, + movement and compiler invoice before another construction search. The + preserved 8k target rank alone grants no recursive saving. + +Credit Dillon/PR4933 for physical signed normalizers and the coded ABI; +Dugongue/mdumitrean/PR4929 for the center-free producer and code; +Cayden Burkart/PR4940 and JoyboyBrian/PR4936 for the caller and physical-pair +question; Cao Yifan/PR4610; Cinna Davis/PR4694/4698/4470; zxv; +Jacob Alan Sussman; and the full inherited native/compiler/precision lineage. +Their archived mathematics is retained as a source premise. New work by +Cinna Davis, with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. No global novelty claim for coordinate transport is intended. diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__SOURCES.json b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__SOURCES.json new file mode 100644 index 0000000000..e732864e85 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/GAUGE.md", + "usage": "input", + "git_blob": "13269f7b1f98535151de173477f9e7d9a0d81079", + "sha256": "09c4e86d99245734761569efd13473623ffdd857e9eae092bd7f54bfd2f42f06" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coded-native-caller/PHYSICAL.md", + "usage": "input", + "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f", + "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078" + }, + { + "path": "research/native-center-free-code/CODE.json", + "usage": "input", + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0" + } + ] +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__TASK.json b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__TASK.json new file mode 100644 index 0000000000..fffb0d7e73 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__common-code-moving-stages__TASK.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 7, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a common physical code by moving stage coordinates, prove its distinct-stage product ranks, and test the inherited controller commutation gate.", + "scope_change_reason": "The PR4933 coded caller leaves terminal code admission open. Instead of another fixed center invoice or terminal support test, change the spectator/coordinate contract and expose its exact F/B endpoint.", + "bottleneck_link": "A common code might enable global caller absorption of the existing center-free producer, but transported stages must satisfy a new caller theorem and pay anchor completion.", + "budget_minutes": 60, + "stop_rule": "Reject direct reuse of the inherited gauge if [C_0,E_s Q] is nonzero. Preserve a scoped construction rather than expand an unpriced compiler or call it a higher kappa.", + "outcome": "partial", + "evidence": "PROOF.md and RESULT.json: common transported code on all 5824 actual nonzero blocks, stage-local support exclusion, exact moving F/B endpoints, distinct-word Gaussian rank formula, and failed inherited commutation gate.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance for reasoning, code, verification and prose; no subagents or independent human review.", + "open_questions": [ + { + "question": "Can a changed caller consume the moving F/B stages without assuming their failed code commutation?", + "why_it_matters": "This would supply a real consumer for the common physical code.", + "first_step": "Prove all blocks of one arbitrary-input thick/thin pair and charge its query/restoration bill.", + "blocked_by": "The inherited gauge requires a commutator that is nonzero." + }, + { + "question": "Can the eight anchor axes be recycled or completed within a favorable full invoice?", + "why_it_matters": "Their added width and spectator completion are nonzero costs.", + "first_step": "Bind one actual target word and the input/output state of every anchor coordinate.", + "blocked_by": "No full completed moment, routing or precision bound is supplied." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768", + "overlap": { + "canonical_main": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "open_prs": 320, + "discussion_records": 4233, + "local_records": 6824, + "specific_terms": [ + "common code", + "simultaneous centralizer", + "stage-local" + ], + "scope": "Complete cached open-PR/discussion pagination and local note inventory; bodies and notes only, no novelty guarantee." + } +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__native-center-free-code__README.md b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__native-center-free-code__README.md new file mode 100644 index 0000000000..26144655f8 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/pair-inventory/source/research__native-center-free-code__README.md @@ -0,0 +1,32 @@ +# A center-free native producer with an explicit eight-mode port code + +This emits an exact changed native word with all eight rank-8 owned-center calls removed. All 632 persistent inputs remain arbitrary and independent, all 408 helper jobs remain autonomous, and the actual entrance/exit charts stay unchanged. The main logical endpoint is + +```text +(X, Y, H) -> (X, Y + A X, H). +``` + +The explicit 112-by-112 code is `A = I - 14 P`, where `P` is an orthogonal projection of rank 8. Its eigenvalues are 1 (104 times) and -13 (8 times), with `A^-1 = I + (A-I)/13`. The forward and actual raw-dual paid profile is `{1:2201, 2:412, 3:510, 4:127, 5:40}`: eight rank-8 children disappear, with no new Gaussian child. The simple compensation uses 6,596 fixed dyadic ADDs. + +**No improved κ or complete multiplier is established.** This code changes the cross-transfer. Treating it as the old uncoded supplier would be wrong. Its inverse is an exact rational matrix, not a free dyadic operation across distinct physical input charts. + +Read [CODED-PROOF.md](CODED-PROOF.md) for the constructive theorem and [ATTRIBUTION.md](ATTRIBUTION.md) for overlap and predecessor credit. + +## Reproduce + +Only Python 3.12 and its standard library are required; there are no Windows paths, external commands, GPU libraries or platform-specific native binaries in the scientific verifier. + +```sh +python3.12 -I -B research/native-center-free-code/coded_verify.py +python3.12 -I -O -B research/native-center-free-code/coded_verify.py +python3.12 -I -B research/native-center-free-code/verify.py +python3.12 -B scripts/research_package.py --package research/native-center-free-code +``` + +The written all-width proof uses evaluation of a rational free-group identity and authenticated existing native operations. Finite replay is evidence for that identity; it is not a Lean kernel or independent human audit. The inherited source physical implementation and analytic multiplication hypotheses are not independently reproved. No selected cold replay or hosted CI pass is claimed. + +## Open next questions + +The structured questions are in [TASK.json](TASK.json). The immediate target is a paid, source-compatible adapter or caller exploiting the eight-mode code. An actual output/input chart conversion, odd-denominator implementation, full moment, storage, precision and outer budget must be supplied before claiming a κ improvement. + +Prepared by Dugongue with substantial OpenAI Codex assistance from the lead and three workers. Apache-2.0. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/CHECK-RESULT-OPTIMIZED.json b/research/moving-anchor-no-q-ceiling/evidence/review/CHECK-RESULT-OPTIMIZED.json new file mode 100644 index 0000000000..e7697e91fc --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/CHECK-RESULT-OPTIMIZED.json @@ -0,0 +1,78 @@ +{ + "C_zero_rank_mass_margin": 0, + "actual_one_bank_separation": { + "max_negative_rank": 5, + "min_positive_rank": 7, + "negative_rank_mass": 15453, + "positive_rank_mass": 12765 + }, + "all_p_source_admission_claimed": false, + "cancelled_signed_profile": { + "1": -6603, + "2": -1236, + "3": -1530, + "4": -297, + "5": -120, + "7": 21, + "8": 141, + "9": 978, + "24": 224 + }, + "comparison_domain": [ + "15108879/5000000000", + "339999/100000000" + ], + "contract_mutants_rejected": [ + "free_Q_rank25", + "448_maps_as448_owners", + "new_main_owners_per_FULL", + "anchor_axes_as8_owners", + "duplicate_helper_reward", + "omit_terminal_FULL_native_bill", + "omit_one_rank1_child", + "free_Q_breaks_equal_mass_certificate" + ], + "exact_symbolic_bound": "M(C)<=15453*(7^(-C)-5^(-C))<0 for C>0", + "native_or_emitter_or_compiler_run": false, + "new_kappa": null, + "paid_recursive_lower": { + "1": 6603, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "rank_separation_certificate": { + "max_negative_rank": 5, + "min_positive_rank": 7, + "negative_rank_mass": 15453, + "positive_rank_mass": 15453 + }, + "retained_route_domain": "00", + "native_or_emitter_or_compiler_run": false, + "new_kappa": null, + "paid_recursive_lower": { + "1": 6603, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "rank_separation_certificate": { + "max_negative_rank": 5, + "min_positive_rank": 7, + "negative_rank_mass": 15453, + "positive_rank_mass": 15453 + }, + "retained_route_domain": "0=7 and negative ranks <=5, proving M(C)<=15453*(7^(-C)-5^(-C))<0 for all C>0. Required [.0030217758,.00339999] is covered; actual one-bank reward is lower. Ten source inputs and normal/optimized exact checks pass with eight mutation rejections. +What remains uncertain: Source native/phase semantics remain inherited. No actual second autonomous main bank, arbitrary-Y restoration, terminal consumer, complete finite tape/precision/storage bill, new supplier, all-p caller family, compiler admission or κ is established. Changed consumers or native profiles are outside this rejection. No emitter, physical fixture, compiler/Lean run, root digits or hosted CI. +Smallest useful next task: Stop this fixed invoice. Reopen only with a source-bound changed paid/target inventory or a new independently proved consumer, retaining every original owner/helper and pricing all corrections; do not add a free Q axis or count moving maps/anchor coordinates as new owners. +Reproduction command and expected runtime: python3 -I -W error -B outputs/moving-anchor-ceiling-review-20261023/check_ceiling.py; repeat with -O. Standard library, under one second per mode here, reads ten self-contained frozen inputs and prints only stdout; no source module or author checker executes. Upstream package/commit/export checks remain pending. +Predecessor credit: Cinna Davis #5113; Dillon #4933; Dugongue/mdumitrean #4929; Astra terminal design; source-inventory worker; Cao Yifan, Cayden Burkart, JoyboyBrian, zxv, Jacob Alan Sussman and the retained native/Clifford/compiler/precision/analytic lineage. Substantial OpenAI Codex assistance; Apache-2.0. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/PR-BODY-PROPOSED.md b/research/moving-anchor-no-q-ceiling/evidence/review/PR-BODY-PROPOSED.md new file mode 100644 index 0000000000..fb10973d44 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/PR-BODY-PROPOSED.md @@ -0,0 +1,62 @@ +## Change and mathematical scope + +The #5113 terminal-anchor schedule completes three existing eight-axis blocks +algebraically, but its optimistic recursive invoice already loses. Independently +verify the exact three-FULL word Es,Et,E0, yielding PtPsD0DsDt with rank 24 and +no central Q bonus. Grant both 112-owner banks autonomous rank-24 targets, +retain all 1,224 fresh helper jobs once, and grant all added finite work free. + +After cancelling 84H4, positive and negative rank masses both equal 15,453; +positive ranks are at least 7 and negative ranks at most 5. Therefore +`M(C)<=15453*(7^(-C)-5^(-C))<0` for every C>0. This is an exact scoped invoice +rejection, not an admitted all-p caller family, a universal moving-coordinate +obstruction, a physical lower bound for changed native implementations or a κ +claim. The actual one-pure-bank inventory earns less and still lacks arbitrary-Y +restoration. Different consumers or target ranks require a fresh bill. + +## Task and overlap + +Root assigned independent ceiling/source/inventory verification, separate from +Astra's terminal design and the parallel source-inventory worker. Source #5113 +is b893ba6bd6c77c6e7efc48acb6f448218df671b7. Its exact three-stage contract, +source P/H profiles and current failed-gauge boundary remain explicit. +The 448 count is moving-coordinate field maps, not owners; anchor axes are +coordinates within each original field. Dillon's active p2/IDLE/port-intertwiner +work, broader caller searches and the author's unspecified larger-K research +are outside scope. Root must refresh overlap and pin publication base before +opening a focused PR. These local drafts perform no public action. + +## Validation + +Ten frozen inputs authenticate against the inventory worker's exact-head source +manifest and frozen design/report hashes. The independent standard-library +checker parses literal source P/H, composes a four-coordinate symbolic stage +normal form, reconstructs complete three-FULL profiles and verifies the exact +separated-mass certificate. Normal and optimized warning-strict receipts are +byte-identical, below one second per mode here. + +Eight mutation controls reject a free Q bonus, maps counted as owners, new +main banks per FULL, anchor axes counted as owners, duplicate helpers, an +omitted terminal native bill, a missing rank-one child and the resulting +unequal-mass Q certificate. A repeated-stage control prevents applying the +rank-24 word formula outside distinct stages. No author checker, source native +module, physical fixture, emitter, compiler, Lean, numerical/root scan, selected +cold replay or hosted CI ran. Package/commit/export preflight remains pending. + +## Credit + +Cinna Davis #5113 supplies the common physical code and moving-stage theorem; +Dillon #4933 the physical normalizers/ABI; Dugongue/mdumitrean #4929 the cheaper +helper-clean producer. Astra owns the terminal question/design and the separate +inventory worker owns source extraction and owner/axis/price typing. Retain +Cao Yifan, Cayden Burkart, JoyboyBrian, zxv, Jacob Alan Sussman and the native, +Clifford, compiler, precision and analytic lineage. Substantial OpenAI Codex +assistance; Apache-2.0. Source native semantics remain inherited premises. + +## Open next questions + +Stop this three-FULL invoice before implementation or compiler retuning. A +reopening needs a source-bound changed paid/target profile or a new consumer +with exact autonomous jobs, complete helper/spectator restoration, actual +movement/precision/storage costs and funded compiler/outer transfer. The +parameterized 5151p invoice lemma does not establish actual all-p callers. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/REVIEW.md b/research/moving-anchor-no-q-ceiling/evidence/review/REVIEW.md new file mode 100644 index 0000000000..a0b813acc8 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/REVIEW.md @@ -0,0 +1,200 @@ +# Independent ceiling review: the three-FULL terminal-anchor relaxation + +**PASS for the stated three-stage contract.** Even granting both existing main +banks independent rank-24 Gaussian targets and all added finite movement, +normalization, cleanup, precision and consumer work for free, the recursive +margin is strictly negative for every C>0. The required comparison interval +[.0030217758,.00339999] is covered. This rejects that fixed optimistic invoice; +it is not a universal obstruction to moving coordinates, changed consumers, +shared native children or other paid profiles. + +## Exact inputs and scope + +Source is Cinna Davis's #5113, +`b893ba6bd6c77c6e7efc48acb6f448218df671b7`, package +`research/common-code-moving-stages`. Six exact-head source snapshots were +received from the separate inventory worker and byte-checked against its +manifest. The native profile/helper premise comes directly from the frozen +`research/coded-native-caller/PHYSICAL.md` and is corroborated by the retained +`research/native-center-free-code/README.md`. + +The reviewed design is Astra's `CONTRACT-AND-SCREEN.md`, SHA256 +`c49164ac1ff5a9f5dfc612ad2f4ae2e1b630617abb7e5716b408df85cfbf8570`, +and RESULT.json, SHA256 +`6b98e7a080412d206fe58d5001a7aa0a69aa2ccf9754597e603b0498cce87be6`. +Inventory report SHA256 is +`5643e5bde8df3cd14bb948a7bfb4c0fa4340673f8ae7f4cc19d2708a9adc94a2`. +All ten inputs are copied unchanged to `frozen/` and bound by SOURCES.json. +This authenticates the reviewed bytes against the supplied exact-head source +manifest. It does not independently replay their native semantic premises or +perform a new online GitHub retrieval. + +The concrete terminal schedule is **p=3 only**, on the same pair of 112-owner +banks: chronological Es,Et,E0 with E0=D0 and distinct nonanchor stages s,t. +The source's general distinct-stage word induction is not a complete family +of admitted callers. No all-p terminal-family admission or p sweep is claimed +by this review. The separate inventory report's p=2 pair is consistent but is +not substituted for the reviewed triple. + +Root/monitor supplied canonical main +`bf5519aa000c0dac09e0c3fd2706558c4af6a481` and unchanged governing/selected +blobs relative to the previous81e9 pin. Overlap/ownership clearance is delegated +bounded monitor evidence, not a fresh exhaustive survey here. No public action +occurred. + +## Exact stage rank, dimensions and productive eligibility + +The source gives Es=PsD0 and Et=PtD0, where P exchanges the eight-axis anchor +block with a fresh eight-axis block. D0,Ds,Dt act on disjoint blocks. Therefore + +``` +E0 Et Es = D0 Pt D0 Ps D0 = Pt Ps D0 Ds Dt. +``` + +The checker independently composes coordinate permutations and commuting +Gaussian-block exponents in the normal form P D. It obtains one D on each +of the three eight-axis blocks and none on the central Q coordinate. Removing +the displayed permutation therefore leaves rank24, in ambient25, not rank25. +This is a source-premise algebra check, not a native program execution or a +proof of all exact phases independently of #5113's inherited native premises. + +The source moving forward FULL has +`diag(Ej,Ej)L(C0 Q^-1)`. Its triangular structure gives the top-bank diagonal +word W on 112 original X owners. The Y bank is coupled to X and has not been +proved an autonomous target. The favorable screen nevertheless grants **both +224 original main owners** independent rank24 jobs. It does not count a new +224-owner bank at each FULL. Each FULL retains a distinct original408-helper +inventory: three calls give1224 helpers, credited once. + +The pure-X endpoint alone is not admission of a supplier restoring arbitrary Y +spectators. That restoration is among the unpaid obligations granted free for +the exclusion. The one-bank comparison below is an inventory relaxation too. + +The anchor's eight axes are coordinates within every arbitrary owner field, +not eight owner arrays. Their enlarged spectator volume is not discarded. +The448 added P maps are224 maps for each of the two nonanchor FULLs; the +terminal P0=I adds no moving P map. Neither these448 maps nor the further224 +proposed composite output normalizers create productive owners. Their actual +fixed-tape bills remain unpaid; setting them to zero is an explicit favorable +grant for this negative screen. + +There is no Q or Q^-1 in the diagonal word W. Its occurrence in a FULL's +off-diagonal shear does not supply an autonomous extra Gaussian axis. A changed +consumer establishing another endpoint would require a new target profile and +complete bill, and is outside this rejection. In particular a free rank25 +target grant changes the problem and invalidates the mass certificate below. + +## Legitimate lower bill and exact rank separation + +For each literal unchanged source FULL, the inherited local recursive bill and +autonomous helper inventory are + +``` +P0={1:2201,2:412,3:510,4:127,5:40}, +H ={4:28,7:7,8:47,9:326}. +``` + +P0 is a lower bill for the proposal that executes those complete source calls +and possibly adds corrections: each call retains every source child. It is +not a universal lower bound for a redesigned native implementation. In +particular the cheaper #4929 profile is granted; no additional #4948 rank-one +repair charge is imposed. Granting fewer paid children than an actual chosen +implementation only strengthens this exclusion. All new recursive corrections +are nonnegative paid burdens in this additive model. + +The source helper jobs are independent arbitrary original inputs under its +inherited autonomy premise. H is the complete per-call reward, not a pool of +scratch or reusable copied credits. Even granting every one of those jobs +plus both main targets gives the source-bound optimistic reward offer + +``` +U(C)=224 H24(C)+3H(C), L(C)=3P0(C), +H_r(C)=r^(1-C), H_0=0. +``` + +The known one-pure-bank contract earns less by112H24. Thus U is a legitimate +upper relaxation for that known contract and for the stipulated two-bank +rank24 offer. It is not an upper bound on every conceivable future consumer's +different target inventory. Extra width, scratch, copied sources or dependent +output recodings do not silently enlarge the eligible reward here. + +The complete raw profiles are + +``` +T=84H4+21H7+141H8+978H9+224H24, +P=6603H1+1236H2+1530H3+381H4+120H5. +``` + +After cancelling84H4, the positive rank mass is + +`21*7+141*8+978*9+224*24 = 15453`, + +and the negative rank mass is + +`6603+1236*2+1530*3+297*4+120*5 = 15453`. + +Every positive rank is at least7; every remaining negative rank is at most5. +Since `H_r=r*r^(-C)`, for every C>0, + +``` +M(C)=T(C)-P(C) + <=15453*7^(-C)-15453*5^(-C) + <0. +``` + +This is an exact symbolic certificate; it requires neither floating-point +evaluation nor an unchanged-root digit extraction. At C=0 the margin is +exactly0, so no strict-negative conclusion is asserted there. The retained +moment route uses00 sign. +The actual one-bank offer is strictly worse by112H24>0. + +The parent shorthand `5151p(7^-C-5^-C)` is a valid arithmetic lemma for the +stipulated profiles `224H_(8p)+pH-pP0`, integer p>=1. Its source-bound instance +here is **p=3**, with5151p=15453. The parameterized invoice lemma does not +establish that actual all-p moving-anchor callers, inventories or autonomous +target outputs exist. + +Directly paying one Q transform on each granted main owner also cannot help +this invoice: it adds224H1 and reward224(H25-H24). For00} + negative = {r:-n for r,n in profile.items() if n<0} + need(positive and negative, "Both signed supports required") + a,b = min(positive),max(negative) + mass_plus = sum(r*n for r,n in positive.items()) + mass_minus = sum(r*n for r,n in negative.items()) + need(a>b and 00", + "retained_route_domain":"00. No emitter or further caller expansion is warranted by this schedule. This is not a universal obstruction to moving-coordinate or coded recursive families. + +## Exact source and ownership gate + +Source: Cinna Davis / 1337isnot1337, PR5113, `b893ba6bd6c77c6e7efc48acb6f448218df671b7`, package `research/common-code-moving-stages`. Its parent is `d87301c0faee971d492091ce8b7314233ec51c6b`; the only current-head change is the explicit failed forward lower-left block in PROOF.md section4. The verifier, RESULT and retained input bytes are unchanged. The monitor authenticated PROOF/TASK/README and reported exact-head ownership at09:42–09:48UTC. Canonical discussion4930 comment19142768 is a released bounded claim with no replies; PR comments remained empty. The author continues unspecified larger-K work, so a broad caller search is not cleared. + +The monitor found no precise owner of this isolated terminal-anchor word/inventory question in its bounded current coverage through5117. This is not exhaustive novelty evidence. Dillon's active whole-p2 code transport, both paid-IDLE pairs, all four banks, commonD1D3Q, port intertwiners and packaged unary query theorem are excluded. No public write was performed. Current main is `bf5519aa000c0dac09e0c3fd2706558c4af6a481`; the monitor verified all nine guidance/selected blob hashes unchanged from the prior81e9 pin. + +## Constructive hypothesis and exact algebra + +Use three existing eight-axis blocks V0,Vs,Vt, plus the central Q axis: ambient25. V0 is the common anchor; it is not eight new owner arrays. Let Ps and Pt exchange V0 with their respective blocks, and let Dj be the Gaussian product on blockj. Source moving stages are Es=PsD0, Et=PtD0. Choose a terminal anchor stage E0=D0, whose inserted moving permutation is identity. + +The exact target-word identity is + + E0 Et Es = D0 Pt D0 Ps D0 + = Pt Ps D0 Ds Dt. + +The proof uses D0Pt=PtDt, D0Ps=PsDs and disjoint-block commutation. After explicitly removing PtPs, all three existing eight-axis blocks receive one Gaussian. There are24Gaussian axes, not25: the central Q in the source FULL's off-diagonal code is not a free diagonal target. This avoids adding a fourth eight-axis anchor block. It does not prove a complete FULL caller. + +For the scalar diagonal word W=PtPsD0DsDt, the same-basis inverse transpose is W^(-T)=PtPs(D0DsDt)^(-T). A valid inverse-transpose partner must use that physical permutation and inverse-transpose Gaussian orientation, with the actual conjugate charts. Neither a scalar transpose substitution nor an unchanged backward chart is certified here. We implement no backward partner. + +## Actual main endpoint and mandatory stock + +Each source transported forward FULL has exact main endpoint + + Ftilde_j = diag(Ej,Ej) L(C0 Q^(-1)). + +On arbitrary independent X,Y, a product of three such forward endpoints gives the top bank X'=WX. The lower bank contains WY plus code-dependent terms from X. Thus one bank of112owners has the indicated diagonal word. The second bank is not an autonomous Gaussian target without a new consumer/restoration proof. This is the precise partial-productive-subspace hypothesis; no full-code inverse or paid-IDLE construction is substituted. + +The persistent main inventory is112X plus112Y, not224new main owners per FULL. Use three disjoint source helper inventories,408 per invocation, for1224independent helper inputs and outputs, each counted once. All actual source chart changes, absolute phases and helper-autonomy premises remain inherited from the pinned PR4929/PR4933 lineage. Owned source scratch is not productive stock. + +The source helper target profile per invocation is {4:28,7:7,8:47,9:326}; the paid profile is {1:2201,2:412,3:510,4:127,5:40}. The parallel inventory worker authenticated these from the5113retained source. The eight anchor axes occur within every owner's address domain; they are not eight extra independent owner rewards. + +The two nonanchor FULLs insert224Ps/Pt maps each,448total. The terminal anchor FULL inserts0moving maps because P0=I; its inherited native/wrapper bill remains. Normalizing both main outputs can require224further whole-field inverse-PtPs maps. Finite-tape movement, chart normalization, stock, precision, arbitrary-Y cleanup and all terminal-consumer work are optimistically free in the rejection screen below, not claimed to be physically free. + +## Complete optimistic moment and exact proof + +Use Hr(C)=r^(1-C), H0=0. Grant even the unrealized second main bank a rank24Gaussian output, with every helper retained once. This upper relaxation is strictly stronger than the actual one-bank endpoint. Its target and paid profiles are + + T = 84H4 +21H7 +141H8 +978H9 +224H24, + P = 6603H1 +1236H2 +1530H3 +381H4 +120H5. + +After cancelling84H4, + + M = 21H7 +141H8 +978H9 +224H24 + -6603H1 -1236H2 -1530H3 -297H4 -120H5. + +Positive and negative rank mass both equal15453. Every positive rank is at least7, and every negative rank is at most5. Since Hr=r*r^(-C), for every C>0, + + M(C) <= 15453*7^(-C) -15453*5^(-C) <0. + +This is an exact symbolic bound, not a floating-point certificate or a sampled range. It covers the required comparison domain [.0030217758,.00339999] and all positive C. AtC=0 the rank-mass margin is exactly0. The actual one-bank target loses another112H24 and is therefore worse. No compiler reserve, paid tail or added outer charge can improve this upper bound. A free rank25 grant would change the problem and is not supplied by this diagonal word. Paying224H1 to add Q increases the reward by224(H25-H24), strictly less than224H1 for C>0, so that direct augmentation also loses margin. + +For scale only, noncertifying70-digit decimal diagnostics give M(.0030217758) approximately-89.2937410696 and M(.00339999) approximately-100.4114321133. A monotonic endpoint enclosure preview T(Clo)-P(Chi) is approximately-85.5877944347. The exact rank-separation proof is the decision evidence; these numbers are not needed for it. + +## Cheapest test, controls and stopping rule + +The smallest discriminating gate is already reached: verify the three-block permutation/Gaussian identity and exact integer profile/rank-mass arithmetic. Before any future execution, independent review should authenticate the native profiles, distinguish24from25targetaxes, ensure224persistentmainowners rather than672, and confirm1224helpers counted once. Controls should reject a freeQrank bonus, omitted helper work, treating axes as owner arrays, and dropping the terminal FULL's native bill. + +The exact negative upper bound stops this terminal-anchor schedule before a native emitter, all-input fixture, recursive caller or compiler retuning. An alternative would need a genuinely changed paid/target profile or a different consumer contract, not a different placement of the same grant. We make no claim about such alternatives. The partial one-bank consumer is likewise unfunded even with free cleanup. + +Credit Cinna Davis for5113's common physical code, moving endpoints and stage-word theorem; Dillon for4933normalizers/coded ABI; Dugongue/mdumitrean for4929helper-clean producer; Cayden Burkart, JoyboyBrian, Cao Yifan, zxv, Jacob Alan Sussman and the retained native/compiler/precision lineage. The terminal-anchor question and the explicit complete optimistic rejection here were developed with OpenAI Codex assistance. No newkappa, full supplier, external post or proof-kernel acceptance is claimed. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/DESIGN-RESULT.json b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/DESIGN-RESULT.json new file mode 100644 index 0000000000..121bdfd188 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/DESIGN-RESULT.json @@ -0,0 +1,67 @@ +{ + "status": "STOP_TERMINAL_ANCHOR_THREE_STAGE_RELAXATION", + "source_pr": 5113, + "source_head": "b893ba6bd6c77c6e7efc48acb6f448218df671b7", + "main_source_owners": 224, + "fresh_helper_owners": 1224, + "actual_unmixed_main_bank_owners": 112, + "unrealized_main_target_grant": 224, + "ambient_axes": 25, + "granted_main_target_rank": 24, + "full_calls": 3, + "inserted_moving_main_maps": 448, + "boundary_normalization_maps_maximum": 224, + "native_paid_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "native_helper_profile": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "optimistic_target_profile": { + "4": 84, + "7": 21, + "8": 141, + "9": 978, + "24": 224 + }, + "paid_profile": { + "1": 6603, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "signed_moment_profile": { + "1": -6603, + "2": -1236, + "3": -1530, + "4": -297, + "5": -120, + "7": 21, + "8": 141, + "9": 978, + "24": 224 + }, + "positive_rank_mass": 15453, + "negative_rank_mass": 15453, + "minimum_positive_rank": 7, + "maximum_negative_rank": 5, + "exact_upper_bound": "15453*(7^(-C)-5^(-C))", + "strictly_negative_for": "every C>0", + "comparison_domain": [ + "0.0030217758", + "0.00339999" + ], + "new_kappa": null, + "native_emitter_executed": false, + "compiler_executed": false, + "finite_overhead_for_screen": "optimistically zero, actual obligations remain", + "independent_review": "pending root-assigned review" +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/INVENTORY-REPORT.md b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/INVENTORY-REPORT.md new file mode 100644 index 0000000000..deb3c261b1 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/INVENTORY-REPORT.md @@ -0,0 +1,177 @@ +# Moving-anchor pair: isolated inventory and price typing + +Read/derive only, at #5113 `b893ba6bd6c77c6e7efc48acb6f448218df671b7`. +The released TASK question 2 is the scope: one anchor/spectator boundary for +one distinct-stage pair. Dillon's active p2/IDLE/port-intertwiner work, the +author's unspecified larger-K mechanism and Astra's new consumer hypothesis +are not taken here. No native word, factory, compiler or physical fixture was +executed. The retained source/proof premises have not been independently +replayed. Six exact-head source files are preserved in `source/`. + +## Axes are not owners + +Let q be the central axis, and let 0,s,t be disjoint eight-axis blocks. +All statements lift columnwise to f digits per axis. A field is an arbitrary +function of every address coordinate, including all 8f anchor bits. The new +anchor creates no new owner array and no extra independent Gaussian output. +It enlarges the surrounding address volume by 2^(8f) relative to a comparable +two-fresh-block field without the anchor. Those arbitrary fibres cannot be +discarded, reset to zero, or counted as eight extra productive owners. + +One main bank contains 112 arbitrary owner fields. A FULL has two banks, +224 main owners. Two sequential FULLs with the same main owners and fresh +independent native helper banks have 224+2*408=1040 original owner fields. +The eight extra axes are present within these fields; they are not another +eight fields. Under source helper autonomy, the 816 helpers retain independent +outputs once, on their source requested axes, with every other coordinate +including the anchor treated as an arbitrary spectator. If a different helper +reuse is proposed, this disjoint inventory no longer applies automatically. + +## Literal pair and its exact boundary + +Use D_b for the product of the eight actual Gaussian kernels on block b, +and P_s for the real coordinate swap (0,s). The source defines + + E_s=P_s D_0, E_t=P_t D_0. + +For s,t distinct and nonzero, + + W=E_t E_s=P_t P_s D_0 D_s. + +This is an identity of literal operators, not merely of frame labels. The +Gaussian factors have their inherited actual phases; the coordinate swaps +have no added phase. They act on whole blocks at each column. The pair +contains no Q factor. + +At each of the eight corresponding bit positions, the output coordinate +permutation P_t P_s sends label positions 0->s, s->t, t->0, fixing q and all +other labels. Before that permutation, D_0 D_s acts on blocks 0 and s and +leaves block t untouched. Therefore applying the explicit output permutation +(P_t P_s)^-1 leaves the exact rank-16 Gaussian D_0 D_s. It does not return +the anchor as identity: anchor inputs have been transformed. The last fresh +block t and q are spectators. Rank is 16, not 17, and no new reward follows +from the eight anchor axes alone. + +For the pure diagonal word there is also a useful two-sided boundary fact: +with L=P_t P_s P_t, which swaps s and t, + + L W P_t = P_t D_0 D_s P_t = D_t D_s. + +This returns the anchor identically for arbitrary anchor-dependent input, +using one input and one output coordinate permutation per affected field. +It proves that an extra H8 completion is not forced by this isolated diagonal +word alone. It is NOT a zero-cost recycling theorem or a full FULL-pair +identity. Its input chart is changed, its two boundary permutations must be +paid, and it does not remove the enlarged address volume or prove that a +larger caller accepts those charts. Nor does it straighten the coupled code +blocks of the actual FULLs. + +The source moving FULLs are + + Ftilde_s=diag(E_s,E_s) L(C0 Q^-1), + Btilde_s=diag(E_s,E_s) U(-Q C0). + +Their entry is the inherited source ABI with P_s appended on both main banks. +All main arrays remain arbitrary and helper autonomy is inherited pointwise +over their spectators. For two forward FULLs, X_out=W X_in is pure on all +112 original X owners. But + + Y_out=W Y_in + (W C0 Q^-1 + E_t C0 Q^-1 E_s) X_in. + +Thus the other 112 owners are not independent Gaussian jobs merely because +their diagonal block is W. For two backward FULLs the analogous pure bank +is Y; mixed orientations need their own full block calculation. This report +does not enter the active p2 caller question. + +## Paid and finite ledger + +The source center-free native price and helper reward are + + P=2201H1+412H2+510H3+127H4+40H5, + H=28H4+7H7+47H8+326H9. + +These are inherited local profiles, not a newly admitted moving-stage supplier. +Two FULLs pay at least 2P and retain at most their two disjoint helper banks +2H, with all those helper inputs distinct. No removed rank-eight center call +is credited again. Unknown closure costs are not subtracted from this bill. + +Known field-level operations over two FULLs are: + +| Item | Count/status | +|---|---| +| Added moving-coordinate P_s/P_t maps | 448 main-field maps: 224 per FULL | +| Four inherited port wrappers | 896 monomial field maps: 448 per FULL | +| Backward convention, if used | At most 448 further monomial maps per backward FULL; retained upper bound | +| Existing center-free dyadic precompensation | 13,192 ADDs: 6,596 per FULL, in addition to the original native work | +| Source Gaussian children | 2P; no changed recursive tariff proved | +| Owned allocation/cleanup introduced by coordinate transport | None: it permutes original fields, not COPY/CLEAR buffers | +| Pair output permutation removal | Two block swaps per affected field in the displayed product; actual fusion/tape price not supplied | +| Optional pure-W two-sided boundary | Two further coordinate maps per affected field; 448 maps if applied to both 112-owner banks | +| Anchor allocation, routing and spectator-volume completion | Unknown full supplier/whole-job cost | +| Coupled-bank correction, terminal decoding and paid restoration | Unknown; inherited direct gauge fails in #5113 | + +The counts above distinguish known operation counts from a complete TM or +compiler tariff. They are not all exact minima or a license to add the upper +bounds as a proved lower bound. Coordinate maps require actual indexed +movement and fixed-tape treatment. Transport itself introduces no denominator +13, but any later C0^-1 decoder still needs its actual rational implementation, +precision and complete ordinary bill. All original native/internal movement, +rounding and helper allocation remain inherited; no such cost is zeroed. + +## Strong optimistic pair screen, without a caller claim + +The source does bind the diagonal pair W to rank 16. Give the proposal the +unrealized favorable grant that BOTH main banks become independent rank-16 +jobs with all code cleanup, output permutations and other costs free. Its +optimistic moment is + + M(theta)=224*16^theta + 2H(theta) - 2P(theta), + theta=1-C. + +The paid rank mass is 2*5263=10526; the granted reward mass is +224*16+2*3471=10526. After cancellation, + + M(theta)= -4402 H1 -824 H2 -1020 H3 -198 H4 -80 H5 + +14 H7 +94 H8 +652 H9 +224 H16. + +Every positive coefficient has rank strictly greater than 5 and every negative +coefficient has rank at most 5. Therefore M(theta)/5^theta is strictly +increasing in theta: each positive term has positive derivative, each negative +term below rank 5 also has positive derivative, and the rank-5 derivative is +zero. Since M(1)=0, M(theta)<0 for 0<=theta<1. In particular the optimistic +pair grant loses for every 00 with q_j=0 and use T_(ej+q) T_(e0+ej). Here T_v(x)=x+(v dot x)v; both v have even weight, hence T_v is orthogonal. Such j exists because q is not the all-ones vector. + +For row j of G put z_j=(wt(row_j G)-1)/2 modulo 2. Define K=Z_z P_G. It is a real signed permutation. The full Gaussian R has entries alpha*(-i)^wt(x+y), with alpha=(1+i)^9/2^9. Orthogonality gives + +wt(G^-1 d)-wt(d) = 2 z dot d (mod 4). + +Indeed the degree-two coefficients vanish modulo four because distinct columns of G^-1 have even dot product; the linear coefficient is the weight of that column minus one. Therefore K R K^-1=R exactly, including absolute phase. K also maps the central line to span(q), and its orthogonal complement to q-perp, at the canonical-frame Lagrangian level. All these statements tensor to every positive digit-column count. + +Let Q be the central C gate, D the product of the other eight C gates, so R=DQ. Let E_i and S_i be the actual retained entrance-line and exit-hyperplane frame operators. With the operator convention that rightmost applies first, use + +input X: E_i K_i Q^-1 +input Y: K_i +output X: K_i^-1 +output Y: D K_i^-1 S_i^-1. + +All four wrappers are monomial. Their Lagrangian incidences prove this for every port, and the scratch verifier checks exact tableaus and absolute phases at every one of the 112 source ports. With A from PR4929, define C_ij= A_ij K_i^-1 K_j. Then the full main endpoint is + +F = diag(D,D) [[I,0],[C Q^-1,I]]. + +C is a physically implementable fixed owner recoding: apply K_i to each owner, apply A among the owners at common physical coordinates, and apply K_i^-1. Its inverse uses A^-1=(A+12I)/13. Since each K_i is real orthogonal and A is real symmetric, C^T=C. Since K_i commutes with R, C commutes with R. The polynomial C^2+12C-13I=0 follows by similarity. The 408 independent helper jobs and every paid Gaussian child are unchanged. + +For the actual raw inverse transpose, F^-T=diag(D^-1,D^-1) [[I,-Q^-1 C],[0,I]], since Q,D are symmetric. Multiply both outputs by D^2, then conjugate the physical X bank by Q^2 (input Q^-2 and output Q^2). These are explicit monomial powers. The result is + +B = diag(D,D) [[I,-Q C],[0,I]]. + +The old source convention using Y-only Q^2 conjugation cannot simply be copied for noncommuting C. The X-only convention above is exact. + +For a prior code B0 commuting with the current D, set G(B0)=diag(B0,Q^-1 B0 Q). The following two constructive local identities hold without requiring C and Q to commute: + +(post X C) F (pre Y C) = G(C B0) F_standard G(B0)^-1, +(post X C^-1) B (pre Y C^-1) = G(C^-1 B0) B_standard G(B0)^-1. + +They use [C,DQ]=0 and [B0,D]=0. Every additional operation on the left is physically cheap fixed recoding. For disjoint fresh blocks, codes from earlier stages commute with the current D. These identities do not yet settle interstage ADD/IDLE compatibility, terminal gauges, productive jobs, or the complete moment. + +## Literal recoding and complete local bill + +The source code has an exact factorization A=I-MM^T/4 with M a 112-by-8 matrix having entries 0,+1,-1 and M^T M=56I. Each mode column has 56 nonzero entries, and each owner row has four. The mode columns are emitted in NORMALIZERS.json and all 12,544 entries are checked against the pinned CODE.json. This factorization is used here as a constructive scalar program, without relying on any common physical address chart for separate Gaussian mode transformations. + +To execute A on arbitrary independent owner fields x, allocate eight owned zero fields t. Compute t=M^T x with 448 signed ADDs; update x-=M t/4 with 448 scaled ADDs; clear the eight owned temporaries. Reading x is finished before any x is updated. Hence no input field is overwritten before its last source read. For A^-1 use the same program with coefficient -1/52, since A^-1=I-MM^T/52. Both are exact rational linear programs. The helper fields of the native producer are never used as scratch, copied as free credit, or erased. + +Conjugating this scalar program by the 112 K_i and their inverses implements C or C^-1. This pays 224 monomial field maps, 896 scalar ADDs and 16 owned CLEARs per recoding, with eight owned fields reusable sequentially. The two additional recodings in either local gauge identity therefore cost at most 448 monomial maps, 1,792 scalar ADDs and 32 CLEARs, with no recursive Gaussian child. The four actual port normalizers contribute 448 monomial maps per native invocation. The displayed backward conversion contributes at most 448 further monomial maps (112 input X powers, 112 output X powers and 224 output D-squares); fusing maps can reduce this upper bound but is not assumed. + +These are field-level operation counts. A lifted K_i is an explicit binary map on nine f-bit address blocks together with signs given by block parity. Its constants, indexed movement and phase passes use the retained native monomial implementation. It is therefore a fixed finite O(V polylog p) nonrecursive operation under that caller's precision/address ABI, not a zero-work instruction. Each fixed rational ADD is likewise charged at its actual scalar precision. In particular the inverse denominator 52 must be implemented and rounded; no free exact real-division oracle is assumed. This lemma makes no independent TM tariff or outer-budget claim. + +The maximum exact component-l1 prefix bound for the scalar A program, including its temporaries, is 57. For A^-1 it is 56 (the output-only bound is 69/13). Signed monomial maps preserve component magnitude. A fixed local sequence has a fixed suffix bound obtained by multiplying elementary bounds 1+|coefficient|; owned CLEAR has bound one. This gives a finite bound for local rounding propagation. The number of local uses, compiler precision and complete outer error allocation still belong to the caller theorem. + +The normalized producer still has its exact PR4929 paid profile + + {1:2201, 2:412, 3:510, 4:127, 5:40} + +and independent helper profile + + {4:28, 7:7, 8:47, 9:326}. + +No productive main ranks are asserted merely from the coupled central ABI. Those depend on the completed caller, its initial/final gauges and every paid correction. + +## Universal scope and reproducible evidence + +PR4929 supplies the arbitrary-input logical identity over Q[FreeGroup72] for its emitted center-free word with ground-chart helper pre-compensation. Its normalized main endpoint is L(A), its raw dual is L(A)^-T, and every one of the 408 helper endpoints is autonomous. This proof is an inherited premise with exact source pins, not a consequence of this normalizer checker. The present wrappers and owner recodings act exclusively on the 224 main fields; new scratch is explicitly owned. Thus the helper block remains autonomous and its independent inputs, requested transforms and paid profile remain unchanged. + +For every f>=1, assign the shared native letters their actual consistent invertible lifted operators. Evaluation of the source free-group algebra is a homomorphism and gives the source logical identity. Independently lift each K_i as its f-fold tensor product, retaining spectator coordinates; its signed-permutation word, the two direct frame identities and its commutation with R lift by operator composition. In every compiled monomial word, P and X act columnwise on the f-bit blocks, D sums its Z4 polynomial over the f columns, and a one-column scalar phase i^gamma becomes i^(f*gamma). Reusing the one-column global phase unchanged would be incorrect. Finally form the owner matrix C_f with entries A_ij K_i,f^-1 K_j,f. One does not tensor the whole 224-by-224 owner matrix and does not assert that tensor powers preserve sums. Instead the finite scalar owner program is evaluated directly in the algebra of these lifted address operators. This proves the central ABI and local gauge identities at every positive width. + +Run `python3 -I -B research/coded-native-caller/normalizers.py` or its optimized `-O` form. The checker authenticates the decompressed actual native payload, CODE.json and retained Clifford source before executing the latter. It verifies all 112 real signed normalizers, 57,344 explicit weight-congruence addresses, 896 forward/backward monomial wrappers and eight exact frame/block identities per port, including absolute phase. Each emitted wrapper is separately lowered to a literal P/D/X/phase-only word and checked against its defining expression by exact tableau and absolute-phase state. No C gate remains in an emitted wrapper. The independent incoming-column and outgoing-row identities imply all 5,824 nonzero off-diagonal code blocks, without sampling those pairs. It also executes the eight-mode recoding on all 112 arbitrary-input basis columns in both directions. Omitting the essential signed phase is rejected at every affected port. The default command compares a regenerated mathematical receipt and performs no writes; `--write` is the explicit authoring path. + +Source pins: canonical main 624de9dc66858af0945e5f8a0942488d62280d43, `research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz`, decompressed SHA-256 cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd; PR4929 head 361f5d4100640177d6a983dd2f336021c75bfd5e, `research/native-center-free-code/CODE.json`, SHA-256 8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0; canonical `research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py`, SHA-256 2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962. Gzip container bytes are not substituted for decompressed source identity. + +Credit Dugongue's PR4929 for the coded producer and stable code; Cinna Davis's PR4694/4698 and the original cache/helper construction; Cao Yifan's PR4610 native word; the retained zxv, Jacob Alan Sussman, Cinna Davis and Clifford/native/compiler lineage. The exact canonical-frame implementation and phase conventions are retained source material. The constructive real centralizing normalizers, their explicit lifted words, X-only raw-dual convention and costed local code gauges are the additions here. New work is Apache-2.0 and has substantial OpenAI Codex assistance; no formal-kernel or independent human acceptance is asserted. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__PROOF.md b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__PROOF.md new file mode 100644 index 0000000000..60fecc67b7 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__PROOF.md @@ -0,0 +1,179 @@ +# A common owner code with moving Gaussian stages + +Cinna Davis; substantial OpenAI Codex assistance. Apache-2.0. + +This is a changed local interface and a rejected direct caller substitution. +It is not a supplier, a multiplication theorem or a kappa improvement. +The normalizer and coded-producer premises are Dillon's PR4933 and +Dugongue's PR4929, respectively. Their complete native word is not replayed +here. The proof below states exactly where those premises are used. + +## 1. Stage-local normalizers cannot give a common code + +Let the binary label space be a direct sum `Z + V_s + V_t + W`, where +`Z` is the shared central block and `V_s,V_t` are distinct fresh blocks. +At stage s each invertible label map `G_i,s` is supported on `Z+V_s`: +it preserves this subspace and is identity on its displayed complement. +Require `G_i,s Z = L_i,s`, with `L_i,s` distinct for different owners i. +The signed monomial normalizer K_i,s has this label map. Arbitrary +nonzero phases do not change the following necessary condition. + +For a fixed scalar owner matrix A, write the physical code block as + + C_s[i,j] = A[i,j] K_i,s^-1 K_j,s. + +Suppose `A[i,j] != 0` and `i != j`. If `C_s[i,j]=C_t[i,j]`, equality of +the nonzero monomial matrices implies equality of their label maps: + + H = G_i,s^-1 G_j,s = G_i,t^-1 G_j,t. + +The first expression preserves `Z+V_s`; the second preserves `Z+V_t`. +Both inverses have the same properties. Thus H preserves their +intersection Z bijectively. It follows that + + G_j,s Z = G_i,s H Z = G_i,s Z, + +contradicting the distinct-line premise. This rules out a common code +within this stage-local monomial class, for any choice of its normalizers. +It does not enumerate just the particular source normalizers. It applies +to arbitrary positive digit-column width by taking Z to have that width +and each fresh block eight times that width. + +For the actual 112 source ports the 112 binary lines are distinct and A +has zero diagonal and 5,824 nonzero ordered off-diagonal blocks. All +5,824 therefore obstruct common-code equality. In the pinned source +choice, block (0,1), coefficient -1/2, maps input label 1 to label 22 at +the anchor stage and 5,632 at the fresh stage in the 17-bit embedding. +Different output labels suffice irrespective of phase. + +The hypotheses matter. Equal-line owner pairs can have identical +normalizers and hence common identity relative maps. Equal stages have +the same code. The global construction below deliberately moves +spectators and lies outside the stage-local premise. + +## 2. A constructive escape by moving coordinates + +Add one common eight-axis anchor block V_0, distinct from all fresh stage +blocks V_s. Let P_s exchange V_0 and V_s and fix the central axis and +all other labels. These are real, self-inverse coordinate permutations. +Let K_i,0 be the pinned real signed anchor normalizers. Instead of the +stage-local normalizers `K_i,s=P_s K_i,0 P_s^-1`, use the intertwiners + + K'_i,s = P_s K_i,0. + +They still take the central line to the actual stage-s port line, but +move the inactive fresh labels into the anchor. Their relative maps are + + (K'_i,s)^-1 K'_j,s = K_i,0^-1 K_j,0. + +Thus they give the same physical owner code C_0 at every stage, including +all signed phases. This is an exact constructive common code once +spectator motion is allowed. It is not a centralizing-normalizer theorem: +the K'_i,s generally intertwine two stage Gaussians rather than commute +with the stage-s Gaussian. + +Here is the resulting concrete endpoint without assuming any new native +semantics. Let Q be the central Gaussian, D_0 the product on the eight +anchor axes, `D_s=P_s D_0 P_s^-1`, and +`C_s=P_s C_0 P_s^-1`. All P_s commute with Q. The inherited PR4933 ABI is + + F_s = diag(D_s,D_s) L(C_s Q^-1), + B_s = diag(D_s,D_s) U(-Q C_s), + +where L(T)=[[I,0],[T,I]] and U(T)=[[I,T],[0,I]]. Append P_s to both +main input banks, before this ABI. Direct block multiplication gives + + F_s diag(P_s,P_s) = diag(E_s,E_s) L(C_0 Q^-1), + B_s diag(P_s,P_s) = diag(E_s,E_s) U(-Q C_0), + E_s = P_s D_0. + +These equations require no commutation of C_0 with Q or P_s. Their +source maps are invertible on every arbitrary main input. They introduce +no CLEAR or claimed independent helper input. The source producer's +autonomous helper outputs remain its inherited premise. The inserted +permutations act on the 224 main fields only. This gives a complete +local input/output contract, not a complete controller. + +Every construction here lifts to arbitrary digit-column width: swap +entire blocks columnwise; lift the source signed K_i columnwise with its +correct accumulated phase; execute the owner scalar coefficients once +on the owner factor. No tensor power of a sum of owner blocks is used. + +## 3. Noncommuting E_s words retain distinct-stage Gaussian ranks + +Consider distinct nonzero stage labels s_1,...,s_k in chronological +order. Write `P_word=P_s_k ... P_s_1`. Moving coordinate permutations +to the left gives the exact formula + + E_s_k ... E_s_1 + = P_word D_0 D_s_1 ... D_s_(k-1). + +One proof proceeds inductively. In the normal form P_word D_support, +left multiplication by `P_s D_0` adds the D block at +`P_word^-1(0)`. For distinct previous swaps this block is the most +recent preceding stage label, or 0 for the empty word. This gives the +displayed support and leaves each Gaussian exponent equal to one. +The D blocks commute because their coordinates are disjoint. + +After removing the explicit monomial P_word, the word therefore has +8k Gaussian axes; adjoining Q or Q^-1 adds one. This is the exact +Gaussian support rank of this operator, not proof that the operator is +an admitted recursive target. P_word removal, ambient width, spectator +multiplicity and completion still require a supplier bill. + +The E_s themselves do not commute. Distinctness also matters: the word +E_1^3 has only eight odd Gaussian axes after monomial removal rather +than 24, since `E_1^2=D_1 D_0` and D_0^2 is monomial. The checker tests +all 1,956 distinct ordered nonempty words on six stages and this +repeat control. Those checks corroborate the induction; they do not +establish arbitrary k by enumeration. + +## 4. The direct controller substitution still fails + +The inherited relation is `[C_0,D_0 Q]=0`. Since `E_s Q=P_s D_0 Q`, + + [C_0,E_s Q]=0 iff [C_0,P_s]=0. + +Indeed multiply the commutation equation on the right by +`(D_0 Q)^-1`, using its commutation with C_0. But +`P_s C_0 P_s^-1=C_s`, and Section 1 shows `C_s != C_0`. +For the source choice their binary maps differ in every one of the +5,824 nonzero code blocks. This also gives an actual failed block +identity, rather than only an unavailable sufficient hypothesis. +Put `F_standard(E)=diag(E,E)L(Q^-1)` and +`G(C)=diag(C,Q^-1 C Q)`. The proposed forward gauge is + + diag(C,I) F_tilde diag(I,C) = G(C) F_standard(E). + +Its lower-left block difference is + + E C Q^-1 - Q^-1 C E = Q^-1 (E Q C - C E Q), + +where E commutes with Q. This is nonzero by the preceding argument. +Thus PR4933's local forward gauge identity itself fails for E_s. Their physical +common code and their rank-preserving products do not by themselves +license that caller substitution. A different caller must prove its +own full block identities. This is a stop gate, not a universal +obstruction to moving-coordinate callers or coded recursive families. + +## 5. Obligation and cost ledger + +| Obligation | Status | +|---|---| +| Source arbitrary-input coded native ABI and helper autonomy | Inherited PR4929/PR4933 premise, exact source pointers retained | +| Stage-local common-code exclusion | Proved above for the stated support/line contract | +| Global common code and transported F/B endpoints | Exact construction and block proof above | +| Distinct-stage product ranks | Proved above; finite independent arithmetic check supplied | +| Extra coordinate permutations | 224 whole-main-field P_s maps per transported FULL; finite-tape price unknown | +| Anchor space | Eight additional label axes, with every added spectator and completion charge unpriced | +| Original native child/helper profiles | Source profiles retained as local premises; no complete new supplier invoice | +| Center deletion | Existing center-free producer property, not new independent credit | +| Complete coded controller, restoration and terminal decoding | Unknown; direct inherited gauge fails Section 4 | +| Precision, routing, recursive compiler, BIT and outer transfer | Unknown for this interface | + +For n fresh eight-axis stages plus Q, the original ambient width +8n+1 becomes 8(n+1)+1. Those eight new axes are never free stock or +productive main Gaussian credit. The preserved rank of a target word +does not remove this change in its surrounding width. Unknown costs +are not zero. The next construction must justify its full completed +moment before a larger search or claimed kappa gain. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__README.md b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__README.md new file mode 100644 index 0000000000..5c78fb365e --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__README.md @@ -0,0 +1,75 @@ +# Common code through moving Gaussian stages + +**Changed local interface and a rejected direct controller substitution; no new κ.** + +An explicit coordinate transport makes the center-free producer's physical +owner code identical at every stage. The price is a moving Gaussian stage +`E_s=P_s D_0`, 224 additional main-field coordinate permutations per FULL, +and eight extra anchor axes. Distinct-stage products retain exactly eight +Gaussian axes per stage after a specified output permutation. The inherited +controller's commutation condition nevertheless fails. This package preserves +the construction and identifies that next algebraic obligation. + +The [proof](PROOF.md) first excludes a common code for **any** stage-local +monomial normalizers with the specified distinct port-line images. Its proof +uses support intersection, not exhaustive normalizer enumeration. It then +constructs global intertwiners `K'_i,s=P_s K_i,0`, proves their common-code +and arbitrary-input F/B endpoints, and derives the exact noncommuting stage +word formula. All 5,824 actual nonzero owner blocks disagree between two +stage-local codes but agree under the global transport, including signed +phases. The preserved Gaussian ranks do not admit the new jobs or price +spectator completion. + +The decisive gate is `[C_0,E_s Q]=0 iff [C_0,P_s]=0`. The latter fails on +all 5,824 nonzero blocks in the source fixture. A direct reuse of PR4933's +local gauge is therefore rejected. This does not exclude another caller, +a recursively coded family, or transport that changes the boundary contract. +No complete moment is asserted; unknown costs remain unknown. + +Reproduce with CPython 3.12, standard library only, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/common-code-moving-stages +python3.12 -I -O -B research/common-code-moving-stages/verify.py +``` + +The replay authenticates all live source hashes, checks the 112 normalizers, +57,344 exact phase congruences, all 5,824 nonzero code blocks, both normalizer +inverse orders and all 1,956 distinct ordered words on six fresh stages. +A separate address-array calculation over F_65537 checks the word formula +on two deterministic vectors per word, using the actual one-axis Gaussian +coefficients. This corroborates the written all-width proof; a finite vector +check alone is not that proof. Equal-line/same-stage positive controls, +noncommuting-order and repeated-stage rank controls retain the scope boundary. +The normal and optimized registered commands are read-only. RESULT.json is +regenerated only by the explicit authoring option `--write-result`. + +Canonical base is `81e9bd69e4a5b00ba9c713a1620e36d576d5522e`, priority revision 7; +selected conditional κ remains 0.00302015. SOURCES.json pins the exact source +bytes; TASK.json retains the changed-card decision, overlap coverage and next +questions. The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768) +was claimed before the checks. No native-word regeneration, complete +controller/compiler/BIT/outer replay, Lean proof, independent human review +or selected-frontier change is claimed. + +## Open next questions + +1. Can the transported F/B endpoints be consumed by a changed caller without + assuming `[C_0,E_s Q]=0`? Start with one complete arbitrary-input pair and + its actual thin queries; charge every added oracle call and both returns. + Stop if the negative bank still requires an unpriced Q-conjugated code. +2. Can an anchor be recycled with a proved boundary and unchanged target rank? + Start with one actual source target word and all its spectator labels. + The new eight-axis anchor and its completion costs currently remain open. +3. If a caller survives, derive its complete completed moment, rounding, + movement and compiler invoice before another construction search. The + preserved 8k target rank alone grants no recursive saving. + +Credit Dillon/PR4933 for physical signed normalizers and the coded ABI; +Dugongue/mdumitrean/PR4929 for the center-free producer and code; +Cayden Burkart/PR4940 and JoyboyBrian/PR4936 for the caller and physical-pair +question; Cao Yifan/PR4610; Cinna Davis/PR4694/4698/4470; zxv; +Jacob Alan Sussman; and the full inherited native/compiler/precision lineage. +Their archived mathematics is retained as a source premise. New work by +Cinna Davis, with substantial OpenAI Codex assistance; no subagents. +Apache-2.0. No global novelty claim for coordinate transport is intended. diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__SOURCES.json b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__SOURCES.json new file mode 100644 index 0000000000..e732864e85 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coded-native-caller/GAUGE.md", + "usage": "input", + "git_blob": "13269f7b1f98535151de173477f9e7d9a0d81079", + "sha256": "09c4e86d99245734761569efd13473623ffdd857e9eae092bd7f54bfd2f42f06" + }, + { + "path": "research/coded-native-caller/NORMALIZERS.json", + "usage": "input", + "git_blob": "bca92c222c395d3d75c047fbb678f3cd0947c60f", + "sha256": "ae8aad06aa5d1811d725895b3ab5a4f4daa9dcdd88294aa0d5f723e78bb1e0da" + }, + { + "path": "research/coded-native-caller/PHYSICAL.md", + "usage": "input", + "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f", + "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078" + }, + { + "path": "research/native-center-free-code/CODE.json", + "usage": "input", + "git_blob": "03170f4a31f7a8a3db7228f1cd5a6fdcb32720ae", + "sha256": "8be7f3f073b7981ec91c6af43edff0ac8a89f4824ef6026ae758c287dd6c03d0" + } + ] +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__TASK.json b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__TASK.json new file mode 100644 index 0000000000..fffb0d7e73 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__common-code-moving-stages__TASK.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "task_id": "centre-path-sharing", + "priority_revision": 7, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "original_card": { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a common physical code by moving stage coordinates, prove its distinct-stage product ranks, and test the inherited controller commutation gate.", + "scope_change_reason": "The PR4933 coded caller leaves terminal code admission open. Instead of another fixed center invoice or terminal support test, change the spectator/coordinate contract and expose its exact F/B endpoint.", + "bottleneck_link": "A common code might enable global caller absorption of the existing center-free producer, but transported stages must satisfy a new caller theorem and pay anchor completion.", + "budget_minutes": 60, + "stop_rule": "Reject direct reuse of the inherited gauge if [C_0,E_s Q] is nonzero. Preserve a scoped construction rather than expand an unpriced compiler or call it a higher kappa.", + "outcome": "partial", + "evidence": "PROOF.md and RESULT.json: common transported code on all 5824 actual nonzero blocks, stage-local support exclusion, exact moving F/B endpoints, distinct-word Gaussian rank formula, and failed inherited commutation gate.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance for reasoning, code, verification and prose; no subagents or independent human review.", + "open_questions": [ + { + "question": "Can a changed caller consume the moving F/B stages without assuming their failed code commutation?", + "why_it_matters": "This would supply a real consumer for the common physical code.", + "first_step": "Prove all blocks of one arbitrary-input thick/thin pair and charge its query/restoration bill.", + "blocked_by": "The inherited gauge requires a commutator that is nonzero." + }, + { + "question": "Can the eight anchor axes be recycled or completed within a favorable full invoice?", + "why_it_matters": "Their added width and spectator completion are nonzero costs.", + "first_step": "Bind one actual target word and the input/output state of every anchor coordinate.", + "blocked_by": "No full completed moment, routing or precision bound is supplied." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19142768", + "overlap": { + "canonical_main": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "open_prs": 320, + "discussion_records": 4233, + "local_records": 6824, + "specific_terms": [ + "common code", + "simultaneous centralizer", + "stage-local" + ], + "scope": "Complete cached open-PR/discussion pagination and local note inventory; bodies and notes only, no novelty guarantee." + } +} diff --git a/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__native-center-free-code__README.md b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__native-center-free-code__README.md new file mode 100644 index 0000000000..26144655f8 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/evidence/review/frozen/research__native-center-free-code__README.md @@ -0,0 +1,32 @@ +# A center-free native producer with an explicit eight-mode port code + +This emits an exact changed native word with all eight rank-8 owned-center calls removed. All 632 persistent inputs remain arbitrary and independent, all 408 helper jobs remain autonomous, and the actual entrance/exit charts stay unchanged. The main logical endpoint is + +```text +(X, Y, H) -> (X, Y + A X, H). +``` + +The explicit 112-by-112 code is `A = I - 14 P`, where `P` is an orthogonal projection of rank 8. Its eigenvalues are 1 (104 times) and -13 (8 times), with `A^-1 = I + (A-I)/13`. The forward and actual raw-dual paid profile is `{1:2201, 2:412, 3:510, 4:127, 5:40}`: eight rank-8 children disappear, with no new Gaussian child. The simple compensation uses 6,596 fixed dyadic ADDs. + +**No improved κ or complete multiplier is established.** This code changes the cross-transfer. Treating it as the old uncoded supplier would be wrong. Its inverse is an exact rational matrix, not a free dyadic operation across distinct physical input charts. + +Read [CODED-PROOF.md](CODED-PROOF.md) for the constructive theorem and [ATTRIBUTION.md](ATTRIBUTION.md) for overlap and predecessor credit. + +## Reproduce + +Only Python 3.12 and its standard library are required; there are no Windows paths, external commands, GPU libraries or platform-specific native binaries in the scientific verifier. + +```sh +python3.12 -I -B research/native-center-free-code/coded_verify.py +python3.12 -I -O -B research/native-center-free-code/coded_verify.py +python3.12 -I -B research/native-center-free-code/verify.py +python3.12 -B scripts/research_package.py --package research/native-center-free-code +``` + +The written all-width proof uses evaluation of a rational free-group identity and authenticated existing native operations. Finite replay is evidence for that identity; it is not a Lean kernel or independent human audit. The inherited source physical implementation and analytic multiplication hypotheses are not independently reproved. No selected cold replay or hosted CI pass is claimed. + +## Open next questions + +The structured questions are in [TASK.json](TASK.json). The immediate target is a paid, source-compatible adapter or caller exploiting the eight-mode code. An actual output/input chart conversion, odd-denominator implementation, full moment, storage, precision and outer budget must be supplied before claiming a κ improvement. + +Prepared by Dugongue with substantial OpenAI Codex assistance from the lead and three workers. Apache-2.0. diff --git a/research/moving-anchor-no-q-ceiling/verify.py b/research/moving-anchor-no-q-ceiling/verify.py new file mode 100644 index 0000000000..f9adb99399 --- /dev/null +++ b/research/moving-anchor-no-q-ceiling/verify.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +"""Portable read-only verification of exactly the frozen p=3 no-Q invoice. +Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0; scientific code/source contributions remain unchanged in evidence/. +""" +from pathlib import Path +from hashlib import sha256 +import json +import os +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def authenticate(root, manifest): + for name, expected in manifest.items(): + p = root / name + need(p.is_file() and not p.is_symlink(), 'Missing regular input: ' + name) + need(sha256(p.read_bytes()).hexdigest() == expected, 'Input hash mismatch: ' + name) + + +def capture_relation(capture, raw): + need(capture == raw + b'\n', 'Design capture must equal raw source plus exactly one LF') + + +def main(): + package_manifest = json.loads((HERE / 'PACKAGE-FILES.json').read_bytes()) + authenticate(HERE, package_manifest) + authenticate(HERE, json.loads((HERE / 'ARCHIVE-FILES.json').read_bytes())) + for group in ('design', 'review', 'pair-inventory'): + base = HERE / 'evidence' / group + manifest = json.loads((base / 'FILES.json').read_bytes()) + authenticate(base, manifest.get('files', manifest)) + for request in json.loads((HERE / 'SOURCE-REQUESTS.json').read_bytes()): + data = (HERE / request['snapshot']).read_bytes() + need(request['head'] == 'b893ba6bd6c77c6e7efc48acb6f448218df671b7', 'Original source head retained') + need(sha256(data).hexdigest() == request['sha256'], 'Original raw source bytes') + for relation in json.loads((HERE / 'CAPTURE-RELATIONS.json').read_bytes()): + raw = (HERE / relation['raw_snapshot']).read_bytes() + capture = (HERE / relation['design_capture']).read_bytes() + capture_relation(capture, raw) + try: + capture_relation(raw, raw) + except ValueError: + pass + else: + raise ValueError('Capture relation rejection control accepted wrong bytes') + with tempfile.TemporaryDirectory(prefix='moving-anchor-check-') as d: + temporary = Path(d) + command = [sys.executable, '-I'] + if sys.flags.optimize: + command.append('-O') + command += ['-X', 'pycache_prefix=' + str(temporary / 'cache'), '-W', 'error', '-B', + str(HERE / 'evidence/review/check_ceiling.py')] + env = {k: v for k, v in os.environ.items() if not k.startswith('GIT_')} + env.pop('PYTHONOPTIMIZE', None) + result = subprocess.run(command, cwd=temporary, env=env, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, timeout=60, check=False) + need(result.returncode == 0, result.stderr.decode(errors='replace')) + need(not result.stderr, 'Unexpected checker stderr') + expected = (HERE / 'evidence/review/CHECK-RESULT.json').read_bytes() + need(result.stdout == expected, 'Fresh independent result differs from frozen receipt') + need(expected == (HERE / 'evidence/review/CHECK-RESULT-OPTIMIZED.json').read_bytes(), 'Frozen normal/optimized equality') + receipt = json.loads(expected) + need(receipt['status'] == 'PASS_INDEPENDENT_SCOPED_P3_MOVING_ANCHOR_CEILING', 'Exact p3 scope') + need(receipt['source_bound_full_calls'] == 3 and not receipt['all_p_source_admission_claimed'], 'No all-p source admission') + authenticate(HERE, package_manifest) + print(json.dumps({'status': 'PASS_MOVING_ANCHOR_NO_Q_CEILING', 'full_calls': 3, + 'main_owners': 224, 'fresh_helper_owners': 1224, 'main_target_rank': 24, + 'positive_rank_mass': 15453, 'negative_rank_mass': 15453, + 'scope': 'fixed source-bound optimistic invoice; strict loss for C>0', + 'source_capture_relation': 'all three exact raw sources plus one preserved LF', + 'capture_relation_control': 'same validator rejects missing LF', + 'unchanged_independent_receipt': True, 'native_execution': False, + 'complete_caller': False, 'all_p_admission': False, 'new_kappa': None}, sort_keys=True)) + + +if __name__ == '__main__': + main()