diff --git a/.gitattributes b/.gitattributes index 314f2a9c94..f76796c0c4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -15,6 +15,22 @@ references/partial-gauge/pr97/** whitespace=-blank-at-eof references/three-stage-cover/pr117/** -whitespace # PR186's manifest hashes original bytes, including two CRLF JSON artifacts. research/coordinated-frames-and-entrance-banks/** -text -whitespace + +# The target-pair manifest preserves this pinned upstream notice verbatim. +research/gen4-extra-target-pairs/NOTICE-PR283.md -text whitespace=cr-at-eol + +# Preserve every source byte covered by the gen5 composition manifest. +research/gen5-retiming-targets/** -text whitespace=cr-at-eol +# Imported native files retain their original trailing blank lines. +research/gen5-retiming-targets/code/** whitespace=cr-at-eol,-blank-at-eof + +# Preserve every source byte covered by the kernel/restoration manifest. +research/gen5-kernel-restoration/** -text whitespace=cr-at-eol +research/gen5-kernel-restoration/code/** whitespace=cr-at-eol,-blank-at-eof + +# Preserve exact manifest-covered gen5b sources and inherited notices. +research/gen5b-weighted-matching/** -text -whitespace + # Frozen PR210 package and round-nine evidence retain their audited bytes. research/five-stage-source527-banks/** -text -whitespace research/community-round9-audit/** -text -whitespace diff --git a/.github/workflows/gen4-extra-target-pairs.yml b/.github/workflows/gen4-extra-target-pairs.yml new file mode 100644 index 0000000000..099364a07b --- /dev/null +++ b/.github/workflows/gen4-extra-target-pairs.yml @@ -0,0 +1,58 @@ +name: Verify extra target pairs on gen4 composition +on: + push: + paths: + - 'research/gen4-extra-target-pairs/**' + - '.github/workflows/gen4-extra-target-pairs.yml' + pull_request: + paths: + - 'research/gen4-extra-target-pairs/**' + - '.github/workflows/gen4-extra-target-pairs.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR283 prerequisite + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: Dugongue/integer-mult-bounds + ref: 65768f62d4fde0d1fa7fc84f71678522a84aaa6c + path: build/pinned-pr283 + sparse-checkout: research/gen4-composed-endpoints120 + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Install pinned arithmetic dependency + run: python -m pip install -r build/pinned-pr283/research/gen4-composed-endpoints120/requirements.txt + - name: Replay complete prerequisites and composed construction + run: python -B research/gen4-extra-target-pairs/verify.py --base build/pinned-pr283/research/gen4-composed-endpoints120 --output /tmp/gen4-extra-target-pairs + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PY' + from pathlib import Path + for path in sorted(Path('/tmp/gen4-extra-target-pairs').rglob('*.log')): + print(path) + print('\n'.join(path.read_text(errors='replace').splitlines()[-30:])) + PY + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/.github/workflows/gen5-kernel-restoration.yml b/.github/workflows/gen5-kernel-restoration.yml new file mode 100644 index 0000000000..456ebb05d5 --- /dev/null +++ b/.github/workflows/gen5-kernel-restoration.yml @@ -0,0 +1,58 @@ +name: Verify gen5 kernels and early restoration +on: + push: + paths: + - 'research/gen5-kernel-restoration/**' + - '.github/workflows/gen5-kernel-restoration.yml' + pull_request: + paths: + - 'research/gen5-kernel-restoration/**' + - '.github/workflows/gen5-kernel-restoration.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR290 prerequisite + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: chafreaky/integer-mult-bounds + ref: 739c3bb0ad0596f427e0a72a2ebeca23277217a3 + path: build/pinned-pr290 + sparse-checkout: research/five-stage-gen5-collective-kernels + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Install pinned arithmetic dependency + run: python -m pip install -r build/pinned-pr290/research/five-stage-gen5-collective-kernels/requirements.txt + - name: Replay complete prerequisites and composed construction + run: python -B research/gen5-kernel-restoration/verify.py --base build/pinned-pr290/research/five-stage-gen5-collective-kernels --output /tmp/gen5-kernel-restoration + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PY' + from pathlib import Path + for path in sorted(Path('/tmp/gen5-kernel-restoration').rglob('*.log')): + print(path) + print('\n'.join(path.read_text(errors='replace').splitlines()[-30:])) + PY + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/.github/workflows/gen5-retiming-targets.yml b/.github/workflows/gen5-retiming-targets.yml new file mode 100644 index 0000000000..632babb5d8 --- /dev/null +++ b/.github/workflows/gen5-retiming-targets.yml @@ -0,0 +1,58 @@ +name: Verify gen5 retiming and target composition +on: + push: + paths: + - 'research/gen5-retiming-targets/**' + - '.github/workflows/gen5-retiming-targets.yml' + pull_request: + paths: + - 'research/gen5-retiming-targets/**' + - '.github/workflows/gen5-retiming-targets.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR285 prerequisite + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: DreamingOfClouds/integer-mult-bounds + ref: b40c1a3d8f40ee3764b9f13fe850f663f2d8c834 + path: build/pinned-pr285 + sparse-checkout: research/five-stage-gen5-banks + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Install pinned arithmetic dependency + run: python -m pip install -r build/pinned-pr285/research/five-stage-gen5-banks/requirements.txt + - name: Replay complete prerequisites and composed construction + run: python -B research/gen5-retiming-targets/verify.py --base build/pinned-pr285/research/five-stage-gen5-banks --output /tmp/gen5-retiming-targets + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PY' + from pathlib import Path + for path in sorted(Path('/tmp/gen5-retiming-targets').rglob('*.log')): + print(path) + print('\n'.join(path.read_text(errors='replace').splitlines()[-30:])) + PY + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/.github/workflows/gen5b-weighted-matching.yml b/.github/workflows/gen5b-weighted-matching.yml new file mode 100644 index 0000000000..d04d3b05d6 --- /dev/null +++ b/.github/workflows/gen5b-weighted-matching.yml @@ -0,0 +1,58 @@ +name: Verify gen5b weighted matching +on: + push: + paths: + - 'research/gen5b-weighted-matching/**' + - '.github/workflows/gen5b-weighted-matching.yml' + pull_request: + paths: + - 'research/gen5b-weighted-matching/**' + - '.github/workflows/gen5b-weighted-matching.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Install pinned arithmetic dependency + run: python -m pip install -r research/gen5b-weighted-matching/requirements.txt + - name: Replay all twelve stages and complete finite invoice + run: python -B research/gen5b-weighted-matching/verify.py --output /tmp/gen5b-weighted-verification + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PYTHON' + from pathlib import Path + p = Path('/tmp/gen5b-weighted-verification/failure.json') + if p.exists(): print(p.read_text()) + PYTHON + - name: Require unchanged tracked artifacts + run: git diff --exit-code + regeneration: + runs-on: ubuntu-24.04 + timeout-minutes: 30 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: '3.13' + - name: Install pinned arithmetic dependency + run: python -m pip install -r research/gen5b-weighted-matching/requirements.txt + - name: Rebuild all five bit files including weighted matching + run: python -B research/gen5b-weighted-matching/gen5bit/producer/regenerate.py --work /tmp/gen5b-weighted-regeneration + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/.github/workflows/zero-frame-target-restores.yml b/.github/workflows/zero-frame-target-restores.yml new file mode 100644 index 0000000000..ed5ab2fc68 --- /dev/null +++ b/.github/workflows/zero-frame-target-restores.yml @@ -0,0 +1,64 @@ +name: Verify zero-frame target restores +on: + push: + paths: + - 'research/zero-frame-target-restores/**' + - '.github/workflows/zero-frame-target-restores.yml' + pull_request: + paths: + - 'research/zero-frame-target-restores/**' + - '.github/workflows/zero-frame-target-restores.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR272 baseline + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: CrocSwap/integer-mult-bounds + ref: 4d23d0ee5682c99b792614bae4bc5330da19ff13 + path: build/pinned-pr272 + persist-credentials: false + - name: Obtain immutable PR271 cleanup package + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: evmckinney9/integer-mult-bounds + ref: ebc1defe8c13f39f86e5901c3437c1be52886a2b + path: build/pinned-pr271 + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Use predecessor dependencies + run: python -m pip install -r build/pinned-pr272/research/filtered-kernel-target120/requirements.txt + - name: Fresh baseline, target restores and complete exact checks + run: python -B research/zero-frame-target-restores/verify.py --base build/pinned-pr272/research/filtered-kernel-target120 --cleanup-base build/pinned-pr271/research/cleanup-sandwich-272 --output /tmp/zero-frame-restores-replay + - name: Show nested verifier diagnostics on failure + if: failure() + run: | + python - <<'PYDIAG' + from pathlib import Path + for path in sorted(Path('/tmp/zero-frame-restores-replay').rglob('*.log')): + print('\n---', path, '---') + print('\n'.join(path.read_text(errors='replace').splitlines()[-40:])) + PYDIAG + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/certificates/mixed-point-audit.json b/certificates/mixed-point-audit.json index 1f6c0fec1b..5b65e2e08a 100644 --- a/certificates/mixed-point-audit.json +++ b/certificates/mixed-point-audit.json @@ -487,7 +487,7 @@ "source_sha256": { "docs/research/mixed-point-audit.md": "c80527f9e98c27bd7f5858a06c7273f84c40e0c41505eb4d16029b61f80fb968", "scripts/experiments/mixed_point_circuit.py": "f509362b5031976a22af351fd158ae0b4520fa4f286a5176ec37023d672a7ddc", - "scripts/rational_span_frames.py": "ac3b9ab462b790d195628f0e5aa4f95143596a51ce7df1a99360b98594c29932" + "scripts/rational_span_frames.py": "766d342dd73ca5efd784c5733282a93d379a58beea763e703238dfbb4eacce82" }, "status": "BOUNDED MIXED-POINT RESEARCH; NO NEW KAPPA", "target": "1/1073741824", diff --git a/research/e8-bit-basis-order/.gitattributes b/research/e8-bit-basis-order/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/e8-bit-basis-order/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/e8-bit-basis-order/EXPECTED.json b/research/e8-bit-basis-order/EXPECTED.json new file mode 100644 index 0000000000..8866c5114c --- /dev/null +++ b/research/e8-bit-basis-order/EXPECTED.json @@ -0,0 +1,6 @@ +{ + "candidate_sha256": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "coefficient": "4133102071585442738602693393898919077364732015670619884057", + "two_level_coefficient": "1765480327964144359059818667672312184441048701945634758871470371595777703976260950775676203474324491767368886150988529342610404", + "kappa": "560432476129139/500000000000000000" +} diff --git a/research/e8-bit-basis-order/LICENSE b/research/e8-bit-basis-order/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-bit-basis-order/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/e8-bit-basis-order/MANIFEST.json b/research/e8-bit-basis-order/MANIFEST.json new file mode 100644 index 0000000000..89ba0e5d4a --- /dev/null +++ b/research/e8-bit-basis-order/MANIFEST.json @@ -0,0 +1,79 @@ +{ + "files": { + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "EXPECTED.json": "27aab0e90e1d498b866f155041044907f0b3b17a36e3688312a80c0dd9f190c5", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "7cdb6660b9678a4914ebbb8482dd57c3dc6db01bb8543233da3fd58ac8ef7269", + "PROOF.md": "d3228bae91c0457e67e10f09dcf5046abdfa23c624ea34ddd61bcb2ff77cdc91", + "README.md": "447fef83f41d4435956e551cb6bbc9cbed3dcea177d36019bf23fe1d726f4725", + "SOURCES.json": "5123a2d4cbd218ef68d67f78ba96fee736299a79242ec326f8c77ceddaffd9b9", + "VALIDATION.json": "7c757648ca3e8f7060a6e32117c6e09241c70e4d046dcdacfa319eb66cc14663", + "basis-order.patch": "59fc282490b7cf575751e9975c4ebe017a6624dc6a9cb449153f647956339843", + "inputs/COMPLETED-RUN-DRIVER.py": "a24a48cc036a31a08792896446c7efdacce08ebda12fbda8e707bd9e9f0288f2", + "inputs/SUPPLIER-MANIFEST.json": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "inputs/SUPPLIER-SOURCE-BINDING.json": "ad1451feae399995cca071345ab090f1282ca5cfe38932bb6345009ae543e2cb", + "inputs/baseline/ASSEMBLY-LOCALS.json": "029b78b4199995c40335aad52e74e60765326f355eeef7be89592bd686278cd9", + "inputs/baseline/COMPLETION.json": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "inputs/baseline/GLOBAL.json": "e84c84f41602168bae25a810737a91ba989783ace2a93944cf5ae965f3199e4c", + "inputs/baseline/RESULT.json": "3c8313d5c180cb10e1b17d2dd09d7845f571dec144954776ba4c9b86d6a75603", + "inputs/baseline/word.json.gz": "6af18cd582296da2fb97d9f645c182678df399712bef056ef1acc182602f0f7e", + "inputs/candidate/AUDIT.json": "ec0e91c2540dcce22836372d6a0692ef2d04d6fb044732eddd2820b54491625d", + "inputs/candidate/BIT-PRICE.json": "578af4b67c4d251e7fefab1b4a6dba1f2a37c9ab13659ab8efce6d600caabc5b", + "inputs/candidate/COMPLETION.json": "f97a6a3d0ce8abbca1996b17c53caa339b00524f0c10c1101a99a191132b5f08", + "inputs/candidate/FINITE-COMPARISON.json": "82572249a38d7c7f87e4d278e561c139ae0cb9f8e2cc1b4edd96ab08f57becf4", + "inputs/candidate/GEOMETRY.json.gz": "3f5cf079d6fe5aed105ea2f0a858c1096d6074a393edb62844e4b16eefc1fd3a", + "inputs/candidate/GLOBAL.json": "30431f77668cfd693eb86e351d08e71107525be17497db31638d4e685692b523", + "inputs/candidate/RESULT.json": "7498e4eac4d4e3598dce02fbe589a4c2ba98fb7b0c471a2e4e5f543b729ec217", + "inputs/candidate/audit.log": "68e8c1a8a7a267a603b784e5261b45fd3c6d45a317ef5ba85bd305b4c143dff2", + "inputs/candidate/combined.log": "5c50444eae0779587c6a70056b3d489ee3b749ea72cea7763896ff4407f5d2a2", + "inputs/candidate/export.log": "6591bd062e93bac77aa788bdda8a982ed6d63ed1e4b2d1048e099555b47a8b50", + "inputs/candidate/global.log": "1110e617dbe5b6c1b738547f3a07a48b8fa012ad4778cf65c5055ae23bf0070d", + "inputs/candidate/price.log": "e487f4822581a1b8d3746cf8a79ae6394342fca1e9c8533e970f0f0c672b5b4b", + "inputs/candidate/word.json.gz": "abcec05de4b76e7258486eb99f566c48626b32cb58959b833adb67a8e7ef9a7b", + "inputs/complex/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "inputs/complex/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "port438/COMPLETION.json": "a7a2efeef20ba6b8fa381b19bd6bd83745bdca4b2ba255de5caa863ff74eec30", + "port438/COMPLEX-REUSE-BINDING.json": "ed3c550dd9bc30512accc35facbe3100021ca3fe7fe04513c94528498eed4561", + "port438/RECEIPT-MAP.json": "56628fc0a7fdc60c578e326205d1100dfcdd3c382a3ab1613b1657a840d94b4f", + "port438/SOURCE-BINDING.json": "cdaf242ac58189968339f06dd4d01ddee2156553a48baf9cb47c514a06b3266e", + "port438/VALIDATION.json": "6435c234e8f94b3b60731d200394f59b0f2ef539c5284f6a0353f3ef8085e994", + "port438/adapter/MANIFEST.json": "e7f88237f8b0e6bd1051ad49738e60d47fc05beef11ed0af2f1ed5befaf63595", + "port438/adapter/basis_postprocess.py": "d19a6dec2c96e9d20eecd483182a6ccd783d23a7365ef756518ab77da6657393", + "port438/adapter/driver.py": "5c3295101d7eb9a8adde8900b158f094c2381829376c299c0939f39fc0827ebb", + "port438/adapter/post_stage.py": "d8189ba82a872b95960063f5c410577fc7ff0ff1029172d1daaec6f0fdce6db3", + "port438/inputs/AUDIT.json": "d5d2a4167c5ef479723f588820cd24316cca6bacb0f3a99e03909335e610c426", + "port438/inputs/BASIS-STAGE.json": "2e0600bc3be25502b2fbc8114cbcbb4e0d5b23b8665d663aaeaa74f47bfb2e8a", + "port438/inputs/CONSTRUCT.json": "cfcc6b56da99ffefcd38175542e924ab64bb4132749aaa67f9395481dfd0a88f", + "port438/inputs/FINITE-COMPARISON.json": "a982badcaa34737018dbf6aaafa79e8c94d32ff4b22cfad01dfdc412f95c509c", + "port438/inputs/GEOMETRY.json.gz": "e7cd5a0ccec5aa27d6c545ba4b35998beada6a1be7b87d644bb87e7d61326f6a", + "port438/inputs/GLOBAL.json": "b1f44877c67842c3a804590c9c691c500aaa74c4484ddfb32f273b9c82922c9e", + "port438/inputs/KERNEL.json": "3eeb80d1bf47f8902a936b11351a636e2021aabf0852a1f2242122c4c3bdb5f8", + "port438/inputs/RESULT.json": "fcdb458e99cd75afd6c4def70fa4dfc603239278e74a784b9658a66e81917d01", + "port438/inputs/original-word.json.gz": "b1152dc605041914c2fc6248e54339ad2d528ccc04ec376b39257548b26c9ad5", + "port438/inputs/word.json.gz": "810fb38be14e68798e51fb79826a0fee665c11fac7d3c09e5af6d856f7dda701", + "port438/logs/audit.log": "7f1b9d5c24e7340d0972cb1cf5ed23ee1a25ea4e3494d8baab96004c173b8baa", + "port438/logs/bit_construct.log": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933", + "port438/logs/bit_kernel.log": "c65c7919e2fef533fa828dabd1397bd5844b183aa49b9a88bbec8ad95fdaa040", + "port438/logs/bit_reset.log": "ac3ff67b486202e46a577d5c867fdce6992e93e47415346c95c4d669b1972b61", + "port438/logs/combined.log": "d63bfdf50707d012ee26e29fed7be296d20943ec22e65107e5eb61228c5f2a7a", + "port438/logs/export.log": "e57459c15c39fddf647f68eca16a169896a0e946bd495db1d4a9ad11472fc92a", + "port438/logs/global.log": "ac3f7c1e017a29fe0d5a69766d0d53345303c273c84f5ee5539dd7261a0e55fe", + "port438/logs/post_basis.log": "526515d93fd8afc8dd475042350601a7ebfcac729ca0b7795972b60378fdf4c3", + "port438/logs/price.log": "98d0243f63083c3904760bb64b266759447a118ec4fbf35bd7ce27ce2811f244", + "port438/supplier/EXPECTED.json": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "port438/supplier/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "port438/supplier/MANIFEST.json": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "port438/supplier/NOTICE.md": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "port438/supplier/SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "port438/supplier/code/complex_phases.py": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "port438/supplier/inputs/complex-phase-receipt.json": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "port438/supplier/stages/kernel-selection.json": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "postprocess.py": "d19a6dec2c96e9d20eecd483182a6ccd783d23a7365ef756518ab77da6657393", + "reproduce.py": "afb2e7a4d6e444cd3bf55e57720e00be58f348908ed8f9eb1fee9eaa921f5704", + "test_postprocess.py": "09fbe6ce946ff6e0423f84518462a9812e3c64e40519a943b6c48ed622799877", + "vendor/NOTICE-PR433.md": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389", + "vendor/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "verify.py": "4d6de0b1b13e709ce897e650b022112de134254c9154ad9ba8bf9c929e80ca00", + "verify_port.py": "d548bf9501933fa72b120ca92c544a49a89823b36ab90fe6ca6c63387f990773" + } +} diff --git a/research/e8-bit-basis-order/NOTICE.md b/research/e8-bit-basis-order/NOTICE.md new file mode 100644 index 0000000000..97ddd1b02d --- /dev/null +++ b/research/e8-bit-basis-order/NOTICE.md @@ -0,0 +1,17 @@ +# Attribution + +Basis-order selection, the finite-cost comparison, equivalence argument and +independent evidence audit are contributed by George Lydakis with substantial +OpenAI Codex assistance, including Ody. Apache-2.0; see LICENSE. + +The source-basis replacement construction and selected supplier are icekylinx's +PR433, with OpenAI Codex assistance. This contribution changes three ordering +lines in that constructor. It does not claim the source-centre reuse idea, +original E8 bit word, geometry, moment engines or outer assembly. + +The full original notice is in vendor/NOTICE-PR433.md. It retains credit to +Zhihao Chen and OpenAI Codex (PR425/386), ai-nanachi and OpenAI Codex (PR426), +Dylan Crow and Anthropic Claude (PR370), Jacob Sussman and upstream contributors. +All sources remain tied to the immutable supplier commit in SOURCES.json. + +Post-kernel source-basis postprocessor and audit: George Lydakis, with OpenAI Codex assistance. The pinned PR438 reset/kernel construction and original supplier notices are retained in port438/supplier. Original contributors retain their attribution; no claim is made to their construction or exponent. diff --git a/research/e8-bit-basis-order/PROOF.md b/research/e8-bit-basis-order/PROOF.md new file mode 100644 index 0000000000..33905b41b9 --- /dev/null +++ b/research/e8-bit-basis-order/PROOF.md @@ -0,0 +1,119 @@ +# Source-basis order and the finite coefficient + +The parent is PR433 at 6d9244518175caf9e0089f92486959bc2c317273. This changes +only the choice and order of an invertible source minor in its R758 bit word. +It does not change a supplier saving, rank profile, helper count or exponent. + +## The nine copied forms are identical + +The original constructor replaces nine retained helpers with nine independent +binary forms in the 120 original source rows. It completes these forms to an +invertible source basis, emits a sequence T of elementary XOR additions, +copies the nine selected rows sequentially, and applies the literal inverse +T^-1 before the remaining program. + +The three-line patch performs high-pivot elimination and assigns the nine +forms to the resulting pivot indices in descending order. Elimination still +proves that the completed 120-by-120 matrix is invertible. Its elementary row +operations realize exactly the selected matrix, and their reversed sequence +is its inverse over F2. The retained forms, in copy order, are exactly the +same nine forms as before. Only their source row names change. + +Every changed scalar operation has the existing full frame. Each copy has the +same rank eight, gather/child/scatter lifetime and decoded target contribution. +No source changes during a copy episode. After T^-1, all source rows return to +their original values. The surrounding A prefix, B suffix, entire D and C +words, scatter lists, helper rows, frames and start/final labels are unchanged. +Thus the parent's arbitrary-helper compensator and cleanup remain valid. + +The independent verifier checks these identities literally, reconstructs the +nine forms, and replays all 998 independent source/target/helper columns in +both orders. Removing the inverse or the dirty compensator is rejected. The +unchanged exporter and global checker also replayed the actual reflected +COPY/ERASE events with their private-work lifetimes. The source changes add +no geometric frame or phase pair; complex evidence is reused explicitly. + +## Account for the complete finite cost + +The forward basis has 575 additions instead of 559. Including its inverse, +the local word increases from 14,510 to 14,542 additions. This is not an +operation-count reduction. Both source orientations and all 72 invocations +retain their paid child profiles and stock. + +The cancellation-free bound follows each emitted addition by +N[dst] <- N[dst] + abs(coefficient)*N[src], starting each live row at one. +Private copies inherit their source bound and erase it at the end of the +episode. The actual forward/reverse maxima change from 3,885,147/15,348,208 +to 352,811/1,303,186. The verifier independently reproduces those values from +the literal words; the emitted-program checker also measured them afresh. + +The nine-stage bound is P=2^18*forward^5*reverse^4. The 18 unchanged bridge +shears account for 2^18. Thus its bit length falls from 223 to 192. +All other scalar, selector, compiler, route, copy and stock terms are charged +as in the unchanged combined certifier. In particular, the 32 additional +local additions contribute 72*32 extra units; they are not omitted. + +Recomputing the complete coefficient gives + + C = 4133102071585442738602693393898919077364732015670619884057. + +With E=321480 paid calls, the two-level coefficient (C+1)^2*(E+1)^2 has +420 bits, down from 483. The final assembly conservatively retains its +256-bit payload and 512-bit two-level charges. The row coefficient remains +18,355 < 20,161. Both rational moments, all 47 outer inequalities, bootstrap +cutoffs and invalid-parameter controls are unchanged and pass. + +This is a strict improvement to a finite overcharge on a pinned construction. +It is not evidence of a practical runtime speedup or a new numerical frontier. +The five tested minor/order choices establish no global optimality of this +basis. Newer reset/kernel words need their own reconstruction and validation +before this choice can be transferred. All inherited compiler, dirty-bank, +common-grid, restored-work, precision and analytic assumptions remain premises. + +## Transfer after a frozen upstream selection + +The same argument holds when the source-basis block follows earlier resets or +kernel transformations. Let T be the explicitly delimited source-only suffix +of A, and require that B begins with its literal inverse. Recover each copied +form by applying T to formal unit source rows. The new basis T' realizes those +same forms in the same copy order. Therefore T', copy, T'^-1 induces the same +source-to-target linear transformation as T, copy, T^-1 for every state +entering the block, including states correlated with dirty helpers. + +The postprocessor uses the actual input block and its copied forms. It requires +all basis operations at the existing full frame and preserves the set of +source rows touched by the block. Thus each affected source reaches the same +full frame, with the same rank increment; subsequent full-frame operations +add no paid frame move. Each selected copy is checked to occupy that frame. +The surrounding word, retained-form order, scatter, helper state, frame data, +and start/final labels are untouched. This algebraic argument does not replace +the supplier's legality, integer-span, ownership, or finite-invoice checks. + +PR438's 11 resets and 118 kernel entries were first reconstructed with their +original input/output hashes and controls. The postprocessor then produced +word 2be5d42a53e367648f4dd33fd4a368c61e1565f0cf7c48bfe887ca953a735063 +from the original post-kernel word cc6242d90ccdd8477521ea16f35ee2667dbe6c48cc60c6e4e9bcf6460497b233. +The unchanged integer-span replay gave the same local paid histogram; both +literal orientations restore all 987 columns. The original kernel receipt +continues to identify its original output, and BASIS-STAGE.json binds the +separate transformation. No upstream selection or receipt was repinned. + +The fresh emitted-program verification measures prefix maxima 352,915 and +1,686,810, versus 4,749,873 and 18,976,454 from the original word. Both words +have the same 727 banks per stage, 14,223 live and 14,232 physical families, +328,536 paid calls, rank deficit 2,496, and row coefficient 18,355. The local +addition counts are 14,725 and 14,757. With all extra additions charged, the +candidate coefficient is + + C = 11618636861972555523343873296287586172648663760810665400081. + +Its 193-bit coefficient and 423-bit two-level coefficient strictly improve the +algebraically reconstructed baseline's 226 and 488 bits. The baseline uses the +same verified schedule/geometry and its own literal prefix and addition count; +there was no second baseline global run. The fresh candidate's unchanged +combined certifier passes both moment engines, all 47 strict inequalities, +eight bank controls and four outer controls. The 256/512 conservative charges +and κ are unchanged. The completed PR433 complex receipts are reused as a +separate component: compared scientific sources match except the phase guard +and receipt representation, whose actual canonical gzip/payload and recipe +hashes satisfy both versions. This is not a fresh PR438 complex replay. diff --git a/research/e8-bit-basis-order/README.md b/research/e8-bit-basis-order/README.md new file mode 100644 index 0000000000..c57740aafd --- /dev/null +++ b/research/e8-bit-basis-order/README.md @@ -0,0 +1,91 @@ +# Smaller finite overcharge from source-basis ordering + +A three-line source-minor ordering change reduces the finite coefficient of +the pinned [PR433](https://github.com/CrocSwap/integer-mult-bounds/pull/433) +bit construction from 223 to 192 bits, and its two-level coefficient from +483 to 420 bits. It adds 32 local XOR additions, which are fully charged. +The saving comes from a lower cancellation-free prefix bound. + +**The supplier caps and multiplication exponent are unchanged.** This is a +finite-accounting improvement, not a practical speed benchmark or a claim to +the current numerical lead. Newer supplier proposals report higher exponents. + +The selected change is `basis-order.patch`; PROOF.md proves equivalence of the +nine copied forms and explains the cost comparison. It preserves every frame, +rank, helper count and surrounding scalar operation. Five deterministic +minor/order choices were screened; global basis optimality is not claimed. + +Run the self-contained standard-library audit: + +```sh +python3 -B research/e8-bit-basis-order/verify.py +``` + +It checks package/source bindings, both literal 998-column orientations, +inverse/dirty-compensator rejection, exact prefix growth, all finite invoice +terms, and the retained five-stage verification receipts. It does not rerun +the global construction or Gaussian phases. + +The actual changed-component run used the unmodified pinned exporter, global +checker, independent audit, price engine and combined certifier. All five +stages passed. The complex component receipts were reused from the completed +source replay. That run and the independent audit retain all source/output +hashes, stage logs and exact coefficients. + +The source package is pinned to commit +`6d9244518175caf9e0089f92486959bc2c317273` in +[`icekylinx/integer-mult-bounds`](https://github.com/icekylinx/integer-mult-bounds/tree/6d9244518175caf9e0089f92486959bc2c317273/research/split-centres-global). +`reproduce.py --source /path/to/that/package --check-inputs` validates the +portable reconstruction inputs without rerunning the scientific stages. +Use `--output /absolute/path/to/new/output` instead to reconstruct the candidate +and replay the five changed-bit stages. Original package bytes are preserved. +The portable wrapper has input-only validation; the completed scientific run +used the separately retained driver described in VALIDATION.json. + +All conditional supplier/compiler/common-grid/precision/analytic interfaces +remain assumptions. Transferring this choice to later reset/kernel words +requires fresh reconstruction and verification, not replacement of a hash. +Original contribution notices and licenses are preserved. + +## Reusable postprocessing after reset and kernel stages + +`postprocess.py` now derives the copied forms from the actual input word and +constructs the reordered basis. It does not contain a hardcoded PR433 basis. +For a compatible word with an explicitly delimited, full-frame source basis: + +```sh +python3 -B research/e8-bit-basis-order/postprocess.py original.json candidate.json +python3 -B research/e8-bit-basis-order/test_postprocess.py +``` + +The output must be a new file. The tool checks the original literal inverse, +source-only operations, independent copied forms, and the set of source rows +entering the full frame. It preserves its input. Its output is a candidate; +run the supplier's unchanged local, reflected, global, pricing and invoice +checks before using it. This ordering is not guaranteed to improve every word. + +The `port438` evidence applies this tool **after** the original reset and +kernel checks in [PR438](https://github.com/CrocSwap/integer-mult-bounds/pull/438), +pinned at `e3b56de7869f6af88d48ac0ab1d7959c4c9e6176`. Their original selection +hashes and receipt remain intact. A separate basis-stage receipt binds the +new word. All nine changed-bit stages passed in one execution, including the +original global checks and combined certifier. + +| Pinned construction | Finite coefficient bits | Two-level coefficient bits | Extra local additions | +| --- | ---: | ---: | ---: | +| PR433 R758 | 223 to 192 | 483 to 420 | 32 | +| PR438 R747 after resets/kernel | 226 to 193 | 488 to 423 | 32 | + +For PR438, both supplier caps and κ = 45340333148791/40000000000000000 remain +unchanged. The candidate invoice comes from fresh emitted-program checks. +The baseline cost is reconstructed from its literally replayed word and the +unchanged geometry/schedule; its full global pipeline was not rerun. +Completed PR433 complex-component evidence is reused with explicit source, +canonical-word and recipe bindings. No new complex or phase replay is claimed. + +The default `verify.py` also audits this port, the original/new word identities, +both 987-column orientations, actual prefix growth, complete finite invoice, +source pins, stage logs, and retained controls. `port438/adapter` preserves the +exact executed scripts and their original temporary paths as evidence; it is +not a portable CLI. The standalone postprocessor and audit commands above are +portable. `port438/VALIDATION.json` records these validation boundaries. diff --git a/research/e8-bit-basis-order/SOURCES.json b/research/e8-bit-basis-order/SOURCES.json new file mode 100644 index 0000000000..93142d7044 --- /dev/null +++ b/research/e8-bit-basis-order/SOURCES.json @@ -0,0 +1,132 @@ +{ + "repository": "icekylinx/integer-mult-bounds", + "commit": "6d9244518175caf9e0089f92486959bc2c317273", + "supplier_manifest_sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "files": [ + { + "path": "inputs/baseline/word.json.gz", + "original_sha256": "015811014644ed62acba1da590d9cf6ebdfe834d89867f8ce2b68722609072ea", + "gzip": true + }, + { + "path": "inputs/baseline/GLOBAL.json", + "original_sha256": "e84c84f41602168bae25a810737a91ba989783ace2a93944cf5ae965f3199e4c", + "gzip": false + }, + { + "path": "inputs/baseline/RESULT.json", + "original_sha256": "3c8313d5c180cb10e1b17d2dd09d7845f571dec144954776ba4c9b86d6a75603", + "gzip": false + }, + { + "path": "inputs/candidate/word.json.gz", + "original_sha256": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "gzip": true + }, + { + "path": "inputs/candidate/GLOBAL.json", + "original_sha256": "30431f77668cfd693eb86e351d08e71107525be17497db31638d4e685692b523", + "gzip": false + }, + { + "path": "inputs/candidate/RESULT.json", + "original_sha256": "7498e4eac4d4e3598dce02fbe589a4c2ba98fb7b0c471a2e4e5f543b729ec217", + "gzip": false + }, + { + "path": "inputs/candidate/GEOMETRY.json.gz", + "original_sha256": "a5515888fffad2f82f7cde74af80cf5fc5a5197974104b63699305b9faeb1889", + "gzip": true + }, + { + "path": "inputs/candidate/AUDIT.json", + "original_sha256": "ec0e91c2540dcce22836372d6a0692ef2d04d6fb044732eddd2820b54491625d", + "gzip": false + }, + { + "path": "inputs/candidate/BIT-PRICE.json", + "original_sha256": "578af4b67c4d251e7fefab1b4a6dba1f2a37c9ab13659ab8efce6d600caabc5b", + "gzip": false + }, + { + "path": "inputs/candidate/COMPLETION.json", + "original_sha256": "f97a6a3d0ce8abbca1996b17c53caa339b00524f0c10c1101a99a191132b5f08", + "gzip": false + }, + { + "path": "inputs/candidate/FINITE-COMPARISON.json", + "original_sha256": "82572249a38d7c7f87e4d278e561c139ae0cb9f8e2cc1b4edd96ab08f57becf4", + "gzip": false + }, + { + "path": "inputs/candidate/export.log", + "original_sha256": "6591bd062e93bac77aa788bdda8a982ed6d63ed1e4b2d1048e099555b47a8b50", + "gzip": false + }, + { + "path": "inputs/candidate/global.log", + "original_sha256": "1110e617dbe5b6c1b738547f3a07a48b8fa012ad4778cf65c5055ae23bf0070d", + "gzip": false + }, + { + "path": "inputs/candidate/audit.log", + "original_sha256": "68e8c1a8a7a267a603b784e5261b45fd3c6d45a317ef5ba85bd305b4c143dff2", + "gzip": false + }, + { + "path": "inputs/candidate/price.log", + "original_sha256": "e487f4822581a1b8d3746cf8a79ae6394342fca1e9c8533e970f0f0c672b5b4b", + "gzip": false + }, + { + "path": "inputs/candidate/combined.log", + "original_sha256": "5c50444eae0779587c6a70056b3d489ee3b749ea72cea7763896ff4407f5d2a2", + "gzip": false + }, + { + "path": "inputs/complex/INTEGRATION.json", + "original_sha256": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "gzip": false + }, + { + "path": "inputs/complex/INDEPENDENT-REPLAY.json", + "original_sha256": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "gzip": false + }, + { + "path": "inputs/baseline/COMPLETION.json", + "original_sha256": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "gzip": false + }, + { + "path": "inputs/SUPPLIER-MANIFEST.json", + "original_sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "gzip": false + }, + { + "path": "inputs/SUPPLIER-SOURCE-BINDING.json", + "original_sha256": "ad1451feae399995cca071345ab090f1282ca5cfe38932bb6345009ae543e2cb", + "gzip": false + }, + { + "path": "inputs/baseline/ASSEMBLY-LOCALS.json", + "original_sha256": "029b78b4199995c40335aad52e74e60765326f355eeef7be89592bd686278cd9", + "gzip": false + }, + { + "path": "vendor/bit_construct.py", + "original_sha256": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "gzip": false + }, + { + "path": "LICENSE", + "original_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "gzip": false + }, + { + "path": "vendor/NOTICE-PR433.md", + "original_sha256": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389", + "gzip": false + } + ] +} diff --git a/research/e8-bit-basis-order/VALIDATION.json b/research/e8-bit-basis-order/VALIDATION.json new file mode 100644 index 0000000000..2dc59855e5 --- /dev/null +++ b/research/e8-bit-basis-order/VALIDATION.json @@ -0,0 +1,42 @@ +{ + "status": "PASS_CHANGED_BIT_FINITE_COST_AND_INDEPENDENT_AUDIT", + "python": "3.14.8", + "supplier_commit": "6d9244518175caf9e0089f92486959bc2c317273", + "supplier_manifest_sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "scientific_stages": [ + "export", + "global", + "audit", + "price", + "combined" + ], + "scientific_run_seconds": 3.5411427090875804, + "completed_driver_sha256": "a24a48cc036a31a08792896446c7efdacce08ebda12fbda8e707bd9e9f0288f2", + "completed_run_sha256": "f97a6a3d0ce8abbca1996b17c53caa339b00524f0c10c1101a99a191132b5f08", + "independent_review": { + "source_inputs": 46, + "output_hashes": 22, + "local_columns_each_orientation": 998, + "global_columns": 7782, + "bank_assignments": 54576, + "bank_controls": 8, + "strict_outer_constraints": 47, + "outer_controls": 4 + }, + "local_additions": [ + 14510, + 14542 + ], + "coefficient_bits": [ + 223, + 192 + ], + "two_level_coefficient_bits": [ + 483, + 420 + ], + "coarse_caps_and_kappa_unchanged": true, + "phase_replay": false, + "complex_component": "exact completed source receipts reused", + "portable_wrapper_validation": "input-only; exact derived constructor and unchanged stage/input bindings checked; no second full scientific run" +} diff --git a/research/e8-bit-basis-order/basis-order.patch b/research/e8-bit-basis-order/basis-order.patch new file mode 100644 index 0000000000..7eee7b7a92 --- /dev/null +++ b/research/e8-bit-basis-order/basis-order.patch @@ -0,0 +1,19 @@ +--- a/research/split-centres-global/code/bit_construct.py ++++ b/research/split-centres-global/code/bit_construct.py +@@ -57,13 +57,13 @@ + # Find an invertible minor, preserving the original order of centre rows. + echelon = {} + for row in rows: +- for p, q in sorted(echelon.items()): ++ for p, q in sorted(echelon.items(), reverse=True): + if row >> p & 1: + row ^= q + assert row, 'Retained forms must be independent' +- p = (row & -row).bit_length() - 1 ++ p = row.bit_length() - 1 + echelon[p] = row +- pivots = sorted(echelon) ++ pivots = sorted(echelon, reverse=True) + matrix = [1 << i for i in range(v)] + for p, row in zip(pivots, rows): + matrix[p] = row diff --git a/research/e8-bit-basis-order/inputs/COMPLETED-RUN-DRIVER.py b/research/e8-bit-basis-order/inputs/COMPLETED-RUN-DRIVER.py new file mode 100644 index 0000000000..1f3dd8a581 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/COMPLETED-RUN-DRIVER.py @@ -0,0 +1,29 @@ +from pathlib import Path +import os,sys,json,hashlib,subprocess,gzip,time,resource +S=Path('/tmp/task2-pr433-immutable-static');B=Path('/tmp/task2-pr433-default-envelope/run');V=Path('/tmp/task2-r758-basis-screen/high_reverse/bit426-source-centres/bit-source-centres.json');O=Path('/tmp/task2-r758-high-reverse-finite-fresh') +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def closure():return {p.relative_to(S).as_posix():sha(p) for p in S.rglob('*') if p.is_file() and p.name!='MANIFEST.json'} +if not __debug__ or sys.flags.optimize:raise RuntimeError('assertions disabled') +if O.exists():raise RuntimeError('fresh output required') +start=time.monotonic() +PIN='3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f' +assert sha(S/'MANIFEST.json')==PIN +completed=B.parent/'COMPLETION.json'; cr=json.loads(completed.read_text());assert cr['status']=='PASS_RETAINED_DEFAULT_PR433_REPLAY' and cr['returncode']==0 and cr['source_manifest_before']==cr['source_manifest_after']==PIN +manifest=json.loads((S/'MANIFEST.json').read_text());before=closure();assert before==manifest['files'];assert sha(V)=='ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453' +O.mkdir();(O/'scratch').mkdir();reused={} +for src,dst in [('work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz','work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz'),('inherited/bit-geometry.json.gz','inherited/bit-geometry.json.gz'),*[(f'work/pr361/code/engines/{n}.py',f'work/pr361/code/engines/{n}.py') for n in ['moment','base_two_moment','outer']],*[(f'split-centres/{n}.json',f'split-centres/{n}.json') for n in ['INTEGRATION','INDEPENDENT-REPLAY']]]: + assert sha(B/src)==cr['output_hashes']['run/'+src] + p=O/dst;p.parent.mkdir(parents=True,exist_ok=True);p.write_bytes((B/src).read_bytes());reused[src]=sha(B/src) +p=O/'bit426-source-centres';p.mkdir();(p/'bit-source-centres.json').write_bytes(V.read_bytes()) +input_before=dict(candidate=sha(V),baseline_completion=sha(completed),**reused) +def inputs_now():return dict(candidate=sha(V),baseline_completion=sha(completed),**{k:sha(B/k) for k in reused}) +env=dict(os.environ,E8_OUTPUT=str(O),PYTHONDONTWRITEBYTECODE='1',PYTHONINTMAXSTRDIGITS='0',TMPDIR=str(O/'scratch'));env.pop('PYTHONOPTIMIZE',None) +steps=[] +try: + for name,script,args in [('export','vendor/export_records.py',[p/'bit-source-centres.json',p/'records']),('global','code/bit_global.py',['--source',p,'--local-check',p,'--out',p/'global']),('audit','code/bit_audit.py',['--local-check',p,'--out',p/'global']),('price','code/bit_price.py',[]),('combined','code/combined.py',[])]: + with (O/(name+'.log')).open('w') as log:r=subprocess.run([sys.executable,'-B',str(S/script),*map(str,args)],cwd=O,env=env,stdout=log,stderr=subprocess.STDOUT) + steps.append(dict(name=name,returncode=r.returncode,log_sha256=sha(O/(name+'.log'))));assert r.returncode==0,(name,r.returncode) + assert closure()==before and inputs_now()==input_before + (O/'COMPLETION.json').write_text(json.dumps(dict(status='PASS_CHANGED_BIT_FINITE_CHECK',scope='changed bit only; unchanged complex receipts reused; no phase replay',source_manifest_sha256=sha(S/'MANIFEST.json'),candidate_sha256=sha(V),reused=reused,input_before=input_before,input_after=inputs_now(),steps=steps,wall_seconds=time.monotonic()-start,child_usage=list(resource.getrusage(resource.RUSAGE_CHILDREN)),output_hashes={p.relative_to(O).as_posix():sha(p) for p in O.rglob('*') if p.is_file()}),indent=2)+'\n') +except BaseException as e: + (O/'FAILURE.json').write_text(json.dumps(dict(error=repr(e),steps=steps,source_unchanged=closure()==before,input_unchanged=inputs_now()==input_before,wall_seconds=time.monotonic()-start),indent=2)+'\n');raise diff --git a/research/e8-bit-basis-order/inputs/SUPPLIER-MANIFEST.json b/research/e8-bit-basis-order/inputs/SUPPLIER-MANIFEST.json new file mode 100644 index 0000000000..1695125698 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/SUPPLIER-MANIFEST.json @@ -0,0 +1,51 @@ +{ + "format": "split-centres-global-manifest/1", + "files": { + ".gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "EXPECTED.json": "9b8e56eee3d5bdabd2e3e6e4ba0d9eba537525fba25a54126f9f0e41d2491a06", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389", + "PROOF.md": "6983e75f29af6eeaab20a30b08307ec6fab75ccb8b10291df8f9eb04d497f894", + "README.md": "b432292594adf2fcba2a8ddd87eda6167c76ff055e85aa5e3e2af7dd7e0f976e", + "SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "VALIDATION.json": "656d9bd7bd66058fdeb60cc90bd887e7ce75c0e0f9a100514e2bd84b95de89b6", + "code/bit_audit.py": "7fdbc077b7501a53662769ff2bf2ab44cc2e32dafc34478d7ef2c10e3144503a", + "code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "code/bit_global.py": "3b2cb3ba21e5cf9b4deddb9e606322f33e9d8082020c0ee9092c21f4ebd9ad48", + "code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "code/combined.py": "9c5bc70f2331b7342ceb252adcddb993581c45f80c37bcc58642dbad3b9775c2", + "code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "code/complex_phases.py": "13a959c52092776ae217df554b51c0298fa9eb3a350279acff6dece651c3f9cc", + "code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "inputs/complex-phase-receipt.json": "01763fee5017745de982f2ff5ee68004e815d6684097cc88011dfbfb1e789581", + "inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "verify.py": "12fcdb20a87f75812b09c4916fbfc86305982cb410247186a123b5c58d517b4c" + } +} diff --git a/research/e8-bit-basis-order/inputs/SUPPLIER-SOURCE-BINDING.json b/research/e8-bit-basis-order/inputs/SUPPLIER-SOURCE-BINDING.json new file mode 100644 index 0000000000..32d91d9b3d --- /dev/null +++ b/research/e8-bit-basis-order/inputs/SUPPLIER-SOURCE-BINDING.json @@ -0,0 +1,241 @@ +{ + "head": "6d9244518175caf9e0089f92486959bc2c317273", + "repository": "icekylinx/integer-mult-bounds", + "files": [ + { + "path": ".gitattributes", + "git_blob": "a251e913f29ecb0540e6dd6f040e23a599dcf385", + "sha256": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e" + }, + { + "path": "CERTIFICATE.json", + "git_blob": "7e807079c1ec4907306035c84be1ba2fb1d69d79", + "sha256": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4" + }, + { + "path": "EXPECTED.json", + "git_blob": "de7c122419325de627528c2b1956e497bae30b39", + "sha256": "9b8e56eee3d5bdabd2e3e6e4ba0d9eba537525fba25a54126f9f0e41d2491a06" + }, + { + "path": "LICENSE", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "MANIFEST.json", + "git_blob": "16951256986998a0cae0f388aec754f963a11c06", + "sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f" + }, + { + "path": "NOTICE.md", + "git_blob": "b7daf8de493d4c6507236f8fc42a6dcf47747577", + "sha256": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389" + }, + { + "path": "PROOF.md", + "git_blob": "8366a89e365cb8a5d7e27e8af1a69155b90f8612", + "sha256": "6983e75f29af6eeaab20a30b08307ec6fab75ccb8b10291df8f9eb04d497f894" + }, + { + "path": "README.md", + "git_blob": "1e31463921e76627f361148b967ea0e507f9723d", + "sha256": "b432292594adf2fcba2a8ddd87eda6167c76ff055e85aa5e3e2af7dd7e0f976e" + }, + { + "path": "SOURCES.json", + "git_blob": "215f58a649c020caab3a5759680b8b8a95ff0d65", + "sha256": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be" + }, + { + "path": "VALIDATION.json", + "git_blob": "70b00c0bc75e02e761aea4e0eb0f0d89c64741b0", + "sha256": "656d9bd7bd66058fdeb60cc90bd887e7ce75c0e0f9a100514e2bd84b95de89b6" + }, + { + "path": "code/bit_audit.py", + "git_blob": "82e1663e58ca51c4528f85e426f86e177938ada6", + "sha256": "7fdbc077b7501a53662769ff2bf2ab44cc2e32dafc34478d7ef2c10e3144503a" + }, + { + "path": "code/bit_construct.py", + "git_blob": "e43632e95fee1d310553596950daef04d2a32b45", + "sha256": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f" + }, + { + "path": "code/bit_global.py", + "git_blob": "5ccf622825bf66cecc12311b0d669e1b346c2279", + "sha256": "3b2cb3ba21e5cf9b4deddb9e606322f33e9d8082020c0ee9092c21f4ebd9ad48" + }, + { + "path": "code/bit_price.py", + "git_blob": "005da012a3cf28c2e9564b0fd7ba5300ae067c4d", + "sha256": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee" + }, + { + "path": "code/combined.py", + "git_blob": "4131327bce31241e71d2d1502959627b1bf32bce", + "sha256": "9c5bc70f2331b7342ceb252adcddb993581c45f80c37bcc58642dbad3b9775c2" + }, + { + "path": "code/complex_audit.py", + "git_blob": "ba6789a3a636ea0204786bb0347c495ebba185b8", + "sha256": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330" + }, + { + "path": "code/complex_construct.py", + "git_blob": "bbc61e57dc320640a6df5023c23b2483ce2a3f72", + "sha256": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f" + }, + { + "path": "code/complex_emit.py", + "git_blob": "e5fe7b34892e5a1ddbae48b39644f85f25d48a71", + "sha256": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1" + }, + { + "path": "code/complex_integrate.py", + "git_blob": "ffa5c036d7409c3b90d598b64327ae53be1c52df", + "sha256": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f" + }, + { + "path": "code/complex_phases.py", + "git_blob": "88d6afa04595b1fcea5af5f4cd7c428364274e59", + "sha256": "13a959c52092776ae217df554b51c0298fa9eb3a350279acff6dece651c3f9cc" + }, + { + "path": "code/complex_phases_full.py", + "git_blob": "b5a5bd64b4dd83a6c75ed97363cd28c0ea74ac0a", + "sha256": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466" + }, + { + "path": "code/complex_replay.py", + "git_blob": "e9f0490478a7d23d5c88fb076e837350163f9387", + "sha256": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9" + }, + { + "path": "inputs/bit-geometry.json.gz", + "git_blob": "19725bec462cbc531e180934c9af965d3ce0637f", + "sha256": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1" + }, + { + "path": "inputs/bit-r767.json.gz", + "git_blob": "807cea53ebe1322721463ee2319bcd52b9714f24", + "sha256": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7" + }, + { + "path": "inputs/complex-data-phases.json.gz", + "git_blob": "22154a8c5875bd3398e1cb112ea0a5307d6793e8", + "sha256": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f" + }, + { + "path": "inputs/complex-phase-receipt.json", + "git_blob": "23d650bc5330686f4785abe19a1d701575f2028a", + "sha256": "01763fee5017745de982f2ff5ee68004e815d6684097cc88011dfbfb1e789581" + }, + { + "path": "inputs/complex-phase-recipes.json.gz", + "git_blob": "03dc5fbe5e54c0f5fe0e104c2d1b27ab6adcfee2", + "sha256": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671" + }, + { + "path": "inputs/complex-ports.json.gz", + "git_blob": "ccbdc0596c33ea2e02649a740bdc2273ef320a58", + "sha256": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b" + }, + { + "path": "inputs/complex-template.json.gz", + "git_blob": "975ce5c0df3e4a7aa22264df7f13b592bd2318e6", + "sha256": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e" + }, + { + "path": "inputs/e8-r865.json.gz", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "path": "notices/NOTICE-PR352.md", + "git_blob": "4f9a0194a34a6b3b431d5b452655a2bc787fdb95", + "sha256": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524" + }, + { + "path": "notices/NOTICE.md", + "git_blob": "c244e3f56a947a926ae2b8fd624e677d10da8957", + "sha256": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3" + }, + { + "path": "notices/PR386.txt", + "git_blob": "28cfebeb08cdcc5bfa61efca17276237289219e5", + "sha256": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1" + }, + { + "path": "notices/PR426-SOURCE-PINS.json", + "git_blob": "24a25d43424e5d41efcde9b2846d8104186fe028", + "sha256": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f" + }, + { + "path": "notices/PR426.md", + "git_blob": "2a7a8c0c6bf6c50348b1c38ae72711a72083b9df", + "sha256": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da" + }, + { + "path": "notices/SUSSMAN-NOTICE", + "git_blob": "63aa295646734f62c4270e653811530f9a570d3a", + "sha256": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81" + }, + { + "path": "proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "git_blob": "c4150cb693414c098690eae79b3aea5f47c184ff", + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + }, + { + "path": "proofs/PR386-BIT-GEOMETRY.txt", + "git_blob": "31efe312680fdafba0ccfb630bb6b711acad5944", + "sha256": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2" + }, + { + "path": "proofs/PR425-COMPLEX.txt", + "git_blob": "41061757ce0af663f589e4ca8e58b6dec39d028c", + "sha256": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc" + }, + { + "path": "proofs/PR426.md", + "git_blob": "e589cfbf5060a05b57facc0e2f1b545b4d73b3fc", + "sha256": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb" + }, + { + "path": "vendor/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "vendor/engines/base_two_moment.py", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61", + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098" + }, + { + "path": "vendor/engines/moment.py", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482" + }, + { + "path": "vendor/engines/outer.py", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + { + "path": "vendor/export_records.py", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + { + "path": "vendor/hamming_packets.py", + "git_blob": "c1299966560e91a52cd2c39783f23ef8d8648eaa", + "sha256": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5" + }, + { + "path": "verify.py", + "git_blob": "01d78bf0d141c8b963c63bfd253e991b152f80c9", + "sha256": "12fcdb20a87f75812b09c4916fbfc86305982cb410247186a123b5c58d517b4c" + } + ] +} diff --git a/research/e8-bit-basis-order/inputs/baseline/ASSEMBLY-LOCALS.json b/research/e8-bit-basis-order/inputs/baseline/ASSEMBLY-LOCALS.json new file mode 100644 index 0000000000..e9b98b22c6 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/baseline/ASSEMBLY-LOCALS.json @@ -0,0 +1,10 @@ +{ + "status": "PASS_UNCHANGED_PR433_ASSEMBLY_LOCALS", + "combined_source_sha256": "9c5bc70f2331b7342ceb252adcddb993581c45f80c37bcc58642dbad3b9775c2", + "coefficient": "12876798640781570347842183363526300622257813041266401296637090677017", + "two_level_coefficient": "17136669865013682256047034150149966782226658034137605324783697895173582461590159743547993072348173042127644485601412302713170608915528813894100964", + "route_items": 746736, + "selectors": 1427176656, + "unit_additions": 1062000, + "source_result_sha256": "3c8313d5c180cb10e1b17d2dd09d7845f571dec144954776ba4c9b86d6a75603" +} diff --git a/research/e8-bit-basis-order/inputs/baseline/COMPLETION.json b/research/e8-bit-basis-order/inputs/baseline/COMPLETION.json new file mode 100644 index 0000000000..c56ba13ef1 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/baseline/COMPLETION.json @@ -0,0 +1,63 @@ +{ + "status": "PASS_RETAINED_DEFAULT_PR433_REPLAY", + "returncode": 0, + "error": null, + "wall_seconds": 6.193095125025138, + "child_user_seconds": 6.00906, + "child_system_seconds": 0.142404, + "child_peak_rss_bytes_macos": 176357376, + "source_manifest_before": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "source_manifest_after": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "phase_mode": "source-bound evidence reused; no all-pair phase replay", + "output_hashes": { + "DRIVER.log": "028a6067de8c3a61dfbf81c5d9c8d3629949b70cc118b64264f25df4b84a64ac", + "LAUNCH.json": "326c4f222543637b9eac16153e2f43993c629cf574036f5bc34d9ca700cf6622", + "run/complex_emit.log": "5bc5e23a3a722fe5484b8603dfe38870c66841c1469ba6685eee6a1b7251d566", + "run/RESULT.json": "3c8313d5c180cb10e1b17d2dd09d7845f571dec144954776ba4c9b86d6a75603", + "run/bit_price.log": "e487f4822581a1b8d3746cf8a79ae6394342fca1e9c8533e970f0f0c672b5b4b", + "run/hamming_packets.log": "2338da125e564481cac168871ab334ded72960d35f73fdabc9a83d3428cd1125", + "run/complex_construct.log": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/complex_phases.log": "3f57c055c80416ad7244dc762051c9bac6ecb74983e460b7876541570bc35bc2", + "run/complex_integrate.log": "32938be76f990be50950051263c8a765da1b00aafe9af455ee775f190e4839a7", + "run/complex_replay.log": "04a057c55168c3dbfe452a4fc62fc90f55f1844d9e8c62e48e78e59b58ae1137", + "run/combined.log": "fef1d8867a50212df361e28e768fffa809a4f4be81de4aaef833d313187dd1eb", + "run/bit_global.log": "c900fc692166ac4f308da4c093affd973570fcc68f42adf74892da813d5b56fd", + "run/bit_construct.log": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933", + "run/BIT-PRICE.json": "5226d8a114fa275f55b1b42ade7b80608d0872c25211ee03f97c572bc626a6d7", + "run/complex_audit.log": "76b9768bddbd48d0511c4d542110e92bc123bb5932779bc25306fc7522c99eb8", + "run/bit_export.log": "292c80db0fc7026a134d52d452a77ff13b5f8bc9701fd35b4183619511d96f2e", + "run/bit_audit.log": "16ed4221099b5ae6752379e90192161be048ea7aea7ed270df6d6893244f8b11", + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd", + "run/bit426-source-centres/bit-input.json": "7a395dd0452b0832f7ffce7148589eafc627b8cf0349a81803fd897e7a24a388", + "run/bit426-source-centres/bit-source-centres-receipt.json": "cfcc6b56da99ffefcd38175542e924ab64bb4132749aaa67f9395481dfd0a88f", + "run/bit426-source-centres/bit-source-centres.json": "015811014644ed62acba1da590d9cf6ebdfe834d89867f8ce2b68722609072ea", + "run/inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "run/work/complex-nine-native/DATA-PHASES.json": "f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a", + "run/work/complex-nine-native/GLOBAL-TEMPLATE.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "run/work/odd-stages/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "run/work/complex-network/hamming/PACKET-PROGRAMS.json.gz": "0a6b0a00664fccad24d4d8508b1880deeb664c8039e20229bce79a2776d76dfb", + "run/work/complex-network/hamming/PROTOTYPE.json": "894343e2dc8c5506dbbf7d199a83bcdc76b707cf37daf3fbecfc0f0ba4877617", + "run/work/higher-stage-e8/verified/gcert1-e8-retimed.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "run/work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "run/work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "run/work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "run/work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "run/bit426-source-centres/records/249-records.bin": "fcc06bc2315d8da0468334c19716eea65bad38945f342635d999901a82d81816", + "run/bit426-source-centres/records/249-states.json": "7b2f18002b619a7ceef98d2432a1a6a5683079a48344510f2139a57f54588cad", + "run/bit426-source-centres/records/frames.json": "884480e45865a9d9d57f5f7198844a64271b046bc95e9820efbefb9e10878330", + "run/bit426-source-centres/global/GEOMETRY.json": "86ab83441723c5e76b32db764f38a32afbc52392f24c3a83091ff695cfe3ddf4", + "run/bit426-source-centres/global/AUDIT.json": "d9458a572a3bc60023a7e367c24e25559bc72498c6772f87955f58058547ec57", + "run/bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz": "e7882a18ed53e85f4a511a9d3d3502e4484b7e1b2e09f4f9d9a90466838708d0", + "run/bit426-source-centres/global/GLOBAL.json": "e84c84f41602168bae25a810737a91ba989783ace2a93944cf5ae965f3199e4c" + } +} diff --git a/research/e8-bit-basis-order/inputs/baseline/GLOBAL.json b/research/e8-bit-basis-order/inputs/baseline/GLOBAL.json new file mode 100644 index 0000000000..eff4153ec4 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/baseline/GLOBAL.json @@ -0,0 +1,164 @@ +{ + "status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", + "h": 8, + "m": 64, + "v": 120, + "R": 758, + "replicas": 8, + "live": 14502, + "physical": 14511, + "word_sha256": "015811014644ed62acba1da590d9cf6ebdfe834d89867f8ce2b68722609072ea", + "source_records_sha256": "fcc06bc2315d8da0468334c19716eea65bad38945f342635d999901a82d81816", + "local_checks": { + "forward": { + "copies": 9, + "adds": 14510, + "records": 18744, + "all_columns": 998, + "cancellation_free_row_l1": 3885147, + "profile": { + "1": 2367, + "2": 875, + "3": 475, + "4": 321, + "5": 164, + "7": 14, + "8": 9 + }, + "sha256": "5036a9d9a8efcc2b0b0eb496e232b303da3f1927c4030af6a9b9f6db521589bb" + }, + "reverse": { + "copies": 9, + "adds": 14510, + "records": 18744, + "all_columns": 998, + "cancellation_free_row_l1": 15348208, + "profile": { + "1": 2367, + "2": 875, + "3": 475, + "4": 321, + "5": 164, + "7": 14, + "8": 9 + }, + "sha256": "0a00237f14ce17de83ed711f12e4fc9506cfab8891b2b512fb765afdd4a20986" + } + }, + "scalar_stages": [ + { + "stage": 0, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 1, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 2, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 3, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 4, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 5, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 6, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 7, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 8, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + } + ], + "independent_unbanked_scalar_columns": 7782, + "all_scalar_columns_restored": true, + "geometry_sha256": "86ab83441723c5e76b32db764f38a32afbc52392f24c3a83091ff695cfe3ddf4", + "template_sha256": "c40f89a2ae3c2c5635ddf8f18d74f24567ddf67fc8c8e93a1fc7a1a8098e857e", + "emitted_program_sha256": "42e8a046fb4ede575eeeea22eb05bb5cdaf56f524f4829036d3d4555267d3c6a", + "emitted_events": 1349568, + "local_invocations": 72, + "bank_assignments": 54576, + "banks_per_stage": 758, + "whole_rank8_slots_per_bank": 8, + "padding_calls": 0, + "profile": { + "1": 170424, + "2": 63000, + "3": 34200, + "4": 23112, + "5": 11808, + "7": 6768, + "8": 648, + "14": 3840, + "28": 3840, + "42": 3840 + }, + "paid_calls": 321480, + "rank_mass": 925632, + "deficit": 2496, + "maxchild": 42, + "halving_depth": 2, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "local_additions": 14510, + "bridge_additions": 17280, + "copy_erase_episodes": 648, + "global_prefix_bound": "12876798640781570347842183363526300622257813041266401009769348333568", + "global_prefix_bits": 223, + "charged_prefix_bits": 256, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", + "seconds": 1.7763645420782268 +} diff --git a/research/e8-bit-basis-order/inputs/baseline/RESULT.json b/research/e8-bit-basis-order/inputs/baseline/RESULT.json new file mode 100644 index 0000000000..98c2a258f9 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/baseline/RESULT.json @@ -0,0 +1,120 @@ +{ + "status": "PASS_CONDITIONAL_SPLIT_CENTRE_ASSEMBLY", + "kappa": "560432476129139/500000000000000000", + "kappa_decimal": "0.001120864952258278", + "bit_lower": "561061350132569610283/500000000000000000000000", + "complex_lower": "1183986549206329/1000000000000000000", + "binding_component": "bit", + "gain_over_pr425_percent": 6.9522005058117555, + "bit_invoice": { + "prefix_bits": 223, + "charged_prefix_bits": 256, + "coefficient_bits": 223, + "two_level_coefficient_bits": 483, + "charged_two_level_coefficient_bits": 512, + "row_coefficient": 18355, + "live": 14502, + "physical": 14511 + }, + "strict_outer_constraints": { + "bit_positive": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "791857266447229204459483569705102945201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30066013450793671/1000000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "791857266447229189304455739864091745201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "7181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "395928633223614609015398433325827868141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "7181585281696892583407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "6392818414718303107416592912348246333468141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "791857266447229218822654133098884940741856057546919645815673725733091011925773442015051156874463156995984475408611624970358395074769112927309248465921781123000121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "395928633223614609015398433325827868141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "7181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "6399999999999999993600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "epsilon_below_one": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "guard_width": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "K_geometry": "4807181585281696892583407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817000000000000000000", + "K_dominates_log": "231664041345061050845983947421186256401668584010497584446258683699366907737186677571792433338340060113453513521617978855187267028104098984087218414251878140832554446748323117142213588175726741393/206683276944570867451077647988766247307479316572776744891925575256476111799662761934047904233001101994161357746522719973016545013550824072000632231965075950141464786411824273258607000000000000000000", + "record_suffix": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "phase_local": "57452682253575172660075115932332441271463422396879066665683849849996634666672126693120783994727674596531689914600391489101073218400050692643898107263289403063667839215065313749127621233447528983183/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "phase_boundary": "11490536450715029406269754961108975467567014357972880107649718965136053613580158978016584167309038954918313004492748842618542529916554807718463285392220894997054215109129499241498821233447528983183/10251490536450715025573451340242805866450974102009726546639508532721215145263272991928776049956854658910403344227526910661620632672120873971231358705467767127016653406026483953626907200000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "12799999999999999980792818414718303109016592912348246333468141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/25628726341126787563933628350607014666127435255024316366598771331803037863158182479821940124892136647276008360568817276654051581680302184928078396763669417817541633515066209884067268000000000000000000", + "prime_interval_packing": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "alpha_positive": "14363170563393788359632590021810442080310539860404516767526852145439839929398406960210596656522703682519149061374476508023700697946773300526302961759162676751217566615750487648225621233447528983183/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "alpha_below_one": "12799999999999999993607181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "alpha_below_one_fourth": "3189227622077454657132070953804066391185618867017635029057319564329939892965374403017531918954994377226981896009727683073732747012090999815483496633699514550441486622767525747860182878766552471016817/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "81827972558059963142482295831039750365059753405165839859500887157900070163784215146039541956047009515286378723945407637791323146319740145866082020356197908534083134290654194352838948148633280800174595114507063924980758679362172726895650066012032777455278212210736064133662717611940569491044304210260992667579958374711353997952140066809896811489/82011924291605720204587610721942446931607792816077812373116068261769721162106183935430208399654837271283226753820215285292965061376966991769850869643742137016133227248211871629015257600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "358859621458028601093359598365557325330989185343344322865175917750116843085479998176003320395642823216282588862770178911921831577311447916339793034478937323776724933813811421508232513136299657413050451/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "5122866517862023505724960619093421545844111701898553134698525509504383311993872387184513125657251444712150871805627114225726283245038727038504547469670408073428467093191496467269437/3203590792640848445491703543825876833265929406878039545824846416475379732894772809977742515611517080909501045071102159581756447710037773116009799595458677227192704189383276235508408500000000000000000", + "coordinate_movement_above_kappa": "16099174487823595540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "3838551450442350120466514150535089425156364590041027177747358186058007158198199154413541220091468727605299653469049909287939671070001907844989495748423461692471525807616440463522057/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817000000000000000000", + "bulk_exposure_above_kappa": "16099174487823595540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "49929956359383891636682334467235976400846493161596454696927943987316335662954230095174784854400852306299403498179012231794056054820241901455974763560139756902928431597231181121226907/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "scalar_work_above_kappa": "3022347308020427168024638512713719642678957136664830842541068612764774941044496502999868999171719558143016474349913180337924305460021763455362126412952366988818802604491895640211767/2050298107290143005114690268048561173290194820401945309327901706544243029052654598385755209991370931782080668845505382132324126534424174794246271741093553425403330681205296790725381440000000000000000", + "dimension_above_kappa": "3196409207359151553231162974036146672459031212215382000019265285423173401803752699526640796382355306275012080586149285130394424095589341109716483649580049811311843280287131837920058593191496467269437/3203590792640848445491703543825876833265929406878039545824846416475379732894772809977742515611517080909501045071102159581756447710037773116009799595458677227192704189383276235508408500000000000000000" + }, + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "bootstrap": [ + { + "gap": "48640105104416009930955104551272628756769/40000000000000000000000000000000000000000000000", + "cutoff_log2": "24346328299693" + }, + { + "gap": "10916033216189494908506938862091413300675156484737667525550897/8000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "19335382939135799529" + }, + { + "gap": "2449825733746901655394438404809502019511708753179325050819248403056515410563319361/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "15355787073969246541017124" + }, + { + "gap": "549801013506219857550281901936704203615404924098069138182437287931091972275689180385852832590942771793/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "12195269025875323655994833423982" + }, + { + "gap": "123388839576821941106964776874551364767558290306753584545234931806617408234472738882773008179061080923160999418343337504609/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "9685246734476302780854842486398253310" + }, + { + "gap": "27691483569705102945201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "7691835588756193183914168151850588989363719" + } + ], + "bit_template_sha256": "c40f89a2ae3c2c5635ddf8f18d74f24567ddf67fc8c8e93a1fc7a1a8098e857e", + "complex_template_sha256": "942d030fa43316c560c88d7d7d904583446e1a96945b3ebd37a91c88a192ab4f", + "scope": "Finite research composition with explicit changed words, exact local and global replay and incremental phase evidence. All-size correlated dirty-bank, compressed-window, compiler, restored-work, tape/common-grid, precision and analytic interfaces remain inherited assumptions. This certificate makes no unconditional integer-multiplication or Lean-kernel claim.", + "verification_steps": [ + "hamming_packets", + "complex_construct", + "complex_audit", + "complex_emit", + "complex_phases", + "bit_construct", + "bit_export", + "bit_global", + "bit_audit", + "bit_price", + "complex_integrate", + "complex_replay", + "combined" + ], + "phase_mode": "source-bound unchanged evidence", + "manifest_sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f" +} diff --git a/research/e8-bit-basis-order/inputs/baseline/word.json.gz b/research/e8-bit-basis-order/inputs/baseline/word.json.gz new file mode 100644 index 0000000000..7029392e9a Binary files /dev/null and b/research/e8-bit-basis-order/inputs/baseline/word.json.gz differ diff --git a/research/e8-bit-basis-order/inputs/candidate/AUDIT.json b/research/e8-bit-basis-order/inputs/candidate/AUDIT.json new file mode 100644 index 0000000000..a9a98bb5c9 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/AUDIT.json @@ -0,0 +1,33 @@ +{ + "status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT", + "template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", + "source_frames": 944, + "exact_nested_frame_pairs": 3342, + "exact_reflected_pairs": 3342, + "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", + "exact_bank_families": 6822, + "slots_per_bank": 8, + "mutations_rejected": [ + "omit an idle child", + "omit a bridge", + "omit terminal exchange", + "remove a local invocation", + "re-use a helper bank slot", + "understate live stock", + "omit a local paid move", + "wrong reflected copy charge" + ], + "profile": { + "1": 170424, + "2": 63000, + "3": 34200, + "4": 23112, + "5": 11808, + "7": 6768, + "8": 648, + "14": 3840, + "28": 3840, + "42": 3840 + }, + "seconds": 1.1894967500120401 +} diff --git a/research/e8-bit-basis-order/inputs/candidate/BIT-PRICE.json b/research/e8-bit-basis-order/inputs/candidate/BIT-PRICE.json new file mode 100644 index 0000000000..e2e246e710 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/BIT-PRICE.json @@ -0,0 +1,17 @@ +{ + "lower": "0.001122122700265139220566", + "upper": "0.001122122700265139220567", + "lower_endpoint_residual_upper": "-4.960606267539563836080524674705444016092647550407767654449014587004507E-25", + "upper_endpoint_residual_lower": "1.904784587516794374709000160965881469336935594610954759245537570477368E-24", + "strict_rational_signs": true, + "moment_minus_one_at_current_k_required_rate": [ + "-0.001024128240011630825678969316568233910010040429826287561887258804917903", + "-0.001024128240011630825678969316568233910010040429826287561887258804843719" + ], + "nominal_k_ceiling_interval": [ + "0.001120864952258278604621028911769996496061369428716520897456706977784461", + "0.001120864952258278604622026671296430220705113361271117121082316083076751" + ], + "source_template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", + "two_exact_engines": true +} diff --git a/research/e8-bit-basis-order/inputs/candidate/COMPLETION.json b/research/e8-bit-basis-order/inputs/candidate/COMPLETION.json new file mode 100644 index 0000000000..fb34a403ce --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/COMPLETION.json @@ -0,0 +1,107 @@ +{ + "status": "PASS_CHANGED_BIT_FINITE_CHECK", + "scope": "changed bit only; unchanged complex receipts reused; no phase replay", + "source_manifest_sha256": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "candidate_sha256": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "reused": { + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29" + }, + "input_before": { + "candidate": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "baseline_completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29" + }, + "input_after": { + "candidate": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "baseline_completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29" + }, + "steps": [ + { + "name": "export", + "returncode": 0, + "log_sha256": "6591bd062e93bac77aa788bdda8a982ed6d63ed1e4b2d1048e099555b47a8b50" + }, + { + "name": "global", + "returncode": 0, + "log_sha256": "1110e617dbe5b6c1b738547f3a07a48b8fa012ad4778cf65c5055ae23bf0070d" + }, + { + "name": "audit", + "returncode": 0, + "log_sha256": "68e8c1a8a7a267a603b784e5261b45fd3c6d45a317ef5ba85bd305b4c143dff2" + }, + { + "name": "price", + "returncode": 0, + "log_sha256": "e487f4822581a1b8d3746cf8a79ae6394342fca1e9c8533e970f0f0c672b5b4b" + }, + { + "name": "combined", + "returncode": 0, + "log_sha256": "5c50444eae0779587c6a70056b3d489ee3b749ea72cea7763896ff4407f5d2a2" + } + ], + "wall_seconds": 3.5411427090875804, + "child_usage": [ + 3.443853, + 0.05456, + 135905280, + 0, + 0, + 0, + 26343, + 326, + 0, + 0, + 0, + 0, + 0, + 0, + 47, + 1953 + ], + "output_hashes": { + "RESULT.json": "7498e4eac4d4e3598dce02fbe589a4c2ba98fb7b0c471a2e4e5f543b729ec217", + "price.log": "e487f4822581a1b8d3746cf8a79ae6394342fca1e9c8533e970f0f0c672b5b4b", + "audit.log": "68e8c1a8a7a267a603b784e5261b45fd3c6d45a317ef5ba85bd305b4c143dff2", + "export.log": "6591bd062e93bac77aa788bdda8a982ed6d63ed1e4b2d1048e099555b47a8b50", + "combined.log": "5c50444eae0779587c6a70056b3d489ee3b749ea72cea7763896ff4407f5d2a2", + "BIT-PRICE.json": "578af4b67c4d251e7fefab1b4a6dba1f2a37c9ab13659ab8efce6d600caabc5b", + "global.log": "1110e617dbe5b6c1b738547f3a07a48b8fa012ad4778cf65c5055ae23bf0070d", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "bit426-source-centres/bit-source-centres.json": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "bit426-source-centres/records/249-records.bin": "be6763a87a826d5e521c3c78b098322404e96c23e79f99cf5e6a4f33c0f387b8", + "bit426-source-centres/records/249-states.json": "e0be800f2fada0efe4bae0077851eae75f1ed4be462f259dd35a2413daf72082", + "bit426-source-centres/records/frames.json": "884480e45865a9d9d57f5f7198844a64271b046bc95e9820efbefb9e10878330", + "bit426-source-centres/global/GEOMETRY.json": "a5515888fffad2f82f7cde74af80cf5fc5a5197974104b63699305b9faeb1889", + "bit426-source-centres/global/AUDIT.json": "ec0e91c2540dcce22836372d6a0692ef2d04d6fb044732eddd2820b54491625d", + "bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz": "52471310c7a730b54d6ed2f979fa4cabd86f180538c0c50b0b38687b7b105eb9", + "bit426-source-centres/global/GLOBAL.json": "30431f77668cfd693eb86e351d08e71107525be17497db31638d4e685692b523" + } +} diff --git a/research/e8-bit-basis-order/inputs/candidate/FINITE-COMPARISON.json b/research/e8-bit-basis-order/inputs/candidate/FINITE-COMPARISON.json new file mode 100644 index 0000000000..049853a46a --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/FINITE-COMPARISON.json @@ -0,0 +1,16 @@ +{ + "status": "PASS_ACTUAL_FINITE_COST_COMPARISON", + "coefficient": "4133102071585442738602693393898919077364732015670619884057", + "two_level_coefficient": "1765480327964144359059818667672312184441048701945634758871470371595777703976260950775676203474324491767368886150988529342610404", + "coefficient_bits": 192, + "two_level_bits": 420, + "baseline_coefficient_bits": 223, + "baseline_two_level_bits": 483, + "local_additions": 14542, + "unit_additions": 1064304, + "kappa": "560432476129139/500000000000000000", + "bit_lower": "561061350132569610283/500000000000000000000000", + "complex_lower": "1183986549206329/1000000000000000000", + "scope": "Pinned433 finite coefficient improvement only; no coarse bound gain, no434 port", + "receipt_sha256": "f97a6a3d0ce8abbca1996b17c53caa339b00524f0c10c1101a99a191132b5f08" +} diff --git a/research/e8-bit-basis-order/inputs/candidate/GEOMETRY.json.gz b/research/e8-bit-basis-order/inputs/candidate/GEOMETRY.json.gz new file mode 100644 index 0000000000..3fcbe4f2ab Binary files /dev/null and b/research/e8-bit-basis-order/inputs/candidate/GEOMETRY.json.gz differ diff --git a/research/e8-bit-basis-order/inputs/candidate/GLOBAL.json b/research/e8-bit-basis-order/inputs/candidate/GLOBAL.json new file mode 100644 index 0000000000..283ca17fa3 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/GLOBAL.json @@ -0,0 +1,164 @@ +{ + "status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", + "h": 8, + "m": 64, + "v": 120, + "R": 758, + "replicas": 8, + "live": 14502, + "physical": 14511, + "word_sha256": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", + "source_records_sha256": "be6763a87a826d5e521c3c78b098322404e96c23e79f99cf5e6a4f33c0f387b8", + "local_checks": { + "forward": { + "copies": 9, + "adds": 14542, + "records": 18776, + "all_columns": 998, + "cancellation_free_row_l1": 352811, + "profile": { + "1": 2367, + "2": 875, + "3": 475, + "4": 321, + "5": 164, + "7": 14, + "8": 9 + }, + "sha256": "4480ae91492d4a727cb4a470224a1fab2ae2d8d0d9053de190cd385caaa6f74e" + }, + "reverse": { + "copies": 9, + "adds": 14542, + "records": 18776, + "all_columns": 998, + "cancellation_free_row_l1": 1303186, + "profile": { + "1": 2367, + "2": 875, + "3": 475, + "4": 321, + "5": 164, + "7": 14, + "8": 9 + }, + "sha256": "a5d699cefa91faf818a795f630fc43ebe57ba493297822ce7dea2f91c75e9717" + } + }, + "scalar_stages": [ + { + "stage": 0, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 1, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 2, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 3, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 4, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 5, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 6, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + }, + { + "stage": 7, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": true + }, + { + "stage": 8, + "all_columns": 7782, + "helper_columns": 6822, + "reverse": false + } + ], + "independent_unbanked_scalar_columns": 7782, + "all_scalar_columns_restored": true, + "geometry_sha256": "a5515888fffad2f82f7cde74af80cf5fc5a5197974104b63699305b9faeb1889", + "template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", + "emitted_program_sha256": "e02fee8f48c6dc257c6c6e1cc96beaa2cd2b51d0a1b5b832820dea5ac4579f67", + "emitted_events": 1351872, + "local_invocations": 72, + "bank_assignments": 54576, + "banks_per_stage": 758, + "whole_rank8_slots_per_bank": 8, + "padding_calls": 0, + "profile": { + "1": 170424, + "2": 63000, + "3": 34200, + "4": 23112, + "5": 11808, + "7": 6768, + "8": 648, + "14": 3840, + "28": 3840, + "42": 3840 + }, + "paid_calls": 321480, + "rank_mass": 925632, + "deficit": 2496, + "maxchild": 42, + "halving_depth": 2, + "halving_integer_inequality": [ + 4096, + 3528 + ], + "local_additions": 14542, + "bridge_additions": 17280, + "copy_erase_episodes": 648, + "global_prefix_bound": "4133102071585442738602693393898919077364731728802877538304", + "global_prefix_bits": 192, + "charged_prefix_bits": 192, + "omitted_bridge_shears_rejected": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ], + "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", + "seconds": 1.7759870000882074 +} diff --git a/research/e8-bit-basis-order/inputs/candidate/RESULT.json b/research/e8-bit-basis-order/inputs/candidate/RESULT.json new file mode 100644 index 0000000000..8d8ff5f229 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/RESULT.json @@ -0,0 +1,103 @@ +{ + "status": "PASS_CONDITIONAL_SPLIT_CENTRE_ASSEMBLY", + "kappa": "560432476129139/500000000000000000", + "kappa_decimal": "0.001120864952258278", + "bit_lower": "561061350132569610283/500000000000000000000000", + "complex_lower": "1183986549206329/1000000000000000000", + "binding_component": "bit", + "gain_over_pr425_percent": 6.9522005058117555, + "bit_invoice": { + "prefix_bits": 192, + "charged_prefix_bits": 256, + "coefficient_bits": 192, + "two_level_coefficient_bits": 420, + "charged_two_level_coefficient_bits": 512, + "row_coefficient": 18355, + "live": 14502, + "physical": 14511 + }, + "strict_outer_constraints": { + "bit_positive": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "791857266447229204459483569705102945201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30066013450793671/1000000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "791857266447229189304455739864091745201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "7181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "395928633223614609015398433325827868141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "7181585281696892583407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "6392818414718303107416592912348246333468141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "791857266447229218822654133098884940741856057546919645815673725733091011925773442015051156874463156995984475408611624970358395074769112927309248465921781123000121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "14363170563393781995540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "395928633223614609015398433325827868141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "7181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "6399999999999999993600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "epsilon_below_one": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "guard_width": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "K_geometry": "4807181585281696892583407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817000000000000000000", + "K_dominates_log": "231664041345061050845983947421186256401668584010497584446258683699366907737186677571792433338340060113453513521617978855187267028104098984087218414251878140832554446748323117142213588175726741393/206683276944570867451077647988766247307479316572776744891925575256476111799662761934047904233001101994161357746522719973016545013550824072000632231965075950141464786411824273258607000000000000000000", + "record_suffix": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "phase_local": "57452682253575172660075115932332441271463422396879066665683849849996634666672126693120783994727674596531689914600391489101073218400050692643898107263289403063667839215065313749127621233447528983183/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "phase_boundary": "11490536450715029406269754961108975467567014357972880107649718965136053613580158978016584167309038954918313004492748842618542529916554807718463285392220894997054215109129499241498821233447528983183/10251490536450715025573451340242805866450974102009726546639508532721215145263272991928776049956854658910403344227526910661620632672120873971231358705467767127016653406026483953626907200000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "12799999999999999980792818414718303109016592912348246333468141186243920908350307167049240534210454380044514968776965838180997909857795680836487104579924453767980400809082645545614591621233447528983183/25628726341126787563933628350607014666127435255024316366598771331803037863158182479821940124892136647276008360568817276654051581680302184928078396763669417817541633515066209884067268000000000000000000", + "prime_interval_packing": "7181585281696897383407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817", + "alpha_positive": "14363170563393788359632590021810442080310539860404516767526852145439839929398406960210596656522703682519149061374476508023700697946773300526302961759162676751217566615750487648225621233447528983183/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "alpha_below_one": "12799999999999999993607181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "alpha_below_one_fourth": "3189227622077454657132070953804066391185618867017635029057319564329939892965374403017531918954994377226981896009727683073732747012090999815483496633699514550441486622767525747860182878766552471016817/12814363170563393781966814175303507333063717627512158183299385665901518931579091239910970062446068323638004180284408638327025790840151092464039198381834708908770816757533104942033634000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "81827972558059963142482295831039750365059753405165839859500887157900070163784215146039541956047009515286378723945407637791323146319740145866082020356197908534083134290654194352838948148633280800174595114507063924980758679362172726895650066012032777455278212210736064133662717611940569491044304210260992667579958374711353997952140066809896811489/82011924291605720204587610721942446931607792816077812373116068261769721162106183935430208399654837271283226753820215285292965061376966991769850869643742137016133227248211871629015257600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "358859621458028601093359598365557325330989185343344322865175917750116843085479998176003320395642823216282588862770178911921831577311447916339793034478937323776724933813811421508232513136299657413050451/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "5122866517862023505724960619093421545844111701898553134698525509504383311993872387184513125657251444712150871805627114225726283245038727038504547469670408073428467093191496467269437/3203590792640848445491703543825876833265929406878039545824846416475379732894772809977742515611517080909501045071102159581756447710037773116009799595458677227192704189383276235508408500000000000000000", + "coordinate_movement_above_kappa": "16099174487823595540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "3838551450442350120466514150535089425156364590041027177747358186058007158198199154413541220091468727605299653469049909287939671070001907844989495748423461692471525807616440463522057/6407181585281696890983407087651753666531858813756079091649692832950759465789545619955485031223034161819002090142204319163512895420075546232019599190917354454385408378766552471016817000000000000000000", + "bulk_exposure_above_kappa": "16099174487823595540516430294897054798660372747977408982986647014886397057213204999835240182750048003850764774138423033492369699369310106183121233447528983183/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "49929956359383891636682334467235976400846493161596454696927943987316335662954230095174784854400852306299403498179012231794056054820241901455974763560139756902928431597231181121226907/51257452682253575127867256701214029332254870510048632733197542663606075726316364959643880249784273294552016721137634553308103163360604369856156793527338835635083267030132419768134536000000000000000000", + "scalar_work_above_kappa": "3022347308020427168024638512713719642678957136664830842541068612764774941044496502999868999171719558143016474349913180337924305460021763455362126412952366988818802604491895640211767/2050298107290143005114690268048561173290194820401945309327901706544243029052654598385755209991370931782080668845505382132324126534424174794246271741093553425403330681205296790725381440000000000000000", + "dimension_above_kappa": "3196409207359151553231162974036146672459031212215382000019265285423173401803752699526640796382355306275012080586149285130394424095589341109716483649580049811311843280287131837920058593191496467269437/3203590792640848445491703543825876833265929406878039545824846416475379732894772809977742515611517080909501045071102159581756447710037773116009799595458677227192704189383276235508408500000000000000000" + }, + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "bootstrap": [ + { + "gap": "48640105104416009930955104551272628756769/40000000000000000000000000000000000000000000000", + "cutoff_log2": "24346328299693" + }, + { + "gap": "10916033216189494908506938862091413300675156484737667525550897/8000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "19335382939135799529" + }, + { + "gap": "2449825733746901655394438404809502019511708753179325050819248403056515410563319361/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "15355787073969246541017124" + }, + { + "gap": "549801013506219857550281901936704203615404924098069138182437287931091972275689180385852832590942771793/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "12195269025875323655994833423982" + }, + { + "gap": "123388839576821941106964776874551364767558290306753584545234931806617408234472738882773008179061080923160999418343337504609/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "9685246734476302780854842486398253310" + }, + { + "gap": "27691483569705102945201339627252022591017013352985113602942786795000164759817249951996149235225861576966507630300630689893816878766552471016817/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "7691835588756193183914168151850588989363719" + } + ], + "bit_template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", + "complex_template_sha256": "942d030fa43316c560c88d7d7d904583446e1a96945b3ebd37a91c88a192ab4f", + "scope": "Finite research composition with explicit changed words, exact local and global replay and incremental phase evidence. All-size correlated dirty-bank, compressed-window, compiler, restored-work, tape/common-grid, precision and analytic interfaces remain inherited assumptions. This certificate makes no unconditional integer-multiplication or Lean-kernel claim." +} diff --git a/research/e8-bit-basis-order/inputs/candidate/audit.log b/research/e8-bit-basis-order/inputs/candidate/audit.log new file mode 100644 index 0000000000..0fde6a584e --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/audit.log @@ -0,0 +1 @@ +{"status": "PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT", "template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", "source_frames": 944, "exact_nested_frame_pairs": 3342, "exact_reflected_pairs": 3342, "orthogonal_lift_argument": "Adding the same orthogonal E_s leaves P_V-P_U unchanged; each audited projector is therefore the literal child projector in every one of the nine windows.", "exact_bank_families": 6822, "slots_per_bank": 8, "mutations_rejected": ["omit an idle child", "omit a bridge", "omit terminal exchange", "remove a local invocation", "re-use a helper bank slot", "understate live stock", "omit a local paid move", "wrong reflected copy charge"], "profile": {"1": 170424, "2": 63000, "3": 34200, "4": 23112, "5": 11808, "7": 6768, "8": 648, "14": 3840, "28": 3840, "42": 3840}, "seconds": 1.1894967500120401} diff --git a/research/e8-bit-basis-order/inputs/candidate/combined.log b/research/e8-bit-basis-order/inputs/candidate/combined.log new file mode 100644 index 0000000000..e28819a244 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/combined.log @@ -0,0 +1 @@ +PASS_CONDITIONAL_SPLIT_CENTRE_ASSEMBLY 0.001120864952258278 6.9522005058117555 {'prefix_bits': 192, 'charged_prefix_bits': 256, 'coefficient_bits': 192, 'two_level_coefficient_bits': 420, 'charged_two_level_coefficient_bits': 512, 'row_coefficient': 18355, 'live': 14502, 'physical': 14511} diff --git a/research/e8-bit-basis-order/inputs/candidate/export.log b/research/e8-bit-basis-order/inputs/candidate/export.log new file mode 100644 index 0000000000..efc422d6ab --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/export.log @@ -0,0 +1 @@ +exported 18776 records, 944 frames, n 998 ZERO 0 diff --git a/research/e8-bit-basis-order/inputs/candidate/global.log b/research/e8-bit-basis-order/inputs/candidate/global.log new file mode 100644 index 0000000000..a6013e87c5 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/global.log @@ -0,0 +1,2 @@ +Fresh prefix bits 192 charged 192 +{"status": "PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE", "h": 8, "m": 64, "v": 120, "R": 758, "replicas": 8, "live": 14502, "physical": 14511, "word_sha256": "ee95a35d2bbdba598ea4e40917467090a956b06fad15b3f00d260f0db7ebd453", "source_records_sha256": "be6763a87a826d5e521c3c78b098322404e96c23e79f99cf5e6a4f33c0f387b8", "independent_unbanked_scalar_columns": 7782, "all_scalar_columns_restored": true, "geometry_sha256": "a5515888fffad2f82f7cde74af80cf5fc5a5197974104b63699305b9faeb1889", "template_sha256": "ab4a62cec382dff22fb440d0943dfe6fe0ca880e3fa772b726b174e7a3d104d5", "emitted_program_sha256": "e02fee8f48c6dc257c6c6e1cc96beaa2cd2b51d0a1b5b832820dea5ac4579f67", "emitted_events": 1351872, "local_invocations": 72, "bank_assignments": 54576, "banks_per_stage": 758, "whole_rank8_slots_per_bank": 8, "padding_calls": 0, "profile": {"1": 170424, "2": 63000, "3": 34200, "4": 23112, "5": 11808, "7": 6768, "8": 648, "14": 3840, "28": 3840, "42": 3840}, "paid_calls": 321480, "rank_mass": 925632, "deficit": 2496, "maxchild": 42, "halving_depth": 2, "halving_integer_inequality": [4096, 3528], "local_additions": 14542, "bridge_additions": 17280, "copy_erase_episodes": 648, "global_prefix_bits": 192, "charged_prefix_bits": 192, "omitted_bridge_shears_rejected": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "scope": "Complete source-bound finite cover template. Local and unbanked global F2 columns are replayed; arbitrary physical bank dirt follows by injective owner routes and the all-column local theorem. Astronomical cover enumeration and all-size compiler interfaces remain explicit inherited assumptions.", "seconds": 1.7759870000882074} diff --git a/research/e8-bit-basis-order/inputs/candidate/price.log b/research/e8-bit-basis-order/inputs/candidate/price.log new file mode 100644 index 0000000000..45aa5a39d5 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/candidate/price.log @@ -0,0 +1 @@ +PASS two rational bit moments 0.001122122700265139220566 diff --git a/research/e8-bit-basis-order/inputs/candidate/word.json.gz b/research/e8-bit-basis-order/inputs/candidate/word.json.gz new file mode 100644 index 0000000000..bb2f3e7e79 Binary files /dev/null and b/research/e8-bit-basis-order/inputs/candidate/word.json.gz differ diff --git a/research/e8-bit-basis-order/inputs/complex/INDEPENDENT-REPLAY.json b/research/e8-bit-basis-order/inputs/complex/INDEPENDENT-REPLAY.json new file mode 100644 index 0000000000..aa7ffa7482 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/complex/INDEPENDENT-REPLAY.json @@ -0,0 +1,46 @@ +{ + "status": "PASS_INDEPENDENT_NEW_STRUCTURAL_IR_REPLAY", + "template_sha256": "942d030fa43316c560c88d7d7d904583446e1a96945b3ebd37a91c88a192ab4f", + "local": { + "forward": { + "all_exact_columns": 800, + "prefix_l1_upper": "32209", + "prefix_bits_upper": 15, + "charged_payload_bits": 192, + "private_work_erased": true + }, + "backward": { + "all_exact_columns": 800, + "prefix_l1_upper": "1039185", + "prefix_bits_upper": 20, + "charged_payload_bits": 192, + "private_work_erased": true + } + }, + "mutation_controls_rejected": [ + "wrong_scale", + "missing_center", + "wrong_common_frame", + "wrong_child_rank", + "missing_padding", + "aliased_owner", + "missing_cover_phase" + ], + "all_eight_global_scalar_columns": true, + "bank_owners_and_padding_exact": true, + "paid_profile": { + "1": 142704, + "2": 56448, + "3": 12096, + "4": 16128, + "5": 28224, + "8": 7488, + "16": 3840, + "32": 3840, + "48": 3840 + }, + "two_rational_moment_engines": true, + "complex_b": "1183986549206329/1000000000000000000", + "next_b_grid_rejected": true, + "scope": "Independent finite replay; retains the written generic scalar-interface lemma and inherited all-size/analytic assumptions." +} diff --git a/research/e8-bit-basis-order/inputs/complex/INTEGRATION.json b/research/e8-bit-basis-order/inputs/complex/INTEGRATION.json new file mode 100644 index 0000000000..b05f3cb948 --- /dev/null +++ b/research/e8-bit-basis-order/inputs/complex/INTEGRATION.json @@ -0,0 +1,144 @@ +{ + "status": "PASS_NEW_STRUCTURAL_PROGRAM_AND_FINITE_ASSEMBLY_PENDING_REPLAY", + "canonical_word_sha256": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "scalar_audit_sha256": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd", + "exact_phase_receipt_sha256": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "global_template_sha256": "942d030fa43316c560c88d7d7d904583446e1a96945b3ebd37a91c88a192ab4f", + "local_program_checks": { + "forward": { + "sha256": "9f9f5034b82277de7ca6dc27a682c1732b28a4450eb057392487910928971cf8", + "events": 24857, + "scalar_macros": 19744, + "real_component_primitive_bound": 222204, + "paid_profile": { + "1": 1912, + "2": 784, + "3": 168, + "4": 224, + "5": 392, + "8": 24 + }, + "all_columns": 800, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true + }, + "backward": { + "sha256": "b06539888be711e562ebcb4166583e970d16b9997b2142b3b4490c50781b3d22", + "events": 24857, + "scalar_macros": 19744, + "real_component_primitive_bound": 222300, + "paid_profile": { + "1": 1912, + "2": 784, + "3": 168, + "4": 224, + "5": 392, + "8": 24 + }, + "all_columns": 800, + "private_centers_cleared": true, + "private_coefficient_stream_cleared_after_each_macro": true + } + }, + "R": 560, + "m": 73, + "live": 12720, + "physical": 13298, + "bank_assignments": 40320, + "rank_mass": 926064, + "deficit": 2496, + "global_profile": { + "1": 142704, + "2": 56448, + "3": 12096, + "4": 16128, + "5": 28224, + "8": 7488, + "16": 3840, + "32": 3840, + "48": 3840 + }, + "emitted_local_events_all_calls": 1789704, + "finite_invoice": { + "local_primitive_bound": 10106507224156, + "local_adapters": 389696, + "pervertex": 771280115394960, + "physical_stock_bits": 2642, + "router_bits": 7984, + "literal_bits": 35284, + "physical_row_coefficient": 15445, + "retained_row_coefficient": 20161, + "compiler": 25934336, + "G_exponent": 30000, + "E_exponent": 100000, + "C0_exponent": 210000, + "required_C0_bits": 200012, + "halving_degree": 2, + "halving_integer_inequality": [ + 5329, + 4608 + ] + }, + "complex_b": "1183986549206329/1000000000000000000", + "bit_c": "561061350132569610283/500000000000000000000000", + "prospective_kappa": "1120864949607597/1000000000000000000", + "kappa_float": 0.001120864949607597, + "log2_kappa": -9.801171822993874, + "kappa_gain_percent": 12.267153776895258, + "strict_outer_constraints": { + "bit_positive": "1795396316178998276139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "98982162551128123860639426960872694082289890349491756322723328881/1600000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30066013450793671/1000000000000000000", + "beta_positive": "1/1000000000", + "beta_below_one": "999999999/1000000000", + "leaf_saving_above_bit": "98982160656749645130513026960872694082289890349491756322723328881/1600000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "897698158087703741753501288243424292385815927519336411728987827315822723328881/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "1795396316178998276139360573039127305917710109650508243677276671119/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "49491080330170218881435511756575707614184072480663588271012172684177276671119/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "897698158287703741753501288243424292385815927519336411728987827315822723328881/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "799102301841712296258246498711756575707614184072480663588271012172684177276671119/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000", + "lambda_above_tau": "1795396316178998276139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "98982162552923520176818425237012054655329017655409466432373837124677276671119/1600000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "1795396316178998276139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "1795396316178998276139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "49491080330170218881435511756575707614184072480663588271012172684177276671119/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000", + "lambda_prime_below_one": "897698158087703741753501288243424292385815927519336411728987827315822723328881/800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "799999999999200000000000000000000000000000000000000000000000000000000000000000000/800897698158087703741753501288243424292385815927519336411728987827315822723328881", + "epsilon_below_one": "897698158887703741753501288243424292385815927519336411728987827315822723328881/800897698158087703741753501288243424292385815927519336411728987827315822723328881", + "guard_width": "897698158887703741753501288243424292385815927519336411728987827315822723328881/800897698158087703741753501288243424292385815927519336411728987827315822723328881", + "K_geometry": "600897698158287703741753501288243424292385815927519336411728987827315822723328881/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000", + "K_dominates_log": "897698158286806043595213584501670791097572503226950595801468490904093735501565177276671119/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000", + "record_suffix": "897698158887703741753501288243424292385815927519336411728987827315822723328881/800897698158087703741753501288243424292385815927519336411728987827315822723328881", + "phase_local": "7181585270300732235869922602205640837798283995862305477904383282114852798803732177276671119/6407181585264701629934028010305947394339086527420154691293831902618526581786631048000000000000", + "phase_boundary": "1436317053419428288647514357447725366529062059738552442838861187293587369498893777276671119/1281436317052940325986805602061189478867817305484030938258766380523705316357326209600000000000", + "gamma_sublinear": "1/2000000000000", + "cell_above_band": "1599999999997599102301841912296258246498711756575707614184072480663588271012172684177276671119/3203590792632350814967014005152973697169543263710077345646915951309263290893315524000000000000", + "prime_interval_packing": "897698158887703741753501288243424292385815927519336411728987827315822723328881/800897698158087703741753501288243424292385815927519336411728987827315822723328881", + "alpha_positive": "1795396316974509785348914872745095083483388430746287007530456318219916458830446177276671119/1601795396316175407483507002576486848584771631855038672823457975654631645446657762000000000000", + "alpha_below_one": "1599999999999200897698158087703741753501288243424292385815927519336411728987827315822723328881/1601795396316175407483507002576486848584771631855038672823457975654631645446657762000000000000", + "alpha_below_one_fourth": "398653452762069342085527835771376617062709519533013381198334037595437994902833994322723328881/1601795396316175407483507002576486848584771631855038672823457975654631645446657762000000000000", + "delta_positive": "1/8000000000000", + "delta_below_one_eighth": "999999999999/8000000000000", + "short_record_fallback": "1278562071221810730043762876711819384759744339885055566686330750204834103195540249905889690519318404576424381156396798172265910092678400995534088712161/1281436317052940325986805602061189478867817305484030938258766380523705316357326209600000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000", + "artificial_boundary": "44857452682126415732566698345558804415216556949634114687798437778957447841256530331468169986643/6407181585264701629934028010305947394339086527420154691293831902618526581786631048000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "800898335053714026321027690194512698991633318425228406127179455068290320748481472891043/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000000000", + "coordinate_movement_above_kappa": "2012396806843076139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "636895626322579274188906269274699247502497709069715450467240974498025152591891043/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000000000", + "bulk_exposure_above_kappa": "2012396806843076139360573039127305917710109650508243677276671119/1600000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "300337273704909211482431751889360558808892183470528820869848837676217931546400922266043/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000000000", + "scalar_work_above_kappa": "700786122783953063353308502533482270955085091434288489075713331589875842908065362766043/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000000000", + "dimension_above_kappa": "799102301841113194593300212738077603397808696771472296906696240578811356731739409320748481472891043/800897698158087703741753501288243424292385815927519336411728987827315822723328881000000000000000000" + }, + "next_kappa_grid_rejected": true, + "bootstrap_cutoffs_log2": [ + "24346328398806", + "19335383056520707335", + "15355787197905685419069746" + ], + "scope": "New finite scalar interface with a written conjugation proof, conditional on inherited all-size compiler, precision/tape and analytic transfer. Independent emitted-program replay and fresh package replay still required before final promotion." +} diff --git a/research/e8-bit-basis-order/port438/COMPLETION.json b/research/e8-bit-basis-order/port438/COMPLETION.json new file mode 100644 index 0000000000..4a0c145607 --- /dev/null +++ b/research/e8-bit-basis-order/port438/COMPLETION.json @@ -0,0 +1,268 @@ +{ + "status": "PASS_CHANGED_PR438_BIT_FINITE_CHECK", + "scope": "Post-kernel port of published basis method; independently completed PR433 complex evidence reused; no new exponent or runtime claim", + "source_before": { + "SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "PROOF.md": "0f482e06aeda510e08055848bc2b68d30c93ed1722b9ed5e7613f96cf6346dde", + "EXPECTED.json": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "aebe7e50b25e43818f844886ae01c08c712b5453604fccac393631592fe9d0d2", + "CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "VALIDATION.json": "4957420a5a988e045537e31f79da7f8d35592185d45802c0ff4adfd0d97a772e", + ".gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "MANIFEST.json": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "verify.py": "46ed1039f35480fef612d54f12fd874e2266c0ce3baab692603886bc7aa4c58b", + "NOTICE.md": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "stages/kernel-selection.json": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "code/bit_reset.py": "000983f6c09ba3baa90cdee69a03464680b6963cfd4f8f7b9301d4e0e6acd6f5", + "code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "code/bit_global.py": "b3a486487e223ef0e2b4fd212063c1506740ba18765e99878e07d06968877eca", + "code/bit_kernel.py": "14f164fcc0674f73163808a9d9762eb439ea130895f593cb78a6cafaed2dfb11", + "code/bit_audit.py": "b2b4b792f14ac9946bdcd1bf4c0d47c46fe05ff6ff9c5f0317037c9a1ee1e5fe", + "code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "code/complex_phases.py": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "code/combined.py": "825c32a81529da35a347666468585c69d66c0ee161717f2994769782fb57e29e", + "code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inputs/complex-phase-receipt.json": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/pr434/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr434/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/pr434/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "source_after": { + "SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "PROOF.md": "0f482e06aeda510e08055848bc2b68d30c93ed1722b9ed5e7613f96cf6346dde", + "EXPECTED.json": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "aebe7e50b25e43818f844886ae01c08c712b5453604fccac393631592fe9d0d2", + "CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "VALIDATION.json": "4957420a5a988e045537e31f79da7f8d35592185d45802c0ff4adfd0d97a772e", + ".gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "MANIFEST.json": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "verify.py": "46ed1039f35480fef612d54f12fd874e2266c0ce3baab692603886bc7aa4c58b", + "NOTICE.md": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "stages/kernel-selection.json": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "code/bit_reset.py": "000983f6c09ba3baa90cdee69a03464680b6963cfd4f8f7b9301d4e0e6acd6f5", + "code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "code/bit_global.py": "b3a486487e223ef0e2b4fd212063c1506740ba18765e99878e07d06968877eca", + "code/bit_kernel.py": "14f164fcc0674f73163808a9d9762eb439ea130895f593cb78a6cafaed2dfb11", + "code/bit_audit.py": "b2b4b792f14ac9946bdcd1bf4c0d47c46fe05ff6ff9c5f0317037c9a1ee1e5fe", + "code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "code/complex_phases.py": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "code/combined.py": "825c32a81529da35a347666468585c69d66c0ee161717f2994769782fb57e29e", + "code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inputs/complex-phase-receipt.json": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/pr434/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr434/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/pr434/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "adapter_manifest_sha256": "e7f88237f8b0e6bd1051ad49738e60d47fc05beef11ed0af2f1ed5befaf63595", + "inputs_before": { + "completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "reuse_binding": "ed3c550dd9bc30512accc35facbe3100021ca3fe7fe04513c94528498eed4561", + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd" + }, + "inputs_after": { + "completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "reuse_binding": "ed3c550dd9bc30512accc35facbe3100021ca3fe7fe04513c94528498eed4561", + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd" + }, + "steps": [ + { + "name": "bit_construct", + "returncode": 0, + "log_sha256": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933" + }, + { + "name": "bit_reset", + "returncode": 0, + "log_sha256": "ac3ff67b486202e46a577d5c867fdce6992e93e47415346c95c4d669b1972b61" + }, + { + "name": "bit_kernel", + "returncode": 0, + "log_sha256": "c65c7919e2fef533fa828dabd1397bd5844b183aa49b9a88bbec8ad95fdaa040" + }, + { + "name": "post_basis", + "returncode": 0, + "log_sha256": "526515d93fd8afc8dd475042350601a7ebfcac729ca0b7795972b60378fdf4c3" + }, + { + "name": "export", + "returncode": 0, + "log_sha256": "e57459c15c39fddf647f68eca16a169896a0e946bd495db1d4a9ad11472fc92a" + }, + { + "name": "global", + "returncode": 0, + "log_sha256": "ac3f7c1e017a29fe0d5a69766d0d53345303c273c84f5ee5539dd7261a0e55fe" + }, + { + "name": "audit", + "returncode": 0, + "log_sha256": "7f1b9d5c24e7340d0972cb1cf5ed23ee1a25ea4e3494d8baab96004c173b8baa" + }, + { + "name": "price", + "returncode": 0, + "log_sha256": "98d0243f63083c3904760bb64b266759447a118ec4fbf35bd7ce27ce2811f244" + }, + { + "name": "combined", + "returncode": 0, + "log_sha256": "d63bfdf50707d012ee26e29fed7be296d20943ec22e65107e5eb61228c5f2a7a" + } + ], + "wall_seconds": 18.487286624964327, + "child_usage": [ + 18.227092, + 0.14591099999999999, + 146374656, + 0, + 0, + 0, + 40749, + 539, + 0, + 0, + 0, + 0, + 0, + 0, + 66, + 9574 + ], + "output_hashes": { + "post_basis.log": "526515d93fd8afc8dd475042350601a7ebfcac729ca0b7795972b60378fdf4c3", + "RESULT.json": "fcdb458e99cd75afd6c4def70fa4dfc603239278e74a784b9658a66e81917d01", + "price.log": "98d0243f63083c3904760bb64b266759447a118ec4fbf35bd7ce27ce2811f244", + "bit_kernel.log": "c65c7919e2fef533fa828dabd1397bd5844b183aa49b9a88bbec8ad95fdaa040", + "FINITE-COMPARISON.json": "a982badcaa34737018dbf6aaafa79e8c94d32ff4b22cfad01dfdc412f95c509c", + "audit.log": "7f1b9d5c24e7340d0972cb1cf5ed23ee1a25ea4e3494d8baab96004c173b8baa", + "export.log": "e57459c15c39fddf647f68eca16a169896a0e946bd495db1d4a9ad11472fc92a", + "combined.log": "d63bfdf50707d012ee26e29fed7be296d20943ec22e65107e5eb61228c5f2a7a", + "bit_construct.log": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933", + "BIT-PRICE.json": "daf68676e1b1734c47f8b41bdce0b6a27df28ad0149b98c5dfffb19ae1a8b35c", + "global.log": "ac3f7c1e017a29fe0d5a69766d0d53345303c273c84f5ee5539dd7261a0e55fe", + "bit_reset.log": "ac3ff67b486202e46a577d5c867fdce6992e93e47415346c95c4d669b1972b61", + "split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd", + "bit426-source-centres/BASIS-STAGE.json": "2e0600bc3be25502b2fbc8114cbcbb4e0d5b23b8665d663aaeaa74f47bfb2e8a", + "bit426-source-centres/bit-input.json": "7a395dd0452b0832f7ffce7148589eafc627b8cf0349a81803fd897e7a24a388", + "bit426-source-centres/bit-source-centres-receipt.json": "cfcc6b56da99ffefcd38175542e924ab64bb4132749aaa67f9395481dfd0a88f", + "bit426-source-centres/bit-source-centres-r758.json": "015811014644ed62acba1da590d9cf6ebdfe834d89867f8ce2b68722609072ea", + "bit426-source-centres/bit-source-centres.json": "2be5d42a53e367648f4dd33fd4a368c61e1565f0cf7c48bfe887ca953a735063", + "bit426-source-centres/bit-source-centres-prekernel.json": "98ffef9246c8bf6c537ab5e134321abea05cf0b7830c9e3fd92cbe4e88d8c308", + "bit426-source-centres/bit-kernel-receipt.json": "3eeb80d1bf47f8902a936b11351a636e2021aabf0852a1f2242122c4c3bdb5f8", + "bit426-source-centres/bit-source-centres-postkernel-original.json": "cc6242d90ccdd8477521ea16f35ee2667dbe6c48cc60c6e4e9bcf6460497b233", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "bit426-source-centres/records/249-records.bin": "a0fd597c8cc0edd639d463f886be5e7984133ae16cf36f73c43aec2ec965c535", + "bit426-source-centres/records/249-states.json": "8973ac9cd6cec93f0adfe06e98da925f35ce4d6a3fffa25581ff4a56a50f38ef", + "bit426-source-centres/records/frames.json": "884480e45865a9d9d57f5f7198844a64271b046bc95e9820efbefb9e10878330", + "bit426-source-centres/global/GEOMETRY.json": "e063503254229545578cf12d53eefbf990129d9335af05c680194d35408a959b", + "bit426-source-centres/global/AUDIT.json": "d5d2a4167c5ef479723f588820cd24316cca6bacb0f3a99e03909335e610c426", + "bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz": "c557653592de641a6cdb22f5ad5b3adb5b00fbff4905b7487e4be6767fd18dbd", + "bit426-source-centres/global/GLOBAL.json": "b1f44877c67842c3a804590c9c691c500aaa74c4484ddfb32f273b9c82922c9e" + } +} diff --git a/research/e8-bit-basis-order/port438/COMPLEX-REUSE-BINDING.json b/research/e8-bit-basis-order/port438/COMPLEX-REUSE-BINDING.json new file mode 100644 index 0000000000..1e2d6fcb7b --- /dev/null +++ b/research/e8-bit-basis-order/port438/COMPLEX-REUSE-BINDING.json @@ -0,0 +1,99 @@ +{ + "scientific_source_comparison": { + "code/complex_audit.py": { + "sha256": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "identical_433": true + }, + "code/complex_construct.py": { + "sha256": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "identical_433": true + }, + "code/complex_emit.py": { + "sha256": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "identical_433": true + }, + "code/complex_integrate.py": { + "sha256": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "identical_433": true + }, + "code/complex_phases.py": { + "sha256": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "identical_433": false + }, + "code/complex_phases_full.py": { + "sha256": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "identical_433": true + }, + "code/complex_replay.py": { + "sha256": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "identical_433": true + }, + "inputs/complex-data-phases.json.gz": { + "sha256": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "identical_433": true + }, + "inputs/complex-phase-receipt.json": { + "sha256": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "identical_433": false + }, + "inputs/complex-phase-recipes.json.gz": { + "sha256": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "identical_433": true + }, + "inputs/complex-ports.json.gz": { + "sha256": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "identical_433": true + }, + "inputs/complex-template.json.gz": { + "sha256": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "identical_433": true + }, + "inputs/e8-r865.json.gz": { + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "identical_433": true + }, + "vendor/clifford_exact.py": { + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "identical_433": true + }, + "vendor/engines/base_two_moment.py": { + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "identical_433": true + }, + "vendor/engines/moment.py": { + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "identical_433": true + }, + "vendor/engines/outer.py": { + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "identical_433": true + }, + "vendor/hamming_packets.py": { + "sha256": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "identical_433": true + } + }, + "changed_files": [ + "code/complex_phases.py", + "inputs/complex-phase-receipt.json" + ], + "completion_sha256": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "verified_outputs": { + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd" + }, + "reuse_scope": "Independent completed PR433 complex run; not new PR438 complex execution", + "phase_binding_exception": { + "difference": "PR433 checks decompressed canonical payload and adds runtime gzip digest; PR438 directly checks gzip digest. The only receipt difference is PR433 extra payload SHA. Recipes/compiler/canonical construction otherwise identical.", + "required_guard": "Before reuse assert retained canonical gzip SHA equals PR438 input receipt canonical_word_sha256, payload SHA equals completed PR433 payload pin, recipe SHA equals both sources. No receipt rewriting." + } +} diff --git a/research/e8-bit-basis-order/port438/RECEIPT-MAP.json b/research/e8-bit-basis-order/port438/RECEIPT-MAP.json new file mode 100644 index 0000000000..9ab88ad2d6 --- /dev/null +++ b/research/e8-bit-basis-order/port438/RECEIPT-MAP.json @@ -0,0 +1,12 @@ +{ + "original-word.json.gz": "bit426-source-centres/bit-source-centres-postkernel-original.json", + "word.json.gz": "bit426-source-centres/bit-source-centres.json", + "GLOBAL.json": "bit426-source-centres/global/GLOBAL.json", + "GEOMETRY.json.gz": "bit426-source-centres/global/GEOMETRY.json", + "AUDIT.json": "bit426-source-centres/global/AUDIT.json", + "BASIS-STAGE.json": "bit426-source-centres/BASIS-STAGE.json", + "KERNEL.json": "bit426-source-centres/bit-kernel-receipt.json", + "RESULT.json": "RESULT.json", + "FINITE-COMPARISON.json": "FINITE-COMPARISON.json", + "CONSTRUCT.json": "bit426-source-centres/bit-source-centres-receipt.json" +} diff --git a/research/e8-bit-basis-order/port438/SOURCE-BINDING.json b/research/e8-bit-basis-order/port438/SOURCE-BINDING.json new file mode 100644 index 0000000000..dd3d527d90 --- /dev/null +++ b/research/e8-bit-basis-order/port438/SOURCE-BINDING.json @@ -0,0 +1,244 @@ +{ + "repository": "rohanarun/integer-mult-bounds", + "commit": "e3b56de7869f6af88d48ac0ab1d7959c4c9e6176", + "package": "research/split-centres-kernel-r747", + "manifest_sha256": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "files": { + "SOURCES.json": { + "sha256": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "git_blob": "215f58a649c020caab3a5759680b8b8a95ff0d65" + }, + "PROOF.md": { + "sha256": "0f482e06aeda510e08055848bc2b68d30c93ed1722b9ed5e7613f96cf6346dde", + "git_blob": "9f0346913c84644513aaf3214b088de7f3413f2e" + }, + "EXPECTED.json": { + "sha256": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "git_blob": "06a6966a8d2ea5c07a786dd9cd55ef73964a80e7" + }, + "LICENSE": { + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + "README.md": { + "sha256": "aebe7e50b25e43818f844886ae01c08c712b5453604fccac393631592fe9d0d2", + "git_blob": "872109a08e9b1ba51bb6596e99e3f3a5f55ae660" + }, + "CERTIFICATE.json": { + "sha256": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "git_blob": "7e807079c1ec4907306035c84be1ba2fb1d69d79" + }, + "VALIDATION.json": { + "sha256": "4957420a5a988e045537e31f79da7f8d35592185d45802c0ff4adfd0d97a772e", + "git_blob": "da1036d4714affe518326f3616da026f828654ed" + }, + ".gitattributes": { + "sha256": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "git_blob": "a251e913f29ecb0540e6dd6f040e23a599dcf385" + }, + "MANIFEST.json": { + "sha256": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "git_blob": "e7cb4bbdc6119ba45fc29355808b67d2e7982019" + }, + "verify.py": { + "sha256": "46ed1039f35480fef612d54f12fd874e2266c0ce3baab692603886bc7aa4c58b", + "git_blob": "3e0ac605ec0ea126bed03446bde6cdff2782f4d8" + }, + "NOTICE.md": { + "sha256": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "git_blob": "ee51ac2694522306a1db686086591e1b5485e0dd" + }, + "stages/kernel-selection.json": { + "sha256": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "git_blob": "b1476580528c28fe14951864bfed3e4638b51e30" + }, + "proofs/PR386-BIT-GEOMETRY.txt": { + "sha256": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "git_blob": "31efe312680fdafba0ccfb630bb6b711acad5944" + }, + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": { + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "git_blob": "c4150cb693414c098690eae79b3aea5f47c184ff" + }, + "proofs/PR426.md": { + "sha256": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "git_blob": "e589cfbf5060a05b57facc0e2f1b545b4d73b3fc" + }, + "proofs/PR425-COMPLEX.txt": { + "sha256": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "git_blob": "41061757ce0af663f589e4ca8e58b6dec39d028c" + }, + "code/bit_reset.py": { + "sha256": "000983f6c09ba3baa90cdee69a03464680b6963cfd4f8f7b9301d4e0e6acd6f5", + "git_blob": "8d6cb354beca3667ade196b38ee28ec4057d2e2e" + }, + "code/complex_emit.py": { + "sha256": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "git_blob": "e5fe7b34892e5a1ddbae48b39644f85f25d48a71" + }, + "code/complex_phases_full.py": { + "sha256": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "git_blob": "b5a5bd64b4dd83a6c75ed97363cd28c0ea74ac0a" + }, + "code/bit_global.py": { + "sha256": "b3a486487e223ef0e2b4fd212063c1506740ba18765e99878e07d06968877eca", + "git_blob": "9c326d6629fe14a8fbf5fc871e089261dedde511" + }, + "code/bit_kernel.py": { + "sha256": "14f164fcc0674f73163808a9d9762eb439ea130895f593cb78a6cafaed2dfb11", + "git_blob": "c0b7445f769713d0cd647c1e01f8befc39fffbd1" + }, + "code/bit_audit.py": { + "sha256": "b2b4b792f14ac9946bdcd1bf4c0d47c46fe05ff6ff9c5f0317037c9a1ee1e5fe", + "git_blob": "522d2b7f497756016f115fe73f7f335c094b4416" + }, + "code/complex_construct.py": { + "sha256": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "git_blob": "bbc61e57dc320640a6df5023c23b2483ce2a3f72" + }, + "code/bit_construct.py": { + "sha256": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "git_blob": "e43632e95fee1d310553596950daef04d2a32b45" + }, + "code/complex_audit.py": { + "sha256": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "git_blob": "ba6789a3a636ea0204786bb0347c495ebba185b8" + }, + "code/bit_price.py": { + "sha256": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "git_blob": "005da012a3cf28c2e9564b0fd7ba5300ae067c4d" + }, + "code/complex_integrate.py": { + "sha256": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "git_blob": "ffa5c036d7409c3b90d598b64327ae53be1c52df" + }, + "code/complex_phases.py": { + "sha256": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "git_blob": "6f199bc139319321800c42dc67eac2c9276ec1c7" + }, + "code/combined.py": { + "sha256": "825c32a81529da35a347666468585c69d66c0ee161717f2994769782fb57e29e", + "git_blob": "49588892f26a534d95b39d72cee93d921bd640b9" + }, + "code/complex_replay.py": { + "sha256": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "git_blob": "e9f0490478a7d23d5c88fb076e837350163f9387" + }, + "notices/PR426.md": { + "sha256": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "git_blob": "2a7a8c0c6bf6c50348b1c38ae72711a72083b9df" + }, + "notices/PR426-SOURCE-PINS.json": { + "sha256": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "git_blob": "24a25d43424e5d41efcde9b2846d8104186fe028" + }, + "notices/NOTICE-PR352.md": { + "sha256": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "git_blob": "4f9a0194a34a6b3b431d5b452655a2bc787fdb95" + }, + "notices/PR386.txt": { + "sha256": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "git_blob": "28cfebeb08cdcc5bfa61efca17276237289219e5" + }, + "notices/SUSSMAN-NOTICE": { + "sha256": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "git_blob": "63aa295646734f62c4270e653811530f9a570d3a" + }, + "notices/NOTICE.md": { + "sha256": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "git_blob": "c244e3f56a947a926ae2b8fd624e677d10da8957" + }, + "vendor/clifford_exact.py": { + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + "vendor/export_records.py": { + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350" + }, + "vendor/hamming_packets.py": { + "sha256": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "git_blob": "c1299966560e91a52cd2c39783f23ef8d8648eaa" + }, + "inputs/bit-geometry.json.gz": { + "sha256": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "git_blob": "19725bec462cbc531e180934c9af965d3ce0637f" + }, + "inputs/complex-template.json.gz": { + "sha256": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "git_blob": "975ce5c0df3e4a7aa22264df7f13b592bd2318e6" + }, + "inputs/e8-r865.json.gz": { + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "git_blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e" + }, + "inputs/complex-phase-receipt.json": { + "sha256": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "git_blob": "2a370225ea52a580873cf3642d25bb21e899bd8c" + }, + "inputs/bit-r767.json.gz": { + "sha256": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "git_blob": "807cea53ebe1322721463ee2319bcd52b9714f24" + }, + "inputs/complex-ports.json.gz": { + "sha256": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "git_blob": "ccbdc0596c33ea2e02649a740bdc2273ef320a58" + }, + "inputs/complex-phase-recipes.json.gz": { + "sha256": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "git_blob": "03dc5fbe5e54c0f5fe0e104c2d1b27ab6adcfee2" + }, + "inputs/complex-data-phases.json.gz": { + "sha256": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "git_blob": "22154a8c5875bd3398e1cb112ea0a5307d6793e8" + }, + "vendor/pr434/LICENSE": { + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + "vendor/pr434/replay.py": { + "sha256": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "git_blob": "84d4875764ba1c9520c07cc49d1fb408f800fb91" + }, + "vendor/pr434/SELECTION.json": { + "sha256": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "git_blob": "9df36fb9ef47e0c2ddad0fe4024dc75c294a72c8" + }, + "vendor/engines/base_two_moment.py": { + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61" + }, + "vendor/engines/moment.py": { + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd" + }, + "vendor/engines/outer.py": { + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2" + }, + "vendor/kernel417/LICENSE": { + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + "vendor/kernel417/e8core.py": { + "sha256": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "git_blob": "f2874bae8ef044240211fd892afb457d13759c74" + }, + "vendor/kernel417/stages.py": { + "sha256": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "git_blob": "9ef95d52f4b2ba0389bb2edb15228da698dd75f4" + }, + "vendor/kernel417/engines/base_two_moment.py": { + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61" + }, + "vendor/kernel417/engines/moment.py": { + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd" + }, + "vendor/kernel417/engines/outer.py": { + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2" + } + } +} diff --git a/research/e8-bit-basis-order/port438/VALIDATION.json b/research/e8-bit-basis-order/port438/VALIDATION.json new file mode 100644 index 0000000000..5d918be3f7 --- /dev/null +++ b/research/e8-bit-basis-order/port438/VALIDATION.json @@ -0,0 +1,37 @@ +{ + "status": "PASS_CHANGED_PR438_BIT_FINITE_CHECK", + "source_commit": "e3b56de7869f6af88d48ac0ab1d7959c4c9e6176", + "source_manifest_sha256": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "completed_run_sha256": "a7a2efeef20ba6b8fa381b19bd6bd83745bdca4b2ba255de5caa863ff74eec30", + "fresh_stages": [ + "bit_construct", + "bit_reset", + "bit_kernel", + "post_basis", + "export", + "global", + "audit", + "price", + "combined" + ], + "wall_seconds": 18.487286624964327, + "local_columns": 987, + "global_columns": 7683, + "bank_controls": 8, + "outer_constraints": 47, + "outer_controls": 4, + "complex_scope": "11 unchanged outputs reused from independently completed PR433 complex component; no new complex/phase execution", + "baseline_scope": "Literal original word replay and exact finite algebra on unchanged candidate geometry/schedule; no second baseline global replay", + "adapter_scope": "Exact executed scripts with original temporary paths retained as evidence, not a portable CLI", + "postprocessor_scope": "Portable actual-input API and CLI; downstream supplier admission required for every new word", + "coefficient_bits": [ + 226, + 193 + ], + "two_level_bits": [ + 488, + 423 + ], + "local_add_delta": 32, + "kappa_unchanged": true +} diff --git a/research/e8-bit-basis-order/port438/adapter/MANIFEST.json b/research/e8-bit-basis-order/port438/adapter/MANIFEST.json new file mode 100644 index 0000000000..d9a458adf5 --- /dev/null +++ b/research/e8-bit-basis-order/port438/adapter/MANIFEST.json @@ -0,0 +1,7 @@ +{ + "files": { + "basis_postprocess.py": "d19a6dec2c96e9d20eecd483182a6ccd783d23a7365ef756518ab77da6657393", + "post_stage.py": "d8189ba82a872b95960063f5c410577fc7ff0ff1029172d1daaec6f0fdce6db3", + "driver.py": "5c3295101d7eb9a8adde8900b158f094c2381829376c299c0939f39fc0827ebb" + } +} diff --git a/research/e8-bit-basis-order/port438/adapter/basis_postprocess.py b/research/e8-bit-basis-order/port438/adapter/basis_postprocess.py new file mode 100644 index 0000000000..52aa4cbe98 --- /dev/null +++ b/research/e8-bit-basis-order/port438/adapter/basis_postprocess.py @@ -0,0 +1,86 @@ +"""Reorder a compatible full-frame source basis after upstream transformations. + +George Lydakis with OpenAI Codex assistance. Apache-2.0. +This preserves the copied forms; downstream supplier validation is still required. +""" +import copy +import json +from pathlib import Path + + +def reorder_basis(word): + if not __debug__: + raise RuntimeError('Assertions must remain enabled') + v, count = word['v'], word['source_basis_gates'] + full = word['final'][0] + if not isinstance(count, int) or count <= 0 or count > min(len(word['A']), len(word['B'])): + raise ValueError('A nonempty, explicitly delimited source basis is required') + basis = word['A'][-count:] + if word['B'][:count] != list(reversed(basis)): + raise ValueError('The original basis block must have its literal inverse') + rows = [1 << i for i in range(v)] + for frame, destination, sources in basis: + if frame != full or not 0 <= destination < v or len(sources) != 1 or not 0 <= sources[0] < v or sources[0] == destination: + raise ValueError('The basis block must consist of full-frame source XORs') + rows[destination] ^= rows[sources[0]] + if not word['ret'] or len(set(word['ret'])) != len(word['ret']) or any(not 0 <= r < v for r in word['ret']): + raise ValueError('Retained forms must occupy distinct original source rows') + forms = [rows[r] for r in word['ret']] + echelon = {} + for row in forms: + for pivot, other in sorted(echelon.items(), reverse=True): + if row >> pivot & 1: + row ^= other + assert row, 'Copied forms must be independent' + echelon[row.bit_length()-1] = row + pivots = sorted(echelon, reverse=True) + matrix = [1 << i for i in range(v)] + for pivot, row in zip(pivots, forms): + matrix[pivot] = row + target = matrix[:] + elimination = [] + def add(destination, source): + matrix[destination] ^= matrix[source] + elimination.append([full, destination, [source]]) + for pivot in range(v): + found = next(i for i in range(pivot, v) if matrix[i] >> pivot & 1) + if found != pivot: + add(pivot, found); add(found, pivot); add(pivot, found) + for row in range(v): + if row != pivot and matrix[row] >> pivot & 1: + add(row, pivot) + assert matrix == [1 << i for i in range(v)] + forward = list(reversed(elimination)) + check = [1 << i for i in range(v)] + for _, destination, sources in forward: + check[destination] ^= check[sources[0]] + assert check == target and [check[r] for r in pivots] == forms + old_touched = {r for _, d, sources in basis for r in [d]+sources} + new_touched = {r for _, d, sources in forward for r in [d]+sources} + if old_touched != new_touched: + raise ValueError('Reordering must preserve the source rows entering the full frame') + current = word['start'][:] + for frame, destination, sources in word['D']+word['A'][:-count]: + for row in [destination]+sources: + current[row] = frame + for row in new_touched: + current[row] = full + if any(current[row] != full for row in pivots): + raise ValueError('Every copied form must be at the full frame') + result = copy.deepcopy(word) + result['A'] = result['A'][:-count]+forward + result['B'] = elimination+result['B'][count:] + result['ret'] = pivots + result['source_basis_gates'] = len(forward) + return result + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('input', type=Path) + parser.add_argument('output', type=Path, help='A new candidate file; the input is preserved') + args = parser.parse_args() + result = reorder_basis(json.loads(args.input.read_bytes())) + with args.output.open('x') as stream: + stream.write(json.dumps(result, sort_keys=True, separators=(',', ':'))) diff --git a/research/e8-bit-basis-order/port438/adapter/driver.py b/research/e8-bit-basis-order/port438/adapter/driver.py new file mode 100644 index 0000000000..959bad14a0 --- /dev/null +++ b/research/e8-bit-basis-order/port438/adapter/driver.py @@ -0,0 +1,49 @@ +from pathlib import Path +import os,sys,json,hashlib,subprocess,gzip,time,resource +S=Path('/tmp/task2-pr438-basis-port/source');A=Path(__file__).resolve().parent;B=Path('/tmp/task2-pr433-default-envelope/run');O=Path('/tmp/task2-pr438-basis-finite-fresh') +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +def snap(root): + assert not any(p.is_symlink() for p in root.rglob('*')) + return {p.relative_to(root).as_posix():sha(p) for p in root.rglob('*') if p.is_file()} +if not __debug__ or sys.flags.optimize:raise RuntimeError('assertions disabled') +if O.exists():raise RuntimeError('fresh output required') +m=json.loads((S/'MANIFEST.json').read_text());before=snap(S);assert {k:v for k,v in before.items() if k!='MANIFEST.json'}==m['files'] +am=json.loads((A/'MANIFEST.json').read_text());ab=snap(A);assert {k:v for k,v in ab.items() if k!='MANIFEST.json'}==am['files'] +cp=B.parent/'COMPLETION.json';cr=json.loads(cp.read_text());PIN='3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f';assert cr['status']=='PASS_RETAINED_DEFAULT_PR433_REPLAY' and cr['returncode']==0 and cr['source_manifest_before']==cr['source_manifest_after']==PIN +oldS=Path('/tmp/task2-pr433-immutable-static');assert sha(oldS/'MANIFEST.json')==PIN;assert {k:v for k,v in snap(oldS).items() if k!='MANIFEST.json'}==json.loads((oldS/'MANIFEST.json').read_text())['files'] +bind=json.loads(Path('/tmp/task2-pr438-basis-port/COMPLEX-REUSE-BINDING.json').read_text());assert sha(cp)==bind['completion_sha256'];assert set(bind['changed_files'])=={'code/complex_phases.py','inputs/complex-phase-receipt.json'} +for n,z in bind['scientific_source_comparison'].items(): + assert sha(S/n)==z['sha256'] + if z['identical_433']:assert (S/n).read_bytes()==(oldS/n).read_bytes() +phase=json.loads((S/'inputs/complex-phase-receipt.json').read_text());canonical=B/'split-centres/CANONICAL-WORD.json.gz';assert sha(canonical)==phase['canonical_word_sha256'];assert hashlib.sha256(gzip.decompress(canonical.read_bytes())).hexdigest()=='be2d8d412b948bce50a0fc852ab4c01f57bff4c3c8272da80c09be5bcdf253bf';assert hashlib.sha256(gzip.decompress((S/'inputs/complex-phase-recipes.json.gz').read_bytes())).hexdigest()==phase['recipe_sha256'] +reused={k:sha(B.parent/k) for k in bind['verified_outputs']};assert reused==bind['verified_outputs'];inputs=dict(completion=sha(cp),reuse_binding=sha(Path('/tmp/task2-pr438-basis-port/COMPLEX-REUSE-BINDING.json')),**reused) +def now():return dict(completion=sha(cp),reuse_binding=sha(Path('/tmp/task2-pr438-basis-port/COMPLEX-REUSE-BINDING.json')),**{k:sha(B.parent/k) for k in reused}) +O.mkdir();(O/'scratch').mkdir();start=time.monotonic();steps=[] +def copy(src,dst,decompress=False): + p=O/dst;p.parent.mkdir(parents=True,exist_ok=True);raw=src.read_bytes();p.write_bytes(gzip.decompress(raw) if decompress else raw) +for src,dst in [('inputs/e8-r865.json.gz','work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz'),('inputs/bit-geometry.json.gz','inherited/bit-geometry.json.gz')]:copy(S/src,dst) +for n in ['moment','base_two_moment','outer']:copy(S/('vendor/engines/'+n+'.py'),'work/pr361/code/engines/'+n+'.py') +for k in reused:copy(B.parent/k,k.removeprefix('run/')) +p=O/'bit426-source-centres';p.mkdir();copy(S/'inputs/bit-r767.json.gz','bit426-source-centres/bit-input.json',True) +env=dict(os.environ,E8_OUTPUT=str(O),PYTHONDONTWRITEBYTECODE='1',PYTHONINTMAXSTRDIGITS='0',TMPDIR=str(O/'scratch'));env.pop('PYTHONOPTIMIZE',None) +try: + tasks=[(n,S/('code/'+n+'.py'),[]) for n in ['bit_construct','bit_reset','bit_kernel']]+[('post_basis',A/'post_stage.py',[]),('export',S/'vendor/export_records.py',[p/'bit-source-centres.json',p/'records']),('global',S/'code/bit_global.py',['--source',p,'--local-check',p,'--out',p/'global']),('audit',S/'code/bit_audit.py',['--local-check',p,'--out',p/'global']),('price',S/'code/bit_price.py',[]),('combined',S/'code/combined.py',[])] + for name,file,args in tasks: + with (O/(name+'.log')).open('w') as log:r=subprocess.run([sys.executable,'-B',str(file),*map(str,args)],cwd=O,env=env,stdout=log,stderr=subprocess.STDOUT) + steps.append(dict(name=name,returncode=r.returncode,log_sha256=sha(O/(name+'.log'))));assert r.returncode==0,(name,r.returncode) + result=json.loads((O/'RESULT.json').read_text());expected=json.loads((S/'EXPECTED.json').read_text()) + for k,v in expected.items(): + if k not in {'bit_invoice','bit_template_sha256'}:assert result[k]==v,(k,result[k],v) + g=json.loads((p/'global/GLOBAL.json').read_text());audit=json.loads((p/'global/AUDIT.json').read_text());assert len(audit['mutations_rejected'])==8 + assert (g['R'],g['live'],g['physical'])==(747,14223,14232);assert result['bit_invoice']['coefficient_bits']==193 and result['bit_invoice']['two_level_coefficient_bits']==423 + P={int(r):n for r,n in audit['profile'].items()};E=sum(P.values());mass=sum(r*n for r,n in P.items());geo=json.loads((p/'global/GEOMETRY.json').read_text()) + assert g['banks_per_stage']==727 and mass==64*g['live']-2496 and P=={1:180792,2:74232,3:22248,4:24984,5:7344,7:6768,8:648,14:3840,28:3840,42:3840} + unit=72*g['local_additions']+g['bridge_additions'];J=8*8*9*(240+g['R'])+8*(2*4*120*8)+2*g['bank_assignments']+2*g['copy_erase_episodes'] + selectors=2*9*8*((g['live']-1)+g['R']*64*(geo['max_route_factors']+63+64));prefix=int(g['global_prefix_bound']) + coefficient=unit+J*16*(4096+1)**2+J*g['physical']+E*(8*4096+8+128*128**3)+16*64**3+g['copy_erase_episodes']+selectors+prefix+1 + two=(coefficient+1)**2*(E+1)**2;assert coefficient==11618636861972555523343873296287586172648663760810665400081 and two.bit_length()==423 and g['local_additions']==14757 + (O/'FINITE-COMPARISON.json').write_text(json.dumps(dict(status='PASS_ACTUAL_FRESH_FINITE_INVOICE',candidate_coefficient=str(coefficient),candidate_bits=coefficient.bit_length(),candidate_two_level_bits=two.bit_length(),source_projected_coefficient='82188330587888376961373106195271196377707398804483318967211886464529',source_projected_bits=226,source_projected_two_level_bits=488,baseline_scope='Local replay plus exact algebra nomination; baseline full global not rerun',b=result['complex_lower'],c=result['bit_lower'],k=result['kappa']),indent=2)+'\n') + assert snap(S)==before and snap(A)==ab and now()==inputs + (O/'COMPLETION.json').write_text(json.dumps(dict(status='PASS_CHANGED_PR438_BIT_FINITE_CHECK',scope='Post-kernel port of published basis method; independently completed PR433 complex evidence reused; no new exponent or runtime claim',source_before=before,source_after=snap(S),adapter_manifest_sha256=sha(A/'MANIFEST.json'),inputs_before=inputs,inputs_after=now(),steps=steps,wall_seconds=time.monotonic()-start,child_usage=list(resource.getrusage(resource.RUSAGE_CHILDREN)),output_hashes=snap(O)),indent=2)+'\n') +except BaseException as e: + (O/'FAILURE.json').write_text(json.dumps(dict(error=repr(e),steps=steps,source_unchanged=snap(S)==before,adapter_unchanged=snap(A)==ab,input_unchanged=now()==inputs,wall_seconds=time.monotonic()-start),indent=2)+'\n');raise diff --git a/research/e8-bit-basis-order/port438/adapter/post_stage.py b/research/e8-bit-basis-order/port438/adapter/post_stage.py new file mode 100644 index 0000000000..5a3e82f50b --- /dev/null +++ b/research/e8-bit-basis-order/port438/adapter/post_stage.py @@ -0,0 +1,25 @@ +from pathlib import Path +import json,os,sys,copy,hashlib,importlib.util +from basis_postprocess import reorder_basis +S=Path('/tmp/task2-pr438-basis-port/source');D=Path(os.environ['E8_OUTPUT'])/'bit426-source-centres';p=D/'bit-source-centres.json';raw=p.read_bytes();w=json.loads(raw) +assert hashlib.sha256(raw).hexdigest()=='cc6242d90ccdd8477521ea16f35ee2667dbe6c48cc60c6e4e9bcf6460497b233' +w0=copy.deepcopy(w);n=reorder_basis(w);assert w==w0 and reorder_basis(n)==n +for k in set(w)-{'A','B','ret','source_basis_gates'}:assert n[k]==w[k] +old=w['source_basis_gates'];new=n['source_basis_gates'];assert n['A'][:-new]==w['A'][:-old] and n['B'][new:]==w['B'][old:] +sys.path.insert(0,str(S/'vendor/kernel417'));import e8core +r0=e8core.replay(w,span_mode='z');r=e8core.replay(n,span_mode='z');assert not r0['viol'] and not r['viol'] and r['H']==r0['H'] and r['sig']==r0['sig'] +def reflected(x): + v=x['v'];N=2*v+x['R'];rows=[1< min(len(word['A']), len(word['B'])): + raise ValueError('A nonempty, explicitly delimited source basis is required') + basis = word['A'][-count:] + if word['B'][:count] != list(reversed(basis)): + raise ValueError('The original basis block must have its literal inverse') + rows = [1 << i for i in range(v)] + for frame, destination, sources in basis: + if frame != full or not 0 <= destination < v or len(sources) != 1 or not 0 <= sources[0] < v or sources[0] == destination: + raise ValueError('The basis block must consist of full-frame source XORs') + rows[destination] ^= rows[sources[0]] + if not word['ret'] or len(set(word['ret'])) != len(word['ret']) or any(not 0 <= r < v for r in word['ret']): + raise ValueError('Retained forms must occupy distinct original source rows') + forms = [rows[r] for r in word['ret']] + echelon = {} + for row in forms: + for pivot, other in sorted(echelon.items(), reverse=True): + if row >> pivot & 1: + row ^= other + assert row, 'Copied forms must be independent' + echelon[row.bit_length()-1] = row + pivots = sorted(echelon, reverse=True) + matrix = [1 << i for i in range(v)] + for pivot, row in zip(pivots, forms): + matrix[pivot] = row + target = matrix[:] + elimination = [] + def add(destination, source): + matrix[destination] ^= matrix[source] + elimination.append([full, destination, [source]]) + for pivot in range(v): + found = next(i for i in range(pivot, v) if matrix[i] >> pivot & 1) + if found != pivot: + add(pivot, found); add(found, pivot); add(pivot, found) + for row in range(v): + if row != pivot and matrix[row] >> pivot & 1: + add(row, pivot) + assert matrix == [1 << i for i in range(v)] + forward = list(reversed(elimination)) + check = [1 << i for i in range(v)] + for _, destination, sources in forward: + check[destination] ^= check[sources[0]] + assert check == target and [check[r] for r in pivots] == forms + old_touched = {r for _, d, sources in basis for r in [d]+sources} + new_touched = {r for _, d, sources in forward for r in [d]+sources} + if old_touched != new_touched: + raise ValueError('Reordering must preserve the source rows entering the full frame') + current = word['start'][:] + for frame, destination, sources in word['D']+word['A'][:-count]: + for row in [destination]+sources: + current[row] = frame + for row in new_touched: + current[row] = full + if any(current[row] != full for row in pivots): + raise ValueError('Every copied form must be at the full frame') + result = copy.deepcopy(word) + result['A'] = result['A'][:-count]+forward + result['B'] = elimination+result['B'][count:] + result['ret'] = pivots + result['source_basis_gates'] = len(forward) + return result + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('input', type=Path) + parser.add_argument('output', type=Path, help='A new candidate file; the input is preserved') + args = parser.parse_args() + result = reorder_basis(json.loads(args.input.read_bytes())) + with args.output.open('x') as stream: + stream.write(json.dumps(result, sort_keys=True, separators=(',', ':'))) diff --git a/research/e8-bit-basis-order/reproduce.py b/research/e8-bit-basis-order/reproduce.py new file mode 100644 index 0000000000..aa2f046dd1 --- /dev/null +++ b/research/e8-bit-basis-order/reproduce.py @@ -0,0 +1,64 @@ +"""Portable pinned-PR433 bit-only reproduction; complex evidence is reused explicitly.""" +import argparse,gzip,hashlib,json,os,resource,subprocess,sys,time +from pathlib import Path +ROOT=Path(__file__).resolve().parent +PIN='3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f' +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def read(p):return json.loads(p.read_bytes()) +def snapshot(root): + paths=list(root.rglob('*')) + if any(p.is_symlink() for p in paths):raise RuntimeError('Symlinks are outside the pinned closure') + return {p.relative_to(root).as_posix():sha(p) for p in paths if p.is_file() and p.relative_to(root).as_posix()!='MANIFEST.json'} +def main(): + if not __debug__ or sys.flags.optimize:raise RuntimeError('Assertions must be enabled') + if hasattr(sys,'set_int_max_str_digits'):sys.set_int_max_str_digits(0) + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source',type=Path,required=True);group=ap.add_mutually_exclusive_group(required=True);group.add_argument('--output',type=Path);group.add_argument('--check-inputs',action='store_true');a=ap.parse_args();S=a.source.resolve();O=a.output.resolve() if a.output else None + if O is not None and (O.exists() or O.is_relative_to(ROOT) or O.is_relative_to(S)):raise RuntimeError('Output must be fresh and outside both packages') + package_before=snapshot(ROOT);source_before=snapshot(S) + assert package_before==read(ROOT/'MANIFEST.json')['files'] + assert sha(S/'MANIFEST.json')==sha(ROOT/'inputs/SUPPLIER-MANIFEST.json')==PIN + assert source_before==read(S/'MANIFEST.json')['files'] + provenance=read(ROOT/'SOURCES.json') + for z in provenance['files']: + raw=(ROOT/z['path']).read_bytes();raw=gzip.decompress(raw) if z['gzip'] else raw + assert hashlib.sha256(raw).hexdigest()==z['original_sha256'],z['path'] + original=(ROOT/'vendor/bit_construct.py').read_text();assert original==(S/'code/bit_construct.py').read_text() + changes=[('sorted(echelon.items())','sorted(echelon.items(), reverse=True)'),('p = (row & -row).bit_length() - 1','p = row.bit_length() - 1'),('pivots = sorted(echelon)','pivots = sorted(echelon, reverse=True)')] + derived=original + for before,after in changes: + assert derived.count(before)==1;derived=derived.replace(before,after) + assert hashlib.sha256(derived.encode()).hexdigest()=='61578d8959893e7fec667d5e7697cc6faef773d1e7c50a45e929e69a0038f279' + expected=read(ROOT/'EXPECTED.json');candidate=gzip.decompress((ROOT/'inputs/candidate/word.json.gz').read_bytes());assert hashlib.sha256(candidate).hexdigest()==expected['candidate_sha256'] + baseline=read(ROOT/'inputs/baseline/COMPLETION.json');assert baseline['status']=='PASS_RETAINED_DEFAULT_PR433_REPLAY' and baseline['returncode']==0 and baseline['source_manifest_before']==baseline['source_manifest_after']==PIN + copies=[('source','inputs/e8-r865.json.gz','work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz'),('source','inputs/bit-geometry.json.gz','inherited/bit-geometry.json.gz')]+[('source','vendor/engines/'+n+'.py','work/pr361/code/engines/'+n+'.py') for n in ['moment','base_two_moment','outer']]+[('package','inputs/complex/'+n+'.json','split-centres/'+n+'.json') for n in ['INTEGRATION','INDEPENDENT-REPLAY']] + for kind,path,dst in copies: + assert sha((S if kind=='source' else ROOT)/path)==baseline['output_hashes']['run/'+dst],path + # Input mode validates bytes and the exact three-line derivation only; it executes no supplier stage. + if a.check_inputs: + assert snapshot(ROOT)==package_before and snapshot(S)==source_before + print(json.dumps(dict(status='PASS_INPUTS_ONLY_NO_SCIENTIFIC_EXECUTION',derived_constructor_sha256=hashlib.sha256(derived.encode()).hexdigest(),candidate_sha256=expected['candidate_sha256'],source_manifest_sha256=PIN)));return + start=time.monotonic();O.mkdir();(O/'scratch').mkdir();steps=[] + def copy(data,dst): + p=O/dst;p.parent.mkdir(parents=True,exist_ok=True);p.write_bytes(data) + for kind,path,dst in copies:copy(((S if kind=='source' else ROOT)/path).read_bytes(),dst) + p=O/'bit426-source-centres';p.mkdir();copy(gzip.decompress((S/'inputs/bit-r767.json.gz').read_bytes()),'bit426-source-centres/bit-input.json');copy(derived.encode(),'derived-bit-construct.py') + env=dict(os.environ,E8_OUTPUT=str(O),PYTHONDONTWRITEBYTECODE='1',PYTHONINTMAXSTRDIGITS='0',TMPDIR=str(O/'scratch'));env.pop('PYTHONOPTIMIZE',None) + def run(name,script,*args): + with (O/(name+'.log')).open('w') as log:r=subprocess.run([sys.executable,'-B',str(script),*map(str,args)],cwd=O,env=env,stdout=log,stderr=subprocess.STDOUT) + steps.append(dict(name=name,returncode=r.returncode,log_sha256=sha(O/(name+'.log'))));assert r.returncode==0,(name,r.returncode) + try: + run('construct',O/'derived-bit-construct.py');assert sha(p/'bit-source-centres.json')==expected['candidate_sha256'] + run('export',S/'vendor/export_records.py',p/'bit-source-centres.json',p/'records') + run('global',S/'code/bit_global.py','--source',p,'--local-check',p,'--out',p/'global') + run('audit',S/'code/bit_audit.py','--local-check',p,'--out',p/'global') + run('price',S/'code/bit_price.py');run('combined',S/'code/combined.py') + result=read(O/'RESULT.json');assert result['kappa']==expected['kappa'] + g=read(p/'global/GLOBAL.json');geo=read(p/'global/GEOMETRY.json');E=g['paid_calls'];J=576*998+61440+2*g['bank_assignments']+2*g['copy_erase_episodes'];selectors=144*(14501+758*64*(geo['max_route_factors']+127)) + coefficient=72*g['local_additions']+g['bridge_additions']+J*(16*4097**2+14511)+E*(8*64**2+8+128*128**3)+16*64**3+g['copy_erase_episodes']+selectors+int(g['global_prefix_bound'])+1 + assert str(coefficient)==expected['coefficient'] and str((coefficient+1)**2*(E+1)**2)==expected['two_level_coefficient'] + assert snapshot(ROOT)==package_before and snapshot(S)==source_before + completion=dict(status='PASS_PORTABLE_CHANGED_BIT_FINITE_REPRODUCTION',scope='Changed bit stages; original complex evidence reused; no complex/phase replay',steps=steps,source_manifest_sha256=PIN,package_manifest_sha256=sha(ROOT/'MANIFEST.json'),source_before=source_before,source_after=snapshot(S),package_before=package_before,package_after=snapshot(ROOT),coefficient=str(coefficient),wall_seconds=time.monotonic()-start,child_usage=list(resource.getrusage(resource.RUSAGE_CHILDREN)),output_hashes=snapshot(O)) + (O/'COMPLETION.json').write_text(json.dumps(completion,indent=2)+'\n');print(completion['status']) + except BaseException as e: + (O/'FAILURE.json').write_text(json.dumps(dict(error=repr(e),steps=steps,source_unchanged=snapshot(S)==source_before,package_unchanged=snapshot(ROOT)==package_before,wall_seconds=time.monotonic()-start),indent=2)+'\n');raise +if __name__=='__main__':main() diff --git a/research/e8-bit-basis-order/test_postprocess.py b/research/e8-bit-basis-order/test_postprocess.py new file mode 100644 index 0000000000..5131329b2f --- /dev/null +++ b/research/e8-bit-basis-order/test_postprocess.py @@ -0,0 +1,85 @@ +"""Behavioral contracts for the guarded source-basis postprocessor.""" +import copy +import gzip +import importlib.util +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location('postprocess', ROOT/'postprocess.py') +module = importlib.util.module_from_spec(spec) +spec.loader.exec_module(module) + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +class PostprocessTests(unittest.TestCase): + def test_reconstructs_both_selected_words_without_mutation(self): + for before, after in [ + ('inputs/baseline/word.json.gz', 'inputs/candidate/word.json.gz'), + ('port438/inputs/original-word.json.gz', 'port438/inputs/word.json.gz'), + ]: + with self.subTest(source=before): + source = read(ROOT/before) + snapshot = copy.deepcopy(source) + candidate = module.reorder_basis(source) + self.assertEqual(candidate, read(ROOT/after)) + self.assertEqual(source, snapshot) + self.assertEqual(module.reorder_basis(candidate), candidate) + + def test_rejects_unsafe_basis_interfaces(self): + word = read(ROOT/'inputs/baseline/word.json.gz') + count = word['source_basis_gates'] + for name in ['undelimited', 'inverse', 'helper', 'frame', 'dependent', 'touch_set']: + with self.subTest(case=name): + bad = copy.deepcopy(word) + if name == 'undelimited': + bad['source_basis_gates'] = 0 + elif name == 'inverse': + bad['B'][0][2][0] = bad['B'][0][1] + elif name in ['helper', 'frame']: + gate = bad['A'][-count] + if name == 'helper': + gate[1] = word['v']*2 + else: + gate[0] = -1 + bad['B'][:count] = copy.deepcopy(list(reversed(bad['A'][-count:]))) + elif name == 'dependent': + bad['ret'][1] = bad['ret'][0] + else: + # This invertible two-row basis copies an untouched third row. + # Replacing it with the identity would drop full-frame visits. + bad = dict(v=3, R=0, final=[1]*6, start=[0]*6, + A=[[1, 0, [1]]], B=[[1, 0, [1]]], D=[], C=[], + source_basis_gates=1, ret=[2], scatter=[[], [], [0]]) + with self.assertRaises((ValueError, AssertionError)): + module.reorder_basis(bad) + + def test_cli_preserves_input_and_refuses_overwrite(self): + source = ROOT/'inputs/baseline/word.json.gz' + directory = tempfile.mkdtemp(prefix='basis-postprocess-test-') + print('Retained CLI test outputs:', directory) + source_path = Path(directory)/'input.json' + output = Path(directory)/'output.json' + raw = gzip.decompress(source.read_bytes()) + source_path.write_bytes(raw) + cmd = [sys.executable, '-B', str(ROOT/'postprocess.py'), str(source_path), str(output)] + result = subprocess.run(cmd, capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(read(output), read(ROOT/'inputs/candidate/word.json.gz')) + saved = output.read_bytes() + result = subprocess.run(cmd, capture_output=True, text=True) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(output.read_bytes(), saved) + self.assertEqual(source_path.read_bytes(), raw) + + +if __name__ == '__main__': + unittest.main() diff --git a/research/e8-bit-basis-order/vendor/NOTICE-PR433.md b/research/e8-bit-basis-order/vendor/NOTICE-PR433.md new file mode 100644 index 0000000000..b7daf8de49 --- /dev/null +++ b/research/e8-bit-basis-order/vendor/NOTICE-PR433.md @@ -0,0 +1,41 @@ +# Attribution + +Copyright 2026 icekylinx. New split-centre cancellation, reversible source-centre +composition, integration and verification changes were prepared by icekylinx +with substantial OpenAI Codex assistance. Apache-2.0 applies to these changes. +Earlier private Pro exploration used GPT-6 Astra; the new construction and +composition in this package were developed with Codex. + +## Direct sources + +- Zhihao Chen, with OpenAI Codex assistance: PR425's mutable-basis Hamming packet + producer, common-frame scalar interface, exact phase lowering and verification; + PR386's compressed nine-stage bit geometry, owner template, audit and finite + accounting. These supply the immediate complex and geometric baselines. +- ai-nanachi, with OpenAI Codex assistance: PR426's R767 bit word, including 55 + clean-reset helper reuses and 54 frame changes. The complete selected word is + imported unchanged before the nine source-centre replacements. +- Dylan Crow (utcorvusvolat-dotcom), with Anthropic Claude assistance: PR370's + Hamming E8 bit producer, root table, record exporter and local format. +- Jacob Sussman: the E8 family, complex unit and underlying interchange framework. +- applecrusher, Dugongue, eumemic, Rohan Arun, Chafik Boukhalfa, DaysSky, + DreamingOfClouds, Henry Grant, Evan McKinney, LJH-217 and other contributors: + the source, frame, compiler, rational-pricing and analytic lineage detailed + in the preserved original notices. + +The current value is computed from the two actual resulting programs. +Independently published improvements are not added numerically. `SOURCES.json` +records original commits and file hashes; `notices/` preserves source notices. +Files under `proofs/` describe their original packages and retain their original +scope and attribution; the current statement is in `PROOF.md`. + +## Earlier contributions by icekylinx + +The earlier #10, #18, #24, #32 and #36 contributions developed projector batching, +partial-swap frames, endpoint gauges and conditional analytic/tape integration. +The subsequent #104, #115, #130 and #144 contributions covered stopped-product +integration, partial gauges, three-stage covers and paired-cube/source chronology. +These provide historical context, not additional savings in this ledger. The +source-centre idea from the preceding local round is used here on PR426's bit +word. Unselected research experiments and superseded submission candidates are +not part of this package. diff --git a/research/e8-bit-basis-order/vendor/bit_construct.py b/research/e8-bit-basis-order/vendor/bit_construct.py new file mode 100644 index 0000000000..e43632e95f --- /dev/null +++ b/research/e8-bit-basis-order/vendor/bit_construct.py @@ -0,0 +1,134 @@ +"""Replace independent retained helpers by a reversible source-basis word. + +icekylinx, with Codex assistance. Inherited E8 input notices apply. This +certifies the finite local F2 word and nested incidences, not a new kappa. +""" +from pathlib import Path +from hashlib import sha256 +import copy +import json + +import os +ROOT = Path(os.environ['E8_OUTPUT']) / 'bit426-source-centres' + + +def replay(c, skip_inverse=False, skip_dirt=False): + v, n = c['v'], 2*c['v'] + c['R'] + x = [1 << i for i in range(n)] + def run(gs): + for f, d, ss in gs: + assert d not in ss + for s in ss: + x[d] ^= x[s] + if not skip_dirt: + run(c['D']) + run(c['A']) + totals = [x[r] for r in c['ret']] + for t, ss in enumerate(c['scatter']): + for k in ss: + x[v+t] ^= totals[k] + run(c['B'][c.get('source_basis_gates', 0):] if skip_inverse else c['B']) + run(c['C']) + expected = [1 << i for i in range(n)] + for t in range(v): + expected[v+t] ^= 1 << t + return x == expected + + +def main(): + source = ROOT / 'bit-input.json' + old = json.loads(source.read_bytes()) + assert replay(old) + v = old['v'] + retired = set(old['ret']) + full = old['final'][0] + rows = [] + for r in old['ret']: + row = 0 + for f, d, ss in old['A']: + if d == r: + assert f == full and all(s < v for s in ss) + for s in ss: + row ^= 1 << s + assert row + rows.append(row) + assert all(not retired.intersection(ss) for f, d, ss in old['A'] + old['B']) + assert all(d not in retired for f, d, ss in old['B']) + # Find an invertible minor, preserving the original order of centre rows. + echelon = {} + for row in rows: + for p, q in sorted(echelon.items()): + if row >> p & 1: + row ^= q + assert row, 'Retained forms must be independent' + p = (row & -row).bit_length() - 1 + echelon[p] = row + pivots = sorted(echelon) + matrix = [1 << i for i in range(v)] + for p, row in zip(pivots, rows): + matrix[p] = row + target = matrix[:] + elimination = [] + def add(d, s): + matrix[d] ^= matrix[s] + elimination.append((d, s)) + for p in range(v): + q = next(i for i in range(p, v) if matrix[i] >> p & 1) + if q != p: + add(p, q); add(q, p); add(p, q) + for i in range(v): + if i != p and matrix[i] >> p & 1: + add(i, p) + assert matrix == [1 << i for i in range(v)] + forward = [[full, d, [s]] for d, s in reversed(elimination)] + inverse = list(reversed(forward)) + check = [1 << i for i in range(v)] + for f, d, ss in forward: + check[d] ^= check[ss[0]] + assert check == target + out = copy.deepcopy(old) + physical = [i for i in range(2*v+old['R']) if i not in retired] + index = {r: i for i, r in enumerate(physical)} + def remap(gs): + return [[f, index[d], [index[s] for s in ss if s not in retired]] + for f, d, ss in gs if d not in retired] + out['R'] -= len(retired) + out['ret'] = pivots + out['D'] = remap(old['D']) + out['A'] = remap(old['A']) + forward + out['B'] = inverse + remap(old['B']) + out['C'] = remap(old['C']) + out['start'] = [old['start'][i] for i in physical] + out['final'] = [old['final'][i] for i in physical] + out['source_basis_gates'] = len(forward) + assert replay(out), 'All independent source, target and dirty columns' + assert not replay(out, skip_inverse=True) + assert not replay(out, skip_dirt=True) + # Frame incidence inclusion uses the root-closed sets in this bit format. + frames = [set(f) for f in out['frames']] + cur = out['start'][:] + for phase in ['D', 'A', 'B', 'C']: + for f, d, ss in out[phase]: + for r in [d] + ss: + assert frames[cur[r]] <= frames[f], (phase, r, cur[r], f) + cur[r] = f + if phase == 'A': + assert all(cur[r] == full for r in out['ret']) + assert all(frames[f] <= frames[g] for f, g in zip(cur, out['final'])) + raw = json.dumps(out, sort_keys=True, separators=(',', ':')).encode() + (ROOT / 'bit-source-centres.json').write_bytes(raw) + result = dict(status='PASS_LOCAL_ALL_COLUMNS_AND_NESTED_FRAMES', + original_R=old['R'], new_R=out['R'], + removed_retained_helpers=sorted(retired), retained_source_rows=pivots, + formal_columns=2*v+out['R'], reversible_basis_gates_each_way=len(forward), + source_sha256=sha256(source.read_bytes()).hexdigest(), + output_sha256=sha256(raw).hexdigest(), + controls=['unmodified word passes', 'missing inverse rejected', 'missing dirt rejected'], + kappa_claimed=False, + remaining=['global ordinary-call and reflected integration', 'finite coefficient and tape invoice', 'exact priced component comparison']) + (ROOT / 'bit-source-centres-receipt.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result)) + + +if __name__ == '__main__': + main() diff --git a/research/e8-bit-basis-order/verify.py b/research/e8-bit-basis-order/verify.py new file mode 100644 index 0000000000..ff26398433 --- /dev/null +++ b/research/e8-bit-basis-order/verify.py @@ -0,0 +1,200 @@ +"""Independent literal-word and retained-evidence audit of basis reordering.""" +from pathlib import Path +import gzip +import hashlib +import json +import difflib + +if not __debug__: + raise RuntimeError('Assertions must remain enabled') +ROOT = Path(__file__).resolve().parent + + +def raw(name): + data = (ROOT/name).read_bytes() + return gzip.decompress(data) if str(name).endswith('.gz') else data + + +def read(name): + return json.loads(raw(name)) + + +def digest(name): + return hashlib.sha256(raw(name)).hexdigest() + + +def snapshot(): + assert not any(p.is_symlink() for p in ROOT.rglob('*')) + return {p.relative_to(ROOT).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() + for p in ROOT.rglob('*') if p.is_file() and p != ROOT/'MANIFEST.json'} + + +def gates(word, omit_inverse=False, omit_dirt=False): + result = [] + def append(group): + for _, destination, sources in group: + for source in sources: + assert destination != source + result.append((destination, source)) + if not omit_dirt: + append(word['D']) + append(word['A']) + for index, source in enumerate(word['ret']): + assert source < word['v'] + for target, selected in enumerate(word['scatter']): + if index in selected: + result.append((word['v']+target, source)) + append(word['B'][word['source_basis_gates']:] if omit_inverse else word['B']) + append(word['C']) + return result + + +def restores(word, reverse=False, **options): + size = 2*word['v']+word['R'] + values = [1 << i for i in range(size)] + stream = gates(word, **options) + for destination, source in reversed(stream) if reverse else stream: + values[destination] ^= values[source] + expected = [1 << i for i in range(size)] + for target in range(word['v']): + expected[word['v']+target] ^= 1 << target + return values == expected + + +def prefix(word, reverse): + norms = [1]*(2*word['v']+word['R']) + peak = 1 + stream = gates(word) + for destination, source in reversed(stream) if reverse else stream: + norms[destination] += norms[source] + peak = max(peak, norms[destination]) + return peak + + +def forms(word): + values = [1 << i for i in range(word['v'])] + for frame, destination, sources in word['A'][-word['source_basis_gates']:]: + assert frame == word['final'][0] + assert destination < word['v'] and len(sources) == 1 and sources[0] < word['v'] + values[destination] ^= values[sources[0]] + return [values[index] for index in word['ret']] + + +def coefficient(g, geo): + paid = sum(g['profile'].values()) + routes = 576*(240+g['R'])+61440+2*g['bank_assignments']+2*g['copy_erase_episodes'] + selectors = 144*((g['live']-1)+g['R']*64*(geo['max_route_factors']+63+64)) + value = (72*g['local_additions']+g['bridge_additions'] + + routes*(16*4097**2+g['physical'])+paid*(8*64**2+8+128*128**3) + + 16*64**3+g['copy_erase_episodes']+selectors+int(g['global_prefix_bound'])+1) + return value, (value+1)**2*(paid+1)**2 + + +def verify(): + manifest = read('MANIFEST.json')['files'] + assert snapshot() == manifest + source = read('SOURCES.json') + for entry in source['files']: + assert digest(entry['path']) == entry['original_sha256'], entry['path'] + assert digest('inputs/SUPPLIER-MANIFEST.json') == source['supplier_manifest_sha256'] + binding = read('inputs/SUPPLIER-SOURCE-BINDING.json') + assert binding['head'] == source['commit'] and binding['repository'] == source['repository'] + for local, upstream in [('vendor/bit_construct.py', 'code/bit_construct.py'), + ('inputs/SUPPLIER-MANIFEST.json', 'MANIFEST.json')]: + entry = next(e for e in binding['files'] if e['path'] == upstream) + data = raw(local) + assert hashlib.sha256(data).hexdigest() == entry['sha256'] + assert hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == entry['git_blob'] + original = raw('vendor/bit_construct.py').decode() + derived = original + for before, after in [ + ('sorted(echelon.items())', 'sorted(echelon.items(), reverse=True)'), + ('p = (row & -row).bit_length() - 1', 'p = row.bit_length() - 1'), + ('pivots = sorted(echelon)', 'pivots = sorted(echelon, reverse=True)'), + ]: + assert derived.count(before) == 1 + derived = derived.replace(before, after) + assert hashlib.sha256(derived.encode()).hexdigest() == '61578d8959893e7fec667d5e7697cc6faef773d1e7c50a45e929e69a0038f279' + patch = ''.join(difflib.unified_diff(original.splitlines(True), derived.splitlines(True), + fromfile='a/research/split-centres-global/code/bit_construct.py', + tofile='b/research/split-centres-global/code/bit_construct.py')) + assert raw('basis-order.patch').decode() == patch + completed = read('inputs/candidate/COMPLETION.json') + baseline_completed = read('inputs/baseline/COMPLETION.json') + assert completed['status'] == 'PASS_CHANGED_BIT_FINITE_CHECK' + assert completed['input_before'] == completed['input_after'] + assert completed['source_manifest_sha256'] == source['supplier_manifest_sha256'] + assert baseline_completed['status'] == 'PASS_RETAINED_DEFAULT_PR433_REPLAY' + assert baseline_completed['source_manifest_before'] == baseline_completed['source_manifest_after'] == source['supplier_manifest_sha256'] + for name, original in [('word.json.gz', 'bit426-source-centres/bit-source-centres.json'), + ('GLOBAL.json', 'bit426-source-centres/global/GLOBAL.json'), ('RESULT.json', 'RESULT.json')]: + assert digest('inputs/baseline/'+name) == baseline_completed['output_hashes']['run/'+original] + paths = {'word.json.gz': 'bit426-source-centres/bit-source-centres.json', + 'GLOBAL.json': 'bit426-source-centres/global/GLOBAL.json', + 'GEOMETRY.json.gz': 'bit426-source-centres/global/GEOMETRY.json', + 'AUDIT.json': 'bit426-source-centres/global/AUDIT.json', + 'BIT-PRICE.json': 'BIT-PRICE.json', 'RESULT.json': 'RESULT.json'} + for name, original in paths.items(): + assert digest('inputs/candidate/'+name) == completed['output_hashes'][original] + assert len(completed['steps']) == 5 + for step in completed['steps']: + assert step['returncode'] == 0 + assert digest('inputs/candidate/'+step['name']+'.log') == step['log_sha256'] + for name in ['INTEGRATION.json', 'INDEPENDENT-REPLAY.json']: + assert digest('inputs/complex/'+name) == completed['reused']['split-centres/'+name] + assert digest('inputs/complex/'+name) == baseline_completed['output_hashes']['run/split-centres/'+name] + old, word = read('inputs/baseline/word.json.gz'), read('inputs/candidate/word.json.gz') + assert set(word) == set(old) + assert {k: v for k, v in word.items() if k not in ['A', 'B', 'ret', 'source_basis_gates']} == { + k: v for k, v in old.items() if k not in ['A', 'B', 'ret', 'source_basis_gates']} + a, b = old['source_basis_gates'], word['source_basis_gates'] + assert (a, b) == (559, 575) + assert old['A'][:-a] == word['A'][:-b] and old['B'][a:] == word['B'][b:] + assert word['A'][-b:] == list(reversed(word['B'][:b])) + assert forms(word) == forms(old) + for item in [old, word]: + assert restores(item) and restores(item, reverse=True) + assert not restores(word, omit_inverse=True) and not restores(word, omit_dirt=True) + bg, g = read('inputs/baseline/GLOBAL.json'), read('inputs/candidate/GLOBAL.json') + audit = read('inputs/candidate/AUDIT.json') + assert g['status'] == 'PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE' + assert audit['status'] == 'PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT' + assert (g['m'], g['R'], g['live'], g['physical']) == (64, 758, 14502, 14511) + assert g['all_scalar_columns_restored'] and g['independent_unbanked_scalar_columns'] == 7782 + result, previous = read('inputs/candidate/RESULT.json'), read('inputs/baseline/RESULT.json') + for key in ['profile', 'live', 'physical', 'rank_mass', 'paid_calls', 'bank_assignments', + 'maxchild', 'local_invocations', 'deficit', 'copy_erase_episodes', 'bridge_additions']: + assert g[key] == bg[key], key + assert g['profile'] == audit['profile'] and len(audit['mutations_rejected']) == 8 + assert g['template_sha256'] == audit['template_sha256'] == result['bit_template_sha256'] + assert g['geometry_sha256'] == digest('inputs/candidate/GEOMETRY.json.gz') + for key in ['bit_lower', 'complex_lower', 'kappa', 'strict_outer_constraints', + 'bootstrap', 'outer_controls', 'complex_template_sha256']: + assert result[key] == previous[key], key + for w, receipt in [(old, bg), (word, g)]: + assert len(gates(w)) == receipt['local_additions'] + factors = [prefix(w, reverse) for reverse in [False, True]] + assert factors == [receipt['local_checks'][key]['cancellation_free_row_l1'] for key in ['forward', 'reverse']] + assert int(receipt['global_prefix_bound']) == 2**18*factors[0]**5*factors[1]**4 + geo = read('inputs/candidate/GEOMETRY.json.gz') + value, two = coefficient(g, geo) + old_value, old_two = coefficient(bg, geo) + assert old_value == int(read('inputs/baseline/ASSEMBLY-LOCALS.json')['coefficient']) + assert value < old_value and two < old_two + assert (old_value.bit_length(), value.bit_length(), old_two.bit_length(), two.bit_length()) == (223, 192, 483, 420) + assert g['local_additions']-bg['local_additions'] == 32 + assert g['word_sha256'] == digest('inputs/candidate/word.json.gz') + report = dict(status='PASS_BASIS_ORDER_FINITE_OVERCHARGE', + candidate_sha256=g['word_sha256'], coefficient=str(value), two_level_coefficient=str(two), + kappa=result['kappa'], local_add_delta=32, coefficient_bits=[223, 192], + two_level_bits=[483, 420], scope='Pinned PR433 finite-cost comparison; coarse caps and exponent unchanged.') + for key, value in read('EXPECTED.json').items(): + assert report[key] == value + from verify_port import verify_port + report['post_kernel_transfer'] = verify_port() + assert snapshot() == manifest + return report + + +if __name__ == '__main__': + print(json.dumps(verify(), indent=2)) diff --git a/research/e8-bit-basis-order/verify_port.py b/research/e8-bit-basis-order/verify_port.py new file mode 100644 index 0000000000..bf46e0ab63 --- /dev/null +++ b/research/e8-bit-basis-order/verify_port.py @@ -0,0 +1,126 @@ +"""Audit the separate basis stage on the pinned PR438 reset/kernel word.""" +from fractions import Fraction +import copy +import hashlib +import json +from postprocess import reorder_basis +from verify import ROOT, raw, read, digest, forms, restores, gates, prefix, coefficient + +P = 'port438/' + +def verify_port(): + binding = read(P+'SOURCE-BINDING.json') + assert binding['commit'] == 'e3b56de7869f6af88d48ac0ab1d7959c4c9e6176' + supplier = read(P+'supplier/MANIFEST.json')['files'] + assert digest(P+'supplier/MANIFEST.json') == binding['manifest_sha256'] + for name, pin in supplier.items(): + assert binding['files'][name]['sha256'] == pin + for path in (ROOT/P/'supplier').rglob('*'): + if path.is_file(): + name = path.relative_to(ROOT/P/'supplier').as_posix() + data = path.read_bytes() + assert hashlib.sha256(data).hexdigest() == binding['files'][name]['sha256'] + assert hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == binding['files'][name]['git_blob'] + completed = read(P+'COMPLETION.json') + assert completed['status'] == 'PASS_CHANGED_PR438_BIT_FINITE_CHECK' + assert completed['source_before'] == completed['source_after'] == {k:v['sha256'] for k,v in binding['files'].items()} + assert completed['inputs_before'] == completed['inputs_after'] + assert digest(P+'adapter/MANIFEST.json') == completed['adapter_manifest_sha256'] + for name, pin in read(P+'adapter/MANIFEST.json')['files'].items(): + assert digest(P+'adapter/'+name) == pin + assert digest('postprocess.py') == digest(P+'adapter/basis_postprocess.py') + for name, path in read(P+'RECEIPT-MAP.json').items(): + assert digest(P+'inputs/'+name) == completed['output_hashes'][path] + assert [s['name'] for s in completed['steps']] == ['bit_construct','bit_reset','bit_kernel','post_basis','export','global','audit','price','combined'] + for step in completed['steps']: + assert step['returncode'] == 0 + assert digest(P+'logs/'+step['name']+'.log') == step['log_sha256'] == completed['output_hashes'][step['name']+'.log'] + reset = json.loads(raw(P+'logs/bit_reset.log')) + kernel = read(P+'inputs/KERNEL.json') + selection = read(P+'supplier/stages/kernel-selection.json') + stage = read(P+'inputs/BASIS-STAGE.json') + assert reset['R'] == 747 and reset['helpers_removed'] == 11 and len(reset['controls']) == 3 + assert reset['sha256'] == kernel['input_sha256'] == selection['input_sha256'] + assert kernel['output_sha256'] == selection['output_sha256'] == stage['input_sha256'] == digest(P+'inputs/original-word.json.gz') + assert stage['output_sha256'] == digest(P+'inputs/word.json.gz') + assert kernel['entries'] == len(selection['entries']) == 118 + assert kernel['total_entrance_rank'] == 160 and kernel['donor_slots'] == 119 + assert kernel['new_frames'] == 0 and kernel['columns'] == stage['columns'] == 987 + assert kernel['local_histogram'] == stage['profile'] + old, word = read(P+'inputs/original-word.json.gz'), read(P+'inputs/word.json.gz') + assert reorder_basis(old) == word and reorder_basis(word) == word + a, b = old['source_basis_gates'], word['source_basis_gates'] + assert (a, b) == (559,575) + assert set(old) == set(word) + for key in set(word)-{'A','B','ret','source_basis_gates'}: + assert old[key] == word[key], key + assert old['A'][:-a] == word['A'][:-b] and old['B'][a:] == word['B'][b:] + assert word['A'][-b:] == list(reversed(word['B'][:b])) and forms(old) == forms(word) + for item in [old, word]: + assert restores(item) and restores(item, reverse=True) + assert not restores(word, omit_inverse=True) and not restores(word, omit_dirt=True) + g, audit = read(P+'inputs/GLOBAL.json'), read(P+'inputs/AUDIT.json') + result = read(P+'inputs/RESULT.json') + assert g['status'] == 'PASS_SOURCE_BOUND_NINE_STAGE_BIT_TEMPLATE' + assert audit['status'] == 'PASS_INDEPENDENT_COMPRESSED_BIT_TEMPLATE_AUDIT' + assert g['word_sha256'] == stage['output_sha256'] + assert g['template_sha256'] == audit['template_sha256'] == result['bit_template_sha256'] + assert g['geometry_sha256'] == digest(P+'inputs/GEOMETRY.json.gz') + assert (g['m'],g['R'],g['live'],g['physical'],g['banks_per_stage']) == (64,747,14223,14232,727) + assert g['all_scalar_columns_restored'] and g['independent_unbanked_scalar_columns'] == 7683 + assert len(g['omitted_bridge_shears_rejected']) == 18 and len(audit['mutations_rejected']) == 8 + assert g['profile'] == audit['profile'] + assert g['paid_calls'] == sum(g['profile'].values()) == 328536 + assert sum(int(r)*n for r,n in g['profile'].items()) == 64*g['live']-2496 + before = [prefix(old, r) for r in [False,True]] + after = [prefix(word, r) for r in [False,True]] + assert before == [4749873,18976454] and after == [352915,1686810] + for reverse, factor in zip(['forward','reverse'],after): + local=g['local_checks'][reverse] + assert local['cancellation_free_row_l1'] == factor and local['all_columns'] == 987 + assert local['profile'] == stage['profile'] and local['adds'] == g['local_additions'] + assert int(g['global_prefix_bound']) == 2**18*after[0]**5*after[1]**4 + assert len(gates(word)) == g['local_additions'] == 14757 + assert len(gates(old)) == 14725 + geo = read(P+'inputs/GEOMETRY.json.gz') + value,two = coefficient(g,geo) + # Same geometry and schedule; recompute the baseline's two changed terms. + # This algebraic counterfactual is not a second baseline global replay. + baseline = copy.deepcopy(g) + baseline['local_additions'] = len(gates(old)) + baseline['global_prefix_bound'] = str(2**18*before[0]**5*before[1]**4) + old_value,old_two = coefficient(baseline,geo) + nomination=read(P+'inputs/FINITE-COMPARISON.json') + assert value == int(nomination['candidate_coefficient']) < old_value == int(nomination['source_projected_coefficient']) + assert (old_value.bit_length(),value.bit_length(),old_two.bit_length(),two.bit_length()) == (226,193,488,423) + assert two < 2**512 and value < 2**256 + expected = read(P+'supplier/EXPECTED.json') + for key in set(expected)-{'bit_invoice','bit_template_sha256'}: + assert result[key] == expected[key],key + assert result['kappa'] == '45340333148791/40000000000000000' + assert len(result['strict_outer_constraints']) == 47 and all(Fraction(x)>0 for x in result['strict_outer_constraints'].values()) + assert len(result['outer_controls']) == 4 + assert result['bit_invoice']['coefficient_bits'] == value.bit_length() + assert result['bit_invoice']['two_level_coefficient_bits'] == two.bit_length() + reuse = read(P+'COMPLEX-REUSE-BINDING.json') + old_completed = read('inputs/baseline/COMPLETION.json') + old_supplier = read('inputs/SUPPLIER-MANIFEST.json')['files'] + assert reuse['completion_sha256'] == digest('inputs/baseline/COMPLETION.json') == completed['inputs_before']['completion'] + assert digest(P+'COMPLEX-REUSE-BINDING.json') == completed['inputs_before']['reuse_binding'] + for name,pin in reuse['verified_outputs'].items(): + assert pin == old_completed['output_hashes'][name] == completed['inputs_before'][name] + assert pin == completed['output_hashes'][name.removeprefix('run/')] + assert set(reuse['changed_files']) == {'code/complex_phases.py','inputs/complex-phase-receipt.json'} + for name, entry in reuse['scientific_source_comparison'].items(): + assert supplier[name] == entry['sha256'] + assert entry['identical_433'] == (old_supplier[name] == supplier[name]) + phase=read(P+'supplier/inputs/complex-phase-receipt.json') + assert phase['canonical_word_sha256'] == reuse['verified_outputs']['run/split-centres/CANONICAL-WORD.json.gz'] + assert phase['recipe_sha256'] == reuse['verified_outputs']['run/split-centres/CLIFFORD-RECIPES.json'] + for name in ['INTEGRATION.json','INDEPENDENT-REPLAY.json']: + assert digest('inputs/complex/'+name) == reuse['verified_outputs']['run/split-centres/'+name] + assert read('inputs/complex/INTEGRATION.json')['global_template_sha256'] == result['complex_template_sha256'] + return dict(status='PASS_POST_KERNEL_BASIS_TRANSFER',candidate_sha256=stage['output_sha256'], + coefficient=str(value),two_level_coefficient=str(two),coefficient_bits=[226,193], + two_level_bits=[488,423],local_add_delta=32,kappa=result['kappa'], + scope='Pinned PR438 finite accounting; baseline reconstructed algebraically; completed PR433 complex evidence reused.') diff --git a/research/e8-dirty-chart-audit/.gitattributes b/research/e8-dirty-chart-audit/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/e8-dirty-chart-audit/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/e8-dirty-chart-audit/LICENSE b/research/e8-dirty-chart-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-dirty-chart-audit/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/e8-dirty-chart-audit/MANIFEST.json b/research/e8-dirty-chart-audit/MANIFEST.json new file mode 100644 index 0000000000..6a381e9fbb --- /dev/null +++ b/research/e8-dirty-chart-audit/MANIFEST.json @@ -0,0 +1,24 @@ +{ + "files": { + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "f35d8b3e74c1ddb4d4c34d0f8ea934cf41008c9b01aa27e5dc531687172eeb12", + "PROOF.md": "4f3f59081cbbabc66d9b844c2a42605e18f15e576fc51a3e4afb92aac43833e8", + "README.md": "2f8b60922d2c0a60155233f33368397f082b58f40ab255b93af35743f60107fd", + "SOURCES.json": "f3b3c45ff2986989fa967b4fb5243d6e847c9993f2514bfb6295da281626da89", + "VALIDATION.md": "5158c7e5e290d3940ab9c47af8d95763fb015732a4e287848880d3fe0fdca61d", + "chart_audit.py": "ee8c6925736e7d9f6b69f02249cd605f2ac5896d1db2d4a561680929370660aa", + "inputs/admitted416-candidate.json.gz": "0c72ea052a4fae96090c1a6cbbcbd6f8ba4c1dfc09c2f832c390ca1b27686a56", + "inputs/admitted416-programs.json.gz": "0414963ae820bf8786fa487c34c23df6a0d08dc4fa22df42a099b1c43ac19095", + "inputs/changed419-candidate.json.gz": "60bf3824b9eda70516b5e76953a70c9c3646d11f0ddfbd4147adfcadbb4931ed", + "inputs/discovery.json": "bf3528d9243eaa7c6718811c4451214a96476a445b9a056179eb90223330e8bd", + "inputs/independent-review.json": "fabbe4626dfc9d8bfa60dd93bec1dc4d8cb40bcbf676c16af533fa013eb07a6e", + "inputs/original419-candidate.json.gz": "ed29208a34f756f4e959ca7573dc6bec4db724e52a9eb623468c38489d719420", + "test_chart_audit.py": "43cc70afca4caae60db8c0a57f2670f8a87efbe5a920cb4729d81ca1732a9164", + "vendor/NOTICE-PR416.md": "e350ff774b71b9100fd9494c6196248da5efb93359efdc9bf05731e893ab9957", + "vendor/NOTICE-PR419.md": "ee738efb80f613f38dbdbd4b02fe91b115e0f24f0fffa82c7a31d1625304e7fc", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/emit419.py": "b06ae2fb90b668f27e73adfee523120f68c746a702c76443e3b9406ccc2f0933", + "verify.py": "49016b026a9c098f0a6a7772f0f87927132e71dd4116e631ac2ec0ab549a58e8" + } +} diff --git a/research/e8-dirty-chart-audit/NOTICE.md b/research/e8-dirty-chart-audit/NOTICE.md new file mode 100644 index 0000000000..1357ffd814 --- /dev/null +++ b/research/e8-dirty-chart-audit/NOTICE.md @@ -0,0 +1,22 @@ +# Attribution and scope + +Prepared for George Lydakis with substantial OpenAI Codex assistance. +Licensed under Apache-2.0; the complete license is retained in LICENSE. + +The chart-sensitive diagnostic and exact counterexamples were developed while +reviewing the composition of entrance 956 with PR419. The normalized independent +entrance-token criterion follows the local-admission method retained in PR416 +and its Dugongue/Jacob Sussman and other credited lineage. + +`vendor/emit419.py` is byte-identical to Chafik Boukhalfa's PR419 emitter, prepared +with Anthropic Claude assistance. `vendor/clifford_exact.py` is byte-identical to +the exact Gaussian Clifford compiler bundled in eumemic's PR416. Their original +notices are retained as `vendor/NOTICE-PR419.md` and `vendor/NOTICE-PR416.md`. +Exact repositories, immutable revisions and file hashes appear in SOURCES.json. + +The original PR419 fixture was generated by its pinned constructor. The changed +fixture adds only our previously documented entrance-956 enlargement. The +positive fixture is our source-bound PR416+956 construction and emitted word. +Original source filenames and hashes are retained even when they refer to +development paths; the verifier does not read those paths or require network +access. The fixture compression and provenance are explicit in SOURCES.json. diff --git a/research/e8-dirty-chart-audit/PROOF.md b/research/e8-dirty-chart-audit/PROOF.md new file mode 100644 index 0000000000..267dc544cc --- /dev/null +++ b/research/e8-dirty-chart-audit/PROOF.md @@ -0,0 +1,78 @@ +# Required dirty endpoint and the missed conjugation + +Let `u` be the vector of independent dirty helper inputs in their old charts. +Let `H` be the scalar helper-to-helper map of the main word. The prewhitening +bracket uses `P = H^-1` before entrance normalization. Let + +``` +D = diag(T_E^-1) +``` + +where an ungauged helper has the identity entry. Scalars commute with address +operators, but mixing helpers does not generally commute with their distinct +normalizations. + +The original [PR390 proof](https://github.com/Dugongue/integer-mult-bounds/blob/0e790f2dfb64e17bdee154aee151bb0c1dddb28e/research/e8-prefix-restoration/PROOF.md) +performs the preconditioning at a common initial frame. Its pinned prefix word +has no entrance gauges and every helper starts at frame zero. That argument +does not establish commutation with later, distinct nontrivial entrance charts. +PR419's README inherits two-sided residual normalization and bank routes while +explicitly reopening phase and invoice work; its supplied proof does not give +a replacement coupled-bank invariant for this interaction. + +Ordinary scalar replay sets all entries of `D` to identity and checks `HP = I`. +The normalized dirty endpoint of this bracket is instead `HDP`. The proposed +independent-helper residual assembly requires `D`. Therefore that assembly needs + +``` +H D H^-1 = D, equivalently D H^-1 = H^-1 D. +``` + +Zero clean-input content in a sink is not this condition. It does not establish +that the sink's dirty helper row is its own identity row, or that inverse helper +cleanup may be omitted there. + +The checker first executes the supplied old response on independent scalar +columns. At `ad0`, it left-multiplies each gauged helper row by its `T_E^-1` tag. +It then executes the actual main and cleanup scalar events and compares against +the required normalized helper endpoints and prescribed target update. Clears, +copies, and private erasure are included. The existing phase/lifetime/geometry +checks are separate requirements; passing this endpoint check alone does not +establish them. + +The replay uses formal tags as a sufficient identity test. A failed formal test +does not by itself imply an operator mismatch, because frame operators can be +linearly dependent. For a counterexample, the tool substitutes the pinned exact +Gaussian matrices and evaluates address basis vectors in order. A single nonzero +entry proves a mismatch. If all `2^h` columns of every coefficient operator +vanish, linearity proves that the emitted endpoint agrees on every input vector. +Repeated coefficient operators are checked once. This resolves formal +cancellations without assuming that distinct tags are independent. + +For example, on three address axes the exact operator + +``` +T_[1,4]^-1 - T_[1,6]^-1 - T_[2,4]^-1 + T_[2,5]^-1 +``` + +annihilates the basis vector at address zero. On address one it instead gives +`i*|4> - |6>`. Thus a zero result on the first address alone cannot certify +operator equality. The focused regression uses these actual canonical frames. + +For both supplied PR419 words, the forward off-diagonal coefficient from dirty +helper 255 to helper 244 is `(I - T_[48]^-1)/4`. On the basis vector at address +zero, its component at address zero is `(1+i)/8`, which is nonzero. The backward +word has coefficient `(T_[3]^-1 - I)/2` from helper 420 to helper 246, with +component `-(1+i)/4` at address zero. These coefficients must be zero under the +required independent-helper endpoint contract. + +Independent invertible input and output chart changes cannot remove a nonzero +off-diagonal coefficient: `L_i A_ij R_j = 0` implies `A_ij = 0`. This explains why +checking additional per-helper boundary adapters does not repair the discovered +gap. It does not exclude a different construction with explicit coupling between +helpers or banks and a separately proved route, phase, padding and cost model. + +The retained admitted PR416+956 event stream passes the same chart-sensitive +replay in both orientations. Both failing fixtures pass the same replay with all +entrance operators collapsed to identity. These controls distinguish the missed +chart interaction from an ordinary scalar failure or an event-format mismatch. diff --git a/research/e8-dirty-chart-audit/README.md b/research/e8-dirty-chart-audit/README.md new file mode 100644 index 0000000000..57948575d7 --- /dev/null +++ b/research/e8-dirty-chart-audit/README.md @@ -0,0 +1,54 @@ +# Check independent dirty endpoints before pricing a supplier + +This verifier keeps each entrance normalization `T_E^-1` distinct when replaying +the actual old response, main word and cleanup. It detects cross-helper dirty +responses that an ordinary scalar identity check can miss. It is an additional +finite interface check, not a full supplier or all-size theorem verifier. + +The included regressions establish: + +- An admitted PR416 plus entrance-956 word passes both orientations. +- The supplied original PR419 word and our entrance-956 extension pass ordinary + scalar replay, but fail the independent-helper endpoint after normalization. +- The failures are instantiated with exact Gaussian operators. In the forward + direction, dirty helper 255 contributes `(I - T_[48]^-1)/4` to helper 244. + A basis input at address zero gives an unexpected `(1+i)/8` at address zero. +- The issue is already present before our entrance upgrade. No improved numerical + bound is claimed by this package. + +This concerns the proposed assembly into independently normalized residual banks. +A different coupled-bank construction would need its own endpoint, routing and +cost proof. The result does not disprove such a construction or an unconditional +multiplication theorem. See [PROOF.md](PROOF.md). + +Run the source closure and regression suite, using Python 3.11 or later: + +```sh +python -B research/e8-dirty-chart-audit/verify.py +``` + +Audit an emitted program with the same scalar/event schema: + +```sh +python -B research/e8-dirty-chart-audit/chart_audit.py candidate.json \ + --programs LOCAL-PROGRAMS.json.gz --output new-result.json +``` + +For the bundled PR419 bracket, use `--emitter419` in place of `--programs`. +Successful formal or exact Gaussian endpoint checks exit zero. An actual +mismatch exits one. Different formal tags alone are not treated as a Gaussian +counterexample: the verifier evaluates all address columns of every distinct +coefficient operator, stopping at the first exact nonzero entry. If every column +vanishes, it reports `PASS_EXACT_GAUSSIAN_ENDPOINT`. It caches operators and the +current address column, without retaining whole dense matrices. + +The regression suite also includes a three-axis operator combination that is +zero on address zero but nonzero on address one. Testing only the first address +would miss this mismatch. Another test resolves different tags that represent +the same exact operator. These checks concern the emitted endpoint only. + +The fixtures are finite words from pinned research runs. PR419 event streams are +regenerated with its byte-identical emitter. The admitted control uses a retained +emitted-program fixture. This package does not rerun the upstream word searches, +phase verification, banks or pricing. [SOURCES.json](SOURCES.json) records exact +provenance; [VALIDATION.md](VALIDATION.md) records what was executed. diff --git a/research/e8-dirty-chart-audit/SOURCES.json b/research/e8-dirty-chart-audit/SOURCES.json new file mode 100644 index 0000000000..d7dc795996 --- /dev/null +++ b/research/e8-dirty-chart-audit/SOURCES.json @@ -0,0 +1,44 @@ +{ + "fixtures": { + "admitted416-candidate.json.gz": { + "source_path": "/tmp/task2-pr416-956-literal-v2-fresh/candidate.json", + "source_sha256": "9504f801c3e9aaabb54a65c7eb94babc4aedfeeb68ebeac73f29610d16887fd9", + "fixture_sha256": "0c72ea052a4fae96090c1a6cbbcbd6f8ba4c1dfc09c2f832c390ca1b27686a56", + "compression": "deterministic gzip, mtime=0" + }, + "original419-candidate.json.gz": { + "source_path": "/tmp/task2-pr419-956-screen-fresh/gcert1-e8promoted.json.gz", + "source_sha256": "ed29208a34f756f4e959ca7573dc6bec4db724e52a9eb623468c38489d719420", + "fixture_sha256": "ed29208a34f756f4e959ca7573dc6bec4db724e52a9eb623468c38489d719420", + "compression": "source gzip bytes retained" + }, + "changed419-candidate.json.gz": { + "source_path": "/tmp/task2-pr419-956-screen-fresh/candidate.json", + "source_sha256": "409308eaaeaa8b0fed1832794f81bac73fb99305335a2b6aff5147c3d701b7b8", + "fixture_sha256": "60bf3824b9eda70516b5e76953a70c9c3646d11f0ddfbd4147adfcadbb4931ed", + "compression": "deterministic gzip, mtime=0" + }, + "admitted416-programs.json.gz": { + "source_path": "/tmp/task2-pr416-956-chain-fresh/local/LOCAL-PROGRAMS.json.gz", + "source_sha256": "0414963ae820bf8786fa487c34c23df6a0d08dc4fa22df42a099b1c43ac19095", + "fixture_sha256": "0414963ae820bf8786fa487c34c23df6a0d08dc4fa22df42a099b1c43ac19095", + "compression": "source gzip bytes retained" + } + }, + "vendor": { + "emit419.py": { + "repo": "chafreaky/integer-mult-bounds", + "head": "70a276cb948e5be6071cde3f1bebdaf2f995ab8e", + "path": "research/e8-promoted-closure/code/emit.py", + "git_blob": "a02dde1ae9386a6b2fffb5a6c7e9ed1bfae08341", + "sha256": "b06ae2fb90b668f27e73adfee523120f68c746a702c76443e3b9406ccc2f0933" + }, + "clifford_exact.py": { + "repo": "eumemic/integer-mult-bounds", + "head": "c76d101df11ad4152c52fd9d68344c064e453d3a", + "path": "research/e8-frameclosure214-target-prefixes/local/deps/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + } + }, + "scope": "Finite word/event fixtures from source-pinned research runs. This package regenerates PR419 event streams and audits endpoints; it does not reconstruct upstream words or repeat the entire supplier verification." +} diff --git a/research/e8-dirty-chart-audit/VALIDATION.md b/research/e8-dirty-chart-audit/VALIDATION.md new file mode 100644 index 0000000000..a159c44638 --- /dev/null +++ b/research/e8-dirty-chart-audit/VALIDATION.md @@ -0,0 +1,31 @@ +# Validation + +The original diagnostic was run on 2026-10-11 under Python 3.14. It checked the +admitted PR416+956 control and both the original and extended PR419 fixtures. +The control passed in both orientations. Both PR419 fixtures passed ordinary +scalar replay and produced the exact chart-sensitive witnesses in PROOF.md. +Ody independently repeated this regression and obtained the same results; the +source-bound discovery and independent-review receipts are retained in inputs/. + +The portable package checks its complete manifest, exact vendored source hashes, +fixture bytes, and six focused tests: admitted endpoints, the original/extended +counterexamples, required normalization chronology, and a formal-token mismatch +that correctly does not establish an actual Gaussian counterexample, a mismatch +first appearing at address one, and an end-to-end exact cancellation that +resolves a failed formal-tag comparison. + +The checker has standard-library-only dependencies. No compiler, installation, +network request, numerical optimizer, full phase replay or full supplier replay +is required. Its negative fixtures are intentional expected results. Passing the +regression suite means the checker detects the contract gap; it does not mean +those candidate suppliers are admitted. The witness search now examines every +address column when necessary. The new address-one regression was run against the previously published checker and +failed because it returned no witness, then passed after the change. All six +focused tests pass under Python 3.14. Exact cancellation is admitted only after +all address columns vanish; the original concrete witnesses remain unchanged. + +The broader changed-419 component run separately passed both scalar orientations, +14 source mutation controls, coefficient expansion, 6,480 exact Gaussian phase +operators, and 43 residual charts. A later entrance-chart check found the endpoint +obstruction before global execution. Those successful component checks are not +represented as complete supplier admission, and no new κ is claimed. diff --git a/research/e8-dirty-chart-audit/chart_audit.py b/research/e8-dirty-chart-audit/chart_audit.py new file mode 100644 index 0000000000..1d0b3f5956 --- /dev/null +++ b/research/e8-dirty-chart-audit/chart_audit.py @@ -0,0 +1,156 @@ +"""Audit normalized dirty endpoints without collapsing distinct entrance charts. + +Ordinary scalar identity and a correct paid histogram do not imply independent +helper endpoints. See PROOF.md for the precise interface and limitations. +""" +from pathlib import Path +from fractions import Fraction as Q +import argparse, gzip, hashlib, json, sys + +if not __debug__: + raise RuntimeError('Assertions are required') +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent +sys.path.insert(0, str(ROOT/'vendor')) +import clifford_exact as X +import emit419 as EM + + +def read(path): + raw = Path(path).read_bytes() + return json.loads(gzip.decompress(raw) if raw[:2] == b'\x1f\x8b' else raw) + + +def programs419(candidate): + assert candidate['v'] == 120 and candidate['h'] == 9 + EM.setR(candidate['R']) + whitening = EM.prewhite(candidate, {301,387}) + return {ori:list(EM.emit(candidate, ori, {}, {301,387}, whitening)) + for ori in ('forward','backward')} + +def replay(c, events, orientation, charts): + n = 2*c['v']+c['R'] + ext = dict(c['ext']) + reg = {('L', i): {(i, -1): Q(1)} for i in range(n)} + phases = [] + for e in events: + if e[0] == 'phase': phases.append(e[1]) + if list(e) == ['phase', 'ad0'] and charts: + for i, f in ext.items(): + assert all(tag == -1 for j, tag in reg['L', i]) + reg['L', i] = {(j, f): a for (j, tag), a in reg['L', i].items()} + if e[0] != 'scalar': continue + op = e[2] + target = tuple(op[1]) + if op[0] == 'clear': reg[target] = {}; continue + source = tuple(op[2]) + if op[0] == 'copy': reg[target] = dict(reg.get(source, {})); continue + assert op[0] == 'add' + q = Q(op[3], op[4]) if len(op) == 5 else Q(op[3]) + dest = reg.setdefault(target, {}) + for k, value in dict(reg.get(source, {})).items(): + a = dest.get(k, Q(0))+q*value + if a: dest[k] = a + else: dest.pop(k, None) + assert phases == ['old_response','ad0','A','centers','B','final','adF','cleanup','done'], 'Unexpected phase order' + expected = {('L', i): {(i, ext[i] if charts and i in ext else -1): Q(1)} for i in range(n)} + for t in range(c['v']): + if orientation == 'forward': expected['L', c['v']+t][t, -1] = Q(1) + else: expected['L', t][c['v']+t, -1] = Q(-1) + delta = {} + for i in range(n): + row = dict(reg['L', i]) + for k, value in expected['L', i].items(): row[k] = row.get(k, Q(0))-value + row = {k:a for k,a in row.items() if a} + if row: delta[i] = row + assert all(not row for key, row in reg.items() if key[0] != 'L') + return delta + + +def gaussian_witness(c, delta): + # Formal frame tags may be linearly dependent. Check every address column + # of each distinct coefficient operator before concluding it is zero. + blocks = {} + for output, row in sorted(delta.items()): + for source in sorted({j for j, frame in row}, key=lambda j: (j == output, j)): + terms = tuple(sorted((frame,a) for (j,frame),a in row.items() + if j == source and a)) + if terms: blocks.setdefault(terms, (output, source)) + operators = {} + for address in range(1< but not |1>. + candidate = {'h':3, 'frames':[[1,4], [1,6], [2,4], [2,5]]} + delta = {0:{(1,0):Q(1), (1,1):Q(-1), + (1,2):Q(-1), (1,3):Q(1)}} + witness = gaussian_witness(candidate, delta) + self.assertIsNotNone(witness) + self.assertEqual(witness['input_address'], 1) + self.assertEqual(witness['nonzero_output_coordinates'], 2) + self.assertEqual(witness['first_nonzero'], + dict(address=4, real='0', imaginary='1')) + + def test_exact_operator_cancellation_resolves_formal_mismatch(self): + candidate = {'v':1, 'R':2, 'h':1, 'frames':[[1], [1]], + 'ext':[[2,0], [3,1]]} + programs = {} + for orientation in ('forward', 'backward'): + update = (['L',1], ['L',0], 1) if orientation == 'forward' else ( + ['L',0], ['L',1], -1) + programs[orientation] = [ + ['phase','old_response'], + ['scalar',0,['add',['L',3],['L',2],1,1]], + ['phase','ad0'], ['phase','A'], + ['scalar',0,['add',['L',3],['L',2],-1,1]], + ['scalar',0,['add',update[0],update[1],update[2],1]], + *[['phase',p] for p in ('centers','B','final','adF','cleanup','done')]] + result = audit(candidate, programs) + self.assertEqual(result['status'], 'PASS_REQUIRED_ENDPOINT') + for r in result['orientations'].values(): + self.assertEqual(r['status'], 'PASS_EXACT_GAUSSIAN_ENDPOINT') + self.assertEqual(r['chart_sensitive_bad_registers'], 1) + self.assertEqual(r['exact_address_columns_examined'], 2) + self.assertIsNone(r['exact_witness']) + + def test_formal_tokens_alone_do_not_establish_a_counterexample(self): + # Frame zero and I are different formal tags but the same operator. + self.assertIsNone(gaussian_witness({'h':1, 'frames':[[]]}, + {0:{(1,-1):Q(1), (1,0):Q(-1)}})) + + +if __name__ == '__main__': + unittest.main() diff --git a/research/e8-dirty-chart-audit/vendor/NOTICE-PR416.md b/research/e8-dirty-chart-audit/vendor/NOTICE-PR416.md new file mode 100644 index 0000000000..3524183808 --- /dev/null +++ b/research/e8-dirty-chart-audit/vendor/NOTICE-PR416.md @@ -0,0 +1,52 @@ +# Direct sources and attribution + +All numbered PRs are in https://github.com/CrocSwap/integer-mult-bounds. Original upstream source and license notices are retained; no submitter identity or credentials are added. + +- **PR401**, head7844f72c6051a4408284c3092490687061675c1a: exact119-gauge response-subspace baseline, two-sided phase-correct residual normalization, mixed-bank admission, source-bound receipts and portable architecture. This package's main new step removes whole-group disjointness while charging nested shared-donor walks. The chronological target-chain step also extends its signed-prefix input. +- **PR376**, downloaded head7aa9d9f0247bb60c0519704bbca18990011e2a37: the rank8→rank7 frame edit at target201 += helper491/2 is directly incorporated and credited. We use that concrete edit, not its different complete prewhitening/fusion stack. Earlier R781 helper substitutions in the exact PR398 lineage remain the input ancestry. +- **PR398** supplies the original signed781 input with25 target-prefix recoveries; **PR390** supplies positive-prefix recovery; **PR396** supplies entrance response kernels and the odd rank-one complement route generalized by PR401. +- **PR378** and **PR365/374** supply far-retimed frame ancestry; **PR377** supplies nine-stage complex geometry, exact Clifford representatives, owner maps and finite invoice conventions. +- **PR381** and earlier **PR376** supply the unchanged bit supplier and helper-lifetime composition. +- **PR387,PR392,PR185** supply six-level ordinary bootstrap and slack refinement; **PR384** carries the exact outer engine, with **PR315/144/23** ancestry retained in source headers. +- **PR400**, headb73a8b4f3d8b32676e7527005911a11a60a1c4fd, and **PR394/395/399** were read for prewhitening, heterogeneous banks and padding fusion. That cleanup route was screened for compatibility but contributes no extra priced saving here. No separately reported gains are added. +- **PR186** shares the refreshed fork head withPR401; its historical shared-edge claim is not a new improvement or an extra contribution here. + +Additional inherited supplier/compiler lineage includes PR352,PR363,PR373,PR370,PR375,PR266 andPR234. Detailed previous attribution is preserved in inherited/PR401-NOTICE.md and the other original notices. + +Structural retrieval in the canonical shared DAG found familiar transvection-composition and nilpotent-inverse identities. These support the algebraic representation change; indexed hits are not fresh Lean certificates. We do not claim to invent transvection algebra, establish literature-wide novelty, or prove global optimality. + +## PR402 resynthesis integration + +Chafik Boukhalfa (chafreaky), assisted by Anthropic Claude, supplied the two-target resynthesis in PR402 at7883c63ec724999b921c2304b66648cbb9e7a112. The integration onto Dugongue's PR404, exact chronological cut relocation, verification and packaging were prepared with substantial OpenAI Codex assistance. All original notices remain in force. + +## Further shared-donor selection and bank integration + +The 205-pivot selection extends Dugongue's PR404 at 12f488264cdd74a3b60d0fb534f4955792384f5c, retaining its exact sufficient construction and credited lineage. The new selection, 64-replica finite bank schedule, exact owner decoder, PR402 relocation and complete changed-composition audits were prepared with substantial OpenAI Codex assistance. All original licenses and AI disclosures are preserved. + +## Concurrent PR406 + +During preparation, PR406 at 5d0d8dff39db99f922ead6d11963aa643511e3ee independently reported the 194-pivot PR404 plus PR402 composition at κ = 0.001016469657190768. This package credits that concurrent result. Its new improvement is the explicit 205-pivot selection and 64-replica packing; the earlier composition is background, not a new claim here. No PR406 implementation bytes were imported. + +## Enlarged206 successor to PR408 + +The new exact selection enlarges eight entrance spaces and promotes donor760 through a literal acyclic sequence. It extends the frozen PR408 at26332a3 without modifying that published head or claim. Earlier PR404 shared donors, PR376 frame retiming, PR402 resynthesis and all prior licenses/notices remain credited. This integration and every new search, constructor and finite audit were prepared with substantial OpenAI Codex assistance. + +## Concurrent ordered-entrance result + +PR409, “Conditional kappa0.001017250500928266: ordered sequential entrance gauges,” by rohanarun at212e03d7665d08fc6a037d3e33612cb7fc60874d, independently reports ordered sequential entrance gauges. Its stated construction promotes194 to204 pivots with51 prepended shears, nonzero N² and N³=0, and a chronological read-before-write omission condition. Our enlarged206 witness was discovered independently before reviewing that PR body. We credit the concurrent mechanism and claim no exclusive priority for ordered entrance gauges. No PR409 implementation bytes were imported. + +Legacy-gx admission concerns, including the disjoint E4 restriction raised around PR407, are not answered by claiming the old checker is unchanged. This package supplies its explicit new finite chronological sufficient condition, full native symbolic dirty-word execution and generalized omission proof. Inherited all-size interfaces and lack of a Lean certificate remain stated limitations. + +## Donor-prefix successor + +The target124/144 prefix construction, complete recomputation of nongauged dirty response, explicit quarter/eighth primitive lowerer and finite integration were prepared with substantial OpenAI Codex assistance. The prefix search adapts Chafik Boukhalfa's PR402 target-window resynthesis to the later shared-donor/acyclic word. Full original PR402,PR404,PR408 and concurrent PR409 credit and disclosures remain intact. New claims apply only to this separately constructed and replayed combination. + +## Grouped210 successor + +The new four-pivot [48] grouped entrance construction and exact residual-bank pricing extend the frozen enlarged206 and target-prefix predecessors. The ordered sequential search is inspired by Rohan Arun's concurrent PR409 (212e03d7665d08fc6a037d3e33612cb7fc60874d); no exclusive priority is claimed. The earlier206 construction and bank-dual pricing were independently obtained. All original PR402, PR404, PR408, PR410, PR411 credits, licenses and disclosures are retained. Grouped selection, portable constructors, new combined admission, phase/bank/finite-invoice verification and integration were prepared with substantial OpenAI Codex assistance. The preliminary local-only search is retained for provenance and explicitly superseded by complete bank-corrected pricing. + +## Frame-closure214 successor + +The new chronological frame-span propagation permits four further pivots beyond the frozen grouped210 word. Original-A scalar instructions remain fixed while five required address frames change. Every new constructor, adverse control, prefix relocation, bank packing and full finite integration was prepared with substantial OpenAI Codex assistance. The shared-donor and ordered sequential entrance mechanisms retain original PR404 and concurrent PR409 provenance; PR376 and Chafik Boukhalfa's PR402 resynthesis remain credited. Source notices and licensing are preserved throughout. New claims apply only to this separately reconstructed combination. + +The complete prefix predecessor was published as PR414 at 7132ca3ebee286fbb01ff5a2f61a6fc32d36ecd4. This separate frameclosure214 successor preserves that PR head and claim. diff --git a/research/e8-dirty-chart-audit/vendor/NOTICE-PR419.md b/research/e8-dirty-chart-audit/vendor/NOTICE-PR419.md new file mode 100644 index 0000000000..96bcda6ef4 --- /dev/null +++ b/research/e8-dirty-chart-audit/vendor/NOTICE-PR419.md @@ -0,0 +1,30 @@ +# Notice + +Apache-2.0 (`LICENSE`). Prepared by Chafik Boukhalfa (chafreaky) with substantial Anthropic Claude assistance. + +- `data/pr390/prefix18.json.gz`, `sink-audit.json`, `prewhite.json` are Dugongue's PR #390 (`research/e8-prefix-restoration/data/`, head 0e790f2), byte-identical (git blobs 51f3ea73, ef2b6f9e, 527a2ea4), Apache-2.0 (`data/pr390/LICENSE-pr390`). + - `prewhite.json` is used only as a regression target. + - #390's scripts (`complex-hetero-compose.py`, `root-global.py`, `root-heterobanks.cpp`) were read as data. Their bracket rule and bank assignment are re-implemented in `code/emit.py` and `code/clean.py`. None of #390's scripts were run. +- `data/pr398/signed25.json.gz` and `VALIDATION.json` are Dugongue's PR #398 (`research/e8-signed-prefix/data/`, head c3251c8), byte-identical (git blobs 23a6396d, 3b1a9bb6), Apache-2.0 (`data/pr398/LICENSE-pr398`). `VALIDATION.json` is used only as the control target. #398's scripts (`reconstruct.py`, `complex-compose.py`, `global-template.py`, `outer.py`) were read as data; its bank rule and profile formula are re-implemented in `code/clean.py`. None of its scripts were run. The R781 word carries #376's (applecrusher) helper substitutions. +- `code/bootstrap.py` re-implements #392's (rohanarun) pricing tail, which #398 also uses. +- `complex/gx/gx.py`, `gxcore.py` are by Jacob Sussman (wht-power-saving-lean `9c94857`, Apache-2.0); upstream LICENSE/NOTICE are kept in `complex/`. +- `data/gcert1-e8-r783-far.json.gz` is our #378 word, and `data/bit/bitE8-kernel.json.gz` is our #382 bit word (derived from utcorvusvolat-dotcom's #370). Both are byte-identical. +- `code/engines/*` are PR #315's engines (DreamingOfClouds; eumemic; the #144/#23 lineage), as in our earlier packages. +- `code/e8core.py`, `cxkernel.py`, `cxretime.py`, `cxcheck.py`, `cxop.py` and `layout_bk.py` (DaysSky's B_K rule, #363) are copied unchanged from our `research/e8-far-nine-complex`. +- `code/word.py` and `code/sinks.py` are unchanged from our #394 (`research/e8-clean-padding`); `code/emit.py` is #394's with a `setR` switch for R = 781. +- `data/pr401/selection.json`, `BANK-PATTERNS.json`, `RESULT.json` are Dugongue's PR #401 (`research/e8-response-subspaces/`, head 7844f72: `frames/selection.json`, `architecture/inputs/BANK-PATTERNS.json`, `RESULT.json`), byte-identical (git blobs 6e75d62b, dae63550, fa8bd211), Apache-2.0 (`data/pr401/LICENSE-pr401`). `RESULT.json` supplies #401's bit coarse bound and the b/kappa control. #401's scripts (`frames/reconstruct.py`, `architecture/banks.py`) were read as data; its entrance construction and bank-pattern assignment are re-implemented in `code/entrance.py` and `code/resynth401.py`. None of #401's scripts were run. +- #400 (rohanarun) was read as data; its R781 heterogeneous-bank composition was re-implemented during our exploration but is not part of this package's word (it is superseded by #401's mixed residual banks). +- `code/clean.py` and `data/sinks-e8clean3.json` are our #399 package, run as a control; `code/cxcheck.py` skips #401 entrance shears in its flipped-sign control. +- From our #402 (`research/e8-response-resynth`, run here as a control): `code/redesign.py`, `code/search.py`, `code/entrance.py`, `code/resynth401.py`, `data/designs-e8resynth401.json`. +- `data/pr404/selection194.json`, `bank-patterns.json`, `RESULT.json` are Dugongue's PR #404 (`research/e8-shared-donor-chains/`, head 12f4882: `shared/selection194.json`, `inputs/bank-patterns.json`, `RESULT.json`), byte-identical (git blobs 486fc922, 36568633, cbae9cc8), Apache-2.0 (`data/pr404/LICENSE-pr404`). #404's scripts (`shared/reconstruct.py`, `dual/reconstruct.py`, `code/frame-rewrite.py`) and research notes were read as data; the construction is re-implemented in `code/entrance404.py`. None of #404's scripts were run. The 203 -> 942 frame edit #404 incorporates is applecrusher's #376. +- From our #407 (`research/e8-repivot-fusion`, run here as a control): `code/entrance404.py`, `code/repivot.py`, `code/fusion404.py`, `data/repivot-e8.json`, `data/sinks-e8repivot.json`, `data/designs-e8repivot.json`. +- `data/pr409/SELECTION.json`, `PATTERNS.json` are rohanarun's PR #409 (`research/e8-sequential-gauges/`, head 212e03d), byte-identical (git blobs 8b50349a, 153f4612), Apache-2.0 (`data/pr409/LICENSE-pr409`). #409's scripts (`construct.py`, `build.py`, `expand.py`, `local_admit.py`) and #406's (`research/e8-shared-donor-resynth/construct.py`) were read as data; the sequential construction and the re-synthesis relocation are re-implemented in `code/seqenlarge.py`. None of their scripts were run. +- `data/pr410/enlarged205.json`, `bank-patterns.json` are eumemic's PR #410 (`research/e8-enlarged-sequential206/`, head 95ad14d: `shared/enlarged205.json`, `inputs/bank-patterns.json`), byte-identical (git blobs fd742887, acaa0964), Apache-2.0 (`data/pr410/LICENSE-pr410`). #410's scripts (`shared/reconstruct.py`, `acyclic/promote.py`, `discovery/*.py`) were read as data; the enlargement and the 760 promotion (control only) are re-implemented in `code/seqenlarge.py`. None of #410's scripts were run. +- `data/pr408/selection205.json`, `bank-patterns.json` are eumemic's PR #408 (`research/e8-shared-donor-205-bank64/`, head 26332a3: `shared/selection205.json`, `inputs/bank-patterns.json`), byte-identical (git blobs f38d996f, c60f2aae), Apache-2.0 (`data/pr408/LICENSE-pr408`), used for the #408 and #410 controls. None of #408's scripts were run. +- From our #412 (`research/e8-sequential-enlarged`, run here as a control): `code/seqenlarge.py`, `code/compose410.py`, `code/packer.py`, `data/repivot-e8seq.json`. +- `data/pr414/selection.json` is eumemic's PR #414 (`research/e8-grouped210-target-prefixes/newgroup/selection.json`, head 7132ca3), byte-identical (git blob a0eb2146), Apache-2.0 (`data/pr414/LICENSE-pr414`). +- `data/pr416/closure211-SELECTION.json` and `closure214-SELECTION.json` are eumemic's PR #416 (`research/e8-frameclosure214-target-prefixes/closure211/SELECTION.json` and `closure214/SELECTION.json`, head c76d101), byte-identical (git blobs c7fcb3b5, 66242297), Apache-2.0 (`data/pr416/LICENSE-pr416`). + - #414's and #416's scripts (`newgroup/construct.py`, `closure211/construct.py`, `closure214/construct.py`, `prefix/apply.py`) and #411's (`prefix/apply.py`, `PREFIX-PROOF.md`) were read as data. The promotion, the frame closure and the prefix rewrite are re-implemented in `code/compose416.py`. None of their scripts were run. +- #415 (rohanarun) was read as a comparison claim only. +- New here: `code/compose416.py`, `data/promote-e8closure.json`. +- #352 (`complex_splice.emit`), #363 and #377 (`PROOF.txt`, `global_nine.py`, `RECIPE-9.json`) were read as data only. diff --git a/research/e8-dirty-chart-audit/vendor/clifford_exact.py b/research/e8-dirty-chart-audit/vendor/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/e8-dirty-chart-audit/vendor/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<Y block) applied: replay main from helper column u_j with x=y=0 + reg={} + cols={j:{j:Fr(1)} for j in range(2*V,N)} + st=[dict() for _ in range(N)] + for j in range(2*V,N): st[j]={j:Fr(1)} + for t,s,q in pre_helper: + for k,x in st[s].items(): + z=st[t].get(k,0)+q*x + if z: st[t][k]=z + else: st[t].pop(k,None) + # st[h] = row h of A^{-1} acting on original columns; now run main on these helper values (x=y=0) + out=replay_main(c,{h:st[h] for h in range(2*V,N)}) + pre_target=[] + for y in range(V,2*V): + for k,x in sorted(out[y].items()): pre_target.append((y,k,-x)) # y -= (B A^-1 h) + # helper part of main from preconditioned helpers must be identity: + for h in range(2*V,N): assert out[h]=={h:Fr(1)}, ('A A^-1 != I',h) + xo=replay_main(c,{t:{t:Fr(1)} for t in range(V)}) + post=[] + for h in range(2*V,N): + if h in sinks: assert not xo[h],('sink row nonzero',h); continue + for s,x in sorted(xo[h].items()): post.append((h,s,-x)) + return pre_target,pre_helper,post +def lift(t,s,q,ori): + return ('add',('L',t),('L',s),q) if ori=='forward' else ('add',('L',s),('L',t),-q) +def emit(c,ori,hetero,fused,pw): + """hetero: {helper: endpoint frame} (#390 rank-8 sinks, no final lift); fused: set of zero-row sinks whose + final climb carries the bank padding C_72.""" + pre_target,pre_helper,post=pw; fr=c['frames']; dim=[len(f) for f in fr] + final=list(c['final']) + for r,f in hetero.items(): final[r]=f + cur=list(c['start']); tab=scat_table(c) + yield ('phase','old_response') + for t,s,q in pre_target+pre_helper: yield ('scalar','old_response',lift(t,s,q,ori),'old0') + yield ('phase','ad0') + for r,f in enumerate(c['start']): yield ('adapter','old_to_new',r,f) + for ph in ['A','centers','B']: + yield ('phase',ph) + if ph=='centers': + for k,r,f in sorted(c['ret']): + C=('C',k) + yield ('scalar','main',('clear',C),f if ori=='forward' else 0) + if ori=='forward': yield ('scalar','main',('add',C,('L',r),Fr(1)),f) + else: + for t in range(V): + if k in tab[t]: yield ('scalar','main',('add',C,('L',V+t),tab[t][k]),0) + yield ('center',k,f if ori=='forward' else 0,0 if ori=='forward' else f,dim[f]) + if ori=='forward': + for t in range(V): + if k in tab[t]: yield ('scalar','main',('add',('L',V+t),C,tab[t][k]),0) + else: yield ('scalar','main',('add',('L',r),C,Fr(-1)),f) + yield ('scalar','main',('clear',C),0 if ori=='forward' else f) + continue + for g in c[ph]: + for r in gate_regs(g): + if cur[r]!=g[1]: + yield ('climb',ph,r,cur[r],g[1],dim[g[1]]-dim[cur[r]]); cur[r]=g[1] + for t,s,q in gate_adds(g): yield ('scalar','main',lift(t,s,q,ori),g[1]) + yield ('phase','final') + for r,f in enumerate(final): + if cur[r]!=f: + if r in fused: yield ('climb_pad72',r,cur[r],f,dim[f]-dim[cur[r]],dim[f]-dim[cur[r]]+1) + else: yield ('climb','final',r,cur[r],f,dim[f]-dim[cur[r]]) + cur[r]=f + yield ('phase','adF') + for r,f in enumerate(final): + yield ('adapter','canonical_to_bank_residual' if r in hetero else 'new_to_old',r,f) + yield ('phase','cleanup') + for t,s,q in post: yield ('scalar','cleanup',lift(t,s,q,ori),'old1') + yield ('phase','done') +PHASES=['old_response','ad0','A','centers','B','final','adF','cleanup','done'] +def nested(fr,a,b): + def red(u,B): + for x in B: + if u>>(x.bit_length()-1)&1: u^=x + return u + return all(red(u,fr[b])==0 for u in fr[a]) +def validate(events,c,ori,hetero,fused): + """independent exact replay on all 1023 live columns + label/lifetime/fusion rules""" + fr=c['frames']; dim=[len(f) for f in fr]; final=list(c['final']) + for r,f in hetero.items(): final[r]=f + cur=list(c['start']); reg={('L',i):{i:Fr(1)} for i in range(N)}; seen=[]; phase=None + hist=Counter(); paid=Counter(); fusedone=set(); centers=set(); counts=Counter(); edges=set() + for ev in events: + counts[ev[0]]+=1 + if ev[0]=='phase': + phase=ev[1]; seen.append(phase); assert seen==PHASES[:len(seen)],'chronology' + if phase=='adF': assert cur==final,'final climbs' + continue + if ev[0]=='adapter': + assert (phase=='ad0' and ev[1]=='old_to_new') or (phase=='adF' and ev[1] in ('new_to_old','canonical_to_bank_residual')); continue + if ev[0] in ('climb','climb_pad72'): + if ev[0]=='climb': _,p,r,o,f,d=ev; assert p==phase + else: + _,r,o,f,d,dp=ev; assert phase=='final' and r in fused and dp==d+1 and f==1; fusedone.add(r) + assert r not in fusedone or ev[0]=='climb_pad72' + assert cur[r]==o and d==dim[f]-dim[o]>0 and nested(fr,o,f),'child' + assert not centers,'centre live during child' + cur[r]=f; hist[d]+=1; paid[d if ev[0]=='climb' else d+1]+=1; edges.add((o,f)); continue + if ev[0]=='center': + _,k,o,f,d=ev; assert phase=='centers' and centers=={('C',k)}; hist[d]+=1; paid[d]+=1; continue + assert ev[0]=='scalar'; _,p,e,f=ev + assert p==('main' if phase in ('A','centers','B') else phase) + tgt=e[1]; src=e[2] if e[0]=='add' else None + for x in [tgt]+([src] if src else []): + if x[0]=='L': + i=x[1]; assert i not in fusedone,'fused sink touched after its padded climb' + if phase=='old_response': assert f=='old0' and role(i) in ('Y','S') + elif phase=='cleanup': assert f=='old1' and cur[i]==1 and role(i) in ('X','S') and i not in hetero and i not in fused + else: assert cur[i]==f,'scalar not at common exact label' + else: assert x[0]=='C' and phase=='centers' + if e[0]=='clear': reg[tgt]={}; centers.discard(tgt) + else: + q=e[3]; d=reg.setdefault(tgt,{}) + for k,x in dict(reg.get(src,{})).items(): + z=d.get(k,0)+q*x + if z: d[k]=z + else: d.pop(k,None) + if tgt[0]=='C': centers.add(tgt) + assert seen==PHASES and not centers + exp={('L',i):{i:Fr(1)} for i in range(N)} + for t in range(V): + if ori=='forward': exp[('L',V+t)][t]=Fr(1) + else: exp[('L',t)][V+t]=Fr(-1) + bad=[r for r in exp if reg[r]!=exp[r]] + assert not bad,(ori,'columns wrong',bad[:5]) + assert all(not z for r,z in reg.items() if r[0]!='L'),'private work not erased' + assert fusedone==set(fused) + return dict(events=sum(counts.values()),counts=dict(counts),local_hist=dict(sorted(hist.items())),paid_hist=dict(sorted(paid.items())),edges=sorted(edges)) diff --git a/research/e8-dirty-chart-audit/verify.py b/research/e8-dirty-chart-audit/verify.py new file mode 100644 index 0000000000..064b4f7349 --- /dev/null +++ b/research/e8-dirty-chart-audit/verify.py @@ -0,0 +1,31 @@ +"""Check the complete package closure and run the finite regression suite.""" +from pathlib import Path +import hashlib, json, subprocess, sys + +if not __debug__: + raise RuntimeError('Assertions are required') +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent + + +def snapshot(): + assert not any(p.is_symlink() for p in ROOT.rglob('*')) + return {p.relative_to(ROOT).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() + for p in ROOT.rglob('*') if p.is_file() and p != ROOT/'MANIFEST.json'} + + +manifest = json.loads((ROOT/'MANIFEST.json').read_text())['files'] +assert snapshot() == manifest, 'Package closure changed' +sources = json.loads((ROOT/'SOURCES.json').read_text()) +for name, entry in sources['vendor'].items(): + raw = (ROOT/'vendor'/name).read_bytes() + assert hashlib.sha256(raw).hexdigest() == entry['sha256'] + if 'git_blob' in entry: + assert hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == entry['git_blob'] +for name, entry in sources['fixtures'].items(): + assert hashlib.sha256((ROOT/'inputs'/name).read_bytes()).hexdigest() == entry['fixture_sha256'] +result = subprocess.run([sys.executable, '-B', '-m', 'unittest', '-v', 'test_chart_audit.py'], cwd=ROOT) +assert snapshot() == manifest, 'Package changed during verification' +if result.returncode: + raise SystemExit(result.returncode) +print('PASS_DIRTY_CHART_AUDIT_PACKAGE', len(manifest), 'source files') diff --git a/research/e8-emitter-digest-cache/EMITTER.patch b/research/e8-emitter-digest-cache/EMITTER.patch new file mode 100644 index 0000000000..995e6284ac --- /dev/null +++ b/research/e8-emitter-digest-cache/EMITTER.patch @@ -0,0 +1,37 @@ +--- original/code/emit.py ++++ candidate/code/emit.py +@@ -17,6 +17,7 @@ + sys.path.insert(0,str(HERE.parents[1]/"idle-axis-hosting")) + from bank_routes import validate_isometries + import hosting_core as HC ++from digest_encoder import compile_stream, encoded_records + + H,L,K,T,M=8,11,5,8,78 + def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +@@ -192,6 +193,7 @@ + hosted={(s,h):(i,cp,off,width) for i,cp,off,width,s,h in slots} + assert len(slots)==len(hosted)==L*R and set(hosted)=={(s,h) for s in range(L) for h in range(R)} + remainder={str(i):{str(r):n for r,n in sorted(Counter(rem[i,cp] for cp in range(2*V)).items())} for i in win} ++ compiled = {ori: compile_stream(events) for ori, events in streams.items()} + paid=Counter(); calls=[]; assignment=set(); expanded=hashlib.sha256(); full_event_count=0 + for e in events: + if e['kind']!='local': continue +@@ -210,14 +212,11 @@ + assert all(0<=f','exec'),namespace) + extract=namespace['extract'] + return extract(ADAPTER/'original_emit.py',False),extract(ADAPTER/'candidate_emit.py',True),namespace['Recorder'] + + +def load_fixtures(): + sources=json.loads((ROOT/'SOURCES.json').read_text()) + return [json.loads(gzip.decompress((ROOT/f['path']).read_bytes())) for f in sources['fixtures']] + + +def check_records(fixtures): + original,cached,Recorder=load_loops() + profiles=[] + for fixture in fixtures: + streams=fixture['local_programs'] + compiled={name:compile_stream(events) for name,events in streams.items()} + before=json.dumps([streams,fixture['calls']],sort_keys=True) + paid_original,paid_cached=Counter(),Counter() + hash_original,hash_cached=hashlib.sha256(),hashlib.sha256() + count=0 + for call in fixture['calls']: + orientation,owners=call['orientation'],call['owners'] + old=Recorder(aggregate=hash_original) + new=Recorder(old.rows,aggregate=hash_cached) + n=len(owners) + old_count=original(streams,orientation,owners,n,fixture['live'],paid_original,old,compiled) + new_count=cached(streams,orientation,owners,n,fixture['live'],paid_cached,new,compiled) + new.finish() + assert old_count==new_count and old.digest.digest()==new.digest.digest() + count+=old_count + assert paid_original==paid_cached and hash_original.digest()==hash_cached.digest() + assert before==json.dumps([streams,fixture['calls']],sort_keys=True) + profiles.append(dict(calls=len(fixture['calls']),count=count,digest=hash_original.hexdigest(), + paid_profile={str(k):v for k,v in sorted(paid_original.items())})) + return profiles + + +def benchmark(fixtures): + original,cached,_=load_loops() + samples={'original':[],'cached':[]} + orders=[] + for repetition in range(3): + order=[('original',original),('cached',cached)] + if repetition%2:order.reverse() + orders.append([name for name,_ in order]) + results=[] + for name,fn in order: + start=time.perf_counter() + digest,paid,count=hashlib.sha256(),Counter(),0 + for fixture in fixtures: + streams=fixture['local_programs'] + compiled={key:compile_stream(events) for key,events in streams.items()} if name=='cached' else {} + for call in fixture['calls']: + count+=fn(streams,call['orientation'],call['owners'],len(call['owners']), + fixture['live'],paid,digest,compiled) + samples[name].append(time.perf_counter()-start) + results.append((digest.hexdigest(),paid,count)) + assert results[0]==results[1] + return dict(seconds_including_compile_and_owner_cache=samples,order=orders, + median_speedup=statistics.median(samples['original'])/statistics.median(samples['cached']), + scope='Extracted hashing loop on retained workloads; not end-to-end supplier runtime.') diff --git a/research/e8-emitter-digest-cache/digest_encoder.py b/research/e8-emitter-digest-cache/digest_encoder.py new file mode 100644 index 0000000000..ab5784f9b5 --- /dev/null +++ b/research/e8-emitter-digest-cache/digest_encoder.py @@ -0,0 +1,30 @@ +"""Byte-identical encoding for the emit.py renamed-instruction SHA stream. +No semantic/invoice transformation. Caller retains original ownership/paid-rank checks. +Precondition: streams and owners remain unchanged while compiled records are encoded. +Only the actual emit.py schema is accepted: op0/1 length6, op2/3 length7. +""" +import json + +def compile_stream(events): + out=[] + for z in events: + op=z[0] + assert type(op) is int and op in (0,1,2,3) + assert len(z)==(6 if op in (0,1) else 7) + assert all(type(x) is int for x in z) + x=z[1] + if op==0: + out.append((b'['+str(op).encode()+b',',x,None,b','+json.dumps(z[2:],separators=(',',':')).encode()[1:]+b'\n')) + else: + out.append((b'['+str(op).encode()+b',',x,z[2],b','+json.dumps(z[3:],separators=(',',':')).encode()[1:]+b'\n')) + return tuple(out) + +def encoded_records(compiled,owners,private_owner): + enc=[json.dumps(o,separators=(',',':')).encode() for o in owners] + private=json.dumps(private_owner,separators=(',',':')).encode();n=len(enc) + for prefix,x,y,suffix in compiled: + assert 0<=x=0 + yield prefix+enc[x]+b','+(enc[y] if y/2') + geo=json.loads((out/'GEOMETRY.json').read_text()) + assert geo['status']=='PASS_COMPRESSED_ELEVEN_BIT_GEOMETRY' + # the port routes depend only on the labels: same 120 label vectors, in the same order + assert len(geo['ports'])==V and all(p['port']==t and p['q']==w['lines'][t] for t,p in enumerate(geo['ports'])) + rp=a.local_check/'records/249-records.bin'; raw=rp.read_bytes(); rec=list(struct.iter_unpack('<6i',raw)) + state=json.loads((a.local_check/'records/249-states.json').read_text()) + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + dims={int(f):z['dim'] for f,z in fs.items()} + parent_global=json.loads((a.local_check/'nine/GLOBAL.json').read_text()) + assert (state['v'],state['n'])==(V,LOCAL) + ADDS=sum(row[0]==1 for row in rec) + assert ADDS==parent_global['local_additions'] + initial=[state['initial'][str(i)] for i in range(LOCAL)] + final=[state['final'][str(i)] for i in range(LOCAL)] + assert all(dims[final[i]]==H for i in range(2*V,LOCAL)) + widths=[H-dims[initial[i]] for i in range(2*V,LOCAL)] + ENT=sum(H-z for z in widths) + NB=0;LIVE=DATA + assert T==8 and M==8+7*(L-1) + isometries=json.loads(a.isometries.read_text()) + assert validate_isometries(isometries,w['frames'],w['lines'],dims)==set(initial[2*V:]) + streams={}; checks={}; localH=None + for reverse in (False,True): + cur=(final if reverse else initial)[:]+[-1]; val=[1<=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x=0 + yield prefix+enc[x]+b','+(enc[y] if y=n for z in events) + assert opcodes=={0,1,2,3} and signed and private + rejected=[] + for z in [[0,0],[1,0,0],[2,0,1,2,3,4],[3,0,1,2,3,4,False]]: + try:compile_stream([z]) + except AssertionError:rejected.append(z) + else:raise AssertionError('invalid schema accepted') + # Setup-inclusive repeated-call timings, both fixtures/all calls. Hashes/accounting still exact. + times={'original':[],'cached':[]};orders=[] + for rep in range(3): + digests=[] + order=[('original',orig),('cached',fast)] if rep%2==0 else [('cached',fast),('original',orig)] + orders.append([name for name,fn in order]) + for name,fn in order: + t=time.perf_counter();hd=hashlib.sha256();paid=Counter();cnt=0 + for d in fixtures: + streams=d['local_programs'];compiled={k:compile_stream(v) for k,v in streams.items()} if name=='cached' else {} + for c in d['calls']:cnt+=fn(streams,c['orientation'],c['owners'],len(c['owners']),d['live'],paid,hd,compiled) + times[name].append(time.perf_counter()-t);digests.append((hd.hexdigest(),cnt,paid)) + assert digests[0]==digests[1] + assert closure()==manifest + for pin in pins['fixtures']:assert sha(Path(pin['path']))==pin['sha256'] + result={'status':'PASS_EXACT_EXTRACTED_HASHING_LOOP','manifest_sha256':manifest,'records_byte_compared':records,'fixtures':profiles,'opcodes':sorted(opcodes),'signed_and_private_operands':True,'schema_controls':len(rejected),'timings_including_compile_and_owner_cache':times,'benchmark_order':orders,'median_speedup':statistics.median(times['original'])/statistics.median(times['cached']),'seconds':time.perf_counter()-start,'peak_rss_bytes':resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,'scope':'hashing-loop microbenchmark only; no full wrapper/runtime/numerical improvement claim','python':sys.version,'source_and_fixtures_unchanged':True} + (out/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n');print(json.dumps(result,indent=2)) + except BaseException as e: + closure();(out/'FAILURE.json').write_text(json.dumps({'error':repr(e),'source_manifest':manifest,'seconds':time.perf_counter()-start},indent=2)+'\n');raise +if __name__=='__main__':main(Path(sys.argv[1]).resolve()) diff --git a/research/e8-emitter-digest-cache/evidence/adapter/original_emit.py b/research/e8-emitter-digest-cache/evidence/adapter/original_emit.py new file mode 100644 index 0000000000..e033a8ceec --- /dev/null +++ b/research/e8-emitter-digest-cache/evidence/adapter/original_emit.py @@ -0,0 +1,259 @@ +# Kernel integration of PR436/PR386 by chafreaky, with OpenAI Codex assistance. +# Original copyright and attribution retained below. This variant uses explicit +# residual isometries and mixed-width banks; the original all-zero-start +# requirement is replaced by the verified kernel entrance contract. +"""Source-bound eleven-stage bit template with 8 independent replicas and no helper banks. +PR386 global identity and PR436 generalization by Zhihao Chen and eumemic, +with their disclosed OpenAI Codex and Anthropic Claude assistance, Apache-2.0. +PR439 explicit residual routes and this replication extension by chafreaky, +with OpenAI Codex assistance. All owner assignments and emitted calls are checked. +Historical PR386 regression is performed by the unchanged parent wrapper. +""" +import argparse, gzip, hashlib, json, struct, time, sys +from collections import Counter +from pathlib import Path +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE.parents[1]/"e8-r740-replica32/code")) +sys.path.insert(0,str(HERE.parents[1]/"idle-axis-hosting")) +from bank_routes import validate_isometries +import hosting_core as HC + +H,L,K,T,M=8,11,5,8,78 +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def write(p,x): p.write_text(json.dumps(x,indent=2)+'\n') + +def recipe(): + out=[dict(kind='local',stage=0,pair=0,reverse=False)]; stage=1 + for j in range(K): + out.append(dict(kind='local',stage=stage,pair=j,reverse=True)); stage+=1 + if j/2') + geo=json.loads((out/'GEOMETRY.json').read_text()) + assert geo['status']=='PASS_COMPRESSED_ELEVEN_BIT_GEOMETRY' + # the port routes depend only on the labels: same 120 label vectors, in the same order + assert len(geo['ports'])==V and all(p['port']==t and p['q']==w['lines'][t] for t,p in enumerate(geo['ports'])) + rp=a.local_check/'records/249-records.bin'; raw=rp.read_bytes(); rec=list(struct.iter_unpack('<6i',raw)) + state=json.loads((a.local_check/'records/249-states.json').read_text()) + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + dims={int(f):z['dim'] for f,z in fs.items()} + parent_global=json.loads((a.local_check/'nine/GLOBAL.json').read_text()) + assert (state['v'],state['n'])==(V,LOCAL) + ADDS=sum(row[0]==1 for row in rec) + assert ADDS==parent_global['local_additions'] + initial=[state['initial'][str(i)] for i in range(LOCAL)] + final=[state['final'][str(i)] for i in range(LOCAL)] + assert all(dims[final[i]]==H for i in range(2*V,LOCAL)) + widths=[H-dims[initial[i]] for i in range(2*V,LOCAL)] + ENT=sum(H-z for z in widths) + NB=0;LIVE=DATA + assert T==8 and M==8+7*(L-1) + isometries=json.loads(a.isometries.read_text()) + assert validate_isometries(isometries,w['frames'],w['lines'],dims)==set(initial[2*V:]) + streams={}; checks={}; localH=None + for reverse in (False,True): + cur=(final if reverse else initial)[:]+[-1]; val=[1<=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x0 for values in timing.values() for x in values) + assert statistics.median(timing['original'])/statistics.median(timing['cached'])==result['median_speedup'] + assert result['benchmark_order']==[['original','cached'],['cached','original'],['original','cached']] + suite=unittest.defaultTestLoader.loadTestsFromModule(test_digest_encoder) + tests=unittest.TextTestRunner(verbosity=1).run(suite) + assert tests.wasSuccessful() and tests.testsRun==2 + report=dict(status='PASS_BYTE_IDENTICAL_EMITTER_DIGEST_CACHE',records=2742552,calls=144, + fixture_digests=[x['digest'] for x in actual],focused_tests=2, + source_checks='All original emitter AST outside import/cache setup/hash-loop unchanged', + recorded_setup_inclusive_hash_loop_speedup=result['median_speedup'], + scope='Pinned PR447 loop contract on completed PR438/PR442 workloads; no full supplier replay or end-to-end speedup claim.') + if run_benchmark:report['new_hash_loop_benchmark']=contract.benchmark(fixtures) + assert snapshot()==manifest + return report + + +if __name__=='__main__': + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--benchmark',action='store_true',help='Also time the extracted loops with cache setup included') + parser.add_argument('--output',type=Path,help='Write the report to a new file outside the package') + args=parser.parse_args() + if args.output and (args.output.exists() or args.output.resolve().is_relative_to(ROOT)): + parser.error('Output must be a new file outside the package') + report=json.dumps(verify(args.benchmark),indent=2)+'\n' + if args.output: + with args.output.open('x') as stream:stream.write(report) + print(report,end='') diff --git a/research/e8-exact-bank-optimizer/.gitattributes b/research/e8-exact-bank-optimizer/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/e8-exact-bank-optimizer/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/e8-exact-bank-optimizer/LICENSE b/research/e8-exact-bank-optimizer/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-exact-bank-optimizer/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/e8-exact-bank-optimizer/MANIFEST.json b/research/e8-exact-bank-optimizer/MANIFEST.json new file mode 100644 index 0000000000..3077a4eff8 --- /dev/null +++ b/research/e8-exact-bank-optimizer/MANIFEST.json @@ -0,0 +1,21 @@ +{ + "files": { + ".gitattributes": "705fd4d6451a31d36b3df7de96f83f30ac976c9b4a6d1e51671d8e2f33e2d0da", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "56f4dcda74784d1c0b61c8eeac625496902235ca99fe27929644df2b541d4e75", + "PROOF.md": "e92b01ce46710cedd2b2d1729e47f75059aa7bd2d940659b8ccb751234277596", + "README.md": "65fae81f0df460203ecdfacc5e56b4d0e88b7ccf82cc66fa2e17b76611f5bb2c", + "SOURCES.json": "e4b5aaf7571e86e19b96d02856b0f610732b8e48b972b1745eb6417c103e969a", + "VALIDATION.md": "8c8220ce3d1db6c731cff7176cf4362b64e64a69a7a5b72940ca8f9b73ebea82", + "bank_optimizer.py": "939dc7823edccbbfcf3e8264cf9ec6fb16fd927466257c193b85b5fada462147", + "inputs/cases.json": "82098b13e450c3b53ea5c258184bb7e10a0fd3316f955b00659692f8474f23ce", + "inputs/example-inventory.json": "1f85510a1ba2057227a1d3dddbf366e3b5aa7fe2997d72839f0e53214f1e09ce", + "inputs/pr404-patterns.json": "23947e260f32de24038674239456a8b1ce590f9f54d34b74289408ebf3d4d4fd", + "inputs/pr404-with-enlarged956-patterns.json": "cd412b44e733fce37e48e716af229a3e6d4a3e24e3f2a31d48139e2d78eccaee", + "inputs/pr409-patterns.json": "e64dfb15ea77d79e92109d53c5a34723e27d49b367f674d694f5c446114ce947", + "inputs/pr409-with-enlarged956-patterns.json": "8aa9ae2cf8259b668f4877f0b835d62287b25646e273be03d26483665b5288d6", + "inputs/pr410-patterns.json": "eb9bd9dd6445e37d43d8240df6c3c74415e7f2d0cc08fe8d0a5e1d35481ace9c", + "test_bank_optimizer.py": "5267616ee5644f6d940a8f42f10f6a6036c85f82a867ce3af38e4b3c9f6794f3", + "verify.py": "b4ef2916f087dcc44cc24794ba6095b9143a9801e8ab6a8b7fe7dc9415c8fb8e" + } +} diff --git a/research/e8-exact-bank-optimizer/NOTICE.md b/research/e8-exact-bank-optimizer/NOTICE.md new file mode 100644 index 0000000000..dba026d43c --- /dev/null +++ b/research/e8-exact-bank-optimizer/NOTICE.md @@ -0,0 +1,16 @@ +# Attribution and license + +Apache-2.0. Original notices and attribution apply to the source pattern fixtures. + +George Lydakis, with substantial OpenAI Codex and Ody assistance: the exact bank-cost dual including fallback, the necessary-and-sufficient width-73 packing characterization, compressed constructive optimizer, minimum-replication calculation, and independent exhaustive validation. These claims concern the stated finite bank model, not literature-wide priority or an unconditional multiplication theorem. + +The bank model and fixtures build on the existing integer-multiplication research: + +- Dugongue, PR404, supplies the shared-donor residual inventory and admitted bank architecture, with the retained PR401/398/390/396, applecrusher PR376, jacklightChen PR377, Jacob Sussman E8 and earlier compiler/analytic lineage. +- Rohan Arun with substantial OpenAI Codex assistance, PR409, supplies the ordered entrance inventory and its bank witness, including the credited Chafik Boukhalfa / Anthropic Claude PR402 target re-synthesis. +- eumemic with substantial OpenAI Codex assistance, PR410, supplies the enlarged sequential inventory and its bank witness, retaining PR408/404/402/376 and earlier sources. +- Rohan Arun's PR403 supplies the existing explicit replication architecture. Its multiple-of-eight requirement is preserved when the optimizer is called with `replica_multiple=8`. + +The five pattern JSON fixtures are preserved byte-for-byte. Public fixture revisions and hashes are in SOURCES.json. The two enlarged research fixtures are locally constructed examples that were superseded numerically before publication; their inclusion asserts only the bank-inventory and optimality properties tested here. No multiplication κ is claimed from those examples. + +The proof and optimizer do not incorporate third-party solver code. Existing transvection, Clifford, compiler, bit and outer constructions are not claimed as new here. diff --git a/research/e8-exact-bank-optimizer/PROOF.md b/research/e8-exact-bank-optimizer/PROOF.md new file mode 100644 index 0000000000..fbd7e57e17 --- /dev/null +++ b/research/e8-exact-bank-optimizer/PROOF.md @@ -0,0 +1,100 @@ +# Exact optimal bank construction + +## Pattern inequality + +Let `h >= 2` be an integer, `m = h(h-1)+1`, `D=(h-1)^2`, `0=0`. A nonempty bank contains `k` residual items of integer ranks at most `h`, with total rank `q<=m` and padding `p=m-q`. It pays one recursive padding child when `p>0`. Define + +``` +C = m - m^a +y_r = (C + h*epsilon)(r-1)/D - epsilon. +``` + +Then its complete bank cost satisfies + +``` +q - m^a + p^a + epsilon*1[p>0] >= sum_items y_r, +``` + +where `0^a=0`. + +If `p=0`, then `k>=h` because `q=m>h(h-1)`. The exact slack is `(k-h)(C+m*epsilon)/D`, which is nonnegative. + +If `p>=1`, concavity of `x^a` on `[1,m]` gives + +``` +p^a >= 1 + (p-1)(m^a-1)/(m-1). +``` + +Thus the main cost is at least `C*q/(h(h-1))`. Subtracting its main dual term leaves at least `C*(h*k-q)/(h*D)>=0`, since every item rank is at most `h`. The fallback slack is + +``` +epsilon * (D + m*k - h*q)/D + >= epsilon * (p-1)/(m-1) >= 0, +``` + +using `k>=q/h`. This establishes the inequality for every permitted real exponent, with no floating solver or sampled powers. + +Equality holds for a full bank containing exactly `h` items, or for `h-1` rank-`h` items with one padding coordinate. For `0= (C+h*epsilon)*W/D - epsilon*K. +``` + +Any exact integer packing made exclusively of the equality patterns attains this bound. Its number of banks is `W/D` and its number of padded banks is `h*W/D-K`. Integer replication scales both the bound and such a packing exactly. + +## Necessary and sufficient conditions for width 73 + +For ranks in `{4,5,7,8,9}`, let `K=sum n_r`, `W=sum (r-1)n_r`. An integer packing attaining the bound exists exactly when + +``` +W is divisible by 64, +P = 9W/64 - K >= 0, +n_8 >= n_4, +n_8 + 2n_7 >= 3n_4. +``` + +For an attaining packing, the preceding equality characterization gives `B=W/64` banks, `P=9B-K` one-coordinate padded banks and `F=K-8B` full banks. These counts are necessary; `F>=0` follows from all ranks being at most9. + +A full bank has nine items of mass73. Replacing each item's rank `r` by its deficit `9-r` therefore leaves exactly8 deficit units per full bank. The available deficits are5,4,2,1,0. A deficit5 cannot share a bank with another5 or a4, and its remaining3 must be either `2+1` or `1+1+1`. Thus each rank4 item needs at least one rank8 item, and all rank4 items together need at least `3n_4` units from ranks7 and8. This proves necessity of the two capacity inequalities. A padded equality bank is eight rank9 items and cannot absorb another rank. + +For sufficiency, put `x=min(n_4,n_7)` rank4 items with one rank7 and one rank8 item each. Put the remaining `n_4-x` rank4 items with three rank8 items each. The two capacity inequalities ensure enough rank8 items: the total used is `3n_4-2x`. Fill each of these banks to nine items with rank9 items after all nonzero deficits have been assigned. + +The residual deficit1 count is even. This follows because the original total deficit is `9K-sum r*n_r = 8F`, and the already completed banks remove multiples of8. Pair the remaining deficit1 items into deficit2 blocks. Combine those with the original remaining deficit2 items; their total number is even because the remaining total deficit is divisible by4. Pair them into deficit4 blocks, combine with the original deficit4 items, and pair again into deficit8 blocks. The total is divisible by8, so this last pairing is exact. Each resulting block has at most8 original items and can be filled to nine with rank9 items. + +These blocks make exactly `F` full banks. If `L` is the number of non-rank9 items, full banks need `9F-L` rank9 items. The inventory contains + +``` +n_9 = 9F - L + 8P, +``` + +because `K=9F+8P`. Since `P>=0`, there are enough rank9 items. Exactly `8P` remain for the padded banks. This constructs an equality witness and proves sufficiency. The empty inventory has the empty packing. + +The implementation keeps multiplicities compressed. Each pairing operates on a bounded number of pattern types, so the number of integer operations does not grow with item counts. Integer bit complexity still grows with the bit length of those counts. It uses neither floating arithmetic nor an optimization dependency. + +## Minimum replication and architecture constraints + +For counts per replica, the two capacity inequalities and the sign of `9W-64K` are invariant under positive replication. If any fails, no replica count reaches this equality bound. This does not mean ordinary nonsaturating bank packing is impossible. + +Otherwise the only remaining condition is `64 | T*W`. The least positive replica count is exactly + +``` +T_min = 64 / gcd(W,64). +``` + +If the surrounding architecture requires a multiple of `A`, the least admissible count is `lcm(T_min,A)`. The existing PR403 expander requires multiples of8. PR404's packing minimum is4, but its existing architecture minimum is8. The optimizer exposes both numbers and never claims a smaller packing witness validates a changed global architecture. + +## Connection to the actual paid moment + +Take `a=1-b` and `epsilon=32*m^2*10^-16`. This epsilon is the retained rank-one fallback charge per paid child, not an omitted lower-order term. Multiplying the normalized moment minus one by the positive denominator `stock*m^a` gives + +``` +sum_paid count*r^a + epsilon*sum_paid count - stock*m^a. +``` + +For a fixed local ledger and `L` stages, the packing-dependent part is `L*sum_banks(p^a+epsilon*1[p>0]-m^a)`. Adding the fixed residual rank mass converts it to the bank cost just bounded. Hence an attaining packing minimizes the full moment numerator for every `0= 0 +n_8 >= n_4 +n_8 + 2*n_7 >= 3*n_4 +``` + +It uses `W/64` banks and `9*W/64-K` rank-one pads. When the three scale-invariant inequalities hold, the minimum replication is `64/gcd(W,64)`. The proof and constructive grouping argument are in [PROOF.md](PROOF.md). + +| Inventory | Packing minimum | Minimum with architecture multiple 8 | Banks at architecture minimum | Rank-one pads | +|---|---:|---:|---:|---:| +| PR404 | 4 | 8 | 738 | 394 | +| PR409 | 32 | 32 | 2,947 | 1,531 | +| PR410 | 16 | 16 | 1,471 | 743 | + +The algorithm operates on a bounded number of compressed pattern counts. It does not loop over every item or replicate. Its integer bit complexity depends on input bit lengths. + +## Verification and scope + +The tests compare the feasibility decision and every successful witness with an independent exhaustive pattern-reachability oracle over 16,875 small inventories. They also check the pinned published witnesses, two enlarged research inventories, architecture constraints, certificate mutations, unsupported inputs and multiplicities above `10^40`. + +The bank theorem optimizes the full moment numerator for a fixed local ledger and residual inventory, including fallback. It therefore optimizes the admissible coarse root within that bank model. It does not establish the all-size multiplication interfaces, local phase correctness, owner routing, a finite compiler invoice, or a new outer κ. Changing a witness in a supplier still requires that supplier's complete admission. + +Source inventories, immutable revisions and attribution are recorded in [SOURCES.json](SOURCES.json) and [NOTICE.md](NOTICE.md). Prepared for George Lydakis with substantial OpenAI Codex and Ody assistance. diff --git a/research/e8-exact-bank-optimizer/SOURCES.json b/research/e8-exact-bank-optimizer/SOURCES.json new file mode 100644 index 0000000000..d4796f4d33 --- /dev/null +++ b/research/e8-exact-bank-optimizer/SOURCES.json @@ -0,0 +1,41 @@ +{ + "public_fixtures": [ + { + "pr": 404, + "head": "12f488264cdd74a3b60d0fb534f4955792384f5c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/12f488264cdd74a3b60d0fb534f4955792384f5c/research/e8-shared-donor-chains/inputs/bank-patterns.json", + "source_manifest_sha256": "19c8820253e1ed55e0cdbd48e255aff489c5681017a8a2041178e64155295b24", + "file": "inputs/pr404-patterns.json", + "sha256": "23947e260f32de24038674239456a8b1ce590f9f54d34b74289408ebf3d4d4fd" + }, + { + "pr": 409, + "head": "212e03d7665d08fc6a037d3e33612cb7fc60874d", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/212e03d7665d08fc6a037d3e33612cb7fc60874d/research/e8-sequential-gauges/PATTERNS.json", + "source_manifest_sha256": "6b413975d40af48fc15ef2a554b3e1f442f8affaafd9da86bdd57d12478b2b19", + "file": "inputs/pr409-patterns.json", + "sha256": "e64dfb15ea77d79e92109d53c5a34723e27d49b367f674d694f5c446114ce947" + }, + { + "pr": 410, + "head": "95ad14d5359d62a89e7bb06eb59b68029e77fb6f", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/95ad14d5359d62a89e7bb06eb59b68029e77fb6f/research/e8-enlarged-sequential206/inputs/bank-patterns.json", + "source_manifest_sha256": "4c4f0cadf2c292d393fdad8bbd4fe72f66328dff92e6f384ae63ebc746734b89", + "file": "inputs/pr410-patterns.json", + "sha256": "eb9bd9dd6445e37d43d8240df6c3c74415e7f2d0cc08fe8d0a5e1d35481ace9c" + } + ], + "research_fixtures": [ + { + "name": "PR404 with enlarged956", + "source_patterns_sha256": "cd412b44e733fce37e48e716af229a3e6d4a3e24e3f2a31d48139e2d78eccaee", + "source_patterns_file": "inputs/pr404-with-enlarged956-patterns.json" + }, + { + "name": "PR409 with enlarged956", + "source_patterns_sha256": "8aa9ae2cf8259b668f4877f0b835d62287b25646e273be03d26483665b5288d6", + "source_patterns_file": "inputs/pr409-with-enlarged956-patterns.json" + } + ], + "scope": "Pinned pattern witnesses only; no claim of replaying their entire supplier packages." +} diff --git a/research/e8-exact-bank-optimizer/VALIDATION.md b/research/e8-exact-bank-optimizer/VALIDATION.md new file mode 100644 index 0000000000..497ff1aacc --- /dev/null +++ b/research/e8-exact-bank-optimizer/VALIDATION.md @@ -0,0 +1,9 @@ +# Validation record + +The four focused tests passed under the existing local Python runtime. They cover an independent exhaustive reachability oracle for all 16,875 inventories in the stated finite grid, exact source-pattern hashes and inventories, compressed large counts, architecture replica multiples, two malformed-witness controls, and invalid or unsupported inputs. The public command-line example generated exactly 1,471 banks and 743 rank-one pads for PR410 at 16 replicas. + +An initial fixture incorrectly assumed PR404's published eight replicas were the mathematical packing minimum. The independent construction returned four replicas, 369 banks and 197 pads. The explicit witness and divisibility equation confirm that result. The fixture was corrected without changing the construction or weakening the exhaustive oracle. A separate architecture constraint now tests that the existing E8 expander still requires eight replicas, yielding the original 738 banks and 394 pads. + +The source manifests bind every copied published pattern fixture to its immutable revision. Source closure is checked before and after the test run. No full multiplication supplier, native phase checker, global owner decoder, bit component, or outer assembly is newly replayed or claimed by this optimizer package. + +Package-specific validation is separate from the repository's existing CI workflows. No dependency was installed, external executor used, or failed research scratch removed for this contribution. diff --git a/research/e8-exact-bank-optimizer/bank_optimizer.py b/research/e8-exact-bank-optimizer/bank_optimizer.py new file mode 100644 index 0000000000..c6a9bf6544 --- /dev/null +++ b/research/e8-exact-bank-optimizer/bank_optimizer.py @@ -0,0 +1,157 @@ +"""Exact width-73 optimizer for residual ranks 4, 5, 7, 8 and 9. + +The optimum is for the bank-dependent paid moment, including fallback, +with a fixed residual inventory. This does not validate a multiplication +supplier or optimize its local program. See PROOF.md for the exact domain. +""" +from collections import Counter +from math import gcd, lcm +from pathlib import Path +import argparse +import json + +RANKS = (4, 5, 7, 8, 9) + + +class NoSaturatingPacking(ValueError): + """The inventory cannot attain this dual bound at any replication.""" + + +def validate(inventory): + if any(type(r) is not int or r not in RANKS or type(n) is not int or n < 0 + for r, n in inventory.items()): + raise ValueError('Expected nonnegative integer counts at ranks 4, 5, 7, 8, 9') + return Counter({r: inventory.get(r, 0) for r in RANKS}) + + +def minimum_replicas(inventory): + """Smallest positive replication admitting an exact dual-saturating packing.""" + n = validate(inventory) + K = sum(n.values()) + W = sum((r-1)*count for r, count in n.items()) + if n[8] < n[4]: + raise NoSaturatingPacking('Each rank-4 item needs at least one rank-8 item') + if n[8] + 2*n[7] < 3*n[4]: + raise NoSaturatingPacking('Insufficient rank-7/rank-8 capacity around rank-4 items') + if 9*W < 64*K: + raise NoSaturatingPacking('The equality equations require a negative padding count') + return 64 // gcd(W, 64) + + +def _pair(blocks): + """Pair an even number of equally weighted blocks, using compressed counts.""" + result, carry = [], None + for pattern, count in blocks: + if not count: + continue + if carry is not None: + result.append((carry + pattern, 1)) + count -= 1 + carry = None + if count // 2: + result.append((Counter({r: 2*n for r, n in pattern.items()}), count // 2)) + if count % 2: + carry = pattern + if carry is not None: + raise ArithmeticError('Nonintegral block pairing') + return result + + +def construct(inventory, replicas=None, replica_multiple=1): + """Return an optimal packing as the existing bank emitter's pattern list. + + Default to the smallest replication that reaches the exact lower bound. + Work uses a bounded number of integer operations, independent of counts; + large multiplicities remain compressed. + """ + base = validate(inventory) + least = minimum_replicas(base) + if type(replica_multiple) is not int or replica_multiple <= 0: + raise ValueError('The architecture replica multiple must be a positive integer') + admissible = lcm(least, replica_multiple) + if replicas is None: + replicas = admissible + if type(replicas) is not int or replicas <= 0 or replicas % admissible: + raise ValueError(f'Replicas must be a positive multiple of {admissible}') + n = Counter({r: count*replicas for r, count in base.items()}) + K = sum(n.values()) + W = sum((r-1)*count for r, count in n.items()) + banks, pads = W//64, 9*(W//64)-K + + # Deficits 9-r are 5,4,2,1,0. Complete every deficit-5 item first. + x = min(n[4], n[7]) + y = n[4]-x + full = [(Counter({4:1,7:1,8:1}),x), (Counter({4:1,8:3}),y)] + ones = n[8]-x-3*y + if ones < 0 or ones % 2: + raise ArithmeticError('Invalid remaining deficit-one count') + twos = [(Counter({7:1}),n[7]-x), (Counter({8:2}),ones//2)] + fours = [(Counter({5:1}),n[5])] + _pair(twos) + full += _pair(fours) + + packed = Counter() + for pattern, count in full: + if not count: + continue + pattern[9] = 9-sum(pattern.values()) + key = tuple(pattern.get(r,0) for r in RANKS)+(0,) + packed[key] += count + if pads: + packed[(0,0,0,0,8,1)] += pads + patterns = [dict(count=count, **{f'r{r}':v for r,v in zip(RANKS,key) if v}, + padding=key[-1]) for key,count in sorted(packed.items())] + certificate = check(patterns, n) + if certificate['banks'] != banks or certificate['padding'] != pads: + raise ArithmeticError('Construction missed the equality count') + certificate.update(replicas=replicas, minimum_replicas=least, + minimum_admissible_replicas=admissible, replica_multiple=replica_multiple, + inventory_per_replica=dict(base)) + return patterns, certificate + + +def check(patterns, inventory): + """Independent integer census of a purported equality witness.""" + expected = validate(inventory) + found, banks, pads = Counter(), 0, 0 + for p in patterns: + if set(p)-{'count','padding',*(f'r{r}' for r in RANKS)}: + raise ValueError('Unknown pattern field') + count, pad = p['count'], p['padding'] + if type(count) is not int or count <= 0 or type(pad) is not int or pad not in (0,1): + raise ValueError('Invalid pattern multiplicity or padding') + items = {r:p.get(f'r{r}',0) for r in RANKS} + if any(type(v) is not int or v < 0 for v in items.values()): + raise ValueError('Invalid item count') + if sum(r*v for r,v in items.items())+pad != 73: + raise ValueError('Bank width differs from 73') + if sum(items.values()) != 9-pad: + raise ValueError('Pattern does not attain the exact bank bound') + found.update({r:count*v for r,v in items.items()}) + banks += count + pads += count*pad + if found != expected: + raise ValueError('Packing inventory does not match') + K = sum(found.values()) + W = sum((r-1)*n for r,n in found.items()) + if W != 64*banks or pads != 9*banks-K: + raise ValueError('Packing does not attain the inventory bound') + return dict(banks=banks, padding=pads, items=K, weighted_inventory=W) + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('inventory',type=Path,help='JSON object mapping ranks to counts per replica') + parser.add_argument('--replicas',type=int) + parser.add_argument('--replica-multiple',type=int,default=1, + help='Required architecture multiple, e.g. 8 for the existing E8 expander') + parser.add_argument('--output',type=Path,required=True,help='New patterns JSON file') + args=parser.parse_args() + raw=json.loads(args.inventory.read_text()) + patterns,certificate=construct({int(r):n for r,n in raw.items()},args.replicas,args.replica_multiple) + with args.output.open('x') as stream: + stream.write(json.dumps(patterns,indent=2)+'\n') + print(json.dumps(certificate,indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/e8-exact-bank-optimizer/inputs/cases.json b/research/e8-exact-bank-optimizer/inputs/cases.json new file mode 100644 index 0000000000..e582543a0f --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/cases.json @@ -0,0 +1,82 @@ +[ + { + "name": "PR404", + "inventory_per_replica": { + "9": 587, + "8": 143, + "5": 27, + "7": 9, + "4": 15 + }, + "minimum_replicas": 4, + "banks": 369, + "padding": 197, + "source_patterns_sha256": "23947e260f32de24038674239456a8b1ce590f9f54d34b74289408ebf3d4d4fd", + "source_patterns_file": "inputs/pr404-patterns.json", + "source_replicas": 8 + }, + { + "name": "PR409", + "inventory_per_replica": { + "9": 577, + "8": 153, + "5": 27, + "4": 15, + "7": 9 + }, + "minimum_replicas": 32, + "banks": 2947, + "padding": 1531, + "source_patterns_sha256": "e64dfb15ea77d79e92109d53c5a34723e27d49b367f674d694f5c446114ce947", + "source_patterns_file": "inputs/pr409-patterns.json", + "source_replicas": 32 + }, + { + "name": "PR410", + "inventory_per_replica": { + "9": 575, + "8": 155, + "5": 19, + "4": 23, + "7": 9 + }, + "minimum_replicas": 16, + "banks": 1471, + "padding": 743, + "source_patterns_sha256": "eb9bd9dd6445e37d43d8240df6c3c74415e7f2d0cc08fe8d0a5e1d35481ace9c", + "source_patterns_file": "inputs/pr410-patterns.json", + "source_replicas": 16 + }, + { + "name": "PR404 with enlarged956", + "inventory_per_replica": { + "9": 587, + "8": 142, + "7": 9, + "5": 28, + "4": 15 + }, + "minimum_replicas": 64, + "banks": 5901, + "padding": 3125, + "source_patterns_sha256": "cd412b44e733fce37e48e716af229a3e6d4a3e24e3f2a31d48139e2d78eccaee", + "source_patterns_file": "inputs/pr404-with-enlarged956-patterns.json", + "source_replicas": 64 + }, + { + "name": "PR409 with enlarged956", + "inventory_per_replica": { + "9": 577, + "8": 152, + "7": 9, + "5": 28, + "4": 15 + }, + "minimum_replicas": 64, + "banks": 5891, + "padding": 3035, + "source_patterns_sha256": "8aa9ae2cf8259b668f4877f0b835d62287b25646e273be03d26483665b5288d6", + "source_patterns_file": "inputs/pr409-with-enlarged956-patterns.json", + "source_replicas": 64 + } +] diff --git a/research/e8-exact-bank-optimizer/inputs/example-inventory.json b/research/e8-exact-bank-optimizer/inputs/example-inventory.json new file mode 100644 index 0000000000..ed1a345079 --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/example-inventory.json @@ -0,0 +1,7 @@ +{ + "4": 23, + "5": 19, + "7": 9, + "8": 155, + "9": 575 +} diff --git a/research/e8-exact-bank-optimizer/inputs/pr404-patterns.json b/research/e8-exact-bank-optimizer/inputs/pr404-patterns.json new file mode 100644 index 0000000000..3656863376 --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/pr404-patterns.json @@ -0,0 +1,34 @@ +[ + { + "count": 394, + "r9": 8, + "padding": 1 + }, + { + "count": 80, + "r8": 8, + "r9": 1, + "padding": 0 + }, + { + "count": 72, + "r5": 1, + "r7": 1, + "r8": 2, + "r9": 5, + "padding": 0 + }, + { + "count": 72, + "r5": 2, + "r9": 7, + "padding": 0 + }, + { + "count": 120, + "r4": 1, + "r8": 3, + "r9": 5, + "padding": 0 + } +] \ No newline at end of file diff --git a/research/e8-exact-bank-optimizer/inputs/pr404-with-enlarged956-patterns.json b/research/e8-exact-bank-optimizer/inputs/pr404-with-enlarged956-patterns.json new file mode 100644 index 0000000000..0eb61054ba --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/pr404-with-enlarged956-patterns.json @@ -0,0 +1,32 @@ +[ + { + "count": 3125, + "r9": 8, + "padding": 1 + }, + { + "count": 776, + "r8": 8, + "r9": 1, + "padding": 0 + }, + { + "count": 144, + "r7": 4, + "r9": 5, + "padding": 0 + }, + { + "count": 896, + "r5": 2, + "r9": 7, + "padding": 0 + }, + { + "count": 960, + "r4": 1, + "r8": 3, + "r9": 5, + "padding": 0 + } +] diff --git a/research/e8-exact-bank-optimizer/inputs/pr409-patterns.json b/research/e8-exact-bank-optimizer/inputs/pr409-patterns.json new file mode 100644 index 0000000000..153f46123b --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/pr409-patterns.json @@ -0,0 +1,35 @@ +[ + { + "count": 1531, + "r9": 8, + "padding": 1 + }, + { + "count": 72, + "r8": 8, + "r9": 1, + "padding": 0 + }, + { + "count": 864, + "r5": 1, + "r8": 4, + "r9": 4, + "padding": 0 + }, + { + "count": 192, + "r4": 1, + "r8": 3, + "r9": 5, + "padding": 0 + }, + { + "count": 288, + "r4": 1, + "r7": 1, + "r8": 1, + "r9": 6, + "padding": 0 + } +] diff --git a/research/e8-exact-bank-optimizer/inputs/pr409-with-enlarged956-patterns.json b/research/e8-exact-bank-optimizer/inputs/pr409-with-enlarged956-patterns.json new file mode 100644 index 0000000000..cf3cf40232 --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/pr409-with-enlarged956-patterns.json @@ -0,0 +1,32 @@ +[ + { + "count": 3035, + "r9": 8, + "padding": 1 + }, + { + "count": 856, + "r8": 8, + "r9": 1, + "padding": 0 + }, + { + "count": 144, + "r7": 4, + "r9": 5, + "padding": 0 + }, + { + "count": 896, + "r5": 2, + "r9": 7, + "padding": 0 + }, + { + "count": 960, + "r4": 1, + "r8": 3, + "r9": 5, + "padding": 0 + } +] diff --git a/research/e8-exact-bank-optimizer/inputs/pr410-patterns.json b/research/e8-exact-bank-optimizer/inputs/pr410-patterns.json new file mode 100644 index 0000000000..acaa0964fb --- /dev/null +++ b/research/e8-exact-bank-optimizer/inputs/pr410-patterns.json @@ -0,0 +1,35 @@ +[ + { + "count": 743, + "padding": 1, + "r9": 8 + }, + { + "count": 56, + "padding": 0, + "r8": 8, + "r9": 1 + }, + { + "count": 304, + "padding": 0, + "r5": 1, + "r8": 4, + "r9": 4 + }, + { + "count": 224, + "padding": 0, + "r4": 1, + "r8": 3, + "r9": 5 + }, + { + "count": 144, + "padding": 0, + "r4": 1, + "r7": 1, + "r8": 1, + "r9": 6 + } +] diff --git a/research/e8-exact-bank-optimizer/test_bank_optimizer.py b/research/e8-exact-bank-optimizer/test_bank_optimizer.py new file mode 100644 index 0000000000..98695a1b40 --- /dev/null +++ b/research/e8-exact-bank-optimizer/test_bank_optimizer.py @@ -0,0 +1,94 @@ +"""Independent finite oracle, source witnesses, boundaries, and large counts.""" +from collections import deque +from itertools import product +from pathlib import Path +import copy +import hashlib +import json +import unittest + +from bank_optimizer import RANKS, NoSaturatingPacking, check, construct, minimum_replicas + +ROOT=Path(__file__).resolve().parent + + +class OptimizerTests(unittest.TestCase): + def test_exhaustive_independent_pattern_oracle(self): + # Enumerate all width-73 equality patterns directly from rank and item + # equations, without the algorithm's grouping or feasibility predicates. + patterns=[] + for a,b,c,d in product(range(2),range(3),range(5),range(9)): + e=9-a-b-c-d + if e>=0 and 4*a+5*b+7*c+8*d+9*e==73: + patterns.append((a,b,c,d,e)) + patterns.append((0,0,0,0,8)) + self.assertEqual(len(patterns),12) + limits=(2,4,4,8,24) + zero=(0,)*5 + reachable={zero} + pending=deque([zero]) + while pending: + state=pending.popleft() + for p in patterns: + nxt=tuple(a+b for a,b in zip(state,p)) + if all(v<=m for v,m in zip(nxt,limits)) and nxt not in reachable: + reachable.add(nxt);pending.append(nxt) + count=0 + for state in product(*(range(m+1) for m in limits)): + inventory=dict(zip(RANKS,state)) + try: + patterns_out,certificate=construct(inventory,replicas=1) + except (NoSaturatingPacking,ValueError): + success=False + else: + success=True + self.assertEqual(check(patterns_out,inventory)['items'],sum(state)) + self.assertEqual(success,state in reachable,state) + count+=1 + self.assertEqual(count,16875) + + def test_published_and_composed_inventories(self): + for case in json.loads((ROOT/'inputs/cases.json').read_text()): + n={int(r):v for r,v in case['inventory_per_replica'].items()} + source=ROOT/case['source_patterns_file'] + self.assertEqual(hashlib.sha256(source.read_bytes()).hexdigest(),case['source_patterns_sha256']) + check(json.loads(source.read_text()),{r:v*case['source_replicas'] for r,v in n.items()}) + patterns,cert=construct(n) + self.assertEqual(cert['minimum_replicas'],case['minimum_replicas'],case['name']) + self.assertEqual(cert['banks'],case['banks'],case['name']) + self.assertEqual(cert['padding'],case['padding'],case['name']) + self.assertLessEqual(len(patterns),12) + + def test_compressed_large_counts_and_replication(self): + n={4:15,5:28,7:9,8:152,9:577} + patterns,cert=construct(n) + self.assertEqual((cert['replicas'],cert['banks'],cert['padding']),(64,5891,3035)) + for multiplier in (3,10**40+1): + scaled={r:v*multiplier for r,v in n.items()} + p,c=construct(scaled,replicas=64) + self.assertEqual(c['banks'],5891*multiplier) + self.assertEqual(c['padding'],3035*multiplier) + self.assertLessEqual(len(p),12) + for invalid in (0,-1,32,65,True): + with self.assertRaises(ValueError):construct(n,replicas=invalid) + original={4:15,5:27,7:9,8:143,9:587} + _,c=construct(original,replica_multiple=8) + self.assertEqual((c['minimum_replicas'],c['minimum_admissible_replicas'],c['banks']),(4,8,738)) + with self.assertRaises(ValueError):construct(original,replicas=4,replica_multiple=8) + + def test_certificate_controls_and_domain(self): + n={4:15,5:28,7:9,8:152,9:577} + p,c=construct(n) + target={r:v*64 for r,v in n.items()} + changed=copy.deepcopy(p);changed[0]['count']+=1 + with self.assertRaises(ValueError):check(changed,target) + changed=copy.deepcopy(p);changed[0]['padding']=7 + with self.assertRaises(ValueError):check(changed,target) + for invalid in ({6:1},{8:-1},{8:0.5},{8:True}): + with self.assertRaises(ValueError):construct(invalid) + # Each of the three independent impossibility conditions. + for n in ({4:1,7:2,9:100},{4:1,8:1,9:100},{8:1}): + with self.assertRaises(NoSaturatingPacking):minimum_replicas(n) + + +if __name__=='__main__':unittest.main() diff --git a/research/e8-exact-bank-optimizer/verify.py b/research/e8-exact-bank-optimizer/verify.py new file mode 100644 index 0000000000..111f0c064a --- /dev/null +++ b/research/e8-exact-bank-optimizer/verify.py @@ -0,0 +1,30 @@ +"""Check package closure and run the independent finite oracle.""" +from pathlib import Path +import hashlib +import json +import subprocess +import sys + +ROOT=Path(__file__).resolve().parent + + +def snapshot(): + if any(p.is_symlink() for p in ROOT.rglob('*')): + raise ValueError('Symlinks are not part of this package') + return {p.relative_to(ROOT).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() + for p in ROOT.rglob('*') if p.is_file() and p!=ROOT/'MANIFEST.json'} + + +def main(): + before=snapshot() + if before!=json.loads((ROOT/'MANIFEST.json').read_text())['files']: + raise ValueError('Package source closure changed') + result=subprocess.run([sys.executable,'-B','-m','unittest','-v','test_bank_optimizer.py'],cwd=ROOT) + if result.returncode: + raise SystemExit(result.returncode) + if snapshot()!=before: + raise ValueError('Package files changed during verification') + print('PASS_EXACT_BANK_OPTIMIZER_SOURCE_CLOSURE_AND_INDEPENDENT_ORACLE') + + +if __name__=='__main__':main() diff --git a/research/e8-hosted-bit-contract/EXPECTED.json b/research/e8-hosted-bit-contract/EXPECTED.json new file mode 100644 index 0000000000..ac578e390b --- /dev/null +++ b/research/e8-hosted-bit-contract/EXPECTED.json @@ -0,0 +1,19 @@ +{ + "profile": { + "1": 178560, + "2": 78072, + "3": 22296, + "4": 26368, + "5": 9576, + "6": 2176, + "7": 4224, + "8": 648 + }, + "hosted_residuals": 39568, + "parent_template_sha256": "f9ce9ac945d9e8ea737dc5e456e366a7e2a21d8b989d24b742d7f124d26fb32f", + "hosted_template_sha256": "dd7833dcaff8c84b258847f4c4d65b6402c702700ae37d2c464083ee37b24126", + "original_accepted_wrong_columns": [ + 8, + 3 + ] +} diff --git a/research/e8-hosted-bit-contract/LICENSE b/research/e8-hosted-bit-contract/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-hosted-bit-contract/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/e8-hosted-bit-contract/MANIFEST.json b/research/e8-hosted-bit-contract/MANIFEST.json new file mode 100644 index 0000000000..8173bf979d --- /dev/null +++ b/research/e8-hosted-bit-contract/MANIFEST.json @@ -0,0 +1,42 @@ +{ + "files": { + "EXPECTED.json": "11691f3648297baf7c3cd590b5a35277e395664c414f95874b6eec9b9d54e2b6", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "cec3c2808906c3840e495f12ae75c739b3857ae3450a4574382f749862939e07", + "PROOF.md": "eb222a2b27d5b3d214c8de4c214f74551d47f2a00f3e6b0148aaaae770d5b2db", + "README.md": "c8fb13edd4f469ebcf1076a97cdd5a3747f71f901a647fd2439ca9ba24065e5f", + "SOURCES.json": "5bae1919fb21de12813553730139ea6963aef2e052601763334429f7fc24ccf1", + "evidence/COMPLETION.json": "3083493cef033d148f08fb4a448fdbfbd45f028fb4d42d0c7e425db39ba42676", + "evidence/RECEIPT-MAP.json": "87d2e7d4d0b58f5fb2456ab69e77c95831015479527a565ec4eeaab4675196c2", + "evidence/REUSED-COMPLETION.json": "a7a2efeef20ba6b8fa381b19bd6bd83745bdca4b2ba255de5caa863ff74eec30", + "evidence/adapter/MANIFEST.json": "62b5ca8458735e867524e3fe97e619aa6a08a35063a966cc0e03d8cb8e469b28", + "evidence/adapter/SOURCE-PINS.json": "889ea5b1ba7eff1e1a95a6fdc22a5d639ff0dd73243fbed25b6db69957b03f62", + "evidence/adapter/audit_stage.py": "a835f61104894e16efff5c64eafcd61f2cf4f8c71d4c53fa0442e87470e2ec36", + "evidence/adapter/driver.py": "a9726a9841de1beb1eb4b39ae5b03c56b040bd1a8aaf317666e5df05bd3cccfb", + "evidence/logs/audit-contract.log": "b047e505755d0b340269037caac721ce5e71f6eafc66e962e789550da45276ac", + "evidence/logs/export.log": "6c647e3d28cf94ce9f8b9fdcfc5c10797c18d488d74fe09b8de8671dfd7ae107", + "evidence/logs/hosted-bit.log": "0f4134e600e0f195c6630a3f4ec2f3253d2bc7cf1fd83bbf5d4361d52aeff898", + "evidence/logs/kernel.log": "3f693dcbe49585d9ce689315e42a81cc7e4a4e45f0990c938217fb43c5150f28", + "evidence/logs/parent-audit.log": "5a7c716a9e694de91720026d7cb50b9860c4047d13e2bc57e4100713f419b980", + "evidence/logs/parent-global.log": "a6c2f8b5bbb809334d51bb5a5df813ac02a90091e94a159d0f149c7d29d39b88", + "evidence/logs/source-spans.log": "bdf95dbce8337be57aab8a3d3b42a711ee276496c40cbb4c5356fc9cc9b2e811", + "hosting-audit.patch": "1bda89c7ea54534e7240b9fccd2a349f4d63ef6f8c7055283cd255495f092e18", + "inputs/AUDIT-CONTRACT.json": "c1ef35445c1cfdf61192484ca66ecb4cc1aaec88ea4451cdae6886097e58ec39", + "inputs/HOSTED-GLOBAL.json": "3b0bb426ea6dcb942cc2007c21a49f6ac89ce5e08a07b6ac47039e4da445b1a8", + "inputs/KERNEL.json": "a1c446b6c83db2391284da5eab5028207c692508439fcfa56a1b30b6a400fc8d", + "inputs/PARENT-AUDIT.json": "dc88232628c407d66421ff604b78e32cc6984ca2c94c058506f8c0dd41cb4447", + "inputs/PARENT-GLOBAL.json": "85b5a3108ddd6964d0391e98ae2c0274f3eca090ecd1882239f30998b6fedd07", + "inputs/frames.json.gz": "ff0c8e37c8dc91cd446b3ebcc7a52feaaad8ccaa3842739ee176ee67a467def6", + "inputs/hosted.json.gz": "39456843593dc113bbffab19a7054612c8f78c10d379f13f526be4830b85f67e", + "inputs/parent.json.gz": "ca3f454af68c8a03ad9cb0a5a43e2da95cffd98fd77062a67eb43a49380c2fa3", + "inputs/states.json.gz": "981a5d53440bd13e28c922b40c70fdd06406c2a62ecc3869ee186934d5c8f841", + "inputs/widths.json": "6da7db63adbfcc0fed92961e4e8dbb33da5c099c2b195496a7e1dffdb78d86e6", + "schedule_guard.py": "40508e189ae06754b2568aa5d405cfb56a7b4138edf7c5d07d96d9dca505c77e", + "test_schedule_guard.py": "e05381b5cf68e120904f1aa8fdd50995997b6c7d2689aabec0f996b1e3478c50", + "upstream/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "upstream/PARENT-GLOBAL.json": "16c4e829eea1b2d12b70cec7e6a9c0e33ea0eae98a40894a3b779790fd2efbb3", + "vendor/NOTICE.md": "027a868628d0408602dbeae688b031ed9b4abfd6e5401f6e8106a3eb25ebc4ca", + "vendor/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "verify.py": "d2adc0bfa2534963bbc8727351018ea921f3b55c219c0e977db72e5cfd9178e0" + } +} diff --git a/research/e8-hosted-bit-contract/NOTICE.md b/research/e8-hosted-bit-contract/NOTICE.md new file mode 100644 index 0000000000..e2843eb450 --- /dev/null +++ b/research/e8-hosted-bit-contract/NOTICE.md @@ -0,0 +1,3 @@ +Parent-contract guard, focused regressions, proof and evidence integration by George Lydakis, with OpenAI Codex assistance including Ody. Apache-2.0. + +The original idle-axis-hosting construction and audit are retained without modification and remain credited as in vendor/NOTICE.md. Original upstream parent/kernel/exporter contributors retain their notices and source attribution. This contribution adds verification of the unchanged parent contract; it claims neither the hosting method nor its numerical result. diff --git a/research/e8-hosted-bit-contract/PROOF.md b/research/e8-hosted-bit-contract/PROOF.md new file mode 100644 index 0000000000..fba5501023 --- /dev/null +++ b/research/e8-hosted-bit-contract/PROOF.md @@ -0,0 +1,39 @@ +# The inherited contract and the gap + +Idle-axis hosting moves helper residual ownership from banks to pending idle +coordinates. Its proof relies on the parent invocation order, bridge actions, +level progression, terminal exchange and local programs remaining unchanged. +The added hosting audit rederives windows from the supplied schedule. That +checks placements relative to that schedule, but does not establish that the +schedule is the admitted parent's schedule. + +Two concrete regressions expose the distinction. Deleting the terminal +exchange changes no paid local call or idle rank. Changing a bridge coefficient +to zero changes neither a hosting window's recorded pair touches nor its paid +profile. Thus the original hosting audit accepts these changes. Literal F2 +replay of the eight scalar data columns rejects both. The actual pinned +generator makes neither change. + +The guard requires the hosted bit schedule to equal the parent's schedule +after removing only the enumerated `idx` field from idle entries. It preserves +all other keys, coefficients and order. JSON comparisons preserve numeric types +as well as values. Invocation lists must retain their count, order and every +non-owner field, including stage, replica, pair, orientation and local hash. +All other template fields are equal except the explicitly allowed version, +live count, helper-route description and hosting metadata. The unchanged +ownership audit remains responsible for the new owners, live count, hosted +slots, remainders and paid profile. + +The guard also replays the parent scalar schedule and its levels independently. +Every local stage starts at its required level; every bridge joins equally +advanced pairs with a coefficient of +1 or -1; idle ranks match their original +level increments; the terminal exchange occurs once, last, after all pairs +reach level eight. The resulting eight F2 columns equal the identity. Exact +parent binding additionally preserves the bridge signs, which F2 replay alone +cannot distinguish. A matching malformed parent/child pair is therefore not +accepted merely because their schedules compare equal. + +Under the independently admitted parent and the original hosting-ownership +premises, these checks enforce the unchanged scalar and schedule premises used +by the hosting proof. They do not prove the inherited all-size compiler, +correlated dirty-bank, precision, or analytic interfaces. diff --git a/research/e8-hosted-bit-contract/README.md b/research/e8-hosted-bit-contract/README.md new file mode 100644 index 0000000000..507999d3bd --- /dev/null +++ b/research/e8-hosted-bit-contract/README.md @@ -0,0 +1,72 @@ +# Preserve the parent contract in the hosted bit audit + +This package adds a guard for the bit-side idle-axis-hosting audit from +[PR442](https://github.com/CrocSwap/integer-mult-bounds/pull/442), pinned at +`4e16d001d505d4f21dd2bcfc44591f9be4c279bd`. + +The original generator preserves the parent scalar schedule. Its independent +hosting audit checks ownership and paid profiles but does not enforce that +schedule preservation. Removing the terminal exchange or zeroing a bridge +coefficient leaves its reported paid profile unchanged and is accepted by the +original audit, although the scalar program is incorrect. + +`require_hosted_bit_contract(hosted, parent)` closes this verification gap. It +checks all eight scalar columns, legal level progression, nine local stages, +nine bridges, and the terminal exchange. It then requires exact preservation +of the parent schedule, invocation headers and inherited template fields. +Only the added, consecutive idle indices and the generator's documented +hosting fields are allowed to differ. In particular, the guard does not strip +unknown metadata or ignore changed bridge signs. + +Use the guard before the existing ownership/profile audit: + +```python +from schedule_guard import require_hosted_bit_contract +require_hosted_bit_contract(hosted, parent) +profile, hosted_count = audit_bit(hosted, parent, widths) +``` + +`hosting-audit.patch` supplies this integration against the pinned original +`audit.py`; place `schedule_guard.py` beside that file. The standalone check +also accepts plain JSON or gzip input: + +```sh +python3 -B schedule_guard.py parent.json.gz hosted.json.gz +python3 -B verify.py +``` + +The parent must be source-bound and independently admitted. The new guard +supplements the ownership, hosting-window, paid-profile and finite-invoice +checks. It does not replace them. This package covers the bit template only; +the complex generator has different permitted schedule edits. + +This is a verification improvement. The demonstrated mutations are deliberate +regressions, not the actual published construction. No invalidity of PR442's +bound, new exponent, or new hosting method is claimed. The original numerical +result retains its conditional supplier and analytic assumptions. + +## Validation and evidence + +The positive fixture is the actual PR442 bit template, payload SHA256 +`dd7833dcaff8c84b258847f4c4d65b6402c702700ae37d2c464083ee37b24126`, +matching the immutable upstream EXPECTED.json. Its parent template also matches +the committed parent receipt. A seven-stage, 4.43-second reconstruction reused +an exact previously verified reset word, then ran the original 110-entry +kernel, exporter, integer source-span checker, global emitter, parent audit, +and frozen bit hosting generator. The parent kernel's three controls and its +audit's eight controls passed. No complex, phase, pricing or assembly run was +performed; this is fixture reconstruction, not a new bound admission. + +On that authentic hosted output, the original audit accepts both regressions +with the same profile and 39,568 hosted residuals. Scalar replay finds eight +wrong columns after exchange removal and three after zeroing the bridge. +The new guard accepts the intact output and rejects both, plus changes to +bridge signs, levels, invocation headers, idle indices and inherited fields. + +The offline verifier checks the exact source/Git bindings, upstream payload +hashes, completion and stage-log bindings, retained dependency reuse, and all +four focused test contracts. It executes the proposed integration patch in +memory against the original audit and checks its positive and negative cases. +`evidence/adapter` retains the executed driver's original temporary paths and +source hash inventory, not a portable reconstruction CLI. The guard, patch and +offline verifier are portable and require only Python's standard library. diff --git a/research/e8-hosted-bit-contract/SOURCES.json b/research/e8-hosted-bit-contract/SOURCES.json new file mode 100644 index 0000000000..f223336fbf --- /dev/null +++ b/research/e8-hosted-bit-contract/SOURCES.json @@ -0,0 +1,36 @@ +{ + "repository": "DaysSky/integer-mult-bounds", + "commit": "4e16d001d505d4f21dd2bcfc44591f9be4c279bd", + "files": [ + { + "path": "vendor/audit.py", + "upstream_path": "research/idle-axis-hosting/audit.py", + "sha256": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "git_blob": "bd40b9b7914deeced02d5364162060d8130ab08e" + }, + { + "path": "vendor/NOTICE.md", + "upstream_path": "research/idle-axis-hosting/NOTICE.md", + "sha256": "027a868628d0408602dbeae688b031ed9b4abfd6e5401f6e8106a3eb25ebc4ca", + "git_blob": "391e865e06f77efa9ec0aa3ee9c048673b1f24ab" + }, + { + "path": "LICENSE", + "upstream_path": "research/idle-axis-hosting/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "upstream/EXPECTED.json", + "upstream_path": "research/idle-axis-hosting/EXPECTED.json", + "sha256": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "git_blob": "1b0811df29bc2eabdabb51219e9b2382da9a48f6" + }, + { + "path": "upstream/PARENT-GLOBAL.json", + "upstream_path": "research/e8-early-reset-kernel/local-evidence/GLOBAL.json", + "sha256": "16c4e829eea1b2d12b70cec7e6a9c0e33ea0eae98a40894a3b779790fd2efbb3", + "git_blob": "9d69b480fb0e58d21a83c208d8337d682ff4d5fb" + } + ] +} diff --git a/research/e8-hosted-bit-contract/evidence/COMPLETION.json b/research/e8-hosted-bit-contract/evidence/COMPLETION.json new file mode 100644 index 0000000000..db6b9b5061 --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/COMPLETION.json @@ -0,0 +1,142 @@ +{ + "status": "PASS_MINIMAL_ACTUAL442_BIT_FIXTURE", + "source_before": { + "SOURCE-PINS.json": "889ea5b1ba7eff1e1a95a6fdc22a5d639ff0dd73243fbed25b6db69957b03f62", + "audit_stage.py": "a835f61104894e16efff5c64eafcd61f2cf4f8c71d4c53fa0442e87470e2ec36", + "MANIFEST.json": "62b5ca8458735e867524e3fe97e619aa6a08a35063a966cc0e03d8cb8e469b28", + "driver.py": "a9726a9841de1beb1eb4b39ae5b03c56b040bd1a8aaf317666e5df05bd3cccfb", + "source/research/idle-axis-hosting/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "source/research/idle-axis-hosting/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "source/research/idle-axis-hosting/bit_hosted.py": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "source/research/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "source/research/idle-axis-hosting/MANIFEST.json": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "source/research/idle-axis-hosting/SELECTION.json": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "source/research/e8-early-reset-kernel/bit_global.py": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "source/research/e8-early-reset-kernel/bit_audit.py": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "source/research/e8-early-reset-kernel/MANIFEST.json": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "source/research/e8-early-reset-kernel/SELECTION.json": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "source/research/e8-early-reset-kernel/source_span.py": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "source/research/e8-early-reset-kernel/apply.py": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "source/research/e8-early-reset-kernel/vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "source/research/split-centres-global/vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + "source_after": { + "SOURCE-PINS.json": "889ea5b1ba7eff1e1a95a6fdc22a5d639ff0dd73243fbed25b6db69957b03f62", + "audit_stage.py": "a835f61104894e16efff5c64eafcd61f2cf4f8c71d4c53fa0442e87470e2ec36", + "MANIFEST.json": "62b5ca8458735e867524e3fe97e619aa6a08a35063a966cc0e03d8cb8e469b28", + "driver.py": "a9726a9841de1beb1eb4b39ae5b03c56b040bd1a8aaf317666e5df05bd3cccfb", + "source/research/idle-axis-hosting/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "source/research/idle-axis-hosting/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "source/research/idle-axis-hosting/bit_hosted.py": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "source/research/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "source/research/idle-axis-hosting/MANIFEST.json": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "source/research/idle-axis-hosting/SELECTION.json": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "source/research/e8-early-reset-kernel/bit_global.py": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "source/research/e8-early-reset-kernel/bit_audit.py": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "source/research/e8-early-reset-kernel/MANIFEST.json": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "source/research/e8-early-reset-kernel/SELECTION.json": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "source/research/e8-early-reset-kernel/source_span.py": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "source/research/e8-early-reset-kernel/apply.py": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "source/research/e8-early-reset-kernel/vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "source/research/split-centres-global/vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + "inputs_before": { + "completion": "a7a2efeef20ba6b8fa381b19bd6bd83745bdca4b2ba255de5caa863ff74eec30", + "bit426-source-centres/bit-source-centres-prekernel.json": "98ffef9246c8bf6c537ab5e134321abea05cf0b7830c9e3fd92cbe4e88d8c308", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "inputs_after": { + "completion": "a7a2efeef20ba6b8fa381b19bd6bd83745bdca4b2ba255de5caa863ff74eec30", + "bit426-source-centres/bit-source-centres-prekernel.json": "98ffef9246c8bf6c537ab5e134321abea05cf0b7830c9e3fd92cbe4e88d8c308", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "steps": [ + { + "name": "kernel", + "returncode": 0, + "log_sha256": "3f693dcbe49585d9ce689315e42a81cc7e4a4e45f0990c938217fb43c5150f28" + }, + { + "name": "export", + "returncode": 0, + "log_sha256": "6c647e3d28cf94ce9f8b9fdcfc5c10797c18d488d74fe09b8de8671dfd7ae107" + }, + { + "name": "source-spans", + "returncode": 0, + "log_sha256": "bdf95dbce8337be57aab8a3d3b42a711ee276496c40cbb4c5356fc9cc9b2e811" + }, + { + "name": "parent-global", + "returncode": 0, + "log_sha256": "a6c2f8b5bbb809334d51bb5a5df813ac02a90091e94a159d0f149c7d29d39b88" + }, + { + "name": "parent-audit", + "returncode": 0, + "log_sha256": "5a7c716a9e694de91720026d7cb50b9860c4047d13e2bc57e4100713f419b980" + }, + { + "name": "hosted-bit", + "returncode": 0, + "log_sha256": "0f4134e600e0f195c6630a3f4ec2f3253d2bc7cf1fd83bbf5d4361d52aeff898" + }, + { + "name": "audit-contract", + "returncode": 0, + "log_sha256": "b047e505755d0b340269037caac721ce5e71f6eafc66e962e789550da45276ac" + } + ], + "wall_seconds": 4.431400874978863, + "child_usage": [ + 4.306425, + 0.08592, + 156090368, + 0, + 0, + 0, + 43248, + 355, + 0, + 0, + 0, + 0, + 0, + 0, + 25, + 2497 + ], + "output_hashes": { + "parent-global.log": "a6c2f8b5bbb809334d51bb5a5df813ac02a90091e94a159d0f149c7d29d39b88", + "AUDIT-CONTRACT.json": "c1ef35445c1cfdf61192484ca66ecb4cc1aaec88ea4451cdae6886097e58ec39", + "source-spans.log": "bdf95dbce8337be57aab8a3d3b42a711ee276496c40cbb4c5356fc9cc9b2e811", + "audit-contract.log": "b047e505755d0b340269037caac721ce5e71f6eafc66e962e789550da45276ac", + "kernel.log": "3f693dcbe49585d9ce689315e42a81cc7e4a4e45f0990c938217fb43c5150f28", + "reset-input.json": "98ffef9246c8bf6c537ab5e134321abea05cf0b7830c9e3fd92cbe4e88d8c308", + "parent-audit.log": "5a7c716a9e694de91720026d7cb50b9860c4047d13e2bc57e4100713f419b980", + "hosted-bit.log": "0f4134e600e0f195c6630a3f4ec2f3253d2bc7cf1fd83bbf5d4361d52aeff898", + "export.log": "6c647e3d28cf94ce9f8b9fdcfc5c10797c18d488d74fe09b8de8671dfd7ae107", + "hosted/GLOBAL-TEMPLATE.json.gz": "39456843593dc113bbffab19a7054612c8f78c10d379f13f526be4830b85f67e", + "hosted/GLOBAL.json": "3b0bb426ea6dcb942cc2007c21a49f6ac89ce5e08a07b6ac47039e4da445b1a8", + "parent/bit426-source-centres/bit-source-centres.json": "da4aa797d6dad909fd1faaa90abea749b026299ac8cad3ad0a4a248e16bdb5f5", + "parent/bit426-source-centres/bit-kernel-receipt.json": "a1c446b6c83db2391284da5eab5028207c692508439fcfa56a1b30b6a400fc8d", + "parent/inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "parent/work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "parent/bit426-source-centres/records/249-records.bin": "99cb283793818ad03f8f16f95a8eb23d0b18769d0657d58043fb7a427471c35d", + "parent/bit426-source-centres/records/249-states.json": "40c063fd3d7b63c735f762097e692b5c36f618c60e8ed257de9e5f92be11b48e", + "parent/bit426-source-centres/records/frames.json": "884480e45865a9d9d57f5f7198844a64271b046bc95e9820efbefb9e10878330", + "parent/bit426-source-centres/global/GEOMETRY.json": "fc7b29b16ee754ca9717973b745d6322bbf8351a5e35e3fc9e0fbf7a88dc0317", + "parent/bit426-source-centres/global/AUDIT.json": "dc88232628c407d66421ff604b78e32cc6984ca2c94c058506f8c0dd41cb4447", + "parent/bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz": "ca3f454af68c8a03ad9cb0a5a43e2da95cffd98fd77062a67eb43a49380c2fa3", + "parent/bit426-source-centres/global/GLOBAL.json": "85b5a3108ddd6964d0391e98ae2c0274f3eca090ecd1882239f30998b6fedd07" + }, + "scope": "Bit-only deterministic fixture and2auditcontract regressions. Reused completed438 exact resetinput; no full parent/complex/phase/price/assembly replay, no numericalbound admission" +} diff --git a/research/e8-hosted-bit-contract/evidence/RECEIPT-MAP.json b/research/e8-hosted-bit-contract/evidence/RECEIPT-MAP.json new file mode 100644 index 0000000000..2d2c74829b --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/RECEIPT-MAP.json @@ -0,0 +1,11 @@ +{ + "parent.json.gz": "parent/bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz", + "hosted.json.gz": "hosted/GLOBAL-TEMPLATE.json.gz", + "PARENT-GLOBAL.json": "parent/bit426-source-centres/global/GLOBAL.json", + "PARENT-AUDIT.json": "parent/bit426-source-centres/global/AUDIT.json", + "HOSTED-GLOBAL.json": "hosted/GLOBAL.json", + "KERNEL.json": "parent/bit426-source-centres/bit-kernel-receipt.json", + "frames.json.gz": "parent/bit426-source-centres/records/frames.json", + "states.json.gz": "parent/bit426-source-centres/records/249-states.json", + "AUDIT-CONTRACT.json": "AUDIT-CONTRACT.json" +} diff --git a/research/e8-hosted-bit-contract/evidence/REUSED-COMPLETION.json b/research/e8-hosted-bit-contract/evidence/REUSED-COMPLETION.json new file mode 100644 index 0000000000..4a0c145607 --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/REUSED-COMPLETION.json @@ -0,0 +1,268 @@ +{ + "status": "PASS_CHANGED_PR438_BIT_FINITE_CHECK", + "scope": "Post-kernel port of published basis method; independently completed PR433 complex evidence reused; no new exponent or runtime claim", + "source_before": { + "SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "PROOF.md": "0f482e06aeda510e08055848bc2b68d30c93ed1722b9ed5e7613f96cf6346dde", + "EXPECTED.json": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "aebe7e50b25e43818f844886ae01c08c712b5453604fccac393631592fe9d0d2", + "CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "VALIDATION.json": "4957420a5a988e045537e31f79da7f8d35592185d45802c0ff4adfd0d97a772e", + ".gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "MANIFEST.json": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "verify.py": "46ed1039f35480fef612d54f12fd874e2266c0ce3baab692603886bc7aa4c58b", + "NOTICE.md": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "stages/kernel-selection.json": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "code/bit_reset.py": "000983f6c09ba3baa90cdee69a03464680b6963cfd4f8f7b9301d4e0e6acd6f5", + "code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "code/bit_global.py": "b3a486487e223ef0e2b4fd212063c1506740ba18765e99878e07d06968877eca", + "code/bit_kernel.py": "14f164fcc0674f73163808a9d9762eb439ea130895f593cb78a6cafaed2dfb11", + "code/bit_audit.py": "b2b4b792f14ac9946bdcd1bf4c0d47c46fe05ff6ff9c5f0317037c9a1ee1e5fe", + "code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "code/complex_phases.py": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "code/combined.py": "825c32a81529da35a347666468585c69d66c0ee161717f2994769782fb57e29e", + "code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inputs/complex-phase-receipt.json": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/pr434/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr434/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/pr434/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "source_after": { + "SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "PROOF.md": "0f482e06aeda510e08055848bc2b68d30c93ed1722b9ed5e7613f96cf6346dde", + "EXPECTED.json": "1563715b7b1ba846ec9dfabf6badd61913269fc84dfb349299a73d530aaac4a9", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "aebe7e50b25e43818f844886ae01c08c712b5453604fccac393631592fe9d0d2", + "CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "VALIDATION.json": "4957420a5a988e045537e31f79da7f8d35592185d45802c0ff4adfd0d97a772e", + ".gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "MANIFEST.json": "8901e14e3d39c218b568e645938b7c9269a723d2978f88c031c1e6dab46475ba", + "verify.py": "46ed1039f35480fef612d54f12fd874e2266c0ce3baab692603886bc7aa4c58b", + "NOTICE.md": "36c3eedbed8c4d3201cb8045615baf9a42a8ccc9ed346e0439857fe1fedebad3", + "stages/kernel-selection.json": "4db07350804923c5c2bdb0aadb5dd4366f55b0e349dccad96d69a09feac9ad9e", + "proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "code/bit_reset.py": "000983f6c09ba3baa90cdee69a03464680b6963cfd4f8f7b9301d4e0e6acd6f5", + "code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "code/bit_global.py": "b3a486487e223ef0e2b4fd212063c1506740ba18765e99878e07d06968877eca", + "code/bit_kernel.py": "14f164fcc0674f73163808a9d9762eb439ea130895f593cb78a6cafaed2dfb11", + "code/bit_audit.py": "b2b4b792f14ac9946bdcd1bf4c0d47c46fe05ff6ff9c5f0317037c9a1ee1e5fe", + "code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "code/complex_phases.py": "3e2a52198475ee280a314895ab74df8437e3c0de0cad2d90baa370aa2a52c364", + "code/combined.py": "825c32a81529da35a347666468585c69d66c0ee161717f2994769782fb57e29e", + "code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "inputs/complex-phase-receipt.json": "b7e9de8137ed1de3e72a94c3a11525a8ff3770c914a43e3c3b82fd5d75264b32", + "inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/pr434/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr434/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/pr434/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "adapter_manifest_sha256": "e7f88237f8b0e6bd1051ad49738e60d47fc05beef11ed0af2f1ed5befaf63595", + "inputs_before": { + "completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "reuse_binding": "ed3c550dd9bc30512accc35facbe3100021ca3fe7fe04513c94528498eed4561", + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd" + }, + "inputs_after": { + "completion": "722690f12ea5bc47effc78ad5f0e3c155344bba513718d2d99f5ffb4e145b321", + "reuse_binding": "ed3c550dd9bc30512accc35facbe3100021ca3fe7fe04513c94528498eed4561", + "run/split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "run/split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "run/split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "run/split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "run/split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "run/split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "run/split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "run/split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "run/split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "run/split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "run/split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd" + }, + "steps": [ + { + "name": "bit_construct", + "returncode": 0, + "log_sha256": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933" + }, + { + "name": "bit_reset", + "returncode": 0, + "log_sha256": "ac3ff67b486202e46a577d5c867fdce6992e93e47415346c95c4d669b1972b61" + }, + { + "name": "bit_kernel", + "returncode": 0, + "log_sha256": "c65c7919e2fef533fa828dabd1397bd5844b183aa49b9a88bbec8ad95fdaa040" + }, + { + "name": "post_basis", + "returncode": 0, + "log_sha256": "526515d93fd8afc8dd475042350601a7ebfcac729ca0b7795972b60378fdf4c3" + }, + { + "name": "export", + "returncode": 0, + "log_sha256": "e57459c15c39fddf647f68eca16a169896a0e946bd495db1d4a9ad11472fc92a" + }, + { + "name": "global", + "returncode": 0, + "log_sha256": "ac3f7c1e017a29fe0d5a69766d0d53345303c273c84f5ee5539dd7261a0e55fe" + }, + { + "name": "audit", + "returncode": 0, + "log_sha256": "7f1b9d5c24e7340d0972cb1cf5ed23ee1a25ea4e3494d8baab96004c173b8baa" + }, + { + "name": "price", + "returncode": 0, + "log_sha256": "98d0243f63083c3904760bb64b266759447a118ec4fbf35bd7ce27ce2811f244" + }, + { + "name": "combined", + "returncode": 0, + "log_sha256": "d63bfdf50707d012ee26e29fed7be296d20943ec22e65107e5eb61228c5f2a7a" + } + ], + "wall_seconds": 18.487286624964327, + "child_usage": [ + 18.227092, + 0.14591099999999999, + 146374656, + 0, + 0, + 0, + 40749, + 539, + 0, + 0, + 0, + 0, + 0, + 0, + 66, + 9574 + ], + "output_hashes": { + "post_basis.log": "526515d93fd8afc8dd475042350601a7ebfcac729ca0b7795972b60378fdf4c3", + "RESULT.json": "fcdb458e99cd75afd6c4def70fa4dfc603239278e74a784b9658a66e81917d01", + "price.log": "98d0243f63083c3904760bb64b266759447a118ec4fbf35bd7ce27ce2811f244", + "bit_kernel.log": "c65c7919e2fef533fa828dabd1397bd5844b183aa49b9a88bbec8ad95fdaa040", + "FINITE-COMPARISON.json": "a982badcaa34737018dbf6aaafa79e8c94d32ff4b22cfad01dfdc412f95c509c", + "audit.log": "7f1b9d5c24e7340d0972cb1cf5ed23ee1a25ea4e3494d8baab96004c173b8baa", + "export.log": "e57459c15c39fddf647f68eca16a169896a0e946bd495db1d4a9ad11472fc92a", + "combined.log": "d63bfdf50707d012ee26e29fed7be296d20943ec22e65107e5eb61228c5f2a7a", + "bit_construct.log": "9077796f449db32a77c66375ee579c9a55bfe740b5dcb757cf9b21be37250933", + "BIT-PRICE.json": "daf68676e1b1734c47f8b41bdce0b6a27df28ad0149b98c5dfffb19ae1a8b35c", + "global.log": "ac3f7c1e017a29fe0d5a69766d0d53345303c273c84f5ee5539dd7261a0e55fe", + "bit_reset.log": "ac3ff67b486202e46a577d5c867fdce6992e93e47415346c95c4d669b1972b61", + "split-centres/CANONICAL-WORD.json.gz": "79ff8e19335d5d5d1563ef0bc218106945d6a2b88ece53ee24bb3d88b2594ba3", + "split-centres/FULL-DISCOVERY.json": "ea19af4453ffb1bc9bf33b9c32eef61d7fff652809beaeb77b786ec550f231a9", + "split-centres/LOCAL-PROGRAMS.json.gz": "65829d265c3ad5955263301b5be23114fec562aa7847d58658df873205aba37e", + "split-centres/LOCAL-CHECKS.json": "c12c15e92ff3ed47be2c293930fda6a5ff69258fa09b19de3cf8e0067b1ceb7d", + "split-centres/CLIFFORD-REVIEW.json": "7a8b21e342680964005d0caff529b133fa4915b97fbca0969b8f28e0da670bf2", + "split-centres/INDEPENDENT-REPLAY.json": "26c16787d76af2f1f354af7f599cda2b1b1ec285eabf500d7aafb3e4f4782c29", + "split-centres/CLIFFORD-RECIPES.json": "242fe77af077973e1933524fe5c7ff3b68bef14b1f6938e024827de78d954492", + "split-centres/GLOBAL-TEMPLATE.json.gz": "a761d07a741a482ad0d2af725fa5298146635a3a2fae69e554bf0565d55d26c6", + "split-centres/INTEGRATION.json": "6666a978604459e235b6081d7ec596537f0b452a0be6963082647730cbe0de14", + "split-centres/FULL-WORD.json.gz": "6d311e5832c1bf86351dd9204971b99b61c0c556bd95d11b0b4b3d15426bab9a", + "split-centres/SCALAR-FRAME-AUDIT.json": "b95a94656aaadde629004fbb2825d8426411edaecd477e160d7c9e8ca6b3b0bd", + "bit426-source-centres/BASIS-STAGE.json": "2e0600bc3be25502b2fbc8114cbcbb4e0d5b23b8665d663aaeaa74f47bfb2e8a", + "bit426-source-centres/bit-input.json": "7a395dd0452b0832f7ffce7148589eafc627b8cf0349a81803fd897e7a24a388", + "bit426-source-centres/bit-source-centres-receipt.json": "cfcc6b56da99ffefcd38175542e924ab64bb4132749aaa67f9395481dfd0a88f", + "bit426-source-centres/bit-source-centres-r758.json": "015811014644ed62acba1da590d9cf6ebdfe834d89867f8ce2b68722609072ea", + "bit426-source-centres/bit-source-centres.json": "2be5d42a53e367648f4dd33fd4a368c61e1565f0cf7c48bfe887ca953a735063", + "bit426-source-centres/bit-source-centres-prekernel.json": "98ffef9246c8bf6c537ab5e134321abea05cf0b7830c9e3fd92cbe4e88d8c308", + "bit426-source-centres/bit-kernel-receipt.json": "3eeb80d1bf47f8902a936b11351a636e2021aabf0852a1f2242122c4c3bdb5f8", + "bit426-source-centres/bit-source-centres-postkernel-original.json": "cc6242d90ccdd8477521ea16f35ee2667dbe6c48cc60c6e4e9bcf6460497b233", + "inherited/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "work/pr370-source/research/e8-bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "bit426-source-centres/records/249-records.bin": "a0fd597c8cc0edd639d463f886be5e7984133ae16cf36f73c43aec2ec965c535", + "bit426-source-centres/records/249-states.json": "8973ac9cd6cec93f0adfe06e98da925f35ce4d6a3fffa25581ff4a56a50f38ef", + "bit426-source-centres/records/frames.json": "884480e45865a9d9d57f5f7198844a64271b046bc95e9820efbefb9e10878330", + "bit426-source-centres/global/GEOMETRY.json": "e063503254229545578cf12d53eefbf990129d9335af05c680194d35408a959b", + "bit426-source-centres/global/AUDIT.json": "d5d2a4167c5ef479723f588820cd24316cca6bacb0f3a99e03909335e610c426", + "bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz": "c557653592de641a6cdb22f5ad5b3adb5b00fbff4905b7487e4be6767fd18dbd", + "bit426-source-centres/global/GLOBAL.json": "b1f44877c67842c3a804590c9c691c500aaa74c4484ddfb32f273b9c82922c9e" + } +} diff --git a/research/e8-hosted-bit-contract/evidence/adapter/MANIFEST.json b/research/e8-hosted-bit-contract/evidence/adapter/MANIFEST.json new file mode 100644 index 0000000000..480a672b31 --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/adapter/MANIFEST.json @@ -0,0 +1,24 @@ +{ + "files": { + "SOURCE-PINS.json": "889ea5b1ba7eff1e1a95a6fdc22a5d639ff0dd73243fbed25b6db69957b03f62", + "audit_stage.py": "a835f61104894e16efff5c64eafcd61f2cf4f8c71d4c53fa0442e87470e2ec36", + "driver.py": "a9726a9841de1beb1eb4b39ae5b03c56b040bd1a8aaf317666e5df05bd3cccfb", + "source/research/idle-axis-hosting/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "source/research/idle-axis-hosting/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "source/research/idle-axis-hosting/bit_hosted.py": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "source/research/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "source/research/idle-axis-hosting/MANIFEST.json": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "source/research/idle-axis-hosting/SELECTION.json": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "source/research/e8-early-reset-kernel/bit_global.py": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "source/research/e8-early-reset-kernel/bit_audit.py": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "source/research/e8-early-reset-kernel/MANIFEST.json": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "source/research/e8-early-reset-kernel/SELECTION.json": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "source/research/e8-early-reset-kernel/source_span.py": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "source/research/e8-early-reset-kernel/apply.py": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "source/research/e8-early-reset-kernel/vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "source/research/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "source/research/split-centres-global/vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + } +} diff --git a/research/e8-hosted-bit-contract/evidence/adapter/SOURCE-PINS.json b/research/e8-hosted-bit-contract/evidence/adapter/SOURCE-PINS.json new file mode 100644 index 0000000000..ac4524015f --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/adapter/SOURCE-PINS.json @@ -0,0 +1,74 @@ +{ + "head": "4e16d001d505d4f21dd2bcfc44591f9be4c279bd", + "files": { + "research/e8-early-reset-kernel/apply.py": { + "sha256": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "git_blob": "f87dfda4b5fe6db6adc095858f994de17f6e6e41" + }, + "research/e8-early-reset-kernel/bit_global.py": { + "sha256": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "git_blob": "f6fb51535b53988d106f0883872b26fc249efd8d" + }, + "research/e8-early-reset-kernel/source_span.py": { + "sha256": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "git_blob": "a8722a7e4f20d109733ec12788925cf645ed7c9a" + }, + "research/e8-early-reset-kernel/MANIFEST.json": { + "sha256": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "git_blob": "c96c75aa928576fef69f9db7298fbc99eace68cc" + }, + "research/e8-early-reset-kernel/SELECTION.json": { + "sha256": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "git_blob": "fff02ebc1ec7814e2df0ffab2c3a5e5ee6394614" + }, + "research/e8-early-reset-kernel/vendor/kernel417/e8core.py": { + "sha256": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "git_blob": "f2874bae8ef044240211fd892afb457d13759c74" + }, + "research/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": { + "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd" + }, + "research/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": { + "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61" + }, + "research/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": { + "sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "git_blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2" + }, + "research/idle-axis-hosting/bit_hosted.py": { + "sha256": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "git_blob": "e2f015dbb78a95c121e187b3c20e0f8d59b60586" + }, + "research/idle-axis-hosting/hosting_core.py": { + "sha256": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "git_blob": "68b536daa9e6546c0aa046934bf840aaa3c3fde3" + }, + "research/idle-axis-hosting/audit.py": { + "sha256": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "git_blob": "bd40b9b7914deeced02d5364162060d8130ab08e" + }, + "research/idle-axis-hosting/SELECTION.json": { + "sha256": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "git_blob": "e3303cd97d132e66145d2fb7e957fd6e5808dd80" + }, + "research/idle-axis-hosting/EXPECTED.json": { + "sha256": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "git_blob": "1b0811df29bc2eabdabb51219e9b2382da9a48f6" + }, + "research/idle-axis-hosting/MANIFEST.json": { + "sha256": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "git_blob": "542ee2f988de429e8fd94c9940a17c35ec65b16d" + }, + "research/split-centres-global/vendor/export_records.py": { + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350" + }, + "research/e8-early-reset-kernel/bit_audit.py": { + "sha256": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "git_blob": "0b71a86132f04b421c8b021bcb866d2a1b89036f" + } + }, + "scope": "Minimal original source dependency closure, partial supplier packages, no scientific bytes edited" +} diff --git a/research/e8-hosted-bit-contract/evidence/adapter/audit_stage.py b/research/e8-hosted-bit-contract/evidence/adapter/audit_stage.py new file mode 100644 index 0000000000..c1135f24cf --- /dev/null +++ b/research/e8-hosted-bit-contract/evidence/adapter/audit_stage.py @@ -0,0 +1,25 @@ +from pathlib import Path +import os,sys,json,gzip,hashlib,copy,importlib.util +O=Path(os.environ['FIXTURE_OUTPUT']);S=Path(__file__).resolve().parent/'source/research/idle-axis-hosting';B=O/'parent/bit426-source-centres';H=O/'hosted' +read=lambda p:json.loads(p.read_bytes());parent=json.loads(gzip.decompress((B/'global/GLOBAL-TEMPLATE.json.gz').read_bytes()));t=json.loads(gzip.decompress((H/'GLOBAL-TEMPLATE.json.gz').read_bytes())) +sp=importlib.util.spec_from_file_location('original442audit',S/'audit.py');a=importlib.util.module_from_spec(sp);sp.loader.exec_module(a) +st=read(B/'records/249-states.json');fs=read(B/'records/frames.json')['frames'];width=[8-fs[str(st['initial'][str(i)])]['dim'] for i in range(240,987)] +profile,n=a.audit_bit(t,parent,width);g=read(H/'GLOBAL.json');assert profile=={int(r):z for r,z in g['profile'].items()} and n==g['hosted_residuals']==39568 +assert (g['live'],g['physical'],g['maxchild'])==(9457,9466,8) +def scalar(events): + x=[1< 2 * max(paid) ** 2 + return paid, sum(1 for _ in hosted) * T + +def audit_complex(t, parent_t, local_checks): + R = 560; m = 73 + assert t['local_programs'] == parent_t['local_programs'] and len(t['calls']) == 72 + prank = {} + for it in parent_t['idle_children']: prank.setdefault(it['child'], it['rank']) + stage_pair = {e['stage']: e['pair'] for e in t['recipe'] if e['kind'] == 'local'} + ev = []; side = {}; pairs = {} + for e in t['execution_schedule']: + if e['kind'] == 'local_cover_sweep': ev.append(('local', e['stage'], stage_pair[e['stage']])) + elif e['kind'] == 'bridge': ev.append(('bridge', e['dst'], e['src'])) + elif e['kind'] == 'idle_cover_sweep': + for sd, ch in enumerate(e['child_indices']): + if ch in prank: ev.append(('idle', ch, e['pair'])); side[ch] = sd; pairs[ch] = e['pair'] + W = wins(ev); hs = t['hosting'] + used = defaultdict(set); hosted = {} + for i, port, off, w, s, h in hs['slots']: + assert w == 9 and s in W[i] and 0 <= off and off + 9 <= prank[i] + cells = set(range(off, off + 9)); assert not cells & used[i, port]; used[i, port] |= cells + assert (s, h) not in hosted; hosted[s, h] = (i, port, off) + rem = {} + for it in parent_t['idle_children']: rem[it['child'], it['port']] = it['rank'] - len(used[it['child'], it['port']]) + got = {(it['child'], it['port']): it['rank'] for it in t['idle_children']} + assert got == {k: r for k, r in rem.items() if r} and all(it['replicas'] == T for it in t['idle_children']) + LIVE = t['live']; occ = defaultdict(set) + for c in t['calls']: + s, rep, p = c['stage'], c['replica'], c['pair']; own = c['owners']; assert len(own) == 2 * V + R + assert own[:2 * V] == next(q for q in parent_t['calls'] if (q['stage'], q['replica']) == (s, rep))['owners'][:2 * V] + for h, (f, r) in enumerate(own[2 * V:]): + if (s, h) in hosted: + i, port, off = hosted[s, h] + assert r == [3, i, off] and f == rep * 960 + (2 * pairs[i] + side[i]) * V + port and pairs[i] != p + else: + assert r[0] == 2 and 0 <= r[1] < 8 and DATA <= f < LIVE and r[1] not in occ[f]; occ[f].add(r[1]) + banks = sorted(occ); assert banks == list(range(DATA, LIVE)) + paid = Counter() + for c in t['calls']: + for r_, z in local_checks[c['orientation']]['paid_profile'].items(): paid[int(r_)] += z + for (ch, port), r_ in rem.items(): + if r_: paid[r_] += T + for f in banks: paid[m - 9 * len(occ[f])] += 1 + mass = sum(r * n for r, n in paid.items()); assert m * LIVE - mass == 2496 + assert m * m > 2 * max(paid) ** 2 + return paid, len(hosted) * T + +def main(): + par, bd, cd, outp = map(Path, sys.argv[1:5]) + pbt = json.loads(gzip.decompress((par / 'bit426-source-centres/global/GLOBAL-TEMPLATE.json.gz').read_bytes())) + bt = json.loads(gzip.decompress((bd / 'GLOBAL-TEMPLATE.json.gz').read_bytes())) + bg = json.loads((bd / 'GLOBAL.json').read_text()) + assert hashlib.sha256(gzip.decompress((bd / 'GLOBAL-TEMPLATE.json.gz').read_bytes())).hexdigest() == bg['template_sha256'] + st = json.loads((par / 'bit426-source-centres/records/249-states.json').read_text()) + fs = json.loads((par / 'bit426-source-centres/records/frames.json').read_text())['frames'] + widths = [8 - fs[str(st['initial'][str(i)])]['dim'] for i in range(240, 987)] + pct = json.loads(gzip.decompress((par / 'split-centres/GLOBAL-TEMPLATE.json.gz').read_bytes())) + ct = json.loads(gzip.decompress((cd / 'GLOBAL-TEMPLATE.json.gz').read_bytes())) + ch = json.loads((cd / 'HOSTED.json').read_text()) + assert hashlib.sha256(gzip.decompress((cd / 'GLOBAL-TEMPLATE.json.gz').read_bytes())).hexdigest() == ch['template_sha256'] + lc = json.loads((par / 'split-centres/LOCAL-CHECKS.json').read_text()) + bp, bh = audit_bit(bt, pbt, widths); assert bp == Counter({int(k): v for k, v in bg['profile'].items()}) + cp, chh = audit_complex(ct, pct, lc); assert cp == Counter({int(k): v for k, v in ch['global_profile'].items()}) + controls = [] + def reject(name, fn, which): + q = copy.deepcopy(bt if which == 'bit' else ct); fn(q) + try: + (audit_bit(q, pbt, widths) if which == 'bit' else audit_complex(q, pct, lc)) + except (AssertionError, KeyError, IndexError, StopIteration): controls.append(name) + else: raise AssertionError('mutation accepted: ' + name) + def outside(q): # move one hosted residual to a stage outside its window + sl = q['hosting']['slots'][0]; i = sl[0]; s_bad = next(s for s in range(9) if s not in q['hosting']['windows'][str(i)][2]); sl[4] = s_bad + reject('bit: hosted residual outside its window', outside, 'bit') + reject('bit: overlapping hosted coordinates', lambda q: q['hosting']['slots'][1].__setitem__(2, q['hosting']['slots'][0][2]) if q['hosting']['slots'][1][:2] == q['hosting']['slots'][0][:2] else q['hosting']['slots'][1].__setitem__(1, q['hosting']['slots'][0][1]) or q['hosting']['slots'][1].__setitem__(2, q['hosting']['slots'][0][2]), 'bit') + reject('bit: understated live stock', lambda q: q.__setitem__('live', q['live'] - 1), 'bit') + reject('bit: hosted owner on the active pair', lambda q: q['calls'][0]['owners'].__setitem__(240 + next(h for h in range(747) if q['calls'][0]['owners'][240 + h][1][0] == 'hosted'), [0, ['hosted', 0, 0, 8]]), 'bit') + reject('bit: missing remainder child', lambda q: q['hosting']['slots'].pop(), 'bit') + reject('complex: hosted residual outside its window', lambda q: q['hosting']['slots'][0].__setitem__(4, next(s for s in range(9) if s not in q['hosting']['windows'][str(q['hosting']['slots'][0][0])][2])), 'complex') + reject('complex: remainder child understated', lambda q: q['idle_children'][0].__setitem__('rank', q['idle_children'][0]['rank'] - 1), 'complex') + reject('complex: dropped bank', lambda q: q.__setitem__('live', q['live'] - 1), 'complex') + reject('complex: duplicated hosted residual', lambda q: q['hosting']['slots'].append(list(q['hosting']['slots'][0])), 'complex') + res = dict(status='PASS_INDEPENDENT_IDLE_AXIS_HOSTING_AUDIT', bit_template_sha256=bg['template_sha256'], complex_template_sha256=ch['template_sha256'], + bit_profile={str(k): v for k, v in sorted(bp.items())}, complex_profile={str(k): v for k, v in sorted(cp.items())}, + bit_live=bt['live'], complex_live=ct['live'], bit_hosted_residuals=bh, complex_hosted_residuals=chh, + bit_maxchild=max(bp), complex_maxchild=max(cp), mutations_rejected=controls) + outp.write_text(json.dumps(res, indent=2) + '\n'); print(json.dumps({k: v for k, v in res.items() if 'profile' not in k})) +if __name__ == '__main__': main() diff --git a/research/e8-hosted-bit-contract/verify.py b/research/e8-hosted-bit-contract/verify.py new file mode 100644 index 0000000000..116decbe8a --- /dev/null +++ b/research/e8-hosted-bit-contract/verify.py @@ -0,0 +1,122 @@ +"""Offline audit of the pinned hosted-bit contract regression and proposed guard.""" +from pathlib import Path +import difflib +import gzip +import hashlib +import json +import types +import unittest +import test_schedule_guard + +if not __debug__: + raise RuntimeError('Assertions must remain enabled') +ROOT = Path(__file__).resolve().parent + + +def raw(name): + return (ROOT/name).read_bytes() + + +def sha(name): + return hashlib.sha256(raw(name)).hexdigest() + + +def payload(name): + data=raw(name) + return gzip.decompress(data) if name.endswith('.gz') else data + + +def read(name): + return json.loads(payload(name)) + + +def snapshot(): + assert not any(p.is_symlink() for p in ROOT.rglob('*')) + return {p.relative_to(ROOT).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() + for p in ROOT.rglob('*') if p.is_file() and p != ROOT/'MANIFEST.json'} + + +def verify(): + manifest=read('MANIFEST.json')['files'] + assert snapshot() == manifest + source=read('SOURCES.json') + assert source['commit'] == '4e16d001d505d4f21dd2bcfc44591f9be4c279bd' + for entry in source['files']: + data=raw(entry['path']) + assert hashlib.sha256(data).hexdigest() == entry['sha256'] + assert hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() == entry['git_blob'] + completed=read('evidence/COMPLETION.json') + assert completed['status'] == 'PASS_MINIMAL_ACTUAL442_BIT_FIXTURE' + assert completed['source_before'] == completed['source_after'] + assert completed['inputs_before'] == completed['inputs_after'] + adapter=read('evidence/adapter/MANIFEST.json')['files'] + assert completed['source_before'] == dict(adapter, **{'MANIFEST.json':sha('evidence/adapter/MANIFEST.json')}) + for name in ['driver.py','audit_stage.py','SOURCE-PINS.json']: + assert sha('evidence/adapter/'+name) == adapter[name] + pins=read('evidence/adapter/SOURCE-PINS.json') + assert pins['head'] == source['commit'] and len(pins['files']) == 17 + for path,entry in pins['files'].items(): + assert entry['sha256'] == adapter['source/'+path] + assert pins['files']['research/idle-axis-hosting/audit.py']['sha256'] == sha('vendor/audit.py') + assert pins['files']['research/idle-axis-hosting/EXPECTED.json']['sha256'] == sha('upstream/EXPECTED.json') + reused=read('evidence/REUSED-COMPLETION.json') + assert sha('evidence/REUSED-COMPLETION.json') == completed['inputs_before']['completion'] + assert reused['status'] == 'PASS_CHANGED_PR438_BIT_FINITE_CHECK' + assert reused['source_before'] == reused['source_after'] and reused['inputs_before'] == reused['inputs_after'] + for name,digest in completed['inputs_before'].items(): + if name != 'completion': + assert digest == reused['output_hashes'][name] + for name,path in read('evidence/RECEIPT-MAP.json').items(): + data=payload('inputs/'+name) if name in ['frames.json.gz','states.json.gz'] else raw('inputs/'+name) + assert hashlib.sha256(data).hexdigest() == completed['output_hashes'][path] + assert [s['name'] for s in completed['steps']] == ['kernel','export','source-spans','parent-global','parent-audit','hosted-bit','audit-contract'] + for stage in completed['steps']: + assert stage['returncode'] == 0 + assert sha('evidence/logs/'+stage['name']+'.log') == stage['log_sha256'] == completed['output_hashes'][stage['name']+'.log'] + expected=read('EXPECTED.json') + for name,key in [('parent','parent_template_sha256'),('hosted','hosted_template_sha256')]: + assert hashlib.sha256(payload('inputs/'+name+'.json.gz')).hexdigest() == expected[key] + assert expected['parent_template_sha256'] == read('upstream/PARENT-GLOBAL.json')['template_sha256'] + assert expected['hosted_template_sha256'] == read('upstream/EXPECTED.json')['bit_template_sha256'] + assert read('inputs/PARENT-GLOBAL.json')['template_sha256'] == read('inputs/PARENT-AUDIT.json')['template_sha256'] == expected['parent_template_sha256'] + assert len(read('inputs/PARENT-AUDIT.json')['mutations_rejected']) == 8 + assert len(read('inputs/KERNEL.json')['controls']) == 3 + frames=read('inputs/frames.json.gz')['frames'];states=read('inputs/states.json.gz') + widths=[8-frames[str(states['initial'][str(i)])]['dim'] for i in range(240,987)] + assert widths == read('inputs/widths.json') + contract=read('inputs/AUDIT-CONTRACT.json') + assert contract['parent_template_sha256'] == expected['parent_template_sha256'] + assert contract['hosted_template_sha256'] == expected['hosted_template_sha256'] + assert contract['profile'] == expected['profile'] and contract['hosted_residuals'] == expected['hosted_residuals'] == 39568 + assert [m['wrong_columns'] for m in contract['mutations']] == expected['original_accepted_wrong_columns'] == [8,3] + assert all(m['original_audit_accepted'] for m in contract['mutations']) + # Verify and execute the exact proposed two-line integration, leaving vendor bytes untouched. + original=raw('vendor/audit.py').decode() + derived=original.replace('import copy, gzip, hashlib, json, sys\n', + 'import copy, gzip, hashlib, json, sys\nfrom schedule_guard import require_hosted_bit_contract\n') + derived=derived.replace('def audit_bit(t, parent_t, widths):\n', + 'def audit_bit(t, parent_t, widths):\n require_hosted_bit_contract(t, parent_t)\n') + patch=''.join(difflib.unified_diff(original.splitlines(True),derived.splitlines(True), + fromfile='a/research/idle-axis-hosting/audit.py',tofile='b/research/idle-axis-hosting/audit.py')) + assert patch == raw('hosting-audit.patch').decode() + patched=types.ModuleType('patched_hosting_audit') + exec(compile(derived,'','exec'),patched.__dict__) + parent,hosted=read('inputs/parent.json.gz'),read('inputs/hosted.json.gz') + paid,count=patched.audit_bit(hosted,parent,widths) + assert {str(k):v for k,v in paid.items()} == expected['profile'] and count == expected['hosted_residuals'] + for name in ['exchange','bridge_zero']: + try:patched.audit_bit(test_schedule_guard.mutate(hosted,name),parent,widths) + except ValueError:pass + else:raise AssertionError('Patched audit accepted '+name) + suite=unittest.defaultTestLoader.loadTestsFromModule(test_schedule_guard) + result=unittest.TextTestRunner(verbosity=1).run(suite) + assert result.wasSuccessful() and result.testsRun == 4 + assert snapshot() == manifest + return dict(status='PASS_HOSTED_BIT_PARENT_CONTRACT_REGRESSIONS', + upstream_commit=source['commit'],hosted_template_sha256=expected['hosted_template_sha256'], + original_accepted_wrong_columns=[8,3],focused_tests=4,patched_audit='positive accepted; both invalid schedules rejected', + scope='Authentic PR442 bit fixture; verifier strengthening only, no new numerical or invalid-bound claim.') + + +if __name__ == '__main__': + print(json.dumps(verify(),indent=2)) diff --git a/research/e8-retimed-component-verification/ADAPTER.diff b/research/e8-retimed-component-verification/ADAPTER.diff new file mode 100644 index 0000000000..e0c0c222eb --- /dev/null +++ b/research/e8-retimed-component-verification/ADAPTER.diff @@ -0,0 +1,21 @@ +--- original377/work/odd-stages/global_nine.py ++++ adapter/work/odd-stages/global_nine.py +@@ -69,7 +69,7 @@ + # slot. Calls, replicas and cover classes run sequentially; their clean work + # is reused only after the source-checked erasure events. + macros=max(raw['scalar_bill'][o]['totals']['scalar_macros'] for o in locals) +-local_children=raw['label_checks']['invocation_calls'];assert local_children==3974 ++local_children=raw['label_checks']['invocation_calls'];assert local_children==3973 + compiler=64*(m+1)**3 + local_adapter_bound=16*(macros+local_children+(2*v+R)+h)+64*m + local_primitive=max(local_checks[o]['real_component_primitives'] for o in locals) +--- original377/work/odd-stages/audit_nine_template.py ++++ adapter/work/odd-stages/audit_nine_template.py +@@ -71,6 +71,6 @@ + M=engine('moment');B=engine('base_two_moment');r=M.certify(H,73,14727,True);b=Q(int(Q(r['lower'])*10**18),10**18);grid=Q(1,10**18);fb=32*73**2*sum(H.values()) + lo,up=M.moment(H,73,14727,b,True);nl,nu=M.moment(H,73,14727,b+grid,True);assert up<1 x + ((q+e_j).x)(q+e_j). Its remaining columns are an orthonormal basis +of q^perp. For s>0, rho_s,q exchanges that complement in the local block +with exterior block s and fixes q and all other exterior coordinates. +It is a symmetric orthogonal involution. The stage data owners are +g=d*rho_s,q, with rho_0,q=I, so the right factors are bijections of O(73,2). + +Use canonical data levels X_s=C_[0,9+8s), Y_s=X_s C_q^(-1), and initially +X_(-1)=C_q, Y_(-1)=I. The routed stage starts at level s-1 and ends at level s. +Their binary preimages agree with the window endpoints. Exact phase +polynomials determine the translation that reconciles each endpoint, and +the template applies that translation. There are 3840 nonzero such +translations across the 120 port types and nine stages, before replica +multiplicity. These operators are not silently identified from equal +binary matrices. + +Four-pair scalar chain and idle children + +Starting with F_0 (Y_0 += X_0), for j=0,1,2,3 apply B_j (X_j -= Y_j), +then for j<3 apply X_j += X_(j+1), Y_(j+1) -= Y_j, apply F_j, and undo +that bridge. The last pair has B_3,F_3 without a following bridge. +Afterwards apply, in descending j=2,1,0, X_(j+1)+=X_j and Y_j-=Y_(j+1). +Finally exchange each pair by newX=oldY, newY=-oldX. The complete signed +integer scalar matrix is the identity; omission of every bridge fails. + +Before a bridge, advance the idle pair to the active pair's level. The +two advances for the newly used pairs have ranks (16,8), (32,8), (48,8). +The final advances have ranks 48,32,16,0. Each rank occurs on both members +of the pair, each of 120 ports, and each of eight replicas. A nested idle +transition is factored in the explicit orthonormal basis U_q direct_sum I. +Its exact Z4 phase is reconciled by the stored translation after that child. + +The final Y endpoint is C_all C_q^(-1). A source began at C_q, so its +unadjusted exchange route would be C_all C_q^(-2)=C_all X_q. Applying the +literal X_q to each final Y before the signed exchange removes this factor. +The corresponding 120 omission controls fail. This correction is charged. + +Banks and arbitrary correlated dirt + +There are eight replicas of each of the four data pairs, hence 7680 data +families. Each stage has 783 independent bank families. Number a local +helper occurrence by z=783*replica+helper. It uses bank floor(z/8) and slot +z mod 8, with its nine-dimensional residual assigned to coordinates +[9*slot,9*slot+9). A paid coordinate C child at coordinate 72 completes +each bank. All eight whole residuals and this padding fill dimension 73. +Thus there are 9*783=7047 bank families and live stock 14727. + +Let Pi_slot swap the first nine coordinates with the assigned block. The +local invocation at class d uses the bank class g=d*Pi_slot^(-1). Its +residual at that owner is P_g C_block P_g^(-1). Right multiplication is a +bijection. Local helpers sharing one bank have distinct slots, hence +different right factors and different actual bank classes for every d. +All data and private families are disjoint from banks. The checker verifies +these injections for all 72 invocation/replica templates and 56376 residual +assignments. A complete cover sweep for one replica finishes before the +next begins. The local dirty invocation is block diagonal on helpers at +its endpoint and permits arbitrary correlated helper values. Therefore +overlap between different invocations does not impose a cleanliness or +independence assumption. At each bank class, the eight residuals and the +padding are coordinate factors in one common conjugated basis, and their +exact product is P_g C_all P_g^(-1). + +One more exact correction is essential. Orthogonality alone does not imply +that P_g commutes with C_all as an exact operator. In fact + P_g C_all P_g^(-1) = C_all X_delta(g), + delta(g)_i = (weight(row_i(g))-1)/2 mod 2. +The quadratic terms cancel by row orthogonality and the remaining even +linear terms give the displayed translation. Both sides fix the uniform +vector, fixing the global scalar. Apply X_delta(g) to EVERY final live +family in cover class g, after the bank padding and signed data exchange. +The template includes and charges all 14727 corrections per cover. This +identity is also checked on every orthogonal matrix in dimensions 1..5. + +Finite work and recurrence charges + +The source emitter is regenerated and revalidated in both orientations. +It accounts for 1242936 local events over 72 invocations, with all copied +center and dirty-tableau lifetimes intact. Forward and backward scalar +words freshly replay all 1023 independent dirty live columns. Only the +private work starts at zero. Work comprises 783 tableau streams, nine +reserved center streams (eight used), and one coefficient stream. Each +invocation completes and erases its private work before the next. Physical +stock is therefore 15520 per cover; scalar-only work is excluded from the +recursion-volume denominator. + +GLOBAL-REVIEW.json records the complete recomputed finite overcharge, with +64*(73+1)^3 compiler groups per rank-zero adapter, source-counted scalar +primitives, and overcharges for all data routes, bank selectors, phases, +padding, bridges, exchanges and cover corrections. The O(73,2) order is +2^(36^2)*product(2^(2i)-1,i=1..36); its bit length is 2628. The recomputed +router fits 2^30000, the literal charge fits 2^100000, and the precision +guard fits C0=2^210000. No even-dimensional orthogonal-order formula is used. + +Largest child 48 does not satisfy one-layer halving. Instead +73^2=5329>2*48^2=4608, so two nested children have width strictly below +half the parent, including floors. The general depth is bounded by +2*ceil(log2 e), with direct small leaves. For B=s+E the completed-child +semantic induction has 2B(73-48)-s-E=49B>0. The resulting conservative +complete-row coefficient is 2*2642+9909+252=15445<20161, retaining the +external bit/base-row allowance as an explicit interface assumption. +The inherited bad-branch envelope is priced conservatively as before. + +Two independent rational moment engines admit +b=999240641319551/10^18 and exclude b+10^-18 for the source-bound profile. +The rank mass is 1072575, and 73*14727-1072575=2496=8*(8*120-9*72). +This complex component exceeds 1/1024 but does not improve the current +bit bottleneck. No improved final kappa or 1% final-kappa milestone follows. diff --git a/research/e8-retimed-component-verification/evidence/component/local-admission/INDEPENDENT-AUDIT.json b/research/e8-retimed-component-verification/evidence/component/local-admission/INDEPENDENT-AUDIT.json new file mode 100644 index 0000000000..865dd8ec2a --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/component/local-admission/INDEPENDENT-AUDIT.json @@ -0,0 +1,124 @@ +{ + "certificate_sha256": "f2a404fe3f00cf843718fc8c23c6227d84e5e65c5a19cc1141dc1a6997ca86e7", + "finite_guard": { + "C0_exponent": 210000, + "E_exponent": 100000, + "G_exponent": 30000, + "all_retained_guards_pass": true, + "binary_basis_count_tests": [ + { + "invertible_matrices": 1, + "m": 1, + "maximum_selected_bit_additions": 0 + }, + { + "invertible_matrices": 6, + "m": 2, + "maximum_selected_bit_additions": 4 + }, + { + "invertible_matrices": 168, + "m": 3, + "maximum_selected_bit_additions": 10 + }, + { + "invertible_matrices": 20160, + "m": 4, + "maximum_selected_bit_additions": 18 + } + ], + "coefficient_denominators": [ + 1, + 2, + 3, + 6 + ], + "complete_invoice": { + "adapters": 134832, + "compiler": 6229504, + "literal": 3484919848008575317301547366832776944651919644766199845423461832546633375534693251767795655111835134465848763638790977104243061204218193988531445898469069281843793927836668850718498823594210341783679714499437372888669947767975431478077977864879274082043680555682766071267979756841807501954853348861881292794234987995223504450724351731133374146861433743129261501741484913649074881672242750260450525789866444785013253355197399640055140252149537847228072277711016842985881003070433778438801826492964763792696331349100526088689941141410761388229177847656260492745989324064647666251256910134499689713640783794411052897914347284622417611430003930619441491316697080909837884295947989970034993166724843668731497653457876590664326959320081835900304046448033289819205148498076750135411559924510254486505748834697336253327943499099557797117924577873014951613091226260310508728425451287537713713005712022244399969998830032224574172753828296845009836824099466411705593262255197783495649112615598000886894024968937792888666197168697697357718327743511213857723157628790834239747203906257289159165718199695395150917007816165048980172250313704546892851721144065410670222669821271311804691386763824427968403949872025584540059251533690989254771503985540788342486955124823953041107837966810711659417200324932004569093708140960749171352687443016563092166888101804075109808729688333132121315789582618193945359478023078042079953383095362419902129452173227347035823814418941538231942811448442078706855737560520695226313352253061942697463297524408305399621738364570721588802223671067001933778318271392120015402135432898860043483340565675798715503292047921610868055071114382097606409284612840294070802066201193138402262352995552297105857736628807732191959877111299565648745345593330262867800712427641152391627251462445928922426807420149183841678090495617130193328083499129958009264267469309360924339257175688647734256346776481784138195639772957012726113429728580747075384534323537367607797129481511335530911627287585664312711493589161827616849878601392473729283716107842433867706264695969731814146201155662392939867733387582555002735780422681222077305049009934706969624653413662167843589342079357719338743928474708859138376647505139376296208400148436927971868859517229408683487873285975641799137565825670568759211344202267287221448233937263883765463937215069148472715017595095180212583147188008736607897811949512503788345573301195540113016685626280089585477297446669370345859840816054161672461162327926859152789904979335638335335874937179433873434749476272480635001823279546928985751452202788273391692031872741680274546346682174746097730867987576266017669669426067375898892514139255610076685914141545671471635746191828983677342217214765558872684598435188323053352094108753879826232271788008793376493754410694589164797005968481608459614061971870521750922234070498330311191877587776614405753585487084089733861670435841929711771722132419637779437222858094615931629508814277874828836873514818973146660453130984672044822270628933069129343195783281452181153968965365343698675625285402840979438475294038568930556243538999890568959361934502660612804548484805397624243934782578526195490020422404017680321028191939415712016875050028450511934875273385326711693258129153199527224899227919403476428994449498349195540390854674344991758519959483704607348538287428414896581867261607661661441298663795270502440848522992484376542179132619502682435522518218838143300259128088828040985483255778062641320905974941867781588447771669432763964866844519952984406087260531320406219218414161373392376094925828222802831181072294066344991267618004272843109259063052244509428170193293013157743919059997982384181920206054205062832094203961860823448635749728936836684679392509027130612502078184980729169926737385881040866615692116960828028432848512010589434958216915750547878443274044048657722422891706069937974755799494068952466587296121737250050810839674373469330633532201480934389270423772178878172458036383684702627611170254800196321363782665120051420791243961368627133326217023127297345856827759285737245630728716991805162223226429566507691442417176247015283372384367241783278102567934397618474813870562706332562664512940036923713657491595935691922233914367589192791807696135261557766902230562420652381800346263073786066764416108098333865267628821439826630208055008570295438359693906963633787101092576631465621438519272869203714854972719960902152353882060414776033484569980625395628389336909888264721913979363125353975768899169679410278139095358274159991692315742834214549758156636992936470655997075235916546670628667915742821243462356978432443625330866958833265102230048137481275210955144142818622975702056950681668428219699451876663903260200737681437804217660861443941519641978689217276925077654611420848116582753063499068804227996778300601868152235934312440886001316114970071074011153331475374470649587357333956573597066642001468457216299776181467797345103677132492399320805950110468430210015171312866269704660907608698734375335794471671928304744992782748309218312951654416611308185073240321472709540152719600750139714070247778424267744995634542697024785660985011457689311474430976593975842512445035865831431889498781187252278616909254382233060133243529251936681890414494307796438929834263892637945420783125255376551121379557080364515049124061979215403627464517973901412321830775802064747787958216486683238419238928372334250091799279424500359721576904730522368898946152432404871684866784505986542881515158669870347334204669336194468890958657001549426833676760343714693134543320282194110939903498406483837032294952597714603749259220162827366516419094908792668723157379040002381138155252169673859388938539885938659071188192989207545439090902174717376510970988101420437837160688974007015644221443380700120672735319680276625592928444056993188487058261719781549423090140959383709962546995502839767034544492945725720294358888522145646380516941606750155874936880666391208402099240075407310880944501947807516474537145309823041879261803439504438393446195229481284035527578176292978153093069479389116338048648030217121518462778903856052716833857483941652836777452362570342415813513013049628336532329582943340813143849086377718337754686788147417670162625578313973745336117814993934545840808606517669576997691300901790755629451833539110265916089985137252919665820378713296191712878730746862928390290952817585375699708943633760714409144039491423838983186002814956172606161812150038149391725419664793789212259721510703454767855018581361149689467970417886066929455599655711402897697054106964651378308337736189184394370330418302587978005291789196856033209090574189258153539442411216406154006261004903258496276529735865052175497656101185049182603288031823304931972912862460598873773817204954979588003754976138014022470425572678562601007783679958849427112729845522611533408547955402486773763610984595949263697028433718335148510556427510768067919345096829217521857565712190902732063828749572482652024624428654606080467293479116108123592109605708151671135017535112490033197119425929211463827596476562621509390729273819407669316210382198891736380888808215039861488300885715892428920929076083805688737100471570156795634577633295053609132528052511358310210830919120643918930634119709670491068603516934277922720947001610403033440893863977726995215388996173784434342090429514947168127904453261943029931492598728828396918465142308856988663856905746783097410938802105794407621818372627509100901651501953508379149501104766652060216909070105687091670802621779364415892095281612298486999027793524911634505602912461663720031205864071672409040143796901470612847863520604474674742877567324793062172195898710437604997934426925651850429934077114727635877720324649286221994883859054139434326187673454485411191644861851257351472404657258019708224318766143484659701319825034718055840422371628200413477602373621879147192006226911778505324270645888882267829013675188218534308687119643300538283405995562452998400456634506490778383247086434193595320630923675594147918736652800462376288895140500179705083138224298222730220642293495361297897473400552707823651697821584813575004400788127610078560327027669482871387129305957406108669491938086457581913245214623969332205351105893031910080185333196773443285861417583728752021423366645002257855150232852589964524430087451129967067600974590962872713263285594687285441069032723690216423636153628960115837647046958137918565968144516445582474617324158617341168993710508403966194111725652066444431478857069750979043717999860568624499010448128223719773528496344962570487690283010493578675277354183334044577141495159708005547080106383028980523496326167808440235349783513299066773857007785889397672543304331103636452893372968232249310252615379182888472317961492297020676550530959067228689529980028660261903394654821844373104273335613759249145627395308264887501691782986185588591228564333301284679825717620785961005422263904420392992943304790531744120999694039679969052705174814187667482431579334024514029341193750008329535404694590002049191339771248635810444333658864066978251243375222123759960181486932164136095872469883086344982523367448842040663488441732619335286178684536277482469442559520281216314469165900976319154333668658373576182821984766396496032600593110001903965044545998733540997826706240540632046279365927142569520456741496091820252897344723503679945941902873288880682050561094076925044319367190996171377645039304641091817709067966876714053560442704795180291769311240518466272484738839929072477310245646829122100567349190878473331557477295943890548270817354680369982119074881982268643293171709666702930004903468257878183261160731665216390879272854968714196166901760000000001444, + "live_stock": 9099691722756384991549642805557503276693293910369415056048712145949139973133489479866880561206039914500021006211095643860998966384820419685187521016541750398895042132694405004566847887047406056836740898101119240040369015073407896635044579668359321430149657889148303133792655222599340523520000000000000, + "logical_groups": 31664051038136097389717295952075429205544889921774074334367717515123862701845498069098068119335325918285528344895170987775044279012128329409933967291007964352891306449723217738705833758271107614807849308034627304345136936997099615747566591001803496798234044417343422272644614532129635118384393748480000000000064, + "macros_max": 11669, + "orthogonal_group": 7204823216750898647307714018652021596748451235446884446594388080719825790287798479704576849727664223673809189399125608757718896583389089220259319886414687568404625599916393511137646783093749847059969040460110245479310384064455975166306080497513318630363941321574270098014770564211671040000000000000, + "outside": 31328, + "pervertex": 4394840801162, + "physical_stock": 14813116533639847618864660022348556402914815740078794422198061893959961824831713674272610003040077643873351693404602251605870051375447967436853161686468597640639910233428105058899001786040749685555296347185986664705462149636521484941925301502887383104028263357156699321518368280019195658240000000000000, + "rank_mass": 408621548738027216782057000567849404859588411818370051388600719998024919696172490776445076032304476445660088176771408900694027219726912195127007327358009005442068340899258257984171637303162022576006144129695152572359088432215620631557049355416467866121090932053084728608907712549264923033600000000000000, + "router": 43282548538816509538125805932284113140127927986766389072402821293693799356983869360092934533220898464587593383761113129593773510412358006081729362765982983836614689434681660296938217116844670867616938399431898976552045312052127548751963066610093513754216753067441189104000021606629189104198277960244362564603384607524979328038450817637400694342848355150117302190517112189184542307990782826327620281891890727129117146610158323082149191065426876521024825430545740998394587812291333582081732441141587005848105945173552051386742087757896076214314006716710731133663482047893845945662289854191623989142722916820030013226904862863644257307220153383574823100226099747698687371615250526857330998287367891985210469200048313615457489993090618834114977017733711063124197462941286465987234182032039254745830716583542543143298961194944285100733494228550666586236613881206486428877278454784011293903159623344580266263838720000404917760, + "scalar_five_invocations": 350186, + "scalar_max": 72856 + }, + "complete_local_group_bits": 40, + "complete_local_group_upper": 839936556184, + "controls": { + "dropped_center": true, + "even_dimension_order_at_odd_m": true, + "missing_tableau": true, + "scratch_in_live": true, + "stale_stock_bound": true, + "unrecorded_divisor": true + }, + "global_logical_groups_bits": 1032, + "group_bits": 990, + "induction_gap_multiple_of_B": 49, + "literal_charge_bits": 32002, + "live_per_vertex": 1263, + "live_row_coefficient": 11161, + "live_stock_bits": 1000, + "m": 45, + "odd_denominator_grid": "2^(-P)3^(-G(D+1)); no return rounding", + "orthogonal_order_formula": "|O(2r+1,2)|=|Sp(2r,2)|=2^(r*r)*product(2^(2*i)-1,i=1..r)", + "physical_per_vertex": 2056, + "physical_row_overcharge_coefficient": 11162, + "physical_stock_bits": 1001, + "rank_mass_bits": 1006, + "required_C0_bits": 200011, + "retained_row_coefficient": 20161, + "retained_row_gap": "23971789/25", + "router_bits": 3055, + "semantic_C1": 1, + "simple_global_logical_bound_exponent": 6050, + "small_dimension_complete_orthogonal_basis_enumeration": { + "1": 1, + "2": 2, + "3": 6, + "4": 48, + "5": 720 + }, + "status": "PASS_CORRECTED_ODD_DIMENSION_COMPLETE_FINITE_INVOICE" + }, + "guard_receipt_sha256": "b3a5225ace875c14c90adeb4dfec0f9afc167bf9700483d2de35aac15d66d104", + "scalar_words": { + "backward": { + "all_live_rows_correct": true, + "all_private_work_restored_zero": true, + "expected_map": "X -= Y; Y and dirty S restored", + "helper_columns": 783, + "independent_live_columns": 1023, + "recursive_scope": "All recursive frame operators specialized to identity; validates literal dirty scalar map and both projection schedules, while upstream splice separately checks exact frame incidence and child ranks.", + "scalar_macros": 11669, + "source_columns": 120, + "status": "PASS_FULL_ACTUAL_DIRTY_SCALAR_WORD", + "target_columns": 120 + }, + "forward": { + "all_live_rows_correct": true, + "all_private_work_restored_zero": true, + "expected_map": "Y += X; X and dirty S restored", + "helper_columns": 783, + "independent_live_columns": 1023, + "recursive_scope": "All recursive frame operators specialized to identity; validates literal dirty scalar map and both projection schedules, while upstream splice separately checks exact frame incidence and child ranks.", + "scalar_macros": 10886, + "source_columns": 120, + "status": "PASS_FULL_ACTUAL_DIRTY_SCALAR_WORD", + "target_columns": 120 + } + }, + "scope": "Independent audit of supplier words and finite charges only; no Lean build or complete multiplication theorem proof.", + "seconds": 0.15581016696523875, + "status": "PASS_E8_INDEPENDENT_DIRTY_SCALARS_AND_CORRECTED_FINITE_GUARD", + "upstream_finding": "The upstream m=45 guard uses the even-dimension orthogonal order and undercounts the cover by (2^44-1)/2. Correcting it preserves every retained strict finite guard and changes no coarse saving.", + "upstream_head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "upstream_manifest_sha256": "4b76fb09595321986da04017db16cf6aa36bcd6a048cdee2ec8b656de811e488" +} diff --git a/research/e8-retimed-component-verification/evidence/component/local-admission/UPSTREAM-GUARD.json b/research/e8-retimed-component-verification/evidence/component/local-admission/UPSTREAM-GUARD.json new file mode 100644 index 0000000000..5610e84e65 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/component/local-admission/UPSTREAM-GUARD.json @@ -0,0 +1,990 @@ +{ + "five_stage_histogram": { + "1": 10465, + "16": 240, + "2": 3030, + "20": 240, + "3": 2620, + "4": 835, + "5": 1075, + "6": 1705, + "7": 215, + "8": 360, + "9": 40 + }, + "inherited_theorem_dependencies": [ + "The pinned gcert/1 program is accepted, fresh in this run, by Sussman's reference checker gx.check1 with the exact scalar identity (E5) and by his gxcore mirror of the two Lean checks; a flipped scalar sign is rejected by both. No Lean check of this program is pinned in this package.", + "Pinned Lab.inv dirty lifting, exact gwinB/G0..G4 geometry, owner bijections and NetCert composition are inherited source theorems.", + "Retained general Clifford synthesis, compact complete-stream tape primitives, common-grid precision and complete-row proofs remain analytic dependencies.", + "The finite operational recipe is regenerated and checked; no astronomical cover enumeration or universal tape-machine execution is claimed." + ], + "input_pins": { + "inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "f2664ee7bcdfb55893abe9f1be8ee6a394a602e8262e611de2a0328bbd508aa7", + "inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf" + }, + "label_checks": { + "Cc_copy_additions": 8, + "Y_bracket_pairs": 0, + "centre_ranks": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "frame_count": 948, + "invocation_calls": 3973, + "invocation_histogram": { + "1": 2093, + "2": 606, + "3": 524, + "4": 119, + "5": 215, + "6": 341, + "7": 43, + "8": 24, + "9": 8 + }, + "invocation_rank_mass": 9039, + "limits": [ + "No scalar all-column replay", + "No old-response or cleanup matrix formed", + "No generated Lean data comparison or kernel build", + "No physical stream compiler" + ], + "literal_gate_coefficients": { + "-1": 628, + "-1/2": 417, + "-2": 91, + "1": 1644, + "1/2": 323, + "2": 37 + }, + "literal_inverse": "Each nonself additive shear inverts by negating its coefficient; inverse phase reverses order; inverse transpose keeps chronological order and swaps source/target with negation.", + "live_registers_per_invocation": 1023, + "phase_histograms": { + "A": { + "1": 765, + "2": 230, + "3": 123, + "4": 4, + "5": 13, + "6": 50, + "7": 30, + "8": 22 + }, + "B": { + "1": 874, + "2": 302, + "3": 290, + "4": 87, + "5": 172, + "6": 213, + "7": 13, + "8": 2 + }, + "copy": { + "9": 8 + }, + "final": { + "1": 454, + "2": 74, + "3": 111, + "4": 28, + "5": 30, + "6": 78 + } + }, + "phase_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0", + "start": "5166476b2cb28fc9a2b5686ef821c3510527d5921a0c9fd32782d5da358d29bf" + }, + "phase_stats": { + "A": { + "gates": 775, + "register_visits": 2237, + "scalar_additions": 1462, + "spectator_visits": 0 + }, + "B": { + "gates": 1226, + "register_visits": 2904, + "scalar_additions": 1678, + "spectator_visits": 0 + } + }, + "ranked_live_transitions": 3965, + "retained_centers": [ + [ + 0, + 504, + 1 + ], + [ + 1, + 505, + 1 + ], + [ + 2, + 506, + 1 + ], + [ + 3, + 507, + 1 + ], + [ + 4, + 508, + 1 + ], + [ + 5, + 509, + 1 + ], + [ + 6, + 510, + 1 + ], + [ + 7, + 511, + 1 + ] + ], + "role_histograms": { + "c": { + "9": 8 + }, + "s": { + "1": 1892, + "2": 528, + "3": 468, + "4": 83, + "5": 182, + "6": 229, + "7": 9, + "8": 2 + }, + "x": { + "1": 119, + "2": 33, + "3": 22, + "4": 4, + "5": 13, + "6": 50, + "7": 24, + "8": 20 + }, + "y": { + "1": 82, + "2": 45, + "3": 34, + "4": 32, + "5": 20, + "6": 62, + "7": 10, + "8": 2 + } + }, + "scalar_role_directions": { + "A:s->s": 532, + "A:x->s": 930, + "B:s->s": 1012, + "B:s->y": 666 + }, + "scatter_additions": 736, + "scatter_coefficients": { + "-1/2": 28, + "-1/6": 448, + "1/2": 36, + "1/3": 224 + }, + "temporary_centers": 8, + "tested_distinct_nested_pairs": 3120, + "two_hosts_metadata_count": 0, + "two_hosts_note": "Metadata only; not an independent allocator or host-use proof." + }, + "ledger": { + "calls": 20825, + "centres": 8, + "copy_calls": 40, + "deficit": 120, + "histogram": { + "1": 10465, + "16": 240, + "2": 3030, + "20": 240, + "3": 2620, + "4": 835, + "5": 1075, + "6": 1705, + "7": 215, + "8": 360, + "9": 40 + }, + "idle_calls": 960, + "max_child": 20, + "rank_mass": 56715 + }, + "precision_guard": { + "C0_exponent": 210000, + "E_exponent": 100000, + "G_exponent": 30000, + "binary_basis_count_tests": [ + { + "invertible_matrices": 1, + "m": 1, + "maximum_selected_bit_additions": 0 + }, + { + "invertible_matrices": 6, + "m": 2, + "maximum_selected_bit_additions": 4 + }, + { + "invertible_matrices": 168, + "m": 3, + "maximum_selected_bit_additions": 10 + }, + { + "invertible_matrices": 20160, + "m": 4, + "maximum_selected_bit_additions": 18 + } + ], + "coefficient_denominators": [ + 1, + 2, + 3, + 6 + ], + "complete_local_group_bits": 40, + "complete_local_group_upper": 839936556184, + "controls": { + "dropped_center": true, + "missing_tableau": true, + "scratch_in_live": true, + "stale_stock_bound": true, + "unrecorded_divisor": true + }, + "global_logical_groups_bits": 989, + "group_bits": 947, + "induction_gap_multiple_of_B": 49, + "literal_charge_bits": 31916, + "live_per_vertex": 1263, + "live_row_coefficient": 11118, + "live_stock_bits": 957, + "m": 45, + "odd_denominator_grid": "2^(-P)3^(-G(D+1)); no return rounding", + "physical_per_vertex": 2056, + "physical_row_overcharge_coefficient": 11119, + "physical_stock_bits": 958, + "rank_mass_bits": 963, + "required_C0_bits": 200011, + "retained_row_coefficient": 20161, + "retained_row_gap": "23971789/25", + "router_bits": 2926, + "semantic_C1": 1, + "simple_global_logical_bound_exponent": 6050, + "status": "PASS_FRESH_EXACT_COMPLEX_GUARD" + }, + "program_check": { + "blocks_total": 3973, + "certificate_sha256": "f2a404fe3f00cf843718fc8c23c6227d84e5e65c5a19cc1141dc1a6997ca86e7", + "controls": [ + { + "checker": "gx.check1", + "name": "flipped_scalar_sign", + "reason": "E5: a target does not receive exactly its source (hid)" + }, + { + "checker": "gxcore.mirror", + "name": "flipped_scalar_sign", + "reason": "E5: a target does not receive exactly its source (hid)" + } + ], + "distinct_frame_steps": 3120, + "gates_A": 775, + "gates_B": 1226, + "gx_check1": "ACCEPTED (labels, blocks, N, exact scalar identity E5, Q2)", + "gx_sha256": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "gxcore_mirror": "ACCEPTED (label and scalar checks; histogram equals the blocks)", + "gxcore_sha256": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "lean": "not run here; no Lean check of this program is pinned in this package", + "scalar_denominators": { + "s": 2, + "x": 1, + "y": 6 + }, + "scalar_max_abs": { + "s": "2", + "x": "0", + "y": "4/3" + }, + "seconds": 0.16406750003807247, + "status": "PASS_COMPLEX_PROGRAM_GX_CHECK1_SCALAR_AND_GXCORE_MIRROR" + }, + "scalar_bill": { + "backward": { + "coefficient_histograms": { + "cleanup": { + "-1": 486, + "-1/2": 234, + "-2": 91, + "1": 1472, + "1/2": 154, + "2": 37 + }, + "main": { + "-1": 1652, + "-1/2": 351, + "-1/6": 448, + "-2": 37, + "1": 628, + "1/2": 453, + "1/3": 224, + "2": 91 + }, + "old_response": { + "-1": 388, + "-1/2": 425, + "-1/6": 448, + "-2": 88, + "1": 1772, + "1/2": 355, + "1/3": 224, + "2": 29 + } + }, + "other_main_recursive_calls": "68230 existing live-label transitions, unchanged; not scalar macros", + "phases": { + "cleanup": { + "Gaussian_primitive_steps": 7938, + "add": 2474, + "all_macros": 2474, + "divisor3_exposure": 0, + "halving_exposure": 388, + "real_component_primitive_steps": 15876, + "scalar_log2_magnitude_charge": 2602, + "scalar_macros": 2474 + }, + "main": { + "Gaussian_primitive_steps": 13720, + "add": 3884, + "all_macros": 3908, + "clear": 16, + "divisor3_exposure": 672, + "halving_exposure": 1252, + "real_component_primitive_steps": 27440, + "recursive_centers": 8, + "recursive_rank_mass": 72, + "scalar_log2_magnitude_charge": 4012, + "scalar_macros": 3900 + }, + "old_response": { + "Gaussian_primitive_steps": 14770, + "add": 3729, + "all_macros": 5295, + "clear": 1566, + "divisor3_exposure": 672, + "halving_exposure": 1228, + "real_component_primitive_steps": 29540, + "scalar_log2_magnitude_charge": 3846, + "scalar_macros": 5295 + } + }, + "schedule_sha256": "e73ba422d94c229a05680251ab28a74cc7258fc3b50bf5061aaf57d42ac37e94", + "totals": { + "Gaussian_primitive_steps": 36428, + "add": 10087, + "all_macros": 11677, + "clear": 1582, + "divisor3_exposure": 1344, + "halving_exposure": 2868, + "real_component_primitive_steps": 72856, + "recursive_centers": 8, + "scalar_log2_magnitude_charge": 10460, + "scalar_macros": 11669 + } + }, + "five_invocation_scalar_primitives_per_vertex": 350186, + "forward": { + "coefficient_histograms": { + "cleanup": { + "-1": 1472, + "-1/2": 154, + "-2": 37, + "1": 486, + "1/2": 234, + "2": 91 + }, + "main": { + "-1": 628, + "-1/2": 445, + "-1/6": 448, + "-2": 91, + "1": 1652, + "1/2": 359, + "1/3": 224, + "2": 37 + }, + "old_response": { + "-1": 418, + "-1/2": 419, + "-1/3": 224, + "-2": 88, + "1": 959, + "1/2": 361, + "1/6": 448, + "2": 29 + } + }, + "other_main_recursive_calls": "68230 existing live-label transitions, unchanged; not scalar macros", + "phases": { + "cleanup": { + "Gaussian_primitive_steps": 7938, + "add": 2474, + "all_macros": 2474, + "divisor3_exposure": 0, + "halving_exposure": 388, + "real_component_primitive_steps": 15876, + "scalar_log2_magnitude_charge": 2602, + "scalar_macros": 2474 + }, + "main": { + "Gaussian_primitive_steps": 13720, + "add": 3884, + "all_macros": 3908, + "clear": 16, + "divisor3_exposure": 672, + "halving_exposure": 1252, + "real_component_primitive_steps": 27440, + "recursive_centers": 8, + "recursive_rank_mass": 72, + "scalar_log2_magnitude_charge": 4012, + "scalar_macros": 3900 + }, + "old_response": { + "Gaussian_primitive_steps": 12421, + "add": 2946, + "all_macros": 4512, + "clear": 783, + "copy": 783, + "divisor3_exposure": 672, + "halving_exposure": 1228, + "real_component_primitive_steps": 24842, + "scalar_log2_magnitude_charge": 3063, + "scalar_macros": 4512 + } + }, + "schedule_sha256": "92dafa62a52fcf152ce27b8f4ae481955416b4bebfc8f64894ace60318d4b417", + "totals": { + "Gaussian_primitive_steps": 34079, + "add": 9304, + "all_macros": 10894, + "clear": 799, + "copy": 783, + "divisor3_exposure": 1344, + "halving_exposure": 2868, + "real_component_primitive_steps": 68158, + "recursive_centers": 8, + "scalar_log2_magnitude_charge": 9677, + "scalar_macros": 10886 + } + }, + "scratch": { + "additional_recursive_calls": 0, + "extra_external_row_coordinate": false, + "live_roles": 1263, + "physical_roles_per_cover": 2056 + }, + "scratch_lifecycle_checks": { + "backward": { + "center_children": 8, + "coefficient_work_cleared_per_add": true, + "complete_stream_fraction": "1/(1263*|Orth(45,2)|)", + "moment_live_width": 1263, + "new_recursive_children": 0, + "new_work_stock_only": 784, + "tableau_absent_from_all_children": true, + "tableau_cleared_before_entire_main_phase": true + }, + "forward": { + "center_children": 8, + "coefficient_work_cleared_per_add": true, + "complete_stream_fraction": "1/(1263*|Orth(45,2)|)", + "moment_live_width": 1263, + "new_recursive_children": 0, + "new_work_stock_only": 784, + "tableau_absent_from_all_children": true, + "tableau_cleared_before_entire_main_phase": true + } + }, + "template_tests": { + "checks_passed": 7, + "published_full_scalar_replay": false, + "tiny_exact_template_columns_checked": 7, + "unreversed_transpose_rejected": true, + "wrong_inverse_sign_rejected": true + } + }, + "splice": { + "certificate_sha256": "f2664ee7bcdfb55893abe9f1be8ee6a394a602e8262e611de2a0328bbd508aa7", + "controls": [ + { + "name": "drop_final_climb", + "orientation": "forward", + "reason": "final climbs omitted before cleanup", + "rejected": true + }, + { + "name": "cleanup_before_final_climbs", + "orientation": "forward", + "reason": "strict old/A/copy/B/final/adapter/cleanup chronology", + "rejected": true + }, + { + "name": "drop_final_frame_adapter", + "orientation": "forward", + "reason": "missing or reordered exact final adapter", + "rejected": true + }, + { + "name": "wrong_common_exact_gate_label", + "orientation": "forward", + "reason": "scalar incidence uses wrong exact label", + "rejected": true + }, + { + "name": "drop_center_child", + "orientation": "forward", + "reason": "center source frame", + "rejected": true + }, + { + "name": "tableau_not_erased_before_child", + "orientation": "forward", + "reason": "old-response tableau survived before label recursion", + "rejected": true + }, + { + "name": "wrong_cleanup_sign", + "orientation": "forward", + "reason": "complete scalar program differs from checked bill", + "rejected": true + }, + { + "name": "drop_final_climb", + "orientation": "backward", + "reason": "final climbs omitted before cleanup", + "rejected": true + }, + { + "name": "cleanup_before_final_climbs", + "orientation": "backward", + "reason": "strict old/A/copy/B/final/adapter/cleanup chronology", + "rejected": true + }, + { + "name": "drop_final_frame_adapter", + "orientation": "backward", + "reason": "missing or reordered exact final adapter", + "rejected": true + }, + { + "name": "wrong_common_exact_gate_label", + "orientation": "backward", + "reason": "scalar incidence uses wrong exact label", + "rejected": true + }, + { + "name": "drop_center_child", + "orientation": "backward", + "reason": "center source frame", + "rejected": true + }, + { + "name": "tableau_not_erased_before_child", + "orientation": "backward", + "reason": "old-response tableau survived before label recursion", + "rejected": true + }, + { + "name": "wrong_cleanup_sign", + "orientation": "backward", + "reason": "complete scalar program differs from checked bill", + "rejected": true + }, + { + "name": "wrong_helper_owner", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "rank_only_frame", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "scratch_alias", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "wrong_live_normalization", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "free_RAM", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "missing_tableau", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + } + ], + "global_contract": { + "chronology": [ + "stage0", + "stage1", + "climbA", + "bridgeA", + "stage2", + "climbB", + "bridgeB", + "stage3", + "stage4", + "final_climbs", + "bridgeC", + "terminal_shifts", + "signed_exchange" + ], + "exact_frame_bindings": { + "sfin": { + "anchor": "sfin :", + "declaration_line": "sfin : \u2200 g, W4 (s4.symm g) * (W3 (s3.symm g) * (W2 (s2.symm g) * (W1 (s1.symm g) * (G0 g).Xm.\u03a6 1))) = kernel \u03b1", + "line": 82, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L82" + }, + "term": { + "anchor": "term :", + "declaration_line": "term : \u2200 g t, kernel \u03b1 * (G0 g).Xm.\u03a6 (tt (I.tv t)) = shift (u g t) * YF g t", + "line": 94, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L94" + }, + "x01": { + "anchor": "x01 :", + "declaration_line": "x01 : \u2200 g t, (G0 g).Xm.\u03a6 1 = (G1 (r1 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 73, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L73" + }, + "x12": { + "anchor": "x12 :", + "declaration_line": "x12 : \u2200 g t, (G1 (r1 t g)).Xm.\u03a6 1 = (G2 (r2 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 75, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L75" + }, + "x23": { + "anchor": "x23 :", + "declaration_line": "x23 : \u2200 g t, (G2 (r2 t g)).Xm.\u03a6 1 = (G3 (r3 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 77, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L77" + }, + "x34": { + "anchor": "x34 :", + "declaration_line": "x34 : \u2200 g t, (G3 (r3 t g)).Xm.\u03a6 1 = (G4 (r4 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 79, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L79" + }, + "y01": { + "anchor": "y01 :", + "declaration_line": "y01 : \u2200 g t, (G0 g).Xm.\u03a6 (1 + tt (I.tv t)) = (G1 (r1 t g)).Xm.\u03a6 0", + "line": 74, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L74" + }, + "y12": { + "anchor": "y12 :", + "declaration_line": "y12 : \u2200 g t, (G1 (r1 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G2 (r2 t g)).Xm.\u03a6 0", + "line": 76, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L76" + }, + "y23": { + "anchor": "y23 :", + "declaration_line": "y23 : \u2200 g t, (G2 (r2 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G3 (r3 t g)).Xm.\u03a6 0", + "line": 78, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L78" + }, + "y34": { + "anchor": "y34 :", + "declaration_line": "y34 : \u2200 g t, (G3 (r3 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G4 (r4 t g)).Xm.\u03a6 0", + "line": 80, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L80" + } + }, + "family": "baseline5stageComplex", + "global_bound_exponent": 6050, + "helper_policy": "arbitrary_input; inherited_dirty_lift; Z5=kernel", + "label_policy": "identical_exact_representative_and_paid_rank_zero_reconciliation", + "live": 1263, + "local_bound_exponent": 48, + "m": 45, + "maintained_guard_changed": false, + "odd_grid": "2^(-P)3^(-G(D+1)); no return rounding", + "physical": 2056, + "primitive_policy": "charged_fixed_tape_complete_streams", + "primitive_recipe": { + "center_backward": "zero at frame zero; accumulate transpose scatter; exact residual to retained frame; subtract into original; erase", + "center_forward": "copy at retained frame; exact residual to frame zero; scatter; erase", + "cross_phase": "i^(2xy) = i^x i^y i^(-(x xor y)); at most three parity-phase scans", + "entry_exit": "WinB.old_to_new and WinB.new_to_old, lowered as paid exact rank-zero Clifford operators", + "live_child": "exact target representative times inverse current representative; two rank-zero factors around one C tensor child", + "phase_scan": "evaluate fixed Z4 quadratic descriptors per record, multiply by fourth root, record suffix pays descriptor arithmetic", + "rank_zero": "binary Gaussian elimination; affine bit flips; Z4 linear phases and even cross terms; exact scalar fourth root", + "role_route": "permutation on all complete live/work roles, at most W_physical^2 complete-stream exchanges on fixed tapes", + "row_stock": "split only live complete rows; scalar-only work creates no row coordinate or recursive branch", + "scalar": "copy source to W; optional double/halve/divide3; signed accumulate; clear W", + "selected_bit": "compact-control-movement proposition, complete restored borrowed fields, paid repair, no RAM lookup" + }, + "recursive_volume_denominator": 1263, + "scratch_namespace": { + "centers": [ + 1263, + 1272 + ], + "coefficient": [ + 2055, + 2056 + ], + "tableau": [ + 1272, + 2055 + ] + }, + "stage_recipe": [ + { + "active_pair": 1, + "bank_owner": "d", + "exterior_subset": "empty", + "helper_owner": "d", + "native_frame": "(G0 d).X.Phi(frames[f])", + "old_frame": "(G0 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 0, + "window": "G0" + }, + { + "active_pair": 1, + "bank_owner": "r1(t)^(-1)(d)", + "exterior_subset": "qS bs1 l", + "helper_owner": "s1(d)", + "native_frame": "(G1 d).X.Phi(frames[f])", + "old_frame": "(G1 d).Xm.Phi(P)", + "orientation": "backward", + "stage": 1, + "window": "G1" + }, + { + "active_pair": 1, + "bank_owner": "r2(t)^(-1)(d)", + "exterior_subset": "qS bs2 l", + "helper_owner": "s2(d)", + "native_frame": "(G2 d).X.Phi(frames[f])", + "old_frame": "(G2 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 2, + "window": "G2" + }, + { + "active_pair": 2, + "bank_owner": "r3(t)^(-1)(d)", + "exterior_subset": "qS bs3 l", + "helper_owner": "s3(d)", + "native_frame": "(G3 d).X.Phi(frames[f])", + "old_frame": "(G3 d).Xm.Phi(P)", + "orientation": "backward", + "stage": 3, + "window": "G3" + }, + { + "active_pair": 2, + "bank_owner": "r4(t)^(-1)(d)", + "exterior_subset": "qS bs4 l", + "helper_owner": "s4(d)", + "native_frame": "(G4 d).X.Phi(frames[f])", + "old_frame": "(G4 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 4, + "window": "G4" + } + ] + }, + "program": { + "backward": { + "Gaussian_primitives": 36428, + "distinct_nested_pairs": 3120, + "entry_and_exit_old_new_adapters": 2046, + "event_counts": { + "adapter": 2046, + "center": 8, + "climb": 3965, + "phase": 9, + "scalar": 11669 + }, + "events": 17697, + "exact_common_label_live_incidences": 7024, + "exact_label_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0" + }, + "final_climbs_before_cleanup": true, + "live_transition_partition": { + "A": 1237, + "B": 1953, + "final": 775 + }, + "old_response_erased_before_all_children": true, + "paid_children": 3973, + "program_sha256": "4151e920bad851e9d7832f42ed7fa8b178cfbf001d56b22d198831f7d9ca6689", + "real_component_primitives": 72856, + "scalar_primitive_sha256": "520fad1c42e19510c1a091522e7a3fd6709d85db10df9a09d1af8553ce9f649e", + "scalar_projection_sha256": "e73ba422d94c229a05680251ab28a74cc7258fc3b50bf5061aaf57d42ac37e94" + }, + "forward": { + "Gaussian_primitives": 34079, + "distinct_nested_pairs": 3120, + "entry_and_exit_old_new_adapters": 2046, + "event_counts": { + "adapter": 2046, + "center": 8, + "climb": 3965, + "phase": 9, + "scalar": 10886 + }, + "events": 16914, + "exact_common_label_live_incidences": 7024, + "exact_label_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0" + }, + "final_climbs_before_cleanup": true, + "live_transition_partition": { + "A": 1237, + "B": 1953, + "final": 775 + }, + "old_response_erased_before_all_children": true, + "paid_children": 3973, + "program_sha256": "67f0d2f0564f6bd4cbda7fbb6c73451ab51caab2b3629f7cc712cc6ab0fe979d", + "real_component_primitives": 68158, + "scalar_primitive_sha256": "155ba11993ead90ac6814c9c21857ed1d42469b89e630d01494ecf7451b6cbda", + "scalar_projection_sha256": "92dafa62a52fcf152ce27b8f4ae481955416b4bebfc8f64894ace60318d4b417" + } + }, + "source_pin": "f010392c923279e3dd59ef3aa5fedad23affc5fd" + }, + "status": "PASS_FRESH_COMPLEX_LABEL_SCALAR_SPLICE_PRECISION" +} diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-data-banks-profile.log b/research/e8-retimed-component-verification/evidence/logs/candidate-data-banks-profile.log new file mode 100644 index 0000000000..ac525407e4 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-data-banks-profile.log @@ -0,0 +1,2 @@ +all 120 ports x 9 exact binary data-route checks PASS +candidate coarse 0.000999632926176283 halving 2 row provisional 15445 diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-data-cover-phases.log b/research/e8-retimed-component-verification/evidence/logs/candidate-data-cover-phases.log new file mode 100644 index 0000000000..7ad574c9ca --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-data-cover-phases.log @@ -0,0 +1 @@ +{'status': 'PASS_EXACT_Z4_DATA_ROUTE_IDLE_AND_TERMINAL_PHASES', 'm': 73, 'ports': 120, 'nonzero_stage_alignment_translations': 3840, 'terminal_omission_controls_rejected': 120, 'exact_phase_polynomial_evaluations': 40960, 'cover_correction': {'formula': 'delta(g)_i = (weight(row_i(g))-1)/2 mod 2; apply X_delta(g) to EVERY final live stream in cover class g.', 'reason': 'P_g C_all P_g^-1 = C_all X_delta(g) exactly. Orthogonality cancels all quadratic cross terms; both sides fix the uniform vector.', 'mandatory': True, 'complete_small_cover_checks': [{'n': 1, 'orthogonal_matrices': 1, 'nonzero_full_kernel_corrections': 0}, {'n': 2, 'orthogonal_matrices': 2, 'nonzero_full_kernel_corrections': 0}, {'n': 3, 'orthogonal_matrices': 6, 'nonzero_full_kernel_corrections': 0}, {'n': 4, 'orthogonal_matrices': 48, 'nonzero_full_kernel_corrections': 24}, {'n': 5, 'orthogonal_matrices': 720, 'nonzero_full_kernel_corrections': 600}]}, 'global_phase_argument': 'Every C_q and every linear address permutation fixes the uniform vector. Equality of the exact Z4 Fourier multiplier therefore fixes the scalar phase as well.', 'scope': 'All compressed data boundary operators, idle children, terminal X_q and all-live cover correction. Internal arbitrary-subspace canonical labels are checked separately.'} diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-exact-clifford.log b/research/e8-retimed-component-verification/evidence/logs/candidate-exact-clifford.log new file mode 100644 index 0000000000..bf2314441c --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-exact-clifford.log @@ -0,0 +1,18 @@ +canonical exact circuits and preimage labels 948 PASS +children 0 / 3122 seconds 0.2932755419751629 +children 200 / 3122 seconds 4.162192541989498 +children 400 / 3122 seconds 8.159302124986425 +children 600 / 3122 seconds 12.349640457890928 +children 800 / 3122 seconds 17.19476337498054 +children 1000 / 3122 seconds 22.038198166992515 +children 1200 / 3122 seconds 26.649091707891785 +children 1400 / 3122 seconds 31.599966332898475 +children 1600 / 3122 seconds 36.66931454197038 +children 1800 / 3122 seconds 41.63113474997226 +children 2000 / 3122 seconds 46.6204061669996 +children 2200 / 3122 seconds 51.62870349991135 +children 2400 / 3122 seconds 56.608355457894504 +children 2600 / 3122 seconds 61.59250033297576 +children 2800 / 3122 seconds 66.65047954197507 +children 3000 / 3122 seconds 71.66945566690993 +{'status': 'PASS_EXACT_GAUSSIAN_CLIFFORD_LOCAL_FRAMES_AND_CHILDREN', 'frames': 948, 'distinct_directed_edges': 3122, 'ranks': {9: 2, 1: 1524, 8: 24, 2: 461, 3: 484, 4: 102, 6: 300, 5: 182, 7: 43}, 'endpoint_adapters': 240, 'recipe_sha256': '1d09d59e7579912d07c8546f293d6ef1596a17b1c8d6e2ed061d279c0b366e1b', 'all_child_equalities_include_global_phase': True, 'small_full_column_controls': [{'h': 1, 'circuits': 32, 'all_address_columns': 64, 'wrong_global_phase_rejected': 32}, {'h': 2, 'circuits': 32, 'all_address_columns': 128, 'wrong_global_phase_rejected': 32}, {'h': 3, 'circuits': 32, 'all_address_columns': 256, 'wrong_global_phase_rejected': 32}, {'h': 4, 'circuits': 32, 'all_address_columns': 512, 'wrong_global_phase_rejected': 32}], 'seconds': 76.19533533288632, 'scope': 'Fixed E8 local frames, every used nested transition, copied-center directions and old/new endpoint adapters. Does not by itself admit nine-stage global cover, routing or all-size theorem.'} diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-fixed-old-bit-regression.log b/research/e8-retimed-component-verification/evidence/logs/candidate-fixed-old-bit-regression.log new file mode 100644 index 0000000000..1f9a0203d8 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-fixed-old-bit-regression.log @@ -0,0 +1 @@ +PASS_NUMERICAL_OUTER_CHECK_WITH_FIXED_BIT_NO_KAPPA_IMPROVEMENT diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-full-local-admission.log b/research/e8-retimed-component-verification/evidence/logs/candidate-full-local-admission.log new file mode 100644 index 0000000000..52f34b5e6b --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-full-local-admission.log @@ -0,0 +1,8 @@ +Checking the complex program: gx.check1 with the exact scalar identity, and the gxcore mirror. +Checking every complex source label and paid child. +Deriving both complex scalar words and temporary lifetimes. +Merging scalar events, exact frames and all final climbs. +Recomputing complex cover, router, precision and row inequalities. +PASS actual dirty scalar word forward 10886 +PASS actual dirty scalar word backward 11669 +PASS corrected complete invoice 990 11162 diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-global-invoice.log b/research/e8-retimed-component-verification/evidence/logs/candidate-global-invoice.log new file mode 100644 index 0000000000..3a5b074af9 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-global-invoice.log @@ -0,0 +1 @@ +{'status': 'PASS_NINE_STAGE_SOURCE_BOUND_TEMPLATE_OWNERS_PROFILE_AND_FINITE_INVOICE', 'm': 73, 'live': 14727, 'physical': 15520, 'invocations': 72, 'local_source_events': 1242864, 'paid_calls': 310383, 'rank_mass': 1072575, 'deficit': 2496, 'profile': {1: 157743, 2: 43632, 3: 37728, 4: 8568, 5: 15480, 6: 24552, 7: 3096, 8: 7488, 9: 576, 16: 3840, 32: 3840, 48: 3840}, 'whole_residual_assignments': 56376, 'bank_padding_calls': 7047, 'bridge_additions': 17280, 'terminal_shift_calls': 3840, 'terminal_complete_stream_movements': 7680, 'work_lifetimes_freshly_revalidated': True, 'owner_injections': True, 'cover_route_bijections': 'Explicit invertible right factors; roles sharing a bank have different disjoint block images, hence different right factors.', 'template_sha256': 'eafb27e64cfb1b4b89e3f6bd467c2fb5828b6f5db7f7e2511f5fd241abba6b5f', 'finite_invoice': {'local_primitive_bound': 7040031186072, 'local_adapters': 271456, 'compiler': 25934336, 'scalar_primitives_all_invocations': 5057712, 'outside_adapter_bound': 1988400, 'pervertex': 558450079948471, 'group_bits': 2628, 'live_stock_bits': 2642, 'physical_stock_bits': 2642, 'logical_groups_bits': 2677, 'router_bits': 7984, 'literal_bits': 35284, 'required_C0_bits': 200012, 'G_exponent': 30000, 'E_exponent': 100000, 'C0_exponent': 210000, 'halving_degree': 2, 'halving_integer_inequality': [5329, 4608], 'induction_gap_multiple_B': 49, 'physical_row_coefficient': 15445, 'retained_row_coefficient': 20161}, 'source_hashes': {'/private/tmp/task2-pr384-component-verification-fresh/candidate/work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_splice.py': 'aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce', 'work/complex-nine-native/local-admission/UPSTREAM-GUARD.json': 'b3a5225ace875c14c90adeb4dfec0f9afc167bf9700483d2de35aac15d66d104', 'work/complex-nine-native/local-admission/INDEPENDENT-AUDIT.json': 'd96cb98da13bfa4bdd8e2ac00552df3a7a9c88f5247e2970464da3d070b83df0', 'work/complex-nine-native/CLIFFORD-REVIEW.json': '633d28a226f71282af65aab142a784cd2d09d9885e25960cadc115b51c882ff8', 'work/complex-nine-native/DATA-PHASES.json': 'f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a'}, 'seconds': 12.064479958964512, 'scope': 'Finite source-bound global recipe, exact owner factors, paid histogram and conservative scalar/tape/precision/row invoice. Requires explicit mathematical integration of the compressed window lift and arbitrary-bank dirty composition; this is not a Lean proof or final multiplication exponent certificate.', 'cover_correction_calls': 14727} diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-independent-template-moments.log b/research/e8-retimed-component-verification/evidence/logs/candidate-independent-template-moments.log new file mode 100644 index 0000000000..065696637e --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-independent-template-moments.log @@ -0,0 +1 @@ +{'status': 'PASS_INDEPENDENT_EMITTED_TEMPLATE_AUDIT_AND_TWO_MOMENTS', 'template_sha256': 'eafb27e64cfb1b4b89e3f6bd467c2fb5828b6f5db7f7e2511f5fd241abba6b5f', 'coarse_complex': '999632926176283/1000000000000000000', 'next_grid_rejected': True, 'all_eight_signed_data_columns': True, 'bridge_omission_controls': 9, 'structural_controls_rejected': ['missing_cover_phase', 'aliased_helper_route', 'missing_padding', 'wrong_reverse_local', 'omitted_terminal_exchange'], 'paid_profile': {1: 157743, 2: 43632, 3: 37728, 4: 8568, 5: 15480, 6: 24552, 7: 3096, 8: 7488, 9: 576, 16: 3840, 32: 3840, 48: 3840}, 'fixed_baseline_kappa': '804849251275843/1000000000000000000', 'final_kappa_improvement_claim': False, 'scope': 'Finite complex component with explicit PROOF.txt retaining the analytic interfaces. No Lean rebuild and no improved bit-side or multiplication certificate.'} diff --git a/research/e8-retimed-component-verification/evidence/logs/candidate-regression-pin-preparation.log b/research/e8-retimed-component-verification/evidence/logs/candidate-regression-pin-preparation.log new file mode 100644 index 0000000000..033b8f8c50 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/candidate-regression-pin-preparation.log @@ -0,0 +1,6 @@ +Checking the complex program: gx.check1 with the exact scalar identity, and the gxcore mirror. +Checking every complex source label and paid child. +Deriving both complex scalar words and temporary lifetimes. +Merging scalar events, exact frames and all final climbs. +Recomputing complex cover, router, precision and row inequalities. +PIN_PREPARATION_ONLY; final strict pinned replay required diff --git a/research/e8-retimed-component-verification/evidence/logs/original377-full-eight-stage-regression.log b/research/e8-retimed-component-verification/evidence/logs/original377-full-eight-stage-regression.log new file mode 100644 index 0000000000..3c7837e71d --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/logs/original377-full-eight-stage-regression.log @@ -0,0 +1,9 @@ +frozen-source-integrity +fresh-local-admission +finite-data-banks-profile +exact-clifford-recipes +exact-data-and-cover-phases +global-template-and-invoice +independent-template-two-moments +fixed-bit-outer-check +PASS_PORTABLE_NINE_STAGE_COMPLEX_FINITE_COMPONENT diff --git a/research/e8-retimed-component-verification/evidence/measured-pins.json b/research/e8-retimed-component-verification/evidence/measured-pins.json new file mode 100644 index 0000000000..d5578b4076 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/measured-pins.json @@ -0,0 +1,58 @@ +{ + "H": 9, + "N": 9039, + "R": 783, + "V": 120, + "centre_ranks": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "climb_backward": 3965, + "climb_forward": 3965, + "climbed": { + "A": 1237, + "B": 1953, + "final": 775 + }, + "cst": 72, + "frames": 948, + "gates": [ + 775, + 1226 + ], + "label_histogram": { + "1": 2093, + "2": 606, + "3": 524, + "4": 119, + "5": 215, + "6": 341, + "7": 43, + "8": 24, + "9": 8 + }, + "ledger": [ + 20825, + 56715, + 120, + 20 + ], + "local_bill": 839936556184, + "scalar_steps": [ + 68158, + 72856 + ], + "scatter": "8178452d0315a0e454b6230b41fd4dca2a55b5519718a2c1ba523f60917a79d4", + "stock_bits": [ + 947, + 957, + 958, + 963 + ] +} diff --git a/research/e8-retimed-component-verification/evidence/original-pins-e8.json b/research/e8-retimed-component-verification/evidence/original-pins-e8.json new file mode 100644 index 0000000000..ba757ae806 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original-pins-e8.json @@ -0,0 +1,58 @@ +{ + "V": 120, + "R": 783, + "H": 9, + "cst": 72, + "N": 9039, + "frames": 946, + "scatter": "8178452d0315a0e454b6230b41fd4dca2a55b5519718a2c1ba523f60917a79d4", + "gates": [ + 773, + 1220 + ], + "centre_ranks": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "label_histogram": { + "1": 2091, + "2": 604, + "3": 518, + "4": 140, + "5": 215, + "6": 331, + "7": 43, + "8": 24, + "9": 8 + }, + "ledger": [ + 20830, + 56715, + 120, + 20 + ], + "scalar_steps": [ + 68158, + 72856 + ], + "climbed": { + "A": 1239, + "B": 1952, + "final": 775 + }, + "climb_forward": 3966, + "climb_backward": 3966, + "local_bill": 839986392216, + "stock_bits": [ + 947, + 957, + 958, + 963 + ] +} \ No newline at end of file diff --git a/research/e8-retimed-component-verification/evidence/original-run-adapter/ADAPTER.diff b/research/e8-retimed-component-verification/evidence/original-run-adapter/ADAPTER.diff new file mode 100644 index 0000000000..e0c0c222eb --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original-run-adapter/ADAPTER.diff @@ -0,0 +1,21 @@ +--- original377/work/odd-stages/global_nine.py ++++ adapter/work/odd-stages/global_nine.py +@@ -69,7 +69,7 @@ + # slot. Calls, replicas and cover classes run sequentially; their clean work + # is reused only after the source-checked erasure events. + macros=max(raw['scalar_bill'][o]['totals']['scalar_macros'] for o in locals) +-local_children=raw['label_checks']['invocation_calls'];assert local_children==3974 ++local_children=raw['label_checks']['invocation_calls'];assert local_children==3973 + compiler=64*(m+1)**3 + local_adapter_bound=16*(macros+local_children+(2*v+R)+h)+64*m + local_primitive=max(local_checks[o]['real_component_primitives'] for o in locals) +--- original377/work/odd-stages/audit_nine_template.py ++++ adapter/work/odd-stages/audit_nine_template.py +@@ -71,6 +71,6 @@ + M=engine('moment');B=engine('base_two_moment');r=M.certify(H,73,14727,True);b=Q(int(Q(r['lower'])*10**18),10**18);grid=Q(1,10**18);fb=32*73**2*sum(H.values()) + lo,up=M.moment(H,73,14727,b,True);nl,nu=M.moment(H,73,14727,b+grid,True);assert up<12*maxchild**t);assert depth==2 +induction=2*(m-maxchild)-1;assert 2*B*(m-maxchild)-s_mass-E==induction*B and induction>=1 +assert local_bound<1<<48 and logical<1<<6050 and router0 +for e in range(1,100001): + f=e//m;assert (maxchild*(maxchild*f//m))*22r^2 proves all e. +template=dict(version='independent-compressed-nine-v1',m=m,cover='all matrices d in O(73,2), in lexicographic row order',loop_order='For each recipe phase: replicas in increasing order, then every cover class d; each local invocation completes before the next.',live=live,physical=physical,recipe=recipe,local_programs=locals,calls=calls,bank_padding=dict(families=list(range(2*k*v*T,live)),axis=72,child_rank=1),idle_children=idle,exact_data_phase_recipe_sha256=sha(OUT/'DATA-PHASES.json'),exact_local_clifford_recipe_sha256=sha(OUT/'CLIFFORD-RECIPES.json'),private_namespace=dict(centers=[live,live+h],tableau=[live+h,live+h+R],coefficient=[physical-1,physical]),route_semantics={'data':'physical cover class d*rho(stage,port); rho is the exact orthogonal involution from data_phases.py','helper':'physical cover class d*Pi(slot)^(-1); Pi swaps the local nine coordinates with the assigned bank block','work':'private family at class d; every allocated work stream is erased before reuse'},adapter_policy='Use the exact rank-zero translations in DATA-PHASES.json, the explicit Gaussian monomial adapters in CLIFFORD-RECIPES.json, and the literal terminal X_q before signed exchange.') +template['cover_final_correction']=dict(kind='translate_every_live_family',formula='delta_i=(weight(row_i(g))-1)/2 mod 2',families=[0,live],must_follow_bank_padding_and_data_signed_exchange=True,charged_calls_per_cover=cover_corrections) +schedule=[] +for e in recipe: + if e['kind']=='local': + s=e['stage'];schedule.append(dict(kind='local_cover_sweep',stage=s,replicas=list(range(T)),entry_exit_phase_adapters='DATA-PHASES.recipes[port].stage_alignment[stage]')) + if s in (1,3,5): + j=(s+1)//2;schedule.append(dict(kind='idle_cover_sweep',pair=j,child_indices=[4*(j-1),4*(j-1)+2],from_level=-1,to_level=s)) + elif s in (2,4,6): + j=s//2;schedule.append(dict(kind='idle_cover_sweep',pair=j,child_indices=[4*(j-1)+1,4*(j-1)+3],from_level=s-1,to_level=s)) + elif s==8: + for j in range(4):schedule.append(dict(kind='idle_cover_sweep',pair=j,child_indices=[12+2*j,13+2*j],from_level=2*j+2,to_level=8)) + elif e['kind']=='bridge':schedule.append(dict(e)) + else: + schedule.append(dict(kind='terminal_Y_translations',pairs=list(range(4)),vector='port q transported by its cover matrix g')) + schedule.append(dict(e)) +schedule.append(dict(kind='bank_padding_cover_sweep',families=[7680,live],axis=72,rank=1)) +schedule.append(dict(template['cover_final_correction'])) +template['execution_schedule']=schedule +blob=json.dumps(template,sort_keys=True,separators=(',',':')).encode();(OUT/'GLOBAL-TEMPLATE.json.gz').write_bytes(gzip.compress(blob,mtime=0)) +invoice=dict(local_primitive_bound=local_bound,local_adapters=local_adapter_bound,compiler=compiler,scalar_primitives_all_invocations=scalar_primitives,outside_adapter_bound=outside,pervertex=pervertex,group_bits=group.bit_length(),live_stock_bits=stock.bit_length(),physical_stock_bits=physical_stock.bit_length(),logical_groups_bits=logical.bit_length(),router_bits=router.bit_length(),literal_bits=literal.bit_length(),required_C0_bits=(32*m*B*B).bit_length(),G_exponent=30000,E_exponent=100000,C0_exponent=210000,halving_degree=depth,halving_integer_inequality=[m**depth,2*maxchild**depth],induction_gap_multiple_B=induction,physical_row_coefficient=row,retained_row_coefficient=20161) +result=dict(status='PASS_NINE_STAGE_SOURCE_BOUND_TEMPLATE_OWNERS_PROFILE_AND_FINITE_INVOICE',m=m,live=live,physical=physical,invocations=72,local_source_events=event_count,paid_calls=sum(paid.values()),rank_mass=mass,deficit=2496,profile=dict(sorted(paid.items())),whole_residual_assignments=len(seen_assign),bank_padding_calls=L*R,bridge_additions=bridge_adds,terminal_shift_calls=terminal_shifts,terminal_complete_stream_movements=terminal_movements,work_lifetimes_freshly_revalidated=True,owner_injections=True,cover_route_bijections='Explicit invertible right factors; roles sharing a bank have different disjoint block images, hence different right factors.',template_sha256=hashlib.sha256(blob).hexdigest(),finite_invoice=invoice,source_hashes={str(p):sha(p) for p in [ROOT/'code/complex_splice.py',OUT/'local-admission/UPSTREAM-GUARD.json',OUT/'local-admission/INDEPENDENT-AUDIT.json',OUT/'CLIFFORD-REVIEW.json',OUT/'DATA-PHASES.json']},seconds=time.monotonic()-t0,scope='Finite source-bound global recipe, exact owner factors, paid histogram and conservative scalar/tape/precision/row invoice. Requires explicit mathematical integration of the compressed window lift and arbitrary-bank dirty composition; this is not a Lean proof or final multiplication exponent certificate.') +result['cover_correction_calls']=cover_corrections +(OUT/'GLOBAL-REVIEW.json').write_text(json.dumps(result,indent=2));print(result,flush=True) diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/exact-clifford-recipes.log b/research/e8-retimed-component-verification/evidence/original377-logs/exact-clifford-recipes.log new file mode 100644 index 0000000000..75e239f119 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/exact-clifford-recipes.log @@ -0,0 +1,18 @@ +canonical exact circuits and preimage labels 946 PASS +children 0 / 3120 seconds 0.281606666976586 +children 200 / 3120 seconds 4.0503234579227865 +children 400 / 3120 seconds 7.965087207965553 +children 600 / 3120 seconds 12.061989999958314 +children 800 / 3120 seconds 16.797965416917577 +children 1000 / 3120 seconds 21.593162833014503 +children 1200 / 3120 seconds 26.140279916930012 +children 1400 / 3120 seconds 31.058064416982234 +children 1600 / 3120 seconds 36.087696583010256 +children 1800 / 3120 seconds 41.018093457911164 +children 2000 / 3120 seconds 45.99409849999938 +children 2200 / 3120 seconds 50.99546720797662 +children 2400 / 3120 seconds 55.94832762493752 +children 2600 / 3120 seconds 60.92116024997085 +children 2800 / 3120 seconds 65.98160229192581 +children 3000 / 3120 seconds 71.00176129199099 +{'status': 'PASS_EXACT_GAUSSIAN_CLIFFORD_LOCAL_FRAMES_AND_CHILDREN', 'frames': 946, 'distinct_directed_edges': 3120, 'ranks': {9: 2, 1: 1519, 8: 24, 2: 465, 3: 484, 4: 113, 6: 292, 5: 178, 7: 43}, 'endpoint_adapters': 240, 'recipe_sha256': '5bfabfdf50aff6d3387d7eb702dbba740b4ca64e7a449ec4924cc9d9f34b6d09', 'all_child_equalities_include_global_phase': True, 'small_full_column_controls': [{'h': 1, 'circuits': 32, 'all_address_columns': 64, 'wrong_global_phase_rejected': 32}, {'h': 2, 'circuits': 32, 'all_address_columns': 128, 'wrong_global_phase_rejected': 32}, {'h': 3, 'circuits': 32, 'all_address_columns': 256, 'wrong_global_phase_rejected': 32}, {'h': 4, 'circuits': 32, 'all_address_columns': 512, 'wrong_global_phase_rejected': 32}], 'seconds': 75.42735733301379, 'scope': 'Fixed E8 local frames, every used nested transition, copied-center directions and old/new endpoint adapters. Does not by itself admit nine-stage global cover, routing or all-size theorem.'} diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/exact-data-and-cover-phases.log b/research/e8-retimed-component-verification/evidence/original377-logs/exact-data-and-cover-phases.log new file mode 100644 index 0000000000..7ad574c9ca --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/exact-data-and-cover-phases.log @@ -0,0 +1 @@ +{'status': 'PASS_EXACT_Z4_DATA_ROUTE_IDLE_AND_TERMINAL_PHASES', 'm': 73, 'ports': 120, 'nonzero_stage_alignment_translations': 3840, 'terminal_omission_controls_rejected': 120, 'exact_phase_polynomial_evaluations': 40960, 'cover_correction': {'formula': 'delta(g)_i = (weight(row_i(g))-1)/2 mod 2; apply X_delta(g) to EVERY final live stream in cover class g.', 'reason': 'P_g C_all P_g^-1 = C_all X_delta(g) exactly. Orthogonality cancels all quadratic cross terms; both sides fix the uniform vector.', 'mandatory': True, 'complete_small_cover_checks': [{'n': 1, 'orthogonal_matrices': 1, 'nonzero_full_kernel_corrections': 0}, {'n': 2, 'orthogonal_matrices': 2, 'nonzero_full_kernel_corrections': 0}, {'n': 3, 'orthogonal_matrices': 6, 'nonzero_full_kernel_corrections': 0}, {'n': 4, 'orthogonal_matrices': 48, 'nonzero_full_kernel_corrections': 24}, {'n': 5, 'orthogonal_matrices': 720, 'nonzero_full_kernel_corrections': 600}]}, 'global_phase_argument': 'Every C_q and every linear address permutation fixes the uniform vector. Equality of the exact Z4 Fourier multiplier therefore fixes the scalar phase as well.', 'scope': 'All compressed data boundary operators, idle children, terminal X_q and all-live cover correction. Internal arbitrary-subspace canonical labels are checked separately.'} diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/finite-data-banks-profile.log b/research/e8-retimed-component-verification/evidence/original377-logs/finite-data-banks-profile.log new file mode 100644 index 0000000000..3825ce0f20 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/finite-data-banks-profile.log @@ -0,0 +1,2 @@ +all 120 ports x 9 exact binary data-route checks PASS +candidate coarse 0.000999240641319551 halving 2 row provisional 15445 diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/fixed-bit-outer-check.log b/research/e8-retimed-component-verification/evidence/original377-logs/fixed-bit-outer-check.log new file mode 100644 index 0000000000..1f9a0203d8 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/fixed-bit-outer-check.log @@ -0,0 +1 @@ +PASS_NUMERICAL_OUTER_CHECK_WITH_FIXED_BIT_NO_KAPPA_IMPROVEMENT diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/fresh-local-admission.log b/research/e8-retimed-component-verification/evidence/original377-logs/fresh-local-admission.log new file mode 100644 index 0000000000..52f34b5e6b --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/fresh-local-admission.log @@ -0,0 +1,8 @@ +Checking the complex program: gx.check1 with the exact scalar identity, and the gxcore mirror. +Checking every complex source label and paid child. +Deriving both complex scalar words and temporary lifetimes. +Merging scalar events, exact frames and all final climbs. +Recomputing complex cover, router, precision and row inequalities. +PASS actual dirty scalar word forward 10886 +PASS actual dirty scalar word backward 11669 +PASS corrected complete invoice 990 11162 diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/frozen-source-integrity.log b/research/e8-retimed-component-verification/evidence/original377-logs/frozen-source-integrity.log new file mode 100644 index 0000000000..5bd4d8e27c --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/frozen-source-integrity.log @@ -0,0 +1 @@ +3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/global-template-and-invoice.log b/research/e8-retimed-component-verification/evidence/original377-logs/global-template-and-invoice.log new file mode 100644 index 0000000000..47afed39ee --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/global-template-and-invoice.log @@ -0,0 +1 @@ +{'status': 'PASS_NINE_STAGE_SOURCE_BOUND_TEMPLATE_OWNERS_PROFILE_AND_FINITE_INVOICE', 'm': 73, 'live': 14727, 'physical': 15520, 'invocations': 72, 'local_source_events': 1242936, 'paid_calls': 310455, 'rank_mass': 1072575, 'deficit': 2496, 'profile': {1: 157599, 2: 43488, 3: 37296, 4: 10080, 5: 15480, 6: 23832, 7: 3096, 8: 7488, 9: 576, 16: 3840, 32: 3840, 48: 3840}, 'whole_residual_assignments': 56376, 'bank_padding_calls': 7047, 'bridge_additions': 17280, 'terminal_shift_calls': 3840, 'terminal_complete_stream_movements': 7680, 'work_lifetimes_freshly_revalidated': True, 'owner_injections': True, 'cover_route_bijections': 'Explicit invertible right factors; roles sharing a bank have different disjoint block images, hence different right factors.', 'template_sha256': 'fb51fe86a8299b4c5f3d03d90e8766e321d534f29fe4ab9d093fdfb8b9826a13', 'finite_invoice': {'local_primitive_bound': 7040446135448, 'local_adapters': 271472, 'compiler': 25934336, 'scalar_primitives_all_invocations': 5057712, 'outside_adapter_bound': 1988400, 'pervertex': 558479956303543, 'group_bits': 2628, 'live_stock_bits': 2642, 'physical_stock_bits': 2642, 'logical_groups_bits': 2677, 'router_bits': 7984, 'literal_bits': 35284, 'required_C0_bits': 200012, 'G_exponent': 30000, 'E_exponent': 100000, 'C0_exponent': 210000, 'halving_degree': 2, 'halving_integer_inequality': [5329, 4608], 'induction_gap_multiple_B': 49, 'physical_row_coefficient': 15445, 'retained_row_coefficient': 20161}, 'source_hashes': {'/private/tmp/task2-pr384-component-verification-fresh/original377/work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_splice.py': 'aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce', 'work/complex-nine-native/local-admission/UPSTREAM-GUARD.json': '85ef9f1ebbaee76a67b5ee1ec37604047a73f8b937322078ce893369e6209adf', 'work/complex-nine-native/local-admission/INDEPENDENT-AUDIT.json': '849449d4b3d58bd3acab893303dae50cf84324d2a8d80c7db3c335913be100aa', 'work/complex-nine-native/CLIFFORD-REVIEW.json': '896e96ac8405633598b422607d10bb9b5b6fc53f20af8722992c37e5dcbf3fcc', 'work/complex-nine-native/DATA-PHASES.json': 'f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a'}, 'seconds': 12.03602849994786, 'scope': 'Finite source-bound global recipe, exact owner factors, paid histogram and conservative scalar/tape/precision/row invoice. Requires explicit mathematical integration of the compressed window lift and arbitrary-bank dirty composition; this is not a Lean proof or final multiplication exponent certificate.', 'cover_correction_calls': 14727} diff --git a/research/e8-retimed-component-verification/evidence/original377-logs/independent-template-two-moments.log b/research/e8-retimed-component-verification/evidence/original377-logs/independent-template-two-moments.log new file mode 100644 index 0000000000..47ba00f316 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/original377-logs/independent-template-two-moments.log @@ -0,0 +1 @@ +{'status': 'PASS_INDEPENDENT_EMITTED_TEMPLATE_AUDIT_AND_TWO_MOMENTS', 'template_sha256': 'fb51fe86a8299b4c5f3d03d90e8766e321d534f29fe4ab9d093fdfb8b9826a13', 'coarse_complex': '999240641319551/1000000000000000000', 'next_grid_rejected': True, 'all_eight_signed_data_columns': True, 'bridge_omission_controls': 9, 'structural_controls_rejected': ['missing_cover_phase', 'aliased_helper_route', 'missing_padding', 'wrong_reverse_local', 'omitted_terminal_exchange'], 'paid_profile': {1: 157599, 2: 43488, 3: 37296, 4: 10080, 5: 15480, 6: 23832, 7: 3096, 8: 7488, 9: 576, 16: 3840, 32: 3840, 48: 3840}, 'fixed_baseline_kappa': '804849251275843/1000000000000000000', 'final_kappa_improvement_claim': False, 'scope': 'Finite complex component with explicit PROOF.txt retaining the analytic interfaces. No Lean rebuild and no improved bit-side or multiplication certificate.'} diff --git a/research/e8-retimed-component-verification/evidence/pin-preparation-guard.json b/research/e8-retimed-component-verification/evidence/pin-preparation-guard.json new file mode 100644 index 0000000000..e6b2a6fcc8 --- /dev/null +++ b/research/e8-retimed-component-verification/evidence/pin-preparation-guard.json @@ -0,0 +1,990 @@ +{ + "five_stage_histogram": { + "1": 10465, + "16": 240, + "2": 3030, + "20": 240, + "3": 2620, + "4": 835, + "5": 1075, + "6": 1705, + "7": 215, + "8": 360, + "9": 40 + }, + "inherited_theorem_dependencies": [ + "The pinned gcert/1 program is accepted, fresh in this run, by Sussman's reference checker gx.check1 with the exact scalar identity (E5) and by his gxcore mirror of the two Lean checks; a flipped scalar sign is rejected by both. No Lean check of this program is pinned in this package.", + "Pinned Lab.inv dirty lifting, exact gwinB/G0..G4 geometry, owner bijections and NetCert composition are inherited source theorems.", + "Retained general Clifford synthesis, compact complete-stream tape primitives, common-grid precision and complete-row proofs remain analytic dependencies.", + "The finite operational recipe is regenerated and checked; no astronomical cover enumeration or universal tape-machine execution is claimed." + ], + "input_pins": { + "inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "f2664ee7bcdfb55893abe9f1be8ee6a394a602e8262e611de2a0328bbd508aa7", + "inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf" + }, + "label_checks": { + "Cc_copy_additions": 8, + "Y_bracket_pairs": 0, + "centre_ranks": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "frame_count": 948, + "invocation_calls": 3973, + "invocation_histogram": { + "1": 2093, + "2": 606, + "3": 524, + "4": 119, + "5": 215, + "6": 341, + "7": 43, + "8": 24, + "9": 8 + }, + "invocation_rank_mass": 9039, + "limits": [ + "No scalar all-column replay", + "No old-response or cleanup matrix formed", + "No generated Lean data comparison or kernel build", + "No physical stream compiler" + ], + "literal_gate_coefficients": { + "-1": 628, + "-1/2": 417, + "-2": 91, + "1": 1644, + "1/2": 323, + "2": 37 + }, + "literal_inverse": "Each nonself additive shear inverts by negating its coefficient; inverse phase reverses order; inverse transpose keeps chronological order and swaps source/target with negation.", + "live_registers_per_invocation": 1023, + "phase_histograms": { + "A": { + "1": 765, + "2": 230, + "3": 123, + "4": 4, + "5": 13, + "6": 50, + "7": 30, + "8": 22 + }, + "B": { + "1": 874, + "2": 302, + "3": 290, + "4": 87, + "5": 172, + "6": 213, + "7": 13, + "8": 2 + }, + "copy": { + "9": 8 + }, + "final": { + "1": 454, + "2": 74, + "3": 111, + "4": 28, + "5": 30, + "6": 78 + } + }, + "phase_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0", + "start": "5166476b2cb28fc9a2b5686ef821c3510527d5921a0c9fd32782d5da358d29bf" + }, + "phase_stats": { + "A": { + "gates": 775, + "register_visits": 2237, + "scalar_additions": 1462, + "spectator_visits": 0 + }, + "B": { + "gates": 1226, + "register_visits": 2904, + "scalar_additions": 1678, + "spectator_visits": 0 + } + }, + "ranked_live_transitions": 3965, + "retained_centers": [ + [ + 0, + 504, + 1 + ], + [ + 1, + 505, + 1 + ], + [ + 2, + 506, + 1 + ], + [ + 3, + 507, + 1 + ], + [ + 4, + 508, + 1 + ], + [ + 5, + 509, + 1 + ], + [ + 6, + 510, + 1 + ], + [ + 7, + 511, + 1 + ] + ], + "role_histograms": { + "c": { + "9": 8 + }, + "s": { + "1": 1892, + "2": 528, + "3": 468, + "4": 83, + "5": 182, + "6": 229, + "7": 9, + "8": 2 + }, + "x": { + "1": 119, + "2": 33, + "3": 22, + "4": 4, + "5": 13, + "6": 50, + "7": 24, + "8": 20 + }, + "y": { + "1": 82, + "2": 45, + "3": 34, + "4": 32, + "5": 20, + "6": 62, + "7": 10, + "8": 2 + } + }, + "scalar_role_directions": { + "A:s->s": 532, + "A:x->s": 930, + "B:s->s": 1012, + "B:s->y": 666 + }, + "scatter_additions": 736, + "scatter_coefficients": { + "-1/2": 28, + "-1/6": 448, + "1/2": 36, + "1/3": 224 + }, + "temporary_centers": 8, + "tested_distinct_nested_pairs": 3120, + "two_hosts_metadata_count": 0, + "two_hosts_note": "Metadata only; not an independent allocator or host-use proof." + }, + "ledger": { + "calls": 20825, + "centres": 8, + "copy_calls": 40, + "deficit": 120, + "histogram": { + "1": 10465, + "16": 240, + "2": 3030, + "20": 240, + "3": 2620, + "4": 835, + "5": 1075, + "6": 1705, + "7": 215, + "8": 360, + "9": 40 + }, + "idle_calls": 960, + "max_child": 20, + "rank_mass": 56715 + }, + "precision_guard": { + "C0_exponent": 210000, + "E_exponent": 100000, + "G_exponent": 30000, + "binary_basis_count_tests": [ + { + "invertible_matrices": 1, + "m": 1, + "maximum_selected_bit_additions": 0 + }, + { + "invertible_matrices": 6, + "m": 2, + "maximum_selected_bit_additions": 4 + }, + { + "invertible_matrices": 168, + "m": 3, + "maximum_selected_bit_additions": 10 + }, + { + "invertible_matrices": 20160, + "m": 4, + "maximum_selected_bit_additions": 18 + } + ], + "coefficient_denominators": [ + 1, + 2, + 3, + 6 + ], + "complete_local_group_bits": 40, + "complete_local_group_upper": 839936556184, + "controls": { + "dropped_center": true, + "missing_tableau": true, + "scratch_in_live": true, + "stale_stock_bound": true, + "unrecorded_divisor": true + }, + "global_logical_groups_bits": 989, + "group_bits": 947, + "induction_gap_multiple_of_B": 49, + "literal_charge_bits": 31916, + "live_per_vertex": 1263, + "live_row_coefficient": 11118, + "live_stock_bits": 957, + "m": 45, + "odd_denominator_grid": "2^(-P)3^(-G(D+1)); no return rounding", + "physical_per_vertex": 2056, + "physical_row_overcharge_coefficient": 11119, + "physical_stock_bits": 958, + "rank_mass_bits": 963, + "required_C0_bits": 200011, + "retained_row_coefficient": 20161, + "retained_row_gap": "23971789/25", + "router_bits": 2926, + "semantic_C1": 1, + "simple_global_logical_bound_exponent": 6050, + "status": "PASS_FRESH_EXACT_COMPLEX_GUARD" + }, + "program_check": { + "blocks_total": 3973, + "certificate_sha256": "f2a404fe3f00cf843718fc8c23c6227d84e5e65c5a19cc1141dc1a6997ca86e7", + "controls": [ + { + "checker": "gx.check1", + "name": "flipped_scalar_sign", + "reason": "E5: a target does not receive exactly its source (hid)" + }, + { + "checker": "gxcore.mirror", + "name": "flipped_scalar_sign", + "reason": "E5: a target does not receive exactly its source (hid)" + } + ], + "distinct_frame_steps": 3120, + "gates_A": 775, + "gates_B": 1226, + "gx_check1": "ACCEPTED (labels, blocks, N, exact scalar identity E5, Q2)", + "gx_sha256": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "gxcore_mirror": "ACCEPTED (label and scalar checks; histogram equals the blocks)", + "gxcore_sha256": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "lean": "not run here; no Lean check of this program is pinned in this package", + "scalar_denominators": { + "s": 2, + "x": 1, + "y": 6 + }, + "scalar_max_abs": { + "s": "2", + "x": "0", + "y": "4/3" + }, + "seconds": 0.16464679094497114, + "status": "PASS_COMPLEX_PROGRAM_GX_CHECK1_SCALAR_AND_GXCORE_MIRROR" + }, + "scalar_bill": { + "backward": { + "coefficient_histograms": { + "cleanup": { + "-1": 486, + "-1/2": 234, + "-2": 91, + "1": 1472, + "1/2": 154, + "2": 37 + }, + "main": { + "-1": 1652, + "-1/2": 351, + "-1/6": 448, + "-2": 37, + "1": 628, + "1/2": 453, + "1/3": 224, + "2": 91 + }, + "old_response": { + "-1": 388, + "-1/2": 425, + "-1/6": 448, + "-2": 88, + "1": 1772, + "1/2": 355, + "1/3": 224, + "2": 29 + } + }, + "other_main_recursive_calls": "68230 existing live-label transitions, unchanged; not scalar macros", + "phases": { + "cleanup": { + "Gaussian_primitive_steps": 7938, + "add": 2474, + "all_macros": 2474, + "divisor3_exposure": 0, + "halving_exposure": 388, + "real_component_primitive_steps": 15876, + "scalar_log2_magnitude_charge": 2602, + "scalar_macros": 2474 + }, + "main": { + "Gaussian_primitive_steps": 13720, + "add": 3884, + "all_macros": 3908, + "clear": 16, + "divisor3_exposure": 672, + "halving_exposure": 1252, + "real_component_primitive_steps": 27440, + "recursive_centers": 8, + "recursive_rank_mass": 72, + "scalar_log2_magnitude_charge": 4012, + "scalar_macros": 3900 + }, + "old_response": { + "Gaussian_primitive_steps": 14770, + "add": 3729, + "all_macros": 5295, + "clear": 1566, + "divisor3_exposure": 672, + "halving_exposure": 1228, + "real_component_primitive_steps": 29540, + "scalar_log2_magnitude_charge": 3846, + "scalar_macros": 5295 + } + }, + "schedule_sha256": "e73ba422d94c229a05680251ab28a74cc7258fc3b50bf5061aaf57d42ac37e94", + "totals": { + "Gaussian_primitive_steps": 36428, + "add": 10087, + "all_macros": 11677, + "clear": 1582, + "divisor3_exposure": 1344, + "halving_exposure": 2868, + "real_component_primitive_steps": 72856, + "recursive_centers": 8, + "scalar_log2_magnitude_charge": 10460, + "scalar_macros": 11669 + } + }, + "five_invocation_scalar_primitives_per_vertex": 350186, + "forward": { + "coefficient_histograms": { + "cleanup": { + "-1": 1472, + "-1/2": 154, + "-2": 37, + "1": 486, + "1/2": 234, + "2": 91 + }, + "main": { + "-1": 628, + "-1/2": 445, + "-1/6": 448, + "-2": 91, + "1": 1652, + "1/2": 359, + "1/3": 224, + "2": 37 + }, + "old_response": { + "-1": 418, + "-1/2": 419, + "-1/3": 224, + "-2": 88, + "1": 959, + "1/2": 361, + "1/6": 448, + "2": 29 + } + }, + "other_main_recursive_calls": "68230 existing live-label transitions, unchanged; not scalar macros", + "phases": { + "cleanup": { + "Gaussian_primitive_steps": 7938, + "add": 2474, + "all_macros": 2474, + "divisor3_exposure": 0, + "halving_exposure": 388, + "real_component_primitive_steps": 15876, + "scalar_log2_magnitude_charge": 2602, + "scalar_macros": 2474 + }, + "main": { + "Gaussian_primitive_steps": 13720, + "add": 3884, + "all_macros": 3908, + "clear": 16, + "divisor3_exposure": 672, + "halving_exposure": 1252, + "real_component_primitive_steps": 27440, + "recursive_centers": 8, + "recursive_rank_mass": 72, + "scalar_log2_magnitude_charge": 4012, + "scalar_macros": 3900 + }, + "old_response": { + "Gaussian_primitive_steps": 12421, + "add": 2946, + "all_macros": 4512, + "clear": 783, + "copy": 783, + "divisor3_exposure": 672, + "halving_exposure": 1228, + "real_component_primitive_steps": 24842, + "scalar_log2_magnitude_charge": 3063, + "scalar_macros": 4512 + } + }, + "schedule_sha256": "92dafa62a52fcf152ce27b8f4ae481955416b4bebfc8f64894ace60318d4b417", + "totals": { + "Gaussian_primitive_steps": 34079, + "add": 9304, + "all_macros": 10894, + "clear": 799, + "copy": 783, + "divisor3_exposure": 1344, + "halving_exposure": 2868, + "real_component_primitive_steps": 68158, + "recursive_centers": 8, + "scalar_log2_magnitude_charge": 9677, + "scalar_macros": 10886 + } + }, + "scratch": { + "additional_recursive_calls": 0, + "extra_external_row_coordinate": false, + "live_roles": 1263, + "physical_roles_per_cover": 2056 + }, + "scratch_lifecycle_checks": { + "backward": { + "center_children": 8, + "coefficient_work_cleared_per_add": true, + "complete_stream_fraction": "1/(1263*|Orth(45,2)|)", + "moment_live_width": 1263, + "new_recursive_children": 0, + "new_work_stock_only": 784, + "tableau_absent_from_all_children": true, + "tableau_cleared_before_entire_main_phase": true + }, + "forward": { + "center_children": 8, + "coefficient_work_cleared_per_add": true, + "complete_stream_fraction": "1/(1263*|Orth(45,2)|)", + "moment_live_width": 1263, + "new_recursive_children": 0, + "new_work_stock_only": 784, + "tableau_absent_from_all_children": true, + "tableau_cleared_before_entire_main_phase": true + } + }, + "template_tests": { + "checks_passed": 7, + "published_full_scalar_replay": false, + "tiny_exact_template_columns_checked": 7, + "unreversed_transpose_rejected": true, + "wrong_inverse_sign_rejected": true + } + }, + "splice": { + "certificate_sha256": "f2664ee7bcdfb55893abe9f1be8ee6a394a602e8262e611de2a0328bbd508aa7", + "controls": [ + { + "name": "drop_final_climb", + "orientation": "forward", + "reason": "final climbs omitted before cleanup", + "rejected": true + }, + { + "name": "cleanup_before_final_climbs", + "orientation": "forward", + "reason": "strict old/A/copy/B/final/adapter/cleanup chronology", + "rejected": true + }, + { + "name": "drop_final_frame_adapter", + "orientation": "forward", + "reason": "missing or reordered exact final adapter", + "rejected": true + }, + { + "name": "wrong_common_exact_gate_label", + "orientation": "forward", + "reason": "scalar incidence uses wrong exact label", + "rejected": true + }, + { + "name": "drop_center_child", + "orientation": "forward", + "reason": "center source frame", + "rejected": true + }, + { + "name": "tableau_not_erased_before_child", + "orientation": "forward", + "reason": "old-response tableau survived before label recursion", + "rejected": true + }, + { + "name": "wrong_cleanup_sign", + "orientation": "forward", + "reason": "complete scalar program differs from checked bill", + "rejected": true + }, + { + "name": "drop_final_climb", + "orientation": "backward", + "reason": "final climbs omitted before cleanup", + "rejected": true + }, + { + "name": "cleanup_before_final_climbs", + "orientation": "backward", + "reason": "strict old/A/copy/B/final/adapter/cleanup chronology", + "rejected": true + }, + { + "name": "drop_final_frame_adapter", + "orientation": "backward", + "reason": "missing or reordered exact final adapter", + "rejected": true + }, + { + "name": "wrong_common_exact_gate_label", + "orientation": "backward", + "reason": "scalar incidence uses wrong exact label", + "rejected": true + }, + { + "name": "drop_center_child", + "orientation": "backward", + "reason": "center source frame", + "rejected": true + }, + { + "name": "tableau_not_erased_before_child", + "orientation": "backward", + "reason": "old-response tableau survived before label recursion", + "rejected": true + }, + { + "name": "wrong_cleanup_sign", + "orientation": "backward", + "reason": "complete scalar program differs from checked bill", + "rejected": true + }, + { + "name": "wrong_helper_owner", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "rank_only_frame", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "scratch_alias", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "wrong_live_normalization", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "free_RAM", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + }, + { + "name": "missing_tableau", + "reason": "five-window exact source/tape/namespace contract changed", + "rejected": true + } + ], + "global_contract": { + "chronology": [ + "stage0", + "stage1", + "climbA", + "bridgeA", + "stage2", + "climbB", + "bridgeB", + "stage3", + "stage4", + "final_climbs", + "bridgeC", + "terminal_shifts", + "signed_exchange" + ], + "exact_frame_bindings": { + "sfin": { + "anchor": "sfin :", + "declaration_line": "sfin : \u2200 g, W4 (s4.symm g) * (W3 (s3.symm g) * (W2 (s2.symm g) * (W1 (s1.symm g) * (G0 g).Xm.\u03a6 1))) = kernel \u03b1", + "line": 82, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L82" + }, + "term": { + "anchor": "term :", + "declaration_line": "term : \u2200 g t, kernel \u03b1 * (G0 g).Xm.\u03a6 (tt (I.tv t)) = shift (u g t) * YF g t", + "line": 94, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L94" + }, + "x01": { + "anchor": "x01 :", + "declaration_line": "x01 : \u2200 g t, (G0 g).Xm.\u03a6 1 = (G1 (r1 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 73, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L73" + }, + "x12": { + "anchor": "x12 :", + "declaration_line": "x12 : \u2200 g t, (G1 (r1 t g)).Xm.\u03a6 1 = (G2 (r2 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 75, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L75" + }, + "x23": { + "anchor": "x23 :", + "declaration_line": "x23 : \u2200 g t, (G2 (r2 t g)).Xm.\u03a6 1 = (G3 (r3 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 77, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L77" + }, + "x34": { + "anchor": "x34 :", + "declaration_line": "x34 : \u2200 g t, (G3 (r3 t g)).Xm.\u03a6 1 = (G4 (r4 t g)).Xm.\u03a6 (tt (I.tv t))", + "line": 79, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L79" + }, + "y01": { + "anchor": "y01 :", + "declaration_line": "y01 : \u2200 g t, (G0 g).Xm.\u03a6 (1 + tt (I.tv t)) = (G1 (r1 t g)).Xm.\u03a6 0", + "line": 74, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L74" + }, + "y12": { + "anchor": "y12 :", + "declaration_line": "y12 : \u2200 g t, (G1 (r1 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G2 (r2 t g)).Xm.\u03a6 0", + "line": 76, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L76" + }, + "y23": { + "anchor": "y23 :", + "declaration_line": "y23 : \u2200 g t, (G2 (r2 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G3 (r3 t g)).Xm.\u03a6 0", + "line": 78, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L78" + }, + "y34": { + "anchor": "y34 :", + "declaration_line": "y34 : \u2200 g t, (G3 (r3 t g)).Xm.\u03a6 (1 + tt (I.tv t)) = (G4 (r4 t g)).Xm.\u03a6 0", + "line": 80, + "source": "Work/GCert/Chain/NetDef.lean", + "url": "https://github.com/jacobalansussman/wht-power-saving-lean/blob/f010392c923279e3dd59ef3aa5fedad23affc5fd/Work/GCert/Chain/NetDef.lean#L80" + } + }, + "family": "baseline5stageComplex", + "global_bound_exponent": 6050, + "helper_policy": "arbitrary_input; inherited_dirty_lift; Z5=kernel", + "label_policy": "identical_exact_representative_and_paid_rank_zero_reconciliation", + "live": 1263, + "local_bound_exponent": 48, + "m": 45, + "maintained_guard_changed": false, + "odd_grid": "2^(-P)3^(-G(D+1)); no return rounding", + "physical": 2056, + "primitive_policy": "charged_fixed_tape_complete_streams", + "primitive_recipe": { + "center_backward": "zero at frame zero; accumulate transpose scatter; exact residual to retained frame; subtract into original; erase", + "center_forward": "copy at retained frame; exact residual to frame zero; scatter; erase", + "cross_phase": "i^(2xy) = i^x i^y i^(-(x xor y)); at most three parity-phase scans", + "entry_exit": "WinB.old_to_new and WinB.new_to_old, lowered as paid exact rank-zero Clifford operators", + "live_child": "exact target representative times inverse current representative; two rank-zero factors around one C tensor child", + "phase_scan": "evaluate fixed Z4 quadratic descriptors per record, multiply by fourth root, record suffix pays descriptor arithmetic", + "rank_zero": "binary Gaussian elimination; affine bit flips; Z4 linear phases and even cross terms; exact scalar fourth root", + "role_route": "permutation on all complete live/work roles, at most W_physical^2 complete-stream exchanges on fixed tapes", + "row_stock": "split only live complete rows; scalar-only work creates no row coordinate or recursive branch", + "scalar": "copy source to W; optional double/halve/divide3; signed accumulate; clear W", + "selected_bit": "compact-control-movement proposition, complete restored borrowed fields, paid repair, no RAM lookup" + }, + "recursive_volume_denominator": 1263, + "scratch_namespace": { + "centers": [ + 1263, + 1272 + ], + "coefficient": [ + 2055, + 2056 + ], + "tableau": [ + 1272, + 2055 + ] + }, + "stage_recipe": [ + { + "active_pair": 1, + "bank_owner": "d", + "exterior_subset": "empty", + "helper_owner": "d", + "native_frame": "(G0 d).X.Phi(frames[f])", + "old_frame": "(G0 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 0, + "window": "G0" + }, + { + "active_pair": 1, + "bank_owner": "r1(t)^(-1)(d)", + "exterior_subset": "qS bs1 l", + "helper_owner": "s1(d)", + "native_frame": "(G1 d).X.Phi(frames[f])", + "old_frame": "(G1 d).Xm.Phi(P)", + "orientation": "backward", + "stage": 1, + "window": "G1" + }, + { + "active_pair": 1, + "bank_owner": "r2(t)^(-1)(d)", + "exterior_subset": "qS bs2 l", + "helper_owner": "s2(d)", + "native_frame": "(G2 d).X.Phi(frames[f])", + "old_frame": "(G2 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 2, + "window": "G2" + }, + { + "active_pair": 2, + "bank_owner": "r3(t)^(-1)(d)", + "exterior_subset": "qS bs3 l", + "helper_owner": "s3(d)", + "native_frame": "(G3 d).X.Phi(frames[f])", + "old_frame": "(G3 d).Xm.Phi(P)", + "orientation": "backward", + "stage": 3, + "window": "G3" + }, + { + "active_pair": 2, + "bank_owner": "r4(t)^(-1)(d)", + "exterior_subset": "qS bs4 l", + "helper_owner": "s4(d)", + "native_frame": "(G4 d).X.Phi(frames[f])", + "old_frame": "(G4 d).Xm.Phi(P)", + "orientation": "forward", + "stage": 4, + "window": "G4" + } + ] + }, + "program": { + "backward": { + "Gaussian_primitives": 36428, + "distinct_nested_pairs": 3120, + "entry_and_exit_old_new_adapters": 2046, + "event_counts": { + "adapter": 2046, + "center": 8, + "climb": 3965, + "phase": 9, + "scalar": 11669 + }, + "events": 17697, + "exact_common_label_live_incidences": 7024, + "exact_label_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0" + }, + "final_climbs_before_cleanup": true, + "live_transition_partition": { + "A": 1237, + "B": 1953, + "final": 775 + }, + "old_response_erased_before_all_children": true, + "paid_children": 3973, + "program_sha256": "4151e920bad851e9d7832f42ed7fa8b178cfbf001d56b22d198831f7d9ca6689", + "real_component_primitives": 72856, + "scalar_primitive_sha256": "520fad1c42e19510c1a091522e7a3fd6709d85db10df9a09d1af8553ce9f649e", + "scalar_projection_sha256": "e73ba422d94c229a05680251ab28a74cc7258fc3b50bf5061aaf57d42ac37e94" + }, + "forward": { + "Gaussian_primitives": 34079, + "distinct_nested_pairs": 3120, + "entry_and_exit_old_new_adapters": 2046, + "event_counts": { + "adapter": 2046, + "center": 8, + "climb": 3965, + "phase": 9, + "scalar": 10886 + }, + "events": 16914, + "exact_common_label_live_incidences": 7024, + "exact_label_state_sha256": { + "after_A": "b9f8977e67543fa8e919b89ffbb290e819bd59200d23e81bc114cdbe5bc4d134", + "after_B": "4ff0360be46e79881377ad25d3ef9a4984b891a0a0ebd7401e538d5e8ba58c94", + "final": "a5524273eb5fba12f511e4227abc87afd5e069ff1918d10ef58d4b2ad4ea29f0" + }, + "final_climbs_before_cleanup": true, + "live_transition_partition": { + "A": 1237, + "B": 1953, + "final": 775 + }, + "old_response_erased_before_all_children": true, + "paid_children": 3973, + "program_sha256": "67f0d2f0564f6bd4cbda7fbb6c73451ab51caab2b3629f7cc712cc6ab0fe979d", + "real_component_primitives": 68158, + "scalar_primitive_sha256": "155ba11993ead90ac6814c9c21857ed1d42469b89e630d01494ecf7451b6cbda", + "scalar_projection_sha256": "92dafa62a52fcf152ce27b8f4ae481955416b4bebfc8f64894ace60318d4b417" + } + }, + "source_pin": "f010392c923279e3dd59ef3aa5fedad23affc5fd" + }, + "status": "PASS_FRESH_COMPLEX_LABEL_SCALAR_SPLICE_PRECISION" +} diff --git a/research/e8-retimed-component-verification/inputs/LICENSE b/research/e8-retimed-component-verification/inputs/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-retimed-component-verification/inputs/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/e8-retimed-component-verification/inputs/NOTICE-PR378.md b/research/e8-retimed-component-verification/inputs/NOTICE-PR378.md new file mode 100644 index 0000000000..ba19bb7de1 --- /dev/null +++ b/research/e8-retimed-component-verification/inputs/NOTICE-PR378.md @@ -0,0 +1,21 @@ +# Notice + +Apache-2.0 (`LICENSE`). Prepared by Chafik Boukhalfa (chafreaky) with substantial Anthropic Claude assistance. + +- `complex/gcert1-e8-r783.json.gz`, `complex/gx/gx.py`, `complex/gx/gxcore.py`: Jacob Sussman, + jacobalansussman/wht-power-saving-lean at `9c94857`, Apache-2.0. The bytes are identical (by git blob id) to the copies vendored in + DaysSky's #363/#375 and aliromman's #365. The upstream LICENSE and NOTICE are kept as `complex/LICENSE-wht-power-saving-lean` + and `complex/NOTICE-wht-power-saving-lean`. +- `data/gcert1-e8-r783-far.json.gz`: this package's certificate, derived from Sussman's by `code/cxfar.py` and `code/cxfinal.py`. + It keeps his format, and its `derived_from` field records the derivation. +- `data/bit/bitE8-r865.json.gz`: utcorvusvolat-dotcom's (Dylan Crow) #370 E8 bit word, byte-identical to #370's and #373's + `data/bit` (Apache-2.0). +- `code/engines/moment.py`, `base_two_moment.py`, `outer.py`: PR #315's engines (DreamingOfClouds; eumemic; the #144/#23 + lineage), as vendored in our #329/#359 packages. +- `code/layout_bk.py`: our reimplementation of DaysSky's B_K rule (#363), on Sussman's B₂ and stage geometry. #363's `bridged.py` was read as data + and not run. +- `code/e8core.py`, `cxcheck.py`, `cxop.py`, `kappa.py`, `cxretime.py`, `cxsplit.py`, `cxpiece.py`, `cxfar.py`, `cxfinal.py`, + `cxkernel.py`: our own code. The retiming and reorder mechanisms follow our #329/#359 stage lineage (#287/#291/#299/#306), and + aliromman's #365 is generalised (read as data, not run). `cxkernel.py` also holds the exterior-gauge kernel census, which is + unprofitable on this unit, together with the helpers it shares with the search (`rehist`, `price`). +- PR #375's halving-degree-two guard (DaysSky) is cited, not vendored. diff --git a/research/e8-retimed-component-verification/inputs/gcert1-e8-r783-far.json.gz b/research/e8-retimed-component-verification/inputs/gcert1-e8-r783-far.json.gz new file mode 100644 index 0000000000..56708f99a4 Binary files /dev/null and b/research/e8-retimed-component-verification/inputs/gcert1-e8-r783-far.json.gz differ diff --git a/research/e8-retimed-component-verification/measure_pins.py b/research/e8-retimed-component-verification/measure_pins.py new file mode 100644 index 0000000000..b2b2ebd3af --- /dev/null +++ b/research/e8-retimed-component-verification/measure_pins.py @@ -0,0 +1,17 @@ +"""Measured regression-pin preparation, NOT final candidate admission.""" +import sys,os,json,importlib.util +from pathlib import Path +if not __debug__ or sys.flags.optimize:raise RuntimeError('Assertions required') +sys.dont_write_bytecode=True +C=Path(sys.argv[1]).resolve() +os.environ['CX_PINS']=str(C/'pins-e8.json') +for key in ['CX_SOURCE_PINS','CX_RECORD']:os.environ.pop(key,None) +s=importlib.util.spec_from_file_location('measured_guard',C/'portable_complex.py');G=importlib.util.module_from_spec(s);s.loader.exec_module(G) +r=G.run(C,progress=lambda s:print(s,flush=True)) +import p10pins +old=json.loads((C/'pins-e8.json').read_text());old.update(p10pins.RECORD) +assert set(old)==set(json.loads(Path(sys.argv[2]).read_text())), 'Regression pin key closure changed' +assert r['label_checks']['invocation_calls']==3973 and r['label_checks']['invocation_rank_mass']==9039 +Path(sys.argv[3]).write_text(json.dumps(old,sort_keys=True,indent=2)+'\n') +Path(sys.argv[4]).write_text(json.dumps(r,sort_keys=True,indent=2)+'\n') +print('PIN_PREPARATION_ONLY; final strict pinned replay required') diff --git a/research/e8-retimed-component-verification/vendor/source377/LICENSE b/research/e8-retimed-component-verification/vendor/source377/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/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/e8-retimed-component-verification/vendor/source377/MANIFEST.json b/research/e8-retimed-component-verification/vendor/source377/MANIFEST.json new file mode 100644 index 0000000000..2a709aaa9e --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/MANIFEST.json @@ -0,0 +1,166 @@ +{ + "schema": "independent-nine-stage-source-manifest/1", + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "a62afee2856e1eb096250efd3202a429cd4118e7d9a114e7b9c67e3c168df3ab", + "README.txt": "ffe26cdb8a7e083f2f745b6cf18916a6af4f1635bc5b1577f30fb1ca4e575e07", + "verify.py": "f99a2601b4864bb596955933b41f45a04e9c9b300b23e4aae2cb2934ec5d8c74", + "work/complex-nine-native/PROOF.txt": "ea0edb8cfb6b2f2c1adb2de12cc0aa5fb7c57e649033528565af3e52087beda7", + "work/native358/vendor/complex-reserve/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "work/native358/vendor/complex-reserve/MANIFEST.json": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "work/native358/vendor/complex-reserve/NOTICE.md": "380ce615ddb67da3680fa188a0ba0daf578b983d58c2496cd20dd06f32e4ef57", + "work/native358/vendor/complex-reserve/SOURCE.json": "e69f2a72785302f892263cf765c84d07e083d9ad05730748f9c3374aade11e53", + "work/native358/vendor/complex-reserve/admit.py": "1b9b069fbdef37b7e3fbc586aad9578ba85948e9f80877733af387573f3fa723", + "work/native358/vendor/complex-reserve/finite_guard.py": "bef59dddd391bcb49ed16ec6384517b8b7a2e21415cc810f9c2f59f440370983", + "work/native358/vendor/complex-reserve/price.py": "90cfb8d102adf0b5f93b71b05af5c078076f56873a868a66865575a5ea85d573", + "work/native358/vendor/complex-reserve/upstream/pr352/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "work/native358/vendor/complex-reserve/upstream/pr352/MANIFEST.sha256": "4b76fb09595321986da04017db16cf6aa36bcd6a048cdee2ec8b656de811e488", + "work/native358/vendor/complex-reserve/upstream/pr352/NOTICE.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "work/native358/vendor/complex-reserve/upstream/pr352/README.md": "c5349ae6637e846fefe132756968376d52c5e3f76241e96214f59e65cdb7ad16", + "work/native358/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json": "2ad0b2138d2aa8cd5c6ab6995fa8c6c167a822b668ef56a9cc39c5765d1134b3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py": "82e5ef0c7b6cf84c53bf6039330930242c9a5c8e8ea13183b2805cf9577f7129", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/build_v5.py": "c0867d68b863ca7d8cdd7002ffed263cbd5525fea4522267b5f640e4eff5597b", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py": "699c424170b41d3711da6a283f58cac824402ca373764365fd05c8e645ed07f5", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/gather.py": "8c7d2a34fdcbe75d8ed8299e399d578b32adf44402c773fd905aa7c88e2b460d", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/interface.py": "3b3e2fb894f871a9b6145844faaff34a05add59ae0eb8882c8feb2b914265b8a", + "work/native358/vendor/complex-reserve/upstream/pr352/code/builders/twin.py": "cfd261d82a31dd9024f1fa191eac2f5d893a7b51833b912459de46a1e9aac003", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp": "26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/exactnd_h.py": "28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/legality_h.cpp": "5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/sub.hpp": "59c1a64f9df61fc50f47d5a78c8f9351875bf6b352db1c9d109c7c90542a4f19", + "work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/verifyT.cpp": "1a5aea81aab652622e6547d901ead6aaf54fdca231da897dd99474c9f64a33bf", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/certify_complex.py": "7e480b7761fa700944a7dca41ccbefd530203b5e9168b6b37fe879b7e6da57fa", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_labels.py": "e000ee131389fec427388b85f632879cbaaf10e5e5d979a47d6307d64ce58982", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_scalars.py": "38e985ebe8c8e7f8c83c03828abde0c80be418caf95e97afdf2d0c357c0ed919", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/complex_splice.py": "aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/p10pins.py": "93b78a2e038b23264d04836928c78b6ebf33b87ff3dcc0e43ba0f1748fadd143", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/code/scatter.py": "dfd1afbbb3ff86f54db6a0313916403ec8ee6f939caa62f3edcc9d7a151bff95", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/source-pins.json": "0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/pins-e8.json": "bf66f785878f636616ceab193e5a222143945ea06fc2f13dfb99b204ebba82ff", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/portable_complex.py": "44e8ae8a5b915358a97dbed5fe4e70195ed3581fd45a216df48fc82a029db87d", + "work/native358/vendor/complex-reserve/upstream/pr352/code/complex/regress_pr346.py": "29479da1547cd39cf20fe387cde4cad847a2880266db9d0ef3fb474f68591feb", + "work/native358/vendor/complex-reserve/upstream/pr352/code/export_p10.py": "1161d23b459f7d981d6716073745909126d5465018cbbea7e6e6a9e4e5d68add", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/certify_bit.py": "fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/prime_new.py": "7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "work/native358/vendor/complex-reserve/upstream/pr352/code/pricing/tile_check.py": "38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae", + "work/native358/vendor/complex-reserve/upstream/pr352/code/provenance.py": "9f5c05aa4d172478f2ab67e7bb83cacebfccc10ecba650c23539cdcee18f2139", + "work/native358/vendor/complex-reserve/upstream/pr352/code/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/BASE-RECORDS.bin.gz": "caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/BASE-frames.json.gz": "35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/BASE-states.json.gz": "1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/FINAL-NEW-FRAMES.json": "e7fe9d0686829ad5acf7930698b3c81a866ae834422aa3c9a12057dfae627175", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/FINAL-RECORDS.bin.gz": "fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/RECORD-SHA256SUMS": "21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2", + "work/native358/vendor/complex-reserve/upstream/pr352/data/bit/labels.json": "e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce", + "work/native358/vendor/complex-reserve/upstream/pr352/receipts/complex-guard-e8.json": "f94a5dca42cbb88e9650f8f8a3ffbd1153636dfc0a48da5f7a7fca908c0650ad", + "work/native358/vendor/complex-reserve/upstream/pr352/receipts/kappa.json": "36316b6cfe423b56cda1fd52843e56c997d060e33d26b732b3ecf4de3ae83aaa", + "work/native358/vendor/complex-reserve/upstream/pr352/receipts/official-five-stage-columns.json": "32e291f249b4eab8d65664d10c94208fe2154bdb4a45aaff84e9e8da5295a29f", + "work/native358/vendor/complex-reserve/upstream/pr352/receipts/official-legality.json": "7e675b7720f056548c1ee9f9de523eea10e6b014ddf90b7a630fd96163acbce6", + "work/native358/vendor/complex-reserve/upstream/pr352/requirements.txt": "ca0825e0ae3db2855af7535ebdc4775beadbb6f07f8d3a84f0f4fd5b95ba5eae", + "work/native358/vendor/complex-reserve/upstream/pr352/verify.sh": "1a05c0b31ea37b2b5a4b84f6f9f504af8dd4220e13a6d9d86f64b2a731a903c7", + "work/native358/vendor/complex-reserve/verify.py": "aa6f05c39404b4038c31c72f9fe7a8e137df911f6cb6fc668e316be37c40b126", + "work/odd-stages/RECIPE-9.json": "abda2e4c73ecb48d29c30c12bc9a5c2db71d11a35667b4298788ec9154eeec7b", + "work/odd-stages/audit_nine_template.py": "30c33508d02aeb8823dc477e8027bf6d44740aea0d3a3970fd2490aaf3b072d0", + "work/odd-stages/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "work/odd-stages/complex_candidate.py": "e4faf656403720f78223934bec90c667086453d449323c85fa839d19829b4517", + "work/odd-stages/data_phases.py": "671d6f8144c6d31e1766c6a0e144172da661a63f86b3d4d17fe2710f3ef752c4", + "work/odd-stages/global_nine.py": "7e33e6ca88b11e28544bf7d43b02252208d4355369a14adb2aa8baa15773e42a", + "work/odd-stages/outer_fixed.py": "0dc5b5a23bba5b4532cd11a290019d66d56ead611dddd3c40e2c9d0df64da198", + "work/odd-stages/verify_clifford_frames.py": "5d8cf110150c66f2e2df58ea4e24096f335740e2ae726a4778347d98053cfa76", + "work/pr361/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "work/pr361/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "work/pr361/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "work/pr361/complex/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa" + } +} diff --git a/research/e8-retimed-component-verification/vendor/source377/README.md b/research/e8-retimed-component-verification/vendor/source377/README.md new file mode 100644 index 0000000000..27f614ff95 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/README.md @@ -0,0 +1,111 @@ +# Compressed nine-stage complex component + +This research package raises the **conditional complex coarse saving** from +`876248285600677/10^18` to **`999240641319551/10^18`** (about 14.04%) +using the same pinned E8 local word. It supplies a compressed nine-stage +construction, exact phase corrections, whole-block banks with paid padding, +a finite execution template and two independent rational pricing checks. + +**This is a complex-side component result.** The frozen #361 bit supplier still +gives final `kappa = 804849251275843/10^18`. The component value exceeds +`2^-10`, but the combined integer-multiplication exponent does not. + +## Reproduce offline + +Python 3.11 or later, standard library only, with assertions enabled: + +```sh +python3 -B research/nine-stage-complex-e8/verify.py --work /tmp/nine-stage-e8-check +``` + +Choose a work path that does **not** already exist and is outside this package. +The verifier checks all input hashes, copies inputs to that directory and +rebuilds its evidence without network access or pre-existing PASS receipts. +Typical runtime is about three minutes. Its final receipt is `VERIFICATION.json`. + +The eight checks cover source integrity; fresh local scalar/frame admission; +data, banks and profile; exact Clifford adapters; data and cover phases; +the global template and finite invoice; independently decoded template pricing; +and the numerical outer assembly with the fixed bit value. + +## Construction and evidence + +The local E8 word has dimension 9, 120 ports, 783 helpers and copied-rank loss +72. Four data pairs and nine local stages are routed through dimension 73. +Each bank contains eight entire rank-9 residuals and one paid rank-1 padding +factor. Eight replicas give 7,680 data families and 7,047 bank families, for +14,727 live recursive families. Including reused private work gives 15,520 +physical streams per cover. + +The implementation includes the exact Clifford phases omitted by a +rank-only calculation: endpoint translations, the final `X_q` correction, +and the all-live-family cover correction `X_delta(g)`. It checks 946 local +frames, 3,120 directed transitions and 240 endpoint adapters, with exact +Gaussian arithmetic fixing global scalar phase. The fresh local invocation +replays all 1,023 dirty live input columns. The global finite template has +72 local invocations and 1,242,936 local events. + +The paid profile is: + +| Child rank | Calls | +| ---: | ---: | +| 1 | 157599 | +| 2 | 43488 | +| 3 | 37296 | +| 4 | 10080 | +| 5 | 15480 | +| 6 | 23832 | +| 7 | 3096 | +| 8 | 7488 | +| 9 | 576 | +| 16 | 3840 | +| 32 | 3840 | +| 48 | 3840 | + +Thus `rank_mass = 1072575` and `73 * 14727 - rank_mass = 2496`. +Both rational moment engines admit the stated complex saving and reject the +next `10^-18` grid point. The largest child has rank 48, so the argument uses +**two-level halving**, `73^2 > 2 * 48^2`, with its depth and finite-work +overcharges explicitly included. It does not assert the false one-level +half-shrink inequality. + +Relevant files: + +- [Construction argument and assumptions](work/complex-nine-native/PROOF.txt). +- [Exact local Clifford arithmetic](work/odd-stages/clifford_exact.py) and + [adapter verification](work/odd-stages/verify_clifford_frames.py). +- [Data and cover phases](work/odd-stages/data_phases.py). +- [Global template and invoice](work/odd-stages/global_nine.py). +- [Independent template decoder and pricing](work/odd-stages/audit_nine_template.py). +- [Fixed-bit outer check](work/odd-stages/outer_fixed.py). + +Phase, padding, bridge and terminal-exchange omission controls are included. +The unchanged-bit outer check has 47 strict numerical constraints and rejects +the next final-kappa grid point. That check is a consistency check, not a new +bit-side construction certificate. + +## Scope and provenance + +The construction retains the pinned local E8 invocation theorem, general +Clifford/compiler interfaces, complete-stream tape primitives, common fine-grid +precision, row allowance and analytic recurrence interfaces. This package does +not build a new Lean kernel proof, enumerate the astronomical cover, regenerate +the E8 certificate producer, or establish an unconditional multiplication +theorem. The finite template and the written argument have the scope stated in +their receipts and proof. + +The unchanged E8 certificate is pinned at SHA256 +`4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa`, +from Jacob Sussman's E8 source at +`9c94857bbaee886f8649edee0bc2d3c738f9555e`, preserved through the fixed +[#352](https://github.com/CrocSwap/integer-mult-bounds/pull/352) source and +local finite-invoice audit. The unchanged bit comparison is frozen at +[#361](https://github.com/CrocSwap/integer-mult-bounds/pull/361), head +`2eef66d847be4441e4f3af681ee7e94dd9b19316`. + +Dependency licenses, notices, assistance disclosures and source manifests are +preserved in `work/native358/vendor/complex-reserve/`. They retain the local +E8, five-stage, completed-bank, compiler and analytic-framework credits. +The new nine-stage construction, verification code and argument were prepared +by Zhihao Chen with OpenAI Codex assistance. Apache-2.0; inherited notices and +licenses continue to apply. diff --git a/research/e8-retimed-component-verification/vendor/source377/README.txt b/research/e8-retimed-component-verification/vendor/source377/README.txt new file mode 100644 index 0000000000..24c828ce46 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/README.txt @@ -0,0 +1,10 @@ +Independent compressed nine-stage complex research component + +Run: python3 -B verify.py --work /new/empty/path +Python 3.11+ standard library only. Typical runtime about three minutes. + +The driver copies pinned inputs into the new work directory, verifies the frozen source package, and regenerates local admission, exact Clifford recipes, global phase corrections, global IR, finite invoice, independent IR pricing and numerical outer checks. No network, repository state or saved PASS receipt is required. + +The conditional complex coarse value is 0.000999240641319551. The unchanged bit side still binds final kappa at 0.000804849251275843. This is not a new integer-multiplication record or a 1% final-kappa improvement. Retained analytic interfaces, lack of a new Lean kernel proof, and the precise theorem scope are explicit in work/complex-nine-native/PROOF.txt and verification receipts. + +Fixed-source credits and licenses are preserved verbatim in work/native358/vendor/complex-reserve. Independent added code and proof: OpenAI Codex assistance, 2026-10-11. diff --git a/research/e8-retimed-component-verification/vendor/source377/verify.py b/research/e8-retimed-component-verification/vendor/source377/verify.py new file mode 100644 index 0000000000..7889e68d55 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/verify.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +"""Replay the independent nine-stage component from pinned sources only.""" +import argparse,hashlib,json,shutil,subprocess,sys,time +from pathlib import Path +assert __debug__, 'Run without -O' +assert sys.version_info>=(3,11) +ROOT=Path(__file__).resolve().parent +sha=lambda p:hashlib.sha256(Path(p).read_bytes()).hexdigest() +read=lambda p:json.loads(Path(p).read_text()) +ap=argparse.ArgumentParser();ap.add_argument('--work',type=Path,required=True);a=ap.parse_args();wd=a.work.resolve();assert not wd.exists() and not wd.is_relative_to(ROOT) +expected=read(ROOT/'MANIFEST.json');actual={p.relative_to(ROOT).as_posix():sha(p) for p in ROOT.rglob('*') if p.is_file() and p.name!='MANIFEST.json'} +# Nested vendor MANIFEST.json files are themselves pinned, too. +actual={p.relative_to(ROOT).as_posix():sha(p) for p in ROOT.rglob('*') if p.is_file() and p!=ROOT/'MANIFEST.json'} +assert actual==expected['files'] and not any(p.is_symlink() for p in ROOT.rglob('*')) +wd.mkdir();shutil.copytree(ROOT/'work',wd/'work');logs=wd/'logs';logs.mkdir();done=[];started=time.monotonic() +def run(name,argv): + t=time.monotonic();log=logs/(name+'.log');print(name,flush=True) + with log.open('w') as f:r=subprocess.run([sys.executable,'-B']+argv,cwd=wd,stdout=f,stderr=subprocess.STDOUT) + assert r.returncode==0,(name,r.returncode,str(log)) + done.append(dict(stage=name,returncode=0,seconds=time.monotonic()-t,log_sha256=sha(log))) +try: + run('frozen-source-integrity',['-c',"import runpy; x=runpy.run_path('work/native358/vendor/complex-reserve/verify.py'); print(x['integrity']())"]) + run('fresh-local-admission',['work/native358/vendor/complex-reserve/admit.py','--source','work/native358/vendor/complex-reserve/upstream/pr352','--output','work/complex-nine-native/local-admission']) + for name,script in [('finite-data-banks-profile','complex_candidate.py'),('exact-clifford-recipes','verify_clifford_frames.py'),('exact-data-and-cover-phases','data_phases.py'),('global-template-and-invoice','global_nine.py'),('independent-template-two-moments','audit_nine_template.py'),('fixed-bit-outer-check','outer_fixed.py')]:run(name,['work/odd-stages/'+script]) + out=wd/'work/complex-nine-native';price=read(out/'INDEPENDENT-TEMPLATE-AUDIT.json');outer=read(out/'OUTER-FIXED-BIT.json');invoice=read(out/'GLOBAL-REVIEW.json') + assert price['coarse_complex']=='999240641319551/1000000000000000000' and outer['kappa']=='804849251275843/1000000000000000000' + assert invoice['cover_correction_calls']==14727 and invoice['finite_invoice']['halving_degree']==2 + receipts={p.relative_to(out).as_posix():sha(p) for p in out.rglob('*') if p.is_file()} + result=dict(status='PASS_PORTABLE_NINE_STAGE_COMPLEX_FINITE_COMPONENT',source_manifest_sha256=sha(ROOT/'MANIFEST.json'),fresh_stages=done,complex_coarse=price['coarse_complex'],fixed_bit_kappa=outer['kappa'],new_final_kappa_claim=False,final_kappa_one_percent_milestone_reached=False,proof='work/complex-nine-native/PROOF.txt',receipt_sha256=receipts,seconds=time.monotonic()-started,scope='The explicit proof retains local E8, Clifford/compiler, common-grid and row/analytic interfaces. No Lean kernel build, astronomical cover enumeration, certificate-producer regeneration or improved bit-side theorem is claimed.') + (wd/'VERIFICATION.json').write_text(json.dumps(result,indent=2));print(result['status'],flush=True) +except BaseException as e: + (wd/'FAILURE.json').write_text(json.dumps(dict(error=str(e),completed=done),indent=2));raise diff --git a/research/e8-retimed-component-verification/vendor/source377/work/complex-nine-native/PROOF.txt b/research/e8-retimed-component-verification/vendor/source377/work/complex-nine-native/PROOF.txt new file mode 100644 index 0000000000..278c379c21 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/complex-nine-native/PROOF.txt @@ -0,0 +1,161 @@ +Independent compressed nine-stage complex component + +Claim and retained assumptions + +The fixed E8 local invocation has h=9, v=120, R=783 and copied rank loss +cst=72. The construction below has m=73, live stock 14727 per complete +orthogonal cover, and paid profile + 1:157599, 2:43488, 3:37296, 4:10080, 5:15480, 6:23832, + 7:3096, 8:7488, 9:576, 16:3840, 32:3840, 48:3840. +It is a conditional complex component, not an integer multiplication bound. +The local E8 invocation theorem, general Clifford rank-zero compiler, +complete-stream tape primitives, common fine-grid precision, and retained +analytic recurrence interfaces are assumptions retained from the fixed local +source package. The new finite construction and its charges are supplied +here. No new Lean kernel proof is asserted. Final bit-side admission and +outer assembly are separate obligations. + +Exact operator convention + +For q in F2^m, let X_q be translation by q and + C_q = ((1+i) I + (1-i) X_q)/2. +Then C_q^2=X_q and C_q fixes the uniform vector. Write C_all for the product +over the coordinate vectors. An invertible binary matrix G acts by the +literal address permutation P_G. All products of C_q are commuting exact +Gaussian-dyadic operators. Their multiplier on Fourier character y is +i^(sum epsilon_q * parity(q.y)). Modulo 4, parity expands as its linear sum +minus twice its pair sum, so this multiplier is an exact Z4 quadratic form. +Equality of these forms proves equality including the scalar phase. + +For arbitrary local subspaces U, including degenerate ones, use the +deterministic canonical representative from clifford_exact.py. A basis G +whose first columns span U gives K_G = D_Q P_G, with +Q=I+G^(-T)G^(-1), and T_U=K_G C_[dim U] K_G^(-1). +Its preimage Lagrangian is {(u,u+w): u in U, w in U^perp}. Thus a nested +transition has Fourier rank equal to the dimension difference. The supplied +compiler produces two explicit monomial operators around one rank-r C child. +Its equality is checked both as a signed Pauli tableau and on a nonzero +exact Gaussian state vector, which fixes the otherwise missing global phase. +All 946 local frames, all 3120 used directed transitions, and all 240 old/new +source/target adapters are checked. No rank-only replacement is made. + +Compressed window and data routes + +Use V=F2^9 direct_sum (F2^8)^8 with the ordinary dot product. Let E_s be the +first s exterior eight-dimensional blocks, for 0<=s<=8. The exact window +representative of local U is T_U tensor C_Es. A nested transition cancels +the common exterior tensor factor exactly and keeps its original rank. +Conjugating the whole window by any cover permutation preserves this fact. +The old/new endpoint adapters are the checked local adapters tensored with +identity, followed by the declared address conjugation. This proves the +window lift directly; a divisibility assumption m=multiple_of_h is not used. + +Every supplied port q has odd weight and a zero coordinate. The explicit +orthogonal matrix U_q in data_phases.py maps e0 to q: swap e0 with a zero +coordinate e_j when necessary, then use the even-vector transvection +x -> x + ((q+e_j).x)(q+e_j). Its remaining columns are an orthonormal basis +of q^perp. For s>0, rho_s,q exchanges that complement in the local block +with exterior block s and fixes q and all other exterior coordinates. +It is a symmetric orthogonal involution. The stage data owners are +g=d*rho_s,q, with rho_0,q=I, so the right factors are bijections of O(73,2). + +Use canonical data levels X_s=C_[0,9+8s), Y_s=X_s C_q^(-1), and initially +X_(-1)=C_q, Y_(-1)=I. The routed stage starts at level s-1 and ends at level s. +Their binary preimages agree with the window endpoints. Exact phase +polynomials determine the translation that reconciles each endpoint, and +the template applies that translation. There are 3840 nonzero such +translations across the 120 port types and nine stages, before replica +multiplicity. These operators are not silently identified from equal +binary matrices. + +Four-pair scalar chain and idle children + +Starting with F_0 (Y_0 += X_0), for j=0,1,2,3 apply B_j (X_j -= Y_j), +then for j<3 apply X_j += X_(j+1), Y_(j+1) -= Y_j, apply F_j, and undo +that bridge. The last pair has B_3,F_3 without a following bridge. +Afterwards apply, in descending j=2,1,0, X_(j+1)+=X_j and Y_j-=Y_(j+1). +Finally exchange each pair by newX=oldY, newY=-oldX. The complete signed +integer scalar matrix is the identity; omission of every bridge fails. + +Before a bridge, advance the idle pair to the active pair's level. The +two advances for the newly used pairs have ranks (16,8), (32,8), (48,8). +The final advances have ranks 48,32,16,0. Each rank occurs on both members +of the pair, each of 120 ports, and each of eight replicas. A nested idle +transition is factored in the explicit orthonormal basis U_q direct_sum I. +Its exact Z4 phase is reconciled by the stored translation after that child. + +The final Y endpoint is C_all C_q^(-1). A source began at C_q, so its +unadjusted exchange route would be C_all C_q^(-2)=C_all X_q. Applying the +literal X_q to each final Y before the signed exchange removes this factor. +The corresponding 120 omission controls fail. This correction is charged. + +Banks and arbitrary correlated dirt + +There are eight replicas of each of the four data pairs, hence 7680 data +families. Each stage has 783 independent bank families. Number a local +helper occurrence by z=783*replica+helper. It uses bank floor(z/8) and slot +z mod 8, with its nine-dimensional residual assigned to coordinates +[9*slot,9*slot+9). A paid coordinate C child at coordinate 72 completes +each bank. All eight whole residuals and this padding fill dimension 73. +Thus there are 9*783=7047 bank families and live stock 14727. + +Let Pi_slot swap the first nine coordinates with the assigned block. The +local invocation at class d uses the bank class g=d*Pi_slot^(-1). Its +residual at that owner is P_g C_block P_g^(-1). Right multiplication is a +bijection. Local helpers sharing one bank have distinct slots, hence +different right factors and different actual bank classes for every d. +All data and private families are disjoint from banks. The checker verifies +these injections for all 72 invocation/replica templates and 56376 residual +assignments. A complete cover sweep for one replica finishes before the +next begins. The local dirty invocation is block diagonal on helpers at +its endpoint and permits arbitrary correlated helper values. Therefore +overlap between different invocations does not impose a cleanliness or +independence assumption. At each bank class, the eight residuals and the +padding are coordinate factors in one common conjugated basis, and their +exact product is P_g C_all P_g^(-1). + +One more exact correction is essential. Orthogonality alone does not imply +that P_g commutes with C_all as an exact operator. In fact + P_g C_all P_g^(-1) = C_all X_delta(g), + delta(g)_i = (weight(row_i(g))-1)/2 mod 2. +The quadratic terms cancel by row orthogonality and the remaining even +linear terms give the displayed translation. Both sides fix the uniform +vector, fixing the global scalar. Apply X_delta(g) to EVERY final live +family in cover class g, after the bank padding and signed data exchange. +The template includes and charges all 14727 corrections per cover. This +identity is also checked on every orthogonal matrix in dimensions 1..5. + +Finite work and recurrence charges + +The source emitter is regenerated and revalidated in both orientations. +It accounts for 1242936 local events over 72 invocations, with all copied +center and dirty-tableau lifetimes intact. Forward and backward scalar +words freshly replay all 1023 independent dirty live columns. Only the +private work starts at zero. Work comprises 783 tableau streams, nine +reserved center streams (eight used), and one coefficient stream. Each +invocation completes and erases its private work before the next. Physical +stock is therefore 15520 per cover; scalar-only work is excluded from the +recursion-volume denominator. + +GLOBAL-REVIEW.json records the complete recomputed finite overcharge, with +64*(73+1)^3 compiler groups per rank-zero adapter, source-counted scalar +primitives, and overcharges for all data routes, bank selectors, phases, +padding, bridges, exchanges and cover corrections. The O(73,2) order is +2^(36^2)*product(2^(2i)-1,i=1..36); its bit length is 2628. The recomputed +router fits 2^30000, the literal charge fits 2^100000, and the precision +guard fits C0=2^210000. No even-dimensional orthogonal-order formula is used. + +Largest child 48 does not satisfy one-layer halving. Instead +73^2=5329>2*48^2=4608, so two nested children have width strictly below +half the parent, including floors. The general depth is bounded by +2*ceil(log2 e), with direct small leaves. For B=s+E the completed-child +semantic induction has 2B(73-48)-s-E=49B>0. The resulting conservative +complete-row coefficient is 2*2642+9909+252=15445<20161, retaining the +external bit/base-row allowance as an explicit interface assumption. +The inherited bad-branch envelope is priced conservatively as before. + +Two independent rational moment engines admit +b=999240641319551/10^18 and exclude b+10^-18 for the source-bound profile. +The rank mass is 1072575, and 73*14727-1072575=2496=8*(8*120-9*72). +This complex component exceeds 1/1024 but does not improve the current +bit bottleneck. No improved final kappa or 1% final-kappa milestone follows. diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/LICENSE b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/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/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/MANIFEST.json b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/MANIFEST.json new file mode 100644 index 0000000000..fb122f82af --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/MANIFEST.json @@ -0,0 +1,147 @@ +{ + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "380ce615ddb67da3680fa188a0ba0daf578b983d58c2496cd20dd06f32e4ef57", + "SOURCE.json": "e69f2a72785302f892263cf765c84d07e083d9ad05730748f9c3374aade11e53", + "admit.py": "1b9b069fbdef37b7e3fbc586aad9578ba85948e9f80877733af387573f3fa723", + "finite_guard.py": "bef59dddd391bcb49ed16ec6384517b8b7a2e21415cc810f9c2f59f440370983", + "price.py": "90cfb8d102adf0b5f93b71b05af5c078076f56873a868a66865575a5ea85d573", + "upstream/pr352/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "upstream/pr352/MANIFEST.sha256": "4b76fb09595321986da04017db16cf6aa36bcd6a048cdee2ec8b656de811e488", + "upstream/pr352/NOTICE.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "upstream/pr352/README.md": "c5349ae6637e846fefe132756968376d52c5e3f76241e96214f59e65cdb7ad16", + "upstream/pr352/SOURCE-pr346.json": "2ad0b2138d2aa8cd5c6ab6995fa8c6c167a822b668ef56a9cc39c5765d1134b3", + "upstream/pr352/code/builders/addcomp.py": "82e5ef0c7b6cf84c53bf6039330930242c9a5c8e8ea13183b2805cf9577f7129", + "upstream/pr352/code/builders/build_v5.py": "c0867d68b863ca7d8cdd7002ffed263cbd5525fea4522267b5f640e4eff5597b", + "upstream/pr352/code/builders/decomp.py": "699c424170b41d3711da6a283f58cac824402ca373764365fd05c8e645ed07f5", + "upstream/pr352/code/builders/gather.py": "8c7d2a34fdcbe75d8ed8299e399d578b32adf44402c773fd905aa7c88e2b460d", + "upstream/pr352/code/builders/interface.py": "3b3e2fb894f871a9b6145844faaff34a05add59ae0eb8882c8feb2b914265b8a", + "upstream/pr352/code/builders/twin.py": "cfd261d82a31dd9024f1fa191eac2f5d893a7b51833b912459de46a1e9aac003", + "upstream/pr352/code/checkers/columns_h.cpp": "26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8", + "upstream/pr352/code/checkers/exactnd_h.py": "28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3", + "upstream/pr352/code/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "upstream/pr352/code/checkers/legality_h.cpp": "5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056", + "upstream/pr352/code/checkers/sub.hpp": "59c1a64f9df61fc50f47d5a78c8f9351875bf6b352db1c9d109c7c90542a4f19", + "upstream/pr352/code/checkers/verifyT.cpp": "1a5aea81aab652622e6547d901ead6aaf54fdca231da897dd99474c9f64a33bf", + "upstream/pr352/code/complex/certify_complex.py": "7e480b7761fa700944a7dca41ccbefd530203b5e9168b6b37fe879b7e6da57fa", + "upstream/pr352/code/complex/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "upstream/pr352/code/complex/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "upstream/pr352/code/complex/code/complex_labels.py": "e000ee131389fec427388b85f632879cbaaf10e5e5d979a47d6307d64ce58982", + "upstream/pr352/code/complex/code/complex_scalars.py": "38e985ebe8c8e7f8c83c03828abde0c80be418caf95e97afdf2d0c357c0ed919", + "upstream/pr352/code/complex/code/complex_splice.py": "aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce", + "upstream/pr352/code/complex/code/p10pins.py": "93b78a2e038b23264d04836928c78b6ebf33b87ff3dcc0e43ba0f1748fadd143", + "upstream/pr352/code/complex/code/scatter.py": "dfd1afbbb3ff86f54db6a0313916403ec8ee6f939caa62f3edcc9d7a151bff95", + "upstream/pr352/code/complex/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "upstream/pr352/code/complex/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "upstream/pr352/code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "upstream/pr352/code/complex/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "upstream/pr352/code/complex/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "upstream/pr352/code/complex/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "upstream/pr352/code/complex/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "upstream/pr352/code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "upstream/pr352/code/complex/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "upstream/pr352/code/complex/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "upstream/pr352/code/complex/inputs/complex/source-pins.json": "0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb", + "upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "upstream/pr352/code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "upstream/pr352/code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "upstream/pr352/code/complex/inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "upstream/pr352/code/complex/inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "upstream/pr352/code/complex/inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "upstream/pr352/code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "upstream/pr352/code/complex/inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "upstream/pr352/code/complex/inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "upstream/pr352/code/complex/inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "upstream/pr352/code/complex/inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "upstream/pr352/code/complex/inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "upstream/pr352/code/complex/inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "upstream/pr352/code/complex/inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "upstream/pr352/code/complex/inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf", + "upstream/pr352/code/complex/pins-e8.json": "bf66f785878f636616ceab193e5a222143945ea06fc2f13dfb99b204ebba82ff", + "upstream/pr352/code/complex/portable_complex.py": "44e8ae8a5b915358a97dbed5fe4e70195ed3581fd45a216df48fc82a029db87d", + "upstream/pr352/code/complex/regress_pr346.py": "29479da1547cd39cf20fe387cde4cad847a2880266db9d0ef3fb474f68591feb", + "upstream/pr352/code/export_p10.py": "1161d23b459f7d981d6716073745909126d5465018cbbea7e6e6a9e4e5d68add", + "upstream/pr352/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "upstream/pr352/code/pricing/certify_bit.py": "fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394", + "upstream/pr352/code/pricing/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "upstream/pr352/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "upstream/pr352/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "upstream/pr352/code/pricing/prime_new.py": "7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a", + "upstream/pr352/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "upstream/pr352/code/pricing/tile_check.py": "38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae", + "upstream/pr352/code/provenance.py": "9f5c05aa4d172478f2ab67e7bb83cacebfccc10ecba650c23539cdcee18f2139", + "upstream/pr352/code/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "upstream/pr352/data/bit/BASE-RECORDS.bin.gz": "caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430", + "upstream/pr352/data/bit/BASE-frames.json.gz": "35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f", + "upstream/pr352/data/bit/BASE-states.json.gz": "1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22", + "upstream/pr352/data/bit/FINAL-NEW-FRAMES.json": "e7fe9d0686829ad5acf7930698b3c81a866ae834422aa3c9a12057dfae627175", + "upstream/pr352/data/bit/FINAL-RECORDS.bin.gz": "fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6", + "upstream/pr352/data/bit/RECORD-SHA256SUMS": "21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2", + "upstream/pr352/data/bit/labels.json": "e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce", + "upstream/pr352/receipts/complex-guard-e8.json": "f94a5dca42cbb88e9650f8f8a3ffbd1153636dfc0a48da5f7a7fca908c0650ad", + "upstream/pr352/receipts/kappa.json": "36316b6cfe423b56cda1fd52843e56c997d060e33d26b732b3ecf4de3ae83aaa", + "upstream/pr352/receipts/official-five-stage-columns.json": "32e291f249b4eab8d65664d10c94208fe2154bdb4a45aaff84e9e8da5295a29f", + "upstream/pr352/receipts/official-legality.json": "7e675b7720f056548c1ee9f9de523eea10e6b014ddf90b7a630fd96163acbce6", + "upstream/pr352/requirements.txt": "ca0825e0ae3db2855af7535ebdc4775beadbb6f07f8d3a84f0f4fd5b95ba5eae", + "upstream/pr352/verify.sh": "1a05c0b31ea37b2b5a4b84f6f9f504af8dd4220e13a6d9d86f64b2a731a903c7", + "verify.py": "aa6f05c39404b4038c31c72f9fe7a8e137df911f6cb6fc668e316be37c40b126" + } +} diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/NOTICE.md b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/NOTICE.md new file mode 100644 index 0000000000..d0a70f4c5c --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/NOTICE.md @@ -0,0 +1,9 @@ +# Attribution and correction + +Upstream PR352 at 04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2 is preserved byte for byte under upstream/pr352, including its complete NOTICE.md and nested notices. DaysSky prepared its E8 integration with Anthropic Claude assistance. Jacob Sussman authored the E8 complex unit, Lean theorem, generators and independent replay at 9c94857bbaee886f8649edee0bc2d3c738f9555e. All inherited contributors and licenses remain credited by the retained upstream notices. + +This independent wrapper, actual dirty scalar column audit, parity-correct finite invoice, receipt binding and adapter were prepared with substantial OpenAI Codex assistance. Apache-2.0 applies to the new code. + +The upstream portable guard applies the even-dimensional binary orthogonal-group order at odd dimension m=45. This wrapper corrects the cover to |O(45,2)|=|Sp(44,2)|=2^484 product_{i=1}^{22}(2^{2i}-1), a factor (2^44-1)/2 larger. The physical-stock row coefficient becomes 11162 instead of 11119. All retained strict finite bounds still hold, and the paid recursive histogram/coarse saving are unchanged. The complete corrected scalar, adapter, router, physical stock and literal invoice is recomputed from fresh receipts. + +The declarative source is the explicit pinned gcert word. Lean data are regenerated byte for byte; neither certificate-producer regeneration nor a local Lean kernel build is claimed. No unconditional multiplication theorem is asserted. diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/SOURCE.json b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/SOURCE.json new file mode 100644 index 0000000000..0d9bdfc56c --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/SOURCE.json @@ -0,0 +1,38 @@ +{ + "candidate_sha256": "3594f19c4d01cf11fb930c5c61baeed399620acbc5b94096b16bcacb23997dd3", + "certificate_gzip_path": "upstream/pr352/code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz", + "certificate_gzip_sha256": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "complex_coarse": "876248285600677/1000000000000000000", + "declarative_source": true, + "declarative_source_scope": "Explicit byte-pinned gcert/1 scalar/frame word; no module/spec-to-certificate regeneration is claimed.", + "e8_source_head": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "lean_data_regeneration_claim": true, + "ledger": { + "calls": 20830, + "centres": 8, + "copy_calls": 40, + "deficit": 120, + "idle_calls": 960, + "max_child": 20, + "rank_mass": 56715 + }, + "parameters": { + "R": 783, + "W_live": 1263, + "h": 9, + "invocation_live": 1023, + "m": 45, + "v": 120 + }, + "parity_corrected_complete_invoice": true, + "producer_regeneration_claim": false, + "public_head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "public_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/352", + "scalar_primitive_steps": [ + 68158, + 72856 + ], + "scope": "Fresh explicit E8 scalar/frame word admission, actual arbitrary-dirty scalar column checks and both reflected paid profiles; unchanged upstream generators reproduce 25 Lean data/configuration files, but no Lean kernel build is performed. Correct odd-dimensional orthogonal cover order and full finite invoice replace PR352 even-dimensional undercount. All-size Clifford/selector/common-grid/row/compiler/routing and multiplication interfaces remain conditional inherited dependencies.", + "upstream_lean_rebuilt": false, + "upstream_manifest_sha256": "4b76fb09595321986da04017db16cf6aa36bcd6a048cdee2ec8b656de811e488" +} diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/admit.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/admit.py new file mode 100644 index 0000000000..82d7254876 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/admit.py @@ -0,0 +1,51 @@ +"""Independent E8 dirty scalar words and corrected odd-dimensional cover invoice. +OpenAI Codex-assisted; no Lean build, unconditional theorem, or combined kappa claim. +""" +import sys +sys.dont_write_bytecode=True +assert __debug__ +sys.set_int_max_str_digits(0) +from pathlib import Path +from fractions import Fraction as Q +from math import prod +import os,importlib.util,gzip,json,hashlib,time +import argparse +ap=argparse.ArgumentParser();ap.add_argument('--source',required=True,type=Path);ap.add_argument('--output',required=True,type=Path);args=ap.parse_args();ROOT=args.source.resolve();C=ROOT/'code/complex';OUT=args.output.resolve();assert not OUT.exists() and not OUT.is_relative_to(ROOT);OUT.mkdir(parents=True) +os.environ['CX_PINS']=str(C/'pins-e8.json') +for k in ['CX_SOURCE_PINS','CX_RECORD']:os.environ.pop(k,None) +sha=lambda p:hashlib.sha256(Path(p).read_bytes()).hexdigest() +def load(name,p): + s=importlib.util.spec_from_file_location(name,p);m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m +G=load('independent_e8_guard',C/'portable_complex.py');raw=G.run(C,progress=lambda s:print(s,flush=True));(OUT/'UPSTREAM-GUARD.json').write_text(json.dumps(raw,sort_keys=True,indent=2)+'\n') +pins=json.loads((C/'inputs/complex/source-pins.json').read_text());cert=json.loads(gzip.decompress((C/pins['certificate']['path']).read_bytes()));S=G.module(C,'complex_scalars');A=S.flat(cert['A']);B=S.flat(cert['B']);v,R,h=cert['v'],cert['R'],cert['h'];n=2*v+R +# Live columns are arbitrary independent input scalars; only private work is initially zero. +# Set all abstract recursive frame transforms to identity to isolate both literal dirty scalar maps. +scalars={};start=time.monotonic() +for orientation in ['forward','backward']: + reg={('L',i):{i:Q(1)}for i in range(n)};steps=0 + for phase,e in S.inv_schedule(orientation,A,B,cert): + tag=e[0] + if tag=='recursive_center':continue + t=e[1] + if tag=='clear':reg[t]={} + elif tag=='copy':reg[t]=dict(reg.get(e[2],{})) + elif tag=='add': + src=dict(reg.get(e[2],{}));q=Q(e[3],e[4]);target=reg.setdefault(t,{}) + for j,c in src.items(): + z=target.get(j,Q(0))+q*c + if z:target[j]=z + else:target.pop(j,None) + else:raise AssertionError(tag) + steps+=1 + expected={('L',i):{i:Q(1)}for i in range(n)} + for t in range(v): + if orientation=='forward':expected[('L',v+t)][t]=Q(1) + else:expected[('L',t)][v+t]=Q(-1) + assert all(reg[r]==e for r,e in expected.items()),orientation+' actual live scalar map' + assert all(not z for r,z in reg.items()if r[0]!='L'),orientation+' dirty work cleanup' + scalars[orientation]=dict(status='PASS_FULL_ACTUAL_DIRTY_SCALAR_WORD',independent_live_columns=n,source_columns=v,target_columns=v,helper_columns=R,scalar_macros=steps,all_live_rows_correct=True,all_private_work_restored_zero=True,expected_map='Y += X; X and dirty S restored'if orientation=='forward'else 'X -= Y; Y and dirty S restored',recursive_scope='All recursive frame operators specialized to identity; validates literal dirty scalar map and both projection schedules, while upstream splice separately checks exact frame incidence and child ranks.') + print('PASS actual dirty scalar word',orientation,steps,flush=True) +guard_module=load('e8_parity_correct_finite_guard',Path(__file__).with_name('finite_guard.py'));correct=guard_module.finite_guard(raw,cert) +rowphysical=correct['physical_row_overcharge_coefficient'] +rec=dict(status='PASS_E8_INDEPENDENT_DIRTY_SCALARS_AND_CORRECTED_FINITE_GUARD',upstream_head='04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2',upstream_manifest_sha256=sha(ROOT/'MANIFEST.sha256'),guard_receipt_sha256=sha(OUT/'UPSTREAM-GUARD.json'),certificate_sha256=pins['certificate']['uncompressed_sha256'],scalar_words=scalars,finite_guard=correct,upstream_finding='The upstream m=45 guard uses the even-dimension orthogonal order and undercounts the cover by (2^44-1)/2. Correcting it preserves every retained strict finite guard and changes no coarse saving.',seconds=time.monotonic()-start,scope='Independent audit of supplier words and finite charges only; no Lean build or complete multiplication theorem proof.') +(OUT/'INDEPENDENT-AUDIT.json').write_text(json.dumps(rec,sort_keys=True,indent=2)+'\n');print('PASS corrected complete invoice',correct['group_bits'],rowphysical,flush=True) diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/finite_guard.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/finite_guard.py new file mode 100644 index 0000000000..c8e3e8cee9 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/finite_guard.py @@ -0,0 +1,41 @@ +"""Parity-correct exact binary orthogonal cover invoice for the pinned E8 supplier. +OpenAI Codex assistance; corrects PR352 even-dimension formula at m=45. +""" +import sys +if not __debug__:raise SystemExit('Assertions required') +sys.dont_write_bytecode=True +sys.set_int_max_str_digits(0) +from math import prod +def orth_order(m): + if m%2: + r=m//2;return(1<<(r*r))*prod((1<<(2*i))-1 for i in range(1,r+1)) + return(1<<(m-1+(m//2-1)**2))*prod((1<<(2*i))-1 for i in range(1,m//2)) + +def finite_guard(raw,cert): + enumeration={} + for d in [1,2,3,4,5]: + odd=[x for x in range(1,1</research/w3-p10b-complex-p10` +runs the original and the generalized checks on PR #346's own p = 10 program and pins. They agree byte for byte on +both scalar schedules, both splice programs, the primitive expansions, the ledger, the labels and the precision +guard. The generalized run only adds the keys `centres` and `centre_ranks`. + +## Bit word + +The bit word, its data and its checks are PR #346's, byte-identical (`data/bit/`, `code/builders/`, `code/checkers/`, +`code/pricing/`, steps 1–4 of `verify.sh`). `SOURCE-pr346.json` records the git blob id of every file carried over +unchanged from PR #346 at `11b4de5` (73 files), the 11 edited files and the 32 not carried over (PR #346's p = 10 +complex producer, its modules, program and receipts). Step 0 of `verify.sh` checks the blob ids (`code/provenance.py`). The vendored base snapshot (PR #325 p10b, root 7.70276909563042·10⁻⁴) is +rebuilt through Design T and twin condensation to the hash-checked final word (root 8.01726·10⁻⁴). On that word +`verify.sh` runs: + +- PR #266's official legality and five-stage columns checkers; +- exact rational nondegeneracy and the prime-witness rule on the 320 new frames; +- the width-100 bank tiling. + +`code/pricing/certify_bit.py` then certifies c and runs PR #315's outer assembly with the E8 b. All 47 strict +constraints are positive (including `complex_above_bit` and `leaf_saving_above_bit`), and the adjacent 10⁻¹⁸ κ is +rejected. + +## Verify + + bash research/w3-p10b-e8-complex/verify.sh /tmp/w3-p10b-e8-verify + +About five minutes. It needs Python 3.12+ with `requirements.txt` (numpy, mpmath), g++ (C++17) and Boost headers. The +final line is: + + PASS conditional kappa = 801083628465007/1000000000000000000 = 0.000801083628465007 + +Receipts of this run are in `receipts/`: +- `complex-guard-e8.json`: the full complex guard output; +- `kappa.json`; +- PR #346's official-checker receipts, unchanged. + +## Open obligations + +- **Bit side.** All of PR #346's open obligations remain unchanged: PR #310's native downstream chain; PR #315's + scalar/prime/finite stages, replaced by the official cohort checkers; the inherited row constants 9909 + 252; + every inherited interface of PR #315/#325. +- **Complex side.** + - The generalization of the portable complex checks to table scatter and full-rank totals is new code, checked by + regression against PR #346 and by the E8 run. + - PR #200's complete complex checker and PR #194's contract, which #346 ran on its #202-tree program, work on + that producer's format and are not run on E8. In their place stand Sussman's Lean theorem (checked in his + repository, not rebuilt here), his two checkers, his independent replay, and the byte-for-byte Lean-data + regeneration. +- This is a conditional finite construction, not a formal verification of the multiplication theorem. + +Because the bit side binds, a bit-side improvement on this word now raises κ until it reaches the E8 complex +saving, about 8.76·10⁻⁴. + +## Credits + +- Complex unit, Lean theorem, generators and replay: Jacob Sussman (wht-power-saving-lean). His unit uses devices + from this repository: jamesyc #124 and eumemic #143; Chafik Boukhalfa #200/#233; icekylinx #184, carried in + ikeboy's #191/#193. +- Bit word and package base: LJH-217 (#346), on DreamingOfClouds' #325/#315 and utcorvusvolat-dotcom's w3 work + (#310). +- Official checkers: #266. +- Complex checks: the #315/#304/#256/#233/#202/#200/#194/#184 lineage. + +See `NOTICE.md`. diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json new file mode 100644 index 0000000000..0de6ddc402 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json @@ -0,0 +1,129 @@ +{ + "schema": "pr346-provenance/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/346", + "commit": "11b4de5ff8ed5fccf55d4af1043358d257308e8e", + "source_root": "research/w3-p10b-complex-p10", + "note": "Every file under \"identical\" has, in this package, the git blob id it has in PR #346 at the commit above (check with: git ls-tree -r 11b4de5ff8ed5fccf55d4af1043358d257308e8e -- research/w3-p10b-complex-p10). Files under \"changed\" were edited here; \"removed\" were not carried over.", + "identical": { + "LICENSE": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "code/builders/addcomp.py": "6d5fea18b0f58bf36e012981055261101230096d", + "code/builders/build_v5.py": "f18f96300806f9308cfd24554de41b85860ae514", + "code/builders/decomp.py": "365e5bf2a8204e3512929c2bba57cc9e8f4b66e9", + "code/builders/gather.py": "ef063373c227fe4efdac34bb7bef11f8f7fe611f", + "code/builders/interface.py": "0673ddabe9c7e6ba6221ca05f288a2b330c627f5", + "code/builders/twin.py": "6ec783fd2b0a5592c5733c1882d896fffa63a0a7", + "code/checkers/columns_h.cpp": "07b7fd220c1742eb9c634e8572bef2df8d1f2aa6", + "code/checkers/exactnd_h.py": "fa90b5089f53cbd1f98ec026391cf9375eb6a11d", + "code/checkers/json.hpp": "82d69f7c5d044c9887c96b90c97f5639083ecd14", + "code/checkers/legality_h.cpp": "f4501be83a229cac1f3050993a204d8f75b86108", + "code/checkers/sub.hpp": "70a8a83faf3e28cb3ffe1eaa1d5dd194028712c7", + "code/checkers/verifyT.cpp": "af2f7a3cd7e1780d549c60a74ef86371abcc560c", + "code/complex/code/complex_basis.py": "8c400798a5f25d366747b35cb55e985222039083", + "code/complex/code/complex_gx.py": "0986cc810e1d72ffb2b9ea70d1fe40517bbf2d76", + "code/complex/inputs/complex/LICENSE": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "code/complex/inputs/complex/NOTICE": "63aa295646734f62c4270e653811530f9a570d3a", + "code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "c1a88436113a1351f80c72bd08f6406ed5faa51d", + "code/complex/inputs/complex/retained/compact-control-layout.tex": "16f4d233471a7d189163ae7e7902becadecbba64", + "code/complex/inputs/complex/retained/compact-control-movement.tex": "06b6a9ef24245ac7b724c53a204635415b402357", + "code/complex/inputs/complex/retained/copied-centers-assembly.tex": "b0c69166c3048d27518355995e3e5b622722c696", + "code/complex/inputs/complex/retained/copied-centers-lemma.tex": "8933aaf508aa9d4c75ba1290913e02f6868d351d", + "code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "907a0ceda8df0317ddc7f2b71df5af2aa4d47dfc", + "code/complex/inputs/complex/retained/general-clifford-frames.tex": "0367eeb005298601f28a673861d6f71bf1d0ebbb", + "code/complex/inputs/complex/retained/stopped-product-complex.tex": "4a9037137cd3158dbeca6d9e3b1881a599ebfcb5", + "code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "f7bdc3d903341a9546056cde124d642e2677318b", + "code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "204f6d9cf902c85900f237bd99a23774e9a3f81b", + "code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "b8306527d64ae06271c6aa55c5e0b3ded85c651c", + "code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "305da15b5d129959a0696e2031289eea91ec1813", + "code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "9aa06b5bf28a2380ef9d54a0785ac2369f6012e4", + "code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "eb4490af8b0f5b97984d9dbdf345d86fe65d02c7", + "code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "d69fcb4992778bcd2d12596e365ee8483aa538a2", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "6336ba076607f4229c58e51b01f35b8457effb88", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "c13042eb43328f9771a5f85e83edb59810f3a006", + "code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "670f4c6a84b3453dd0b1bc0879fff3ecd9410919", + "code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "e68c42377f4fd0d0352ba697357d05f60333c8dc", + "code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "951edde5cf5fdfb1dd5f7902499f3ccab961bf4a", + "code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "d7ecfebcea804af8209a0db3d89caa9ed364ea7a", + "code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "c6cbac38e3a2fbabac74610519e26fcc065f7ff5", + "code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9b9925ce268a9f757fd44913140a57df95315769", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "3c3250279e66b56c9fee8a12c265ae2780ce4761", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "eeed011d64482adbdf0d6ff48a7c395a7252d57a", + "code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "3539192ac1d3a51641f7ba08fa06a8659b12bc0b", + "code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "df563cde73a8f942e9c90189261dd6e8482d40f1", + "code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "499fa67e88ebfe0ad777081cb61def3f74de81ba", + "code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "0392e1f05bb89cca472c976391a649418dde186e", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "24e261ad0862ba778f0e7f00d48756865b7f4eb8", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "2eca6e713bfd47449b872a0462857806861be9d5", + "code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "6bd7cfa0c3f34bbd04fc445eceae0cc4d4c567fc", + "code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "e28b355d0a271da6c8c7da8b6d68451817378bf1", + "code/complex/inputs/complex/sources/tools__gx__gx.py": "6d14c0a976146eb881c1e3897b2476f8633d4e9c", + "code/complex/inputs/complex/sources/tools__gx__gxbind.py": "fcb625619cb07a9be9594422357786ca6e3c4add", + "code/complex/inputs/complex/sources/tools__gx__gxconv.py": "49ebb65973a2403bb22aa32692762cd0522a0287", + "code/complex/inputs/complex/sources/tools__gx__gxcore.py": "3e3f0a3076f3c326e7833c74eceecb3436dd3185", + "code/export_p10.py": "f492305d64e2354ed2959f8bd19ad670f50db238", + "code/pricing/base_two_moment.py": "14a90fa0e788217856f070382c9e61bd7c603c61", + "code/pricing/certify_bit.py": "b8a6c4be5931daa83921e23ee5ad3ab263ca8ce8", + "code/pricing/cost.py": "677584c1c6b0e959c19f58521b68d4b3e847f97e", + "code/pricing/moment.py": "7d697cb45203fe72d97037403d6da41f71f3b7fd", + "code/pricing/outer.py": "43007488ad2c43187c77cc6798beff8b1cd76ad2", + "code/pricing/prime_new.py": "372ce0958a23c0312209a0a0c6ea11af34e8a92d", + "code/pricing/prime_witnesses.py": "7f16d930302ae879c562dd58e085d9747fcac077", + "code/pricing/tile_check.py": "1e537bd2e48b93bbfdcbdec42672075a2441b584", + "code/stage_cohort.py": "f6d7afe3e623208c4207b6a683a1e3e49249e31c", + "data/bit/BASE-RECORDS.bin.gz": "087f8261242e0e897907b8d4a86a7e1d100df172", + "data/bit/BASE-frames.json.gz": "42ad5869ca5927c51daaa0af887c58960a4b37e3", + "data/bit/BASE-states.json.gz": "427bc873b9ac858dd42c41b7a0cf8523e7dc3d09", + "data/bit/FINAL-NEW-FRAMES.json": "a508432521da48acfe249be0690405b24a955ed0", + "data/bit/FINAL-RECORDS.bin.gz": "884af231daea2b9d5fdb7d44b28e3126c42c9fab", + "data/bit/RECORD-SHA256SUMS": "6525e19277a941f45d75ab9235c72fd9a0ac0bc8", + "data/bit/labels.json": "b2974963e69f9462817c1db422575843f15a412d", + "receipts/official-five-stage-columns.json": "34918d43331b6585f2df68f27a0de4a806d4e1f5", + "receipts/official-legality.json": "1f400bd50f802ffd9dcd89a522e8ff29ec29c174" + }, + "changed": { + "NOTICE.md": "6d5643cc768697bae1e5c42668492ee446eb4fb0", + "README.md": "4de9dab5f7ef1d4d0855b44f9bfa59f29abd9bc7", + "code/complex/certify_complex.py": "d29a2e4e6f0e6b3c30c1ec59ae9f3fdef98f3d8b", + "code/complex/code/complex_labels.py": "bf144bc76410bf868028cb2374ddbf77eab4186a", + "code/complex/code/complex_scalars.py": "8289132f0db52cc5d4d44598c445273a22cece55", + "code/complex/code/complex_splice.py": "bb6fb13fde2cf7f32c4d1b05c31dbfcb53f0047e", + "code/complex/code/p10pins.py": "d9063dd4b736ea486b8dcb1f059cc441a216cc89", + "code/complex/inputs/complex/source-pins.json": "b4fe17102a50e62710634e24af6d542367f06cb8", + "code/complex/portable_complex.py": "f2b639da7b4cf06fdcfbe67809ea07577bedf945", + "receipts/kappa.json": "cf7e59c10041610cd4dc89f9beb2e3630c8a9521", + "verify.sh": "93efd88caac9bcc44916aa3ee8d0e39858939fd9" + }, + "removed": [ + "code/complex/inputs/complex/NOTICE-PR304", + "code/complex/inputs/complex/centre-mw/NOTICE", + "code/complex/inputs/complex/centre-mw/centre46_graph.diff", + "code/complex/inputs/complex/centre-mw/exact_result.json", + "code/complex/inputs/complex/centre-mw/pmod46_ptc1_final.json", + "code/complex/inputs/complex/centre-mw/qmod_q1_snap1.json", + "code/complex/inputs/complex/centre-mw/tmod_final.json", + "code/complex/inputs/complex/gcert1-p10-L10f.json.gz", + "code/complex/pins-p10f.json", + "data/complex/bit_qmod_p10.json", + "data/complex/gcert1-p10-L10f.json.gz", + "data/complex/pm_p10b.json", + "data/complex/tmod_t2_p10.json", + "producer/admit_p.py", + "producer/aligned_word_p.py", + "producer/anneal_pmod.py", + "producer/basecost.py", + "producer/certify_complex.py", + "producer/compmap.py", + "producer/contract_p.py", + "producer/gcert_emit.py", + "producer/graph_centre46.diff", + "producer/localscan.py", + "producer/make_layer_p.py", + "producer/modules_centre_root.diff", + "producer/normalize_scatter.py", + "producer/run_one.sh", + "receipts/complex-admission-L10e.txt", + "receipts/complex-admission-L10f.txt", + "receipts/complex-guard-L10e.json", + "receipts/complex-guard-L10f.json", + "receipts/kappa-L10f.json" + ] +} diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py new file mode 100644 index 0000000000..6d5fea18b0 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py @@ -0,0 +1,12 @@ +import numpy as np, json, sys +d=sys.argv[1] +s=json.load(open(d+'/249-states.json')) +v=s['v']; ZERO=s['ZERO'] +rec=np.fromfile(d+'/249-records.bin',dtype='1 else ''+os.environ.get('W3WORK','work')+'/agentA/T/out' +LIMIT=int(sys.argv[2]) if len(sys.argv)>2 else 10**9 +os.makedirs(OUT,exist_ok=True) +s,fr,dim,rec=load_snapshot(''+os.environ.get('W3WORK','work')+'/snap') +v=s['v'];n=s['n']; ZERO=s['ZERO']; FULL=s['FULL'] +FR=fr['frames'] +info=pickle.load(open(''+os.environ.get('W3WORK','work')+'/agentA/T/info.pkl','rb')) +part=pickle.load(open(''+os.environ.get('W3WORK','work')+'/agentA/interface.pkl','rb')) +P=lambda p:p//2 +cube_of=[tuple(sorted(P(p) for p in lab[i])) for i in range(v)] +bits=lambda i: tuple(p%2 for p in lab[i]) +init={r:s['initial'][str(r)] for r in range(n)} +NR=len(rec) +HH=20 +chi=np.zeros((v,HH),dtype=np.int64) +for i in range(v): + for p in lab[i]: chi[i,p]=1 +icache={} +def items_in(fid): + if fid in icache: return icache[fid] + if dim[fid]==0 or dim[fid]>3: icache[fid]=None; return None + A=np.array(FR[str(fid)]['A'],dtype=np.int64) + I=frozenset(np.nonzero(np.all(chi@A.T==0,axis=1))[0].tolist()); icache[fid]=I if I else None; return icache[fid] +byset={} +for k_ in FR: + f=int(k_) + if 1<=dim[f]<=2: + I=items_in(f) + if I and len(I)==dim[f]: byset.setdefault(I,f) +newframes={} +nextid=max(int(k) for k in FR)+1 +from fractions import Fraction +def kernel_int(B): + M=[[Fraction(x) for x in b] for b in B]; m=len(M); piv=[]; r=0 + for c in range(HH): + pr=next((i for i in range(r,m) if M[i][c]!=0),None) + if pr is None: continue + M[r],M[pr]=M[pr],M[r]; pv=M[r][c]; M[r]=[x/pv for x in M[r]] + for i in range(m): + if i!=r and M[i][c]!=0: + f_=M[i][c]; M[i]=[a-f_*b for a,b in zip(M[i],M[r])] + piv.append(c); r+=1 + if r==m: break + out=[] + for fc in [c for c in range(HH) if c not in piv]: + x=[Fraction(0)]*HH; x[fc]=Fraction(1) + for i,pc in enumerate(piv): x[pc]=-M[i][fc] + den=1 + for q in x: den=den*q.denominator//math.gcd(den,q.denominator) + out.append([int(q*den) for q in x]) + return out +def frame_for(itemset): + global nextid + I=frozenset(itemset) + if I in byset: return byset[I] + B=[chi[i].tolist() for i in sorted(I)] + fid=nextid; nextid+=1 + newframes[fid]={'B':B,'A':kernel_int(B),'dim':len(B)} + dim[fid]=len(B); byset[I]=fid; icache[fid]=I + return fid +# ---------------- roles +role={} +for cube,C in info.items(): + for x in C['X']: role[x]=('X',cube) + for pl,(r,last,e) in C['BH'].items(): role[r]=('BH',cube) + for r in C['single']: role[r]=('S',cube) + for r in C['carrier']: role[r]=('C',cube) + for r in C['death']: role[r]=('D',cube) + for r in C['upper']: role[r]=('U',cube) + for r in C['other']: role[r]=('Y' if v<=r<2*v else 'M',cube) +moves=collections.defaultdict(list) +for k in np.nonzero(rec[:,0]==0)[0]: moves[int(rec[k,1])].append(int(k)) +# special cubes: Y or X reading BH at planes -> skip +skipc=set(); xplane_keep=set() +for k in np.nonzero(rec[:,0]==1)[0]: + a,b,f=int(rec[k,1]),int(rec[k,2]),int(rec[k,4]) + if 1<=dim[f]<=3: + ra=role.get(a,('?',None)); rb=role.get(b,('?',None)) + if rb[0]=='BH' and ra[0]=='X': xplane_keep.add(a) # v5: keep this X's plane visit +# single -> target (delivery ADD) +sdeliv={} +for k in np.nonzero(rec[:,0]==1)[0]: + a,b=int(rec[k,1]),int(rec[k,2]) + if v<=a<2*v and role.get(b,('?',))[0]=='S' and dim[int(rec[k,4])]==HH-1: sdeliv[b]=a-v +# X-X forward mix ADDs +xx={} +for k in np.nonzero(rec[:,0]==1)[0]: + a,b=int(rec[k,1]),int(rec[k,2]) + if a new record (replace in place) +insert_before=collections.defaultdict(list) # k -> records to emit before k +newblock=[] +fwd=[] # new forward gates for inversion (a,b,f) +unused=set() +def MOVE(r,old,new): + assert dim[new]>=dim[old], (r,old,new) + return [0,r,old,new,dim[new]-dim[old],0] +def ADD(a,b,f,c=1,z=40): return [1,a,b,c,f,z] +def xor(a,b): return tuple(p^q for p,q in zip(a,b)) +allb=[(i,j,k) for i in (0,1) for j in (0,1) for k in (0,1)] +cubeframes_of={} +def is_cubeframe(fid,cube): + I=items_in(fid) + return bool(I) and all(cube_of[i]==cube for i in I) +stats=collections.Counter() +GPOOL=[] +for cube in todo: GPOOL.extend(sorted(info[cube]['death'])) +GPOOL_SET=set(GPOOL) +used_ids=set() +def take_id(own): + while own: + r=own.pop() + if r not in used_ids: used_ids.add(r); return r + while GPOOL: + r=GPOOL.pop() + if r not in used_ids: used_ids.add(r); return r + raise Exception('global pool empty') +for cube in todo: + C=info[cube]; byb=C['byb']; Xb=lambda b: byb[b] + cubeset=set(C['items']) + regs=set(C['X'])|{r for pl,(r,l,e) in C['BH'].items()}|set(C['single'])|set(C['carrier'])|set(C['death']) + # ---- mix pairs + mixpairs=[] + for b in allb: + if b[1]==0: + A_,B_=Xb(b),Xb(xor(b,(0,1,1))) + k=xx[frozenset((A_,B_))] + car=int(rec[k,1]); pas=int(rec[k,2]) + early=dim[int(rec[k,4])]==2 + Mf=int(rec[k,4]) if early else frame_for((A_,B_)) + mixpairs.append(dict(A=car,B=pas,k=k,early=early,M=Mf,bA=bits(car),bB=bits(pas))) + mixof={} + for mp in mixpairs: mixof[frozenset((mp['A'],mp['B']))]=mp + # ---- planes and BHs + planes=[] + for pl,(r,last,e) in C['BH'].items(): + fl=part[r]['frames']; pids=[f for f in fl if dim[f]==3] + bs=[bits(i) for i in pl] + if len({b[0] for b in bs})==1 or len({b[1]^b[2] for b in bs})==1: dirn=(0,1,1) + elif len({b[1] for b in bs})==1 or len({b[0]^b[2] for b in bs})==1: dirn=(1,0,1) + else: dirn=(1,1,0) + # split into 2 edges along dirn + its=sorted(pl); e1=None + edges=[] + rest=set(its) + while rest: + a=min(rest); bb=[i for i in rest if xor(bits(a),bits(i))==dirn][0] + edges.append(frozenset((a,bb))); rest-={a,bb} + planes.append(dict(items=pl,BH=r,pids=pids,first=pids[0],dirn=dirn,edges=edges)) + # ---- tetra edges (non-mix): each in 2 planes + tedges={} + for p in planes: + if p['dirn']!=(0,1,1): + for e in p['edges']: tedges.setdefault(e,[]).append(p) + assert len(tedges)==8 and all(len(x)==2 for x in tedges.values()), (cube,len(tedges)) + medges={} + for p in planes: + if p['dirn']==(0,1,1): + for e in p['edges']: medges.setdefault(e,[]).append(p) + assert len(medges)==4 and all(len(x)==2 for x in medges.values()) + # ---- singles matching: single for target t holds item s=t^011; edge {s, t^101} or {s, t^110} + singles=[] + for r,d in C['single'].items(): + t=sdeliv[r]; c=d['exit_content']; assert len(c)==1 + sitem=c[0]; tb=bits(t); assert xor(tb,(0,1,1))==bits(sitem), (r,t,sitem) + cands=[frozenset((sitem,byb[xor(tb,(1,0,1))])),frozenset((sitem,byb[xor(tb,(1,1,0))]))] + singles.append((r,t,sitem,cands)) + # bipartite matching singles <-> tedges + match={} + def try_assign(i,used): + r,t,si,cands=singles[i] + for e in cands: + if e in used: continue + used.add(e) + if e not in match or try_assign(match[e],used): match[e]=i; return True + return False + for i in range(len(singles)): assert try_assign(i,set()), 'no matching' + # ---- carriers + carriers=[] + for r in C['carrier']: + d=part[r]; c=d['exit_content'] + if len(c)==1: carriers.append((r,'line',c[0])) + elif len(c)==2: + e=frozenset(c); diff=xor(bits(c[0]),bits(c[1])) + if diff==(0,1,1): carriers.append((r,'M',e)) + else: + assert e in tedges, ('carrier pair not a T edge',cube,c) + carriers.append((r,'T',e)) + elif len(c)==3: carriers.append((r,'drop',None)) # p10 port: dead 3-item chain partial, register continues as a gauge + else: raise Exception(('carrier content',len(c))) + # ---- id pool for leftovers + pool=list(C['death']) + # ---- assign pair-holders + # tetra edges: L_a, L_b ; send L for item min->face plane? choose: arrival to plane p from edge e + arrivals=collections.defaultdict(list) # plane index -> list of (regid placeholder, source kind, edge, item) + T_regs={} + for e,pls in tedges.items(): + a,b=sorted(e) + # pls: two planes; L_a -> pls[0], L_b -> pls[1] + T_regs[e]=dict(La=a,Lb=b,pa=pls[0],pb=pls[1]) + plane_index={id(p):i for i,p in enumerate(planes)} + for e,tr in T_regs.items(): + arrivals[plane_index[id(tr['pa'])]].append(('L',e,tr['La'])) + arrivals[plane_index[id(tr['pb'])]].append(('L',e,tr['Lb'])) + for e,pls in medges.items(): + for p in pls: arrivals[plane_index[id(p)]].append(('M',e,None)) + # decide BH vs LO per plane, assign ids + regid={} # (kind,e,item/planeidx) -> role id + recyc={} # plane index -> carrier id + pair_carriers=[(r,kind,c) for (r,kind,c) in carriers if kind in ('M','T')] + for (r,kind,c) in pair_carriers: + last=part[r]['frames'][-1] + for pi,p in enumerate(planes): + if last in p['pids'] and c in p['edges'] and pi not in recyc: + recyc[pi]=(r,kind,c); break + recycled_carriers={x[0] for x in recyc.values()} + carriers=[x for x in carriers if x[0] not in recycled_carriers] + for pi,p in enumerate(planes): + arr=arrivals[pi]; assert len(arr)==2 + bh,lo=arr[0],arr[1] + if pi in recyc: + ce=recyc[pi][2] + if bh[1]==ce: bh,lo=lo,bh + assert lo[1]==ce + key_bh=(bh[0],bh[1],bh[2] if bh[0]=='L' else pi); key_lo=(lo[0],lo[1],lo[2] if lo[0]=='L' else pi) + regid[key_bh]=p['BH'] + if pi in recyc: regid[key_lo]=recyc[pi][0]; p['lo_carrier']=recyc[pi][0] + else: regid[key_lo]=take_id(pool) + p['bh_key']=key_bh; p['lo_key']=key_lo + # ---- remove old records of cube-layer regs within the cube layer + # deaths: all records removed (MOVEs, ADDs) -> handled via role-level removal below + # BH: MOVEs into cube frames up to and including first plane id + for p in planes: + r=p['BH'] + for k in moves[r]: + nf=int(rec[k,3]) + if is_cubeframe(nf,cube): + remove[k]=True + if nf==p['first']: break + # singles: remove MOVEs into cube frames; modify exit MOVE + for r,t,si,c in singles: + ex=part[r]['exit']; k=ex[2] + for kk in moves[r]: + if kkE (k_A), B: line->E (k_B), mix at E (mp['k']) + kA=part[A_]['exit'][2]; kB=part[B_]['exit'][2] + E=int(rec[kA,3]); assert int(rec[mp['k'],4])==E + # carrier: emit mix at M then MOVE M->E in place of kA + mixrec=rec[mp['k']].tolist(); mixrec[4]=mp['M'] + insert_before[kA].append(mixrec) + rr=rec[kA].tolist(); rr[2]=mp['M']; rr[4]=dim[rr[3]]-dim[rr[2]]; modify[kA]=rr + remove[mp['k']]=True + # passive: remove its MOVE to E; its next MOVE (from E) gets source M + remove[kB]=True + nxt=[kk for kk in moves[B_] if kk>kB] + assert nxt, 'passive no next move' + k2=nxt[0]; rr=rec[k2].tolist(); assert rr[2]==int(rec[kB,3]), ('passive next move',rr) + # any ADDs of passive at E between? check later in verification + rr[2]=mp['M']; rr[4]=dim[rr[3]]-dim[rr[2]]; modify[k2]=rr + # ---- deaths & cube-internal ADD removal + for r in C['death']: + for kk in moves[r]: remove[kk]=True + stats['cubes']+=1 +unused=GPOOL_SET-used_ids +print('new frames',len(newframes),'unused ids',len(unused), dict(stats)) +# ---------------- ADD removal (forward cube-layer gates) for transformed cubes +tset=set(todo) +cl_regs=set() +for cube in todo: + C=info[cube] + cl_regs|=set(C['X'])|{r for pl,(r,l,e) in C['BH'].items()}|set(C['single'])|set(C['carrier'])|set(C['death']) +deaths=set(); +for cube in todo: deaths|=set(info[cube]['death']) +fwd_removed=np.zeros(NR,bool) +for k in np.nonzero(rec[:,0]==1)[0]: + a,b,f=int(rec[k,1]),int(rec[k,2]),int(rec[k,4]) + if dim[f]==HH: continue + if a in deaths or b in deaths: + if v<=a<2*v and dim[f]==0 and int(rec[k,5])==4: continue # comp read handled separately + fwd_removed[k]=True; continue + if 1<=dim[f]<=3: + ra=role.get(a,('?',None)); rb=role.get(b,('?',None)) + if ra[1] in tset or rb[1] in tset: + # keep interface ADDs + if ra[0] in ('U','Y','M'): continue + if ra[0]=='X' and rb[0]=='X': continue # mix handled separately + if ra[0]=='X' and a in xplane_keep and rb[0]=='BH': continue # v5: special X reads its plane block + fwd_removed[k]=True +# LIFO matching of inverses +stack=collections.defaultdict(list); inv_of={} +for k in range(NR): + if rec[k,0]!=1: continue + a,b,f=int(rec[k,1]),int(rec[k,2]),int(rec[k,4]) + if v<=a<2*v: continue + if dim[f]!=HH: stack[(a,b)].append(k) + else: + if stack[(a,b)]: inv_of[stack[(a,b)].pop()]=k +nomatch=sum(1 for k in np.nonzero(fwd_removed)[0] if k not in inv_of) +print('removed forward ADDs',int(fwd_removed.sum()),'without inverse',nomatch) +for k in np.nonzero(fwd_removed)[0]: + remove[k]=True + if k in inv_of: remove[inv_of[k]]=True +# deaths: also remove any FULL ADDs involving them that remain +for k in np.nonzero(rec[:,0]==1)[0]: + a,b,f=int(rec[k,1]),int(rec[k,2]),int(rec[k,4]) + if (a in deaths or b in deaths) and dim[f]==HH: remove[k]=True +# comp reads: remove all frame-0 cat4 reads from sigma0 helpers (regenerated later) +comp=(rec[:,0]==1)&(rec[:,5]==4)&(rec[:,1]>=v)&(rec[:,1]<2*v) +for k in np.nonzero(comp)[0]: + if dim[int(rec[k,4])]==0 and dim[init[int(rec[k,2])]]==0: remove[k]=True +# ---------------- assemble +out=[] +out.extend(newblock) +for k in range(NR): + if k in insert_before: out.extend(insert_before[k]) + if remove[k] and k not in modify: continue + out.append(modify.get(k, rec[k].tolist())) +# inverses of new forward gates, appended at the end +for (o,a,b,c,f,z) in reversed(fwd): + out.append([1,a,b,-c,FULL,41]) +out=np.array(out,dtype=np.int32) +print('records',NR,'->',len(out)) +# states +newinit=dict(s['initial']); +for r in unused: newinit[str(r)]=FULL +st=dict(s); st['initial']=newinit; st['record_count']=len(out) +json.dump(st,open(OUT+'/249-states.json','w')) +out.tofile(OUT+'/249-records.bin') +# frames +fr2={'h':fr['h'],'frames':dict(FR)} +for fid,ff in newframes.items(): fr2['frames'][str(fid)]=ff +json.dump(fr2,open(OUT+'/frames.json','w')) +with open(OUT+'/frames.txt','w') as fo: + fo.write('%d\n'%len(fr2['frames'])) + for k_,ff in fr2['frames'].items(): + fo.write('%s %d\n'%(k_,len(ff['B']))) + for row in ff['B']: fo.write(' '.join(map(str,row))+'\n') +with open(OUT+'/states.txt','w') as fo: + fo.write('%d %d %d %d\n'%(n,v,ZERO,FULL)) + for r in range(n): fo.write('%d %d\n'%(int(newinit[str(r)]),int(s['final'][str(r)]))) + for t in range(v): fo.write(' '.join(map(str,s['source_covectors'][t]))+'\n') +pickle.dump(dict(todo=todo,unused=sorted(unused),newframes=list(newframes)),open(OUT+'/plan.pkl','wb')) +print('done') diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py new file mode 100644 index 0000000000..365e5bf2a8 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py @@ -0,0 +1,6 @@ +import json +import os +lab=[tuple(l) for l in json.load(open(os.environ.get('W3LABELS','labels.json')))['lab']] +idx={l:i for i,l in enumerate(lab)} +def comps(*a): raise NotImplementedError +def name(*a): raise NotImplementedError diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/gather.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/gather.py new file mode 100644 index 0000000000..ef063373c2 --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/gather.py @@ -0,0 +1,58 @@ +# Gather per-cube structural info for the cube-layer redesign. +import os +import json, collections, sys, math, pickle +import numpy as np +sys.path.insert(0,''+os.environ.get('W3WORK','work')+'/eval'); sys.path.insert(0,''+os.environ.get('W3WORK','work')+'/agentA') +from cost import load_snapshot +from decomp import lab, idx +s,fr,dim,rec=load_snapshot(''+os.environ.get('W3WORK','work')+'/snap') +v=s['v'];n=s['n']; R=n+1 +F=fr['frames'] +P=lambda p:p//2 +cube_of=[tuple(sorted(P(p) for p in lab[i])) for i in range(v)] +bits=lambda i: tuple(p%2 for p in lab[i]) +part=pickle.load(open(''+os.environ.get('W3WORK','work')+'/agentA/interface.pkl','rb')) +init={r:s['initial'][str(r)] for r in range(n)} +ZERO=s['ZERO']; FULL=s['FULL'] +HH=20 +chi=np.zeros((v,HH),dtype=np.int64) +for i in range(v): + for p in lab[i]: chi[i,p]=1 +icache={} +def items_in(fid): + if fid in icache: return icache[fid] + if dim[fid]==0 or dim[fid]>3: icache[fid]=None; return None + A=np.array(F[str(fid)]['A'],dtype=np.int64) + I=frozenset(np.nonzero(np.all(chi@A.T==0,axis=1))[0].tolist()); icache[fid]=I if I else None; return icache[fid] +cubes=collections.defaultdict(set) +for r,d in part.items(): cubes[d['cube']].add(r) +# classify participants +info={} +cnt=collections.Counter() +for cube,regs in cubes.items(): + items=sorted(i for i in range(v) if cube_of[i]==cube) + byb={bits(i):i for i in items} + C=dict(items=items,byb=byb,BH={},single={},carrier=[],death=[],upper=[],other=[],X={}) + for r in regs: + d=part[r]; e=d['exit'] + if r3: icache[fid]=None; return None + A=np.array(F[str(fid)]['A'],dtype=np.int64) + I=frozenset(np.nonzero(np.all(chi@A.T==0,axis=1))[0].tolist()) + icache[fid]=I if I else None + return icache[fid] +def cubeframe(fid): + I=items_in(fid) + if not I: return None + cs={cube_of[i] for i in I} + return next(iter(cs)) if len(cs)==1 else None +init={r:s['initial'][str(r)] for r in range(n)} +fin={r:s['final'][str(r)] for r in range(n)} +# simulate contents; track per register its frame and content at each move +Wd=(v+63)//64 +val=np.zeros((R,Wd),np.uint64) +for i in range(v): val[i,i//64]|=np.uint64(1)< dict(cube, entry_frame, entry_from_zero, frames list, exit (frame,dim,k), exit_content) +for r in range(n): + c=cubeframe(init[r]) + if c is not None: part[r]=dict(cube=c,entry=init[r],fromzero=False,frames=[init[r]],exit=None,firstk=0) +for k in range(len(rec)): + o,a,b,c,f,z=map(int,rec[k]) + if o==0: + r=a; newf=c + cq=cubeframe(newf) + if r in part and part[r]['exit'] is None: + if cq==part[r]['cube']: + part[r]['frames'].append(newf) + else: + part[r]['exit']=(newf,dim[newf],k); part[r]['exit_content']=its(r) + elif r not in part and cq is not None and dim[cur[r]]==0: + part[r]=dict(cube=cq,entry=newf,fromzero=True,frames=[newf],exit=None,firstk=k) + cur[r]=newf + elif o==1: + if c&1: val[a]^=val[b] + elif o==2: val[n]=val[a] + elif o==3: val[n]=0 +pickle.dump(part,open(''+os.environ.get('W3WORK','work')+'/agentA/interface.pkl','wb')) +stat=collections.Counter() +for r,d in part.items(): + kind='X' if r4')]+=1 +for k,c in sorted(stat.items(), key=lambda x:-x[1])[:40]: print(c,k) diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/twin.py b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/twin.py new file mode 100644 index 0000000000..6ec783fd2b --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/builders/twin.py @@ -0,0 +1,160 @@ +# Twin condensation of M-type plane leftovers on top of a Design-T word. +# For each plane where BH and LO are both M-starters (0->M->P) and LO goes P->FULL after BH += LO: +# LO (pivot) enters at the common line E = M_bh ∩ M_lo (sigma=1); BH visits E first and absorbs LO there; +# the absorption is inverted at FULL at the very end. LO's dirt then cancels (it enters BH twice). +import sys, json, collections, pickle, math, os +import numpy as np +from fractions import Fraction +sys.path.insert(0,''+os.environ.get('W3WORK','work')+'/eval'); sys.path.insert(0,''+os.environ.get('W3WORK','work')+'/agentA') +from cost import load_snapshot +from decomp import lab +HH=20 +IN=sys.argv[1]; OUT=sys.argv[2] +os.makedirs(OUT,exist_ok=True) +s,fr,dim,rec=load_snapshot(IN) +v=s['v']; n=s['n']; ZERO=s['ZERO']; FULL=s['FULL'] +FR=fr['frames'] +init={r:s['initial'][str(r)] for r in range(n)} +NR=len(rec) +moves=collections.defaultdict(list) +for k in np.nonzero(rec[:,0]==0)[0]: moves[int(rec[k,1])].append(int(k)) +adds_dst=collections.defaultdict(list); adds_src=collections.defaultdict(list) +for k in np.nonzero(rec[:,0]==1)[0]: + adds_dst[int(rec[k,1])].append(int(k)); adds_src[int(rec[k,2])].append(int(k)) +def chain(r): return [init[r]]+[int(rec[k,3]) for k in moves[r]] +chi=np.zeros((v,HH),dtype=np.int64) +for i in range(v): + for p in lab[i]: chi[i,p]=1 +G=None +def gnorm(w): + s1=sum(x*x for x in w); s2=sum(w) + return Fraction(s1)-Fraction(s2*s2,9) +def kernel_int(Bm): + M=[[Fraction(x) for x in b] for b in Bm]; m=len(M); piv=[]; r=0 + for c in range(HH): + pr=next((i for i in range(r,m) if M[i][c]!=0),None) + if pr is None: continue + M[r],M[pr]=M[pr],M[r]; pv=M[r][c]; M[r]=[x/pv for x in M[r]] + for i in range(m): + if i!=r and M[i][c]!=0: + f_=M[i][c]; M[i]=[a-f_*b for a,b in zip(M[i],M[r])] + piv.append(c); r+=1 + if r==m: break + out=[] + for fc in [c for c in range(HH) if c not in piv]: + x=[Fraction(0)]*HH; x[fc]=Fraction(1) + for i,pc in enumerate(piv): x[pc]=-M[i][fc] + den=1 + for q in x: den=den*q.denominator//math.gcd(den,q.denominator) + out.append([int(q*den) for q in x]) + return out +def intersect_line(a1,a2,b1,b2): + # solve al*chi[a1]+be*chi[a2]-ga*chi[b1]-de*chi[b2]=0 + Mx=np.stack([chi[a1],chi[a2],-chi[b1],-chi[b2]],axis=1).astype(object) + # nullspace over Q + M=[[Fraction(int(x)) for x in row] for row in Mx] + rows=len(M); cols=4; piv=[]; r=0 + for c in range(cols): + pr=next((i for i in range(r,rows) if M[i][c]!=0),None) + if pr is None: continue + M[r],M[pr]=M[pr],M[r]; pv=M[r][c]; M[r]=[x/pv for x in M[r]] + for i in range(rows): + if i!=r and M[i][c]!=0: + f_=M[i][c]; M[i]=[a-f_*b for a,b in zip(M[i],M[r])] + piv.append(c); r+=1 + free=[c for c in range(cols) if c not in piv] + if len(free)!=1: return None + fc=free[0]; x=[Fraction(0)]*cols; x[fc]=Fraction(1) + for i,pc in enumerate(piv): x[pc]=-M[i][fc] + w=[x[0]*int(chi[a1,j])+x[1]*int(chi[a2,j]) for j in range(HH)] + den=1 + for q in w: den=den*q.denominator//math.gcd(den,q.denominator) + wi=[int(q*den) for q in w] + gg=0 + for q in wi: gg=math.gcd(gg,abs(q)) + wi=[q//gg for q in wi] + return wi +# detect eligible planes +elig=[] +for k in np.nonzero((rec[:,0]==1)&(rec[:,5]==40))[0]: + a,b,f=int(rec[k,1]),int(rec[k,2]),int(rec[k,4]) + if dim[f]!=3 or a<2*v or b<2*v or a>=n or b>=n: continue + ca,cb=chain(a),chain(b) + if len(ca)<3 or len(cb)!=4: continue + if not (ca[0]==ZERO and dim[ca[1]]==2 and ca[2]==f): continue + if not (cb[0]==ZERO and dim[cb[1]]==2 and cb[2]==f and cb[3]==FULL): continue + if ca[1]==cb[1]: continue + xa=[int(rec[kk,2]) for kk in adds_dst[a] if int(rec[kk,4])==ca[1]] + xb=[int(rec[kk,2]) for kk in adds_dst[b] if int(rec[kk,4])==cb[1]] + if len(xa)!=2 or len(xb)!=2 or max(xa+xb)>=v: continue + # LO consumers: only BH at P (forward); BH must not be read before this merge + lo_src=[kk for kk in adds_src[b] if 0',len(out)) diff --git a/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp new file mode 100644 index 0000000000..07b7fd220c --- /dev/null +++ b/research/e8-retimed-component-verification/vendor/source377/work/native358/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp @@ -0,0 +1,42 @@ +#include "json.hpp" +#include +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=4*v+r,temp=global; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.srca((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +if(stage==1||stage==2||stage==4){int b=stage==1?0:stage==2?1:2;for(auto q:bridges[b])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<4;bank+=2)for(int i=0;i()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template