From cc8cb58ab4083c1cfd58e0e2eb17c0b2a88070a9 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Sat, 24 Oct 2026 00:30:59 +1100 Subject: [PATCH] Verify a conditional one-native-fusion compiler target --- .../one-fusion-compiler-target/.gitattributes | 2 + .../CAPTURE-BINDINGS.json | 69 + .../one-fusion-compiler-target/EVIDENCE.json | 33 + research/one-fusion-compiler-target/LICENSE | 201 +++ research/one-fusion-compiler-target/NOTICE | 415 ++++++ research/one-fusion-compiler-target/README.md | 133 ++ .../one-fusion-compiler-target/SOURCES.json | 86 ++ research/one-fusion-compiler-target/TASK.json | 100 ++ .../one-fusion-compiler-target/VERIFY.json | 34 + .../evidence/review/FILES.json | 134 ++ .../evidence/review/FREEZE.json | 13 + .../review/INDEPENDENT-OPTIMIZED.json | 65 + .../evidence/review/INDEPENDENT.json | 65 + .../review/MERGE-REPLAY-OPTIMIZED.json | 169 +++ .../evidence/review/MERGE-REPLAY.json | 169 +++ .../review/POINT-REPLAY-OPTIMIZED.json | 186 +++ .../evidence/review/POINT-REPLAY.json | 186 +++ .../evidence/review/REVIEW.md | 86 ++ .../evidence/review/SOURCES.json | 109 ++ .../author/COMPILER-POINT-OPTIMIZED.json | 186 +++ .../review/author/COMPILER-POINT.json | 186 +++ .../evidence/review/author/FREEZE.json | 16 + .../evidence/review/author/REPORT.md | 88 ++ .../review/author/RESULT-OPTIMIZED.json | 169 +++ .../evidence/review/author/RESULT.json | 169 +++ .../evidence/review/author/SOURCES.json | 61 + .../review/author/check_compiler_point.py | 85 ++ .../evidence/review/author/check_merge.py | 138 ++ .../author/frozen/4610-ACTUAL-WORD.json.gz | Bin 0 -> 207673 bytes .../review/author/frozen/4610-ARITHMETIC.json | 241 +++ .../author/frozen/4610-NumericalMoments.lean | 1310 +++++++++++++++++ .../author/frozen/4610-outer-endpoint.py | 240 +++ .../author/frozen/4610-round6-ARITHMETIC.json | 241 +++ .../author/frozen/4610-round6-arithmetic.py | 147 ++ .../review/author/frozen/5226-PROOF.md | 192 +++ .../review/author/frozen/5226-verify.py | 205 +++ .../evidence/review/check_independent.py | 187 +++ research/one-fusion-compiler-target/verify.py | 87 ++ 38 files changed, 6203 insertions(+) create mode 100644 research/one-fusion-compiler-target/.gitattributes create mode 100644 research/one-fusion-compiler-target/CAPTURE-BINDINGS.json create mode 100644 research/one-fusion-compiler-target/EVIDENCE.json create mode 100644 research/one-fusion-compiler-target/LICENSE create mode 100644 research/one-fusion-compiler-target/NOTICE create mode 100644 research/one-fusion-compiler-target/README.md create mode 100644 research/one-fusion-compiler-target/SOURCES.json create mode 100644 research/one-fusion-compiler-target/TASK.json create mode 100644 research/one-fusion-compiler-target/VERIFY.json create mode 100644 research/one-fusion-compiler-target/evidence/review/FILES.json create mode 100644 research/one-fusion-compiler-target/evidence/review/FREEZE.json create mode 100644 research/one-fusion-compiler-target/evidence/review/INDEPENDENT-OPTIMIZED.json create mode 100644 research/one-fusion-compiler-target/evidence/review/INDEPENDENT.json create mode 100644 research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY-OPTIMIZED.json create mode 100644 research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY.json create mode 100644 research/one-fusion-compiler-target/evidence/review/POINT-REPLAY-OPTIMIZED.json create mode 100644 research/one-fusion-compiler-target/evidence/review/POINT-REPLAY.json create mode 100644 research/one-fusion-compiler-target/evidence/review/REVIEW.md create mode 100644 research/one-fusion-compiler-target/evidence/review/SOURCES.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/COMPILER-POINT-OPTIMIZED.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/COMPILER-POINT.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/FREEZE.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/REPORT.md create mode 100644 research/one-fusion-compiler-target/evidence/review/author/RESULT-OPTIMIZED.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/RESULT.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/SOURCES.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/check_compiler_point.py create mode 100644 research/one-fusion-compiler-target/evidence/review/author/check_merge.py create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-ACTUAL-WORD.json.gz create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-ARITHMETIC.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-NumericalMoments.lean create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-outer-endpoint.py create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-ARITHMETIC.json create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-arithmetic.py create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/5226-PROOF.md create mode 100644 research/one-fusion-compiler-target/evidence/review/author/frozen/5226-verify.py create mode 100644 research/one-fusion-compiler-target/evidence/review/check_independent.py create mode 100644 research/one-fusion-compiler-target/verify.py diff --git a/research/one-fusion-compiler-target/.gitattributes b/research/one-fusion-compiler-target/.gitattributes new file mode 100644 index 0000000000..5a037805b0 --- /dev/null +++ b/research/one-fusion-compiler-target/.gitattributes @@ -0,0 +1,2 @@ +# Immutable source capsules retain exact original CRLF/LF and gzip bytes. +evidence/** -text whitespace=cr-at-eol diff --git a/research/one-fusion-compiler-target/CAPTURE-BINDINGS.json b/research/one-fusion-compiler-target/CAPTURE-BINDINGS.json new file mode 100644 index 0000000000..307cfc9d68 --- /dev/null +++ b/research/one-fusion-compiler-target/CAPTURE-BINDINGS.json @@ -0,0 +1,69 @@ +{ + "scope": "All eight original source aliases bound to exact raw Git blobs; no source normalization.", + "files": [ + { + "capture": "evidence/review/author/frozen/4610-ACTUAL-WORD.json.gz", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/4610-ARITHMETIC.json", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round3-warp-20261022/ARITHMETIC.json", + "git_blob": "c89e009ca4a5ad316c69f0371d885d72045ba415", + "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/4610-NumericalMoments.lean", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round3-warp-lean-20261022/NumericalMoments.lean", + "git_blob": "9ca4fe2ebb2733d809f8eb06c3e3b6f03540d75b", + "sha256": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/4610-outer-endpoint.py", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/vendor/outer_endpoint.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/4610-round6-ARITHMETIC.json", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/4610-round6-arithmetic.py", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "git_blob": "12af6aa9377fa0ab84d485a37df0fe59e907e03c", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/5226-PROOF.md", + "commit": "dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40", + "path": "research/fragmentation-ceiling/PROOF.md", + "git_blob": "c4033090d7cd35d9c80744922c587ae115b1de8a", + "sha256": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "capture_equals_raw_git_bytes": true + }, + { + "capture": "evidence/review/author/frozen/5226-verify.py", + "commit": "dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40", + "path": "research/fragmentation-ceiling/verify.py", + "git_blob": "4a676e0397a307f69204765fb0d20dbcf29a5935", + "sha256": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8", + "capture_equals_raw_git_bytes": true + } + ] +} diff --git a/research/one-fusion-compiler-target/EVIDENCE.json b/research/one-fusion-compiler-target/EVIDENCE.json new file mode 100644 index 0000000000..07fcc623d8 --- /dev/null +++ b/research/one-fusion-compiler-target/EVIDENCE.json @@ -0,0 +1,33 @@ +{ + "files": { + "evidence/review/FILES.json": "cbb32ac69f87a4641e9103ca12bb337f4925408eb9ffa221a0475a47b160705d", + "evidence/review/FREEZE.json": "1b320fbdcef7c416cc634d7ceb9580605442046e0e216ccb7118bc9b608eb563", + "evidence/review/INDEPENDENT-OPTIMIZED.json": "c0785cbb98cd48e72636b998ba29d0e9da58793b4028889bcad0df3669ba3a2d", + "evidence/review/INDEPENDENT.json": "c0785cbb98cd48e72636b998ba29d0e9da58793b4028889bcad0df3669ba3a2d", + "evidence/review/MERGE-REPLAY-OPTIMIZED.json": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "evidence/review/MERGE-REPLAY.json": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "evidence/review/POINT-REPLAY-OPTIMIZED.json": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "evidence/review/POINT-REPLAY.json": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "evidence/review/REVIEW.md": "ac0d4444aac62d3c857de1e32c427226dd22202c5525b49005308d0fa11d0759", + "evidence/review/SOURCES.json": "e862cf75a203d137a412ee00ea9d3c0f4366f2b7d7561703c2b86f674ece2a76", + "evidence/review/author/COMPILER-POINT-OPTIMIZED.json": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "evidence/review/author/COMPILER-POINT.json": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "evidence/review/author/FREEZE.json": "3e7d1b73b0a4df34b47b4eee904be205d50256299f3fc97f91fd3c0b2e84e71c", + "evidence/review/author/REPORT.md": "828b0cfa56c550c8024c8b3e0d68c39e2ac1222b5b74200ebfe11e73b3db2413", + "evidence/review/author/RESULT-OPTIMIZED.json": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "evidence/review/author/RESULT.json": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "evidence/review/author/SOURCES.json": "976cf3c5e43f713616a6229635d5e1e6a56ac8b1e3d0cd04d6b0443069958b5b", + "evidence/review/author/check_compiler_point.py": "d11ec44c05c816f54068e6581f05c6c06f6c3dbd3b3c791ef04e540e320b725c", + "evidence/review/author/check_merge.py": "31332d9ef11c8e18f29f33e4d87c419662e4b9a8e6d2544b7f83d5f83217fac7", + "evidence/review/author/frozen/4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "evidence/review/author/frozen/4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "evidence/review/author/frozen/4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "evidence/review/author/frozen/4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "evidence/review/author/frozen/4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "evidence/review/author/frozen/4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "evidence/review/author/frozen/5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "evidence/review/author/frozen/5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8", + "evidence/review/check_independent.py": "e1d856ff0e8c89ae795753ac70733d435b5ca2ce82eef00f0c07bd3b4ebc4061" + }, + "schema_version": 1 +} diff --git a/research/one-fusion-compiler-target/LICENSE b/research/one-fusion-compiler-target/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/one-fusion-compiler-target/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/one-fusion-compiler-target/NOTICE b/research/one-fusion-compiler-target/NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/one-fusion-compiler-target/NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/one-fusion-compiler-target/README.md b/research/one-fusion-compiler-target/README.md new file mode 100644 index 0000000000..74095d20fc --- /dev/null +++ b/research/one-fusion-compiler-target/README.md @@ -0,0 +1,133 @@ +# One native fusion: a conditional compiler construction target + +**No physical pair is supplied and no new κ is admitted.** The reviewed scalar +screen says that one genuine `H1+H1→H2` fusion in **each of 18 native occurrences** +would support the fixed candidate `.0030220` under the retained source, finite, +precision, compiler and outer cost contracts. The complete hypothetical paid +change is exactly `−36 H1+18 H2`; productive targets and rank mass stay fixed. +This is a source-bound verification and construction handoff, not a completed +supplier or a retuning of an unchanged root. +The candidate is above the frozen #4610 value `.0030217758`; the selected +#4470 record `.00302015` is unchanged. No frontier promotion follows here. + +The unchanged [author report](evidence/review/author/REPORT.md), +SHA256 `828b0cfa56c550c8024c8b3e0d68c39e2ac1222b5b74200ebfe11e73b3db2413`, +passes the separate [independent scientific review](evidence/review/REVIEW.md), +SHA256 `ac0d4444aac62d3c857de1e32c427226dd22202c5525b49005308d0fa11d0759`. +The review independently uses a positive-Taylor enclosure engine without +importing the author's interval engine. All original reports, source capsules, +normal/O receipts and freeze metadata are retained unchanged. + +## Fixed profile, point and incidence + +The p16/a7 source has 18 native calls, 15 banks of 112 thin queries, all IDLE +transports and complete targets. Native helpers are 408 independent inputs per +occurrence, credited once; owned centres and query/scratch fields earn no new +productive reward. The unchanged invoice has 10928 productive fields including +7344 helpers, 64404 paid positions and rank-mass surplus 752. + +One source fusion per complete native occurrence removes 36 H1 and adds 18 H2, +so paid positions drop by 18 and paid rank mass is unchanged. This is neither +free deletion of two calls nor a 112-port multiplier. A pair must be legal for +the full all-input/all-port source word in forward and raw inverse-transpose +orientations, reusable at each actual occurrence. Partial incidence must be +repriced literally; the 18 multiplier cannot be assumed for one orientation +or one isolated field experiment. + +At the fixed candidate `.0030220` the raw margin is enclosed by +`[.019920219426956723598947498263,.019920219426956723598947498264]`. +At tested saving `.00302200001`, with reserve `10^-11`, the charged reserve +margin stays positive, about `.01991537426018165`. Strictly negative derivative +bounds prove raw positivity over the complete pre-test interval for this +hypothetical invoice. No root or parameter scan is performed. + +At #5226's larger fixed bar `.0030233`, one fusion per native is insufficient. +Five such fusions per native—90 total—are the least integer incidence of this +specific change giving positive **raw moment** there. That raw sign is not +compiler or physical admission for the larger bar. + +## Conditional compiler and outer checks + +Retain 1024 tensor copies, cutoff/floor 20/21, tail offset 1/5, caps .97 with 128 +blocks, productive maximum rank 145, theta 63/64 and logarithmic power 1000. +The fixed source gap is `1/700000000000`; the inherited sufficient encoded +height `38569300000000000` and exponent 55099 are verified directly, including +failure of the preceding exponent in that particular sufficient inequality. +No height search, compiler word or new uniform construction is emitted. + +The arithmetic checks cover contraction/reserve, both paid completion tails, +splitting/rounding, shifted exits, eta/initial range, and the 54 strict plus +four functional conditions of the retained nine-row pure outer ledger. The +ordinary BIT admitted exponent remains .0034 with its actual .004 atom check; +the inherited .003 stock check remains distinct. Old BIT, closed uniform slack, +epsilon 1 and unfunded-endpoint controls fail as expected. These are conditional +scalar applicability checks, not a universal semantic completeness theorem. + +A literal fusion must keep the native scalar 158168, routing 4802000 and +whole-controller scalar 181098496 upper bounds, or provide replacement bills. +It must preserve coefficients/denominators, fields/lifetimes, owned zeros, +rank-two normalization, every column width, helpers/complements/targets, +raw dual, precision/template and completed-child closure. Actual C1=1 guards, +ordinary BIT/stock/prime interfaces and all outer cost semantics remain open +for the changed implementation. Unknown costs are not zero. + +## Sources, verification and portability + +Publication base: `ff3cc58e370d0f678e529246f8c73e8094e18fcf`, refreshed via the +sole monitor and canonical source fetch; governing guidance/selected record +are unchanged. Source #4610 is `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`; +#5226 is `dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40`. All eight captures match +raw Git blobs at their exact repository paths in [CAPTURE-BINDINGS.json](CAPTURE-BINDINGS.json) +and [SOURCES.json](SOURCES.json). No extra LF or source normalization is used. +The gzip native word is an immutable input; no container is regenerated. + +The static census checks 632 source field histories, GF(2) basis independence, +subspace nesting, forward/backward event chronology and centre/helper counts. +It does **not** evaluate Gaussian amplitudes, absolute phase, scalar-contact +legality, raw-dual operator identity or the native all-input theorem. The +NumericalMoments Lean file is read as source text; Lean is not executed. The +vendored #5226 verifier and round6 generator are reference inputs, not run. +Only the retained pure outer-ledger function and exact scalar checkers execute. + +```sh +python3 -I -W error -B research/one-fusion-compiler-target/verify.py +python3 -I -O -W error -B research/one-fusion-compiler-target/verify.py +python3 -B scripts/research_package.py --package research/one-fusion-compiler-target --check-only +python3 -B scripts/research_package.py --package research/one-fusion-compiler-target +python3 scripts/check_research_commit.py --package research/one-fusion-compiler-target --ref HEAD --check-source-history +``` + +Standard-library CPython 3.12. The wrapper authenticates the 28-file review +packet, including its exact original author tree. Three unchanged scalar +scripts run in private scratch; only that authenticated private author path +is explicitly added for its sibling import under isolated Python. Complete +raw/point/independent receipts must match all frozen normal/O copies. +Package and export bytes remain read-only. No shared 414 helper suite, native, +Tensor, compiler/emitter/Lean campaign, source search or physical pair test runs. + +```sh +python3 scripts/export_research_package.py export --package research/one-fusion-compiler-target --ref HEAD --output /tmp/one-fusion-compiler-target.tar.gz +python3 scripts/export_research_package.py check /tmp/one-fusion-compiler-target.tar.gz +``` + +## Open next questions + +The useful next object is one named literal native pair: exact event positions, +source field/charts, ordered operator/absolute phase proof, full all-input and +both-orientation witness, legal contact transport and actual occurrence count. +Then bind finite routing/scalar/precision bounds and all completed-child/outer +semantics. If any target, field, correction or bill changes, recompute the +profile/guards before using this target. Neither rank labels nor a standalone +Gaussian factorization supplies that object. No pair is selected here. + +## Credit + +DreamingOfClouds supplied #5226's fragmentation organization/fixed bar; +Cao Yifan/intqwq supplied #4610's native profile and compiler tightening; +Cinna Davis/1337isnot1337 supplied retained native/controller work; zxv and +Jacob Alan Sussman supplied paid tensor completion/mixed-job compilation. +Retain Dugongue, dillona, Clear1nsight, SethBurkart123, Ryanson Jonathan and +all native/helper/compiler/precision contributors. Source-bound author review, +separate independent positive-Taylor review and Chris R/Clear1nsight packaging +used substantial OpenAI Codex assistance. Apache-2.0 and original notices +remain included. No independent human or proof-kernel acceptance is claimed. diff --git a/research/one-fusion-compiler-target/SOURCES.json b/research/one-fusion-compiler-target/SOURCES.json new file mode 100644 index 0000000000..676332ef36 --- /dev/null +++ b/research/one-fusion-compiler-target/SOURCES.json @@ -0,0 +1,86 @@ +{ + "schema_version": 1, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05" + }, + { + "path": "research/kappa-round3-warp-20261022/ARITHMETIC.json", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round3-warp-20261022/ARITHMETIC.json", + "git_blob": "c89e009ca4a5ad316c69f0371d885d72045ba415", + "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521" + }, + { + "path": "research/kappa-round3-warp-lean-20261022/NumericalMoments.lean", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round3-warp-lean-20261022/NumericalMoments.lean", + "git_blob": "9ca4fe2ebb2733d809f8eb06c3e3b6f03540d75b", + "sha256": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6" + }, + { + "path": "research/higher-moment-strictification/vendor/outer_endpoint.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/higher-moment-strictification/vendor/outer_endpoint.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "git_blob": "12af6aa9377fa0ab84d485a37df0fe59e907e03c", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38" + }, + { + "path": "research/fragmentation-ceiling/PROOF.md", + "usage": "provenance", + "pin": "head:dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40:research/fragmentation-ceiling/PROOF.md", + "git_blob": "c4033090d7cd35d9c80744922c587ae115b1de8a", + "sha256": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264" + }, + { + "path": "research/fragmentation-ceiling/verify.py", + "usage": "provenance", + "pin": "head:dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40:research/fragmentation-ceiling/verify.py", + "git_blob": "4a676e0397a307f69204765fb0d20dbcf29a5935", + "sha256": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + { + "path": "LICENSE", + "usage": "provenance", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "NOTICE", + "usage": "provenance", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + } + ] +} diff --git a/research/one-fusion-compiler-target/TASK.json b/research/one-fusion-compiler-target/TASK.json new file mode 100644 index 0000000000..1118ae81c0 --- /dev/null +++ b/research/one-fusion-compiler-target/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Source-bound independent verification and construction handoff: one hypothetical legal H1+H1\u2192H2 fusion in every18 retained native occurrences changes the complete profile by\u221236H1+18H2; fixed candidate .0030220 under retained source/compiler/outer cost contracts. No physical pair or admitted kappa.", + "scope_change_reason": "Retarget the independent-moment card to #5226/#4610 and a changed hypothetical paid profile plus one fixed compiler-parameter point, rather than refining an unchanged root. This is a conditional construction target, not a completed supplier.", + "bottleneck_link": "Gives a concrete necessary physical object to seek: one native source pair legal for all inputs/ports and forward/raw inverse-transpose orientations, reusable at actual incidence while preserving finite/precision and semantic guards.", + "budget_minutes": 60, + "stop_rule": "No physical pair search, new native/emitter/compiler/Lean execution, root/parameter optimization, or historical helper suite. Preserve original capsules, independent review and scalar evidence; hold admission until the literal witness and all source-specific obligations exist.", + "outcome": "completed", + "evidence": "README.md; evidence/review/REVIEW.md; evidence/review/FREEZE.json; evidence/review/author/REPORT.md; evidence/review/INDEPENDENT.json; verify.py", + "author": "Chris R / Clear1nsight, with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for source census, rational scalar verification, independent positive-Taylor review and packaging. No independent human, proof-kernel or actual native/compiler acceptance is claimed.", + "open_questions": [ + { + "question": "Can one literal native H1 pair be fused to H2 in both orientations and all18 occurrences without changing any boundary or finite contract?", + "why_it_matters": "The fixed scalar target is positive only for the explicitly changed complete profile; no physical pair has been supplied.", + "first_step": "Name exact event positions, source field/chart word and all-port/all-input phase identity, then price actual incidence, raw dual, helper returns and finite bounds before admission.", + "blocked_by": "Physical pair missing; C1=1, scalar/routing/height/precision, completed-child/template closure, ordinary BIT/stock and outer semantic contracts remain required." + } + ] +} diff --git a/research/one-fusion-compiler-target/VERIFY.json b/research/one-fusion-compiler-target/VERIFY.json new file mode 100644 index 0000000000..bb66554d6f --- /dev/null +++ b/research/one-fusion-compiler-target/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate unchanged author/reviewer/source capsules. Private normal/O replay of static GF2 event census, exact conditional fusion/compiler-point arithmetic and separate positive-Taylor engine; full receipts match originals. No actual pair, native amplitudes/phase/raw-dual identity, compiler execution or kappa admission." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate unchanged author/reviewer/source capsules. Private normal/O replay of static GF2 event census, exact conditional fusion/compiler-point arithmetic and separate positive-Taylor engine; full receipts match originals. No actual pair, native amplitudes/phase/raw-dual identity, compiler execution or kappa admission." + } + ] +} diff --git a/research/one-fusion-compiler-target/evidence/review/FILES.json b/research/one-fusion-compiler-target/evidence/review/FILES.json new file mode 100644 index 0000000000..2ec0546e89 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/FILES.json @@ -0,0 +1,134 @@ +{ + "files": [ + { + "path": "INDEPENDENT-OPTIMIZED.json", + "sha256": "c0785cbb98cd48e72636b998ba29d0e9da58793b4028889bcad0df3669ba3a2d", + "bytes": 2206 + }, + { + "path": "INDEPENDENT.json", + "sha256": "c0785cbb98cd48e72636b998ba29d0e9da58793b4028889bcad0df3669ba3a2d", + "bytes": 2206 + }, + { + "path": "MERGE-REPLAY-OPTIMIZED.json", + "sha256": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "bytes": 4970 + }, + { + "path": "MERGE-REPLAY.json", + "sha256": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "bytes": 4970 + }, + { + "path": "POINT-REPLAY-OPTIMIZED.json", + "sha256": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "bytes": 8509 + }, + { + "path": "POINT-REPLAY.json", + "sha256": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "bytes": 8509 + }, + { + "path": "REVIEW.md", + "sha256": "ac0d4444aac62d3c857de1e32c427226dd22202c5525b49005308d0fa11d0759", + "bytes": 11860 + }, + { + "path": "SOURCES.json", + "sha256": "e862cf75a203d137a412ee00ea9d3c0f4366f2b7d7561703c2b86f674ece2a76", + "bytes": 5009 + }, + { + "path": "author/COMPILER-POINT-OPTIMIZED.json", + "sha256": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "bytes": 8509 + }, + { + "path": "author/COMPILER-POINT.json", + "sha256": "9e1eab9c62a8b1c27340f07d3f9ac95f4f9fcf297907bc02fa275ab08d5adb20", + "bytes": 8509 + }, + { + "path": "author/FREEZE.json", + "sha256": "3e7d1b73b0a4df34b47b4eee904be205d50256299f3fc97f91fd3c0b2e84e71c", + "bytes": 1092 + }, + { + "path": "author/REPORT.md", + "sha256": "828b0cfa56c550c8024c8b3e0d68c39e2ac1222b5b74200ebfe11e73b3db2413", + "bytes": 11446 + }, + { + "path": "author/RESULT-OPTIMIZED.json", + "sha256": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "bytes": 4970 + }, + { + "path": "author/RESULT.json", + "sha256": "c9dfcdfac4a6fab4ae3582267fb030459e5d6c57e217f5364bea905037547645", + "bytes": 4970 + }, + { + "path": "author/SOURCES.json", + "sha256": "976cf3c5e43f713616a6229635d5e1e6a56ac8b1e3d0cd04d6b0443069958b5b", + "bytes": 2780 + }, + { + "path": "author/check_compiler_point.py", + "sha256": "d11ec44c05c816f54068e6581f05c6c06f6c3dbd3b3c791ef04e540e320b725c", + "bytes": 5397 + }, + { + "path": "author/check_merge.py", + "sha256": "31332d9ef11c8e18f29f33e4d87c419662e4b9a8e6d2544b7f83d5f83217fac7", + "bytes": 7352 + }, + { + "path": "author/frozen/4610-ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "bytes": 207673 + }, + { + "path": "author/frozen/4610-ARITHMETIC.json", + "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "bytes": 10009 + }, + { + "path": "author/frozen/4610-NumericalMoments.lean", + "sha256": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "bytes": 89888 + }, + { + "path": "author/frozen/4610-outer-endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "bytes": 11603 + }, + { + "path": "author/frozen/4610-round6-ARITHMETIC.json", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "bytes": 10555 + }, + { + "path": "author/frozen/4610-round6-arithmetic.py", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "bytes": 9113 + }, + { + "path": "author/frozen/5226-PROOF.md", + "sha256": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "bytes": 23169 + }, + { + "path": "author/frozen/5226-verify.py", + "sha256": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8", + "bytes": 10996 + }, + { + "path": "check_independent.py", + "sha256": "e1d856ff0e8c89ae795753ac70733d435b5ca2ce82eef00f0c07bd3b4ebc4061", + "bytes": 7125 + } + ] +} diff --git a/research/one-fusion-compiler-target/evidence/review/FREEZE.json b/research/one-fusion-compiler-target/evidence/review/FREEZE.json new file mode 100644 index 0000000000..aa76d67420 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/FREEZE.json @@ -0,0 +1,13 @@ +{ + "status": "PASS_INDEPENDENT_CONDITIONAL_SCIENTIFIC_REVIEW_NATIVE_ADMISSION_HELD", + "reviewed_author_report_sha256": "828b0cfa56c550c8024c8b3e0d68c39e2ac1222b5b74200ebfe11e73b3db2413", + "reviewed_author_freeze_sha256": "3e7d1b73b0a4df34b47b4eee904be205d50256299f3fc97f91fd3c0b2e84e71c", + "review_sha256": "ac0d4444aac62d3c857de1e32c427226dd22202c5525b49005308d0fa11d0759", + "files_sha256": "cbb32ac69f87a4641e9103ca12bb337f4925408eb9ffa221a0475a47b160705d", + "independent_result_sha256": "c0785cbb98cd48e72636b998ba29d0e9da58793b4028889bcad0df3669ba3a2d", + "source_inputs_verified_unchanged": true, + "normal_optimized_and_author_receipts_match": true, + "independent_normal_optimized_match": true, + "actual_physical_pair_supplied": false, + "scope": "Fixed hypothetical -36H1+18H2 full invoice; kappa candidate.0030220,tested.00302200001,reserve1e-11. Physical all-input/all-port/dual witness, finite bounds, completed-child/compiler/outer semantic applicability remain required. No new kappa admission." +} diff --git a/research/one-fusion-compiler-target/evidence/review/INDEPENDENT-OPTIMIZED.json b/research/one-fusion-compiler-target/evidence/review/INDEPENDENT-OPTIMIZED.json new file mode 100644 index 0000000000..d0c7cb1e14 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/INDEPENDENT-OPTIMIZED.json @@ -0,0 +1,65 @@ +{ + "alpha": { + "lower": "0.999999916072006981295014592357910252", + "upper": "0.999999916072006981295014592357910253" + }, + "controls": { + "deletion_without_rank2_changes_rank_mass": true, + "larger_unfunded_reserve_rejected": true, + "physical_witness_still_absent": true, + "single_occurrence_is_not_18_occurrences": true + }, + "delta": { + "lower": "0.958285429443578784436048541321313050", + "upper": "0.958285429443578784436048541321313051" + }, + "derivative_upper": { + "lower": "-240672.100904695047702951563202913912770409", + "upper": "-240672.100904695047702951563202913912770408" + }, + "eta": { + "lower": "0.000000204301592366054215209950275752", + "upper": "0.000000204301592366054215209950275753" + }, + "finite_capacity": { + "eta_capacity": true, + "height_encoding": true, + "height_wins": true, + "inherited_gap": true, + "initial_range": true, + "normalized_paid": true, + "preceding_exponent_fails": true, + "shifted_exit_capacity": true, + "split_round": true, + "two_tail_blocks": true + }, + "finite_height": 38569300000000000, + "gamma": { + "lower": "0.956229817116094782390067703047433518", + "upper": "0.956229817116094782390067703047433519" + }, + "integer_exponent": 55099, + "kappa_candidate": "1511/500000", + "margin": { + "lower": "0.019917747454957141453179925063616661", + "upper": "0.019917747454957141453179925063616662" + }, + "method": "Positive Taylor exp with positive geometric tail,48-term atanh logs, outward rational1e-60 rounding; no imports from author engines.", + "outer54plus4": "Receipt positive; formulas/source applicability separately reviewed, not a completeness certificate.", + "paid_delta": { + "1": -36, + "2": 18 + }, + "pretest_domain": [ + "0", + "302200001/100000000000" + ], + "reserve": "1/100000000000", + "reserve_margin": { + "lower": "0.019915374260181648837255143954833405", + "upper": "0.019915374260181648837255143954833406" + }, + "scope": "No physical witness, native/Gaussian operator execution, compiler word, Lean, root search or kappa admission.", + "status": "PASS_INDEPENDENT_CONDITIONAL_FIXED_POINT_SCALAR_REVIEW", + "tested": "302200001/100000000000" +} diff --git a/research/one-fusion-compiler-target/evidence/review/INDEPENDENT.json b/research/one-fusion-compiler-target/evidence/review/INDEPENDENT.json new file mode 100644 index 0000000000..d0c7cb1e14 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/INDEPENDENT.json @@ -0,0 +1,65 @@ +{ + "alpha": { + "lower": "0.999999916072006981295014592357910252", + "upper": "0.999999916072006981295014592357910253" + }, + "controls": { + "deletion_without_rank2_changes_rank_mass": true, + "larger_unfunded_reserve_rejected": true, + "physical_witness_still_absent": true, + "single_occurrence_is_not_18_occurrences": true + }, + "delta": { + "lower": "0.958285429443578784436048541321313050", + "upper": "0.958285429443578784436048541321313051" + }, + "derivative_upper": { + "lower": "-240672.100904695047702951563202913912770409", + "upper": "-240672.100904695047702951563202913912770408" + }, + "eta": { + "lower": "0.000000204301592366054215209950275752", + "upper": "0.000000204301592366054215209950275753" + }, + "finite_capacity": { + "eta_capacity": true, + "height_encoding": true, + "height_wins": true, + "inherited_gap": true, + "initial_range": true, + "normalized_paid": true, + "preceding_exponent_fails": true, + "shifted_exit_capacity": true, + "split_round": true, + "two_tail_blocks": true + }, + "finite_height": 38569300000000000, + "gamma": { + "lower": "0.956229817116094782390067703047433518", + "upper": "0.956229817116094782390067703047433519" + }, + "integer_exponent": 55099, + "kappa_candidate": "1511/500000", + "margin": { + "lower": "0.019917747454957141453179925063616661", + "upper": "0.019917747454957141453179925063616662" + }, + "method": "Positive Taylor exp with positive geometric tail,48-term atanh logs, outward rational1e-60 rounding; no imports from author engines.", + "outer54plus4": "Receipt positive; formulas/source applicability separately reviewed, not a completeness certificate.", + "paid_delta": { + "1": -36, + "2": 18 + }, + "pretest_domain": [ + "0", + "302200001/100000000000" + ], + "reserve": "1/100000000000", + "reserve_margin": { + "lower": "0.019915374260181648837255143954833405", + "upper": "0.019915374260181648837255143954833406" + }, + "scope": "No physical witness, native/Gaussian operator execution, compiler word, Lean, root search or kappa admission.", + "status": "PASS_INDEPENDENT_CONDITIONAL_FIXED_POINT_SCALAR_REVIEW", + "tested": "302200001/100000000000" +} diff --git a/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY-OPTIMIZED.json b/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY-OPTIMIZED.json new file mode 100644 index 0000000000..3fbf78efb6 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY-OPTIMIZED.json @@ -0,0 +1,169 @@ +{ + "bar": "30233/10000000", + "baseline_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "controls": { + "centre_retained": true, + "five_per_native_meets_raw_bar": true, + "four_per_native_does_not_meet_bar": true, + "helper_once": true, + "merge_has_no_rank_mass_credit": true, + "single_whole_merge_does_not_meet_bar": true + }, + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "lambda": { + "lower": "23.874626472708570953169540516146", + "upper": "23.874626472708570953169540516147" + }, + "lambda_star": { + "lower": "23.853693275818453744787927482868", + "upper": "23.853693275818453744787927482869" + }, + "method": "rational log atanh40 with geometric tail; alternating exp(-C log r)17/18; outward decimal30 display", + "native_paid_count": 3298, + "native_paid_rank_mass": 5327, + "one_merge_gain": { + "lower": "0.004186795302678511308850275751", + "upper": "0.004186795302678511308850275752" + }, + "one_pair_fixed_lower_bar": { + "first_crossing_and_funding_proved": false, + "margin": { + "lower": "0.019920219426956723598947498263", + "upper": "0.019920219426956723598947498264" + }, + "saving": "1511/500000" + }, + "per_native_gap": { + "lower": "0.020933196890117208381613033277", + "upper": "0.020933196890117208381613033278" + }, + "scenarios": { + "0": { + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.020933196890117208381613033278", + "upper": "-0.020933196890117208381613033277" + }, + "whole_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "whole_paid_H1": 41298, + "whole_paid_H2": 7416, + "whole_paid_count": 64404 + }, + "1": { + "local_paid": { + "1": 2199, + "2": 413, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.016746401587438697072762757527", + "upper": "-0.016746401587438697072762757526" + }, + "whole_margin": { + "lower": "-0.301435228573896547309729635475", + "upper": "-0.301435228573896547309729635474" + }, + "whole_paid_H1": 41262, + "whole_paid_H2": 7434, + "whole_paid_count": 64386 + }, + "4": { + "local_paid": { + "1": 2193, + "2": 416, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.004186015679403163146211930274", + "upper": "-0.004186015679403163146211930273" + }, + "whole_margin": { + "lower": "-0.075348282229256936631814744917", + "upper": "-0.075348282229256936631814744916" + }, + "whole_paid_H1": 41154, + "whole_paid_H2": 7488, + "whole_paid_count": 64332 + }, + "5": { + "local_paid": { + "1": 2191, + "2": 417, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "0.000000779623275348162638345477", + "upper": "0.000000779623275348162638345478" + }, + "whole_margin": { + "lower": "0.000014033218956266927490218602", + "upper": "0.000014033218956266927490218603" + }, + "whole_paid_H1": 41118, + "whole_paid_H2": 7506, + "whole_paid_count": 64314 + } + }, + "scope": "formal unchanged-target profile only; no physical pair, funded compiler, first-crossing sufficiency or kappa admission", + "source_native_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "static_profiles": { + "backward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + }, + "forward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + } + }, + "status": "PASS_STATIC_CENSUS_AND_CONDITIONAL_RAW_PROFILE_ARITHMETIC", + "whole_paid_count": 64404, + "whole_rank_mass_surplus": 752, + "whole_target_count": 10928 +} diff --git a/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY.json b/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY.json new file mode 100644 index 0000000000..3fbf78efb6 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/MERGE-REPLAY.json @@ -0,0 +1,169 @@ +{ + "bar": "30233/10000000", + "baseline_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "controls": { + "centre_retained": true, + "five_per_native_meets_raw_bar": true, + "four_per_native_does_not_meet_bar": true, + "helper_once": true, + "merge_has_no_rank_mass_credit": true, + "single_whole_merge_does_not_meet_bar": true + }, + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "lambda": { + "lower": "23.874626472708570953169540516146", + "upper": "23.874626472708570953169540516147" + }, + "lambda_star": { + "lower": "23.853693275818453744787927482868", + "upper": "23.853693275818453744787927482869" + }, + "method": "rational log atanh40 with geometric tail; alternating exp(-C log r)17/18; outward decimal30 display", + "native_paid_count": 3298, + "native_paid_rank_mass": 5327, + "one_merge_gain": { + "lower": "0.004186795302678511308850275751", + "upper": "0.004186795302678511308850275752" + }, + "one_pair_fixed_lower_bar": { + "first_crossing_and_funding_proved": false, + "margin": { + "lower": "0.019920219426956723598947498263", + "upper": "0.019920219426956723598947498264" + }, + "saving": "1511/500000" + }, + "per_native_gap": { + "lower": "0.020933196890117208381613033277", + "upper": "0.020933196890117208381613033278" + }, + "scenarios": { + "0": { + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.020933196890117208381613033278", + "upper": "-0.020933196890117208381613033277" + }, + "whole_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "whole_paid_H1": 41298, + "whole_paid_H2": 7416, + "whole_paid_count": 64404 + }, + "1": { + "local_paid": { + "1": 2199, + "2": 413, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.016746401587438697072762757527", + "upper": "-0.016746401587438697072762757526" + }, + "whole_margin": { + "lower": "-0.301435228573896547309729635475", + "upper": "-0.301435228573896547309729635474" + }, + "whole_paid_H1": 41262, + "whole_paid_H2": 7434, + "whole_paid_count": 64386 + }, + "4": { + "local_paid": { + "1": 2193, + "2": 416, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.004186015679403163146211930274", + "upper": "-0.004186015679403163146211930273" + }, + "whole_margin": { + "lower": "-0.075348282229256936631814744917", + "upper": "-0.075348282229256936631814744916" + }, + "whole_paid_H1": 41154, + "whole_paid_H2": 7488, + "whole_paid_count": 64332 + }, + "5": { + "local_paid": { + "1": 2191, + "2": 417, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "0.000000779623275348162638345477", + "upper": "0.000000779623275348162638345478" + }, + "whole_margin": { + "lower": "0.000014033218956266927490218602", + "upper": "0.000014033218956266927490218603" + }, + "whole_paid_H1": 41118, + "whole_paid_H2": 7506, + "whole_paid_count": 64314 + } + }, + "scope": "formal unchanged-target profile only; no physical pair, funded compiler, first-crossing sufficiency or kappa admission", + "source_native_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "static_profiles": { + "backward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + }, + "forward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + } + }, + "status": "PASS_STATIC_CENSUS_AND_CONDITIONAL_RAW_PROFILE_ARITHMETIC", + "whole_paid_count": 64404, + "whole_rank_mass_surplus": 752, + "whole_target_count": 10928 +} diff --git a/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY-OPTIMIZED.json b/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY-OPTIMIZED.json new file mode 100644 index 0000000000..9472449b23 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY-OPTIMIZED.json @@ -0,0 +1,186 @@ +{ + "alpha": { + "lower": "0.999999916072006981295014592357", + "upper": "0.999999916072006981295014592358" + }, + "capacity": { + "completion_tail_block": true, + "eta_above_theta_power": true, + "height_encoding": true, + "initial_range": true, + "normalized_paid_below_one": true, + "paid_tail_block": true, + "predecessor_integer_fails": true, + "same_gap": true, + "shifted_exits": true, + "split_and_round": true, + "uniform_integer_wins": true + }, + "compiler_executed": false, + "conditions": [ + "actual all-port all-input forward/raw-dual native fusion with unchanged targets", + "unchanged native scalar/routing/denominator/precision/template closure bounds or separately rebilled replacements", + "unchanged whole-job completed-child and spectator contracts", + "admitted uniform complex supplier at stated saving; inherited ordinary BIT/stock interface", + "same nine outer cost formulas and semantic C1=1 premises" + ], + "controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "delta": { + "lower": "0.958285429443578784436048541321", + "upper": "0.958285429443578784436048541322" + }, + "derivative_domain": [ + "0", + "302200001/100000000000" + ], + "eta": { + "lower": "0.000000204301592366054215209950", + "upper": "0.000000204301592366054215209951" + }, + "finite_height": 38569300000000000, + "gamma": { + "lower": "0.956229817116094782390067703047", + "upper": "0.956229817116094782390067703048" + }, + "gap": "1/700000000000", + "kappa": "1511/500000", + "margin": { + "lower": "0.019917747454957141453179925063", + "upper": "0.019917747454957141453179925064" + }, + "normalized_paid_upper": "104857600097656251/104857601073741824", + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1480780002797884599997/490000000000000000000000", + "fused_gaussian": "1480780002793653799991/490000000000000000000000", + "global_coordinate_router": "528850001/175000000000", + "group_bit_router": "370195000873413449997/122500000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "1480780002097884599997/490000000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "200543280002797884599997/490000000000000000000000" + }, + "parameters": { + "a": "528850001/175000000000", + "b": "423080001/140000000000", + "beta": "699999999997/700000000000", + "bit_saving": "17/5000", + "cap_xi": "445543280002097884599997/490000000000000000000000", + "complex_uniform_saving": "1057700003/350000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "1511/500000", + "lambda_": "199395599999/200000000000", + "lambda_prime": "697884599997/700000000000", + "layout": "1/700000000000", + "q": "2115400003/700000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "302200001/100000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "66149999/175000000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "44456719998952115400003/245000000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "2797884599997/490000000000000000000000", + "cap_above_band": "200543280002097884599997/490000000000000000000000", + "cap_below_cell": "44456719997202115400003/490000000000000000000000", + "cap_below_phase_cell_power": "534456719997902115400003/490000000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "3951919999/140000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793653799991/490000000000000000000000", + "gaussian_above_main": "347884599997/245000000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "873413449997/122500000000000000000000", + "group_gauge_power_slack": "44456719998917115400003/245000000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "348942299999/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645514790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "279576919999/98000000000000000000000", + "leaf_saving_above_effective": "139576919999/98000000000000000000000", + "main_transform_above_kappa": "2097884599997/490000000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "13474471150001/175000000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "697884599999/700000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "279576919999/98000000000000000000000", + "q_positive": "2115400003/700000000000", + "short_record_fallback": "139576919999/140000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "199062500002797884599997/490000000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "physical_witness_supplied": false, + "positive_entire_pretest_interval": true, + "reserve_margin_M_minus_T_1e11": { + "lower": "0.019915374260181648837255143954", + "upper": "0.019915374260181648837255143955" + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "status": "PASS_CONDITIONAL_ONE_FUSION_FIXED_COMPILER_PARAMETER_SCREEN", + "tested": "302200001/100000000000", + "uniform_derivative_upper": "-240672.100904695047702951563202913912" +} diff --git a/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY.json b/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY.json new file mode 100644 index 0000000000..9472449b23 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/POINT-REPLAY.json @@ -0,0 +1,186 @@ +{ + "alpha": { + "lower": "0.999999916072006981295014592357", + "upper": "0.999999916072006981295014592358" + }, + "capacity": { + "completion_tail_block": true, + "eta_above_theta_power": true, + "height_encoding": true, + "initial_range": true, + "normalized_paid_below_one": true, + "paid_tail_block": true, + "predecessor_integer_fails": true, + "same_gap": true, + "shifted_exits": true, + "split_and_round": true, + "uniform_integer_wins": true + }, + "compiler_executed": false, + "conditions": [ + "actual all-port all-input forward/raw-dual native fusion with unchanged targets", + "unchanged native scalar/routing/denominator/precision/template closure bounds or separately rebilled replacements", + "unchanged whole-job completed-child and spectator contracts", + "admitted uniform complex supplier at stated saving; inherited ordinary BIT/stock interface", + "same nine outer cost formulas and semantic C1=1 premises" + ], + "controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "delta": { + "lower": "0.958285429443578784436048541321", + "upper": "0.958285429443578784436048541322" + }, + "derivative_domain": [ + "0", + "302200001/100000000000" + ], + "eta": { + "lower": "0.000000204301592366054215209950", + "upper": "0.000000204301592366054215209951" + }, + "finite_height": 38569300000000000, + "gamma": { + "lower": "0.956229817116094782390067703047", + "upper": "0.956229817116094782390067703048" + }, + "gap": "1/700000000000", + "kappa": "1511/500000", + "margin": { + "lower": "0.019917747454957141453179925063", + "upper": "0.019917747454957141453179925064" + }, + "normalized_paid_upper": "104857600097656251/104857601073741824", + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1480780002797884599997/490000000000000000000000", + "fused_gaussian": "1480780002793653799991/490000000000000000000000", + "global_coordinate_router": "528850001/175000000000", + "group_bit_router": "370195000873413449997/122500000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "1480780002097884599997/490000000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "200543280002797884599997/490000000000000000000000" + }, + "parameters": { + "a": "528850001/175000000000", + "b": "423080001/140000000000", + "beta": "699999999997/700000000000", + "bit_saving": "17/5000", + "cap_xi": "445543280002097884599997/490000000000000000000000", + "complex_uniform_saving": "1057700003/350000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "1511/500000", + "lambda_": "199395599999/200000000000", + "lambda_prime": "697884599997/700000000000", + "layout": "1/700000000000", + "q": "2115400003/700000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "302200001/100000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "66149999/175000000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "44456719998952115400003/245000000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "2797884599997/490000000000000000000000", + "cap_above_band": "200543280002097884599997/490000000000000000000000", + "cap_below_cell": "44456719997202115400003/490000000000000000000000", + "cap_below_phase_cell_power": "534456719997902115400003/490000000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "3951919999/140000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793653799991/490000000000000000000000", + "gaussian_above_main": "347884599997/245000000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "873413449997/122500000000000000000000", + "group_gauge_power_slack": "44456719998917115400003/245000000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "348942299999/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645514790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "279576919999/98000000000000000000000", + "leaf_saving_above_effective": "139576919999/98000000000000000000000", + "main_transform_above_kappa": "2097884599997/490000000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "13474471150001/175000000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "697884599999/700000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "279576919999/98000000000000000000000", + "q_positive": "2115400003/700000000000", + "short_record_fallback": "139576919999/140000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "199062500002797884599997/490000000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "physical_witness_supplied": false, + "positive_entire_pretest_interval": true, + "reserve_margin_M_minus_T_1e11": { + "lower": "0.019915374260181648837255143954", + "upper": "0.019915374260181648837255143955" + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "status": "PASS_CONDITIONAL_ONE_FUSION_FIXED_COMPILER_PARAMETER_SCREEN", + "tested": "302200001/100000000000", + "uniform_derivative_upper": "-240672.100904695047702951563202913912" +} diff --git a/research/one-fusion-compiler-target/evidence/review/REVIEW.md b/research/one-fusion-compiler-target/evidence/review/REVIEW.md new file mode 100644 index 0000000000..cfd5212426 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/REVIEW.md @@ -0,0 +1,86 @@ +# Independent review of the conditional one-native-fusion budget gate + +**PASS for the frozen conditional source/profile arithmetic and fixed compiler-parameter screen. Actual native and compiler admission remains on HOLD.** One genuinely legal `1+1 -> 2` fusion in every one of the 18 retained native occurrences is a useful construction target at candidate saving `.0030220`. The packet supplies no physical pair, changed emitted native program, or new kappa result. + +Reviewed report SHA256: `828b0cfa56c550c8024c8b3e0d68c39e2ac1222b5b74200ebfe11e73b3db2413`. Author FREEZE SHA256: `3e7d1b73b0a4df34b47b4eee904be205d50256299f3fc97f91fd3c0b2e84e71c`. Exact author files are captured under `author/`; `SOURCES.json` binds every byte. Scientific sources remain #5226 head `dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40` and #4610 head `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`. No author or predecessor file was edited. + +## 1. Source binding and incidence are correct + +The eight retained source payloads match both their declared SHA256 hashes and their raw Git blob IDs, reconstructed locally as SHA1 of `blob NUL `. This authenticates the captured bytes against the declared object identities; upstream reachability and the monitor's acquisition remain inherited records. No Git fetch or second upstream intake was performed. + +The two retained #4610 arithmetic capsules agree exactly on local helpers, local paid jobs, whole targets and whole paid jobs. The literal NumericalMoments definitions also bind the whole polynomial through the replayed source checker. The native profile is + +`N={1:2201,2:412,3:510,4:127,5:40,8:8}`; + +the productive helper profile is `H={4:28,7:7,8:47,9:326}`. The eight H8 centres are paid jobs, not productive fields. The controller invoice has 18 native calls, 15 banks of 112 H1 thin queries, and the retained IDLE transports and main targets. It has 10,928 productive fields, including 7,344 helpers credited once; 64,404 paid positions; target rank mass 239,886 and paid rank mass 239,134. + +One fusion per native changes the **local** paid profile by `-2H1+H2` and the whole paid profile by `-36H1+18H2`. This preserves paid rank mass and reduces paid positions by 18. Its moment saving is exactly `18*(2-2^(1-C))`. It is not a free deletion, one pair in the whole caller, or a credit for a dependent query/centre output. + +At the larger #5226 bar `.0030233`, four such fusions per native fail and five pass the raw sign; linear dependence on their integer incidence makes five the minimum for that specific bar. That does not imply that five are needed for every smaller improvement. The one-fusion fixed point below is a different, explicitly conditional target. + +## 2. The static event census is properly scoped + +The replay checks both retained forward and backward event lists, 632 original field histories, 224 main net ranks of 8, the 408 helper residual ranks, 3,290 climbs, 240 dimension-preserving warps and eight centre events. For each climb it verifies current-frame chronology, independence of the two listed GF(2) bases, and actual subspace containment, rather than only the dimension gap. Each field's cumulative climb rank telescopes to its declared final frame. + +These checks establish a static GF(2) frame/event census. They do **not** validate Gaussian phases, absolute normalizations, scalar contacts, eligibility of a pair, the centre operators, or the all-input raw inverse transpose. The report states this limitation and does not import #5226's verifier, grid scan, Lean declarations or other source searches as independently executed evidence. + +The identity `phi=-232*8^(1-C)-Lambda` is normalized correctly: 224 net-up main fields plus eight paid centre jobs produce the factor 232. This is neither a count of all fields nor a substitution of helper rank mass. The p16/a7 threshold and `M=18 phi+Gamma` agree with the complete polynomial. The broader all-controller or arbitrary coded-adapter claims are not needed for the accepted fixed-point screen. + +## 3. Both outward interval methods are valid + +The author's integer logarithm encloses a range-reduced atanh series with 40 positive terms and the upper remainder + +`2*z^81 / (81*(1-z^2))`, for `0<=z<=1/3`. + +The denominator bound is valid term by term. Powers `r^(1-C)=r*exp(-C log r)` use the odd/even alternating Taylor polynomials of degree 17/18 on an explicitly checked interval below `.02`, giving lower/upper bounds in the correct order. Subtractions use opposite endpoints and displayed decimals use directed floor/ceiling, including negative numbers. The compiler-point engine range-reduces larger exponential arguments, squares positive enclosures with outward rounding, and uses reciprocal intervals for positive exponential arguments. Its divisions have positive denominators. No floating-point rounding assumption is needed. + +For a separate check, `check_independent.py` imports no author interval engine. It uses a 48-term positive atanh logarithm enclosure and a **positive** exponential Taylor series with a geometric bound on its remaining positive tail, range reduction, reciprocal intervals and outward rational rounding at `10^-60`. Its independently computed tested margin, alpha, gamma, delta and eta enclosures lie entirely inside the author's displayed enclosures. This is a cross-check of elementary-function arithmetic, not a compiler or native replay. + +## 4. Reserve, derivative and fixed compiler parameters pass + +The fixed parameters are candidate `k=.0030220`, tested `k+10^-11=.00302200001`, and alpha reserve `10^-11`. The candidate exceeds the frozen developed comparison `.0030217758`; the old baseline embedded in the inherited ledger is not substituted for that comparison. + +Independent outward enclosures include: + +| Quantity | Independent enclosure | +|---|---| +| Tested M | `[.019917747454957141453179925063616661, .019917747454957141453179925063616662]` | +| Tested `M-10^-11*T` | `[.019915374260181648837255143954833405, .019915374260181648837255143954833406]` | +| alpha | `[.999999916072006981295014592357910252, .999999916072006981295014592357910253]` | +| gamma | `[.956229817116094782390067703047433518, .956229817116094782390067703047433519]` | +| delta | `[.958285429443578784436048541321313050, .958285429443578784436048541321313051]` | +| eta | `[.000000204301592366054215209950275752, .000000204301592366054215209950275753]` | + +The derivative bound has the correct sign and domain. Since each nonnegative logarithmic moment decreases with C, + +`M'(C) <= sum_P r log r - sum_T r^(1-tested) log r` + +throughout `[0,tested]`. Independent outward arithmetic gives an upper bound below `-240672.100904695047702951563202913912770408`. Thus the complete raw moment is decreasing on that interval and its positive tested value proves positivity on the whole pre-test interval. This does not assert global single crossing or rely on the source's 1,000-point S1 grid. + +The reserve comparison is equivalent to `alpha<1-10^-11`. Retained gamma and delta are both below `.97` with the same cutoff/floor 20/21, offset 1/5 and 1,024 tensor copies. Separate exact checks validate the paid normalization and rounding allowance, `20^64<21^63`, both 128-block tail inequalities, shifted exits, eta versus `(63/64)^1000`, and the initial range. The maximum productive rank remains 145. + +The gap remains `1/700000000000`. The source sufficient height is correctly encoded by `H=38569300000000000=(700000000000)*55099`. Direct integer substitution validates the sufficient winning inequality at exponent 55,099 and its failure at the preceding exponent. This is verification of the retained sufficient bound, not a new height search, a claim of global minimum height, or a materialized compiler word. + +## 5. The 54+4 ledger checks are conditional applicability arithmetic + +Inspection of the frozen round6 arithmetic and pure ledger confirms the same parameter order `k.0030217758` is explicit; the source ledger's older baseline is not substituted for it. + +These54+4 positives are arithmetic applicability checks under the same nine outer cost formulas. They are not a universal completeness certificate or an admission of a changed supplier. COMPILER-POINT.json retains every exact outer rational and condition. + +## Concrete admission target and invalid imports + +The next useful object is **one literal eligible native pair**, not more raw-root digits. It must replace two rank-one positions on the same evolving field by a rank-two transport with the same ordered operator, absolute phase and normalization, preserving intervening scalar contacts or proving a fully priced legal commutation. A matching pair of rank labels or a standalone Gaussian factorization is insufficient. + +The witness must cover all632 original arbitrary inputs and all ports, both forward and raw inverse-transpose orientations, all helper/complement returns once, all final frames and spectators. It must show that the18 retained native occurrences can use it without changed boundaries. If only some occurrences or one orientation can use it, price their actual incidence; the18 multiplier is then unavailable. No cross-call fusion is established by the symbolic controller inventory. + +To turn the fixed scalar screen into funded transfer, prove the emitted change stays within the existing local scalar158168, routing4802000 and whole-controller scalar upper181098496 bounds, or supply replacement bounds. Preserve actual coefficients and denominators, field lifetimes, owned zero work, rank-two normalization, all-column lifting, source-complement splitting, productive completion and completed-child precision/template closure. The existing C1=1 semantic guards, ordinary BIT admission/row stock and all outer interfaces must actually apply. A larger raw moment cannot waive these source-specific premises. If the new implementation adds fields, scalar contacts, precision losses, paid rank corrections or changes the source endpoint, recompute the affected profile and guards before using this result. + +#5226's general threshold is scoped to its kap unit(112,8), controller family and eight H8 centres. This review directly checks p16/a7, not its exhaustive all-p controller maximum, Lean declarations, unshipped source searches or other PRs' physical endpoints. The PR's grid S1 is not a proof of global single crossing. Its nonnested-path and arbitrary-centre statements must retain their stated hypotheses. + +In particular, A30-CUT and the coded-centre repair bounds remain conditional on P-ATOM, DELIV (or its transverse variant), mains net-up, and the further owned-carrier/fixed-main-chain conditions where used. They do not price arbitrary decoders, direct-X access, changed contacts, query shears, warp-riding carriers, deliveries at meeting frames or broader common-frame network coding. This review supplies no universal centre optimality or coded-family impossibility claim and does not import source-only counts as newly verified facts. + +## Reproduction, coverage and credit + +Run `python3 -B check_merge.py` and `python3 -B check_compiler_point.py` from this folder, with `-O -B` variants for optimized Python. Normal/optimized JSON agrees byte-for-byte. The checks include actual subspace nesting, orientation counts, public polynomial binding, zero/four/five fusion signs, single-whole-invoice versus per-native incidence, rank-mass conservation, centre retention, helper credit once, full pre-test monotonicity and four outer rejection controls. They perform no native numerical evaluation. + +Credit DreamingOfClouds for the fragmentation-loss organization and fixed-bar target; Cao Yifan/intqwq for #4610 and its changed native profile/compiler tightening; Cinna Davis for the native/controller lineage; zxv and Jacob Alan Sussman for paid tensor completion and mixed-job compilation; and Dugongue, dillona, Clear1nsight and SethBurkart123 for the distinct coded mechanisms discussed by #5226. The prior source-bound compiler obligation map remains unchanged. Substantial OpenAI Codex assistance. All new files are local and scoped; no external post or shared-source edit occurred. diff --git a/research/one-fusion-compiler-target/evidence/review/author/RESULT-OPTIMIZED.json b/research/one-fusion-compiler-target/evidence/review/author/RESULT-OPTIMIZED.json new file mode 100644 index 0000000000..3fbf78efb6 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/RESULT-OPTIMIZED.json @@ -0,0 +1,169 @@ +{ + "bar": "30233/10000000", + "baseline_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "controls": { + "centre_retained": true, + "five_per_native_meets_raw_bar": true, + "four_per_native_does_not_meet_bar": true, + "helper_once": true, + "merge_has_no_rank_mass_credit": true, + "single_whole_merge_does_not_meet_bar": true + }, + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "lambda": { + "lower": "23.874626472708570953169540516146", + "upper": "23.874626472708570953169540516147" + }, + "lambda_star": { + "lower": "23.853693275818453744787927482868", + "upper": "23.853693275818453744787927482869" + }, + "method": "rational log atanh40 with geometric tail; alternating exp(-C log r)17/18; outward decimal30 display", + "native_paid_count": 3298, + "native_paid_rank_mass": 5327, + "one_merge_gain": { + "lower": "0.004186795302678511308850275751", + "upper": "0.004186795302678511308850275752" + }, + "one_pair_fixed_lower_bar": { + "first_crossing_and_funding_proved": false, + "margin": { + "lower": "0.019920219426956723598947498263", + "upper": "0.019920219426956723598947498264" + }, + "saving": "1511/500000" + }, + "per_native_gap": { + "lower": "0.020933196890117208381613033277", + "upper": "0.020933196890117208381613033278" + }, + "scenarios": { + "0": { + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.020933196890117208381613033278", + "upper": "-0.020933196890117208381613033277" + }, + "whole_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "whole_paid_H1": 41298, + "whole_paid_H2": 7416, + "whole_paid_count": 64404 + }, + "1": { + "local_paid": { + "1": 2199, + "2": 413, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.016746401587438697072762757527", + "upper": "-0.016746401587438697072762757526" + }, + "whole_margin": { + "lower": "-0.301435228573896547309729635475", + "upper": "-0.301435228573896547309729635474" + }, + "whole_paid_H1": 41262, + "whole_paid_H2": 7434, + "whole_paid_count": 64386 + }, + "4": { + "local_paid": { + "1": 2193, + "2": 416, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.004186015679403163146211930274", + "upper": "-0.004186015679403163146211930273" + }, + "whole_margin": { + "lower": "-0.075348282229256936631814744917", + "upper": "-0.075348282229256936631814744916" + }, + "whole_paid_H1": 41154, + "whole_paid_H2": 7488, + "whole_paid_count": 64332 + }, + "5": { + "local_paid": { + "1": 2191, + "2": 417, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "0.000000779623275348162638345477", + "upper": "0.000000779623275348162638345478" + }, + "whole_margin": { + "lower": "0.000014033218956266927490218602", + "upper": "0.000014033218956266927490218603" + }, + "whole_paid_H1": 41118, + "whole_paid_H2": 7506, + "whole_paid_count": 64314 + } + }, + "scope": "formal unchanged-target profile only; no physical pair, funded compiler, first-crossing sufficiency or kappa admission", + "source_native_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "static_profiles": { + "backward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + }, + "forward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + } + }, + "status": "PASS_STATIC_CENSUS_AND_CONDITIONAL_RAW_PROFILE_ARITHMETIC", + "whole_paid_count": 64404, + "whole_rank_mass_surplus": 752, + "whole_target_count": 10928 +} diff --git a/research/one-fusion-compiler-target/evidence/review/author/RESULT.json b/research/one-fusion-compiler-target/evidence/review/author/RESULT.json new file mode 100644 index 0000000000..3fbf78efb6 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/RESULT.json @@ -0,0 +1,169 @@ +{ + "bar": "30233/10000000", + "baseline_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "controls": { + "centre_retained": true, + "five_per_native_meets_raw_bar": true, + "four_per_native_does_not_meet_bar": true, + "helper_once": true, + "merge_has_no_rank_mass_credit": true, + "single_whole_merge_does_not_meet_bar": true + }, + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "lambda": { + "lower": "23.874626472708570953169540516146", + "upper": "23.874626472708570953169540516147" + }, + "lambda_star": { + "lower": "23.853693275818453744787927482868", + "upper": "23.853693275818453744787927482869" + }, + "method": "rational log atanh40 with geometric tail; alternating exp(-C log r)17/18; outward decimal30 display", + "native_paid_count": 3298, + "native_paid_rank_mass": 5327, + "one_merge_gain": { + "lower": "0.004186795302678511308850275751", + "upper": "0.004186795302678511308850275752" + }, + "one_pair_fixed_lower_bar": { + "first_crossing_and_funding_proved": false, + "margin": { + "lower": "0.019920219426956723598947498263", + "upper": "0.019920219426956723598947498264" + }, + "saving": "1511/500000" + }, + "per_native_gap": { + "lower": "0.020933196890117208381613033277", + "upper": "0.020933196890117208381613033278" + }, + "scenarios": { + "0": { + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.020933196890117208381613033278", + "upper": "-0.020933196890117208381613033277" + }, + "whole_margin": { + "lower": "-0.376797544022109750869034598994", + "upper": "-0.376797544022109750869034598993" + }, + "whole_paid_H1": 41298, + "whole_paid_H2": 7416, + "whole_paid_count": 64404 + }, + "1": { + "local_paid": { + "1": 2199, + "2": 413, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.016746401587438697072762757527", + "upper": "-0.016746401587438697072762757526" + }, + "whole_margin": { + "lower": "-0.301435228573896547309729635475", + "upper": "-0.301435228573896547309729635474" + }, + "whole_paid_H1": 41262, + "whole_paid_H2": 7434, + "whole_paid_count": 64386 + }, + "4": { + "local_paid": { + "1": 2193, + "2": 416, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "-0.004186015679403163146211930274", + "upper": "-0.004186015679403163146211930273" + }, + "whole_margin": { + "lower": "-0.075348282229256936631814744917", + "upper": "-0.075348282229256936631814744916" + }, + "whole_paid_H1": 41154, + "whole_paid_H2": 7488, + "whole_paid_count": 64332 + }, + "5": { + "local_paid": { + "1": 2191, + "2": 417, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "per_native_residual_gain": { + "lower": "0.000000779623275348162638345477", + "upper": "0.000000779623275348162638345478" + }, + "whole_margin": { + "lower": "0.000014033218956266927490218602", + "upper": "0.000014033218956266927490218603" + }, + "whole_paid_H1": 41118, + "whole_paid_H2": 7506, + "whole_paid_count": 64314 + } + }, + "scope": "formal unchanged-target profile only; no physical pair, funded compiler, first-crossing sufficiency or kappa admission", + "source_native_profile": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "source_sha256": { + "4610-ACTUAL-WORD.json.gz": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "4610-ARITHMETIC.json": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "4610-NumericalMoments.lean": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "4610-outer-endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "4610-round6-ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "4610-round6-arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "5226-PROOF.md": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "5226-verify.py": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8" + }, + "static_profiles": { + "backward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + }, + "forward": { + "centres": 8, + "climbs": 3290, + "warps": 240 + } + }, + "status": "PASS_STATIC_CENSUS_AND_CONDITIONAL_RAW_PROFILE_ARITHMETIC", + "whole_paid_count": 64404, + "whole_rank_mass_surplus": 752, + "whole_target_count": 10928 +} diff --git a/research/one-fusion-compiler-target/evidence/review/author/SOURCES.json b/research/one-fusion-compiler-target/evidence/review/author/SOURCES.json new file mode 100644 index 0000000000..03ef2742d1 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/SOURCES.json @@ -0,0 +1,61 @@ +{ + "scope": "read-only source capsules; upstream #5226 proof via sole monitor; #5226 verifier and #4610 numeric definitions by pinned GET; native word read from local Git object; round6 arithmetic and pure ledger from prior authenticated capsule", + "files": [ + { + "file": "4610-ACTUAL-WORD.json.gz", + "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05", + "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "expected_git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "4610-ARITHMETIC.json", + "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521", + "git_blob": "c89e009ca4a5ad316c69f0371d885d72045ba415", + "expected_git_blob": "c89e009ca4a5ad316c69f0371d885d72045ba415", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "4610-NumericalMoments.lean", + "sha256": "e2841986fd6e6c4cc60cfe40f58a25f87a7be3bba5f89307d8a10082e48c66e6", + "git_blob": "9ca4fe2ebb2733d809f8eb06c3e3b6f03540d75b", + "expected_git_blob": "9ca4fe2ebb2733d809f8eb06c3e3b6f03540d75b", + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "4610-outer-endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "expected_git_blob": null, + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "4610-round6-ARITHMETIC.json", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "expected_git_blob": null, + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "4610-round6-arithmetic.py", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "git_blob": "12af6aa9377fa0ab84d485a37df0fe59e907e03c", + "expected_git_blob": null, + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296" + }, + { + "file": "5226-PROOF.md", + "sha256": "28be45a551ed8491be1ebb8c64acba2834aaa402452cb02e3c71c83e49232264", + "git_blob": "c4033090d7cd35d9c80744922c587ae115b1de8a", + "expected_git_blob": "c4033090d7cd35d9c80744922c587ae115b1de8a", + "commit": "dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40" + }, + { + "file": "5226-verify.py", + "sha256": "913e37958011f7dd926aa671eede8058f716a4c7723e24bd8c621a93da9930d8", + "git_blob": "4a676e0397a307f69204765fb0d20dbcf29a5935", + "expected_git_blob": "4a676e0397a307f69204765fb0d20dbcf29a5935", + "commit": "dc5764630fdf34f72bbe76efd4b79d3b2bc3dd40" + } + ] +} diff --git a/research/one-fusion-compiler-target/evidence/review/author/check_compiler_point.py b/research/one-fusion-compiler-target/evidence/review/author/check_compiler_point.py new file mode 100644 index 0000000000..9ba99f1f47 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/check_compiler_point.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python3 +"""One fixed conditional scalar screen; no compiler/emitter/native run. +Uses the retained outer ledger formulas only; applicability remains conditional. +""" +from check_merge import Q,HERE,F,need,moment,interval,sub,scale,logint,alt,power +from hashlib import sha256 +import json,runpy + +GRID=10**50 +def down(x):return Q((x*GRID).__floor__(),GRID) +def up(x):return Q((x*GRID).__ceil__(),GRID) +def expone(x): + if x>0: + a,b=expone(-x);return down(1/b),up(1/a) + x=-x;n=0 + while x>=Q(1,50):x/=2;n+=1 + a,b=down(alt(x,17)),up(alt(x,18)) + for _ in range(n):a,b=down(a*a),up(b*b) + return a,b +def rp(r,t): + a,b=sorted(t*x for x in logint(r)) + return expone(a)[0],expone(b)[1] +def mom(h,t): + return tuple(sum((n*rp(r,t)[i] for r,n in h.items()),Q(0)) for i in (0,1)) +def divide(a,b):return a[0]/b[1],a[1]/b[0] +def main(): + A=json.loads((F/'4610-round6-ARITHMETIC.json').read_text()) + T={int(k):n for k,n in A['targets'].items()};P={int(k):n for k,n in A['paid'].items()} + P[1]-=36;P[2]+=18 + k=Q('.0030220');tested=k+Q(1,10**11);gap=(tested-k)/7 + need(k>Q('.0030217758') and testedtheta**1000, + 'initial_range':rp(145,1024*tested)[1]<2**1000} + # Source gap unchanged: verify its frozen integer sufficient height directly. + step=gap.denominator;j=A['compiler']['integer_test_exponent'];height=A['compiler']['H'] + capacity.update({'same_gap':gap==Q(A['compiler']['gap']), + 'height_encoding':height==step*j and height>8*1024, + 'uniform_integer_wins':(step*j+1)**1000<2**j, + 'predecessor_integer_fails':(step*(j-1)+1)**1000>=2**(j-1)}) + need(all(capacity.values()),'finite sufficient scalar capacity') + params={'kappa':k,'tested_saving':tested,'complex_uniform_saving':k+6*gap, + 'b':k+5*gap,'a':k+4*gap,'q':k+3*gap,'bit_saving':Q('.0034'), + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + ledger=runpy.run_path(str(F/'4610-outer-endpoint.py'))['ledger'] + outer=ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-Q('.004')) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'literal source inventory') + need(all(v>0 for g in ('strict_checks','functional_checks') for v in outer[g].values()),'all outer arithmetic positive') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}), + ('closed_epsilon',{'epsilon':Q(1)}),('unfunded_endpoint',{'kappa':tested})]: + bad=ledger(dict(params,**patch));failed=[n for n,v in bad['strict_checks'].items() if v<=0] + need(failed,'reject unsupported '+name);controls[name]=failed + result={'status':'PASS_CONDITIONAL_ONE_FUSION_FIXED_COMPILER_PARAMETER_SCREEN', + 'physical_witness_supplied':False,'compiler_executed':False,'kappa':str(k),'tested':str(tested),'gap':str(gap), + 'margin':interval(sub(target,paid)),'reserve_margin_M_minus_T_1e11':interval(sub(scale(target,1-alpha_gap),paid)), + 'derivative_domain':['0',str(tested)],'uniform_derivative_upper':interval((derivative_upper,derivative_upper))['upper'], + 'positive_entire_pretest_interval':True, + 'alpha':interval(alpha),'gamma':interval(gamma),'delta':interval(delta),'eta':interval(eta), + 'normalized_paid_upper':str(normalized),'capacity':capacity,'finite_height':height, + 'outer':outer,'controls':controls, + 'conditions':['actual all-port all-input forward/raw-dual native fusion with unchanged targets', + 'unchanged native scalar/routing/denominator/precision/template closure bounds or separately rebilled replacements', + 'unchanged whole-job completed-child and spectator contracts', + 'admitted uniform complex supplier at stated saving; inherited ordinary BIT/stock interface', + 'same nine outer cost formulas and semantic C1=1 premises'], + 'source_sha256':{p.name:sha256(p.read_bytes()).hexdigest() for p in sorted(F.iterdir()) if p.is_file()}} + print(json.dumps(result,indent=2,sort_keys=True,default=str)) +if __name__=='__main__':main() diff --git a/research/one-fusion-compiler-target/evidence/review/author/check_merge.py b/research/one-fusion-compiler-target/evidence/review/author/check_merge.py new file mode 100644 index 0000000000..402aa10576 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/check_merge.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python3 +"""Static source census and exact rational interval check, no native evaluation. +Prepared with substantial OpenAI Codex assistance; preserves Cao Yifan/#4610 +and DreamingOfClouds/#5226 attribution. No root extraction or compiler replay. +""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from hashlib import sha256, sha1 +from pathlib import Path +import gzip, json, re + +HERE=Path(__file__).resolve().parent +F=HERE/'frozen' +def need(x, why): + if not x: raise ValueError(why) +def logsmall(z): + need(0<=z<=Q(1,3),'log reduced domain') + n=40 + s=sum((2*z**(2*j+1)/(2*j+1) for j in range(n)),Q(0)) + return s,s+2*z**(2*n+1)/((2*n+1)*(1-z*z)) +def logint(r): + k=r.bit_length()-1;x=Q(r,2**k) + a,b=logsmall((x-1)/(x+1));c,d=logsmall(Q(1,3)) + return a+k*c,b+k*d +def alt(x,n): + need(0<=x0,'climb chronology') + need(rank(E)==len(E) and rank(G)==len(G) and rank(E+G)==len(G),'actual nested subspaces') + jobs[f].append(r);cur[f]=b + elif e[0]=='warp': + f=e[1][1];a,b=e[3:5] + need(cur[f]==a and len(frames[a])==len(frames[b]),'warp dimensions') + cur[f]=b;warps+=1 + elif e[0]=='center':centres+=1 + need(cur==c['final'] and all(sum(jobs[f])==R[f] for f in range(nf)),'endpoint telescoping') + h=Counter(r for js in jobs.values() for r in js);h[8]+=centres + need(h==Counter(N) and centres==8 and warps==240,'exact local paid census') + profile_results[direction]={'climbs':sum(len(js) for js in jobs.values()),'centres':centres,'warps':warps} + C=Q('.0030233') + base=sub(moment(T,C),moment(P,C)) + phi=sub(moment(H,C),moment(N,C)) + lam=sub(scale(power(8,C),-232),phi) + # Gamma=full invoice minus18phi; Lambda*=Gamma/18-232*8^t. + gamma=sub(base,scale(phi,18)) + star=sub(scale(gamma,Q(1,18)),scale(power(8,C),232)) + gain=sub((Q(2),Q(2)),power(2,C)) + gap=sub(lam,star) + scenarios={} + for m in (0,1,4,5): + n=N.copy();n[1]-=2*m;n[2]+=m + paid=P.copy();paid[1]-=36*m;paid[2]+=18*m + result=sub(moment(T,C),moment(paid,C)) + predicted=add(base,scale(gain,18*m)) + need(max(result[0],predicted[0])<=min(result[1],predicted[1]),'independent delta agreement') + need(result[1]<0 if m<5 else result[0]>0,'one/four fail and five pass raw bar') + need(sum(r*x for r,x in paid.items())==sum(r*x for r,x in P.items()),'paid rank mass unchanged') + scenarios[str(m)]={'local_paid':n,'whole_paid_H1':paid[1],'whole_paid_H2':paid[2], + 'whole_paid_count':sum(paid.values()),'whole_margin':interval(result), + 'per_native_residual_gain':interval(add(scale(gain,m),scale(gap,-1)))} + one_whole=add(base,gain) + need(one_whole[1]<0,'a single merge in whole caller also fails') + lower_bar=Q('.003022') + one_paid=P.copy();one_paid[1]-=36;one_paid[2]+=18 + one_lower=sub(moment(T,lower_bar),moment(one_paid,lower_bar)) + need(one_lower[0]>0,'one repeated pair does improve raw sign at a fixed smaller bar') + # Negative controls distinguish wrong counting and free deletion from merging. + controls={'single_whole_merge_does_not_meet_bar':one_whole[1]<0, + 'four_per_native_does_not_meet_bar':Q(scenarios['4']['whole_margin']['upper'])<0, + 'five_per_native_meets_raw_bar':Q(scenarios['5']['whole_margin']['lower'])>0, + 'merge_has_no_rank_mass_credit':sum(r*n for r,n in N.items())==sum(r*n for r,n in scenarios['1']['local_paid'].items()), + 'centre_retained':scenarios['5']['local_paid'][8]==8, + 'helper_once':sum(T.values())==10928 and 18*sum(H.values())==7344} + need(all(controls.values()),'controls') + out={'status':'PASS_STATIC_CENSUS_AND_CONDITIONAL_RAW_PROFILE_ARITHMETIC', + 'bar':str(C),'source_native_profile':N,'helpers':H,'native_paid_count':sum(N.values()), + 'native_paid_rank_mass':sum(r*n for r,n in N.items()),'whole_target_count':sum(T.values()), + 'whole_paid_count':sum(P.values()),'whole_rank_mass_surplus':sum(r*n for r,n in T.items())-sum(r*n for r,n in P.items()), + 'static_profiles':profile_results,'baseline_margin':interval(base),'lambda':interval(lam),'lambda_star':interval(star), + 'per_native_gap':interval(gap),'one_merge_gain':interval(gain),'scenarios':scenarios,'controls':controls, + 'one_pair_fixed_lower_bar':{'saving':str(lower_bar),'margin':interval(one_lower),'first_crossing_and_funding_proved':False}, + 'method':'rational log atanh40 with geometric tail; alternating exp(-C log r)17/18; outward decimal30 display', + 'scope':'formal unchanged-target profile only; no physical pair, funded compiler, first-crossing sufficiency or kappa admission', + 'source_sha256':{p.name:sha256(p.read_bytes()).hexdigest() for p in sorted(F.iterdir()) if p.is_file()}} + print(json.dumps(out,indent=2,sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-ACTUAL-WORD.json.gz b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-ACTUAL-WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..46d929df83817b85a5387bcdb9745e0627d6366e GIT binary patch literal 207673 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%0An&u`Csb3RV8)-*z=ghBCmu|` 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%0A}m#BC$*!P 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

