diff --git a/research/three-total-decoders/LICENSE b/research/three-total-decoders/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/three-total-decoders/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/three-total-decoders/MANIFEST.sha256 b/research/three-total-decoders/MANIFEST.sha256 new file mode 100644 index 0000000000..efdc0ef9d1 --- /dev/null +++ b/research/three-total-decoders/MANIFEST.sha256 @@ -0,0 +1,61 @@ +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 LICENSE +ccab919d95d1f5c137de9044897938188edddd967936ebcfff697ee32ab1c451 NOTICE.md +a812bb80e480a3f2f446e0f0f77300606e4337e4a888c141a7f4380ca15bef07 README.md +ad8545cd8408c80fc24ec82d3ebbe13b337ca66d0deabe388672b4e4b88c5558 SOURCES.json +9d5490a6bc5c9696e902075da2560d43abeef3d69c24b6dd05590d5d0fc93d35 c/brutetu.c +55d864202535c22952e1a9080ad834f1908d18ff857c8dc26211e25a847d1fc8 c/enumall.c +11f8c3d1ddb103eac91ef7c92e2dd887d53b5aa407997afba3105b01ac18bdc1 c/jsign.c +c1a69e5ca874d6a382583132f0596ddefb84f0e1b31b34775ca1c2aab32b95da c/mas.c +60e2538145cf3d0031ae29769b4c1a9a93fbcd252bed9163942cc5f1fd75bf2b c/tusign.c +fb18332a3adb4842c3662346aa7f6b5115debc04f1a392b6e9cbb423b7b83c8d checks/expect.py +c9b843903c6a1fb51e7a0664b010de0aa0a6cd66384b3ef39a71afb168b85285 checks/f2s.py +2c2d273387d6cd315e8606c8b5ffaa0421980d017c25f18df59177b3ef6277e1 checks/g1_cex.py +7b535510a03aa255e4ba78fd5787e58abbba214632966b6bba100cf1932cb10d checks/hesse_below.py +a656c6a54bc5cd1b3878dc63a020e25d910208e9fc6d347ffd0f6e968531a5b5 checks/hesse_smoke.py +0dc28b867ffa7d977aeb92cf9c71012030b4c27e0291b2a3659e8497622c3480 checks/lifts.py +0dc3997bdc78454b1e67e3d3c3798e4924817d311bbbc526d3554876d08a053c checks/mcc_cex.py +63cf4cb580ec56102a74680d226bc6f7993e233b3406ae409b6b19bcbc78f173 checks/nondeg.py +6b5d409e22d936c429f44595467939ef9e0dacedc73bc4ea177d7de2ba1770d3 checks/thm.py +e6d03be2481e30439f8bd2ab03c066b56025f89924f7309dab9dd59902da1f92 checks/tied_min.py +4c48f91787e8ee0407c218e3253ab38327cad0536128f73533edf864c9040891 data/aff14.json +89907be2205b217f5dfa79f6e12b19f05e52f158be301752a0ccfd3759151122 data/cech_v8.json +6ef2af941ccad9f8a1c38f3a26020425022b5b09e15183b52dc0a3651261cde8 data/cex_joint_v7.json +86064701dde94b4f35427bc3e19275eaf1e40e9e90d4fea28e7857f3564d4dd7 data/cex_min_1.json +15f5039069a175831f92c4ffe023a23a6f6e6bd6665f0ca2c2734bbe672b51ef data/cex_min_1.json.B22.json +9e92b7b5f1221c180af3637ff70940aca5255b92f7b641efe3c615433e54761a data/cex_wholeTS_v9.json +ea72716f98af4a99141d28f828db3c5c99c2cc8ad7d15ed6a8329de37ee36790 data/gad.json +312ee28adea5fba1b1d518271dfa57ef047a7b9c0560a57d397105ff49af2e12 data/gad_nonTS_minimiser.json +0eb5a156f3ca4c2fdbc43ad1004ade0897453702f25662837f33a0bf811d12da data/lifts_nojoint.json +201337647ca3012543ae326285fbf7a77d3e0b4290d156b72dde4e22e4186a3f data/mcc_cex_min_1_solution.json +7e5e5fa66dbaf0ac1fa7382fec28bbebe10d477e80022d648fb4c0093f23c64c data/nojoint_21_1.json +c56efcac1b354fca4efe5ce203c0df2c723e28b5acaf6600c53d65510f2aad5e data/nojoint_21_10.json +8315bda5e6e175c322c1db4767635c30c58a8095ff939b8555984da737fcd258 data/nojoint_21_11.json +a4ac2c9bfb72c2256032c5cde87860e0a82e78b4b788d0dae39d96e56dec7a58 data/nojoint_21_12.json +2d4ab6b67d6b17d8c231d6ddfaf58f1c73e34e1c8d622b69b133ac83b0a62b0b data/nojoint_21_13.json +b6ef1c334c38c805bfb8c33459db73f805da80a3e3bc64944a5542d75dafc4dd data/nojoint_21_14.json +6020caec4ce319e9ee122948b3e09ac987cba8f504ece906e550f3996e3d46a5 data/nojoint_21_2.json +d9531dccba8cad1ed6bce75e21ee1336d512969e73a53faff98718b3889b1ec3 data/nojoint_21_3.json +ba139ce8e3e65f429346a60015042ff2bffd25b91c7487a68d06f12457aba6b5 data/nojoint_21_4.json +e7cd06311ce71bd6460b3c6cf237eb9c19721ddc4c8cedd39ea736c1dfe1692f data/nojoint_21_5.json +9c7c2d30b33de6a34821ad853f455bbe9a8ca3c42707010c247dbef00575bca8 data/nojoint_21_6.json +d477bd3bafb872c2ba638183e34762d402f2c3687953360b137cc7222afa3f98 data/nojoint_21_7.json +99fd2dcbc1b52b1a7255cabe92e88508bccf936900d87f42108609bbc58952e4 data/nojoint_21_8.json +4b44af0cf900012124e1844f223abf1423c46d2561dce60a380d3957495d0e8e data/nojoint_21_9.json +2781dda2b8bc4d3ee75a2465cb7350973b514a9c737f9181e3bcff3f358ce839 data/supmin_fail_v8.json +670ed90924b601ade22f0d4adaff46d1667e5449326a0f7ba7b88dd8f5906f93 data/tied_min.json +ef10f51b533d349ae465b1df2f46d367182264c22609d2d5cbfe3b7a6cfd7ff1 evidence/T3-PROOF.md +f91bbb764bb6c10a4348b3063000b3f773aeffc7dbe65c60e93a926794e5b4e8 evidence/cex-README.txt +5b11bc485ef50627e04fb790c463fba4ec31e851d788233ed0a4216938239a13 evidence/fleet-BRIEF.md +462fe8e9fa662365648e4f6fda3e029915a6e6b275b84f409670f35996098485 evidence/fleet-REQUESTS.md +791c7d53cb1b94cfe2674be0ffd5ba509fb1cf162ced5515ac0858fa23be1f91 evidence/fleet-S1.md +139f441a18e855e2761d2ec2ce0b53bcc2fad42d074368b02601f3bba8dc9882 evidence/fleet-S2.md +ba1ab38b52c84e59623ac33be6e5a7a8d5cf940d66047555905c366306861bb9 evidence/fleet-S3.md +cc1d9287fcdadb9afb670103fb18fac0d55664b6afd1673557aa60c217e59136 evidence/fprime-PROOF.md +304ff3ef8ef20093236d366b728acf570575050d1b9c64631bf3e5f7da668df8 evidence/g1-PROOF.md +7eb9e6735ff036533cfbdd86e5aa981d62a81a76deb95aeb2b61ddf3c6362c99 lib/hesse.py +c707f5270b2eaef2da1dc0c1bf95c3ebf55d3fb667161c6c03a2126fad0422ec lib/kit.py +cfbddbee3112f115c2ef606f7603481b4ef18cf80341041513a203417cc789e9 lib/satlib.py +427121d36b70d068fca3807e37868002f6271a9aa4eb465c18b347535040ba65 requirements.txt +b07eeaeeb537fecc75390ab832a5df4a629f9a1115bbd8cd40a77fd816a71d4c scripts/make_lifts.py +6c4c71c693e63a9b27b327c181d308878dd7c8ec966d70fea708e8bed4d9355b scripts/provenance.py +834a66a3fbd088400b1b4d063386ec8a2a62e0dd3d674aef1e952f4d9a25cf9e verify.sh diff --git a/research/three-total-decoders/NOTICE.md b/research/three-total-decoders/NOTICE.md new file mode 100644 index 0000000000..1e697e8b41 --- /dev/null +++ b/research/three-total-decoders/NOTICE.md @@ -0,0 +1,19 @@ +# Notice + +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code; Apache-2.0 (`LICENSE`, copied from the repository root). + +## Credits (prior work this package stands on) + +- **#446** (Theorem C; closed, not merged): the cost formula and exactness model; **#595** (FL C.6): the pairing model and the window table; **#717**: the provenance/manifest pattern of `scripts/provenance.py` and the complex E8 decoders; **#1590** (`research/root-unit-decoder-lemmas`, merged): Lemma A (T ≤ 2), the lift identity Lemma B, ERR1, the D5 CNF; `checks/expect.py` and `scripts/provenance.py` are adapted from that package. **#2031** (pending): the DRAT certificate of the D5 CNF, cited, not duplicated. +- Swarm work used, all from our own working cards of 2026-10-13/14: the second-prover card `KPR4-T3/PROOF.md` (L1–L8, Theorem P), the `fprime` card (Theorems M1, U, MCC, tied_min, SCC/Peel), fleet workers S1 (matroid route, TU-signability, gadget, aff14), S2 (F2S exchange route, PP, 4095 sub-configurations), S3 (adversary search), and the `g1` card (joint signability, counterexamples, Hesse runs). Their notes are shipped verbatim in `evidence/`. + +## New in this package + +`README.md`, `verify.sh`, `SOURCES.json`, `requirements.txt`, `MANIFEST.sha256`, `c/brutetu.c`, `lib/kit.py`, `lib/satlib.py`, `scripts/make_lifts.py` (adapted from the g1 card's `exactlift.py`), `data/lifts_nojoint.json`, `checks/*.py` (written for this package; they re-implement the checks of the working cards in exact arithmetic with fixed seeds), and the selection of data. + +## Adapted from our earlier work + +- `c/enumall.c`, `c/tusign.c`, `c/mas.c`: unchanged from the g1 and fprime cards. `c/jsign.c`: the g1 card's program with an added option that prints the solving signing. +- `lib/hesse.py`: the arithmetic and sampler of `g1/hesse.py` with the module-level search loop removed. `lib/satlib.py`: from `fprime/enumB.py` and `fprime/costsat2.py`. +- `data/`: configurations and certificates copied from the cards; `data/gad_nonTS_minimiser.json` is one entry of the card's list of 23552 gadget minimisers. +- `evidence/`: verbatim snapshots (snapshot of 2026-10-14 14:32; the status header of `g1-PROOF.md` predates its §11–14). diff --git a/research/three-total-decoders/README.md b/research/three-total-decoders/README.md new file mode 100644 index 0000000000..229c79d6e9 --- /dev/null +++ b/research/three-total-decoders/README.md @@ -0,0 +1,186 @@ +# Three-total root-unit decoders (partial, no κ claim): reductions, the sharp example tied_min and the lift route + +> **What is claimed, and what is not.** This package is deliberately partial. It concerns exact decoders with **T = 3 totals** under the cost formula of Theorem C of #446 (closed, not merged; the model is carried in the merged #595, FL C.6), in the setting of the merged #1590 (`research/root-unit-decoder-lemmas`: Lemma A for T ≤ 2, the lift identity Lemma B, ERR1, the D5 CNF); the DRAT certificate of that D5 CNF is the subject of the pending #2031 and is not duplicated here. +> **Claimed.** +> (1) PROVEN, every configuration: two reductions (Lemma SCC, Lemma Peel), monotonicity under deleting lines, and the structure of a minimal counterexample to (A) (§2). +> (2) PROVEN, partial theorems: Theorem M1 (cost ≥ v/2 when no point has full support, any field), Theorem U (unit world: certificate ≥ |G| + |I|/2 ≥ v/2), and the F2S rowspace identity cost = 3ρ − Σ w_j ≥ 2ρ (§3). +> (3) PROVEN with one computer-assisted step, CHECKED exactly: tied_min, a 12-line configuration whose cost is exactly v = 12 (exchange proof, all 217 optima, all of them lift to Q) (§4). +> (4) CHECKED: every order, label, multi-copy and per-scale 2-adic certificate stops at v − 1 = 11 on tied_min, so no certificate of that kind proves (A); the multi-copy certificate does reach 20 ≥ v on the 19-line cex_min_1 where the one-copy certificate stops at 18 (§5). +> (5) PROVEN and CHECKED, the lift route: Lemma W′ (a TU signing gives cost ≥ v), Theorem 9.3 (joint signability is one linear system over F2), the two failure modes (one block not signable; a purely three-block Čech relation), and exact counterexamples: whole-matrix TU fails at v = 9, non-regular minimisers, K22-freeness does not give TU-signability, the peeling induction (Conjecture PP) is false (§6). +> (6) The two experiments, X1 (joint signing) and X2 (Hesse configuration over Q(ω)), are reported in §7 and §8: +> **X1 = OPEN (G1′).** The statement "some cost-minimiser admits one signing with all three blocks TU" (G1-joint) is false: exact counterexamples at v = 7 and v = 10, and 14 instances in all, with (A) checked to hold on every one. What survives is the rank-preserving lift G1′ (a same-support rational lift with rank_Q = rank_F2 on each block), which is open, as is its parent (Q ≤ F2) (§7, §10). +> **X2 = NONE FOUND.** No tested rank-3 decoder built on the Hesse configuration over Q(ω) costs less than v (counts in §8): (A) also holds on all tested Hesse geometry, so the lack of a field order is not supported as the mechanism. Recorded evidence, not a proof. +> +> **Not claimed.** No κ gain, no word. **(A) — cost ≥ v for every exact three-total decoder — is not proved and not refuted over Q.** No new window is closed: M1 and U give v/2 only, and only for restricted types. Nothing here says the E8 frontier cannot be improved. + +## 0. Reading this package + +Every result has one of three statuses: + +- **PROVEN**: a proof is in this README or in the cited section of `evidence/` (a verbatim snapshot of our working cards; the proof is the claim, the scripts only sanity-check it on instances); +- **CHECKED**: recomputed by `verify.sh` (exact integer / rational / F2 arithmetic, exhaustive enumeration, or a small CNF) — the check group is named. **CHECKED (recorded)** marks a machine result of our own working cards (CP-SAT or SA run, long enumeration) that `verify.sh` does **not** repeat; the card, script and log line are named, and the stored certificate is verified wherever one exists; +- **OPEN**: a precisely stated problem, or an argument that is not a proof. + +```sh +python3 -m pip install -r research/three-total-decoders/requirements.txt # python-sat only; a C compiler (cc) is also needed +bash research/three-total-decoders/verify.sh /fresh/output/dir # from a checkout or `git archive` of the whole repository +``` + +Step 0 checks every file against `MANIFEST.sha256` and every pin of `SOURCES.json` and stops with exit 1 on any mismatch; then the five C programs of `c/` are compiled from source (`G0`) and groups G1–G7 run in one process, one PASS/FAIL line per assertion (34 PASS lines after step 0, 36 with step 0; about one minute). No external solver binary runs. Were a file `data/hesse_below_*.json` present, `verify.sh` would evaluate it too (none exists). + +**Sources** (snapshot of 2026-10-14, 14:32 local; cited below by the short names). `evidence/fprime-PROOF.md` = `cards/KPR4-T3/fprime/PROOF.md` (**fprime**; §§0–14 incl. M1 = §7, MCC = §9, tied_min §§11.5, 12, 13, 14); `evidence/g1-PROOF.md` = `cards/KPR4-T3/g1/PROOF.md` (**g1**, §§1–14; the status header of the file predates §11–14, which supersede it); `evidence/T3-PROOF.md` = `cards/KPR4-T3/PROOF.md` (**T3**; L1–L8, Theorem P, Conjecture F); `evidence/fleet-{BRIEF,S1,S2,S3,REQUESTS}.md` = `cards/KPR4-T3/fprime/fleet/` (**S1** matroid route, **S2** exchange / F2S, **S3** adversary); `evidence/cex-README.txt` = `cards/KPR4-T3/cex/README.txt`. The older draft `KPR4/T3-SECTION.md` is superseded and not shipped. Script names in brackets are the working-card scripts the package checks were adapted from. + +## 1. Model (as in #1590 and #446 Theorem C) + +A configuration is a list of lines t = 1…v, each with a point p(t) ∈ Q³ and a line q(t) ∈ Q³ with p(t)·q(t) ≠ 0. A **pairing** B is a 0/1 matrix over F2 with unit diagonal and B_ts = 1 (s ≠ t) only where p(t)·q(s) = 0 (*admissible*). An **exact decoder** with T = 3 totals is M = Σ_{j≤3} p_j q_jᵀ over Q (p_j the j-th coordinate vector over the lines, so M_ts = p(t)·q(s)) with M_tt ≠ 0 and M_ts = 0 wherever B_ts = 1. Write R_j = supp p_j, A_j = supp q_j, D_j = R_j ∩ A_j, r_j = rank_F2 B[R_j, A_j], and π(t) = {j : p_j(t) ≠ 0}, σ(t) = {j : q_j(t) ≠ 0}, D(t) = π(t) ∩ σ(t) ≠ ∅. Theorem C prices the decoder at Σ_j max(w, r_j) ≥ **cost := Σ_j r_j**; we drop the floor w, so a lower bound on Σ_j r_j is the stronger statement. The incidence t → s (t ≠ s) means p(t)·q(s) = 0; only entries inside some block R_j × A_j matter. + +Facts used from the earlier work (all PROVEN; proofs in `evidence/T3-PROOF.md` §§2–3 and in #1590, whose lemmas are cited, not reproved): + +- **Lemma A** (#1590 §2): (A) holds for T ≤ 2, any admissible B. +- **L5**: an incidence t → s forces |π(t) ∩ σ(s)| ≠ 1 (a single nonzero product cannot vanish); so every off-diagonal entry lies in ≥ 2 blocks. **L6** (K22): no t ≠ t′, s ≠ s′ with B_ts = B_ts′ = B_t′s = B_t′s′ = 1 unless the two points or the two lines coincide. **L3/L4**: no transitive 4-tournament; a full clique B[S,S] = J with |S| = 3 meets every D_j. +- **Lemma B = L7** (#1590 §3): for every rational B′ with supp B′ ⊆ supp B and B′_tt ≠ 0, **v ≤ Σ_j rank_Q B′[R_j, A_j]**. +- **L8**: for F2 vectors a(t) ⊆ π(t), b(t) ⊆ σ(t), cost ≥ rank_F2(B ∘ K), K_ts = |a(t) ∩ b(s)| mod 2; so a set S with K_tt = 1 on S and an order in which every incidence with K_ts = 1 points forward certifies cost ≥ |S| for every admissible B. Theorem P (2-adic reduction with one-sided repairs, cost ≥ |G| + |F|) is the main source of such certificates. + +**Target (A).** At T = 3, **cost ≥ v for every exact decoder over Q and every admissible B.** (A) is the strong form: it would close every T = 3 window of #1590's table, since N(h) ≤ ⌈2v/3⌉ ≤ v there. It is known for T ≤ 2 (Lemma A), for decoders over a field of characteristic 2, and fails for T ≥ 7 (E7/E8 coordinates, cost 49 < 63 and 72 < 120; #1590 ERR1, Fano-type F2 cancellation). Whether it holds at T = 3 is **OPEN** (§10). + +## 2. Proven reductions (every configuration) + +**Lemma SCC (strong components) — PROVEN.** Let H be the digraph t → s (t ≠ s) with p(t)·q(s) = 0 and π(t) ∩ σ(s) ≠ ∅ — exactly the incidences that land inside some block. Order the strong components of H topologically. Then every block B[R_j, A_j] is block upper triangular in that order for every admissible B, so **cost(config) ≥ Σ_C cost(C)** over the strong components C. *Proof.* An entry (t, s) of block j that can be nonzero has t = s or t → s in H, and then comp(t) ≤ comp(s). A block upper-triangular matrix has rank ≥ the sum of the ranks of its diagonal blocks, and the diagonal block of C in block j is block j of the sub-configuration C (with B restricted to C, admissible there). ∎ So (A) need only be proved for configurations whose H is strongly connected. CHECKED: G4.SCC (triangularity on 300 random configurations; tied_min and cex_min_1 are single components of sizes 12 and 19) [`scc.py`]; G1.structure (tied_min strongly connected). + +**Lemma Peel (unit rows) — PROVEN.** If |π(t)| = 1 (or |σ(t)| = 1), then **cost(config) ≥ cost(config − t) + 1**. *Proof.* Say π(t) = {j}. Then t lies only in R_j and, since M_tt ≠ 0, in A_j. For s ∈ A_j, p(t)·q(s) = p_j(t) q_j(s) ≠ 0, so row t of block j is the unit vector e_t and rank B_j = 1 + rank(B_j without row t and column t). Deleting column t from the other blocks does not raise their ranks. (The case |σ(t)| = 1 is the transpose.) ∎ So (A) also reduces to configurations where every point and every line has ≥ 2 nonzero coordinates. CHECKED: G4.Peel (36 exact enumerations over all admissible B) [fprime §13]. + +**Monotonicity — PROVEN.** Restricting an admissible B to a subset S of the lines gives an admissible B for S whose blocks are submatrices, so cost(S) ≤ cost(config). CHECKED: G4.Peel (36 instances, exact). + +**Structure of a minimal counterexample — PROVEN** [fprime §13.4]. Let config be a counterexample to (A) (cost < v) with v minimal and B a minimiser. Then: +1. cost(config) = v − 1 and cost(config − t) = v − 1 for every line t: by minimality cost(config − t) ≥ v − 1, and by monotonicity cost(config − t) ≤ cost(config) ≤ v − 1. Every one-line deletion is *tight*. +2. No line is rank-critical for B: if deleting row t and column t lowered some block rank, B restricted to config − t would have cost ≤ v − 2 < v − 1. +3. H is strongly connected (otherwise cost ≥ Σ cost(C) ≥ Σ |C| = v by Lemma SCC and minimality) and every point and every line has ≥ 2 nonzero coordinates (Lemma Peel, same reason). +4. For every group X of lines (same point, or same line), cost(config − X) ≤ v − 1, so a counterexample is ruled out as soon as one group X satisfies cost(config) ≥ cost(config − X) + |X| (the induction scheme **PP**; it is false in general, §6). + +Tight configurations (cost = v) are therefore the building blocks of any counterexample; tied_min (§4) is a 12-line tight configuration in which no group of lines can be peeled off at the price of its size (it has tight sub-configurations of every size ≤ 10, and every one-line deletion costs 12 again). CHECKED: G1.subconfigurations (all 12 one-line deletions of tied_min cost 12; a tight 10-line subconfiguration is found) [`s2b.py`, S2 §4]. + +## 3. Partial theorems + +**Theorem M1 (no point of full support; any field) — PROVEN** [fprime §7]. If every point p(t) has a zero coordinate (|π(t)| ≤ 2), then + **cost ≥ Σ_j r_j ≥ Σ_j MAS(G[D_j]) ≥ Σ_t c(t) ≥ v/2**, with c(t) = |D(t)| / C(|π(t)| + |σ(t)| − 2, |π(t)| − 1), +where MAS is the largest induced acyclic subgraph of the incidence digraph (an acyclic X ⊆ D_j makes B[X,X] unit triangular, so r_j ≥ |X|). The same holds if every line has a zero coordinate (reverse all edges). *Proof (summary).* Fix j and the chart x_k(t) = p_k(t)/p_j(t), y_k(t) = q_k(t)/q_j(t). Give t the vertices ξ_k(t) = (k, −1/x_k(t)) for k ∈ π(t) − {j} and η_k(t) = (k, y_k(t)) for k ∈ σ(t) − {j}. Since |π(t)| ≤ 2, an incidence t → s inside D_j is a vertex coincidence ξ_k(t) = η_k(s). Order the vertices uniformly at random; X_j = {t : every η-vertex of t precedes every ξ-vertex of t} is acyclic (the earliest ξ-vertex strictly increases along edges) and t ∈ X_j with probability 1/C(m_ξ + m_η, m_ξ). Summing the expectations over j and taking the best order for each j gives Σ_t c(t), which is ≥ 1/2 for every line. ∎ v/2 is sharp for the MAS-sum (the private digon has MAS-sum 1 of v = 2 while its cost is 2). What blocks the general case is the *wild* edge: a full-support point on a full-support line, where 1 + x₂y₂ + x₃y₃ = 0 has no vertex form (fprime §7 end, §8: value-order potentials give coverage 0 on some sign types). CHECKED: G4.M1 (80 random configurations with a zero coordinate at every point, v 6–14, exact MAS by subset DP: no violation; the digon: Σ c(t) = 1 = MAS-sum, cost 2) [`thmM1.py`, `mas.c`]. + Related lemmas, **PROVEN** [fprime §6.2–6.3]: for the private lines P_j = {D(t) = {j}}, MAS(G[P_j]) ≥ #sources + #sinks + ⌈#(types III, IV)/2⌉, hence cost ≥ |P|/2 over any field; two-shared classes give 1/4 per class. **CHECKED (recorded)**: 400 random private-only configurations, no violation, 34 tight [`private.py`, fprime §6.2]. + +**Theorem U (unit world) — PROVEN** [fprime §2]. Call a configuration *unit* if, after row and column scalings, every nonzero entry of all p(t), q(t) is a 2-adic unit (e.g. entries in {−1, 0, 1}, or all odd). Let G = {t : |D(t)| odd} and let I be the tied lines (|D(t)| = 2). In the unit world an incidence forces |π(t) ∩ σ(s)| even (Lemma 1.1), and for a tied class C_ij = {D(t) = {i, j}} with α(t) = p_i/p_j, β(t) = −q_j/q_i (α ≠ β) an incidence inside C_ij forces α(t) = β(s). Split C_ij into the halves H^< = {α < β} and H^> = {α > β}: each half is acyclic. Then the labels G: a = π, b = σ; one deletion of a coordinate for each chosen half (the order A_12, H_02, G, H_01, B_12 of fprime §2) give an L8 certificate of size **|G| + max-half(C_01) + max-half(C_02) + max-half(C_12) ≥ |G| + |I|/2 ≥ v/2.** CHECKED: G4.U (explicit labels and order, every conflict verified forward, for cex_min_1: 15 of 19, the 121-line pool of all primitive pairs in {−1,0,1}³: 106 of 121, and 250 random unit-world configurations of 4–60 lines with forced incidences: all valid, smallest best-certificate/v = 0.706) [`theoremU.py`]. **CHECKED (recorded)** [fprime §2 end, §11.2]: by column generation over *all* group-level one-deletion schemes (and, with copies, §11.2) the value 1/2 is exact, so no scheme depending only on (π, σ, half) can prove more than v/2 in the unit world. It does not cover all rational decoders: the third product p_k(t)q_k(s) can be even but nonzero, and the three tied lines p = (3,−1,−6), (−1,7,−4), (1,1,0) (with suitable q) form a complete digraph on three vertices that no splitting into two acyclic halves can handle [fprime §6.1, **CHECKED (recorded)** `k3class.py`]. + +**F2S rowspace identity — PROVEN** [fprime §13]. Let F2S be the class of configurations in which every point has full support and every line has exactly two nonzero coordinates (tied_min is its sharp member). Then R_j = all lines, and with W = rowspace(B), ρ = dim W, C_j = {columns with q_j = 0} and w_j = dim(W ∩ F2^{C_j}): + **r_j = ρ − w_j, so cost = 3ρ − Σ_j w_j,** and Σ_j w_j ≤ ρ because the subspaces W ∩ F2^{C_j} have disjoint supports (they sit in different column classes), hence **cost ≥ 2ρ**; in particular (A) holds in F2S for every B with rank_F2 B ≥ v/2. *Proof.* B[:, A_j] is the restriction of the row space W to the columns outside C_j; the restriction map W → F2^{A_j} has kernel W ∩ F2^{C_j}, so its rank is ρ − w_j. ∎ Equivalently cost = 2 Σ w_j + 3(ρ − Σ w_j). On tied_min: the 216 class-block-diagonal optima have ρ = 6, w = (2,2,2); the special optimum B0 has ρ = 4, w = (0,0,0). CHECKED: G1.f2s-identity (all 217 optima; w_j computed by counting elements of W), G5.identity (179 random (F2S configuration, B) pairs). Natural strengthenings are false by exactly 1 (§5, per-class rowspace lemmas). + +## 4. The sharp example tied_min: cost = v = 12 + +**Definition.** Four points a ∈ {(1, ±1, ±1) with a fixed product sign pattern}, the vertices of a K4, and the three perfect matchings M_k (k = 0,1,2) of K4. Class k consists of the lines whose q has q_k = 0: q ∈ {(0,1,±1)}, {(1,±1,0)}, {(1,0,±1)}. Line (a, k) = point a with the class-k line q that misses a. So v = 12 lines, all with |D| = 2 (*tied*), 72 incidences, one strong component (`data/tied_min.json`; it is the complete quadrangle against its own diagonal triangle). Every point has full support, so R_j = all 12 rows, and A_j = the 8 columns of the two classes k ≠ j. Entry (row (x,c), column (b,k)) is free iff x lies in the pair of M_k not containing b. CHECKED: G1.structure [fprime §12.1, `quads.py`]. + +**Theorem T (cost(tied_min) = 12) — PROVEN, computer-assisted in step (b) only** [fprime §12.3]. +(a) Every block has rank ≥ 3: MAS(G[D_j]) = 3 gives a unit-triangular 3×3 principal minor. CHECKED: G1.step-a. +(b) A block of rank ≤ 3 has a **unique** filling of its 8 columns (exhaustive enumeration of all B with rank_F2 of the 12×8 block ≤ 3, by CNF with blocking clauses: exactly 1 solution for each j = 0,1,2). In it dim S_k = dim S_l = dim(S_k + S_l) = 3 (S_k the column span of the class-k columns), so S_k = S_l =: U, and every class-j row is 0 on those columns. CHECKED: G1.step-b [`rank3.py`]. +(c) *Exchange.* If block j has rank 3, each of the other two blocks contains the class-j columns and one of the classes k, l; say it is S_j + U. U vanishes on the class-j rows T_j; the projection of S_j onto T_j is B[T_j, C_j] = [[I₂, ∗],[∗, I₂]], whose rank is ≥ 2 for every filling. So dim(S_j + U) ≥ rank B[T_j, C_j] + dim U ≥ 2 + 3 = 5. CHECKED: G1.step-c (all 2⁸ fillings of the 4×4 block have rank ≥ 2). +(d) So either all three blocks have rank ≥ 4 (cost ≥ 12) or some block has rank 3 and the other two have rank ≥ 5 (cost ≥ 3 + 5 + 5 = 13). Hence cost ≥ 12, and 12 is attained. ∎ + Independent confirmation: one CNF "cost ≤ K" (per-block factorisations plus a cardinality bound): K = 11 UNSAT, K = 12 SAT with block ranks recomputed by elimination (4,4,4) — CHECKED: G1.cnf [`costsat2.py`; the card also cross-checked with a CP-SAT model and a split-by-split CNF, **CHECKED (recorded)**, fprime §11.5]. + +**The 217 optima — CHECKED** [fprime §12.2, `enumW.py`, `anaB.py`]. Enumerating to exhaustion all B with block ranks ≤ (4,4,4) gives exactly **217**, all of cost 12 with ranks (4,4,4) (G1.optima). 216 = 6³ are class-block-diagonal (only same-class entries; each 4×4 class block [[I,U],[V,I]] has rank 2; dim S_k = 2, ρ = 6, w = (2,2,2)); one, B0, uses 24 cross-class entries and has ρ = 4, w = (0,0,0), S_0 = S_1 = S_2 = W of dimension 4. G1.f2s-identity confirms cost = 3ρ − Σ w_j for all 217. + +**All 217 lift — CHECKED.** For each optimum the Camion linear system of the three blocks (one shared sign per entry, `jsign.c`) is consistent, and the resulting ±1 signing of supp B has exact Q-ranks (4,4,4) = the F2 ranks (217 of 217); the whole 12×12 B is even TU-signable (217 of 217) (G1.lifts) [`liftall.py`, S1 addendum A]. By Lemma B the lift gives cost ≥ v on tied_min independently of (a)–(d). + +**Sub-configurations — CHECKED / CHECKED (recorded).** Every one-line deletion costs 12 (G1.subconfigurations: the CNF "cost ≤ 11" is UNSAT for all 12). S2 computed the exact cost of **all 4095** sub-configurations: cost ≥ v for every one, with tight ones (cost = v) of every size ≤ 10 and none of size 11 [`s2b.py`, S2 §4; **CHECKED (recorded)**: the table is in `evidence/fleet-S2.md`; verify.sh recomputes the size-11 and one size-10 case only]. + +## 5. Certificate limits: every order / label / multi-copy / 2-adic certificate stops at v − 1 on tied_min + +**Lemma MC (multi-copy certificate, MCC) — PROVEN** [fprime §9]. Give each line t any number of *copies* (t, c) with labels a(t,c) ⊆ π(t), b(t,c) ⊆ σ(t), |a ∩ b| odd, and an order on the copies such that every pair (t,c) ≠ (s,c′) with |a(t,c) ∩ b(s,c′)| odd and (t → s an incidence, or t = s) is forward. Then **cost ≥ Σ_i r_i ≥ #copies.** *Proof.* With U_i[(t,c), t] = [i ∈ a(t,c)] and V_i[s, (s,c′)] = [i ∈ b(s,c′)], N := Σ_i U_i B[R_i, A_i] V_i has entries B_ts · |a(t,c) ∩ b(s,c′)| mod 2, rank N ≤ Σ_i r_i, and N is unit upper triangular in the given order. ∎ L8 is the one-copy case; MAS-sum is the case of copies (t, j), j ∈ D(t), with a = b = {j}; Theorems P, U and M1 are MCC bounds. CHECKED: G3.lemma-MC (N unit upper triangular, Σ r_j ≥ 20, on 60 admissible B for cex_min_1). + +**On the 19-line cex_min_1 (entries in {−1, 0, 1}; `data/cex_min_1.json`)** [T3 "Conjecture F"; fprime §0, §9]: +- the maximum one-copy L8 certificate is **18 < v = 19**, so T3's Conjecture F (a certificate of size v always exists) is **false** — **CHECKED (recorded)** (CP-SAT, two independent encodings, `certlib.py`, `verify.py`; T3 Conjecture F; `evidence/cex-README.txt`); +- the **multi-copy certificate reaches 20 ≥ v = 19** (CP-SAT optimal with up to 3 copies per line). Here the stored certificate (20 copies on 17 lines) is *verified*, not solved: labels inside supports, odd diagonals, every odd entry on an incidence or same-line pair forward — **CHECKED**: G3.mcc-certificate. A stored B of cost 22 (ranks 10, 6, 6) gives 20 ≤ cost(cex_min_1) ≤ 22 — CHECKED: G3.lemma-MC. So cex_min_1 refutes the *certificate*, not (A); +- parity structure: every incidence has |π(t) ∩ σ(s)| ∈ {0, 2} (Lemma 1.1, an odd number of ±1 cannot vanish), tied lines with the same D and the same sign class never meet (Lemma 1.2) — CHECKED: G3.parity-lemmas (all 114 incidences of cex_min_1 and of the whole 121-line pool); G3.cex-structure: D-types {0,2}:5, {0}:4, {1,2}:3, {0,1}:3, {2}:2, {0,1,2}:1, {1}:1, eight lines of odd |D|. + +**On tied_min** [fprime §11.5, §10, §12; all **CHECKED (recorded)**, CP-SAT OPTIMAL, stored solutions re-verified on the card; the solves are not repeated here]: L8 certificate = **11**; multi-copy certificate = **11** with 1, 2, 4 and 6 copies per line; the per-scale 2-adic copies with one-sided repairs (the restricted family of §10) stay below the unrestricted MCC. The true cost is 12 (§4). Consequently **no certificate of the multi-copy kind — in particular none built from Theorem P, Theorem U, M1, MAS-sum, L8 or per-scale 2-adic reductions, and no cross-scale ordering lemma for them — can prove (A) at T = 3** (a proof must see genuine F2 rank, not one triangular minor of Σ_j U_j B_j V_j with copy-type U_j, V_j). Caveat: "up to 6 copies per line" is what was solved; the number of distinct label types per line is larger, and the claim for arbitrarily many copies is not proved. Also **CHECKED (recorded)** [fprime §11.2]: even allowing copies, every group-level unit-world scheme is capped at 1/2. + +**Per-class rowspace lemmas are false by exactly 1 — CHECKED (recorded)** [fprime §13.2; `lemmaN.py`, `lemmaNsum.py`, `lemmaN2.py`, adversarial annealing with exact F2 ranks on F2S configurations of 4–7 lines where cost ≥ v still holds]: N (a_j + w_j ≥ n_j), N-sum (Σ_j (a_j + w_j) ≥ v) and N′ (n_j ≤ 2w_j + ρ′) fail; and the polymatroid bound 2·cost ≥ 3ρ + Σ_k dim S_k gives only 9 on tied_min [S2 §3]. In F2S the slack must move between classes: any proof needs a joint argument across the three classes, as in step (c). + +**The mod-4 lift framework — a framework, not a proof tool** [fprime §12.4]. For any F2 rank factorisation B_j = UVᵀ and integer lifts U + 2X, V + 2Y, N = Σ_j D(p_j)(U + 2X)(V + 2Y)ᵀ D(q_j) has rank_Q N ≤ Σ_j r_j; on tied unit lines N = Δ + 2W and the obstruction is a linking form; on the 217 optima of tied_min the linking forms are mostly nonzero. For a *fixed* B, "some lift has rank v" is equivalent to Σ r_j ≥ v, so the framework needs a B-independent argument on the coset family (**OPEN**). + +## 6. The lift route + +**Lemma W′ — PROVEN** [fprime §13.3, S1 addendum A]. If B has a **TU signing** (a ±1 signing of supp B under which B is totally unimodular — equivalently the binary matroid M[I | B] is regular, Camion/Tutte), then every block of the signed matrix B′ is TU, so rank_Q = rank_F2 on every block, and by Lemma B **cost(B) ≥ v**. (Regularity of the column matroid M[B] alone is *not* enough: a full-rank B has M[B] free; A = [[1,1,0,1],[1,0,1,1],[0,1,1,1]] has M[A] graphic but M[I|A] = F7.) The weaker hypothesis Lemma B actually uses is any rational B′ supported on incidences plus the diagonal, with nonzero diagonal, and Σ_j rank_Q B′[R_j, A_j] ≤ cost: the **open core is (Q ≤ F2)**, "the minimum Q-cost over such B′ is ≤ the minimum F2-cost", and (A) = (Q ≤ F2) + Lemma B (g1 §14). A *same-support* rational lift of a minimiser with **rank_Q = rank_F2 on the three blocks** (**G1′, lift**) is a convenient witness for (Q ≤ F2) — it implies (A) for the configuration — and probably not the final form (§10.2). Since F7* blocks occur for non-optimal admissible B (below), a statement about same-support lifts must be about a minimiser, not about every admissible B. + +**Camion, chordless cycles, and joint signability — PROVEN** [g1 §9]. Let G be the bipartite support graph of B (every 1, diagonal included); block j is the *induced* subgraph G_j = G[V_j], V_j = R_j + A_j. Signs are written additively, x ∈ F2^{E(G)} (x_e = 1 meaning −1). +- **Lemma 9.1 (chordless holonomy).** If a signing of a 0/1 matrix is TU, every chordless cycle γ of its support graph (length 2m) has Σ_{e∈γ} x_e = m mod 2. *Proof.* γ spans a square submatrix with support exactly γ, a 2m-cycle matrix of determinant ±(Π₁ + (−1)^{m−1}Π₂), which must lie in {0, ±2} and so be 0, i.e. Π₁Π₂ = (−1)^m. ∎ +- **Lemma 9.2 (uniqueness up to scaling).** Two TU signings of M differ by a coboundary x′ = x + (r_t + c_s): chordless cycles span the cycle space Z(G), so x and x′ agree on all of it; coboundaries (row/column scalings) preserve TU. ∎ +- **Theorem 9.3.** B admits one signing with all three blocks TU **iff** (i) each block B[R_j, A_j] is TU-signable and (ii) the F2 system {Σ_{e∈γ} x_e = |γ|/2 : γ a chordless cycle of some G_j} is consistent. *Proof.* (⇒) Lemma 9.1 in each block. (⇐) Take a solution x and a TU signing s_j of block j: on every chordless cycle of G_j they have the same sum, hence on Z(G_j), so x|G_j = s_j + coboundary, which is TU. ∎ Equivalently, with h_j the holonomy functional on Z(G_j): h₀(g₀) + h₁(g₁) + h₂(g₂) = 0 whenever g₀ + g₁ + g₂ = 0, g_j ∈ Z(G_j). +- **Lemma G (gluing; S1 §3).** Pairwise relations g ∈ Z(G_j) ∩ Z(G_k) = Z(G[V_j ∩ V_k]) never obstruct, because a chordless cycle of the induced graph G[V_j ∩ V_k] is chordless in both G_j and G_k. So an obstruction to (ii) is a genuinely **three-block (Čech) relation**. + CHECKED: G2.theorem-9.3 — the Camion system (`jsign.c`, which builds exactly the system of 9.3) agrees with an *independent* oracle (`brutetu.c`: every ±1 signing of the entries off a spanning forest, every square minor computed exactly) on 53 instances (all minimisers of the v = 7, v = 8, v = 9 examples below and 40 random small B), covering the outcome classes J = 1; J = 0 with one, two or three blocks signable; and the Čech class (all blocks signable, no joint signing); the pure-Python Camion solver (`jointsign.py` method) agrees with `jsign.c` on every minimiser of the instances below. + +**Two failure modes of G1-joint, both occur — CHECKED** [g1 §9–10]. (F1) one block is not TU-signable: the basic obstruction is an induced *odd theta* — branch vertices row 0 and column 6, three paths of length 3 — e.g. the 4×4 submatrix [1110 / 0011 / 0101 / 1001], which uses diagonal entries, so non-degenerate geometry does not exclude it (G2.obstructions: not TU-signable; F7 = [110,011,101,111] likewise, J2 and the odd 3-cycle are signable). (F2) all blocks TU-signable but no joint signing: `cech_v8.json`, v = 8, f = 11, one of 320 minimisers (G2.failure-modes). + +**Exact counterexamples to nearby statements — all CHECKED:** +1. *Whole-matrix TU fails* (`cex_wholeTS_v9.json`, g1 §6): v = 9, f = 13; exhaustive minimum cost 18, 16 minimisers, block ranks (7,4,7) for all; **none** of the 16 is TU-signable as a whole 9×9 matrix (`tusign.c` and the Python Camion solver agree), yet every block of every minimiser is TU-signable, one joint signing exists for each, and its exact Q block ranks equal the F2 ranks (so the lift Lemma B needs exists and (A) holds: 18 ≥ 9). The unique fewest-ones minimiser (8 off-diagonal ones) is support-minimal and not whole-TS, so "support-minimal ⇒ whole-TS" and "fewest-ones ⇒ whole-TS" are false. The example is degenerate (lines 1 = 2, lines 4 = 6 equal, lines 7, 8 on one projective line, points 4, 5 coincide); whether whole-TS fails also for non-degenerate configurations is open. G2.w9-instance, G2.w9-no-whole-TS, G2.w9-lift. +2. *Support-minimal ⇏ jointly signable* (`supmin_fail_v8.json`, v = 8, cost 14, 2 minimisers, both with 9 ones, both support-minimal, ranks (4,5,5)): one is whole-TS, the other has block 0 non-signable; they differ by the swap (3,0) ↔ (1,6). Any selection rule must see signability. G2.failure-modes. +3. *Non-regular minimisers* (S1's F7* gadget, `gad.json`, v = 10, f = 29): the recorded exhaustive run over all 2²⁹ matrices gives minimum cost 19 and 23552 minimisers, 3052 of them with a non-TU-signable block [g1 §1; **CHECKED (recorded)**; the 2²⁹ run is not repeated]. CHECKED: G2.gadget — a stored minimiser (11 off-diagonal ones) has block ranks (6,6,7), sum 19, blocks 1 and 2 not TU-signable. So "every optimum is regular" is false. +4. *K22-free ⇏ TU-signable* (S1's aff14, n = 14): an admissible B with 14 distinct points and 14 distinct lines, off-diagonal K22-free (L6 holds), ranks (9,11,11), one block equal to the whole matrix, **not TU-signable** — so non-degeneracy plus L6 does not give a Lemma W′ signing; the property must come from optimality (this B has cost 31 vs an SA minimum of 24 on that configuration, **CHECKED (recorded)** S1 addendum B). G6.aff14. +5. *Peeling induction PP is false* (S2): there are 272 of 4095 subsets of tied_min with no group X satisfying cost(S) ≥ cost(S − X) + |X|; the smallest failure is v = 2, since a lone line costs |D(t)| = 2 and the pair {0, 3} (distinct points, distinct lines) costs 2. CHECKED: G4.PP; the 272 of 4095 is **CHECKED (recorded)** [`pp.py`]. +6. *Single-block regularity of the exchange*: single-entry deletion does not restore signability (32 minimisers of the gadget have no single deletion that stays a minimiser; 2–3 entries are needed) [g1 §1, **CHECKED (recorded)**]; any exchange proof must be a multi-entry move. + The packing structure — "every fewest-ones minimiser is a vertex-disjoint union of directed cycles and K3 cliques" — is true on 450 random configurations but fails on three configurations (v = 7, 7, 10) [g1 §2, **CHECKED (recorded)**], so G1 cannot be reduced to cycle and clique packings. + +**Where the route stands.** Whole-B TU-signable ⇒ joint block-TU signable ⇒ G1′ (lift) ⇒ (Q ≤ F2) ⇒ (A) for that configuration. The first implication is false in general (item 1) and so is the second (§7, X1). G1′ and (Q ≤ F2) are OPEN (§10). + +## 7. Outcome X1: does some cost-minimiser always admit one signing with all three blocks TU? ("G1-joint") + + + +**G1-joint is false at T = 3 — CHECKED, exact; G1′ (lift) is OPEN.** Two counterexamples are described in full (the other twelve instances of the same kind are checked in G2.nojoint14) (`data/cex_joint_v7.json`, `data/nojoint_21_1.json`; g1 §10–11 and the jclimb2 search of the same card). +- **v = 7** (f = 11): P = (2,0,−2) (−32,−32,−48) (−4,−4,−4) (0,1,1) (−2,0,−1) (0,−1,1) (−2,−2,0), Q = (2,−12,−4) (1,−2,0) (−2,2,−1) (−1,2,−1) (−2,0,2) (−4,4,0) (32,64,−64). Exhaustive over all 2¹¹ admissible B: minimum cost **12**, exactly **four** minimisers (7, 8, 9, 10 off-diagonal ones), all with block ranks (4,4,4). In **all four, block 2 (rows 0–5, columns 0,2,3,4,6) is not TU-signable**, so no minimiser has a signing with all three blocks TU (G2.j7-no-joint: `tusign.c`, `jsign.c`, the Python Camion solver and the exhaustive oracle agree). Obstruction: the 4×4 submatrix on rows 0,2,3,4 × columns 0,3,4,6 — an induced odd theta (branch vertices row 4 and column 3, paths r4–c0–r0–c3, r4–c4–r2–c3, r4–c6–r3–c3) using the diagonal entries (0,0), (3,3), (4,4) — is not TU-signable in any of the four. **(A) holds here: 12 ≥ 7.** +- **v = 10** (f = 19): minimum cost 14, two minimisers, ranks (5,4,5); blocks 0 and 1 are TU-signable but block 2 is not, in both, so there is no joint signing; (A) holds: 14 ≥ 10 (G2.j10-no-joint). +- **14 instances in all** (`data/nojoint_21_1…14.json`, v = 7–10, found by the climb `jclimb2.py`): none has a jointly signable minimiser, and (A) holds on each (cost ≥ v; e.g. 15 ≥ 7, 14 ≥ 9, 16 ≥ 9); G2.nojoint14. +- **The lift that Lemma B needs exists on the v = 7 example.** The same-support rational matrix [[−1,0,0,−2,0,0,0],[0,3,0,0,0,0,0],[0,0,1,−2,1,0,0],[0,0,0,−2,0,0,−1],[−2,0,0,0,−2,0,2],[0,0,0,0,0,2,0],[0,0,2,0,0,0,2]] has the support of the 7-ones minimiser and exact Q block ranks (4,4,4) = the F2 ranks (G2.j7-lift). Reason: block 2 has only 4 nonzero rows and F2 rank 4, so any lift with the same support whose 4 nonzero rows stay linearly independent over Q has Q-rank exactly 4 — TU is irrelevant for a full-row-rank block. +- **Exact lifts for every minimiser tested — CHECKED (G2.nojoint-lifts).** An exact computation in the manner of the card's `exactlift.py` (row/column scalings fix a spanning forest to 1; the lift conditions are the vanishing of all (r_j + 1)-minors of each block, with all support entries nonzero; a lex Gröbner basis decides the system over C on the card, and `scripts/make_lifts.py` finds explicit points) gives an explicit same-support rational lift with exact block ranks equal to the F2 ranks for: all 4 minimisers of cex_joint_v7; the first ≤ 12 minimisers (by ones count) of each of nojoint_21_1…14; 8 sampled non-TS minimisers of the F7* gadget — 102 lifts in all, mostly with ±1 entries in a unique gauge class, stored in `data/lifts_nojoint.json`; `verify.sh` re-checks, for each, that the matrix is a minimiser's support with nonzero diagonal and exact Fraction block ranks equal to the F2 ranks. These are ±1 (or small integer) signings that preserve every block rank without being TU. Earlier random-weighting searches that found no lift on some of these were inconclusive (the lift is a structured solution of the minor equations). The tested minimisers are not all minimisers of nojoint_21_*, and no failure of G1′ is known. + +**Hierarchy, exact at T = 3.** whole-B TU-signable (false: v = 9, §6.1) ⇒ one signing with all three blocks TU (false: v = 7 and v = 10) ⇒ G1′, a rank-preserving same-support rational lift on the three blocks (OPEN; holds on every minimiser tested, 102 exact lifts) ⇒ (Q ≤ F2) ⇒ (A). So TU-signability is too strong an invariant: **the Lemma W′ route cannot prove (A) as stated.** G1′ needs the (r_j + 1)-minors of each block to vanish — an algebraic, not a linear, condition — and only where a block is rank-deficient. The TU-signability test is a *linear* system; its failure says nothing yet about (A). + + + +## 8. Outcome X2: rank-3 decoders on the Hesse configuration over Q(ω) + +**Setting.** The Hesse configuration is the 9 flexes of a cubic, 9 points and 12 lines with 3 points on every line and 4 lines through every point; it is realised over Z[ω], ω² + ω + 1 = 0, and over no real or rational field (no ordinary line exists, so Sylvester–Gallai fails). `lib/hesse.py` builds it exactly (G7.hesse: 9 points, 12 lines, 3 points per line, 4 lines per point, 21 intersection points, every pair of the 9 points on one of the 12 lines). The experiment draws configurations of v = 6–12 lines (p, q) with p among the 9 Hesse points (or the 21 intersection points of the 12 lines) and q among the 12 Hesse lines (or the lines through pairs of the 21 points), after a random projective change of coordinates so that the coordinate triangle is generic; the pairs (p, q) with p·q ≠ 0 are biased towards incidences; the exact minimum of cost over **all** 2^f admissible B is computed (f ≤ 22) with the same C enumerator as G2. Lemma B (and the lift route) hold verbatim over Q(ω); the ordering arguments of Lemma A, Theorem U and M1 do not (Q(ω) has no field order). The question: *does any rank-3 decoder built this way cost less than v?* + +**Smoke check in `verify.sh` (G7, CHECKED).** 16 random configurations with fixed seed, evaluated exhaustively: smallest cost − v = 0, cost = v in 1, cost < v in 0. It checks the harness; it is not the experiment. + + + +**No cost < v found — CHECKED (recorded), evidence only** (scripts `g1/hesse.py`, `g1/hesse_hc.py`; logs `g1/hesse_runs/`; the harness of `lib/hesse.py` is a port, G7). Snapshot 2026-10-14, 14:20: four random-sampler runs (seeds 1–4, 400 configurations each, cap f ≤ 22, every one evaluated exhaustively over all admissible B): 1600 configurations, smallest cost − v = 0, 61 with cost = v, none with cost < v. Three hill-climbs over the configuration (seeds 11, 12, 13; 30 restarts of 200 steps each, objective (cost − v)·100 − f, cap f ≤ 22): 90 restarts, 6 reach cost = v, none goes below v. So **(A) also holds on all tested Hesse geometry over Q(ω)**: the lack of a field order, or the absence of an ordinary line, is **not** supported as the mechanism of any cost < v. This is evidence only: the tested configurations are small (v ≤ 12, f ≤ 22) and the search is stochastic. + +## 9. Evidence + +All **CHECKED (recorded)** unless a verify group is named; none is a proof. +- *Adversarial hill-climb* (S3, `S3_search.c`, 1 process): lines (p, q) with entries in {−R..R}³, R = 1, 2, v = 5–12; several hundred climbs of 3000–6000 mutations, objective cost·1000 − #incidences, inner simulated annealing over B. **No configuration with cost < v**; every climb ends at cost = v exactly, including tight cases with 40–51 incidences at v = 9 (R = 1). Caveat: the inner SA gives only an upper bound on cost, so a hidden narrow basin could be missed. +- *All 4095 sub-configurations of tied_min* (S2 `s2b.py`): cost ≥ v for every one; tight at every size ≤ 10; size 11 costs 12 (recomputed here for the 12 one-line deletions: G1.subconfigurations). +- *Random F2S* (S2 `f2stest.py`): 30 random {−2..2} F2S configurations (8–13 lines, 20–66 incidences): "cost ≤ v − 1" UNSAT for every rank split, MCC = v + 2…v + 8 (OPTIMAL); recomputed here for 8 smaller ones (G5.identity). +- *Exhaustive small configurations* (S1): ~85 random configurations (v = 6–9, including repeated lines and collinear points) and 120+ grid configurations (v = 7–9, f ≤ 23): in every one some minimiser is jointly signable (these sweeps predate the counterexamples of §7, which came from a targeted climb); and 450 random configurations (v = 6–12, exhaustive) in which every fewest-ones minimiser is TS. +- *Per-scale and multi-copy data* (fprime §10): 10 random {−1,0,1} configurations, L8 = v in each, MCC = v + 1…v + 5; 121-line pool: MCC ≥ 119 (not shown ≥ 121). +- *Hesse* (§8). + +## 10. Open problems, stated precisely + +1. **(A) at T = 3 over Q.** For every configuration of lines (p(t), q(t)) ∈ Q³ × Q³ with p(t)·q(t) ≠ 0 and every admissible B, Σ_{j=1}^{3} rank_F2 B[R_j, A_j] ≥ v. Known: T ≤ 2 (Lemma A); fails in char 2 for no T (cost ≥ v there) and for T ≥ 7 over Q; tied_min is tight; no counterexample in any search (§9). +2. **(Q ≤ F2), the open core.** For every such configuration, is min over rational B′ supported on incidences plus the diagonal (nonzero diagonal) of Σ_j rank_Q B′[R_j, A_j] ≤ min over admissible B over F2 of Σ_j rank_F2 B[R_j, A_j]? Then (A) = (Q ≤ F2) + Lemma B. It fails at T ≥ 7. *Witness form.* **G1′ (lift):** some cost-minimiser B has a same-support rational B′ (B′_tt ≠ 0) with rank_Q B′[R_j, A_j] = rank_F2 B[R_j, A_j] for j = 1, 2, 3. It holds on every minimiser tested (102 exact lifts, §7) and is a convenient witness, but probably not the final form: with a_i collinear on a line L, all Y-lines equal to L, all Y-points equal to one point c off L and X-lines through c, the admissible pattern contains B = [[I_k, F],[G, I_m]] with F and G arbitrary 0/1 matrices (g1 §14, **CHECKED (recorded)** for k = 3, m = 4), so any F2/Q minrank gap of a 0/1 pattern embeds in a same-support lift question; there sub-support lifts still reach the F2 optimum, so (Q ≤ F2) is unaffected, and a proof must allow the support to change (an exchange to a liftable minimiser, or a direct construction of a cheap rational B′). +3. **A uniform F2 certificate beyond multi-copy.** Does there exist, for every configuration, a family of F2 matrices U_j (m × |R_j|), V_j (|A_j| × m) — arbitrary row and column combinations inside each block, not only copy-type labels — such that Σ_j U_j B[R_j, A_j] V_j has rank ≥ v **for every admissible B**? (It would give (A) with cost ≥ rank ≥ v.) On tied_min the optimum has all three block ranks 4 and each of its kinds is tight in a different way (block-diagonal: ρ = 6; B0: ρ = 4), so such a family must be B-dependent in structure or rank-based. +4. **F2S.** Is Σ_j w_j ≤ 3ρ − v, i.e. is (A) true in F2S? Equivalent to (A) there; the observed frontier of (ρ, rank pattern) on tied_min is (4; 4,4,4), (5; 2,3,3), (ρ ≥ 6; 2,2,2). A general lower bound Σ_{i≠j} dim(S_i ∩ K_j) ≥ v − 2 Σ_j mr_j (fprime §12.5) would suffice and is not proved. +5. **M1 without the hypothesis.** Does cost ≥ v/2 (or Σ_j MAS(G[D_j]) ≥ v/2, Conjecture M) hold when some point has full support? The wild edges (full-support point on full-support line) need a block-rank argument; fprime §9 gives a heuristic warning that MAS-sum alone may be o(v) on Szemerédi–Trotter-extremal full-support configurations, so a proof must use the F2 label part. +6. **Theorem U beyond the unit world.** A rational "digit lemma" for tied classes whose third product p_k(t)q_k(s) is even but nonzero, plus an e-selection (multi-scale) argument; a lower bound of 2/3 needs labels beyond one deletion even in the unit world (minimax of one-deletion schemes is exactly 1/2). +7. **Whole-B TU-signability for non-degenerate configurations.** The v = 9 counterexample is degenerate; is a non-degenerate one possible? +8. **Lemma SCC/Peel completeness.** Are there further universal reductions beyond strong components and unit rows (a rank-critical-line lemma fails: 850 of 1117 low-cost B on tied_min have no rank-critical line [fprime §12.5, CHECKED (recorded), `critical.py`])? +9. **T ≥ 4.** All lemmas but SCC's three-block structure and the specific tied_min exchange carry over verbatim; a T = 4 statement needs the analogous theory in PG(3,2). + +## 11. Files, reproduction, and what is not here + +- `scripts/make_lifts.py` (authors' script, needs sympy, not run by verify.sh: finds the lifts of `data/lifts_nojoint.json`), `verify.sh`, `scripts/provenance.py`, `MANIFEST.sha256`, `SOURCES.json` (pins of code, data and evidence snapshots), `requirements.txt`, `LICENSE`, `NOTICE.md`. +- `c/`: `enumall.c` (exhaustive over all 2^f admissible B, f ≤ 30), `tusign.c` (Camion TU-signability), `jsign.c` (joint Camion system; ours adds the solution output), `mas.c` (largest induced acyclic subgraph), `brutetu.c` (new: exhaustive signings × exhaustive minors, the independent oracle). Compiled from source by `verify.sh`. +- `lib/`: `kit.py` (configuration model, wrappers, exact rank routines), `satlib.py` (small CNFs: rank enumeration, "cost ≤ K"), `hesse.py` (Z[ω] arithmetic and the Hesse sampler). +- `checks/`: `tied_min.py` (G1), `g1_cex.py` and `lifts.py` (G2), `mcc_cex.py` (G3), `thm.py` (G4), `f2s.py` (G5), `nondeg.py` (G6), `hesse_smoke.py`, `hesse_below.py` (G7), `expect.py` (assertion helper). +- `data/`: configurations: `tied_min`, `cex_min_1`, `cex_wholeTS_v9`, `cex_joint_v7`, `nojoint_21_1`, `cech_v8`, `supmin_fail_v8`, `aff14`, `gad` (+ one stored non-TS minimiser), the MCC certificate of cex_min_1 and a stored cost-22 B. +- `evidence/`: verbatim snapshots of the source cards named in §0. + +**Not here, and not claimed:** the D5 DRAT certificate (#2031); the CP-SAT solves behind the certificate values of §5 and the long enumerations of §6 (their results are named as CHECKED (recorded)); the Hesse experiment itself (§8; only its harness and a smoke sample run); any κ-bearing construction. diff --git a/research/three-total-decoders/SOURCES.json b/research/three-total-decoders/SOURCES.json new file mode 100644 index 0000000000..665c62752a --- /dev/null +++ b/research/three-total-decoders/SOURCES.json @@ -0,0 +1,170 @@ +{ + "description": "Pins for research/three-total-decoders. files = code and data whose content the statements depend on; evidence = verbatim snapshots of the working cards (sources named in README section 0; the snapshot time is stated there). scripts/provenance.py checks the pins (sha256 as stored) and MANIFEST.sha256.", + "files": [ + { + "file": "c/brutetu.c", + "sha256": "9d5490a6bc5c9696e902075da2560d43abeef3d69c24b6dd05590d5d0fc93d35" + }, + { + "file": "c/enumall.c", + "sha256": "55d864202535c22952e1a9080ad834f1908d18ff857c8dc26211e25a847d1fc8" + }, + { + "file": "c/jsign.c", + "sha256": "11f8c3d1ddb103eac91ef7c92e2dd887d53b5aa407997afba3105b01ac18bdc1" + }, + { + "file": "c/mas.c", + "sha256": "c1a69e5ca874d6a382583132f0596ddefb84f0e1b31b34775ca1c2aab32b95da" + }, + { + "file": "c/tusign.c", + "sha256": "60e2538145cf3d0031ae29769b4c1a9a93fbcd252bed9163942cc5f1fd75bf2b" + }, + { + "file": "lib/hesse.py", + "sha256": "7eb9e6735ff036533cfbdd86e5aa981d62a81a76deb95aeb2b61ddf3c6362c99" + }, + { + "file": "lib/kit.py", + "sha256": "c707f5270b2eaef2da1dc0c1bf95c3ebf55d3fb667161c6c03a2126fad0422ec" + }, + { + "file": "lib/satlib.py", + "sha256": "cfbddbee3112f115c2ef606f7603481b4ef18cf80341041513a203417cc789e9" + }, + { + "file": "checks/expect.py", + "sha256": "fb18332a3adb4842c3662346aa7f6b5115debc04f1a392b6e9cbb423b7b83c8d" + }, + { + "file": "checks/f2s.py", + "sha256": "c9b843903c6a1fb51e7a0664b010de0aa0a6cd66384b3ef39a71afb168b85285" + }, + { + "file": "checks/g1_cex.py", + "sha256": "2c2d273387d6cd315e8606c8b5ffaa0421980d017c25f18df59177b3ef6277e1" + }, + { + "file": "checks/hesse_smoke.py", + "sha256": "a656c6a54bc5cd1b3878dc63a020e25d910208e9fc6d347ffd0f6e968531a5b5" + }, + { + "file": "checks/mcc_cex.py", + "sha256": "0dc3997bdc78454b1e67e3d3c3798e4924817d311bbbc526d3554876d08a053c" + }, + { + "file": "checks/nondeg.py", + "sha256": "63cf4cb580ec56102a74680d226bc6f7993e233b3406ae409b6b19bcbc78f173" + }, + { + "file": "checks/thm.py", + "sha256": "6b5d409e22d936c429f44595467939ef9e0dacedc73bc4ea177d7de2ba1770d3" + }, + { + "file": "checks/tied_min.py", + "sha256": "e6d03be2481e30439f8bd2ab03c066b56025f89924f7309dab9dd59902da1f92" + }, + { + "file": "data/aff14.json", + "sha256": "4c48f91787e8ee0407c218e3253ab38327cad0536128f73533edf864c9040891" + }, + { + "file": "data/cech_v8.json", + "sha256": "89907be2205b217f5dfa79f6e12b19f05e52f158be301752a0ccfd3759151122" + }, + { + "file": "data/cex_joint_v7.json", + "sha256": "6ef2af941ccad9f8a1c38f3a26020425022b5b09e15183b52dc0a3651261cde8" + }, + { + "file": "data/cex_min_1.json", + "sha256": "86064701dde94b4f35427bc3e19275eaf1e40e9e90d4fea28e7857f3564d4dd7" + }, + { + "file": "data/cex_min_1.json.B22.json", + "sha256": "15f5039069a175831f92c4ffe023a23a6f6e6bd6665f0ca2c2734bbe672b51ef" + }, + { + "file": "data/cex_wholeTS_v9.json", + "sha256": "9e92b7b5f1221c180af3637ff70940aca5255b92f7b641efe3c615433e54761a" + }, + { + "file": "data/gad.json", + "sha256": "ea72716f98af4a99141d28f828db3c5c99c2cc8ad7d15ed6a8329de37ee36790" + }, + { + "file": "data/mcc_cex_min_1_solution.json", + "sha256": "201337647ca3012543ae326285fbf7a77d3e0b4290d156b72dde4e22e4186a3f" + }, + { + "file": "data/nojoint_21_1.json", + "sha256": "7e5e5fa66dbaf0ac1fa7382fec28bbebe10d477e80022d648fb4c0093f23c64c" + }, + { + "file": "data/supmin_fail_v8.json", + "sha256": "2781dda2b8bc4d3ee75a2465cb7350973b514a9c737f9181e3bcff3f358ce839" + }, + { + "file": "data/tied_min.json", + "sha256": "670ed90924b601ade22f0d4adaff46d1667e5449326a0f7ba7b88dd8f5906f93" + }, + { + "file": "scripts/make_lifts.py", + "sha256": "b07eeaeeb537fecc75390ab832a5df4a629f9a1115bbd8cd40a77fd816a71d4c" + }, + { + "file": "checks/lifts.py", + "sha256": "0dc28b867ffa7d977aeb92cf9c71012030b4c27e0291b2a3659e8497622c3480" + }, + { + "file": "data/lifts_nojoint.json", + "sha256": "0eb5a156f3ca4c2fdbc43ad1004ade0897453702f25662837f33a0bf811d12da" + } + ], + "evidence": [ + { + "file": "evidence/T3-PROOF.md", + "sha256": "ef10f51b533d349ae465b1df2f46d367182264c22609d2d5cbfe3b7a6cfd7ff1" + }, + { + "file": "evidence/cex-README.txt", + "sha256": "f91bbb764bb6c10a4348b3063000b3f773aeffc7dbe65c60e93a926794e5b4e8" + }, + { + "file": "evidence/fleet-BRIEF.md", + "sha256": "5b11bc485ef50627e04fb790c463fba4ec31e851d788233ed0a4216938239a13" + }, + { + "file": "evidence/fleet-REQUESTS.md", + "sha256": "462fe8e9fa662365648e4f6fda3e029915a6e6b275b84f409670f35996098485" + }, + { + "file": "evidence/fleet-S1.md", + "sha256": "791c7d53cb1b94cfe2674be0ffd5ba509fb1cf162ced5515ac0858fa23be1f91" + }, + { + "file": "evidence/fleet-S2.md", + "sha256": "139f441a18e855e2761d2ec2ce0b53bcc2fad42d074368b02601f3bba8dc9882" + }, + { + "file": "evidence/fleet-S3.md", + "sha256": "ba1ab38b52c84e59623ac33be6e5a7a8d5cf940d66047555905c366306861bb9" + }, + { + "file": "evidence/fprime-PROOF.md", + "sha256": "cc1d9287fcdadb9afb670103fb18fac0d55664b6afd1673557aa60c217e59136" + }, + { + "file": "evidence/g1-PROOF.md", + "sha256": "304ff3ef8ef20093236d366b728acf570575050d1b9c64631bf3e5f7da668df8" + } + ], + "sources": { + "evidence/fprime-PROOF.md": "cards/KPR4-T3/fprime/PROOF.md", + "evidence/g1-PROOF.md": "cards/KPR4-T3/g1/PROOF.md", + "evidence/T3-PROOF.md": "cards/KPR4-T3/PROOF.md", + "evidence/fleet-*.md": "cards/KPR4-T3/fprime/fleet/*.md", + "evidence/cex-README.txt": "cards/KPR4-T3/cex/README.txt" + } +} \ No newline at end of file diff --git a/research/three-total-decoders/c/brutetu.c b/research/three-total-decoders/c/brutetu.c new file mode 100644 index 0000000000..ceaaff5cb7 --- /dev/null +++ b/research/three-total-decoders/c/brutetu.c @@ -0,0 +1,54 @@ +// Brute-force oracle for Theorem 9.3 (new in this package; independent of Camion's theorem). +// For a 0/1 matrix B (v x v) and three blocks B[R_j,A_j] it decides, by trying EVERY +-1 signing of the ones of B and testing +// total unimodularity of each block by computing ALL its square minors (exact integer determinants), whether +// b_j = some signing makes block j TU, J = some single signing makes all three blocks TU. +// Gauge: a spanning forest of the bipartite support graph is fixed to +1 (scaling rows/columns by -1 preserves TU of every +// submatrix, so this loses no case). Input format = jsign: per instance v, v rows as bitmasks, then per block "nR R.. nA A..". +// Output per instance: "J b0 b1 b2" (1/0) or "-1" if more than MAXFREE free sign bits remain. +#include +#include +#include +#include +#define MAXFREE 22 +int v; uint32_t row[32]; int nR[3],nA[3],R[3][32],A[3][32]; +int sg[32][32]; // sign of entry (t,s), 0 if not a one +static long long det(int k,long long m[8][8]){ // Bareiss, exact in int64 for k<=8 and entries in {0,+-1} + long long a[8][8]; memcpy(a,m,sizeof a); long long prev=1; int sign=1; + for(int i=0;i8)mn=8; + for(int k=1;k<=mn;k++){ + for(uint32_t S=0;S<(1u<>i&1)rs[q++]=R[j][i]; + for(uint32_t T=0;T<(1u<>i&1)cs[w++]=A[j][i]; + for(int a=0;a1||d<-1)return 0;}}} + return 1;} +int par[64]; static int fnd(int x){while(par[x]!=x)x=par[x]=par[par[x]];return x;} +int main(){ + while(scanf("%d",&v)==1){ + for(int i=0;i>s&1){ + int a=fnd(t),b=fnd(v+s); + if(a!=b){par[a]=b;sg[t][s]=1;} else {fr[nf][0]=t;fr[nf][1]=s;nf++;sg[t][s]=1;}} + int big=0;for(int j=0;j<3;j++){int m=nR[j]8)big=1;} + if(nf>MAXFREE||big){printf("-1\n");fflush(stdout);continue;} + int J=0,bo[3]={0,0,0}; + for(uint32_t x=0;x<(1u<>i&1)?-1:1; + int ok[3],all=1; + for(int j=0;j<3;j++){ ok[j]=tu(j); if(ok[j])bo[j]=1; else all=0;} + if(all)J=1; + if(J&&bo[0]&&bo[1]&&bo[2])break;} + printf("%d %d %d %d\n",J,bo[0],bo[1],bo[2]);fflush(stdout);} + return 0;} diff --git a/research/three-total-decoders/c/enumall.c b/research/three-total-decoders/c/enumall.c new file mode 100644 index 0000000000..f05b16c846 --- /dev/null +++ b/research/three-total-decoders/c/enumall.c @@ -0,0 +1,28 @@ +// exhaustive: input v f; f lines "t s"; for j: nR R.., nA A..; optional slack k: output all B with cost<=min+k (we output cost too) +#include +#include +#include +int v,f,ft[64],fs[64],nR[3],nA[3],R[3][32],A[3][32]; +uint32_t row[32]; +static inline int rk(int j){uint32_t rows[32];int n=0; + for(int a=0;a>s&1)x|=1u<0 && (31-__builtin_clz(rows[k]))>(31-__builtin_clz(rows[k-1]));k--){uint32_t tmp=rows[k];rows[k]=rows[k-1];rows[k-1]=tmp;} + }} + return r;} +int main(int argc,char**argv){int slack=argc>1?atoi(argv[1]):0; + if(scanf("%d %d",&v,&f)!=2)return 1;for(int i=0;i' after the flags line, +// bit i = 1 means the i-th one of B (row-major order) gets sign -1). input v; v rows of B as bitmasks; then 3 blocks: nR R.., nA A.. +// mode argv[1]: "j" joint (all blocks one system) -> prints "J b0 b1 b2" (J joint ok, bk block k ok) +#include +#include +#include +typedef unsigned __int128 u128; +int v; uint32_t row[32]; int vid[32][32]; int nv; +int nR[3],nA[3],R[3][32],A[3][32]; +u128 bs[128]; int br[128]; int havep[128]; +static int addeq(u128 e,int rhs){for(int b=127;b>=0;b--){if(!((e>>b)&1))continue;if(havep[b]){e^=bs[b];rhs^=br[b];}else{havep[b]=1;bs[b]=e;br[b]=rhs;return 1;}}return rhs==0;} +static int block(int j){ // add all Camion eqs of block j; return 0 if inconsistent + int nr=nR[j],nc=nA[j]; uint32_t rw[32]; + for(int a=0;a>A[j][b]&1)x|=1u<>i&1)x^=rw[i]; + uint32_t Z=((nc==32)?0xffffffffu:((1u<>i&1)if(__builtin_popcount(rw[i]&T)&1)ok=0; + if(ok){u128 e=0;int cnt=0;for(int i=0;i>i&1)for(int b=0;b>b&1&&(rw[i]>>b&1)){e|=(u128)1<>64));} +int main(int argc,char**argv){ + int sflag=argc>1&&argv[1][0]=='s'; + while(scanf("%d",&v)==1){ + for(int i=0;i>k&1)vid[i][k]=nv++; + if(nv>128){printf("-1\n");fflush(stdout);continue;} + int bo[3]; + for(int j=0;j<3;j++){memset(havep,0,sizeof havep);bo[j]=block(j);} + memset(havep,0,sizeof havep);int J=1;for(int j=0;j<3&&J;j++)J=block(j); + printf("%d %d %d %d\n",J,bo[0],bo[1],bo[2]); + if(sflag&&J){u128 x=0;for(int b=0;b>b&1)?'1':'0');putchar('\n');} + fflush(stdout);} + return 0;} diff --git a/research/three-total-decoders/c/mas.c b/research/three-total-decoders/c/mas.c new file mode 100644 index 0000000000..d32f99943c --- /dev/null +++ b/research/three-total-decoders/c/mas.c @@ -0,0 +1,9 @@ +// max induced acyclic subgraph size: argv: n then n lines of out-bitmasks (decimal). DP over subsets (n<=26). +#include +#include +#include +int main(){int n; if(scanf("%d",&n)!=1)return 1; uint32_t o[32]; for(int i=0;ibest)best=c;}} + printf("%d\n",best); return 0;} diff --git a/research/three-total-decoders/c/tusign.c b/research/three-total-decoders/c/tusign.c new file mode 100644 index 0000000000..17f6e818fa --- /dev/null +++ b/research/three-total-decoders/c/tusign.c @@ -0,0 +1,25 @@ +// TU-signability of binary matrix via Camion: all square Eulerian submatrices sum = 0 mod 4 (linear system over F2). +// input: nr nc, then nr rows as bitmasks (decimal over nc bits). output 1 signable /0 +#include +#include +#include +typedef unsigned __int128 u128; +int nr,nc; uint32_t row[20]; int vid[20][20]; int nv=0; +uint64_t basis[128]; int brhs[128]; // pivot by highest bit; vars <=64 -> use u128? use u128 +u128 bs[128]; int br[128]; int havep[128]; +int addeq(u128 e,int rhs){ // returns 0 if inconsistent + for(int b=127;b>=0;b--){ if(!((e>>b)&1))continue; if(havep[b]){e^=bs[b];rhs^=br[b];} else {havep[b]=1;bs[b]=e;br[b]=rhs;return 1;} } + return rhs==0; } +int main(){scanf("%d %d",&nr,&nc);for(int i=0;i>j&1)vid[i][j]=nv++; + if(nv>127){printf("-1\n");return 0;} + for(uint32_t S=1;S<(1u<>i&1)x^=row[i]; + uint32_t Z=((1u<>i&1)if(__builtin_popcount(row[i]&T)&1)ok=0; + if(ok){u128 e=0;int cnt=0;for(int i=0;i>i&1)for(int j=0;j>j&1&&(row[i]>>j&1)){e|=(u128)1<= 2 rho for EVERY B (w_j computed here by counting the elements of W, not by rank-nullity).""" +import sys, os, random, itertools +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * +from satlib import cost_leq + +rng = random.Random(21); vals = (-2, -1, 1, 2) +PF = [x for x in itertools.product(vals, repeat=3)] +Q2 = [x for x in itertools.product((-2, -1, 0, 1, 2), repeat=3) if sum(1 for c in x if c) == 2] +def f2s_config(v): + P = []; Q = [] + while len(P) < v: + if P and rng.random() < 0.9: + s = rng.randrange(len(P)); t = rng.randrange(len(P)) + p = rng.choice([x for x in PF if dot(x, Q[s]) == 0] or PF); q = rng.choice([x for x in Q2 if dot(P[t], x) == 0] or Q2) + else: p = rng.choice(PF); q = rng.choice(Q2) + if dot(p, q): P.append(list(p)); Q.append(list(q)) + return P, Q +def rowspace_elems(B): + v = len(B); basis = [] + for r in B: + x = sum(b << s for s, b in enumerate(r)) + for b in basis: x = min(x, x ^ b) + if x: basis.append(x) + el = {0} + for b in basis: el |= {w ^ b for w in el} + return len(basis), el +ident = 0; ge2 = 0; n = 0; direct = 0; tot_inc = 0 +for it in range(40): + v = rng.randrange(6, 14); P, Q = f2s_config(v); R, A, free = setup(P, Q) + zero = [[s for s in range(v) if Q[s][k] == 0] for k in range(3)] + for rep in range(5): + g = rng.getrandbits(len(free)) & rng.getrandbits(len(free)) if rep else (1 << len(free)) - 1 + B = tomat(g, free, v); rho, W = rowspace_elems(B) + if rho > 12: continue + w = [(sum(1 for x in W if x & ~sum(1 << s for s in zero[k]) == 0)).bit_length() - 1 for k in range(3)] + br = blockranks(B, R, A); n += 1; ident += (sum(br) == 3 * rho - sum(w)); ge2 += (sum(br) >= 2 * rho); direct += (sum(w) <= rho) + tot_inc += len(free) +print("F2S identity cost = 3 rho - sum_j w_j on %d (configuration, B) pairs (40 random F2S configurations, v 6-13, B random, sparse to full): holds in %d; cost >= 2 rho in %d; sum_j w_j <= rho (direct sum) in %d" % (n, ident, ge2, direct)) +# small exact: random F2S configurations have cost >= v (UNSAT at v-1); tied_min is the sharp one +rng = random.Random(33); okc = 0; N = 8 +for it in range(N): + v = rng.randrange(6, 9); P, Q = f2s_config(v) + okc += cost_leq(P, Q, v - 1) is None +print("F2S %d random F2S configurations (v 6-8): cost <= v-1 UNSAT (cost >= v) in %d" % (N, okc)) diff --git a/research/three-total-decoders/checks/g1_cex.py b/research/three-total-decoders/checks/g1_cex.py new file mode 100644 index 0000000000..fe6200053c --- /dev/null +++ b/research/three-total-decoders/checks/g1_cex.py @@ -0,0 +1,151 @@ +"""Group G2 (lift route): exact checks of the g1/PROOF.md data (sections 6, 9, 10, 11) and of Theorem 9.3 on small cases. +Every instance is enumerated over ALL admissible B (enumall.c, exhaustive), so 'minimisers' means the full list. +Prints one line per fact; verify.sh matches them with checks/expect.py.""" +import sys, os, json, itertools, random +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * + +def cross(a, b): + return (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]) + +def projeq(a, b): + return all(x == 0 for x in cross(a, b)) + +def analyse(name, py_cross=True): + P, Q = load_cfg(name); v = len(P) + best, ms, R, A, free = enum(P, Q) + Bs = [tomat(g, free, v) for _, g in ms] + rk = sorted(set(tuple(blockranks(B, R, A)) for B in Bs)) + fl = jsign_batch(Bs, R, A, True) + whole = [tus(B, range(v), range(v)) for B in Bs] + blk = [[tus(B, R[j], A[j]) for j in range(3)] for B in Bs] + assert all(f[0][1:] == tuple(b) for f, b in zip(fl, blk)), 'jsign block flags disagree with tusign' + info = dict(P=P, Q=Q, v=v, best=best, ms=ms, R=R, A=A, free=free, Bs=Bs, ranks=rk, fl=fl, whole=whole, blk=blk) + if py_cross: + info['py'] = [py_flags(B, R, A) for B in Bs] + assert all(p == f[0] for p, (f) in zip(info['py'], fl)), 'python Camion disagrees with jsign' + return info + +def lifts_ok(I, idx): + """Exact Fraction block ranks of the joint signing found by the Camion system equal the F2 ranks?""" + out = [] + for i in idx: + (f, sgn) = I['fl'][i] + if not f[0]: + out.append(None); continue + S = signed_matrix(I['Bs'][i], sgn) + out.append(block_q(S, I['R'], I['A']) == blockranks(I['Bs'][i], I['R'], I['A'])) + return out + +# ---------------------------------------------------------------- 6. whole-matrix TU fails: v = 9 +I = analyse('cex_wholeTS_v9.json') +v = I['v']; ones = sorted(bin(g).count('1') for _, g in I['ms']) +print("W9 v=%d f=%d mincost=%d minimisers=%d block ranks %s offdiag-ones %d..%d" % (v, len(I['free']), I['best'], len(I['ms']), I['ranks'], ones[0], ones[-1])) +print("W9 whole-matrix TU-signable: %d of %d; all three blocks TU-signable: %d of %d; jointly block-TU signable: %d of %d; python Camion agrees: %s" % ( + sum(I['whole']), len(I['ms']), sum(all(b) for b in I['blk']), len(I['ms']), sum(f[0][0] for f in I['fl']), len(I['ms']), all(p == f[0] for p, f in zip(I['py'], I['fl'])))) +lo = lifts_ok(I, range(len(I['ms']))) +print("W9 joint signing has exact Q block ranks equal to the F2 ranks for %d of %d minimisers; (A) %d >= v = %d: %s" % (sum(1 for x in lo if x), len(I['ms']), I['best'], v, I['best'] >= v)) +# fewest-ones minimiser = the matrix printed in g1/PROOF.md section 6 +want = ["100100001", "010000001", "001000100", "011100000", "000010000", "000001000", "100000100", "000000010", "001000001"] +mins8 = [B for (c, g), B in zip(I['ms'], I['Bs']) if bin(g).count('1') == 8] +print("W9 the 8-ones minimiser of PROOF section 6 occurs: %s (number of 8-ones minimisers %d)" % (any(["".join(map(str, r)) for r in B] == want for B in mins8), len(mins8))) +P, Q = I['P'], I['Q'] +print("W9 degeneracy: lines 1,2 equal %s; lines 4,6 equal %s; lines 7,8 same projective line %s; points 4,5 coincide %s" % ( + projeq(Q[1], Q[2]), projeq(Q[4], Q[6]), projeq(Q[7], Q[8]), projeq(P[4], P[5]))) + +# ---------------------------------------------------------------- 11. joint block-TU fails: v = 7 (X1 evidence) +I7 = analyse('cex_joint_v7.json') +v = I7['v'] +print("J7 v=%d f=%d mincost=%d minimisers=%d off-diagonal ones %s block ranks %s" % (v, len(I7['free']), I7['best'], len(I7['ms']), sorted(bin(g).count('1') for _, g in I7['ms']), I7['ranks'])) +print("J7 jointly block-TU signable: %d of %d; whole-matrix TU-signable: %d; block 2 TU-signable: %d; blocks 0,1 TU-signable: %d,%d; python Camion agrees: %s; (A) %d >= v = %d: %s" % ( + sum(f[0][0] for f in I7['fl']), len(I7['ms']), sum(I7['whole']), sum(b[2] for b in I7['blk']), sum(b[0] for b in I7['blk']), sum(b[1] for b in I7['blk']), + all(p == f[0] for p, f in zip(I7['py'], I7['fl'])), I7['best'], v, I7['best'] >= v)) +M7 = [[-1, 0, 0, -2, 0, 0, 0], [0, 3, 0, 0, 0, 0, 0], [0, 0, 1, -2, 1, 0, 0], [0, 0, 0, -2, 0, 0, -1], [-2, 0, 0, 0, -2, 0, 2], [0, 0, 0, 0, 0, 2, 0], [0, 0, 2, 0, 0, 0, 2]] +supp7 = [[int(x != 0) for x in r] for r in M7] +hit = [i for i, B in enumerate(I7['Bs']) if B == supp7] +print("J7 lift: the printed rational 7x7 matrix has the support of a minimiser: %s; exact Q block ranks %s, F2 block ranks %s" % ( + bool(hit), block_q(M7, I7['R'], I7['A']), blockranks(supp7, I7['R'], I7['A']))) +print("J7 block 2 has %d nonzero rows of %d (full row rank 4 for every odd lift: F2 rank 4 = number of nonzero rows)" % ( + sum(1 for t in I7['R'][2] if any(I7['Bs'][hit[0]][t][s] for s in I7['A'][2])), len(I7['R'][2])) if hit else "J7 no hit") + +print("J7 submatrix rows 0,2,3,4 x cols 0,3,4,6 (induced odd theta once the leaf column 2 is dropped) TU-signable, per minimiser (by ones): %s" % sorted( + (bin(g).count('1'), tus(B, [0, 2, 3, 4], [0, 3, 4, 6])) for (_, g), B in zip(I7['ms'], I7['Bs']))) +# second refutation instance of the same kind (jclimb2): v = 10 +I10 = analyse('nojoint_21_1.json', py_cross=False) +print("J10 v=%d f=%d mincost=%d minimisers=%d block ranks %s jointly block-TU signable %d; block-wise TU-signable (b0 b1 b2) %s; (A) %s" % ( + I10['v'], len(I10['free']), I10['best'], len(I10['ms']), I10['ranks'], sum(f[0][0] for f in I10['fl']), [tuple(int(x) for x in b) for b in I10['blk']], I10['best'] >= I10['v'])) + +# ---------------------------------------------------------------- 9/10. the two failure modes F1 and F2 (Cech) +IC = analyse('cech_v8.json', py_cross=False) +cech = [i for i, f in enumerate(IC['fl']) if (not f[0][0]) and all(f[0][1:])] +print("C8 v=%d f=%d mincost=%d minimisers=%d; minimisers with all blocks TU-signable but NO joint signing (Cech, F2): %d; jointly signable: %d" % ( + IC['v'], len(IC['free']), IC['best'], len(IC['ms']), len(cech), sum(f[0][0] for f in IC['fl']))) +pc = [py_flags(IC['Bs'][i], IC['R'], IC['A']) for i in cech[:3]] +print("C8 python Camion agrees on the Cech minimisers: %s" % all(p == IC['fl'][i][0] for p, i in zip(pc, cech[:3]))) +IS = analyse('supmin_fail_v8.json') +v = IS['v'] +print("S8 v=%d f=%d mincost=%d minimisers=%d ones %s block ranks %s; whole-TU %s; block TU flags %s; jointly signable %d" % ( + v, len(IS['free']), IS['best'], len(IS['ms']), sorted(bin(g).count('1') for _, g in IS['ms']), IS['ranks'], [int(x) for x in IS['whole']], + [tuple(int(x) for x in b) for b in IS['blk']], sum(f[0][0] for f in IS['fl']))) +print("S8 the two minimisers differ by one swap of ones: %s" % (bin(IS['ms'][0][1] ^ IS['ms'][1][1]).count('1') == 2)) + +# ---------------------------------------------------------------- Lemma 9.1 / F7 / odd theta +F7 = [[1, 1, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]] +J2 = [[1, 1], [1, 1]]; C3 = [[1, 1, 0], [0, 1, 1], [1, 0, 1]] +print("L91 TU-signable: J2 %s, odd 3-cycle %s, F7 submatrix [110,011,101,111] %s" % (tus(J2, range(2), range(2)), tus(C3, range(3), range(3)), tus(F7, range(4), range(3)))) +theta = [[1, 1, 1, 0], [0, 0, 1, 1], [0, 1, 0, 1], [1, 0, 0, 1]] +print("L91 odd theta of supmin_fail_v8 (rows 0,1,2,6 x cols 0,3,4,6): TU-signable %s" % tus(theta, range(4), range(4))) + +# ---------------------------------------------------------------- Theorem 9.3 against the brute-force oracle +cases = [] +def add(I, idx, tag): + for i in idx: + cases.append((tag, I['Bs'][i], I['R'], I['A'])) +add(I7, range(len(I7['Bs'])), 'J7'); add(IS, range(len(IS['Bs'])), 'S8'); add(IC, cech[:2] + [i for i, f in enumerate(IC['fl']) if f[0][0]][:3], 'C8') +add(I, [0, 1, 2], 'W9') +rng = random.Random(93) +vals = (-2, -1, 0, 1, 2) +pool = [x for x in itertools.product(vals, repeat=3) if any(x)] +n_rand = 0 +while n_rand < 40: + v = rng.randrange(5, 8); P = []; Q = [] + while len(P) < v: + if P and rng.random() < 0.9: + s = rng.randrange(len(P)); t = rng.randrange(len(P)) + p = rng.choice([x for x in pool if dot(x, Q[s]) == 0] or pool); q = rng.choice([x for x in pool if dot(P[t], x) == 0] or pool) + else: + p = rng.choice(pool); q = rng.choice(pool) + if dot(p, q): + P.append(list(p)); Q.append(list(q)) + R, A, free = setup(P, Q) + if len(free) < 4 or len(free) > 40: + continue + B = tomat(rng.getrandbits(len(free)) | rng.getrandbits(len(free)), free, v) + cases.append(('R%d' % n_rand, B, R, A)); n_rand += 1 +agree = 0; tot = 0; stats = {}; skipped = 0 +for tag, B, R, A in cases: + br = brute_batch([B], R, A)[0] + if br is None: + skipped += 1; continue + fl = jsign_batch([B], R, A)[0] + tot += 1; agree += (br == fl) + key = pretty_flags(fl); stats[key] = stats.get(key, 0) + 1 +print("T93 Camion system (jsign.c) vs exhaustive signings x exhaustive minors (brutetu.c): %d instances, %d agree on (J,b0,b1,b2), %d skipped as out of range" % (tot, agree, skipped)) +print("T93 outcome classes seen: %s" % ", ".join("%s x%d" % (k, stats[k]) for k in sorted(stats))) +print("T93 Cech case (every block signable, no joint signing) confirmed by the exhaustive oracle: %s" % any( + brute_batch([B], R, A)[0] == (False, True, True, True) for tag, B, R, A in cases if tag == 'C8')) + +# ---------------------------------------------------------------- S1's F7* gadget (g1/PROOF.md section 1): a minimiser with a non-TU-signable block +Pg, Qg = load_cfg('gad.json'); vg = len(Pg); Rg, Ag, fg = setup(Pg, Qg) +gm = json.load(open(os.path.join(DATA, 'gad_nonTS_minimiser.json'))) +Bg = tomat(gm['g'], fg, vg) +print("GAD v=%d f=%d (cost 19 and 23552 minimisers are the recorded exhaustive 2^29 run); stored minimiser: %d off-diagonal ones, block ranks %s sum %d = 19: %s; block TU-signable flags %s; whole B TU-signable %s" % ( + vg, len(fg), bin(gm['g']).count('1'), blockranks(Bg, Rg, Ag), sum(blockranks(Bg, Rg, Ag)), sum(blockranks(Bg, Rg, Ag)) == 19, [tus(Bg, Rg[j], Ag[j]) for j in range(3)], tus(Bg, range(vg), range(vg)))) + +# ---------------------------------------------------------------- 14 instances of jclimb2 with no jointly signable minimiser +rows = [] +for i in range(1, 15): + Ik = analyse('nojoint_21_%d.json' % i, py_cross=False) + rows.append((Ik['v'], Ik['best'], len(Ik['ms']), sum(f[0][0] for f in Ik['fl']), Ik['best'] >= Ik['v'])) +print("NJ14 instances nojoint_21_1..14 (v 7-10): minimisers without a joint block-TU signing: %d of %d instances (joint signings in total %d); (A) cost >= v in %d; (v, cost): %s" % ( + sum(1 for r in rows if r[3] == 0), len(rows), sum(r[3] for r in rows), sum(1 for r in rows if r[4]), [(r[0], r[1]) for r in rows])) diff --git a/research/three-total-decoders/checks/hesse_below.py b/research/three-total-decoders/checks/hesse_below.py new file mode 100644 index 0000000000..d921d5fb7b --- /dev/null +++ b/research/three-total-decoders/checks/hesse_below.py @@ -0,0 +1,16 @@ +"""Group X2 hook: exact evaluation of every data/hesse_below_*.json (a list of configurations [P, Q] over Z[w], w^2+w+1=0, each coordinate a pair [a, b] = a + b w). +Present only if the Hesse experiment ends BELOW-v FOUND (README, Outcome X2). For each configuration: v, f, the exact minimum of cost over all 2^f admissible B, +and the F2 block ranks of one minimiser recomputed by elimination. Prints 'HB #: ... exact minimum cost c < v = v' only if c < v.""" +import sys, os, json, glob +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +import hesse as H, kit +n = 0; nbelow = 0 +for fn in sorted(glob.glob(os.path.join(kit.DATA, 'hesse_below_*.json'))): + for k, (P, Q) in enumerate(json.load(open(fn))): + P = [tuple(tuple(c) for c in p) for p in P]; Q = [tuple(tuple(c) for c in q) for q in Q] + assert all(H.nz(H.dot(P[t], Q[t])) for t in range(len(P))) + v, f, best = H.evaluate(P, Q, cap=30) + tag = '<' if best is not None and best < v else '>=' + n += 1; nbelow += (best is not None and best < v) + print("HB %s#%d: v = %d, f = %d, exact minimum cost %s %s v = %d" % (os.path.basename(fn), k, v, f, best, tag, v)) +if n and n == nbelow: print("HB all %d configurations have exact minimum cost below v" % n) diff --git a/research/three-total-decoders/checks/hesse_smoke.py b/research/three-total-decoders/checks/hesse_smoke.py new file mode 100644 index 0000000000..f43ef7aec3 --- /dev/null +++ b/research/three-total-decoders/checks/hesse_smoke.py @@ -0,0 +1,20 @@ +"""Group X2 (harness only): the Hesse configuration over Z[w], and an exhaustive-cost smoke run of the sampler of g1/hesse.py with fixed seeds. +This is NOT the experiment: it shows the harness is exact (every configuration is evaluated over all 2^f admissible B) and records what the +smoke sample gives. The running experiment's counts are in README 'Outcome X2'.""" +import sys, os, random, json, itertools +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +import hesse as H +pts, lines, xp = H.hesse() +ppl = sorted(sum(H.inc(p, l) for p in pts) for l in lines); lpp = sorted(sum(H.inc(p, l) for l in lines) for p in pts) +print("HS Hesse configuration over Z[w] (w^2+w+1=0): %d points, %d lines, points per line %s, lines per point %s; intersection points of the lines %d" % ( + len(pts), len(lines), sorted(set(ppl)), sorted(set(lpp)), len(xp))) +# the 9 points are the 9 flexes: any two lie on a common line with a third (Sylvester-Gallai fails: no ordinary line) +third = all(any(H.inc(a, l) and H.inc(b, l) for l in lines) for a, b in itertools.combinations(pts, 2)) +print("HS every pair of the 9 points lies on one of the 12 lines (no ordinary line): %s" % third) +rng = random.Random(2026); mins = []; done = 0; tight = 0 +while done < 16: + P, Q = H.random_config(rng, xp, pts, lines) + v, f, best = H.evaluate(P, Q, cap=20) + if best is None or f < 6: continue + done += 1; mins.append(best - v); tight += (best == v) +print("HS smoke sample: %d random configurations on the Hesse points/lines (v 6-12, 6 <= f <= 20), evaluated exhaustively over all B: smallest cost - v = %d, cost = v in %d, cost < v in %d" % (done, min(mins), tight, sum(1 for m in mins if m < 0))) diff --git a/research/three-total-decoders/checks/lifts.py b/research/three-total-decoders/checks/lifts.py new file mode 100644 index 0000000000..de3e876e10 --- /dev/null +++ b/research/three-total-decoders/checks/lifts.py @@ -0,0 +1,23 @@ +"""Group G2.nojoint-lifts: the explicit same-support rational lifts in data/lifts_nojoint.json (made by scripts/make_lifts.py, an exact gauge-fixed +minor search in the manner of card g1/exactlift.py). For each stored (configuration, minimiser g, rational matrix M): + g is a cost-minimiser (exhaustive minimum recomputed; for the gadget the recorded minimum 19 is used), supp M = supp B (ones of B, diagonal included), + the diagonal of M is nonzero, and the exact Fraction block ranks of M are <= the F2 block ranks of B (all Lemma B needs); equality is reported.""" +import sys, os, json +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * +L = json.load(open(os.path.join(DATA, 'lifts_nojoint.json'))) +cache = {}; ok_min = ok_supp = ok_diag = ok_le = ok_eq = 0; byc = {} +for e in L: + n = e['config'] + if n not in cache: + P, Q = load_cfg(n); R, A, free = setup(P, Q) + cache[n] = (P, Q, R, A, free, 19 if n == 'gad.json' else enum(P, Q)[0]) + P, Q, R, A, free, best = cache[n]; v = len(P) + B = tomat(e['g'], free, v); M = e['lift']; fr = blockranks(B, R, A); qr = block_q(M, R, A) + ok_min += (sum(fr) == best); ok_supp += all((M[t][s] != 0) == bool(B[t][s]) for t in range(v) for s in range(v)) + ok_diag += all(M[t][t] != 0 for t in range(v)); ok_le += all(a <= b for a, b in zip(qr, fr)); ok_eq += (qr == fr) + byc[n] = byc.get(n, 0) + 1 +n = len(L) +print("NL lifts: %d stored (%d configurations: cex_joint_v7 all 4 minimisers, nojoint_21_1..14 the first <= 12 minimisers by ones count, gad.json 8 sampled non-TS minimisers); minimiser %d, support equal %d, diagonal nonzero %d, exact Q block ranks <= F2 ranks %d (equal %d) of %d" % ( + n, len(byc), ok_min, ok_supp, ok_diag, ok_le, ok_eq, n)) +print("NL cex_joint_v7 minimisers lifted: %d of 4" % byc.get('cex_joint_v7.json', 0)) diff --git a/research/three-total-decoders/checks/mcc_cex.py b/research/three-total-decoders/checks/mcc_cex.py new file mode 100644 index 0000000000..f82188bf31 --- /dev/null +++ b/research/three-total-decoders/checks/mcc_cex.py @@ -0,0 +1,62 @@ +"""Group G3: cex_min_1 (19 lines in {-1,0,1}^3): Conjecture F is false for the one-copy certificate, and the multi-copy certificate (MCC, Lemma MC) +reaches 20 >= v. VERIFICATION of the stored certificate only (the CP-SAT solve is not repeated), plus the {-1,0,1} parity lemmas.""" +import sys, os, json, ast, random, itertools, collections +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * + +P, Q = load_cfg('cex_min_1.json'); v = len(P) +pi = [frozenset(k for k in range(3) if p[k]) for p in P]; sg = [frozenset(k for k in range(3) if q[k]) for q in Q] +Dt = [pi[t] & sg[t] for t in range(v)] +types = collections.Counter(tuple(sorted(d)) for d in Dt) +print("CX v=%d entries in {-1,0,1}: %s; |D(t)| odd for %d lines (set G), even (=2, tied) for %d" % ( + v, all(abs(x) <= 1 for l in P + Q for x in l), sum(1 for d in Dt if len(d) % 2), sum(1 for d in Dt if len(d) % 2 == 0))) +print("CX D-types %s" % dict(sorted(types.items()))) +inc = lambda t, s: t != s and dot(P[t], Q[s]) == 0 +print("CX Lemma 1.1: every incidence t->s has |pi(t) & sigma(s)| in {0,2}: %s (%d incidences)" % ( + all(len(pi[t] & sg[s]) in (0, 2) for t in range(v) for s in range(v) if inc(t, s)), sum(1 for t in range(v) for s in range(v) if inc(t, s)))) +# Lemma 1.2: tied lines with the same D and the same eps are never incident +eps = {} +for t in range(v): + if len(Dt[t]) == 2: + i, j = sorted(Dt[t]); eps[t] = (i, j, P[t][i] * P[t][j]) +print("CX Lemma 1.2: tied lines of the same (D, eps) are never incident: %s (%d classes)" % ( + all(not inc(t, s) for t in eps for s in eps if t != s and eps[t] == eps[s]), len(set(eps.values())))) + +# multi-copy certificate +raw = json.load(open(os.path.join(DATA, 'mcc_cex_min_1_solution.json'))) +sol = {ast.literal_eval(k): (set(a), set(b), pos) for k, (a, b, pos) in raw.items()} +def verify_mcc(sol): + for (t, c), (a, b, p) in sol.items(): + if not (a <= pi[t] and b <= sg[t] and len(a & b) % 2 == 1): return False + for (t, c), (a, _, p) in sol.items(): + for (s, d), (_, b, q) in sol.items(): + if (t, c) == (s, d): continue + if (t != s and inc(t, s)) or t == s: + if len(a & b) % 2 and not p < q: return False + return True +print("CX MCC: stored solution has %d copies on %d lines (up to %d per line); labels inside supports, odd diagonals, every odd entry on an incidence or same-line pair forward: %s" % ( + len(sol), len({t for t, _ in sol}), max(collections.Counter(t for t, _ in sol).values()), verify_mcc(sol))) +print("CX MCC: %d copies >= v = %d: %s" % (len(sol), v, len(sol) >= v)) +# the identity behind Lemma MC on random admissible B: N is unit upper triangular in the order, rank N = #copies <= sum_j r_j +rng = random.Random(5); R, A, free = setup(P, Q); order = sorted(sol, key=lambda k: sol[k][2]); ok = 0; mincost = 99; tri = 0 +for it in range(60): + g = rng.getrandbits(len(free)) & rng.getrandbits(len(free)) if it else 0 + B = tomat(g, free, v); br = blockranks(B, R, A) + N = [[(B[x[0]][y[0]] * (len(sol[x][0] & sol[y][1]) % 2)) % 2 for y in order] for x in order] + up = all(N[i][i] == 1 and all(N[i][j] == 0 for j in range(i)) for i in range(len(order))) + tri += up; ok += (sum(br) >= len(sol)); mincost = min(mincost, sum(br)) +print("CX Lemma MC on 60 admissible B (incl. B = I): N unit upper triangular for %d of 60; sum_j rank B_j >= %d for %d of 60 (smallest sum seen %d)" % (tri, len(sol), ok, mincost)) +# stored B of cost 22 (costsat2 at K = 22) +B22 = json.load(open(os.path.join(DATA, 'cex_min_1.json.B22.json'))) +adm = all(B22[t][t] == 1 and all(B22[t][s] == 0 or inc(t, s) for s in range(v) if s != t) for t in range(v)) +print("CX stored B of cost <= 22: admissible %s; block ranks %s sum %d; so 20 <= cost(cex_min_1) <= 22" % (adm, blockranks(B22, R, A), sum(blockranks(B22, R, A)))) + +# 121-line pool: Lemma 1.1 for all pairs +def prim(): + out = [] + for x in itertools.product((-1, 0, 1), repeat=3): + if any(x) and next(c for c in x if c) > 0: out.append(x) + return out +pr = prim(); pool = [(p, q) for p in pr for q in pr if dot(p, q)] +ok11 = all(len({k for k in range(3) if p[k]} & {k for k in range(3) if q2[k]}) % 2 == 0 for (p, q) in pool for (p2, q2) in pool if (p, q) != (p2, q2) and dot(p, q2) == 0) +print("CX pool: %d primitive pairs (p,q) in {-1,0,1}^3 with p.q != 0 (13 vectors up to sign); Lemma 1.1 on all incidences of the pool: %s" % (len(pool), ok11)) diff --git a/research/three-total-decoders/checks/nondeg.py b/research/three-total-decoders/checks/nondeg.py new file mode 100644 index 0000000000..78ef5d1b2a --- /dev/null +++ b/research/three-total-decoders/checks/nondeg.py @@ -0,0 +1,15 @@ +"""Group G6: S1's non-degenerate counterexample aff14 (fleet/S1.md addendum B): a K22-free admissible B on 14 distinct points and 14 distinct lines +that is NOT TU-signable, so 'non-degenerate admissible B is regular' (and hence 'L6 forces a Lemma W' signing') is false.""" +import sys, os, json, itertools +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * +P, Q, B = json.load(open(os.path.join(DATA, 'aff14.json'))); n = len(P) +adm = all(B[t][t] == 1 and dot(P[t], Q[t]) != 0 for t in range(n)) and all(dot(P[t], Q[s]) == 0 for t in range(n) for s in range(n) if t != s and B[t][s]) +def prop(a, b): return all(x == 0 for x in (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0])) +dp = not any(prop(P[i], P[j]) for i in range(n) for j in range(i)); dl = not any(prop(Q[i], Q[j]) for i in range(n) for j in range(i)) +k22 = any(B[t][s] and B[t][s2] and B[t2][s] and B[t2][s2] for t, t2 in itertools.combinations(range(n), 2) for s, s2 in itertools.combinations(range(n), 2) if len({t, t2, s, s2}) == 4) +R, A, free = setup(P, Q) +full = [j for j in range(3) if len(R[j]) == n and len(A[j]) == n] +print("NG aff14: n=%d admissible %s; points pairwise distinct %s; lines pairwise distinct %s; off-diagonal ones %d; K22 (L6 pattern, 4 distinct indices) present: %s" % ( + n, adm, dp, dl, sum(B[t][s] for t in range(n) for s in range(n) if t != s), k22)) +print("NG aff14: blocks R_j x A_j equal to the whole matrix for j in %s; block ranks %s; whole B TU-signable (Camion): %s" % (full, blockranks(B, R, A), tus(B, range(n), range(n)))) diff --git a/research/three-total-decoders/checks/thm.py b/research/three-total-decoders/checks/thm.py new file mode 100644 index 0000000000..0eb006b812 --- /dev/null +++ b/research/three-total-decoders/checks/thm.py @@ -0,0 +1,178 @@ +"""Group G4: spot checks of the partial theorems and the two reductions (fprime/PROOF.md sections 7, 2, 13). Exact arithmetic, fixed seeds. + M1: if every point has a zero coordinate, sum_j MAS(G[D_j]) >= sum_t c(t) >= v/2 (MAS = largest induced acyclic subgraph, exact subset DP in mas.c). + U: in the unit world (all nonzero entries odd) the explicit label/order scheme of Theorem U is a valid L8 certificate of size >= |G| + |I|/2 >= v/2. + SCC: every block is block upper triangular in a topological order of the strong components of H. + Peel: |pi(t)| = 1 or |sigma(t)| = 1 => cost(config) >= cost(config - t) + 1 (exact, exhaustive over all B). + Monotone: cost(S) <= cost(config) for every sub-configuration (exact).""" +import sys, os, json, random, itertools, subprocess +from math import comb +from fractions import Fraction as F +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * + +def outs(P, Q): + v = len(P); return [[s for s in range(v) if s != t and dot(P[t], Q[s]) == 0] for t in range(v)] +def mas(nodes, out): + if not nodes: return 0 + idx = {t: i for i, t in enumerate(nodes)} + o = [sum(1 << idx[s] for s in out[t] if s in idx) for t in nodes] + return int(subprocess.run([os.path.join(BIN, 'mas')], input="%d\n" % len(nodes) + "\n".join(map(str, o)), capture_output=True, text=True, check=True).stdout) +def Dj(P, Q, j): return [t for t in range(len(P)) if P[t][j] and Q[t][j]] + +# ---------------------------------------------------------------- Theorem M1 +rng = random.Random(11); vals = (1, -1, 2, -2, 3, 0) +pts = [x for x in itertools.product(vals, repeat=3) if any(x) and 0 in x]; lns = [x for x in itertools.product(vals, repeat=3) if any(x)] +viol = 0; worst = F(9); ndone = 0; tight = 0 +for it in range(80): + v = rng.randrange(6, 15); P = []; Q = [] + while len(P) < v: + if P and rng.random() < 0.85: + s = rng.randrange(len(P)); t = rng.randrange(len(P)) + p = rng.choice([x for x in pts if dot(x, Q[s]) == 0] or pts); q = rng.choice([x for x in lns if dot(P[t], x) == 0] or lns) + else: p = rng.choice(pts); q = rng.choice(lns) + if dot(p, q): P.append(list(p)); Q.append(list(q)) + o = outs(P, Q); ms = sum(mas(Dj(P, Q, j), o) for j in range(3)); lb = F(0) + for p, q in zip(P, Q): + a = sum(1 for x in p if x) - 1; b = sum(1 for x in q if x) - 1; d = sum(1 for k in range(3) if p[k] and q[k]) + lb += F(d, comb(a + b, a)) + ndone += 1; viol += (ms < lb) or (lb < F(v, 2)); worst = min(worst, F(ms, v)); tight += (ms == lb) +print("M1 %d random configurations with every point having a zero coordinate (v 6-14): violations of MAS-sum >= sum_t c(t) >= v/2: %d; smallest MAS-sum/v %.3f; equality MAS-sum = sum c(t) in %d" % (ndone, viol, float(worst), tight)) +# sharpness: private digon, p=(1,1,0) q=(1,0,1); p=(1,0,-1) q=(1,-1,0): MAS-sum 1 of v=2, and cost is 2 +Pd = [[1, 1, 0], [1, 0, -1]]; Qd = [[1, 0, 1], [1, -1, 0]] +best, ms_, Rd, Ad, fd = enum(Pd, Qd) +lbd = sum(F(sum(1 for k in range(3) if p[k] and q[k]), comb(sum(1 for x in p if x) - 1 + sum(1 for x in q if x) - 1, sum(1 for x in p if x) - 1)) for p, q in zip(Pd, Qd)) +print("M1 sharpness digon: v=2, sum_t c(t) = %s, MAS-sum %d, exact cost %d (so MAS-sum = v/2 is attained while cost = v)" % (lbd, sum(mas(Dj(Pd, Qd, j), outs(Pd, Qd)) for j in range(3)), best)) + +# ---------------------------------------------------------------- Theorem U +def supp(x): return sum(1 << k for k in range(3) if x[k] != 0) +par = lambda x: bin(x).count('1') & 1 +def u_scheme(P, Q, special): + v = len(P); c0, c1, c2 = [(special + r) % 3 for r in range(3)] + a = [supp(P[t]) for t in range(v)]; b = [supp(Q[t]) for t in range(v)] + G = []; cl = {} + for t in range(v): + Dd = a[t] & b[t] + if bin(Dd).count('1') % 2: G.append(t); continue + i, j = [k for k in range(3) if Dd >> k & 1] + al = F(P[t][i], P[t][j]); be = F(-Q[t][j], Q[t][i]); assert al != be + cl.setdefault((i, j), {True: [], False: []})[al < be].append((t, al, be)) + A1 = []; A2 = []; B1 = []; B2 = []; tiedtot = 0 + for (i, j), H in cl.items(): + tiedtot += len(H[True]) + len(H[False]) + h = max((True, False), key=lambda x: len(H[x])); L = H[h] + L = sorted(L, key=lambda z: -z[1]) if h else sorted(L, key=lambda z: z[2]); T = [z[0] for z in L]; s = {i, j} + if s == {c0, c2}: + for t in T: a[t] &= ~(1 << c0) + A2 += T + elif s == {c0, c1}: + for t in T: b[t] &= ~(1 << c0) + B1 += T + else: + for t in T: + if P[t][c0]: a[t] &= ~(1 << c2); A1.append(t) + else: b[t] &= ~(1 << c2); B2.append(t) + S = A1 + A2 + G + B1 + B2 + pos = {t: i for i, t in enumerate(S)} + for t in S: + assert a[t] & ~supp(P[t]) == 0 and b[t] & ~supp(Q[t]) == 0 and par(a[t] & b[t]) == 1 + for t in S: + for s in S: + if t != s and dot(P[t], Q[s]) == 0 and par(a[t] & b[s]): assert pos[t] < pos[s], 'conflict points backward' + return len(S), len(G), tiedtot +P, Q = load_cfg('cex_min_1.json') +r = [u_scheme(P, Q, sp) for sp in range(3)] +print("U cex_min_1: certificate sizes for the three special coordinates %s (|S|, |G|, #tied); best %d of v = 19; all valid (checked inside)" % (r, max(x[0] for x in r))) +def prim(): + return [x for x in itertools.product((-1, 0, 1), repeat=3) if any(x) and next(c for c in x if c) > 0] +pr = prim(); pool = [(p, q) for p in pr for q in pr if dot(p, q)] +rp = [u_scheme([l[0] for l in pool], [l[1] for l in pool], sp) for sp in range(3)] +print("U 121-line pool: sizes %s; best %d of v = 121" % ([x[0] for x in rp], max(x[0] for x in rp))) +rng = random.Random(7); worst = 9; n = 0 +for it in range(250): + v = rng.randrange(4, 30); Pu = []; Qu = [] + while len(Pu) < v: + p = [rng.choice((1, -1, 3, -3, 5, 0, 0)) for _ in range(3)]; q = [rng.choice((1, -1, 3, -3, 5, 0, 0)) for _ in range(3)] + if any(p) and any(q) and dot(p, q): Pu.append(p); Qu.append(q) + for _ in range(v): + t, s = rng.randrange(len(Pu)), rng.randrange(len(Pu)) + cand = [(p, Qu[rng.randrange(len(Qu))]) for p in itertools.product((1, -1, 3, 0), repeat=3) if any(p) and dot(p, Qu[s]) == 0] + cand = [(p, q) for p, q in cand if dot(p, q)] + if cand: p, q = rng.choice(cand); Pu.append(list(p)); Qu.append(list(q)) + best = max(u_scheme(Pu, Qu, sp)[0] for sp in range(3)); worst = min(worst, best / len(Pu)); n += 1 +print("U %d random unit-world configurations (4-60 lines, forced incidences): every scheme valid; smallest best-certificate/v = %.3f (>= 1/2: %s)" % (n, worst, worst >= 0.5)) + +# ---------------------------------------------------------------- Lemma SCC +def sccs(G): + idx = {}; low = {}; st = []; on = set(); out = []; c = [0] + sys.setrecursionlimit(10000) + def dfs(u): + idx[u] = low[u] = c[0]; c[0] += 1; st.append(u); on.add(u) + for w in G[u]: + if w not in idx: dfs(w); low[u] = min(low[u], low[w]) + elif w in on: low[u] = min(low[u], idx[w]) + if low[u] == idx[u]: + comp = [] + while True: + w = st.pop(); on.discard(w); comp.append(w) + if w == u: break + out.append(comp) + for u in G: + if u not in idx: dfs(u) + return out[::-1] +def scc_check(P, Q): + v = len(P) + G = {t: [s for s in range(v) if s != t and dot(P[t], Q[s]) == 0 and any(P[t][k] and Q[s][k] for k in range(3))] for t in range(v)} + C = sccs(G); comp = {t: i for i, cc in enumerate(C) for t in cc} + for j in range(3): + for t in range(v): + if not P[t][j]: continue + for s in range(v): + if Q[s][j] and (t == s or dot(P[t], Q[s]) == 0): + if comp[t] > comp[s]: return None + return sorted(len(c) for c in C) +rng = random.Random(1); vl = (-2, -1, 0, 1, 2); pool5 = [x for x in itertools.product(vl, repeat=3) if any(x)]; okc = 0; multi = 0 +for it in range(300): + v = rng.randrange(4, 16); Ps = []; Qs = [] + while len(Ps) < v: + p = rng.choice(pool5); q = rng.choice(pool5) + if dot(p, q): Ps.append(list(p)); Qs.append(list(q)) + r = scc_check(Ps, Qs); okc += r is not None; multi += (r is not None and len(r) > 1) +print("SCC block upper-triangularity in topological order of the strong components of H: %d of 300 random configurations (%d of them with more than one component)" % (okc, multi)) +Pt, Qt = load_cfg('tied_min.json') +print("SCC component sizes: tied_min %s, cex_min_1 %s" % (scc_check(Pt, Qt), scc_check(P, Q))) + +# ---------------------------------------------------------------- Lemma Peel and monotonicity (exact, exhaustive over all B) +def cost_of(P, Q): + return enum(P, Q)[0] +rng = random.Random(4); vl = (-2, -1, 0, 1, 2); pool5 = [x for x in itertools.product(vl, repeat=3) if any(x)] +unit_p = [x for x in pool5 if sum(1 for c in x if c) == 1]; unit_q = unit_p +npeel = 0; viol = 0; nmono = 0; viol2 = 0; tried = 0 +while npeel < 36 and tried < 3000: + tried += 1; v = rng.randrange(4, 8); Ps = []; Qs = [] + while len(Ps) < v: + if rng.random() < 0.9 and Ps: + s = rng.randrange(len(Ps)); t = rng.randrange(len(Ps)) + p = rng.choice([x for x in pool5 if dot(x, Qs[s]) == 0] or pool5); q = rng.choice([x for x in pool5 if dot(Ps[t], x) == 0] or pool5) + else: p = rng.choice(pool5); q = rng.choice(pool5) + if dot(p, q): Ps.append(list(p)); Qs.append(list(q)) + # make line 0 a unit-support point (case |pi|=1) or unit-support line (|sigma|=1), keeping p.q != 0 + if npeel % 2 == 0: + p = rng.choice(unit_p); q = rng.choice([x for x in pool5 if dot(p, x)]) + else: + q = rng.choice(unit_q); p = rng.choice([x for x in pool5 if dot(x, q)]) + Ps[0] = list(p); Qs[0] = list(q) + R, A, free = setup(Ps, Qs) + if len(free) > 18: continue + full = enum(Ps, Qs)[0]; rest = enum(Ps[1:], Qs[1:])[0] + npeel += 1; viol += (full < rest + 1) + nmono += 1; viol2 += (rest > full) +print("PEEL %d configurations with a unit-support point or line: exact cost(config) >= cost(config - t) + 1 violated in %d" % (npeel, viol)) +print("MONO exact cost(sub-configuration) <= cost(config) violated in %d of %d" % (viol2, nmono)) + +# ---------------------------------------------------------------- Conjecture PP is false (S2): a lone line costs |D(t)|, so cost(S) >= cost(S-X) + |X| fails already at v = 2 +Pt, Qt = load_cfg('tied_min.json') +single = [enum([Pt[t]], [Qt[t]])[0] for t in range(12)] +pair = enum([Pt[0], Pt[3]], [Qt[0], Qt[3]])[0] +def prop(a, b): return all(x == 0 for x in (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0])) +dist = (not prop(Pt[0], Pt[3])) and (not prop(Qt[0], Qt[3])) +print("PP lone tied lines of tied_min cost %s; lines 0 and 3 (different point, different line: %s) together cost %d, so no group X of S = {0,3} satisfies cost(S) >= cost(S - X) + |X| (X = a single line: %d >= %d + 1 is false)" % (sorted(set(single)), dist, pair, pair, single[0])) diff --git a/research/three-total-decoders/checks/tied_min.py b/research/three-total-decoders/checks/tied_min.py new file mode 100644 index 0000000000..7b332163a8 --- /dev/null +++ b/research/three-total-decoders/checks/tied_min.py @@ -0,0 +1,162 @@ +"""Group G1: the sharp example tied_min (12 lines, cost = v = 12), fprime/PROOF.md sections 11.5, 12.1-12.3, 12.7, 13.3, 14. +Re-checks: the structure; step (a) and (b) of the exchange proof (the computational steps); the projection fact used in (c); +an independent CNF for 'cost <= 11' (UNSAT) and 'cost <= 12' (SAT); all 217 optima (enumeration to exhaustion), their structure, +their rowspace data, their exact Q-lifts; and 'every one-line deletion costs 12'.""" +import sys, os, itertools, subprocess, collections +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * +from satlib import enumerate_B, cost_leq +from pysat.solvers import Cadical153 +from pysat.formula import IDPool + +P, Q = load_cfg('tied_min.json'); v = len(P) +miss = lambda q: [k for k in range(3) if q[k] == 0][0] +cls = {k: [s for s in range(v) if miss(Q[s]) == k] for k in range(3)} +inc = lambda t, s: t != s and dot(P[t], Q[s]) == 0 +R, A, free = setup(P, Q) +D = [[t for t in range(v) if P[t][j] and Q[t][j]] for j in range(3)] +nin = sum(1 for t in range(v) for s in range(v) if inc(t, s)) +print("TM structure: v=%d points all full support with entries +-1: %s; q two-support: %s; |D(t)|=2 for every line (tied): %s; incidences %d; block row sets all %d rows: %s" % ( + v, all(all(abs(x) == 1 for x in p) for p in P), all(sum(1 for x in q if x) == 2 for q in Q), + all(sum(1 for k in range(3) if P[t][k] and Q[t][k]) == 2 for t in range(v)), nin, v, all(len(R[j]) == v for j in range(3)))) +print("TM classes (missing coordinate of q): sizes %s; distinct points %d, distinct q-lines %d" % ( + [len(cls[k]) for k in range(3)], len(set(map(tuple, P))), len(set(map(tuple, Q))))) + +# SCC (Lemma SCC): H is strongly connected on tied_min +H = {t: [s for s in range(v) if inc(t, s) and any(P[t][k] and Q[s][k] for k in range(3))] for t in range(v)} +def reach(src, G): + seen = {src}; st = [src] + while st: + u = st.pop() + for w in G[u]: + if w not in seen: seen.add(w); st.append(w) + return seen +Hr = {t: [s for s in range(v) if t in H[s]] for t in range(v)} +print("TM H strongly connected (Lemma SCC): %s" % (len(reach(0, H)) == v and len(reach(0, Hr)) == v)) + +# (a) MAS(G[D_j]) = 3 +def mas(nodes): + idx = {t: i for i, t in enumerate(nodes)} + o = [sum(1 << idx[s] for s in range(v) if s in idx and inc(t, s)) for t in nodes] + return int(subprocess.run([os.path.join(BIN, 'mas')], input="%d\n" % len(nodes) + "\n".join(map(str, o)), capture_output=True, text=True, check=True).stdout) +print("TM step (a): MAS(G[D_j]) for j=0,1,2: %s" % [mas(D[j]) for j in range(3)]) + +# (b) block of rank <= 3: unique filling of its 8 columns (exhaustive SAT enumeration), then dims +def rank3_fillings(j): + cols = A[j]; r = 3; pool = IDPool(); cl = [] + for t in range(v): + for s in cols: + target = True if t == s else (pool.id(('B', t, s)) if inc(t, s) else False); ands = [] + for k in range(r): + x = pool.id(('X', t, k)); y = pool.id(('Y', k, s)); z = pool.id(('Z', t, s, k)); cl += [[-z, x], [-z, y], [z, -x, -y]]; ands.append(z) + acc = ands[0] + for z in ands[1:]: + n = pool.id(('C', t, s, z)); cl += [[-n, acc, z], [-n, -acc, -z], [n, -acc, z], [n, acc, -z]]; acc = n + if target is True: cl.append([acc]) + elif target is False: cl.append([-acc]) + else: cl += [[-acc, target], [acc, -target]] + bv = {(t, s): pool.id(('B', t, s)) for t in range(v) for s in cols if inc(t, s)} + S = Cadical153(bootstrap_with=cl); sols = [] + while S.solve(): + m = set(l for l in S.get_model() if l > 0) + sols.append({k for k, x in bv.items() if x in m}) + S.add_clause([-x if x in m else x for x in bv.values()]) + return sols, cols +def colvec(ent, s): + return sum((1 if (t == s or (t, s) in ent) else 0) << t for t in range(v)) +for j in range(3): + sols, cols = rank3_fillings(j) + ks = [k for k in range(3) if k != j] + out = [] + for ent in sols: + d = [rank2([colvec(ent, s) for s in cls[ks[0]]]), rank2([colvec(ent, s) for s in cls[ks[1]]]), rank2([colvec(ent, s) for s in cls[ks[0]] + cls[ks[1]]])] + zr = all(((t == s) or ((t, s) in ent)) is False for s in cols for t in cls[j]) + out.append((tuple(d), zr)) + print("TM step (b) j=%d: block rank <= 3 fillings of its %d columns: %d; (dim S_k, dim S_l, dim(S_k+S_l), class-%d rows vanish) = %s" % (j, len(cols), len(sols), j, out)) + +# (c) the projection onto the class-j rows: B[T_j, C_j] has rank >= 2 for every filling +okc = [] +for j in range(3): + T = cls[j]; C = cls[j] + fr = [(t, s) for t in T for s in C if inc(t, s)] + mn = 9 + for g in range(1 << len(fr)): + rows = [sum((1 if (t == s or ((t, s) in fr and g >> fr.index((t, s)) & 1)) else 0) << i for i, s in enumerate(C)) for t in T] + mn = min(mn, rank2(rows)) + okc.append((len(fr), mn)) +print("TM step (c): B[T_j,C_j] is 4x4 with (free entries, minimum F2 rank over all fillings) = %s" % okc) + +# independent CNF: cost <= 11 UNSAT, cost <= 12 SAT with ranks (4,4,4) +print("TM CNF cost<=11: %s" % ("UNSAT" if cost_leq(P, Q, 11) is None else "SAT")) +B12 = cost_leq(P, Q, 12) +print("TM CNF cost<=12: %s, block ranks recomputed by elimination %s" % ("SAT" if B12 else "UNSAT", blockranks(B12, R, A) if B12 else None)) + +# all 217 optima +opt = enumerate_B(P, Q, (4, 4, 4)) +print("TM optima: B with block ranks <= (4,4,4) enumerated to exhaustion: %d" % len(opt)) +cl_of = [miss(Q[t]) for t in range(v)] +kinds = collections.Counter(); sumcost = set(); blkr = set(); lift_ok = 0; wholeTU = 0; rhow = collections.Counter(); costid = 0 +Bs = [] +for ent in opt: + B = [[1 if t == s else 0 for s in range(v)] for t in range(v)] + for (t, s) in ent: B[t][s] = 1 + Bs.append(B) + cross = sum(1 for (t, s) in ent if cl_of[t] != cl_of[s]) + br = tuple(blockranks(B, R, A)); blkr.add(br); sumcost.add(sum(br)) + rho = rank2([sum(B[t][s] << s for s in range(v)) for t in range(v)]) + # rowspace W by enumeration of all 2^rho elements; w_j = dim(W cap F2^{C_j}) from the count of elements supported on C_j + rows = [sum(B[t][s] << s for s in range(v)) for t in range(v)] + basis = [] + for x in rows: + for b in basis: x = min(x, x ^ b) + if x: basis.append(x) + Wset = {0} + for b in basis: Wset |= {w ^ b for w in Wset} + assert len(Wset) == 1 << rho + w = [] + for j in range(3): + mask = sum(1 << s for s in cls[j]); cnt = sum(1 for x in Wset if x & ~mask == 0); w.append(cnt.bit_length() - 1) + costid += (3 * rho - sum(w) == sum(br)) + Sdim = [rank2([colvec(set(ent), s) for s in cls[k]]) for k in range(3)] + if cross == 0: + kinds[('class-diagonal', tuple(Sdim), rho, tuple(w), tuple(rank2([sum(B[t][s] << i for i, s in enumerate(cls[k])) for t in cls[k]]) for k in range(3)))] += 1 + else: + kinds[('cross-class entries %d' % cross, tuple(Sdim), rho, tuple(w), None)] += 1 +print("TM optima: block-rank triples %s, costs %s" % (sorted(blkr), sorted(sumcost))) +for k, c in sorted(kinds.items(), key=lambda kv: -kv[1]): + print("TM optimum kind: %s: dim S_k %s, rank B %d, w %s, class-block ranks %s -> %d matrices" % (k[0], k[1], k[2], k[3], k[4], c)) +print("TM F2S identity cost = 3*rho - sum_j w_j (w_j by counting the elements of the row space on C_j) holds for %d of %d optima" % (costid, len(opt))) +# the special optimum: S_0 = S_1 = S_2 = W as column spaces +spec = [B for B, ent in zip(Bs, opt) if sum(1 for (t, s) in ent if cl_of[t] != cl_of[s]) > 0] +def colspace(B, S): + basis = [] + for s in S: + x = sum(B[t][s] << t for t in range(v)) + for b in basis: x = min(x, x ^ b) + if x: basis.append(x) + el = {0} + for b in basis: el |= {w ^ b for w in el} + return frozenset(el) +print("TM special optimum B0: S_0 = S_1 = S_2 = W (column spaces equal, dim 4): %s" % ( + all(len({colspace(B, cls[0]), colspace(B, cls[1]), colspace(B, cls[2]), colspace(B, range(v))}) == 1 for B in spec) and len(spec) == 1)) + +# lifts: joint block-TU signing, whole-matrix TU signability, exact Q block ranks +fl = jsign_batch(Bs, R, A, True) +for B, (f, sgn) in zip(Bs, fl): + if f[0] and block_q(signed_matrix(B, sgn), R, A) == blockranks(B, R, A): lift_ok += 1 + wholeTU += tus(B, range(v), range(v)) +print("TM lifts: joint block-TU signing from the Camion system with exact Q block ranks equal to the F2 ranks (4,4,4): %d of %d; whole 12x12 B TU-signable: %d of %d" % (lift_ok, len(Bs), wholeTU, len(Bs))) + +# one-line deletions and the exact cost of lone lines +dels = [] +for t in range(v): + keep = [u for u in range(v) if u != t] + dels.append((cost_leq([P[u] for u in keep], [Q[u] for u in keep], 11) is None)) +print("TM every one-line deletion has cost >= 12 (cost <= 11 UNSAT): %d of %d" % (sum(dels), v)) +# a tight subconfiguration of size 10 (cost = v) +found = None +for S in itertools.combinations(range(v), 10): + Ps = [P[u] for u in S]; Qs = [Q[u] for u in S] + if cost_leq(Ps, Qs, 9) is None and cost_leq(Ps, Qs, 10) is not None: + found = S; break +print("TM first tight 10-line subconfiguration (cost <= 9 UNSAT, cost <= 10 SAT): %s" % (found,)) diff --git a/research/three-total-decoders/data/aff14.json b/research/three-total-decoders/data/aff14.json new file mode 100644 index 0000000000..5e44c9fe09 --- /dev/null +++ b/research/three-total-decoders/data/aff14.json @@ -0,0 +1 @@ +[[[0, 3, 2], [3, 0, -1], [1, -3, -3], [1, 3, 1], [3, 1, 3], [1, -3, 3], [2, -3, -2], [2, 3, 3], [1, -2, -2], [2, 1, -1], [2, -1, -1], [1, -1, 2], [3, -3, -1], [0, 1, 2]], [[2, -3, 4], [0, 1, -1], [0, 1, -3], [6, 4, -1], [2, 2, -1], [1, 0, 3], [3, -4, 2], [3, -4, 9], [3, -2, 3], [1, -12, 3], [0, 2, -3], [15, 2, -3], [0, 0, 1], [6, -3, -5]], [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/cech_v8.json b/research/three-total-decoders/data/cech_v8.json new file mode 100644 index 0000000000..731b545d93 --- /dev/null +++ b/research/three-total-decoders/data/cech_v8.json @@ -0,0 +1 @@ +[[[-1, 2, 1], [-1, 2, -1], [-2, -2, -1], [-2, 2, 0], [2, -1, -2], [1, -3, 4], [0, -2, 2], [0, -4, 2]], [[1, -1, -1], [2, 0, 0], [-2, 2, 2], [4, 2, 0], [-4, 1, 6], [4, 0, -8], [-4, 1, 6], [0, 2, -2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/cex_joint_v7.json b/research/three-total-decoders/data/cex_joint_v7.json new file mode 100644 index 0000000000..cf7a3db872 --- /dev/null +++ b/research/three-total-decoders/data/cex_joint_v7.json @@ -0,0 +1 @@ +[[[2, 0, -2], [-32, -32, -48], [-4, -4, -4], [0, 1, 1], [-2, 0, -1], [0, -1, 1], [-2, -2, 0]], [[2, -12, -4], [1, -2, 0], [-2, 2, -1], [-1, 2, -1], [-2, 0, 2], [-4, 4, 0], [32, 64, -64]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/cex_min_1.json b/research/three-total-decoders/data/cex_min_1.json new file mode 100644 index 0000000000..4629aa02b1 --- /dev/null +++ b/research/three-total-decoders/data/cex_min_1.json @@ -0,0 +1 @@ +[[[1, -1, 0], [1, 0, -1]], [[1, -1, 1], [0, 1, -1]], [[1, -1, 1], [1, -1, 0]], [[1, -1, 1], [1, 0, 1]], [[1, 0, -1], [0, 1, -1]], [[1, 0, -1], [0, 1, 1]], [[1, 0, -1], [1, -1, 0]], [[1, 0, -1], [1, 1, -1]], [[1, 0, 1], [1, 1, 0]], [[1, 0, 1], [1, 1, 1]], [[1, 1, -1], [0, 1, -1]], [[1, 1, -1], [1, -1, 1]], [[1, 1, -1], [1, 0, -1]], [[1, 1, -1], [1, 1, 0]], [[1, 1, 0], [0, 1, 1]], [[1, 1, 0], [1, 0, 1]], [[1, 1, 1], [0, 1, 1]], [[1, 1, 1], [1, 0, 1]], [[1, 1, 1], [1, 1, 0]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/cex_min_1.json.B22.json b/research/three-total-decoders/data/cex_min_1.json.B22.json new file mode 100644 index 0000000000..0161536922 --- /dev/null +++ b/research/three-total-decoders/data/cex_min_1.json.B22.json @@ -0,0 +1 @@ +[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]] \ No newline at end of file diff --git a/research/three-total-decoders/data/cex_wholeTS_v9.json b/research/three-total-decoders/data/cex_wholeTS_v9.json new file mode 100644 index 0000000000..a843cce049 --- /dev/null +++ b/research/three-total-decoders/data/cex_wholeTS_v9.json @@ -0,0 +1 @@ +[[[2, -1, -2], [1, 0, -1], [2, 2, -1], [0, -6, 3], [-3, -2, 1], [3, 2, -1], [-2, 0, -2], [1, 3, 1], [-2, 2, 0]], [[-2, 2, 2], [1, 1, 2], [1, 1, 2], [0, 6, -3], [4, 0, 8], [3, -1, -3], [4, 0, 8], [1, 0, 1], [-1, 0, -1]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/gad.json b/research/three-total-decoders/data/gad.json new file mode 100644 index 0000000000..9cd95fad4d --- /dev/null +++ b/research/three-total-decoders/data/gad.json @@ -0,0 +1 @@ +[[[1, 0, 1], [0, 2, 1], [3, 3, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]], [[0, 4, -4], [-4, 0, 4], [-1, -4, 5], [1, 0, 1], [0, 1, 1], [1, 1, 3], [-2, -1, 2], [-3, 2, 3], [-1, 3, -6], [6, 4, -30]], [[1, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, 0, 0, 1]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/gad_nonTS_minimiser.json b/research/three-total-decoders/data/gad_nonTS_minimiser.json new file mode 100644 index 0000000000..72a949a117 --- /dev/null +++ b/research/three-total-decoders/data/gad_nonTS_minimiser.json @@ -0,0 +1 @@ +{"g": 102056172, "free_count": 29, "offdiag_ones": 11} \ No newline at end of file diff --git a/research/three-total-decoders/data/lifts_nojoint.json b/research/three-total-decoders/data/lifts_nojoint.json new file mode 100644 index 0000000000..cf296cbe21 --- /dev/null +++ b/research/three-total-decoders/data/lifts_nojoint.json @@ -0,0 +1 @@ +[{"config": "cex_joint_v7.json", "g": 985, "lift": [[1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, -1, 0, -1], [0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "cex_joint_v7.json", "g": 987, "lift": [[1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, -1, 0, -1], [0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "cex_joint_v7.json", "g": 2041, "lift": [[1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0], [0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, -1, 0, -1], [0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 1, -1]]}, {"config": "cex_joint_v7.json", "g": 2043, "lift": [[1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 1, 1, 1, 0], [0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, -1, 0, -1], [0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 1, -1]]}, {"config": "nojoint_21_1.json", "g": 493213, "lift": [[1, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, -1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, -1, 0, 0, 0, -1]]}, {"config": "nojoint_21_1.json", "g": 495261, "lift": [[1, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, -1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, -1, 0, 0, 0, -1]]}, {"config": "nojoint_21_2.json", "g": 65218, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 195778, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, -1, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65219, "lift": [[1, 0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65222, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65226, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65234, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65250, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 65474, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 130754, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 1, 0, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 195779, "lift": [[1, 0, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, -1, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 195782, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, -1, 0, 0, 1]]}, {"config": "nojoint_21_2.json", "g": 195786, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, -1, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, -1, 0, 0, 1]]}, {"config": "nojoint_21_3.json", "g": 515804, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 515805, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 515806, "lift": [[1, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 515836, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 516060, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0, 0], [1, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 515807, "lift": [[1, 0, 1, 0, 0, 0, 0, 1], [0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_3.json", "g": 516092, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [1, 1, 1, 1, 0, 0, 0, 0], [1, 0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 0, -1, 0, -1, 0], [0, 1, 0, 0, 0, -1, 0, -1]]}, {"config": "nojoint_21_4.json", "g": 2011, "lift": [[1, 0, 0, 1, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0], [1, 0, 1, 0, -1, 0, 0], [1, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "nojoint_21_4.json", "g": 1983, "lift": [[1, 0, 0, 1, 0, 0, 1], [0, 1, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 0], [1, 0, 1, 0, 1, 0, 0], [1, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "nojoint_21_4.json", "g": 2015, "lift": [[1, 0, 0, 1, 0, 0, 1], [0, 1, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0], [1, 0, 1, 0, -1, 0, 0], [1, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "nojoint_21_4.json", "g": 2043, "lift": [[1, 0, 0, 1, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 1, 0], [0, 1, 0, 1, 1, 0, 0], [1, 0, 1, 0, -1, 0, 0], [1, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, -1]]}, {"config": "nojoint_21_5.json", "g": 202038, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 202102, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 202166, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 210230, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [1, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 218422, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 1, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 234806, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 202230, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 202551, "lift": [[1, 0, 1, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, -1, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 210294, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [1, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 210358, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [1, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 218486, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 1, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_5.json", "g": 218550, "lift": [[1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, -1], [0, 0, 1, 0, 0, 0, 0, 1, 0], [1, 0, -1, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_6.json", "g": 159462, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 0, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_6.json", "g": 159726, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1], [0, 0, 1, 0, 0, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 0, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_6.json", "g": 196326, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 1, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 1], [0, 0, 1, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_6.json", "g": 225014, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 1, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 0, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 0], [1, 0, -1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_6.json", "g": 259830, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 1, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, -1, -1, 0, 0], [0, 0, 1, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 1], [1, 0, -1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_6.json", "g": 196590, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1], [0, 0, 1, 0, 0, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 1, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 1], [0, 0, 1, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_6.json", "g": 225278, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1], [0, 0, 1, 0, 1, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, -1, -1, 0, 0], [1, 0, 0, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 0], [1, 0, -1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_6.json", "g": 260094, "lift": [[1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1], [0, 0, 1, 0, 1, 0, 0, 1], [1, 1, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, -1, -1, 0, 0], [0, 0, 1, 0, 0, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1, 1], [1, 0, -1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_7.json", "g": 57085, "lift": [[1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 57087, "lift": [[1, 1, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 57341, "lift": [[1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 65277, "lift": [[1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 57343, "lift": [[1, 1, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 65279, "lift": [[1, 1, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 65533, "lift": [[1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_7.json", "g": 65535, "lift": [[1, 1, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 1], [1, 0, -1, 0, 0, 0, 0, -1], [1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 0, -1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, -1, 0, 1]]}, {"config": "nojoint_21_8.json", "g": 56831, "lift": [[1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 1, 1, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, 0, 1, -1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, -1, -1, 0, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0, -1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_8.json", "g": 318975, "lift": [[1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 1, 1, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, 0, 1, -1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, -1, -1, 0, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0, -1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1]]}, {"config": "nojoint_21_9.json", "g": 61215, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 61247, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 61279, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 65311, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 61311, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 65343, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 65375, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_9.json", "g": 65407, "lift": [[1, 1, 0, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, -1, 0], [1, 1, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_10.json", "g": 12215, "lift": [[1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 1, -1, 0, 0, 0], [1, 0, 0, 0, 1, 0, -1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0, 1]]}, {"config": "nojoint_21_10.json", "g": 14263, "lift": [[1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 1, -1, 0, 0, 0], [1, 0, 0, 0, 0, 1, -1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0, 1]]}, {"config": "nojoint_21_10.json", "g": 12279, "lift": [[1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 1, -1, 0, 0, 0], [1, 0, 0, 0, 1, 0, -1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0, 1]]}, {"config": "nojoint_21_10.json", "g": 14327, "lift": [[1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 1, -1, 0, 0, 0], [1, 0, 0, 0, 0, 1, -1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 257015, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 0, 1, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 257023, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 1, 1, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 258039, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 0, 1, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 261103, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 1, 0, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, -1, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 261111, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 0, 1, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 524135, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 0, 0, 1], [0, 1, -1, 0, 0, 0, 0, 0], [1, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 1, 1]]}, {"config": "nojoint_21_11.json", "g": 258047, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 1, 1, 1], [0, 1, -1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 0, 1]]}, {"config": "nojoint_21_11.json", "g": 524159, "lift": [[1, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 1, 1, 1], [0, 1, -1, 0, 0, 0, 0, 0], [1, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, -1, 0, 0, 1, 1], [0, 0, 1, -1, 0, 0, 1, 1]]}, {"config": "nojoint_21_12.json", "g": 3442, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3443, "lift": [[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3446, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3450, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3954, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3447, "lift": [[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3454, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0], [1, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3958, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3962, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 7666, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 1, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3963, "lift": [[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0], [1, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_12.json", "g": 3966, "lift": [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0], [1, 0, 1, 1, 1, 0, 0, 0], [0, 1, 0, -1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, -1]]}, {"config": "nojoint_21_13.json", "g": 65527, "lift": [[1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 0, 0, 0, 1], [1, 0, -1, 0, 1, 0, 0], [1, 0, 0, 1, 0, 1, 0], [0, 1, 0, 0, 1, -1, 0], [0, 0, 1, 1, -1, 1, 0], [0, 0, 0, 1, 0, 0, -1]]}, {"config": "nojoint_21_14.json", "g": 462, "lift": [[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "nojoint_21_14.json", "g": 478, "lift": [[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "gad.json", "g": 102056172, "lift": [[1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "gad.json", "g": 155418866, "lift": [[1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "gad.json", "g": 278216940, "lift": [[1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "gad.json", "g": 287539442, "lift": [[1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, -1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "gad.json", "g": 295829663, "lift": [[1, 1, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [1, -1, 0, 0, 0, 0, 0, 0, -1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "gad.json", "g": 43352175, "lift": [[1, 1, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, -1, 0, 0, 0, 0, 0, -1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]}, {"config": "gad.json", "g": 89735350, "lift": [[1, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, -1, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, -1]]}, {"config": "gad.json", "g": 102056684, "lift": [[1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, -1]]}] \ No newline at end of file diff --git a/research/three-total-decoders/data/mcc_cex_min_1_solution.json b/research/three-total-decoders/data/mcc_cex_min_1_solution.json new file mode 100644 index 0000000000..044dee192f --- /dev/null +++ b/research/three-total-decoders/data/mcc_cex_min_1_solution.json @@ -0,0 +1 @@ +{"(0, 0)": [[0, 1], [0, 2], 8], "(1, 0)": [[2], [1, 2], 2], "(3, 0)": [[0, 1, 2], [0], 7], "(3, 1)": [[0, 1], [0, 2], 2], "(4, 0)": [[0, 2], [1, 2], 4], "(5, 0)": [[0, 2], [1, 2], 3], "(6, 0)": [[0, 2], [0, 1], 6], "(7, 0)": [[2], [2], 1], "(8, 0)": [[0], [0, 1], 0], "(9, 0)": [[0], [0, 1], 7], "(10, 0)": [[1], [1, 2], 2], "(11, 0)": [[0, 1, 2], [0, 1, 2], 2], "(13, 0)": [[1, 2], [0, 1], 1], "(14, 0)": [[0, 1], [1, 2], 3], "(15, 0)": [[0, 1], [0], 7], "(16, 0)": [[0, 1, 2], [1], 8], "(17, 0)": [[0, 1, 2], [2], 7], "(17, 1)": [[0], [0, 2], 2], "(18, 0)": [[0, 1, 2], [0], 9], "(18, 1)": [[1], [0, 1], 1]} \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_1.json b/research/three-total-decoders/data/nojoint_21_1.json new file mode 100644 index 0000000000..154d2ffb50 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_1.json @@ -0,0 +1 @@ +[[[-2, 1, -2], [-96, 0, 0], [-4, 0, 4], [2, 0, 1], [192, -192, 384], [-2, -1, -2], [16, -16, 32], [-10, -2, -2], [0, -8, 0], [2, 2, -2]], [[-1, 0, -1], [4, 4, 0], [0, -8, 8], [-2, 2, -2], [-4, 0, 4], [-2, 6, 4], [0, -12, 0], [16, 0, -8], [0, -192, -96], [0, -2, 1]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_10.json b/research/three-total-decoders/data/nojoint_21_10.json new file mode 100644 index 0000000000..be9e238216 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_10.json @@ -0,0 +1 @@ +[[[1, 1, 0], [-1, -1, -1], [12, -44, 14], [-2, -2, -1], [-12, 12, -14], [11, -1, -6], [-2, 1, 0], [-1, -1, -2], [2, 2, 2]], [[1, 2, -6], [-6, 2, 8], [-2, 2, 2], [-14, 0, 12], [-2, -4, -3], [-1, -2, 6], [-48, -16, 64], [2, -1, -2], [1, 1, 0]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_11.json b/research/three-total-decoders/data/nojoint_21_11.json new file mode 100644 index 0000000000..e684f066b3 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_11.json @@ -0,0 +1 @@ +[[[0, 2, -2], [2, 2, 2], [18, 6, -24], [6, 8, 5], [0, -1, -1], [4, 2, -3], [-6, -2, -2], [-66, -42, 18]], [[-6, 2, 4], [-60, 180, 0], [48, -132, -132], [-1, 2, 1], [-3, 1, 2], [6, -2, -4], [30, -42, 12], [0, 2, -2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_12.json b/research/three-total-decoders/data/nojoint_21_12.json new file mode 100644 index 0000000000..4a5df3368c --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_12.json @@ -0,0 +1 @@ +[[[-1, -2, -2], [-2, 0, -1], [-2, 2, 1], [-6, 5, -2], [0, -1, -2], [2, -2, 0], [-6, 0, 0], [0, 36, -36]], [[-108, -72, -72], [-1, -2, -2], [0, -216, -216], [3, 5, -4], [3, 6, -6], [-18, -36, -36], [-2, -3, 4], [0, -12, 6]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_13.json b/research/three-total-decoders/data/nojoint_21_13.json new file mode 100644 index 0000000000..7d152dd0e2 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_13.json @@ -0,0 +1 @@ +[[[1, -2, 2], [12, -4, -20], [-60, 36, 132], [40, -52, -144], [-2, 1, 2], [-3, 3, 3], [2, -3, -4]], [[4, -8, 4], [-6, -6, -3], [2, 1, 1], [1, 2, -1], [-12, -9, -3], [-40, -208, 64], [48, 44, 20]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_14.json b/research/three-total-decoders/data/nojoint_21_14.json new file mode 100644 index 0000000000..c8a6e78ee3 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_14.json @@ -0,0 +1 @@ +[[[0, -12, -12], [1, 1, -2], [-1, 1, -2], [0, 0, 1], [18, 0, 0], [-12, -4, -12], [4, 8, -2], [1, 0, 2]], [[8, -12, -4], [-2, 0, 2], [2, -2, -4], [4, 6, -6], [2, -1, 2], [1, 1, 0], [0, 6, -6], [-1, 0, -2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_2.json b/research/three-total-decoders/data/nojoint_21_2.json new file mode 100644 index 0000000000..68b8427982 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_2.json @@ -0,0 +1 @@ +[[[-2, 1, -1], [2, 0, 1], [1, -1, 2], [-2, -4, -1], [-2, -1, 2], [0, 2, 2], [2, 2, 2], [0, 2, -1], [-8, -6, -4]], [[3, -9, -6], [4, 8, 4], [-2, 4, -2], [2, 1, 2], [-1, 0, 2], [-1, 0, 2], [-2, -4, 4], [-6, -2, 2], [1, -1, 2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_3.json b/research/three-total-decoders/data/nojoint_21_3.json new file mode 100644 index 0000000000..b176c2557b --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_3.json @@ -0,0 +1 @@ +[[[1, 0, 1], [2, 2, 2], [2, 1, -2], [-2, 8, 2], [-8, -2, -6], [-16, -16, 24], [-28, -8, -20], [8, -4, 0]], [[-2, 0, -2], [-1, -2, -2], [-1, 1, 1], [6, -8, 2], [-12, -8, 20], [4, 8, -8], [-8, 8, 0], [2, 1, -2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_4.json b/research/three-total-decoders/data/nojoint_21_4.json new file mode 100644 index 0000000000..fbd7a7ded2 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_4.json @@ -0,0 +1 @@ +[[[-2, 0, -2], [-1, -1, 2], [-10, 20, 10], [1, 1, -1], [2, -4, -1], [3, -1, 1], [-4, -2, 2]], [[1, 1, -2], [-2, 1, -1], [-10, 0, -20], [-16, -16, 16], [1, -1, 0], [0, -2, 4], [2, -1, -2]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_5.json b/research/three-total-decoders/data/nojoint_21_5.json new file mode 100644 index 0000000000..1117ca7270 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_5.json @@ -0,0 +1 @@ +[[[-1, 2, 2], [6, 36, 6], [-2, 0, 1], [-1, -1, 0], [-6, 3, 6], [2, -3, -4], [0, 14, -7], [-1, 0, 2], [-2, 0, 4]], [[8, -2, 4], [-3, 6, -6], [-2, 0, -1], [-144, 36, -72], [-2, -2, 2], [-6, 1, -4], [-198, 72, -234], [2, 1, 2], [11, 2, 4]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_6.json b/research/three-total-decoders/data/nojoint_21_6.json new file mode 100644 index 0000000000..e0dda71fe4 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_6.json @@ -0,0 +1 @@ +[[[288, -288, 288], [-2, 1, 1], [-18, -2, 2], [72, 96, 48], [16, -12, -4], [-2, -2, -1], [8, -15, -11], [2, 2, 1]], [[0, 24, -48], [-288, 48, 336], [-9, 18, -18], [1, 2, -2], [0, -1, -1], [-4, -4, -4], [-2, 2, 0], [-2, 7, -11]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_7.json b/research/three-total-decoders/data/nojoint_21_7.json new file mode 100644 index 0000000000..e0caf1819a --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_7.json @@ -0,0 +1 @@ +[[[1, -2, 0], [-2, -9, -7], [-2, 1, -1], [2, -1, 2], [2, 0, -2], [0, -6, -6], [1, 1, -2], [0, 6, 12]], [[1, 2, 0], [4, 2, 4], [-1, 1, -1], [2, -1, 1], [4, 4, -2], [-1, 2, -1], [4, 2, -2], [-4, -3, 5]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_8.json b/research/three-total-decoders/data/nojoint_21_8.json new file mode 100644 index 0000000000..f2b1cf2b19 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_8.json @@ -0,0 +1 @@ +[[[1, 0, 1], [1, -2, 1], [12, 8, -4], [1, -1, 2], [2, 0, -2], [-4, 0, 0], [-2, 2, 2], [-1, -1, -1], [1, -2, -1]], [[-1, 2, -1], [-2, -4, 2], [0, 4, -4], [4, 0, 4], [0, -2, -4], [-16, 0, -16], [-2, 0, 2], [3, 1, -1], [0, 2, -1]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/nojoint_21_9.json b/research/three-total-decoders/data/nojoint_21_9.json new file mode 100644 index 0000000000..f8691b0ad2 --- /dev/null +++ b/research/three-total-decoders/data/nojoint_21_9.json @@ -0,0 +1 @@ +[[[-28, -28, 112], [2, 0, 2], [4, 4, 4], [-4, -8, 24], [0, 0, -2], [-1, -2, 8], [4, 4, -2], [2, 2, -1], [-4, 6, -4]], [[2, 0, -2], [28, 28, 14], [-2, -2, 1], [0, -4, -1], [2, 1, 2], [2, -2, 0], [1, -1, -2], [4, -14, -4], [2, -1, 0]]] \ No newline at end of file diff --git a/research/three-total-decoders/data/supmin_fail_v8.json b/research/three-total-decoders/data/supmin_fail_v8.json new file mode 100644 index 0000000000..384dc6d2c8 --- /dev/null +++ b/research/three-total-decoders/data/supmin_fail_v8.json @@ -0,0 +1 @@ +[[[2, -1, 0], [1, -1, 2], [-2, -1, -1], [2, 0, -2], [4, 4, 4], [0, -2, 0], [2, -3, -2], [-2, 0, 2]], [[1, 0, 1], [-2, 2, -2], [-2, 0, 2], [1, 2, -4], [2, 4, 1], [2, 1, 0], [2, -2, -2], [0, 0, -2]]] diff --git a/research/three-total-decoders/data/tied_min.json b/research/three-total-decoders/data/tied_min.json new file mode 100644 index 0000000000..ae11f01fab --- /dev/null +++ b/research/three-total-decoders/data/tied_min.json @@ -0,0 +1 @@ +[[[1, -1, -1], [0, 1, 1]], [[1, -1, -1], [1, -1, 0]], [[1, -1, -1], [1, 0, -1]], [[1, -1, 1], [0, 1, -1]], [[1, -1, 1], [1, -1, 0]], [[1, -1, 1], [1, 0, 1]], [[1, 1, -1], [0, 1, -1]], [[1, 1, -1], [1, 0, -1]], [[1, 1, -1], [1, 1, 0]], [[1, 1, 1], [0, 1, 1]], [[1, 1, 1], [1, 0, 1]], [[1, 1, 1], [1, 1, 0]]] \ No newline at end of file diff --git a/research/three-total-decoders/evidence/T3-PROOF.md b/research/three-total-decoders/evidence/T3-PROOF.md new file mode 100644 index 0000000000..a3288fc88a --- /dev/null +++ b/research/three-total-decoders/evidence/T3-PROOF.md @@ -0,0 +1,145 @@ +# KPR4 T >= 3 under Thm C: proofs and closure status (Oct 13, second prover) + +Model (FL C.6 / #446 Thm C): B over F2, unit diagonal, 0 on non-orthogonal root pairs, free on orthogonal pairs; +decoder M = sum_{j<=T} p_j q_j^T over Q, M_tt != 0, M_ts = 0 where B_ts = 1 (s != t); R_j = supp p_j, A_j = supp q_j, +D_j = R_j cap A_j, r_j = rank_F2 B[R_j, A_j], cost = sum_j max(w, r_j). A window (unit, T, h) closes iff cost >= N(h) := c(h)+1, +c(h) = ceil(v x*(h)) - 1 (open_cases.py). + +## 0. What each window actually needs (scratch need.py; N(h) = c(h)+1) + +| unit | v | w | 3w | N(h) over the open T=3 range | +|---|---|---|---|---| +| D5 | 20 | 4 | 12 | h7-8: 13 | +| D6 | 30 | 5 | 15 | h7 20, h8-9 19, h10 18, h11-13 17, h14-17 16 | +| D7 | 42 | 6 | 18 | h7 28, h8 27, h9 26, h10 25, h11-12 24, h13-14 23, h15-17 22, h18-19 21, h20-21 20, h22-24 19 | +| D8 | 56 | 7 | 21 | h7 37, h8 35, h9 34, h10 33, h11 32, h12-13 31, h14-15 30, h16-17 29, h18 28, h19-20 27, h21-22 26, h23-24 25, h25-26 24, h27 23, h28-29 22 | +| E6 | 36 | 5 | 15 | h8 23, h9 22, h10-11 21, h12-14 20, h15-17 19, h18-19 18, h20-22 17, h23-25 16 | +| E7 | 63 | 7 | 21 | h8 40, h9 38, h10 37, h11 36, h12-13 35, h14 34, h15-16 33, h17 32, h18-19 31, h20-21 30, h22 29, h23-24 28, h25 27, h26-27 26, h28-29 25, h30 24, h31-32 23, h33 22 | + +Two targets: (i) top of every window needs only N = 3w+1, i.e. "the three totals cannot all have r_j <= w"; +(ii) the low-h end needs ~0.62-0.67 v. + +(sections below are filled as results land) + +## 1. Decoder-free bound: does NOT close anything (exact) + +Since D_j = R_j cap A_j, r_j >= rank B[D_j, D_j] >= f(D_j) := min F2 rank of a unit-diagonal matrix on D_j vanishing on +non-orthogonal pairs, and every line lies in some D_j (M_tt != 0). Pure root-system bound: Phi = min over 3-covers of +sum_j max(w, f(D_j)). **D5: Phi = 12 = 3w < 13.** Witness (new/verify_partition.py, B blocks re-verified by elimination): +parts {0,4} (rank 2), {6,8,9,11,12,13,15,16,17} (rank 3: three disjoint orthogonal triples, B = J_3 + J_3 + J_3), +{1,2,3,5,7,10,14,18,19} (rank 4). Lines indexed as ade.D(5). So the decoder geometry is indispensable even at the top +of the smallest window; the obstruction is dense J-blocks on orthogonal triples/pairs. + +## 2. Decoder lemmas (all rigorous; each is a constraint of new/coversat.py) + +Notation: omega_j(t) = p_j(t) q_j(t) / M_tt, so sum_j omega_j(t) = 1 and t in D_j iff omega_j(t) != 0. + +**L1 (cover).** Every t lies in some D_j. (M_tt = sum_j p_j(t) q_j(t) != 0.) + +**L2 (principal block).** r_j >= rank B[X, Y] for X subset R_j, Y subset A_j; in particular for X = Y = D_j. + +**L3 (no transitive (T+1)-tournament).** No T+1 lines t_1..t_{T+1} with B_{t_i t_k} = 1 for all i < k. +Proof: M[S,S] would be triangular with nonzero diagonal, rank T+1 > rank M. + +**L4 (full clique meets every total).** If |S| = T and B[S,S] = J (all off-diagonal ones), then S meets every D_j. +Proof: M[S,S] = P_S Q_S^T = Delta is diagonal invertible, so P_S (T x T) is invertible and Q_S^T = P_S^{-1} Delta. +Then sum_{t in S} omega_j(t) = sum_i (P_S)_{ij} (P_S^{-1})_{ji} = (P_S^{-1} P_S)_{jj} = 1, so some omega_j(t) != 0. +(Consequence: the 3-disjoint-triples part above is impossible as a single D_j with the triples private to it.) + +**L5 (single surviving product).** If B_ts = 1 (t != s) then |pi(t) cap sigma(s)| != 1, pi = row support, sigma = column +support: a single nonzero product p_j(t) q_j(s) cannot sum to 0. (Consequence: if a digon t,s (B_ts = B_st = 1) has +t, s in D_j and in no other D_k, then pi(t) cap sigma(s) has size >= 2, so it contains some k != j and B_ts = 1 sits in +block k; likewise B_st sits in some block k'; if pi(t), sigma(t), pi(s), sigma(s) force k' != k, all three totals are +nonzero on {t,s}. A digon spread over two totals, e.g. p(t)=q(t)=e_1, p(s)=q(s)=e_2, costs exactly 2.) + +**L6 (K22).** Distinct t,t',s,s' with B_ts = B_ts' = B_t's = B_t's' = 1: two distinct points cannot lie on two distinct +lines, so P_t = P_t' (then B_tt' = B_t't = 0 and pi(t) = pi(t')) or L_s = L_s' (then B_ss' = B_s's = 0, sigma(s) = sigma(s')). + +**L7 (lift identity; new).** For every rational matrix B' supported on supp(B) with nonzero diagonal, + v <= sum_j rank_Q B'[R_j, A_j]. +Proof: B' o M = diag(B'_tt M_tt) (off-diagonal: B'_ts != 0 only where B_ts = 1, where M_ts = 0), and +B' o M = sum_j D(p_j) B' D(q_j), whose j-th term has rank <= rank_Q B'[R_j, A_j]. +Consequence: a decoder with cost < v needs B whose blocks are *jointly non-liftable*: no common rational re-weighting of +the ones of B brings every block's Q-rank down to its F2 rank. J-block (clique) structures, unimodular blocks, and +anything with a sign-lift are therefore never cheaper than v. This is the precise sense in which the T = 3 question is +cross-characteristic, and why the cost < v phenomenon needs F2-specific (Fano-like) cancellation, as at T >= 7. + +## 3. A global F2 certificate (rigorous) and the 2-adic theorem P + +**L8 (labelling certificate).** For any F2 vectors a(t) subset pi(t), b(s) subset sigma(s) (pi, sigma the row/column supports), +cost >= sum_j r_j >= rank_F2( sum_j D(x_j) B D(y_j) ) = rank_F2( B o K ), K_ts = a(t).b(s) mod 2, +where x_j(t) = a(t)_j, y_j(s) = b(s)_j (each term is a sub-block of B[R_j, A_j]). If there is a linear order on a set S +with K_tt = 1 on S and K_ts = 0 for every incidence p(t).q(s) = 0 with t before s (t, s in S), then B o K restricted to +S x S is unit lower-triangular for EVERY admissible B, so cost >= |S|. (This is the T >= 1 generalisation of the T = 2 +alpha/beta triangularity; the T = 2 proof is the case a = b = e_1 on {alpha < beta}, a = b = e_2 on {alpha > beta}.) + +**Theorem P (2-adic reduction with one-sided repairs).** Fix e in Z^3 and rescale p_k -> 2^{e_k} p_k, q_k -> 2^{-e_k} q_k +(M unchanged, supports unchanged); scale each p(t), q(s) to a primitive 2-integral vector and reduce mod 2: a(t), b(s). +Then a(t).b(s) = 0 for every incidence (an odd number of odd terms cannot sum to 0). Let G = {t : a(t).b(t) = 1} and +I = the rest ("isotropic"). Call t in I *b-repairable* if some delta subset sigma(t) has a(t).delta = 1 and a(u).delta = 0 +for all u in I with p(u).q(t) = 0, and *a-repairable* dually (delta subset pi(t), delta.b(t) = 1, delta.b(s) = 0 for all +s in I with p(t).q(s) = 0). Let F = repairable lines. Then **cost >= |G| + |F|**. +Proof. Labels a'(u) = a(u) + delta_u on a-repaired u, b'(t) = b(t) + delta_t on b-repaired t (each repaired line uses one +side), unchanged otherwise; S = G + F. K_tt = 1 on S. For an incidence u -> t (p(u).q(t) = 0, u != t), since +a(u).b(t) = 0: K_ut = [t b-rep] a(u).delta_t + [u a-rep] delta_u.b(t) + [both] delta_u.delta_t. + - t b-repaired, u not a-repaired: a(u).delta_t = 0 if u in I (choice of delta_t); possibly 1 if u in G. + - u a-repaired, t not b-repaired: delta_u.b(t) = 0 if t in I; possibly 1 if t in G. + - u a-repaired, t b-repaired: the first two terms vanish (u, t in I); delta_u.delta_t possibly 1. +So every kept incidence goes a-repaired -> G, G -> b-repaired or a-repaired -> b-repaired. In the order +(a-repaired, G, b-repaired) all kept entries of B o K[S,S] lie above the unit diagonal: rank |S|, so cost >= |G| + |F|. [] +Check: new/thmP.py (exact Fraction valuations). On random rational configurations (v = 6-12, pools {-1,0,1,2}, +{+-1,+-2}) theorem P gives >= 0.75 v (worst sampled ratio 0.75; e.g. 7/8, 8/10); it alone is not a uniform 2/3 bound. + +**Conjecture F -- FALSE as stated (cex/cex_min_1.json, hunter, Oct 13).** Original statement: For every rational T = 3 decoder there are labels +a(t) subset pi(t), b(t) subset sigma(t) and an order with K_tt = 1 for all t and every forward incidence killed. +Refuted: a 19-line {-1,0,1}^3 configuration has max L8 certificate 18 (two CP-SAT encodings, cex/); its best known +Thm-C cost is 23 >= v, so it is NOT a decoder win -- only the certificate is too weak there. Theorem P gives just 8/19 on +it (all entries +-1/0: heavily isotropic). Earlier sampling evidence (local search reached |S| = v on ~90 random +configurations tried (v = 6-12, +dense pools), including the v = 9 example whose per-total MAS sum is only 7. Not proven. Over R the analogue is +doubtful (Kochen-Specker / 4-chromatic orthogonality graphs of S^2), over Q the 2-adic structure is what makes it plausible +(Godsil-Zaks: the orthogonality graph of Q^3 is 3-colourable -- not re-checked against the paper; per LIT.md their +argument avoids isotropy via the unit-norm constraint, which our p, q lack, so it does not transfer directly), and theorem P is the first half of such a proof: what is +left is ordering the unrepairable isotropic lines (|Z(t)| = 2: two tied minimal 2-adic valuations among p_k(t) q_k(t)).) +What the windows need is only Conjecture F': certificate >= c v with c ~ 0.67 (low h) or >= 3w+1 (top); open. + +## 4. Root-system relaxation (SAT, no proof logs) -- status + +new/coversat.py encodes L1-L6 (+ valid symmetry breaking --sb: totals sorted by |D_j|, a line of the largest D moved to +line 0 by W transitivity) and asks for B, supports pi/sigma and rank-<=c_j factorisations of every B[R_j, A_j]. +UNSAT at caps (w,w,w) would close the top of the window ("not all r_j <= w"). + - D4, caps 2,2,2: UNSAT in 0.1 s (calibration only; D4 is closed by T <= 2). + - **D4, caps 3,3,3 (--sb --C7): UNSAT in 1710 s** (CaDiCaL, no proof log): the relaxation alone proves that a D4 T=3 + decoder has some r_j >= 4, i.e. cost >= 10 of v = 12 (D4 is already closed by T <= 2; this is the calibration -- the + relaxation is strong, not near-vacuous). + - D5, caps 4,4,4: undecided. Without --sb/C7: 60 min timeout. Running: jobs/cov_d5_sb (--sb --C7, started ~16:27, + 2 h cap) and jobs/cov_d5_sb_noc7 (--sb, started 16:58, 2.5 h cap); logs in jobs/cov_d5_sb*.log. **UNSAT would close + the whole D5 T3 window (h7 and h8 both need exactly 3w+1 = 13)**, provisionally (no proof log). DIMACS for a + DRAT/LRAT rerun: new/cov_D5_T3_4-4-4_sb_c7.cnf, new/cov_D4_T3_3-3-3_sb_c7.cnf (new/dumpcnf.py). +The D-only version (C2 on D_j x D_j instead of R_j x A_j) is SAT instantly for D5 4,4,4: the off-D_j rows/columns that +L5 forces into other totals (a digon private to one total puts its off-diagonal ones into other blocks) are essential. + +## 5. Open table after this pass + +Nothing in the open list is closed yet. Unchanged: D5 T3 h7-8; D6 T3 h7-17; D7 T3 h7-24, T4 h7-10; D8 T3 h7-29, T4 h7-17, +T5 h7; E6 T3 h8-25, T4 h8-11; E7 T3 h8-33, T4 h8-22, T5 h8-11. + +Sharpest remaining obstruction (two faces of one gap): + (a) root side: the orthogonality graph alone allows three totals of F2 rank <= w on D5 (section 1); what kills it is + decoder geometry -- L4 (a mutually-paired triple meets every total) and L5 (a pair private to one total spills into the others) -- whose SAT closure + is computationally hard as encoded; + (b) decoder side: by L7 a cheap decoder needs jointly non-liftable F2 blocks; by theorem P the only lines that resist + the 2-adic certificate are isotropic lines that cannot be repaired on either side. Conjecture F (repair + order; now refuted, F' with c ~ 2/3 suffices) + would have given cost >= v for every B; a proven F' would close every T = 3 window and, at T = 4, the T = 4 ones + (T = 4 needs the analogous statement in PG(3,2)). + +## 6. T = 4, 5 (free extensions) + +L1, L2, L5, L6, L7, L8 hold verbatim for any T. L3: no transitive (T+1)-tournament. L4: a T-set with B[S,S] = J meets +every D_j (same proof, P_S is T x T). Theorem P holds verbatim with reductions in PG(T-1, 2) (a(t), b(s) in F2^T). +A constant-factor F' at T = 4 would close the T = 4 windows; F itself fails already at T = 3 (cex) and cost >= v fails by T = 7 (E7 coordinates give cost < v). + +Note (coordinator question): theorem P cannot by itself close the top of a window -- it is a bound for a GIVEN decoder +(it reads the decoder's 2-adic valuations), so closing a window needs it (or Conjecture F) for every decoder, which is +exactly the unproven step. It would close a window only together with a classification of the possible isotropic +(unrepairable) sets, which is not done. diff --git a/research/three-total-decoders/evidence/cex-README.txt b/research/three-total-decoders/evidence/cex-README.txt new file mode 100644 index 0000000000..06b10ed675 --- /dev/null +++ b/research/three-total-decoders/evidence/cex-README.txt @@ -0,0 +1,2 @@ +cex_min_1.json: 19 lines [P,Q] (rows of P,Q in Z^3, M_ts=P_t.Q_s), 1-minimal: Conjecture F infeasible (certlib.py max cert 18; verify.py independent encoding INFEAS). +Source: all (p,q), p,q in primitive vectors of {-1,0,1}^3, p.q!=0 (121 lines; max cert 115). Thm-C actual cost (actualcost.py, min over B of sum rank_F2): best found 23 (CP-SAT, bound 10 not proved), SA best 25. diff --git a/research/three-total-decoders/evidence/fleet-BRIEF.md b/research/three-total-decoders/evidence/fleet-BRIEF.md new file mode 100644 index 0000000000..bbcc8eb0a6 --- /dev/null +++ b/research/three-total-decoders/evidence/fleet-BRIEF.md @@ -0,0 +1,34 @@ +# Fleet brief: prove cost >= v at T = 3 (theorem (A)) + +**Read first:** ../PROOF.md §0–2 (model, L1–L8), §7 (Theorem M1), §9 (multi-copy certificate), and §11–12. §12 covers tied_min: cost 12 = v, the exchange proof, the 217 optima, and the fact that all of them lift to Q. + +## Model +- Lines t = 1..v. For each t: a point p(t) ∈ Q³ and a line q(t) ∈ Q³ with p(t)·q(t) ≠ 0. +- The decoder is M = PQᵀ with rank ≤ 3 and totals j = 1, 2, 3. +- R_j = {t : p_j(t) ≠ 0}, A_j = {t : q_j(t) ≠ 0}. +- B is an F2 matrix: unit diagonal, B_ts = 1 allowed only where p(t)·q(s) = 0. (Root-system admissibility only removes options, so a proof for all B suffices.) +- cost = Σ_j rank_F2 B[R_j, A_j]. We drop the max(w, ·) floor; proving cost ≥ v is the strong form. + +## Theorem (A), the target +cost ≥ v for every such configuration and every such B. + +## Known facts +- **Lemma A:** (A) holds with ≤ 2 totals. +- **Lemma B, lift identity:** for any rational B′ with the same support as B (B′_tt ≠ 0), v ≤ Σ_j rank_Q B′[R_j, A_j]. + - So if some cost-minimising B has a **joint Q-lift** with rank_Q B′[R_j, A_j] = rank_F2 B[R_j, A_j] for all j, then (A) holds for that configuration. +- **Liftability conjecture (LC):** at T = 3, some cost-minimising B is jointly Q-liftable. + - It is false at T ≥ 7 (E7/E8, Fano-type cancellation). It holds on all 217 optima of tied_min. +- **Theorem M1:** if every point has a zero coordinate, cost ≥ v/2. +- **Sharp example:** tied_min.json, 12 lines, points (1,±1,±1) against the B3 two-support lines. Cost 12 exactly. Ordering/label certificates provably stop at 11. + +## Possible routes +- **Matroid route.** A binary matroid is representable over Q iff it is regular (no Fano F7 or F7* minor; Tutte). A block whose column matroid over F2 is regular admits a signing, so a Q-lift of the same rank exists (totally unimodular). + - So LC would follow from: some optimal B has every block regular, and the per-block signings can be chosen *compatibly* on shared entries. + - The rank ≤ 3 (P²) geometry of the decoder may forbid Fano minors in optimal blocks. +- **Exchange route.** Generalise §12.3: a block of unusually low rank forces its neighbours up. +- **Direct rank route.** Bound Σ rank_F2 by a single F2 rank of an assembled matrix, using incidence structure in P². + +## Rules +- Write your findings to fleet/.md, short and precise: statements, proofs, counterexamples. +- Every claim must be machine-checked on tied_min.json, cex_min_1 (../cex/), and random small configurations, in exact arithmetic. +- Compute: at most 1 process each, no SAT solvers (math focus), CP-SAT only if tiny (num_workers 1, ≤ 2 min). No git. diff --git a/research/three-total-decoders/evidence/fleet-REQUESTS.md b/research/three-total-decoders/evidence/fleet-REQUESTS.md new file mode 100644 index 0000000000..73dedda73c --- /dev/null +++ b/research/three-total-decoders/evidence/fleet-REQUESTS.md @@ -0,0 +1,58 @@ +# Requests from the math lead (relay to the fleet) + +R1 (S1, matroid / LC): before theory, measure. +- On tied_min's 217 optima (../tied_min_optBs.json, entries are (t,s) incidences set to 1) and on any optimum you can + get with tiny CP-SAT (cex_min_1 has cost in [20,22]), test each block for regularity: try a TU signing via Camion's + propagation, then check TU by brute force on small minors. +- Report: + - whether any optimal block contains an F7 or F7* minor; + - whether the per-block signings can be made compatible on shared entries. An entry (t,s) is shared by the blocks + j in pi(t) cap sigma(s), which has size 2 or 3. +- Compatibility is the real content of LC. Find the smallest obstruction: a cycle of shared entries whose sign + constraints conflict. + +R2 (S2, exchange): use the two new reductions in PROOF.md section 13. +- Lemma SCC: H is strongly connected, WLOG. +- Lemma Peel: every point and every line has >= 2 nonzero coordinates, WLOG. +- Then try to prove "cost = 3 rho - sum w_j >= v" in F2S via an upper bound on sum_j w_j. w_j counts row-space vectors + supported on class-j columns, i.e. dependencies of rows restricted to the two other classes ("flow conservation" + on the pencil-k fibres). +- Concrete target: sum_j w_j <= 3 rho - v, at least when rho < v/2, which is the only open case since cost >= 2 rho. + +R3 (S3, adversary): hunt only inside the reduced class. +- Strongly connected H, every point and every line with >= 2 nonzero coordinates. +- Prefer F2S with rho < v/2 possible: dense label coincidences, quadrangle-like nets. +- tied_min is the smallest tight example known; report any configuration whose min cost equals v (tight), not only + ones below v. Tight examples are what a proof must explain. + +R4 (S1/S3, literature hook): (A) is a coupled Haemers-minrank / linear index-coding comparison between F_2 and Q +(PROOF.md 13.1). +- S1: check whether the matroid obstruction in the known T >= 7 counterexamples is literally an F7 / F7* minor inside + one block, or only appears through the coupling. Whichever it is tells us where a T = 3 proof must look. +- S3: use Lubetzky-Stav-type F_2-cheap digraphs as seeds. Ask which of them embed as point-line incidence digraphs in + P^2(Q) (K_{2,2}-free in the L6 sense, no transitive 4-tournament). + +R5 (S1, URGENT correction to Lemma W). reg.py tests the column matroid M[B]. A TU signing of B exists iff +M[I | B] is regular (Camion), and that is NOT implied by M[B] regular: +- any full-rank B has M[B] free (hence regular); +- A = [[1,1,0,1],[1,0,1,1],[0,1,1,1]] has M[A] graphic, but M[I|A] = F7, so A has no TU signing. +So Lemma W must read: "if B has a TU signing (M[I|B] regular), then cost(B) >= v". Please re-run t1b.py on +[I | B]. Note that F7 search at rank 12 with 24 elements is still feasible. +More useful than TU, and exactly what Lemma B needs: a signing (or any rational lift on supp B, nonzero diagonal) with +rank_Q = rank_F2 on the three blocks only. I checked this directly: all 217 tied_min optima have a +-1 joint lift +with Q-ranks (4,4,4) (liftall.py, exact). Suggested precise gap G1': "some cost-minimiser has a joint rank-preserving +lift on the three blocks". Lemma G (gluing) is the right tool for it; the triple-overlap obstruction is the content. + +R6 (S3, test an induction scheme; exact costs on small configurations, CP-SAT tiny OK). +Single-line deletion can't drive an induction: tied_min minus any one line still costs 12. Test group peeling. +For a point P, let X_P = {t : p(t) = P}; for a line l, let Y_l = {t : q(t) = l}. +- Conjecture PP: every configuration with v >= 1 has a point P or a line l such that + cost(config) >= cost(config - X) + |X| (X = X_P or Y_l). + PP implies (A) by induction. +- Mechanism: B[X_P, X_P] = I (same-point lines are never incident), so rank B_j = |X_P cap D_j| + rank(Schur + complement). The Schur complement adds B_ut B_ts along paths u -> t -> s through X_P. It can leave the incidence + class, so PP is not automatic. +- On tied_min it holds: remove a point (3 lines), 12 >= 9 + 3; remove a q-line (2 lines), 12 >= 10 + 2. +- Please test PP on every 4095-subset of tied_min (S2 has all their exact costs: S2_scripts/s2b.py), on cex_min_1 + sub-configurations, and on random configurations with coincident points and lines. +- Report the smallest failure. If none, also test the stronger "every P with |X_P| >= 2 works". diff --git a/research/three-total-decoders/evidence/fleet-S1.md b/research/three-total-decoders/evidence/fleet-S1.md new file mode 100644 index 0000000000..de765a3007 --- /dev/null +++ b/research/three-total-decoders/evidence/fleet-S1.md @@ -0,0 +1,58 @@ +# S1 (matroid route): status = NOT PROVED, NOT REFUTED; two reductions proved, one gap precise + +Code: fleet/S1_code/ (reg.py = exact F2 regularity test via F7 / F7* minor search: tests pass on F7, F7*, graphic examples). + +## 1. Checked facts (machine, exact) +- tied_min, all 217 optima (tied_min_optBs.json): all 3x217 blocks B[R_j,A_j] (12x8, F2-rank 4) are REGULAR (t1.py). +- STRONGER: the WHOLE 12x12 matrix B is regular for all 217 (ranks 6 for the 216 class-diagonal ones, 4 for B0) (t1b.py). +- Exhaustive minimisation (enum.c, all 2^f B, f<=26) on ~85 random small T=3 configs (v=6..9, incl. configs with repeated lines q0 and collinear points): + every config has an optimum with all blocks regular AND with whole B regular; in these no minimiser at all had a nonregular block. 3000 random B on tied_min-like configs: 0 nonregular blocks. + +## 2. Do Fano-minor blocks occur at T=3? YES (non-optimal B), constructed (gad.py, gad.json, v=10) +Block j in affine coordinates: rows = points u(t) of Q^2, columns = lines not through 0; support of B inside incidence + unit diagonal. +Gadget: a_0,a_1,a_2 non-collinear points (own lines q_0,q_1,q_2 concurrent at c, a_i not on q_i); +seven lines s with point c (coincident points!) and q(s) = a_i a_j / a_i / free lines chosen so that the 3x7 part F satisfies F G^T = I_3, +G^T = the 7 nonzero vectors of F2^3 as rows (1604 solutions with column weights <= 2). B = [[I3,F],[G^T,I7]]. +Contracting the 3 columns i gives I7 + G^T F of rank 4 with 3-dim kernel = simplex code => F7* minor. Verified: block 2 (10x10) rank 7, regular = False. +So F7* blocks are realisable by admissible B (p.q=0 pattern), but this needs degenerate geometry: coincident points (or q_0=q_1=q_2) -- 7 points b_s lie on the 3 lines in all Fano patterns, which forces concurrency/coincidence over Q. +(Pure rank-3 F7-column B with unit diagonal and admissible also exists, fano7.py, v=7, but there the block cuts R_j,A_j break the F7 and the cost is 8>=7.) +That gadget config: SA (40k steps) min cost 19 (v=10); minimisers include 5/200 with a nonregular block, but 1499/1507 minimisers have all blocks AND the whole B regular. Regular-restricted SA reaches the same min (19) on this and 4 random gadget variants (var.py): no gap found. +=> "every optimum is regular" is FALSE; "some optimum is regular" is untested-to-refuted. + +## 3. Proven (rigorous) +**Lemma W (whole-B regularity gives joint lift, no gluing needed).** If the whole F2 matrix B (v x v) has a regular column matroid, it has a TU signing B' +(Tutte/Camion). Every B[R_j,A_j] is a submatrix, hence TU, hence rank_Q = rank_F2 (all minors are 0,+-1 and nonzero over Q iff over F2). B' has the same +support, B'_tt != 0. By Lemma B: v <= sum rank_Q B'[R_j,A_j] = cost(B). So: **(A) at T=3 follows if SOME cost-minimiser B has regular column matroid.** +The block-wise condition is the weaker hypothesis whose only extra difficulty is gluing (below). + +**Lemma G (gluing, partial).** Blocks overlap in H_jk = B[R_j∩R_k, A_j∩A_k], the same entries. A chordless cycle of H_jk is a chordless cycle in both blocks, and +Camion forces the holonomy of every chordless cycle (n_- = m mod 2 for length 2m), so sigma_j|H_jk and sigma_k|H_jk have equal holonomy on all cycles (chordless cycles generate the cycle space) => they differ by a +-1 row/column gauge on each component. +Hence any two blocks can be glued; blocks 0,1,2 glue iff the pairwise-corrected signings also agree around cycles of H02 ∪ H12 that mix both overlaps +(Cech-type obstruction on triple overlap R0∩R1∩R2 x A0∩A1∩A2). I could not rule the obstruction out in general; it vanishes when the whole B is regular (Lemma W) or when H012 has no entries. + +## 4. Gap (precise) +Need: (G1) at T=3 some cost-minimiser B has a regular whole column matroid (or all blocks regular plus vanishing triple-overlap obstruction). +No proof. Mechanism that should be used: a Fano/F7* minor forces coincident points or equal lines (F7 is not realisable as a point-line configuration over Q, Sylvester-Gallai-type); the exchange needed is +"replace B by B' = B with rows/columns of coincident points/equal lines re-routed", which should lower or keep rank; verified only computationally (no counterexample found, gap search on gadget variants negative). +Not tested: cex_min_1 (v=19) whole-B regularity of its best known B (cost 22, > v anyway); large v with many coincidences. + +--- +# ADDENDUM (second pass, L6 / non-degenerate bridge) + +## A. CORRECTION to Lemma W / Lemma G above +"Column matroid M[B] regular" is NOT enough for a same-support rank-preserving signing (regularity of M[B] gives a TU matrix representing the matroid, in general with a different support). The correct sufficient condition is +**TS(B): B is TU-signable, i.e. [I|B] is regular, i.e. some +-1 signing of supp(B) is totally unimodular** (Camion: all square Eulerian submatrices sum = 0 mod 4; this is a LINEAR system over F2 in the sign bits, solved exactly by tusign.c, tests: J2, odd 3-cycle signable; 3x7 Fano matrix not). +Lemma W': TS(whole B) => every submatrix (all blocks) TU => rank_Q = rank_F2 for the signed B' (same support) => joint Q-lift => cost >= v by Lemma B. (Note this is strictly stronger than needed: the 3x7 Fano matrix is not TU-signable but trivially lifts with equal rank 3.) +Rechecked with the right notion: tied_min, all 217 optima: whole B TU-signable (217/217) and all 651 blocks TU-signable. (The earlier "regular" results for M[B] still hold but are the weaker statement.) + +## B. Q1/Q2: does non-degenerate (L6, K22-free off-diagonal, unit diagonal) imply regular? NO. +- Exhaustive: all K22-free unit-diagonal matrices n=4 (2902) and n=5 (301826): M[B] regular (trivial: F7 needs >=7 columns). +- Random greedy K22-free, n=6..11 (thousands): M[B] always regular. (k22.py) +- But TU-signability fails already at n=5 for K22-free B (k22b.py): e.g. rows [11100],[01110],[01101],[10111],[11011]; minimal non-signable submatrix is 4x4 [[1,1,1,0],[0,1,1,1],[0,1,1,0],[1,0,1,1]]. This B is realised by 5 DISTINCT points of P^2(Q) (realiz.py) and the resulting config has 8 minimisers, all TU-signable (cfgchk.py): non-signable is harmless when rank is full. +- COUNTEREXAMPLE (search14.py -> aff14.py, aff14.json): n=14, B=[[I7,N],[M,I7]] with N,M sparse (<=3 ones per row), off-diagonal K22-free, and M[B] has an F7*/F7 minor (contracting the first 7 columns leaves I+MN nonregular; whole 14-column matroid verified regular=False, rank 11). Realised by 14 DISTINCT affine points (all z != 0) and 14 DISTINCT lines (all q_z != 0), so the whole B is one block, admissible, and non-degenerate. So "non-degenerate => regular" is FALSE (smallest found n=14; I did not search for smaller). + BUT this B is far from optimal: cost 31 vs SA minimum 24 (v=14); the SA minimiser is TU-signable (sa14.py). +Conclusion: L6 alone (K22-freeness) does not force regularity; the property must come from OPTIMALITY (cost-minimal B), not from admissibility. + +## C. Q3 degenerate case: not closed +Empirics only: gadget (coincident points/equal lines) minimisers are mostly TS; regular-restricted SA matches unrestricted SA. 120+ further random grid configs (7-9 lines, distinct and with repeats, exhaustive over all B, f<=23; drv3.py): in every one some minimiser is TU-signable (up to 28 non-signable minimisers coexisting). Among inclusion-minimal and min-cardinality minimisers (12-25 informative configs, drv4.py) all were TU-signable -- candidate selection rule "take a support-minimal optimum", unproved, tested only on small random configs (most have B=I optimal, so weak evidence). +No exchange proof found. Remaining precise gap: show a support-minimal (or otherwise canonical) cost-minimiser is TU-signable at T=3; admissibility alone cannot (section B). diff --git a/research/three-total-decoders/evidence/fleet-S2.md b/research/three-total-decoders/evidence/fleet-S2.md new file mode 100644 index 0000000000..125c0f92f1 --- /dev/null +++ b/research/three-total-decoders/evidence/fleet-S2.md @@ -0,0 +1,61 @@ +# S2 (exchange route, class F2S): status = NO proof of cost >= v; reformulation, partial theorems, negatives + +## 1. Reformulation of F2S (proved, exact) +F2S = full-support points, lines with exactly 2 nonzero coords. A class-k line (q_k = 0) is a line through the coordinate +vertex e_k; points are off the coordinate triangle. So each point t lies on exactly one pencil line per class: label +lam_k(t) in V_k (pencil-k lines). A line s of class c has tail g(s) in V_c (its own pencil line), lam_c(s) != g(s). +Hyperarc model: line t = (tail g(t) in V_c(t); head set Hd(t) = {lam_0(t), lam_1(t), lam_2(t)}, 3 distinct labels, tail not in Hd). +Incidence t -> s iff g(s) in Hd(t). B = I + N, N_ts free exactly on incidences. Block j = columns whose tail lies in V_k u V_l. +(Two points share at most one label -- a net condition; not used below.) +tied_min: V has 6 vertices (the pairs of the 3 perfect matchings of K4), Hd(a) = 3 pairs containing a, tail of (a,k) = pair of M_k missing a. +Tight small members (all cost = v): K3 = one line per class, all six incidences (B = all-ones, ranks (1,1,1), v = 3); +one class with 4 lines on a 2-cycle of labels (ranks 0,2,2, v = 4); B0. + +## 2. Proved facts +**Lemma SC (single class).** If all n lines have one class (a loopless label digraph H, arc s : g(s) -> lam(s), incidence = line digraph: +t->s iff head(t) = tail(s)), then rank_F2(I+N) >= n/2 for every admissible N. Proof: order the labels; arcs with tailhead; one of the two has >= n/2 arcs. [] +So rank B[:,C_k] >= rank B[C_k,C_k] >= n_k/2. (sc.py: brute-force min rank over all N for 400 random small digraphs: never < n/2.) +**Theorem S2-1 (class-triangular).** If class-level incidences are acyclic in some class order (no incidence from a class-l point to a class-k line +for k= v: block j is block triangular on C_k u C_l, rank >= rank B_kk + rank B_ll >= (n_k+n_l)/2 by SC; sum over j gives v. (Includes "no cross-class incidence".) +**Rowspace identity.** W = rowspace(B) in F2^{C_0}+F2^{C_1}+F2^{C_2}. r_j = rho - w_j, w_j = dim{x in W : supp x in C_j}, rho = rank B. So cost = 3 rho - sum w_j. +**Polymatroid bound.** h(S)=rank B[:,C_S] is submodular, so 2 cost >= 3 rho + sum a_k (a_k = rank B[:,C_k]). (Recorded in PROOF 12.5 as giving only 9 on tied_min.) +**Hyperarc order.** X = {t : tail(t) < Hd(t)}, Y = {tail > Hd} are acyclic (tail strictly monotone along incidences), P(t in X)=1/4: rho >= v/4. +Per block (tails restricted to V_k u V_l, 3 distinct labels): 1/3 each, giving cost >= 2v/3 = exactly Theorem M1 reversed (c(t) = 2/3 for F2S). Nothing new. +**Monotonicity.** Taking B[S,S]: cost(config) >= cost(sub-configuration) for every line subset S. Hence for the general case "F2S + M1" does NOT reduce: +the F2S part gives |F2S| at best (if proved) and M1 only v/2 on the rest; no superadditivity across the split (cross terms can cancel). A reduction needs a separate +argument for lines with q full or p non-full; none found. + +## 3. Negative results (all exact, CaDiCaL via S2_scripts/gen.py, a multi-block rank-feasibility CNF) +* Principal version (rows restricted to the block's own columns, i.e. sum_j rank B[A_j,A_j]) has min 11 < 12 on tied_min (SAT at K=11). So rows of the third class are essential (as in 12.3(c)). +* Candidate Lemma X: 3 rho + sum a_k >= 2v. Tight at K3, at block-diagonal optima (rho 6, a 2,2,2) and at B0 (rho 4, a 4,4,4), but FALSE on tied_min: + (rho; a) = (5; 2,3,3) feasible, 3*5+8 = 23 < 24 (still cost >= 12 by integrality, 11.5 -> 12). Frontier of (rho, sorted a) on tied_min: + rho=4:(4,4,4); 5:(2,3,3); 6,7,8:(2,2,2). The three tight examples span only the line X, so NO linear inequality in (rho, sum a) can prove cost >= v, and the polymatroid bound is + intrinsically short; the proof needs an integer/rigidity step (as in 12.3(b),(c)). +* Random F2S configs (s2a, {+-1,+-2}, v 4-9) have cost >> v (tight ones need the special net structure), so random testing is uninformative; tightness lives on K3-like cliques, + 2-cycles of labels, and tied_min. +## 4. Data (S2_scripts/s2b.py: exact min cost of EVERY sub-configuration of tied_min) +Counts (cost -> #subsets), sizes 3..12: 3:{3:4,4:108,5:60,6:48}; 4:{4:51,...}; 5:{5:24}; 6:{6:94}; 7:{7:48}; 8:{8:63}; 9:{9:36}; 10:{10:18}; +11:{12:12 (all)}; 12:{12}. cost >= v for ALL 4095 subsets; many tight at every size <= 10 (size-11 subsets are strictly above: cost 12). +So (A) holds on every sub-quadrangle configuration, supporting a clean general F2S statement but not proving it. + +## 5. What a proof would need (suggested) +Strengthen Theorem S2-1 from class-level to piece-level: find an ordered partition of lines into pieces so cross-piece incidences go forward and each piece is +either a single-class (SC) or a "K3-clique" piece with a direct rank count; the obstruction is exactly tied_min where no such partition exists and the exchange (12.3 c) is needed. +Open: an exchange lemma replacing the SAT step 12.3(b) ("rank-3 block has unique filling"): in hyperarc language, a block of rank < (#columns)/2 forces S_k = S_l and vanishing on rows of the third class. + +# R2 follow-up (after PROOF 13): sum w_j <= 3 rho - v ? and Conjecture PP -- NOT proved; measurements + +* In F2S Lemma Peel is vacuous (|pi|=3, |sigma|=2) and SCC is automatic-compatible (pi cap sigma != {}). S2-1 (class-acyclic) is now just the SCC lemma applied + to a class-level order; SCC says WLOG every line has an incoming and an outgoing incidence, and the cross-class incidences are cyclic at class level. +* "sum w_j <= 3 rho - v" is literally (A) (cost = 3rho - sum w_j), so it cannot be easier by restatement. Data on tied_min (exact, S2 frontier): rho=4: w=0; + rho=5: a=(2,3,3), so sum w <= 3 (cost >= 12 needs 15 - sum w >= 12); rho>=6: w=(2,2,2) max. Equality sum w = 3rho - 12 at (4,0),(6,6); at rho=5 the slack is 0 or 1 only through + integrality, matching 13.2 (no per-class rowspace inequality). I found no proof of an upper bound on sum w_j; the obstruction is the same as in 12.5 (need joint rigidity of + low-rank blocks, 12.3(b)). Easy partial: w_j <= a_j-type bounds are useless since w_j <= rho - r_j is the definition. +* **Conjecture PP is FALSE as stated** (S2_scripts/pp.py, exact costs of all 4095 sub-configurations of tied_min, X in {same-point groups, same-line groups}, including singletons): + 272 of 4095 subsets have no X with cost(S) >= cost(S-X)+|X|; smallest failure v=2: lines (0,3) cost 2, and cost(single line) = 2 (a lone line costs 2, not 1), so deleting any group + gives 2 >= 2+|X| false. Failures also at v=3 (the K3 triangles, cost 3), and at every size up to 8 (counts by size 2:12, 3:4, 4:51, 5:24, 6:88, 7:48, 8:45); none at sizes 9-12. + The cause: excess cost-v is NOT monotone under deletion (a lone line has excess +1, the tight pair excess 0). Since PP is only needed on a minimal counterexample, a weaker + form (PP only for configurations with cost <= v-1, or PP with cost replaced by max(cost, |lines|)) is untested by me; as stated, groups X_P/Y_l, including whole same-point groups of size >=2, + fail 4084 times (strong form fails massively). +* So from the S2 side PP is NOT accessible as an induction; the data refute the plain statement. diff --git a/research/three-total-decoders/evidence/fleet-S3.md b/research/three-total-decoders/evidence/fleet-S3.md new file mode 100644 index 0000000000..9c0d900bcb --- /dev/null +++ b/research/three-total-decoders/evidence/fleet-S3.md @@ -0,0 +1,17 @@ +# S3 (adversary): no counterexample to (A) found, v <= 12 + +Method: S3_search.c (C, 1 process). Lines (p,q) with p,q primitive vectors in {-R..R}^3 (R = 1, 2), p(t).q(t) != 0. +B ranges over F2 matrices with unit diagonal and free entries on exact incidences p(t).q(s) = 0. +Cost = sum_j rank_F2 B[R_j,A_j] (no floor). The outer loop is a hill-climb on the configuration +(objective cost*1000 - #incidences, so it is pushed toward many incidences AND low cost, with occasional uphill moves). +The inner loop is simulated annealing over B, which gives an upper bound on the true minimum, so a refutation would show. + +Results (v = 5..12, R = 1,2, several hundred climbs of 3000-6000 mutations each, 4k-60k SA steps per evaluation): +- NO configuration with cost < v. Every climb ends at cost = v exactly (the floor), never below. +- Tight cases (cost/v = 1.000) reach 40-51 incidences at v = 9 (R=1) and 28-42 (R=2), so they are not just the trivial incidence-free case. +- Fano-type structure: P^2(Q) cannot hold the Fano incidence graph (needs char 2), so a whole F7 incidence pattern never + appears among p(t).q(s)=0 pairs; the search found nothing beating the floor. This is evidence, not proof, that no F7 minor is + usable inside a rank-3 block. +- Not done: joint Q-liftability of the optima for these random tight configs (no enumeration of all optimal B was run); LC was + not tested beyond what PROOF.md 12.7 records for tied_min. No LC counterexample found or looked for beyond the cost search. +- Caveat: SA is heuristic. It gives no UNSAT certificate; a cost < v with a hidden narrow basin could be missed. diff --git a/research/three-total-decoders/evidence/fprime-PROOF.md b/research/three-total-decoders/evidence/fprime-PROOF.md new file mode 100644 index 0000000000..036693af36 --- /dev/null +++ b/research/three-total-decoders/evidence/fprime-PROOF.md @@ -0,0 +1,561 @@ +# F' (T = 3 lower bounds) -- third prover, Oct 13 night + +Setting and notation as ../PROOF.md: lines t = (p(t), q(t)), pi = supp p, sigma = supp q, D(t) = pi cap sigma, +incidence t -> s iff p(t).q(s) = 0 (s != t); L8 certificate = labels a(t) subset pi(t), b(t) subset sigma(t), a set S with +|a(t) cap b(t)| odd on S, and an order on S in which every incidence t -> s inside S with |a(t) cap b(s)| odd points forward. +cost >= sum_j r_j >= |S| for every admissible B (L8). Scripts in this directory; python = intmult-work/venv/bin/python. + +## 0. Calibration on cex_min_1 (v = 19) + +| bound | value | script | +|---|---|---| +| D-types | {0,2}:5, {0}:4, {1,2}:3, {0,1}:3, {2}:2, {0,1,2}:1, {1}:1 (11 tied, 8 odd) | t_cex.py | +| MAS-sum sum_j MAS(G[D_j]) | 6+4+6 = 16 | t_cex.py (mas.c, exact subset DP) | +| Theorem P (e = 0) | 8 | (= # odd-|D| lines, see section 1) | +| max L8 certificate | 18 (OPTIMAL, explicit labels + order re-checked) | certsol.py | +| restricted certificate (section 2 label family) | 18 (OPTIMAL, re-checked) | restricted.py | + +MAS-sum (a rigorous cost bound: an acyclic X subset D_j makes B[X,X] unit-triangular) is not a route to F': a digon whose +two lines are both private to D_1 exists (p = (1,1,0), q = (1,0,1); p = (1,0,-1), q = (1,-1,0)), MAS-sum = 1 of v = 2, while +its L8 certificate is 2 (labels a = {1,2}, b = {1} ; a = {1}, b = {1,2}). + +## 1. The {-1,0,1} world: exact parity structure + +**Lemma 1.1.** If all entries of p, q lie in {-1,0,1}, then an incidence t -> s forces |pi(t) cap sigma(s)| in {0, 2}. +Proof: p(t).q(s) is a sum of |pi(t) cap sigma(s)| terms equal to +-1; an odd number of +-1 cannot vanish. [] + +So the canonical labels a = pi, b = sigma kill every incidence (K = 0 off the diagonal) and K_tt = |D(t)| mod 2: the lines +with |D(t)| odd (call them G) form an L8 certificate on their own (Theorem P at e = 0). The others have |D(t)| = 2: *tied*. + +**Lemma 1.2 (sign classes).** For a tied line with D(t) = {i,j}, M_tt = p_i q_i + p_j q_j != 0 forces p_i q_i = p_j q_j, so +eps(t) := p_i(t) p_j(t) = q_i(t) q_j(t) in {+1,-1} (invariant under p -> -p, q -> -q). Two tied lines t, s with the same +D = {i,j} and the same eps are never incident. Proof: p_i(t) q_i(s) + p_j(t) q_j(s) = eps p_j(t) q_i(s) (1 + 1) = +-2 (using +p_i(t) = eps p_j(t), q_j(s) = eps q_i(s)) and the third term is in {0, +-1}. [] +Checked: signclass.py (no violation of 1.1 or 1.2 on cex and on the 121-line pool). + +**Lemma 1.2' (unit world, halves).** More generally, call a configuration *unit* if for some e in Z^3 and some per-line +rational scalars lambda_t, mu_t, every nonzero entry of the rescaled vectors lambda_t 2^{e_k} p_k(t) and mu_t 2^{-e_k} q_k(t) +is a 2-adic unit (M changes only by row/column scalings, so supports, incidences and M_tt != 0 are unchanged). All +statements below are applied to the rescaled vectors. +Lemma 1.1 holds verbatim in the unit world (an odd number of odd numbers is odd). For a tied line with D(t) = {i,j} +(i < j) put alpha(t) = p_i/p_j, beta(t) = -q_j/q_i (rationals; alpha != beta because p_i q_i + p_j q_j = M_tt != 0, the +third product being 0 as k is not in D(t)). Split the class C_ij = {t : D(t) = {i,j}} into the halves +H^< = {alpha < beta} and H^> = {alpha > beta} (any total order of the SET Q works -- the argument below uses only the +exact equality alpha(t) = beta(s) and transitivity, never field compatibility; we use the usual one). +Claim: if t, s in C_ij and t -> s then alpha(t) = beta(s). Proof: pi(t) cap sigma(s) contains {i,j} and is even +(Lemma 1.1), so it is {i,j}; the k-th product p_k(t) q_k(s) is exactly 0 and p_i(t)q_i(s) + p_j(t)q_j(s) = 0. [] +Hence inside H^<, t -> s gives alpha(s) < beta(s) = alpha(t): alpha strictly decreases along incidences; inside H^>, +beta(t) < alpha(t) = beta(s): beta strictly increases. Each half is acyclic in G. (This is the T = 2 alpha/beta +argument run inside one class; in the {-1,0,1} world the halves are the sign classes eps = -1, +1 and are even +independent sets.) + +## 2. Theorem U (unit world: certificate >= |G| + |I|/2) + +**Theorem U.** Let the configuration be unit (Lemma 1.2'). Let G = {t : |D(t)| odd}, and for each of the three tied +classes C_01, C_02, C_12 let H_ij be either half (H^< or H^>). Then the L8 certificate is at least + |G| + |H_01| + |H_02| + |H_12|, +so, taking the larger half of every class, cost >= sum_j r_j >= |G| + |I|/2 >= v/2, I = all tied lines. +(Coordinate 0 plays a special role below; the three choices of the special coordinate give the same bound.) + +*Labels.* G: a = pi, b = sigma. H_02: a = pi - {0}, b = sigma ("A, delete 0"). H_01: a = pi, b = sigma - {0} +("B, delete 0"). H_12: if 0 in pi(t): a = pi - {2}, b = sigma ("A, delete 2"); otherwise a = pi, b = sigma - {2} +("B, delete 2"). Every label has |a cap b| = |D| - 1 = 1 on the tied lines: the diagonal of B o K is 1 on S. +*Order.* A_12 := {t in H_12 : 0 in pi(t)}, then H_02, then G, then H_01, then B_12 := H_12 - A_12; inside a half, +order by alpha decreasing (H^<) or beta increasing (H^>). Claim: every incidence t -> s inside S with +|a(t) cap b(s)| odd ("conflict") has t before s; then B o K[S,S] is unit upper-triangular for EVERY admissible B (L8). + +*Proof.* Write a(t) = pi(t) - d_A(t) and b(s) = sigma(s) - d_B(s) (d_A = the deleted coordinate for an A-line, empty set +otherwise; same for d_B). For an incidence t -> s, Lemma 1.1 gives |pi(t) cap sigma(s)| even, so + |a(t) cap b(s)| = [d_A(t) in sigma(s)] + [d_B(s) in pi(t)] + [d_A(t) = d_B(s)] (mod 2) (*) +(the last term only when t is an A-line and s a B-line: the deleted coordinate is then in pi(t) cap sigma(s)). +(i) No conflict leaves a non-A line toward a non-B line: all three terms of (*) vanish. So conflicts start in + A = A_12 + H_02 or end in B = H_01 + B_12; those from A to G or B and from G or A to B point forward. +(ii) Conflicts inside A: by (*), t -> s conflicts iff d_A(t) in sigma(s). + - t in H_02 (d_A = 0), s in A_12: sigma(s) = D(s) = {1,2} (0 is in pi(s) and not in D(s)), so 0 not in sigma(s): none. + - t in A_12 (d_A = 2), s in H_02: 2 in D(s) is in sigma(s): conflicts may occur; they point forward (A_12 first). + - t, s in the same half: incidences there are monotone in alpha (or beta), so they point forward in the half's order. +(iii) Conflicts inside B: t -> s conflicts iff d_B(s) in pi(t). + - s in H_01 (d_B = 0), t in B_12: pi(t) does not contain 0 (definition of B_12): none. + - s in B_12, t in H_01: may occur; forward (H_01 before B_12). + - same half: monotone, forward. +So all conflicts point forward and B o K[S,S] is unit upper triangular: rank |S|. [] + +*Checks* (exact rationals; certsol.check re-verifies labels, |a cap b| odd on S, and every conflict's direction): + - theoremU.py: cex_min_1 15/19 (|G| = 8, larger halves 7), 121-pool 106/121, and 3000 random unit configurations + (odd entries {+-1,+-3,5}, 4-80 lines, forced incidences, up to ~650 incidences each): all valid, worst ratio 2/3. + - stressU.py: 1800 tied-only configurations (entries {+-1,+-3,0}, 6-44 lines, 189k incidences in total): all valid, + worst ratio exactly 1/2 (the bound is attained by the scheme, not by the true certificate). Negative control: a + naive scheme (delete the smallest D-coordinate, no halves) is rejected by check() in 299/300 trials. + - Optimality of 1/2 *for this kind of scheme*: colgen.py / colgen3.py solve the minimax over all group-level schemes + (groups = (class, half, pi, sigma), options: A or B with either deleted coordinate, acyclic group digraph) by column + generation (CP-SAT pricing, HiGHS LP): the value is exactly 1/2 both with the exact {-1,0,1} incidence table + (groups.py, exhaustive over the 121 lines) and with the conservative unit-world table. So one-deletion schemes + cannot beat |G| + |I|/2 in the worst case; the true certificate on cex (18/19) uses more. + +## 3. What Theorem U does and does not give + + - cost and the L8 certificate depend only on the *combinatorial type* tau = (supports pi, sigma; incidence digraph). + So Theorem U bounds every decoder whose type has SOME unit realisation (over Q, or over any field with a valuation of + residue characteristic 2 -- the proof only uses parity of units and a total order on the field). (A type realisable + over a field of characteristic 2 has cost >= v outright: B o M = diag(M_tt) over that field.) + - It does not cover all rational decoders: a type can force 2-adic structure (von Staudt / harmonic constructions force + a point (1,2,0) next to (1,1,0), which no column rescaling makes simultaneously unit). For those, Theorem P handles + the odd lines at each e; the missing piece is the analogue of Lemma 1.2' when the third product p_k(t)q_k(s) is + even but NOT zero (section 4). + - Windows: v/2 would close D7 h>=18, D8 h>=18, E6 h>=18, E7 h>=17 (N(h) <= ceil(v/2)) -- but only once it holds for + all rational decoders; restricted to unit types it closes nothing on its own. + +## 4. Handoff: the general rational case (not attempted to completion) + +1. *Generic-e framework.* Take e in R^3 generic (realised in a ramified extension Q_2(2^{1/m}); residue field still F_2). + Then a(t) = argmin_k (nu p_k(t) + e_k) and b(t) = argmin_k (nu q_k(t) - e_k) are single coordinates for every line: an + "arrow" (a(t), b(t)). Lemma 1.1 (odd number of leading units) gives a(t) != b(s) on every incidence. G_e = diagonal + arrows (k,k); every other line is an off-diagonal arrow (i,j) (tied lines always are). A-repair a = {i,j} needs + j in pi(t); B-repair b = {i,j} needs i in sigma(t). By Lemma 1.1, A-conflicts occur only between A-lines with EQUAL + b-label, B-conflicts only between B-lines with EQUAL a-label. So a general theorem reduces to (a) a splitting lemma + "lines with the same arrow (and same support type) split into O(1) parts, each acyclic in G", then (b) the same + group-level minimax (colgen*.py) over (arrow, part, pi, sigma) groups. +2. *Template for (a): the T = 2 splitting.* With only coordinates i, j: put g(t) = (nu p_j + e_j) - (nu p_i + e_i) > 0 and + h(s) = (nu q_i - e_i) - (nu q_j - e_j) > 0. t -> s forces g(t) = h(s), and g(t) - h(t) = z_j(t) - z_i(t) + (z_k = nu(p_k q_k), independent of e). Dominant-i lines (z_i < z_j): g strictly increases along incidences; dominant-j + lines: h strictly decreases; tied lines (z_i = z_j): g is constant along incidences, so each level set is a unit-world + problem and Lemma 1.2' (alpha/beta halves) orders it. With three coordinates the incidence condition is "the minimum + of nu(p_k(t) q_k(s)) is attained exactly twice" and the third product can be even but nonzero; the 2-adic-digit + version of the alpha/beta argument then needs nu(p_k(t) q_k(s)) > nu(alpha(s) - beta(s)), which is e-independent + and can fail. That digit lemma is the first missing piece. +3. *e-selection obstruction.* Any single-e argument gives a bound of the form max_e(...). Unrepairable arrows (e.g. + pi = {i,l}, sigma = {j,l}, arrow (i,j)) occupy cones of e-space with arbitrary apexes, which can cover all of it; and + full-support tied lines (e.g. p = (1,1,1), q = (1,1,2)) are never in G_e nor e-unit for any e, so the general form + of Theorem U, cert >= max_e (|G_e| + |T_e|/2) (T_e = tied lines that are unit at e), bounds a configuration made of + them by 0. Yet the true certificate is v there (fulltied.py: 12/12 random such configurations, 10-18 lines, cert = v). + Quantified (gap.py, 20 random non-unit configs, entries {+-1,+-2,+-3,4,0}, 10-16 lines, e in {-2..2}^2): + max_e(|G_e| + |T_e|/2) / v ranged 0.50-0.88, while the true certificate was v in all 20. So in the general case + the certificate's strength comes from mixed labels across scales, not from one reduction; a proof needs an + e-selection (or multi-scale) argument on top of the digit lemma. + +## 5. Status of the targets + + - (A) cost >= v: untouched. On cex_min_1, cost is still known only to lie in [18, 23] (L8 certificate 18; best B found 23). + - (B) F': proved with c = 1/2 for unit types (Theorem U); open in general. c = 2/3 needs labels beyond one deletion even + in the unit world (minimax = 1/2 exactly for one-deletion schemes). + - (C) not attempted (root-system SAT route belongs to ../PROOF.md section 4). + - Windows closed: none. + +## 6. Continuation (general rational case) + +**6.1 Gap 1 is false as posed: no "halves" lemma exists for non-unit tied classes.** The lines +p = (3,-1,-6), q = (1,-1,-2); p = (-1,7,-4), q = (-3,3,-2); p = (1,1,0), q = (23,9,10) +are all tied with Z = {0,1} (z = (0,0,2), (0,0,3), (0,0,inf)), so they lie in class {0,1} at every scale where they are +I_2. Each line passes through the other two points: G is the complete digraph on 3 vertices, so the class cannot be split +into 2 acyclic parts by ANY rule (k3class.py found 3 such triangles among 200k random small-integer triangles). Their +true certificate is 3 (certsol.py), using labels on coordinate 2, i.e. labels from another scale. So the general case +needs labels that mix scales; a single-scale digit lemma cannot exist. + +**6.2 Lemma (private lines; any field, rigorous).** Let P_j = {t : D(t) = {j}}. Then + MAS(G[P_j]) >= #(I) + #(II) + ceil(#(III or IV)/2), +where, writing k, l for the other two coordinates: I = {p_k = p_l = 0} (sinks: p(t) = E_j, which is on no line of D_j), +II = {q_k = q_l = 0} (sources), III = {p_k = 0, q_l = 0}, IV = {p_l = 0, q_k = 0}. +Proof: III -> III has p(t).q(s) = p_j q_j != 0, so there are no such edges, and likewise IV -> IV. III t -> IV s iff +p_l(t)/p_j(t) = -q_j(s)/q_l(s), and IV s -> III t iff p_k(s)/p_j(s) = -q_j(t)/q_k(t). So G[III + IV] is the line digraph of +the bipartite digraph Gamma_j whose vertices are the values on two copies of Q*. Here III t is the arc +(-q_j/q_k)(t) -> (p_l/p_j)(t) and IV s is the arc (-q_j/q_l)(s) -> (p_k/p_j)(s), and t -> s iff head(t) = tail(s). A set +of arcs induces an acyclic subdigraph of a line digraph iff it contains no closed walk, so for any linear order of the +vertices of Gamma_j, the forward arcs or the backward arcs (at least half) qualify. Sources and sinks can be added +to any acyclic set. [] +Hence cost >= sum_j MAS(G[D_j]) >= sum_j MAS(G[P_j]) >= |P|/2 for every decoder, over any field. +Check: private.py, 400 random private-only configurations (entries {+-1,+-2,3,0}, 6-15 lines): 0 violations, 34 tight. + +**6.3 Two-shared lines.** For S_12 = {t : D(t) = {1,2}} (so p_3 q_3 = 0), an incidence t -> s is "tame" (third product +0, so alpha(t) = beta(s) exactly, as in the T = 2 argument) whenever p_3(t) = 0 or q_3(s) = 0. The four sets +{alpha < beta or alpha > beta} x {p_3 = 0, or q_3 = 0 and p_3 != 0} contain only tame edges, so each is acyclic and +MAS(G[S_12]) >= |S_12|/4. Since S_12 lies in both D_1 and D_2, these lines alone contribute >= |S_12|/2 to the MAS-sum. + +**6.4 Conjecture M (MAS-sum >= v/2) and its char-2 obstruction.** Conjecture: sum_j MAS(G[D_j]) >= v/2 for every +rational T = 3 decoder. This is field-sensitive and would give cost >= v/2 (closing D7, D8 and E6 h >= 18, and +E7 h >= 17). +Evidence: +- 6.2 and 6.3 handle private lines and each two-shared class separately; what is missing is the interaction between + classes inside one D_j, and full-D lines, which need weight 1/6 per D_j. +- Hill-climb searches (massrch.py) found minima of 5/8 and 6/9 (pool {-1,0,1}) and 8/10 (pool {-1,0,1,2}). +- The natural way to go below 1/2 fails exactly in characteristic != 2. The gadget is one full-D line x forming a + triangle with a private III/IV digon in each of D_1, D_2, D_3, so MAS-sum = 3 on 7 lines. This forces p(x)'s three + traces (0,x2,x3), (x1,0,x3), (x1,x2,0) onto the line l(x). Their determinant is -2 x1 x2 x3 (sympy), so they are + collinear only in characteristic 2 (Fano), the same obstruction as for cost < v at T >= 7. +A proof needs (i) a weighted version of 6.2 and 6.3 inside one D_j (an acyclic-set distribution covering private lines +with probability >= 1/2, two-shared lines >= 1/4 and full-D lines >= 1/6) and (ii) bounded fractional dichromatic number +(<= 6) for full-D incidence digraphs. (ii) is plausible: a complete digraph on 3 vertices gives 3, and fullmas2.py +found MAS/v = 1/2 at its worst. + +**6.5 Where the obvious weighted version of 6.2 and 6.3 stops.** Fix D_1 and normalise p_1 = q_1 = 1. Put +PT(t) = {k in {2,3} : p_k(t) != 0} and LT(s) = {k : q_k(s) != 0}. An incidence t -> s uses the terms PT(t) cap LT(s), +which is nonempty. Each family F_k^p = {PT = {k}} and F_k^q = {LT = {k}} has only coordinate-k ("tame") edges, so it is +a T = 2 structure: sources, sinks and two acyclic halves. Private lines are sources or sinks in both families that +contain them (coverage 1/2, which is how 6.2 arises). But a line with |pi| = 2 and sigma = [3] lies in one family per D_j +it belongs to. The six resulting constraints P_1(F_2^p) + P_2(F_1^p) >= 1, ... use every family probability exactly +once (total 3 < 6). So tame families cover such lines only with weight 1/4 in total, and MAS-sum >= v/2 needs acyclic +sets that contain wild edges. In D_1, the lines of these types form a "one head, two tails" digraph: each t has a head +(c(t), -1/u_c(t)) and tails (2, w_2), (3, w_3), and t -> s iff head(t) is a tail of s. A random vertex order gives +MAS >= 1/3 there, and complete digraphs on 3 vertices are impossible (they would need three distinct coordinates in +{2,3}). Whether 1/2 holds for this digraph class is the next concrete question. + +## 7. Theorem M1: cost >= v/2 when no point has full support (any field) + +**Theorem M1.** If every point p(t) has a zero coordinate (|pi(t)| <= 2 for all t), then + cost >= sum_j r_j >= sum_j MAS(G[D_j]) >= sum_t c(t) >= v/2, +where c(t) = |D(t)| / C(|pi(t)|+|sigma(t)|-2, |pi(t)|-1). The same holds if every line q(s) has a zero coordinate +(|sigma(s)| <= 2): reverse all edges. It holds over every field, and v/2 is sharp: a configuration of private +digons (section 0) has MAS-sum exactly v/2, and its certificate is v, so MAS-sum is the weak link there. + +*Proof.* Fix j and a chart: for t in D_j put x_k(t) = p_k(t)/p_j(t) and y_k(t) = q_k(t)/q_j(t) (k != j). Let +V = {(k, c) : k != j, c in F*}, a set of "vertices". Give t the vertices xi_k(t) = (k, -1/x_k(t)) for +k in pi(t) - {j} and eta_k(t) = (k, y_k(t)) for k in sigma(t) - {j}. +(a) Edges are vertex coincidences. For t, s in D_j, pi(t) cap sigma(s) contains j and is not {j} (a single nonzero + product cannot vanish). Since |pi(t)| <= 2 it equals {j,k} with pi(t) = {j,k}, and + p(t).q(s) = p_j(t) q_j(s) (1 + x_k(t) y_k(s)). So t -> s iff xi_k(t) = eta_k(s). +(b) A line's vertices are distinct. Different coordinates give different vertices. xi_k(t) = eta_k(t) would give + p(t).q(t) = 0, because pi(t) = {j,k}. +(c) Random order. Order V uniformly at random and let X_j = {t in D_j : every eta-vertex of t precedes every + xi-vertex of t}. Along an edge t -> s inside X_j, the vertex xi_k(t) = eta_k(s) precedes every xi-vertex of s. + So the earliest xi-vertex strictly increases along edges, X_j is acyclic, and B[X_j, X_j] is unit triangular. + By (b), P(t in X_j) = 1 / C(m_xi + m_eta, m_xi), with m_xi = |pi(t)| - 1 and m_eta = |sigma(t)| - 1. +(d) Summing E|X_j| over j: line t contributes |D(t)| / C(...). Going through the cases with |pi| <= 2: + - |pi| = 1, or |sigma| = 1: contribution >= 1; + - |pi| = 2, |sigma| = 2: 1/2 each, so 1/2 if |D| = 1 and 1 if |D| = 2; + - |pi| = 2, |sigma| = 3: D = pi, so 2 x 1/3 = 2/3. + Every line contributes >= 1/2, and for each j some order attains at least the expectation. [] +Check: thmM1.py, 300 random configurations with every point having a zero coordinate (6-14 lines, dense forced +incidences, entries {+-1,+-2,3,0}): MAS-sum >= sum c(t) in all of them, sum c(t) >= v/2 asserted. +Lemma 6.2 (private lines) is the case |pi|, |sigma| <= 2 inside one D_j. + +**What blocks the general case (precise).** The only edges not of form (a) are *wild*: t -> s with +pi(t) = sigma(s) = [3] (a full-support point on a full-support line), where 1 + x_2(t) y_2(s) + x_3(t) y_3(s) = 0. +Three kinds of lines are affected: +- B = {|pi| = 3, |sigma| <= 2}, the sources of wild edges; +- A' = {|pi| <= 2, |sigma| = 3}, their targets; +- F = full-support lines, which are both. +Excluding B or A' per chart (randomly) still gives MAS-sum >= (1/2)|others| + (1/3)|A' + B|. This is a valid bound +whenever F is empty, but it is below v/2. F needs a lower bound on MAS for general point-line incidence digraphs +(fraction 1/6 per chart would do; a complete digraph on 3 vertices gives 1/3). So the next step is a potential +for wild edges. For example, with all x_k > 0 > y_k a wild edge t -> s gives eta_k(s) < xi_k(t) in value for both +k, which matches the order of tame edges under the rule "xi before eta" (max xi strictly decreases along both +kinds of edge). Sign patterns therefore look like the right way to split. + +## 8. Attempts to remove the hypothesis of Theorem M1 (negative, exact) + +- *Sign-order potentials for wild edges* (signlp*.py). If a wild source t has both xi_k(t) > 0 (after per-coordinate sign + flips) and the vertex order is by value, then every wild edge t -> s has some k with eta_k(s) < xi_k(t): write + r_k = eta_k(s)/xi_k(t), so r_2 + r_3 = 1 and some r_k < 1. So the rule "all xi before all eta" stays acyclic on wild + edges too. The LP below allows 16 orders per chart: sign flips, extreme interleavings of the two coordinates, and + forward or reversed (p <-> q) mode. Over all line sign-types (124 found by sampling): + - optimum coverage = 0. The full-support lines whose three products p_k q_k share a sign are never covered: their + xi and eta have opposite signs in every coordinate, so safety and the rule clash. + - Without full-support lines (p and q both full): optimum 5/16 < 1/2. + So value-order potentials cannot give v/2 in general; wild edges need a block-rank argument. +- A trivial general corollary of M1: M1 on {|pi| <= 2} and its reverse on {|sigma| <= 2} give cost >= (v - |F|)/4, + where F = lines with p and q both of full support. Too weak for any window. +- Useful structural fact for the next attempt: with the support labels a = pi, b = sigma, K_ts = |pi(t) cap sigma(s)| + mod 2 is 0 on every tame edge and 1 on every wild edge. So the L8 sum and the MAS-sum kill complementary edge + classes, and a hybrid (sums of 2 blocks plus a single block) is the natural next object. + +## 9. The multi-copy certificate (MCC) -- strictly stronger than L8; cost(cex_min_1) >= 20 > v + +**Lemma MC.** Take any finite family of *copies* (t, c) of lines. Give each copy labels a(t,c) subset pi(t) and +b(t,c) subset sigma(t), with |a(t,c) cap b(t,c)| odd. Order the copies so that every pair (t,c) != (s,c') with +|a(t,c) cap b(s,c')| odd and (t -> s an incidence, or t = s) is forward. Then cost >= sum_i r_i >= #copies. +Proof: let U_i[(t,c), t] = [i in a(t,c)] and V_i[s, (s,c')] = [i in b(s,c')]. Then +N := sum_i U_i B[R_i, A_i] V_i has entries N[(t,c),(s,c')] = B_ts |a(t,c) cap b(s,c')| (mod 2), so rank N <= sum_i r_i. +B_ts != 0 only on the diagonal and on incidences, and B_tt = 1, so N is unit upper triangular in the given order. [] +L8 is the one-copy case. MAS-sum is the case of copies (t,j), j in D(t), with a = b = {j}: copies with different j +never interact. So MCC >= max(L8 certificate, MAS-sum), and Theorem M1 and Theorem U are both MCC bounds. + +**cex_min_1: MCC = 20 (CP-SAT OPTIMAL, up to 3 copies per line; mcc.py).** The solution was re-verified by an +independent checker (verify() in mcc.py: label supports, odd diagonals, every odd entry on an incidence or same-line +pair is forward). The solution is saved in mcc_cex_min_1_solution.json. Hence **cost(cex_min_1) >= 20 >= v = 19**. +This refutes cex_min_1 as an obstruction to (A): it was only an obstruction to the one-copy certificate. +Sanity check: the private digon has MCC = 2 = v (its MAS-sum is 1). +More MCC data (all verified by verify()): +- 8 random {-1,0,1} configurations (9-14 lines, 22-62 incidences): L8 = v in each; MCC = v+1 to v+5 (OPTIMAL). + Script: mcctest.py. +- 121-line pool: MCC >= 119 with 2 copies per line (FEASIBLE; two 9.5-min runs with different seeds; bound 164). + L8 gives 115, so the pool is not yet shown to have cost >= v. +- Direction this points to: **Conjecture MCC: MCC >= v for every rational T = 3 configuration.** It would give (A). + It is a finite, checkable object per configuration. + +**Heuristic warning about pure-MAS routes (not proved).** Look at full-support configurations, where MAS-sum is +3 MAS(G) and G is an arbitrary point-line incidence digraph after a generic projective change. Take v grid points +and v lines with Szemerédi–Trotter-extremal incidence counts (average degree ~ v^{1/3}). If these digraphs behave +randomly, MAS(G) is ~ v^{2/3} log v = o(v), so Conjecture M (6.4) would fail asymptotically. The only general lower +bound I have there is the hyperarc order argument, 1/(k+1) per line with k = number of used lines through its point. +So a general v/2 must use the F_2 / 2-adic label part of MCC (Theorem P-type copies) for full-support lines, together +with M1-type chart copies for the rest. The interaction between the two kinds of copies (conflicts [j in a(t)] in both +directions) is the open step. + +## 10. Per-scale 2-adic multi-copy certificate (rmcc.py, rmcc_run.py; all solutions re-verified by mcc.verify) + +Each line gets one copy per scale e in E, labelled with the 2-adic reductions at e +(a = argmin_k nu(p_k) + e_k, b = argmin_k nu(q_k) - e_k); identical copies are merged. +- 'canon': these labels only. +- 'rep': also one-sided repairs at that scale (a' subset pi with |a' cap b| odd and b kept, or the mirror). +- 'target': adds, for every non-tied line, a (possibly half-integral) scale inside its good box. + Tied lines have no scale at which they are non-isotropic. +E1 = {0,1}^3 - {(1,1,1)} (the 7 classes mod the all-ones vector); E2 = {0,1,2}^3. + +| instance | v | L8 | canon E1 | rep E1 | rep+target | unrestricted MCC | +|---|---|---|---|---|---|---| +| cex_min_1 | 19 | 18 | 8 (opt; E2 also 8) | 20 | 20 | >= 20 (opt 20) | +| gap-1 triangle | 3 | 3 | 0 (opt; E2 also 0) | 3 (opt) | 3 | 3 | +| 121-pool | 121 | 115 | 91 (= |G|) | 119 | -- | >= 119 | +| 10 random {-1,0,1}, v 9-12 | | = v | 4-10 (< v in 10/10) | v+1..v+5 | same | equal to rep in 10/10 | +| 9 random {-2..2}, v 8-12 | | = v | 11-14 (>= v in 9/9) | v+3..v+7 | same | equal to rep in 9/9 | + +(rep/MCC values on the random sets are best-found within 30-60 s, mostly FEASIBLE rather than proved optimal; canon +values are OPTIMAL. The 10th {-2..2} instance was cut by the 10-min cap.) + +Reading: +- The pure 2-adic derivation fails exactly on tied (unit-world) lines. Those are isotropic at every scale, so the + smallest failing instance is a single tied line, e.g. p = q = (1,1,0): canon = 0, v = 1. On non-unit data + ({-2..2}) canon alone already reaches >= v. +- With one-sided repairs per scale, the restricted certificate matches the best unrestricted multi-copy value on + every instance tried, and is >= v everywhere except the pool. On the pool it is 119 < 121, open: neither solver + proved a bound. +- So the multi-scale object that would need a proof is "Theorem P at every scale, plus one-sided repairs, with copies + of different scales ordered together". Theorem P (one scale) and Theorem U (unit world, repairs + halves) are its + one-scale cases. The missing formal step is ordering across scales. A conflict between copies at scales e != e' + needs |a_e(t) cap b_e'(s)| odd on an incidence, and Lemma 1.1 says nothing about mixed scales. + +## 11. Toward "cost >= v" (Oct 14): what the cross-scale lemma can and cannot be + +**11.1 The per-scale 2-adic labels are inert on exactly the lines that matter.** Canonical per-scale labels give |G| +(cex 8, pool 91) and 0 on tied lines, at every scale (§10). A tied line is isotropic at every scale, so its +reductions have even |a cap b| everywhere. Every gain to >= v comes from the one-sided repairs, i.e. from one free side. +So a cross-scale ordering lemma *for reductions* would formalise the part that contributes nothing. The object that +needs a proof is a label-and-order scheme for tied lines that uses their real alpha/beta values (Theorem U does half). + +**11.2 Proven ceiling: group-level schemes stop at 1/2, even with copies (unitmc.py).** In the unit world, let a +scheme give each group a list of copies with labels. The groups are (pi, sigma) for odd |D|, and (pi, sigma, half) for +tied lines, with clusters (D, half). Multiple copies per line are allowed, ordered so that a later copy sends only even +entries back to an earlier one. Cross-cluster conflicts are allowed only along an acyclic cluster order. Incidence +between groups is "possible iff |pi(g) cap sigma(h)| is even" (Lemma 1.1). Column generation (CP-SAT pricing, exact +LP) gives c* = 1/2 exactly. The dual is supported uniformly (weight 1/6 each) on the six groups pi = D of size 2, +sigma = [3], all three classes, both halves. So any rule of the form "scale order, then within-scale order", which in +the unit world is a function of (pi, sigma, half), cannot prove MCC >= v. It is capped at 1/2 on that obstruction. + +**11.3 The obstruction world W (pi = D of size 2, sigma = [3]).** +- Every incidence there is tame: t -> s iff head_{pi(t)}(t) = tail_{pi(t)}(s) in P^1 of the pair pi(t). +- Theorem M1 applies and gives MAS-sum >= 2v/3. +- Exact data (obst2.py, 8 random {-2..2} instances): MAS-sum >= v in all of them, MCC = v to v+1. Hill-climbing + (obstclimb.py, v = 10, entries {-3..3}) found minimum MAS-sum / v = 1.0 exactly. +- So in W the target is the purely combinatorial statement MAS-sum >= v, with no labels needed. +- It does NOT hold chart by chart. In chart 1 the data (head, tail_12, tail_13) are three independent values, and + abstract one-head-two-tails digraphs reach MAS/n = 0.4 (headtails.py). So a proof must use the coupling between + charts: tail_23 = tail_13 / tail_12. + +**11.4 Pool status.** Unrestricted MCC on the 121-line pool: 119 (C = 2, two seeds), and a C = 3 run with that +solution as hint is in progress. Upper bound on the pool's cost by simulated annealing: 183 (uninformative). Random +25-45-line sub-pools all have L8 = v, so they cannot separate. Structured sub-pools are being tested (subtypes.py). + +**11.5 Refutation of the certificate route to (A): the 12-line tetrahedral configuration.** +tied_min.json: the 4 full-support points p = (1,+-1,+-1), each paired with the 3 two-support lines q among +(0,1,+-1), (1,+-1,0), (1,0,+-1) that miss it. So there are 12 lines, all tied (|D| = 2), with 72 incidences. It was +found by greedily shrinking the 30 tied lines of the 121-pool while keeping MCC < v (shrinkmcc.py). +- L8 certificate = 11 (OPTIMAL). +- Multi-copy certificate = 11 with 1, 2, 4 and 6 copies per line (all OPTIMAL; solutions re-verified). +- True cost = 12 = v, from two independent exact solvers: + - actualcost.py (CP-SAT) gives OPTIMAL 12; + - costsat.py (pure CNF, Tseitin XOR chains, CaDiCaL) is UNSAT for every rank split with r_1 + r_2 + r_3 = 11, and SAT + only at (4,4,4) for sum 12. +Consequences: +- (A) holds here, with equality. +- No certificate of the multi-copy kind can prove it: MCC = 11 < 12 = cost. That kind includes L8, MAS-sum, + Theorem P, Theorem U and the per-scale 2-adic copies with repairs, so it includes every cross-scale ordering lemma + for them. +- **The cross-scale lemma requested on Oct 14 cannot exist in a form that yields cost >= v.** +- The same deficit shows in the 30 tied lines of the pool (MCC = 27 OPTIMAL with up to 4 copies, v = 30), and very + likely explains the pool's 119 < 121. +- A proof of (A) must see genuine F_2 rank, not a single triangular minor of sum_j U_j B_j V_j with + copy-type U_j, V_j. +- Next certificate class to test: general F_2 matrices U_j, V_j, i.e. arbitrary row and column combinations inside + each block. On the 12-line configuration, the optimum (4,4,4) means each block has rank exactly 4 at the minimum. + +## 12. Why cost(tied_min) = 12 is forced, and the second-order lift framework + +**12.1 Structure of tied_min.** Points: the 4 vertices a of K4, realised as (1,+-1,+-1). Classes k = 0,1,2, one per +missing coordinate of q, i.e. one per perfect matching M_k of K4. Line (a,k) has point a and the class-k q-line that +misses a. Every block row set R_j is everything, since points have full support. Block j consists of the columns +of the two classes k != j: block j = S_k + S_l, where S_k is the span of the class-k columns. Entry (row (x,c), +column (b,k)) is free iff x lies in the pair of M_k not containing b; the diagonal is 1; everything else is 0. Rows of +class j have no diagonal entry inside block j. + +**12.2 Exhaustive optimum structure (enumW.py, anaB.py; CaDiCaL with blocking clauses, run to exhaustion).** There +are exactly 217 matrices B of cost 12, all with block ranks (4,4,4). +- 216 = 6^3 of them are class-block-diagonal: only same-class entries are used, and each 4x4 class block + [[I,U],[V,I]] has rank 2. So the S_k have disjoint row supports and cost = 2 sum_k dim S_k = 12. +- 1 of them, B0, uses 24 cross-class entries and has rank 4 with S_0 = S_1 = S_2 = W: cost = 3 dim W = 12. + +**12.3 Proof that cost(tied_min) >= 12 (computer-assisted in step (b) only).** +(a) Every block has rank >= 3: MAS(G[D_j]) = 3 gives a unit-triangular 3x3 principal minor. +(b) A block of rank exactly 3 has a unique filling of its 8 columns (rank3.py, exhaustive SAT enumeration, the same + for j = 0, 1, 2). In it dim S_k = dim S_l = dim(S_k + S_l) = 3 (so S_k = S_l =: U), and every class-j row is 0 in + those columns. +(c) Exchange. If block j has rank 3, each other block contains class j and one of k, l, say S_j + S_l = S_j + U. + U vanishes on the class-j rows T_j. The projection of S_j onto T_j is B[T_j, C_j] = [[I_2, *],[*, I_2]], whose + rank is >= 2 (the two identity blocks sit in different rows and columns of each pair). So + dim(S_j + U) >= rank B[T_j, C_j] + dim U >= 2 + 3 = 5. +(d) So either all blocks have rank >= 4, giving cost >= 12, or some block has rank 3 and cost >= 3 + 5 + 5 = 13. [] +Cross-checks: costsat.py gives UNSAT for every split with sum 11, and the only SAT split at 12 is (4,4,4). The SAT +splits at 13 are exactly the permutations of (3,5,5) and (4,4,5), as (c) predicts. + +**12.4 The second-order (mod 4) lift framework (recorded; not by itself a proof tool).** +- For any F_2 rank factorisation B_j = U V^T and integer lifts U + 2X, V + 2Y, the matrix + N = sum_j D(p_j)(U+2X)(V+2Y)^T D(q_j) has rank_Q N <= sum_j r_j. +- On tied unit lines N = Delta + 2W. Halving the tied rows gives + N' mod 2 = diag(M_tt/2 mod 2) + sum_j Cbar_j. +- Cbar_j ranges over a coset of the tangent space {X V^T + U Y^T}. Its class is the linking form + phi_j(x,y) = (x^T B_j y)_Z / 2 mod 2 on (left kernel) x (right kernel). If every phi_j vanishes, N' = I and + cost >= v. +- This framework subsumes L8 and the multi-copy certificate. Generic rank over a large unramified extension is the + right invariant. +- But for a FIXED B, "some lift has rank v" is equivalent to sum r_j >= v (generic lifts give min(v, sum r_j)). So + it only becomes a proof tool through a B-independent argument on the coset family. +- On the 217 optima of tied_min the linking forms are mostly nonzero (rank 1-2 per block), so vanishing forms are not + the mechanism there. + +**12.5 Further evidence and failed general routes.** +- *F2S class* (full-support points, two-support lines; tied_min is its sharp member). 30 random {-2..2} F2S + configurations with 8-13 lines and 20-66 incidences (f2stest.py): exact "cost <= v-1" is UNSAT for every rank split + in all 30 (CaDiCaL), so cost >= v in all of them. MCC there is v+2 to v+8 (OPTIMAL). tied_min is special: it is + the complete quadrangle against its own diagonal triangle (quads.py regenerates it from (a,b) = (1,1)). +- *Induction by deleting a line fails.* Call a line rank-critical for B if deleting its row and column lowers some + block rank. If every B had one, (A) would follow by induction. Among 1117 low-cost B on tied_min (splits (4,4,4), + (3,5,5), (4,4,5), (5,5,5)), 850 have no rank-critical line (critical.py). +- *Per-class principal bounds fail.* The polymatroid bound 2 cost >= 3 rank B + sum_k dim S_k gives only 9. The + principal 2-class minor can have rank 3 < 4. The inequality cost >= sum_j mr_j + (1/2) sum_{i != j} dim(S_i cap K_j) + (from the projection in 12.3(c)) is tight at both optimum types of tied_min. A general lower bound + sum_{i != j} dim(S_i cap K_j) >= v - 2 sum mr_j is what it would take; it is not proved. + +**12.6 Exact-cost tool and current values.** costsat2.py decides "cost <= K" with ONE CNF: per-block factorisations +with activity-ordered columns, plus a cardinality bound on the active columns (CaDiCaL). Every SAT answer comes with a +B whose block ranks are recomputed by independent F_2 elimination. +- tied_min: K = 11 UNSAT, K = 12 SAT (4,4,4), in about 1 s. This is a third independent confirmation of cost 12. +- cex_min_1 (v = 19): cost <= 22 (SAT, verified ranks (10,6,6)); MCC gives cost >= 20. K = 21 and 20 were pending at + the time of writing. +- 30 tied pool lines: cost <= 30 (split (10,10,10) SAT); MCC gives >= 27. "cost <= 29" was not decided in 25 min. + +**12.7 Liftability of the optima (L7 view).** +- All 216 class-block-diagonal optima of tied_min lift to Q with the same support and the same block ranks: each + class block [[I,U],[V,I]] with UV = I over F_2 lifts with signs. +- The special optimum B0 also lifts: a +-1 assignment on its support gives Q-ranks (4,4,4) (liftB0.py). +- So on tied_min the F_2 optimum is attained by Q-realisable sign patterns, and L7 explains cost >= v there. +- Natural structural conjecture behind (A): *some cost-minimising B is jointly Q-liftable.* It is false at T >= 7 + (Fano-type F_2 cancellation), so a proof must use T = 3, i.e. rank 3 / P^2 geometry. + +## 13. Math-lead notes (Oct 14 midday): reductions valid for every configuration + +**Lemma SCC (strong components).** Let H be the digraph t -> s (t != s) with p(t).q(s) = 0 and +pi(t) cap sigma(s) != {} (exactly the incidences that land inside some block; incidences with +pi(t) cap sigma(s) = {} never appear in any block). Order the strong components of H topologically. Then every +block B[R_j, A_j] is block upper triangular in that order for EVERY admissible B, so +cost(config) >= sum over strong components C of cost(C). Hence (A) needs only be proved for configurations whose +H is strongly connected. (scc.py checks the triangularity on 500 random configurations. tied_min and cex_min_1 are +each one strong component, of sizes 12 and 19.) +Proof: an entry (t,s) of a block that can be nonzero has t = s or t -> s in H, and then comp(t) <= comp(s). A block +upper-triangular matrix has rank >= the sum of the ranks of its diagonal blocks, and the diagonal block of +component C in block j is exactly block j of the sub-configuration C. [] + +**Lemma Peel (unit rows).** If |pi(t)| = 1 (or |sigma(t)| = 1), then cost(config) >= cost(config - t) + 1. +Proof: say pi(t) = {j}. Then t lies only in R_j, and t is in A_j because M_tt != 0. For s in A_j, +p(t).q(s) = p_j q_j(s) != 0, so row t of block j is the unit vector e_t, and rank B_j = 1 + rank(B_j minus row t and +column t). Deleting column t from the other blocks does not raise their ranks. [] +So (A) also reduces to configurations where every point and every line has at least two nonzero coordinates. + +**F2S rowspace identity (cf. fleet/S2.md).** If every point has full support (R_j = all lines), let +W = rowspace(B), rho = dim W and w_j = dim(W cap F_2^{C_j}). Then cost = 3 rho - sum_j w_j >= 2 rho. So in F2S, (A) +holds for every B with rank_F2 B >= v/2. On tied_min both optimum types are tight in different ways: +- block-diagonal: rho = 6, w = (2,2,2); +- B0: rho = 4, w = (0,0,0). + +**13.1 Framing: (A) is a coupled Haemers-minrank comparison between F_2 and Q.** +- For a digraph D, minrk_F(D) is the least rank of an F-matrix with nonzero diagonal and zeros off the arcs (Haemers; + this is the linear index-coding optimum). +- Here block j is a matrix of exactly that kind for the digraph of incidences inside block j. cost is a *sum* of + three such ranks with the free entries *shared* between blocks, since an incidence t -> s sits in every block of + pi(t) cap sigma(s). +- Lemma B says the Q-version of this coupled sum is >= v. +- (A) says F_2 cannot do better. For single digraphs, F_2 minrank can be far below the real minrank + (Lubetzky-Stav 2009, "Non-linear index coding outperforming the linear optimum": field-dependent minrank gaps). So + (A) cannot follow from minrank theory alone; it must use the P^2 incidence structure (K_{2,2}-freeness L6, no + transitive 4-tournament L3, cliques meet all totals L4) and the coupling. +- tied_min shows the coupling is essential: the three decoupled F_2 minranks sum to 3+3+3 = 9 < 12. The T >= 7 + failures are the coupled analogue of a Lubetzky-Stav gap, of Fano type. + +**13.2 F2S exact decomposition, and three natural lemmas that are FALSE (adversarial annealing, exact F_2 ranks).** +Take W = rowspace(B), W_j^0 = W cap F_2^{C_j} (w_j = dim), U = W_0^0 + W_1^0 + W_2^0 (a direct sum) and +rho' = rho - sum w_j = dim W/U. Then exactly + cost = 3 rho - sum w_j = 2 sum_j w_j + 3 rho'. +- Block-diagonal optima of tied_min: w = (2,2,2), rho' = 0. +- B0: w = 0, rho' = 4. +With a_j = rank B[:, C_j] <= w_j + rho' this gives cost >= sum_j (a_j + w_j). Natural sufficient lemmas, each +checked by annealing over B (lemmaN.py, lemmaNsum.py, lemmaN2.py), all FALSE by exactly 1 on small F2S +configurations (4-7 lines) where cost >= v still holds: +- N: a_j + w_j >= n_j (fails, e.g. a class with n = 2, a = 1, w = 0); +- N-sum: sum_j (a_j + w_j) >= v (fails by 1; the step a_j <= w_j + rho' is lossy); +- N': n_j <= 2 w_j + rho' (fails by 1 on single classes; its sum is exactly (A)). +So in F2S the slack must move between classes. No per-class rowspace inequality closes the proof; any proof needs +a joint argument across the three classes, as in the exchange of 12.3. + +**13.3 The lift route, corrected (with fleet S1).** +- *Lemma W.* If B has a signing B' (entries +-1 on supp B) that is totally unimodular, then every block of B' has + rank_Q = rank_F2, and Lemma B gives cost(B) >= v. + - Camion: a TU signing exists iff the binary matroid M[I | B] is regular. + - Regularity of the column matroid M[B] alone is NOT enough: a full-rank B has M[B] free. +- Weaker hypothesis that still suffices: (G1') some cost-minimiser B has a rational lift B' with the same support, + nonzero diagonal, and rank_Q B'[R_j,A_j] = rank_F2 B[R_j,A_j] for j = 1, 2, 3. Then (A) follows from Lemma B. +- Checked: all 217 optima of tied_min have such a lift with +-1 entries (liftall.py, exact Q-ranks). +- S1 shows F7* blocks do occur for non-optimal admissible B, so (G1') must be a statement about some minimiser, not + about all B. + +**13.4 Structure of a minimal counterexample (rigorous).** Monotonicity: restricting B to a subset S of lines gives +an admissible matrix for S, whose blocks are submatrices, so cost(S) <= cost(config). Let config be a counterexample +to (A) with v minimal, and let B be a minimiser. Then: +1. cost(config) = v - 1, and cost(config - t) = v - 1 for every line t. Each one-line deletion is a *tight* + configuration: by minimality v - 1 <= cost(config - t) <= cost(config) <= v - 1. +2. No line is rank-critical for B: deleting row t and column t lowers no block rank (by 1, B restricted is a minimiser + of config - t with the same total). +3. H is strongly connected (Lemma SCC); every point and every line has >= 2 nonzero coordinates (Lemma Peel). +4. For every point P (and line l), with X = X_P (resp. Y_l), cost(config - X) <= v - 1 < (v - |X|) + |X|. So + Conjecture PP (fleet R6) would rule out minimal counterexamples. +Tight configurations (cost = v) are therefore the building blocks. On tied_min, S2 found tight sub-configurations of +every size <= 10, but none of size 11 (all of those cost 12). + +## 14. Synthesis after the fleet round (Oct 14, ~12:30) + +**Proved, any field / any rational configuration:** +- Lemma B (lift identity). +- Lemma W' (fleet S1, corrected): if B has a TU signing (Camion: [I|B] regular), then cost(B) >= v. More generally + the same holds whenever B has a same-support rational lift with rank_Q = rank_F_2 on the three blocks. +- Lemma SCC and Lemma Peel (section 13): H strongly connected and no 1-support points or lines, WLOG. +- Minimal counterexample structure (13.4): cost = v - 1, every one-line deletion is tight, no rank-critical line. +- Exact F2S identities: cost = 3 rho - sum w_j = 2 sum w_j + 3 rho' >= 2 rho. So (A) holds in F2S whenever + rank B >= v/2. +- tied_min: cost = 12 by the exchange proof (12.3). All 217 optima are TU-signable (S1) and lift (liftall.py). +- Theorems P, U (unit world, |G| + |I|/2) and M1 (no full-support points, v/2). + +**Refuted (exact):** +- Certificate routes: L8, multi-copy, and per-scale 2-adic copies all stop at 11 on tied_min. +- Per-class rowspace lemmas N, N-sum and N' (13.2). +- "Every optimum is regular": S1's F7* gadget, v = 10, has a non-regular minimiser. +- "Non-degenerate admissible B is regular": S1's aff14, 14 distinct points and lines. +- Peeling induction PP: S2, 272 of 4095 tied_min subsets; a lone line costs |D(t)|. + +**Evidence for (A):** +- S3: hill-climb over configurations (R <= 2, v <= 12) never below v; every climb ends exactly at cost = v. +- Exact: all 4095 sub-configurations of tied_min, 30 random F2S configurations, and every small instance checked earlier. + +**The single remaining gap, sharpest form (G1'):** + at T = 3, some cost-minimising admissible B has a same-support rational lift with nonzero diagonal and the same + rank on each of the three blocks. +G1' implies (A) by Lemma B, and it fails at T >= 7 (Fano-type cancellation). +- Empirical selection rule (S1): a support-minimal minimiser is TU-signable. Tested on about 120 small random grid + configurations, all sub-configurations of tied_min, and the gadgets. +- Admissibility alone cannot give G1': non-regular admissible B exist, so the proof must use optimality, i.e. an + exchange that removes Fano / F7* minors without raising any block rank. diff --git a/research/three-total-decoders/evidence/g1-PROOF.md b/research/three-total-decoders/evidence/g1-PROOF.md new file mode 100644 index 0000000000..8b27a3af43 --- /dev/null +++ b/research/three-total-decoders/evidence/g1-PROOF.md @@ -0,0 +1,205 @@ +# G1' at T = 3 (some cost-minimising B is TU-signable): status file + +Status: G1' in the form "some minimiser is TU-signable as a whole matrix" is FALSE at T = 3 (section 6, v = 9). +The weaker form that Lemma B needs (one signing that makes each of the three BLOCKS TU) holds on every instance tested. No general proof. + +Tools: enumall.c (exhaustive 2^f enumeration of all B, exact F2 block ranks, outputs every minimiser), +tusign.c (S1's Camion TU-signability test), g1lib.py, gadtest.py, fewest.py, dense.py, nonpack.py. + +## 1. Exact data on S1's gadget (gad.json, v = 10, seven coincident points c, f = 29 free entries) +Exhaustive over all 2^29 B: min cost 19, 23552 minimisers, 3052 of them NOT TS (S1's SA sample reported 5/200). +- Every fewest-ones minimiser (6 ones; 5 of them) is TS: each is three disjoint 2-cycles (J2 pieces). +- Every non-TS minimiser has a minimiser on a proper sub-support, and every inclusion-minimal + (support-minimal) minimiser is TS (0 of 3052). So "support-minimal => TS" holds here; fewest-ones is a corollary. +- Single-entry deletion does NOT suffice: 32 minimisers are non-TS yet no single deletion keeps cost 19. + Their nearest sub-minimisers need removal of 2 entries (26 cases) or 3 entries (6 cases). + So any exchange proof must be a multi-entry move. + +## 2. Packing structure: TRUE on random configs, FALSE in general (refuted, exact) +Observation: for 450 random configs (v 6-12, exhaustive), every fewest-ones minimiser is TS, and in most of them +its support is a vertex-disjoint union of directed cycles (I + permutation) and K3 cliques (J3). Such "packings" are +direct sums of TU-signable pieces, hence TS, and would give (A) directly. +But three configurations (nonpack_cfgs.json: c47 v=7 cost 8; c511 v=7 cost 9; c58 v=10 cost 16) have NO packing +minimiser at all (all 12 / 8 / 4 minimisers checked). Their fewest-ones minimisers contain strongly connected pieces with +(vertices, edges) = (4,7), (5,11), (5,8). They are still TS. So the optimum genuinely uses non-principal block effects +(R_j != A_j), and G1' cannot be reduced to cycle/clique packings. + +## 3. Proved facts used +- Every off-diagonal admissible entry (t,s) lies in >= 2 blocks: p(t).q(s)=0 forces |supp p(t) cap supp q(s)| != 1. +- Clique pieces have size <= 3 (cliques need distinct points and lines; a 4-clique forces three collinear points + on two different lines). A K2 piece meets >= 2 blocks and a K3 piece meets all 3 (proof: a K2 bad in two blocks + forces q_s = L_a containing p_s). [direct check; packings satisfy (A) without lifts] +- Deleting a 1 at (t,s) from a block M raises rank iff row t is in the span of the other rows of M and column s + in the span of the other columns. + +## 4. Mining the TS-restoring move on gad.json (mine.py, obst.py; exact, all 3052 non-TS minimisers) +For each non-TS minimiser B, the smallest X subset supp(B) with B - X a TS minimiser has |X| = 1 (1952), 2 (832), 3 (228), +4 (36), 5 (4). (These counts allow X with B - X TS but not support-minimal; section 1's "32 need 2-3" is about single +deletions that stay minimisers at all.) +- In 1952 cases X is one entry, and in 2280 cases some optimal X lies in ONE column with rows at the coincident + point c (the "re-route coincident rows" move S1 anticipated). The other 772 need X spread over 2-3 columns: + the coincident-point move alone does not cover every case. +- Minimal non-signable submatrices (greedy row/column deletion, 300 samples) are tiny: 4x4 with 9 ones (147), + 3x4 or 4x3 with 9 ones (98; this is the F7 matrix [110,011,101,111] itself, as a plain submatrix), 4x5/5x5 with 11. + Some optimal X lies INSIDE that obstruction in 251/300 cases and meets it in all 300. So the exchange is local to the obstruction, + but the obstruction is not unique (deleting inside the first one found is not always optimal). +Geometric reading: a 3x4 F7 submatrix whose ones are all off-diagonal needs three collinear points on four columns +whose lines all equal that line (or coincident points). With distinct points and lines, every F7 submatrix must use diagonal entries. + +## 5. Gadget variants (gadvar.py, exhaustive, six random realisations of the F G^T = I_3 gadget, v = 10, f = 21-27) +| f | min cost | #minimisers | non-TS | support-minimal minimisers (non-TS) | +|---|---|---|---|---| +| 26 | 20 | 3072 | 144 | 2 (0) | +| 21 | 15 | 80896 | 12284 | 4 (0) | +| 26 | 20 | 4096 | 101 | 4 (0) | +| 23 | 17 | 115200 | 20308 | 10 (0) | +| 27 | 16 | 384 | 14 | 2 (0) | +| 23 | 14 | 4608 | 184 | 3 (0) | +Up to 18% of the minimisers are non-TS, but every support-minimal minimiser is TS (30/30), so G1' holds in all of them. + +## 6. COUNTEREXAMPLE to whole-matrix G1' (found by worker w1, verified here exactly): cex_wholeTS_v9.json +P = (2,-1,-2) (1,0,-1) (2,2,-1) (0,-6,3) (-3,-2,1) (3,2,-1) (-2,0,-2) (1,3,1) (-2,2,0) +Q = (-2,2,2) (1,1,2) (1,1,2) (0,6,-3) (4,0,8) (3,-1,-3) (4,0,8) (1,0,1) (-1,0,-1) +v = 9, f = 13. Exhaustive: min cost 18, 16 minimisers, block ranks (7,4,7) for all of them. +- NONE of the 16 minimisers is TU-signable as a whole 9x9 matrix. tusign.c and an independent Python Camion + solver (jointsign.py) agree. +- Every block of every minimiser is TU-signable, and a JOINT signing exists (one sign per entry; the Camion + equations of the three blocks are solved together). Its exact Fraction block ranks are (7,4,7), equal to the F2 ranks, + for all 16 minimisers. So the lift that Lemma B needs exists, and (A) holds here (18 >= 9). +Fewest-ones minimiser (8 off-diagonal ones), rows: + 100100001 / 010000001 / 001000100 / 011100000 / 000010000 / 000001000 / 100000100 / 000000010 / 001000001 +The whole-matrix obstruction combines entries that never sit together in one block (row 3 is not in R_0, row 8 is not +in R_2, and so on). So whole-matrix TS is the wrong invariant. + +## 7. Corrected target (G1-joint), open +At T = 3, some cost-minimiser B admits one +-1 signing of supp(B) under which every block B[R_j,A_j] is TU. +This is a linear system over F2 (the union of the three blocks' Camion equations; jointsign.py). It implies +rank_Q = rank_F2 on each block, so by Lemma B it implies (A). It is weaker than whole-B TS and stronger than G1' (lift). +Evidence: it holds on every configuration tested here (gadget, its variants, c47/c511/c58, the v = 9 example). + +## 8. Consequences for the selection rules (corrections to sections 1 and 5) +- The 8-ones minimiser of cex_wholeTS_v9 is both support-minimal and fewest-ones (w1: no minimiser on a proper sub-support), + and it is not whole-TS. So "support-minimal => whole-TS" and "fewest-ones => whole-TS" (S1's rule) are FALSE. + In w1/cfgA.json (v = 9, f = 18) the two fewest-ones minimisers split: one TS, one not. + Sections 1 and 5 hold only on those instances. +- What survives everywhere tested: "support-minimal => joint block-TU signable" (section 7). +- cex_wholeTS_v9 is DEGENERATE on both sides. Lines 1 and 2 are equal, (1,1,2). Lines 4 and 6 are equal, (4,0,8). + Lines 7 and 8 are the same projective line. Points 4 and 5 coincide, (-3,-2,1) ~ (3,2,-1). So "whole-TS fails only in + degenerate configurations" remains open. +- w1's random +-1..3 lifts matched the block ranks in only 1 of 48000 trials. That does not conflict with section 6: + the joint signing is a structured solution of the Camion linear system, not a random draw. + +## 9. G1-joint: exact formulation (proved) +Let G be the bipartite support graph of B: row vertices t, column vertices s, an edge for every 1 (diagonal included). +Block j is the INDUCED subgraph G_j = G[V_j], with V_j = (rows R_j) + (columns A_j). Off-diagonal edges lie in >= 2 of +the G_j (section 3), and a diagonal edge (t,t) lies in |pi(t) cap sigma(t)| >= 1 of them. +Signs are written additively: x in F2^{E(G)}, x_e = 1 meaning entry e gets sign -1. + +**Lemma 9.1 (chordless holonomy).** If a signing of a 0/1 matrix M is TU, then every chordless cycle gamma of its +support graph (length 2m) has sum_{e in gamma} x_e = m mod 2. +Proof: the rows and columns of gamma span a square submatrix whose support is exactly gamma (chordless), so it is a +2m-cycle matrix. Its determinant is +-(Pi_1 + (-1)^{m-1} Pi_2), where Pi_1, Pi_2 are the sign products of the two +perfect matchings (they differ by an m-cycle permutation). So it lies in {0, +-2}, and TU forces 0, i.e. +Pi_1 Pi_2 = (-1)^m: the number of -1 entries on gamma is = m mod 2 (check: J2, m = 2, all +1, det 0). [] + +**Lemma 9.2 (uniqueness up to scaling; Camion).** Two TU signings of M differ by a coboundary: x' = x + (r_t + c_s). +Proof: chordless cycles span the cycle space Z(G) over F2. By 9.1, x and x' have the same sum on each of them, hence on +all of Z(G). A vector orthogonal to Z(G) is a coboundary. Coboundaries (row and column scalings) preserve TU. [] + +**Theorem 9.3 (joint signability is a linear system).** B admits one signing with all three blocks TU iff +(i) each block B[R_j,A_j] is TU-signable, and +(ii) the F2 system { sum_{e in gamma} x_e = |gamma|/2 mod 2 : gamma a chordless cycle of some G_j } is consistent. +Proof: (=>) by 9.1 applied to each block. (<=) take a solution x and a TU signing s_j of block j. On G_j, x and s_j have +equal sums on every chordless cycle of G_j, hence on Z(G_j), so x|G_j = s_j + coboundary, and x|G_j is TU. [] +Equivalently: with h_j the holonomy functional on Z(G_j), (ii) says h_0(g_0) + h_1(g_1) + h_2(g_2) = 0 whenever +g_0 + g_1 + g_2 = 0 with g_j in Z(G_j). Pairwise relations (g in Z(G_j) cap Z(G_k) = Z(G[V_j cap V_k])) never obstruct, +because a chordless cycle of the induced graph G[V_j cap V_k] is chordless in both G_j and G_k (S1, Lemma G). So an +obstruction to (ii) is a genuinely three-block ("Cech") relation. +Check: jsign.c builds exactly this system (Camion Eulerian equations of the three blocks, one shared variable per +entry). On cex_wholeTS_v9 all 16 minimisers pass (i) and (ii), while the whole-matrix system fails. + +So G1-joint has two separate failure modes for a given minimiser: (F1) one block is not TU-signable (an F7/F7* minor +inside one block, as on the gadget, where block 2 is the whole matrix); (F2) a Cech relation across the three blocks. + +## 10. Testing G1-joint (jsign.c, jsweep.py; exact; w1-style configurations: 3 points a_i with lines q_i plus lines +whose point/line pass through 0-2 of the q_i / a_i; v = 6-10, exhaustive over all B) +- **Both failure modes occur among minimisers.** (F2) Cech failures, where every block is TU-signable but there is no joint + signing, show up already at v = 6 (cech_v8.json: v = 8, f = 11, one of 320 minimisers). (F1) failures, where a single block is not + TU-signable, are common (up to ~25% of minimisers). +- **"Support-minimal => jointly signable" is FALSE.** Smallest instance found: supmin_fail_v8.json (v = 8, f = 12, cost 14). + It has exactly 2 minimisers, both with 9 ones, both support-minimal, block ranks (4,5,5). + One is whole-TS. The other has block 0 not TU-signable. They differ by the one-for-one SWAP (3,0) <-> (1,6). + So neither fewest-ones nor support-minimality selects a good minimiser; any selection rule must see signability. + The minimal obstruction in block 0 is rows (0,1,2,6) x cols (0,3,4,6) = [1110 / 0011 / 0101 / 1001]: an induced + "odd theta" (branch vertices row 0 and column 6, three paths of length 3). Each path joins a row to a column, so it has + odd length; the three chordless cycles would need holonomy (a+b)/2 + (b+c)/2 + (a+c)/2 = a+b+c = 9 = 1 mod 2, but their sum is 0. + This is the basic F1 obstruction. It uses two DIAGONAL entries, (0,0) and (6,6), so non-degenerate geometry does not exclude it. +- Random sweep totals (jsweep_11.log): 6018 configurations; 60 have a Cech-failing minimiser, 1311 a block-non-TS minimiser, and none had zero jointly signable minimisers. Targeted climbing (jclimb.py) then found such configurations, see section 11. + +## 11. COUNTEREXAMPLE to G1-joint (exact): cex_joint_v7.json, found by jclimb.py +P = (2,0,-2) (-32,-32,-48) (-4,-4,-4) (0,1,1) (-2,0,-1) (0,-1,1) (-2,-2,0) +Q = (2,-12,-4) (1,-2,0) (-2,2,-1) (-1,2,-1) (-2,0,2) (-4,4,0) (32,64,-64) +v = 7, f = 11. Exhaustive: min cost 12, exactly 4 minimisers (7, 8, 9 and 10 ones), all with block ranks (4,4,4). +In ALL FOUR, block 2 (rows 0-5, cols 0,2,3,4,6) is not TU-signable (tusign.c; the Python Camion solver agrees: no joint signing). +So no minimiser is jointly signable: G1-joint is FALSE at T = 3. (A) holds here: 12 >= 7. +Obstruction: the nonzero rows of block 2 are rows 0,2,3,4 = [10100 / 01110 / 00101 / 10011]. Dropping the leaf column 2 +leaves an induced odd theta (branch vertices row 4 and column 3; paths r4-c0-r0-c3, r4-c4-r2-c3, r4-c6-r3-c3), using the +diagonal entries (0,0), (3,3) and (4,4). +**But the lift that Lemma B needs exists.** For the 7-ones minimiser, the same-support rational matrix + [[-1,0,0,-2,0,0,0],[0,3,0,0,0,0,0],[0,0,1,-2,1,0,0],[0,0,0,-2,0,0,-1],[-2,0,0,0,-2,0,2],[0,0,0,0,0,2,0],[0,0,2,0,0,0,2]] +has exact Fraction block ranks (4,4,4) = the F2 ranks. Reason: block 2 has only 4 nonzero rows and F2 rank 4, so ANY odd lift +has Q-rank exactly 4. TU is irrelevant for a full-row-rank block. +For the 8-, 9- and 10-ones minimisers, 2000 random weightings in {+-1,+-2,3} found no lift. That is not a proof that none exists. + +**Hierarchy, all now exact at T = 3:** + whole-B TS (false, v = 9) => joint block-TU (false, v = 7) => G1'-lift (holds on every case tested). +So TU-signability is too strong an invariant. The surviving target is G1'-lift: some minimiser B has a rational B' with +supp B' = supp B and rank_Q B'[R_j,A_j] = rank_F2 B[R_j,A_j] for j = 0,1,2. A TU signing is needed only where a block is +rank-deficient. A rank-preserving lift has to kill the (r_j+1)-minors of each block, which is an algebraic condition, not a linear one. + +## 12. G1'-lift settled EXACTLY on every no-joint configuration: a lift always exists, with +-1 entries +Tool: exactlift.py (sympy). Row and column scalings W -> D1 W D2 preserve all three block ranks, so the entries on a spanning forest +of supp(B) are fixed to 1 (gauge). One variable stays per independent cycle. The conditions are all (r_j+1)-minors of +each block = 0, plus prod(vars) != 0 (Rabinowitsch variable tinv). A lex Groebner basis decides the system over C. +rational_point() then finds an explicit point with entries in {+-1, +-2} and re-verifies the block ranks with exact Fractions. +Only rank_Q <= rank_F2 is needed for Lemma B (rank_Q >= rank_F2 holds automatically for odd integer lifts). +Results: +- cex_joint_v7 (= nojoint_5): all 4 minimisers lift, each with a UNIQUE gauge class, and all variables are +-1. + So these are +-1 signings that preserve every block rank without being TU. +- All 14 no-joint configurations from jclimb2.py (nojoint_21_1..14, v = 7-10; 1 to 256 minimisers; first <= 12 minimisers each + by ones count): EVERY minimiser tested is consistent, and almost all have a unique +-1 solution. +- Gadget gad.json: 8 non-TS minimisers (sample) all lift. S1's hand-built F7* matrix (gad.json B, ranks (7,7,7), no block + TU-signable) also lifts, with entries in {+-1,+-2}. +- Beyond minimisers: random ADMISSIBLE B (not optimised) with at least one non-TU-signable block: 60/60 (w1-style configs) and + 74/74 (dense grid configs; 6 skipped with > 9 cycle variables) have a small rational rank-preserving lift. + +**New sharpened conjecture (Lift-all, T = 3):** every admissible B, not only a minimiser, has a same-support rational lift +B' with rank_Q B'[R_j,A_j] <= rank_F2 B[R_j,A_j] for j = 0,1,2. By Lemma B, this gives cost(B) >= v for every B, i.e. (A). +It would make the selection problem disappear. Evidence: everything above; no counterexample in about 160 exact tests. +It is false at T >= 7 (Fano cancellation), so a proof must use the P^2(Q) incidence pattern. +Hierarchy now: whole-B TS (false, v = 9) => joint block-TU (false, v = 7) => Lift-all (open, no counterexample) => (A). + +## 13. Hesse / Q(omega) test (hesse.py, hesse_hc.py; coordinator's runs in hesse_runs/) +Configurations from the Hesse configuration (9 points, 12 lines, plus the 12 extra pairwise intersection points) over the +Eisenstein integers, with exact arithmetic in Z[omega], under random projective transforms. In all runs (mine: 300 random + +20 climbs x 150 steps; coordinator: seeds 1-4 x 400 random, hc seeds 11-13), cost >= v everywhere, with many tight (cost = v) cases. +No "BELOW v" event. Lemma B holds over any field of characteristic 0, and the F2 obstructions seen are Fano-type +(characteristic 2) and not Hesse-type (characteristic 3). So there is no sign that the ORDER of Q (Sylvester-Gallai) is the +mechanism. The relevant input looks like "characteristic 0 geometry cannot host F2-cancelling patterns". + +## 14. What the lift route really needs, and where a proof must come from +- Lemma B needs only SOME rational B' supported on (incidences + diagonal), with nonzero diagonal and + sum_j rank_Q B'[R_j,A_j] <= cost(B). Same support is not required. So the honest target is + **(Q <= F2):** min over rational admissible B' of the Q-cost <= min over F2 admissible B of the F2-cost, + and (A) = (Q <= F2) + Lemma B. Same-support rank-preserving lifts (section 12) are a convenient witness for it. + Every exact test so far has produced such a witness, almost always with +-1 entries in a unique gauge class. +- **Same-support Lift-all is probably the wrong final form.** With a_i collinear on a line L, all Y-lines equal + to L and all Y-points equal to one point c not on L, and X-lines through c, the admissible pattern contains + B = [[I_k, F],[G, I_m]] with F and G ARBITRARY 0/1 matrices. (Checked exactly for k = 3, m = 4: c = (1,2,3), L = (1,1,1), + a = (1,2,-3),(2,1,-3),(1,-3,2); the free set is exactly X x Y + Y x X.) So any F2/Q minrank gap of a 0/1 pattern (Lubetzky-Stav type) + embeds into a same-support lift question at T = 3. But there sub-support lifts always reach the F2 optimum + (rank max(k,m)), so (Q <= F2) is unaffected. Any proof must therefore allow the support to change, e.g. an exchange + that moves to a minimiser with a liftable pattern, or a direct construction of a cheap rational B'. +- **Mechanism status:** no proof. Every candidate invariant short of (Q <= F2) is now refuted at small v (whole-TS v = 9, + joint-TU v = 7, packing, single-entry exchange, support-minimal/fewest-ones selection). The data point to + "F2-optimal patterns at T = 3 admit +-1 rank-preserving signings", and these are not TU signings. diff --git a/research/three-total-decoders/lib/hesse.py b/research/three-total-decoders/lib/hesse.py new file mode 100644 index 0000000000..3e7aebc89b --- /dev/null +++ b/research/three-total-decoders/lib/hesse.py @@ -0,0 +1,64 @@ +"""Rank-3 decoder configurations built on the Hesse configuration over Q(w), w^2 + w + 1 = 0 (Eisenstein integers a + b w as pairs). +Adapted from the working card g1/hesse.py (module-level search loop removed; the exhaustive evaluation is kit.enum_raw). +A configuration is a list of (point, line) pairs with p.q != 0; incidence p.q = 0 is evaluated in Z[w].""" +import itertools, os, sys, json, random +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import kit + +Z = (0, 0); O = (1, 0); W = (0, 1); W2 = (-1, -1) +def add(x, y): return (x[0] + y[0], x[1] + y[1]) +def neg(x): return (-x[0], -x[1]) +def mul(x, y): a, b = x; c, d = y; return (a * c - b * d, a * d + b * c - b * d) +def dot(p, q): + s = Z + for a, b in zip(p, q): s = add(s, mul(a, b)) + return s +def cross(a, b): + return (add(mul(a[1], b[2]), neg(mul(a[2], b[1]))), add(mul(a[2], b[0]), neg(mul(a[0], b[2]))), add(mul(a[0], b[1]), neg(mul(a[1], b[0])))) +def nz(x): return x != Z +def same(p, q): return all(not nz(x) for x in cross(p, q)) +def inc(p, l): return not nz(dot(p, l)) + +def hesse(): + ws = [O, W, W2]; pts = [] + for k in range(3): + pts += [(Z, O, neg(ws[k])), (neg(ws[k]), Z, O), (O, neg(ws[k]), Z)] + lines = [] + for a, b in itertools.combinations(pts, 2): + l = cross(a, b) + if not any(same(l, m) for m in lines): lines.append(l) + xp = list(pts) + for a, b in itertools.combinations(lines, 2): + p = cross(a, b) + if not any(same(p, q) for q in xp): xp.append(p) + return pts, lines, xp + +def evaluate(P, Q, cap=26): + """Exhaustive minimum of cost over all admissible B: returns (v, f, best); best is None (not evaluated) if f > cap.""" + v = len(P) + R = [[t for t in range(v) if nz(P[t][j])] for j in range(3)]; A = [[s for s in range(v) if nz(Q[s][j])] for j in range(3)] + free = [(t, s) for t in range(v) for s in range(v) if t != s and inc(P[t], Q[s]) and any(t in R[j] and s in A[j] for j in range(3))] + if len(free) > cap: return v, len(free), None + best, _ = kit.enum_raw(v, R, A, free) + return v, len(free), best + +def transform(M, p): return tuple(dot(r, p) for r in M) + +def random_config(rng, xp, pts, lines, v=None): + """The sampler of the working card: random projective change of coordinates (so the coordinate triangle is generic), points from the + 9 Hesse points or all 21 intersection points, lines from the 12 Hesse lines; pairs (p,l) with p.l != 0 chosen biased towards incidences.""" + if rng.random() < 0.3: M = [[O, Z, Z], [Z, O, Z], [Z, Z, O]] + else: + while True: + M = [[(rng.randint(-2, 2), rng.randint(-1, 1)) for _ in range(3)] for _ in range(3)] + if nz(dot(M[0], cross(M[1], M[2]))): break + cof = [cross(M[1], M[2]), cross(M[2], M[0]), cross(M[0], M[1])] + PP = [transform(M, p) for p in (xp if rng.random() < 0.5 else pts)] + LL = [transform(cof, l) for l in lines] + pairs = [(p, l) for p in PP for l in LL if not inc(p, l)] + v = v or rng.randint(6, 12); P = []; Q = [] + for _ in range(v): + cand = rng.sample(pairs, min(12, len(pairs))) + sc = lambda pl: sum(inc(pl[0], q) for q in Q) + sum(inc(p, pl[1]) for p in P) + rng.random() + p, l = max(cand, key=sc); P.append(p); Q.append(l) + return P, Q diff --git a/research/three-total-decoders/lib/kit.py b/research/three-total-decoders/lib/kit.py new file mode 100644 index 0000000000..cf4d156d58 --- /dev/null +++ b/research/three-total-decoders/lib/kit.py @@ -0,0 +1,203 @@ +"""Shared helpers of research/three-total-decoders (standard library; python-sat only where a SAT call is made). + +Model (see README section 1): a configuration is a list of lines t = (p(t), q(t)) with p, q in Z^3 and p(t).q(t) != 0. +R_j = {t : p_j(t) != 0}, A_j = {t : q_j(t) != 0}. An admissible B over F2 has unit diagonal and B_ts = 1 (t != s) only where +p(t).q(s) = 0. Only entries that fall inside some block R_j x A_j matter for the cost, so 'free' lists exactly those incidences. +cost(B) = sum_j rank_F2 B[R_j, A_j]. +""" +import json, os, subprocess, itertools +from fractions import Fraction + +PKG = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +DATA = os.path.join(PKG, 'data') +BIN = os.environ.get('TTD_BIN') or os.path.join(PKG, 'c', 'bin') + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def load_cfg(name): + """Return (P, Q) from data/; accepts [[p,q],...] and [P,Q] (and [P,Q,B]).""" + d = json.load(open(os.path.join(DATA, name))) + if len(d) in (2, 3) and isinstance(d[0][0], list) and isinstance(d[0][0][0], int) and len(d[0]) == len(d[1]): + return d[0], d[1] + return [l[0] for l in d], [l[1] for l in d] + + +def setup(P, Q): + v = len(P) + R = [[t for t in range(v) if P[t][j]] for j in range(3)] + A = [[s for s in range(v) if Q[s][j]] for j in range(3)] + free = [(t, s) for t in range(v) for s in range(v) + if t != s and dot(P[t], Q[s]) == 0 and any(t in R[j] and s in A[j] for j in range(3))] + return R, A, free + + +def _run(binary, text, *args): + return subprocess.run([os.path.join(BIN, binary), *args], input=text, capture_output=True, text=True, check=True).stdout + + +def blocks_text(R, A): + return "".join("%d %s\n%d %s\n" % (len(R[j]), " ".join(map(str, R[j])), len(A[j]), " ".join(map(str, A[j]))) for j in range(3)) + + +def enum_raw(v, R, A, free, slack=0): + """Exhaustive over all 2^f admissible B (C program enumall, f <= 30). Returns (best, [(cost, g)]); g bit i = free[i].""" + inp = "%d %d\n" % (v, len(free)) + "".join("%d %d\n" % e for e in free) + blocks_text(R, A) + out = _run('enumall', inp, str(slack)).split() + best, nm = int(out[0]), int(out[1]); xs = list(map(int, out[2:])) + return best, [(xs[2 * i], xs[2 * i + 1]) for i in range(nm)] + + +def enum(P, Q, slack=0): + """enum_raw for an integer configuration. Returns (best, [(cost, g)], R, A, free).""" + v = len(P); R, A, free = setup(P, Q) + best, ms = enum_raw(v, R, A, free, slack) + return best, ms, R, A, free + + +def tomat(g, free, v): + B = [[int(t == s) for s in range(v)] for t in range(v)] + for i, (t, s) in enumerate(free): + if g >> i & 1: + B[t][s] = 1 + return B + + +def rank2(rows): + """F2 rank of a list of int bitmasks.""" + piv = [] + for x in rows: + for p in piv: + x = min(x, x ^ p) + if x: + piv.append(x); piv.sort(reverse=True) + return len(piv) + + +def blk_rows(B, rows, cols): + return [sum(B[t][s] << i for i, s in enumerate(cols)) for t in rows] + + +def blockranks(B, R, A): + return [rank2(blk_rows(B, R[j], A[j])) for j in range(3)] + + +def qrank(M): + M = [[Fraction(x) for x in r] for r in M] + if not M or not M[0]: + return 0 + rk = 0 + for c in range(len(M[0])): + p = next((i for i in range(rk, len(M)) if M[i][c] != 0), None) + if p is None: + continue + M[rk], M[p] = M[p], M[rk] + for i in range(len(M)): + if i != rk and M[i][c] != 0: + f = M[i][c] / M[rk][c]; M[i] = [a - f * b for a, b in zip(M[i], M[rk])] + rk += 1 + return rk + + +def tus(B, rows, cols): + """Camion test (C program tusign): is the submatrix B[rows, cols] TU-signable?""" + rows = list(rows); cols = list(cols) + inp = "%d %d\n" % (len(rows), len(cols)) + "\n".join(str(x) for x in blk_rows(B, rows, cols)) + r = _run('tusign', inp).strip() + assert r in ('0', '1'), r + return r == '1' + + +def jsign_batch(Bs, R, A, want_sign=False): + """C program jsign: per B the tuple (J, b0, b1, b2); with want_sign also the joint signing (list of +-1 per one, row-major) or None.""" + inp = [] + for B in Bs: + v = len(B); inp.append(str(v)); inp += [str(sum(B[t][s] << s for s in range(v))) for t in range(v)] + inp.append(blocks_text(R, A).strip()) + out = _run('jsign', "\n".join(inp) + "\n", *(['s'] if want_sign else [])).split('\n') + res = []; i = 0; out = [l for l in out if l.strip()] + while i < len(out): + fl = tuple(x == '1' for x in out[i].split()); i += 1 + sgn = None + if want_sign and fl[0]: + bits = out[i].split()[1]; i += 1 + sgn = [-1 if b == '1' else 1 for b in bits] + res.append((fl, sgn) if want_sign else fl) + assert len(res) == len(Bs), (len(res), len(Bs)) + return res + + +def brute_batch(Bs, R, A): + """C program brutetu: exhaustive signings + exhaustive minors; per B (J, b0, b1, b2) or None if out of range.""" + inp = [] + for B in Bs: + v = len(B); inp.append(str(v)); inp += [str(sum(B[t][s] << s for s in range(v))) for t in range(v)] + inp.append(blocks_text(R, A).strip()) + out = [l for l in _run('brutetu', "\n".join(inp) + "\n").split('\n') if l.strip()] + return [None if l.strip() == '-1' else tuple(x == '1' for x in l.split()) for l in out] + + +def signed_matrix(B, sgn): + v = len(B); S = [[0] * v for _ in range(v)]; k = 0 + for t in range(v): + for s in range(v): + if B[t][s]: + S[t][s] = sgn[k]; k += 1 + return S + + +def block_q(S, R, A): + return [qrank([[S[t][s] for s in A[j]] for t in R[j]]) for j in range(3)] + + +# ---- independent pure-Python Camion solver (same linear system as jsign.c, different code) ------------------------------- +def camion_eqs(B, rows, cols, vid): + eqs = [] + for k in range(1, len(rows) + 1): + for S in itertools.combinations(rows, k): + par = [sum(B[t][s] for t in S) % 2 for s in cols] + Z = [s for s, p in zip(cols, par) if p == 0] + for T in itertools.combinations(Z, k): + if all(sum(B[t][s] for s in T) % 2 == 0 for t in S): + e = 0; cnt = 0 + for t in S: + for s in T: + if B[t][s]: + e |= 1 << vid[(t, s)]; cnt += 1 + if cnt: + eqs.append((e, (cnt // 2) & 1)) + return eqs + + +def solve_f2(eqs): + piv = {} + for e, r in eqs: + while e: + b = e.bit_length() - 1 + if b in piv: + pe, pr = piv[b]; e ^= pe; r ^= pr + else: + piv[b] = (e, r); break + if not e and r: + return None + x = 0 + for b in sorted(piv): + e, r = piv[b] + if r ^ (bin(e & x & ~(1 << b)).count('1') & 1): + x |= 1 << b + return x + + +def py_flags(B, R, A, which=(0, 1, 2)): + """(J, b0, b1, b2) by the Python Camion system.""" + v = len(B); ents = [(t, s) for t in range(v) for s in range(v) if B[t][s]]; vid = {e: i for i, e in enumerate(ents)} + eq = [camion_eqs(B, R[j], A[j], vid) for j in range(3)] + bo = [solve_f2(eq[j]) is not None for j in range(3)] + J = solve_f2(eq[0] + eq[1] + eq[2]) is not None + return (J, *bo) + + +def pretty_flags(f): + return "J=%d b=%d%d%d" % (f[0], f[1], f[2], f[3]) diff --git a/research/three-total-decoders/lib/satlib.py b/research/three-total-decoders/lib/satlib.py new file mode 100644 index 0000000000..deda2e3d6d --- /dev/null +++ b/research/three-total-decoders/lib/satlib.py @@ -0,0 +1,75 @@ +"""Small exact SAT encodings (python-sat, CaDiCaL): rank factorisations over F2 of the three blocks of an admissible B. +build_ranks: all B with rank B[R_j,A_j] <= rs[j] (used to enumerate the optima of tied_min). +cost_leq: one CNF 'cost <= K' (per block a factorisation with c_j active columns, total active <= K); returns a B or None. +Adapted from fprime/enumB.py and fprime/costsat2.py of the working cards (see NOTICE.md).""" +from pysat.solvers import Cadical153 +from pysat.formula import IDPool +from pysat.card import CardEnc, EncType + + +def _inc(P, Q): + return lambda t, s: t != s and sum(a * b for a, b in zip(P[t], Q[s])) == 0 + + +def _factor(cl, pool, P, Q, j, c, R, A, Bv, tag=''): + for t in R: + for s in A: + target = Bv(t, s) + ands = [] + for k in range(c): + x = pool.id(('X', j, t, k)); y = pool.id(('Y', j, k, s)); z = pool.id(('Z', j, t, s, k)) + cl += [[-z, x], [-z, y], [z, -x, -y]]; ands.append(z) + if not ands: + if target is True: cl.append([]) + elif target is not False: cl.append([-target]) + continue + acc = ands[0] + for z in ands[1:]: + n = pool.id(('C', j, t, s, z)); cl += [[-n, acc, z], [-n, -acc, -z], [n, -acc, z], [n, acc, -z]]; acc = n + if target is True: cl.append([acc]) + elif target is False: cl.append([-acc]) + else: cl += [[-acc, target], [acc, -target]] + + +def build_ranks(P, Q, rs): + v = len(P); pool = IDPool(); cl = []; inc = _inc(P, Q) + def Bv(t, s): + if t == s: return True + if inc(t, s): return pool.id(('B', t, s)) + return False + for j, r in enumerate(rs): + R = [t for t in range(v) if P[t][j]]; A = [s for s in range(v) if Q[s][j]] + _factor(cl, pool, P, Q, j, r, R, A, Bv) + bvars = {(t, s): pool.id(('B', t, s)) for t in range(v) for s in range(v) if inc(t, s)} + return cl, bvars + + +def enumerate_B(P, Q, rs, limit=10 ** 6): + """All distinct B (as set of (t,s) off-diagonal ones) with block ranks <= rs, by blocking clauses on the B variables.""" + cl, bv = build_ranks(P, Q, rs); s = Cadical153(bootstrap_with=cl); out = [] + while len(out) < limit and s.solve(): + m = set(l for l in s.get_model() if l > 0) + out.append(sorted(k for k, x in bv.items() if x in m)) + s.add_clause([-x if x in m else x for x in bv.values()]) + return out + + +def cost_leq(P, Q, K): + v = len(P); pool = IDPool(); cl = []; inc = _inc(P, Q); act = [] + def Bv(t, s): + if t == s: return True + if inc(t, s): return pool.id(('B', t, s)) + return False + for j in range(3): + R = [t for t in range(v) if P[t][j]]; A = [s for s in range(v) if Q[s][j]] + c = min(len(R), len(A), K) + e = [pool.id(('e', j, k)) for k in range(c)]; act += e + for k in range(c - 1): cl.append([-e[k + 1], e[k]]) + for t in R: + for k in range(c): cl.append([-pool.id(('X', j, t, k)), e[k]]) + _factor(cl, pool, P, Q, j, c, R, A, Bv) + card = CardEnc.atmost(lits=act, bound=K, top_id=pool.top, encoding=EncType.seqcounter) + s = Cadical153(bootstrap_with=cl + card.clauses) + if not s.solve(): return None + m = set(l for l in s.get_model() if l > 0) + return [[1 if t == u else (1 if inc(t, u) and pool.id(('B', t, u)) in m else 0) for u in range(v)] for t in range(v)] diff --git a/research/three-total-decoders/requirements.txt b/research/three-total-decoders/requirements.txt new file mode 100644 index 0000000000..3981157000 --- /dev/null +++ b/research/three-total-decoders/requirements.txt @@ -0,0 +1,5 @@ +# Tested set (versions of the development environment; Python 3.14.7, Apple clang 16). Everything except the SAT steps is standard library. +# The SAT steps (checks/tied_min.py, checks/f2s.py) need python-sat (CaDiCaL 1.5.3, cardinality encodings); numpy is NOT needed. +# A C compiler (cc, C99, 128-bit integers: gcc or clang on a 64-bit host) is needed for the five programs in c/ (enumall, tusign, jsign, mas, brutetu). +python-sat==1.9.dev15 +# scripts/make_lifts.py (authors only, not run by verify.sh) additionally needs sympy. diff --git a/research/three-total-decoders/scripts/make_lifts.py b/research/three-total-decoders/scripts/make_lifts.py new file mode 100644 index 0000000000..1bc0e41c52 --- /dev/null +++ b/research/three-total-decoders/scripts/make_lifts.py @@ -0,0 +1,62 @@ +"""Authors' script (NOT run by verify.sh; needs sympy): finds same-support rational lifts with rank_Q <= rank_F2 on every block for minimisers, and dumps them +to data/lifts_nojoint.json, which verify.sh (group G2.nojoint-lifts) re-checks with exact Fractions. Method of the card g1/exactlift.py (adapted, same math): +row/column scalings preserve all block ranks, so entries on a spanning forest of supp B are fixed to 1; the remaining variables are searched over small +integers, accepting a point only if the exact block ranks are <= the F2 ranks. usage: python3 make_lifts.py (from the package directory)""" +import sys, os, json, itertools +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')) +from kit import * +import sympy as sp + +def lift_system(B, R, A, rk): + v = len(B); E = [(t, s) for t in range(v) for s in range(v) if B[t][s]] + par = {('r', t): ('r', t) for t in range(v)}; par.update({('c', s): ('c', s) for s in range(v)}) + def find(x): + while par[x] != x: par[x] = par[par[x]]; x = par[x] + return x + W = {}; vs = [] + for (t, s) in E: + a, b = find(('r', t)), find(('c', s)) + if a != b: par[a] = b; W[(t, s)] = sp.Integer(1) + else: + x = sp.Symbol('x%d_%d' % (t, s)); vs.append(x); W[(t, s)] = x + eqs = [] + for j in range(3): + rows = [t for t in R[j] if any(B[t][s] for s in A[j])]; cols = [s for s in A[j] if any(B[t][s] for t in R[j])] + r = rk[j] + if min(len(rows), len(cols)) <= r: continue + M = sp.Matrix([[W.get((t, s), 0) for s in cols] for t in rows]) + for rs in itertools.combinations(range(len(rows)), r + 1): + for cs in itertools.combinations(range(len(cols)), r + 1): + d = sp.expand(M.extract(list(rs), list(cs)).det(method='berkowitz')) + if d != 0: eqs.append(d) + return vs, list(set(eqs)), W + +def find_lift(B, R, A, rk, maxvars=12): + vs, eqs, W = lift_system(B, R, A, rk) + if len(vs) > maxvars: return None + f = sp.lambdify(vs, eqs, 'math') if eqs else None + v = len(B) + for vals in ((1, -1), (1, -1, 2, -2)): + for combo in itertools.product(vals, repeat=len(vs)): + if f is None or all(e == 0 for e in f(*combo)): + sub = dict(zip(vs, combo)) + M = [[int(W[(t, s)].subs(sub)) if (t, s) in W else 0 for s in range(v)] for t in range(v)] + if all(M[t][s] != 0 for (t, s) in W) and all(qrank([[M[t][s] for s in A[j]] for t in R[j]]) <= rk[j] for j in range(3)): + return M + return None + +if __name__ == '__main__': + out = [] + def do(name, items): + P, Q = load_cfg(name); v = len(P); R, A, free = setup(P, Q) + for g in items: + B = tomat(g, free, v); rk = blockranks(B, R, A); M = find_lift(B, R, A, rk) + print(name, bin(g).count('1'), rk, 'lift' if M else 'NONE', flush=True) + if M: out.append({'config': name, 'g': g, 'lift': M}) + for name in ['cex_joint_v7.json'] + ['nojoint_21_%d.json' % i for i in range(1, 15)]: + P, Q = load_cfg(name); best, ms, R, A, free = enum(P, Q) + do(name, [g for _, g in sorted(ms, key=lambda x: (bin(x[1]).count('1'), x[1]))[:12 if 'nojoint' in name else 99]]) + gm = json.load(open('/Users/mason/repo_clones/intmult-work/cards/KPR4-T3/g1/gad.json.mins.json')) + bad = sorted((e for e in gm if not all(e[2])), key=lambda e: (e[0], e[4])) + do('gad.json', [e[4] for e in bad[:8]]) + json.dump(out, open(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'data', 'lifts_nojoint.json'), 'w')) diff --git a/research/three-total-decoders/scripts/provenance.py b/research/three-total-decoders/scripts/provenance.py new file mode 100644 index 0000000000..53abd0bee9 --- /dev/null +++ b/research/three-total-decoders/scripts/provenance.py @@ -0,0 +1,45 @@ +"""Step 0 of verify.sh (standard library only). Prints one PASS/FAIL line per group and exits 1 on any mismatch. + 0.manifest every file of the package matches MANIFEST.sha256 (sha256), none is missing and none is extra + 0.sources every pin of SOURCES.json holds: the sha256 of each pinned package file (checks, libraries, C sources, data, evidence snapshots) +usage: python3 provenance.py [--write-manifest] (--write-manifest is for the authors: it rewrites MANIFEST.sha256; SOURCES.json is written by --write-sources)""" +import hashlib, json, os, sys +PKG = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +bad = 0 +def sha(b): return hashlib.sha256(b).hexdigest() +def listing(): + out = [] + for d, ds, fs in os.walk(PKG): + ds[:] = sorted(x for x in ds if x != '__pycache__' and x != 'bin') + for f in fs: + if f.endswith('.pyc') or f == '.DS_Store': continue + p = os.path.relpath(os.path.join(d, f), PKG) + if p != 'MANIFEST.sha256': out.append(p) + return sorted(out) +if '--write-manifest' in sys.argv: + with open(os.path.join(PKG, 'MANIFEST.sha256'), 'w') as h: + for p in listing(): h.write('%s %s\n' % (sha(open(os.path.join(PKG, p), 'rb').read()), p)) + print('wrote MANIFEST.sha256 (%d files)' % len(listing())); sys.exit(0) +if '--write-sources' in sys.argv: + S = json.load(open(os.path.join(PKG, 'SOURCES.json'))) + for sect in ('files', 'evidence'): + for e in S[sect]: e['sha256'] = sha(open(os.path.join(PKG, e['file']), 'rb').read()) + json.dump(S, open(os.path.join(PKG, 'SOURCES.json'), 'w'), indent=1); print('wrote SOURCES.json pins'); sys.exit(0) +want = {} +for l in open(os.path.join(PKG, 'MANIFEST.sha256'), encoding='utf-8'): + h, p = l.rstrip('\n').split(' ', 1); want[p] = h +have = listing(); n = 0 +for p in sorted(set(want) | set(have)): + f = os.path.join(PKG, p) + if p not in want: print('FAIL 0.manifest extra file not in MANIFEST: ' + p); bad += 1 + elif not os.path.isfile(f): print('FAIL 0.manifest missing file: ' + p); bad += 1 + elif sha(open(f, 'rb').read()) != want[p]: print('FAIL 0.manifest hash differs: ' + p); bad += 1 + else: n += 1 +print('%s 0.manifest %d files match MANIFEST.sha256' % ('PASS' if not bad else 'FAIL', n), flush=True) +S = json.load(open(os.path.join(PKG, 'SOURCES.json'))); b0 = bad; k = 0 +for sect in ('files', 'evidence'): + for e in S[sect]: + k += 1; f = os.path.join(PKG, e['file']) + if not os.path.isfile(f): print('FAIL 0.sources missing ' + e['file']); bad += 1 + elif sha(open(f, 'rb').read()) != e['sha256']: print('FAIL 0.sources pin differs: ' + e['file']); bad += 1 +print('%s 0.sources %d pins hold (checks, libraries, C sources, data, evidence snapshots)' % ('PASS' if bad == b0 else 'FAIL', k - (bad - b0)), flush=True) +sys.exit(1 if bad else 0) diff --git a/research/three-total-decoders/verify.sh b/research/three-total-decoders/verify.sh new file mode 100644 index 0000000000..b8c6374f5e --- /dev/null +++ b/research/three-total-decoders/verify.sh @@ -0,0 +1,123 @@ +#!/usr/bin/env bash +# One-command verification of research/three-total-decoders (no kappa claim): reductions, partial theorems, the sharp example tied_min and the +# lift route for three-total root-unit decoders under #446 Theorem C. Step 0 checks the package against MANIFEST.sha256 and every pin of SOURCES.json and +# stops hard on any mismatch. Then C sources are compiled and seven check groups run one after the other (single process; python-sat and a C compiler only), +# printing one PASS/FAIL line per assertion. Exit status 0 only if every assertion passes. +# usage: bash verify.sh [/fresh/output/dir] (inside a checkout or `git archive` of the repository; nothing outside the package is read) +# needs python3 >= 3.11 with python-sat (requirements.txt) and cc; set PYTHON to choose the interpreter, CC for the compiler. No external solver binary is run. +# Not re-run here: the Hesse experiment itself (README, Outcome X2), the G1 provers, the CP-SAT solve behind the multi-copy certificate (its certificate IS verified), #2031. +set -uo pipefail +HERE=$(cd "$(dirname "$0")" && pwd) +OUT=${1:-$(mktemp -d "${TMPDIR:-/tmp}/three-total-decoders.XXXXXX")} +mkdir -p "$OUT"; OUT=$(cd "$OUT" && pwd) +case "$OUT/" in "$HERE"/*) echo "output dir must be outside the package"; exit 2;; esac +PY="${PYTHON:-python3}"; CC="${CC:-cc}"; export PYTHONDONTWRITEBYTECODE=1 +T0=$SECONDS +echo "== 0. manifest and provenance" +if ! "$PY" -B "$HERE/scripts/provenance.py" | tee "$OUT/provenance.log" | sed 's/^/ /' || grep -q '^FAIL' "$OUT/provenance.log" \ + || [ "$(grep -c '^PASS' "$OUT/provenance.log")" != 2 ]; then + echo "step 0 FAILED"; exit 1 +fi +# work tree: scripts and binaries live here, never in the package +R="$OUT/tree"; mkdir -p "$R" "$OUT/logs" "$R/bin" +cp -R "$HERE/checks" "$HERE/lib" "$HERE/data" "$HERE/c" "$R/" +export TMPDIR="$OUT/tmp"; mkdir -p "$TMPDIR"; export TTD_BIN="$R/bin" +E_="$PY -B $R/checks/expect.py" +run() { local n=$1; shift; ( cd "$R/checks" && "$@" > "$OUT/logs/$n.log" 2>&1; echo $? > "$OUT/logs/$n.rc" ); } +chk() { local l=$1 n=$2; shift 2; $E_ "$l" "$OUT/logs/$n.log" "$@" | tee -a "$OUT/all.out"; } + +echo "== G0 compile the five C programs from source" +ok=1; for p in enumall tusign jsign mas brutetu; do "$CC" -O2 -o "$R/bin/$p" "$R/c/$p.c" > "$OUT/logs/cc_$p.log" 2>&1 || ok=0; done +if [ "$ok" = 1 ]; then echo "PASS G0.compile enumall tusign jsign mas brutetu" | tee -a "$OUT/all.out"; else echo "FAIL G0.compile see $OUT/logs/cc_*.log" | tee -a "$OUT/all.out"; fi + +echo "== G1 tied_min: cost = v = 12 (exchange proof, 217 optima, lifts)" +run tied_min $PY -B tied_min.py +chk G1.structure tied_min --has '^TM structure: v=12 points all full support with entries \+-1: True; q two-support: True; \|D\(t\)\|=2 for every line \(tied\): True; incidences 72; block row sets all 12 rows: True$' \ + --has '^TM classes \(missing coordinate of q\): sizes \[4, 4, 4\]; distinct points 4, distinct q-lines 6$' --has '^TM H strongly connected \(Lemma SCC\): True$' +chk G1.step-a tied_min --has '^TM step \(a\): MAS\(G\[D_j\]\) for j=0,1,2: \[3, 3, 3\]$' +chk G1.step-b tied_min --count '^TM step \(b\) j=[012]: block rank <= 3 fillings of its 8 columns: 1; \(dim S_k, dim S_l, dim\(S_k\+S_l\), class-[012] rows vanish\) = \[\(\(3, 3, 3\), True\)\]$' 3 +chk G1.step-c tied_min --has '^TM step \(c\): B\[T_j,C_j\] is 4x4 with \(free entries, minimum F2 rank over all fillings\) = \[\(8, 2\), \(8, 2\), \(8, 2\)\]$' +chk G1.cnf tied_min --has '^TM CNF cost<=11: UNSAT$' --has '^TM CNF cost<=12: SAT, block ranks recomputed by elimination \[4, 4, 4\]$' +chk G1.optima tied_min --has '^TM optima: B with block ranks <= \(4,4,4\) enumerated to exhaustion: 217$' --has '^TM optima: block-rank triples \[\(4, 4, 4\)\], costs \[12\]$' \ + --has "^TM optimum kind: class-diagonal: dim S_k \(2, 2, 2\), rank B 6, w \(2, 2, 2\), class-block ranks \(2, 2, 2\) -> 216 matrices$" \ + --has "^TM optimum kind: cross-class entries 24: dim S_k \(4, 4, 4\), rank B 4, w \(0, 0, 0\), class-block ranks None -> 1 matrices$" \ + --has '^TM special optimum B0: S_0 = S_1 = S_2 = W \(column spaces equal, dim 4\): True$' +chk G1.f2s-identity tied_min --has '^TM F2S identity cost = 3\*rho - sum_j w_j .*holds for 217 of 217 optima$' +chk G1.lifts tied_min --has '^TM lifts: .*\(4,4,4\): 217 of 217; whole 12x12 B TU-signable: 217 of 217$' +chk G1.subconfigurations tied_min --has '^TM every one-line deletion has cost >= 12 \(cost <= 11 UNSAT\): 12 of 12$' \ + --has '^TM first tight 10-line subconfiguration \(cost <= 9 UNSAT, cost <= 10 SAT\): \(0, 1, 2, 3, 4, 5, 6, 7, 9, 10\)$' --absent 'Traceback' + +echo "== G2 lift route: v = 9 whole-TS counterexample, joint block-TU counterexamples (X1 evidence), Theorem 9.3" +run g1_cex $PY -B g1_cex.py +run lifts $PY -B lifts.py +chk G2.w9-instance g1_cex --has '^W9 v=9 f=13 mincost=18 minimisers=16 block ranks \[\(7, 4, 7\)\] offdiag-ones 8..12$' \ + --has '^W9 the 8-ones minimiser of PROOF section 6 occurs: True \(number of 8-ones minimisers 1\)$' \ + --has '^W9 degeneracy: lines 1,2 equal True; lines 4,6 equal True; lines 7,8 same projective line True; points 4,5 coincide True$' +chk G2.w9-no-whole-TS g1_cex --has '^W9 whole-matrix TU-signable: 0 of 16; all three blocks TU-signable: 16 of 16; jointly block-TU signable: 16 of 16; python Camion agrees: True$' +chk G2.w9-lift g1_cex --has '^W9 joint signing has exact Q block ranks equal to the F2 ranks for 16 of 16 minimisers; \(A\) 18 >= v = 9: True$' +chk G2.j7-no-joint g1_cex --has '^J7 v=7 f=11 mincost=12 minimisers=4 off-diagonal ones \[7, 8, 9, 10\] block ranks \[\(4, 4, 4\)\]$' \ + --has '^J7 submatrix rows 0,2,3,4 x cols 0,3,4,6 .*: \[\(7, False\), \(8, False\), \(9, False\), \(10, False\)\]$' \ + --has '^J7 jointly block-TU signable: 0 of 4; whole-matrix TU-signable: 0; block 2 TU-signable: 0; blocks 0,1 TU-signable: 4,4; python Camion agrees: True; \(A\) 12 >= v = 7: True$' +chk G2.j7-lift g1_cex --has '^J7 lift: the printed rational 7x7 matrix has the support of a minimiser: True; exact Q block ranks \[4, 4, 4\], F2 block ranks \[4, 4, 4\]$' \ + --has '^J7 block 2 has 4 nonzero rows of 6 ' +chk G2.j10-no-joint g1_cex --has '^J10 v=10 f=19 mincost=14 minimisers=2 block ranks \[\(5, 4, 5\)\] jointly block-TU signable 0; block-wise TU-signable \(b0 b1 b2\) \[\(1, 1, 0\), \(1, 1, 0\)\]; \(A\) True$' +chk G2.failure-modes g1_cex --has '^C8 v=8 f=11 mincost=16 minimisers=320; minimisers with all blocks TU-signable but NO joint signing \(Cech, F2\): 1; jointly signable: 318$' \ + --has '^C8 python Camion agrees on the Cech minimisers: True$' \ + --has '^S8 v=8 f=12 mincost=14 minimisers=2 ones \[9, 9\] block ranks \[\(4, 5, 5\)\]; whole-TU \[1, 0\]; block TU flags \[\(1, 1, 1\), \(0, 1, 1\)\]; jointly signable 1$' \ + --has '^S8 the two minimisers differ by one swap of ones: True$' +chk G2.obstructions g1_cex --has '^L91 TU-signable: J2 True, odd 3-cycle True, F7 submatrix \[110,011,101,111\] False$' --has '^L91 odd theta of supmin_fail_v8 \(rows 0,1,2,6 x cols 0,3,4,6\): TU-signable False$' +chk G2.theorem-9.3 g1_cex --has '^T93 Camion system \(jsign.c\) vs exhaustive signings x exhaustive minors \(brutetu.c\): 53 instances, 53 agree on \(J,b0,b1,b2\), 0 skipped as out of range$' \ + --has '^T93 outcome classes seen: J=0 b=011 x2, J=0 b=100 x1, J=0 b=101 x2, J=0 b=110 x4, J=0 b=111 x2, J=1 b=111 x42$' \ + --has '^T93 Cech case \(every block signable, no joint signing\) confirmed by the exhaustive oracle: True$' +chk G2.nojoint14 g1_cex --has '^NJ14 instances nojoint_21_1..14 \(v 7-10\): minimisers without a joint block-TU signing: 14 of 14 instances \(joint signings in total 0\); \(A\) cost >= v in 14;' +chk G2.nojoint-lifts lifts --has '^NL lifts: 102 stored \(16 configurations: .*minimiser 102, support equal 102, diagonal nonzero 102, exact Q block ranks <= F2 ranks 102 \(equal 102\) of 102$' --has '^NL cex_joint_v7 minimisers lifted: 4 of 4$' --absent 'Traceback' +chk G2.gadget g1_cex --has '^GAD v=10 f=29 .*: 11 off-diagonal ones, block ranks \[6, 6, 7\] sum 19 = 19: True; block TU-signable flags \[True, False, False\]; whole B TU-signable False$' --absent 'Traceback' + +echo "== G3 cex_min_1: the one-copy certificate stops at 18, the multi-copy certificate (verified, not solved) reaches 20" +run mcc_cex $PY -B mcc_cex.py +chk G3.cex-structure mcc_cex --has '^CX v=19 entries in \{-1,0,1\}: True; \|D\(t\)\| odd for 8 lines \(set G\), even \(=2, tied\) for 11$' \ + --has '^CX D-types \{\(0,\): 4, \(0, 1\): 3, \(0, 1, 2\): 1, \(0, 2\): 5, \(1,\): 1, \(1, 2\): 3, \(2,\): 2\}$' +chk G3.parity-lemmas mcc_cex --has '^CX Lemma 1.1: every incidence t->s has \|pi\(t\) & sigma\(s\)\| in \{0,2\}: True \(114 incidences\)$' \ + --has '^CX Lemma 1.2: tied lines of the same \(D, eps\) are never incident: True \(6 classes\)$' \ + --has '^CX pool: 121 primitive pairs \(p,q\) in \{-1,0,1\}\^3 with p.q != 0 \(13 vectors up to sign\); Lemma 1.1 on all incidences of the pool: True$' +chk G3.mcc-certificate mcc_cex --has '^CX MCC: stored solution has 20 copies on 17 lines \(up to 2 per line\); .*forward: True$' --has '^CX MCC: 20 copies >= v = 19: True$' +chk G3.lemma-MC mcc_cex --has '^CX Lemma MC on 60 admissible B \(incl. B = I\): N unit upper triangular for 60 of 60; sum_j rank B_j >= 20 for 60 of 60 ' \ + --has '^CX stored B of cost <= 22: admissible True; block ranks \[10, 6, 6\] sum 22; so 20 <= cost\(cex_min_1\) <= 22$' --absent 'Traceback' + +echo "== G4 partial theorems and reductions: M1, U, SCC, Peel" +run thm $PY -B thm.py +chk G4.M1 thm --has '^M1 80 random configurations with every point having a zero coordinate \(v 6-14\): violations of MAS-sum >= sum_t c\(t\) >= v/2: 0; ' \ + --has '^M1 sharpness digon: v=2, sum_t c\(t\) = 1, MAS-sum 1, exact cost 2 ' +chk G4.U thm --has '^U cex_min_1: certificate sizes for the three special coordinates \[\(15, 8, 11\), \(15, 8, 11\), \(15, 8, 11\)\] ' --has '^U 121-line pool: sizes \[106, 106, 106\]; best 106 of v = 121$' \ + --has '^U 250 random unit-world configurations \(4-60 lines, forced incidences\): every scheme valid; smallest best-certificate/v = .*\(>= 1/2: True\)$' +chk G4.SCC thm --has '^SCC block upper-triangularity in topological order of the strong components of H: 300 of 300 random configurations ' --has '^SCC component sizes: tied_min \[12\], cex_min_1 \[19\]$' +chk G4.PP thm --has '^PP lone tied lines of tied_min cost \[2\]; lines 0 and 3 \(different point, different line: True\) together cost 2, so no group X ' +chk G4.Peel thm --has '^PEEL 36 configurations with a unit-support point or line: exact cost\(config\) >= cost\(config - t\) \+ 1 violated in 0$' --has '^MONO exact cost\(sub-configuration\) <= cost\(config\) violated in 0 of 36$' --absent 'Traceback' + +echo "== G5 F2S rowspace identity" +run f2s $PY -B f2s.py +chk G5.identity f2s --has '^F2S identity cost = 3 rho - sum_j w_j on 179 .*: holds in 179; cost >= 2 rho in 179; sum_j w_j <= rho \(direct sum\) in 179$' --has '^F2S 8 random F2S configurations \(v 6-8\): cost <= v-1 UNSAT \(cost >= v\) in 8$' --absent 'Traceback' + +echo "== G6 non-degenerate admissible B that is not TU-signable (aff14)" +run nondeg $PY -B nondeg.py +chk G6.aff14 nondeg --has '^NG aff14: n=14 admissible True; points pairwise distinct True; lines pairwise distinct True; off-diagonal ones 24; K22 \(L6 pattern, 4 distinct indices\) present: False$' \ + --has '^NG aff14: blocks R_j x A_j equal to the whole matrix for j in \[2\]; block ranks \[9, 11, 11\]; whole B TU-signable \(Camion\): False$' --absent 'Traceback' + +echo "== G7 Hesse harness (smoke only; the experiment is described in README, Outcome X2)" +run hesse_smoke $PY -B hesse_smoke.py +chk G7.hesse hesse_smoke --has '^HS Hesse configuration over Z\[w\] \(w\^2\+w\+1=0\): 9 points, 12 lines, points per line \[3\], lines per point \[4\]; intersection points of the lines 21$' \ + --has '^HS every pair of the 9 points lies on one of the 12 lines \(no ordinary line\): True$' \ + --has '^HS smoke sample: 16 random configurations .*: smallest cost - v = 0, cost = v in 1, cost < v in 0$' --absent 'Traceback' +# X2 hook: if the Hesse experiment ends BELOW-v FOUND, the configuration(s) go to data/hesse_below_*.json (README, Outcome X2) and are evaluated exactly here. +EXPECT=34 +nb=$(ls "$HERE"/data/hesse_below_*.json 2>/dev/null | wc -l | tr -d ' ') +if [ "$nb" -gt 0 ]; then + echo "== G7b Hesse configurations below v (data/hesse_below_*.json)" + run hesse_below $PY -B hesse_below.py + chk G7.below hesse_below --has '^HB all [1-9][0-9]* configurations have exact minimum cost below v$' --absent 'Traceback' --absent '>= v' + EXPECT=$((EXPECT+1)) +fi + +npass=$(grep -c '^PASS' "$OUT/all.out"); nfail=$(grep -c '^FAIL' "$OUT/all.out") +echo "== done in $((SECONDS - T0))s: $((npass + 2)) PASS (2 in step 0), $nfail FAIL; logs in $OUT" +[ "$nfail" = 0 ] && [ "$npass" = "$EXPECT" ] || { echo "FAILED: expected $EXPECT assertion PASS lines after step 0, got $npass PASS / $nfail FAIL"; exit 1; }