diff --git a/.gitattributes b/.gitattributes index 6825630198..976f1cccb1 100644 --- a/.gitattributes +++ b/.gitattributes @@ -18,3 +18,7 @@ research/coordinated-frames-and-entrance-banks/** -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 + +# Preserve every audited source and receipt byte in this frozen construction. +research/w3-staged354-signed20-native/** -text -whitespace +research/w3-staged354-signed20-native-audit/** -text -whitespace diff --git a/.github/workflows/w3-staged354-signed20-native.yml b/.github/workflows/w3-staged354-signed20-native.yml new file mode 100644 index 0000000000..d0e76d39d8 --- /dev/null +++ b/.github/workflows/w3-staged354-signed20-native.yml @@ -0,0 +1,34 @@ +name: Complete staged signed20 native admission +on: + pull_request: + paths: + - 'research/w3-staged354-signed20-native/**' + - 'research/w3-staged354-signed20-native-audit/**' + - '.github/workflows/w3-staged354-signed20-native.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + full-admission: + runs-on: ubuntu-latest + timeout-minutes: 60 + env: + PYTHONDONTWRITEBYTECODE: '1' + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: python -m pip install -r research/w3-staged354-signed20-native/requirements.txt + - run: sudo apt-get update && sudo apt-get install -y libboost-dev + - name: Replay every immutable stage + run: python -B research/w3-staged354-signed20-native/verify.py --output "$RUNNER_TEMP/w3-staged354-signed20-proof" + - name: Independent word, bank, minor and assembly audit + run: python -B research/w3-staged354-signed20-native-audit/verify.py --proof "$RUNNER_TEMP/w3-staged354-signed20-proof" --output "$RUNNER_TEMP/w3-staged354-signed20-audit" + - uses: actions/upload-artifact@v4 + if: always() + with: + name: w3-staged354-signed20-native-proof + path: | + ${{ runner.temp }}/w3-staged354-signed20-proof + ${{ runner.temp }}/w3-staged354-signed20-audit diff --git a/research/w3-staged354-signed20-native-audit/EXPECTED.json b/research/w3-staged354-signed20-native-audit/EXPECTED.json new file mode 100644 index 0000000000..f9875be2f2 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/EXPECTED.json @@ -0,0 +1,14 @@ +{ + "kappa": "401580942485227026650141/500000000000000000000000000", + "literal_expected": { + "banks_per_stage": 396780, + "literal_stock": 3135900, + "normalized_stock": 627180, + "paid_calls": 46004, + "paid_rank_mass": 169100, + "records": 406292, + "scalar_ADDs": 358152 + }, + "manifest_sha256": "338180183b553e635bf3c51cfb7c0d30cc2c144a2aa81777c21372bce8c45aa3", + "word_sha256": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330" +} diff --git a/research/w3-staged354-signed20-native-audit/LICENSE b/research/w3-staged354-signed20-native-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/w3-staged354-signed20-native-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/w3-staged354-signed20-native-audit/MANIFEST.json b/research/w3-staged354-signed20-native-audit/MANIFEST.json new file mode 100644 index 0000000000..99edb4fcc3 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/MANIFEST.json @@ -0,0 +1,50 @@ +{ + "files": { + "EXPECTED.json": "ae9d5eeb35cdbc472d6ba81cd839b617fc6d7acb9f3f05e401c4f23b045cfde9", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "README.md": "fb378be0a4f786af36fe32b2bd99672867f860ba3962eb5c3e7ddb38d02356ae", + "code/assembly.py": "63210aa022ae2a6a904fc63dbed286b9eaf8f9770774e26b782487899b15584a", + "code/audit.cpp": "a2d72e15d48edfc92d94f7a8c06fd792076a13182d81a5f7e22a1fa570f2305b", + "code/minors.py": "7a73232ee86655f1fc60e143382d41b96b59c25bb9673832e18b55aaa533c918", + "code/tiling.py": "74f38f8d172ec791ef53ed13de90737c7ca1767b233fae8cf4982b85a79e76d2", + "receipts/ASSEMBLY-AUDIT.json": "e28f5142589ca30c05b01c80e8db82f420fb50c97d3cbee75044442c7913db1d", + "receipts/BOUND-RESULT.json": "6a43d7a71ba6381bc5ed2a8d4b66b7ec017ccb5e8620625cafa1bfc35d643001", + "receipts/CP311-OBSERVED-EXIT.json": "5d50ad758b2eb20b59e64a25dd6dc4c9a5cb4f929d5939fd9705771aa59198d5", + "receipts/E8-INDEPENDENT-GUARD.json": "296463726d1931512242ff6a45cc15197649f1fa6b6dca55a4b2cba2fab87819", + "receipts/E8-JSON-ROUNDTRIP-CHECK.json": "f0090a8a60778879e3c16ffcd7266d09305861b6bae39005b4c190287c14044c", + "receipts/E8-PROVENANCE.json": "145fb6442098ee764d0a56fefe84a984f84e663d7a9e8662f0d97a7f72820796", + "receipts/E8-SERIALIZER-REVIEW.json": "beaf956b2e16ea8bd29423ecdd26ad680f8e42431a82c86487c6c0d1d604307b", + "receipts/E8-SUPPLIER-ADAPTER-CONTROLS.json": "e9f41106a63b49586e3bddc6d839531618be98a4f398821e47396ac730cd5f66", + "receipts/E8-SUPPLIER-CLOSEOUT.json": "efc97f263fffd9799cc657bbf07095d007386a7108b90af371f5b992eb5ff118", + "receipts/INTEGRATION-PRE-REPLAY-REVIEW.json": "c8a8e0ebece9c6684c207655fd9912c6643107e72feca07a946cd3ddec820fca", + "receipts/MINOR-AUDIT.json": "44e03eda6a4bcf2d4857b6e41c4d504616d1137ad47a79db4bed2928ea803a9b", + "receipts/OBSERVED-ROOT-EXITS.json": "a60a8fbf5d9095150a5471780a6ccef8aa5458b39fa49fba57cc92e1f12a39b3", + "receipts/RESULT.json": "a77ec8eb67b6859150b2acfd025c3095f95d53a67f1423a75aa27cbab278b255", + "receipts/ROOT-PRE-REPLAY-REVIEW.json": "839a4dda948f20e653292f96fa24715e24e20c34290d8868743c48249766c306", + "receipts/SOURCE354-REVIEW.json": "be4ba99b0207e9e6197d4f43051a7c06d7a7bde0f240e7471360f9f79fa3fed7", + "receipts/TWO-REPLAYS.json": "502bf1e7deef63e788a9b436c7cbc0435fb373a8d8293d7ee26c6ab46963812e", + "receipts/cp311-CERTIFICATE.json": "f151c2b92df91c332328cd1cb6347896de06744ab756d42e5c6d7535f13f377a", + "receipts/cp311-COMPACTION.json": "fff360d0744d1b0eca2f3860dba0d9de1e866d1d8dfb4d6af9b4472c5fb16c6e", + "receipts/cp311-INTEGER-AUDIT.json": "596bf57e28cdc355c4cfb6cb5be065bf40775d84a087f233a79f01c999e5e6de", + "receipts/cp311-ORIGINAL-EXPORT.json": "a756704d5f7793dcede058c2c9eb8c410d22d78e99bdabf4f212a89163fc5dd1", + "receipts/cp311-REFLECTED-LEDGERS.json": "d694caac30c90422a0276dcfacba15bab93b133de0818907c2874fa34ad5e83d", + "receipts/cp311-ROLE-MAP.json": "0331fe4c6ceee3a9e75d59be8d0f95aa24db344d72e5483b82a79be4030c3425", + "receipts/cp311-SOURCE-REGENERATION.json": "f83fdb683795f0105c1ae7963cc3b4cfca768e4e093416c96fa63e2c70bbf634", + "receipts/cp311-STAGED-REGENERATION.json": "caa70f31daf98a992439358172347f8507cc17f79a581c54f8b22eb7354e2ef6", + "receipts/cp311-VERIFICATION.json": "c370f4f78e4ee87c2cffe3e0c8a75e2d08c94700c4ba19bab32c31445acf4157", + "receipts/cp311-candidate-REGENERATION.json": "0932a720a9d47a9ce7fa28b418281b86d324079dae191da2e7f0070084db500b", + "receipts/cp311-candidate-signed18-REGENERATION.json": "a3425a828c36837ae295f9354db3b81762389b12ab161cdb1062c7fd573c29a6", + "receipts/cp312-CERTIFICATE.json": "3b7f8f1b0e8865ec9e6201a207900f50caddab5ebb12bfcaa4dee5888bbbf481", + "receipts/cp312-COMPACTION.json": "8e00896fbb87f26c68296151326707b935e33131b0a05e2a4048547fc78cfb9c", + "receipts/cp312-INTEGER-AUDIT.json": "66aa8de0e4d0f4375ea8b135da7c958394c5203ee341012d175cff9249df5403", + "receipts/cp312-ORIGINAL-EXPORT.json": "db108a077a70dce612d2dfec187815413e0bdce2d1970e137de2a8cffd5076e9", + "receipts/cp312-REFLECTED-LEDGERS.json": "d694caac30c90422a0276dcfacba15bab93b133de0818907c2874fa34ad5e83d", + "receipts/cp312-ROLE-MAP.json": "0331fe4c6ceee3a9e75d59be8d0f95aa24db344d72e5483b82a79be4030c3425", + "receipts/cp312-SOURCE-REGENERATION.json": "f83fdb683795f0105c1ae7963cc3b4cfca768e4e093416c96fa63e2c70bbf634", + "receipts/cp312-STAGED-REGENERATION.json": "caa70f31daf98a992439358172347f8507cc17f79a581c54f8b22eb7354e2ef6", + "receipts/cp312-VERIFICATION.json": "f4df0dafc98f696bca61cfaeb5425cf84d9fc54ce2bdf15b164d031fa30bbebb", + "receipts/cp312-candidate-REGENERATION.json": "0932a720a9d47a9ce7fa28b418281b86d324079dae191da2e7f0070084db500b", + "receipts/cp312-candidate-signed18-REGENERATION.json": "a3425a828c36837ae295f9354db3b81762389b12ab161cdb1062c7fd573c29a6", + "verify.py": "56098e67de063b4f88ba241641d50275bbbe9393505a25533b520109f7f47b1f" + } +} diff --git a/research/w3-staged354-signed20-native-audit/README.md b/research/w3-staged354-signed20-native-audit/README.md new file mode 100644 index 0000000000..08dedf980a --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/README.md @@ -0,0 +1,31 @@ +The signed20 construction passed two complete immutable 24-stage replays, +CPython 3.11 session 63544 and CPython 3.12 session 44877, both observed exit 0. +The mathematical certificates match, excluding only top-level receipt hashes. +The distinct five-stage audit exited 0 in session 15137. Its literal checker, +endpoint tiling, modular determinants with exact Hadamard lifting, and closed-form +bootstrap/outer-grid calculation use separate implementations. + + python3 -B verify.py --proof /tmp/w3-proof --output /tmp/w3-independent + +The construction defaults to sibling `w3-staged354-signed20-native`; use +`--package` to select another location. A C++17 compiler is required. The small +JSON header comes from the manifest-checked construction package. + +The separate construction audit compares the signed extension over the integers +on all 9,530 input columns and 9,531 output rows, including arbitrary dirt and +COPY/ERASE, and rejects six omission/sign controls. That comparison ignores MOVE +operators; mandatory native geometry checks MOVE semantics separately. The last +two pairs have earlier proper-frame reads, so no single-consumer template proof +is claimed for them. Both reflected ledgers and complete paid profiles are checked. +The distinct operator audit here is over F2, including restoration and an omission +control. Conditional compiler/chart/integer-recovery/analytic interfaces persist. + +The E8 supplier has a separately recomputed parity-correct dimension-45 invoice. +Lean-data regeneration binds source bytes; no local Lean kernel build or certificate +producer regeneration is claimed. Its complete scalar/frame/dirty/stock/moment +admission runs in each full construction replay. Earlier pre-replay review receipts +are historical snapshots; TWO-REPLAYS.json and observed exit receipts close their +replay obligations. All source and audit blobs must also pass the publication gate. +Absolute paths in receipts are evidence metadata, not required replay locations. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. Original credits and +licenses remain in the immutable construction and E8 receipts. diff --git a/research/w3-staged354-signed20-native-audit/code/assembly.py b/research/w3-staged354-signed20-native-audit/code/assembly.py new file mode 100644 index 0000000000..7e8b456798 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/code/assembly.py @@ -0,0 +1,52 @@ +"""Independent closed-form recurrence and strict rational outer-grid audit. +No imports from the construction's arithmetic implementation. +Prepared with OpenAI Codex assistance; Apache-2.0. +""" +import sys +sys.dont_write_bytecode=True +sys.set_int_max_str_digits(0) +import argparse,hashlib,json +from fractions import Fraction as F +from pathlib import Path +ap=argparse.ArgumentParser();ap.add_argument('proof',type=Path);ap.add_argument('output',type=Path);args=ap.parse_args() +raw=(args.proof/'REFINEMENT.json').read_bytes();r=json.loads(raw) +price=json.loads((args.proof/'PRICE.json').read_text()) +eta,beta=F(r['eta']),F(r['beta']);grid=r['grid'];s=F(r['ordinary_saving']['value']) +b=F(price['complex_saving']);assert b==F(r['complex_saving']) +limit=(1-beta)*b +strict_ticks=(limit.numerator*grid-1)//limit.denominator +strict_cap=F(strict_ticks,grid) +assert strict_cap==F(r['ordinary_saving']['strict_complex_cap']) +assert s==min(F(r['root']['lower']),strict_cap)0 and cut*delta**2>=36 and cut*delta>=2*(4+(C-1).bit_length()) + if levelcap +assert len(r['assembly']['strict_constraints'])==47 and all(F(v)>0 for v in r['assembly']['strict_constraints'].values()) +result=dict(status='PASS_INDEPENDENT_CLOSED_FORM_BOOTSTRAP_COMPLEX_CLIPPING_AND_OUTER_GRID',kappa=str(cap),complex_b=str(b),ordinary_saving=str(s),bootstrap_levels=levels,refinement_sha256=hashlib.sha256(raw).hexdigest(),scope='Independently recomputed all finite recurrence levels by closed form, their cutoffs, strict complex cap, seven outer margins and final grid; full structural and moment admission remain the complete verifier responsibility.') +assert not args.output.exists();args.output.write_text(json.dumps(result,indent=2)+'\n');print(result['status'],str(cap)) diff --git a/research/w3-staged354-signed20-native-audit/code/audit.cpp b/research/w3-staged354-signed20-native-audit/code/audit.cpp new file mode 100644 index 0000000000..098e2d9230 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/code/audit.cpp @@ -0,0 +1,23 @@ +// Independent literal audit adapted with OpenAI Codex assistance; Apache-2.0. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std;using J=nlohmann::json;using Row=vector;struct F{int d;vectorB,A;};struct E{int op,x,y,c,f,z;}; +void ck(bool b,string s){if(!b)throw runtime_error(s);}J rd(string p){ifstream in(p);J j;in>>j;return j;} +int main(int argc,char**argv){ck(argc==5,"arguments");string p=argv[1],out=argv[2],pkg=argv[3];J st=rd(p+"/249-states.json"),frames=rd(p+"/frames.json")["frames"],ini=rd(p+"/COHORT249-INITIAL.json"),fin=rd(p+"/COHORT249-FINAL.json"),tiling=rd(pkg+"/stages/bank-tiling.json");int n=st["n"],v=st["v"],h=rd(p+"/frames.json")["h"];int T=tiling.at("physical_replicas"),m=5*h;mapfs;for(auto it=frames.begin();it!=frames.end();++it){F f;f.d=it.value()["dim"];f.A=it.value()["A"].get>();f.B=it.value()["B"].get>();ck(f.A.size()+f.B.size()==h&&f.B.size()==f.d,"frame dimensions");for(auto rows:{f.A,f.B})for(auto row:rows){ck(row.size()==h,"row width");for(int x:row)ck(abs(x)<=7,"coefficient guard");}fs.emplace(stoi(it.key()),f);}ifstream raw(p+"/COHORT249-RECORDS.bin",ios::binary);raw.seekg(0,ios::end);auto bytes=raw.tellg();raw.seekg(0);ck(bytes%24==0,"record width");vectores(bytes/24);raw.read((char*)es.data(),bytes);ck(raw.good(),"read"); +mapinitial,final,state;for(auto it=ini.begin();it!=ini.end();++it)initial[stoi(it.key())]=it.value();for(auto it=fin.begin();it!=fin.end();++it)final[stoi(it.key())]=it.value();ck(initial.size()==n&&final.size()==n,"role census");state=initial; +set>pairs;auto subset=[&](int a,int b){if(a==b)return;pairpr{a,b};if(!pairs.insert(pr).second)return;F&A=fs.at(a),&B=fs.at(b);ck(A.d<=B.d,"nonnested dimension");for(auto x:A.B)for(auto y:B.A){int dot=0;for(int k=0;kpaid,required,reflected;vector>needs(n);mapcoeff;long long adds=0,moves=0,copies=0,erasures=0;int temp=-1;for(auto e:es){if(e.op==0){ck(state.at(e.x)==e.y,"MOVE predecessor");subset(e.y,e.c);ck(fs.at(e.c).d-fs.at(e.y).d==e.f,"MOVE gap");ck(fs.at(e.y).A.size()-fs.at(e.c).A.size()==e.f,"reflected MOVE gap");state[e.x]=e.c;if(e.f)paid[e.f]++;moves++;}else if(e.op==1){ck(e.x!=e.y&&(e.c%2)!=0,"scalar contract");ck(e.x=0)ck(e.x!=temp,"borrowed source mutated");ck(state.at(e.x)==e.f&&state.at(e.y)==e.f,"common frame");needs[e.x].push_back(e.f);if(e.y=0&&e.f==int(st["ZERO"]),"temp read");coeff[e.c]++;adds++;}else if(e.op==2){ck(temp==-1&&e.y==n&&state.at(e.x)==e.c&&e.f==int(st["ZERO"])&&e.z==h-2,"COPY contract");state[e.y]=e.f;needs[e.x].push_back(e.c);temp=e.x;copies++;paid[e.z]++;required[e.z]++;reflected[e.z]++;}else if(e.op==3){ck(temp==e.x&&e.y==n&&state.at(e.x)==e.c&&state.at(n)==e.f,"ERASE contract");state.erase(n);temp=-1;erasures++;}else throw runtime_error("opcode");}ck(temp==-1&&state==final,"actual endpoints"); +for(int r=0;rpath{initial.at(r)};path.insert(path.end(),needs[r].begin(),needs[r].end());path.push_back(final.at(r));for(int k=1;k0;k--){int a=path[k],b=path[k-1];subset(b,a);int d=int(fs.at(b).A.size())-int(fs.at(a).A.size());ck(d>=0,"reflected required gap");if(d)reflected[d]++;}}ck(required==paid&&reflected==paid,"independent required ledger census"); +int nw=(n+1+63)/64;auto replay=[&](bool rev,bool omit){vector>rows(n+1,vector(nw));for(int r=0;r<=n;r++)rows[r][r/64]|=1ull<<(r%64);int borrowed=-1;int restoreCat=atoi(argv[4]);for(int k=0;k=v&&r<2*v)rows[r][(r-v)/64]^=1ull<<((r-v)%64);bool wrong=any_of(rows[r].begin(),rows[r].end(),[](uint64_t x){return x;});bad+=wrong;}ck(borrowed==-1,"temp replay complete");if(omit)ck(bad>0,"restoration omission must fail");else ck(bad==0,"all-column endpoint");return bad;};int fw=replay(false,false),iv=replay(true,false),om=replay(false,true); +mapcensus;int deleted=0;long long rankMass=0;for(int r=2*v;rslots;int banks=0;for(auto pat:tiling["patterns"]){int count=pat["count"],width=0;for(int w:pat["widths"]){slots[w]+=count;width+=w;}ck(width==m,"bank width");banks+=count;}for(auto[r,c]:census)if(r)ck(slots[r]==1ll*T*c,"T_ADAPTED exact supply");ck(rankMass*T==1ll*m*banks,"bank conservation");long long stock=4ll*v*T+5ll*banks;mappaidCounts=paid;long long paidcalls=0,paidmass=0;for(auto[r,c]:paid){paidcalls+=c;paidmass+=r*c;}J result={{"status","PASS_INDEPENDENT_LITERAL_COMBINED_WORD_ENDPOINTS_REFLECTIONS_T_ADAPTED_CENSUS"},{"records",es.size()},{"scalar_ADDs",adds},{"signed_coefficients",coeff},{"moves",moves},{"copies",copies},{"erasures",erasures},{"paid_calls",paidcalls},{"paid_rank_mass",paidmass},{"paid_histogram",paid},{"required_histogram",required},{"reflected_histogram",reflected},{"unique_nonsame_frame_pairs",pairs.size()},{"forward_wrong_rows",fw},{"inverse_wrong_rows",iv},{"omission_wrong_rows",om},{"residual_census",censusJ},{"deleted_roles",deleted},{"endpoint_rank_mass_per_replica",rankMass},{"banks_per_stage",banks},{"literal_stock",stock},{"normalized_stock",stock/5},{"scope","Independent actual binary and endpoint ledger audit; finite prime chart and exact price checked in native pipeline."}};ofstream(out+"/RESULT.json")<0 and sum(widths)==100 + for w,n in Counter(widths).items():rem[w]-=count*n;assert rem[w]>=0,(w,rem[w]) + patterns.append(dict(count=count,widths=widths)) +# A mixed anchor makes this tiling intentionally different from the producer. +if rem[19]>=900 and rem[3]>=300 and rem[20]>=600:use([19,19,19,3,20,20],300) +for w in sorted(set(census)-{4,20},reverse=True): + if not rem[w]:continue + groups=[g for g in range(1,101//w+1)if 300%g==0 and g*w<=100 and (100-g*w)%4==0] + assert groups,(w,'no independent pattern') + g=max(groups);assert rem[w]%g==0 + left=100-g*w;twenties=left//20;fours=(left-20*twenties)//4 + use([w]*g+[20]*twenties+[4]*fours,rem[w]//g) +# Complete the remaining 20/4 inventory, including a non-pure bridge if needed. +r=rem[20]%5 +if r:use([20]*r+[4]*(25-5*r),1) +if rem[20]:use([20]*5,rem[20]//5) +assert rem[4]%25==0 +if rem[4]:use([4]*25,rem[4]//25) +assert all(n==0 for n in rem.values()) +assert 100*sum(p['count']for p in patterns)==300*sum(w*n for w,n in census.items()) +r=dict(census=dict(sorted(census.items())),physical_replicas=300,patterns=patterns,scope='Independent deterministic exact packing built only from actual endpoint ranks; optional mixed19/3 anchor and20/4 completion.') +a.output.parent.mkdir(parents=True,exist_ok=True);assert not a.output.exists();a.output.write_text(json.dumps(r,indent=2)+'\n');print('PASS independent generic endpoint tiling',sum(p['count']for p in patterns),dict(census)) diff --git a/research/w3-staged354-signed20-native-audit/receipts/ASSEMBLY-AUDIT.json b/research/w3-staged354-signed20-native-audit/receipts/ASSEMBLY-AUDIT.json new file mode 100644 index 0000000000..fbe474aae3 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/ASSEMBLY-AUDIT.json @@ -0,0 +1,9 @@ +{ + "status": "PASS_INDEPENDENT_CLOSED_FORM_BOOTSTRAP_COMPLEX_CLIPPING_AND_OUTER_GRID", + "kappa": "401580942485227026650141/500000000000000000000000000", + "complex_b": "876248285600677/1000000000000000000", + "ordinary_saving": "20095186812380416197599/25000000000000000000000000", + "bootstrap_levels": 8, + "refinement_sha256": "4e75c449bc9acde931fde4d4f89874586194d9393667e4618f6ea77a8f965347", + "scope": "Independently recomputed all finite recurrence levels by closed form, their cutoffs, strict complex cap, seven outer margins and final grid; full structural and moment admission remain the complete verifier responsibility." +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/BOUND-RESULT.json b/research/w3-staged354-signed20-native-audit/receipts/BOUND-RESULT.json new file mode 100644 index 0000000000..ef5d983bca --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/BOUND-RESULT.json @@ -0,0 +1,482 @@ +{ + "banks_per_stage": 396780, + "copies": 20, + "deleted_roles": 0, + "endpoint_rank_mass_per_replica": 132260, + "engine_hashes": { + "EXPECTED.json": "ae9d5eeb35cdbc472d6ba81cd839b617fc6d7acb9f3f05e401c4f23b045cfde9", + "code/assembly.py": "63210aa022ae2a6a904fc63dbed286b9eaf8f9770774e26b782487899b15584a", + "code/audit.cpp": "a2d72e15d48edfc92d94f7a8c06fd792076a13182d81a5f7e22a1fa570f2305b", + "code/minors.py": "7a73232ee86655f1fc60e143382d41b96b59c25bb9673832e18b55aaa533c918", + "code/tiling.py": "74f38f8d172ec791ef53ed13de90737c7ca1767b233fae8cf4982b85a79e76d2", + "verify.py": "56098e67de063b4f88ba241641d50275bbbe9393505a25533b520109f7f47b1f" + }, + "erasures": 20, + "forward_wrong_rows": 0, + "input_hashes": { + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/BANK.json": "d0479d17ca59bbfb8984ec70fb50c6e8c35f59f8079f4c663c1216221e392782", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/CERTIFICATE.json": "3b7f8f1b0e8865ec9e6201a207900f50caddab5ebb12bfcaa4dee5888bbbf481", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/COLUMNS.json": "d15d297e12daf470d510bb50ad61ae5daf8d380f851530a65079d50c35598b20", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/COMPACTION.json": "8e00896fbb87f26c68296151326707b935e33131b0a05e2a4048547fc78cfb9c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/DESIGN-SCALAR.json": "baf7a3a18846191e29bdb185026bfe0d2d92151a73a335d97ea6e506011992b4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/FRAME-PRIMES.json": "9ef4eaafb01429c432d418c6ee52e341fbb06fad8643851d701c5b76a4223306", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/INTEGER-AUDIT.json": "66aa8de0e4d0f4375ea8b135da7c958394c5203ee341012d175cff9249df5403", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/INVOICE.json": "3ca7e232576fcd68f22c86ecac533a05c92c7aae357bbf4c10e8cf882d0537c4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/LEGALITY.json": "ccf1c5417ac849af6dff76ebf0f1a851220cea60dcd5226ffe670cba91bb25c3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/ORIGINAL-EXPORT.json": "db108a077a70dce612d2dfec187815413e0bdce2d1970e137de2a8cffd5076e9", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/PARITY-CONTROL.json": "c5c813d216b21212d438dbda6923aaef85a1c5492462fffc65c62ba6ac42970d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/PRICE.json": "cacb5d16f68884e1c1377e6a1172c3c872f9d873b53d3f61014a0059dd2e1c54", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/REFINEMENT.json": "4e75c449bc9acde931fde4d4f89874586194d9393667e4618f6ea77a8f965347", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/REFLECTED-LEDGERS.json": "d694caac30c90422a0276dcfacba15bab93b133de0818907c2874fa34ad5e83d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/ROLE-MAP.json": "0331fe4c6ceee3a9e75d59be8d0f95aa24db344d72e5483b82a79be4030c3425", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/TILING.json": "daae46f48f4deef318dbfb140373a9504b0695588488a628834ffb9928ece89d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/VERIFICATION.json": "f4df0dafc98f696bca61cfaeb5425cf84d9fc54ce2bdf15b164d031fa30bbebb", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bank/BANK-CHARTS.json": "8af1fd1b54dcd46d9ded94c6c150a2eb128fddf71f65f1e4206b0e3b86128517", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bank/BANK-REVIEW.json": "d75e1eaa12a32093ecdbaf1c615c37b87ecb5d17406664757b7866bad24b6739", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/base/249-states.json": "78e775dbc25882c48aa4a092265e64848d982dba25db3beb1fe7658c9d51c1bd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/base/COHORT249-RECORDS.bin": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/base/frames.json": "d7cd8a574c44ebf5f0cfc2bb4ba6c91d8e33bf3ca246935cf3cc8c26a2a14a05", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bin/banks": "4059d4697cba5e8f2d12dbec0149326efd6e2284ce7fc36235216ed9a50891b0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bin/changed-charts": "6b988e4e537b5eb661ec32e05a53016fd5409d784cd77f46a3d079593c28a1a2", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bin/columns": "15f853935b7970d8fbbcd910ce4f56ac4aaf7c2138ec4bd065792460713237af", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bin/invoice": "d5e0da886f958da08bb6355309d6d3d23e42c261f9e83f8a61b9cea81eb12ae3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/bin/legality": "bb5b3afccb46d0204a2f4def8f5d78b149cbb71bcddd2eb46acb1219c27fa19c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-REGENERATION.json": "0932a720a9d47a9ce7fa28b418281b86d324079dae191da2e7f0070084db500b", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18-REGENERATION.json": "a3425a828c36837ae295f9354db3b81762389b12ab161cdb1062c7fd573c29a6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/249-states.json": "077a3e16a361fe1cd650d04535624fb306f7bc5dc5718ef30996b6459bc8b0a6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/COHORT249-INITIAL.json": "ce065ff1abc11517ee02eeda8e14aa22055df06eae5c431def7a245180c178be", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/COHORT249-RECORDS.bin": "8e9996b6819c1129b2507e3915842507d9dbe28077c7505bf57ebeaa6e53777e", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-signed18/frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/249-states.json": "79de66272d4092010cf7cd342fcb4b6c50268f92c3e3cb844194758f9fc433f9", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/COHORT249-FRAMES.json": "1550d26e4569e400817d1c1de4dc30fd0a6458bb8d41597c5f80a7aa7d1e9109", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/COHORT249-INITIAL.json": "3c90f37c23a092855baf4def0ca489c09b11ecbfed366888d096ea326badae14", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/COHORT249-RECORDS.bin": "2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate-source/frames.json": "583303099bceb6468167f71adf74fd86ee56b3646bd6af3700f160b2fdef9691", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/249-states.json": "7eb8e23b858a525754eea3075b3a149bf69a69bb6149872cbd872a2c2f3883f9", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/COHORT249-INITIAL.json": "1854658f58bc9de5642fbdf9538e93c35ce7a14cef6b04d02708feb25d343232", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/COHORT249-RECORDS.bin": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/candidate/frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/charts/COMBINED-CHART-AUDIT.json": "710ddc69f413c32e7952cd0439f0d70805c3f4af3c8e1bee42bc628542dc9545", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/charts/COMBINED-CHARTS.json": "4dcd25aa247dd59ae51b91629256abdf01fee01b31e65e2b2663123def316679", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/INDEPENDENT-REPLAY.json": "8b5540505a128bcc6af9bbb76615f48e4cfcee2083c4e310905c1d62a986a21d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/LEAN-DATA.json": "46cd7067860eabd9e8b6fa41f4397fea1566b14dc72afff456814f73fc0535aa", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/SUPPLIER-CHECK.json": "05ee9cbc0ea142995d87f0cff7a5ee923023e1178c6536d0b3b401fa05605b6e", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/VERIFICATION.json": "04290e911223dacf53a214d3c557f256528ce9bc8c1bf31a7e5ec46c3d6f47f0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/admission/INDEPENDENT-AUDIT.json": "35b15e4ac817b64b8d5e21c65afa525ccd74477c9d0ae3aef976504dbc095b3e", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/admission/UPSTREAM-GUARD.json": "91b9ab3387301eb79ba774fd15541e51fc08aa0e3d7abab599a69907aeab39e0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/candidate.json": "3594f19c4d01cf11fb930c5c61baeed399620acbc5b94096b16bcacb23997dd3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/ChallengeB2Ge8.lean": "7fa5c55f223f64e666059e30812e5f7cfd7eeb290563fc6f5a6504bae9a10f29", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/SolutionB2Ge8.lean": "c4454a61b7df233a60dcc884e9086fbdd11a734e55bee46569292468d4007573", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/cmp/B2Ge8.json": "6747a9b47a8e9f9edeacd792e68315f365394134bf243a95736c1713cbb55551", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/cmp/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/logs/gen-E8.json": "f088ab4186025fa71895c151220ea8fe404ce7c0e98763bd733ea7a86422da39", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/logs/rate-B2Ge8.json": "66048a1eefb4a571eb6d153c6cf3c3ab254f313f4e0ce92cf5aedb16b2c79d08", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/lean-data/logs/rate-B2Ge8x.json": "7fdf2a91f768184e545d6dc9b02442ca9ea24a52ab554445825e4317aee9c7fa", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/logs/complete-e8-scalar-splice-dirty-parity-guard.log": "ea59968fc1becce7944aa07c4bf857098ad890905a318fc48ffc8413570c7735", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/logs/complete-e8-two-moment-pricing.log": "f76572381ac979511392dcdd2d24461cffe3fb18cd49906c51246d3de9bdee6a", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/logs/e8-independent-replay.log": "7cfdeff7993cb845fb70ef13def3a2f2844259b2a80ebe0619ad2c7e4e49a0b8", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/complex-reserve/logs/e8-lean-data-regeneration.log": "47c17c17e1dd55d4f9a8d1f7a767b5fb4fb9af6de5f6da5d4b1298c7ef0c70f2", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T-control/249-records.bin": "91cd7052058f9aecae866b0a54df703f8cbc64f13f757be4cd2a3da9cafdb014", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T-control/249-states.json": "538ad90845a34140e6c1dc4214b070497cdfe7b92bc9442a6d165c1ad318db90", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T-control/frames.json": "09a613f5405d77afc339ce789c872177ed21dbff607108f8e7985c8f966db6c5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T/249-records.bin": "135bd091c12789f968a80e09fec682ea9728949e1960a93c3b599aaf94da1284", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T/249-states.json": "b5e6e618d196b196a3b25ef785c2dcfb7498da8842e10d32b41f19edd1f191dc", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/T/frames.json": "46a005bdaeb2076cdce3a1c92303deef9161b2bb8733e820be8959240a9af4ed", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT-control/249-records.bin": "c6a9311acfcf85f4a5775ed0187e31f84531614bb08434ef887ae1e63dda99c4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT-control/249-states.json": "25e4e0698ba42699d75fc257716415fc306344ca918c04d83d72931d730258cc", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT-control/frames.json": "f51c8597fe43fad6d4ce7431b61426279141211db09c302a449f26e004486ffd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT/249-records.bin": "f5fca11b5855a5a575a9408b1cde69d152d03432ce3e8e375d6b20b39baf3434", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT/249-states.json": "e84850741d2a379c3b4b721dac6844a72c98b616c74980257d693c0eb4f3a2a1", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/design/TT/frames.json": "2bcb4678e9891ab5583bce0e240ebd516a04ef6db23e3c1aa60c93ffd56d578c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/all-frame-prime-minors.log": "d782cc60b6a504da20be2b86c465c1834c930d344c0bc5f428d9e5d126b1de9e", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/bank-frames-and-assignment.log": "d75e1eaa12a32093ecdbaf1c615c37b87ecb5d17406664757b7866bad24b6739", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/base-export-0.log": "185e8c3bcf12bf4457ac0c3d2d0e39e111e49c0bb70988aff148aefb88c396cd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/base-export-1.log": "185e8c3bcf12bf4457ac0c3d2d0e39e111e49c0bb70988aff148aefb88c396cd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/both-reflected-ledgers.log": "133be287530fbf290603f603d17c3daf67b67d4c037d1c62e1a146defca8d418", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/changed-charts.log": "a2f5101a9eba2cf63417ee6c23a1a6634988402bf51e18ea3ef1acbc24e9b3bc", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/check-design-word.log": "2edf9b8315bebc75bac079711853104c623104d321e67396b734300d0147f7c1", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/columns.log": "368dbfc1b5136d678692f0ffcb441c2507ca9f1b76b61645be638884e530f2b8", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compact-dormant-helpers.log": "e91f4fc4776ef342c60f3b3a7bb804701d5f4518c6724acfeb203776e00d9193", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compile-banks.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compile-changed-charts.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compile-columns.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compile-invoice.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/compile-legality.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/complete-admission.log": "485369d1d30d129a41f08838a994fcd856dcf911827f88279a3f70301b426b79", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-T.log": "9d04253c6f90a5f4012e18d1d927f2d61300f040a542dc397c84fdb986d20902", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-completion.log": "64b2e9485b67884aa9d80dd891df78377fff7b1cd0e2f0a768e040e9bafff096", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-parity-control-T.log": "bc07c241fca24e453c05d59fa8dea919ba03df1c153f84a4e5e1ba6fcd3617c0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-parity-control-completion.log": "5e02eacb47e6f59eea5fdf44dcb3748b3e130c13889e3012dff2b8bdb877d3cd", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-parity-control-twin.log": "22da005e5ad6beb4c50a3a9470563d16b832927beef0258d110cea1bcaa0aa69", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/design-twin.log": "f5129c17f586c918059883cf99d0cf4cb4aa9a8b299736891fb91c69f98bc354", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/exact-integer-operator.log": "541c206fcdab06b693f86127b14bf31e0557b1320ae5e2cf3d841c978bbc997c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/export-native.log": "24991f5b1722921ebb1916fa1aeb3a05106b61013ed8394473a923db9cd54a38", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/finite-invoice.log": "4e9290bd79ee6d5d34019b3db5d4d0f3bd4d661c53d96db337f4e72d680dfd05", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/geometry-admission.log": "2f4ec9486b31c6817f4c73daf03172697c66db667cf2db8b08dfa725863b33dc", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/immutable-complex-reserve.log": "969f557bf9bbdbcec83b8a21eb5016524f911c3807d4f33939f6193b14132020", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/immutable-source325.log": "7e1af51f74b4a3e539fbc5f4f85c0819d84e0881cd07d296c9ea3201bacc4901", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/legality.log": "77e54572e511c6535113ee4628c05f8622aec3680e0f82c9a64a1796a463e9d6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/price.log": "4d2d493fd3d0202631679663476bfeb27bf705edd950759b6edeebb605365f9b", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/prime-threshold-bootstrap.log": "0ed8ca5cd55389a607b591c92f44fe309647238fb9d2738d3a97afbe0b710d19", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/regenerate-design-and-compact.log": "c2e31d4c281deeab8f497825f6a0dba946c0eab3c0144c0d06afdf385d530a68", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/regenerate-four-stages.log": "a1eee75ee03ccccd4e390a29abf4f339c718185441d2a3a79d9ec18af7bdd012", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/regenerate-signed-eighteen.log": "510e62a84e9a60a60dd945f76bd7721d94e2246ad6df1e69fded339d87d04569", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/regenerate-two-further-twins.log": "fb45431a3ffdbdc05f1859d9512965415e5655ba2567cccc2488c2510e38fa3c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/logs/tiling.log": "7da3bcbd080a41dd9a6b432237f34902c9e73a0739bcc18318c5b1710333b2a7", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/COMPACTION.json": "8e00896fbb87f26c68296151326707b935e33131b0a05e2a4048547fc78cfb9c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/final.json": "39e4fa8177180693b6617c6168942d73d70d050491901c36295c5a7ef4b91225", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/frames.json": "09a613f5405d77afc339ce789c872177ed21dbff607108f8e7985c8f966db6c5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/initial.json": "bc6386298895801ac5a59d50ae5b23e30fa777b89d1f647f362c3dfbec762f98", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/meta.json": "5e7c1a58f707309aabd1493633c7fcdf561121539e31e51b6d9b88c2ca1f8ae4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/records.bin": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/base/regs.json": "95d8b36f0728e0c7797bb5f2aa14c8596356dd008ee3ff65084bda207fbe10b9", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/final.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/frames.json": "2bcb4678e9891ab5583bce0e240ebd516a04ef6db23e3c1aa60c93ffd56d578c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/initial.json": "3c90f37c23a092855baf4def0ca489c09b11ecbfed366888d096ea326badae14", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/meta.json": "935e7a2da4dc80060def6cb6aa0976f05ee803c5ebb7941032e92412edcc7e71", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/records.bin": "2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/materialized/final/regs.json": "12d1d9d5014a318289d43d8958c61cc9e8e1c07795aa29627aa8d1a5195edb43", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/banks.json": "36274735f06e356294abebef8589f1fb4dbb7e40ecc25c375f846345d2550ba4", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/bit.json": "043a90db8fc3984d506cfebcce245f687622675b3841d114daa65a2ee1b0e1ce", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/certificate.json": "6a9638af48f344aa94e2c3401cf3fc1d08eda5cb7fcc5283d7e42ea79f95b50c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/complex.json": "02437daaa65c6f13b72ed87a23957317773bac95e8e864caa23634106f6a73df", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/finite.json": "6e9c5028ce78fa4c2d558abe2e61a7d4c5563a75e3cbbed19aa35b9e6be29d3d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/geometry.json": "134f526984b1ccbbb36ac70eda4633a028e60df6a8ec4ed0573b28d7678998af", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/global_result.json": "c61aab7216bd4aabe4a7a7129d212a4de257b75e8fbdd67061fb80295f6649b9", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/math.json": "0f0d82fefac3a9b28e30810d5942570a3b8bedd3418345af4b76538614e1e5a5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/parity.json": "126f2c713a0786c24c15763f0e5add7faeda422fa43557a7c858c799ea813b97", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/physical.json": "ed716268da435d54d7cc4917a32bd0af33be8207b2674bb64306101cf3d291e0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/primes.json": "d64b445e2979df6bb6c54172250ca415c3af6d3a75925e4f73d0d64af1d76aae", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/producer-bit/generated-physical-word.py": "2831337c17e44188841cbaa335ce055eb917808e21f728d2194667befe37a636", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/producer-bit/physical.json": "85f22f5ca88ad02e5fe6e54221b068ceff865bfd0ec589bc05bce9d70b2e5257", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/producer-bit/records.bin.gz": "84a5944ce14eb8638bb6731efe95a0fc10fa68f589bb75e3c48ed119b25d8959", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/raw.json": "bd2cbcd93d150b741049c45944bcfcbfce5d75f45046efa8dd4ddeacd17a4c86", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/records.bin.gz": "fb038955261551815771eaf6d77f4739302152e7b257cdf117f4b4116f801d15", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/scalar.json": "2f4f577e56ab57f22e97caaa859786dc8953597709354222d036d5543d1ccd0a", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/verification.json": "1610b90164b88bed531daba7921ccc835560df52871fb77e8e41e29e2cb00232", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual-bit/frames_p10.json": "16eda0a6e7ca8a7be2c05f83be3f53d8086bbb67225bb5c8c36aa002c7b7c5ff", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual-bit/graph_p10.json": "4a43116c8d154e61be795ca76b3a550c9f5bb579a5fe3fb88a09279512aab174", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual-bit/kchron_p10.json": "1ce62b85b496cbec17fe9eb9e81152126cb90708577cc2e3bcece9b2796ef31c", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual-bit/profile_p10.json": "177ff70a322f152ccc6c12471aced7a207062e445f9f64c7d3bd96e6f18c6f63", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual-bit/word_p10.json": "0b476129d89a02ae1ffecd94438b5075b50a9f12dcba32b754fcadc1d719e0e5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/predecessor/virtual.json": "63a8740b7857262f4e3409888cc12c4809ac0dc3ef895c1ffa29d584ad8f84f0", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/REGENERATION.json": "f83fdb683795f0105c1ae7963cc3b4cfca768e4e093416c96fa63e2c70bbf634", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round0/249-records.bin": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round0/249-states.json": "a3ce88f95080d3c9d73138c3e1edf15ab361ab8a2ff0d1dee61cb3975eab4d25", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round0/frames.json": "09a613f5405d77afc339ce789c872177ed21dbff607108f8e7985c8f966db6c5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round0/run-meta.pkl": "13adf80e08caa36549998881f9e33ef744bc1e49aa30346b2db1d8ef5a745b40", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round1/249-records.bin": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round1/249-states.json": "a3ce88f95080d3c9d73138c3e1edf15ab361ab8a2ff0d1dee61cb3975eab4d25", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round1/frames.json": "09a613f5405d77afc339ce789c872177ed21dbff607108f8e7985c8f966db6c5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/source-regeneration/round1/run-meta.pkl": "13adf80e08caa36549998881f9e33ef744bc1e49aa30346b2db1d8ef5a745b40", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/00-parity/249-records.bin": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/00-parity/249-states.json": "a3ce88f95080d3c9d73138c3e1edf15ab361ab8a2ff0d1dee61cb3975eab4d25", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/00-parity/frames.json": "09a613f5405d77afc339ce789c872177ed21dbff607108f8e7985c8f966db6c5", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/00-parity/meta.pkl": "ed8704d46cba8940145eb8b21f628875782939e3a8e9e0ed98fc0ebb01b37e20", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/01-descent/249-records.bin": "04e8e96b70aa156a66fc6cfbbbe031c8d1bb54527568b095a305f6b2c587f5ae", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/01-descent/249-states.json": "c2906e28c02dde56925c603314208167b255b715eee66a8c87366d05e55e8a71", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/01-descent/frames.json": "1a52ddb4942358222fb51e358d9260232c340e1df87cb6c26aa94f106d0aacd2", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/01-descent/meta.pkl": "d9d5f3af4aa9d635b534cfcd2d01a03ad7c17a9b279dc46fd6264d60d7962403", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/02-target/249-records.bin": "d857cdd26e0e5e85c975e65964d9c214b905ee53806febf588b7c0014a7aa110", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/02-target/249-states.json": "c1993ac2945179972f9f01a391277dc0bd18c41779244dafa8c660f004b6676d", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/02-target/frames.json": "de9cf49d4cc9bc197bbf7b2668c53bdf827bc221cee8daf58cafba66ff060f21", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/02-target/meta.pkl": "7fb7e846346b17859c2b99423df728367eb420e6efc12ee84a63a7dcd4792234", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/03-restore/249-records.bin": "95ecbf5d6f82508e80fc51914174195dc99f21fce212305bf1962b2c609d85ba", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/03-restore/249-states.json": "c9edce65c1a879a65704906e64d3e0a895deb05e2abe93290db88446ac846f05", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/03-restore/frames.json": "46a005bdaeb2076cdce3a1c92303deef9161b2bb8733e820be8959240a9af4ed", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/03-restore/meta.pkl": "cbe6a6e71691038168847bd850fe0b00112a880d8b61173e1c11b1098cfd07d3", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/04-sink/249-records.bin": "ec06e4aa11d2bccb8e7f5515b8e88d2bca334db82b53cf4bb91a60b58c6eb410", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/04-sink/249-states.json": "3a179a2985cb0c58e7bebd6cfc02d22a9823d9086ecd3ef2320f21cd77f28397", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/04-sink/frames.json": "46a005bdaeb2076cdce3a1c92303deef9161b2bb8733e820be8959240a9af4ed", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/04-sink/meta.pkl": "fa72ca0b0cbebca753627bb0129866c3d8467aca36b93e9d0899e515c0742607", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/REGENERATION.json": "caa70f31daf98a992439358172347f8507cc17f79a581c54f8b22eb7354e2ef6", + "/private/tmp/w3-staged354-e8-signed20-cp312-proof/staged-regeneration/SOURCE-ROLE-MAP.json": "8261a031f5675db56ce7c9b85c5d40f5ecf81dee957ab4768d4385a0a88bddcc" + }, + "inputs_unchanged": true, + "inverse_wrong_rows": 0, + "kappa": "401580942485227026650141/500000000000000000000000000", + "literal_stock": 3135900, + "manifest_sha256": "338180183b553e635bf3c51cfb7c0d30cc2c144a2aa81777c21372bce8c45aa3", + "moves": 48100, + "normalized_stock": 627180, + "omission_wrong_rows": 480, + "paid_calls": 46004, + "paid_histogram": [ + [ + 1, + 21540 + ], + [ + 2, + 8229 + ], + [ + 3, + 6015 + ], + [ + 4, + 1359 + ], + [ + 5, + 1092 + ], + [ + 6, + 1006 + ], + [ + 7, + 640 + ], + [ + 8, + 164 + ], + [ + 9, + 293 + ], + [ + 10, + 248 + ], + [ + 11, + 80 + ], + [ + 12, + 1006 + ], + [ + 13, + 2 + ], + [ + 14, + 344 + ], + [ + 16, + 840 + ], + [ + 17, + 2646 + ], + [ + 18, + 500 + ] + ], + "paid_rank_mass": 169100, + "receipt_hashes": { + "ASSEMBLY-AUDIT.json": "e28f5142589ca30c05b01c80e8db82f420fb50c97d3cbee75044442c7913db1d", + "MINOR-AUDIT.json": "44e03eda6a4bcf2d4857b6e41c4d504616d1137ad47a79db4bed2928ea803a9b", + "RESULT.json": "a77ec8eb67b6859150b2acfd025c3095f95d53a67f1423a75aa27cbab278b255", + "stages/bank-tiling.json": "4a8b9f7bf2d41bb987cb89be00b073a8055811058948ba73b8dec05b84182e53" + }, + "records": 406292, + "reflected_histogram": [ + [ + 1, + 21540 + ], + [ + 2, + 8229 + ], + [ + 3, + 6015 + ], + [ + 4, + 1359 + ], + [ + 5, + 1092 + ], + [ + 6, + 1006 + ], + [ + 7, + 640 + ], + [ + 8, + 164 + ], + [ + 9, + 293 + ], + [ + 10, + 248 + ], + [ + 11, + 80 + ], + [ + 12, + 1006 + ], + [ + 13, + 2 + ], + [ + 14, + 344 + ], + [ + 16, + 840 + ], + [ + 17, + 2646 + ], + [ + 18, + 500 + ] + ], + "required_histogram": [ + [ + 1, + 21540 + ], + [ + 2, + 8229 + ], + [ + 3, + 6015 + ], + [ + 4, + 1359 + ], + [ + 5, + 1092 + ], + [ + 6, + 1006 + ], + [ + 7, + 640 + ], + [ + 8, + 164 + ], + [ + 9, + 293 + ], + [ + 10, + 248 + ], + [ + 11, + 80 + ], + [ + 12, + 1006 + ], + [ + 13, + 2 + ], + [ + 14, + 344 + ], + [ + 16, + 840 + ], + [ + 17, + 2646 + ], + [ + 18, + 500 + ] + ], + "residual_census": { + "19": 500, + "20": 5910, + "3": 240, + "4": 960 + }, + "scalar_ADDs": 358152, + "scope": "Independent actual binary and endpoint ledger audit; finite prime chart and exact price checked in native pipeline.", + "signed_coefficients": [ + [ + -1, + 326702 + ], + [ + 1, + 31450 + ] + ], + "stages": [ + "independent-tiling", + "compile-distinct-audit", + "literal-word", + "modular-minors", + "closed-form-assembly" + ], + "status": "PASS_INDEPENDENT_LITERAL_COMBINED_WORD_ENDPOINTS_REFLECTIONS_T_ADAPTED_CENSUS", + "unique_nonsame_frame_pairs": 42921, + "word_sha256": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/CP311-OBSERVED-EXIT.json b/research/w3-staged354-signed20-native-audit/receipts/CP311-OBSERVED-EXIT.json new file mode 100644 index 0000000000..c678648867 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/CP311-OBSERVED-EXIT.json @@ -0,0 +1,19 @@ +{ + "actual_exit_code": 0, + "all_certificate_receipts_checked": true, + "certificate_sha256": "f151c2b92df91c332328cd1cb6347896de06744ab756d42e5c6d7535f13f377a", + "completion_chunk": "51f731", + "integer_audit_sha256": "596bf57e28cdc355c4cfb6cb5be065bf40775d84a087f233a79f01c999e5e6de", + "kappa": "401580942485227026650141/500000000000000000000000000", + "manifest_sha256": "338180183b553e635bf3c51cfb7c0d30cc2c144a2aa81777c21372bce8c45aa3", + "package": "/private/tmp/w3-staged354-e8-signed20-native-work", + "proof": "/private/tmp/w3-staged354-e8-signed20-cp311-proof", + "python": "3.11.5 (main, May 29 2026, 21:26:09) [Clang 17.0.0 (clang-1700.3.19.1)]", + "seconds": 281.5459399999818, + "session": 63544, + "stages": 24, + "status": "OBSERVED_ACTUAL_PROCESS_EXIT0_COMPLETE_SIGNED20_WRAPPER", + "utc": "2026-10-11T01:54:47.727573+00:00", + "verification_sha256": "c370f4f78e4ee87c2cffe3e0c8a75e2d08c94700c4ba19bab32c31445acf4157", + "word_sha256": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-INDEPENDENT-GUARD.json b/research/w3-staged354-signed20-native-audit/receipts/E8-INDEPENDENT-GUARD.json new file mode 100644 index 0000000000..cb6e6792c2 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-INDEPENDENT-GUARD.json @@ -0,0 +1,21 @@ +{ + "all_complete_invoice_fields_equal": true, + "guard_receipt_sha256": "28445ec16605e19c7d40fe5c976ad84f9ed1592b025cb156cf8041936adf841b", + "independent_audit_sha256": "09e0c2275212e9df991d72174ed5b9ffb082b3b948909c3223a8ae4e9177fa13", + "induction_gap_multiple_B": 49, + "live_per_vertex": 1263, + "m": 45, + "old_undercount_ratio": "(2^44-1)/2", + "order_derivation": "Sp(2r,2) multiplicative recurrence order(r)=2^(2r-1)*(2^(2r)-1)*order(r-1); odd nonalternating45dim orthogonal group fixes allones and restricts to Sp44.", + "physical_per_vertex": 2056, + "physical_row": 11162, + "retained_row": 20161, + "scope": "Independent exact arithmetic recomputation of full finite guard from pinned scalar/frame ledger values; structural scalar/frame admission remains carrier audit.", + "source_manifest_sha256": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "status": "PASS_INDEPENDENT_E8_PARITY_CORRECT_COMPLETE_INVOICE_RECOMPUTATION", + "stock_bits": [ + 990, + 1000, + 1001 + ] +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-JSON-ROUNDTRIP-CHECK.json b/research/w3-staged354-signed20-native-audit/receipts/E8-JSON-ROUNDTRIP-CHECK.json new file mode 100644 index 0000000000..69e274fee1 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-JSON-ROUNDTRIP-CHECK.json @@ -0,0 +1,41 @@ +{ + "changes": [ + { + "bits": 32002, + "path": "/complex_supplier/finite_guard/complete_invoice/literal" + }, + { + "bits": 1000, + "path": "/complex_supplier/finite_guard/complete_invoice/live_stock" + }, + { + "bits": 1032, + "path": "/complex_supplier/finite_guard/complete_invoice/logical_groups" + }, + { + "bits": 990, + "path": "/complex_supplier/finite_guard/complete_invoice/orthogonal_group" + }, + { + "bits": 1001, + "path": "/complex_supplier/finite_guard/complete_invoice/physical_stock" + }, + { + "bits": 1006, + "path": "/complex_supplier/finite_guard/complete_invoice/rank_mass" + }, + { + "bits": 3055, + "path": "/complex_supplier/finite_guard/complete_invoice/router" + } + ], + "cpp_parser_exit": 0, + "implementation_sha256": "15432d42b411ad2f18f2becc6ff93ca04397d1df4a758baa033816e691bbd405", + "native_invoice_exit": 0, + "native_invoice_stdout": "PASS stock 3142800 K 1808510397000 coefficientbits 57 payloadbits 88\n", + "new_price_sha256": "844ff8e217b9647d591db1ba161e734a118cb2891e040684f6dedb544c34d3b5", + "old_price_sha256": "285438d7c91a13984b6fd36f4297bcd152e63fefb87ac37e2b76db392b64fb19", + "scope": "Serialization-only preflight; two fresh full immutable v3 replays remain mandatory.", + "status": "PASS_EXACT_BIG_INTEGER_JSON_ROUNDTRIP_AND_NATIVE_INVOICE", + "v3_manifest": "32e5f821e802313565695274447fd89a841c2c52fff6aff0faf9dd5d72410842" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-PROVENANCE.json b/research/w3-staged354-signed20-native-audit/receipts/E8-PROVENANCE.json new file mode 100644 index 0000000000..189b31abc9 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-PROVENANCE.json @@ -0,0 +1,612 @@ +{ + "all_vendored_pin_sha256_checked": 80, + "certificate": { + "git_blob": "0bd0bacf744f1c31419e05b834e34a92be77ae57", + "gzip_sha256": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "raw_sha256": "3594f19c4d01cf11fb930c5c61baeed399620acbc5b94096b16bcacb23997dd3" + }, + "claim_boundaries": [ + "The challenge module intentionally contains sorry to state the target; the solution module closes it through B2Ge8Main. Do not treat the challenge sorry as a solution proof hole.", + "Upstream WHT theorem saving is8762479/10^10; upstream Fourier saving is8762478/10^10. Neither equals newly priced full-fallback b876248285600677/10^18.", + "The newly priced b uses exact rational moment engines and a10^-16 bad-class fallback; it is not a new Lean theorem at that exponent.", + "Byte regeneration certifies data provenance, not proof execution. The integration remains a conditional finite construction.", + "Upstream whole-block WHT/Fourier claims do not formalize the bit side, integer multiplication, analytic routing interfaces, or the new corrected physical guard.", + "Lean does not read the total-frame field according to upstream mutation evidence; Python frame/scalar/lifetime/physical checks remain mandatory." + ], + "comparator_configuration": { + "challenge_module": "Work.GCert.Data.ChallengeB2Ge8x", + "definition_names": [], + "enable_nanoda": false, + "permitted_axioms": [ + "propext", + "Quot.sound", + "Classical.choice" + ], + "solution_module": "Work.GCert.Data.SolutionB2Ge8x", + "theorem_names": [ + "OAI.PowerSaving.WHT.wht_main_block_B2Ge8x" + ] + }, + "current_upstream_blobs_checked": [ + { + "bytes": 11357, + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "inputs/e8/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "upstream": "LICENSE" + }, + { + "bytes": 28678, + "git_blob": "7008ce01c1f84c4ac181dd9382a94c83a1a172aa", + "path": "inputs/e8/NOTICE", + "sha256": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "upstream": "NOTICE" + }, + { + "bytes": 325, + "git_blob": "7fda546848f67f704e3f900c2c2f82d44f48deee", + "path": "inputs/e8/comparator/B2Ge8x.json", + "sha256": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "upstream": "comparator/B2Ge8x.json" + }, + { + "bytes": 7390, + "git_blob": "a6287172bab665b9e5f125256dd535590c2be5f4", + "path": "inputs/e8/tools/gen/foldgen.py", + "sha256": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "upstream": "tools/gen/foldgen.py" + }, + { + "bytes": 5914, + "git_blob": "2cd642ec9e3d5b4b31ccaeec8eaafad5dab7790d", + "path": "inputs/e8/tools/gen/foldlib.py", + "sha256": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "upstream": "tools/gen/foldlib.py" + }, + { + "bytes": 1071, + "git_blob": "8f90a197ba4642c36f82e804be5fd23e3c688b19", + "path": "inputs/e8/tools/gen/gen_rates.py", + "sha256": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "upstream": "tools/gen/gen_rates.py" + }, + { + "bytes": 1098, + "git_blob": "e28409ef864a8d6970d0a45457f67b08c1f0e380", + "path": "inputs/e8/tools/gen/gen_sharp.py", + "sha256": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "upstream": "tools/gen/gen_sharp.py" + }, + { + "bytes": 13287, + "git_blob": "5863ad32a049b0e1f3ebe48a6bcb4b67f1009fb4", + "path": "inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt", + "sha256": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "upstream": "tools/gen/templates/ChallengeB2L16x.lean.txt" + }, + { + "bytes": 1470, + "git_blob": "c111b98f65c32c1c29fe625880b4e836636d119b", + "path": "inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt", + "sha256": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "upstream": "tools/gen/templates/SolutionB2L16x.lean.txt" + }, + { + "bytes": 13874, + "git_blob": "35af7ef46bd21341813b0e483b268fea60556896", + "path": "inputs/e8/tools/gx/gsmirror.py", + "sha256": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "upstream": "tools/gx/gsmirror.py" + }, + { + "bytes": 24311, + "git_blob": "fcb625619cb07a9be9594422357786ca6e3c4add", + "path": "inputs/e8/tools/gx/gxbind.py", + "sha256": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "upstream": "tools/gx/gxbind.py" + }, + { + "bytes": 15129, + "git_blob": "3e3f0a3076f3c326e7833c74eceecb3436dd3185", + "path": "inputs/e8/tools/gx/gxcore.py", + "sha256": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "upstream": "tools/gx/gxcore.py" + }, + { + "bytes": 11479, + "git_blob": "12d847f09db92df2c68d10faf8c7403322110ef7", + "path": "inputs/e8/tools/gx/gxgen.py", + "sha256": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "upstream": "tools/gx/gxgen.py" + }, + { + "bytes": 1078, + "git_blob": "355613a9c9641b4ec7754cd2503684bf60ac9aaf", + "path": "inputs/e8/tools/gx/gxpaths.py", + "sha256": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "upstream": "tools/gx/gxpaths.py" + }, + { + "bytes": 9979, + "git_blob": "6a58830d4c5eb950b5f73567374ec786a4ae4982", + "path": "inputs/e8/tools/gx/gxrate.py", + "sha256": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "upstream": "tools/gx/gxrate.py" + }, + { + "bytes": 2260, + "git_blob": "2c4587038c5f33358600b9feca285487e8453cfb", + "path": "inputs/e8/tools/gx/gxunit.py", + "sha256": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "upstream": "tools/gx/gxunit.py" + }, + { + "bytes": 3603, + "git_blob": "720c4c06afb82330a4f23f1c3f7d3d529038b876", + "path": "inputs/e8/tools/gx/regen_check.py", + "sha256": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "upstream": "tools/gx/regen_check.py" + }, + { + "bytes": 2113, + "git_blob": "c4db78c06fa6a5f21f7323edf8bf3d13ab07a931", + "path": "inputs/e8/tools/gx/regen_check_e8.py", + "sha256": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf", + "upstream": "tools/gx/regen_check_e8.py" + }, + { + "bytes": 7367, + "git_blob": "d1e3afba66b01bdc95d55d805ae63efa653031ff", + "path": "inputs/e8/Work/GCert/Data/B2Ge8.lean", + "sha256": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "upstream": "Work/GCert/Data/B2Ge8.lean" + }, + { + "bytes": 1512, + "git_blob": "ef1487658291016d68e78b865f9239d100c69e1c", + "path": "inputs/e8/Work/GCert/Data/B2Ge8Main.lean", + "sha256": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "upstream": "Work/GCert/Data/B2Ge8Main.lean" + }, + { + "bytes": 13287, + "git_blob": "c6c1567f5dfe456c5ffe4aad42598363df0a747a", + "path": "inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean", + "sha256": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "upstream": "Work/GCert/Data/ChallengeB2Ge8x.lean" + }, + { + "bytes": 4535, + "git_blob": "ab43d9bf07756e60715ffad5e1f644cc2a1e6978", + "path": "inputs/e8/Work/GCert/Data/E8Cert.lean", + "sha256": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "upstream": "Work/GCert/Data/E8Cert.lean" + }, + { + "bytes": 2863, + "git_blob": "71b561645b714e82324a649d540e0628bc7c8c66", + "path": "inputs/e8/Work/GCert/Data/E8Price.lean", + "sha256": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "upstream": "Work/GCert/Data/E8Price.lean" + }, + { + "bytes": 691, + "git_blob": "0657e91b9975ca1dfa8da21ddd37e81e8a58adb6", + "path": "inputs/e8/Work/GCert/Data/E8ScalOK.lean", + "sha256": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "upstream": "Work/GCert/Data/E8ScalOK.lean" + }, + { + "bytes": 2278, + "git_blob": "be583c65d3a375aea13449a3b52fc07be39a60ea", + "path": "inputs/e8/Work/GCert/Data/InstB2Ge8.lean", + "sha256": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "upstream": "Work/GCert/Data/InstB2Ge8.lean" + }, + { + "bytes": 15089, + "git_blob": "46c0ed04cdadb5a3bf15920e51dc537fdfa43eb2", + "path": "inputs/e8/Work/GCert/Data/RateB2Ge8.lean", + "sha256": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "upstream": "Work/GCert/Data/RateB2Ge8.lean" + }, + { + "bytes": 15522, + "git_blob": "10c148fd72833f12e94e5a1770e13d60eaa6f8dc", + "path": "inputs/e8/Work/GCert/Data/RateB2Ge8x.lean", + "sha256": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "upstream": "Work/GCert/Data/RateB2Ge8x.lean" + }, + { + "bytes": 1476, + "git_blob": "bfa1d0308824cb8c4261a78b5eb7a297fce2ab4c", + "path": "inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean", + "sha256": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "upstream": "Work/GCert/Data/SolutionB2Ge8x.lean" + }, + { + "bytes": 599, + "git_blob": "c8165c355b811de25107973fe7e22e2ea036bf51", + "path": "inputs/e8/Work/GCert/Data/Gen/E8.lean", + "sha256": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "upstream": "Work/GCert/Data/Gen/E8.lean" + }, + { + "bytes": 476, + "git_blob": "dfec705e0e8de5098b1359e4deaa07d14fa595e3", + "path": "inputs/e8/Work/GCert/Data/Gen/E8End.lean", + "sha256": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "upstream": "Work/GCert/Data/Gen/E8End.lean" + }, + { + "bytes": 2974, + "git_blob": "4c0a89ebc5b5ae8c23d94a576d8752056179b99a", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Hist.lean", + "sha256": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "upstream": "Work/GCert/Data/Gen/E8Hist.lean" + }, + { + "bytes": 329, + "git_blob": "9ace01b6f3ea6f04174a4d15ba700544b057df8a", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Par.lean", + "sha256": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "upstream": "Work/GCert/Data/Gen/E8Par.lean" + }, + { + "bytes": 451, + "git_blob": "219dd4f6dba8e79a8b041acc999938253d1a12f6", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean", + "sha256": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "upstream": "Work/GCert/Data/Gen/E8Scal0.lean" + }, + { + "bytes": 428, + "git_blob": "b69b6fdff45e26b5eae1b394c8556b13c1f4aa40", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean", + "sha256": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "upstream": "Work/GCert/Data/Gen/E8Seg0.lean" + }, + { + "bytes": 431, + "git_blob": "a05e925bdef191129c376518b18d0061f52fc9a4", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean", + "sha256": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "upstream": "Work/GCert/Data/Gen/E8Seg1.lean" + }, + { + "bytes": 405, + "git_blob": "72addebadbfea53898f7664f923f4f6f80b58c6c", + "path": "inputs/e8/Work/GCert/Data/Gen/E8SegF.lean", + "sha256": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "upstream": "Work/GCert/Data/Gen/E8SegF.lean" + }, + { + "bytes": 449, + "git_blob": "8995e049e05267f04b48eb4e9232bb8b056c4fec", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean", + "sha256": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "upstream": "Work/GCert/Data/Gen/E8Tab0.lean" + }, + { + "bytes": 449, + "git_blob": "38ccb738cedf7e10794161a90313cea62a3f6360", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean", + "sha256": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "upstream": "Work/GCert/Data/Gen/E8Tab1.lean" + }, + { + "bytes": 449, + "git_blob": "bc10a63187ba520d96e2d8bba3349afe334a7233", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean", + "sha256": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "upstream": "Work/GCert/Data/Gen/E8Tab2.lean" + }, + { + "bytes": 449, + "git_blob": "07453a6580dcfb848970fce591c1a7e64867f860", + "path": "inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean", + "sha256": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "upstream": "Work/GCert/Data/Gen/E8Tab3.lean" + }, + { + "bytes": 419, + "git_blob": "e7129aa67f278d4fc1656f1d814bc4e6251a324c", + "path": "inputs/e8/Work/GCert/Data/Gen/E8YChk.lean", + "sha256": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "upstream": "Work/GCert/Data/Gen/E8YChk.lean" + }, + { + "bytes": 227089, + "git_blob": "5069b78564d65fcd7ea4a4865871cb783958a2c0", + "path": "inputs/e8/Work/GCert/Data/Gen/E8/S0.lean", + "sha256": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "upstream": "Work/GCert/Data/Gen/E8/S0.lean" + }, + { + "bytes": 42145, + "git_blob": "a281ae6687ec6d8c6f71480bba7507f0b1eb4fd1", + "path": "inputs/e8/tools/e8/replay.py", + "sha256": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "upstream": "tools/e8/replay.py" + } + ], + "generated_different_count": 0, + "generated_extra_count": 3, + "generated_file_count": 25, + "generated_files_identical": [ + { + "bytes": 7367, + "git_blob": "d1e3afba66b01bdc95d55d805ae63efa653031ff", + "path": "Work/GCert/Data/B2Ge8.lean", + "sha256": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0" + }, + { + "bytes": 1512, + "git_blob": "ef1487658291016d68e78b865f9239d100c69e1c", + "path": "Work/GCert/Data/B2Ge8Main.lean", + "sha256": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05" + }, + { + "bytes": 13287, + "git_blob": "c6c1567f5dfe456c5ffe4aad42598363df0a747a", + "path": "Work/GCert/Data/ChallengeB2Ge8x.lean", + "sha256": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3" + }, + { + "bytes": 4535, + "git_blob": "ab43d9bf07756e60715ffad5e1f644cc2a1e6978", + "path": "Work/GCert/Data/E8Cert.lean", + "sha256": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea" + }, + { + "bytes": 2863, + "git_blob": "71b561645b714e82324a649d540e0628bc7c8c66", + "path": "Work/GCert/Data/E8Price.lean", + "sha256": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e" + }, + { + "bytes": 691, + "git_blob": "0657e91b9975ca1dfa8da21ddd37e81e8a58adb6", + "path": "Work/GCert/Data/E8ScalOK.lean", + "sha256": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3" + }, + { + "bytes": 227089, + "git_blob": "5069b78564d65fcd7ea4a4865871cb783958a2c0", + "path": "Work/GCert/Data/Gen/E8/S0.lean", + "sha256": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2" + }, + { + "bytes": 599, + "git_blob": "c8165c355b811de25107973fe7e22e2ea036bf51", + "path": "Work/GCert/Data/Gen/E8.lean", + "sha256": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4" + }, + { + "bytes": 476, + "git_blob": "dfec705e0e8de5098b1359e4deaa07d14fa595e3", + "path": "Work/GCert/Data/Gen/E8End.lean", + "sha256": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d" + }, + { + "bytes": 2974, + "git_blob": "4c0a89ebc5b5ae8c23d94a576d8752056179b99a", + "path": "Work/GCert/Data/Gen/E8Hist.lean", + "sha256": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51" + }, + { + "bytes": 329, + "git_blob": "9ace01b6f3ea6f04174a4d15ba700544b057df8a", + "path": "Work/GCert/Data/Gen/E8Par.lean", + "sha256": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016" + }, + { + "bytes": 451, + "git_blob": "219dd4f6dba8e79a8b041acc999938253d1a12f6", + "path": "Work/GCert/Data/Gen/E8Scal0.lean", + "sha256": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd" + }, + { + "bytes": 428, + "git_blob": "b69b6fdff45e26b5eae1b394c8556b13c1f4aa40", + "path": "Work/GCert/Data/Gen/E8Seg0.lean", + "sha256": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138" + }, + { + "bytes": 431, + "git_blob": "a05e925bdef191129c376518b18d0061f52fc9a4", + "path": "Work/GCert/Data/Gen/E8Seg1.lean", + "sha256": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839" + }, + { + "bytes": 405, + "git_blob": "72addebadbfea53898f7664f923f4f6f80b58c6c", + "path": "Work/GCert/Data/Gen/E8SegF.lean", + "sha256": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe" + }, + { + "bytes": 449, + "git_blob": "8995e049e05267f04b48eb4e9232bb8b056c4fec", + "path": "Work/GCert/Data/Gen/E8Tab0.lean", + "sha256": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17" + }, + { + "bytes": 449, + "git_blob": "38ccb738cedf7e10794161a90313cea62a3f6360", + "path": "Work/GCert/Data/Gen/E8Tab1.lean", + "sha256": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0" + }, + { + "bytes": 449, + "git_blob": "bc10a63187ba520d96e2d8bba3349afe334a7233", + "path": "Work/GCert/Data/Gen/E8Tab2.lean", + "sha256": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41" + }, + { + "bytes": 449, + "git_blob": "07453a6580dcfb848970fce591c1a7e64867f860", + "path": "Work/GCert/Data/Gen/E8Tab3.lean", + "sha256": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed" + }, + { + "bytes": 419, + "git_blob": "e7129aa67f278d4fc1656f1d814bc4e6251a324c", + "path": "Work/GCert/Data/Gen/E8YChk.lean", + "sha256": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524" + }, + { + "bytes": 2278, + "git_blob": "be583c65d3a375aea13449a3b52fc07be39a60ea", + "path": "Work/GCert/Data/InstB2Ge8.lean", + "sha256": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954" + }, + { + "bytes": 15089, + "git_blob": "46c0ed04cdadb5a3bf15920e51dc537fdfa43eb2", + "path": "Work/GCert/Data/RateB2Ge8.lean", + "sha256": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6" + }, + { + "bytes": 15522, + "git_blob": "10c148fd72833f12e94e5a1770e13d60eaa6f8dc", + "path": "Work/GCert/Data/RateB2Ge8x.lean", + "sha256": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1" + }, + { + "bytes": 1476, + "git_blob": "bfa1d0308824cb8c4261a78b5eb7a297fce2ab4c", + "path": "Work/GCert/Data/SolutionB2Ge8x.lean", + "sha256": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f" + }, + { + "bytes": 325, + "git_blob": "7fda546848f67f704e3f900c2c2f82d44f48deee", + "path": "comparator/B2Ge8x.json", + "sha256": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926" + } + ], + "generated_lean_module_count": 24, + "historical_source_caveat": "Eight retained CrocSwap notes belong to another repository and historical tools/gx/ORIGIN.md belongs to f010392; neither category is claimed byte-identical to current9c94857.", + "intentional_lower_precision_extras": [ + { + "bytes": 13271, + "git_blob": "4b07ff8be06f0e7299dc2894999b913c348143fd", + "path": "Work/GCert/Data/ChallengeB2Ge8.lean", + "sha256": "7fa5c55f223f64e666059e30812e5f7cfd7eeb290563fc6f5a6504bae9a10f29" + }, + { + "bytes": 1462, + "git_blob": "a4b5220914768b0333b2649210acb7a171a52df6", + "path": "Work/GCert/Data/SolutionB2Ge8.lean", + "sha256": "c4454a61b7df233a60dcc884e9086fbdd11a734e55bee46569292468d4007573" + }, + { + "bytes": 322, + "git_blob": "c8b9862f43ce6a53107c1492cf54c0823498dac8", + "path": "comparator/B2Ge8.json", + "sha256": "6747a9b47a8e9f9edeacd792e68315f365394134bf243a95736c1713cbb55551" + } + ], + "local_processes": [ + { + "log_sha256": "2ac94de8d1805ee00d9239cd96f156871f44af6bd149f10ccea01c54e91af29c", + "name": "regen_check_e8.py --keep lean-regenerated", + "observed_exit_code": 0, + "tool_chunk_id": "ff1b02" + }, + { + "log_sha256": "5d27576f8c9b094488027c474fe36fe976d04cad62376827acc1953609af7c82", + "name": "python -I -B replay.py certificate e8", + "observed_exit_code": 0, + "tool_chunk_id": "a0eb10" + } + ], + "public_pr_head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "public_tree_sha256": "97bf4f6e8a2852ae9ac130f3a6a3d1f818c8afb0e02f22215508d434c137010e", + "required_supplier_wrapper_obligations": [ + "Verify all pinned input bytes and certificate compressed/uncompressed hashes before use.", + "Require regeneration actual exit0 and exact25 identical/0 different/3 intentional extra counts; generic regen exit0 alone is too weak.", + "Require standalone replay actual exit0 with E8 family, R783/W1263/D120/cst72/N9039/figure8762479.", + "Require parity-corrected odd-dimensional orthogonal-cover guard: m45 stocks990/1000/1001 bits and physical row11162<20161; upstream copied even-formula guard must not be admitted.", + "Use the generalized exact scalar/frame/lifetime/splice adapter and full fresh native21-stage replay; this receipt is not a substitute.", + "Recompute b with two rational moment engines including full fallback and reject adjacent1e-18 point.", + "Pin expected binding=false for complex in finish.py; preserve binding assertions with the new expected value." + ], + "scope": "Independent source-byte and certificate/data replay audit only; no local Lean build or comparator execution, no unconditional multiplication theorem.", + "source_pin_sha256": "0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb", + "standalone_replay": { + "D": 120, + "N": 9039, + "R": 783, + "W": 1263, + "accepted": true, + "checks_exact_rational_vectors": true, + "checks_separate_positive_and_negative_parts": true, + "cst": 72, + "figure": 8762479, + "h": 9, + "imports": [ + "sys", + "json", + "gzip", + "hashlib", + "os", + "random", + "time", + "collections", + "fractions", + "math" + ], + "source_sha256": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "uses_only_python_standard_library": true, + "v": 120 + }, + "status": "PASS_INDEPENDENT_E8_SOURCE_AND_GENERATED_DATA_BINDING", + "upstream_commit": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "upstream_documents_and_build_metadata": [ + { + "bytes": 128254, + "git_blob": "1ebcd0462239a3107a63a031f0136c5b7ca574f4", + "path": "README.md", + "sha256": "2029b33bbad4879630097164322b0ac3d4ea10db15f7aa93d75b5a16bb617483" + }, + { + "bytes": 64042, + "git_blob": "5a391a18e84724e3c72c620e1a49f103aa620a90", + "path": "VERIFY.md", + "sha256": "a7a14de579569f56a18cf4dd07a4738e74d7e9eb8700b5c63d96253cb93b22be" + }, + { + "bytes": 3222, + "git_blob": "75d612b05487f31bb784649ed886fe57cd6bf12f", + "path": "lake-manifest.json", + "sha256": "3a7cabde26b0c210cb99f8ad8d523ff7969aea6bc949b6e009a20963802161fa" + }, + { + "bytes": 1250, + "git_blob": "4ba6a25765136f820a2c6568089a0ee06e4bf7ed", + "path": "lakefile.lean", + "sha256": "8927b3ee27366af0a026fbaefbc0c5d87fcbfc9138a68ab0938bf71e6cc9f8b5" + }, + { + "bytes": 25, + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "path": "lean-toolchain", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ], + "upstream_reported_lean_evidence": { + "limitations": [ + "No full fourth-revision build from an empty directory in one run.", + "Official comparator used sandbox stand-ins on both machines; no real comparator sandbox.", + "enable_nanoda=false; no second independent kernel and no leanchecker.", + "Comparator consumed previously compiled modules.", + "Upstream evidence is documented evidence, not locally rerun or independently verified execution logs." + ], + "reported_builds": "39 new fourth-result modules compiled from source on Mac and Linux above prior compiled modules; second Mac run used exact exported Git files above a complete third-revision build.", + "reported_byte_binding": "391 Lean-related source/config/build files match build trees by SHA256.", + "reported_checks": "tools/Compare.lean and official comparator accepted WHT theorem and Fourier pair on both machines; allowed axioms propext, Classical.choice, Quot.sound.", + "source": "VERIFY.md sections10.1-10.3 and10.7, exact pinned Git bytes" + }, + "upstream_repository": "jacobalansussman/wht-power-saving-lean" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-SERIALIZER-REVIEW.json b/research/w3-staged354-signed20-native-audit/receipts/E8-SERIALIZER-REVIEW.json new file mode 100644 index 0000000000..2ea04b0054 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-SERIALIZER-REVIEW.json @@ -0,0 +1,42 @@ +{ + "all_changed_values_decimal_roundtrip_exact": true, + "all_other_leaf_values_and_types_unchanged": true, + "boolean_values_remain_boolean": true, + "changed_fields": [ + { + "bit_length": 32002, + "path": ".complex_supplier.finite_guard.complete_invoice.literal" + }, + { + "bit_length": 1000, + "path": ".complex_supplier.finite_guard.complete_invoice.live_stock" + }, + { + "bit_length": 1032, + "path": ".complex_supplier.finite_guard.complete_invoice.logical_groups" + }, + { + "bit_length": 990, + "path": ".complex_supplier.finite_guard.complete_invoice.orthogonal_group" + }, + { + "bit_length": 1001, + "path": ".complex_supplier.finite_guard.complete_invoice.physical_stock" + }, + { + "bit_length": 1006, + "path": ".complex_supplier.finite_guard.complete_invoice.rank_mass" + }, + { + "bit_length": 3055, + "path": ".complex_supplier.finite_guard.complete_invoice.router" + } + ], + "cohort_candidate_unchanged": true, + "failed_v2_price_sha256": "d0db2ccc366764f375c88d0945914a57aa77c971641b5740185f206cc3d3ae1c", + "manifest_sha256": "32e5f821e802313565695274447fd89a841c2c52fff6aff0faf9dd5d72410842", + "price_py_sha256": "15432d42b411ad2f18f2becc6ff93ca04397d1df4a758baa033816e691bbd405", + "scope": "Independent source review and value-by-value serialization audit. FullCP312v3 native replay remains in progress.", + "signed64_range_boundaries_checked": true, + "status": "PASS_INDEPENDENT_POST_ARITHMETIC_EXACT_INTEGER_SERIALIZER_REVIEW" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-ADAPTER-CONTROLS.json b/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-ADAPTER-CONTROLS.json new file mode 100644 index 0000000000..f3062a1b6c --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-ADAPTER-CONTROLS.json @@ -0,0 +1,86 @@ +{ + "adapter_sha256": "8bfe60ec267aa7ee028bcd09e0a1986a23838f5b77eff16753e385b5060eec63", + "controls": [ + { + "exception": "AssertionError", + "mutation": "missing-lean-data-stage", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "failed-independent-replay", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "false-producer-regeneration-claim", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "false-lean-kernel-rebuild-claim", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "missing-corrected-guard-flag", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "wrong-candidate-hash", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "missing-fresh-dirty-receipt", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "dirty-helper-not-restored", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "even-cover-undercount", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "omitted-router-charge", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "false-data-regeneration-count", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "wrong-independent-replay-script", + "reason": "", + "rejected": true + }, + { + "exception": "AssertionError", + "mutation": "changed-stage-log", + "reason": "", + "rejected": true + } + ], + "manifest_sha256": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "status": "PASS_E8_CORRECTED_ADAPTER_CONTROLS", + "successful_proof_unchanged": true +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-CLOSEOUT.json b/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-CLOSEOUT.json new file mode 100644 index 0000000000..6e5d7f11c8 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/E8-SUPPLIER-CLOSEOUT.json @@ -0,0 +1,36 @@ +{ + "adapter_check_path": "/private/tmp/pr352-e8-supplier-audit/ADAPTER-CHECK-V3.json", + "adapter_check_sha256": "19f8b288a49092e416ed50beae4c6a1a7954593dde580b68ec67d8bc952df593", + "adapter_controls": 13, + "adapter_controls_path": "/private/tmp/pr352-e8-supplier-audit/ADAPTER-CONTROLS-V3.json", + "adapter_controls_sha256": "e9f41106a63b49586e3bddc6d839531618be98a4f398821e47396ac730cd5f66", + "adapter_sha256": "8bfe60ec267aa7ee028bcd09e0a1986a23838f5b77eff16753e385b5060eec63", + "adapter_smoke_exit_code": 0, + "adapter_smoke_tool_chunk": "6ad7a0", + "all_receipts_fresh": true, + "candidate_sha256": "3594f19c4d01cf11fb930c5c61baeed399620acbc5b94096b16bcacb23997dd3", + "complex_coarse": "876248285600677/1000000000000000000", + "e8_source_head": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "full_dirty_scalar_words": true, + "full_supplier_exit_code": 0, + "full_supplier_session": 4569, + "guard_corrected_row": 11162, + "lean_data_regeneration_claim": true, + "manifest_files": 143, + "manifest_sha256": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "producer_regeneration_claim": false, + "proof_all_stage_exit0": true, + "proof_dir": "/private/tmp/pr352-e8-corrected-proof-v3", + "proof_stages": [ + "complete-e8-scalar-splice-dirty-parity-guard", + "e8-lean-data-regeneration", + "e8-independent-replay", + "complete-e8-two-moment-pricing" + ], + "proof_verification_sha256": "685c6346379973a3eabdab4b38fa97884a5c1b7ea65406093497dfdfbb77158a", + "scope": "Supplier-only corrected E8 evidence; outer bit admission and combined kappa assembly remain parent obligations. Upstream PR352 bytes are preserved; odd-dimensional cover parity correction is explicit.", + "status": "PASS_E8_CORRECTED_SUPPLIER_AUDIT_CLOSEOUT", + "upstream_lean_rebuilt": false, + "upstream_public_head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "upstream_public_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/352" +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/INTEGRATION-PRE-REPLAY-REVIEW.json b/research/w3-staged354-signed20-native-audit/receipts/INTEGRATION-PRE-REPLAY-REVIEW.json new file mode 100644 index 0000000000..dd45f86570 --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/INTEGRATION-PRE-REPLAY-REVIEW.json @@ -0,0 +1,31 @@ +{ + "added": [ + "code/audit_signed_twenty354.py", + "code/generalized_twin_signed354.py", + "code/generalized_twin_two_more354.py", + "discovery/SIGNED20-EXPECTED.json" + ], + "baseline_manifest_sha256": "a1d66cb46ec2d0354797d1b3bdc65451c4c7f8dfb07afb42ebc073492dd117df", + "disjoint_twin_pairs": 20, + "e8_adapter_unchanged": true, + "full_replay_pending": true, + "immutable_code_sha256": { + "audit_signed_twenty354.py": "2f956494b71cec06e3591135328a29e453cc2f1d1cf6e272eae9a4499bb5ac9e", + "generalized_twin_signed354.py": "74bcec2f8ae32345cb375a519c892dee3bd0bb26596ee4a9b5715a2f63cc2a70", + "generalized_twin_two_more354.py": "aec59caef2c0ddf0e578fe0209c59083e4224f83ed175a576c0c739fa2e4430e" + }, + "large_integer_serializer_unchanged": true, + "manifest_sha256": "338180183b553e635bf3c51cfb7c0d30cc2c144a2aa81777c21372bce8c45aa3", + "modified": [ + "NOTICE.md", + "README.md", + "SOURCE.json", + "code/finish.py", + "verify.py" + ], + "package": "/private/tmp/w3-staged354-e8-signed20-native-work", + "removed": [], + "source_intermediate_final_file_count": 21, + "status": "PASS_INTEGRATOR_STATIC_BINDING_CHECK_NOT_INDEPENDENT_ADMISSION", + "vendor_tree_unchanged": true +} diff --git a/research/w3-staged354-signed20-native-audit/receipts/MINOR-AUDIT.json b/research/w3-staged354-signed20-native-audit/receipts/MINOR-AUDIT.json new file mode 100644 index 0000000000..c4ac50521e --- /dev/null +++ b/research/w3-staged354-signed20-native-audit/receipts/MINOR-AUDIT.json @@ -0,0 +1,13 @@ +{ + "status": "PASS_INDEPENDENT_MODULAR_DETERMINANTS_WITH_EXACT_HADAMARD_LIFT", + "frames": 13887, + "witnesses": 27774, + "distinct_minor_matrices": 10875, + "prime": 170141183460469231731687303715884105727, + "max_abs_determinant": 1062882, + "max_squared_hadamard_bound": "4000000000000", + "input_sha256": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb", + "witness_sha256": "9ef4eaafb01429c432d418c6ee52e341fbb06fad8643851d701c5b76a4223306", + "seconds": 1.2897961249691434, + "proof": "Hadamard gives abs(actual determinant)0 and r['forward_wrong_rows']==r['inverse_wrong_rows']==0 +assert read(O/'ASSEMBLY-AUDIT.json')['kappa']==cert['kappa'] +for name in ('records','scalar_ADDs','paid_calls','paid_rank_mass','banks_per_stage','literal_stock','normalized_stock'):assert r[name]==expected['literal_expected'][name],name +r.update(kappa=cert['kappa'],manifest_sha256=manifest,word_sha256=cert['word_sha256'],stages=stages,inputs_unchanged=True,input_hashes=inputs,engine_hashes=engines,receipt_hashes={n:sha(O/n)for n in ['RESULT.json','MINOR-AUDIT.json','ASSEMBLY-AUDIT.json','stages/bank-tiling.json']}) +(O/'BOUND-RESULT.json').write_text(json.dumps(r,sort_keys=True,indent=2)+'\n');print('PASS_INDEPENDENT_WORD_AND_ASSEMBLY',flush=True) diff --git a/research/w3-staged354-signed20-native/LICENSE b/research/w3-staged354-signed20-native/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/MANIFEST.json b/research/w3-staged354-signed20-native/MANIFEST.json new file mode 100644 index 0000000000..0e5b4887d0 --- /dev/null +++ b/research/w3-staged354-signed20-native/MANIFEST.json @@ -0,0 +1,643 @@ +{ + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE.md": "ea1e8db2bf564efb32f6cc50a1afbd9382ae1dba9712324221df3c7464e48132", + "README.md": "8ba3855eabd5e7d44f11d105923078e1cfb29afca5137cbb5ae9d21af2e67b78", + "SOURCE.json": "888d71f583ebcad4eb8f7893734100d6e9a369d7d8be5f512afc6a6c5141ada6", + "code/admit_geometry.py": "c16c29e7d09aa9693ab7fb4330c8f1136146378c5391b3d3c14253a7b3afbbd6", + "code/audit_signed_twenty354.py": "2f956494b71cec06e3591135328a29e453cc2f1d1cf6e272eae9a4499bb5ac9e", + "code/banks.cpp": "5b85c63ebc95708b1ec61dbf407a0d7899707c0858c7ddc5393b3c49c2f9583f", + "code/changed-charts.cpp": "a19f24ef975010b2df78cc993e60acf9e27ab252d7817a4be048933f5281d3d8", + "code/check354_scalar.py": "bdabbccf2416f38e4e37b0d47b4baeb4fe8309ef52196a9b76ed48a423d66def", + "code/columns.cpp": "34c8df52a3e1ed15d2507338c2e0c5dea66083045f62592289e96522d2432cab", + "code/compact.py": "c2e92f50c109f9df84312ee0ba11841fbd3f947f8b4e6295846ec07290de7f75", + "code/export_native.py": "cc7e7833189ff16e97af0c2524705820800be7bb6b4ebbda836246e0d735b0ff", + "code/finish.py": "eca8b20157f9d92a37a441610c7038556b39e417231e26a953b2f3439127bdcf", + "code/frame_prime_minors.py": "15b70e8b069d128033fbac1713a75323fcaf2c7746ceec2e1c896c24e193aa76", + "code/future_supplier.py": "8bfe60ec267aa7ee028bcd09e0a1986a23838f5b77eff16753e385b5060eec63", + "code/generalized_twin_signed354.py": "74bcec2f8ae32345cb375a519c892dee3bd0bb26596ee4a9b5715a2f63cc2a70", + "code/generalized_twin_two_more354.py": "aec59caef2c0ddf0e578fe0209c59083e4224f83ed175a576c0c739fa2e4430e", + "code/invoice.cpp": "08125712b112201b81576d7763fcbb80a982f8a8f2fdb91c07328b46ffcc799f", + "code/legality.cpp": "786c5f5ddbc152fad2eb9f637a1d394640789030fe5936ea2fa607242d3fa085", + "code/materialize.py": "da9c2ca00a7cd600909252b220e67df33f30737c55c715c67b42f7d61f4bd16d", + "code/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99", + "code/price.py": "15432d42b411ad2f18f2becc6ff93ca04397d1df4a758baa033816e691bbd405", + "code/reflected_ledgers.py": "560fe654157f4a9501bf594d9bebd36af8cf3a281be5b83e0a09ad22502cec82", + "code/source_tiling.py": "89754753a514fa3fdb2bff51e9ce030356afb6c83176d53a10653228f6040714", + "code/staged_export.py": "7c7371e9100dc727cefa9950fbacef38df9c0c2090001a1a31ee68de46d6ee1a", + "code/threshold_bootstrap.py": "a0fb12677b45f1f8b81aa5b0df58b7e34c57908c0c84b3a14b19b62b3e302bf3", + "code/tiling.py": "9e650b5325d55f30e0de10cdc973819c3482faeb7bc2de8b3334e48ddd95bb6b", + "code/upstream-pr321-fixed_prime.py": "62967b70e104d59c00d89fc5be9d9956bcd465a632bd95173b029cb30620e9c1", + "discovery/SIGNED20-EXPECTED.json": "6b60e6b7b3e24f3238e26feb1bbdbad539d2b519cc8146fb0d7bb99ac40823c0", + "provenance/PR348-MANIFEST.json": "12ddc77ff4beafb848126f5b8d6ed9979614b66460e5aa1675e85e8ca97609d7", + "provenance/PR348-NOTICE.md": "89d5e68252ca35205382e39a9e0c6b317c36f2d8be435c4faee6364d83392370", + "provenance/PR348-README.md": "65ff95f63441f902912e1cbe24897bcd77fb018769ad6d184e8dc33386af0387", + "provenance/pr346-MANIFEST.sha256": "d747c94a2d1c4bc28764fdba78125614a6f3b01921858b83d21a8eaddb3e495b", + "provenance/pr346-NOTICE.md": "02b59cc0542c78f409d30ce4fd546a806b606b76e185acd9aad1e32deb705008", + "provenance/pr346-README.md": "bc3ca7ac910e024742d09aa524f3adea81d7226ad1d3afaea588b102d3a31537", + "provenance/pr346-at-discovery.json": "209af904e1abac4c7fda8954469a46c8bd476a020774720c5c6f42b2cdb22a5b", + "requirements.txt": "f7308e5b60ea62603b458da5fadbb55614b46fbb4d083200fa2cc9843085ceef", + "vendor/complex-reserve/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex-reserve/MANIFEST.json": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "vendor/complex-reserve/NOTICE.md": "380ce615ddb67da3680fa188a0ba0daf578b983d58c2496cd20dd06f32e4ef57", + "vendor/complex-reserve/SOURCE.json": "e69f2a72785302f892263cf765c84d07e083d9ad05730748f9c3374aade11e53", + "vendor/complex-reserve/admit.py": "1b9b069fbdef37b7e3fbc586aad9578ba85948e9f80877733af387573f3fa723", + "vendor/complex-reserve/finite_guard.py": "bef59dddd391bcb49ed16ec6384517b8b7a2e21415cc810f9c2f59f440370983", + "vendor/complex-reserve/price.py": "90cfb8d102adf0b5f93b71b05af5c078076f56873a868a66865575a5ea85d573", + "vendor/complex-reserve/upstream/pr352/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex-reserve/upstream/pr352/MANIFEST.sha256": "4b76fb09595321986da04017db16cf6aa36bcd6a048cdee2ec8b656de811e488", + "vendor/complex-reserve/upstream/pr352/NOTICE.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "vendor/complex-reserve/upstream/pr352/README.md": "c5349ae6637e846fefe132756968376d52c5e3f76241e96214f59e65cdb7ad16", + "vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json": "2ad0b2138d2aa8cd5c6ab6995fa8c6c167a822b668ef56a9cc39c5765d1134b3", + "vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py": "82e5ef0c7b6cf84c53bf6039330930242c9a5c8e8ea13183b2805cf9577f7129", + "vendor/complex-reserve/upstream/pr352/code/builders/build_v5.py": "c0867d68b863ca7d8cdd7002ffed263cbd5525fea4522267b5f640e4eff5597b", + "vendor/complex-reserve/upstream/pr352/code/builders/decomp.py": "699c424170b41d3711da6a283f58cac824402ca373764365fd05c8e645ed07f5", + "vendor/complex-reserve/upstream/pr352/code/builders/gather.py": "8c7d2a34fdcbe75d8ed8299e399d578b32adf44402c773fd905aa7c88e2b460d", + "vendor/complex-reserve/upstream/pr352/code/builders/interface.py": "3b3e2fb894f871a9b6145844faaff34a05add59ae0eb8882c8feb2b914265b8a", + "vendor/complex-reserve/upstream/pr352/code/builders/twin.py": "cfd261d82a31dd9024f1fa191eac2f5d893a7b51833b912459de46a1e9aac003", + "vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp": "26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8", + "vendor/complex-reserve/upstream/pr352/code/checkers/exactnd_h.py": "28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3", + "vendor/complex-reserve/upstream/pr352/code/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/complex-reserve/upstream/pr352/code/checkers/legality_h.cpp": "5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056", + "vendor/complex-reserve/upstream/pr352/code/checkers/sub.hpp": "59c1a64f9df61fc50f47d5a78c8f9351875bf6b352db1c9d109c7c90542a4f19", + "vendor/complex-reserve/upstream/pr352/code/checkers/verifyT.cpp": "1a5aea81aab652622e6547d901ead6aaf54fdca231da897dd99474c9f64a33bf", + "vendor/complex-reserve/upstream/pr352/code/complex/certify_complex.py": "7e480b7761fa700944a7dca41ccbefd530203b5e9168b6b37fe879b7e6da57fa", + "vendor/complex-reserve/upstream/pr352/code/complex/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "vendor/complex-reserve/upstream/pr352/code/complex/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "vendor/complex-reserve/upstream/pr352/code/complex/code/complex_labels.py": "e000ee131389fec427388b85f632879cbaaf10e5e5d979a47d6307d64ce58982", + "vendor/complex-reserve/upstream/pr352/code/complex/code/complex_scalars.py": "38e985ebe8c8e7f8c83c03828abde0c80be418caf95e97afdf2d0c357c0ed919", + "vendor/complex-reserve/upstream/pr352/code/complex/code/complex_splice.py": "aaf46c8e5c68875b8315892e924e082b2f219f8d042dd14937e7cd2f72456dce", + "vendor/complex-reserve/upstream/pr352/code/complex/code/p10pins.py": "93b78a2e038b23264d04836928c78b6ebf33b87ff3dcc0e43ba0f1748fadd143", + "vendor/complex-reserve/upstream/pr352/code/complex/code/scatter.py": "dfd1afbbb3ff86f54db6a0313916403ec8ee6f939caa62f3edcc9d7a151bff95", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/source-pins.json": "0d76527bf9c259b9532466a7b056ad6ff118867a96e044ff8e1a24aca12e1dbb", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/NOTICE": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8.lean": "842b217147cf84e8042d6ef1c33104d5444b6587b594664bc9eb89b237ab4ad0", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/B2Ge8Main.lean": "987103107d5586c096016f0a702d0de35b74398dbb50ac66f5886a43a5ca0d05", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/ChallengeB2Ge8x.lean": "a59db9d54b83adc73391916f7c1ef5e381ff073027781c26cb350f43b79839e3", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Cert.lean": "13a243c7d7be31ae429d19b5ecd5d428d60c41b7cca8a330f0c4179b110ba7ea", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8Price.lean": "cd250dd72406dde37765c501f666ceeedcc18f831070b26369bcb154c1f99a8e", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/E8ScalOK.lean": "6bd5e68effe8913a3f73e25ea59142cd9928ddf81e94250a6ea28aa7317388b3", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8.lean": "5c7fb23df2c10b690f638a19bf066905b5b620b8a2ad0ffde76cc9348d8aa2b4", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8/S0.lean": "36de82f6969c23082876a4d6848428623d1c65d2df3fc917f23ecba003189dd2", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8End.lean": "6ea83365afe01664b2132a630511b4de65f938dc328744ce7f77a01fad97f32d", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Hist.lean": "cce81699abe1f85a870dcf64edd395d2cf5a586da7700af565b557093095ab51", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Par.lean": "a343219b419f30f8ac4dd3a0a98bf53550c5fec6b2cbd245320a95977c319016", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Scal0.lean": "78036e5443775ade5bde46a77ba3e0433fe22160da11b5b6c96c7f1075ecfbbd", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg0.lean": "f6b248dc4c3b2c94db95989b6bd5ad3c3f0d7ece3a511e5b69069550b821b138", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Seg1.lean": "79d16ccceb61391446ea97f77fddadafa9150e9dea97919e775f6c78daa71839", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8SegF.lean": "924340aebc6f68b5a6526311ce33341af0a0a5a8375416762f08c1914ec08abe", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab0.lean": "650600b631a21221956f9abbab9abebcc9cca628512d3e9a017e2373e2649b17", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab1.lean": "60036fa4deeb19d39fc0dddf31359d2b6d2407ff66070f145b111bff16190eb0", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab2.lean": "c8a248da3eb770ba55ef267d118b29d49983311087ef789398d555e2c44b3a41", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8Tab3.lean": "41975d430ec0095ad465a36d4903e90c01bc891d3abe5e2c372ef786c029a7ed", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/Gen/E8YChk.lean": "a290360c175544cb85edffe1b92fcf7d447cba09128e19de8dc87e0a1ff0c524", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/InstB2Ge8.lean": "c1fee298187ea19b5d70fcfccef7d4fd4161be70c0adda19a89ca9933a759954", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8.lean": "7b6e59724c0f140e714afba237d5a1a91b22da70abc096ce274690140b39a3a6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/RateB2Ge8x.lean": "7c56d865ed6bfcb6919dabc1a6e53f8744ff4824a2f78335787485f3090970d1", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/Work/GCert/Data/SolutionB2Ge8x.lean": "dd52f1fe0a372480edaf5e6c64903d6257c410e43d406f8acb6bf8f60a1ee28f", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/comparator/B2Ge8x.json": "ddad06c37f9268986f3ec8ce43da5230ee2bd887da2480328413a0dc58f2a926", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/certificate/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/e8/replay.py": "be41ee310f28121c3e424cc8637d8fa02ef7c47fc8945e9bbd3856138fd800d6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/foldgen.py": "a0f16e2c9e078ffbfb2174281ee93a48c18593aefb880318fc105ec85a205932", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/foldlib.py": "7a3c38a698c129e13a767da75926a1305eb0c031b908450afc6feb185505c59a", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/gen_rates.py": "ef8c869e4cf8da33a4c10b96f7f6faafd46e15d66766238070a60315aa169994", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/gen_sharp.py": "1b5eb3730cb16cf516e760879951fdfb9b065efc55f78c29a5c6404fcca57a78", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/templates/ChallengeB2L16x.lean.txt": "0488b7a2442c795414f103df912d1e6cc66d37b5be270940ea9564b7f2b666be", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gen/templates/SolutionB2L16x.lean.txt": "d414a890dfe126916374c1afc804b90e5081b7760f894b9ccdcf23d83a12f9ee", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gsmirror.py": "0e22bbe5924284e2fb916337ccefc8e41f6e54469749986ad15b3b81cfaec534", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxgen.py": "ce9151054370c2210ed08f54c249a19dcb6946d182cdf934dee1a3781b53040f", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxpaths.py": "f00802d48ef3fedb00278f0b1c7bde074cc49dd30f202d7f32a9d2aebb3be443", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxrate.py": "514a5719f970fe36b1273cf59df0396db0e042dd7864c2eea53ab2a2fd1e2ad6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/gxunit.py": "3cc09a9c1a2db681c0f2016bc821af5b674d34834dbd6f195b9d482ce7c0ff58", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check.py": "b6172d58749c0b3b9138570c74827bcb23bf5db4ff9643740768cd7782ac4ca6", + "vendor/complex-reserve/upstream/pr352/code/complex/inputs/e8/tools/gx/regen_check_e8.py": "ad8fe9811c6ea0d89c795caef48686cfca600f5d540ebfd5d1251d6777cec7cf", + "vendor/complex-reserve/upstream/pr352/code/complex/pins-e8.json": "bf66f785878f636616ceab193e5a222143945ea06fc2f13dfb99b204ebba82ff", + "vendor/complex-reserve/upstream/pr352/code/complex/portable_complex.py": "44e8ae8a5b915358a97dbed5fe4e70195ed3581fd45a216df48fc82a029db87d", + "vendor/complex-reserve/upstream/pr352/code/complex/regress_pr346.py": "29479da1547cd39cf20fe387cde4cad847a2880266db9d0ef3fb474f68591feb", + "vendor/complex-reserve/upstream/pr352/code/export_p10.py": "1161d23b459f7d981d6716073745909126d5465018cbbea7e6e6a9e4e5d68add", + "vendor/complex-reserve/upstream/pr352/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/complex-reserve/upstream/pr352/code/pricing/certify_bit.py": "fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394", + "vendor/complex-reserve/upstream/pr352/code/pricing/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "vendor/complex-reserve/upstream/pr352/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/complex-reserve/upstream/pr352/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/complex-reserve/upstream/pr352/code/pricing/prime_new.py": "7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a", + "vendor/complex-reserve/upstream/pr352/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/complex-reserve/upstream/pr352/code/pricing/tile_check.py": "38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae", + "vendor/complex-reserve/upstream/pr352/code/provenance.py": "9f5c05aa4d172478f2ab67e7bb83cacebfccc10ecba650c23539cdcee18f2139", + "vendor/complex-reserve/upstream/pr352/code/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "vendor/complex-reserve/upstream/pr352/data/bit/BASE-RECORDS.bin.gz": "caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430", + "vendor/complex-reserve/upstream/pr352/data/bit/BASE-frames.json.gz": "35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f", + "vendor/complex-reserve/upstream/pr352/data/bit/BASE-states.json.gz": "1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22", + "vendor/complex-reserve/upstream/pr352/data/bit/FINAL-NEW-FRAMES.json": "e7fe9d0686829ad5acf7930698b3c81a866ae834422aa3c9a12057dfae627175", + "vendor/complex-reserve/upstream/pr352/data/bit/FINAL-RECORDS.bin.gz": "fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6", + "vendor/complex-reserve/upstream/pr352/data/bit/RECORD-SHA256SUMS": "21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2", + "vendor/complex-reserve/upstream/pr352/data/bit/labels.json": "e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce", + "vendor/complex-reserve/upstream/pr352/receipts/complex-guard-e8.json": "f94a5dca42cbb88e9650f8f8a3ffbd1153636dfc0a48da5f7a7fca908c0650ad", + "vendor/complex-reserve/upstream/pr352/receipts/kappa.json": "36316b6cfe423b56cda1fd52843e56c997d060e33d26b732b3ecf4de3ae83aaa", + "vendor/complex-reserve/upstream/pr352/receipts/official-five-stage-columns.json": "32e291f249b4eab8d65664d10c94208fe2154bdb4a45aaff84e9e8da5295a29f", + "vendor/complex-reserve/upstream/pr352/receipts/official-legality.json": "7e675b7720f056548c1ee9f9de523eea10e6b014ddf90b7a630fd96163acbce6", + "vendor/complex-reserve/upstream/pr352/requirements.txt": "ca0825e0ae3db2855af7535ebdc4775beadbb6f07f8d3a84f0f4fd5b95ba5eae", + "vendor/complex-reserve/upstream/pr352/verify.sh": "1a05c0b31ea37b2b5a4b84f6f9f504af8dd4220e13a6d9d86f64b2a731a903c7", + "vendor/complex-reserve/verify.py": "aa6f05c39404b4038c31c72f9fe7a8e137df911f6cb6fc668e316be37c40b126", + "vendor/native/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/pr329/BANK-PROOF.md": "eadfea08b70240262670ac0743fba30d3ec506c099944fc5fd4412d4f6fea1ce", + "vendor/pr329/COMPLEX-P10.md": "be3a9ced4c1dd1f752e091a79be04929d0531719ffe78ec5c7281fadc3ea1555", + "vendor/pr329/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr329/MANIFEST.json": "c9ccfca59839057ee98a04e9882aee8c1f46c196a0ae7d16d7d62f91d5caa877", + "vendor/pr329/NOTICE.md": "dd0315326fbfeeacd15f8ad4835b1b36c5ace806f26db53385b1dbb82081f32e", + "vendor/pr329/PR-STATEMENT-PR325.md": "211fcfe39971fc6de63a844f4c4a5a28539949c81c39d59f9304d0896fc1f472", + "vendor/pr329/PR-STATEMENT.md": "4d1ae307c34a08c89e83d67efe75f597a626636c2aef1e4e72128e0edb3c1357", + "vendor/pr329/PROOF.md": "5033d3b87037823e711cef8a1583afc0528a56c4c9962e37fae2619fad47fbbf", + "vendor/pr329/README-PR325.md": "495768c2289929a319883c976003b9c80ca6b6cd58386693adbc7d1482b8cc9e", + "vendor/pr329/README.md": "afe12289b0bafb16187155fb9bd16581a8c471981ebd5dffc8577033cffc420a", + "vendor/pr329/STAGES-PROOF.md": "3d4401e12e41310c5a37dd2d4cd0665520c2f28c464cdf08a2d0e6bfa54591c3", + "vendor/pr329/UPSTREAM-PR234-NOTICE.md": "ce978c8dfc8a2b36eed7a53014b1a792248b22ef4cee3edd8adab825a571c429", + "vendor/pr329/UPSTREAM-PR234-PROOF.md": "c9722b07256758cd3b307dd46689f99984c66e16c3dd934f9c34e551620bfc0f", + "vendor/pr329/bank_check.py": "5fdcba97a59f2713f3f534763a88a8c737adf28279b94a4e484e62b1793404aa", + "vendor/pr329/bank_template.py": "1c124900095abfd0c06cba507c2ed804f5475bea1b3f698ef66d412417ad4264", + "vendor/pr329/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/pr329/bitword/NOTICE-PR200": "9e82089424092c1dabc2341a09ead255633d78c90dbdc199c4336ca1c0f3bdf4", + "vendor/pr329/bitword/README.md": "5c5100382411b8a09ed3f485e2e2fe1ce925e51df997d475dcdf9976084da84a", + "vendor/pr329/bitword/bit/base_word.py": "9fe3a81b7561d2b09c086f63fac4626e88a32369ef8bc5579c94878de1218a89", + "vendor/pr329/bitword/bit/word.py": "88554981690cb43c4286fd962dddf0f20c58cf0c6cd58f0b8081ac88b16531ff", + "vendor/pr329/bitword/producer/data/arcs_p10.json": "8d4d1339ff69150d0892f30d66fb5108802c633c69a8e1f511bbfd5a2ed78a7d", + "vendor/pr329/bitword/producer/data/cube_orient_p10.json": "cb0c503be9e4a9696f01a7f18b92383e8be118adca29a19b43a472489ffbc0af", + "vendor/pr329/bitword/producer/data/local_design_p10.json": "374803215ffb55e7c77c816b7c53e8e031cb6850d4d369f77b3528a9365d1b9d", + "vendor/pr329/bitword/producer/data/pm_p10.json": "8d71f5004acb0ea902ad594a7d298f8d2099114e5d6d42c6357f09c44ab3ce87", + "vendor/pr329/bitword/producer/data/qmod_p10.json": "40ffb168466bc016bc18a2bbdde65d38b7fd1b406d8a4026f1a6e517fe153459", + "vendor/pr329/bitword/producer/descent.py": "873fdf8d1281e034a238e09968ee66d77dcc236616305893c1aaee2b516299ff", + "vendor/pr329/bitword/producer/make_physical.py": "854640404e8fc5c7d7b1089e1291ee98c7c21056f6d1baae04a57ea6928e8db9", + "vendor/pr329/bitword/producer/paired_cube_bit_word.py": "ca512704f85dcce0a58a4da64c141b9bc0a74ffa3743ed7d2b16e9e8074b22e1", + "vendor/pr329/bitword/producer/regenerate.py": "2929047b40a3a2dcbadd7df95c8cba0a7fc68abb705f878b6767a41f90fac02e", + "vendor/pr329/bitword/references/pr168-v4/SOURCE.json": "21a412177c9309d89472aabf4c67618d7a546811f7e68a5904304ae46a98d27c", + "vendor/pr329/bitword/references/pr168-v4/research/paired-cube-bit/check_paired_cube_bit.py": "4d7c86cd999a1519e0dfb6dcf33a8f26e442a353c3665a0f06881216a260fbf3", + "vendor/pr329/bitword/selected/bit/frames_p10.json.gz": "fec07e983f81459c45747dfaa4eecabc3429e84d4685f385771904dee4c4fbc0", + "vendor/pr329/bitword/selected/bit/graph_p10.json": "4a43116c8d154e61be795ca76b3a550c9f5bb579a5fe3fb88a09279512aab174", + "vendor/pr329/bitword/selected/bit/kchron_p10.json": "1ce62b85b496cbec17fe9eb9e81152126cb90708577cc2e3bcece9b2796ef31c", + "vendor/pr329/bitword/selected/bit/profile_p10.json": "177ff70a322f152ccc6c12471aced7a207062e445f9f64c7d3bd96e6f18c6f63", + "vendor/pr329/bitword/selected/bit/word_p10.json.gz": "601da0e6a67715011a4bbc44f6977f13625c5833d4d40443c10b0d5a9da1896d", + "vendor/pr329/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "vendor/pr329/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "vendor/pr329/code/complex_labels.py": "76df13a56ee1192914b40ab0c2f9206ee9f87f2c086c6cb1d33c553d7a405b9e", + "vendor/pr329/code/complex_scalars.py": "cab795fc6529b9303e3628bf4f3719eede0eebc63505c79a6e6e1fb18ee7213d", + "vendor/pr329/code/complex_splice.py": "e0f2b3ad17e52c4b1da5c476533607bc284254c73119d1d999a90f785cea4840", + "vendor/pr329/code/geometry527.py": "7cf018695f54e337d5b86ac2b49e676c361841773c8ada9f44f5c04d3a314636", + "vendor/pr329/code/global_lowering.py": "ebfb692cef4c05082bceaac39dd7e9d9bcf61f38f55dfa302974ba37559b8e6d", + "vendor/pr329/code/physical527.py": "4d4bf47ee083d3864f76907428f4e813a147f7ea6ab0b8cd1536adcd2c469395", + "vendor/pr329/descent-selection.json": "4eb2be5ee14047d10e986d5526b4f32ff4e2599ca9616b7f43f31cee3a74c588", + "vendor/pr329/descent2-selection.json": "ff0283c0116aaa8c43101626a5a944149730e0f7400ea28d36ca6f44a49c83dd", + "vendor/pr329/descent2_transform.py": "715cc90b3ce4b649baea34aba690363cf9dd3cd15aac1599566a95ce43eaf5ef", + "vendor/pr329/descent_transform.py": "7a2e3fbb4bf01e0702baaa285c9641fd8c99d793254bd8e3875fa41bf6c03b9f", + "vendor/pr329/discovery/README.md": "e0952275babb9fe86ff3a63271b658eebb114a74ddc1cc2313c5223d1e5b29ea", + "vendor/pr329/discovery/REPIN.md": "1dd75c93205183a0e32e514b0bb554b50b9cb928bff5b10a26a95b148cd1af29", + "vendor/pr329/discovery/build_reorder_selection.py": "fd3935ed50aecfba031ecbae419eb5c8d1202685b639a7fd9ab3d89795e3a41a", + "vendor/pr329/discovery/build_restore_selection.py": "03f54ebe786d85ce140eb488fb3f5f71d7860620235fde14298f6e1d63ed76c9", + "vendor/pr329/discovery/build_selection.py": "5a4f6e3ee0516ba3fe2e39f89bcf44c13df846d3f7f825f49c797428d9490f0e", + "vendor/pr329/discovery/build_shared_kernel_selection.py": "2756b1881fc8693038a211f366bfbf347d6e0cdb9c3f27b28356678c7306f038", + "vendor/pr329/discovery/build_sink_selection.py": "02724b8cef540a986075d38b7e84897e6b2af2863a1ea33e8b2d0605a275afda", + "vendor/pr329/discovery/coll/census.py": "52713d8fc19b2e25af9307ae87d5d85a87f07ca21cee0d05388cf1718cb66202", + "vendor/pr329/discovery/coll/closure_pack.py": "7cb01f07b57be2edb6d74b86775eb6bf9c6a98512a4780d43a528838fcc6a45f", + "vendor/pr329/discovery/coll/fameval.py": "9b5b888d061ffc790ceb96e2f31358cc43d81d32fa3d5c50aaeaace7f8cdb561", + "vendor/pr329/discovery/coll/families.py": "458e81f7ba5e67c755bbf246b59836ed3e1ea08026b05d4714acf7c8ca343b79", + "vendor/pr329/discovery/coll/linalg.py": "a6fd2155ef5e1ab74a4ae4aefa1ca787d01916cc0e2c95b142e425d3782b91cf", + "vendor/pr329/discovery/coll/lines.py": "adf77c498fa521bfeb2ac3b478b94d51f5513e6c4778bf66a0d6bca1a4638598", + "vendor/pr329/discovery/coll/load.py": "338b388451a333c5a59ba429f63e8b5d6b4ab6a94a7e4007524e8a963d0c751d", + "vendor/pr329/discovery/coll/pack_restarts.py": "194454bfb4de612076041a841683a1ea51f55423986f1fe62e65c8891fdb9191", + "vendor/pr329/discovery/coll/planes.py": "3f1950807a677aa622320674dcf629afaf5bda59c138213cfcd2dcb319e47150", + "vendor/pr329/discovery/coll/trim5.py": "96d4634f2c4a91c260c51f663b103ab39a7dd43bb5fd6d317a552e9f2196a4cf", + "vendor/pr329/discovery/descent2_dump.py": "bc218021ca7d033fcfad06a77f2815a91fda58c7a5881a67348527971ae416d0", + "vendor/pr329/discovery/descent2_freeze.py": "790770195ae12cd504e389624ec836f7115a2ba4cf38942de2b03ab7436f63be", + "vendor/pr329/discovery/descent2_search.py": "8d20165cc0792691f92028816cf5c236a6566ed5cd26c2224746fe4e17e50b1a", + "vendor/pr329/discovery/descent_search.py": "3d7f9638c71ea66bd858facf2f0956571c70cef372e6821ef9c3fb8ea3d5278c", + "vendor/pr329/discovery/dump_at.py": "25c0d98f2c8bf1354e8d6fe927205e99e87f2c0817977401a55f402877eed23c", + "vendor/pr329/discovery/repin.py": "8bd21ad00c07d2f9cbde3a882721882d12e0e50851c720799b449599f205654f", + "vendor/pr329/discovery/sink_screen_at.py": "ef3a857e5bf67abdba5c5d3b4384589d93aefbacb89ff1f6d345cfea1afa2928", + "vendor/pr329/discovery/target_search.py": "263948ad04a8144bb59f6cbd4b9f725eef7e4c59ed618c1a621b9402d5b1affd", + "vendor/pr329/finite_check.py": "f7580cb096ac3de9b866cb3a7b48d6385e2694f077dc85afad7c273fcb0e9bb9", + "vendor/pr329/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr329/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/pr329/inputs/complex/NOTICE-PR304": "319165f41cf97f37b587c92351289db2d287ca7a90845338318086d5ff447e84", + "vendor/pr329/inputs/complex/centre-mw-p10/NOTICE": "997038e3859b058c14aa6c77a9791b6098620f2e4b10a4e400b6b242ab34f831", + "vendor/pr329/inputs/complex/centre-mw-p10/NOTICE-PR327": "193a094dbd9a881d8fe4f4e6f0bf535506b2761cdad696919b60fc6af5256855", + "vendor/pr329/inputs/complex/centre-mw-p10/centre46_graph.diff": "229eea46b56d19b262d1498f489f9bca84c347e33b16553079d38c4276700280", + "vendor/pr329/inputs/complex/centre-mw-p10/expected-centre-mw.json": "f7dc252903d702d85f0b98d7468fd5760ed370482b54e66da1acefe0118fe98e", + "vendor/pr329/inputs/complex/centre-mw-p10/layers/kernel-pairs-mw.json": "e47454fb1838c9372a403b5156bc195630ba6f0cfcaf71b92170f05f111a11cc", + "vendor/pr329/inputs/complex/centre-mw-p10/layers/matching-arcs.json": "ea7300db2cdb324ddf680bee6d447e9a9994e0b77bf2cf7fbf25e7cd1f6cb16e", + "vendor/pr329/inputs/complex/centre-mw-p10/layers/physical-frames.json": "1f9813eee92459b341fd437f4ec3a87ae9b440384a277450f483112481381b12", + "vendor/pr329/inputs/complex/centre-mw-p10/layers/physical-pairs-mw.json": "6c910a4ed8fe325547d9da065edbe8176969048724c0f96ee43a075b2813bd53", + "vendor/pr329/inputs/complex/centre-mw-p10/modules/pmod46_pc1_p10.json": "7f0bfd151e7ec0b2a74bc6fd994acde477e23f1425f4da798202f510489b6a3c", + "vendor/pr329/inputs/complex/centre-mw-p10/modules/qmod_sa1_p10.json": "7f7f96efc14921c9dbd8a888a7f3a35b267f7c47d0a8e1e3926c3ff34011e8a6", + "vendor/pr329/inputs/complex/centre-mw-p10/modules/tmod_t2_p10.json": "4d39faeedfb5a5283a7ad34a8a18af93072e4d155d61dec6c28d7751bc2e4e04", + "vendor/pr329/inputs/complex/gcert1-p10-centre-mw-flow.json.gz": "274d1bd671eb74d4fa8f63bb7048d929d6b51f6275a5ff6f69e04588f03d5c7a", + "vendor/pr329/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "vendor/pr329/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "vendor/pr329/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "vendor/pr329/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "vendor/pr329/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/pr329/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "vendor/pr329/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "vendor/pr329/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "vendor/pr329/inputs/complex/source-pins.json": "dfaeae9eafc8299b3bc61eda5b76ebc456a1dd704c3407cb27b24894e73499c1", + "vendor/pr329/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "vendor/pr329/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "vendor/pr329/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "vendor/pr329/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "vendor/pr329/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "vendor/pr329/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "vendor/pr329/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "vendor/pr329/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "vendor/pr329/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "vendor/pr329/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "vendor/pr329/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "vendor/pr329/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "vendor/pr329/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "vendor/pr329/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "vendor/pr329/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/pr329/kernel-selection.json": "e2d67dc69e0a2992ba15a58f0ec1fdd25cadae137be6253826f03460f3003fd6", + "vendor/pr329/kernel_transform.py": "8ca8f07e2ee73569a3222a9172e19ccccda88ba9a9657fcc00b01878c8a84902", + "vendor/pr329/math_check.py": "3b9c4f83b8d9a1eef95d3da42109aa616aa745df11f4dc2db2d30ec329d781a8", + "vendor/pr329/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/pr329/notices/PR210-coordinated-crossover-NOTICE": "9fc5561c0995892dbdde777c713899486920c32d3562392f5f72377a4953bf98", + "vendor/pr329/notices/PR230-NOTICE": "7dfbad087ee49b74fd5075d517eaa263c5dd3d4fbd4c69bfba34ee1cb55e837f", + "vendor/pr329/notices/PR230-PROVENANCE.json": "19957e28a8ad26281bfe8bfaf8ae16191be53e729a8870a6154671b3384959d4", + "vendor/pr329/notices/README.md": "d1fcf4e4209d5966282ac8202cf461bd575119a7aaf2ca64e8746810fe5259b8", + "vendor/pr329/notices/base-bit-PR200-PR202-NOTICE": "c9850418622aea8d1382a230306c940947b5da818f4854b4b272ed60cf239f6c", + "vendor/pr329/notices/source527-loader-NOTICE.md": "ee632728cc4d89565292d288f8289f483ac794b5d02cc6e42c2b2c43c43ff1d8", + "vendor/pr329/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/pr329/parity_transform.py": "e068874694fc15135a0950b7361e537f48688d9ac9f0a05c2372f1deb813d085", + "vendor/pr329/portable_bit.py": "61ba4a2ee153a3d0ba1d7a4542a2f666d377b1c0e30bff477c0d0d6bf0c27d6d", + "vendor/pr329/portable_complex.py": "1b7b7b8a1e0b4edac46972e9ca9396d0dae11ce358d0635413672f6b4215e271", + "vendor/pr329/prepare.py": "c1a215713f47b954c28a3f0d48490a055fb75f6af31a0e6b5248802d6951a09b", + "vendor/pr329/prime_check.py": "94b0f0603a12e03225344ed9a1a4554a079fd893df3dc15346f569a9aba5967d", + "vendor/pr329/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/pr329/proof/FINITE_BIT_ACCOUNTING.md": "602923520af184670170bf159fde7b4c72e79a72570eddd7746b7c97bc51fc5b", + "vendor/pr329/proof/INTEGRATED_PROOF.md": "cff22391e71a50bad27a1e832d5c0a2c8b2446df55adb1297c8b1485b3761257", + "vendor/pr329/proof/PARITY-CONTRACT.md": "a9246be656e31f1a21d5ec714e002f51be0aa07c36e1528066a25b2c7a02db91", + "vendor/pr329/proof/README.md": "435c699dc07400366b84fe43d981cd2f6c95a4837e636fff8fe6a25897d853c4", + "vendor/pr329/proof/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/pr329/proof/primary/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "vendor/pr329/proof/primary/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr329/proof/primary/PROVENANCE.md": "dd9054c58aa92c44b0ef5f691ad4dc52b8ead2f20a9843d4399d6c300d616023", + "vendor/pr329/proof/primary/UPSTREAM-README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "vendor/pr329/proof/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "vendor/pr329/proof/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "vendor/pr329/raw_ledger.py": "95f2a1fe56dc9f2d253d405ecc5a81dc66545978564bf9b554f400e4bb266a8e", + "vendor/pr329/reorder-selection.json": "1655138407cec8d079d0d1331203db46c95b70bac135f3256f66b38af5011a2a", + "vendor/pr329/reorder2-selection.json": "598e4cd20aa804b79e2a31163a312679dc0419dfb26a5494e7f0186fe6076d79", + "vendor/pr329/reorder_transform.py": "dfb2759314eba6e713696bd1622e7d0be21f203f00c2c7fa88b1f443d93a8935", + "vendor/pr329/requirements.txt": "25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc", + "vendor/pr329/restore-selection.json": "7ded9e7b5848915422e7e508b8e21e43eab52f5acaf05c41366a875657d01646", + "vendor/pr329/restore_transform.py": "8ae804aba73fe6ec14c484503af02f1ef4dc6af073c9d39377f22b511896ab21", + "vendor/pr329/scalar/word.py": "e675d4eb9d90ff0b44279fae0b46f1a8b39f65421cc38454b70a6b75d0e10b42", + "vendor/pr329/scalar_check.py": "7df8fcca1d866087f982549df8424ee0b26d5dd3bbb2a725e5ddfb347ed125e4", + "vendor/pr329/sink-selection.json": "202d3463e5c2620803dec19e74dea7d81d8be8989bcf4f0986f9e39d23656d22", + "vendor/pr329/sink_transform.py": "39c573a6404a4f76f1bca3a1721f3afe0a3937c4543d6eaadbc3ae881b632b22", + "vendor/pr329/target-selection.json": "d25fb50ab7e4ad3c646a8ad9633a7f6f9247be077caf3431f6b609053a0fd8ac", + "vendor/pr329/target_transform.py": "0955daa2a15dc58b27a6b57aad029c0e97a417400c7c2d7eba8e54a34b974d69", + "vendor/pr329/verify.py": "fbfeac193b877e68ff7704555175a695aa96c95a8431eab0ae087134d6cd7514", + "vendor/pr329/virtual_check.py": "ec952d99c151e6e336631210e598d58478293491ca01842fd4c9d0a4b57b4e5a", + "vendor/pr329/word-pins.json": "c18420400589b29f9487b2f6497ce2c53d034df1882d5ea4a1b19fb17fe278fb", + "vendor/pr329/word_pins.py": "3cc2662630af62aaabb6966f03b5d01a2f06a5f3490c6979a3e54daf550958b4", + "vendor/pr346/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr346/MANIFEST.sha256": "d747c94a2d1c4bc28764fdba78125614a6f3b01921858b83d21a8eaddb3e495b", + "vendor/pr346/NOTICE.md": "02b59cc0542c78f409d30ce4fd546a806b606b76e185acd9aad1e32deb705008", + "vendor/pr346/README.md": "bc3ca7ac910e024742d09aa524f3adea81d7226ad1d3afaea588b102d3a31537", + "vendor/pr346/code/builders/addcomp.py": "82e5ef0c7b6cf84c53bf6039330930242c9a5c8e8ea13183b2805cf9577f7129", + "vendor/pr346/code/builders/build_v5.py": "c0867d68b863ca7d8cdd7002ffed263cbd5525fea4522267b5f640e4eff5597b", + "vendor/pr346/code/builders/decomp.py": "699c424170b41d3711da6a283f58cac824402ca373764365fd05c8e645ed07f5", + "vendor/pr346/code/builders/gather.py": "8c7d2a34fdcbe75d8ed8299e399d578b32adf44402c773fd905aa7c88e2b460d", + "vendor/pr346/code/builders/interface.py": "3b3e2fb894f871a9b6145844faaff34a05add59ae0eb8882c8feb2b914265b8a", + "vendor/pr346/code/builders/twin.py": "cfd261d82a31dd9024f1fa191eac2f5d893a7b51833b912459de46a1e9aac003", + "vendor/pr346/code/checkers/columns_h.cpp": "26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8", + "vendor/pr346/code/checkers/exactnd_h.py": "28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3", + "vendor/pr346/code/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/pr346/code/checkers/legality_h.cpp": "5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056", + "vendor/pr346/code/checkers/sub.hpp": "59c1a64f9df61fc50f47d5a78c8f9351875bf6b352db1c9d109c7c90542a4f19", + "vendor/pr346/code/checkers/verifyT.cpp": "1a5aea81aab652622e6547d901ead6aaf54fdca231da897dd99474c9f64a33bf", + "vendor/pr346/code/complex/certify_complex.py": "254ecb86795f603e32b01fbf3f3a8ce726a720057ac04579cf87da1014be7ec4", + "vendor/pr346/code/complex/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "vendor/pr346/code/complex/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "vendor/pr346/code/complex/code/complex_labels.py": "e8f7a541a712681e9052822b3be31ed7461ac2f60678ba1fb63d418e999049c6", + "vendor/pr346/code/complex/code/complex_scalars.py": "456c223b52e057d254d236780aea9ed92acdf25fe71c51b545634f43c770395b", + "vendor/pr346/code/complex/code/complex_splice.py": "3cee3f87d38fe6c15891d3aa09b36c4683a3749ced40616f996a045dc234b40e", + "vendor/pr346/code/complex/code/p10pins.py": "70645dced290c26ef6dbae707c3ef398b1400a356a5dd5503ba71f8959ea5352", + "vendor/pr346/code/complex/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr346/code/complex/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/pr346/code/complex/inputs/complex/NOTICE-PR304": "319165f41cf97f37b587c92351289db2d287ca7a90845338318086d5ff447e84", + "vendor/pr346/code/complex/inputs/complex/centre-mw/NOTICE": "c39fddd8a76cd7b14fd19e71a903eebd62e21fd7c00e76e658a190d96074020b", + "vendor/pr346/code/complex/inputs/complex/centre-mw/centre46_graph.diff": "229eea46b56d19b262d1498f489f9bca84c347e33b16553079d38c4276700280", + "vendor/pr346/code/complex/inputs/complex/centre-mw/exact_result.json": "250aa8f9037e9b6fd59291a9c98ff3c7242ec384c6129c95bf5223dc6c9e77a9", + "vendor/pr346/code/complex/inputs/complex/centre-mw/pmod46_ptc1_final.json": "d5a171674141bd2a4ac2e099c9f19dee3600482f06d4f83245a427f402c6b19b", + "vendor/pr346/code/complex/inputs/complex/centre-mw/qmod_q1_snap1.json": "cb71db4928088f0e20913dfe33df215c2a00e2bc33968d8d501f4f647cc920bc", + "vendor/pr346/code/complex/inputs/complex/centre-mw/tmod_final.json": "3ed4ffb275c3b7fc609d617a2c2b60d761306a1fe306492dc1d9ea9940c41073", + "vendor/pr346/code/complex/inputs/complex/gcert1-p10-L10f.json.gz": "50d8fb96fb3644c0307d8bb81d53811cbcd6b3151ab89dfcdc320676ede09a0c", + "vendor/pr346/code/complex/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "vendor/pr346/code/complex/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "vendor/pr346/code/complex/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "vendor/pr346/code/complex/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "vendor/pr346/code/complex/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/pr346/code/complex/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "vendor/pr346/code/complex/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "vendor/pr346/code/complex/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "vendor/pr346/code/complex/inputs/complex/source-pins.json": "0bdc84476809dda6217864632ed32056254dd7fb29001564f3dddfd73087b77e", + "vendor/pr346/code/complex/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "vendor/pr346/code/complex/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "vendor/pr346/code/complex/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "vendor/pr346/code/complex/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "vendor/pr346/code/complex/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "vendor/pr346/code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "vendor/pr346/code/complex/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "vendor/pr346/code/complex/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "vendor/pr346/code/complex/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "vendor/pr346/code/complex/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "vendor/pr346/code/complex/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/pr346/code/complex/pins-p10f.json": "8804008eb3d3cb877c597178c7ad39f50df8782f5743ca51c826724d54337688", + "vendor/pr346/code/complex/portable_complex.py": "464033e906cda0d9e002406ab816ddc3042c7ac1e61992a71111a4a5ede348c2", + "vendor/pr346/code/export_p10.py": "1161d23b459f7d981d6716073745909126d5465018cbbea7e6e6a9e4e5d68add", + "vendor/pr346/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/pr346/code/pricing/certify_bit.py": "fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394", + "vendor/pr346/code/pricing/cost.py": "d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f", + "vendor/pr346/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/pr346/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/pr346/code/pricing/prime_new.py": "7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a", + "vendor/pr346/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/pr346/code/pricing/tile_check.py": "38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae", + "vendor/pr346/code/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "vendor/pr346/data/bit/BASE-RECORDS.bin.gz": "caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430", + "vendor/pr346/data/bit/BASE-frames.json.gz": "35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f", + "vendor/pr346/data/bit/BASE-states.json.gz": "1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22", + "vendor/pr346/data/bit/FINAL-NEW-FRAMES.json": "e7fe9d0686829ad5acf7930698b3c81a866ae834422aa3c9a12057dfae627175", + "vendor/pr346/data/bit/FINAL-RECORDS.bin.gz": "fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6", + "vendor/pr346/data/bit/RECORD-SHA256SUMS": "21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2", + "vendor/pr346/data/bit/labels.json": "e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce", + "vendor/pr346/data/complex/bit_qmod_p10.json": "40ffb168466bc016bc18a2bbdde65d38b7fd1b406d8a4026f1a6e517fe153459", + "vendor/pr346/data/complex/gcert1-p10-L10f.json.gz": "50d8fb96fb3644c0307d8bb81d53811cbcd6b3151ab89dfcdc320676ede09a0c", + "vendor/pr346/data/complex/pm_p10b.json": "8d71f5004acb0ea902ad594a7d298f8d2099114e5d6d42c6357f09c44ab3ce87", + "vendor/pr346/data/complex/tmod_t2_p10.json": "4d39faeedfb5a5283a7ad34a8a18af93072e4d155d61dec6c28d7751bc2e4e04", + "vendor/pr346/producer/admit_p.py": "267e6366b14326d8ea260bfb559cd9be892d70a952453005161db66c45ff9473", + "vendor/pr346/producer/aligned_word_p.py": "90fff7260091c698f2e017086e0b1cdfc0a437e19c8044e4a2c2d75c293ff47b", + "vendor/pr346/producer/anneal_pmod.py": "af6d630bdb4a9e07e718dd4e489c26b81ba790e6b80a13e04b3b6c6917ebfd3e", + "vendor/pr346/producer/basecost.py": "637a19620c12fef9915289d49253d1496a6d02d92ce48dab5bf361fe9ed41a53", + "vendor/pr346/producer/certify_complex.py": "f2adace7e4ccb9a8ff14021c0eb317007ace16e7918461ee0dd79e32bcfbc10b", + "vendor/pr346/producer/compmap.py": "74adae25a8372f983dd9514842808404e6e01945dbdd0cbca7ac14970bf60c2b", + "vendor/pr346/producer/contract_p.py": "4dc539b4dd9a68c5ac6b515081144e280c3f9aac9e9e59aaff25bfdedde6bcb1", + "vendor/pr346/producer/gcert_emit.py": "10d2fc3f1f3d8cda5f0b07720f51b5a6fd40cfc1490d361939ff93e5470805d3", + "vendor/pr346/producer/graph_centre46.diff": "ac4a678da2000a71cfa3599e7585e7bd4b696036d02c99a572102615eb216c34", + "vendor/pr346/producer/localscan.py": "11f50f0f54af61df0dc54f8423e3bef99d4823883409921fd5e7d3a488b1daeb", + "vendor/pr346/producer/make_layer_p.py": "a51937ce3d56cb36a1471f13ba6e6eadb835fd040773a14cc7492d304020b6ba", + "vendor/pr346/producer/modules_centre_root.diff": "59f2d83ec4f7e79cc5f1074f8fbd2fb04ea92056a3afe47d686c7450f7205882", + "vendor/pr346/producer/normalize_scatter.py": "403ef1db92bafcb973857063bc96ec9ac326838b7595af642d5f11fef3350211", + "vendor/pr346/producer/run_one.sh": "1ba231cdfee7a97ea78d72250bedc01c099da4ab732a9b7ad41ccfd04ae88ee2", + "vendor/pr346/receipts/complex-admission-L10e.txt": "a87e07966af3e9234fc798133980989dd0d6bd6c18dafe1204b777946263a6d0", + "vendor/pr346/receipts/complex-admission-L10f.txt": "a87e07966af3e9234fc798133980989dd0d6bd6c18dafe1204b777946263a6d0", + "vendor/pr346/receipts/complex-guard-L10e.json": "8d52f3cffb99540a4366581fac6d91b6415c1215bdbc0c179e7bafbeeb69dd4f", + "vendor/pr346/receipts/complex-guard-L10f.json": "97307821a0b0c4cc0aa4508484000f6f77d325556ed1bd07390a18890e3badef", + "vendor/pr346/receipts/kappa-L10f.json": "5b93dee60fb047f70f0b20e3e4bb84f3992515fbc39fc9d27788cd9ae2d950a8", + "vendor/pr346/receipts/kappa.json": "9a0a9d4a5eb93fe086dcf1c91768bf22fa5303b92acee0e8b5dc667ccaa7d8d6", + "vendor/pr346/receipts/official-five-stage-columns.json": "32e291f249b4eab8d65664d10c94208fe2154bdb4a45aaff84e9e8da5295a29f", + "vendor/pr346/receipts/official-legality.json": "7e675b7720f056548c1ee9f9de523eea10e6b014ddf90b7a630fd96163acbce6", + "vendor/pr346/verify.sh": "b5dcc944d46a75eafe70f3945ada8b67ff8a2d807a1a24f5c640dab911721edd", + "vendor/pr354/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr354/MANIFEST.sha256": "454ea0eb05225e6098f77517d043990ce2740e841279eef67c71a23ecdbcb83c", + "vendor/pr354/NOTICE.md": "1ddf21090262f590b6a24cdd72c317bb4ea6aab093f42013282df2909d51a95a", + "vendor/pr354/README.md": "32c84868f673a347b19e0aeaeffd8579d66ed7eb8629b0d2b841a6ce4f472bd2", + "vendor/pr354/code/checkers/bits/stdc++.h": "51908262576163a64815def96ff39b62aef3d52daaad9c561505c4293ff88e18", + "vendor/pr354/code/checkers/columns_h.cpp": "79ab5ed7102a63a5b0b9d7342fff30ad0f7a495d05c48c6a1da876bc3f8ea565", + "vendor/pr354/code/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/pr354/code/checkers/legality_h.cpp": "6505929ed3556c221e2f447b1ddf81f1e2bcb30d8289243dde12c5df8713c030", + "vendor/pr354/code/classify.py": "82d18ebe61466c0c7df4b34bf6b0d2aae1831a195e0d0cfb2ef2f01eab956929", + "vendor/pr354/code/comp.py": "73e9df80d75c01fd94a8254ec6e0e001b10cbb394ba65fd0bf0e646154825f9d", + "vendor/pr354/code/complex_b.py": "dc6178da32c4674ef52c65515c3cb1799db66134f18f069d277db9e747b374f3", + "vendor/pr354/code/dt.py": "0be6764d8a902b287f24e136dfebe2c8d5426598d1ac555e857c9b3084ef450b", + "vendor/pr354/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/pr354/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/pr354/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/pr354/code/export_stages.py": "98fa99c15a0a5d55c00d31888e57b729e29168937beb5d03826598f7fe5ed4d1", + "vendor/pr354/code/f2.py": "c1964dc092c8ea7bc1116280bc4770f07d9e2db8534a7a42c1174099d8a3f0d7", + "vendor/pr354/code/hist.py": "d9e8698bce944388e0916e7097a81af24447a1e95c9fe8fd3412ac92fd625d29", + "vendor/pr354/code/nondeg.py": "4ff9e102b08a2e72d2a93489e744d5e836462595c6ac30269af30f856e8a1c42", + "vendor/pr354/code/price.py": "67ea6223dc833b8adc5bdbabc7ab5fbef13ee182aa2b978d3e6de604e306d3e7", + "vendor/pr354/code/snapio.py": "410bf564422d46f2bbd863bdb4ec050204132bf611b68afe4c7322809af92b06", + "vendor/pr354/code/stage_official.py": "ef2d1e1b76bf398b23c9e9ce3e838641bc640e4bbf862232365e4249e38d5f92", + "vendor/pr354/code/tile.py": "3738dfd4b4a59581d25b6b9944149678a9da19a3384f265ab68d55d5e8b40704", + "vendor/pr354/code/twin.py": "c870214b4910c81fb083af79ee2998a88ec0d19aa6ea845f35c3dba354178251", + "vendor/pr354/complex/LICENSE-wht-power-saving-lean": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/pr354/complex/NOTICE-wht-power-saving-lean": "557c9ad4660eebd14a00583736c4d12d2c45f3fc9bc148845f9f3efec72c9434", + "vendor/pr354/complex/gcert1-e8-r783.json.gz": "4b92f00fc7454b9b15e6d71a3b05062792eacca0a0ca4efee46f87827d57c8aa", + "vendor/pr354/complex/gx/gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "vendor/pr354/complex/gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/pr354/data/SHA256SUMS-final": "9635e34d9cdb45e9bcec2639bf133f5797720e2859762537dbd15f6c08575c2b", + "vendor/pr354/data/SHA256SUMS-inputs": "6a6615d88adf07d17e361ca76aafd348a9867a625bfb5dcb5426aa586d52630e", + "vendor/pr354/data/final/249-records.bin.gz": "1f44da7e27276dc4a7200f409c2fd8ab3ade5bfa8eb248cbdee39facc2a9b55c", + "vendor/pr354/data/labels.json": "e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce", + "vendor/pr354/data/parity/249-records.bin.gz": "55ab8b9cc380eb8203bddf40774524c32e208a5ed1eebf8ae0bd60eea3581e5e", + "vendor/pr354/data/parity/249-states.json.gz": "7b09a24ff094deff00190190ba896898a1cf60b7b1e49253a1d2ebe6f9d769a6", + "vendor/pr354/data/parity/frames.json.gz": "13a7712722fba7391fdf9c0cbf99100379efb5b906e32e3eef90339f15711710", + "vendor/pr354/data/staged/249-records.bin.gz": "a2c027f0570e73463b4f9a3f3989943b1a50f185365370f8d5201dbec529d349", + "vendor/pr354/data/staged/249-states.json.gz": "d75f997ba7e5b708121404b14bc6fc03ebdcfc2efc7721ff4cdf40ffc8f6dff0", + "vendor/pr354/data/staged/frames.json.gz": "722f275e1c0f833d891dd83b6f06f1853145a688f46d8f05a8945018073411af", + "vendor/pr354/stages/restore-selection.json": "f3a7c2cac2119ab77c2671709a11edd5c524998913bcb719a32d9e2a16788d43", + "vendor/pr354/stages/sink-selection.json": "ed87572f2426f120ccaf3752f00192c3f983ab846075bd25b45c57b7e5043670", + "vendor/pr354/verify.sh": "e1c4a361073c552341b8b8ea1856b8ba601bd4d0d33f9c43a2fbcf4541af9af0", + "vendor/predecessor/BANK-PROOF.md": "a5f5a7707fab610c05a182fa3f80eb05c343eacd3d7e25f3c449e7c789d503eb", + "vendor/predecessor/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/predecessor/MANIFEST.json": "dfbb1190533dd8fb52eeafc2483f7992bdc3909607097947960ffa830bf373f6", + "vendor/predecessor/NOTICE.md": "1607ec1f620c1f5188b2166539e037e43a489427a506dcf4f92934cbbdcf521c", + "vendor/predecessor/PR-STATEMENT.md": "211fcfe39971fc6de63a844f4c4a5a28539949c81c39d59f9304d0896fc1f472", + "vendor/predecessor/PROOF.md": "b1187cf1e943ddcd44e8cf096935a0406444199d464ed0df04c983fe9582371e", + "vendor/predecessor/README.md": "495768c2289929a319883c976003b9c80ca6b6cd58386693adbc7d1482b8cc9e", + "vendor/predecessor/UPSTREAM-PR234-NOTICE.md": "ce978c8dfc8a2b36eed7a53014b1a792248b22ef4cee3edd8adab825a571c429", + "vendor/predecessor/UPSTREAM-PR234-PROOF.md": "c9722b07256758cd3b307dd46689f99984c66e16c3dd934f9c34e551620bfc0f", + "vendor/predecessor/bank_check.py": "b67d1e5870239a456a732caa8e56b836d3fa472f451790700276ce706bed1da8", + "vendor/predecessor/bank_template.py": "8c131d76ebfa7788f18020d4b7a8b5dbf84c1387c6879a0046bd158cff840016", + "vendor/predecessor/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/predecessor/bitword/NOTICE-PR200": "9e82089424092c1dabc2341a09ead255633d78c90dbdc199c4336ca1c0f3bdf4", + "vendor/predecessor/bitword/README.md": "5c5100382411b8a09ed3f485e2e2fe1ce925e51df997d475dcdf9976084da84a", + "vendor/predecessor/bitword/bit/base_word.py": "9fe3a81b7561d2b09c086f63fac4626e88a32369ef8bc5579c94878de1218a89", + "vendor/predecessor/bitword/bit/word.py": "88554981690cb43c4286fd962dddf0f20c58cf0c6cd58f0b8081ac88b16531ff", + "vendor/predecessor/bitword/producer/data/arcs_p10.json": "8d4d1339ff69150d0892f30d66fb5108802c633c69a8e1f511bbfd5a2ed78a7d", + "vendor/predecessor/bitword/producer/data/cube_orient_p10.json": "cb0c503be9e4a9696f01a7f18b92383e8be118adca29a19b43a472489ffbc0af", + "vendor/predecessor/bitword/producer/data/local_design_p10.json": "374803215ffb55e7c77c816b7c53e8e031cb6850d4d369f77b3528a9365d1b9d", + "vendor/predecessor/bitword/producer/data/pm_p10.json": "8d71f5004acb0ea902ad594a7d298f8d2099114e5d6d42c6357f09c44ab3ce87", + "vendor/predecessor/bitword/producer/data/qmod_p10.json": "40ffb168466bc016bc18a2bbdde65d38b7fd1b406d8a4026f1a6e517fe153459", + "vendor/predecessor/bitword/producer/descent.py": "873fdf8d1281e034a238e09968ee66d77dcc236616305893c1aaee2b516299ff", + "vendor/predecessor/bitword/producer/make_physical.py": "854640404e8fc5c7d7b1089e1291ee98c7c21056f6d1baae04a57ea6928e8db9", + "vendor/predecessor/bitword/producer/paired_cube_bit_word.py": "ca512704f85dcce0a58a4da64c141b9bc0a74ffa3743ed7d2b16e9e8074b22e1", + "vendor/predecessor/bitword/producer/regenerate.py": "2929047b40a3a2dcbadd7df95c8cba0a7fc68abb705f878b6767a41f90fac02e", + "vendor/predecessor/bitword/references/pr168-v4/SOURCE.json": "21a412177c9309d89472aabf4c67618d7a546811f7e68a5904304ae46a98d27c", + "vendor/predecessor/bitword/references/pr168-v4/research/paired-cube-bit/check_paired_cube_bit.py": "4d7c86cd999a1519e0dfb6dcf33a8f26e442a353c3665a0f06881216a260fbf3", + "vendor/predecessor/bitword/selected/bit/frames_p10.json.gz": "fec07e983f81459c45747dfaa4eecabc3429e84d4685f385771904dee4c4fbc0", + "vendor/predecessor/bitword/selected/bit/graph_p10.json": "4a43116c8d154e61be795ca76b3a550c9f5bb579a5fe3fb88a09279512aab174", + "vendor/predecessor/bitword/selected/bit/kchron_p10.json": "1ce62b85b496cbec17fe9eb9e81152126cb90708577cc2e3bcece9b2796ef31c", + "vendor/predecessor/bitword/selected/bit/profile_p10.json": "177ff70a322f152ccc6c12471aced7a207062e445f9f64c7d3bd96e6f18c6f63", + "vendor/predecessor/bitword/selected/bit/word_p10.json.gz": "601da0e6a67715011a4bbc44f6977f13625c5833d4d40443c10b0d5a9da1896d", + "vendor/predecessor/code/complex_basis.py": "52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8", + "vendor/predecessor/code/complex_gx.py": "ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2", + "vendor/predecessor/code/complex_labels.py": "0c288a7923ff5923f8b3a1bb425b17679633e02284a8c32898bbb2fc24ca131a", + "vendor/predecessor/code/complex_scalars.py": "87b19c643205f7d0ebab7fefb95e5aba31fefb3129b998d4b0e5070031f4898e", + "vendor/predecessor/code/complex_splice.py": "b1b4847652a9968d7afb8dd529bc371b656afa240f2e393f03c187dca250c4ce", + "vendor/predecessor/code/geometry527.py": "734cb349cc109fc7fe6b074ecb77ff80544f630dee331000f4d0ab79e77ac4f3", + "vendor/predecessor/code/global_lowering.py": "53b7a45006893218e6eb7fed026ef2e51809f8f04ef25a07cf4e1ca563de30fa", + "vendor/predecessor/code/physical527.py": "4d4bf47ee083d3864f76907428f4e813a147f7ea6ab0b8cd1536adcd2c469395", + "vendor/predecessor/discovery/REPIN.md": "7f1f381c640c0db2c3805973e8d17c81a9fb007eb4397d072b64928e6a177285", + "vendor/predecessor/discovery/repin.py": "8bd21ad00c07d2f9cbde3a882721882d12e0e50851c720799b449599f205654f", + "vendor/predecessor/finite_check.py": "7383f1cea130244e5b35fc8c707d132091b5c81943f7e61fd4c9a778c77344ee", + "vendor/predecessor/inputs/complex/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/predecessor/inputs/complex/NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/predecessor/inputs/complex/NOTICE-PR304": "319165f41cf97f37b587c92351289db2d287ca7a90845338318086d5ff447e84", + "vendor/predecessor/inputs/complex/centre-mw/NOTICE": "c39fddd8a76cd7b14fd19e71a903eebd62e21fd7c00e76e658a190d96074020b", + "vendor/predecessor/inputs/complex/centre-mw/centre46_graph.diff": "229eea46b56d19b262d1498f489f9bca84c347e33b16553079d38c4276700280", + "vendor/predecessor/inputs/complex/centre-mw/exact_result.json": "250aa8f9037e9b6fd59291a9c98ff3c7242ec384c6129c95bf5223dc6c9e77a9", + "vendor/predecessor/inputs/complex/centre-mw/pmod46_ptc1_final.json": "d5a171674141bd2a4ac2e099c9f19dee3600482f06d4f83245a427f402c6b19b", + "vendor/predecessor/inputs/complex/centre-mw/qmod_q1_snap1.json": "cb71db4928088f0e20913dfe33df215c2a00e2bc33968d8d501f4f647cc920bc", + "vendor/predecessor/inputs/complex/centre-mw/tmod_final.json": "3ed4ffb275c3b7fc609d617a2c2b60d761306a1fe306492dc1d9ea9940c41073", + "vendor/predecessor/inputs/complex/gcert1-p11-cmod-centre-mw-flow.json.gz": "bb0499ab342aee3594904fc1cd72b9ff496cdb315d0840f4cdd5ba64ef794d34", + "vendor/predecessor/inputs/complex/retained/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46", + "vendor/predecessor/inputs/complex/retained/compact-control-layout.tex": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87", + "vendor/predecessor/inputs/complex/retained/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "vendor/predecessor/inputs/complex/retained/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "vendor/predecessor/inputs/complex/retained/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/predecessor/inputs/complex/retained/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "vendor/predecessor/inputs/complex/retained/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "vendor/predecessor/inputs/complex/retained/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "vendor/predecessor/inputs/complex/source-pins.json": "c32bb00a73aa82043ee9727d9d7eda9aedb6518e55cc638df53cf6611e54e146", + "vendor/predecessor/inputs/complex/sources/Work__Bridge__Cert.lean": "5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980", + "vendor/predecessor/inputs/complex/sources/Work__Bridge__Net.lean": "cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0", + "vendor/predecessor/inputs/complex/sources/Work__Carrier__Live.lean": "6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0", + "vendor/predecessor/inputs/complex/sources/Work__Carrier__Phases.lean": "71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812", + "vendor/predecessor/inputs/complex/sources/Work__Fourier__Main.lean": "2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__Geom.lean": "c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__InvThm.lean": "ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__NetCert.lean": "22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__NetDef.lean": "6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__NetStage.lean": "c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__Phased.lean": "0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Chain__WinB.lean": "c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean": "cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__Glue.lean": "d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean": "9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__P193Cert.lean": "d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__P193Price.lean": "0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean": "479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean": "6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__Raw.lean": "aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66", + "vendor/predecessor/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean": "45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169", + "vendor/predecessor/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean": "feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7", + "vendor/predecessor/inputs/complex/sources/Work__GFrame__Engine__Letters.lean": "34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09", + "vendor/predecessor/inputs/complex/sources/Work__GFrame__Engine__Level.lean": "80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0", + "vendor/predecessor/inputs/complex/sources/tools__gx__ORIGIN.md": "6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b", + "vendor/predecessor/inputs/complex/sources/tools__gx__gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "vendor/predecessor/inputs/complex/sources/tools__gx__gxbind.py": "9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835", + "vendor/predecessor/inputs/complex/sources/tools__gx__gxconv.py": "dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2", + "vendor/predecessor/inputs/complex/sources/tools__gx__gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "vendor/predecessor/math_check.py": "e9372d61a9d7841bbf3a61a44603627f2a7703b6304106640a83f26c8f899058", + "vendor/predecessor/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/predecessor/notices/PR210-coordinated-crossover-NOTICE": "9fc5561c0995892dbdde777c713899486920c32d3562392f5f72377a4953bf98", + "vendor/predecessor/notices/PR230-NOTICE": "7dfbad087ee49b74fd5075d517eaa263c5dd3d4fbd4c69bfba34ee1cb55e837f", + "vendor/predecessor/notices/PR230-PROVENANCE.json": "19957e28a8ad26281bfe8bfaf8ae16191be53e729a8870a6154671b3384959d4", + "vendor/predecessor/notices/README.md": "d1fcf4e4209d5966282ac8202cf461bd575119a7aaf2ca64e8746810fe5259b8", + "vendor/predecessor/notices/base-bit-PR200-PR202-NOTICE": "c9850418622aea8d1382a230306c940947b5da818f4854b4b272ed60cf239f6c", + "vendor/predecessor/notices/source527-loader-NOTICE.md": "ee632728cc4d89565292d288f8289f483ac794b5d02cc6e42c2b2c43c43ff1d8", + "vendor/predecessor/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/predecessor/parity_transform.py": "e068874694fc15135a0950b7361e537f48688d9ac9f0a05c2372f1deb813d085", + "vendor/predecessor/portable_bit.py": "368ef679009f7272fffd30fe18aeb12722e00612e040aa6eb2a4dbd019486a5a", + "vendor/predecessor/portable_complex.py": "a09d19a4efa54c0646b06ccb5393e3f1eb928b2e002738bb2a2af2a2ba7efb3a", + "vendor/predecessor/prepare.py": "c1a215713f47b954c28a3f0d48490a055fb75f6af31a0e6b5248802d6951a09b", + "vendor/predecessor/prime_check.py": "045831f41b9f4208538ba4b17c9354c125acb33b5f538f7a30f4813c2948c57c", + "vendor/predecessor/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/predecessor/proof/FINITE_BIT_ACCOUNTING.md": "602923520af184670170bf159fde7b4c72e79a72570eddd7746b7c97bc51fc5b", + "vendor/predecessor/proof/INTEGRATED_PROOF.md": "cff22391e71a50bad27a1e832d5c0a2c8b2446df55adb1297c8b1485b3761257", + "vendor/predecessor/proof/PARITY-CONTRACT.md": "a9246be656e31f1a21d5ec714e002f51be0aa07c36e1528066a25b2c7a02db91", + "vendor/predecessor/proof/README.md": "435c699dc07400366b84fe43d981cd2f6c95a4837e636fff8fe6a25897d853c4", + "vendor/predecessor/proof/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "vendor/predecessor/proof/primary/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "vendor/predecessor/proof/primary/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/predecessor/proof/primary/PROVENANCE.md": "dd9054c58aa92c44b0ef5f691ad4dc52b8ead2f20a9843d4399d6c300d616023", + "vendor/predecessor/proof/primary/UPSTREAM-README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "vendor/predecessor/proof/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "vendor/predecessor/proof/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "vendor/predecessor/raw_ledger.py": "782c2aef0b6225b0e99f73abbc98681d21125c17c024ab0b8a0e4d0382182ef0", + "vendor/predecessor/requirements.txt": "25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc", + "vendor/predecessor/scalar/word.py": "e675d4eb9d90ff0b44279fae0b46f1a8b39f65421cc38454b70a6b75d0e10b42", + "vendor/predecessor/scalar_check.py": "520c4549de9200811dd594d15cdf73de28f287b04778965491b2c5b3f6d6ed5a", + "vendor/predecessor/verify.py": "b0d2a2cf1e348545dbace3c5f3e98b1c91c1f7773969decdc76ca4240c174599", + "vendor/predecessor/virtual_check.py": "ec952d99c151e6e336631210e598d58478293491ca01842fd4c9d0a4b57b4e5a", + "vendor/predecessor/word-pins.json": "f3a21b85364d601f9c561dc8739de0d081ddea181416b182d837456dd789300c", + "vendor/predecessor/word_pins.py": "3cc2662630af62aaabb6966f03b5d01a2f06a5f3490c6979a3e54daf550958b4", + "verify.py": "e72893dfe3b25d4190da46dc81c47eb9a196fb67946b105dd1d54da639f083b6" + } +} diff --git a/research/w3-staged354-signed20-native/NOTICE.md b/research/w3-staged354-signed20-native/NOTICE.md new file mode 100644 index 0000000000..8d06cca5fb --- /dev/null +++ b/research/w3-staged354-signed20-native/NOTICE.md @@ -0,0 +1,58 @@ +# PR354 native integration and provenance + +Chafik Boukhalfa (chafreaky), with substantial Anthropic Claude assistance, +supplied PR354's four-stage/Design T/twin composition and reimplementation, +head 3c59b8c8fc8521e8ba4ed87c6c4368457b13c485. The complete unmodified +package, manifest, README, notices and license are retained under vendor/pr354. +His PR329 stage package, c6b1a28fcc3cf00c9bb129e184cc4d95035c7892, is retained +unmodified under vendor/pr329. Stage mechanisms descend from #268/#273 +(eumemic), #280/#283/#287/#295 (including Rohan Arun's descent), and #320. +The exact four-stage adapter omits the kernel and reorder stages, as #354 +requires. It does not claim that #329's complete verifier was run. + +The source adapter, complete native admission, physical-map binding, strict +scalar wrapper, corrected E8 invoice, finite assembly and independent audits +were prepared with substantial OpenAI Codex assistance under Apache-2.0. +All original author and AI attributions remain intact. The following prior +integration notice is retained as its provenance, not a claim that the old +bit word is the new final construction. + +# Attribution and scope + +The complete native bit admission, dormant-role compaction, corrected odd- +dimensional E8 invoice, integration and independent audits were prepared +with substantial OpenAI Codex assistance, Apache-2.0. + +PR352 at 04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2: DaysSky, assisted +with Anthropic Claude. Its generalized scatter/scalar/splice checks and +E8 Lean-data binding are preserved in the supplier with exact upstream bytes. + +Jacob Sussman supplied the E8 unit, Lean data/theorem, generators and independent +replay in wht-power-saving-lean at 9c94857bbaee886f8649edee0bc2d3c738f9555e. +His license and notice remain intact. The new work does not claim authorship +of E8, the upstream theorem, or a new local Lean kernel build. All community +devices and contributions credited by Sussman and PR352 remain credited. + +Design T/twins originate with utcorvusvolat-dotcom's PR310. Louis Harrison, +assisted substantially by Anthropic Claude, supplied PR346's h=20 port and +module combination at 11b4de5ff8ed5fccf55d4af1043358d257308e8e. Its available +package and original notices are under vendor/pr346; two names missing from +its historical manifest are never treated as successful replay evidence. + +DreamingOfClouds, assisted substantially by Anthropic Claude, supplied the +PR325 bit source at 0eca9340a3df6141b8e71a41638c3937b3522888 and PR327. +The full unmodified PR325 package and notices remain under vendor/predecessor. + +The native admission engines descend from eumemic's PR320/PR322/PR333/PR351, +prepared with substantial OpenAI Codex assistance. They retain PR266's cohort +checkers, PR315's moment/outer engines, and PR321 arithmetic primitives by +Rohan Arun. The complex checker lineage includes Chafik Boukhalfa and the +PR315/PR304/PR256/PR233/PR202/PR200/PR194/PR184 contributors named in the +retained source notices. Credits imply neither endorsement nor independent +review by the credited authors. + +The twenty generalized rank-three twin entrances, signed negative-entry/positive-exit +compensation, deterministic source transforms and independent exact integer +local scalar operator comparison were prepared with substantial OpenAI Codex +assistance. They extend the credited PR310/PR346 twin pattern. The original, +intermediate and final seven-file native exports remain separately bound. diff --git a/research/w3-staged354-signed20-native/README.md b/research/w3-staged354-signed20-native/README.md new file mode 100644 index 0000000000..d3c3fd270d --- /dev/null +++ b/research/w3-staged354-signed20-native/README.md @@ -0,0 +1,102 @@ +κ = 8.03161884970454053300282e-4 + +Exact κ: `401580942485227026650141/500000000000000000000000000`. + +This admits twenty signed twin transformations of PR354's staged Design +T/twin word and combines the result with the fully replayed, parity-correct +E8 supplier from PR352. Eight finite bootstrap levels refine the native +κ=4015809407857/5000000000000000. The bit side binds. All published PR heads +and claims remain frozen; this package is a separate construction. + +The source chain is explicit. The unmodified pinned PR325 verifier runs +first. PR346's exporter then rebuilds all three parity snapshot files twice +byte for byte. A derived PR354 exporter uses unmodified PR329 source modules +with exactly four stages: descent, target, restore and sink. The restore and +sink selections come from PR354 and are freshly screened by the original +transforms. All six parity/staged snapshot files must equal PR354's pinned +compressed inputs. The sink stage rederives the original physical-role map. +The complete PR329 verifier is not run: its published kernel/reorder stages +are omitted, as PR354 specifies. The admitted base remains the exact PR325 +source verified in this replay. + +PR354's original Design T, completion and twin scripts then reproduce its +shipped final word. Their output metadata retains an old record hash; that +field is recorded as historical metadata and never used as the actual word +identity. The final literal bytes are hashed afresh. A control runs the same +three scripts on the unstaged parity word and must reproduce PR346's final +word `c6a9311acfcf85f4a5775ed0187e31f84531614bb08434ef887ae1e63dda99c4`. +A strict wrapper asserts every result of PR354's scalar replay. + +The source word has 10,010 registers after ten terminal sinks. The compactor +removes exactly 480 FULL/FULL helpers occurring in no event and composes the +two physical-role maps, including the COPY slot. Inverse relabeling returns +every final source event byte. The resulting word has 9,530 registers, +7,610 arbitrary dirty helpers, 406,312 events and 358,192 ADDs. Its hash is +`2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6`. + +The original seven native files remain separately bound as candidate-source +with ORIGINAL-EXPORT.json. Two deterministic transformations first select +18 disjoint helper pairs, then add two further pairs. The intermediate seven +files remain bound as candidate-signed18; the final seven as candidate. +The intermediate word is +8e9996b6819c1129b2507e3915842507d9dbe28077c7505bf57ebeaa6e53777e; +the final word is +6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330. +The transformations use negative entrances and positive exits, add two +frame charts, remove 80 zero-frame ADDs and save 20 paid ranks. The final +word has 406,292 events and 358,152 ADDs. + +The two additional pairs have earlier proper-frame reads, so a simple +single-consumer template does not establish equivalence. A mandatory exact +integer replay compares all 9,530 independent input columns and 9,531 output +rows, including arbitrary dirty helpers and COPY/ERASE. It rejects six +controls: missing entry, missing exit and wrong entry sign for each of the +18-pair and 2-pair groups. MOVE operators are ignored in this local scalar +comparison. Recursive frame semantics, geometry and decoder/recovery retain +their separate admission checks and inherited interfaces. + +The native pipeline checks all 11,450 formal F2 columns, forward/inverse dirty +restoration, COPY lifetimes, both reflected frame ledgers and their complete +paid profiles. It binds 1,002 new frame charts, 3,340 changed projectors and +27,774 basis/annihilator minor witnesses. At T=300, all 11,415,000 helper, +replica and stage assignments are enumerated. Literal stock is 3,135,900, +with 396,780 width-100 banks per stage, selector charge 1,806,128,697,000 and +complete finite coefficient 120,718,938,573,985,001. All 47 strict outer +constraints and rejection of the adjacent κ grid point are required. + +The full E8 supplier is unchanged from the separately frozen corrected +integration. Every replay checks actual scalar schedules and temporary +lifetimes, dirty restoration, both reflected splices, the complete paid +profile, Sussman's gx and gxcore, both rational moments and the finite +invoice. The scalar dirty audit specializes recursive frame operators to +identity; frame incidences and child ranks are separately checked. +It admits b=876248285600677/10^18. The odd-dimensional group order is +|O(45,2)|=|Sp(44,2)|, yielding physical row coefficient 11,162 below the +retained 20,161 ceiling. Seven oversized invoice integers use exact decimal +strings, with unchanged integer values. + +Run in a fresh output directory: + + python3 -B verify.py --output /tmp/w3-staged354-signed20-proof + +Python 3.11+, requirements.txt, C++17 and Boost headers are required. +Use --boost-include /path/to/boost as needed. All 24 stages must finish. +The wrapper uses no network and rejects changed, missing or extra sources. +A successful complete replay writes CERTIFICATE.json and VERIFICATION.json. +Until such replays complete, this README is a proposed construction claim. + +Every complex replay regenerates 24 Lean modules and one comparator config +byte for byte and runs Sussman's independent E8 replay. This is source-data +binding, not a local Lean kernel build or module-to-gcert regeneration. The +upstream WHT theorem uses 8762479/10^10; the finer rational b is independently +recomputed. No new unconditional multiplication theorem is claimed. + +This is a conditional sufficient construction under the inherited all-size +compiler, common-ancestor charts, selectors, restored rows, routing, prime +supply, precision/recovery, complex-symbolic and analytic interfaces. +The native numerical operator replay is over F2. Integer signed inverse and +decoder/recovery semantics remain inherited. The 127-bit prime is only an +eventual lower threshold in the growing-prime regime. + +Prepared with substantial OpenAI Codex assistance. Full attribution and +licenses are retained in NOTICE.md and all vendored upstream packages. diff --git a/research/w3-staged354-signed20-native/SOURCE.json b/research/w3-staged354-signed20-native/SOURCE.json new file mode 100644 index 0000000000..ef3e9a8327 --- /dev/null +++ b/research/w3-staged354-signed20-native/SOURCE.json @@ -0,0 +1,120 @@ +{ + "base_kappa": "384842019691667/500000000000000000", + "baseline_wrapper_manifest_sha256": "a1d66cb46ec2d0354797d1b3bdc65451c4c7f8dfb07afb42ebc073492dd117df", + "complex_binds": false, + "complex_reserve": { + "candidate_sha256": "3594f19c4d01cf11fb930c5c61baeed399620acbc5b94096b16bcacb23997dd3", + "coarse": "876248285600677/1000000000000000000", + "declarative_source": true, + "head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "lean_data_regeneration_claim": true, + "manifest_sha256": "3d0d867b84b86dd9f0850cedce9a6de83f2313a604bdef58f7235af30f94bcbd", + "parity_corrected_complete_invoice": true, + "producer_regeneration_claim": false, + "source_description": "Pinned explicit E8 gcert; 25 Lean data/configuration files regenerated; no module-to-gcert producer regeneration or local Lean kernel rebuild claimed.", + "upstream_e8_head": "9c94857bbaee886f8649edee0bc2d3c738f9555e", + "upstream_lean_rebuilt": false, + "verification_status": "PASS_PORTABLE_E8_CORRECTED_COMPLEX_SUPPLIER" + }, + "expected": { + "adds": 358152, + "banks_per_stage": 396780, + "bit_coarse": "200951867372647/250000000000000000", + "bootstrap_levels": 8, + "candidate_files": { + "249-states.json": "7eb8e23b858a525754eea3075b3a149bf69a69bb6149872cbd872a2c2f3883f9", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "COHORT249-INITIAL.json": "1854658f58bc9de5642fbdf9538e93c35ce7a14cef6b04d02708feb25d343232", + "COHORT249-RECORDS.bin": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb" + }, + "changed_helper_endpoints": 740, + "changed_projector_charts": 3340, + "coefficient": 120718938573985001, + "columns": 11450, + "frames": 13887, + "helpers": 7610, + "literal_stock": 3135900, + "max_new_chart_factors": 131, + "new_frame_charts": 1002, + "normalized_stock": 627180, + "normalizer_factor_ceiling": 787, + "paid_calls": 46004, + "rank_mass": 169100, + "records": 406292, + "selector_charge": 1806128697000, + "units": 358152 + }, + "final_word_sha256": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "intermediate_word_sha256": "8e9996b6819c1129b2507e3915842507d9dbe28077c7505bf57ebeaa6e53777e", + "kappa": "401580942485227026650141/500000000000000000000000000", + "native_kappa": "4015809407857/5000000000000000", + "physical_replicas": 300, + "predecessor": { + "head": "0eca9340a3df6141b8e71a41638c3937b3522888", + "manifest_sha256": "dfbb1190533dd8fb52eeafc2483f7992bdc3909607097947960ffa830bf373f6" + }, + "schema": "source-bound-w3-staged354-e8-signed20-native/1", + "signed_twin_transform": { + "code_sha256": { + "audit_signed_twenty354.py": "2f956494b71cec06e3591135328a29e453cc2f1d1cf6e272eae9a4499bb5ac9e", + "generalized_twin_signed354.py": "74bcec2f8ae32345cb375a519c892dee3bd0bb26596ee4a9b5715a2f63cc2a70", + "generalized_twin_two_more354.py": "aec59caef2c0ddf0e578fe0209c59083e4224f83ed175a576c0c739fa2e4430e" + }, + "files": { + "final": { + "249-states.json": "7eb8e23b858a525754eea3075b3a149bf69a69bb6149872cbd872a2c2f3883f9", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "COHORT249-INITIAL.json": "1854658f58bc9de5642fbdf9538e93c35ce7a14cef6b04d02708feb25d343232", + "COHORT249-RECORDS.bin": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb" + }, + "intermediate": { + "249-states.json": "077a3e16a361fe1cd650d04535624fb306f7bc5dc5718ef30996b6459bc8b0a6", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "COHORT249-INITIAL.json": "ce065ff1abc11517ee02eeda8e14aa22055df06eae5c431def7a245180c178be", + "COHORT249-RECORDS.bin": "8e9996b6819c1129b2507e3915842507d9dbe28077c7505bf57ebeaa6e53777e", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb" + }, + "source": { + "249-states.json": "79de66272d4092010cf7cd342fcb4b6c50268f92c3e3cb844194758f9fc433f9", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "1550d26e4569e400817d1c1de4dc30fd0a6458bb8d41597c5f80a7aa7d1e9109", + "COHORT249-INITIAL.json": "3c90f37c23a092855baf4def0ca489c09b11ecbfed366888d096ea326badae14", + "COHORT249-RECORDS.bin": "2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "583303099bceb6468167f71adf74fd86ee56b3646bd6af3700f160b2fdef9691" + } + }, + "intermediate_records": 406294, + "new_frames": 2, + "removed_zero_frame_additions": 80, + "scope": "Original PR354 compact/export receipts remain bound to 2aa5. Two fresh deterministic transforms produce intermediate 8e99 and final 6e0f. The full exact-Z comparison proves local scalar operator preservation with MOVE operators ignored; it is not an integer multiplication proof or proof of recursive frame semantics. Two additional twins have earlier proper-frame reads, so the simple single-consumer template is insufficient.", + "selected_twins": 20, + "source_frames": 13885, + "source_new_frames": 1000, + "source_records": 406312 + }, + "source_compacted_word_sha256": "2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6", + "source_parity_sha256": "f1933dbf6f82303bb0cc6e42d4e292a652d99fb44286648452db374178e60c6f", + "staged_source": { + "parity_control_word": "c6a9311acfcf85f4a5775ed0187e31f84531614bb08434ef887ae1e63dda99c4", + "pr329_head": "c6b1a28fcc3cf00c9bb129e184cc4d95035c7892", + "pr329_manifest": "c9ccfca59839057ee98a04e9882aee8c1f46c196a0ae7d16d7d62f91d5caa877", + "pr354_head": "3c59b8c8fc8521e8ba4ed87c6c4368457b13c485", + "pr354_manifest": "454ea0eb05225e6098f77517d043990ce2740e841279eef67c71a23ecdbcb83c", + "stages": [ + "descent", + "target", + "restore", + "sink" + ] + }, + "upstream_final_word_sha256": "f5fca11b5855a5a575a9408b1cde69d152d03432ce3e8e375d6b20b39baf3434" +} diff --git a/research/w3-staged354-signed20-native/code/admit_geometry.py b/research/w3-staged354-signed20-native/code/admit_geometry.py new file mode 100644 index 0000000000..6c7ceb5554 --- /dev/null +++ b/research/w3-staged354-signed20-native/code/admit_geometry.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +"""Bind exact new-frame and changed-projector audits to the complete word.""" +import sys +if not __debug__:raise SystemExit('Assertions required') +sys.dont_write_bytecode=True +from pathlib import Path +from fractions import Fraction as Q +import argparse,json,hashlib,struct + +def read(p):return json.loads(Path(p).read_text()) +def rank_mod(rows): + if not rows:return 0 + p=2147483647;M=[[x%p for x in r] for r in rows];r=0 + for c in range(len(M[0])): + pivot=next((i for i in range(r,len(M)) if M[i][c]),None) + if pivot is None:continue + M[r],M[pivot]=M[pivot],M[r];iv=pow(M[r][c],-1,p);M[r]=[(x*iv)%p for x in M[r]] + for i in range(r+1,len(M)): + if M[i][c]: + k=M[i][c];M[i]=[(a-k*b)%p for a,b in zip(M[i],M[r])] + r+=1 + if r==len(M):break + return r + +def frame(f): + d=f['dim'];B=f['B'];A=f['A'];assert len(B)==d and len(A)==20-d + assert all(len(r)==20 and all(isinstance(x,int) for x in r) for r in B+A) + # Full rank modulo a prime proves full rank over Q; exact orthogonality then proves A=B-perp. + assert rank_mod(B)==d and rank_mod(A)==20-d + assert all(sum(x*y for x,y in zip(a,b))==0 for a in A for b in B) + +def run(base,candidate,bank_dir,charts_dir,output): + base,candidate,bank_dir,charts_dir=map(Path,(base,candidate,bank_dir,charts_dir));nf=read(candidate/'COHORT249-FRAMES.json') + for f in nf.values():frame(f) + negative=[] + if nf: + f=json.loads(json.dumps(next(iter(nf.values())))) + if f['A']:f['A'][0]=[0]*20 + else:f['B'][0]=[0]*20 + try:frame(f) + except AssertionError:negative.append('zero basis or annihilator row rejected') + else:raise AssertionError('Bad frame accepted') + old=read(base/'249-states.json');ini=read(candidate/'COHORT249-INITIAL.json');fin=read(candidate/'COHORT249-FINAL.json');fs=read(base/'frames.json')['frames'];fs.update(nf) + def pairs(path):return {(b,c,r) for op,a,b,c,r,z in struct.iter_unpack('<6i',path.read_bytes()) if op==0 and r} + required=pairs(candidate/'COHORT249-RECORDS.bin')-pairs(base/'COHORT249-RECORDS.bin') + endpoints=0 + for i in range(2*old["v"],old["n"]): + role=str(i) + if ini[role]!=old['initial'][role] or fin[role]!=old['final'][role]: + before,after=ini[role],fin[role];required.add((before,after,fs[str(after)]['dim']-fs[str(before)]['dim']));endpoints+=1 + audit=read(charts_dir/'COMBINED-CHART-AUDIT.json');charts=read(charts_dir/'COMBINED-CHARTS.json');bank=read(bank_dir/'BANK-REVIEW.json');full=read(bank_dir/'BANK-CHARTS.json') + assert {(x['before'],x['after'],x['rank']) for x in charts}==required and len(charts)==len(required) + assert audit['retired_endpoints']==endpoints and audit['unique_projectors_checked']==len(required) + assert audit['all_entries_below_two_to_80'] and audit['max_factors']<=548 + assert int(audit['max_numerator'])<2**80 and int(audit['max_denominator'])<2**80 + assert {x['frame'] for x in full}=={int(k) for k in nf} and len(full)==len(nf) + assert bank['new_exact_charts']==len(nf) and bank['max_new_chart_factors']<=548 + assert bank['actual_role_replica_stage_assignments']==5*bank['physical_replicas']*bank['actual_helper_roles'] and bank['actual_helper_roles']==old['n']-2*old['v']-bank['deleted_inert_roles'] + assert bank['literal_stock']==5*bank['normalized_stock'] + bank['new_frame_chart_max']=bank['max_new_chart_factors'];bank['max_new_chart_factors']=max(bank['max_new_chart_factors'],audit['max_factors']) + assert bank['max_new_chart_factors']+99+100<=bank['normalizer_factor_ceiling']==787 + bank.update(inherited_only_frames=not bool(nf),changed_projector_charts=len(required),changed_helper_endpoints=endpoints,all_new_ordinary_annihilators_full_rank=True,geometry_controls=negative) + bank['geometry_input_hashes']={str(p.resolve()):hashlib.sha256(p.read_bytes()).hexdigest() for p in [candidate/'COHORT249-RECORDS.bin',candidate/'COHORT249-FRAMES.json',charts_dir/'COMBINED-CHART-AUDIT.json',charts_dir/'COMBINED-CHARTS.json',bank_dir/'BANK-REVIEW.json',bank_dir/'BANK-CHARTS.json']} + Path(output).write_text(json.dumps(bank,sort_keys=True,indent=2)+'\n');print('PASS all new frame ranks, exact annihilators and',len(required),'changed charts',flush=True) +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--base',required=True);ap.add_argument('--candidate',required=True);ap.add_argument('--bank',required=True);ap.add_argument('--charts',required=True);ap.add_argument('--output',required=True);a=ap.parse_args();run(a.base,a.candidate,a.bank,a.charts,a.output) diff --git a/research/w3-staged354-signed20-native/code/audit_signed_twenty354.py b/research/w3-staged354-signed20-native/code/audit_signed_twenty354.py new file mode 100644 index 0000000000..69ab8d1e3c --- /dev/null +++ b/research/w3-staged354-signed20-native/code/audit_signed_twenty354.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +"""Independent exact integer operator comparison for all twenty signed generalized twin changes. +All physical registers start as independent formal integer coordinates. No modular reductions. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" +import sys +if not __debug__:raise SystemExit('Assertions required') +sys.dont_write_bytecode=True +from pathlib import Path +import argparse,json,struct,time,hashlib +sha=lambda b:hashlib.sha256(b).hexdigest() +def replay(events,n): + V=[{i:1}for i in range(n)]+[{}];open_source=None + for op,a,b,c,f,z in events: + if op==0:continue + if op==1: + assert 0<=a0;tests.append(dict(name=kind,entry_category=entrycat,record=k,changed_rows=count,rejected=True)) + result=dict(status='PASS_EXACT_INTEGER_PR354_SIGNED_TWENTY_TWIN_OPERATOR_EQUIVALENCE',source_sha256=sha(s),candidate_sha256=sha(c),independent_integer_input_columns=n,output_rows_compared=n+1,all_output_rows_equal=True,source_nonzero_coefficients=sum(map(len,original)),max_abs_coefficient=max(abs(x)for row in original for x in row.values()),mutation_controls=tests,seconds=time.monotonic()-start,scope='Full local signed scalar operators agree exactly over Z, including arbitrary helper variables, source/target variables and COPY/ERASE. This preserves the predecessor integer lift; the intended transform remains its inherited F2 theorem. Frames, precision, paid calls and finite banks are separately audited.') + output.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n');print('PASS exact integer generalized twin operator and six controls',flush=True) +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--source',required=True);p.add_argument('--candidate',required=True);p.add_argument('--output',required=True);a=p.parse_args();run(a.source,a.candidate,a.output) diff --git a/research/w3-staged354-signed20-native/code/banks.cpp b/research/w3-staged354-signed20-native/code/banks.cpp new file mode 100644 index 0000000000..41c6432c87 --- /dev/null +++ b/research/w3-staged354-signed20-native/code/banks.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using Z=boost::multiprecision::cpp_int;using M=vector>; +J ld(string p){ifstream f(p);if(!f)throw runtime_error("missing "+p);J j;f>>j;return j;} +Q rat(J j){return j.is_string()?Q(j.get()):Q(j.get());}M eye(int n){M a(n,vector(n));for(int i=0;i(a.size()));for(int i=0;i(b[0].size()));for(int i=0;i=(Z(1)<<80)||d>=(Z(1)<<80))throw runtime_error("finite prime guard exceeded");} +M inverse(M a,int &ops,Q &det){int n=a.size();M b=eye(n);det=1;ops=0;for(int k=0;kpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;iw;int count;}; +int main(int ac,char**av){if(ac!=8)throw runtime_error("args: baseline_export initial_json new_frames_json output_dir label tiling_json final_json");auto tiling=ld(av[6]);string inp=av[1],out=av[4];auto st=ld(inp+"/249-states.json"),fj=ld(inp+"/frames.json")["frames"],ini=ld(av[2]),nf=ld(av[3]),fin=ld(av[7]);int n=st["n"],v=st["v"],h=20,m=100,T=300;if(tiling["physical_replicas"]!=T)throw runtime_error("replica binding");mapdims;for(auto it=fj.begin();it!=fj.end();it++)dims[stoi(it.key())]=it.value()["dim"];for(auto it=nf.begin();it!=nf.end();it++)dims[stoi(it.key())]=it.value()["dim"]; +M G=eye(h);for(auto&r:G)for(auto&q:r)q-=Q(1)/9;J charts=J::array();int maxops=0;for(auto it=nf.begin();it!=nf.end();it++){int d=it.value()["dim"];M U;for(auto row:it.value()["B"]){vectorr;for(auto x:row)r.push_back(rat(x));U.push_back(r);}if(U.size()!=d)throw runtime_error("dim");auto UG=mul(U,G);auto V=nullspace(UG);M B=tr(V);for(int i=0;i548)throw runtime_error("inherited factor budget exceeded"); +map>fam;int sumdim=0,changed=0,deleted=0; +for(int i=0;i())*a[k].get();if(dot!=0)throw runtime_error("nonnested helper endpoints");} + sumdim+=(dims.at(oldend)-dims.at(old))-r;changed+=f!=old||end!=oldend; + if(r==0){deleted++;continue;}fam[r].push_back(physical); +} +mapexpected;for(auto it=tiling["census"].begin();it!=tiling["census"].end();++it)expected[stoi(it.key())]=it.value();int wantDeleted=tiling["deleted"],wantRank=tiling["entrance_rank"]; +if(fam.size()!=expected.size()||deleted!=wantDeleted||sumdim!=wantRank)throw runtime_error("actual residual census or saved rank"); +for(auto[r,k]:expected)if(fam[r].size()!=k)throw runtime_error("actual residual count"); +vectorpat;auto add=[&](vectorw,int count){if(count<0||accumulate(w.begin(),w.end(),0)!=m)throw runtime_error("pattern");if(count)pat.push_back({w,count});}; +auto rep=[](int r,int k){return vector(k,r);};auto mix=[&](int r,int k,int four){auto w=rep(r,k);w.insert(w.end(),four,4);return w;}; +for(auto pp:tiling["patterns"])add(pp["widths"].get>(),pp["count"]); +struct Slot{int bank,off,r,block;};map>slots;int banks=0,maxblock=0;J pj=J::array();for(auto pp:pat){maxblock=max(maxblock,(int)pp.w.size());pj.push_back({{"widths",pp.w},{"count",pp.count}});for(int b=0;b()-sumdim))throw runtime_error("bank stock invariant");uint64_t hash=1469598103934665603ull;auto hm=[&](uint64_t x){for(int j=0;j<8;j++){hash^=(x>>(8*j))&255;hash*=1099511628211ull;}};long long assignments=0,mass=0,columns=0,controls=0;for(int stage=0;stage<5;stage++){vector>occ(banks);for(auto[r,rows]:fam)for(int i=0;is{};s[col]=1;vector>bl;int o=0;for(int r:pp.w){bl.push_back({o,r});o+=r;}if(rev)reverse(bl.begin(),bl.end());for(auto[o,r]:bl)for(int j=o;js{};s[col]=1;int o=0;for(int b=0;b +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using Z=boost::multiprecision::cpp_int;using M=vector>; +J ld(string p){ifstream f(p);if(!f)throw runtime_error("missing "+p);J j;f>>j;return j;} +Q rat(J j){return j.is_string()?Q(j.get()):Q(j.get());}M eye(int n){M a(n,vector(n));for(int i=0;i(a.size()));for(int i=0;i(b[0].size()));for(int i=0;i=(Z(1)<<80)||d>=(Z(1)<<80))throw runtime_error("finite prime guard exceeded");} +M inverse(M a,int &ops,Q &det){int n=a.size();M b=eye(n);det=1;ops=0;for(int k=0;kpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;i piv;M copy=a;for(int c=0;cpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;iprojectors;auto proj=[&](int f)->M{if(projectors.count(f))return projectors[f];int d=fs.at(to_string(f))["dim"];if(d==h)return projectors[f]=eye(h);if(!d)return projectors[f]=M(h,vector(h));M B;for(auto row:fs.at(to_string(f))["B"]){vectorr;for(auto x:row)r.push_back(rat(x));B.push_back(r);}int ops;Q det;M BG=mul(B,G), gram=mul(BG,tr(B)), inv=inverse(gram,ops,det);return projectors[f]=mul(mul(tr(B),inv),BG);};set>pairs,oldpairs;int endpoints=0; +auto events=[&](string path){ifstream f(path,ios::binary);if(!f)throw runtime_error("missing word");f.seekg(0,ios::end);size_t size=f.tellg();f.seekg(0);if(size%sizeof(Ev))throw runtime_error("word shape");vectorv(size/sizeof(Ev));f.read((char*)v.data(),size);return v;}; +for(auto e:events(base+"/COHORT249-RECORDS.bin"))if(e.op==0&&e.r)oldpairs.insert({e.b,e.c,e.r}); +for(auto e:events(candidate+"/COHORT249-RECORDS.bin"))if(e.op==0&&e.r&&!oldpairs.count({e.b,e.c,e.r}))pairs.insert({e.b,e.c,e.r}); +J oldstate=ld(base+"/249-states.json");int v=oldstate["v"],n=oldstate["n"]; +for(int a=2*v;a()||after!=oldstate["final"][role].get()){int rank=fs.at(to_string(after))["dim"].get()-fs.at(to_string(before))["dim"].get();pairs.insert({before,after,rank});endpoints++;}} + +int maxops=0,checked=0;J charts=J::array();for(auto[before,after,r]:pairs){M E=sub(proj(after),proj(before));if(mul(E,E)!=E)throw runtime_error("not projector");M C=independent_columns(E);if(C[0].size()!=r)throw runtime_error("rank mismatch");M K=kernel_general(E);if(K.size()!=h-r)throw runtime_error("nullity mismatch");for(int i=0;i548)throw runtime_error("factor budget exceeded");J receipt={{"status","PASS_EXACT_CHANGED_ENDPOINT_AND_MOVE_CHARTS"},{"retired_endpoints",endpoints},{"unique_projectors_checked",checked},{"max_factors",maxops},{"max_numerator",maxnum.str()},{"max_denominator",maxden.str()},{"all_entries_below_two_to_80",true}};ofstream(output+"/COMBINED-CHART-AUDIT.json")< +#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==6,"usage RAW6_RECORDS OUTPUT V HELPERS H");std::string pre=argv[1];int h=std::stoi(argv[5]),v=std::stoi(argv[3]),r=std::stoi(argv[4]),loc=2*v+r,global=4*v+r,temp=global;need(v>0 && r>=0,"dimensions"); +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>0,"positive finite prefix"); // Exact width is reported and must be included in the separate finite invoice. +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},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])<=2*v]if isfinal else list(range(b['n']-2*v)) + meta=dict(n=len(survivors)if isfinal else b['n'],v=v,ZERO=st['ZERO'],FULL=st['FULL'],raw_sha256=hashlib.sha256(records).hexdigest()) + write(out/'meta.json',meta);write(out/'regs.json',regs) + for end in ('initial','final'):write(out/(end+'.json'),{str(mp[int(i)]):f for i,f in st[end].items()if int(i)in mp and int(i)0 for x in zi['mutation_controls']) + assert len(read(c/'frames.json')['frames'])==E['frames'] and len(read(c/'COHORT249-FRAMES.json'))==E['new_frame_charts'] + H=Counter();adds=units=copies=erases=records=0 + for op,a,bb,cc,f,z in struct.iter_unpack('<6i',(c/'COHORT249-RECORDS.bin').read_bytes()): + records+=1 + if op==0 and f:H[f]+=1 + elif op==1:adds+=1;units+=abs(cc) + elif op==2:H[z]+=1;copies+=1 + elif op==3:erases+=1 + assert adds==E['adds'] and units==E['units'] and records==E['records'] and copies==erases==20 + assert sum(H.values())==E['paid_calls'] and sum(r*n for r,n in H.items())==E['rank_mass'] + legal=read(out/'LEGALITY.json');cols=read(out/'COLUMNS.json');bank=read(out/'BANK.json');price=read(out/'PRICE.json');inv=read(out/'INVOICE.json');fp=read(out/'FRAME-PRIMES.json');refl=read(out/'REFLECTED-LEDGERS.json') + assert legal['status']=='PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE' and legal['all_final_frames_pass'] and legal['copies']==legal['erasures']==20 + assert legal['common_frame_ADDs']==adds and legal['rank_mass']==E['rank_mass'] and Counter(dict(legal['paid_histogram']))==H + assert cols['status']=='PASS_GENERIC_FIVE_STAGE_FORMAL_COLUMNS_AND_COMPUTED_PREFIX' and cols['formal_columns_checked']==11450 and cols['independent_dirty_registers']==7610 + assert cols['local_scalar_additions']==adds and cols['fresh_center_copies']==100 and cols['copied_center_original_source_immutable'] + assert len(cols['negative_controls'])==6 and all(x['rejected']for x in cols['negative_controls']) + assert H==Counter({int(k):v for k,v in cols['local_raw_H']})==Counter({int(k):v for k,v in price['local_histogram'].items()}) + assert refl['status']=='PASS_BOTH_CHRONOLOGICAL_REFLECTED_FRAME_LEDGERS_AND_PAID_HISTOGRAMS' and refl['non_nested_control_rejected'] + assert refl['source_word_sha256']==pin['final_word_sha256'] and refl['frame_sha256']==sha(c/'frames.json') and refl['state_sha256']==sha(c/'249-states.json') + assert len(refl['ledgers'])==2 and {q['reverse_complement'] for q in refl['ledgers']}=={False,True} + for q in refl['ledgers']: + assert q['records']==records and q['rank_mass']==E['rank_mass'] and q['copies']==20 and q['all_endpoints_exact'] and q['common_frame_adds'] and q['copy_original_source_immutable'] + assert Counter({int(k):v for k,v in q['paid_histogram'].items()})==H and q['operations']['1']==adds + assert bank['status']=='PASS_GENERIC_EXACT_CHARTS_ACTUAL_BANK_ALLOCATION' and bank['all_new_ordinary_annihilators_full_rank'] and bank['deleted_inert_roles']==0 + assert bank['actual_helper_roles']==7610 and bank['actual_role_replica_stage_assignments']==11415000 and bank['physical_replicas']==300 + for key in ('literal_stock','normalized_stock','banks_per_stage','changed_projector_charts','max_new_chart_factors','selector_charge','normalizer_factor_ceiling'): + assert bank[key]==E[key],key + assert bank['new_exact_charts']==E['new_frame_charts']==1002 and bank['changed_helper_endpoints']==E['changed_helper_endpoints']==740 + geometry_files=['candidate/COHORT249-RECORDS.bin','candidate/COHORT249-FRAMES.json','charts/COMBINED-CHART-AUDIT.json','charts/COMBINED-CHARTS.json','bank/BANK-REVIEW.json','bank/BANK-CHARTS.json'] + assert bank['geometry_input_hashes']=={str((out/n).resolve()):sha(out/n)for n in geometry_files} + assert fp['input_sha256']==sha(c/'frames.json') and fp['zero_row_control_rejected'] and fp['frames']==E['frames'] and fp['basis_witnesses']==2*E['frames'] + assert fp['status']=='PASS_EXACT_FRAME_AND_ANNIHILATOR_MINORS_FOR_ALL_PRIMES_ABOVE_2_POWER_80' and 01 for k in ('first_next','second_next')) + assert len(price['assembly']['strict_constraints'])==47 and min(map(Q,price['assembly']['strict_constraints'].values()))>0 + cv=read(out/'complex-reserve/VERIFICATION.json');binding=price['complex_supplier']['source_binding'] + assert cv['status']==pin['complex_reserve']['verification_status'] and cv['inputs_unchanged'] and cv['producer_regeneration_claim'] is False + assert cv['candidate_sha256']==pin['complex_reserve']['candidate_sha256'] + assert cv['lean_data_regeneration_claim'] is True and cv['upstream_lean_rebuilt'] is False and cv['parity_corrected_complete_invoice'] is True + assert cv['manifest_sha256']==binding['manifest_sha256']==pin['complex_reserve']['manifest_sha256']==sha(ROOT/'vendor/complex-reserve/MANIFEST.json') + assert Q(cv['complex_coarse'])==Q(price['complex_saving'])==Q(pin['complex_reserve']['coarse']) + assert binding['adapter_sha256']==sha(ROOT/'code/future_supplier.py') and binding['all_supplier_stages_fresh'] and binding['declarative_source'] and binding['producer_regeneration_claim'] is False + assert binding['lean_data_regeneration_claim'] is True and binding['upstream_lean_rebuilt'] is False and binding['parity_corrected_complete_invoice'] is True + for name,h in binding['receipt_hashes'].items():assert sha(out/'complex-reserve'/name)==h + ref=read(out/'REFINEMENT.json');assert ref['status']=='PASS_P10_PRIME_THRESHOLD_FULL_INVOICE_TWO_MOMENTS_FINITE_BOOTSTRAP_OUTER47' + assert Q(ref['native_kappa'])==Q(price['kappa'])0 + assert int(inv['full_counted_primitive_coefficient'])==ref['complete_literal_invoice']['coefficient']==E['coefficient'] and inv['payload_bits']==88 + names=['source-regeneration/REGENERATION.json','COMPACTION.json','ORIGINAL-EXPORT.json','candidate-signed18-REGENERATION.json','candidate-REGENERATION.json','INTEGER-AUDIT.json','ROLE-MAP.json','LEGALITY.json','COLUMNS.json','REFLECTED-LEDGERS.json','TILING.json','BANK.json','FRAME-PRIMES.json','PRICE.json','INVOICE.json','REFINEMENT.json'] + names+=['predecessor/'+n for n in ('verification.json','certificate.json','complex.json','primes.json','banks.json','math.json')] + names+=['complex-reserve/'+n for n in binding['receipt_hashes']] + names+=geometry_files + names+=[folder+'/'+name for folder,key in [('candidate-source','source'),('candidate-signed18','intermediate'),('candidate','final')]for name in tp['files'][key]] + names+=['staged-regeneration/REGENERATION.json','staged-regeneration/SOURCE-ROLE-MAP.json','DESIGN-SCALAR.json','PARITY-CONTROL.json'] + result=dict(status='PASS_SOURCE_BOUND_W3_STAGED354_E8_SIGNED20_COMPLETE_NATIVE_CONDITIONAL_CONSTRUCTION',kappa=pin['kappa'],native_kappa=pin['native_kappa'],word_sha256=pin['final_word_sha256'],source_regenerated=True,source_compacted_word_sha256=pin['source_compacted_word_sha256'],intermediate_word_sha256=pin['intermediate_word_sha256'],signed_twin_source_regenerated=True,integer_local_scalar_operator_preserved=True,integer_comparison_ignores_moves=True,integer_input_columns=9530,integer_output_rows=9531,signed_twin_count=20,complex_declarative_source=True,complex_producer_regeneration_claim=False,complex_lean_data_regeneration_claim=True,complex_upstream_lean_rebuilt=False,complex_parity_corrected_invoice=True,physical_replicas=300,literal_stock=bank['literal_stock'],normalized_stock=bank['normalized_stock'],helper_assignments=bank['actual_role_replica_stage_assignments'],new_frame_charts=E['new_frame_charts'],changed_projector_charts=E['changed_projector_charts'],new_chart_factor_max=bank['max_new_chart_factors'],normalizer=787,finite_coefficient=E['coefficient'],selector_charge=bank['selector_charge'],payload_bits=88,bootstrap_levels=E['bootstrap_levels'],scope=ref['scope'],fresh_receipt_hashes={n:sha(out/n)for n in names}) + (out/'CERTIFICATE.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n');print('PASS integrated source-bound Design T/twins '+pin['kappa'],flush=True) + +if __name__=='__main__':finish(sys.argv[1]) diff --git a/research/w3-staged354-signed20-native/code/frame_prime_minors.py b/research/w3-staged354-signed20-native/code/frame_prime_minors.py new file mode 100644 index 0000000000..2105355a44 --- /dev/null +++ b/research/w3-staged354-signed20-native/code/frame_prime_minors.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +"""Exact full-row-rank witnesses for actual new frame bases and annihilators. +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +A nonzero integer minor of magnitude below 2^80 stays nonzero over every +prime field of characteristic greater than 2^80. No factorization oracle. +""" +import sys +if not __debug__:raise SystemExit('Assertions required') +sys.dont_write_bytecode=True +import argparse,hashlib,json +from pathlib import Path +P=2147483647 + +def columns(rows): + if not rows:return [] + a=[[int(x)%P for x in row]for row in rows];m=len(a);n=len(a[0]);r=0;cols=[] + for c in range(n): + k=next((k for k in range(r,m)if a[k][c]),None) + if k is None:continue + a[k],a[r]=a[r],a[k];iv=pow(a[r][c],-1,P);a[r]=[iv*x%P for x in a[r]] + for k in range(r+1,m): + if a[k][c]:z=a[k][c];a[k]=[(x-z*y)%P for x,y in zip(a[k],a[r])] + cols.append(c);r+=1 + if r==m:return cols + raise AssertionError('Frame rows fail independent modular witness') + +def determinant(a): + n=len(a) + if not n:return 1 + a=[list(row)for row in a];sign=1;prev=1 + for k in range(n-1): + pivot=next((i for i in range(k,n)if a[i][k]),None) + if pivot is None:return 0 + if pivot!=k:a[k],a[pivot]=a[pivot],a[k];sign=-sign + p=a[k][k] + for i in range(k+1,n): + for j in range(k+1,n): + value=a[i][j]*p-a[i][k]*a[k][j];assert value%prev==0;a[i][j]=value//prev + a[i][k]=0 + prev=p + return sign*a[-1][-1] + +def witness(rows): + c=columns(rows);d=determinant([[int(row[k])for k in c]for row in rows]);assert 0max(ka,kb);k=merges[0] + chosen.append(dict(a=a,b=b,first_a=ka,first_b=kb,first_frame_a=u,first_frame_b=w,k=k,merge_frame=ev[k][4],B=B,A=A,dimension=1,entrance_frame=E)) + st['initial'][str(b)]=E;pivots.add(b);insert[min(ka,kb)].extend([(0,a,Z,E,1,0),(1,a,b,-1,E,46)]) + change[ka]=(0,a,E,u,2,0);change[kb]=(0,b,E,w,2,0);append.append((1,a,b,1,F,47)) + out=[];removed=[] + for k,r in enumerate(ev): + out.extend(insert.get(k,())) + if r[0]==1 and dim[r[4]]==0 and (r[1]in pivots or r[2]in pivots):removed.append(k);continue + out.append(change.get(k,r)) + out.extend(reversed(append));raw=b''.join(struct.pack('<6i',*r)for r in out) + assert len(ev)==406294 and len(out)==406292 and len(removed)==8;digest=hashlib.sha256(raw).hexdigest();assert digest==TARGET_WORD + shutil.copytree(source,output);(output/'COHORT249-RECORDS.bin').write_bytes(raw);st['record_sha256']=digest;write(output/'249-states.json',st);write(output/'COHORT249-INITIAL.json',st['initial']);assert files(output)==TARGET_FILES + report=dict(status='PASS_EXACT_TWO_FURTHER_SIGNED_TWINS_REGENERATION_NOT_FULL_ADMISSION',source_word_sha256=SOURCE_WORD,candidate_word_sha256=digest,source_files=SOURCE_FILES,candidate_files=files(output),chosen=chosen,removed_zero_frame_additions=removed,records_before=len(ev),records_after=len(out),new_frames=0,entrance_rank_saved=2,scope='The additional earlier proper-frame reads invalidate the simple single-consumer template proof; the complete exact integer operator comparison is mandatory. Native frames, F2 columns, both ledgers, geometry, banks, moments and invoice are separate mandatory gates.') + write(output.parent/(output.name+'-REGENERATION.json'),report);print('PASS exact two further signed twins',digest,flush=True) +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--source',required=True);p.add_argument('--output',required=True);a=p.parse_args();regenerate(a.source,a.output) diff --git a/research/w3-staged354-signed20-native/code/invoice.cpp b/research/w3-staged354-signed20-native/code/invoice.cpp new file mode 100644 index 0000000000..87316f7d5e --- /dev/null +++ b/research/w3-staged354-signed20-native/code/invoice.cpp @@ -0,0 +1,14 @@ +#include +#include "json.hpp" +#include +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using I=cpp_int;using Q=cpp_rational; +void need(bool x,const char*s){if(!x)throw runtime_error(s);}J load(string p){ifstream f(p);need(bool(f),"missing input");J j;f>>j;return j;} +Q rat(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));}I ceilQ(Q x){return (numerator(x)+denominator(x)-1)/denominator(x);}struct E{int op,a,b,c,f,z;}; +int main(int argc,char**argv){try{need(argc==6,"usage RECORDS ROOT_PRICE BANK_RECEIPT FIVE_STAGE_RECEIPT OUTPUT");ifstream f(argv[1],ios::binary|ios::ate);size_t bytes=f.tellg();need(bytes%sizeof(E)==0,"ABI");vectorev(bytes/sizeof(E));f.seekg(0);f.read((char*)ev.data(),bytes);J price=load(argv[2])["cohort_candidate"],bank=load(argv[3]),global=load(argv[4]);mapH;I adds=0,units=0,copies=0;for(auto e:ev){if(e.op==0&&e.f)H[e.f]++;else if(e.op==1){adds++;units+=abs(e.c);}else if(e.op==2){H[e.z]++;copies++;}}need(copies==20&&adds>0&&units>=adds,"actualword inventory");int m=100,v=960,R=bank["actual_helper_roles"],T=300,N=2*m,d=m*m,stock=bank["literal_stock"];need(bank["physical_replicas"]==T,"replica binding");need(stock==bank["normalized_stock"].get()*5&&bank["actual_role_replica_stage_assignments"]==5*T*R,"actualbanks");need(bank["new_exact_charts"].get()>0&&bank["max_new_chart_factors"]<=548&&I(bank["max_intermediate_denominator"].get())<(I(1)<<80)&&I(bank["max_intermediate_numerator"].get())<(I(1)<<80),"newchart invoice");mapL;for(auto[r,n]:H)L[r]+=5*T*n;for(int r:{4,19,38,42})L[r]+=T*2*v;I Ecount=0,mass=0;J hh=J::object();for(auto[r,n]:L){Ecount+=n;mass+=r*n;need(r<50,"half-shrink");hh[to_string(r)]=n.convert_to();need(n==5*price["histogram"][to_string(r)].get(),"fullH versusnormalizedprice");}need(m*I(stock)-mass==612000,"physicaldeficit");need(price["stock"].get()*5==stock,"literalstock notnormalized");Q mu=rat(price["moment_upper"]);need(mu<1,"strict moment");Q c=rat(price["coarse"]),deltaTau=1-mu,deltaLin=1-Q(mass)/(m*stock)-Q(32*m)*Ecount/(I("10000000000000000")*stock);need(deltaLin>0,"linear fallback");I Jroute=T*(24*v+10*R),good=8*m*m+8,high=16*I(d+1)*(d+1),K=2*5*T*(I(stock-1)+I(R)*100*787),weighted=T*(5*adds+6*v),unit=T*(5*units+6*v);need(K==bank["selector_charge"].get()&&K<(I(1)<<41),"all selector factors");I F=I(global["signed_lift_prefix"][0]["cancellation_free_signed_row_l1_upper"].get()),B=I(global["signed_lift_prefix"][1]["cancellation_free_signed_row_l1_upper"].get()),payload=64*F*F*F*B*B;need(payload<(I(1)<<104),"payload prefix");I coeff=unit+Jroute*high+Jroute*(stock+20)+Ecount*good+Ecount*(128*I(N)*N*N)+16*I(m)*m*m+100*T+Ecount+K+1;need(coeff<(I(1)<<80)&&2*I(m)*m*m*I("10000000000000000")<(I(1)<<80),"fixed coefficient below prime threshold");need(I(stock+20)<(I(1)<<80),"stocklessprime");Q previous=rat("384599/10000000000");J cuts=J::array();for(int stage=0;stage<3;stage++){Q a=(1-c)*c+c*previous;vectorgaps={c-a,1-a-c,1-a-c*(1-previous),1-c};Q gap=*min_element(gaps.begin(),gaps.end());need(gap>0,"ordinary cutoff gap");I L1=ceilQ(36/(gap*gap)),L2=ceilQ(2*(4+msb(coeff)+1)/gap),cut=max(I(1),max(L1,L2));need(Q(cut)*gap*gap>=36&&Q(cut)*gap>=2*(4+msb(coeff)+1),"cutoff inequality");cuts.push_back({{"stage",stage+1},{"minimum_gap",gap.str()},{"counted_coefficient_cutoff_log2",cut.convert_to()},{"general_rule","For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta))."}});previous=a;} +J out={{"status","PASS_COHORT_LITERAL_FIVE_STAGE_FINITE_INVOICE_AND_POSITIVE_CUTOFFS"},{"physical_replicas",T},{"literal_stock",stock},{"normalized_stock",price["stock"]},{"positive_rank_children",Ecount.convert_to()},{"literal_rank_mass",mass.convert_to()},{"literal_deficit",612000},{"literal_histogram",hh},{"global_weighted_additions",weighted.convert_to()},{"global_unit_expanded_additions",unit.convert_to()},{"route_families",Jroute.convert_to()},{"normalizer_factor_bound",787},{"new_chart_factor_max",bank["max_new_chart_factors"]},{"extra_selector_calls",K.convert_to()},{"full_counted_primitive_coefficient",coeff.convert_to()},{"primitive_coefficient_bits",msb(coeff)+1},{"payload_signed_prefix_upper",payload.convert_to()},{"payload_bits",msb(payload)+1},{"internal_row_coefficient",10001},{"external_complex_row_coefficient",20161},{"simultaneous_extra_work_streams",1},{"strict_moment_slack",deltaTau.str()},{"linear_moment_slack",deltaLin.str()},{"ordinary_cutoffs",cuts},{"scope","Sufficient finite invoice for the literal new cohort word, 300 physical replicas and fully admitted bank stock; original 40dim route, retained odd-prime rational address grid, common-ancestor compiler and complex recovery interfaces are inherited unchanged. No Lean or independent certification of those underlying public theorems asserted."}};ofstream(argv[5])< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +using namespace std;using nlohmann::json;struct Ev{int k,a,b,c,f,z;};struct F{int d;vector>B,A;};json ld(string p){json j;ifstream(p)>>j;return j;}int main(int ac,char**av){if(ac!=4)return 2;string in=av[1],out=av[2];auto st=ld(in+"/249-states.json"),fj=ld(in+"/frames.json"),nf=ld(out+"/COHORT249-FRAMES.json"),ii=ld(out+"/COHORT249-INITIAL.json"),sel=ld(out+"/COHORT249-SELECTION.json");int n=st["n"],v=st["v"],h=fj["h"],zero=st["ZERO"];mapfs;long long maxabs=0;int oldmax=0;for(auto it=fj["frames"].begin();it!=fj["frames"].end();++it){int k=stoi(it.key());oldmax=max(oldmax,k);F f{it.value()["dim"],it.value()["B"],it.value()["A"]};for(auto M:{f.B,f.A})for(auto r:M)for(auto x:r)maxabs=max(maxabs,llabs(x));fs[k]=f;}for(auto it=nf.begin();it!=nf.end();++it){int k=stoi(it.key());if(fs.count(k))throw runtime_error("new frame collides");fs[k]={it.value()["dim"],it.value()["B"],it.value()["A"]};}map,bool>cache;long long contain=0;auto sub=[&](int a,int b){if(!fs.count(a)||!fs.count(b))throw runtime_error("unknown frame");auto k=make_pair(a,b);if(cache.count(k))return cache[k];contain++;bool ok=fs[a].d<=fs[b].d;for(auto r:fs[a].B)for(auto s:fs[b].A){boost::multiprecision::cpp_int d=0;for(int i=0;ichosen;auto final=ld(out+"/COHORT249-FINAL.json");setrestored; +for(int r=0;rstate(n+1,zero);for(auto it=ii.begin();it!=ii.end();++it)state[stoi(it.key())]=it.value();bool copied=false;int copySource=-1;long long mov=0,adds=0,cop=0,era=0,mass=0;maphist;Ev e;ifstream f(out+"/COHORT249-RECORDS.bin",ios::binary);long long records=0;while(f.read((char*)&e,sizeof e)){records++;if(e.a<0||e.a>n||(e.k!=0&&(e.b<0||e.b>n)))throw runtime_error("bad role id");if(e.k==0){if(e.a==n&&!copied)throw runtime_error("move inactive temporary");if(state[e.a]!=e.b||!sub(e.b,e.c)||fs[e.c].d-fs[e.b].d!=e.f)throw runtime_error("illegal or mispriced MOVE");state[e.a]=e.c;if(e.f){hist[e.f]++;mass+=e.f;}mov++;}else if(e.k==1){if(state[e.a]!=e.f||state[e.b]!=e.f)throw runtime_error("ADD not in common frame");if((e.a==n||e.b==n)&&!copied)throw runtime_error("ADD inactive temporary");if(e.a==e.b)throw runtime_error("self ADD");if(copied&&(e.a==copySource||e.a==n))throw runtime_error("copied source or temporary mutated inside COPY window");adds++;}else if(e.k==2){if(copied||e.b!=n||state[e.a]!=e.c)throw runtime_error("invalid COPY lifecycle");if(e.z!=fs[e.c].d)throw runtime_error("COPY rank");copied=true;copySource=e.a;state[n]=e.f;hist[e.z]++;mass+=e.z;cop++;}else if(e.k==3){if(!copied||e.b!=n||e.a!=copySource||state[e.a]!=e.c||state[n]!=e.f)throw runtime_error("invalid ERASE lifecycle");copied=false;era++;}else throw runtime_error("unknown event");}if(copied||cop!=h||era!=h)throw runtime_error("unclosed COPY");for(int s=0;s +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif diff --git a/research/w3-staged354-signed20-native/code/price.py b/research/w3-staged354-signed20-native/code/price.py new file mode 100644 index 0000000000..53294ef52e --- /dev/null +++ b/research/w3-staged354-signed20-native/code/price.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +"""Price the actual p10 composed word with PR315's two engines and complete fallback. +Prepared with OpenAI Codex assistance; Apache-2.0. PR315 math interfaces are inherited. +""" +import sys +if not __debug__:raise SystemExit('assertions required') +sys.dont_write_bytecode=True +sys.set_int_max_str_digits(0) +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +import argparse,hashlib,json,struct,importlib.util +ROOT=Path(__file__).resolve().parents[1];SRC=ROOT/'vendor/predecessor';sys.path.insert(0,str(SRC)) +def load(n,p): + s=importlib.util.spec_from_file_location(n,p);m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m + +def portable_json_numbers(value): + # Preserve exact large integers as decimal strings for the native C++ JSON reader. + # Python's bool is an int subtype, so require the exact integer type. + if type(value) is int and not -(1<<63)<=value<(1<<63):return str(value) + if isinstance(value,dict):return {k:portable_json_numbers(v)for k,v in value.items()} + if isinstance(value,list):return [portable_json_numbers(v)for v in value] + return value + +def run(candidate,bank_path,complex_path,output,source_root=None,complex_reserve=None,complex_reserve_proof=None): + global SRC + if source_root:SRC=Path(source_root).resolve();sys.path.insert(0,str(SRC)) + candidate=Path(candidate);read=lambda p:json.loads(Path(p).read_text());bank=read(bank_path);st=read(candidate/'249-states.json');fs=read(candidate/'frames.json')['frames'];raw=(candidate/'COHORT249-RECORDS.bin').read_bytes();digest=hashlib.sha256(raw).hexdigest();assert st['record_sha256']==digest + H=Counter();adds=units=copies=0 + for op,a,b,c,f,z in struct.iter_unpack('<6i',raw): + if op==0 and f:H[f]+=1 + elif op==2:H[z]+=1;copies+=1 + elif op==1:adds+=1;units+=abs(c) + assert copies==20 and adds>0 + residual=sum(fs[str(st['final'][str(i)])]['dim']-fs[str(st['initial'][str(i)])]['dim'] for i in range(2*st["v"],st["n"])) + stock=bank['normalized_stock'];assert bank['physical_replicas']==300;assert bank['literal_stock']==5*stock and 100*bank['banks_per_stage']==300*residual + assert bank['literal_stock']==4*960*300+5*bank['banks_per_stage'] + hist={r:300*n for r,n in H.items()} + for r in (4,19,38,42):hist[r]=hist.get(r,0)+115200 + calls=sum(hist.values());mass=sum(r*n for r,n in hist.items());assert 100*stock-mass==122400 and max(hist)==42 + cost=load('composition_cost',SRC/'moment.py');other=load('composition_other',SRC/'base_two_moment.py');outer=load('composition_outer',SRC/'outer.py');upmath=load('composition_upmath',SRC/'math_check.py') + root=cost.certify(hist,100,stock,True);coarse=Q(int(Q(root['lower'])*10**18),10**18);step=Q(1,10**18) + first=cost.moment(hist,100,stock,coarse,True);first_next=cost.moment(hist,100,stock,coarse+step,True);assert first[1]<10;chain.append(new);gaps.append(row) + leaf=chain[-1];bridge=dict(proof='vendor/pr315/PROOF.md',representation='Exact powers with source-bound finite overcharges',semantic=dict(G=dict(base=2,exponent=30000),E=dict(base=2,exponent=100000),B_upper=dict(base=2,exponent=100001),C0=dict(base=2,exponent=210000),C1=1,strict_literal_gap=1,induction_gap_lower=1),rows=dict(coefficient=20161,degree=10**6,suffix_slope=4*10**6,degree_gap=Q(10**6)-Q(51*20161,25))) + q=leaf*(1-2*eta);minimum=(1-eta)*q/(1+q);ticks=minimum*10**18;k=Q((ticks.numerator-1)//ticks.denominator,10**18);assembly=outer.assembly(leaf,b,bridge,k,eta=eta,beta=beta) + assert len(assembly['strict_constraints'])==47 and min(assembly['strict_constraints'].values())>0 + try:outer.assembly(leaf,b,bridge,k+step,eta=eta,beta=beta) + except AssertionError:pass + else:raise AssertionError('adjacent kappa admitted') + result=dict(complex_reserve=dict(package=str(Path(complex_reserve).resolve()),proof=str(Path(complex_reserve_proof).resolve()),binding=supplier['source_binding']) if complex_reserve else None,status='PASS_ACTUAL_P10_COMPOSED_WORD_TWO_MOMENTS_AND_47_CONSTRAINTS',source_word_sha256=digest,adds=adds,unit_adds=units,local_histogram=dict(H),local_rank_mass=sum(r*n for r,n in H.items()),residual=residual,cohort_candidate=dict(stock=stock,histogram=hist,calls=calls,rank_mass=mass,deficit=122400,coarse=s,moment_upper=first[1] if s==coarse else cost.moment(hist,100,stock,s,True)[1],kappa=k),first_interval=first,first_next=first_next,second_interval=second,second_next=second_next,ordinary_chain=chain,ordinary_gaps=gaps,assembly=assembly,kappa=k,bit_root=coarse,complex_saving=b,complex_supplier=supplier,complex_binds=s=0 + if difference:H[difference]+=1 + state[t]=new + elif op==1: + assert state[t]==state[s]==fid and t!=s + assert t!=n and (s!=n or open_source is not None) + assert open_source is None or t!=open_source + elif (op==3 if rev else op==2): + assert open_source is None and s==n and state[t]==v and n not in state + # Reflection swaps the rank difference's orientation; the paid extraction + # rank remains dim(source)-dim(temporary), independently of basis choice. + assert z==fs[v]['dim']-fs[fid]['dim'] and z>0 + open_source=t;state[n]=fid;H[z]+=1 + else: + assert s==n and open_source==t and state[t]==v and state[n]==fid + open_source=None;del state[n] + assert open_source is None and state=={int(k):v for k,v in end.items()} + assert counts[2]==counts[3]==h + results.append(dict(reverse_complement=rev,records=len(ev),operations=dict(counts),paid_histogram=dict(H),rank_mass=sum(r*c for r,c in H.items()),copies=h,all_endpoints_exact=True,common_frame_adds=True,copy_original_source_immutable=True)) +assert results[0]['paid_histogram']==results[1]['paid_histogram'] +# Reject a rank-changing endpoint overcharge directly on the actual primitive. +try:sub(st['FULL'],st['ZERO'],False) +except AssertionError:negative=True +else:raise AssertionError('non-nested control accepted') +out=dict(status='PASS_BOTH_CHRONOLOGICAL_REFLECTED_FRAME_LEDGERS_AND_PAID_HISTOGRAMS',source_word_sha256=hashlib.sha256(raw).hexdigest(),frame_sha256=hashlib.sha256((c/'frames.json').read_bytes()).hexdigest(),state_sha256=hashlib.sha256((c/'249-states.json').read_bytes()).hexdigest(),containment_pairs=sub.cache_info().currsize,non_nested_control_rejected=negative,ledgers=results,scope='Exact original B/A dot products and both chronological frame/state ledgers; separate native frame-minor and projector receipts certify ranks/nondegeneracy. Complementary COPY uses the same paid rank difference with its orientation reversed.') +a.output.write_text(json.dumps(out,sort_keys=True,indent=2)+'\n');print('PASS both reflected ledgers',len(ev),results[0]['rank_mass'],flush=True) diff --git a/research/w3-staged354-signed20-native/code/source_tiling.py b/research/w3-staged354-signed20-native/code/source_tiling.py new file mode 100644 index 0000000000..8c5a96ea83 --- /dev/null +++ b/research/w3-staged354-signed20-native/code/source_tiling.py @@ -0,0 +1,84 @@ +"""Exact tiling and economy fallback extracted without algorithm changes from PR320. +Source bank_template.py retained in frozen PR322 predecessor; source SHA256 1c124900095abfd0c06cba507c2ed804f5475bea1b3f698ef66d412417ad4264. +Original p10 port by DreamingOfClouds with Anthropic Claude assistance; economy fallback by Chafik Boukhalfa with Anthropic Claude assistance. +Extraction and downstream integration prepared with OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter + +def tile(blocks, m): + """Exact tiling of {width: number of blocks} into banks of total width m, as ((widths, banks), ...). + + A width dividing m fills pure banks. A width w not dividing m is mixed with a filler width f dividing m: + banks w^a f^b with a maximal (w*a + f*b = m), then at most one bank w^r f^t for the remainder r. Fillers + are tried in a fixed order (most blocks first) with backtracking until every pure width also divides out. + Fails (AssertionError) unless every block is used and every bank is full; there is no padding.""" + blocks = {w: n for w, n in blocks.items() if n} + assert all(0 < w <= m for w in blocks) + mixed = sorted(x for x in blocks if m % x) + + def search(i, left, out): + if i == len(mixed): + if any(left[w] % (m // w) for w in left): return None + return out + [(tuple([w]*(m // w)), left[w]//(m // w)) for w in sorted(left) if left[w]] + w = mixed[i]; n = blocks[w] + for f in sorted(left, key=lambda x: (-left[x], x)): + a = next((a for a in range(m // w, 0, -1) if (m - w*a) % f == 0), None) + if a is None: continue + b = (m - w*a)//f; q, r = divmod(n, a) + if r and (m - w*r) % f: continue + t = (m - w*r)//f if r else 0 + if q*b + t > left[f]: continue + rest = dict(left); rest[f] -= q*b + t + found = search(i + 1, rest, out + ([(tuple([w]*a + [f]*b), q)] if q else []) + ([(tuple([w]*r + [f]*t), 1)] if r else [])) + if found is not None: return found + return None + out = search(0, {w: n for w, n in blocks.items() if not m % w}, []) + if out is None: out = economy_tile(blocks, m) + assert all(sum(widths) == m and count > 0 for widths, count in out) + used = Counter() + for widths, count in out: + for x in widths: used[x] += count + assert used == Counter(blocks), 'every block used exactly once' + return tuple(out) + + +def economy_tile(blocks, m): + """Exact zero-padding tiling used when the filler search of tile() runs out of filler blocks (the kernel pivots + and early restorations of the stage stack add many residual widths that do not divide m; the PR #299 analogue at + p = 12 was the (r^4, 24, 4^(24-r)) re-tiling). The fillers are the two most numerous widths dividing m (here the + full helper width h and the rank-4 entrance residual). Each other width w, in decreasing order, gets the bank + w^a F^c f^b (w*a + F*c + f*b = m) that spends the fewest narrow fillers f per w block (then the largest a), plus + at most one bank w^r F^c' f^b' for the remainder r = n mod a. The leftover fillers fill pure banks F^(m/F), + f^(m/f) and y residue banks F^j f^k. Every bank sums to m and every block is used exactly once (no padding).""" + from fractions import Fraction + blocks = {w: n for w, n in blocks.items() if n} + div = sorted((w for w in blocks if m % w == 0), key=lambda w: (-blocks[w], w)) + assert len(div) >= 2, ('economy tiling needs two filler widths', blocks) + F, f = sorted(div[:2], reverse=True) + + def fill(rest): + """(c, b) with F*c + f*b = rest, c maximal (fewest narrow fillers); None if impossible.""" + return next(((c, (rest - F*c)//f) for c in range(rest//F, -1, -1) if (rest - F*c) % f == 0), None) + + left = {F: blocks[F], f: blocks[f]}; out = [] + for w in sorted((x for x in blocks if x not in (F, f)), reverse=True): + n = blocks[w] + opts = [(Fraction(cb[1], a), -a, a, cb) for a in range(m//w, 0, -1) for cb in [fill(m - w*a)] if cb] + assert opts, ('no bank for width', w) + _, _, a, (c, b) = min(opts); q, r = divmod(n, a) + if q: out.append(((w,)*a + (F,)*c + (f,)*b, q)); left[F] -= q*c; left[f] -= q*b + if r: + cb = fill(m - w*r); assert cb, ('no remainder bank', w, r) + out.append(((w,)*r + (F,)*cb[0] + (f,)*cb[1], 1)); left[F] -= cb[0]; left[f] -= cb[1] + assert left[F] >= 0 and left[f] >= 0, ('fillers exhausted', left) + pF, pf = m//F, m//f + for y in range((pF*pf) + 1): + for j in range(1 if y else 0, pF if y else 1): + if (m - F*j) % f: continue + k = (m - F*j)//f; aF, af = left[F] - y*j, left[f] - y*k + if aF >= 0 and af >= 0 and aF % pF == 0 and af % pf == 0: + out += ([((F,)*j + (f,)*k, y)] if y else []) + ([((F,)*pF, aF//pF)] if aF else []) + ([((f,)*pf, af//pf)] if af else []) + return out + raise AssertionError(('no exact zero-padding tiling', blocks, m)) + + diff --git a/research/w3-staged354-signed20-native/code/staged_export.py b/research/w3-staged354-signed20-native/code/staged_export.py new file mode 100644 index 0000000000..9401ec0c4f --- /dev/null +++ b/research/w3-staged354-signed20-native/code/staged_export.py @@ -0,0 +1,54 @@ +# Derived from Chafik Boukhalfa/Anthropic Claude PR354 export_stages.py. +# Explicit kernel-free selections, source-role map and guards: OpenAI Codex assistance; Apache-2.0. +"""Export the p10bs word after parity and after each transcript stage as PR249 snapshots (records.bin, states.json, frames.json) + meta.pkl. +usage: export_stages.py PKG OUTDIR""" +import sys,json,pickle,hashlib,importlib.util,time +sys.dont_write_bytecode=True +if not __debug__:raise SystemExit("Assertions required") +from pathlib import Path +import numpy as np +P=Path(sys.argv[1]).resolve();O=Path(sys.argv[2]).resolve();U=Path(sys.argv[3]).resolve();sys.path.insert(0,str(P));sys.dont_write_bytecode=True +def load(name,path): + s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);sys.modules[name]=m;s.loader.exec_module(m);return m +t=time.monotonic() +ctx=load('portable527_prepare',P/'prepare.py').prepare() +context=dict(ctx) +run=load('portable527_physical',P/'code/physical527.py').run(context,context['SOURCE_TEXT'],output_dir=None) +run=load('portable527_parity',P/'parity_transform.py').run(run) +ST=('descent','target','restore','sink') +original_regs=list(run['context']['regs']) +rm=load('portable527_reorder',P/'reorder_transform.py') +def dump(tag,run): + D=O/tag;D.mkdir(parents=True,exist_ok=True) + W,C=run['W'],run['C'] + arr=np.asarray(run['records'],dtype='0 and T%5==0 + R=bank['actual_helper_roles'];stock=bank['literal_stock'];norm=bank['normalizer_factor_ceiling'] + assert bank['actual_role_replica_stage_assignments']==5*T*R + assert stock==4*v*T+5*bank['banks_per_stage']==5*bank['normalized_stock'] + residual={int(r):n for r,n in bank['residual_families'].items()};used=Counter() + for row in bank['bank_patterns']: + assert sum(row['widths'])==m and row['count']>0 + for r in row['widths']:used[r]+=row['count'] + assert used=={r:T*n for r,n in residual.items()} and sum(residual.values())==R + assert sum(row['count']for row in bank['bank_patterns'])==bank['banks_per_stage'] + H,adds,units,nrecords=census(word);literal=Counter({r:5*T*n for r,n in H.items()}) + for r in (4,19,38,42):literal[r]+=2*v*T + E=sum(literal.values());mass=sum(r*n for r,n in literal.items()) + assert max(literal)==42 and m*stock-mass==2040*T + assert dict(literal)=={int(r):int(n)for r,n in inv['literal_histogram'].items()}=={int(r):5*n for r,n in price['cohort_candidate']['histogram'].items()} + assert price['adds']==adds and price['unit_adds']==units and price['local_rank_mass']==sum(r*n for r,n in H.items()) + assert dict(H)=={int(r):n for r,n in price['local_histogram'].items()}==dict(columns['local_raw_H']) + assert columns['independent_dirty_registers']==R and columns['local_scalar_additions']==adds + assert columns['fresh_center_copies']==100 and columns['copied_center_original_source_immutable'] + assert len(columns['negative_controls'])==6 and all(c['rejected']for c in columns['negative_controls']) + N=2*m;d=m*m;J=T*(24*v+10*R);K=2*5*T*((stock-1)+R*m*norm) + weighted=T*(5*adds+6*v);unit=T*(5*units+6*v) + components=dict(unit_expanded_additions=unit,high_affine_factors=J*16*(d+1)**2,low_transposition_coefficient=J*(stock+h),generic_wrappers=E*(8*m*m+8),matrix_preparation=E*128*N**3,selector_preparation=16*m**3,copy_erase_episodes=5*h*T,paid_children=E,extra_bank_selector_calls=K,one_extra_work_stream=1) + C=sum(components.values()) + assert norm==int(inv['normalizer_factor_bound']) and K==bank['selector_charge']==int(inv['extra_selector_calls']) + assert T==inv['physical_replicas'] and stock==inv['literal_stock'] and 5*price['cohort_candidate']['stock']==stock + assert E==int(inv['positive_rank_children']) and mass==int(inv['literal_rank_mass']) and inv['literal_deficit']==2040*T + assert weighted==int(inv['global_weighted_additions']) and unit==int(inv['global_unit_expanded_additions']) and J==int(inv['route_families']) + assert C==int(inv['full_counted_primitive_coefficient']) and C<2**80

Q(price['bit_root']) + complex_saving=Q(price['complex_saving']);complex_limit=(1-BETA)*complex_saving;limit_ticks=complex_limit*GRID;strict_complex_cap=Q((limit_ticks.numerator-1)//limit_ticks.denominator,GRID) + coarse=min(bitcoarse,strict_complex_cap);admit_first=primitive.moment(H,m,W,coarse,cost,rho);admit_second=primitive.second(H,m,W,coarse,other,rho);assert admit_first[1]<1 and admit_second[1]<1 and coarse0 + delta=min(ds.values());cut=primitive.cutoff(delta,C);assert cut*delta**2>=36 and cut*delta>=2*(4+(C-1).bit_length());chain.append(a);gaps.append(dict(level=level,gaps=ds,minimum_gap=delta,primitive_coefficient_cutoff_log2=cut)) + if primitive.gridk(a)==cap:break + else:raise AssertionError('finite bootstrap budget exhausted') + bridge=read(parent/'math.json')['mathematics']['finite_bridge'];bridge['rows']['degree_gap']=Q(bridge['rows']['degree_gap']);complex_saving=Q(price['complex_saving']);assert coarse<(1-BETA)*complex_saving + assembly=outer.assembly(chain[-1],complex_saving,bridge,cap,eta=ETA,beta=BETA);assert len(assembly['strict_constraints'])==47 and len(assembly['margins'])==7 and min(assembly['strict_constraints'].values())>0 + controls=[] + def reject(label,fn): + try:fn() + except(AssertionError,ValueError):controls.append(label) + else:raise AssertionError('mutation accepted '+label) + for leaf in (chain[-1],coarse):reject('adjacent kappa',lambda leaf=leaf:outer.assembly(leaf,complex_saving,bridge,cap+Q(1,GRID),eta=ETA,beta=BETA)) + for key in ('full_counted_primitive_coefficient','global_unit_expanded_additions','literal_stock','positive_rank_children','literal_rank_mass','extra_selector_calls','normalizer_factor_bound','payload_signed_prefix_upper'): + bad=dict(inv);bad[key]=str(int(bad[key])-1)if isinstance(bad[key],str)else bad[key]-1 + reject('undercharged '+key,lambda bad=bad:invoice(word,bank,columns,price,bad)) + reject('zero cutoff gap',lambda:primitive.cutoff(Q(0),C));reject('zero coefficient',lambda:primitive.cutoff(Q(1,2),0)) + tau=1-admit_first[1];linear=1-Q(bill['rank_mass'],m*bill['literal_stock'])-rho*Q(32*m*bill['positive_rank_children'],bill['literal_stock']);assert tau>0 and linear>0 + external={} + if price.get('complex_reserve'): + cr=price['complex_reserve'];binding=cr['binding'];assert sha(Path(cr['package'])/'MANIFEST.json')==binding['manifest_sha256'];assert binding['inputs_unchanged'] and binding['all_supplier_stages_fresh'];engine_hashes['future_supplier.py']=sha(ROOT/'future_supplier.py');assert engine_hashes['future_supplier.py']==binding['adapter_sha256'] + for name,digest in binding['receipt_hashes'].items(): + path=Path(cr['proof'])/name;assert sha(path)==digest;external[str(path)]=digest + result=dict(status='PASS_P10_PRIME_THRESHOLD_FULL_INVOICE_TWO_MOMENTS_FINITE_BOOTSTRAP_OUTER47',kappa=cap,kappa_decimal=format(float(cap),'.18e'),native_kappa=native,exact_gain=cap-native,source=dict(word_sha256=expected_word,external_receipt_hashes=external,receipt_hashes=receipt_hashes,engine_hashes=engine_hashes,arithmetic_source_pr='https://github.com/CrocSwap/integer-mult-bounds/pull/321',arithmetic_source_head='c76247701762feb2c5bea5bcf302b010eb7d1bc3',structural_admission='Consumed only; the enclosing full verifier must bind and admit these exact structural receipts.'),prime_threshold=dict(Q=P,lucas_lehmer_residue=ll,density=rho,growing_prime_regime_retained=True,all_permitted_primes_q_at_least_Q=True,current_frame_and_bank_exclusions_below_2_power_80=True),complete_literal_invoice=bill,bit_profile=dict(m=m,W=W,histogram=H),ordinary_saving=dict(value=coarse,complex_limit=complex_limit,strict_complex_cap=strict_complex_cap,complex_binds=coarse0 + patterns=tile({r:300*n for r,n in census.items()},100) + result=dict(physical_replicas=300,original_residual=original,census=dict(census),deleted=deleted,entrance_rank=saved,changed_helpers=changed,patterns=[dict(widths=w,count=n)for w,n in patterns],note='entrance_rank is total initial/final endpoint residual saving') + Path(output).write_text(json.dumps(result,sort_keys=True,indent=2)+'\n');print('PASS exact tiling',sum(n for w,n in patterns),'banks',dict(census),flush=True) +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('base');ap.add_argument('candidate');ap.add_argument('output');ap.add_argument('--source-root');a=ap.parse_args();run(a.base,a.candidate,a.output,a.source_root) diff --git a/research/w3-staged354-signed20-native/code/upstream-pr321-fixed_prime.py b/research/w3-staged354-signed20-native/code/upstream-pr321-fixed_prime.py new file mode 100644 index 0000000000..79b1ddff10 --- /dev/null +++ b/research/w3-staged354-signed20-native/code/upstream-pr321-fixed_prime.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +"""Exact p10 fixed-prime/full-fallback arithmetic on freshly admitted PR320 outputs.""" +if not __debug__:raise SystemExit('Assertions required; refusing optimization') +import sys +sys.dont_write_bytecode=True +sys.set_int_max_str_digits(0) +import argparse,hashlib,importlib.util,json +from decimal import Decimal,ROUND_FLOOR,localcontext +from fractions import Fraction as Q +from pathlib import Path +ROOT=Path(__file__).resolve().parent +GRID=10**27 +PRIME=(1<<127)-1 +ETA=Q(1,10**24) +BETA=Q(1,10**9) +BASE=Q(384599485948493,5*10**17) +INITIAL=Q(384599,10**10) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def ld(p):return json.loads(p.read_text(encoding='utf-8')) +def serial(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):serial(v)for k,v in x.items()} + if isinstance(x,(list,tuple)):return list(map(serial,x)) + return x +def load(n,p): + s=importlib.util.spec_from_file_location('p10_fixed_'+n,p);v=importlib.util.module_from_spec(s);s.loader.exec_module(v);return v +def gridk(a,eta=ETA): + q=a*(1-2*eta);v=(1-eta)*q/(1+q)*GRID + return Q((v.numerator-1)//v.denominator,GRID) +def moment(H,m,W,a,cost,rho): + lo,hi=cost.moment(H,m,W,a,False);l,u=cost.logarithm(Q(m));e,f=cost.exponential(a*l,a*u) + w=Q(32*m*sum(H.values()),W)*rho + return cost.floor(lo+w*e),cost.ceil(hi+w*f) +def second(H,m,W,a,other,rho): + lo,hi=other.moment(m,W,list(H.items()),a);l,u=other.log_bounds(Q(m)) + w=Q(32*m*sum(H.values()),W)*rho + return lo+w*other.exp_bounds(a*l)[0],hi+w*other.exp_bounds(a*u)[1] +def certify(H,m,W,cost,other,rho): + with localcontext()as c: + c.prec=90 + terms=[(Decimal(r*n)/Decimal(m*W),(Decimal(m)/Decimal(r)).ln())for r,n in H.items()] + f=Decimal(32*m*sum(H.values()))/Decimal(W)*Decimal(rho.numerator)/Decimal(rho.denominator) + lm=Decimal(m).ln();lo=Decimal(0);hi=Decimal('.003') + for _ in range(270): + a=(lo+hi)/2 + if sum(p*(a*l).exp()for p,l in terms)+f*(a*lm).exp()<1:lo=a + else:hi=a + a=Q(int(((lo+hi)/2*GRID).to_integral_value(rounding=ROUND_FLOOR)),GRID) + b=a+Q(1,GRID);x=moment(H,m,W,a,cost,rho);y=moment(H,m,W,b,cost,rho);u=second(H,m,W,a,other,rho);v=second(H,m,W,b,other,rho) + assert x[1]<10 + return max(1,ceilq(36/delta**2),ceilq(2*(4+(C-1).bit_length())/delta)) +def validate_invoice(i,bp,p): + m=i['m'];T=i['physical_replicas'];stock=i['literal_stock'];E=i['positive_rank_children'];mass=i['rank_mass'];N=2*m + assert(m,T)==(100,60) and bp['m']==m + assert stock==bp['literal_stock']==5*bp['W'] and E==bp['literal_children']==5*bp['calls'] + assert mass==bp['literal_rank_mass']==5*bp['rank_mass'] and m*stock-mass==T*2040 + assert i['fallback_per_child']==32*m*m and i['simultaneous_extra_work_streams']==1 + assert i['generic_wrappers']==E*(8*m*m+8) and i['matrix_preparation']==E*128*N**3 + assert i['copy_erase_episodes']==5*20*T and i['bridge_additions']==T*6*960 + assert i['route_families']==T*(24*960+10*8223) + assert i['high_affine_factors']==i['route_families']*16*(m*m+1)**2 + assert i['low_transposition_coefficient']==i['route_families']*(stock+20) + C=i['unit_expanded_additions']+i['high_affine_factors']+i['low_transposition_coefficient']+i['generic_wrappers']+i['matrix_preparation']+16*m**3+i['copy_erase_episodes']+E+i['extra_bank_selector_calls']+1 + assert C==p['coefficient'] and C<2**802**80 and all(PRIME%d for d in(2,3,5,7,11,13,17,19,23,29,31)) + bp=ma['bit_profile'];H={int(k):int(n)for k,n in bp['histogram'].items()};m=bp['m'];W=bp['W'];rho=Q(2*m**3,PRIME) + assert m==100 and sum(H.values())==bp['calls'] and sum(r*n for r,n in H.items())==bp['rank_mass'] + assert m*W-bp['rank_mass']==24480 and max(H)==42Q(ma['bit_root']) + cap=gridk(coarse);chain=[INITIAL];gaps=[] + for level in range(1,21): + old=chain[-1];a=(1-coarse)*coarse+coarse*old + ds=dict(atom=coarse-a,borrowing=1-a-coarse,remainder=1-a-coarse*(1-old),stock=1-coarse) + assert old0 + delta=min(ds.values());L=cutoff(delta,C) + assert Q(L)*delta**2>=36 and Q(L)*delta>=2*(4+(C-1).bit_length()) + chain.append(a);gaps.append(dict(level=level,gaps=ds,minimum_gap=delta,cutoff_log2_at_charged_coefficient=L)) + if gridk(a)==cap:break + else:raise AssertionError('Finite bootstrap budget20 exhausted') + bridge=ma['finite_bridge'];bridge['rows']['degree_gap']=Q(bridge['rows']['degree_gap']) + complex_saving=Q(ma['complex_coarse']);assert coarse<(1-BETA)*complex_saving + assembly=outer.assembly(chain[-1],complex_saving,bridge,cap,eta=ETA,beta=BETA) + assert len(assembly['strict_constraints'])==47 and len(assembly['margins'])==7 and min(assembly['strict_constraints'].values())>0 and cap>BASE + controls=[] + def reject(name,fn): + try:fn() + except(AssertionError,ValueError):controls.append(name) + else:raise AssertionError('Mutationaccepted '+name) + for a in(chain[-1],coarse):reject('adjacent kappa at '+('finite leaf'if a==chain[-1]else'coarse cap'),lambda a=a:outer.assembly(a,complex_saving,bridge,cap+Q(1,GRID),eta=ETA,beta=BETA)) + for key in('fallback_per_child','matrix_preparation','generic_wrappers','literal_stock','copy_erase_episodes','high_affine_factors','low_transposition_coefficient'): + bad=dict(fin['paid_inventory']);bad[key]-=1 + reject('undercharged '+key,lambda bad=bad:validate_invoice(bad,bp,fin['q_power_bound'])) + reject('zero finite cutoff gap',lambda:cutoff(Q(0),C));reject('zero invoice coefficient',lambda:cutoff(Q(1,2),0)) + tau=1-x[1];linear=1-Q(bp['rank_mass'],m*W)-rho*Q(32*m*bp['calls'],W);assert tau>0 and linear>0 + oldeta=gridk(coarse,Q(1,10**12)) + result=dict(status='PASS_SOURCE_BOUND_FIVE_NEW_KERNELS_P10_PRIME_THRESHOLD_FULL_FALLBACK_BOOTSTRAP_OUTER47',kappa=cap,kappa_scientific=format(float(cap),'.17e'),baseline_kappa=BASE,candidate_native_kappa=Q(pin['supplier_kappa']),candidate_native_gain_over_public_parent=Q(pin['supplier_kappa'])-BASE,exact_gain=cap-BASE,additional_threshold_bootstrap_gain=cap-Q(pin['supplier_kappa']),binding='bit',conditional=True,lean_certificate=False,supplier_reused_stages=reuse,new_kernel_entries=5,kernel_entries_total=780,new_kernel_selection_sha256=pin['new_kernel_selection_sha256'], + source=dict(public_pr=pin['public_pr'],public_parent_head=pin['public_parent_head'],derived_source=True,manifest_sha256=vr['manifest_sha256'],compressed_source_word_sha256=sha(source/'bitword/selected/bit/word_p10.json.gz'),emitted_global_program_sha256=fin['source_binding']['global_program'],local_tagged_word_sha256=fin['source_binding']['tagged'],replay_certificate_sha256=sha(replay/'certificate.json'),replay_verification_sha256=sha(replay/'verification.json'),source_unchanged_during_checked_replay=True), + fixed_prime=dict(minimum_prime_threshold=PRIME,policy='Every prime q at least this threshold; retain the source all-size q-growth and prime-supply regime. No replacement by a constant-modulus machine.',uniform_density_upper_bound=True,exponent=127,lucas_lehmer_iterations=125,lucas_lehmer_residue=ll,density=rho,density_formula='2*m^3/q',actual_basis_inventory_sha256=pr['basis_inventory_sha256'],actual_unique_bases=pr['unique_bases'],retained_residual_upper=2**80,named_factors_upper=31), + bit_profile=bp,whole_literal_invoice=fin['paid_inventory'],finite_coefficient=C,full_fallback_retained=True, + root=dict(lower=coarse,upper=nextcoarse,first_lower=x,first_upper=y,second_lower=u,second_upper=v), + complex_supplier_unchanged=ma['complex_coarse'],ordinary_bootstrap=dict(initial=INITIAL,seed_justification='The freshly verified baseline ordinary leaf is stronger than INITIAL; use its weaker admitted bound as the seed.',verified_baseline_leaf=baseline_leaf,seed_gap=baseline_leaf-INITIAL,levels=level,chain=chain,gaps=gaps,eta=ETA,beta=BETA,grid=GRID,coarse_grid_cap=cap,eta_1e_12_cap=oldeta), + moment_gaps=dict(delta_tau=tau,delta_linear=linear),growing_prime_regime=dict(retained=True,all_primes_above_threshold=True,coefficient_below_threshold=C= threshold, each exact basis denominator and bank-normalizer factor is a unit, rho(q)=2m^3/q <= the priced threshold envelope, and C*q^10000 < q^10001. The unchanged supplier prime-supply and asymptotic q regime are retained.'),assembly=assembly,finite_bridge=bridge,negative_controls=controls, + scope='Conditional sufficient finite construction under the unchanged PR320 public all-size compiler, weighted-selector, common-ancestor-chart, restored-row, routing, prime-supply, recovery and complex analytic interfaces. The derived complete p10 word, regenerated banks, geometry and full finite invoice are freshly admitted; only the source-identical complex supplier is inherited unchanged. No universal machine or Lean certificate is asserted.', + cutoff_scope='Displayed cutoffs use the freshly charged primitive coefficient. As in PR320, the full asymptotic cutoff also multiplies every inherited primitive, wrapper and preceding ordinary-level constant; those retained public interfaces remain conditions.') + output.write_text(json.dumps(serial(result),indent=2,sort_keys=True)+'\n',encoding='utf-8');print(result['status'],str(cap),format(float(cap),'.17e'),'levels',level,flush=True) + return result +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('replay',type=Path);p.add_argument('output',type=Path);p.add_argument('--source',type=Path);a=p.parse_args();run(a.replay,a.output,a.source) diff --git a/research/w3-staged354-signed20-native/discovery/SIGNED20-EXPECTED.json b/research/w3-staged354-signed20-native/discovery/SIGNED20-EXPECTED.json new file mode 100644 index 0000000000..571262286b --- /dev/null +++ b/research/w3-staged354-signed20-native/discovery/SIGNED20-EXPECTED.json @@ -0,0 +1,72 @@ +{ + "actual_sessions": { + "native_discovery": [ + 25027, + 0 + ], + "portable_cp312": [ + 61606, + 0 + ] + }, + "adds": 358152, + "banks_per_stage": 396780, + "bit_coarse": "200951867372647/250000000000000000", + "bootstrap_levels": 8, + "changed_helper_endpoints": 740, + "changed_projector_charts": 3340, + "code_sha256": { + "audit_signed_twenty354.py": "2f956494b71cec06e3591135328a29e453cc2f1d1cf6e272eae9a4499bb5ac9e", + "generalized_twin_signed354.py": "74bcec2f8ae32345cb375a519c892dee3bd0bb26596ee4a9b5715a2f63cc2a70", + "generalized_twin_two_more354.py": "aec59caef2c0ddf0e578fe0209c59083e4224f83ed175a576c0c739fa2e4430e" + }, + "coefficient": 120718938573985001, + "columns": 11450, + "files": { + "final": { + "249-states.json": "7eb8e23b858a525754eea3075b3a149bf69a69bb6149872cbd872a2c2f3883f9", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "COHORT249-INITIAL.json": "1854658f58bc9de5642fbdf9538e93c35ce7a14cef6b04d02708feb25d343232", + "COHORT249-RECORDS.bin": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb" + }, + "intermediate": { + "249-states.json": "077a3e16a361fe1cd650d04535624fb306f7bc5dc5718ef30996b6459bc8b0a6", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "c20b8a07afe23e4c30132c770984ea2c10d37834bae338196236046da8489d40", + "COHORT249-INITIAL.json": "ce065ff1abc11517ee02eeda8e14aa22055df06eae5c431def7a245180c178be", + "COHORT249-RECORDS.bin": "8e9996b6819c1129b2507e3915842507d9dbe28077c7505bf57ebeaa6e53777e", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "3526c2d515706f0222393ce4a0949525dc7f44fd8802374f27eb012ce9f16beb" + }, + "source": { + "249-states.json": "79de66272d4092010cf7cd342fcb4b6c50268f92c3e3cb844194758f9fc433f9", + "COHORT249-FINAL.json": "0ff88d85207a7c0c5fecbb2f093f853d512a88650e9f78a8ff29d0a39d500fd4", + "COHORT249-FRAMES.json": "1550d26e4569e400817d1c1de4dc30fd0a6458bb8d41597c5f80a7aa7d1e9109", + "COHORT249-INITIAL.json": "3c90f37c23a092855baf4def0ca489c09b11ecbfed366888d096ea326badae14", + "COHORT249-RECORDS.bin": "2aa5b4af88e4295588079cf951a5655bdff861588d39ba8af43c185ee93d14b6", + "COHORT249-SELECTION.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356", + "frames.json": "583303099bceb6468167f71adf74fd86ee56b3646bd6af3700f160b2fdef9691" + } + }, + "frames": 13887, + "helpers": 7610, + "kappa": "401580942485227026650141/500000000000000000000000000", + "literal_stock": 3135900, + "max_new_chart_factors": 131, + "native_kappa": "4015809407857/5000000000000000", + "native_verification_sha256": "80a269cb54e4f4a7db761b4236449794e01d4fe54322a1454db13e0ffa4d06c8", + "new_frame_charts": 1002, + "normalized_stock": 627180, + "normalizer_factor_ceiling": 787, + "paid_calls": 46004, + "payload_bits": 88, + "rank_mass": 169100, + "records": 406292, + "residual": 132260, + "selector_charge": 1806128697000, + "source_word": "6e0fcf5dd38d18a057a841b5dca56a4ab9c2d0489f37bc72a54a277d3f068330", + "units": 358152 +} diff --git a/research/w3-staged354-signed20-native/provenance/PR348-MANIFEST.json b/research/w3-staged354-signed20-native/provenance/PR348-MANIFEST.json new file mode 100644 index 0000000000..08f47d3a8e --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/PR348-MANIFEST.json @@ -0,0 +1,78 @@ +{ + "description": "sha256 of every file of research/w3-p10b-pointwise-complex except this one; verify.py requires the package to be exactly these files", + "files": { + "NOTICE": "89d5e68252ca35205382e39a9e0c6b317c36f2d8be435c4faee6364d83392370", + "PROOF.md": "65539c02cfebca3dc93aebcf3fc228f6baae1ff6c9db05ef4362ef69db56bb71", + "README.md": "65ff95f63441f902912e1cbe24897bcd77fb018769ad6d184e8dc33386af0387", + "SOURCE.json": "8af41f59ebe6ac70cafc04d576309ee03f873c80f7275869d57c3b9d103a19c4", + "aligned_word_p.py": "bca04f6027c6c6696c1593767487dffa0965cbd7c9fc83493552de4569857757", + "aligned_word_spec.py": "6d249179796ecf5aa3e2722e65d98485510752861dc78465498f4cdce7e219ee", + "bit/pr346/FINAL-RECORDS.bin.gz": "fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6", + "bit/pr346/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "bit/pr346/NOTICE.md": "02b59cc0542c78f409d30ce4fd546a806b606b76e185acd9aad1e32deb705008", + "bit/pr346/RECORD-SHA256SUMS": "21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2", + "bit/pr346/kappa-L10f.json": "5b93dee60fb047f70f0b20e3e4bb84f3992515fbc39fc9d27788cd9ae2d950a8", + "centre46.py": "40e36dbb4b8a6a2ddb7c947433522d31efbb1ed92969eab7b9da03dacf4e8f9b", + "certificate/expected.json": "3a008374da466c2885bb1cad1309c5871ab2b09f8fc0c6eb1cfcebbf63314930", + "certificates/gcert1-p10-b325-c2.json.gz": "5c51f5d5c70ef53526740e140d435828ae6bb2be072aae9eca3bc2c40f11265f", + "discovery/README.md": "f445c7bb8b026294175ef8c57a99ca56aae2fae51611c35b39411e4e808b1b8d", + "discovery/pipe.py": "dccba23ec014a995a65149784ca2b3208231c11a33a0c327608b0c57045406f2", + "discovery/pr327/add_centre.py": "891c89f436ebe9e785c98b5e48b85a875dcf18c08fe5f6aac754b59b36502512", + "discovery/pr327/extend_floor.py": "6762dd49b801f2419416bcf2c60b6390605a382d252b30679cf53a024aaa8126", + "discovery/pr327/make_layer_p.py": "ea339b774109bbfb4ca5c00ff164d7ddff4c3c97433ab064b0a8d78744c3469e", + "discovery/pr327/pairs_mw_p.py": "7f619d53d1109626f8f3307b1735606572645518d07ac4f423b851939ff56382", + "discovery/pr327/pr233/README.md": "1bd628da0afbccfd9baafc2d51cd96a51a4e46c782b783a1c16bea04fd88d98c", + "discovery/pr327/pr233/bundles.py": "71c81bc858e62e03e2a5230c16c4c199a027c24402cdc937bd4ded60f4ee3286", + "discovery/pr327/pr233/joint.py": "e4857418f6e16d6fbb1815d3c4148116e35a6b9940cb57acb2b563da5621b92c", + "discovery/pr327/pr233/matching.py": "59d1cd30e67d3511cf799140eb248e785e77aaccff7c47a22a0feef8fb6f021e", + "discovery/pr327/pr233/pairs_mw.py": "aa927718ad27bebcfa2bddeb3704d4721433c2d4e6b6e218ceb9d28a07cd6c83", + "discovery/pr327/pr233/physical_opt.py": "cbfd06026a44df30944781262848c88ec987ca5e80381e35ae7ad715a9db1fce", + "gcert_emit.py": "10d2fc3f1f3d8cda5f0b07720f51b5a6fd40cfc1490d361939ff93e5470805d3", + "gx/gx.py": "6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95", + "gx/gxcore.py": "eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517", + "layers/c2/kernel-pairs-mw.json": "709cf1e26557c94ee86dff46265518ac903f8f691d5af273bc7f407a9db1f431", + "layers/c2/matching-arcs.json": "99029733d575d67ff8a69b91f37d45274478b40a6265f510b96f08c2e417f245", + "layers/c2/physical-frames.json": "8fc1c64d2f10ad276818b5886caad1d58a40996868e7704fd358469e279d28a2", + "layers/c2/physical-pairs-mw.json": "eb2903eb019c460fad111ce42bcbdf0ee19df1e5361611db12036c1ad4032951", + "layers/uniform/kernel-pairs-mw.json": "709cf1e26557c94ee86dff46265518ac903f8f691d5af273bc7f407a9db1f431", + "layers/uniform/matching-arcs.json": "99818cca6260ecd2cb010fdb5ccc4f35998ac33e0d98ae9d487e0452254abfec", + "layers/uniform/physical-frames.json": "85a57de777bb0e5410612807208e741f3d2688bd4c0ae05a1e356befe609f50d", + "layers/uniform/physical-pairs-mw.json": "9cb7988300b3d393ff42e77442382316abe06fa5c03a53ef100242f9f8c89f6b", + "lean/companion-7932-evidence.txt": "005f0d3a0dfc02d46999eda86f1dbe1ee0c8d3d18e958072295a4031169bd0da", + "module_cut.py": "4004cce8e4b392d90db02862e1d631aca586483a59532de9eca426504ff1293f", + "modules/pm_p10.json": "8d71f5004acb0ea902ad594a7d298f8d2099114e5d6d42c6357f09c44ab3ce87", + "modules/pointwise/pmod_i0.json": "7d9c0aaf02fbb91a7004821adcd9bdcc577513a4052cd21689a8e1bea7616ce5", + "modules/pointwise/pmod_i1.json": "867744aacd6ce119954ad2ba2de51819551e590a22eae4815ba6a111d16ef748", + "modules/pointwise/pmod_i2.json": "0c56f9e38be7d6c9e4968012afcc37479c114453a2dad6a0ff64b5a446123f16", + "modules/pointwise/pmod_i3.json": "7d9c0aaf02fbb91a7004821adcd9bdcc577513a4052cd21689a8e1bea7616ce5", + "modules/pointwise/pmod_i4.json": "867744aacd6ce119954ad2ba2de51819551e590a22eae4815ba6a111d16ef748", + "modules/pointwise/pmod_i5.json": "5e7f9239867d066850dcca94106cab8420fd04b494e7718526311ecc08950117", + "modules/pointwise/pmod_i6.json": "5e7f9239867d066850dcca94106cab8420fd04b494e7718526311ecc08950117", + "modules/pointwise/pmod_i7.json": "a10816b44292874da2d7596b044b9be876e112ca00581bde2ef9a74213b10dc3", + "modules/pointwise/pmod_i8.json": "5e7f9239867d066850dcca94106cab8420fd04b494e7718526311ecc08950117", + "modules/pointwise/pmod_i9.json": "953e80941984780dfba6952537cace9d1214270bda5735f27dc1cfe020cfcef6", + "modules/qmod_p10.json": "40ffb168466bc016bc18a2bbdde65d38b7fd1b406d8a4026f1a6e517fe153459", + "modules/tmod_t2_p10.json": "4d39faeedfb5a5283a7ad34a8a18af93072e4d155d61dec6c28d7751bc2e4e04", + "normalize_scatter.py": "403ef1db92bafcb973857063bc96ec9ac326838b7595af642d5f11fef3350211", + "paircheck.py": "acde7bef664c2b0aa9f0c99424053ff4cf5091e4eb7bba7e048f5a51e0933b31", + "pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "references/centre46_graph.diff": "229eea46b56d19b262d1498f489f9bca84c347e33b16553079d38c4276700280", + "references/pr233-layer/NOTICE": "5826b9f155b70d496d729cbaddeadb881abfb68da77f82dfc1746ddfc753313b", + "references/pr233-layer/SOURCE.json": "9ad0549ba2403e8d84d7c0c8e71e5ca952a0604ad626f403426164bd4bc2982c", + "references/pr233-layer/baseline-pr202.tar.gz": "5d08386f71c421d2b83b21020e3b74198e9d0c75884d7d81987307740d98883f", + "references/pr233-layer/certificate.json": "691cb0aaeb0d6b993e1e1e5116ae7a5c57af058a8c413249016347d1b40d3b90", + "references/pr233-layer/verify.py": "cd61a8c61462b4eee95c0858335a9a11bdf1ff8e8e63ebb1e488da29f061ca71", + "references/pr233-layer/witness/kernel-pairs.json": "e33b753fc4519170373207b0527b9cb53e0b552e2a27f48f72381a881c7a227f", + "references/pr233-layer/witness/physical-frames.json": "1a6c215cdc58216f7ec96fb898a471e25d094fd86de085f6c06e86fd8997bfad", + "references/pr233-layer/witness/physical-pairs.json": "e6409fffbf5f3b1ac6434acf2e426503de3a8a18537b8fee761fc4fc931fb896", + "references/sussman/pr193-blocks.json": "4049d066f71119fa72bbc37f7db753ce1e79ae5a69aef9cd2651d618bea5c855", + "scripts/moment.py": "0c7c68122cea18503e973ccf0d244adf8fa0edab95f104393528c6c57f24863a", + "scripts/source527/NOTICE": "c461d8aef9a0c1ec5015a300bdbf37e566610d50139d730ba677eb0df5d7ffe0", + "scripts/source527/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "scripts/source527/moment.py": "9d465c716c6b910ff66e1453e3bf0057608a787b5f5361be93781f42cb3370f7", + "spec/c2.json": "569bd70b4d945ccc42e3ff84f8901af49b65f77f97cabe2e2655443244c067b5", + "spec/uniform.json": "c0f1bfed8343ed2a0cbb374b175ff2dd194757116edf8c1b6de656ddc3bd042a", + "spec_graph.py": "8dc9a58bd6f5a4bc8e29a4550464dba65583dc1a8d3a3e4cb82b66d5489ab3c2", + "verify.py": "12c49aa6b943f7ecdc5380c4018b2598b882fd99d8c78f3ecd961a8011bf238a" + } +} diff --git a/research/w3-staged354-signed20-native/provenance/PR348-NOTICE.md b/research/w3-staged354-signed20-native/provenance/PR348-NOTICE.md new file mode 100644 index 0000000000..ebd612a2be --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/PR348-NOTICE.md @@ -0,0 +1,57 @@ +Prepared by Chafik Boukhalfa with substantial Anthropic Claude assistance. Apache-2.0. +Inherited files keep their original notices and assistance disclosures. This package claims no exclusive priority +over concurrent work. + +What this package contributes: +- the per-point p = 10 complex program (claim 7940/10^7, coarse b = 794022782431403/10^18), together with its + pointwise pair modules, its frozen layer and its spec; +- the per-invocation module spec and builder (spec_graph.py, aligned_word_spec.py, and anchors (e) and (f)); +- the composition of that program with PR #346's bit word, an independent recount of that word's paid children, + and the reproduction of PR #346's kappa; +- verify.py, MANIFEST.json and the git-blob pins of SOURCE.json. + +Everything else is retained and credited: + +- LJH-217 / Louis Harrison (Anthropic Claude assistance), PR #346 (research/w3-p10b-complex-p10 at 11b4de5): the + final w3 bit word on PR #325's p10b word. It is vendored unchanged in bit/pr346/, with its records, hash list, + kappa receipt, LICENSE and NOTICE.md. PR #346 also composed it with a p = 10 complex supplier and computed the + complex-bound kappa that this package reproduces. Its bit word's own checks (Design T verifier, PR #266 + checkers, primes, bank tiling) are PR #346's and are not re-run here. +- utcorvusvolat-dotcom: PR #310, the w3 Design T and twin condensation, with their builders and cost model, which + PR #346 ported to h = 20. +- PR #266's official cohort legality and five-stage column checkers, as run by PR #346. +- DreamingOfClouds (Anthropic Claude assistance): + - PR #325 (c4f1b74): the p10b bit word under PR #346's, the re-annealed pair module pm_p10.json (the default pair + module of the spec and the start of the pointwise climb) and the all-but-one module qmod_p10.json; + - PR #315: the p = 10 five-stage package, qmod_p10.json, the centre-sharing Graph.finish patch, and the outer + assembly convention (complex-bound path) used for kappa; + - PR #327 (40ed045): the p = 10 complex supplier, its recipe and chain (aligned_word_p.py, centre46.py, + paircheck.py, normalize_scatter.py, module_cut.py, discovery/pr327/), the triple module tmod_t2_p10.json, and + verify.py, which this verify.py generalises; all vendored byte for byte; + - PR #304: the p = 11 recipe. +- Jacob Sussman (Anthropic Claude assistance): gcert/1, gx.py and gxcore.py (vendored unchanged in gx/, + Apache-2.0, Copyright 2026 Jacob Sussman, jacobalansussman/wht-power-saving-lean at f010392c), the bridged + five-stage layout B_2, and the Lean generator and Compare.lean used for the companion program. +- chafreaky / Chafik Boukhalfa (Anthropic Claude and OpenAI Codex assistance): + - PR #233: the maximum-weight pairing, and the layer package vendored in references/pr233-layer/; + - PR #200: the frame descent and the complete complex checker; + - PR #256: the gcert emitter gcert_emit.py; + - PR #225: scripts/moment.py; + - PR #329: pricing/outer.py, which is PR #315's unchanged. +- icekylinx (OpenAI GPT-6 Astra and Codex assistance): PR #144 paired cubes and Graph.finish; PR #184 the + source-assisted construction, frame flow, exact lift and contract. +- Avi Eisenberg (ikeboy): PR #191/193/194/202, the source-aligned pipeline and the PR #202 baseline. +- eumemic (Anthropic Claude and OpenAI Codex assistance): + - PR #168 modules and frames; + - the source527 rational moment engines (scripts/source527/, see its NOTICE); + - outer.py, the 47-constraint outer assembly of PR #315 (from icekylinx's PR #144 and Zhihao Chen's PR #23, + with hipotures' balanced prefix). +- DaysSky: PR #162, the extended carrier closure. +- hcg890: PR #234, the five-stage architecture and the 10^-16 fallback envelope. +- SovereignSteak: PR #250. +- Evan McKinney: the completed banks of the five-stage packages. +- Rohan Arun: the joint-dual re-pin in PR #327's head. +- The PR #202 baseline lineage, as credited in references/pr233-layer/NOTICE. +- OpenAI: the original complex phase network of "Integer multiplication below n log n". + +The credits above do not imply review or endorsement by the credited authors. diff --git a/research/w3-staged354-signed20-native/provenance/PR348-README.md b/research/w3-staged354-signed20-native/provenance/PR348-README.md new file mode 100644 index 0000000000..cfea704e2d --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/PR348-README.md @@ -0,0 +1,123 @@ +κ = 7.93392809291691e-4 + +# PR #346's w3 bit word with a per-point p = 10 complex supplier + +A conditional finite construction with **κ = 793392809291691/10¹⁸ ≈ 7.93392809291691 × 10⁻⁴**. That is ++8.127·10⁻⁷ (+0.1025 %) over PR #346 (κ = 396290046684973/(5·10¹⁷) ≈ 7.92580093369946·10⁻⁴). + +PR #346 (LJH-217) put PR #310's w3 Design T and twin condensation on PR #325's p10b bit word. That word's bit +coarse saving lies above every known complex cap, so κ is set by the complex supplier. This package keeps PR +#346's bit word unchanged and replaces its complex supplier with a stronger p = 10 program of the same recipe. In +that program each point i has its own pair module, shared by both bits. + +| side | supplier | coarse saving (10⁻¹⁶ fallback) | +| --- | --- | ---: | +| bit | PR #346's final w3 word on PR #325's p10b word (vendored) | c = 32069035133443/(4·10¹⁶) ≈ 8.01725878336075·10⁻⁴ | +| complex, PR #346 | p = 10 gcert/1 program, PR #325's pair module, flow R 6,265 | 396604388013523/(5·10¹⁷) ≈ 7.93208776027046·10⁻⁴ | +| **complex, this package** | **p = 10 gcert/1 program, pointwise pair modules, R 6,253** | **b = 794022782431403/10¹⁸ ≈ 7.94022782431403·10⁻⁴** | + +Both suppliers make the complex side bind. Here the bit saving is capped one 10⁻¹⁸ grid point below the leaf cap +(1 − 10⁻⁹)·b and fed through PR #315's outer assembly, which checks 47 strict constraints and the finite bridge. +`verify.py` first reproduces PR #346's κ exactly from PR #346's b, then computes κ from this package's b. In both +cases the next 10⁻¹⁸ κ and the cap itself are rejected. + +## Complex supplier + +The word, recipe and chain are PR #327's (at `40ed045`): the source-assisted complex word of PR #184/#194 at +p = 10, with the centre-sharing graph, HK carrier arcs plus PR #162's extension, PR #200's frame descent, PR #233's +maximum-weight pairs, PR #184's flow and exact lift, PR #194's contract and PR #256's emitter. The query modules +come from `spec/c2.json`: + +- triple module: PR #327's `tmod_t2_p10.json`; +- all-but-one module: PR #325's `qmod_p10.json` (PR #315's), the same for all 90 invocations; +- pair module of point i (both bits): `modules/pointwise/pmod_i{i}.json`. These six distinct files were found by a + greedy climb that started from PR #325's `pm_p10.json` (`discovery/README.md`). Each has 36 inputs plus the + star-centre root, and `centre46.load_pmod46` checks its contract. + +| program | R | W | N | blocks | a | rejected | coarse b (/10¹⁸) | Lean | +|---|---|---|---|---|---|---|---|---| +| PR #327 centre-mw | 6,455 | 10,295 | 165,940 | 47,979 | 7795/10⁷ | 7796/10⁷ | 779597612622781 | 1 − 7795973/10¹⁰ | +| shared #325 modules (`spec/uniform.json`; same b as PR #346's supplier) | 6,265 | 10,105 | 162,140 | 47,619 | 7932/10⁷ | 7933/10⁷ | 793208776027046 | 1 − 7932084/10¹⁰ | +| **pointwise pair modules (`spec/c2.json`, this package)** | **6,253** | **10,093** | **161,900** | **47,599** | **7940/10⁷** | **7941/10⁷** | **794022782431403** | **pending** | + +**Status of the 7940/10⁷ program.** Sussman's reference checker `gx.check1` (exact scalar identity) and his +`gxcore` mirror of the two Lean checks accept it, and both reject a flipped sign. It also passes the rest of the +chain: `paircheck.py`, PR #200's checker, the exact flow lift and PR #194's contract (13/13). `verify.py` +regenerates it byte for byte. **Its Lean run is pending**: the host with the Lean toolchain needs an interactive +re-authentication. The companion program with one shared pair module (7932/10⁷) went through the same pipeline and +was built in Lean (`lean/companion-7932-evidence.txt`). The per-point program uses the same generator path, with +only its module files changed. + +## Bit side + +PR #346's final word is vendored unchanged (`bit/pr346/`). It consists of: + +- its final records (`FINAL-RECORDS.bin.gz`, checked against its `RECORD-SHA256SUMS`); +- its κ receipt (the normalized five-stage histogram, the stock W = 125,712 and c); +- its LICENSE and NOTICE. + +`verify.py` decodes the records with its own reader and recounts the paid children (MOVE and COPY ranks). It then +requires PR #346's normalized histogram to equal 60·H + 12·2v·(e₃₈ + e₁₉ + e₄₂ + e₄), and certifies c from it with +both rational engines. The stock W is taken from PR #346's receipt and is not re-derived. PR #346's own bit checks +are not re-run here: the Design T verifier, PR #266's legality and five-stage column checkers, primes and bank +tiling. Since the complex side binds, κ depends on the bit word only through c > (1 − 10⁻⁹)·b, and c is 0.97 % +above that cap. + +## Verify + + python -m pip install numpy==2.3.5 scipy==1.17.0 + python3 -B research/w3-p10b-pointwise-complex/verify.py --quick # about 30 s: pins, bit side, program, kappa + python3 -B research/w3-p10b-pointwise-complex/verify.py # about 6 min: also regenerates the program + +Nothing is fetched; `-O` is refused. `--quick` covers: + +1. `MANIFEST.json`; +2. `SOURCE.json`: git blob and sha256 of every vendored file at PR #327 `40ed045`, PR #325 `c4f1b74`, PR #346 + `11b4de5` and PR #329 `c6b1a28`; +3. the bit side; +4. the committed program: canonical sha256 `ff2d7307…`, `gx.check1`, `gxcore`, the E5 controls, and the exact + price (7940/10⁷ with and without the fallback, 7941/10⁷ rejected, b by both engines); +5. κ for PR #346 (reproduced) and for this package. + +The full run also regenerates the program: + +1. it rebuilds PR #202's 308 files from the vendored PR #233 package; +2. it runs PR #327's anchors (a) and (b), then anchors (d) and (e) on `spec/uniform.json`; +3. it runs anchor (f): on the companion's frozen layer, `aligned_word_spec.py --spec` writes the same seven files as + PR #327's `aligned_word_p.py --centre46`; +4. it builds the per-point word with `aligned_word_spec.py --spec spec/c2.json` and runs the whole chain; +5. it requires the committed program byte for byte, and compares the run with `certificate/expected.json`. + +`.github/workflows/w3-p10b-pointwise-complex.yml` runs both modes on Python 3.12 and 3.14. + +## Open obligations + +- The Lean build of the 7940/10⁷ program (pending; see above). +- Everything PR #346 lists as open for its bit word: PR #310's native downstream chain is not ported to p = 10, + PR #315's scalar/prime/finite stages cannot take an edited word, and the complex guard keeps PR #315's p = 11 + additive row constants. +- PR #346 also ran PR #315's portable complex checks, ported to p = 10 (labels, scalar words, splice, precision + guard); they are not run on this program here. This package's complex checks are PR #327's chain plus + `gx.check1`/`gxcore`. +- All inherited interfaces of PR #315/#325/#346 remain assumptions. This is a conditional finite construction, + not a formal verification of the multiplication theorem. + +## Files + +| path | origin | content | +|---|---|---| +| `verify.py` | new (from PR #327's verify.py and PR #329's math_check.py) | the checks above | +| `spec_graph.py`, `aligned_word_spec.py` | new | per-invocation spec and word builder | +| `spec/c2.json`, `spec/uniform.json` | new | the program's spec, and the companion spec used for anchors | +| `modules/pointwise/` | new | the ten per-point pair modules | +| `modules/pm_p10.json`, `modules/qmod_p10.json` | PR #325 `c4f1b74` | default pair module and the all-but-one module | +| `modules/tmod_t2_p10.json` | PR #327 `40ed045` | triple module | +| `layers/c2/`, `layers/uniform/` | new | frozen layers of the program and of the companion | +| `certificates/gcert1-p10-b325-c2.json.gz` | new | the program, star form | +| `certificate/expected.json` | new | the full run's record | +| `bit/pr346/` | PR #346 `11b4de5` | bit word records, hash list, κ receipt, LICENSE, NOTICE | +| `pricing/outer.py` | PR #329 `c6b1a28` (= PR #315's) | the 47-constraint outer assembly | +| `lean/companion-7932-evidence.txt` | new | Lean console output of the companion program | +| chain, checkers, engines, `references/`, `discovery/pr327/` | PR #327 `40ed045` | vendored byte for byte | +| `discovery/` | new | how the modules and layer were found | +| `SOURCE.json`, `MANIFEST.json`, `PROOF.md`, `NOTICE` | new | provenance, pins, claim, credits | diff --git a/research/w3-staged354-signed20-native/provenance/pr346-MANIFEST.sha256 b/research/w3-staged354-signed20-native/provenance/pr346-MANIFEST.sha256 new file mode 100644 index 0000000000..3f822293ad --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/pr346-MANIFEST.sha256 @@ -0,0 +1,118 @@ +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 ./LICENSE +02b59cc0542c78f409d30ce4fd546a806b606b76e185acd9aad1e32deb705008 ./NOTICE.md +bc3ca7ac910e024742d09aa524f3adea81d7226ad1d3afaea588b102d3a31537 ./README.md +82e5ef0c7b6cf84c53bf6039330930242c9a5c8e8ea13183b2805cf9577f7129 ./code/builders/addcomp.py +c0867d68b863ca7d8cdd7002ffed263cbd5525fea4522267b5f640e4eff5597b ./code/builders/build_v5.py +699c424170b41d3711da6a283f58cac824402ca373764365fd05c8e645ed07f5 ./code/builders/decomp.py +8c7d2a34fdcbe75d8ed8299e399d578b32adf44402c773fd905aa7c88e2b460d ./code/builders/gather.py +3b3e2fb894f871a9b6145844faaff34a05add59ae0eb8882c8feb2b914265b8a ./code/builders/interface.py +cfd261d82a31dd9024f1fa191eac2f5d893a7b51833b912459de46a1e9aac003 ./code/builders/twin.py +26f5c9be3a7f545d50be458e3d17403921b5542a7dcd2986c848664a774977a8 ./code/checkers/columns_h.cpp +28a0d8ee29ac75b8a789705454987f07d618f135ed1f1bd45b97f18bcc4163e3 ./code/checkers/exactnd_h.py +aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63 ./code/checkers/json.hpp +5661d0b91e07d95736bde4c1824f27bebaecce0a84e38403f5391ebc51a52056 ./code/checkers/legality_h.cpp +59c1a64f9df61fc50f47d5a78c8f9351875bf6b352db1c9d109c7c90542a4f19 ./code/checkers/sub.hpp +1a5aea81aab652622e6547d901ead6aaf54fdca231da897dd99474c9f64a33bf ./code/checkers/verifyT.cpp +254ecb86795f603e32b01fbf3f3a8ce726a720057ac04579cf87da1014be7ec4 ./code/complex/certify_complex.py +52d68781eaf6d9decf02446a532a7336fcf15924a9f6781ba0833d038decb9f8 ./code/complex/code/complex_basis.py +ccc924537db0c0d55f0c1934e79b8cf4d85b4fb336473d7b42d69e12557aa9f2 ./code/complex/code/complex_gx.py +e8f7a541a712681e9052822b3be31ed7461ac2f60678ba1fb63d418e999049c6 ./code/complex/code/complex_labels.py +456c223b52e057d254d236780aea9ed92acdf25fe71c51b545634f43c770395b ./code/complex/code/complex_scalars.py +3cee3f87d38fe6c15891d3aa09b36c4683a3749ced40616f996a045dc234b40e ./code/complex/code/complex_splice.py +70645dced290c26ef6dbae707c3ef398b1400a356a5dd5503ba71f8959ea5352 ./code/complex/code/p10pins.py +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 ./code/complex/inputs/complex/LICENSE +9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81 ./code/complex/inputs/complex/NOTICE +319165f41cf97f37b587c92351289db2d287ca7a90845338318086d5ff447e84 ./code/complex/inputs/complex/NOTICE-PR304 +c39fddd8a76cd7b14fd19e71a903eebd62e21fd7c00e76e658a190d96074020b ./code/complex/inputs/complex/centre-mw/NOTICE +229eea46b56d19b262d1498f489f9bca84c347e33b16553079d38c4276700280 ./code/complex/inputs/complex/centre-mw/centre46_graph.diff +250aa8f9037e9b6fd59291a9c98ff3c7242ec384c6129c95bf5223dc6c9e77a9 ./code/complex/inputs/complex/centre-mw/exact_result.json +d5a171674141bd2a4ac2e099c9f19dee3600482f06d4f83245a427f402c6b19b ./code/complex/inputs/complex/centre-mw/pmod46_ptc1_final.json +cb71db4928088f0e20913dfe33df215c2a00e2bc33968d8d501f4f647cc920bc ./code/complex/inputs/complex/centre-mw/qmod_q1_snap1.json +3ed4ffb275c3b7fc609d617a2c2b60d761306a1fe306492dc1d9ea9940c41073 ./code/complex/inputs/complex/centre-mw/tmod_final.json +50d8fb96fb3644c0307d8bb81d53811cbcd6b3151ab89dfcdc320676ede09a0c ./code/complex/inputs/complex/gcert1-p10-L10f.json.gz +66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46 ./code/complex/inputs/complex/retained/FINITE_BRIDGE.txt +2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87 ./code/complex/inputs/complex/retained/compact-control-layout.tex +b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6 ./code/complex/inputs/complex/retained/compact-control-movement.tex +00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb ./code/complex/inputs/complex/retained/copied-centers-assembly.tex +d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe ./code/complex/inputs/complex/retained/copied-centers-lemma.tex +dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e ./code/complex/inputs/complex/retained/endpoint-gauge-complex.tex +c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54 ./code/complex/inputs/complex/retained/general-clifford-frames.tex +4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a ./code/complex/inputs/complex/retained/stopped-product-complex.tex +0bdc84476809dda6217864632ed32056254dd7fb29001564f3dddfd73087b77e ./code/complex/inputs/complex/source-pins.json +5c24746a6330907b9b37d6064095035a58575d64ce793d6d7c9881121fdc3980 ./code/complex/inputs/complex/sources/Work__Bridge__Cert.lean +cf7d7d330b1bffe2e66712c873e647b13dc32db1ccfc0e0f4cd62ee6caf584f0 ./code/complex/inputs/complex/sources/Work__Bridge__Net.lean +6d0649eb62589e66057f044e1e2103fc42f3f57a1498f82a26565bd8eb4026d0 ./code/complex/inputs/complex/sources/Work__Carrier__Live.lean +71dc3dda23dfe510d5d53cbada3a6c540cd1dc2825503fda618a5bd6cfc3e812 ./code/complex/inputs/complex/sources/Work__Carrier__Phases.lean +2e8e88efd4dcbdf0b1a6e39ce7eea8c5fd5ffee2faf360a8c0c9cba84c0e4ef3 ./code/complex/inputs/complex/sources/Work__Fourier__Main.lean +c302f5834287421f11f3b0da7112fcde876cbc702896f2af4145b2d72ee393a2 ./code/complex/inputs/complex/sources/Work__GCert__Chain__Geom.lean +ade7e7873da75ca63a4b5ce2f562dde9c12bfbb69d87d7ae831039ff790e5adb ./code/complex/inputs/complex/sources/Work__GCert__Chain__InvThm.lean +22ae34809466b4ac2a2c5cdde526f51ff246f5189f7c142b38aa4c0dcffb04a4 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetCert.lean +6e17a68b1e988969f6eb77000028f7ed877e687b8ad3976ec1707fcfe1d2f520 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetDef.lean +c122bc01392a6fdcc0bee918fed81804d3c9b1d3e071016dab65a4ed804ef0b6 ./code/complex/inputs/complex/sources/Work__GCert__Chain__NetStage.lean +0de429c80231334f1ce92575c1e8ac382ca2d5e7d956767b547639a8941d9a8c ./code/complex/inputs/complex/sources/Work__GCert__Chain__Phased.lean +c33ec3fce09c0971c32ddcbb86d9383ffbe4c6d05cf36f20460005e6547bb845 ./code/complex/inputs/complex/sources/Work__GCert__Chain__WinB.lean +cb61f304da51f1dd0a2ec25bca4b63eb095eeb2863289e1e2bdee7c82beff48b ./code/complex/inputs/complex/sources/Work__GCert__Data__B2Gp193Main.lean +d5314f2b93a7f0e1c949fb502331825bfc6d9d8762d35f865443e7c95b6c7ef7 ./code/complex/inputs/complex/sources/Work__GCert__Data__Glue.lean +9587ddb9961f44938032b609307ab91c0b0e757e3991f1ad95480dd50fd4f72b ./code/complex/inputs/complex/sources/Work__GCert__Data__InstB2Gp193.lean +d92ee6889be4753fc99f467bd84039743325123a1165128378b9c906a04f2703 ./code/complex/inputs/complex/sources/Work__GCert__Data__P193Cert.lean +0299bcd0fe255960eec682eef0f045f7e5cb1e4711af2aab4393526eae2caea3 ./code/complex/inputs/complex/sources/Work__GCert__Data__P193Price.lean +479434815822e98f015e335361089c3788d00dc3dd39c2944f75410aa0c158fe ./code/complex/inputs/complex/sources/Work__GCert__Data__P193ScalOK.lean +6b40cac1481c931d47b1a092e382d04716ede0e785c492a2f2983e886a257c3f ./code/complex/inputs/complex/sources/Work__GCert__Data__RateB2Gp193x.lean +aba94a004c94dcae7cf3047c88a6da9561555f4ebe8ab92e299e6ce09ee7aa66 ./code/complex/inputs/complex/sources/Work__GCert__Data__Raw.lean +45c768c9d71a7cc18bd6db74cb036db880d89580ca60557bb4a492280296b169 ./code/complex/inputs/complex/sources/Work__GCert__Data__SolutionB2Gp193x.lean +feec0a3828867968a5c7c2c30b86ed70449abc3c660a60ada67203a75bae2ef7 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Adapt.lean +34906dbf5ae16b5174db00b4881a5cc1d2e583b8c8806db6523a5e2f86565f09 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Letters.lean +80fb3daa9a45de0ed6da570eb4476b9104734be65d0116f58bcfcbcd67f771d0 ./code/complex/inputs/complex/sources/Work__GFrame__Engine__Level.lean +6ba897a9495ddadcf8558b93133fdfaf66fc35ce7fa2c53e2d5667335c315e0b ./code/complex/inputs/complex/sources/tools__gx__ORIGIN.md +6f3dc8bb639933227a8dae181ec4a542e85c7276be9c9e330f49518e7b630b95 ./code/complex/inputs/complex/sources/tools__gx__gx.py +9c9dcfac47f0535bf3aa8ebf7c662cdef0ebda50a9f0a9282b8f3cf34809f835 ./code/complex/inputs/complex/sources/tools__gx__gxbind.py +dab7fec9f44c2d368ed334055d7126e202017feb46e41a8d86e2d998720f67c2 ./code/complex/inputs/complex/sources/tools__gx__gxconv.py +eb972c06fe8c322db2d9a8d9a7d05596e8f40c4ca8e5f42eb6df3c7361b5d517 ./code/complex/inputs/complex/sources/tools__gx__gxcore.py +8804008eb3d3cb877c597178c7ad39f50df8782f5743ca51c826724d54337688 ./code/complex/pins-p10f.json +464033e906cda0d9e002406ab816ddc3042c7ac1e61992a71111a4a5ede348c2 ./code/complex/portable_complex.py +1161d23b459f7d981d6716073745909126d5465018cbbea7e6e6a9e4e5d68add ./code/export_p10.py +aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098 ./code/pricing/base_two_moment.py +fc03e8f7bf73d7d70346b87c835d44508b0581c9ff9aec708fbbd4f0121e0394 ./code/pricing/certify_bit.py +d55d2b865d1c3d35e343e1a38c592b9172ed8e2596d1107e34d92e2a80c7d03f ./code/pricing/cost.py +81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482 ./code/pricing/moment.py +c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c ./code/pricing/outer.py +7bd5cb48537621f1217d174274d42483da4e2d02feec238643c798c36b30366a ./code/pricing/prime_new.py +98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab ./code/pricing/prime_witnesses.py +38c3f78daac118395565a65fa3543b1c349638ff2519ce7fda0dad2d788e90ae ./code/pricing/tile_check.py +6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a ./code/stage_cohort.py +caabc13126e8f87d08f7697f51512cb3431ff52861f4190149251d8e19224430 ./data/bit/BASE-RECORDS.bin.gz +35070b83d12ebc60003ed344315328713134a43bdb04217c2c5cbc39e101391f ./data/bit/BASE-frames.json.gz +1e37ae5001447dd78a8287d8aa23d73a1d5862c4017f44db49af327f58d7cf22 ./data/bit/BASE-states.json.gz +e7fe9d0686829ad5acf7930698b3c81a866ae834422aa3c9a12057dfae627175 ./data/bit/FINAL-NEW-FRAMES.json +fc4f1986da4585dc1721bcd954a95b3ffb2b562cc7031f40242de81664e3acb6 ./data/bit/FINAL-RECORDS.bin.gz +21f732671eb34468be2252d4dfb81bdec4e7d7cd6564b93a482c2dd925e9c3b2 ./data/bit/RECORD-SHA256SUMS +e037cd3d19d68e08523d09fce1c5f92206567784eb59f1924d93a837e4302fce ./data/bit/labels.json +40ffb168466bc016bc18a2bbdde65d38b7fd1b406d8a4026f1a6e517fe153459 ./data/complex/bit_qmod_p10.json +50d8fb96fb3644c0307d8bb81d53811cbcd6b3151ab89dfcdc320676ede09a0c ./data/complex/gcert1-p10-L10f.json.gz +8d71f5004acb0ea902ad594a7d298f8d2099114e5d6d42c6357f09c44ab3ce87 ./data/complex/pm_p10b.json +4d39faeedfb5a5283a7ad34a8a18af93072e4d155d61dec6c28d7751bc2e4e04 ./data/complex/tmod_t2_p10.json +267e6366b14326d8ea260bfb559cd9be892d70a952453005161db66c45ff9473 ./producer/admit_p.py +90fff7260091c698f2e017086e0b1cdfc0a437e19c8044e4a2c2d75c293ff47b ./producer/aligned_word_p.py +af6d630bdb4a9e07e718dd4e489c26b81ba790e6b80a13e04b3b6c6917ebfd3e ./producer/anneal_pmod.py +637a19620c12fef9915289d49253d1496a6d02d92ce48dab5bf361fe9ed41a53 ./producer/basecost.py +f2adace7e4ccb9a8ff14021c0eb317007ace16e7918461ee0dd79e32bcfbc10b ./producer/certify_complex.py +74adae25a8372f983dd9514842808404e6e01945dbdd0cbca7ac14970bf60c2b ./producer/compmap.py +4dc539b4dd9a68c5ac6b515081144e280c3f9aac9e9e59aaff25bfdedde6bcb1 ./producer/contract_p.py +10d2fc3f1f3d8cda5f0b07720f51b5a6fd40cfc1490d361939ff93e5470805d3 ./producer/gcert_emit.py +ac4a678da2000a71cfa3599e7585e7bd4b696036d02c99a572102615eb216c34 ./producer/graph_centre46.diff +11f50f0f54af61df0dc54f8423e3bef99d4823883409921fd5e7d3a488b1daeb ./producer/localscan.py +a51937ce3d56cb36a1471f13ba6e6eadb835fd040773a14cc7492d304020b6ba ./producer/make_layer_p.py +59f2d83ec4f7e79cc5f1074f8fbd2fb04ea92056a3afe47d686c7450f7205882 ./producer/modules_centre_root.diff +403ef1db92bafcb973857063bc96ec9ac326838b7595af642d5f11fef3350211 ./producer/normalize_scatter.py +1ba231cdfee7a97ea78d72250bedc01c099da4ab732a9b7ad41ccfd04ae88ee2 ./producer/run_one.sh +a87e07966af3e9234fc798133980989dd0d6bd6c18dafe1204b777946263a6d0 ./receipts/complex-admission-L10e.txt +a87e07966af3e9234fc798133980989dd0d6bd6c18dafe1204b777946263a6d0 ./receipts/complex-admission-L10f.txt +02846fcc55826425b01153d7fd837fd5e80ba6d3b3c02166b33f54a05fbbdc36 ./receipts/complex-contract-L10e.log +7a7e1c52d1ef537ae00a83d12d059f307099ada8af355011134cb1ce60272f31 ./receipts/complex-contract-L10f.log +8d52f3cffb99540a4366581fac6d91b6415c1215bdbc0c179e7bafbeeb69dd4f ./receipts/complex-guard-L10e.json +97307821a0b0c4cc0aa4508484000f6f77d325556ed1bd07390a18890e3badef ./receipts/complex-guard-L10f.json +5b93dee60fb047f70f0b20e3e4bb84f3992515fbc39fc9d27788cd9ae2d950a8 ./receipts/kappa-L10f.json +9a0a9d4a5eb93fe086dcf1c91768bf22fa5303b92acee0e8b5dc667ccaa7d8d6 ./receipts/kappa.json +32e291f249b4eab8d65664d10c94208fe2154bdb4a45aaff84e9e8da5295a29f ./receipts/official-five-stage-columns.json +7e675b7720f056548c1ee9f9de523eea10e6b014ddf90b7a630fd96163acbce6 ./receipts/official-legality.json +b5dcc944d46a75eafe70f3945ada8b67ff8a2d807a1a24f5c640dab911721edd ./verify.sh diff --git a/research/w3-staged354-signed20-native/provenance/pr346-NOTICE.md b/research/w3-staged354-signed20-native/provenance/pr346-NOTICE.md new file mode 100644 index 0000000000..6d5643cc76 --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/pr346-NOTICE.md @@ -0,0 +1,28 @@ +# Attribution and provenance + +Prepared with substantial Anthropic Claude assistance. Apache-2.0 (see `LICENSE`) applies to the new code and to the +inherited Apache-2.0 code below; third-party notices are preserved where files are vendored. + +- **Base bit word, re-annealed pair module, p = 10 five-stage pipeline and its moment/outer/prime engines** + (`data/bit/BASE-*`, `data/complex/pm_p10b.json`, `code/pricing/{moment,base_two_moment,outer,prime_witnesses}.py`): + DreamingOfClouds, PR #325 at `0eca9340a3df6141b8e71a41638c3937b3522888` on PR #315 at + `64bccfb67494f7c4549bfb2f186b400a3cfefb42` (#285/#276 gen5/gen4 lineage on eumemic's PR168 generator and source527 + package, PR #200's physical rules, hcg890 and Jacob Sussman's five-stage architecture, Evan McKinney's completed + banks). The engines are copied unchanged from PR #315's package. +- **Design T, twin condensation, the Design T verifier and the cost model** (`code/builders/{interface,gather,build_v5,twin,addcomp}.py`, + `code/checkers/{verifyT.cpp,sub.hpp,exactnd_h.py}`, `code/pricing/cost.py`): utcorvusvolat-dotcom's w3 supplier work + (Agents A/B) packaged in PR #310 at `484b85f1d1fada27fda2ddab3ec952c1314d84c7`, ported here to h = 20 (literals 24/23 + replaced by h and h − 1, a `drop` case for gauge-bound partial carriers, configurable paths). +- **Official checkers** (`code/checkers/{legality_h,columns_h}.cpp`): PR #266's `cohort-legality-independent` and + `cohort-five-stage-columns` as retained in PR #310, with only h, v, R and the copy count generalized. + `json.hpp`: Niels Lohmann, MIT license in its header. +- **Triple module** (`data/complex/tmod_t2_p10.json`): PR #327 (complex-p10) at `40ed0456ab1990beb3440e61bb883ccf95fdcea4`. +- **Complex chain and checks** (`producer/`, `code/complex/`): PR #304's recipe and PR #315's portable complex checks + (#256/#233/#202/#200/#194/#184 lineage: icekylinx, Chafik Boukhalfa, Avi Eisenberg, eumemic and others), ported to + p = 10. Jacob Sussman's `gx.check1`, `gxcore` and pinned Lean sources are vendored unchanged under + `code/complex/inputs/complex/sources` with their own notices. +- **New here** (Claude-assisted): the exporter, the h = 20 ports, the selection of the complex modules with a + one-instance compile proxy, the p = 10 complex program and its pins, the tiling/prime/certification helpers and + `verify.sh`. + +Credits do not imply endorsement or review by the credited authors. diff --git a/research/w3-staged354-signed20-native/provenance/pr346-README.md b/research/w3-staged354-signed20-native/provenance/pr346-README.md new file mode 100644 index 0000000000..4de9dab5f7 --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/pr346-README.md @@ -0,0 +1,78 @@ +κ = 7.92580093369946e-4 + +# w3 cube layer on PR #325's p10b bit word, with a stronger p = 10 complex supplier + +A conditional finite construction with **κ = 396290046684973/(5·10¹⁷) ≈ 7.92580093369946 × 10⁻⁴**, +3.71 % over +PR #315 (7.64230861320245e-4) and +1.97 % over the best open PR at packaging time (#332/#333, 7.77268259042372e-4). +The complex supplier binds; the bit root lies 1.07 % above its leaf cap. + +| side | supplier | coarse saving | +| --- | --- | ---: | +| bit | PR #325's p10b word + w3 Design T + twin condensation | c = 32069035133443/(4·10¹⁶) ≈ 8.01725878336075·10⁻⁴ | +| complex | p = 10 gcert/1 program: PR #304's recipe on PR #325's pair module, PR #327's triple module and PR #315's all-but-one module | b = 396604388013523/(5·10¹⁷) ≈ 7.93208776027046·10⁻⁴ | + +## Bit word + +The base is PR #325's p10b local word (h = 20, v = 960, m = 100, R = 8,100), exported unchanged from PR #325's own +`prepare`, `physical527` and parity fusion into the PR249 snapshot format (`code/export_p10.py`). On that snapshot +w3's pricer returns PR #325's bit root 7.70276909563042·10⁻⁴ exactly; its five-stage profile equals the banked +profile of PR #315's pipeline row for row. + +1. **Design T** (PR #310's supplied builder, ported to h = 20). All 120 cubes carry the 12 plane block holders, + 8 partner singles and four 011 mixes the builder expects. 480 helpers are freed (entrance FULL, no records); no + new frame is needed because every tetra-edge frame span(χa, χb) already exists in the word. +2. **Twin condensation** (PR #310's `twin.py`, ported). 480 planes whose two arrivals are mix-frame starters take + their leftover at the 1-dimensional intersection line of the two mix frames (σ = 1); 320 new line frames. + +Root: 7.70277 → 8.00345 (Design T) → 8.01726·10⁻⁴. W = 10,476 per copy; residual census {20: 5,940, 19: 480, 4: 1,200}. + +## Complex supplier + +PR #304's build chain (PR #202 tree with PR #315's centre-sharing `Graph.finish` patch, PR #184 flow and exact lift, +PR #256's emitter), made p-generic and run at p = 10 (`producer/`). A one-instance proxy of the base compile +(R = additions + roots − carrier arcs, exact on the tested pair and all-but-one modules) selected the modules: PR #325's +re-annealed pair module (92 net registers per instance against 95 for PR #315's), PR #327's p = 10 triple module +(549 against 593 for a p = 11 module cut down) and PR #315's all-but-one module (8). Flow R 6,265 (PR #327's own +p = 10 program: 6,455, 7795/10⁷). + +Checks run on this program: PR #200's complete complex checker (all formal source/target/dirty columns), PR #194's +contract (13 checks, physical R = flow R, equal histograms), and in `verify.sh` PR #315's complex checks ported to +p = 10 (`code/complex/`): Sussman's `gx.check1` with the exact scalar identity and his `gxcore` mirror, every label +and paid child, both scalar words and lifetimes, the five-window splice with all controls rejected, and the finite +precision guard (external rows 15,125 < 20,161, induction gap 115·B, half-shrink 84 < 100). The five places where +#315 pinned its p = 11 program are now derived from the certificate (h, v, R, centres = h, centre rank h − 2, +m = 5h, W = 4v + R) or re-pinned to this program (`code/complex/pins-p10f.json`). + +## Verify + + bash research/w3-p10b-complex-p10/verify.sh /tmp/w3-p10b-verify + +About five minutes; needs Python 3.11+ with numpy, mpmath and sympy, g++ (C++17) and Boost headers. It checks the +manifest, rebuilds the final word from the vendored base snapshot (hash-checked), runs the ported Design T verifier +(legality, all F₂ columns, nondegeneracy), PR #266's official legality and five-stage columns checkers (11,940 columns, +six omitted-bridge controls), exact rational nondegeneracy and PR #315's prime-witness rule on the 320 new frames +(determinants ≤ 6 bits, primes {2, 3}), an exact width-100 bank tiling with 60 replicas, the complex checks above, +both rational moment engines with the 10⁻¹⁶ fallback on both sides, and PR #315's outer assembly on the complex-bound +path (47 strict constraints; the cap itself fails `leaf_saving_above_bit`; the adjacent 10⁻¹⁸ κ is rejected). + +Regeneration from source (optional): `code/export_p10.py` exports the base from PR #325's package at +`0eca9340a3df6141b8e71a41638c3937b3522888`; `producer/run_one.sh L10f 10 tmod_t2_p10.json pm_p10b.json bit_qmod_p10.json` +rebuilds the complex program on the PR #202 tree (see `producer/README.md` of the predecessor complex-p10 work). + +## Open obligations + +- Not ported: PR #310's native downstream chain (bank review with charts and normalizers, changed projector charts, + geometry admission, finite invoice). Only bank feasibility is shown; freed roles carry no records and are not banked. +- PR #315's scalar/prime/finite stages regenerate the word from its generator and cannot take an edited word; the + official cohort checkers replace them for the edited word. +- The complex guard keeps PR #315's additive row constants (9909 + 252) derived at p = 11. +- All inherited interfaces of PR #315/#325 remain assumptions (all-size compiler, weighted selectors, common + charts, restored rows, routing, prime supply, precision/recovery, complex symbolic correctness, analytic transfer). + This is a conditional finite construction, not a formal verification of the multiplication theorem. + +## Credits + +Bit base word, pair module and the p = 10 five-stage pipeline: DreamingOfClouds (#325 on #315, gen5 lineage on +eumemic's source527 and hcg890/Sussman's five-stage architecture, Evan McKinney's completed banks). Design T, twin +condensation and diagnostic checkers: utcorvusvolat-dotcom's w3 work (#310); official checkers: #266. Triple module: +#327. Complex chain: #304/#256/#233/#202/#200/#194/#184 lineage; Sussman's gx checker. See `NOTICE.md`. diff --git a/research/w3-staged354-signed20-native/provenance/pr346-at-discovery.json b/research/w3-staged354-signed20-native/provenance/pr346-at-discovery.json new file mode 100644 index 0000000000..890ae060fc --- /dev/null +++ b/research/w3-staged354-signed20-native/provenance/pr346-at-discovery.json @@ -0,0 +1,10 @@ +{ + "body": "**Conditional \u03ba = 396290046684973/(5\u00b710\u00b9\u2077) \u2248 7.92580093369946e-4** (+3.71 % over #315, +1.97 % over #332/#333). The complex supplier binds; the bit root is 1.07 % above its leaf cap.\n\n## What this adds\n\n- **Bit side:** PR #310's w3 Design T and twin condensation, ported to h = 20 and applied to PR #325's p10b word (exported unchanged from #325's own pipeline; the export reproduces #325's bit root exactly). Design T frees 480 helpers and needs no new frames; twin condensation adds 320 line frames. Bit root 7.70277e-4 \u2192 8.01726e-4.\n- **Complex side:** a p = 10 gcert/1 program built with #304's recipe on #325's re-annealed pair module, #327's p = 10 triple module and #315's all-but-one module (flow R 6,265). b = 396604388013523/(5\u00b710\u00b9\u2077), against 7795/10\u2077 for #327's p = 10 program.\n- **#315's complex checks ported to p = 10**, with the five p = 11 pins derived from the certificate or re-pinned.\n\n## Checks (`bash research/w3-p10b-complex-p10/verify.sh `, ~5 min)\n\nManifest; rebuild of the final word from the vendored base (both hashes); ported Design T verifier (legality, all F\u2082 columns, nondegeneracy); #266's official legality and five-stage columns checkers (11,940 columns, bridge controls); exact nondegeneracy and #315's prime-witness rule on the new frames; exact width-100 bank tiling; Sussman's gx.check1 + gxcore, labels, scalar words, splice controls and precision guard on the complex program; both rational moment engines with the 10\u207b\u00b9\u2076 fallback; #315's outer assembly on the complex-bound path (47 strict constraints, cap rejected, adjacent \u03ba rejected). PR #200's complete complex checker and PR #194's contract were also run on the complex program (receipts in `receipts/`).\n\n## Open obligations\n\n#310's native downstream chain (bank review with charts, changed projector charts, geometry admission, finite invoice) is not ported to p = 10; only bank feasibility is shown. #315's own scalar/prime/finite stages cannot take an edited word. The complex guard keeps #315's p = 11 additive row constants. All inherited interfaces remain assumptions; this is a conditional finite construction, not a formal verification.\n\n## Credits and AI disclosure\n\nBuilds on #325/#315 (DreamingOfClouds), #310 (utcorvusvolat-dotcom's w3 work), #266's checkers, #327's triple module and the #304/#256/#233/#202/#200/#194/#184 complex lineage with Sussman's checker; see `NOTICE.md`. Prepared with substantial Anthropic Claude assistance.\n\nSubmitted by Louis Harrison (@LJH-217)\n\n", + "headRefName": "w3-p10b-complex-p10", + "headRefOid": "11b4de5ff8ed5fccf55d4af1043358d257308e8e", + "isDraft": false, + "number": 346, + "title": "\u03ba = 7.92580093369946e-4: w3 cube layer on #325's p10b word with a stronger p = 10 complex supplier", + "updatedAt": "2026-10-10T23:45:40Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/346" +} diff --git a/research/w3-staged354-signed20-native/requirements.txt b/research/w3-staged354-signed20-native/requirements.txt new file mode 100644 index 0000000000..78c2682d1f --- /dev/null +++ b/research/w3-staged354-signed20-native/requirements.txt @@ -0,0 +1,3 @@ +numpy==2.3.5 +scipy==1.17.0 +sympy==1.14.0 diff --git a/research/w3-staged354-signed20-native/vendor/complex-reserve/LICENSE b/research/w3-staged354-signed20-native/vendor/complex-reserve/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/MANIFEST.json b/research/w3-staged354-signed20-native/vendor/complex-reserve/MANIFEST.json new file mode 100644 index 0000000000..fb122f82af --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/NOTICE.md b/research/w3-staged354-signed20-native/vendor/complex-reserve/NOTICE.md new file mode 100644 index 0000000000..d0a70f4c5c --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/SOURCE.json b/research/w3-staged354-signed20-native/vendor/complex-reserve/SOURCE.json new file mode 100644 index 0000000000..0d9bdfc56c --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/admit.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/admit.py new file mode 100644 index 0000000000..82d7254876 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/finite_guard.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/finite_guard.py new file mode 100644 index 0000000000..c8e3e8cee9 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/SOURCE-pr346.json new file mode 100644 index 0000000000..0de6ddc402 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/addcomp.py new file mode 100644 index 0000000000..6d5fea18b0 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/decomp.py new file mode 100644 index 0000000000..365e5bf2a8 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/gather.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/gather.py new file mode 100644 index 0000000000..ef063373c2 --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/twin.py b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/builders/twin.py new file mode 100644 index 0000000000..6ec783fd2b --- /dev/null +++ b/research/w3-staged354-signed20-native/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/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp b/research/w3-staged354-signed20-native/vendor/complex-reserve/upstream/pr352/code/checkers/columns_h.cpp new file mode 100644 index 0000000000..07b7fd220c --- /dev/null +++ b/research/w3-staged354-signed20-native/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