2VZSP}KItK@?5y|8|LhfHIf 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

$ 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 x`NPMb-+jFN^26gF|LMc;zrXwN{ih%Q`2F1 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999253/175000000000", + "fixed_halo_explicit_metadata_branch": "13475000001/175000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899997009/700000000000", + "new_semantic_group_guard": "3/700000000" + }, + "margins": { + "boundary_algebraic_matrix": "296133039576953/98000000000000000", + "fused_gaussian": "296133038730859/98000000000000000", + "global_coordinate_router": "528809/175000000", + "group_bit_router": "370166473413573/122500000000000000", + "group_scans": "349999999/350000000", + "main_transform": "296132899576953/98000000000000000", + "microbox_face_corrections": "13475000001/175000000", + "polynomial_products": "699999999/700000000", + "sparse_union_movement": "40108633039576953/98000000000000000" + }, + "parameters": { + "a": "528809/175000000", + "b": "2115237/700000000", + "beta": "699999997/700000000", + "bit_saving": "17/5000", + "cap_xi": "89108632899576953/98000000000000000", + "complex_uniform_saving": "1057619/350000000", + "d": "1/700000000", + "epsilon": "699999999/700000000", + "kappa": "9443/3125000", + "lambda_": "199395647/200000000", + "lambda_prime": "139576953/140000000", + "layout": "1/700000000", + "q": "423047/140000000", + "r0": "1/7000000000", + "stop": "1/700000000", + "tested_saving": "302177/100000000" + }, + "strict_checks": { + "actual_bit_above_effective": "66191/175000000", + "actual_logarithmic_gamma_guard": "1/700000000", + "actual_logarithmic_group_guard": "8891367310423047/49000000000000000", + "alpha_logarithm_absorption": "1/7000000000", + "boundary_algebraic_matrix_above_kappa": "559576953/98000000000000000", + "cap_above_band": "40108632899576953/98000000000000000", + "cap_below_cell": "8891366960423047/98000000000000000", + "cap_below_phase_cell_power": "106891367100423047/98000000000000000", + "complex_above_effective": "1/700000000", + "complex_below_one_over_32": "19759763/700000000", + "complex_endpoint": "1/350000000", + "epsilon_below_one": "1/700000000", + "epsilon_positive": "699999999/700000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "558730859/98000000000000000", + "gaussian_above_main": "69576953/49000000000000000", + "global_coordinate_router_above_kappa": "1/175000000", + "global_gamma_power_slack": "9/7000000000", + "group_below_dimension": "1/350000000", + "group_bit_router_above_kappa": "873413573/122500000000000000", + "group_gauge_power_slack": "8891367303423047/49000000000000000", + "group_key_fits_record": "1/350000000", + "group_positive": "699999997/700000000", + "group_scans_above_kappa": "348942383/350000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645394790400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000", + "lambda_above_sigma": "3/1400000000", + "lambda_above_tau": "1/1400000000", + "lambda_prime_above_lambda": "1/1400000000", + "lambda_prime_above_leaf": "1397884763/490000000000000000", + "leaf_saving_above_effective": "697884763/490000000000000000", + "main_transform_above_kappa": "419576953/98000000000000000", + "membership_arithmetic_fits_record": "1/700000000", + "microbox_face_corrections_above_kappa": "13474471193/175000000", + "microbox_halo_volume": "55300000003/700000000", + "new_complex_uniform_saving_above_b": "1/700000000", + "new_semantic_guard_with_C1_one": "1/700000000", + "polynomial_products_above_kappa": "697884767/700000000", + "positive_layout_slack": "1/700000000", + "q_below_effective": "1/700000000", + "q_below_internal": "1/700000000", + "q_below_leaf": "1397884763/490000000000000000", + "q_positive": "423047/140000000", + "short_record_fallback": "697884763/700000000", + "source_axis_superpolynomial": "1/700000000", + "sparse_union_movement_above_kappa": "39812500559576953/98000000000000000", + "stop_below_one": "699999999/700000000", + "stop_positive": "1/700000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000", + "union_tag_work_per_visit_fits_record": "3/700000000" + } + }, + "paid": { + "1": 41298, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64404, + "productive_fields": 10928, + "rank_mass_surplus": 752, + "raw_root_interval": [ + "15108879/5000000000", + "30217759/10000000000" + ], + "scope": "Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.", + "source_sha256": { + "research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/joint-helper-lattice/CONTROLLER.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "research/joint-helper-lattice/verify.py": "8eb13f77a94315f811612cb557a17edeecb6b9d9a75dfa238b112dd6520c336f", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-interface-round2-20261022/price_profile.py": "adde619968d3ac37147d239e25145b28150650e9ce0f76035f680f22589adcbb", + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/query-thinned-controllers/RESULT.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "research/query-thinned-controllers/controller.py": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2" + }, + "status": "PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE", + "strictification": { + "alpha": { + "lower": "0.999999993884252622740095906769", + "upper": "0.999999993884252622740095906770" + }, + "cutoff": 20, + "delta": { + "lower": "0.958285305508943939401236992035", + "upper": "0.958285305508943939401236992036" + }, + "floor": 21, + "gamma": { + "lower": "0.956217506703714253758457710273", + "upper": "0.956217506703714253758457710274" + }, + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "302177/100000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5868 + } +} diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-NumericalMoments.lean b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-NumericalMoments.lean new file mode 100644 index 0000000000..9ca4fe2ebb --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-NumericalMoments.lean @@ -0,0 +1,1310 @@ +/- Scoped real-rpow contraction and tail proof for the literal finite profiles. +Generated by numerical_generate.py. Apache-2.0; substantial OpenAI Codex assistance. +The native extraction and full compiler transfer are separate obligations. -/ +import Mathlib.Analysis.SpecialFunctions.Log.Deriv +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Data.Complex.ExponentialBounds +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.Ring +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +namespace NumericalMoments + +lemma log_2 : (6931471803 / 10000000000 : ℝ) ≤ Real.log 2 ∧ Real.log 2 ≤ (108304247 / 156250000 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 1 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_3 : (137326536051 / 125000000000 : ℝ) ≤ Real.log 3 ∧ Real.log 3 ≤ (1098612288909 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 3 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 3 : ℝ) = (2 : ℝ) ^ 1 / 3 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 3 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_4 : (6931471803 / 5000000000 : ℝ) ≤ Real.log 4 ∧ Real.log 4 ≤ (108304247 / 78125000 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 2 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_5 : (804718955957 / 500000000000 : ℝ) ≤ Real.log 5 ∧ Real.log 5 ≤ (321887582583 / 200000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 5 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 5 : ℝ) = (2 : ℝ) ^ 2 / 5 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 5 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_7 : (389182029707 / 200000000000 : ℝ) ≤ Real.log 7 ∧ Real.log 7 ≤ (60809692173 / 31250000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (3 / 7 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (3 / 7 : ℝ) = (2 : ℝ) ^ 2 / 7 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (3 / 7 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_8 : (20794415409 / 10000000000 : ℝ) ≤ Real.log 8 ∧ Real.log 8 ≤ (324912741 / 156250000 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 3 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_9 : (549306144139 / 250000000000 : ℝ) ≤ Real.log 9 ∧ Real.log 9 ≤ (2197224578057 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 9 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 9 : ℝ) = (2 : ℝ) ^ 3 / 9 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 9 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_16 : (6931471803 / 2500000000 : ℝ) ≤ Real.log 16 ∧ Real.log 16 ≤ (108304247 / 39062500 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 4 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_17 : (354151667877 / 125000000000 : ℝ) ≤ Real.log 17 ∧ Real.log 17 ≤ (2833213345017 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 17 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 17 : ℝ) = (2 : ℝ) ^ 4 / 17 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 17 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_20 : (1497866136257 / 500000000000 : ℝ) ≤ Real.log 20 ∧ Real.log 20 ≤ (599146454903 / 200000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 5 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 5 : ℝ) = (2 : ℝ) ^ 4 / 20 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 5 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_24 : (794513457327 / 250000000000 : ℝ) ≤ Real.log 24 ∧ Real.log 24 ≤ (3178053831309 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 3 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 3 : ℝ) = (2 : ℝ) ^ 4 / 24 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 3 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_25 : (804718955957 / 250000000000 : ℝ) ≤ Real.log 25 ∧ Real.log 25 ≤ (3218875825829 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (9 / 25 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (9 / 25 : ℝ) = (2 : ℝ) ^ 4 / 25 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (9 / 25 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_32 : (6931471803 / 2000000000 : ℝ) ≤ Real.log 32 ∧ Real.log 32 ≤ (108304247 / 31250000 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 5 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_33 : (1748253780083 / 500000000000 : ℝ) ≤ Real.log 33 ∧ Real.log 33 ≤ (3496507562667 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 33 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 33 : ℝ) = (2 : ℝ) ^ 5 / 33 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 33 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_40 : (1844439726407 / 500000000000 : ℝ) ≤ Real.log 40 ∧ Real.log 40 ≤ (737775891063 / 200000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 5 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 5 : ℝ) = (2 : ℝ) ^ 5 / 40 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 5 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_41 : (928393016351 / 250000000000 : ℝ) ≤ Real.log 41 ∧ Real.log 41 ≤ (742714413581 / 200000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (9 / 41 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (9 / 41 : ℝ) = (2 : ℝ) ^ 5 / 41 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (9 / 41 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_48 : (483900126201 / 125000000000 : ℝ) ≤ Real.log 48 ∧ Real.log 48 ≤ (3871201012109 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 3 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 3 : ℝ) = (2 : ℝ) ^ 5 / 48 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 3 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_49 : (389182029681 / 100000000000 : ℝ) ≤ Real.log 49 ∧ Real.log 49 ≤ (3891820299311 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (17 / 49 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (17 / 49 : ℝ) = (2 : ℝ) ^ 5 / 49 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (17 / 49 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_56 : (805070337887 / 200000000000 : ℝ) ≤ Real.log 56 ∧ Real.log 56 ≤ (125792240373 / 31250000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (3 / 7 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (3 / 7 : ℝ) = (2 : ℝ) ^ 5 / 56 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (3 / 7 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_57 : (2021525633267 / 500000000000 : ℝ) ≤ Real.log 57 ∧ Real.log 57 ≤ (808610253807 / 200000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (25 / 57 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (25 / 57 : ℝ) = (2 : ℝ) ^ 5 / 57 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (25 / 57 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_64 : (20794415409 / 5000000000 : ℝ) ≤ Real.log 64 ∧ Real.log 64 ≤ (324912741 / 78125000 : ℝ) := by + have h := Real.log_pow (2 : ℝ) 6 + norm_num at h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_65 : (834877453667 / 200000000000 : ℝ) ≤ Real.log 65 ∧ Real.log 65 ≤ (521798408917 / 125000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 65 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 65 : ℝ) = (2 : ℝ) ^ 6 / 65 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 65 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_72 : (267291632341 / 62500000000 : ℝ) ≤ Real.log 72 ∧ Real.log 72 ≤ (4276666120457 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (1 / 9 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (1 / 9 : ℝ) = (2 : ℝ) ^ 6 / 72 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (1 / 9 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_73 : (1072614859897 / 250000000000 : ℝ) ≤ Real.log 73 ∧ Real.log 73 ≤ (4290459442589 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (9 / 73 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (9 / 73 : ℝ) = (2 : ℝ) ^ 6 / 73 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (9 / 73 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma log_145 : (24883668703 / 5000000000 : ℝ) ≤ Real.log 145 ∧ Real.log 145 ≤ (4976733744101 / 1000000000000 : ℝ) := by + have h := Real.abs_log_sub_add_sum_range_le (x := (17 / 145 : ℝ)) + (by apply abs_lt.mpr; constructor <;> norm_num) 40 + rw [show 1 - (17 / 145 : ℝ) = (2 : ℝ) ^ 7 / 145 by norm_num, + Real.log_div (by norm_num) (by norm_num), Real.log_pow] at h + norm_num [Finset.sum_range_succ, abs_of_nonneg (show 0 ≤ (17 / 145 : ℝ) by norm_num)] at h + have h' := abs_le.mp h + constructor <;> linarith [Real.log_two_gt_d9, Real.log_two_lt_d9] + +lemma moment_2 : (997907660643131 / 500000000000000 : ℝ) ≤ (2 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (2 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (124738457580641 / 62500000000000 : ℝ) := by + have hl := log_2 + have hxlo : (-2094531357 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 2 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 2 ≤ (-418906271 / 200000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-2094531357 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-418906271 / 200000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (997907660643131 / 1000000000000000 : ℝ) ≤ Real.exp (-2094531357 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-2094531357 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-418906271 / 200000000000 : ℝ) ≤ (124738457580641 / 125000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-418906271 / 200000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (2 : ℝ) ^ (99697823 / 100000000 : ℝ) = 2 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 2) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 2 * (99697823 / 100000000 : ℝ) = Real.log 2 + (-302177 / 100000000 : ℝ) * Real.log 2 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_3 : (119602290075903 / 40000000000000 : ℝ) ≤ (3 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (3 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (747514312976637 / 250000000000000 : ℝ) := by + have hl := log_3 + have hxlo : (-3319753657 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 3 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 3 ≤ (-1659876827 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-3319753657 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-1659876827 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (39867430025301 / 40000000000000 : ℝ) ≤ Real.exp (-3319753657 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-3319753657 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-1659876827 / 500000000000 : ℝ) ≤ (249171437658879 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1659876827 / 500000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (3 : ℝ) ^ (99697823 / 100000000 : ℝ) = 3 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 3) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 3 * (99697823 / 100000000 : ℝ) = Real.log 3 + (-302177 / 100000000 : ℝ) * Real.log 3 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_4 : (497909849585123 / 125000000000000 : ℝ) ≤ (4 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (4 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (995819699174231 / 250000000000000 : ℝ) := by + have hl := log_4 + have hxlo : (-2094531357 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 4 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 4 ≤ (-418906271 / 100000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-2094531357 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-418906271 / 100000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (497909849585123 / 500000000000000 : ℝ) ≤ Real.exp (-2094531357 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-2094531357 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-418906271 / 100000000000 : ℝ) ≤ (995819699174231 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-418906271 / 100000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (4 : ℝ) ^ (99697823 / 100000000 : ℝ) = 4 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 4) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 4 * (99697823 / 100000000 : ℝ) = Real.log 4 + (-302177 / 100000000 : ℝ) * Real.log 4 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_5 : (248787113935317 / 50000000000000 : ℝ) ≤ (5 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (5 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (995148455745249 / 200000000000000 : ℝ) := by + have hl := log_5 + have hxlo : (-4863351203 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 5 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 5 ≤ (-4863351199 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-4863351203 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-4863351199 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (248787113935317 / 250000000000000 : ℝ) ≤ Real.exp (-4863351203 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-4863351203 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-4863351199 / 1000000000000 : ℝ) ≤ (995148455745249 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-4863351199 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (5 : ℝ) ^ (99697823 / 100000000 : ℝ) = 5 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 5) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 5 * (99697823 / 100000000 : ℝ) = Real.log 5 + (-302177 / 100000000 : ℝ) * Real.log 5 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_7 : (6958960126989969 / 1000000000000000 : ℝ) ≤ (7 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (7 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (434935007938613 / 62500000000000 : ℝ) := by + have hl := log_7 + have hxlo : (-5880092913 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 7 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 7 ≤ (-5880092909 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-5880092913 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-5880092909 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (994137160998567 / 1000000000000000 : ℝ) ≤ Real.exp (-5880092913 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5880092913 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-5880092909 / 1000000000000 : ℝ) ≤ (62133572562659 / 62500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5880092909 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (7 : ℝ) ^ (99697823 / 100000000 : ℝ) = 7 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 7) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 7 * (99697823 / 100000000 : ℝ) = Real.log 7 + (-302177 / 100000000 : ℝ) * Real.log 7 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_8 : (993736106422321 / 125000000000000 : ℝ) ≤ (8 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (8 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (993736106427291 / 125000000000000 : ℝ) := by + have hl := log_8 + have hxlo : (-628359407 / 100000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 8 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 8 ≤ (-1256718813 / 200000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-628359407 / 100000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-1256718813 / 200000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (993736106422321 / 1000000000000000 : ℝ) ≤ Real.exp (-628359407 / 100000000000 : ℝ) := by + rw [abs_of_nonpos (show (-628359407 / 100000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-1256718813 / 200000000000 : ℝ) ≤ (993736106427291 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1256718813 / 200000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (8 : ℝ) ^ (99697823 / 100000000 : ℝ) = 8 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 8) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 8 * (99697823 / 100000000 : ℝ) = Real.log 8 + (-302177 / 100000000 : ℝ) * Real.log 8 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_9 : (27938882405079 / 3125000000000 : ℝ) ≤ (9 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (9 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (8940442369678929 / 1000000000000000 : ℝ) := by + have hl := log_9 + have hxlo : (-3319753657 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 9 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 9 ≤ (-1659876827 / 250000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-3319753657 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-1659876827 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (3104320267231 / 3125000000000 : ℝ) ≤ Real.exp (-3319753657 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-3319753657 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-1659876827 / 250000000000 : ℝ) ≤ (993382485519881 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1659876827 / 250000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (9 : ℝ) ^ (99697823 / 100000000 : ℝ) = 9 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 9) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 9 * (99697823 / 100000000 : ℝ) = Real.log 9 + (-302177 / 100000000 : ℝ) * Real.log 9 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_16 : (15494638644633 / 976562500000 : ℝ) ≤ (16 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (16 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (198331374652691 / 12500000000000 : ℝ) := by + have hl := log_16 + have hxlo : (-8378125427 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 16 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 16 ≤ (-418906271 / 50000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-8378125427 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-418906271 / 50000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (15494638644633 / 15625000000000 : ℝ) ≤ Real.exp (-8378125427 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-8378125427 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-418906271 / 50000000000 : ℝ) ≤ (198331374652691 / 200000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-418906271 / 50000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (16 : ℝ) ^ (99697823 / 100000000 : ℝ) = 16 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 16) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 16 * (99697823 / 100000000 : ℝ) = Real.log 16 + (-302177 / 100000000 : ℝ) * Real.log 16 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_17 : (16855078818886919 / 1000000000000000 : ℝ) ≤ (17 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (17 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (4213769704751229 / 250000000000000 : ℝ) := by + have hl := log_17 + have hxlo : (-856131909 / 100000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 17 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 17 ≤ (-8561319083 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-856131909 / 100000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-8561319083 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (991475224640407 / 1000000000000000 : ℝ) ≤ Real.exp (-856131909 / 100000000000 : ℝ) := by + rw [abs_of_nonpos (show (-856131909 / 100000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-8561319083 / 1000000000000 : ℝ) ≤ (247868806161837 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-8561319083 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (17 : ℝ) ^ (99697823 / 100000000 : ℝ) = 17 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 17) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 17 * (99697823 / 100000000 : ℝ) = Real.log 17 + (-302177 / 100000000 : ℝ) * Real.log 17 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_20 : (247747108956749 / 12500000000000 : ℝ) ≤ (20 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (20 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (495494217916967 / 25000000000000 : ℝ) := by + have hl := log_20 + have hxlo : (-2263103479 / 250000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 20 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 20 ≤ (-9052413909 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-2263103479 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-9052413909 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (247747108956749 / 250000000000000 : ℝ) ≤ Real.exp (-2263103479 / 250000000000 : ℝ) := by + rw [abs_of_nonpos (show (-2263103479 / 250000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-9052413909 / 1000000000000 : ℝ) ≤ (495494217916967 / 500000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-9052413909 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (20 : ℝ) ^ (99697823 / 100000000 : ℝ) = 20 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 20) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 20 * (99697823 / 100000000 : ℝ) = Real.log 20 + (-302177 / 100000000 : ℝ) * Real.log 20 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_24 : (742831962870873 / 31250000000000 : ℝ) ≤ (24 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (24 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (2971327851504297 / 125000000000000 : ℝ) := by + have hl := log_24 + have hxlo : (-4801673863 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 24 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 24 ≤ (-9603347719 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-4801673863 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-9603347719 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (247610654290291 / 250000000000000 : ℝ) ≤ Real.exp (-4801673863 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-4801673863 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-9603347719 / 1000000000000 : ℝ) ≤ (990442617168099 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-9603347719 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (24 : ℝ) ^ (99697823 / 100000000 : ℝ) = 24 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 24) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 24 * (99697823 / 100000000 : ℝ) = Real.log 24 + (-302177 / 100000000 : ℝ) * Real.log 24 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_25 : (990320448965221 / 40000000000000 : ℝ) ≤ (25 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (25 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (495160224486077 / 20000000000000 : ℝ) := by + have hl := log_25 + have hxlo : (-1945340481 / 200000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 25 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 25 ≤ (-4863351199 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-1945340481 / 200000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-4863351199 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (990320448965221 / 1000000000000000 : ℝ) ≤ Real.exp (-1945340481 / 200000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1945340481 / 200000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-4863351199 / 500000000000 : ℝ) ≤ (495160224486077 / 500000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-4863351199 / 500000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (25 : ℝ) ^ (99697823 / 100000000 : ℝ) = 25 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 25) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 25 * (99697823 / 100000000 : ℝ) = Real.log 25 + (-302177 / 100000000 : ℝ) * Real.log 25 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_32 : (494790995276539 / 15625000000000 : ℝ) ≤ (32 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (32 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (247395497640249 / 7812500000000 : ℝ) := by + have hl := log_32 + have hxlo : (-10472656783 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 32 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 32 ≤ (-418906271 / 40000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-10472656783 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-418906271 / 40000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (494790995276539 / 500000000000000 : ℝ) ≤ Real.exp (-10472656783 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-10472656783 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-418906271 / 40000000000 : ℝ) ≤ (247395497640249 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-418906271 / 40000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (32 : ℝ) ^ (99697823 / 100000000 : ℝ) = 32 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 32) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 32 * (99697823 / 100000000 : ℝ) = Real.log 32 + (-302177 / 100000000 : ℝ) * Real.log 32 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_33 : (32653169296219131 / 1000000000000000 : ℝ) ≤ (33 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (33 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (4081646162060049 / 125000000000000 : ℝ) := by + have hl := log_33 + have hxlo : (-5282820829 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 33 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 33 ≤ (-211312833 / 20000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-5282820829 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-211312833 / 20000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (989489978673307 / 1000000000000000 : ℝ) ≤ Real.exp (-5282820829 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5282820829 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-211312833 / 20000000000 : ℝ) ≤ (123686247335153 / 125000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-211312833 / 20000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (33 : ℝ) ^ (99697823 / 100000000 : ℝ) = 33 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 33) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 33 * (99697823 / 100000000 : ℝ) = Real.log 33 + (-302177 / 100000000 : ℝ) * Real.log 33 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_40 : (494457475860751 / 12500000000000 : ℝ) ≤ (40 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (40 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (197782990345883 / 5000000000000 : ℝ) := by + have hl := log_40 + have hxlo : (-1393368159 / 125000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 40 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 40 ≤ (-696684079 / 62500000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-1393368159 / 125000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-696684079 / 62500000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (494457475860751 / 500000000000000 : ℝ) ≤ Real.exp (-1393368159 / 125000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1393368159 / 125000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-696684079 / 62500000000 : ℝ) ≤ (197782990345883 / 200000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-696684079 / 62500000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (40 : ℝ) ^ (99697823 / 100000000 : ℝ) = 40 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 40) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 40 * (99697823 / 100000000 : ℝ) = Real.log 40 + (-302177 / 100000000 : ℝ) * Real.log 40 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_41 : (10135621953484113 / 250000000000000 : ℝ) ≤ (41 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (41 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (10135621953565211 / 250000000000000 : ℝ) := by + have hl := log_41 + have hxlo : (-2805390167 / 250000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 41 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 41 ≤ (-561078033 / 50000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-2805390167 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-561078033 / 50000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (247210291548393 / 250000000000000 : ℝ) ≤ Real.exp (-2805390167 / 250000000000 : ℝ) := by + rw [abs_of_nonpos (show (-2805390167 / 250000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-561078033 / 50000000000 : ℝ) ≤ (247210291550371 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-561078033 / 50000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (41 : ℝ) ^ (99697823 / 100000000 : ℝ) = 41 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 41) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 41 * (99697823 / 100000000 : ℝ) = Real.log 41 + (-302177 / 100000000 : ℝ) * Real.log 41 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_48 : (1482555412638837 / 31250000000000 : ℝ) ≤ (48 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (48 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (1482555412652181 / 31250000000000 : ℝ) := by + have hl := log_48 + have hxlo : (-11697879083 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 48 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 48 ≤ (-5848939537 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-11697879083 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-5848939537 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (494185137546279 / 500000000000000 : ℝ) ≤ Real.exp (-11697879083 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-11697879083 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-5848939537 / 500000000000 : ℝ) ≤ (494185137550727 / 500000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5848939537 / 500000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (48 : ℝ) ^ (99697823 / 100000000 : ℝ) = 48 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 48) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 48 * (99697823 / 100000000 : ℝ) = Real.log 48 + (-302177 / 100000000 : ℝ) * Real.log 48 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_49 : (4842712604903621 / 100000000000000 : ℝ) ≤ (49 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (49 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (24213563024711851 / 500000000000000 : ℝ) := by + have hl := log_49 + have hxlo : (-5880092913 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 49 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 49 ≤ (-5880092909 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-5880092913 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-5880092909 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (98830869487829 / 100000000000000 : ℝ) ≤ Real.exp (-5880092913 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5880092913 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-5880092909 / 500000000000 : ℝ) ≤ (494154347443099 / 500000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-5880092909 / 500000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (49 : ℝ) ^ (99697823 / 100000000 : ℝ) = 49 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 49) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 49 * (99697823 / 100000000 : ℝ) = Real.log 49 + (-302177 / 100000000 : ℝ) * Real.log 49 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_56 : (864421242667899 / 15625000000000 : ℝ) ≤ (56 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (56 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (1728842485351359 / 31250000000000 : ℝ) := by + have hl := log_56 + have hxlo : (-12163686983 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 56 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 56 ≤ (-6081843487 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-12163686983 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-6081843487 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (123488748952557 / 125000000000000 : ℝ) ≤ Real.exp (-12163686983 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-12163686983 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-6081843487 / 500000000000 : ℝ) ≤ (246977497907337 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-6081843487 / 500000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (56 : ℝ) ^ (99697823 / 100000000 : ℝ) = 56 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 56) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 56 * (99697823 / 100000000 : ℝ) = Real.log 56 + (-302177 / 100000000 : ℝ) * Real.log 56 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_57 : (14076964467371763 / 250000000000000 : ℝ) ≤ (57 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (57 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (56307857869993839 / 1000000000000000 : ℝ) := by + have hl := log_57 + have hxlo : (-6108585517 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 57 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 57 ≤ (-488686841 / 40000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-6108585517 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-488686841 / 40000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (246964288901259 / 250000000000000 : ℝ) ≤ Real.exp (-6108585517 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-6108585517 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-488686841 / 40000000000 : ℝ) ≤ (987857155613927 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-488686841 / 40000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (57 : ℝ) ^ (99697823 / 100000000 : ℝ) = 57 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 57) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 57 * (99697823 / 100000000 : ℝ) = Real.log 57 + (-302177 / 100000000 : ℝ) * Real.log 57 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_64 : (197502289841479 / 3125000000000 : ℝ) ≤ (64 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (64 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (987511449217271 / 15625000000000 : ℝ) := by + have hl := log_64 + have hxlo : (-628359407 / 50000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 64 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 64 ≤ (-1256718813 / 100000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-628359407 / 50000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-1256718813 / 100000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (197502289841479 / 200000000000000 : ℝ) ≤ Real.exp (-628359407 / 50000000000 : ℝ) := by + rw [abs_of_nonpos (show (-628359407 / 50000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-1256718813 / 100000000000 : ℝ) ≤ (987511449217271 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1256718813 / 100000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (64 : ℝ) ^ (99697823 / 100000000 : ℝ) = 64 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 64) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 64 * (99697823 / 100000000 : ℝ) = Real.log 64 + (-302177 / 100000000 : ℝ) * Real.log 64 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_65 : (3209261852211363 / 50000000000000 : ℝ) ≤ (65 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (65 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (160463092612173 / 2500000000000 : ℝ) := by + have hl := log_65 + have hxlo : (-504561529 / 40000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 65 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 65 ≤ (-2522807643 / 200000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-504561529 / 40000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-2522807643 / 200000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (246866296323951 / 250000000000000 : ℝ) ≤ Real.exp (-504561529 / 40000000000 : ℝ) := by + rw [abs_of_nonpos (show (-504561529 / 40000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-2522807643 / 200000000000 : ℝ) ≤ (12343314816321 / 12500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-2522807643 / 200000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (65 : ℝ) ^ (99697823 / 100000000 : ℝ) = 65 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 65) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 65 * (99697823 / 100000000 : ℝ) = Real.log 65 + (-302177 / 100000000 : ℝ) * Real.log 65 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_72 : (4442220195046731 / 62500000000000 : ℝ) ≤ (72 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (72 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (8884440390182319 / 125000000000000 : ℝ) := by + have hl := log_72 + have hxlo : (-12923101383 / 1000000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 72 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 72 ≤ (-12923101373 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-12923101383 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-12923101373 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (493580021671859 / 500000000000000 : ℝ) ≤ Real.exp (-12923101383 / 1000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-12923101383 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-12923101373 / 1000000000000 : ℝ) ≤ (987160043353591 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-12923101373 / 1000000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (72 : ℝ) ^ (99697823 / 100000000 : ℝ) = 72 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 72) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 72 * (99697823 / 100000000 : ℝ) = Real.log 72 + (-302177 / 100000000 : ℝ) * Real.log 72 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_73 : (72059679636251947 / 1000000000000000 : ℝ) ≤ (73 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (73 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (18014919909243169 / 250000000000000 : ℝ) := by + have hl := log_73 + have hxlo : (-1296478163 / 100000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 73 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 73 ≤ (-648239081 / 50000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-1296478163 / 100000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-648239081 / 50000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (987118899126739 / 1000000000000000 : ℝ) ≤ Real.exp (-1296478163 / 100000000000 : ℝ) := by + rw [abs_of_nonpos (show (-1296478163 / 100000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-648239081 / 50000000000 : ℝ) ≤ (246779724784153 / 250000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-648239081 / 50000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (73 : ℝ) ^ (99697823 / 100000000 : ℝ) = 73 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 73) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 73 * (99697823 / 100000000 : ℝ) = Real.log 73 + (-302177 / 100000000 : ℝ) * Real.log 73 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma moment_145 : (571342902289729 / 4000000000000 : ℝ) ≤ (145 : ℝ) ^ (99697823 / 100000000 : ℝ) ∧ + (145 : ℝ) ^ (99697823 / 100000000 : ℝ) ≤ (28567145114800723 / 200000000000000 : ℝ) := by + have hl := log_145 + have hxlo : (-7519272363 / 500000000000 : ℝ) ≤ (-302177 / 100000000 : ℝ) * Real.log 145 := by nlinarith [hl.1, hl.2] + have hxhi : (-302177 / 100000000 : ℝ) * Real.log 145 ≤ (-3007708943 / 200000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (-7519272363 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (-3007708943 / 200000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (19701479389301 / 20000000000000 : ℝ) ≤ Real.exp (-7519272363 / 500000000000 : ℝ) := by + rw [abs_of_nonpos (show (-7519272363 / 500000000000 : ℝ) ≤ 0 by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (-3007708943 / 200000000000 : ℝ) ≤ (985073969475887 / 1000000000000000 : ℝ) := by + rw [abs_of_nonpos (show (-3007708943 / 200000000000 : ℝ) ≤ 0 by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (145 : ℝ) ^ (99697823 / 100000000 : ℝ) = 145 * Real.exp ((-302177 / 100000000 : ℝ) * Real.log 145) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 145 * (99697823 / 100000000 : ℝ) = Real.log 145 + (-302177 / 100000000 : ℝ) * Real.log 145 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_2 : (229258977632251 / 100000000000000 : ℝ) ≤ (2 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (2 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (573147444137943 / 250000000000000 : ℝ) := by + have hl := log_2 + have hxlo : (1066678943 / 7812500000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 2 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 2 ≤ (34133726201 / 250000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (1066678943 / 7812500000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (34133726201 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (229258977632251 / 200000000000000 : ℝ) ≤ Real.exp (1066678943 / 7812500000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (1066678943 / 7812500000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (34133726201 / 250000000000 : ℝ) ≤ (573147444137943 / 500000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (34133726201 / 250000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (2 : ℝ) ^ (119697823 / 100000000 : ℝ) = 2 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 2) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 2 * (119697823 / 100000000 : ℝ) = Real.log 2 + (19697823 / 100000000 : ℝ) * Real.log 2 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_3 : (1862403414861 / 500000000000 : ℝ) ≤ (3 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (3 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (3724806830094483 / 1000000000000000 : ℝ) := by + have hl := log_3 + have hxlo : (108201352013 / 500000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 3 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 3 ≤ (108201352063 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (108201352013 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (108201352063 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (620801138287 / 500000000000 : ℝ) ≤ Real.exp (108201352013 / 500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (108201352013 / 500000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (108201352063 / 500000000000 : ℝ) ≤ (1241602276698161 / 1000000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (108201352063 / 500000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (3 : ℝ) ^ (119697823 / 100000000 : ℝ) = 3 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 3) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 3 * (119697823 / 100000000 : ℝ) = Real.log 3 + (19697823 / 100000000 : ℝ) * Real.log 3 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_4 : (65699598531297 / 12500000000000 : ℝ) ≤ (4 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (4 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (1313991970886111 / 250000000000000 : ℝ) := by + have hl := log_4 + have hxlo : (273069809409 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 4 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 4 ≤ (273069809607 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (273069809409 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (273069809607 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (65699598531297 / 50000000000000 : ℝ) ≤ Real.exp (273069809409 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (273069809409 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (273069809607 / 1000000000000 : ℝ) ≤ (1313991970886111 / 1000000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (273069809607 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (4 : ℝ) ^ (119697823 / 100000000 : ℝ) = 4 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 4) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 4 * (119697823 / 100000000 : ℝ) = Real.log 4 + (19697823 / 100000000 : ℝ) * Real.log 4 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_5 : (1373035841805121 / 200000000000000 : ℝ) ≤ (5 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (5 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (1373035842076983 / 200000000000000 : ℝ) := by + have hl := log_5 + have hxlo : (317024231183 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 5 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 5 ≤ (317024231381 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (317024231183 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (317024231381 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (1373035841805121 / 1000000000000000 : ℝ) ≤ Real.exp (317024231183 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (317024231183 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (317024231381 / 1000000000000 : ℝ) ≤ (1373035842076983 / 1000000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (317024231381 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (5 : ℝ) ^ (119697823 / 100000000 : ℝ) = 5 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 5) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 5 * (119697823 / 100000000 : ℝ) = Real.log 5 + (19697823 / 100000000 : ℝ) * Real.log 5 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_8 : (376555569753739 / 31250000000000 : ℝ) ≤ (8 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (8 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (301244455892461 / 25000000000000 : ℝ) := by + have hl := log_8 + have hxlo : (204802357057 / 500000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 8 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 8 ≤ (409604714411 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (204802357057 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (409604714411 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (376555569753739 / 250000000000000 : ℝ) ≤ Real.exp (204802357057 / 500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (204802357057 / 500000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (409604714411 / 1000000000000 : ℝ) ≤ (301244455892461 / 200000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (409604714411 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (8 : ℝ) ^ (119697823 / 100000000 : ℝ) = 8 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 8) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 8 * (119697823 / 100000000 : ℝ) = Real.log 8 + (19697823 / 100000000 : ℝ) * Real.log 8 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_16 : (13488866397431 / 488281250000 : ℝ) ≤ (16 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (16 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (863287449776583 / 31250000000000 : ℝ) := by + have hl := log_16 + have hxlo : (546139618819 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 16 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 16 ≤ (273069809607 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (546139618819 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (273069809607 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (13488866397431 / 7812500000000 : ℝ) ≤ Real.exp (546139618819 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (546139618819 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (273069809607 / 500000000000 : ℝ) ≤ (863287449776583 / 500000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (273069809607 / 500000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (16 : ℝ) ^ (119697823 / 100000000 : ℝ) = 16 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 16) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 16 * (119697823 / 100000000 : ℝ) = Real.log 16 + (19697823 / 100000000 : ℝ) * Real.log 16 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_24 : (5610387031959957 / 125000000000000 : ℝ) ≤ (24 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (24 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (5610387034176063 / 125000000000000 : ℝ) := by + have hl := log_24 + have hxlo : (626007418141 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 24 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 24 ≤ (78250927317 / 125000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (626007418141 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (78250927317 / 125000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (1870129010653319 / 1000000000000000 : ℝ) ≤ Real.exp (626007418141 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (626007418141 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (78250927317 / 125000000000 : ℝ) ≤ (1870129011392021 / 1000000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (78250927317 / 125000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (24 : ℝ) ^ (119697823 / 100000000 : ℝ) = 24 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 24) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 24 * (119697823 / 100000000 : ℝ) = Real.log 24 + (19697823 / 100000000 : ℝ) * Real.log 24 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_32 : (61848874393923 / 976562500000 : ℝ) ≤ (32 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (32 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (494790995395811 / 7812500000000 : ℝ) := by + have hl := log_32 + have hxlo : (170668630881 / 250000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 32 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 32 ≤ (341337262009 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (170668630881 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (341337262009 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (61848874393923 / 31250000000000 : ℝ) ≤ Real.exp (170668630881 / 250000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (170668630881 / 250000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (341337262009 / 500000000000 : ℝ) ≤ (494790995395811 / 250000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (341337262009 / 500000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (32 : ℝ) ^ (119697823 / 100000000 : ℝ) = 32 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 32) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 32 * (119697823 / 100000000 : ℝ) = Real.log 32 + (19697823 / 100000000 : ℝ) * Real.log 32 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_40 : (2068097174814997 / 25000000000000 : ℝ) ≤ (40 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (40 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (1034048587918319 / 12500000000000 : ℝ) := by + have hl := log_40 + have hxlo : (363314472649 / 500000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 40 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 40 ≤ (5676788639 / 7812500000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (363314472649 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (5676788639 / 7812500000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (2068097174814997 / 1000000000000000 : ℝ) ≤ Real.exp (363314472649 / 500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (363314472649 / 500000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (5676788639 / 7812500000 : ℝ) ≤ (1034048587918319 / 500000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (5676788639 / 7812500000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (40 : ℝ) ^ (119697823 / 100000000 : ℝ) = 40 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 40) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 40 * (119697823 / 100000000 : ℝ) = Real.log 40 + (19697823 / 100000000 : ℝ) * Real.log 40 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_48 : (643115797534833 / 6250000000000 : ℝ) ≤ (48 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (48 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (1607789494631331 / 15625000000000 : ℝ) := by + have hl := log_48 + have hxlo : (381271161423 / 500000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 48 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 48 ≤ (38127116167 / 50000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (381271161423 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (38127116167 / 50000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (214371932511611 / 100000000000000 : ℝ) ≤ Real.exp (381271161423 / 500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (381271161423 / 500000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (38127116167 / 50000000000 : ℝ) ≤ (535929831543777 / 250000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (38127116167 / 50000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (48 : ℝ) ^ (119697823 / 100000000 : ℝ) = 48 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 48) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 48 * (119697823 / 100000000 : ℝ) = Real.log 48 + (19697823 / 100000000 : ℝ) * Real.log 48 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_56 : (3867167932847807 / 31250000000000 : ℝ) ≤ (56 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (56 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (15468671739032757 / 125000000000000 : ℝ) := by + have hl := log_56 + have hxlo : (24778332841 / 31250000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 56 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 56 ≤ (396453325703 / 500000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (24778332841 / 31250000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (396453325703 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (552452561835401 / 250000000000000 : ℝ) ≤ Real.exp (24778332841 / 31250000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (24778332841 / 31250000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (396453325703 / 500000000000 : ℝ) ≤ (2209810248433251 / 1000000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (396453325703 / 500000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (56 : ℝ) ^ (119697823 / 100000000 : ℝ) = 56 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 56) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 56 * (119697823 / 100000000 : ℝ) = Real.log 56 + (19697823 / 100000000 : ℝ) * Real.log 56 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_64 : (1134352776901639 / 7812500000000 : ℝ) ≤ (64 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (64 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (141794097196647 / 976562500000 : ℝ) := by + have hl := log_64 + have hxlo : (819209428229 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 64 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 64 ≤ (819209428821 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (819209428229 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (819209428821 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (1134352776901639 / 500000000000000 : ℝ) ≤ Real.exp (819209428229 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (819209428229 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (819209428821 / 1000000000000 : ℝ) ≤ (141794097196647 / 62500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (819209428821 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (64 : ℝ) ^ (119697823 / 100000000 : ℝ) = 64 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 64) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 64 * (119697823 / 100000000 : ℝ) = Real.log 64 + (19697823 / 100000000 : ℝ) * Real.log 64 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma tail_72 : (10448803966491657 / 62500000000000 : ℝ) ≤ (72 : ℝ) ^ (119697823 / 100000000 : ℝ) ∧ + (72 : ℝ) ^ (119697823 / 100000000 : ℝ) ≤ (4179521589070941 / 25000000000000 : ℝ) := by + have hl := log_72 + have hxlo : (842410122117 / 1000000000000 : ℝ) ≤ (19697823 / 100000000 : ℝ) * Real.log 72 := by nlinarith [hl.1, hl.2] + have hxhi : (19697823 / 100000000 : ℝ) * Real.log 72 ≤ (842410122709 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (842410122117 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (842410122709 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (1160978218499073 / 500000000000000 : ℝ) ≤ Real.exp (842410122117 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (842410122117 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (842410122709 / 1000000000000 : ℝ) ≤ (464391287674549 / 200000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (842410122709 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + have hr : (72 : ℝ) ^ (119697823 / 100000000 : ℝ) = 72 * Real.exp ((19697823 / 100000000 : ℝ) * Real.log 72) := by + rw [Real.rpow_def_of_pos (by norm_num)] + rw [show Real.log 72 * (119697823 / 100000000 : ℝ) = Real.log 72 + (19697823 / 100000000 : ℝ) * Real.log 72 by ring, + Real.exp_add, Real.exp_log (by norm_num)] + rw [hr] + constructor <;> nlinarith + +lemma cutoff_tail_20 : (1820564202645949 / 1000000000000000 : ℝ) ≤ (20 : ℝ) ^ (1 / 5 : ℝ) ∧ + (20 : ℝ) ^ (1 / 5 : ℝ) ≤ (455141050843999 / 250000000000000 : ℝ) := by + have hl := log_20 + have hxlo : (299573227251 / 500000000000 : ℝ) ≤ (1 / 5 : ℝ) * Real.log 20 := by nlinarith [hl.1, hl.2] + have hxhi : (1 / 5 : ℝ) * Real.log 20 ≤ (599146454903 / 1000000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (299573227251 / 500000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have heu := Real.exp_bound (x := (599146454903 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 20) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (1820564202645949 / 1000000000000000 : ℝ) ≤ Real.exp (299573227251 / 500000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (299573227251 / 500000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (599146454903 / 1000000000000 : ℝ) ≤ (455141050843999 / 250000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (599146454903 / 1000000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + rw [Real.rpow_def_of_pos (by norm_num)] + simpa only [mul_comm] using And.intro hlo hhi + +lemma cutoff_completion_20 : (504546755461623 / 500000000000000 : ℝ) ≤ (20 : ℝ) ^ (302177 / 100000000 : ℝ) ∧ + (20 : ℝ) ^ (302177 / 100000000 : ℝ) ≤ (100909351093031 / 100000000000000 : ℝ) := by + have hl := log_20 + have hxlo : (9052413909 / 1000000000000 : ℝ) ≤ (302177 / 100000000 : ℝ) * Real.log 20 := by nlinarith [hl.1, hl.2] + have hxhi : (302177 / 100000000 : ℝ) * Real.log 20 ≤ (2263103479 / 250000000000 : ℝ) := by nlinarith [hl.1, hl.2] + have hel := Real.exp_bound (x := (9052413909 / 1000000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have heu := Real.exp_bound (x := (2263103479 / 250000000000 : ℝ)) (by apply abs_le.mpr; constructor <;> norm_num) (n := 8) (by norm_num) + have hel' := (abs_le.mp hel).1 + have heu' := (abs_le.mp heu).2 + have hexplo : (504546755461623 / 500000000000000 : ℝ) ≤ Real.exp (9052413909 / 1000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (9052413909 / 1000000000000 : ℝ) by norm_num)] at hel' + norm_num [Finset.sum_range_succ, Nat.factorial] at hel' ⊢ + linarith + have hexphi : Real.exp (2263103479 / 250000000000 : ℝ) ≤ (100909351093031 / 100000000000000 : ℝ) := by + rw [abs_of_nonneg (show 0 ≤ (2263103479 / 250000000000 : ℝ) by norm_num)] at heu' + norm_num [Finset.sum_range_succ, Nat.factorial] at heu' ⊢ + linarith + have hlo := hexplo.trans (Real.exp_le_exp.mpr hxlo) + have hhi := (Real.exp_le_exp.mpr hxhi).trans hexphi + rw [Real.rpow_def_of_pos (by norm_num)] + simpa only [mul_comm] using And.intro hlo hhi + +noncomputable def targetMoment (t : ℝ) : ℝ := + 504 * (4 : ℝ) ^ t + + 126 * (7 : ℝ) ^ t + + 846 * (8 : ℝ) ^ t + + 5868 * (9 : ℝ) ^ t + + 448 * (17 : ℝ) ^ t + + 448 * (25 : ℝ) ^ t + + 448 * (33 : ℝ) ^ t + + 448 * (41 : ℝ) ^ t + + 448 * (49 : ℝ) ^ t + + 448 * (57 : ℝ) ^ t + + 448 * (65 : ℝ) ^ t + + 224 * (73 : ℝ) ^ t + + 224 * (145 : ℝ) ^ t + +noncomputable def paidMoment (t : ℝ) : ℝ := + 41298 * (1 : ℝ) ^ t + + 7416 * (2 : ℝ) ^ t + + 9180 * (3 : ℝ) ^ t + + 2286 * (4 : ℝ) ^ t + + 720 * (5 : ℝ) ^ t + + 144 * (8 : ℝ) ^ t + + 448 * (16 : ℝ) ^ t + + 448 * (24 : ℝ) ^ t + + 448 * (32 : ℝ) ^ t + + 448 * (40 : ℝ) ^ t + + 448 * (48 : ℝ) ^ t + + 448 * (56 : ℝ) ^ t + + 448 * (64 : ℝ) ^ t + + 224 * (72 : ℝ) ^ t + +lemma target_lower : (118659835882717186839 / 500000000000000 : ℝ) ≤ targetMoment (99697823 / 100000000 : ℝ) := by + dsimp [targetMoment] + nlinarith only [moment_4.1, moment_7.1, moment_8.1, moment_9.1, moment_17.1, moment_25.1, moment_33.1, moment_41.1, moment_49.1, moment_57.1, moment_65.1, moment_73.1, moment_145.1] + +lemma paid_upper : paidMoment (99697823 / 100000000 : ℝ) ≤ (29664958789460926697 / 125000000000000 : ℝ) := by + dsimp [paidMoment] + simp only [Real.one_rpow] + nlinarith only [moment_2.2, moment_3.2, moment_4.2, moment_5.2, moment_8.2, moment_16.2, moment_24.2, moment_32.2, moment_40.2, moment_48.2, moment_56.2, moment_64.2, moment_72.2] + +lemma paid_tail_upper : paidMoment (119697823 / 100000000 : ℝ) ≤ (103284805855456102571 / 250000000000000 : ℝ) := by + dsimp [paidMoment] + simp only [Real.one_rpow] + nlinarith only [tail_2.2, tail_3.2, tail_4.2, tail_5.2, tail_8.2, tail_16.2, tail_24.2, tail_32.2, tail_40.2, tail_48.2, tail_56.2, tail_64.2, tail_72.2] + +theorem contraction : paidMoment (99697823 / 100000000 : ℝ) < (1 - (1 / 1000000000 : ℝ)) * targetMoment (99697823 / 100000000 : ℝ) := by + nlinarith only [target_lower, paid_upper] + +theorem paid_tail : paidMoment (119697823 / 100000000 : ℝ) < + (97 / 100 : ℝ) * (20 : ℝ) ^ (1 / 5 : ℝ) * targetMoment (99697823 / 100000000 : ℝ) := by + have h0 : 0 ≤ targetMoment (99697823 / 100000000 : ℝ) := by nlinarith only [target_lower] + have h1 := mul_le_mul_of_nonneg_right cutoff_tail_20.1 h0 + nlinarith only [target_lower, paid_tail_upper, h1] + +theorem completion_tail : (10928 * 21 : ℝ) < + (97 / 100 : ℝ) * (20 : ℝ) ^ (302177 / 100000000 : ℝ) * targetMoment (99697823 / 100000000 : ℝ) := by + have h0 : 0 ≤ targetMoment (99697823 / 100000000 : ℝ) := by nlinarith only [target_lower] + have h1 := mul_le_mul_of_nonneg_right cutoff_completion_20.1 h0 + nlinarith only [target_lower, h1] + +end NumericalMoments +#print axioms NumericalMoments.contraction +#print axioms NumericalMoments.paid_tail +#print axioms NumericalMoments.completion_tail diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-outer-endpoint.py b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-outer-endpoint.py new file mode 100644 index 0000000000..340e1f0ffb --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-outer-endpoint.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +"""Exact endpoint refill conditional on the source PR4359 construction. + +Apache-2.0. Substantial OpenAI assistance. The mixed inventory and elementary +function enclosure are zxv's PR4359; mixed-target flow is Jacob Alan Sussman's +Theorem 1G. Outer formulas retain the attribution in PR4359 outer_parameters.py. +This file checks arithmetic, not the native or all-size proof hypotheses. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +PREFIX = Path('research/kappa-rebuild') +OLD_BASELINE = Q('0.001730970419199163702738') +KAPPA = Q('0.00230509') +TESTED = Q('0.00230509019') +ROOT_UPPER = Q('0.002306') + + +def need(value, message): + if not value: + raise AssertionError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def ceil(value): + value = Q(value) + return -((-value.numerator) // value.denominator) + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def family(kappa, tested): + """One explicit slack family approaching the same source mixed root.""" + need(Q(0) < kappa < tested < ROOT_UPPER, 'Positive strictly ordered savings') + d = (tested-kappa)/7 + return {'kappa': kappa, 'tested_saving': tested, + 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, + 'bit_saving': Q('0.0027'), 'epsilon': 1-d, 'beta': 1-3*d, + 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + + +def ledger(p): + """Recompute all 54 named PR4359 checks with freely supplied parameters.""" + kappa, b, a, q = (p[key] for key in ('kappa', 'b', 'a', 'q')) + epsilon, beta, r0, stop, layout = (p[key] for key in + ('epsilon', 'beta', 'r0', 'stop', 'layout')) + sigma, tau = 1-b, 1-a + internal = tau+(1-stop)*max(sigma-tau, Q(0)) + leaf = sigma+stop*(1-sigma) + lam, c = 1-(q+a)/2, Q(3, 32) + xi, key = epsilon*(1+q)-c+layout, beta+1-epsilon + margins = { + 'main_transform': epsilon*q, + 'global_coordinate_router': a, + 'fused_gaussian': 1-epsilon+q*beta, + 'group_bit_router': 1-epsilon+a*beta, + 'group_scans': 1-epsilon+beta, + 'boundary_algebraic_matrix': c+xi-epsilon, + 'sparse_union_movement': xi+Q(1, 2)-epsilon, + 'polynomial_products': epsilon, + 'microbox_face_corrections': 1-(epsilon+beta+48-128+2), + } + checks = { + 'actual_bit_above_effective': p['bit_saving']-a, + 'complex_above_effective': b-a, + 'q_positive': q, 'complex_endpoint': b-q, 'q_below_effective': a-q, + 'stop_positive': stop, 'stop_below_one': 1-stop, + 'leaf_saving_above_effective': (1-stop)*b-a, + 'q_below_internal': 1-internal-q, 'q_below_leaf': 1-leaf-q, + 'lambda_above_tau': lam-tau, 'lambda_above_sigma': lam-sigma, + 'lambda_above_internal': lam-internal, + 'lambda_prime_above_lambda': 1-q-lam, + 'lambda_prime_above_leaf': 1-q-leaf, + 'epsilon_positive': epsilon, 'epsilon_below_one': 1-epsilon, + 'cap_above_band': xi-Q(1, 2), 'cap_below_cell': epsilon-xi, + 'group_positive': beta, 'group_below_dimension': epsilon-beta, + 'support_router_span': 1-beta, + 'group_gauge_power_slack': 1-(2*xi-2)-r0-beta, + 'actual_logarithmic_group_guard': 1-(2*xi-2)-beta, + 'global_gamma_power_slack': 1-epsilon-r0, + 'actual_logarithmic_gamma_guard': 1-epsilon, + 'alpha_logarithm_absorption': r0, + 'group_key_fits_record': 1-key, + 'membership_arithmetic_fits_record': 1-beta-2*(1-epsilon), + 'microbox_halo_volume': 128-48-beta, + 'positive_layout_slack': layout, + 'short_record_fallback': epsilon-a, + 'complex_below_one_over_32': Q(1, 32)-b, + 'strassen_integer_power_gap': Q(2**45-7**16), + 'theta_positive_polynomial_power': Q(2), + 'cap_below_phase_cell_power': 2-xi, + 'halo_covers_generic_inverse_radius': Q(48-43), + 'union_tag_work_per_visit_fits_record': 1-beta, + 'union_header_fits_record': 1-beta, + 'source_axis_superpolynomial': 1-epsilon, + 'gaussian_above_main': margins['fused_gaussian']-margins['main_transform'], + 'new_complex_uniform_saving_above_b': p['complex_uniform_saving']-b, + 'improvement_over_user_baseline': kappa-OLD_BASELINE, + 'new_semantic_guard_with_C1_one': 1-epsilon, + 'fine_prime_halo_umbrella': 10-(2*2+2+Q(1, 2)), + } + checks.update({name+'_above_kappa': value-kappa for name, value in margins.items()}) + # These are the additional functional conditions in the independent + # PR4359 outer_transfer_audit.py, beyond the 54-row parameter ledger. + functional = { + 'new_semantic_group_guard': 1-beta, + 'new_BIT_row_stock_sublinear_in_active_group': beta*(1-Q(3, 1000)), + 'fixed_halo_explicit_metadata_branch': 128-48-epsilon-beta-1, + } + return {'parameters': dict(p, cap_xi=xi, lambda_=lam, lambda_prime=1-q), + 'margins': margins, 'strict_checks': checks, 'functional_checks': functional} + + +def compiler_rank(E, targets, paid, tested, uniform): + """The original sufficient bound, re-instantiated for the new exponent.""" + m, kmin, rmax = max(targets), min(targets), max(paid) + need((m, kmin, rmax) == (57, 6, 5), 'Pinned complex separation') + t, z = 1-tested, 1-uniform + z0, h = (t+z)/2, Q(1, 10) + delta = z0-t + need(0 < t < z0 < z < 1, 'Compiler exponent order') + need(5**10 < 6**9 and 57 < 2**10, 'Exact source rank bounds') + need(z0 > Q(1, 2) and (1-z0)*E.log_interval(m)[1] < E.log_interval(2)[0], + 'Original eta strictly exceeds 1/4') + H0 = ceil((3+4*delta)/(h*delta)) + ratio = H0*(1-z0)/(z-z0) + H1 = ratio.numerator//ratio.denominator+1 + need(H0 >= m.bit_length() and H0*h*delta >= 3+4*delta, 'Induction starts') + need(H1*(z-z0) > H0*(1-z0), 'Strict winning uniform rank') + need((H0-1)*h*delta < 3+4*delta, 'Reject one lower threshold exponent') + need((H1-1)*(z-z0) <= H0*(1-z0), 'Reject one lower final exponent') + return {'t': t, 'z0': z0, 'z': z, 'theta_upper': Q(9, 10), + 'H0': H0, 'H1': H1, 'N_encoding': '2^H1', + 'strict_final_gap': H1*(z-z0)-H0*(1-z0), + 'winning_word_materialized': False, + 'bound': 'Original sufficient inequality; a sharper bound is separate.'} + + +def run(source_root): + base = source_root/PREFIX + interval_path = base/'architecture/mixed_target_probe.py' + spec = importlib.util.spec_from_file_location('pr4359_moment', interval_path) + E = importlib.util.module_from_spec(spec) + spec.loader.exec_module(E) + cover = read(base/'controller/P3-NATIVE-COVER.json.gz')['cover'] + targets = {int(k): int(v) for k, v in cover['targets'].items()} + paid = {int(k): int(v) for k, v in cover['paid'].items()} + need(targets == {6: 192, 7: 56, 8: 93, 9: 1229, 25: 448, 57: 224}, + 'Exact source productive inventory') + need(paid == {1: 17623, 2: 5065, 3: 1738, 4: 714, 5: 254}, + 'Exact source paid inventory') + signed = Counter(targets) + signed.subtract(paid) + need(sum(k*v for k, v in signed.items()) == 224, 'Rank-one surplus') + bracket = {'lower': E.moment(signed, TESTED), 'upper': E.moment(signed, ROOT_UPPER)} + need(bracket['lower'][0] > 0 and bracket['upper'][1] < 0, + 'Strict mixed test and upper root bound') + + original = read(base/'controller/OUTER-PARAMETERS.json')['outer'] + old = ledger({'kappa': Q('0.0023'), 'complex_uniform_saving': Q('0.002304'), + 'b': Q('0.002303'), 'a': Q('0.0023025'), 'q': Q('0.002302'), + 'bit_saving': Q('0.0027'), 'epsilon': Q('0.99999'), + 'beta': Q('0.99997'), 'r0': Q(1, 10**6), + 'stop': Q(1, 10**8), 'layout': Q(1, 10**6)}) + for group in ('margins', 'strict_checks'): + frozen = {key: Q(value['rational']) for key, value in original[group].items()} + need(old[group] == frozen, 'Exact reproduction of every old '+group) + p = family(KAPPA, TESTED) + result = ledger(p) + need(all(v > 0 for v in result['strict_checks'].values()), 'All 54 new outer predicates') + need(all(v > 0 for v in result['functional_checks'].values()), 'Additional functional predicates') + need(min(result['margins'].values()) == result['margins']['main_transform'], + 'Main transform remains limiting') + need(result['parameters']['cap_xi'] == Q(29, 32)+(1-p['d'])*p['q'], + 'Cofinal cap simplification') + controls = {} + for label, updates in [('closed_epsilon_gap', {'epsilon': Q(1)}), + ('missing_layout', {'layout': Q(0)}), + ('unfunded_kappa', {'kappa': Q('0.002306')}), + ('BIT_below_effective', {'bit_saving': OLD_BASELINE}), + ('no_complex_slack', {'complex_uniform_saving': p['b']})]: + tested = ledger(dict(p, **updates)) + failures = {k: v for k, v in tested['strict_checks'].items() if v <= 0} + need(failures, 'Mutation rejected: '+label) + controls[label] = failures + need(E.moment(signed, Q('0.004'))[1] < 0, 'Unsupported mixed target is rejected') + inputs = [interval_path, base/'controller/P3-NATIVE-COVER.json.gz', + base/'controller/OUTER-PARAMETERS.json'] + return encode({'schema': 'pr4359-cofinal-outer-refill/1', + 'status': 'PASS_EXACT_CONDITIONAL_ENDPOINT_REFILL', + 'kappa': KAPPA, 'gain_over_PR4359': KAPPA-Q('0.0023'), + 'unchanged_paid': paid, 'unchanged_targets': targets, + 'mixed_test_saving': TESTED, 'mixed_test_margin': E.show(bracket['lower']), + 'root_upper_test': ROOT_UPPER, 'root_upper_margin': E.show(bracket['upper']), + 'old_ledger_crosscheck': {'matched_savings': len(old['margins']), + 'matched_checks': len(old['strict_checks'])}, + 'outer': result, 'limiting_margin': min(result['margins'].values())-KAPPA, + 'compiler': compiler_rank(E, targets, paid, TESTED, p['complex_uniform_saving']), + 'negative_controls': controls, + 'source_sha256': {str(p.relative_to(source_root)): sha256(p.read_bytes()).hexdigest() + for p in inputs}, + 'scope': 'Conditional arithmetic and specified finite rank. The PR4359 native, compiler, cover, precision, fixed-tape and outer hypotheses remain premises; no full theorem or practical word is certified.'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=HERE/'source') + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = run(args.source_root) + if args.out: + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({key: result[key] for key in + ('status', 'kappa', 'gain_over_PR4359', 'limiting_margin', 'compiler')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-ARITHMETIC.json b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-ARITHMETIC.json new file mode 100644 index 0000000000..0fdb65f946 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-ARITHMETIC.json @@ -0,0 +1,241 @@ +{ + "compiler": { + "H": 38569300000000000, + "N": "2^38569300000000000", + "eta": { + "lower": "0.000000204535199106284215364833", + "upper": "0.000000204535199106284215364834" + }, + "gap": "1/700000000000", + "integer_test_exponent": 55099, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "1057621533/350000000000", + "word_materialized": false + }, + "gain_over_PR4535": "4027/2500000000", + "kappa": "15108879/5000000000", + "local_helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "margin_at_old_root_upper": [ + "78072058023577019965454984044224523228758899702419408235/196159429230833773869868419475239575503198607639501078528", + "1249152928377232319447279744707592371660142395238823308861/3138550867693340381917894711603833208051177722232017256448" + ], + "native_receipt_sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "local_routes": 4802000, + "local_scalar": 158168, + "raw_scalar_upper": 181098496 + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1480670144797884756937/490000000000000000000000", + "fused_gaussian": "1480670144793654270811/490000000000000000000000", + "global_coordinate_router": "264405383/87500000000", + "group_bit_router": "185083768186706783851/61250000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "1480670144097884756937/490000000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "200543170144797884756937/490000000000000000000000" + }, + "parameters": { + "a": "264405383/87500000000", + "b": "423048613/140000000000", + "beta": "699999999997/700000000000", + "bit_saving": "17/5000", + "cap_xi": "445543170144097884756937/490000000000000000000000", + "complex_uniform_saving": "1057621533/350000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "15108879/5000000000", + "lambda_": "199395644839/200000000000", + "lambda_prime": "697884756937/700000000000", + "layout": "1/700000000000", + "q": "2115243063/700000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "302177581/100000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "33094617/87500000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "44456829856952115243063/245000000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "2797884756937/490000000000000000000000", + "cap_above_band": "200543170144097884756937/490000000000000000000000", + "cap_below_cell": "44456829855202115243063/490000000000000000000000", + "cap_below_phase_cell_power": "534456829855902115243063/490000000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "3951951387/140000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793654270811/490000000000000000000000", + "gaussian_above_main": "347884756937/245000000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "436706783851/61250000000000000000000", + "group_gauge_power_slack": "44456829856917115243063/245000000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "348942378469/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645402690400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "279576951387/98000000000000000000000", + "leaf_saving_above_effective": "139576951387/98000000000000000000000", + "main_transform_above_kappa": "2097884756937/490000000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "3368617797309/43750000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "697884756939/700000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "279576951387/98000000000000000000000", + "q_positive": "2115243063/700000000000", + "short_record_fallback": "139576951387/140000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "199062500002797884756937/490000000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "paid": { + "1": 41298, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64404, + "productive_fields": 10928, + "rank_mass_surplus": 752, + "raw_root_interval": [ + "302177587077/100000000000000", + "151088793539/50000000000000" + ], + "scope": "Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.", + "source_sha256": { + "research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/joint-helper-lattice/CONTROLLER.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "research/joint-helper-lattice/verify.py": "8eb13f77a94315f811612cb557a17edeecb6b9d9a75dfa238b112dd6520c336f", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "research/kappa-round6-compiler-tightening-20261022/arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/query-thinned-controllers/RESULT.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "research/query-thinned-controllers/controller.py": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2" + }, + "status": "PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE", + "strictification": { + "alpha": { + "lower": "0.999999999936687383304469699479", + "upper": "0.999999999936687383304469699480" + }, + "cutoff": 20, + "delta": { + "lower": "0.958285308639504859158849914083", + "upper": "0.958285308639504859158849914084" + }, + "floor": 21, + "gamma": { + "lower": "0.956217509753795293454516855483", + "upper": "0.956217509753795293454516855484" + }, + "normalized_paid_upper": "104857600097656251/104857601073741824", + "power": 1024, + "tail_offset": "1/5", + "tested": "302177581/100000000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5868 + } +} diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-arithmetic.py b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-arithmetic.py new file mode 100644 index 0000000000..12af6aa937 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/4610-round6-arithmetic.py @@ -0,0 +1,147 @@ +"""Complete p16 price and finite compiler for a changed native profile. + +Adapted from Cinna Davis's PR4470 arithmetic, retaining zxv's paid tensor +completion/logarithmic majorant and Jacob Alan Sussman's mixed-job flow. +Apache-2.0. Substantial OpenAI Codex assistance. Native admission is separate. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import math +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + +def need(ok,why): + if not ok:raise ValueError(why) + +def load(path,name): + spec=importlib.util.spec_from_file_location(name,path) + m=importlib.util.module_from_spec(spec);sys.modules[name]=m;spec.loader.exec_module(m) + return m + +def encode(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +def read(path): + import gzip + b=path.read_bytes();return json.loads(gzip.decompress(b) if path.suffix=='.gz' else b) + +def assemble(local): + H={int(k):v for k,v in local['helpers'].items()};N={int(k):v for k,v in local['paid'].items()} + sys.path.insert(0,str(ROOT/'research/joint-helper-lattice')) + J=load(ROOT/'research/joint-helper-lattice/verify.py','round2_pinned_controller') + sys.path.insert(0,str(ROOT/'research/query-thinned-controllers')) + C=load(ROOT/'research/query-thinned-controllers/controller.py','round2_controller_engine') + word=J.controller16(C) + T,P=Counter(),Counter();full=thin=0 + for e in word['physical_events']: + if e[0]=='LOCAL':full+=1;T.update(H);P.update(N) + elif e[0]=='QUERY_SHEAR':thin+=1;P[1]+=112 + elif e[0]=='IDLE':P[8*len(e[2])]+=224 + for term in word['diagonal']:T[1+8*sum(term[1:])]+=112 + need(full==18 and thin==15 and sum(H.values())==408,'Complete retained p16 call and input inventory') + return H,N,T,P,word + +def run(local,kappa=None): + H,N,T,P,word=assemble(local) + E=load(ROOT/'research/higher-moment-strictification/verify.py','round2_exact_intervals') + other=load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','round2_second_intervals') + def margin(c): + t,p=E.moment(T,1-c),E.moment(P,1-c) + return t[0]-p[1],t[1]-p[0] + old_upper=Q('.0030201659771') + need(margin(old_upper)[0]>0,'Changed complete invoice strictly beats old raw root upper endpoint') + # Binary search on a fixed rational grid; all final signs use exact intervals. + lo,hi=0,1000000000000 + grid=10**14 + while hi-lo>1: + mid=(lo+hi)//2 + if margin(Q(mid,grid))[0]>0:lo=mid + else:hi=mid + root_low,root_high=Q(lo,grid),Q(hi,grid) + need(margin(root_low)[0]>0 and margin(root_high)[1]<0,'Strict changed-profile rational root enclosure') + if kappa is None:kappa=Q((root_low*10**8).__floor__()-3,10**8) + tested=kappa+Q(1,10**11) + need(Q('.003020165')ph and max(tl,target[0])<=min(th,target[1]) and max(pl,paid[0])<=min(ph,paid[1]),'Two independently implemented rational moment engines agree') + alpha=E.divide(paid,target) + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,tested),target)) + alpha_gap=Q(1,10**11);g=d=Q(97,100) + need(alpha[1]<1-alpha_gap and gamma[1]theta**power,'Shifted exits and complement capacity') + need(E.power(145,v*tested)[1]<2**power,'Compiler initial range') + gap=(tested-kappa)/7;need(gap.numerator==1,'Explicit finite integer grid') + step=gap.denominator + def wins(j):return (step*j+1)**power<2**j + left,right=1,2 + while not wins(right):left,right=right,2*right + while right-left>1: + mid=(left+right)//2 + if wins(mid):right=mid + else:left=mid + height=step*right + need(height>8*v and wins(right) and not wins(right-1),'Strict finite uniform-rank integer bound') + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + routes=(sum(N.values())+2*408+688)*1000 + need(local_scalar+routes<10**7,'Complete scalar and fixed monomial routing bound') + scalar_upper=18*10**7+15*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(scalar_upper<10**9,'Raw controller scalar bound') + bit=read(ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom==Q('.004') and atom>ordinary>admitted>tested and atom<1-ordinary,'Source ordinary BIT admission and stock') + L=load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','round2_outer_ledger') + params={'kappa':kappa,'tested_saving':tested,'complex_uniform_saving':kappa+6*gap, + 'b':kappa+5*gap,'a':kappa+4*gap,'q':kappa+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=L.ledger(params);outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Whole outer predicate inventory') + need(all(x>0 for key in ('strict_checks','functional_checks') for x in outer[key].values()),'All outer inequalities strictly positive') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_endpoint',{'kappa':tested}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0] + need(failed,'Reject unsupported outer patch '+name);controls[name]=failed + return encode({'status':'PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE','kappa':kappa, + 'gain_over_PR4535':kappa-Q('.003020165'),'raw_root_interval':[root_low,root_high], + 'margin_at_old_root_upper':margin(old_upper),'local_helpers':H,'local_paid':N,'targets':T,'paid':P, + 'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),'rank_mass_surplus':sum(r*n for r,n in T.items())-sum(r*n for r,n in P.items()), + 'strictification':{'tested':tested,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'uniform_saving':params['complex_uniform_saving'],'H':height,'N':'2^'+str(height),'integer_test_exponent':right,'word_materialized':False}, + 'nonrecursive':{'local_scalar':local_scalar,'local_routes':routes,'raw_scalar_upper':scalar_upper}, + 'ordinary_BIT':bit,'outer':outer,'negative_controls':controls, + 'scope':'Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.'}) + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--native',type=Path,required=True);ap.add_argument('--kappa');ap.add_argument('--out',type=Path,default=HERE/'ARITHMETIC.json');args=ap.parse_args() + result=run(read(args.native),Q(args.kappa) if args.kappa else None) + result['native_receipt_sha256']=sha256(args.native.read_bytes()).hexdigest() + # Pin all loaded project source modules and the non-module controller/stock + # records read by the inherited engines. Standard-library files are outside + # the repository and are recorded instead by the replay's Python version. + paths={Path(__file__).resolve(),ROOT/'research/joint-helper-lattice/CONTROLLER.json', + ROOT/'research/query-thinned-controllers/RESULT.json'} + for module in tuple(sys.modules.values()): + name=getattr(module,'__file__',None) + if name: + path=Path(name).resolve() + if path.is_relative_to(ROOT) and path.is_file():paths.add(path) + result['source_sha256']={p.relative_to(ROOT).as_posix():sha256(p.read_bytes()).hexdigest() for p in sorted(paths)} + args.out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','kappa','gain_over_PR4535','raw_root_interval','paid_calls','compiler')},indent=2)) diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-PROOF.md b/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-PROOF.md new file mode 100644 index 0000000000..c4033090d7 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-PROOF.md @@ -0,0 +1,192 @@ +# Proofs: one number governs the native call + +Status tags used for every claim: + +| tag | meaning | +|---|---| +| **PROVED-LEAN** | machine-checked in `lean/Skel.lean` (Lean 4 + Mathlib, no `sorry`), under the stated hypotheses | +| **PROVED-PAPER** | proof given here, not formalised | +| **CHECKED-EXACT** | exact or 60-digit computation. "verify.py" means it is rebuilt by `verify.py` from the public #4610 package; "source" means it was run in the research notes on data not shipped here | +| **CONDITIONAL** | holds only under a stated modelling assumption, named in its scope | + +Every claim carries its scope. Pointers `[k]` refer to numbered lines of `data/verify_output.txt`. + +Notation. P = `research/joint-helper-lattice/PROOF.md`; Q = `research/kappa-round3-warp-20261022/PROOF.md`; V = that directory's `verify_candidate.py`; NE = `research/kappa-rebuild/complex/native_extensions.py`. "#4610" is the word `kappa-round3-warp-20261022/ACTUAL-WORD.json.gz`, whose κ is in (0.0030217758, 0.0030217759) [8]. + +## 0. Setting + +An invoice is a pair of multisets: credits T and paid jobs P of positive integer ranks. Its moment is f(t) = Σ_T k^t − Σ_P r^t. The pricer returns the first crossing of f in C = 1 − t on (0, 0.05], and f > 0 at small C. Fix a bar and write t* = 1 − bar; the default is bar = 0.0030233 (about 0.05% above κ(#4610)). Because the pricer returns the first crossing, **κ ≥ bar implies f(t*) ≥ 0** with no further assumption. The converse needs f to have a single crossing on (0, 0.05] (assumption S1, checked on a 1000-point grid for the invoices used here). + +**Frames and fields.** A frame is a subspace of F₂⁹. A persistent field carries one logical value in a current frame, from a start frame S_f to a final frame T_f. Events on a field are paid transports E → F (which cost a rank) and free events (warps K_G with G ∈ GL(9,2), and scalar operations). A climb is a nested paid transport E ⊂ F. A field's history is an integer dimension path d₀ = dim S_f, …, d_n = dim T_f with costs c_j ≥ 0. Write R_f = dim T_f − dim S_f. + +**Contract hypotheses (used explicitly).** + +| | statement | source | status | +|---|---|---|---| +| H1 | A field's frame dimension changes only at paid transports. Warps preserve dimension. Scalar operations act inside one frame. | P:15–17; Q:5–8 | package contract. On #4610 all 240 warps preserve dimension and every field replays start → final in both orientations [2] | +| H2 | A nested transport E ⊂ F costs dim F − dim E. A general transport costs dim E + dim F − 2 dim(E ∩ F) ≥ \|dim F − dim E\|, with the parity of dim F − dim E. | nested: P:15, Q:5–6. General formula: L_E ∩ L_F = (E ∩ F) ⊕ (E + F)^⊥ | nested: package contract. General formula: **PROVED-LEAN** (`rankCost_ge_abs`, `rankCost_nested`, `rankCost_parity`) | +| H3 | A helper is credited once, with its whole residual rank R_f = dim T − dim S, S ⊊ T. No duplicate field, discarded helper, clean input or free temporary productive input. | P:19; Q:18–21; V:40 | package contract | +| H4 | Transports of helper and main fields are ascending climbs. | NE:123 | a verifier convention. Section 3 shows the results hold with or without it | +| H5 | Unit (v, d) = (112, 8). One pair per LOCAL, port-uniform. Kap path controller with thick set {0, 2p, odd}, e = 1. | model family | model assumption. The p16 a7 invoice is public [1] | + +The **centre** is the owned rank-8 jobs on the C buffers. In #4610 there are 8 per call (M = 64). + +## 1. Analytic core (PROVED-LEAN) + +For 0 < t ≤ 1 and x ↦ x^t on [0, ∞): + +- **Lemma 1 (subadditivity).** (Σxᵢ)^t ≤ Σxᵢ^t, strictly for 0 < t < 1 when two terms are positive. `rpow_add_le`, `rpow_sum_le`, `rpow_add_lt`, `rpow_sum_lt`. +- **Lemma 2 (chord).** For 0 ≤ x ≤ y: x^t ≥ x·y^{t−1}. `mul_rpow_sub_one_le`. +- **Lemma 3 (exchange).** For 0 ≤ x ≤ y and r ≥ 0: (y+r)^t − y^t ≤ (x+r)^t − x^t. Proof: concavity applied at μ = r/(y−x+r). `rpow_increment_antitone`. + +## 2. Paths, Theorem B and Theorem C + +**Lemma 4 (path identity; PROVED-LEAN).** For an integer path with R = d_n − d₀ and down-mass D = Σ max(−Δ_j, 0): Σ|Δ_j| = R + 2D. Hence under H1–H2, Σ c_j ≥ R + 2D. `FieldPath.sum_abs_eq`, `mass_ge`. + +**Theorem B (per-call decomposition; PROVED-LEAN under H1–H3).** Every paid native job is a single-field climb or a centre job. The native per-call moment φ(t) := Σ_helpers h^t − Σ_paid r^t satisfies + + φ(t) = −2v·d^t − Σ_centre c^t − Λ(t), Λ(t) = Σ_f Λ_f(t), Λ_f(t) = Σ_j c_j^t − R_f^t ≥ 0. + +For 0 < t < 1, Λ_f = 0 iff the field pays a single job of rank R_f (or none if R_f = 0); two positive jobs give Λ_f > 0. Proof: partition the jobs by field; Lemma 4 gives Σ c_j ≥ R_f, then Lemma 1 and monotonicity give Σ c_j^t ≥ R_f^t. `decomposition`, `FieldPath.lam_nonneg`, `lam_pos_of_two`, and for real subspace histories `lam_nonneg_ofSubspaces`. + +*Application to #4610 (CHECKED-EXACT, verify.py).* +- Σ climbs = R_f on all 632 fields, in both orientations [2]. +- Climb profile plus the 8 centre jobs equals the public `local_paid` exactly [2]. +- Λ(t*) = **23.8746264727**: helpers 16.2711462249, mains 7.6034802478 [4]. +- The identity closes to 6·10⁻⁵⁷ [5]. + +**Theorem C (no net-productive helpers; PROVED-LEAN under H1–H3).** For every helper, Hnet_f = Σ c_j − R_f ≥ 0, and its moment contribution R_f^t − Σ c_j^t = −Λ_f ≤ 0, with equality iff it has exactly one climb. A helper is at best neutral whatever its credited rank, so the helper census enters κ only through Λ_h. Crediting descents as well does not change this: credit mass R_f + D against paid mass ≥ R_f + 2D. `hnet_nonneg`, `hnet_inverse_nonneg`, `helper_contribution_nonpos`. + +*Consequence (PROVED-PAPER).* A net-productive helper (Hnet < 0) needs either a free dimension increase (violating H1) or credit for a non-independent input (violating H3). The moment can turn positive only by crediting finer than paying: credit {1,1} against paid {2} gains 2 − 2^t* = 0.0041868 [10]. + +**Lemma 5 (descents never help; PROVED-LEAN for nested endpoints, PROVED-PAPER otherwise).** With endpoints fixed, replacing a field's path by the single transport start → final never raises the paid moment. For nested endpoints (all helpers and mains in the contract) this is exactly Λ_f ≥ 0. For non-nested endpoints it is the triangle inequality of the rank metric, which is outside the verifier's current scope. A single-field exhaustive search (all walks of at most 5 steps, ranks 1–9, dimensions 0–12, 40 digits) agrees: the minimum paid moment is that of the single climb (CHECKED-EXACT, source). Hence H4 is a convention that costs nothing. + +## 3. Descent price (Theorem D) + +**Theorem D (PROVED-LEAN under H1, H2).** A field with fixed endpoints, R ≥ 0, and one descent of rank r has + + Λ_f(t) ≥ r^t + (R+r)^t − R^t ≥ r^t + (9+r)^t − 9^t (second step for R ≤ 9). + +Proof: the descent step pays ≥ r; the other steps telescope to R + r (Lemma 4), so by Lemma 1 their moment is ≥ (R+r)^t; the second inequality is Lemma 3. `descent_price`, `descent_price_nine`. + +At t* [9] (CHECKED-EXACT, verify.py): the bound is 1.99022 (r = 1), 3.97594 (r = 2), 5.95983 (r = 3), 7.94244 (r = 4). Corollary: any word with Λ ≤ Λ* contains at most ⌊Λ*/1.99022⌋ = **11** rank-1 descents. + +*Order of magnitude (PROVED-PAPER).* A descent costs first order in mass (about 2r). Any unlock of fragmentation is a concavity gain, second order in 1 − t (about 0.003 per unit of mass). + +*Application to #4610 (CHECKED-EXACT, source; not rebuilt by verify.py).* With the scalar program fixed, relaxing the frame model so that all 44 frame-infeasible helpers are free gains at most 1.3293 + 0.1176 of Λ, below the price 1.9902 of one descent. A relaxation freeing the hub field 225 completely gains 0.07417 against that price, net −1.916 per call. These are relaxation bounds, and are scoped to a fixed scalar program with nested descents only (CONDITIONAL on that scope). + +## 4. Theorem A and the exact ship threshold + +**Theorem A (controller separation; PROVED-PAPER, CHECKED-EXACT at p16 a7 by verify.py).** Under H5, f(t) = (p+2)·φ(t) + Γ_{p,a}(t), where Γ depends on the controller only: targets 2v at 1 + d(p+2) and 2v at 1 + d(j+1) for j = 1..a and j = 1..b (b = p−1−a); paid v(p−1) rank-1 thin shears and 2v at d(j+1) for the same j. This is the invoice construction itself. Public check [1]: at (16, 7), with (H, N) from `ARITHMETIC.json`, it reproduces `targetMoment` and `paidMoment` of `NumericalMoments.lean` coefficient by coefficient (13 target and 14 paid terms). + +**Corollary A1 (universal controller; CHECKED-EXACT for p ≤ 400 plus PROVED-PAPER tail, verify.py; CONDITIONAL on the kap family).** Define φ* = −max_{p,a} Γ_{p,a}(t*)/(p+2). Over all p ≥ 1 and all a the maximum is at p = 16, a ∈ {7, 8} (the same invoice): φ* = **−1868.2220388492** [7], [7b]. For p ≤ 400 this is an exact search. For p > 400, write Γ/(p+2) = F(p) + Σ_{k=1}^{p−1}(2v·δ_{j_k} − v)/(p+2) with F(p) = 2v(1+d(p+2))^t/(p+2), which decreases in p, and δ_j = (1+d(j+1))^t − (d(j+1))^t ≤ δ_1 (Lemma 3), each bracket positive; so Γ/(p+2) ≤ F(401) + 2vδ_1 − v = 1858.7424 < −φ* [7b]. In the family, some (p, a) clears the bar with native call φ only if φ(t*) ≥ φ*, and under S1 also if. + +**Theorem (ship threshold).** Under H1–H5 and the #4610 centre (8 rank-8 jobs per call): + + κ ≥ bar ⟹ Λ(t*) ≤ **Λ\* = −φ\* − 232·8^{t\*} = 23.8536932758.** + +PROVED-PAPER from Theorem B, Theorem A and the first-crossing remark in §0. The converse holds under S1 (CONDITIONAL). For #4610 [6]: + +- Λ − Λ* = **0.0209331969 per call**. +- 18(Λ* − Λ) = −0.3767975440, which equals the public invoice f(t*) to 10⁻⁴⁰. This closes the whole chain independently. +- At #4610's own root t₀ = 1 − κ, Λ(t₀) = Λ*(bar = κ) = 23.8626369199 to 10⁻⁴⁰ [12]. + +**Exchange values per call at t\*** (CHECKED-EXACT, verify.py [10]; the gap to close is 0.0209332): + +| move | value | +|---|---| +| merge two rank-1 climbs on one field (1+1 → 2) | 0.0041868 (5 per call clear the bar) | +| uneven split 4+4 → 3+5 (the #4610 mechanism) | 0.00075844 | + +*Scope.* The threshold applies to words in the family 𝔉: the kap path controller at unit (112, 8) with the 8-job centre. It says nothing about other units, other controllers outside the kap family, or words that change H1–H3. + +## 5. A30-CUT: the owned centre is moment-optimal + +**Setting.** H1–H3, linear contents over any field, U uses of the centre. Each use must deliver a vector whose p-part is c_u·p_u. Write g(x) = x^t and y = g(8)/8. + +**Hypotheses.** +- **P-ATOM (contact restriction).** Carriers acquire p-content only by reading the port, and no new L–L contacts are added. Relative to the frozen L word, p_u is then an atomic item independent of all other carrier content. This is a modelling step; in real coordinates it needs the lemma that with no L–L contacts every carrier's content lies in span(its own native input, port reads received). +- **DELIV.** Every add that changes an L register's p-coefficient happens at frame 0. In the variant ψ there is one port frame P and the adds happen at frames F with F ∩ P = 0. +- **Mains are net-up.** True for #4610 (starts are lines in P and finals are pinned at dimension 8). Without it the dual fails: a credited 8 → 0 field that need not end holding its own input gives −7.95. + +**Theorem (A30-CUT).** Σ_fields [Σ_jobs g(c_j) − g(credit_f)] ≥ U·g(8) + Σ_f slack_f with every slack_f ≥ 0. Fields with no centre traffic keep slack_f = Λ_f. The number of owned, helper, main and target registers, dirty contents, inverse credit, sharing across uses and order are arbitrary. + +*Proof.* Take φ = dim (or ψ = dim(· ∩ P)); both are integer-valued and 1-Lipschitz for rank. + +1. **(i) Cut lemma (PROVED-PAPER, CONDITIONAL on P-ATOM and DELIV).** For a level λ ∈ {1..8} let N_λ = span{r_j : φ(S_j) < λ}. By induction over events, every content held below λ lies in N_λ plus the vectors moved by transports that crossed λ downward. At the end, below λ sit the U delivered vectors and the r_j of every helper with φ(S_j) ≥ λ > φ(T_j); by P-ATOM these are independent modulo N_λ. Each crossing transport moves one field's content, so downward crossings at λ number at least U + (net-down helpers at λ). +2. **(ii) Per-level telescoping (PROVED-LEAN).** On each field, up(λ) − down(λ) = [λ ≤ final] − [λ ≤ start]. `FieldPath.up_sub_dn`. Summing (i) over fields and levels gives Σ_f cov_f ≥ 8U, where cov_f = Σ_{λ=1..8} min(up, down) (owned fields: down). +3. **(iii) Rank pays for crossings (PROVED-LEAN).** A job crosses at most min(c_j, 8) of the levels 1..8. `levels_crossed_le`, `crossings_le_mass`. +4. **(iv) Dual feasibility of y (PROVED-LEAN for each case given Σ c_j ≥ R + 2k; that mass bound is PROVED-PAPER; k ≥ 2 case for t ∈ [0.99, 1]).** We need loss_f ≥ y·cov_f on every field. + - Owned fields: g(a) ≥ y·min(a, 8) by Lemma 2 (`owned_dual`). + - Credited fields with cov = 0: loss = Λ_f ≥ 0. + - Credited fields with k = cov ≥ 1: levels 1..8 give Σ c_j ≥ R − 1 + 2k and parity makes it Σ c_j ≥ R + 2k (`rankCost_parity` per step; the summation of parity along the path is PROVED-PAPER, not in Lean). For k = 1, Lemmas 1 and 3 give loss ≥ 1 > y (`credited_k1`, `y_lt_one`). For k ≥ 2, Lemma 2 with y = 9 and Bernoulli (9^{t−1} ≥ 25/27 for t ≥ 0.99) give loss ≥ y·k (`credited_k2`, `nine_rpow_sub_one_ge`). + - The owned 8 → 0 job attains the bound, so it is tight. + +At t*: y = 0.993733 and 9^{t−1} = 0.993379 [11]. ∎ + +**Corollaries (CONDITIONAL on the hypotheses above).** +1. No dirty, inverse-credited, catalytic or shared centre gets below g(8) = 7.9499 per use. +2. Recruiting an existing helper or main as a carrier costs slack ≥ 0.9968 (minimum at path 1 → 0 → 9; CHECKED-EXACT, source, on all dimension paths of at most 6 jobs, see below), while the largest baseline Λ_f in #4610 is 0.05959 [11]. Any gain must therefore come from fields with no centre traffic, which is Λ. + +*Independent checks (CHECKED-EXACT, source).* An exhaustive Dijkstra over all subspace states of F₂ⁿ and F₃ⁿ (n = 3, 4; helpers, owned registers, inverse credit on or off, one or two uses) found no pattern below the owned centre. An independent re-derivation checked dual feasibility on all 5,978,700 dimension paths of at most 6 jobs (minimum reduced cost 0, no violations; smallest credited traffic slack 0.99682), and on real-subspace ψ models (19,558,506 and 13,017,840 paths). + +**Scope not covered.** Cross-use sharing with different ports and deliveries at a common frame z; deliveries at frames meeting P; dropping P-ATOM (the decoder question); carriers that ride warps; query shears. + +## 6. Centre-free (coded) family: exact budget and ceiling + +Context. #4929 (Dugongue) is a centre-free producer with an explicit code A = I − 14P. #4694 and #4698 (Cinna Davis, 1337isnot1337) supply a 640-field interface, +112 cache pricing and eight chains. #4933 (dillona) is a coded p16 caller with deferred decoding. #4932 and #4931 (Clear1nsight) give a one-bank decoder ceiling and a one-port prefix offer. #4940 (SethBurkart123) proposes A⁻¹-mixed query shears. This section prices these constructions in the Λ currency. Claims about their contents are as stated in those PRs and were not re-run here. + +**6.1 The coded endpoint is #4610 with the centre deleted (CHECKED-EXACT, source, on #4929's SOURCE-WORD).** Same 3290 climbs, same Λ (helpers 16.2711462249, mains 7.6034802478), same 632 start and final frames, in both orientations; the difference is 6,596 free dyadic adds. + +**6.2 Exact budget (CHECKED-EXACT, verify.py [13]).** With φ_coded = φ(#4610) + 8·8^{t*}: + + B = φ_coded − φ* = **63.577975271157 per call** = 8f(8) − (Λ − Λ*), where f(8) = 8^{t*} and 8f(8) = 63.5989084680. + +Over the 18 calls of the invoice, 18B = 1144.40355488. Any adapter that restores the contract endpoint must therefore cost less than 8f(8) − 0.0209332 per call. + +**6.3 Per-call restoration (CONDITIONAL on A30-CUT scope).** The repair ΔY = 14PX is exactly the source's eight centre deliveries (22 Y targets per port; 24 distinct needed vectors). A30-CUT applies under its hypotheses: DELIV and mains net-up hold here (p_u is read at a port register of dimension 8, mains are net-up, deliveries are at frame 0), and P-ATOM is assumed for the adapter. Then the cost is ≥ 8f(8) = 63.5989 > B, short by exactly 0.0209331969. The deleted centre is the cheapest in-scope adapter, and coded + adapter ≤ κ(#4610). + +Cheapest designs priced (CHECKED-EXACT, source): owned centre re-instated 63.5989 (margin −0.0209); hub at line 114/115 (in all ports) 63.6715; hub at a dim-2 meet 63.7072; #4694 direct cache 112; post-call up-and-down 224. + +**6.4 Single-commodity lemma at any frame and time (CHECKED-EXACT, source; SUBCLASS: owned carriers, fixed #4610 main chains, no warp-riding carriers, no target-to-target relays).** If every carrier holds a multiple of one p_u and deliveries are at any frame the target occupies after p_u exists, each use costs ≥ f(8). Proof: if some target is served at frame 0, the content path from P_u to 0 has total rank ≥ 8, so cost ≥ f(8) by Lemma 1. Otherwise the 22 targets need ≥ h_u distinct nonzero arrival frames, each costing ≥ 1; exact hitting-set MILPs give h_u = 16, 16, 16, 16, 14, 18, 14, 18, all ≥ 14 > f(8). Nested stops with shedding at a common frame M ⊆ K (K the intersection of the 8 ports, dimension 5) were checked on all 31 lines of K against all 203,360 (line, hyperplane) pairs: no design gives every late target a nested stop. + +**6.5 Deferred decoding (#4933).** The budget becomes whole-invoice: 18B = 1144.4036, i.e. at most 71.5252 per negative bank if the positive half is free (CHECKED-EXACT, verify.py [13]). +- (CONDITIONAL: P-ATOM, owned carriers, fixed main chains.) Decoding one stage-s factor means delivering 8 independent items. At the stage this is the per-call adapter, so ≥ 8f(8) by A30-CUT. Later or post-hoc, items of different debt classes are independent modulo N_λ, so the count adds over the **53** debt classes (class counts EXACT on #4933's `GAUGE.json`): 53·8f(8) = 3370.74. +- Any mix of at-stage and later decoding costs ≥ 18·8f(8) = 1144.78035 against 1144.40355, a shortfall of 18 × 0.0209332 = 0.376798 (CONDITIONAL: P-ATOM, owned carriers, fixed main chains). Reinstating all 144 centre calls attains it and is #4610. +- #4932's one-bank decoder needs ≥ 112 grade-2 channels per bank, 112f(2) = 223.53. Its grade-2 projection is block-diagonal over independent banks, so 16 banks cost 3576.5 against 1144.40 (scope: the single-layer decoders that #4932 treats). +- #4931's one-port prefix offer costs +0.0057610 per use with no reward in the moment. +- Past the invoice, handing codes to the parent recursion is not allowed by the current compiler (#4933's own README); that would need a typed recursive coded product. + +**6.6 A⁻¹-mixed query shears (#4940).** Frame replay on #4929's canonical frames (CHECKED-EXACT, source): the 112 x-roles enter their calls at 112 distinct non-nested dimension-1 lines, so a cross-port add at the call entrance fails the verifier's scalar-source-frame rule, and each source must first leave its line by a paid rank-1 transport: ≥ 112 rank-1 jobs per thick call. Commutation (CHECKED-EXACT, F₂-symplectic, all 5,824 coupled pairs): in the physical ABI of #4933 the code C = K⁻¹AK does not commute with Q, so the needed input conversion QCQ⁻¹ is non-monomial. The sub-lemma that one boundary conversion per thick call is Q-twisted is PROVED-PAPER for conversions inside the stage-s recode group, and argued for common-frame conversions (CONDITIONAL). Priced in #4940's own invoice, break-even is about 63.6 per call and the repair costs ≥ 112, so there is no root at any p (CONDITIONAL on the Q-twist sub-lemma above); the model reproduces #4940's published 0.0030201659770. The credit for #4940 is the idea and its exact diagonalisation: with it the question reduces to the same centre budget B. + +**6.7 What reopens the coded route (stated as scope, not as a claim).** Every statement in 6.3–6.6 is inside the A30-CUT and single-commodity scope. Doors outside it, shared with #4610 without any coding: network-coded carriers with stops and shedding; decoders that read X directly (breaking P-ATOM); a native word with port-independent entrance lines. + +## 7. Claim index + +| claim | tag | rebuilt by verify.py | +|---|---|---| +| Lemmas 1–3 | PROVED-LEAN | text check only | +| H2 for subspaces (general formula, nested, parity) | PROVED-LEAN | | +| Lemma 4, Theorem C | PROVED-LEAN | | +| Theorem B: identity, Λ_f ≥ 0, strictness | PROVED-LEAN | | +| Theorem B on #4610 (Λ = 23.8746264727, identity to 10⁻⁵⁷) | CHECKED-EXACT | yes [2]–[5] | +| Lemma 5 (nested endpoints) | PROVED-LEAN | | +| Lemma 5 (non-nested); inverse-credit remark | PROVED-PAPER | | +| Theorem D, descent price table, cap of 11 | PROVED-LEAN; numbers CHECKED-EXACT | yes [9] | +| Descent unlock bounds on #4610 (44 helpers, hub 225) | CHECKED-EXACT, scoped to fixed scalar program | no | +| Theorem A, p16 a7 invoice | PROVED-PAPER; CHECKED-EXACT | yes [1] | +| Corollary A1 (best controller in the kap family, all p) | CHECKED-EXACT (p ≤ 400) + PROVED-PAPER tail; CONDITIONAL on the family | yes [7], [7b] | +| Ship threshold Λ\* = 23.8536932758, gap 0.0209331969 | PROVED-PAPER (necessity); CHECKED-EXACT numbers | yes [6] | +| Sufficiency of Λ ≤ Λ\* | CONDITIONAL on S1 | no | +| A30-CUT (ii), (iii), (iv) | PROVED-LEAN; in (iv) the parity summation Σ c_j ≥ R + 2k is PROVED-PAPER | | +| A30-CUT (i) cut lemma | PROVED-PAPER, CONDITIONAL on P-ATOM, DELIV, mains net-up | | +| A30-CUT exhaustive and independent dual checks | CHECKED-EXACT | no | +| Coded budget B = 63.577975271157, 18B, 71.5252, shortfall | CHECKED-EXACT | yes [13] | +| Coded endpoint equals #4610 minus centre | CHECKED-EXACT | no (needs #4929 data) | +| Per-call and deferred kills (6.3–6.5) | CONDITIONAL on A30-CUT scope (P-ATOM, DELIV, mains net-up) and, for 6.4–6.5, owned carriers and fixed main chains; counts CHECKED-EXACT | no | +| #4940 no-root conclusion (6.6) | CONDITIONAL on the Q-twist sub-lemma | no | +| #4940 frame and commutation witnesses | CHECKED-EXACT | no (needs #4940 data) | + +## 8. Lean build + +`lean/Skel.lean` imports only Mathlib. It builds with the shipped `lean/lakefile.toml` and `lean/lake-manifest.json` (Lean `v4.33.0-rc1`, pinned Mathlib): `cd lean && lake exe cache get && LEAN_NUM_THREADS=4 lake build Skel`, with "Build completed successfully". `#print axioms` on the headline theorems gives only `propext`, `Classical.choice`, `Quot.sound`. Not formalised: the cut lemma (i), the identification of verifier events with `FieldPath`s (that is H1–H3, checked on #4610 by `verify.py`), the invoice structure, S1, and the real-number constants at t*. diff --git a/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-verify.py b/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-verify.py new file mode 100644 index 0000000000..4a676e0397 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/author/frozen/5226-verify.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python3 +"""Rebuild the fragmentation loss Lambda of the public #4610 word and the exact ship threshold. + +Python standard library only (decimal, 60 digits); about 6 s. Reads the public #4610 package +(Cao Yifan / intqwq), nothing else: + research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz + research/kappa-round3-warp-20261022/ARITHMETIC.json + research/kappa-round3-warp-lean-20261022/NumericalMoments.lean + +Usage: python3 -B verify.py [PKG_ROOT] [BAR] + PKG_ROOT directory that contains research/kappa-round3-warp-20261022 (default: searched upward + from this file, then $INTMULT_PKG). + BAR internal bar, default 0.0030233; t* = 1 - BAR. +Exit status 0 iff every assertion passes. Output lines are numbered [k]; PROOF.md cites them. +""" +import sys, os, json, gzip, re, collections +from decimal import Decimal as D, getcontext +getcontext().prec = 60 + +def find_pkg(): + if len(sys.argv) > 1: return sys.argv[1] + if os.environ.get('INTMULT_PKG'): return os.environ['INTMULT_PKG'] + here = os.path.dirname(os.path.abspath(__file__)) + p = here + for _ in range(6): + for cand in (p, os.path.join(p, 'wt')): + if os.path.isdir(os.path.join(cand, 'research', 'kappa-round3-warp-20261022')): return cand + p = os.path.dirname(p) + sys.exit('cannot find the #4610 package; pass PKG_ROOT') +PKG = find_pkg() +BAR = D(sys.argv[2]) if len(sys.argv) > 2 else D('0.0030233') +TS = 1 - BAR +W3 = PKG + '/research/kappa-round3-warp-20261022/' +LN = PKG + '/research/kappa-round3-warp-lean-20261022/NumericalMoments.lean' +v, d = 112, 8 + +def pw(x, t): + x = D(x) + return D(0) if x == 0 else (t * x.ln()).exp() +def mom(Dct, t): return sum(D(n) * pw(r, t) for r, n in Dct.items()) +def fmt(x, k=10): return f'{x:.{k}f}' +def near(x, ref, tol='1e-9'): return abs(D(x) - D(ref)) < D(tol) +default_bar = (BAR == D('0.0030233')) + +# [1] public profiles and the controller family +A = json.load(open(W3 + 'ARITHMETIC.json')) +H = {int(k): n for k, n in A['local_helpers'].items()} +N = {int(k): n for k, n in A['local_paid'].items()} +lean = open(LN).read() +def lean_poly(name): + body = re.search(r'def ' + name + r' \(t : ℝ\) : ℝ :=(.*?)\n\n', lean, re.S).group(1) + return {int(r): int(n) for n, r in re.findall(r'(\d+) \* \((\d+) : ℝ\) \^ t', body)} +T_pub, P_pub = lean_poly('targetMoment'), lean_poly('paidMoment') + +def inv(p, a, H, N, ports=v, block=d): + T = collections.Counter({r: (p + 2) * n for r, n in H.items()}) + P = collections.Counter({r: (p + 2) * n for r, n in N.items()}) + P[1] += ports * (p - 1); T[1 + block * (p + 2)] += 2 * ports + for L in (a, p - 1 - a): + for j in range(1, L + 1): + T[1 + block * (j + 1)] += 2 * ports; P[block * (j + 1)] += 2 * ports + return dict(T), dict(P) +T16, P16 = inv(16, 7, H, N) +assert T16 == T_pub and P16 == P_pub, 'controller formula does not match the public invoice' +print('[1] kap-family formula at p16 a7 reproduces the public Lean invoice exactly:', + len(T_pub), 'target and', len(P_pub), 'paid coefficients') + +# [2] per-field climbs from the public word, both orientations +w = json.loads(gzip.decompress(open(W3 + 'ACTUAL-WORD.json.gz', 'rb').read())) +c = w['canonical']; fr = c['frames']; nf = len(c['start']) +R = [len(fr[c['final'][f]]) - len(fr[c['start'][f]]) for f in range(nf)] +res = {} +for orient in ('forward', 'backward'): + jobs = collections.defaultdict(list); cur = list(c['start']); ncen = 0 + for e in w['programs'][orient]: + if e[0] == 'climb': + f, a_, b_, r = e[2], e[3], e[4], e[5] + assert cur[f] == a_ and r == len(fr[b_]) - len(fr[a_]) and r > 0, e # H1/H2: nested ascending climb + jobs[f].append(r); cur[f] = b_ + elif e[0] == 'warp': + f, a_, b_ = e[1][1], e[3], e[4] + assert cur[f] == a_ and len(fr[a_]) == len(fr[b_]), e # H1: warps preserve dimension + cur[f] = b_ + elif e[0] == 'center': + ncen += 1 + assert cur == list(c['final']) + assert all(sum(jobs[f]) == R[f] for f in range(nf)) # telescoping + prof = collections.Counter(r for f in range(nf) for r in jobs[f]); prof[8] += 8 + assert dict(prof) == N, (orient, dict(prof), N) + res[orient] = jobs + print(f'[2] {orient}: {nf} fields replay start->final; all climbs nested, rank = dim gap; sum climbs = R_f on all fields; ' + f'climb profile + 8 centre jobs = ARITHMETIC local_paid; centre events {ncen}') +nh = sum(H.values()); nm = nf - nh +assert all(R[f] == d for f in range(nm)) and collections.Counter(R[nm:]) == collections.Counter(H) +print(f'[3] mains: {nm} fields with R_f = {d}; helpers: {nh} fields with R_f census = local_helpers {H}') + +def Lam(jobs, t, fields): + return sum(sum(pw(x, t) for x in jobs[f]) - pw(R[f], t) for f in fields) +lams = {} +for orient in ('forward', 'backward'): + jobs = res[orient] + Lh, Lm = Lam(jobs, TS, range(nm, nf)), Lam(jobs, TS, range(nm)) + lams[orient] = Lh + Lm + print(f'[4] {orient}: Lambda(t*) = {fmt(Lh + Lm)} (helpers {fmt(Lh)}, mains {fmt(Lm)})') +assert lams['forward'] == lams['backward'] +jobs = res['forward']; L = lams['forward'] + +# [5] Theorem B identity +phi = mom(H, TS) - mom(N, TS) +centre = 8 * pw(8, TS) +resid = phi + 2 * v * pw(d, TS) + centre + L +print(f'[5] phi(t*) = {fmt(phi)}; -2v d^t* - 8*8^t* - Lambda = {fmt(-2*v*pw(d, TS) - centre - L)}; residual {resid:.2E}') +assert abs(resid) < D('1e-50') + +# [6] ship threshold +Gam = lambda p, a, t: (lambda TP: mom(TP[0], t) - mom(TP[1], t))(inv(p, a, {}, {})) +G16 = Gam(16, 7, TS); phistar16 = -G16 / 18 +Lstar = -phistar16 - (2 * v + 8) * pw(d, TS) +f_ts = mom(T_pub, TS) - mom(P_pub, TS) +print(f'[6] p16 a7: phi* = -Gamma(t*)/18 = {fmt(phistar16)}; Lambda* = -phi* - 232*8^t* = {fmt(Lstar)}') +print(f' Lambda(#4610) - Lambda* = {fmt(L - Lstar)} per call; 18*(Lambda*-Lambda) = {fmt(18*(Lstar - L))}; public invoice f(t*) = {fmt(f_ts)}') +assert abs(18 * (Lstar - L) - f_ts) < D('1e-40') + +# [7] Corollary A1: p16 is the best controller of the kap family at t* +best = max((Gam(p, a, TS) / (p + 2), p, a) for p in range(3, 61) for a in range(p)) +okA1 = best[1] == 16 and best[2] in (7, 8) and abs(best[0] + phistar16) < D('1e-45') +print(f'[7] max over kap family p=3..60, all a: Gamma/(p+2) best at p={best[1]} a={best[2]} (phi* = {fmt(-best[0])}); ' + f'p16 a7 is the max (a and p-1-a give the same invoice): {okA1}') +assert okA1 +# [7b] the rest of the family: exact max for p = 1..PMAX via prefix sums, and for p > PMAX the bound +# Gamma/(p+2) <= F(PMAX+1) + 2v*delta_1 - v, with F(p) = 2v(1+8(p+2))^t/(p+2) decreasing in p and +# delta_j = (1+8(j+1))^t - (8(j+1))^t <= delta_1 (Lemma 3), each bracket term 2v*delta_j - v > 0. +PMAX = 400 +dl = [D(0)] + [pw(1 + d * (j + 1), TS) - pw(d * (j + 1), TS) for j in range(1, PMAX + 1)] +S = [D(0)] +for j in range(1, PMAX + 1): S.append(S[-1] + dl[j]) +Fp = lambda p: 2 * v * pw(1 + d * (p + 2), TS) / (p + 2) +best_all = max((F + (2 * v * (S[a] + S[p - 1 - a]) - v * (p - 1)) / (p + 2), p, a) + for p, F in ((p, Fp(p)) for p in range(1, PMAX + 1)) for a in range(p)) +tail = Fp(PMAX + 1) + 2 * v * dl[1] - v +okA1b = best_all[1] == 16 and abs(best_all[0] + phistar16) < D('1e-45') and tail < -phistar16 and all(2 * v * x > v for x in dl[1:]) +print(f'[7b] exact max over p=1..{PMAX}: p={best_all[1]} a={best_all[2]}; tail bound for p>{PMAX}: {fmt(tail, 4)} < {fmt(-phistar16, 4)}: {okA1b}') +assert okA1b + +# [8] root of the public invoice +def froot(T, P): + lo, hi = D('1e-6'), D('0.05') + for _ in range(140): + m = (lo + hi) / 2 + if mom(T, 1 - m) - mom(P, 1 - m) > 0: lo = m + else: hi = m + return lo +kap = froot(T_pub, P_pub) +print(f'[8] public invoice root kappa = {kap:.13f} (package: in (0.0030217758, 0.0030217759))') +assert D('0.0030217758') < kap < D('0.0030217759') +print('SHIP TEST: a word in this family clears the bar iff Lambda(t*) <=', fmt(Lstar, 7), '; #4610 has', fmt(L, 7)) + +# [9] descent price (Theorem D), merge values +price = lambda r: pw(r, TS) + pw(9 + r, TS) - pw(9, TS) +n_desc = int(Lstar / price(1)) +print('[9] descent price lower bound r^t+(9+r)^t-9^t:', ', '.join(f'r={r}: {fmt(price(r), 5)}' for r in (1, 2, 3, 4)), + f'; max rank-1 descents with Lambda <= Lambda*: {n_desc}') +print('[10] merge values: 1+1->2', fmt(2 - pw(2, TS), 7), ' 4+4->3+5', fmt(2*pw(4, TS) - pw(3, TS) - pw(5, TS), 8), + ' needed per call', fmt(L - Lstar, 7)) + +# [11] A30-CUT dual constants +Lf_max = max(sum(pw(x, TS) for x in jobs[f]) - pw(R[f], TS) for f in range(nf)) +y = pw(8, TS) / 8 +print('[11] A30 dual: y = 8^t/8 =', fmt(y, 6), ' 9^(t-1) =', fmt(pw(9, TS) / 9, 6), ' max_f Lambda_f =', fmt(Lf_max, 5)) +assert y < 1 and pw(9, TS) / 9 >= D(25) / 27 and Lf_max < D('0.06') + +# [12] consistency at #4610's own root: Lambda*(bar = kappa) equals Lambda(t0) +t0 = 1 - kap +Ls0 = -(-(Gam(16, 7, t0) / 18)) - (2 * v + 8) * pw(d, t0) +L0 = Lam(jobs, t0, range(nf)) +print(f'[12] at its own root t0 = 1 - kappa: Lambda(t0) = {fmt(L0)}, Lambda*(bar=kappa) = {fmt(Ls0)}, difference {abs(L0 - Ls0):.2E}') +assert abs(L0 - Ls0) < D('1e-9') + +# [13] budget arithmetic for the centre-free (coded) family: the centre is deleted, nothing else changes +f8 = pw(8, TS) +phi_coded = phi + 8 * f8 +B = phi_coded - phistar16 +print(f'[13] centre-free budget B = phi_coded - phi* = {fmt(B, 12)} per call = 8 f(8) - gap = {fmt(8*f8 - (L - Lstar), 12)}; 8 f(8) = {fmt(8*f8, 10)}') +print(f' whole invoice 18B = {fmt(18*B, 8)}; 144 f(8) = {fmt(144*f8, 8)}; shortfall 144 f(8) - 18B = {fmt(144*f8 - 18*B, 10)} = 18 x gap') +print(f' per negative bank if the positive half is free: 18B/16 = {fmt(18*B/16, 10)}; 53 debt classes x 8 f(8) = {fmt(53*8*f8, 2)}; ' + f'16 banks x 112 f(2) = {fmt(16*112*pw(2, TS), 1)}') +assert abs(B - (8 * f8 - (L - Lstar))) < D('1e-40') +assert 144 * f8 - 18 * B == 18 * (L - Lstar) or abs(144 * f8 - 18 * B - 18 * (L - Lstar)) < D('1e-40') +if default_bar: + assert near(B, '63.577975271157', '1e-9') and near(Lstar, '23.8536932758', '1e-9') and near(L, '23.8746264727', '1e-9') + assert near(L - Lstar, '0.0209331969', '1e-9') and n_desc == 11 + assert near(price(1), '1.99022', '1e-5') and near(price(2), '3.97594', '1e-5') + assert near(53 * 8 * f8, '3370.74', '1e-2') and near(18 * B / 16, '71.5252221801', '1e-9') + +# [14] Lean file hygiene (text-level only; the Lean build is separate, see README) +lp = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'lean', 'Skel.lean') +if os.path.exists(lp): + src = open(lp, encoding='utf-8').read() + code = re.sub(r'/-.*?-/', '', src, flags=re.S) + decls = re.findall(r'^\s*(?:private\s+)?(?:theorem|lemma)\s+(\S+)', code, re.M) + has_sorry = 'sorry' in code + has_axiom = bool(re.search(r'^\s*axiom\b', code, re.M)) + print(f'[14] lean/Skel.lean: {len(decls)} theorem/lemma declarations; "sorry" present: {has_sorry}; "axiom" present: {has_axiom}') + assert 'sorry' not in code +print('ALL CHECKS PASSED') diff --git a/research/one-fusion-compiler-target/evidence/review/check_independent.py b/research/one-fusion-compiler-target/evidence/review/check_independent.py new file mode 100644 index 0000000000..db06c94378 --- /dev/null +++ b/research/one-fusion-compiler-target/evidence/review/check_independent.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +"""Independent positive-Taylor scalar audit; no author engine imports.""" +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path +import json + +HERE = Path(__file__).resolve().parent +GRID = 10**60 + + +def need(ok, message): + if not ok: + raise RuntimeError(message) + + +def down(x): + return Q((x * GRID).__floor__(), GRID) + + +def up(x): + return Q((x * GRID).__ceil__(), GRID) + + +def logseries(z): + need(0 <= z <= Q(1, 3), 'log domain') + n = 48 + lo = sum((2*z**(2*j+1)/(2*j+1) for j in range(n)), Q(0)) + return lo, lo + 2*z**(2*n+1)/((2*n+1)*(1-z*z)) + + +@lru_cache(None) +def ln(r): + k = r.bit_length()-1 + x = Q(r, 2**k) + a, b = logseries((x-1)/(x+1)) + c, d = logseries(Q(1, 3)) + return a+k*c, b+k*d + + +def exp_point(x): + # Positive Taylor series with geometric upper bound on its positive tail. + if x < 0: + a, b = exp_point(-x) + return down(1/b), up(1/a) + s = 0 + while x > Q(1, 32): + x /= 2 + s += 1 + term = total = Q(1) + n = 24 + for j in range(1, n+1): + term *= x/j + total += term + tail = (term*x/(n+1))/(1-x/(n+2)) + a, b = down(total), up(total+tail) + for _ in range(s): + a, b = down(a*a), up(b*b) + return a, b + + +@lru_cache(None) +def rp(r, exponent): + a, b = sorted(exponent*x for x in ln(r)) + return exp_point(a)[0], exp_point(b)[1] + + +def moment(profile, exponent): + return tuple(sum((count*rp(r, exponent)[i] for r, count in profile.items()), Q(0)) + for i in (0, 1)) + + +def minus(a, b): + return a[0]-b[1], a[1]-b[0] + + +def div(a, b): + need(b[0] > 0, 'positive divisor') + return a[0]/b[1], a[1]/b[0] + + +def scaled(a, x): + return tuple(sorted(x*v for v in a)) + + +def show(a): + def fmt(q, upper=False): + g = 10**36 + n = (q*g).__ceil__() if upper else (q*g).__floor__() + return ('-' if n < 0 else '')+str(abs(n)//g)+'.'+str(abs(n)%g).zfill(36) + return {'lower': fmt(a[0]), 'upper': fmt(a[1], True)} + + +def main(): + a = json.loads((HERE/'author/frozen/4610-round6-ARITHMETIC.json').read_text()) + t = {int(r): n for r, n in a['targets'].items()} + p0 = {int(r): n for r, n in a['paid'].items()} + p = p0.copy() + p[1] -= 36 + p[2] += 18 + k, reserve = Q('.0030220'), Q(1, 10**11) + tested = k+reserve + need(k > Q('.0030217758'), 'candidate comparison') + mass = lambda h: sum(r*n for r, n in h.items()) + need(mass(p) == mass(p0) and sum(p.values()) == sum(p0.values())-18, + 'full paid mass/position incidence') + target, paid = moment(t, 1-tested), moment(p, 1-tested) + margin = minus(target, paid) + reserve_margin = minus(scaled(target, 1-reserve), paid) + alpha = div(paid, target) + gamma = div(moment(p, 1-tested+Q(1, 5)), + (rp(20, Q(1, 5))[0]*target[0], rp(20, Q(1, 5))[1]*target[1])) + delta = div((Q(21*sum(t.values())),)*2, + (rp(20, tested)[0]*target[0], rp(20, tested)[1]*target[1])) + eta = scaled(rp(145, -1024*tested), 1-tested) + def logmoment(h, c): + return tuple(sum((n*rp(r, 1-c)[i]*ln(r)[i] for r, n in h.items()), Q(0)) + for i in (0, 1)) + derivative_upper = logmoment(p, Q(0))[1]-logmoment(t, tested)[0] + need(margin[0] > 0 and reserve_margin[0] > 0 and derivative_upper < 0, + 'whole pretest monotonicity and tested reserve') + need(alpha[1] < 1-reserve and gamma[1] < Q(97, 100) + and delta[1] < Q(97, 100), 'contraction/tails') + checks = { + 'normalized_paid': 1/(1+1024*reserve)+Q(4, 2**32) < 1, + 'split_round': 20**64 < 21**63, + 'two_tail_blocks': Q(97, 100)**128 < Q(1, 16), + 'shifted_exit_capacity': 2*20**(1024*64) <= 145**(1024*63), + 'eta_capacity': eta[0] > Q(63, 64)**1000, + 'initial_range': rp(145, 1024*tested)[1] < 2**1000, + } + gap = (tested-k)/7 + step = gap.denominator + j, height = a['compiler']['integer_test_exponent'], a['compiler']['H'] + checks.update({ + 'inherited_gap': gap == Q(a['compiler']['gap']) == Q(1, 700000000000), + 'height_encoding': height == step*j and height > 8*1024, + 'height_wins': (step*j+1)**1000 < 2**j, + 'preceding_exponent_fails': (step*(j-1)+1)**1000 >= 2**(j-1), + }) + need(all(checks.values()), 'finite scalar capacity') + author = json.loads((HERE/'author/COMPILER-POINT.json').read_text()) + for key, values in {'margin': margin, 'reserve_margin_M_minus_T_1e11': reserve_margin, + 'alpha': alpha, 'gamma': gamma, 'delta': delta, 'eta': eta}.items(): + enclosure = author[key] + need(Q(enclosure['lower']) <= values[0] <= values[1] <= Q(enclosure['upper']), + 'Independent enclosure not contained in author displayed '+key) + ordinary = a['ordinary_BIT'] + ordinary_saving = (1-Q(ordinary['atom']))*Q(ordinary['after_cover'])+Q(ordinary['atom'])*Q('.0000384599') + need(ordinary_saving == Q(ordinary['ordinary_saving']) > Q(ordinary['admitted']) > tested, + 'retained ordinary BIT source rational') + outer = author['outer'] + need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4 + and all(Q(v) > 0 for key in ('strict_checks', 'functional_checks') + for v in outer[key].values()), 'source-bound outer receipt positives') + single = p0.copy() + single[1] -= 2 + single[2] += 1 + free_deletion = p0.copy() + free_deletion[1] -= 36 + # These are controls of the arithmetic premise, not physical-pair tests. + controls = { + 'single_occurrence_is_not_18_occurrences': minus(moment(t, 1-k), moment(single, 1-k))[1] < 0, + 'deletion_without_rank2_changes_rank_mass': mass(free_deletion) != mass(p0), + 'larger_unfunded_reserve_rejected': minus(scaled(target, 1-Q(1, 10**7)), paid)[1] < 0, + 'physical_witness_still_absent': author['physical_witness_supplied'] is False, + } + need(all(controls.values()), 'arithmetic controls') + print(json.dumps({ + 'status': 'PASS_INDEPENDENT_CONDITIONAL_FIXED_POINT_SCALAR_REVIEW', + 'method': 'Positive Taylor exp with positive geometric tail,48-term atanh logs, ' + 'outward rational1e-60 rounding; no imports from author engines.', + 'kappa_candidate': str(k), 'tested': str(tested), 'reserve': str(reserve), + 'paid_delta': {'1': -36, '2': 18}, + 'margin': show(margin), 'reserve_margin': show(reserve_margin), + 'alpha': show(alpha), 'gamma': show(gamma), 'delta': show(delta), 'eta': show(eta), + 'pretest_domain': ['0', str(tested)], + 'derivative_upper': show((derivative_upper, derivative_upper)), + 'finite_capacity': checks, 'controls': controls, + 'finite_height': height, 'integer_exponent': j, + 'outer54plus4': 'Receipt positive; formulas/source applicability separately reviewed, not a completeness certificate.', + 'scope': 'No physical witness, native/Gaussian operator execution, compiler word, Lean, root search or kappa admission.', + }, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/one-fusion-compiler-target/verify.py b/research/one-fusion-compiler-target/verify.py new file mode 100644 index 0000000000..59fafa6855 --- /dev/null +++ b/research/one-fusion-compiler-target/verify.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python3 +"""Conditional scalar construction-target replay; no physical supplier admission.""" +from hashlib import sha256 +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +ROOT=Path(__file__).resolve().parent + +def need(ok,why): + if not ok: + raise ValueError(why) + +def authenticate(): + manifest=json.loads((ROOT/'EVIDENCE.json').read_text()) + actual={str(f.relative_to(ROOT)) for f in (ROOT/'evidence').rglob('*') if f.is_file()} + need(actual==set(manifest['files']),'Evidence inventory changed') + for name,digest in manifest['files'].items(): + f=ROOT/name + need(not f.is_symlink() and sha256(f.read_bytes()).hexdigest()==digest,'Immutable evidence mismatch: '+name) + review=ROOT/'evidence/review' + for row in json.loads((review/'FILES.json').read_text())['files']: + f=review/row['path'] + need(f.stat().st_size==row['bytes'] and sha256(f.read_bytes()).hexdigest()==row['sha256'],'Independent freeze mismatch: '+row['path']) + freeze=json.loads((review/'FREEZE.json').read_text()) + need(sha256((review/'FILES.json').read_bytes()).hexdigest()==freeze['files_sha256'],'Review manifest pin changed') + need(sha256((review/'REVIEW.md').read_bytes()).hexdigest()==freeze['review_sha256'],'Review prose pin changed') + author=review/'author' + need(sha256((author/'FREEZE.json').read_bytes()).hexdigest()==freeze['reviewed_author_freeze_sha256'],'Reviewed author freeze changed') + for name,digest in json.loads((author/'FREEZE.json').read_text())['files'].items(): + need(sha256((author/name).read_bytes()).hexdigest()==digest,'Original author pin changed: '+name) + for row in json.loads((ROOT/'CAPTURE-BINDINGS.json').read_text())['files']: + need(sha256((ROOT/row['capture']).read_bytes()).hexdigest()==row['sha256'],'Raw source capture pin changed') + return manifest + +def run_script(script,local_module_directory=None): + cmd=[sys.executable,'-I'] + if sys.flags.optimize: + cmd.append('-O') + cmd+=['-W','error','-B'] + if local_module_directory is None: + cmd.append(str(script)) + else: + # Only the authenticated private author directory is added. The unchanged + # compiler-point script imports its sibling check_merge under isolated Python. + driver="import runpy,sys;sys.path.insert(0,sys.argv[1]);runpy.run_path(sys.argv[2],run_name='__main__')" + cmd+=['-c',driver,str(local_module_directory),str(script)] + return subprocess.run(cmd,check=True,capture_output=True,timeout=150).stdout + +def main(): + manifest=authenticate() + original=ROOT/'evidence/review' + with tempfile.TemporaryDirectory(prefix='one-fusion-target-') as temporary: + review=Path(temporary)/'review' + shutil.copytree(original,review) + merge=run_script(review/'author/check_merge.py') + point=run_script(review/'author/check_compiler_point.py',review/'author') + independent=run_script(review/'check_independent.py') + for data,names in [(merge,['author/RESULT.json','author/RESULT-OPTIMIZED.json','MERGE-REPLAY.json','MERGE-REPLAY-OPTIMIZED.json']), + (point,['author/COMPILER-POINT.json','author/COMPILER-POINT-OPTIMIZED.json','POINT-REPLAY.json','POINT-REPLAY-OPTIMIZED.json']), + (independent,['INDEPENDENT.json','INDEPENDENT-OPTIMIZED.json'])]: + for name in names: + need(data==(original/name).read_bytes(),'Full regenerated receipt differs: '+name) + need(all((review/f.relative_to(original)).read_bytes()==f.read_bytes() for f in original.rglob('*') if f.is_file()),'Private frozen copy changed') + p=json.loads(point) + need(not p['physical_witness_supplied'] and not p['compiler_executed'],'Conditional admission boundary changed') + print(json.dumps({ + 'status':'PASS_CONDITIONAL_ONE_FUSION_CONSTRUCTION_TARGET_ONLY', + 'immutable_evidence_files':len(manifest['files']), + 'reviewed_report_sha256':sha256((original/'author/REPORT.md').read_bytes()).hexdigest(), + 'independent_review_sha256':sha256((original/'REVIEW.md').read_bytes()).hexdigest(), + 'merge_receipt_sha256':sha256(merge).hexdigest(), + 'compiler_point_receipt_sha256':sha256(point).hexdigest(), + 'independent_receipt_sha256':sha256(independent).hexdigest(), + 'candidate':p['kappa'], + 'tested':p['tested'], + 'hypothetical_paid_delta':{'H1':-36,'H2':18}, + 'physical_pair_supplied':False, + 'compiler_executed':False, + 'scope':'Source-bound static census and exact scalar conditional target under retained contracts. No literal pair/phase/raw-dual/native/compiler/caller or new kappa admission.' + },indent=2,sort_keys=True)) + +if __name__=='__main__': + main()