From 647de55efebbffd34375d5019b3a92259b54a546 Mon Sep 17 00:00:00 2001 From: ross Date: Wed, 21 Oct 2026 09:42:56 +1100 Subject: [PATCH] Prove sharp formal orbit query count with returned spectators --- .../CORE-SNAPSHOT.json | 120 ++++ .../FROZEN-SHA256.json | 28 + research/orbit-closed-call-bound/LICENSE | 201 ++++++ research/orbit-closed-call-bound/ORIGINS.json | 109 +++ research/orbit-closed-call-bound/README.md | 29 + .../orbit-closed-call-bound/SOURCE-AUDIT.md | 13 + research/orbit-closed-call-bound/SOURCES.json | 65 ++ research/orbit-closed-call-bound/TASK.json | 90 +++ research/orbit-closed-call-bound/VERIFY.json | 47 ++ research/orbit-closed-call-bound/controls.py | 460 ++++++++++++ .../independent/CHECKS.json.gz | Bin 0 -> 23291 bytes .../independent/PROOF-INDEPENDENT.md | 185 +++++ .../independent/VALIDATION.json | 37 + .../independent/check.py | 425 +++++++++++ .../orbit/CHECKS.json.gz | Bin 0 -> 64855 bytes .../orbit-closed-call-bound/orbit/INPUTS.json | 43 ++ .../orbit-closed-call-bound/orbit/ORIGINS.md | 59 ++ .../orbit/OUTPUT-INVENTORY.json | 33 + .../orbit/PACKAGE-FILES.json | 20 + .../orbit-closed-call-bound/orbit/PROOF.md | 235 ++++++ .../orbit/VALIDATION.json | 20 + .../orbit-closed-call-bound/orbit/check.py | 502 +++++++++++++ .../orbit/frozen/history/DERIVATIVE.md | 62 ++ .../frozen/history/GEOMETRY-DERIVATIVE.json | 675 ++++++++++++++++++ .../frozen/history/geometry_derivative.py | 133 ++++ .../orbit/frozen/source/LICENSE | 201 ++++++ .../orbit/frozen/source/NOTICE.md | 69 ++ .../orbit/frozen/source/bitE8-r865.json.gz | Bin 0 -> 33865 bytes .../reviews/CONTROL-VALIDATION.json | 22 + .../reviews/CONTROLS.json | 647 +++++++++++++++++ .../reviews/CROSS-REVIEW-ORBIT.md | 70 ++ .../reviews/GIT-SOURCE-CHECKS.json | 62 ++ .../orbit-closed-call-bound/reviews/REVIEW.md | 41 ++ .../reviews/SNAPSHOT-REVIEW.json | 64 ++ .../reviews/SOURCE-CLOSURE.json | 137 ++++ research/orbit-closed-call-bound/verify.py | 157 ++++ 36 files changed, 5061 insertions(+) create mode 100644 research/orbit-closed-call-bound/CORE-SNAPSHOT.json create mode 100644 research/orbit-closed-call-bound/FROZEN-SHA256.json create mode 100644 research/orbit-closed-call-bound/LICENSE create mode 100644 research/orbit-closed-call-bound/ORIGINS.json create mode 100644 research/orbit-closed-call-bound/README.md create mode 100644 research/orbit-closed-call-bound/SOURCE-AUDIT.md create mode 100644 research/orbit-closed-call-bound/SOURCES.json create mode 100644 research/orbit-closed-call-bound/TASK.json create mode 100644 research/orbit-closed-call-bound/VERIFY.json create mode 100644 research/orbit-closed-call-bound/controls.py create mode 100644 research/orbit-closed-call-bound/independent/CHECKS.json.gz create mode 100644 research/orbit-closed-call-bound/independent/PROOF-INDEPENDENT.md create mode 100644 research/orbit-closed-call-bound/independent/VALIDATION.json create mode 100644 research/orbit-closed-call-bound/independent/check.py create mode 100644 research/orbit-closed-call-bound/orbit/CHECKS.json.gz create mode 100644 research/orbit-closed-call-bound/orbit/INPUTS.json create mode 100644 research/orbit-closed-call-bound/orbit/ORIGINS.md create mode 100644 research/orbit-closed-call-bound/orbit/OUTPUT-INVENTORY.json create mode 100644 research/orbit-closed-call-bound/orbit/PACKAGE-FILES.json create mode 100644 research/orbit-closed-call-bound/orbit/PROOF.md create mode 100644 research/orbit-closed-call-bound/orbit/VALIDATION.json create mode 100644 research/orbit-closed-call-bound/orbit/check.py create mode 100644 research/orbit-closed-call-bound/orbit/frozen/history/DERIVATIVE.md create mode 100644 research/orbit-closed-call-bound/orbit/frozen/history/GEOMETRY-DERIVATIVE.json create mode 100644 research/orbit-closed-call-bound/orbit/frozen/history/geometry_derivative.py create mode 100644 research/orbit-closed-call-bound/orbit/frozen/source/LICENSE create mode 100644 research/orbit-closed-call-bound/orbit/frozen/source/NOTICE.md create mode 100644 research/orbit-closed-call-bound/orbit/frozen/source/bitE8-r865.json.gz create mode 100644 research/orbit-closed-call-bound/reviews/CONTROL-VALIDATION.json create mode 100644 research/orbit-closed-call-bound/reviews/CONTROLS.json create mode 100644 research/orbit-closed-call-bound/reviews/CROSS-REVIEW-ORBIT.md create mode 100644 research/orbit-closed-call-bound/reviews/GIT-SOURCE-CHECKS.json create mode 100644 research/orbit-closed-call-bound/reviews/REVIEW.md create mode 100644 research/orbit-closed-call-bound/reviews/SNAPSHOT-REVIEW.json create mode 100644 research/orbit-closed-call-bound/reviews/SOURCE-CLOSURE.json create mode 100644 research/orbit-closed-call-bound/verify.py diff --git a/research/orbit-closed-call-bound/CORE-SNAPSHOT.json b/research/orbit-closed-call-bound/CORE-SNAPSHOT.json new file mode 100644 index 0000000000..65338f1a20 --- /dev/null +++ b/research/orbit-closed-call-bound/CORE-SNAPSHOT.json @@ -0,0 +1,120 @@ +{ + "created_utc": "2026-10-20T22:41:45.079211+00:00", + "files": { + "FROZEN-SHA256.json": { + "bytes": 2484, + "sha256": "02f29358ac08aeaa969d82ba1967c25c9a28b536a6393e7bf44b6f3e6a2264ec" + }, + "LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "ORIGINS.json": { + "bytes": 5137, + "sha256": "f741f1faef3c0e55a23623b12ce1d9bc6905e947dadefd26c3665dd8bf397f1d" + }, + "README.md": { + "bytes": 4988, + "sha256": "13c72641d2f3f2da52da50cd6a9d0b9affafecd782fe9ce8f2696bf7ecaeed0e" + }, + "SOURCE-AUDIT.md": { + "bytes": 2785, + "sha256": "298a5c495f178816d03aec98bebbf9f179ca02fedc0ef38834915d563ab036d5" + }, + "SOURCES.json": { + "bytes": 2926, + "sha256": "9ab1c95b9502f9258351488c1167859227ec137d16b973df4773df0b11cce00f" + }, + "TASK.json": { + "bytes": 6406, + "sha256": "3fd614b0a40553687467121d10db7348a7f7126b10151ab622f32b99003f3585" + }, + "VERIFY.json": { + "bytes": 1169, + "sha256": "2996eaa7220147c35014832917009c3b36a1a811abe9da6672829a5c9e02b22c" + }, + "controls.py": { + "bytes": 23016, + "sha256": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671" + }, + "independent/CHECKS.json.gz": { + "bytes": 23291, + "sha256": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884" + }, + "independent/PROOF-INDEPENDENT.md": { + "bytes": 9866, + "sha256": "815f860c19ae9b25429b8102adfe5e2772bb8c1d5e9dc4bed6d9cacf43ccd8c4" + }, + "independent/VALIDATION.json": { + "bytes": 1585, + "sha256": "0ca399582830f9c4b0946002df15b5a68565b72f8290245580fa0304c02fffdd" + }, + "independent/check.py": { + "bytes": 17721, + "sha256": "c19dabdb8a6f84a44a2a3acbe86d9e2c380100c6217a3f89028742c15b423826" + }, + "orbit/CHECKS.json.gz": { + "bytes": 64855, + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + }, + "orbit/INPUTS.json": { + "bytes": 1890, + "sha256": "2b804087ce248aaf606043e90937638e68426783d9ec0f8b132ebed113ab32ca" + }, + "orbit/ORIGINS.md": { + "bytes": 3441, + "sha256": "2ef0ae702d9d477d293332c62e7f802d500b5afc4edc22ae39b3cb354a4c40f5" + }, + "orbit/OUTPUT-INVENTORY.json": { + "bytes": 980, + "sha256": "ac033d11090a326c1c9cfdc9fcbd5755425dfeec95d72132f7bd5b617eed33b6" + }, + "orbit/PACKAGE-FILES.json": { + "bytes": 566, + "sha256": "dd6a543672552e171a8f5dc6f7c3fa05d2bb09dfb312209dae959156de3f2b20" + }, + "orbit/PROOF.md": { + "bytes": 12586, + "sha256": "573b7ab3132f0d2d0c1777cc457a254e67a6ff001d0fc55b61447018806e56e6" + }, + "orbit/VALIDATION.json": { + "bytes": 933, + "sha256": "97ffa427c2dd824c96bea0c2abcaceb7a3736ad441b9fc6623a161c763fcc692" + }, + "orbit/check.py": { + "bytes": 21857, + "sha256": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3" + }, + "orbit/frozen/history/DERIVATIVE.md": { + "bytes": 3962, + "sha256": "ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399" + }, + "orbit/frozen/history/GEOMETRY-DERIVATIVE.json": { + "bytes": 8966, + "sha256": "7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98" + }, + "orbit/frozen/history/geometry_derivative.py": { + "bytes": 6520, + "sha256": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04" + }, + "orbit/frozen/source/LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "orbit/frozen/source/NOTICE.md": { + "bytes": 5439, + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a" + }, + "orbit/frozen/source/bitE8-r865.json.gz": { + "bytes": 33865, + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "verify.py": { + "bytes": 5401, + "sha256": "9566d768b7929e25e8ad62b96f27986827c7ae4d94a5faa25d296f58391d9a3e" + } + }, + "manifest_sha256": "f086955ecbc5e5d7a61a34e5c10c72baa0af5fc6f943cb209d0b0dda38d486c3", + "schema": "core_snapshot.v1", + "scope": "Complete candidate core; snapshot and subsequent review reports excluded to avoid circular hashes." +} diff --git a/research/orbit-closed-call-bound/FROZEN-SHA256.json b/research/orbit-closed-call-bound/FROZEN-SHA256.json new file mode 100644 index 0000000000..ef10dd3f17 --- /dev/null +++ b/research/orbit-closed-call-bound/FROZEN-SHA256.json @@ -0,0 +1,28 @@ +{ + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "13c72641d2f3f2da52da50cd6a9d0b9affafecd782fe9ce8f2696bf7ecaeed0e", + "SOURCE-AUDIT.md": "298a5c495f178816d03aec98bebbf9f179ca02fedc0ef38834915d563ab036d5", + "SOURCES.json": "9ab1c95b9502f9258351488c1167859227ec137d16b973df4773df0b11cce00f", + "TASK.json": "3fd614b0a40553687467121d10db7348a7f7126b10151ab622f32b99003f3585", + "VERIFY.json": "2996eaa7220147c35014832917009c3b36a1a811abe9da6672829a5c9e02b22c", + "controls.py": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671", + "independent/CHECKS.json.gz": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884", + "independent/PROOF-INDEPENDENT.md": "815f860c19ae9b25429b8102adfe5e2772bb8c1d5e9dc4bed6d9cacf43ccd8c4", + "independent/VALIDATION.json": "0ca399582830f9c4b0946002df15b5a68565b72f8290245580fa0304c02fffdd", + "independent/check.py": "c19dabdb8a6f84a44a2a3acbe86d9e2c380100c6217a3f89028742c15b423826", + "orbit/CHECKS.json.gz": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf", + "orbit/INPUTS.json": "2b804087ce248aaf606043e90937638e68426783d9ec0f8b132ebed113ab32ca", + "orbit/ORIGINS.md": "2ef0ae702d9d477d293332c62e7f802d500b5afc4edc22ae39b3cb354a4c40f5", + "orbit/OUTPUT-INVENTORY.json": "ac033d11090a326c1c9cfdc9fcbd5755425dfeec95d72132f7bd5b617eed33b6", + "orbit/PACKAGE-FILES.json": "dd6a543672552e171a8f5dc6f7c3fa05d2bb09dfb312209dae959156de3f2b20", + "orbit/PROOF.md": "573b7ab3132f0d2d0c1777cc457a254e67a6ff001d0fc55b61447018806e56e6", + "orbit/VALIDATION.json": "97ffa427c2dd824c96bea0c2abcaceb7a3736ad441b9fc6623a161c763fcc692", + "orbit/check.py": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3", + "orbit/frozen/history/DERIVATIVE.md": "ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399", + "orbit/frozen/history/GEOMETRY-DERIVATIVE.json": "7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98", + "orbit/frozen/history/geometry_derivative.py": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04", + "orbit/frozen/source/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "orbit/frozen/source/NOTICE.md": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "orbit/frozen/source/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "verify.py": "9566d768b7929e25e8ad62b96f27986827c7ae4d94a5faa25d296f58391d9a3e" +} diff --git a/research/orbit-closed-call-bound/LICENSE b/research/orbit-closed-call-bound/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/orbit-closed-call-bound/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/orbit-closed-call-bound/ORIGINS.json b/research/orbit-closed-call-bound/ORIGINS.json new file mode 100644 index 0000000000..8d1973a718 --- /dev/null +++ b/research/orbit-closed-call-bound/ORIGINS.json @@ -0,0 +1,109 @@ +{ + "LICENSE": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "README.md": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "13c72641d2f3f2da52da50cd6a9d0b9affafecd782fe9ce8f2696bf7ecaeed0e" + }, + "SOURCE-AUDIT.md": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "298a5c495f178816d03aec98bebbf9f179ca02fedc0ef38834915d563ab036d5" + }, + "SOURCES.json": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "9ab1c95b9502f9258351488c1167859227ec137d16b973df4773df0b11cce00f" + }, + "TASK.json": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "3fd614b0a40553687467121d10db7348a7f7126b10151ab622f32b99003f3585" + }, + "VERIFY.json": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "2996eaa7220147c35014832917009c3b36a1a811abe9da6672829a5c9e02b22c" + }, + "controls.py": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671" + }, + "independent/CHECKS.json.gz": { + "original_sha256": "d35b53eed29d63d97b4eeb6ba05c302a53656241e894a262bd7344ec2178a01a", + "provenance": "Component input/source and transport inventories", + "sha256": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884" + }, + "independent/PROOF-INDEPENDENT.md": { + "provenance": "Component input/source and transport inventories", + "sha256": "815f860c19ae9b25429b8102adfe5e2772bb8c1d5e9dc4bed6d9cacf43ccd8c4" + }, + "independent/VALIDATION.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "0ca399582830f9c4b0946002df15b5a68565b72f8290245580fa0304c02fffdd" + }, + "independent/check.py": { + "provenance": "Component input/source and transport inventories", + "sha256": "c19dabdb8a6f84a44a2a3acbe86d9e2c380100c6217a3f89028742c15b423826" + }, + "orbit/CHECKS.json.gz": { + "original_sha256": "31f90a56ce4ce6bbdcee97b44eabf07ef82121cbe22c640b85ac364baaec7230", + "provenance": "Component input/source and transport inventories", + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + }, + "orbit/INPUTS.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "2b804087ce248aaf606043e90937638e68426783d9ec0f8b132ebed113ab32ca" + }, + "orbit/ORIGINS.md": { + "provenance": "Component input/source and transport inventories", + "sha256": "2ef0ae702d9d477d293332c62e7f802d500b5afc4edc22ae39b3cb354a4c40f5" + }, + "orbit/OUTPUT-INVENTORY.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "ac033d11090a326c1c9cfdc9fcbd5755425dfeec95d72132f7bd5b617eed33b6" + }, + "orbit/PACKAGE-FILES.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "dd6a543672552e171a8f5dc6f7c3fa05d2bb09dfb312209dae959156de3f2b20" + }, + "orbit/PROOF.md": { + "provenance": "Component input/source and transport inventories", + "sha256": "573b7ab3132f0d2d0c1777cc457a254e67a6ff001d0fc55b61447018806e56e6" + }, + "orbit/VALIDATION.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "97ffa427c2dd824c96bea0c2abcaceb7a3736ad441b9fc6623a161c763fcc692" + }, + "orbit/check.py": { + "provenance": "Component input/source and transport inventories", + "sha256": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3" + }, + "orbit/frozen/history/DERIVATIVE.md": { + "provenance": "Component input/source and transport inventories", + "sha256": "ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399" + }, + "orbit/frozen/history/GEOMETRY-DERIVATIVE.json": { + "provenance": "Component input/source and transport inventories", + "sha256": "7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98" + }, + "orbit/frozen/history/geometry_derivative.py": { + "provenance": "Component input/source and transport inventories", + "sha256": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04" + }, + "orbit/frozen/source/LICENSE": { + "provenance": "Component input/source and transport inventories", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "orbit/frozen/source/NOTICE.md": { + "provenance": "Component input/source and transport inventories", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a" + }, + "orbit/frozen/source/bitE8-r865.json.gz": { + "original_sha256": "fbc56ed40d857b6ed74cbab1badd144fc276f08f76326dcb21a3ab2178a40c13", + "provenance": "Component input/source and transport inventories", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "verify.py": { + "provenance": "Parent integration of explicit C09 orbit contribution", + "sha256": "9566d768b7929e25e8ad62b96f27986827c7ae4d94a5faa25d296f58391d9a3e" + } +} diff --git a/research/orbit-closed-call-bound/README.md b/research/orbit-closed-call-bound/README.md new file mode 100644 index 0000000000..c8a92a387f --- /dev/null +++ b/research/orbit-closed-call-bound/README.md @@ -0,0 +1,29 @@ +# Sharp calls for an orbit-closed scalar caller + +The fixed two-bank, three-port query grammar needs exactly `3B` calls to apply `xyz` to `6B` independent public rows. The lower bound allows arbitrary finite dirty scalar spectators that must be returned unchanged, with parameter-independent invertible bridges mixing public and spectator coordinates. Three cyclic port-conjugates per disjoint bank pair attain the bound without spectators. This is a sharp formal query count; the scalar bridges have not been assigned a native or physical implementation. + +The proof keeps three models distinct. Over `F2[C2^3]`, dual-number first variation gives rank at most two per call and target rank `6B`. For complex order-four variables, two exact evaluations give the same ranks. A separately specified regular cover admits the cyclic order-three source action, with ranks six and `18B`. A source automorphism is not silently treated as a scalar bridge in a single-character evaluation. The lower bound concerns a full formal identity or a separately justified operator representation; the orders of concrete native transforms alone do not establish that reduction. + +[The main proof](orbit/PROOF.md) gives the all-B, all-spectator and independent-generator tensor statements. [The independent proof](independent/PROOF-INDEPENDENT.md) separates the regular-cover argument and complete dirty-input interface. The attaining word has `3B` queries and `4B` nonidentity scalar permutation events in its displayed unmerged implementation; only query count is optimized. + +The geometric motivation is authenticated against the pinned E8 root chart: 54 eligible root lines form 18 orthogonal triples, each with a common rank-five spectator projector. The finite census does not establish a global native arity or a reduction of all E8 callers to this grammar. Only the root-line data are used; the retained R865 circuit is not replayed or newly certified. + +## Reproduction and scope + +Run `python3.12 -B scripts/research_package.py --package research/orbit-closed-call-bound`. `VERIFY.json` lists the direct standard-library commands for a read-only Git-free export. Every executed source and expected receipt is authenticated, captured source is compiled with optimization disabled, and generated output must be fresh and external. Complete typed receipts are compared. Finite coefficient and failure checks support the examples; the written rank and cyclic-word arguments supply the all-parameter theorem. + +Finite word coverage uses `B=1,2,4` with `h=0,1,3` dirty spectators, retaining every formal coefficient. The independent regular actions check 1,104 BIT columns and 8,832 C4 columns. Three cover fixtures check the actual covariance. The two mathematical components execute 30 semantic defect rejections and 30 corresponding named-guard deletions; package-integrity controls are separate. + +The theorem assumes the declared local generator and parameter-independent bridges. Arbitrary internal address maps, cross-orbit operators, changed outputs, broader coupled queries and a complete native reduction remain separate questions. Native child admission, source scans, scalar/address work, restoration costs, precision, ownership, storage and tape execution are not implied by the formal query optimum. No new kappa or selected-result change is claimed. + +## Sources and related work + +Scientific data are pinned to `20ecf2891d80b5acf18d980b2164fb44ea7faa90`; current guidance is pinned to `12fa8c5c844be21bfefb38a19503fbd867a11244`, priority 7. The original C09 first-variation note, script and receipt remain unchanged in the component source inventory. The new contribution completes sharpness and the restored-spectator extension with independent exact review. + +[PR4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023) treats a different one-bank order-four/quartic query alphabet, including a swap-algebra bridge theorem. Its `2n` optimum does not certify the two-bank, three-port model here. Earlier group-algebra rank and specialization methods, including eumemic's retained PR288 source and Ali Romman's PR468, are credited in `SOURCE-AUDIT.md`; those methods are not claimed as new. + +The E8 Hamming-chart data retain Dylan Crow / utcorvusvolat-dotcom's PR370 ancestry through eumemic's carrier-skeleton package, with the original Apache-2.0 notices and AI assistance disclosure. Ross Richardson with substantial OpenAI Codex assistance in the present proof, construction, exact checks and separate mathematical review contexts. AI review is not independent human acceptance or a formal-kernel proof. + +## Open next questions + +Bind one actual paid native caller to the displayed grammar before applying the query floor to it. The smallest useful next step is a literal source-to-generator and bridge map, preserving every independent input and returned spectator. Missing that reduction and its complete physical bill blocks any supplier conclusion; `TASK.json` records this boundary. diff --git a/research/orbit-closed-call-bound/SOURCE-AUDIT.md b/research/orbit-closed-call-bound/SOURCE-AUDIT.md new file mode 100644 index 0000000000..7923172993 --- /dev/null +++ b/research/orbit-closed-call-bound/SOURCE-AUDIT.md @@ -0,0 +1,13 @@ +# Attribution and publication scope + +The historical paired-bit C09 note supplies the root-chart census and the first-variation obstruction. Its original sources and receipt are retained unchanged and authenticated. The present package adds the matching three-call cyclic-port word per bank pair, the arbitrary restored dirty scalar-spectator extension, explicit regular-cover semantics and new independent finite checks. It does not turn local root geometry into a native caller construction. + +The original root file is `research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz` at scientific commit `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. Only its root-line table is consumed. Its source package credits Dylan Crow / utcorvusvolat-dotcom's PR370, with Anthropic Claude assistance, and eumemic's retained carrier-skeleton work. The complete original notice and Apache-2.0 license are preserved. No circuit, hosting or frontier claim from the larger source package is freshly verified here. + +The group-algebra normalization, rank and specialization methods have prior use in eumemic's [retained PR288 note](https://github.com/CrocSwap/integer-mult-bounds/blob/20ecf2891d80b5acf18d980b2164fb44ea7faa90/research/abelian-cayley-metric-scope/sources/pr288-README.md) and Ali Romman's [PR468](https://github.com/CrocSwap/integer-mult-bounds/blob/07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea/research/bit-three-register-lower-bound/README.md). The latter concerns three registers and rational rank-one frames in a different abelian group algebra. Its large finite search is not rerun or invoked as a lemma here. These mechanisms are credited rather than claimed as new. + +The current [fixed-support unary package / PR4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023) proves a `2n` optimum for a distinct order-four carrier and swap-algebra bridges, plus a narrower quartic result. The C09 model instead charges one simultaneous two-bank, three-port diagonal call. Neither alphabet reduction follows merely from the shared rank method. The separate cubic scalar-caller contribution concerns yet another ring and is excluded from this PR. + +Current tracked README and source-manifest searches found no direct retained C09 script paths or named orbit-closed claim. Live overlap coverage is recorded externally at intake and submission; textual searches are leads, not novelty certificates. Exact source pins and complete component inventories permit review without the author's original local directories. + +Ross Richardson with substantial OpenAI Codex assistance in the new construction, proofs, verification and separate mathematical review contexts. Finite exact computations, written all-parameter proofs, automated package checks and formal-kernel acceptance are distinct. diff --git a/research/orbit-closed-call-bound/SOURCES.json b/research/orbit-closed-call-bound/SOURCES.json new file mode 100644 index 0000000000..28dae2885a --- /dev/null +++ b/research/orbit-closed-call-bound/SOURCES.json @@ -0,0 +1,65 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "docs/research/research-family-status.md", + "usage": "provenance", + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f" + }, + { + "path": "research/fixed-support-unary-query-bounds/README.md", + "git_blob": "29e1f2ba643e36ef43d566d32242bf6950b2ab27", + "sha256": "58f4675f0b6694177bba3a2c8de7bf7d9445f6e87437356e2cf1e33bb090f3d4", + "usage": "provenance" + }, + { + "path": "research/e8-bit-carrier-skeleton/NOTICE.md", + "git_blob": "5a0ecdcd2c7fad0488740a1da0f633b73b56a809", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "usage": "provenance", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/NOTICE.md" + }, + { + "path": "research/e8-bit-carrier-skeleton/LICENSE", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "provenance", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/LICENSE" + }, + { + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "usage": "provenance", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz" + }, + { + "path": "research/abelian-cayley-metric-scope/sources/pr288-README.md", + "usage": "provenance", + "git_blob": "dc04f533bd0f3b185969bb259e876a73714f7285", + "sha256": "c091e98c415e2a80bb28402b789363eb97dd3492061ca8875e421ae437de7482", + "pin": "head:20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/abelian-cayley-metric-scope/sources/pr288-README.md" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "provenance", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "pin": "head:07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea:research/bit-three-register-lower-bound/README.md" + } + ] +} diff --git a/research/orbit-closed-call-bound/TASK.json b/research/orbit-closed-call-bound/TASK.json new file mode 100644 index 0000000000..e7fe01c4b7 --- /dev/null +++ b/research/orbit-closed-call-bound/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the sharp 3B query optimum for the fixed orbit-closed BIT/C4 caller grammars, including returned dirty scalar spectators and the separately stated C3 regular-cover model.", + "scope_change_reason": "Explicit user assignment to complete preserved C09 contributions sequentially. This fixed formal query alphabet does not solve the current QQ16 installed-caller task.", + "bottleneck_link": "A local paired orbit transform cannot be promoted to a caller without paying enough distinct parameter variations; scalar spectators do not remove that rank requirement.", + "budget_minutes": 240, + "stop_rule": "Authenticate the pinned E8 orbit census, prove the exact lower bound and matching cyclic-port word, and test finite coefficient/control coverage. No native grammar-reduction claim or broader caller search.", + "outcome": "partial", + "evidence": "Written all-parameter sharp query theorem, source-bound finite geometry and exact formal word checks, plus separate independent mathematical review.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance, including separate AI mathematical review contexts; no independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Which actual paid native caller interfaces factor through this orbit-closed grammar?", + "why_it_matters": "The sharp formal query count does not include internal address automorphisms or other operator-valued bridges.", + "first_step": "Bind one literal native caller word to the stated parameter-independent bridge and two-bank local generator contracts.", + "blocked_by": "No complete native reduction, scan/owner/precision/tape bill or selected supplier admission is supplied." + } + ] +} diff --git a/research/orbit-closed-call-bound/VERIFY.json b/research/orbit-closed-call-bound/VERIFY.json new file mode 100644 index 0000000000..dabe1e5cce --- /dev/null +++ b/research/orbit-closed-call-bound/VERIFY.json @@ -0,0 +1,47 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "orbit" + ], + "timeout_seconds": 120, + "checks": "Pinned complete E8 orbit census, exact sharp formal query word, distinct BIT/C4/regular-cover hypotheses and actual semantic controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent" + ], + "timeout_seconds": 120, + "checks": "Separate exact group-ring and variation-rank checks, all declared dirty input columns, and model-sensitive semantic defects." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py", + "--package", + "{package}" + ], + "timeout_seconds": 90, + "checks": "Captured-source authentication, complete typed record equality, exact stage coverage and output-path behavior with check deletion sensitivity." + } + ] +} diff --git a/research/orbit-closed-call-bound/controls.py b/research/orbit-closed-call-bound/controls.py new file mode 100644 index 0000000000..860b6050a7 --- /dev/null +++ b/research/orbit-closed-call-bound/controls.py @@ -0,0 +1,460 @@ +#!/usr/bin/env python3 +"""Compact source, complete-record and real semantic controls for C09 orbit calls. + +Adapted from the reviewed C07 wrapper controls. All mutations are disposable. +Substantial OpenAI Codex assistance; Apache-2.0. +""" +import argparse +import copy +import gzip +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import types + +STAGES = ('orbit', 'independent') + +def require(ok, message): + if not ok: + raise ValueError(message) + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def load_module(path, raw=None, name="reviewed_controls_module"): + source = path.read_bytes() if raw is None else raw + module = types.ModuleType(name) + module.__file__ = str(path) + exec(compile(source, str(path), "exec", dont_inherit=True, optimize=0), module.__dict__) + return module + +def reject(label, action, expected, records, exact=True): + try: + action() + except (ValueError, AssertionError) as error: + message = str(error) + require(message == expected if exact else expected in message, + "wrong rejection for " + label + ": " + message) + records.append({"name": label, "intended_gate": expected}) + else: + raise ValueError("control accepted: " + label) + +def fixture(root, files, originals=None): + root.mkdir(parents=True) + hashes, origins = {}, {} + for name, raw in files.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + hashes[name] = sha(raw) + origins[name] = {"sha256": sha(raw)} + if originals and name in originals: + origins[name]["original_sha256"] = sha(originals[name]) + (root / "FROZEN-SHA256.json").write_text(json.dumps(hashes)) + (root / "ORIGINS.json").write_text(json.dumps(origins)) + return root + +def loader_checks(v, temporary): + positive = ( + b"import json, sys\nfrom pathlib import Path\n" + b"assert __debug__ and sys.flags.optimize == 0, 'CHILD_OPTIMIZATION'\n" + b"assert __file__ == sys.argv[0], 'SCRIPT_FILE_ARGUMENT'\n" + b"Path(sys.argv[-1]).write_text(json.dumps(sys.argv[1:-1]))\n" + ) + files = { + "script with spaces.py": positive, + "direct.py": b"assert False, 'DIRECT_ASSERT'\n", + "nested.py": b"def inner():\n assert False, 'NESTED_ASSERT'\ninner()\n", + "notfinite.json": b'{"a":NaN}', + } + root = fixture(temporary / "loader", files) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + output = temporary / "literal argument result.json" + frozen.run("script with spaces.py", ["argument with spaces", output]) + require(json.loads(output.read_text()) == ["argument with spaces"], "preserved script arguments") + for name, marker in (("direct.py", "DIRECT_ASSERT"), ("nested.py", "NESTED_ASSERT")): + reject(name, lambda name=name: frozen.run(name, []), + "AssertionError: " + marker, rejected, exact=False) + # This disposable source is changed only after Frozen.raw has returned. + # The script passed to the interpreter must remain the captured old bytes. + original_path, calls = frozen.path, {"count": 0} + def changed_path(name): + path = original_path(name) + calls["count"] += 1 + if calls["count"] == 2: + path.write_bytes(b"raise RuntimeError('REOPENED_CHANGED_SOURCE')\n") + return path + frozen.path = changed_path + try: + frozen.run("script with spaces.py", ["captured bytes", output]) + require(calls["count"] == 2 and json.loads(output.read_text()) == ["captured bytes"], + "captured authenticated source execution") + finally: + frozen.path = original_path + (root / "script with spaces.py").write_bytes(positive) + (root / "direct.py").write_bytes(b"PASS = True\n") + reject("changed_executable_source", lambda: frozen.run("direct.py", []), + "changed frozen input: direct.py", rejected) + (root / "direct.py").unlink() + reject("missing_executable_source", lambda: frozen.run("direct.py", []), + "missing regular input: direct.py", rejected) + reject("unregistered_source", lambda: frozen.run("absent.py", []), + "unregistered input: absent.py", rejected) + reject("absolute_path", lambda: frozen.path("/etc/passwd"), "unsafe package path", rejected) + reject("parent_escape", lambda: frozen.path("../outside"), "unsafe package path", rejected) + (root / "link.py").symlink_to(root / "nested.py") + reject("symlink_input", lambda: frozen.path("link.py"), + "missing regular input: link.py", rejected) + outside = temporary / "external" + outside.mkdir() + (outside / "data.json").write_text("{}") + (root / "outside").symlink_to(outside, target_is_directory=True) + reject("ancestor_symlink_escape", lambda: frozen.path("outside/data.json"), + "input escapes package", rejected) + reject("direct_runtime_requirement", lambda: v.require(False, "DIRECT_RUNTIME_GATE"), + "DIRECT_RUNTIME_GATE", rejected) + return {"rejections": rejected, "captured_source_survives_disposable_path_change": True, + "child_assertions_enabled": True, "file_and_argument_semantics_preserved": True} + +def record_checks(v, temporary): + value = {"integer": 1, "boolean": True, "nested": {"ordered": [1, 2, 3]}} + raw = json.dumps(value).encode() + root = fixture(temporary / "record", {"expected.json": raw}) + frozen, rejected = v.Frozen(root), [] + frozen.compare("expected.json", raw) + mutations = { + "boolean_for_integer": dict(value, integer=True), + "float_for_integer": dict(value, integer=1.0), + "integer_for_boolean": dict(value, boolean=1), + "nested_omission": dict(value, nested={}), + "ordered_list_reorder": dict(value, nested={"ordered": [1, 3, 2]}), + "ordered_list_truncate": dict(value, nested={"ordered": [1, 2]}), + } + for label, changed in mutations.items(): + reject(label, lambda changed=changed: frozen.compare("expected.json", json.dumps(changed).encode()), + "complete typed record mismatch: expected.json", rejected) + reject("duplicate_json_key", lambda: v.data(b'{"a":1,"a":2}'), + "duplicate JSON key: a", rejected) + reject("nested_duplicate_json_key", lambda: v.data(b'{"n":{"a":1,"a":2}}'), + "duplicate JSON key: a", rejected) + for value_ in ("NaN", "Infinity", "-Infinity"): + reject("nonfinite_" + value_, lambda value_=value_: v.data(value_.encode()), + "nonfinite JSON constant: " + value_, rejected) + (root / "expected.json").unlink() + reject("missing_expected_record", lambda: frozen.compare("expected.json", raw), + "missing regular input: expected.json", rejected) + require(not (root / "expected.json").exists(), "missing expected record regenerated") + (root / "expected.json").write_bytes(raw) + saved = v.require + try: + v.require = lambda ok, message: None if message.startswith("complete typed record mismatch:") else saved(ok, message) + try: + reject("deleted_record_gate", + lambda: frozen.compare("expected.json", json.dumps(mutations["boolean_for_integer"]).encode()), + "complete typed record mismatch: expected.json", []) + except ValueError as error: + require(str(error) == "control accepted: deleted_record_gate", "record check-deletion sensitivity") + else: + raise ValueError("record check deletion not detected") + finally: + v.require = saved + return {"rejections": rejected, "named_record_gate_deletion_detected": True} + +def compression_checks(v, temporary): + name, plain = "original.json.gz", b'{"original":[1,2,3]}\n' + root = fixture(temporary / "compression", {name: gzip.compress(plain, mtime=0)}, {name: plain}) + frozen, rejected = v.Frozen(root), [] + frozen.check_all() + changed = gzip.compress(b'{"original":[1,2,4]}\n', mtime=0) + (root / name).write_bytes(changed) + reject("changed_compressed_input", frozen.check_all, + "changed frozen input: " + name, rejected) + frozen.hashes[name] = sha(changed) + reject("changed_container_origin", frozen.check_all, + "origin digest mismatch: " + name, rejected) + frozen.origins[name]["sha256"] = sha(changed) + reject("changed_original_after_transport_rebinding", frozen.check_all, + "original decoded bytes changed: " + name, rejected) + same = gzip.compress(plain, mtime=17) + (root / name).write_bytes(same) + frozen.hashes[name] = frozen.origins[name]["sha256"] = sha(same) + frozen.check_all() + saved = frozen.origins + frozen.origins = {} + reject("omitted_origin", frozen.check_all, "frozen/origin inventory mismatch", rejected) + frozen.origins = saved + return {"rejections": rejected, "equivalent_recompression_accepted": True} + +def deletion(v, action, gate): + saved = v.require + try: + v.require = lambda ok, message: None if message == gate else saved(ok, message) + try: + reject('deleted_'+gate, action, gate, []) + except ValueError as error: + require(str(error) == 'control accepted: deleted_'+gate, 'intended check deletion') + else: + raise ValueError('deleted gate still rejected: '+gate) + finally: + v.require = saved + +def real_records(v, package): + frozen, records = v.Frozen(package), [] + names = sorted(set().union(*(v.expected_records(stage) for stage in STAGES))) + def leaves(value, path=()): + if isinstance(value, dict): + for key in sorted(value): + yield from leaves(value[key], path+(key,)) + elif isinstance(value, list): + for i, child in enumerate(value): + yield from leaves(child, path+(i,)) + else: + yield path, value + for name in names: + raw = frozen.raw(name) + value = v.data(raw) + frozen.compare(name, json.dumps(value).encode()) + path, old = max(leaves(value), key=lambda item: len(item[0])) + require(len(path) > 1, 'real nested record coverage') + changed, omitted = copy.deepcopy(value), copy.deepcopy(value) + parent, other = changed, omitted + for key in path[:-1]: + parent, other = parent[key], other[key] + parent[path[-1]] = not old if type(old) is bool else old+1 if type(old) is int else {'changed': True} + del other[path[-1]] + rejected = [] + for label, candidate in (('deep_field_changed', changed), ('deep_field_omitted', omitted)): + reject(label, lambda candidate=candidate: frozen.compare(name, json.dumps(candidate).encode()), + 'complete typed record mismatch: '+name, rejected) + records.append({'record': name, 'sha256': sha(raw), 'nested_path': list(path), 'rejections': rejected}) + require(len(records) == 2, 'two complete scientific records') + return records + +def coverage_checks(v, temporary): + require(set(v.STAGES) == set(STAGES), 'exact two science stages') + rejected, counts = [], {} + for stage in STAGES: + names = sorted(v.expected_records(stage)) + v.check_coverage(stage, names) + counts[stage] = len(names) + for label, changed in (('omitted', []), ('duplicated', names+names), + ('extra', names+['extra.json'])): + reject(stage+'_'+label, + lambda stage=stage, changed=changed: v.check_coverage(stage, changed), + 'complete stage record coverage changed: '+stage, rejected) + require(counts == dict.fromkeys(STAGES, 1), 'two singleton complete records') + + class Tiny: + def __init__(self, omit=False): + self.compared, self.scripts, self.omit = [], [], omit + def run(self, script, arguments): + self.scripts.append(script) + require(len(arguments) == 2 and arguments[0] == '--output', + 'exact declared output argument') + output = Path(arguments[1]) + require(output.is_relative_to(temporary), 'external dispatch scratch') + output.write_text('{}') + def compare(self, name, raw): + require(raw == b'{}', 'generated fixture reaches complete comparison') + if not self.omit: + self.compared.append(name) + for stage in STAGES: + scratch = temporary/('dispatch-'+stage) + scratch.mkdir() + tiny = Tiny() + v.replay(tiny, scratch, stage) + v.check_coverage(stage, tiny.compared) + require(tiny.scripts == [v.STAGES[stage][0]], 'one declared checker selected') + scratch = temporary/'dispatch-omitted-comparison' + scratch.mkdir() + tiny = Tiny(True) + v.replay(tiny, scratch, 'orbit') + action = lambda: v.check_coverage('orbit', tiny.compared) + gate = 'complete stage record coverage changed: orbit' + reject('omitted_actual_compare', action, gate, rejected) + deletion(v, action, gate) + return {'rejections': rejected, 'stage_counts': counts, + 'actual_dispatch_tested_with_tiny_receipts': True, + 'executed_check_deletions': 1} + +def output_checks(v, package, temporary): + rejected, argv = [], sys.argv + existing = temporary/'existing output.json' + existing.write_text('preserved') + def invoke(output): + sys.argv = ['verify.py', '--stage', 'orbit', '--output', str(output)] + v.main() + try: + reject('relative_output', lambda: invoke(Path('relative.json')), + 'output must be absolute', rejected) + reject('existing_output', lambda: invoke(existing), 'output already exists', rejected) + reject('internal_output', lambda: invoke(package/'forbidden.json'), + 'output must be external', rejected) + original_replay = v.replay + race_output = temporary/'racing output.json' + def racing_replay(frozen, scratch, stage): + frozen.compared.extend(sorted(v.expected_records(stage))) + race_output.write_text('race winner preserved') + v.replay = racing_replay + try: + try: + invoke(race_output) + except FileExistsError: + require(race_output.read_text() == 'race winner preserved', + 'exclusive creation preserves racing output') + rejected.append({'name': 'output created during replay', + 'intended_gate': 'exclusive output creation FileExistsError'}) + else: + raise ValueError('racing output overwritten') + finally: + v.replay = original_replay + finally: + sys.argv = argv + require(existing.read_text() == 'preserved', 'existing output retained') + return {'rejections': rejected, 'early_output_guards': True, + 'exclusive_output_creation_exercised': True} + +def child(package): + v = load_module(package/'verify.py') + v.Frozen(package).check_all() + with tempfile.TemporaryDirectory(prefix='C09 orbit compact controls ') as directory: + temporary = Path(directory) + result = {'loader': loader_checks(v, temporary), 'record_gate': record_checks(v, temporary), + 'compression': compression_checks(v, temporary), + 'coverage': coverage_checks(v, temporary), + 'sources': source_checks(v, package, temporary), + 'scientific': scientific_checks(v, package), + 'output': output_checks(v, package, temporary), + 'real_records': real_records(v, package)} + v.Frozen(package).check_all() + return {'parent_optimization': sys.flags.optimize, **result} + + +def source_checks(v, package, temporary): + frozen, rejected = v.Frozen(package), [] + orbit = load_module(package/'orbit/check.py', frozen.raw('orbit/check.py')) + blobs = {name: frozen.raw('orbit/'+name) for name in orbit.PINS} + original = blobs['frozen/history/geometry_derivative.py'] + changed = dict(blobs) + changed['frozen/history/geometry_derivative.py'] = original+b"\ndef nested_assertion():\n assert False, 'HISTORICAL_NESTED_ASSERT'\nnested_assertion()\n" + reject('captured_historical_nested_assertion', lambda: orbit.captured_history(changed), + 'HISTORICAL_NESTED_ASSERT', rejected) + literal = "SOURCE = Path('/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz')" + for label, value in (('duplicate', original+b'\n'+literal.encode()+b'\n'), + ('missing', original.replace(literal.encode(), b'# removed SOURCE literal'))): + candidate = dict(blobs) + candidate['frozen/history/geometry_derivative.py'] = value + reject(label+'_historical_adapter', + lambda candidate=candidate: orbit.captured_history(candidate), + 'unique historical adaptation', rejected) + candidate = dict(blobs) + candidate['frozen/history/geometry_derivative.py'] = original+b'\nEXTRA_READ = SOURCE.read_bytes()\n' + reject('undeclared_additional_source_read', lambda: orbit.captured_history(candidate), + 'captured root read count', rejected) + source_dir = temporary/'orbit sources' + for name, value in blobs.items(): + target = source_dir/name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(value) + (source_dir/'INPUTS.json').write_bytes(frozen.raw('orbit/INPUTS.json')) + source_name = 'frozen/source/bitE8-r865.json.gz' + original_here = orbit.HERE + try: + orbit.HERE = source_dir + (source_dir/source_name).write_bytes(blobs[source_name]+b' ') + reject('changed_actual_root_source', orbit.run, + 'authenticated input: '+source_name, rejected) + finally: + orbit.HERE = original_here + return {'rejections': rejected, 'historical_assertions_execute_with_optimization_zero': True, + 'all_mutations_in_disposable_bytes_or_directory': True, + 'no_path_import_or_pyc_execution': True, + 'full_scientific_stages_replayed': False} + + +def scientific_checks(v, package): + frozen, rejected = v.Frozen(package), [] + independent = load_module(package/'independent/check.py', + frozen.raw('independent/check.py')) + controls = independent.controls() + require(len(controls) == 9 and all(row['same_guard_deletion'] == 'ACCEPTED' for row in controls), + 'complete independent orbit controls') + rejected.extend({'name': row['name'], 'intended_gate': row['intended_guard']} for row in controls) + orbit = load_module(package/'orbit/check.py', frozen.raw('orbit/check.py')) + events = orbit.word(1, 1) + orbit.endpoint(orbit.ring_word(1, 1, events), 1, 1, 2) + omitted_query = copy.deepcopy(events) + del omitted_query[next(index for index, event in enumerate(omitted_query) if event['op'] == 'query')] + bad_public = orbit.ring_word(1, 1, omitted_query) + bad_private = orbit.ring_word(1, 1, events[:-1]) + cases = [ + ('actual orbit query omitted', 'public every-coefficient endpoint', + lambda deleted: orbit.endpoint(bad_public, 1, 1, 2, deleted)), + ('actual borrowed spectator return omitted', 'dirty spectator every-coefficient endpoint', + lambda deleted: orbit.endpoint(bad_private, 1, 1, 2, deleted)), + ('full common transform violates actual local alphabet', 'local first-order capacity', + lambda deleted: orbit.local_capacity(orbit.target(4, 3, 2), deleted)), + ] + for name, guard, probe in cases: + result = orbit.reject_delete(name, guard, probe) + require(result['same_guard_deletion_accepts'], 'actual orbit production gate deletion') + rejected.append({'name': name, 'intended_gate': guard}) + return {'rejections': rejected, 'executed_check_deletions': 12, + 'actual_mathematical_mutations_after_authentication': True, + 'deletion_scope': 'the same named production predicate', + 'full_scientific_stages_replayed': False} + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--package', type=Path, required=True) + parser.add_argument('--output', type=Path) + parser.add_argument('--child', action='store_true') + args = parser.parse_args() + package = args.package.resolve() + if args.output: + require(args.output.is_absolute(), 'control output must be absolute') + require(not args.output.exists(), 'control output already exists') + require(not args.output.resolve().is_relative_to(package), 'control output must be external') + if args.child: + print(json.dumps(child(package), sort_keys=True)) + return + names = ['verify.py', 'FROZEN-SHA256.json', 'ORIGINS.json', + 'orbit/check.py', 'independent/check.py'] + before = {name: sha((package/name).read_bytes()) for name in names} + results = [] + for optimized in (False, True): + command = [sys.executable, '-I', '-B']+(['-O'] if optimized else []) + command += [str(Path(__file__).resolve()), '--package', str(package), '--child'] + completed = subprocess.run(command, capture_output=True, text=True) + require(completed.returncode == 0, completed.stdout+completed.stderr) + results.append(json.loads(completed.stdout)) + require(before == {name: sha((package/name).read_bytes()) for name in names}, + 'reviewed source changed during controls') + comparable = [{k: value for k, value in row.items() if k != 'parent_optimization'} + for row in results] + require(comparable[0] == comparable[1], 'normal and optimized controls differ') + count = sum(len(row.get('rejections', [])) for row in results[0].values() + if isinstance(row, dict)) + count += sum(len(row['rejections']) for row in results[0]['real_records']) + deletions = 1+sum(row.get('executed_check_deletions', 0) + for row in results[0].values() if isinstance(row, dict)) + result = {'status': 'PASS_C09_ORBIT_COMPACT_SOURCE_RECORD_AND_SEMANTIC_CONTROLS', + 'source_hashes': before, 'control_source_sha256': sha(Path(__file__).read_bytes()), + 'runs': results, 'normal_and_optimized_receipts_equal_except_mode': True, + 'intended_rejections_per_mode': count, + 'executed_check_deletions_per_mode': deletions, + 'full_scientific_receipts_compared': 2, + 'full_scientific_stages_replayed': False, 'no_new_kappa': True} + if args.output: + with args.output.open('x') as destination: + destination.write(json.dumps(result, sort_keys=True, indent=2)+'\n') + print(json.dumps({key: result[key] for key in ('status', 'intended_rejections_per_mode', + 'executed_check_deletions_per_mode', 'full_scientific_receipts_compared')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/orbit-closed-call-bound/independent/CHECKS.json.gz b/research/orbit-closed-call-bound/independent/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..a3f024974e6062cba75ac83d81e7a2d6ee5155c8 GIT binary patch literal 23291 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 literal 0 HcmV?d00001 diff --git a/research/orbit-closed-call-bound/independent/PROOF-INDEPENDENT.md b/research/orbit-closed-call-bound/independent/PROOF-INDEPENDENT.md new file mode 100644 index 0000000000..a1ab6dbb02 --- /dev/null +++ b/research/orbit-closed-call-bound/independent/PROOF-INDEPENDENT.md @@ -0,0 +1,185 @@ +# Sharp orbit-call bound with arbitrary dirty spectators + +Ross Richardson with substantial OpenAI Codex assistance. Apache-2.0. + +The three arguments below use three explicitly different algebras. They share +an abstract call-count conclusion, but none proves that an arbitrary native +controller belongs to these algebras. The root-orbit geometry is the companion +component's source-bound obligation. This independent proof and checker do not +import that component, its historical program, or a Clifford compiler. + +## Precise linear-word contract + +Let `B>=1` and `h>=0`. There are `2B` data banks with three port coordinates +each, and `h` additional spectator coordinates. The entire matrix therefore +has `n=6B+h` rows and columns. Every initial data and spectator coordinate is +independent and arbitrary. A spectator is a coordinate of this algebraic +module; calling it scalar does not assert a particular physical array width. + +A charged local call, up to parameter-independent invertible scalar entrance +and exit matrices, is + +`diag(z,x,y,z,x,y)` + +on exactly two banks and identity on every other coordinate. The two banks +may be chosen anew. Arbitrary intervening invertible scalar matrices may mix +data and spectators. The word is finite and linear, with no data-dependent +branching or uncharged parameter-dependent generator. The final contract is + +`diag(g I_(6B), I_h)`, where `g=xyz`. + +Thus spectators return literally, and their dirt cannot leak into data. +Fixed invertible scalar endpoint factors also preserve the rank argument +when interpreted as explicit changes of coordinates; literal return is the +contract in the displayed coordinates after those fixed factors are undone. +The proof does not allow a spectator initially promised to contain a useful +parameter-dependent function of the data. + +## BIT: the dual-number specialization + +Work over `R=F2[C2^3]`, with commuting generators and `x^2=y^2=z^2=1`. +The map `x -> 1+e`, `y,z -> 1` to `F2[e]/(e^2)` is a ring homomorphism: +`(1+e)^2=1` uses characteristic two. Every matrix factor has an image +`A_(j,0)+e A_(j,1)`. Constants have zero first coefficient. Each charged +diagonal has exactly two varying diagonal positions, so its first coefficient +has rank two. Constant invertible entrance/exit factors preserve that rank, +even if they mix all data and dirty spectators. + +For a chronological product `W=A_L ... A_1`, the first coefficient is + +`W_1=sum_j A_(L,0)...A_(j+1,0) A_(j,1) A_(j-1,0)...A_(1,0)`. + +There may also be any number of constant bridge factors; they add no terms. +Rank subadditivity and `rank(P A Q)<=rank(A)` give `rank(W_1)<=2L`, where L +counts charged calls only. The target specializes to +`diag((1+e) I_(6B),I_h)`, so its first coefficient has rank exactly `6B`. +Consequently `L>=3B`. No assumption that spectators remain unmixed at an +intermediate time was used. The result permits arbitrarily many dirty +spectators returned at the endpoint. + +## Complex C4: two evaluations, not a derivative of x^4 + +Over `C[C4^3]`, evaluate at `(x,y,z)=(1,1,1)` and `(i,1,1)`. Both maps +respect the generator relations. If `A'_j,A_j` are the two evaluations, then + +`A'_L...A'_1-A_L...A_1 = sum_j A'_L...A'_(j+1) (A'_j-A_j) A_(j-1)...A_1`. + +Every parameter-independent bridge contributes zero. Each charged call has +difference rank two, with two entries `i-1`, and scalar invertible entrance/ +exit factors preserve that rank. The target difference is +`diag((i-1)I_(6B),0_h)` of rank `6B`. Thus again `L>=3B`. This holds for +arbitrary complex scalar bridge coefficients, hence for Gaussian dyadic ones. +It does not use a derivative inconsistent with the relation `x^4=1`. + +An inverse generator is a real distinction here: `x^-1=x` in the BIT group, +but `x^-1` evaluates to `-i` in this complex test. The checker includes an +actual word mutation that is invisible to the BIT regular action and fails +the C4 regular action. + +## C3-covariant source rotations require the cover + +Suppose the alphabet also has a source rotation O satisfying +`O x O^-1=y`, `O y O^-1=z`, `O z O^-1=x`, and `O^3=1`. +The previous one-character specializations do not extend by merely declaring +O to be a scalar constant: conjugation cannot turn the scalar `1+e` (or i) +into 1. This is an actual algebraic obstruction to that proposed shortcut. + +Instead use the three-dimensional regular C3 cover. Let O cyclically permute +the three coordinate axes and represent + +`X=diag(t,1,1)`, `Y=diag(1,t,1)`, `Z=diag(1,1,t)`. + +Conjugation by O cyclically permutes these matrices, and `XYZ=t I_3`. +For BIT take `t=1+e`; for C4 compare `t=1` and `t=i`. These are valid +representations of the stated semidirect relations. Faithfulness on the +entire semidirect group algebra is not required for a necessary condition. +The word "regular" describes the C3 cover, not a claim of that larger +faithfulness. + +Each of the six varying local port blocks contributes rank one, so the local +first-coefficient/difference rank is six. The target contributes rank three +per data row and zero per spectator, giving `18B`. The same product argument +gives `6L>=18B`. Every spectator lifts to three cover coordinates and still +has identity target. The allowable free bridges must have identical constant +images at both evaluations (or zero dual first coefficient), including the +displayed cyclic cover permutation. Arbitrary native source automorphisms or +phase adapters are not automatically such bridges. + +## A sharp word: three local calls per pair + +Pair the `2B` banks into B disjoint pairs. On one pair let +`D=diag(z,x,y,z,x,y)`, and let P cycle the three port rows in each bank by +the same orientation. P is a parameter-independent scalar permutation. +The three matrices + +`D`, `P D P^-1`, `P^2 D P^-2` + +are diagonal; in every one of the six positions their product contains each +of x,y,z exactly once. Since those generators commute, their product is +`xyz I_6`. Applying this word to all B pairs gives exactly +`diag(xyz I_(6B),I_h)` with `3B` charged calls. All spectators may be dirty +and remain unchanged. Therefore the lower bound is sharp in each stated +grammar. Constants and port permutations may be free in this algebraic +count; that is not a physical claim that their scans are free. + +This construction uses scalar permutations of *port rows*, without renaming +any source generator. A physical source rotation is a different operation; +its admission uses the separate covariance argument above. On the cover the +same scalar port word acts blockwise and still has the claimed endpoint. + +If a tensor version of the grammar defines `x=product_j x_j`, and similarly +for y,z, with commuting independent copies of the same generators, the word +remains an identity. Specializing one `x_j` and all other generators to 1 +gives the same lower bound. This conditional algebraic extension does not +provide an all-chunk native implementation or a physical recursive invoice. + +## Independent finite checks and controls + +The checker represents the group action directly on every regular basis +vector. It does not multiply the companion checker's group-ring coefficient +matrices. At `B=1,2,4` and `h=0,1,3`, it constructs literal local permutations, +their scalar port conjugations and the complete word. It compares all 1,104 +BIT regular input columns and all 8,832 C4 regular input columns, including +every spectator column. These are faithful regular actions of the respective +commutative groups, so the comparisons fix the full formal operator of these +monomial words. Reversing the commuting call product is accepted in both +grammars for all nine cases. + +For BIT, coefficient augmentation and first coefficient are reconstructed +from the regular action on zero-address inputs. Equivariance is then checked +on every remaining address column, so this extraction cannot silently omit +a coefficient. A free transvection that mixes an arbitrary spectator into +an active x port is conjugated around the local call; its actual derivative +matrix changes, remains invertible at augmentation, and retains rank two. +This executes the spectator-mixing case covered by the written proof. +Independent exact Gaussian elimination checks the complex evaluation ranks. +The C3 matrices, covariance, fourth-power relation and full target variation +are checked exactly; the BIT cover's three first-coefficient projectors have +the same explicitly verified cyclic support pattern. + +Nine adverse cases execute production acceptance predicates: + +- Omit one local call, or repeat the wrong port conjugate: the full operator + endpoint fails. +- Add a dirty spectator into a public row: all public-input columns still + pass when spectator dirt is suppressed, but the complete matrix fails. +- Leave a data coefficient in a spectator: literal return fails. +- Label a paid full-common transform as one local call: its derivative rank + is six rather than at most two. +- Replace a positive x occurrence by its inverse: BIT accepts, C4 rejects. +- Label a parameter-dependent full transform as a free bridge: its two + evaluation matrices differ. +- Combine the cyclic source rotation with the old one-character y image, + or reverse the cover rotation: the actual covariance identity fails. + +Each rejection checks its exact intended error and repeats the same candidate +with only that predicate disabled, outside the rejection catch. These are +predicate-sensitivity checks, not a claim that disabling one predicate would +pass every other independent obligation. Normal and optimized Python 3.12 +must emit identical complete receipts. Fresh absolute external outputs use +exclusive creation. + +The finite verification and written all-B/h proofs do not certify root +geometry, native adapters, source windows, scalar cost, dirty-copy capacity, +rounding, physical controllers, storage or an outer multiplication theorem. +Those obligations remain separate; in particular no new kappa is claimed. diff --git a/research/orbit-closed-call-bound/independent/VALIDATION.json b/research/orbit-closed-call-bound/independent/VALIDATION.json new file mode 100644 index 0000000000..0f0cd87791 --- /dev/null +++ b/research/orbit-closed-call-bound/independent/VALIDATION.json @@ -0,0 +1,37 @@ +{ + "normal_optimized_full_byte_equality": true, + "python_executable": "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "python_version": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "runs": [ + { + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-B", + "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-orbit-review/check.py", + "--output", + "/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/Orbit independent frozen lvudgwff/normal.json" + ], + "mode": "normal", + "raw_sha256": "d35b53eed29d63d97b4eeb6ba05c302a53656241e894a262bd7344ec2178a01a", + "seconds": 0.0712, + "stdout": "PASS independent sharp orbit call: 9 cases, 9 semantic rejections/deletions\n" + }, + { + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-B", + "-O", + "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-orbit-review/check.py", + "--output", + "/var/folders/3v/9244hdf12cj1k9jjspv9wh2h0000gn/T/Orbit independent frozen lvudgwff/optimized.json" + ], + "mode": "optimized", + "raw_sha256": "d35b53eed29d63d97b4eeb6ba05c302a53656241e894a262bd7344ec2178a01a", + "seconds": 0.1438, + "stdout": "PASS independent sharp orbit call: 9 cases, 9 semantic rejections/deletions\n" + } + ], + "status": "PASS" +} diff --git a/research/orbit-closed-call-bound/independent/check.py b/research/orbit-closed-call-bound/independent/check.py new file mode 100644 index 0000000000..ccba6a4a82 --- /dev/null +++ b/research/orbit-closed-call-bound/independent/check.py @@ -0,0 +1,425 @@ +#!/usr/bin/env python3 +"""Independent regular-action checks for the sharp orbit-call bound. + +No compiler, historical geometry, or companion checker is imported. +Ross Richardson with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from fractions import Fraction as F +import hashlib +import json +from pathlib import Path + + +class AuditError(ValueError): + pass + + +DISABLED = frozenset() + + +def need(value, guard): + if not value and guard not in DISABLED: + raise AuditError(guard) + + +def identity(size): + return list(range(size)) + + +def compose(left, right): + return [left[index] for index in right] + + +def inverse(permutation): + result = [0] * len(permutation) + for index, value in enumerate(permutation): + result[value] = index + return result + + +def shift(address, axis, q, exponent=1): + place = q ** axis + old = address // place % q + return address + ((old + exponent) % q - old) * place + + +def local(pairs, spectators, pair, q, x_inverse=False, all_common=False): + fields, width = 6 * pairs + spectators, q ** 3 + result = identity(fields * width) + for field in range(6 * pair, 6 * pair + 6): + axis = (2, 0, 1)[field % 3] + for address in range(width): + value = address + for selected in (range(3) if all_common else (axis,)): + value = shift(value, selected, q, + q - 1 if x_inverse and selected == 0 else 1) + result[field * width + address] = field * width + value + return result + + +def port_cycle(pairs, spectators, pair, q): + fields, width = 6 * pairs + spectators, q ** 3 + result = identity(fields * width) + for field in range(6 * pair, 6 * pair + 6): + target = 3 * (field // 3) + (field % 3 + 1) % 3 + for address in range(width): + result[field * width + address] = target * width + address + return result + + +def sharp_word(pairs, spectators, q, omit=None, wrong_cycle=False, x_inverse=False, reverse_order=False): + size = (6 * pairs + spectators) * q ** 3 + answer, events, gates = identity(size), [], [] + for pair in range(pairs): + p = port_cycle(pairs, spectators, pair, q) + pp = compose(p, p) + for step, adapter in enumerate((identity(size), p, pp)): + if omit == (pair, step): + continue + if wrong_cycle and pair == 0 and step == 2: + adapter = p + d = local(pairs, spectators, pair, q, + x_inverse=x_inverse and pair == 0 and step == 0) + gate = compose(adapter, compose(d, inverse(adapter))) + gates.append(gate) + events.append({'pair': pair, 'port_cycle_power': step, + 'local_diagonal': ['z', 'x', 'y', 'z', 'x', 'y']}) + for gate in reversed(gates) if reverse_order else gates: + answer = compose(gate, answer) + return answer, events + + +def target(pairs, spectators, q): + width = q ** 3 + result = identity((6 * pairs + spectators) * width) + for field in range(6 * pairs): + for address in range(width): + value = address + for axis in range(3): + value = shift(value, axis, q) + result[field * width + address] = field * width + value + return result + + +def accept_endpoint(actual, pairs, spectators, q): + need(actual == target(pairs, spectators, q), 'complete regular-action endpoint') + + +def columns(permutation): + return [1 << row for row in permutation] + + +def linear_compose(left, right): + result = [] + for value in right: + out = 0 + while value: + bit = value & -value + out ^= left[bit.bit_length() - 1] + value ^= bit + result.append(out) + return result + + +def field_add(cols, destination, source, width): + mask = (1 << width) - 1 + return [value ^ (((value >> (width * source)) & mask) << (width * destination)) + for value in cols] + + +def accept_linear_endpoint(actual, pairs, spectators): + need(actual == columns(target(pairs, spectators, 2)), + 'all public and arbitrary dirty spectator columns') + + +def rank2(rows): + basis = {} + for value in rows: + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + break + return len(basis) + + +def derivative(cols, fields): + # Read the coefficient at every C2^3 translation from the regular action + # on address-zero inputs; then verify every other address column too. + width, mask = 8, 255 + for source in range(fields): + for address in range(width): + expected = 0 + base = cols[source * width] + while base: + bit = base & -base + index = bit.bit_length() - 1 + expected ^= 1 << (width * (index // width) + ((index % width) ^ address)) + base ^= bit + need(cols[source * width + address] == expected, 'translation-module coefficient binding') + ordinary, first = [0] * fields, [0] * fields + for source in range(fields): + base = cols[source * width] + for destination in range(fields): + terms = (base >> (width * destination)) & mask + ordinary[destination] |= (terms.bit_count() & 1) << source + first[destination] |= ((terms & 0b10101010).bit_count() & 1) << source + return ordinary, first + + +def accept_local(cols, fields): + ordinary, first = derivative(cols, fields) + need(rank2(ordinary) == fields, 'local augmentation invertible') + need(rank2(first) <= 2, 'charged local derivative rank at most two') + + +ZERO, ONE, IMAG = (F(0), F(0)), (F(1), F(0)), (F(0), F(1)) + + +def gadd(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def gneg(a): + return (-a[0], -a[1]) + + +def gmul(a, b): + return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]) + + +def ginv(a): + norm = a[0] * a[0] + a[1] * a[1] + return (a[0] / norm, -a[1] / norm) + + +def gmatrix(size): + return [[ONE if row == col else ZERO for col in range(size)] for row in range(size)] + + +def gproduct(a, b): + out = [[ZERO for _ in b[0]] for _ in a] + for row in range(len(a)): + for middle in range(len(b)): + if a[row][middle] == ZERO: + continue + for col in range(len(b[0])): + if b[middle][col] != ZERO: + out[row][col] = gadd(out[row][col], gmul(a[row][middle], b[middle][col])) + return out + + +def grank(matrix): + a = [list(row) for row in matrix] + row = 0 + for col in range(len(a[0])): + pivot = next((i for i in range(row, len(a)) if a[i][col] != ZERO), None) + if pivot is None: + continue + a[row], a[pivot] = a[pivot], a[row] + factor = ginv(a[row][col]) + a[row] = [gmul(value, factor) for value in a[row]] + for i in range(len(a)): + if i != row and a[i][col] != ZERO: + scalar = a[i][col] + a[i] = [gadd(x, gneg(gmul(scalar, y))) for x, y in zip(a[i], a[row])] + row += 1 + if row == len(a): + break + return row + + +def difference(a, b): + return [[gadd(x, gneg(y)) for x, y in zip(r, s)] for r, s in zip(a, b)] + + +def complex_eval(permutation, fields, vary): + units = (ONE, IMAG, gneg(ONE), gneg(IMAG)) + out = [[ZERO for _ in range(fields)] for _ in range(fields)] + for source in range(fields): + destination = permutation[64 * source] + out[destination // 64][source] = units[destination % 4] if vary else ONE + return out + + +def accept_constant_bridge(a, b): + need(a == b, 'free bridge is parameter independent') + + +def accept_covariance(o, x, y): + inverse_o = gproduct(o, o) + need(gproduct(o, gproduct(x, inverse_o)) == y, 'exact C3 source covariance') + + +def cover_record(): + o = [[ZERO, ZERO, ONE], [ONE, ZERO, ZERO], [ZERO, ONE, ZERO]] + need(gproduct(o, gproduct(o, o)) == gmatrix(3), 'cover rotation order three') + generators = [] + for axis in range(3): + matrix = gmatrix(3) + matrix[axis][axis] = IMAG + generators.append(matrix) + for axis in range(3): + accept_covariance(o, generators[axis], generators[(axis + 1) % 3]) + need(gproduct(gproduct(generators[axis], generators[axis]), + gproduct(generators[axis], generators[axis])) == gmatrix(3), + 'C4 cover generator relation') + product = gproduct(generators[0], gproduct(generators[1], generators[2])) + need(product == [[IMAG if i == j else ZERO for j in range(3)] for i in range(3)], + 'xyz is i times cover identity') + # The identical cyclic conjugation also permutes the three derivative + # projectors over F2. Coefficient 2 vanishes, so (I+eE)^2=I. + projectors = [[(1 << i) if i == axis else 0 for i in range(3)] for axis in range(3)] + for axis in range(3): + e = [[ONE if row == col == axis else ZERO for col in range(3)] for row in range(3)] + following = [[ONE if row == col == (axis + 1) % 3 else ZERO + for col in range(3)] for row in range(3)] + accept_covariance(o, e, following) + need(all(rank2(e) == 1 for e in projectors), 'dual cover variation projectors') + need(rank2([projectors[0][i] ^ projectors[1][i] ^ projectors[2][i] + for i in range(3)]) == 3, 'dual cover target variation') + return o, generators, {'complex_generator_variation_ranks': [grank(difference(x, gmatrix(3))) for x in generators], + 'complex_target_variation_rank': grank(difference(product, gmatrix(3))), + 'BIT_derivative_projectors': projectors, + 'two_bank_local_cover_rank': 6, + 'target_cover_rank_per_bank_pair': 18, + 'cover_meaning': 'three-dimensional regular C3 cover, not a faithful representation of the entire semidirect group algebra'} + + +def rejected(name, action, guard): + global DISABLED + try: + action() + except AuditError as error: + need(str(error) == guard, 'wrong rejection: ' + name) + else: + raise AuditError('mutation survived: ' + name) + prior = DISABLED + try: + DISABLED = prior | {guard} + action() + finally: + DISABLED = prior + return {'name': name, 'intended_guard': guard, 'same_guard_deletion': 'ACCEPTED'} + + +def controls(): + out = [] + for label, kwargs in [('omitted local call', {'omit': (0, 2)}), + ('wrong cyclic port conjugation', {'wrong_cycle': True})]: + bad, _ = sharp_word(1, 1, 2, **kwargs) + out.append(rejected(label, lambda bad=bad: accept_endpoint(bad, 1, 1, 2), + 'complete regular-action endpoint')) + good = columns(target(1, 1, 2)) + dirty_leak = field_add(good, 0, 6, 8) + need(dirty_leak[:48] == good[:48], 'clean spectator restriction misses dirt leak') + out.append(rejected('dirty spectator leaks into public output', + lambda: accept_linear_endpoint(dirty_leak, 1, 1), + 'all public and arbitrary dirty spectator columns')) + private_residual = field_add(good, 6, 0, 8) + out.append(rejected('spectator not returned literally', + lambda: accept_linear_endpoint(private_residual, 1, 1), + 'all public and arbitrary dirty spectator columns')) + forbidden = columns(local(1, 1, 0, 2, all_common=True)) + out.append(rejected('paid full common transform mislabeled one local call', + lambda: accept_local(forbidden, 7), + 'charged local derivative rank at most two')) + inverse_bit, _ = sharp_word(1, 1, 2, x_inverse=True) + accept_endpoint(inverse_bit, 1, 1, 2) + inverse_complex, _ = sharp_word(1, 1, 4, x_inverse=True) + out.append(rejected('BIT inverse coincidence does not transfer to C4', + lambda: accept_endpoint(inverse_complex, 1, 1, 4), + 'complete regular-action endpoint')) + original = local(1, 1, 0, 4, all_common=True) + out.append(rejected('parameter dependent transform mislabeled free bridge', + lambda: accept_constant_bridge(complex_eval(original, 7, False), + complex_eval(original, 7, True)), + 'free bridge is parameter independent')) + o, gs, _ = cover_record() + out.append(rejected('source rotation with the one-character y specialization', + lambda: accept_covariance(o, gs[0], gmatrix(3)), + 'exact C3 source covariance')) + out.append(rejected('inverse cover rotation has wrong source covariance', + lambda: accept_covariance(gproduct(o, o), gs[0], gs[1]), + 'exact C3 source covariance')) + return out + + +def case(pairs, spectators): + fields = 6 * pairs + spectators + bit, events = sharp_word(pairs, spectators, 2) + complex_word, complex_events = sharp_word(pairs, spectators, 4) + accept_endpoint(bit, pairs, spectators, 2) + accept_endpoint(complex_word, pairs, spectators, 4) + for q in (2, 4): + equivalent, _ = sharp_word(pairs, spectators, q, reverse_order=True) + accept_endpoint(equivalent, pairs, spectators, q) + need(events == complex_events and len(events) == 3 * pairs, 'exact sharp local call inventory') + base, first = derivative(columns(bit), fields) + need(rank2(base) == fields and rank2(first) == 6 * pairs, 'complete target derivative rank') + generator = columns(local(pairs, spectators, 0, 2)) + accept_local(generator, fields) + _, local_first = derivative(generator, fields) + ce0, ce1 = complex_eval(complex_word, fields, False), complex_eval(complex_word, fields, True) + complex_rank = grank(difference(ce1, ce0)) + local4 = local(pairs, spectators, 0, 4) + local_rank = grank(difference(complex_eval(local4, fields, True), complex_eval(local4, fields, False))) + need(complex_rank == 6 * pairs and local_rank == 2, 'complex two-evaluation ranks') + mixed = None + if spectators: + s = field_add(columns(identity(fields * 8)), 1, 6 * pairs, 8) + # This is an actual free invertible scalar bridge involving an + # initially arbitrary spectator. In characteristic two S^-1=S. + conjugate = linear_compose(s, linear_compose(generator, s)) + accept_local(conjugate, fields) + m0, m1 = derivative(conjugate, fields) + need(m1 != local_first, 'dirty spectator bridge changes the actual coefficient matrix') + mixed = {'augmentation_rows': m0, 'derivative_rows': m1, + 'derivative_rank': rank2(m1), + 'complete_regular_columns': conjugate} + return {'bank_pairs': pairs, 'data_rows': 6 * pairs, 'dirty_scalar_spectators': spectators, + 'local_calls': len(events), 'events': events, + 'BIT_complete_regular_operator_columns': bit, + 'C4_complete_regular_operator_columns': complex_word, + 'regular_input_columns': {'BIT': len(bit), 'C4': len(complex_word)}, + 'target_augmentation_rows': base, 'target_derivative_rows': first, + 'target_derivative_rank': rank2(first), 'local_derivative_rows': local_first, + 'complex_target_difference_rank': complex_rank, 'complex_local_difference_rank': local_rank, + 'mixed_dirty_bridge_local': mixed, + 'cover_target_rank': 18 * pairs, 'cover_local_rank': 6, + 'all_spectator_input_columns_returned_identically': True, + 'reversed_product_positive_control': ['BIT', 'C4']} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', required=True, type=Path) + args = parser.parse_args() + need(args.output.is_absolute(), 'output must be absolute') + need(not args.output.exists() and not args.output.is_symlink(), 'output must be new') + need(not args.output.resolve().is_relative_to(Path(__file__).resolve().parent), + 'output must be external') + cases = [case(b, h) for b in (1, 2, 4) for h in (0, 1, 3)] + negative = controls() + _, _, cover = cover_record() + result = {'status': 'PASS_INDEPENDENT_SHARP_ORBIT_CALL_WITH_DIRTY_SPECTATORS', + 'checker_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'cases': cases, 'cover': cover, 'controls': negative, + 'coverage': {'bank_pairs': [1, 2, 4], 'spectators': [0, 1, 3], + 'cases': len(cases), 'BIT_regular_columns': sum(len(c['BIT_complete_regular_operator_columns']) for c in cases), + 'C4_regular_columns': sum(len(c['C4_complete_regular_operator_columns']) for c in cases), + 'semantic_rejections': len(negative), 'named_guard_deletions': len(negative), + 'reversed_product_positive_controls': 2 * len(cases)}, + 'scope': 'algebraic call grammar only; full literal spectator return, scalar invertible parameter-independent bridges; no native reduction, scan, source, precision, owner or recursive invoice admission', + 'source_rotation': 'scalar cyclic port permutation proves sharpness without renaming x,y,z; genuine source rotation uses the separate C3 regular cover', + 'no_new_kappa': True} + with args.output.open('x') as destination: + destination.write(json.dumps(result, indent=2, sort_keys=True) + '\n') + print('PASS independent sharp orbit call: 9 cases, 9 semantic rejections/deletions') + + +if __name__ == '__main__': + main() diff --git a/research/orbit-closed-call-bound/orbit/CHECKS.json.gz b/research/orbit-closed-call-bound/orbit/CHECKS.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..70cacc6e85f71a246e8c0e4db1fc17c1f7bb7b00 GIT binary patch literal 64855 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 literal 0 HcmV?d00001 diff --git a/research/orbit-closed-call-bound/orbit/INPUTS.json b/research/orbit-closed-call-bound/orbit/INPUTS.json new file mode 100644 index 0000000000..58fc3d5549 --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/INPUTS.json @@ -0,0 +1,43 @@ +{ + "files": [ + { + "bytes": 3962, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/DERIVATIVE.md", + "path": "frozen/history/DERIVATIVE.md", + "sha256": "ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399" + }, + { + "bytes": 6520, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/geometry_derivative.py", + "path": "frozen/history/geometry_derivative.py", + "sha256": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04" + }, + { + "bytes": 8966, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/GEOMETRY-DERIVATIVE.json", + "path": "frozen/history/GEOMETRY-DERIVATIVE.json", + "sha256": "7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98" + }, + { + "bytes": 33865, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "path": "frozen/source/bitE8-r865.json.gz", + "raw_bytes": 165963, + "raw_sha256": "fbc56ed40d857b6ed74cbab1badd144fc276f08f76326dcb21a3ab2178a40c13", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 5439, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/NOTICE.md", + "path": "frozen/source/NOTICE.md", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a" + }, + { + "bytes": 11357, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/LICENSE", + "path": "frozen/source/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ], + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90" +} diff --git a/research/orbit-closed-call-bound/orbit/ORIGINS.md b/research/orbit-closed-call-bound/orbit/ORIGINS.md new file mode 100644 index 0000000000..8d7a979acd --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/ORIGINS.md @@ -0,0 +1,59 @@ +# Preserved sources and execution adaptations + +`INPUTS.json` is the exact source inventory. The three original C09 files in +`frozen/history/` are copied without changes from the external +`kappa-major-20261018T1330Z/paired-bit` research run. The scientific root file, +its notice and license are copied without changes from commit +`20ecf2891d80b5acf18d980b2164fb44ea7faa90`, paths under +`research/e8-bit-carrier-skeleton/`. Both compressed transport and decompressed +root-data hashes and byte counts are recorded. The root transport Git blob is +`8bec1751f7e33c3a1e4673ef5dbc34d6f205321e`. + +The root file's Apache-2.0 license, contributor notices and AI disclosure remain +in `frozen/source/`. The inherited E8 Hamming-chart lineage includes Dylan Crow / +utcorvusvolat-dotcom's PR370 material through eumemic's carrier-skeleton package; +the original notice is the authoritative detailed attribution. Only the JSON +`lines` field is consumed by this contribution. Retention of the whole compressed +source is provenance, not fresh validation of its R865 circuit. + +`check.py` is the new adapter and formal-algebra checker. It authenticates all +captured input bytes before executing the historical source. It does not import +historical modules from ambient paths, consult Git, or load historical bytecode. +The historical source is compiled from the authenticated, adapted string with +`dont_inherit=True, optimize=0`. The immutable file itself is never rewritten. +The only adaptations are these: + +1. Replace the absolute `SOURCE` declaration with a comment and replace both + `SOURCE.read_bytes()` calls with already-authenticated `ROOT_BYTES`. +2. Remove the historical command-line parser for `--write`. +3. Replace the historical local receipt I/O and terminal print tail by + `return out`. + +Each replacement has an exact occurrence-count guard. The returned historical +record is compared to **all** fields of the frozen original receipt, recursively +including JSON types. The adapted string's hash appears in the fresh receipt +alongside the original source hash. Original source proof statements, historical +scope, notices, and original control fields are retained unchanged. New scope +and defect-sensitive checks are explicit separate additions. + +The extension is a sharp formal-query result and a returned-scalar-spectator +generalization. The root census, first-variation argument and cover motivation +originate in the preserved C09 files. Earlier rank/specialization techniques are +not claimed as new; related-work attribution to the existing group-algebra +literature and repository contributions belongs to the parent package's source +audit. Ross Richardson with substantial OpenAI Codex assistance prepared the +new proof, checker, finite constructions and mathematical review. + +For a standalone read-only export, run + +``` +python3.12 -B check.py --output /absolute/external/new-receipt.json.gz +``` + +The output must be absolute, external to this component, not a symlink and not +already present. It is created exclusively. `.gz` selects deterministic gzip +transport; other suffixes give UTF-8 JSON. Normal and `-O` Python3.12 executions +have been compared byte-for-byte, including the complete fresh receipt. +`PACKAGE-FILES.json` is the minimal handoff list. Scratch outputs and duplicate +normal/optimized receipts are excluded. `OUTPUT-INVENTORY.json` records the final +code, proof, input inventory, compressed receipt and raw receipt hashes. diff --git a/research/orbit-closed-call-bound/orbit/OUTPUT-INVENTORY.json b/research/orbit-closed-call-bound/orbit/OUTPUT-INVENTORY.json new file mode 100644 index 0000000000..ef6f1f0e6f --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/OUTPUT-INVENTORY.json @@ -0,0 +1,33 @@ +{ + "files": { + "CHECKS.json.gz": { + "bytes": 64855, + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + }, + "INPUTS.json": { + "bytes": 1890, + "sha256": "2b804087ce248aaf606043e90937638e68426783d9ec0f8b132ebed113ab32ca" + }, + "ORIGINS.md": { + "bytes": 3441, + "sha256": "2ef0ae702d9d477d293332c62e7f802d500b5afc4edc22ae39b3cb354a4c40f5" + }, + "PROOF.md": { + "bytes": 12586, + "sha256": "573b7ab3132f0d2d0c1777cc457a254e67a6ff001d0fc55b61447018806e56e6" + }, + "VALIDATION.json": { + "bytes": 933, + "sha256": "97ffa427c2dd824c96bea0c2abcaceb7a3736ad441b9fc6623a161c763fcc692" + }, + "check.py": { + "bytes": 21857, + "sha256": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3" + } + }, + "receipt_raw": { + "bytes": 5978887, + "sha256": "31f90a56ce4ce6bbdcee97b44eabf07ef82121cbe22c640b85ac364baaec7230" + }, + "schema": "c09_output_inventory.v1" +} diff --git a/research/orbit-closed-call-bound/orbit/PACKAGE-FILES.json b/research/orbit-closed-call-bound/orbit/PACKAGE-FILES.json new file mode 100644 index 0000000000..ac411baaae --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/PACKAGE-FILES.json @@ -0,0 +1,20 @@ +{ + "files": [ + "CHECKS.json.gz", + "INPUTS.json", + "ORIGINS.md", + "OUTPUT-INVENTORY.json", + "PACKAGE-FILES.json", + "PROOF.md", + "VALIDATION.json", + "check.py", + "frozen/history/DERIVATIVE.md", + "frozen/history/GEOMETRY-DERIVATIVE.json", + "frozen/history/geometry_derivative.py", + "frozen/source/LICENSE", + "frozen/source/NOTICE.md", + "frozen/source/bitE8-r865.json.gz" + ], + "notes": "Immutable originals; compressed complete receipt only. External development receipts are excluded.", + "schema": "c09_package_files.v1" +} diff --git a/research/orbit-closed-call-bound/orbit/PROOF.md b/research/orbit-closed-call-bound/orbit/PROOF.md new file mode 100644 index 0000000000..ed2fc7ae50 --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/PROOF.md @@ -0,0 +1,235 @@ +# A sharp tariff for the closed three-port orbit alphabet + +This note proves an exact formal query count. It does not identify an arbitrary +native caller with this alphabet, price scalar bridges, or construct a physical +supplier. The finite root census motivates the alphabet; it does not imply that +all E8 callers reduce to it. The rank-specialization method is inherited from +earlier group-algebra query arguments; sharpness and the returned-spectator +extension below are the bounded additions to the preserved C09 note. + +## The model and the complete endpoint + +Let `B>=1` and `h>=0` be integers and put `n=6B+h`. Work first over + +`R=F2[C2^3]=F2[x,y,z]/(x^2-1,y^2-1,z^2-1)`. + +There are `2B` labeled public banks of three independent rows each, followed by +`h` independent, arbitrary dirty scalar rows. Matrices act on column vectors; +events listed first execute first, so the total matrix is the product in reverse +event order. A free gate is any parameter-independent member of `GL_n(F2)`. +One paid gate is a matrix with diagonal `(z,x,y)` on each of two distinct public +banks and identity elsewhere, with optional parameter-independent invertible +scalar factors on the left and right. The factors may mix public and spectator +coordinates. Equivalently they may be included among the free bridges. Each +such local gate costs one formal query, regardless of the scalar factors. + +The required **complete** endpoint is + +`T=diag(xyz I_(6B), I_h)`. + +Thus every public output has the specified operator on its own independent +input, every dirty spectator is returned to its own entrance value, and all +cross coefficients vanish. No zero, correlated, or discardable helper is +assumed. Optional fixed scalar entrance/exit factors preserve the lower bound +below. With those factors the displayed restoration refers to the normalized +endpoint; a raw same-frame restoration claim requires that the factors actually +be applied. They are free only in this formal tariff. + +**Theorem.** The minimum number of paid queries is exactly `3B`, for every +finite `h`. The upper bound already holds with `h=0`. + +## Lower bound, uniformly in the number of dirty spectators + +Use the algebra homomorphism + +`phi_x: R -> F2[epsilon]/(epsilon^2), x |-> 1+epsilon, y,z |-> 1`. + +It respects the defining relation because `(1+epsilon)^2=1` in characteristic +two. Write `phi_x(M_j)=A_j+epsilon B_j`. All `A_j` are invertible: scalar gates +are invertible, and a local diagonal specializes to identity. Free gates have +`B_j=0`. A local query has exactly two nonzero diagonal derivative entries, +one `x` port in each active bank. Its left and right scalar factors preserve +that derivative rank, so its rank is two. + +For an arbitrary word, including all free bridges, the exact first coefficient +is + +`[epsilon](M_m ... M_1) = sum_j A_m ... A_(j+1) B_j A_(j-1) ... A_1`. + +Each paid summand has rank at most two and each free summand is zero. Rank +subadditivity gives `rank([epsilon]M)<=2L`. On the required complete endpoint +the coefficient is `diag(I_(6B),0_h)`, of rank `6B`. Therefore `L>=3B`. +Left/right fixed scalar endpoint factors do not change this rank. + +The argument holds for every finite `n`; it does not enumerate a maximum helper +count or assume that spectators stay untouched during the word. Arbitrary +parameter-independent scalar borrowing is allowed. It is the complete +returned-spectator target, not a clean-helper test, that fixes the target rank. +The `B=4,L=9` candidate consequently fails this alphabet since `18<24`. + +## An attaining word in the actual alphabet + +Fix one disjoint pair of banks and write `D=diag(z,x,y,z,x,y)`. Let `P` be the +scalar permutation that rotates the three row positions identically in the two +banks, leaving every other row fixed. No generator is renamed. The three +queries in + +`D (P D P^-1) (P^2 D P^-2)` + +are permitted scalar conjugates. Their three diagonal entries on each row are +a permutation of `x,y,z`. All commute, hence the product is `xyz I_6` on that +pair and identity outside it. Applying this to `B` disjoint pairs gives `T` +using exactly `3B` queries and `4B` nonidentity scalar permutation events in +the displayed literal implementation. Every scalar permutation is invertible. +There is no use of a source/address automorphism in this construction. + +The finite fixtures with `h>0` additionally append a scalar shear +`d_0 += public_0` and its inverse. This redundant, fully recorded free pair +returns arbitrary dirt and makes omission of the return a genuine semantic +defect. It is unnecessary for the upper bound. Its two free shears are not +silently counted as physical zero-cost operations. + +## Independent tensor generators: the precise all-f statement + +For every integer `f>=1`, replace the ring by `F2[C2^(3f)]`, with independent +commuting involutions `x_j,y_j,z_j`, and define + +`X=product_(j=1)^f x_j`, `Y=product_j y_j`, `Z=product_j z_j`. + +Stipulate the same one-query local diagonal `(Z,X,Y)` on two banks and the +target `diag(XYZ I_(6B),I_h)`. Send `x_1` to `1+epsilon` and every other +generator to one. The same two-versus-`6B` rank argument applies. The cyclic +word also applies verbatim, so its formal optimum is `3B` for every `f,B,h` +in this domain. The local aggregate diagonal is one paid query by the stated +alphabet; this statement does not price the work required to produce it. + +The attaining identity remains true under **every** operator representation of +these rings. The lower bound is a full formal-ring identity obstruction, or an +operator obstruction after a separately proved faithful realization. Order two +or order four alone does not make a chosen native representation faithful as +an algebra. In particular, this theorem does not assert a fixed-f native lower +bound merely from the orders of some concrete transforms. + +## Separate complex order-four model + +Over `K[C4^3]`, with `K=Q(i)` or `C`, use the same alphabet and arbitrary +parameter-independent invertible scalar bridges over `K`. Compare the two +algebra homomorphisms `(x,y,z)=(1,1,1)` and `(i,1,1)`. These are legitimate +evaluations because `i^4=1`. They are not a differentiation of `x^4=1`. + +For arbitrary evaluated factors `A_j` and `A'_j`, + +`A_m ... A_1 - A'_m ... A'_1` + +`= sum_j A_m ... A_(j+1) (A_j-A'_j) A'_(j-1) ... A'_1`. + +A free factor has zero difference. Each local query has difference rank two, +while the complete target difference is +`diag((i-1)I_(6B),0_h)`, of rank `6B`. Thus again `L>=3B`. The same cyclic +construction attains it. In fact its finite identity is checked over +`Z[C4^3]`, before either Gaussian evaluation; every one of the 64 coefficients +is retained. For `f` independent order-four triples, evaluate `x_1=i` and all +other generators at one; the preceding all-f formal conclusion is unchanged. + +A source rotation cannot be treated as a scalar bridge in this single-character +evaluation if it rotates the parameters. The following model treats that +covariance explicitly. + +## The specified C3 evaluation cover + +On a three-dimensional cover with basis `e_0,e_1,e_2`, set + +`X_lambda=diag(lambda,1,1)`, `Y_lambda=diag(1,lambda,1)`, +`Z_lambda=diag(1,1,lambda)`, and `O e_j=e_(j+1 mod3)`. + +Directly, + +`O X_lambda O^-1=Y_lambda`, `O Y_lambda O^-1=Z_lambda`, +`O Z_lambda O^-1=X_lambda`, `O^3=I`, + +and `X_lambda Y_lambda Z_lambda=lambda I_3`. This is the regular action of +`C3` on the orbit of the chosen evaluation; it is not asserted to be a faithful +representation of the entire `C2^3` or `C4^3` group algebra. + +Replace each scalar row by a cover block. The actual local query has blocks +`(Z_lambda,X_lambda,Y_lambda)` on each of two banks. At `lambda=1+epsilon` +over the dual numbers its derivative has rank six. At `lambda=1` versus `i` +over `Q(i)` its difference has rank six. The complete public target derivative +or difference has rank `18B`; all `3h` arbitrary spectator coordinates have +zero target variation. Thus the respective rank argument gives `L>=3B`. + +The allowed scalar bridges and cover rotations are represented by invertible +matrices independent of `lambda`. Products of ordinary scalar bridges lifted +by `I_3` and the displayed cover permutation satisfy this premise. The rank +bound even remains valid if this constant-matrix class is enlarged to all +invertible constant matrices of the same dimension, while retaining the +specified local query. Any proposed native map must still be proved to factor +through a parameter-independent matrix in this representation. That reduction +is not supplied by an abstract claim of covariance. + +For `f` independent cover factors, use their tensor product and vary only the +first factor, setting all other factors to the identity evaluation. Then local +variation rank is `6*3^(f-1)` and target variation rank is +`18B*3^(f-1)`. Their ratio again yields `3B`. This is a conditional formal +tensor-cover statement, not an assertion about physical column counts or an +unspecified native representation. The cyclic attaining word still uses only +scalar port permutations. + +## Exact finite evidence and controls + +`check.py` captures and authenticates every original input before executing the +historical geometry source, with `compile(...,optimize=0)`. The original source +is unchanged on disk. Its only execution adaptations replace its absolute root +read with captured bytes, remove the historical command-line parser, and return +its result instead of writing/reading a local receipt. The complete returned +receipt is compared recursively with exact JSON types and **no excluded fields**. +Its original and executed-source hashes are retained. + +The fresh census checks all 120 pinned root lines, all 54 eligible lines, all +18 oriented triples, their rational projectors and rank-five orthogonal +spectators, and all three residual identities per orbit. It preserves all +historical `B=1..8` screens and the 96 defects of the wrong chart rotation. +Only the `lines` field is used; the R865 circuit inside the retained source file +is neither executed nor recertified. + +For every `B in {1,2,4}` and `h in {0,1,3}`, the new checker executes the literal +word, retains all eight `F2[C2^3]` coefficient matrices and all 64 +`Z[C4^3]` coefficient matrices, and checks the complete endpoint. A separate +bit-vector implementation executes every one of the `8n` independent columns +of the faithful `C2^3` regular action. It also executes the exact derivative +product rule at every prefix, checks each literal event's derivative capacity, +and retains the full prefix rows. The all-basis specialization tables check all +64 binary and 4096 order-four basis products. Full Gaussian matrices at both +evaluations, the local rank-two differences, the full target ranks, and the +three `B=1,2,4,h=1` cover cases are retained. + +Twenty-one semantic mutations are actually executed: nine omitted paid queries, +six omitted dirty returns, one wrong cyclic scalar bridge, a full-common query +that exceeds local derivative capacity, reversal of the complex phase, inverse +cover covariance, wrong root-chart rotation, and a type-corrupted historical +count. Each must fail its exact named production predicate. The same mutant +then executes successfully with **only that predicate** deleted, outside the +rejection handler. These controls check sensitivity; they are not additional +mathematical lower bounds. + +The all-`B,h,f` statements above are written proofs. Finite examples and exact +controls are reproducibility evidence, not an exhaustive proof over unbounded +word length. No formal proof-assistant kernel has checked this argument. + +## Boundary and attribution + +Only formal query count is priced. Native scalar/address work, source access, +carrier admission, numerical precision, restored physical frames, ownership, +storage, finite-tape execution, and a complete open caller remain separate +obligations. Changed query alphabets, parameter-dependent bridges, changed +consumers, or failure of a proposed representation map reopen the obstruction. +The spectator extension concerns independent **scalar** dirty rows with the +displayed complete target, not arbitrary native auxiliary carriers. + +Original C09 note/script/receipt and scientific data notices are preserved +byte-for-byte under `frozen/`; `INPUTS.json` gives exact origins and hashes. +The root chart retains its original contributor credits in `NOTICE.md` and +Apache-2.0 license. Ross Richardson with substantial OpenAI Codex assistance +prepared this extension and checker. The inherited rank/specialization method +is not claimed as a new proof technique. Package-level related-work attribution +is maintained by the parent contribution's source audit. diff --git a/research/orbit-closed-call-bound/orbit/VALIDATION.json b/research/orbit-closed-call-bound/orbit/VALIDATION.json new file mode 100644 index 0000000000..4db992566e --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/VALIDATION.json @@ -0,0 +1,20 @@ +{ + "commands": [ + "python3.12 -B check.py --output ABS_EXTERNAL_NEW.json.gz", + "python3.12 -B -O check.py --output ABS_EXTERNAL_OTHER_NEW.json.gz" + ], + "executed_same_guard_deletions": 21, + "finite_group_ring_cases": 9, + "full_original_receipt_typed_comparison": true, + "historical_source_compile_dont_inherit": true, + "historical_source_compile_optimize": 0, + "normal_optimized_gzip_bytes_equal": true, + "normal_optimized_raw_bytes_equal": true, + "python_version": "3.12.12 (main, Oct 9 2025, 11:07:00) [Clang 17.0.0 (clang-1700.6.3.2)]", + "raw_receipt_sha256": "31f90a56ce4ce6bbdcee97b44eabf07ef82121cbe22c640b85ac364baaec7230", + "receipt_sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf", + "regular_cover_cases": 3, + "schema": "c09_validation.v1", + "scope": "formal algebra, exact finite records and written all-parameter theorem; no physical caller", + "semantic_rejections": 21 +} diff --git a/research/orbit-closed-call-bound/orbit/check.py b/research/orbit-closed-call-bound/orbit/check.py new file mode 100644 index 0000000000..f749b1ff4a --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/check.py @@ -0,0 +1,502 @@ +#!/usr/bin/env python3 +"""Exact, source-bound orbit tariff; formal calls, not a native supplier. + +Prepared with substantial OpenAI Codex assistance. Standard library only. +""" +import argparse +import copy +import gzip +import hashlib +import json +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PINS = { + 'frozen/history/DERIVATIVE.md': 'ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399', + 'frozen/history/geometry_derivative.py': '009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04', + 'frozen/history/GEOMETRY-DERIVATIVE.json': '7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98', + 'frozen/source/bitE8-r865.json.gz': '1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55', + 'frozen/source/NOTICE.md': '5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a', + 'frozen/source/LICENSE': 'c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4', +} + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def digest(data): + return hashlib.sha256(data).hexdigest() + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def typed_equal(a, b): + if type(a) is not type(b): + return False + if isinstance(a, dict): + return a.keys() == b.keys() and all(typed_equal(a[k], b[k]) for k in a) + if isinstance(a, list): + return len(a) == len(b) and all(typed_equal(x, y) for x, y in zip(a, b)) + return a == b + + +def gate(ok, label, deleted=()): + if label not in deleted: + need(ok, label) + + +def reject_delete(name, label, probe): + try: + probe(()) + except ValueError as exc: + need(str(exc) == label, 'wrong rejection: ' + name) + else: + raise ValueError('mutation survived: ' + name) + probe((label,)) + return {'name': name, 'rejected_by': label, 'same_guard_deletion_accepts': True} + + +def captured_history(blobs): + raw = blobs['frozen/history/geometry_derivative.py'] + source = raw.decode() + replacements = [ + ("SOURCE = Path('/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz')", '# SOURCE bytes captured and authenticated by the adapter.'), + (" ap=argparse.ArgumentParser(description=__doc__)\n ap.add_argument('--write',action='store_true')\n args=ap.parse_args()\n", ''), + (" path=HERE/'GEOMETRY-DERIVATIVE.json'\n if args.write:\n path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\\n')\n else:\n need(json.loads(path.read_bytes())==out,'complete receipt mismatch')\n print(out['status'])\n print('54 root lines, 18 orthogonal triples; orbit-closed B4 nine-call grammar needs at least 12 calls')", ' return out'), + ] + for old, new in replacements: + need(source.count(old) == 1, 'unique historical adaptation') + source = source.replace(old, new) + need(source.count('SOURCE.read_bytes()') == 2, 'captured root read count') + source = source.replace('SOURCE.read_bytes()', 'ROOT_BYTES') + env = {'__name__': 'captured_geometry', '__file__': str(HERE/'frozen/history/geometry_derivative.py'), + 'ROOT_BYTES': blobs['frozen/source/bitE8-r865.json.gz']} + exec(compile(source, '', 'exec', dont_inherit=True, optimize=0), env) + actual = env['main']() + expected = json.loads(blobs['frozen/history/GEOMETRY-DERIVATIVE.json']) + gate(typed_equal(actual, expected), 'complete historical receipt') + return env, actual, {'original_sha256': digest(raw), 'executed_sha256': digest(source.encode()), + 'compile_optimize': 0, 'compile_dont_inherit': True, + 'replacement_count': 3, 'captured_root_reads': 2} + + +def rank2(rows): + pivots = {} + for row in rows: + while row: + k = row.bit_length()-1 + if k in pivots: + row ^= pivots[k] + else: + pivots[k] = row + break + return len(pivots) + + +def shift(g, axis, order): + step = order**axis + return g + step if (g//step) % order < order-1 else g-(order-1)*step + + +def word(B, h): + n = 6*B+h + events = [] + for pair in range(B): + for k in range(3): + perm = list(range(n)) + inv = list(range(n)) + for bank in range(2): + base = 6*pair+3*bank + for j in range(3): + perm[base+j] = base+(j+k)%3 + inv[base+j] = base+(j-k)%3 + if k: + events.append({'op': 'permute', 'new_row_from_old': perm}) + events.append({'op': 'query', 'pair': pair}) + if k: + events.append({'op': 'permute', 'new_row_from_old': inv}) + if h: + # A nontrivial free spectator borrow/return pair supplies a dirt control. + events.extend([{'op': 'add', 'dst': 6*B, 'src': 0, 'coefficient': 1}, + {'op': 'add', 'dst': 6*B, 'src': 0, 'coefficient': -1}]) + return events + + +def ring_word(B, h, events, order=2): + """Every coefficient in F2[C2^3] or Z[C4^3]; integer C4 is stronger here.""" + n = 6*B+h + rows = [{(j, 0): 1} for j in range(n)] + for e in events: + if e['op'] == 'permute': + gate(sorted(e['new_row_from_old']) == list(range(n)), 'scalar permutation admission') + rows = [rows[j].copy() for j in e['new_row_from_old']] + elif e['op'] == 'query': + gate(type(e['pair']) is int and 0 <= e['pair'] < B, 'two-bank query admission') + for j in range(6): + r = 6*e['pair']+j + axis = (2, 0, 1)[j%3] + rows[r] = {(c, shift(g, axis, order)): a for (c, g), a in rows[r].items()} + elif e['op'] == 'add': + gate(0 <= e['dst'] < n and 0 <= e['src'] < n and e['dst'] != e['src'], 'scalar shear admission') + for key, value in rows[e['src']].items(): + new = rows[e['dst']].get(key, 0)+e['coefficient']*value + if order == 2: + new %= 2 + if new: + rows[e['dst']][key] = new + else: + rows[e['dst']].pop(key, None) + else: + raise ValueError('unknown event') + return rows + + +def target(B, h, order): + t = 1+order+order*order + return [{(r, t if r < 6*B else 0): 1} for r in range(6*B+h)] + + +def endpoint(rows, B, h, order, deleted=()): + wanted = target(B, h, order) + gate(rows[:6*B] == wanted[:6*B], 'public every-coefficient endpoint', deleted) + gate(rows[6*B:] == wanted[6*B:], 'dirty spectator every-coefficient endpoint', deleted) + + +def coefficients(rows, order): + n = len(rows) + return [[[rows[r].get((c, g), 0) for c in range(n)] for r in range(n)] + for g in range(order**3)] + + +def regular_columns(B, h, events): + """Independent bit-vector execution of all 8N input columns.""" + n = 6*B+h + columns = [] + for col in range(8*n): + state = [0]*n + state[col//8] = 1 << (col%8) + for e in events: + if e['op'] == 'permute': + state = [state[j] for j in e['new_row_from_old']] + elif e['op'] == 'query': + for j in range(6): + r = 6*e['pair']+j + bit = (4, 1, 2)[j%3] + out = 0 + for g in range(8): + if state[r] & (1 << g): + out ^= 1 << (g ^ bit) + state[r] = out + else: + if e['coefficient'] & 1: + state[e['dst']] ^= state[e['src']] + columns.append(sum(v << (8*r) for r, v in enumerate(state))) + wanted = [1 << (8*(c//8)+((c%8)^7 if c//8 < 6*B else c%8)) for c in range(8*n)] + gate(columns == wanted, 'independent regular-action columns') + return columns + + +def derivative(rows): + # All y,z go to1, x goes to1+epsilon; a monomial has derivative its x parity. + result = [] + for row in rows: + packed = 0 + for (c, g), a in row.items(): + if g & 1 and a & 1: + packed ^= 1 << c + result.append(packed) + return result + + +def augmentation(rows): + result = [] + for row in rows: + value = 0 + for (c, _), a in row.items(): + if a & 1: + value ^= 1 << c + result.append(value) + return result + + +def binary_product(a, b): + result = [] + for row in a: + value = 0 + for j in range(len(b)): + if row & (1 << j): + value ^= b[j] + result.append(value) + return result + + +def derivative_replay(B, h, events, expected): + n = 6*B+h + zero, first = [1 << j for j in range(n)], [0]*n + prefixes = [] + paid = 0 + for e in events: + local = ring_word(B, h, [e]) + a, b = augmentation(local), derivative(local) + gate(rank2(a) == n, 'invertible scalar specialization') + gate(rank2(b) == (2 if e['op'] == 'query' else 0), 'literal event derivative rank') + left, right = binary_product(b, zero), binary_product(a, first) + first = [x ^ y for x, y in zip(left, right)] + zero = binary_product(a, zero) + paid += e['op'] == 'query' + gate(rank2(first) <= 2*paid, 'telescoping prefix capacity') + prefixes.append({'paid_queries':paid, 'event_derivative_rank':rank2(b), + 'prefix_derivative_rank':rank2(first), + 'prefix_derivative_rows_hex':[hex(v) for v in first]}) + gate(zero == augmentation(expected) and first == derivative(expected), 'independent derivative product rule') + return prefixes + + +def homomorphisms(): + binary = [] + for a in range(8): + for b in range(8): + # (u,v) denotes u+epsilon*v; every group basis element has u=1. + product = (1, (a & 1) ^ (b & 1)) + expected = (1, (a ^ b) & 1) + gate(product == expected, 'dual-number multiplication homomorphism') + binary.append([a,b,a^b,list(product)]) + gaussian = [] + powers = [(1,0),(0,1),(-1,0),(0,-1)] + for a in range(64): + for b in range(64): + c = sum((((a//(4**k))%4+(b//(4**k))%4)%4)*(4**k) for k in range(3)) + product = gmul(powers[a%4], powers[b%4]) + gate(product == powers[c%4], 'C4 finite-evaluation homomorphism') + gaussian.append([a,b,c,list(product)]) + return {'F2_dual_number_all_64_basis_products':binary, + 'C4_i_evaluation_all_4096_basis_products':gaussian} + + +def local_capacity(rows, deleted=()): + gate(rank2(derivative(rows)) <= 2, 'local first-order capacity', deleted) + + +def gadd(a, b): + return (a[0]+b[0], a[1]+b[1]) + + +def gmul(a, b): + return (a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0]) + + +def gdiv(a, b): + d = b[0]*b[0]+b[1]*b[1] + return (Fraction(a[0]*b[0]+a[1]*b[1], d), Fraction(a[1]*b[0]-a[0]*b[1], d)) + + +def grank(matrix): + a = [[(Fraction(x), Fraction(y)) for x, y in row] for row in matrix] + rank = 0 + for c in range(len(a[0])): + k = next((r for r in range(rank, len(a)) if a[r][c] != (0, 0)), None) + if k is None: + continue + a[rank], a[k] = a[k], a[rank] + pivot = a[rank][c] + a[rank] = [gdiv(v, pivot) for v in a[rank]] + for r in range(len(a)): + if r != rank and a[r][c] != (0, 0): + scale = a[r][c] + a[r] = [gadd(v, tuple(-z for z in gmul(scale, w))) for v, w in zip(a[r], a[rank])] + rank += 1 + return rank + + +def gaussian_word(B, h, events, phase, cover=False): + n = 6*B+h + width = 3 if cover else 1 + rows = [[(int(r == c), 0) for c in range(width*n)] for r in range(width*n)] + for e in events: + if e['op'] == 'permute': + rows = [rows[width*j+k][:] for j in e['new_row_from_old'] for k in range(width)] + elif e['op'] == 'query': + for j in range(6): + r = 6*e['pair']+j + axis = (2, 0, 1)[j%3] + for k in range(width): + factor = phase if (k == axis if cover else axis == 0) else (1, 0) + rows[width*r+k] = [gmul(factor, v) for v in rows[width*r+k]] + else: + for k in range(width): + dst, src = width*e['dst']+k, width*e['src']+k + rows[dst] = [gadd(a, (e['coefficient']*b[0], e['coefficient']*b[1])) + for a, b in zip(rows[dst], rows[src])] + return rows + + +def gaussian_endpoint(rows, B, h, phase, cover=False, deleted=()): + width = 3 if cover else 1 + n = width*(6*B+h) + expected = [[phase if r == c and r < width*6*B else (1, 0) if r == c else (0, 0) + for c in range(n)] for r in range(n)] + gate(rows == expected, 'finite complex full endpoint', deleted) + + +def difference(a, b): + return [[gadd(x, (-y[0], -y[1])) for x, y in zip(r, s)] for r, s in zip(a, b)] + + +def cover_covariance(perm, deleted=()): + # O e_j=e_(j+1); conjugation moves the unique nontrivial diagonal entry. + need(sorted(perm) == [0, 1, 2], 'cover permutation admission') + diagonals = [(1, 0, 0), (0, 1, 0), (0, 0, 1)] + actual = [] + for d in diagonals: + a = [0]*3 + for j in range(3): + a[perm[j]] = d[j] + actual.append(a) + gate(actual == [list(diagonals[1]), list(diagonals[2]), list(diagonals[0])], 'C3 covariance', deleted) + return actual + + +def run(): + blobs = {p: (HERE/p).read_bytes() for p in PINS} + for p, b in blobs.items(): + need(digest(b) == PINS[p], 'authenticated input: '+p) + inventory = json.loads((HERE/'INPUTS.json').read_bytes()) + need(len(inventory['files']) == len(PINS), 'source inventory cardinality') + need({x['path']: x['sha256'] for x in inventory['files']} == PINS, 'source inventory closure') + for entry in inventory['files']: + data = blobs[entry['path']] + need(entry['bytes'] == len(data), 'source inventory byte count') + if entry['path'].endswith('.gz'): + raw = gzip.decompress(data) + need(entry['raw_bytes'] == len(raw) and entry['raw_sha256'] == digest(raw), 'source raw transport closure') + env, old, adaptation = captured_history(blobs) + maps = homomorphisms() + controls = [] + wrong = copy.deepcopy(old) + wrong['orthogonal_orbits'] = True + controls.append(reject_delete('typed_historical_count', 'complete historical receipt', + lambda d: gate(typed_equal(old, wrong), 'complete historical receipt', d))) + roots = sorted({env['canon'](p) for p in json.loads(gzip.decompress(blobs['frozen/source/bitE8-r865.json.gz']))['lines']}) + def geometry_gate(rot, deleted=()): + gate(all(env['canon'](rot(p)) in roots and rot(rot(rot(p))) == p for p in roots), 'order3 root automorphism', deleted) + geometry_gate(env['rotate']) + controls.append(reject_delete('wrong_chart_rotation', 'order3 root automorphism', + lambda d: geometry_gate(lambda p: (p[2],p[0],p[1],p[5],p[3],p[4],p[6],p[7]), d))) + finite = [] + for B in (1, 2, 4): + for h in (0, 1, 3): + events = word(B, h) + rows = ring_word(B, h, events) + rows4 = ring_word(B, h, events, 4) + endpoint(rows, B, h, 2) + endpoint(rows4, B, h, 4) + regular = regular_columns(B, h, events) + gate(sum(e['op'] == 'query' for e in events) == 3*B, 'sharp query invoice') + local = ring_word(B, h, [{'op':'query', 'pair':0}]) + local_capacity(local) + derivative_prefixes = derivative_replay(B, h, events, rows) + target_rank = rank2(derivative(rows)) + gate(target_rank == 6*B, 'restored target derivative rank') + g0 = gaussian_word(B, h, events, (1,0)) + gi = gaussian_word(B, h, events, (0,1)) + gaussian_endpoint(g0, B, h, (1,0)) + gaussian_endpoint(gi, B, h, (0,1)) + complex_rank = grank(difference(gi, g0)) + gate(complex_rank == 6*B, 'complex target variation rank') + local0 = gaussian_word(B,h,[{'op':'query','pair':0}],(1,0)) + locali = gaussian_word(B,h,[{'op':'query','pair':0}],(0,1)) + local_complex_rank = grank(difference(locali,local0)) + gate(local_complex_rank == 2, 'complex local variation rank') + finite.append({'B': B, 'dirty_scalar_spectators': h, 'ordinary_column_order': list(range(6*B+h)), + 'events': events, 'paid_calls': 3*B, 'F2_all_8_coefficient_matrices': coefficients(rows, 2), + 'Z_C4_all_64_coefficient_matrices': coefficients(rows4, 4), + 'regular_action_column_order': [[r,g] for r in range(6*B+h) for g in range(8)], + 'regular_action_all_columns_hex': [hex(v) for v in regular], + 'derivative_rows_hex': [hex(v) for v in derivative(rows)], 'derivative_rank': target_rank, + 'literal_product_rule_prefixes':derivative_prefixes, + 'complex_evaluation_one': g0, 'complex_evaluation_i': gi, + 'complex_local_evaluation_one':local0,'complex_local_evaluation_i':locali, + 'complex_local_variation_rank':local_complex_rank,'complex_difference_rank': complex_rank}) + removed = copy.deepcopy(events) + del removed[next(i for i,e in enumerate(removed) if e['op']=='query')] + bad = ring_word(B, h, removed) + controls.append(reject_delete('omit_query_B%d_h%d'%(B,h), 'public every-coefficient endpoint', + lambda d, bad=bad, B=B, h=h: endpoint(bad, B, h, 2, d))) + if h: + bad = ring_word(B, h, events[:-1]) + controls.append(reject_delete('omit_dirty_return_B%d_h%d'%(B,h), 'dirty spectator every-coefficient endpoint', + lambda d, bad=bad, B=B, h=h: endpoint(bad, B, h, 2, d))) + # Genuine full-common query exceeds the local alphabet capacity. + controls.append(reject_delete('admit_paid_full_common_gate', 'local first-order capacity', + lambda d: local_capacity(target(4, 3, 2), d))) + bad_events = word(1, 1) + # Replace a cyclic conjugation by identity; this preserves scalar invertibility. + q = next(i for i,e in enumerate(bad_events) if e['op']=='permute') + bad_events[q]['new_row_from_old'] = list(range(7)) + bad = ring_word(1, 1, bad_events) + controls.append(reject_delete('wrong_cyclic_bridge', 'public every-coefficient endpoint', + lambda d: endpoint(bad, 1, 1, 2, d))) + controls.append(reject_delete('complex_phase_reversal', 'finite complex full endpoint', + lambda d: gaussian_endpoint(gaussian_word(1, 1, word(1,1), (0,-1)), 1, 1, (0,1), False, d))) + covariance = cover_covariance([1,2,0]) + controls.append(reject_delete('inverse_C3_covariance', 'C3 covariance', + lambda d: cover_covariance([2,0,1], d))) + cover_records = [] + for B in (1,2,4): + h = 1 + events = word(B,h) + one = gaussian_word(B,h,events,(1,0),True) + imag = gaussian_word(B,h,events,(0,1),True) + gaussian_endpoint(one,B,h,(1,0),True) + gaussian_endpoint(imag,B,h,(0,1),True) + local_one = gaussian_word(B,h,[{'op':'query','pair':0}],(1,0),True) + local_i = gaussian_word(B,h,[{'op':'query','pair':0}],(0,1),True) + local_rank = grank(difference(local_i,local_one)) + full_rank = grank(difference(imag,one)) + gate(local_rank == 6 and full_rank == 18*B, 'regular-cover variation ranks') + derivative_cover = [0]*(3*(6*B+h)) + for j in range(6): + r = 3*j+(2,0,1)[j%3] + derivative_cover[r] = 1 << r + gate(rank2(derivative_cover) == 6, 'BIT regular-cover local derivative') + cover_records.append({'B':B,'dirty_scalar_spectators':h,'cover_dimension':3, + 'local_one':local_one,'local_i':local_i,'target_one':one,'target_i':imag, + 'local_variation_rank':local_rank,'target_variation_rank':full_rank, + 'BIT_local_derivative_rows_hex':[hex(r) for r in derivative_cover]}) + need(len(controls) == 21, 'complete semantic control census') + return {'status':'PASS_SCOPED_SHARP_ORBIT_TARIFF', 'schema':1, + 'source_inventory':inventory, 'historical_adaptation':adaptation, 'complete_original_receipt':old, + 'specialization_homomorphisms':maps, + 'finite_cases':finite,'C3_covariance_images':covariance,'regular_cover_cases':cover_records, + 'semantic_controls':controls,'control_count':len(controls),'same_guard_deletion_count':len(controls), + 'theorem_domain':{'B':'every integer B>=1','h':'every finite integer h>=0', + 'f':'every f>=1 for the independent tensor-generator formal lift in PROOF.md', + 'alphabet':'constant invertible scalar bridges; local two-bank diag(z,x,y)', + 'target':'diag(xyz I_(6B), I_h), optionally multiplied by constant invertibles', + 'sharp_paid_query_calls':'3B','physical_supplier_admission':False,'new_kappa':False}} + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--output', type=Path, required=True) + args = ap.parse_args() + need(args.output.is_absolute(), 'output must be absolute') + need(not args.output.is_symlink(), 'output must not be a symlink') + path = args.output.resolve() + need(not path.is_relative_to(HERE), 'output must be external to package') + need(not path.exists(), 'output must be new') + result = run() + raw = json.dumps(result,sort_keys=True,indent=2)+'\n' + data = gzip.compress(raw.encode(),mtime=0) if path.suffix == '.gz' else raw.encode() + with path.open('xb') as out: + out.write(data) + print('PASS: 9 full group-ring cases, 3 regular-cover cases; 21 defects and 21 guard deletions') + + +if __name__ == '__main__': + main() diff --git a/research/orbit-closed-call-bound/orbit/frozen/history/DERIVATIVE.md b/research/orbit-closed-call-bound/orbit/frozen/history/DERIVATIVE.md new file mode 100644 index 0000000000..0a284e4681 --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/frozen/history/DERIVATIVE.md @@ -0,0 +1,62 @@ +# Paired BIT orbit geometry and an early controller screen + +Canonical scientific source: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +This is local research, not a new supplier or conditional kappa. + +The coordinate rotation `(124)(365)` fixes coordinates zero and seven and +preserves the 120 real E8 root lines. Exactly 54 lines satisfy `p dot O p=0`. +They form 18 orthogonal triples `(p,O p,O^2 p)`. For each triple, the paired +residual `I-P_p-P_Op` is the sum of the third root-line projector and a common +rank-five orthogonal spectator projector. These statements are checked over +the rationals from the pinned actual root file. +The pinned chart uses extended-Hamming supports. The superficially similar +permutation `(012)(345)` does not preserve that file and is not used here. + +This geometry does not establish a global arity `3+5L`. In the following +restricted, orbit-closed algebra it already imposes a call-count condition. +Use the exact BIT involutions on the three common axes, represented by the +group ring `F2[C2^3]` with commuting variables `x,y,z`. There are `2B` +independent banks, each with the three orbit ports, and no auxiliary values. +Each local invocation, up to parameter-independent invertible scalar factors, +has diagonal `(z,x,y)` on exactly two banks and identity on all other banks. +All intervening free operations are parameter-independent scalar invertible +matrices. The requested endpoint is `xyz` on all `6B` data rows, up to such +scalar factors. + +Map `x` to `1+e`, `y,z` to `1` in `F2[e]/(e^2)`. This is well-defined because +`(1+e)^2=1`. Write the image of every gate as `M0+e M1`, with `M0` invertible. +The first-order coefficient of a product is the sum of the conjugated local +first-order coefficients. Each local invocation contributes rank at most two: +one x-coordinate on each of the two active banks. Thus the product's +first-order coefficient has rank at most `2L`. The requested endpoint has +coefficient rank `6B`, since `xyz` maps to `1+e`. Necessarily `L >= 3B`. +In particular `B=4,L=9` fails this grammar regardless of the scalar bridge word. + +There is a finite two-evaluation version that also applies to complex C4 +variables, without differentiating the relation `x^4=1`. Compare the evaluations +`(1,1,1)` and `(i,1,1)`. For matrices A_j and their evaluations A'_j, the exact +telescoping identity for the difference of two products bounds its rank by +`sum rank(A_j-A'_j)`. Each local variation has rank two and the endpoint +variation `(i-1)I` has rank `6B`. Thus the same bound follows over the complex +numbers, allowing arbitrary dyadic scalar coefficients in the free matrices. + +Covariant order-three address rotations can be included on a regular cover. +Represent x,y,z by three-by-three diagonal matrices whose single varying +coordinate rotates, and represent O by the cyclic permutation matrix. These +matrices obey the semidirect covariance relation. On this cover the local +variation rank is six and the endpoint variation rank is `18B`, again giving +`L>=3B`. For BIT the varying entry is `1+e`; for complex it is i. This is an +algebraic representation argument, not an assertion that every native +Clifford adapter factors through this representation. + +The result is not a universal native obstruction. Other address automorphisms, +cross-orbit mixing, changed consumers, extra paid gates, and auxiliary carriers +lie outside the stated model. A complete native reduction to this grammar is +an additional obligation. The independent complex lane is checking its own +covariant route semantics. In particular arbitrary phase adapters cannot be +declared parameter-independent scalar gates without that reduction. + +Reproduce with `python3 geometry_derivative.py` in this directory. The receipt +includes exact source hash, all eligible oriented triples, call screens for +`B=1..8`, and a control showing that a paid complete common transform has the +full missing derivative rank and violates the local-gate hypothesis. diff --git a/research/orbit-closed-call-bound/orbit/frozen/history/GEOMETRY-DERIVATIVE.json b/research/orbit-closed-call-bound/orbit/frozen/history/GEOMETRY-DERIVATIVE.json new file mode 100644 index 0000000000..395a7872d0 --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/frozen/history/GEOMETRY-DERIVATIVE.json @@ -0,0 +1,675 @@ +{ + "control_paid_full_common_derivative_rank": 24, + "eligible_root_lines": 54, + "first_order_ring": "F2[e]/(e^2), x maps to 1+e, y,z map to 1", + "local_derivative_rank": 2, + "local_residual": "rank5 spectator plus the third orbit line", + "necessary_calls": "L >= 3 B", + "no_new_kappa": true, + "orbits": [ + [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 1, + -1, + 1, + -1 + ], + [ + 0, + 1, + 0, + -1, + 0, + 1, + 0, + -1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 1 + ], + [ + 0, + 1, + 0, + -1, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + -1, + 1 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 1, + 1, + -1, + -1 + ], + [ + 0, + 1, + 0, + 1, + 0, + -1, + 0, + -1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 1, + -1 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1 + ], + [ + 0, + 1, + 0, + 1, + 0, + -1, + 0, + 1 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 1, + 1 + ] + ], + [ + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 1, + -1, + -1, + -1, + 0, + 0 + ], + [ + 0, + -1, + 0, + -1, + 1, + 0, + -1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + -1, + -1, + 0 + ] + ], + [ + [ + 0, + 0, + 1, + -1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 1, + 0, + -1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + -1, + 1, + 0 + ] + ], + [ + [ + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0 + ], + [ + 0, + -1, + 0, + 1, + 1, + 0, + 1, + 0 + ], + [ + 0, + 1, + -1, + 0, + 0, + 1, + 1, + 0 + ] + ], + [ + [ + 0, + 0, + 1, + 1, + 1, + -1, + 0, + 0 + ], + [ + 0, + 1, + 0, + -1, + 1, + 0, + 1, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0, + 1, + -1, + 0 + ] + ], + [ + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + -1, + 1, + 0, + -1, + 0, + 0, + -1 + ], + [ + 0, + -1, + -1, + 0, + 1, + 0, + 0, + -1 + ] + ], + [ + [ + 0, + 1, + -1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + -1, + 1, + 0, + -1, + 0, + 0, + 1 + ], + [ + 0, + -1, + -1, + 0, + 1, + 0, + 0, + 1 + ] + ], + [ + [ + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 1, + 1, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0, + -1, + 0, + -1, + 0 + ] + ], + [ + [ + 1, + -1, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 1, + 1, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0, + -1, + 0, + 1, + 0 + ] + ], + [ + [ + 1, + -1, + 1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + -1, + 0 + ], + [ + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0 + ] + ], + [ + [ + 1, + -1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + 1, + 0 + ], + [ + 1, + 1, + 0, + 0, + -1, + 1, + 0, + 0 + ] + ], + [ + [ + 1, + 0, + 0, + -1, + 0, + -1, + 1, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 1, + -1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + -1, + -1, + 0 + ] + ], + [ + [ + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + 1, + -1, + 0 + ], + [ + 1, + 0, + 0, + 1, + 0, + -1, + 1, + 0 + ] + ] + ], + "orthogonal_orbits": 18, + "outside_scope": [ + "address automorphisms beyond the stated C3 regular-cover grammar", + "cross-orbit port mixing, arbitrary native operator coefficients", + "changed final consumers, paid correction gates, auxiliary carriers" + ], + "regular_cover": { + "additional_premise": "all free native maps factor through parameter-independent scalar matrices and the C3 cover permutation", + "finite_complex_comparison": "(x,y,z)=(1,1,1) versus cyclic cover of (i,1,1)", + "local_variation_rank": 6, + "target_variation_rank": "18 B" + }, + "scope": [ + "one closed orthogonal three-port orbit", + "2B independent data banks; no auxiliary values", + "each local gate has scalar invertible factors and diagonal (z,x,y) on exactly two banks", + "free gates are parameter-independent scalar matrices", + "desired endpoint is xyz on every data row, up to parameter-independent scalar invertible maps" + ], + "screens": [ + { + "bank_pairs": 1, + "first_order_rejects_old_call_count": false, + "max_derivative_rank": 6, + "necessary_calls": 3, + "old_calls": 3, + "required_rank": 6 + }, + { + "bank_pairs": 2, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 10, + "necessary_calls": 6, + "old_calls": 5, + "required_rank": 12 + }, + { + "bank_pairs": 3, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 14, + "necessary_calls": 9, + "old_calls": 7, + "required_rank": 18 + }, + { + "bank_pairs": 4, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 18, + "necessary_calls": 12, + "old_calls": 9, + "required_rank": 24 + }, + { + "bank_pairs": 5, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 22, + "necessary_calls": 15, + "old_calls": 11, + "required_rank": 30 + }, + { + "bank_pairs": 6, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 26, + "necessary_calls": 18, + "old_calls": 13, + "required_rank": 36 + }, + { + "bank_pairs": 7, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 30, + "necessary_calls": 21, + "old_calls": 15, + "required_rank": 42 + }, + { + "bank_pairs": 8, + "first_order_rejects_old_call_count": true, + "max_derivative_rank": 34, + "necessary_calls": 24, + "old_calls": 17, + "required_rank": 48 + } + ], + "source_sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "status": "PASS_EXACT_GEOMETRY_AND_SCOPED_ORBIT_CLOSED_DERIVATIVE_BOUND", + "wrong_chart_rotation_defects": 96 +} diff --git a/research/orbit-closed-call-bound/orbit/frozen/history/geometry_derivative.py b/research/orbit-closed-call-bound/orbit/frozen/history/geometry_derivative.py new file mode 100644 index 0000000000..113e3621de --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/frozen/history/geometry_derivative.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Exact E8 O3 geometry and a scoped first-order caller obstruction. + +This does not assert that all possible native controllers obey the grammar. +Prepared with substantial OpenAI Codex assistance; local research only. +""" +import argparse +import gzip +import hashlib +import json +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SOURCE = Path('/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz') + +def need(ok, message): + if not ok: + raise ValueError(message) + +def canon(p): + return tuple(-x for x in p) if next(x for x in p if x) < 0 else tuple(p) + +def rotate(p): + # Cyclic permutation of the three bits indexing the eight coordinates. + # The pinned root chart is the extended-Hamming chart, not the usual D8 + # plus spinor chart; the literal (012)(345) does not preserve this file. + return (p[0], p[4], p[1], p[5], p[2], p[6], p[3], p[7]) + +def dot(p, q): + return sum(a*b for a,b in zip(p,q)) + +def projector(p): + return [[Q(a*b,4) for b in p] for a in p] + +def mm(a,b): + return [[sum(x*y for x,y in zip(row,col)) for col in zip(*b)] for row in a] + +def rank2(rows): + pivots={} + for row in rows: + while row: + p=row.bit_length()-1 + if p in pivots: + row ^= pivots[p] + else: + pivots[p]=row + break + return len(pivots) + +def main(): + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write',action='store_true') + args=ap.parse_args() + roots=sorted({canon(p) for p in json.loads(gzip.decompress(SOURCE.read_bytes()))['lines']}) + need(len(roots)==120 and all(dot(p,p)==4 for p in roots),'root census') + need(all(canon(rotate(p)) in roots and rotate(rotate(rotate(p)))==p for p in roots),'order3 automorphism') + chosen={p for p in roots if dot(p,rotate(p))==0} + seen=set();orbits=[] + for p in sorted(chosen): + if p in seen: + continue + orbit=[p,rotate(p),rotate(rotate(p))] + seen.update(map(canon,orbit)) + need(all(dot(orbit[i],orbit[j])==0 for i in range(3) for j in range(3) if i!=j),'orthogonal orbit') + ps=list(map(projector,orbit)) + s=[[Q(i==j)-sum(a[i][j] for a in ps) for j in range(8)] for i in range(8)] + need(mm(s,s)==s and sum(s[i][i] for i in range(8))==5,'rank5 orbit spectator') + for k in range(3): + residual=[[Q(i==j)-ps[k][i][j]-ps[(k+1)%3][i][j] for j in range(8)] for i in range(8)] + need(residual==[[s[i][j]+ps[(k+2)%3][i][j] for j in range(8)] for i in range(8)],'paired residual split') + orbits.append(orbit) + need(len(chosen)==54 and len(orbits)==18 and seen==chosen,'eligible O3 orbit census') + invalid_chart_permutation=lambda p:(p[2],p[0],p[1],p[5],p[3],p[4],p[6],p[7]) + chart_defects=sum(canon(invalid_chart_permutation(p)) not in roots for p in roots) + need(chart_defects>0,'wrong-chart rotation control') + # On one closed orbit and two active banks, d_x diag(z,x,y,z,x,y) + # has two independent rows. Scalar entrance/exit gates preserve rank. + derivative=[0,1<<1,0,0,1<<4,0] + need(rank2(derivative)==2,'local first derivative rank') + screens=[] + for banks in range(1,9): + old_calls=2*banks+1 + target_rank=6*banks + screens.append({'bank_pairs':banks,'old_calls':old_calls, + 'max_derivative_rank':2*old_calls,'required_rank':target_rank, + 'first_order_rejects_old_call_count':2*old_calls2,'paid full-common gate mutation') + # C3 regular cover: x,y,z have their nonzero variation on separate + # diagonal cover coordinates. Each orbit port contributes one and the + # two active banks therefore contribute six. Their product varies on + # every cover coordinate, including for the finite complex x=i test. + cover_local=[0]*18 + for bank in range(2): + for port in range(3): + index=9*bank+3*port+port + cover_local[index]=1<= 3 B', + 'regular_cover':{'local_variation_rank':6,'target_variation_rank':'18 B', + 'finite_complex_comparison':'(x,y,z)=(1,1,1) versus cyclic cover of (i,1,1)', + 'additional_premise':'all free native maps factor through parameter-independent scalar matrices and the C3 cover permutation'}, + 'wrong_chart_rotation_defects':chart_defects, + 'screens':screens,'control_paid_full_common_derivative_rank':mutation_rank, + 'scope':['one closed orthogonal three-port orbit', + '2B independent data banks; no auxiliary values', + 'each local gate has scalar invertible factors and diagonal (z,x,y) on exactly two banks', + 'free gates are parameter-independent scalar matrices', + 'desired endpoint is xyz on every data row, up to parameter-independent scalar invertible maps'], + 'outside_scope':['address automorphisms beyond the stated C3 regular-cover grammar', + 'cross-orbit port mixing, arbitrary native operator coefficients', + 'changed final consumers, paid correction gates, auxiliary carriers'], + 'no_new_kappa':True} + out=json.loads(json.dumps(out)) + path=HERE/'GEOMETRY-DERIVATIVE.json' + if args.write: + path.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n') + else: + need(json.loads(path.read_bytes())==out,'complete receipt mismatch') + print(out['status']) + print('54 root lines, 18 orthogonal triples; orbit-closed B4 nine-call grammar needs at least 12 calls') + +if __name__=='__main__': + main() diff --git a/research/orbit-closed-call-bound/orbit/frozen/source/LICENSE b/research/orbit-closed-call-bound/orbit/frozen/source/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/frozen/source/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/orbit-closed-call-bound/orbit/frozen/source/NOTICE.md b/research/orbit-closed-call-bound/orbit/frozen/source/NOTICE.md new file mode 100644 index 0000000000..5a0ecdcd2c --- /dev/null +++ b/research/orbit-closed-call-bound/orbit/frozen/source/NOTICE.md @@ -0,0 +1,69 @@ +# Notice + +Apache-2.0 (`LICENSE`). Prepared by eumemic with substantial Anthropic Claude assistance. + +## New in this package + +- `code/skeleton/`: the D4 quad-skeleton geometry (`geom.py`), the word builder with source registers as gate + destinations (`wordkit.py`), the generator (`gen.py`) and an E8 root-line helper (`e8.py`, #370's Hamming + coordinates and line order). +- `data/skeleton/plan-skB.json` (CP-SAT plan nominated by `discovery/plan.py`), `data/skeleton/d4part-pairs.json` + (the 5-pair D4 partition, found by `discovery/d4part.py`), `data/bit/bitE8mut-r489.json.gz` (the word), + `data/eleven/hosting.json` (frozen hosting selection nominated by `discovery/host_select.py` with #442's integer + programme), `data/eleven/residual-isometries.json` (the frame-zero record of #443's isometry format: every helper of + this word enters at frame zero). +- `code/bit/independent/relax.py` (generates the relaxed #370 checker), `interface.py` (#425 lemma hypotheses), + `mutate_mut.py` (word-level mutants and hypothesis controls), `code/bit/mutate_records_mut.py` (record-level + mutable-source mutants). +- `code/eleven/adapt.py` and the adapted files it checks, `code/eleven/{emit,audit,local_audit}.py` (PR #472's files + plus 19 listed edits: R = 489, package paths, a `--hosting` argument, one frame-zero entrance instead of eleven). +- `code/eleven/assemble.py`: PR #472's bit invoice and pricing arithmetic with R as a parameter, and its outer + assembly run once per cited complex supplier. +- `code/cited.py`, `data/complex-b.json`, `verify.sh`, `EXPECTED.json`, `requirements.txt`, `discovery/`, + `.github/workflows/e8-bit-carrier-skeleton.yml`. + +## Vendored, byte-identical (git blob ids in `SOURCE-pr*.json`, checked by `code/provenance.py`) + +- **PR #370 (Dylan Crow / utcorvusvolat-dotcom, with Anthropic Claude assistance), commit b7fe9cd:** the independent + checker `checkword.py` and its controls `mutate.py`; `export_records.py`, `mutate_records.py`, `stage_cohort.py`; + PR #266's official cohort checkers as generalised there (`legality_h.cpp`, `columns_h.cpp`, NCOPY); nlohmann/json + (`json.hpp`, MIT licence in its header); `gram_frames.py`; PR #315's engines (`code/pricing/`, DreamingOfClouds); + the R865 word `data/bit/bitE8-r865.json.gz` (read only for the E8 label table by the geometry scripts); `LICENSE`. +- **PR #381 (DaysSky, assisted with Claude), commit 00765b2:** `columns_k.cpp`. +- **PR #386 (Zhihao Chen / jacklightChen, with OpenAI Codex assistance), commit dd11cf8:** the nine-stage bit geometry + `code/nine/geometry.py` (parent geometry checked by the eleven-stage audit) and `portable-include/bits/stdc++.h`. +- **PR #436 (eumemic, with Anthropic Claude assistance), commit 8f6b829:** `code/provenance.py`. +- **PR #445 (chafreaky, with OpenAI Codex assistance), commit 40ab91d:** `code/hub/r740-hosted-eleven/code/geometry.py` + (eleven-stage geometry), `row_bound.py` (orthogonal-cover row bound), `emit.py` and `data/selection.json` (used + unchanged for the PR #445 control). +- **PR #451 (chafreaky, with OpenAI Codex assistance), commit f3a3815:** `code/hub/r740-hosted-rank149/`: its + eleven-stage bit emitter (byte-identical to PR #445's), frozen selection, R740 rank149 word and isometries + (PR #451 control). +- **PR #472 (chafreaky, with OpenAI Codex assistance), commit 259c684,** and files its branch carries unchanged: + - `code/hub/e8-r715-whole-hosted/`: PR #472's eight-replica pooled emitter, independent audit, local projector + audit and assembly (the originals of the adapted files), its R715 word, isometries and frozen hosting (used + unchanged for the PR #472 control); + - `code/hub/e8-r740-replica32/`: PR #443 (chafreaky): `bank_routes.py`, `tile_m.py`, `e8core.py`, the R740 rank138 + word and its isometries (PR #445 control); PR #315's engines (DreamingOfClouds) in `code/engines/`; + - `code/hub/idle-axis-hosting/hosting_core.py`: PR #442 (DaysSky, with Anthropic Claude assistance). +- **Receipts (`data/complex/`):** `EXPECTED.json` of PR #484 (DreamingOfClouds, 035845c), PR #471 (Dugongue, + 56b3da6), PR #458 (chafreaky, 44e9eae), PR #448 (higherbeing, 359022b), and of the bit-bound frontier PRs #483 + (Dugongue, 3738c3c), #473 (rohanarun, c7590f1) and #478 (Dugongue, bea1d52). + +The repository-level files `certificates/joint-dual-kappa.json`, `certificates/joint-dual-validation.json` and +`research/joint-dual/SOURCE.json` in this branch are byte-identical to rohanarun's PR #318 (a45747d). They repair +stale root-file pins so the repository's joint check passes; #417, #436 and #439 carry the same repair. + +## Cited, not rebuilt + +Complex coarse savings in `data/complex-b.json`, each bound to its PR's `EXPECTED.json` by `code/cited.py`: +PR #484 (primary; draft, conditional on its Lemmas A and G), PR #471 (the complex supplier of #473, #478 and #483), +PR #458 (the complex supplier of #472) and PR #448 (information only; disputed cross-copy split). No complex +construction is rebuilt here. + +## Ideas used + +PR #425 (Zhihao Chen, with OpenAI Codex assistance): the scalar-interface lemma that permits source registers as +gate destinations when the full-frame cleanup restores them. PR #463 (DreamingOfClouds, with Claude Opus 5.5): the +carrier bound (three registers leave a source's line). PR #433 (icekylinx): source rows written on the bit side. +PR #442 (DaysSky): idle-axis hosting of whole residuals. Jacob Sussman introduced the E8 unit. diff --git a/research/orbit-closed-call-bound/orbit/frozen/source/bitE8-r865.json.gz b/research/orbit-closed-call-bound/orbit/frozen/source/bitE8-r865.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..8bec1751f7e33c3a1e4673ef5dbc34d6f205321e GIT binary patch literal 33865 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 F0sxs54@Cd~ literal 0 HcmV?d00001 diff --git a/research/orbit-closed-call-bound/reviews/CONTROL-VALIDATION.json b/research/orbit-closed-call-bound/reviews/CONTROL-VALIDATION.json new file mode 100644 index 0000000000..7ead493453 --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/CONTROL-VALIDATION.json @@ -0,0 +1,22 @@ +{ + "command": [ + "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "-I", + "-B", + "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-orbit-review/controls.py", + "--package", + "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09a-staging", + "--output", + "/Users/ross/git/math/.research-automation/runs/unpublished-round3-20261020T2130Z/c09-orbit-review/CONTROLS.json" + ], + "complete_scientific_receipts": 2, + "control_source_sha256": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671", + "final_refresh": "Re-executed after the README heading-only metadata correction; prior receipt preserved separately.", + "intended_rejections_per_mode": 58, + "named_deletions_per_mode": 14, + "normal_optimized_equal_except_mode": true, + "python_executable": "/Users/ross/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3", + "python_version": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "receipt_sha256": "cb94c173b7cb590157861bd1a3f5052d313153433b99003d23e5b529c874746e", + "status": "PASS" +} diff --git a/research/orbit-closed-call-bound/reviews/CONTROLS.json b/research/orbit-closed-call-bound/reviews/CONTROLS.json new file mode 100644 index 0000000000..d7bd7d135c --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/CONTROLS.json @@ -0,0 +1,647 @@ +{ + "control_source_sha256": "fca42a2da26c110ecf2ece5dee9bcdf49b225e83722ced29deb34a5414406671", + "executed_check_deletions_per_mode": 14, + "full_scientific_receipts_compared": 2, + "full_scientific_stages_replayed": false, + "intended_rejections_per_mode": 58, + "no_new_kappa": true, + "normal_and_optimized_receipts_equal_except_mode": true, + "runs": [ + { + "compression": { + "equivalent_recompression_accepted": true, + "rejections": [ + { + "intended_gate": "changed frozen input: original.json.gz", + "name": "changed_compressed_input" + }, + { + "intended_gate": "origin digest mismatch: original.json.gz", + "name": "changed_container_origin" + }, + { + "intended_gate": "original decoded bytes changed: original.json.gz", + "name": "changed_original_after_transport_rebinding" + }, + { + "intended_gate": "frozen/origin inventory mismatch", + "name": "omitted_origin" + } + ] + }, + "coverage": { + "actual_dispatch_tested_with_tiny_receipts": true, + "executed_check_deletions": 1, + "rejections": [ + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_extra" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_extra" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "omitted_actual_compare" + } + ], + "stage_counts": { + "independent": 1, + "orbit": 1 + } + }, + "loader": { + "captured_source_survives_disposable_path_change": true, + "child_assertions_enabled": true, + "file_and_argument_semantics_preserved": true, + "rejections": [ + { + "intended_gate": "AssertionError: DIRECT_ASSERT", + "name": "direct.py" + }, + { + "intended_gate": "AssertionError: NESTED_ASSERT", + "name": "nested.py" + }, + { + "intended_gate": "changed frozen input: direct.py", + "name": "changed_executable_source" + }, + { + "intended_gate": "missing regular input: direct.py", + "name": "missing_executable_source" + }, + { + "intended_gate": "unregistered input: absent.py", + "name": "unregistered_source" + }, + { + "intended_gate": "unsafe package path", + "name": "absolute_path" + }, + { + "intended_gate": "unsafe package path", + "name": "parent_escape" + }, + { + "intended_gate": "missing regular input: link.py", + "name": "symlink_input" + }, + { + "intended_gate": "input escapes package", + "name": "ancestor_symlink_escape" + }, + { + "intended_gate": "DIRECT_RUNTIME_GATE", + "name": "direct_runtime_requirement" + } + ] + }, + "output": { + "early_output_guards": true, + "exclusive_output_creation_exercised": true, + "rejections": [ + { + "intended_gate": "output must be absolute", + "name": "relative_output" + }, + { + "intended_gate": "output already exists", + "name": "existing_output" + }, + { + "intended_gate": "output must be external", + "name": "internal_output" + }, + { + "intended_gate": "exclusive output creation FileExistsError", + "name": "output created during replay" + } + ] + }, + "parent_optimization": 0, + "real_records": [ + { + "nested_path": [ + "cases", + 0, + "events", + 0, + "local_diagonal", + 0 + ], + "record": "independent/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884" + }, + { + "nested_path": [ + "finite_cases", + 0, + "F2_all_8_coefficient_matrices", + 0, + 0, + 0 + ], + "record": "orbit/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: orbit/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: orbit/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + } + ], + "record_gate": { + "named_record_gate_deletion_detected": true, + "rejections": [ + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "boolean_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "float_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "integer_for_boolean" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "nested_omission" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_reorder" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_truncate" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "duplicate_json_key" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "nested_duplicate_json_key" + }, + { + "intended_gate": "nonfinite JSON constant: NaN", + "name": "nonfinite_NaN" + }, + { + "intended_gate": "nonfinite JSON constant: Infinity", + "name": "nonfinite_Infinity" + }, + { + "intended_gate": "nonfinite JSON constant: -Infinity", + "name": "nonfinite_-Infinity" + }, + { + "intended_gate": "missing regular input: expected.json", + "name": "missing_expected_record" + } + ] + }, + "scientific": { + "actual_mathematical_mutations_after_authentication": true, + "deletion_scope": "the same named production predicate", + "executed_check_deletions": 12, + "full_scientific_stages_replayed": false, + "rejections": [ + { + "intended_gate": "complete regular-action endpoint", + "name": "omitted local call" + }, + { + "intended_gate": "complete regular-action endpoint", + "name": "wrong cyclic port conjugation" + }, + { + "intended_gate": "all public and arbitrary dirty spectator columns", + "name": "dirty spectator leaks into public output" + }, + { + "intended_gate": "all public and arbitrary dirty spectator columns", + "name": "spectator not returned literally" + }, + { + "intended_gate": "charged local derivative rank at most two", + "name": "paid full common transform mislabeled one local call" + }, + { + "intended_gate": "complete regular-action endpoint", + "name": "BIT inverse coincidence does not transfer to C4" + }, + { + "intended_gate": "free bridge is parameter independent", + "name": "parameter dependent transform mislabeled free bridge" + }, + { + "intended_gate": "exact C3 source covariance", + "name": "source rotation with the one-character y specialization" + }, + { + "intended_gate": "exact C3 source covariance", + "name": "inverse cover rotation has wrong source covariance" + }, + { + "intended_gate": "public every-coefficient endpoint", + "name": "actual orbit query omitted" + }, + { + "intended_gate": "dirty spectator every-coefficient endpoint", + "name": "actual borrowed spectator return omitted" + }, + { + "intended_gate": "local first-order capacity", + "name": "full common transform violates actual local alphabet" + } + ] + }, + "sources": { + "all_mutations_in_disposable_bytes_or_directory": true, + "full_scientific_stages_replayed": false, + "historical_assertions_execute_with_optimization_zero": true, + "no_path_import_or_pyc_execution": true, + "rejections": [ + { + "intended_gate": "HISTORICAL_NESTED_ASSERT", + "name": "captured_historical_nested_assertion" + }, + { + "intended_gate": "unique historical adaptation", + "name": "duplicate_historical_adapter" + }, + { + "intended_gate": "unique historical adaptation", + "name": "missing_historical_adapter" + }, + { + "intended_gate": "captured root read count", + "name": "undeclared_additional_source_read" + }, + { + "intended_gate": "authenticated input: frozen/source/bitE8-r865.json.gz", + "name": "changed_actual_root_source" + } + ] + } + }, + { + "compression": { + "equivalent_recompression_accepted": true, + "rejections": [ + { + "intended_gate": "changed frozen input: original.json.gz", + "name": "changed_compressed_input" + }, + { + "intended_gate": "origin digest mismatch: original.json.gz", + "name": "changed_container_origin" + }, + { + "intended_gate": "original decoded bytes changed: original.json.gz", + "name": "changed_original_after_transport_rebinding" + }, + { + "intended_gate": "frozen/origin inventory mismatch", + "name": "omitted_origin" + } + ] + }, + "coverage": { + "actual_dispatch_tested_with_tiny_receipts": true, + "executed_check_deletions": 1, + "rejections": [ + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "orbit_extra" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_omitted" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_duplicated" + }, + { + "intended_gate": "complete stage record coverage changed: independent", + "name": "independent_extra" + }, + { + "intended_gate": "complete stage record coverage changed: orbit", + "name": "omitted_actual_compare" + } + ], + "stage_counts": { + "independent": 1, + "orbit": 1 + } + }, + "loader": { + "captured_source_survives_disposable_path_change": true, + "child_assertions_enabled": true, + "file_and_argument_semantics_preserved": true, + "rejections": [ + { + "intended_gate": "AssertionError: DIRECT_ASSERT", + "name": "direct.py" + }, + { + "intended_gate": "AssertionError: NESTED_ASSERT", + "name": "nested.py" + }, + { + "intended_gate": "changed frozen input: direct.py", + "name": "changed_executable_source" + }, + { + "intended_gate": "missing regular input: direct.py", + "name": "missing_executable_source" + }, + { + "intended_gate": "unregistered input: absent.py", + "name": "unregistered_source" + }, + { + "intended_gate": "unsafe package path", + "name": "absolute_path" + }, + { + "intended_gate": "unsafe package path", + "name": "parent_escape" + }, + { + "intended_gate": "missing regular input: link.py", + "name": "symlink_input" + }, + { + "intended_gate": "input escapes package", + "name": "ancestor_symlink_escape" + }, + { + "intended_gate": "DIRECT_RUNTIME_GATE", + "name": "direct_runtime_requirement" + } + ] + }, + "output": { + "early_output_guards": true, + "exclusive_output_creation_exercised": true, + "rejections": [ + { + "intended_gate": "output must be absolute", + "name": "relative_output" + }, + { + "intended_gate": "output already exists", + "name": "existing_output" + }, + { + "intended_gate": "output must be external", + "name": "internal_output" + }, + { + "intended_gate": "exclusive output creation FileExistsError", + "name": "output created during replay" + } + ] + }, + "parent_optimization": 1, + "real_records": [ + { + "nested_path": [ + "cases", + 0, + "events", + 0, + "local_diagonal", + 0 + ], + "record": "independent/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: independent/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884" + }, + { + "nested_path": [ + "finite_cases", + 0, + "F2_all_8_coefficient_matrices", + 0, + 0, + 0 + ], + "record": "orbit/CHECKS.json.gz", + "rejections": [ + { + "intended_gate": "complete typed record mismatch: orbit/CHECKS.json.gz", + "name": "deep_field_changed" + }, + { + "intended_gate": "complete typed record mismatch: orbit/CHECKS.json.gz", + "name": "deep_field_omitted" + } + ], + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + } + ], + "record_gate": { + "named_record_gate_deletion_detected": true, + "rejections": [ + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "boolean_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "float_for_integer" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "integer_for_boolean" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "nested_omission" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_reorder" + }, + { + "intended_gate": "complete typed record mismatch: expected.json", + "name": "ordered_list_truncate" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "duplicate_json_key" + }, + { + "intended_gate": "duplicate JSON key: a", + "name": "nested_duplicate_json_key" + }, + { + "intended_gate": "nonfinite JSON constant: NaN", + "name": "nonfinite_NaN" + }, + { + "intended_gate": "nonfinite JSON constant: Infinity", + "name": "nonfinite_Infinity" + }, + { + "intended_gate": "nonfinite JSON constant: -Infinity", + "name": "nonfinite_-Infinity" + }, + { + "intended_gate": "missing regular input: expected.json", + "name": "missing_expected_record" + } + ] + }, + "scientific": { + "actual_mathematical_mutations_after_authentication": true, + "deletion_scope": "the same named production predicate", + "executed_check_deletions": 12, + "full_scientific_stages_replayed": false, + "rejections": [ + { + "intended_gate": "complete regular-action endpoint", + "name": "omitted local call" + }, + { + "intended_gate": "complete regular-action endpoint", + "name": "wrong cyclic port conjugation" + }, + { + "intended_gate": "all public and arbitrary dirty spectator columns", + "name": "dirty spectator leaks into public output" + }, + { + "intended_gate": "all public and arbitrary dirty spectator columns", + "name": "spectator not returned literally" + }, + { + "intended_gate": "charged local derivative rank at most two", + "name": "paid full common transform mislabeled one local call" + }, + { + "intended_gate": "complete regular-action endpoint", + "name": "BIT inverse coincidence does not transfer to C4" + }, + { + "intended_gate": "free bridge is parameter independent", + "name": "parameter dependent transform mislabeled free bridge" + }, + { + "intended_gate": "exact C3 source covariance", + "name": "source rotation with the one-character y specialization" + }, + { + "intended_gate": "exact C3 source covariance", + "name": "inverse cover rotation has wrong source covariance" + }, + { + "intended_gate": "public every-coefficient endpoint", + "name": "actual orbit query omitted" + }, + { + "intended_gate": "dirty spectator every-coefficient endpoint", + "name": "actual borrowed spectator return omitted" + }, + { + "intended_gate": "local first-order capacity", + "name": "full common transform violates actual local alphabet" + } + ] + }, + "sources": { + "all_mutations_in_disposable_bytes_or_directory": true, + "full_scientific_stages_replayed": false, + "historical_assertions_execute_with_optimization_zero": true, + "no_path_import_or_pyc_execution": true, + "rejections": [ + { + "intended_gate": "HISTORICAL_NESTED_ASSERT", + "name": "captured_historical_nested_assertion" + }, + { + "intended_gate": "unique historical adaptation", + "name": "duplicate_historical_adapter" + }, + { + "intended_gate": "unique historical adaptation", + "name": "missing_historical_adapter" + }, + { + "intended_gate": "captured root read count", + "name": "undeclared_additional_source_read" + }, + { + "intended_gate": "authenticated input: frozen/source/bitE8-r865.json.gz", + "name": "changed_actual_root_source" + } + ] + } + } + ], + "source_hashes": { + "FROZEN-SHA256.json": "02f29358ac08aeaa969d82ba1967c25c9a28b536a6393e7bf44b6f3e6a2264ec", + "ORIGINS.json": "f741f1faef3c0e55a23623b12ce1d9bc6905e947dadefd26c3665dd8bf397f1d", + "independent/check.py": "c19dabdb8a6f84a44a2a3acbe86d9e2c380100c6217a3f89028742c15b423826", + "orbit/check.py": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3", + "verify.py": "9566d768b7929e25e8ad62b96f27986827c7ae4d94a5faa25d296f58391d9a3e" + }, + "status": "PASS_C09_ORBIT_COMPACT_SOURCE_RECORD_AND_SEMANTIC_CONTROLS" +} diff --git a/research/orbit-closed-call-bound/reviews/CROSS-REVIEW-ORBIT.md b/research/orbit-closed-call-bound/reviews/CROSS-REVIEW-ORBIT.md new file mode 100644 index 0000000000..db18c8401d --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/CROSS-REVIEW-ORBIT.md @@ -0,0 +1,70 @@ +# Independent review of the C09 orbit tariff + +Verdict: PASS for the stated formal alphabets and complete arbitrary-input +endpoints. No correction is requested. This is a source/proof review with +independent algebraic derivations; it is not an additional execution of the +entire orbit audit and does not validate a native supplier. + +The reviewed files in the sibling `c09-orbit/` package have these SHA-256 pins: + +| File | SHA-256 | +| --- | --- | +| `check.py` | `75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3` | +| `PROOF.md` | `573b7ab3132f0d2d0c1777cc457a254e67a6ff001d0fc55b61447018806e56e6` | +| `CHECKS.json.gz` | `b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf` | +| decompressed complete receipt | `31f90a56ce4ce6bbdcee97b44eabf07ef82121cbe22c640b85ac364baaec7230` | +| `OUTPUT-INVENTORY.json` | `ac033d11090a326c1c9cfdc9fcbd5755425dfeec95d72132f7bd5b617eed33b6` | + +The lower bound correctly applies the exact dual-number product rule to the +entire word. Every augmented factor is invertible; a paid two-bank diagonal +has two varying coordinates, and constant left/right scalar factors preserve +this rank. The complete target derivative is `diag(I_(6B),0_h)`, even when +scalar bridges borrow arbitrary spectator coordinates. Hence `6B<=2L` for +every finite `h`. The proof requires the complete endpoint on every ordinary +input; it never substitutes a zero-spectator test. + +The attaining word uses only conjugation by scalar port permutations. +Cycling the three ports makes each public row acquire each of `x,y,z` once, +with no generator renaming. The literal implementation uses three queries +and four nonidentity scalar permutation events per bank pair. The extra +spectator shear/inverse pair is recorded, algebraically redundant, and not +counted as a physical free operation. Thus the formal optimum is exactly +`3B`, including the returned-spectator extension. + +The order-four proof uses a difference of two genuine characters, not an +invalid characteristic-zero derivative of a finite-order relation. Its +local and target ranks are respectively two and `6B`. In the C3 cover, +`O e_j=e_(j+1)` sends the nontrivial diagonal coordinate of X to that of Y, +then Z; the direction of conjugation in the code and proof agrees. Each +local query has six varying cover coordinates, while the complete target +has `18B`. Tensoring independent cover factors and varying only the first +multiplies both ranks by `3^(f-1)`. The full-ring and cover representation +premises are stated separately and do not imply a native faithful +representation. + +The pinned geometry source checks all root norms, the actual chart rotation, +the 54 eligible lines and 18 orthogonal triples. For each triple the mutually +orthogonal rank-one projectors give an idempotent complement of trace five, +and each paired residual equals that complement plus the third projector. +The changed chart permutation is a real admission defect. Only the root +`lines` are used; no R865 circuit verification is claimed. + +The source adapter authenticates captured bytes and compiles with explicit +`optimize=0`. Its exact replacements preserve the old mathematical checks; +the full old typed receipt is compared without a field projection. The fresh +coefficient interpreter retains all eight binary and all 64 order-four +coefficients, and a separate bit-vector implementation checks all `8n` +regular-action columns. The phase-bearing Gaussian evaluation is executed +on complete matrices. The 21 controls mutate actual word, phase, capacity, +covariance, geometry or typed-evidence inputs and match the intended guard; +the same mutant is accepted only after deletion of that guard outside the +rejection handler. + +The all-`B,h,f` assertions are written proofs, while the nine word cases and +three cover cases are finite reproducibility evidence. Scalar/address work, +native frame admission, precision, ownership, storage and physical execution +remain unpriced. The sharp formal tariff cannot be transferred to another +query alphabet or a parameter-dependent bridge without a separate reduction. + +Prepared with substantial OpenAI Codex assistance. The cubic package's frozen +core inventory is unchanged; this review is a separate companion artifact. diff --git a/research/orbit-closed-call-bound/reviews/GIT-SOURCE-CHECKS.json b/research/orbit-closed-call-bound/reviews/GIT-SOURCE-CHECKS.json new file mode 100644 index 0000000000..b5096c9a58 --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/GIT-SOURCE-CHECKS.json @@ -0,0 +1,62 @@ +{ + "count": 9, + "rows": [ + { + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "path": "certificates/selected-result.json", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "spec": "12fa8c5c844be21bfefb38a19503fbd867a11244:certificates/selected-result.json" + }, + { + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "path": "docs/research/agent-task-catalog.json", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96", + "spec": "12fa8c5c844be21bfefb38a19503fbd867a11244:docs/research/agent-task-catalog.json" + }, + { + "git_blob": "abdd2792e6a5596b3fa6be3dc9db882bd8e3ef89", + "path": "docs/research/research-family-status.md", + "sha256": "0e61c47dfbc6f16e5f64594fcc7d907d4187568e38dddf10d473f0992419c44f", + "spec": "12fa8c5c844be21bfefb38a19503fbd867a11244:docs/research/research-family-status.md" + }, + { + "git_blob": "29e1f2ba643e36ef43d566d32242bf6950b2ab27", + "path": "research/fixed-support-unary-query-bounds/README.md", + "sha256": "58f4675f0b6694177bba3a2c8de7bf7d9445f6e87437356e2cf1e33bb090f3d4", + "spec": "12fa8c5c844be21bfefb38a19503fbd867a11244:research/fixed-support-unary-query-bounds/README.md" + }, + { + "git_blob": "5a0ecdcd2c7fad0488740a1da0f633b73b56a809", + "path": "research/e8-bit-carrier-skeleton/NOTICE.md", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "spec": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/NOTICE.md" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "research/e8-bit-carrier-skeleton/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "spec": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/LICENSE" + }, + { + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "path": "research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "spec": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz" + }, + { + "git_blob": "dc04f533bd0f3b185969bb259e876a73714f7285", + "path": "research/abelian-cayley-metric-scope/sources/pr288-README.md", + "sha256": "c091e98c415e2a80bb28402b789363eb97dd3492061ca8875e421ae437de7482", + "spec": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/abelian-cayley-metric-scope/sources/pr288-README.md" + }, + { + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "path": "research/bit-three-register-lower-bound/README.md", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "spec": "07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea:research/bit-three-register-lower-bound/README.md" + } + ], + "scope": "Exact declared source byte bindings; no scientific revalidation of earlier PRs.", + "source_manifest_sha256": "9ab1c95b9502f9258351488c1167859227ec137d16b973df4773df0b11cce00f", + "status": "PASS_DECLARED_GIT_BINDINGS" +} diff --git a/research/orbit-closed-call-bound/reviews/REVIEW.md b/research/orbit-closed-call-bound/reviews/REVIEW.md new file mode 100644 index 0000000000..59520225a0 --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/REVIEW.md @@ -0,0 +1,41 @@ +# Independent exact review of the orbit-call package + +The reviewed result is a sharp formal query count: `L = 3B` for the declared two-bank, three-port generator, for every positive integer `B` and every finite number of independent dirty scalar spectators returned unchanged. This review finds no remaining mathematical or source-control defect within that model. The final package snapshot binding is recorded in `SNAPSHOT-REVIEW.json`: all 28 core files match manifest SHA-256 `f086955ecbc5e5d7a61a34e5c10c72baa0af5fc6f943cb209d0b0dda38d486c3`; the snapshot file SHA-256 is `b9d9f6e30faf8946d9bf625a5bb601fea4432e6fb88069f57bfa38e5db782db5`. The four copied reviewer receipts match their executed originals, and the separate cross-review retains the same scientific pins. + +## Mathematical boundary and derivation + +The complete target is `diag(xyz I_(6B), I_h)`. Every public input and spectator input is independent. A free bridge is parameter independent and invertible, and may mix all public and spectator coordinates. A charged local generator acts as `diag(z,x,y,z,x,y)` on two banks, with identity elsewhere; constant invertible changes of its input and output coordinates preserve the rank argument. The statement concerns finite linear words in this alphabet. It does not grant free data-dependent operations or uncharged parameter-dependent transforms. + +Over `F2[C2^3]`, the specialization `x -> 1+e`, `y,z -> 1` with `e^2=0` has first-variation rank two on each charged call. The product rule expresses the final variation as a sum of `L` left/right transported local variations. Constant bridges contribute zero, so its rank is at most `2L`. The complete target has rank `6B`, including zero variation on every spectator row. Thus `L >= 3B`, regardless of intermediate public/spectator mixing. This uses full operators, not a promise that spectators start at zero. + +For the complex order-four algebra, the difference between evaluations `(x,y,z)=(1,1,1)` and `(i,1,1)` replaces the characteristic-two derivative. The exact product-difference expansion again gives rank at most `2L` and target rank `6B`. Inverting a generator is harmless in the BIT model but changes the complex model; the independent controls exercise this distinction. + +A genuine cyclic source automorphism requires a separate representation. The three-dimensional evaluation-orbit cover uses `O e_j=e_(j+1)` and diagonal `X,Y,Z` with the varying entry in successive coordinates. Its covariance is checked with phases retained. Local and target variation ranks become six and `18B`, respectively, with identity on the `3h` lifted spectator coordinates. This still implies `L >= 3B`. Here “regular cover” describes the cyclic evaluation orbit; faithfulness of the entire semidirect group algebra is unnecessary for this necessary-condition argument and is not asserted. The independent-generator tensor extension is conditional on the written formal alphabet and constant-image bridge hypotheses. + +Sharpness uses scalar port permutations without any source automorphism. If `P` cycles the three port rows in each bank, the three conjugates `D`, `P D P^-1`, and `P^2 D P^-2` multiply to `xyz I_6`. Applying this word to `B` disjoint bank pairs gives `3B` calls and literal identity on spectators. The displayed unmerged word has `4B` nonidentity permutation events. Query optimality does not assign those events zero physical work. + +## Independent finite evidence + +The independent checker uses direct regular-action permutations and exact Gaussian-rational ranks, with no imports from the producer, historical checker, or compiler. For `B` in `{1,2,4}` and `h` in `{0,1,3}`, it retains all 1,104 BIT regular-action columns and all 8,832 C4 columns. All 9,936 columns were separately compared against the other component's full coefficient matrices. Every comparison includes initially dirty columns and restored spectator rows. The dual-number coefficient reconstruction also verifies translation equivariance on every regular-action column. + +The checker explicitly permits a scalar bridge mixing an active row with a spectator and verifies that the transported derivative changes while retaining rank two. Three cover fixtures check actual cyclic covariance. Eighteen positive controls reverse commuting products. Nine semantic mutations exercise the actual independent production guards and then remove only the named guard on the same candidate. In particular, a dirty-input leak passes the restriction to public input columns but fails the complete operator test. These are finite executable witnesses; the all-parameter statements rely on the written proofs. + +The main component adds 21 semantic rejections with corresponding guard deletions. Its new finite checks retain full ring coefficients, event-by-event variation recurrences, all 64 dual-number basis products and all 4,096 C4 evaluation basis products. The reviewed geometric census uses the pinned root-line chart only: 54 eligible lines, 18 triples, and rank-five common spectator projectors. It does not replay or recertify the stored R865 circuit. + +## Source and production-gate review + +The top wrapper authenticates captured source bytes and executes those same bytes through isolated subprocesses with `dont_inherit=True` and `optimize=0`. It compares each complete typed JSON receipt and requires the exact two-stage receipt inventory. It does not reopen a source path through an importer, and therefore has no source-module bytecode-cache execution path. Scratch and final outputs are external; final outputs use exclusive creation. + +The historical adapter authenticates the unchanged original script before applying three declared I/O adaptations. An AST comparison found all historical function definitions unchanged except `main`, whose changes bind the two captured root reads, remove argument parsing and return the complete result. The exact executed adaptation digest and full regenerated historical receipt match the retained record. Both compressed transport and decompressed original root bytes are bound. Six original-file bindings and all nine declared Git source rows were independently checked. Those bindings establish provenance, not fresh scientific verification of the earlier PRs. + +The source review identified three issues before freeze: omitted `dont_inherit=True` in the historical compiler call, an independent regular-action helper that assumed odd ADD coefficients, and output symlink checking after resolution. All three were corrected before the final scientific pins. The fixed receipt and source hashes are recorded in the snapshot review. + +The compact wrapper controls execute 58 intended rejections and 14 named-check deletions per mode on Python 3.12.14. Normal and optimized records agree after removing only the mode indicator. They cover captured execution, direct and nested assertions, original-source adapter omissions and duplication, actual changed root bytes, typed scalar and nested/list receipt changes, both complete real scientific records, exact stage coverage, compression/original bindings, output collision and race behavior, and actual mathematical mutations. Unexpected acceptance is raised outside the caught failure path. Mathematical sensitivity is demonstrated after source authentication and is not inferred from hash failures. + +The final control replay includes the README heading-only metadata correction. The final source closure authenticates 26 frozen package files; `CONTROL-VALIDATION.json`, `SOURCE-CLOSURE.json`, and `GIT-SOURCE-CHECKS.json` preserve the exact evidence and command provenance. + +## Limits + +This review certifies the stated formal grammar and the inspected evidence. A concrete native representation needs its own reduction or evaluation/faithfulness justification before the lower bound applies to it. General internal address maps, cross-orbit operations, wider coupled queries and changed output contracts are outside the theorem. Native child admission, paid source scans, scalar/address work, restoration costs, precision, ownership, storage and tape realization remain separate obligations. No multiplication exponent, selected-result change, or formal-kernel proof follows. + +Committed-package replay, Git-free export replay, repository-wide gates and hosted CI are the parent integration obligations and are not asserted by this report. Review was performed in a separate model context with a different exact representation; it is not independent human acceptance. diff --git a/research/orbit-closed-call-bound/reviews/SNAPSHOT-REVIEW.json b/research/orbit-closed-call-bound/reviews/SNAPSHOT-REVIEW.json new file mode 100644 index 0000000000..90d5a8169d --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/SNAPSHOT-REVIEW.json @@ -0,0 +1,64 @@ +{ + "copied_review_artifacts": { + "CONTROL-VALIDATION.json": { + "bytes": 1177, + "sha256": "93158d1dad2e83972461cbaa5a2f220a013fef2da64782d951f361fdd70b25e3" + }, + "CONTROLS.json": { + "bytes": 21848, + "sha256": "cb94c173b7cb590157861bd1a3f5052d313153433b99003d23e5b529c874746e" + }, + "CROSS-REVIEW-ORBIT.md": { + "bytes": 4231, + "sha256": "9494192aa7c688dfde8cdd6025b3305ab53e33b6ecd0afba321dcc22241bb5dd" + }, + "GIT-SOURCE-CHECKS.json": { + "bytes": 3202, + "sha256": "f6333e69413d4f5d5636584fb9dc1f66fa9caac51e3e2f53cbaa3c5a5648c7db" + }, + "SOURCE-CLOSURE.json": { + "bytes": 4018, + "sha256": "a28b3b17c22fd9ada715061eee59686bb477c7ccf5346db209d22f47d0840d27" + } + }, + "core_file_count": 28, + "core_manifest_sha256": "f086955ecbc5e5d7a61a34e5c10c72baa0af5fc6f943cb209d0b0dda38d486c3", + "core_snapshot_scope": "Complete candidate core; snapshot and subsequent review reports excluded to avoid circular hashes.", + "core_snapshot_sha256": "b9d9f6e30faf8946d9bf625a5bb601fea4432e6fb88069f57bfa38e5db782db5", + "cross_component_BIT_columns": 1104, + "cross_component_C4_columns": 8832, + "declared_Git_bindings": 9, + "exact_core_inventory_checked": true, + "fresh_scientific_replays_during_snapshot_review": 0, + "frozen_files": 26, + "full_scientific_receipts_compared": 2, + "intended_rejections_per_mode": 58, + "named_check_deletions_per_mode": 14, + "normal_optimized_equal_except_mode": true, + "original_byte_bindings": 6, + "scientific_source_and_receipt_pins": { + "independent/CHECKS.json.gz": { + "bytes": 23291, + "original_bytes": 189856, + "original_sha256": "d35b53eed29d63d97b4eeb6ba05c302a53656241e894a262bd7344ec2178a01a", + "sha256": "226dc4c62b00d3bedbcd72e4763275b49223704bb25e68ff44cd3681d9e1c884" + }, + "independent/check.py": { + "bytes": 17721, + "sha256": "c19dabdb8a6f84a44a2a3acbe86d9e2c380100c6217a3f89028742c15b423826" + }, + "orbit/CHECKS.json.gz": { + "bytes": 64855, + "original_bytes": 5978887, + "original_sha256": "31f90a56ce4ce6bbdcee97b44eabf07ef82121cbe22c640b85ac364baaec7230", + "sha256": "b719b88739795f625b7722f0621612b816267b23cf5d9325c9799a7baac161bf" + }, + "orbit/check.py": { + "bytes": 21857, + "sha256": "75ed569703eec067756efebc8067517ef77d771d2df95d39084482726ec3e3e3" + } + }, + "scope": "Exact final package bytes, previously executed complete receipts and source/control review; committed/export/hosted validation is not asserted.", + "source_control_hashes_match": true, + "status": "PASS_SNAPSHOT_BOUND_ORBIT_REVIEW" +} diff --git a/research/orbit-closed-call-bound/reviews/SOURCE-CLOSURE.json b/research/orbit-closed-call-bound/reviews/SOURCE-CLOSURE.json new file mode 100644 index 0000000000..8b1a42d2b7 --- /dev/null +++ b/research/orbit-closed-call-bound/reviews/SOURCE-CLOSURE.json @@ -0,0 +1,137 @@ +{ + "FROZEN_sha256": "02f29358ac08aeaa969d82ba1967c25c9a28b536a6393e7bf44b6f3e6a2264ec", + "ORIGINS_sha256": "f741f1faef3c0e55a23623b12ce1d9bc6905e947dadefd26c3665dd8bf397f1d", + "changed_definition": "main: capture root reads, remove parser and return full output only", + "complete_historical_receipt_equal": true, + "cross_component_BIT_columns": 1104, + "cross_component_C4_columns": 8832, + "cross_component_full_operator_comparison": [ + { + "B": 1, + "BIT_columns": 48, + "C4_columns": 384, + "all_equal": true, + "h": 0 + }, + { + "B": 1, + "BIT_columns": 56, + "C4_columns": 448, + "all_equal": true, + "h": 1 + }, + { + "B": 1, + "BIT_columns": 72, + "C4_columns": 576, + "all_equal": true, + "h": 3 + }, + { + "B": 2, + "BIT_columns": 96, + "C4_columns": 768, + "all_equal": true, + "h": 0 + }, + { + "B": 2, + "BIT_columns": 104, + "C4_columns": 832, + "all_equal": true, + "h": 1 + }, + { + "B": 2, + "BIT_columns": 120, + "C4_columns": 960, + "all_equal": true, + "h": 3 + }, + { + "B": 4, + "BIT_columns": 192, + "C4_columns": 1536, + "all_equal": true, + "h": 0 + }, + { + "B": 4, + "BIT_columns": 200, + "C4_columns": 1600, + "all_equal": true, + "h": 1 + }, + { + "B": 4, + "BIT_columns": 216, + "C4_columns": 1728, + "all_equal": true, + "h": 3 + } + ], + "declared_Git_bindings": 9, + "frozen_count": 26, + "historical_adapter": { + "captured_root_reads": 2, + "compile_dont_inherit": true, + "compile_optimize": 0, + "executed_sha256": "c469db061eca0ed71210da223ee82f41b7b1e2be8deb276158a6a1aed3fd638a", + "original_sha256": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04", + "replacement_count": 3 + }, + "historical_compile_options": { + "dont_inherit": true, + "optimize": 0 + }, + "independent_runtime_dependencies": "Python standard library only", + "no_runtime_Git_network_or_source_path_import": true, + "original_byte_bindings": [ + { + "bytes": 3962, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/DERIVATIVE.md", + "path": "orbit/frozen/history/DERIVATIVE.md", + "sha256": "ab4f11141fa44a87ee542056fbc217cdfe0ac059af4f37f8b1b5c850d14b4399" + }, + { + "bytes": 6520, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/geometry_derivative.py", + "path": "orbit/frozen/history/geometry_derivative.py", + "sha256": "009332a9f7aa35d1e7c529531214c0d428e946041ca7fa9a589f56302144ec04" + }, + { + "bytes": 8966, + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/paired-bit/GEOMETRY-DERIVATIVE.json", + "path": "orbit/frozen/history/GEOMETRY-DERIVATIVE.json", + "sha256": "7ff46e239a8ffdf2d621cf220aba155cbc5cbec94198de8fb15437278b63fb98" + }, + { + "bytes": 33865, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "path": "orbit/frozen/source/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 5439, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/NOTICE.md", + "path": "orbit/frozen/source/NOTICE.md", + "sha256": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a" + }, + { + "bytes": 11357, + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/e8-bit-carrier-skeleton/LICENSE", + "path": "orbit/frozen/source/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ], + "status": "PASS_ORBIT_SOURCE_CLOSURE", + "unchanged_historical_definitions": [ + "canon", + "dot", + "mm", + "need", + "projector", + "rank2", + "rotate" + ] +} diff --git a/research/orbit-closed-call-bound/verify.py b/research/orbit-closed-call-bound/verify.py new file mode 100644 index 0000000000..b5ed9bdb9a --- /dev/null +++ b/research/orbit-closed-call-bound/verify.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +"""Authenticate and replay the orbit-closed call-bound package. + +Ross Richardson with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +import gzip +import hashlib +import json +from pathlib import Path, PurePosixPath +import subprocess +import sys +import tempfile + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def unique_object(pairs): + result = {} + for key, value in pairs: + require(key not in result, "duplicate JSON key: " + key) + result[key] = value + return result + + +def invalid_constant(value): + raise ValueError("nonfinite JSON constant: " + value) + + +def decoded(raw): + return gzip.decompress(raw) if raw.startswith(b"\x1f\x8b") else raw + + +def data(raw): + return json.loads(decoded(raw), object_pairs_hook=unique_object, + parse_constant=invalid_constant) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), + ensure_ascii=False, allow_nan=False) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +class Frozen: + def __init__(self, root): + self.root = Path(root).resolve() + self.hashes = data((self.root / "FROZEN-SHA256.json").read_bytes()) + self.origins = data((self.root / "ORIGINS.json").read_bytes()) + self.compared = [] + + def path(self, name): + parts = PurePosixPath(name) + require(not parts.is_absolute() and ".." not in parts.parts, + "unsafe package path") + path = self.root / name + require(path.is_file() and not path.is_symlink(), "missing regular input: " + name) + require(path.resolve().is_relative_to(self.root), "input escapes package") + return path + + def raw(self, name): + require(name in self.hashes, "unregistered input: " + name) + raw = self.path(name).read_bytes() + require(digest(raw) == self.hashes[name], "changed frozen input: " + name) + return raw + + def check_all(self): + require(set(self.origins) == set(self.hashes), "frozen/origin inventory mismatch") + for name in self.hashes: + raw = self.raw(name) + origin = self.origins[name] + require(origin["sha256"] == digest(raw), "origin digest mismatch: " + name) + if "original_sha256" in origin: + require(digest(decoded(raw)) == origin["original_sha256"], + "original decoded bytes changed: " + name) + + def compare(self, expected, generated): + require(canonical(data(self.raw(expected))) == canonical(data(generated)), + "complete typed record mismatch: " + expected) + self.compared.append(expected) + + def run(self, script, arguments): + source = self.raw(script) + bootstrap = ( + "import sys\n" + "source = sys.stdin.buffer.read()\n" + "sys.argv = sys.argv[1:]\n" + "namespace = {'__name__': '__main__', '__file__': sys.argv[0]}\n" + "exec(compile(source, sys.argv[0], 'exec', dont_inherit=True, optimize=0), namespace)\n" + ) + completed = subprocess.run( + [sys.executable, "-I", "-B", "-c", bootstrap, + str(self.path(script)), *map(str, arguments)], + cwd=self.root, input=source, capture_output=True, check=False) + require(completed.returncode == 0, + "checker failed: " + script + "\n" + + completed.stdout.decode(errors="replace") + + completed.stderr.decode(errors="replace")) + + +STAGES = { + "orbit": ("orbit/check.py", "orbit/CHECKS.json.gz"), + "independent": ("independent/check.py", "independent/CHECKS.json.gz"), +} + + +def expected_records(stage): + return {STAGES[stage][1]} + + +def check_coverage(stage, compared): + expected = expected_records(stage) + require(set(compared) == expected and len(compared) == len(expected), + "complete stage record coverage changed: " + stage) + + +def replay(frozen, scratch, stage): + script, expected = STAGES[stage] + output = scratch / (stage + ".json") + frozen.run(script, ["--output", output]) + frozen.compare(expected, output.read_bytes()) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--stage", required=True, choices=tuple(STAGES)) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + root = Path(__file__).resolve().parent + if args.output is not None: + require(args.output.is_absolute(), "output must be absolute") + require(not args.output.exists(), "output already exists") + require(not args.output.resolve().is_relative_to(root), "output must be external") + frozen = Frozen(root) + frozen.check_all() + with tempfile.TemporaryDirectory(prefix="Orbit call replay ") as directory: + replay(frozen, Path(directory), args.stage) + check_coverage(args.stage, frozen.compared) + frozen.check_all() + result = {"status": "PASS_ORBIT_CALL_" + args.stage.upper(), + "compared": sorted(frozen.compared), + "no_new_kappa": True} + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.output is not None: + with args.output.open("x") as destination: + destination.write(encoded) + print(encoded, end="") + + +if __name__ == "__main__": + main()