From 01651795be9570c47977a73f9cf3e8eeb3fbe64a Mon Sep 17 00:00:00 2001 From: DreamingOfClouds Date: Sat, 7 Nov 2026 04:30:34 -0600 Subject: [PATCH] Add a 14-port Hall obstruction to rank-8 complex realisations of P104 (no kappa) Co-Authored-By: Claude Opus 5.5 --- research/p104-rank8-hall-obstruction/LICENSE | 201 ++++++++++++++++++ research/p104-rank8-hall-obstruction/NOTICE | 5 + .../p104-rank8-hall-obstruction/PR_BODY.md | 24 +++ .../p104-rank8-hall-obstruction/README.md | 83 ++++++++ .../p104-rank8-hall-obstruction/SOURCES.json | 37 ++++ .../p104-rank8-hall-obstruction/TASK.json | 134 ++++++++++++ .../p104-rank8-hall-obstruction/VERIFY.json | 21 ++ research/p104-rank8-hall-obstruction/check.py | 143 +++++++++++++ .../retained/expected-output.txt | 20 ++ .../retained/s_asymA.sing | 33 +++ .../retained/s_asymA_Z.sing | 33 +++ .../retained/s_asymA_c0.sing | 33 +++ .../retained/s_asymA_c3.sing | 33 +++ .../retained/s_asymA_c5.sing | 33 +++ .../p104-rank8-hall-obstruction/verify.sh | 4 + 15 files changed, 837 insertions(+) create mode 100644 research/p104-rank8-hall-obstruction/LICENSE create mode 100644 research/p104-rank8-hall-obstruction/NOTICE create mode 100644 research/p104-rank8-hall-obstruction/PR_BODY.md create mode 100644 research/p104-rank8-hall-obstruction/README.md create mode 100644 research/p104-rank8-hall-obstruction/SOURCES.json create mode 100644 research/p104-rank8-hall-obstruction/TASK.json create mode 100644 research/p104-rank8-hall-obstruction/VERIFY.json create mode 100644 research/p104-rank8-hall-obstruction/check.py create mode 100644 research/p104-rank8-hall-obstruction/retained/expected-output.txt create mode 100644 research/p104-rank8-hall-obstruction/retained/s_asymA.sing create mode 100644 research/p104-rank8-hall-obstruction/retained/s_asymA_Z.sing create mode 100644 research/p104-rank8-hall-obstruction/retained/s_asymA_c0.sing create mode 100644 research/p104-rank8-hall-obstruction/retained/s_asymA_c3.sing create mode 100644 research/p104-rank8-hall-obstruction/retained/s_asymA_c5.sing create mode 100755 research/p104-rank8-hall-obstruction/verify.sh diff --git a/research/p104-rank8-hall-obstruction/LICENSE b/research/p104-rank8-hall-obstruction/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-rank8-hall-obstruction/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/p104-rank8-hall-obstruction/NOTICE b/research/p104-rank8-hall-obstruction/NOTICE new file mode 100644 index 0000000000..b0be83829d --- /dev/null +++ b/research/p104-rank8-hall-obstruction/NOTICE @@ -0,0 +1,5 @@ +A 14-port Hall obstruction to rank-8 realisations of P104 under the complex label pattern (no new kappa). +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Apache-2.0. + +The 104 ports are read from research/p104-designer-toolkit-v2/words/5561.json.gz (the word of #5561); the package copies nothing +from it. retained/ holds the Singular input files that re-derive the k = 1 statement over several coefficient rings, with their output. diff --git a/research/p104-rank8-hall-obstruction/PR_BODY.md b/research/p104-rank8-hall-obstruction/PR_BODY.md new file mode 100644 index 0000000000..bd22a8ba09 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/PR_BODY.md @@ -0,0 +1,24 @@ +Title: Prove that P104 has no rank-8 complex realisation over any field: a 14-port Hall obstruction (no ฮบ) + +No ฮบ claim. This adds `research/p104-rank8-hall-obstruction/`, a registered research package for the card `p104-side-correction`. + +**Result.** Assume the complex label pattern: each of the 104 ports of the #5561 word carries a pair of label matrices of size k ร— d over a +field, the pairing between ports vanishes exactly on the E8-non-orthogonal pairs (port pairs with zero F2 dot product), and every diagonal +block is invertible. The pairing may be asymmetric. Then no realisation has inner dimension exactly 8k, over any field of any +characteristic. For k = 1 the minimum rank is at least 9. + +**Proof sketch.** Eight pairwise forced-zero ports (`62, 63, 69, 74, 81, 86, 91, 99`) fix a gauge. Six further ports +(`57, 67, 68, 95, 100, 101`) are then supported on at most five of those coordinates, any two of them sharing a coordinate are forced zero and +share only that one, so the stacked products at each coordinate are block diagonal and have rank at most k. The six invertible diagonal +blocks need total rank 6k, but only 5k is available: a Hall deficiency. + +**Checks.** `check.py` (standard library, under a second) verifies the clique, the coordinate sets, the 11 sharing pairs, the +absence of a system of distinct representatives, an exhaustive F2 and F3 search of the gauge-fixed 14-port system, a satisfiable control, and a +satisfiable dimension-9 realisation. Singular inputs and outputs (rings Z/2, Q, Z/3, Z/5, Z) are retained. + +**Scope.** The label pattern is a hypothesis. Ranks strictly between 8k and 9k (k >= 2), other masks and any pricing are not covered; they are +listed as open questions in the package. + +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. + +๐Ÿค– Generated with [Claude Code](https://claude.com/claude-code) diff --git a/research/p104-rank8-hall-obstruction/README.md b/research/p104-rank8-hall-obstruction/README.md new file mode 100644 index 0000000000..7197471b67 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/README.md @@ -0,0 +1,83 @@ +# A 14-port Hall obstruction to rank-8 realisations of P104 (no ฮบ) + +**No new ฮบ.** This package proves that, under a stated label pattern, the 104 ports of the #5561 word have no realisation of inner +dimension exactly `8k`, over any field. The obstruction is combinatorial: fourteen of the ports already have a Hall deficiency. + +## Statement + +**Hypothesis (complex label pattern).** Each port `T` carries a pair of `k ร— d` matrices `U_T, W_T` over a field `F` (`d` is the inner +dimension; `k >= 1` is the label dimension), and the pairing `B_ST = W_S U_T^T` (`k ร— k`) satisfies + +* `B_ST = 0` for every pair `S != T` of ports with F2 dot product 0 (the "forced-zero" pairs, which are the E8-non-orthogonal pairs of + the 104 ports; the ports are 9-bit odd-weight vectors and the rule is `popcount(p_S & p_T)` even); +* `B_TT` invertible for every port `T`. + +`W != U` is allowed (asymmetric and Hermitian-type pairings are covered). The pattern is an assumption: it records how the pairing +of the labels of a complex-field construction is constrained at its frame contacts. It is not proved here for any word, and the +mask is not the one used for the real-valued completion in `research/p104-designer-toolkit-v2/P104-LEMMAS.md` (there the forced values are +on the pairs of F2 dot product 1). + +**Theorem.** Under this hypothesis, for the ports of `research/p104-designer-toolkit-v2/words/5561.json.gz` (0-based indices), no +realisation has inner dimension `d = 8k`, over any field of any characteristic, for any `k >= 1`. For `k = 1`: the minimum rank is +at least 9 (`d = 8` is impossible, and `d < 8` is excluded by the 8-clique below). + +**Scope.** Ranks `8k < d < 9k` (`k >= 2`) are *not* covered. Other masks are not covered. Nothing is priced. + +## The obstruction + +`K = {62, 63, 69, 74, 81, 86, 91, 99}` is a clique of the forced-zero graph (its clique number is 8, so `K` is maximal and no +9-clique exists). `O = {57, 67, 68, 95, 100, 101}`. Writing `A(T)` for the members of `K` that are *not* forced-zero to `T`: + +| T | 57 | 67 | 68 | 95 | 100 | 101 | +|---|---|---|---|---|---|---| +| A(T) | {62, 91} | {63, 99} | {62, 99} | {62, 63} | {62, 69} | {63, 69} | + +The union is `{62, 63, 69, 91, 99}` (five coordinates for six ports). Any two ports of `O` with a common coordinate are forced zero +and have exactly one common coordinate (11 such pairs). `check.py` verifies all of this from the ports. + +## Proof + +Let `d = 8k` and suppose a realisation exists. + +1. **Gauge.** `K` is a forced-zero clique, so `B_KK` is block diagonal with invertible diagonal blocks and has rank `8k`. As + `B_KK = W_K U_K^T` with `W_K, U_K` of size `8k ร— d = 8k ร— 8k`, both are invertible. Replace `U` by `U g`, `W` by `W h` with + `g = U_K^{-1}` and `h = g^{-T}`; the pairing is unchanged and now `U_K = I`, `W_K = B_KK`. Multiplying the block rows of `W_k` + (`k โˆˆ K`) on the left by `B_kk^{-1}` changes only block row `k` of `B` by an invertible left factor, which preserves every + zero block and every invertible diagonal block. So `U_K = W_K = I`. +2. **Support.** Write `U_T = (U_T[c])_{c โˆˆ K}` and `W_T = (W_T[c])_{c โˆˆ K}` in `k ร— k` blocks. Then `B_{kT} = U_T[k]^T` and + `B_{Tk} = W_T[k]`, so a forced-zero pair `(T, k)` gives `U_T[k] = W_T[k] = 0`: both are supported on `A(T)`. +3. **X Y^T is block diagonal.** Fix `c โˆˆ K` and let `O_c = {T โˆˆ O : c โˆˆ A(T)}`. Any two `S != T` in `O_c` are forced zero and share + only the coordinate `c`, so `B_ST = W_S[c] U_T[c]^T = 0`. Let `X` be the stack of the `W_T[c]` and `Y` the stack of the `U_T[c]` + over `T โˆˆ O_c` (each block `k ร— k`). Then `X Y^T` is block diagonal with diagonal blocks `W_T[c] U_T[c]^T`, and as a product through + dimension `k` it has rank at most `k`. Hence, with `r_T(c) = rank(W_T[c] U_T[c]^T)`, + `sum_{T โˆˆ O_c} r_T(c) <= k`. +4. **Rank sum.** `B_TT = sum_{c โˆˆ A(T)} W_T[c] U_T[c]^T` is invertible, and rank is subadditive, so `sum_c r_T(c) >= k`. + Summing over the six ports and exchanging the sums: + `6k <= sum_{c} sum_{T โˆˆ O_c} r_T(c) <= k ยท |{62, 63, 69, 91, 99}| = 5k`, + a contradiction. `โˆŽ` + +For `k = 1` the rank sum is the pigeonhole principle: each of the six ports needs a coordinate where both of its entries are non-zero, two ports +cannot use the same coordinate, and there are five coordinates. + +## What `check.py` verifies (about 0.3 s, standard library) + +* ports are 104 distinct odd-weight 9-bit vectors; the forced-zero graph has clique number 8 and `K` is a maximal clique; +* the `A(T)` table, the five coordinates, the 11 sharing pairs (all forced zero, one common coordinate each); +* `k = 1`, any field: no system of distinct representatives for `A(57), ..., A(101)`; +* `k = 1`, `F_2` and `F_3`: an exhaustive search of the gauge-fixed asymmetric 14-port system, with all `U_T, W_T` entries free on the + eight coordinates (supports are derived from the mask, not assumed): zero solutions; +* a satisfiable control for the same search (port 101 left out), and a satisfiable symmetric dimension-9 realisation of the whole + 14-port mask (one extra coordinate lets the six ports have distinct active coordinates). + +`retained/` holds the Singular inputs for the support-reduced `k = 1` system (`s_asymA*.sing`: rings `Z/2`, `Q`, `Z/3`, `Z/5`, `Z`) and +`expected-output.txt`: the standard basis is the unit ideal in each ring. They need Singular and are not run by `verify.sh`. + +## Open next questions + +1. **Change the label pattern.** Which mechanism forces the pairing to vanish on every zero-dot pair, and can a contact be routed + through a paid helper so that one forced zero inside each Hall-deficient configuration is broken? Every rank-`8k` route has to do + this for configurations like the 14 above. +2. **Ranks strictly between `8k` and `9k`** (`k >= 2`). The gauge needs `d = 8k`; with a free extra column the rank sum may or may not close. +3. **Other port systems.** Apply the same support argument (distinct representatives over a forced-zero clique) to other port sets. + +See `TASK.json` for first steps and blockers. Credit: DreamingOfClouds. diff --git a/research/p104-rank8-hall-obstruction/SOURCES.json b/research/p104-rank8-hall-obstruction/SOURCES.json new file mode 100644 index 0000000000..3ac5f08e9b --- /dev/null +++ b/research/p104-rank8-hall-obstruction/SOURCES.json @@ -0,0 +1,37 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "docs/research/research-family-status.md", + "usage": "provenance", + "git_blob": "3c19b18ef7225b47f0abcd9d51ae7c83d0cdfd15", + "sha256": "92c8010dfd9fc33e921f70526231f8689e06ea784f1b1387d895344b227f36d7" + }, + { + "path": "docs/research/current-priorities.md", + "usage": "provenance", + "git_blob": "6f5d40d13d8f3bdc12ce7954c8c3eb4ab1f8be91", + "sha256": "70f61c8d140ae6e892f2b8f065bba4eae3e76f7a8f55f632fd4e2f9f34039bdc" + }, + { + "path": "research/p104-designer-toolkit-v2/P104-LEMMAS.md", + "usage": "provenance", + "git_blob": "129f28dd10c9e1c43d29a9dd280e022070288a73", + "sha256": "54263ecdcabb067b1f77749ae60cb1f430c02fd720b63e5e39f358f6bfee78ec" + }, + { + "path": "research/p104-designer-toolkit-v2/words/5561.json.gz", + "usage": "input", + "git_blob": "c367d865a154ffd2ae0b6f6053469580a139f487", + "sha256": "b3701d78bee3661382ebe5414e678dfc9ee292e254cb9dc56339c2d2f45fdf44" + } + ], + "source_availability": "Every listed file is a blob of the base commit; check.py reads only research/p104-designer-toolkit-v2/words/5561.json.gz, which is declared as a VERIFY.json input and checked against its pinned blob." +} \ No newline at end of file diff --git a/research/p104-rank8-hall-obstruction/TASK.json b/research/p104-rank8-hall-obstruction/TASK.json new file mode 100644 index 0000000000..a5f5b8d055 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/TASK.json @@ -0,0 +1,134 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove that under the complex label pattern (the pairing between port labels is forced zero exactly on port pairs with zero F2 dot product, the E8-non-orthogonal pairs, with invertible diagonal blocks, stated as a hypothesis) no realisation of the 104 ports of the #5561 word has inner dimension exactly 8k, over any field and for symmetric or asymmetric pairings; for k = 1 the minimum rank is at least 9. The obstruction is a Hall deficiency on 14 ports, and ranks strictly between 8k and 9k for k >= 2 are not covered.", + "scope_change_reason": "The card asks for a helper-basis and causal-split construction on the complete invoice. This package is a rank obstruction for one label pattern on one port set; it constructs no word, prices nothing and splits nothing. It limits which label dimensions a rank-8 route could use.", + "bottleneck_link": "docs/research/research-family-status.md; the statement removes one inner dimension (8k) for every complete-invoice construction whose labels follow the stated pattern, so such a construction has to pay the next rank or change the pattern.", + "stop_rule": "No kappa claim. The theorem is conditional on the complex label pattern, which is a hypothesis about how labels pair, not something proved here for any word; it says nothing for ranks strictly between 8k and 9k when k >= 2, for other masks, or for any pricing of a word.", + "evidence": "README.md (statement and self-contained proof), check.py (exact checks on the ports of #5561 with controls), retained/ (Singular inputs over Z/2, Z/3, Z/5, Q and Z with their output).", + "author": "DreamingOfClouds", + "ai_assistance": "Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.", + "outcome": "completed", + "open_questions": [ + { + "question": "Which mechanism in a complex supplier actually forces the pairing to vanish on every zero-dot port pair, and can a contact be routed through a paid helper so that one forced zero inside every Hall-deficient configuration is broken?", + "why_it_matters": "The theorem is only as strong as the label pattern; every rank-8k route must break a forced zero inside each configuration like the 14 ports found here.", + "first_step": "List, for the six O ports and the eight K ports, the frame contacts of the #5561 word that produce the zeros B_ST = 0, then re-run check.py with one pair of the 11 sharing pairs removed from the mask and record which single pair removals restore k = 1 satisfiability.", + "blocked_by": "The frame-contact derivation of the pattern from the supplier rules has not been written as a statement; without it the mask change cannot be priced." + }, + { + "question": "For k >= 2, is there a realisation of inner dimension strictly between 8k and 9k under the same pattern?", + "why_it_matters": "The proof only excludes exactly 8k; a fractional saving per label block would be a different route from rank 9.", + "first_step": "For k = 2 and inner dimension 17, write U_K, W_K as 16 x 17 matrices of rank 16 and compute, by exact linear algebra over F_2 on the 14 ports, whether the six-port Hall count 6k <= 5k can be repaired by the single extra column; start by enumerating the sharing-pair constraints of the proof with that extra column.", + "blocked_by": "The gauge U_K = W_K = I needs invertible U_K, W_K, which holds only at inner dimension exactly 8k; the argument has to be redone with a free extra column." + }, + { + "question": "Does another system of ports with the same stated pattern have a Hall deficiency that survives a larger inner dimension, or a system outside P104 for which the pattern admits rank 8?", + "why_it_matters": "A line system that passes the Hall check at 8 would be a candidate host, while a deficiency at larger dimension would extend the obstruction.", + "first_step": "Apply check.py's support argument (distinct representatives of A(T) over a maximal forced-zero clique) to subsystems of the 104 ports of other P104 words and to the E7-type hyperplane subsystem of 56 ports.", + "blocked_by": "None; a computation on exported port lists." + } + ], + "research_context": { + "sources": [ + "research/p104-designer-toolkit-v2/words/5561.json.gz (ports), research/p104-designer-toolkit-v2/P104-LEMMAS.md (arena and the related rank-8 statement for a different mask)" + ], + "credit": "DreamingOfClouds." + }, + "selected_frontier_changed": false +} \ No newline at end of file diff --git a/research/p104-rank8-hall-obstruction/VERIFY.json b/research/p104-rank8-hall-obstruction/VERIFY.json new file mode 100644 index 0000000000..19db2360dd --- /dev/null +++ b/research/p104-rank8-hall-obstruction/VERIFY.json @@ -0,0 +1,21 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-designer-toolkit-v2/words/5561.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/check.py" + ], + "timeout_seconds": 120, + "checks": "From the 104 ports of 5561: the 8-clique K and its maximality and clique number 8 of the forced-zero graph; the sets A(T) for the six O ports, the 5 available coordinates and the 11 forced-zero sharing pairs (each sharing exactly one coordinate); the k = 1 field-free support argument (no system of distinct representatives); an exhaustive gauge-fixed search of the 14-port asymmetric system over F_2 and F_3 (no solution) with a satisfiable 13-port control; a satisfiable dimension-9 control on all 14 ports." + } + ] +} \ No newline at end of file diff --git a/research/p104-rank8-hall-obstruction/check.py b/research/p104-rank8-hall-obstruction/check.py new file mode 100644 index 0000000000..eddabe1821 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/check.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +"""Exact checks for the 14-port Hall obstruction on P104. Python 3.12, standard library only. + +Run: python3 -I -B research/p104-rank8-hall-obstruction/check.py +Marker: PASS_P104_RANK8_HALL_OBSTRUCTION + +Input: the 104 ports of research/p104-designer-toolkit-v2/words/5561.json.gz (9-bit integers). +Mask: ports s != t are "forced zero" when their F2 dot product is 0 (the complex label pattern). +""" +import gzip +import itertools +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PORTS_FILE = HERE.parent / "p104-designer-toolkit-v2" / "words" / "5561.json.gz" + + +def require(ok, msg): + if not ok: + raise ValueError(msg) + + +ports = json.loads(gzip.decompress(PORTS_FILE.read_bytes()))["ports"] +n = len(ports) +dot = lambda a, b: bin(a & b).count("1") & 1 +require(n == 104 and all(0 < p < 512 for p in ports) and len(set(ports)) == 104, "ports shape") +require(all(dot(p, p) == 1 for p in ports), "every port has odd weight") +Z = lambda s, t: s != t and dot(ports[s], ports[t]) == 0 # forced-zero pair +require(all(Z(s, t) == Z(t, s) for s in range(n) for t in range(n)), "mask symmetric") + +K = [62, 63, 69, 74, 81, 86, 91, 99] +O = [57, 67, 68, 95, 100, 101] +EXPECT_A = {57: [62, 91], 67: [63, 99], 68: [62, 99], 95: [62, 63], 100: [62, 69], 101: [63, 69]} + +# 1. the 8-clique of the forced-zero graph, maximal, and no 9-clique anywhere +require(all(Z(a, b) for a, b in itertools.combinations(K, 2)), "K is a forced-zero clique") +require(not any(all(Z(x, k) for k in K) for x in range(n) if x not in K), "K is a maximal clique") +adj = [{t for t in range(n) if Z(s, t)} for s in range(n)] +best = [0] +def bk(R, P, X): + if not P and not X: + best[0] = max(best[0], R); return + u = max(P | X, key=lambda v: len(adj[v] & P)) + for v in list(P - adj[u]): + bk(R + 1, P & adj[v], X & adj[v]); P = P - {v}; X = X | {v} +bk(0, set(range(n)), set()) +require(best[0] == 8, "clique number of the forced-zero graph is 8, got %d" % best[0]) +print("clique: K is an 8-clique, maximal; clique number of the forced-zero graph =", best[0]) + +# 2. the O-coordinate claims +A = {t: [k for k in K if not Z(t, k)] for t in O} +require(A == EXPECT_A, "A(T) sets: %r" % A) +require(set().union(*map(set, A.values())) == {62, 63, 69, 91, 99}, "5 available coordinates") +sharing = [(s, t) for s, t in itertools.combinations(O, 2) if set(A[s]) & set(A[t])] +require(len(sharing) == 11, "11 sharing pairs, got %d" % len(sharing)) +for s, t in sharing: + require(Z(s, t), "sharing pair is forced zero: %r" % ((s, t),)) + require(len(set(A[s]) & set(A[t])) == 1, "sharing pair shares exactly one coordinate") +print("O: A(T) =", A, "; 5 coordinates for 6 ports; %d sharing pairs, all forced zero, each sharing exactly one coordinate" % len(sharing)) + +# 3. k = 1, field-free support argument: T active at c means u_T[c] w_T[c] != 0 (needed for B_TT != 0). +# Two ports active at the same shared coordinate give B_ST = w_S[c] u_T[c] != 0 (the only term), contradicting the mask. +# So active coordinates must be pairwise distinct: a system of distinct representatives of A. +def sdr(sets): + sets = list(sets) + def go(i, used): + if i == len(sets): return True + return any(c not in used and go(i + 1, used | {c}) for c in sets[i]) + return go(0, frozenset()) +require(not sdr(A[t] for t in O), "no system of distinct representatives for the 6 ports") +print("k=1, any field: no system of distinct representatives for A(57..101) (5 coordinates, 6 ports)") + +# 4. k = 1 linear algebra over F_p, p = 2, 3, 7: gauge U_K = W_K = I, then search all (u_T, w_T) +# vectors on the 8 coordinates, B_ST = w_S . u_T = 0 on forced-zero pairs, B_TT != 0 for T in O. +def f_p_search(p, O=O): + ip = lambda a, b: sum(x * y for x, y in zip(a, b)) % p + unit = {k: tuple(int(i == j) for j in range(8)) for i, k in enumerate(K)} + dom = {} + for t in O: # B_kT = u_T[k] and B_Tk = w_T[k] vanish when (t, k) is forced zero; B_TT != 0 + ok = [i for i, k in enumerate(K) if not Z(t, k)] + rows = [] + for u in itertools.product(range(p), repeat=len(ok)): + for w in itertools.product(range(p), repeat=len(ok)): + fu, fw = [0] * 8, [0] * 8 + for i, a, b in zip(ok, u, w): fu[i], fw[i] = a, b + if ip(fw, fu): rows.append((tuple(fu), tuple(fw))) + dom[t] = rows + # the gauge-fixed K ports pair with t as B_kT = u_T[k], B_Tk = w_T[k] + for u, w in rows: + for i, k in enumerate(K): + if Z(t, k): require(ip(unit[k], u) == 0 and ip(w, unit[k]) == 0, "K-O mask") + def go(i, dom): + if i == len(O): return 1 + t = O[i]; total = 0 + for u, w in dom[t]: + nd = dict(dom) + for s in O[i + 1:]: + if Z(s, t): + nd[s] = [(u2, w2) for u2, w2 in dom[s] if ip(w, u2) == 0 and ip(w2, u) == 0] + if not nd[s]: break + else: + total += go(i + 1, nd) + return total + return go(0, dom) +for p in (2, 3): + cnt = f_p_search(p) + require(cnt == 0, "F_%d: expected no solution, found %d" % (p, cnt)) + print("k=1, F_%d, rank 8 (gauge-fixed, asymmetric W,U): %d solutions on the 14 ports (UNSAT)" % (p, cnt)) + +# search control: the same search with port 101 left out (5 ports, 5 coordinates) must find solutions +O5 = [t for t in O if t != 101] +require(f_p_search(2, O5) > 0 and f_p_search(3, O5) > 0, "search control: 5-port subsystem is satisfiable") +print("search control: dropping port 101 leaves a satisfiable system over F_2 and F_3 (the search is not vacuous)") + +# 5. rank-9 control: one extra coordinate lets the six O ports have distinct active coordinates. +# Port vectors over Z in dimension 9; the full 14x14 Gram B = W U^T must vanish on every forced-zero pair +# and be invertible on the diagonal. +def control(): + best_assign = None + for extra in O: + rest = [t for t in O if t != extra] + for choice in itertools.product(*[A[t] for t in rest]): + if len(set(choice)) == len(rest): + best_assign = (extra, dict(zip(rest, choice))); break + if best_assign: break + require(best_assign is not None, "rank-9 control assignment exists") + extra, ch = best_assign + U = {k: [int(i == j) for j in range(9)] for i, k in enumerate(K)} + for t in O: + e = 8 if t == extra else K.index(ch[t]) + U[t] = [int(j == e) for j in range(9)] + W = U + B = {(s, t): sum(a * b for a, b in zip(W[s], U[t])) for s in K + O for t in K + O} + for s in K + O: + require(B[s, s] == 1, "diagonal") + for t in K + O: + if Z(s, t): require(B[s, t] == 0, "forced zero violated at %r" % ((s, t),)) + return extra, ch +extra, ch = control() +print("control: a symmetric dimension-9 realisation of the 14-port mask exists (port %d on the extra coordinate; %r on K positions)" % (extra, ch)) +print("PASS_P104_RANK8_HALL_OBSTRUCTION") diff --git a/research/p104-rank8-hall-obstruction/retained/expected-output.txt b/research/p104-rank8-hall-obstruction/retained/expected-output.txt new file mode 100644 index 0000000000..8278128e20 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/expected-output.txt @@ -0,0 +1,20 @@ +== s_asymA ring r=2 +size of std basis: +1 +1 +== s_asymA_c0 ring r=0 +size of std basis: +1 +1 +== s_asymA_c3 ring r=3 +size of std basis: +1 +1 +== s_asymA_c5 ring r=5 +size of std basis: +1 +1 +== s_asymA_Z ring r=integer +size of std basis: +1 +1 diff --git a/research/p104-rank8-hall-obstruction/retained/s_asymA.sing b/research/p104-rank8-hall-obstruction/retained/s_asymA.sing new file mode 100644 index 0000000000..13c04978ac --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/s_asymA.sing @@ -0,0 +1,33 @@ +ring r=2,(u_0_0,u_0_6,u_3_1,u_3_7,u_4_0,u_4_7,u_10_0,u_10_1,u_12_0,u_12_2,u_13_1,u_13_2,w_0_0,w_0_6,w_3_1,w_3_7,w_4_0,w_4_7,w_10_0,w_10_1,w_12_0,w_12_2,w_13_1,w_13_2),dp; +option(redSB); +ideal I=w_0_0*u_0_0+w_0_6*u_0_6-1, +w_3_1*u_3_1+w_3_7*u_3_7-1, +w_4_0*u_4_0+w_4_7*u_4_7-1, +w_10_0*u_10_0+w_10_1*u_10_1-1, +w_12_0*u_12_0+w_12_2*u_12_2-1, +w_13_1*u_13_1+w_13_2*u_13_2-1, +w_0_0*u_4_0, +w_0_0*u_10_0, +w_0_0*u_12_0, +w_3_7*u_4_7, +w_3_1*u_10_1, +w_3_1*u_13_1, +w_4_0*u_0_0, +w_4_7*u_3_7, +w_4_0*u_10_0, +w_4_0*u_12_0, +w_10_0*u_0_0, +w_10_1*u_3_1, +w_10_0*u_4_0, +w_10_0*u_12_0, +w_10_1*u_13_1, +w_12_0*u_0_0, +w_12_0*u_4_0, +w_12_0*u_10_0, +w_12_2*u_13_2, +w_13_1*u_3_1, +w_13_1*u_10_1, +w_13_2*u_12_2; +ideal G=std(I); +print("size of std basis:"); print(size(G)); print(G[1]); +quit; diff --git a/research/p104-rank8-hall-obstruction/retained/s_asymA_Z.sing b/research/p104-rank8-hall-obstruction/retained/s_asymA_Z.sing new file mode 100644 index 0000000000..1c264ad2e0 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/s_asymA_Z.sing @@ -0,0 +1,33 @@ +ring r=integer,(u_0_0,u_0_6,u_3_1,u_3_7,u_4_0,u_4_7,u_10_0,u_10_1,u_12_0,u_12_2,u_13_1,u_13_2,w_0_0,w_0_6,w_3_1,w_3_7,w_4_0,w_4_7,w_10_0,w_10_1,w_12_0,w_12_2,w_13_1,w_13_2),dp; +option(redSB); +ideal I=w_0_0*u_0_0+w_0_6*u_0_6-1, +w_3_1*u_3_1+w_3_7*u_3_7-1, +w_4_0*u_4_0+w_4_7*u_4_7-1, +w_10_0*u_10_0+w_10_1*u_10_1-1, +w_12_0*u_12_0+w_12_2*u_12_2-1, +w_13_1*u_13_1+w_13_2*u_13_2-1, +w_0_0*u_4_0, +w_0_0*u_10_0, +w_0_0*u_12_0, +w_3_7*u_4_7, +w_3_1*u_10_1, +w_3_1*u_13_1, +w_4_0*u_0_0, +w_4_7*u_3_7, +w_4_0*u_10_0, +w_4_0*u_12_0, +w_10_0*u_0_0, +w_10_1*u_3_1, +w_10_0*u_4_0, +w_10_0*u_12_0, +w_10_1*u_13_1, +w_12_0*u_0_0, +w_12_0*u_4_0, +w_12_0*u_10_0, +w_12_2*u_13_2, +w_13_1*u_3_1, +w_13_1*u_10_1, +w_13_2*u_12_2; +ideal G=std(I); +print("size of std basis:"); print(size(G)); print(G[1]); +quit; diff --git a/research/p104-rank8-hall-obstruction/retained/s_asymA_c0.sing b/research/p104-rank8-hall-obstruction/retained/s_asymA_c0.sing new file mode 100644 index 0000000000..e35cfe36b4 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/s_asymA_c0.sing @@ -0,0 +1,33 @@ +ring r=0,(u_0_0,u_0_6,u_3_1,u_3_7,u_4_0,u_4_7,u_10_0,u_10_1,u_12_0,u_12_2,u_13_1,u_13_2,w_0_0,w_0_6,w_3_1,w_3_7,w_4_0,w_4_7,w_10_0,w_10_1,w_12_0,w_12_2,w_13_1,w_13_2),dp; +option(redSB); +ideal I=w_0_0*u_0_0+w_0_6*u_0_6-1, +w_3_1*u_3_1+w_3_7*u_3_7-1, +w_4_0*u_4_0+w_4_7*u_4_7-1, +w_10_0*u_10_0+w_10_1*u_10_1-1, +w_12_0*u_12_0+w_12_2*u_12_2-1, +w_13_1*u_13_1+w_13_2*u_13_2-1, +w_0_0*u_4_0, +w_0_0*u_10_0, +w_0_0*u_12_0, +w_3_7*u_4_7, +w_3_1*u_10_1, +w_3_1*u_13_1, +w_4_0*u_0_0, +w_4_7*u_3_7, +w_4_0*u_10_0, +w_4_0*u_12_0, +w_10_0*u_0_0, +w_10_1*u_3_1, +w_10_0*u_4_0, +w_10_0*u_12_0, +w_10_1*u_13_1, +w_12_0*u_0_0, +w_12_0*u_4_0, +w_12_0*u_10_0, +w_12_2*u_13_2, +w_13_1*u_3_1, +w_13_1*u_10_1, +w_13_2*u_12_2; +ideal G=std(I); +print("size of std basis:"); print(size(G)); print(G[1]); +quit; diff --git a/research/p104-rank8-hall-obstruction/retained/s_asymA_c3.sing b/research/p104-rank8-hall-obstruction/retained/s_asymA_c3.sing new file mode 100644 index 0000000000..9764c45303 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/s_asymA_c3.sing @@ -0,0 +1,33 @@ +ring r=3,(u_0_0,u_0_6,u_3_1,u_3_7,u_4_0,u_4_7,u_10_0,u_10_1,u_12_0,u_12_2,u_13_1,u_13_2,w_0_0,w_0_6,w_3_1,w_3_7,w_4_0,w_4_7,w_10_0,w_10_1,w_12_0,w_12_2,w_13_1,w_13_2),dp; +option(redSB); +ideal I=w_0_0*u_0_0+w_0_6*u_0_6-1, +w_3_1*u_3_1+w_3_7*u_3_7-1, +w_4_0*u_4_0+w_4_7*u_4_7-1, +w_10_0*u_10_0+w_10_1*u_10_1-1, +w_12_0*u_12_0+w_12_2*u_12_2-1, +w_13_1*u_13_1+w_13_2*u_13_2-1, +w_0_0*u_4_0, +w_0_0*u_10_0, +w_0_0*u_12_0, +w_3_7*u_4_7, +w_3_1*u_10_1, +w_3_1*u_13_1, +w_4_0*u_0_0, +w_4_7*u_3_7, +w_4_0*u_10_0, +w_4_0*u_12_0, +w_10_0*u_0_0, +w_10_1*u_3_1, +w_10_0*u_4_0, +w_10_0*u_12_0, +w_10_1*u_13_1, +w_12_0*u_0_0, +w_12_0*u_4_0, +w_12_0*u_10_0, +w_12_2*u_13_2, +w_13_1*u_3_1, +w_13_1*u_10_1, +w_13_2*u_12_2; +ideal G=std(I); +print("size of std basis:"); print(size(G)); print(G[1]); +quit; diff --git a/research/p104-rank8-hall-obstruction/retained/s_asymA_c5.sing b/research/p104-rank8-hall-obstruction/retained/s_asymA_c5.sing new file mode 100644 index 0000000000..fe8ed2b6d8 --- /dev/null +++ b/research/p104-rank8-hall-obstruction/retained/s_asymA_c5.sing @@ -0,0 +1,33 @@ +ring r=5,(u_0_0,u_0_6,u_3_1,u_3_7,u_4_0,u_4_7,u_10_0,u_10_1,u_12_0,u_12_2,u_13_1,u_13_2,w_0_0,w_0_6,w_3_1,w_3_7,w_4_0,w_4_7,w_10_0,w_10_1,w_12_0,w_12_2,w_13_1,w_13_2),dp; +option(redSB); +ideal I=w_0_0*u_0_0+w_0_6*u_0_6-1, +w_3_1*u_3_1+w_3_7*u_3_7-1, +w_4_0*u_4_0+w_4_7*u_4_7-1, +w_10_0*u_10_0+w_10_1*u_10_1-1, +w_12_0*u_12_0+w_12_2*u_12_2-1, +w_13_1*u_13_1+w_13_2*u_13_2-1, +w_0_0*u_4_0, +w_0_0*u_10_0, +w_0_0*u_12_0, +w_3_7*u_4_7, +w_3_1*u_10_1, +w_3_1*u_13_1, +w_4_0*u_0_0, +w_4_7*u_3_7, +w_4_0*u_10_0, +w_4_0*u_12_0, +w_10_0*u_0_0, +w_10_1*u_3_1, +w_10_0*u_4_0, +w_10_0*u_12_0, +w_10_1*u_13_1, +w_12_0*u_0_0, +w_12_0*u_4_0, +w_12_0*u_10_0, +w_12_2*u_13_2, +w_13_1*u_3_1, +w_13_1*u_10_1, +w_13_2*u_12_2; +ideal G=std(I); +print("size of std basis:"); print(size(G)); print(G[1]); +quit; diff --git a/research/p104-rank8-hall-obstruction/verify.sh b/research/p104-rank8-hall-obstruction/verify.sh new file mode 100755 index 0000000000..f5a4c6d4ed --- /dev/null +++ b/research/p104-rank8-hall-obstruction/verify.sh @@ -0,0 +1,4 @@ +#!/bin/sh +# Runs the exact checks; run from anywhere. Needs python3.12 (standard library only). +set -e +exec python3.12 -I -B "$(dirname "$0")/check.py"