From 2914d809222345a56f22b63ee2f51aa68dce8bd2 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 11 Nov 2026 10:44:26 +0000 Subject: [PATCH] Exhibit an irreducible no-edge image of dimension 7 at pattern dimension 5. The seven explicit projectors are the complete pool of a unit-free pattern space of dimension 5. Their joint image has dimension 7 and the action is irreducible, so the pattern-dimension-4 ceiling of 6 does not survive. No kappa change. Co-authored-by: unpaidmoon --- .../no-edge-dim5-irreducible-seven/PROOF.md | 291 +++++++++++++++ .../no-edge-dim5-irreducible-seven/README.md | 107 ++++++ .../SOURCES.json | 18 + .../no-edge-dim5-irreducible-seven/TASK.json | 70 ++++ .../VERIFY.json | 36 ++ .../no-edge-dim5-irreducible-seven/verify.py | 352 ++++++++++++++++++ 6 files changed, 874 insertions(+) create mode 100644 research/no-edge-dim5-irreducible-seven/PROOF.md create mode 100644 research/no-edge-dim5-irreducible-seven/README.md create mode 100644 research/no-edge-dim5-irreducible-seven/SOURCES.json create mode 100644 research/no-edge-dim5-irreducible-seven/TASK.json create mode 100644 research/no-edge-dim5-irreducible-seven/VERIFY.json create mode 100644 research/no-edge-dim5-irreducible-seven/verify.py diff --git a/research/no-edge-dim5-irreducible-seven/PROOF.md b/research/no-edge-dim5-irreducible-seven/PROOF.md new file mode 100644 index 0000000000..1464df6982 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/PROOF.md @@ -0,0 +1,291 @@ +# An irreducible no-edge image of dimension 7 at pattern dimension 5 + +Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0. +The fiber lemma is cited and not reproved. Everything else is proved here. + +This is a written existence proof for one explicit pool. It is not a new κ. +The selected frontier stays `363005817/100000000000`. It is not an upper +bound on every pattern-dimension-5 pool, and it is not a census of those +pools. The 127-vector scan in `verify.py` checks this one image; it does +not search pattern spaces. + +## 1. Statement + +Work over F2. For a matrix N, write off(N) for N with its diagonal deleted. +For ambient width W, let P be a linear space of zero-diagonal W×W matrices +containing no matrix unit. The complete no-edge pool is + +```text +C(P) = {x y^T : y·x = 1, off(x y^T) is a nonzero element of P}. +``` + +Every element is a rank-one idempotent. Coordinate projectors have zero +pattern, so they are not in C(P). Write V(P) for the span of the images of +C(P). The action is reducible when some subspace 0 < U < V(P) is invariant +under every pool projector. + +**Theorem.** For every W ≥ 7 there is a 5-dimensional unit-free pattern +space whose complete pool has seven projectors, joint image of dimension 7, +and irreducible action. + +Explicitly, on coordinates {0,1,2}, {3,4,5} and {6}, + +```text +(e0+e2)(e1+e2)^T, +(e1+e2)(e0+e2)^T, +(e0+e1+e2)(e0+e1+e2)^T, +(e3+e5)(e4+e5)^T, +(e4+e5)(e3+e5)^T, +(e3+e4+e5)(e3+e4+e5)^T, +(e2+e5+e6)(e2+e5+e6)^T. +``` + +Let z = e2+e5+e6 and let P be the span of the seven off-diagonal patterns, +padded by zero rows and columns when W > 7. Then C(P) is exactly these +seven projectors, dim V(P) = 7, and the action on V(P) is irreducible. + +In particular, a complete no-edge pool of pattern dimension 5 need not have +total joint image at most 6, and its irreducible image can have dimension 7. +Both answers use this one pool. The argument uses completeness, the absence +of matrix units, and pattern dimension exactly 5 for this P. It does not +bound any other pattern space, and it does not price a word. + +## 2. The seven patterns + +Write A = {0,1,2} and B = {3,4,5}. The first three projectors are the +normal-form triple on A. Put + +```text +u = e1+e2, v = e0+e2, o = e0+e1+e2. +``` + +Then v·u = 1 and o·o = 1, so u v^T, v u^T and o o^T are rank-one +idempotents. Their off-diagonal patterns are + +```text +p_u = E10 + E12 + E20, +p_v = E01 + E02 + E21, +p_o = E01 + E02 + E10 + E12 + E20 + E21. +``` + +These have weights 3, 3 and 6. The first two are disjoint and their sum is +the third, so they are the three nonzero elements of a 2-dimensional space +Q_A supported on the off-diagonal positions of A. The same formulas shifted +by 3 give a 2-dimensional space Q_B on block B, with weights 3, 3 and 6. +The two blocks use disjoint positions, so H = Q_A ⊕ Q_B is 4-dimensional. + +The seventh pattern comes from z = e2+e5+e6. This vector has weight 3, so +z·z = 1 and z z^T is a rank-one idempotent. Its off-diagonal pattern is + +```text +p_* = E25 + E26 + E52 + E56 + E62 + E65. +``` + +It has weight 6. None of its six positions lies in an off-diagonal A-block +or B-block: each position meets coordinate 6 or crosses from A to B. Thus +p_* is outside H. Let P = H ⊕ span(p_*). Then dim P = 5. + +A general element is q_A + q_B + λ p_* with q_A in Q_A, q_B in Q_B and +λ in F2. If λ = 0 and the element is nonzero, its weight is the sum of a +weight in {0,3,6} from each block, not both zero, hence at least 3. If +λ = 1, all six positions of p_* survive, because neither block meets them, +so the weight is at least 6. Every nonzero element has weight at least 3. +In particular P contains no matrix unit. + +## 3. Support + +Let x y^T be a pool element, so y·x = 1 and the pattern p = off(x y^T) lies +in P and is nonzero. Call p even when λ = 0 and odd when λ = 1. + +Every matrix in P is zero in every row and every column indexed by +t ≥ 7. If x_t = 1, then y_j = p_tj = 0 for all j ≠ t, so y = e_t and +y·x = 1 forces y_t = 1. The pattern is then the off-diagonal part of row t, +which is zero, contradicting membership in the pool. Thus x_t = 0. If +y_t = 1, column t of the pattern is x with bit t cleared, hence x = e_t. +Combined with x_t = 0 this gives x = 0, which is impossible. Thus y_t = 0. +Both factors are supported on {0,1,2,3,4,5,6}. + +The same reading applies to coordinate 6 when p is even: an even pattern +has zero row 6 and zero column 6, so x_6 = y_6 = 0 by the same two +sentences. An even pattern also has no cross entry between A and B. + +## 4. The odd coset + +Every odd pattern has λ = 1, so it contains all six positions of p_*. Those +entries are x_i y_j. Therefore + +```text +x2 y6 = x6 y2 = x5 y6 = x6 y5 = x2 y5 = x5 y2 = 1, +``` + +and x_i y_6 = 0 for every i outside {2,5,6}, because every matrix in P has +zero column 6 outside rows 2 and 5. The first family gives +x2 = x5 = x6 = y2 = y5 = y6 = 1. The second gives x_i = 0 outside +{2,5,6}. Thus x = z. Row 6 of an odd pattern is zero outside columns 2 and +5, and x6 = 1, so y_j = 0 outside {2,5,6}. Thus y = z. + +The projector is z z^T. Its pattern is exactly p_*, whose blocks inside A +and inside B are zero. An odd pattern with a nonzero block summand is +therefore not the pattern of this projector. It has no other candidate, +because the six entries already force the factors. The only odd pool element +is z z^T. + +## 5. The even coset + +Let p = q_A + q_B be even and nonzero, and let x y^T realize it. Section 3 +puts both factors on A ∪ B, with no cross entry: x_a y_b = 0 and +x_b y_a = 0 for all a in A and b in B. + +The internal A-pattern is the restriction of x y^T. If it is nonzero, some +x_a = y_a' = 1, so both the A-part of x and the A-part of y are nonzero. +From x_a = 1 and the cross equations, every B-bit of y is zero. From +y_a' = 1, every B-bit of x is zero. The internal B-pattern is then zero. +The symmetric argument says that a nonzero B-pattern forces the A-pattern +to vanish. A pattern with both blocks nonzero is unrealized. + +So p lies in Q_A or in Q_B. Consider Q_A. Its three nonzero elements are +p_u, p_v and p_o, of weights 3, 3 and 6, and the three displayed projectors +realize them. None is a matrix unit. By the fiber lemma of #5921, a +realizable nonzero off-diagonal pattern that is not a matrix unit has +exactly one rank-one idempotent lift. Those three lifts are the first three +projectors, and the same holds for Q_B. There is no further even pool +element. + +## 6. The pool and the image + +Sections 4 and 5 account for every nonzero pattern in P. For every W ≥ 7, + +```text +C(P) = the seven projectors in Section 1. +``` + +The first three images are u, v and o. Then u+o = e0, v+o = e1 and +u+v+o = e2, so they span the coordinate space L = span(e0,e1,e2). The next +three span R = span(e3,e4,e5) by the same sums. These two coordinate spaces +meet only at zero, and z is not in L ⊕ R because of e6. Therefore + +```text +V(P) = L ⊕ R ⊕ span(e6), dim V(P) = 7. +``` + +Section 7 shows that the block covectors span L* ⊕ R* and that ζ is nonzero +on e6, so the seven covectors span the dual of V(P). The common kernel is +zero. That is not yet irreducibility. + +## 7. Irreducibility + +Identify V(P) with F2^7 on the ordered coordinates +(e0,e1,e2,e3,e4,e5,e6). Write a vector as ℓ + r + γ e6 with ℓ in L and +r in R. The linking covector is ζ = e2* + e5* + e6*, so + +```text +ζ(ℓ + r + γ e6) = ℓ2 + r5 + γ. +``` + +The three block-A covectors, in coordinates (e0,e1,e2), are the rows + +```text +0 1 1 +1 0 1 +1 1 1. +``` + +Adding row 0 to row 1 produces (1,1,0); adding that to row 2 produces +(0,0,1); back-substitution produces the identity. They are a basis of L*. +The block-B covectors are the same matrix on (e3,e4,e5), hence a basis of +R*. Each block image meets z in one coordinate: u, v and o each meet z in +e2, and each B-image meets z in e5. Therefore ζ is 1 on all six block +images. The block covectors are the swapped copies u*, v*, o* and their +translates, so each block covector is likewise 1 on z. Also ζ(z) = 1. + +Let U be a nonzero invariant subspace. + +If some w in U has ζ(w) = 1, the linking projector sends w to z, so z is in +U. Every block covector is 1 on z, so every block projector sends z to its +image, and all six images lie in U. The three A-images span L and the three +B-images span R, so L ⊕ R is contained in U. Then e2 and e5 lie in U, and +z + e2 + e5 = e6 lies in U. Hence U = V(P). + +If instead ζ vanishes on every vector of U, none of the six block images can +lie in U, because ζ is 1 on each of them. An invariant subspace that does not +contain a block image cannot be hit by that block's covector. All three +A-covectors therefore vanish on U. They span L*, so the L-component of every +vector in U is zero. The same holds for R. The relation ζ = 0 then forces the +e6-coordinate to vanish as well. Thus U = 0, contradicting the choice of U. + +Every nonzero invariant subspace equals V(P). The action is irreducible. + +Deleting the linking projector leaves the first six. Their covectors vanish +on the opposite block, and each block's projectors map into that block, so +L is a proper nonzero invariant subspace. The link is what makes the +seven-projector action irreducible. A single normal-form block is already +reducible for the same reason; the verifier uses the deleted pool, rather +than that smaller block, as the control. + +## 8. The parity construction does not decide the question + +The question asks about the parity construction one dimension above the +pattern-dimension-4 example. That construction is the even-weight column, +and it stays at total image 6. + +Let S be the even-weight subspace of the coordinate space on {1,2,3,4,5,6}. +It is the kernel of the all-ones functional, so dim S = 5, and every nonzero +vector of S has weight at least 2. Let P_even be the 5-dimensional space of +matrices s e0^T with s in S. A nonzero element has weight at least 2, so +P_even contains no matrix unit. + +A pool element x y^T has its only possible nonzero column in column 0. If +y_t = 1 for some t ≠ 0, column t of the pattern is zero, so x = e_t, and +column 0 is then 0 or e_t. The pattern is 0 or the matrix unit E_t0. Neither +lies in the pool. Thus y = e0 and x_0 = 1. The pattern is the vector x + e0 +placed in column 0, so x = e0 + s for some nonzero s in S. These 31 +projectors are exactly the pool, at every width at least 7. Their images +are e0 + s. Differences span S, and e0 is outside S, so the image has +dimension 6. Every covector is e0. The space S lies in the image and is +orthogonal to e0, so every projector sends S to 0. Thus S is a proper +nonzero invariant subspace. The parity pool is reducible and has total +image 6. + +It therefore does not show that the total image can exceed 6, and it does +not show that an irreducible image can exceed 5. Section 1 is the pool that +decides both questions. + +## 9. What this does not claim + +The selected κ and its framework assumptions are unchanged. No rational +address, native word, supplier admission, or multiplication identity is +produced. + +The theorem does not say that every complete no-edge pool of pattern +dimension 5 has joint image at most 7, and it does not say that 7 is the +only irreducible dimension above 5. The edge-quotient bound of #6782, in +the zero-edge case, still gives only dim V ≤ 2^5 − 1 = 31. A search through +one family of extensions is not a substitute for that upper bound, and none +is claimed here. + +The 127 nonzero vectors of this image form a finite set. The verifier +closes every one under the seven projectors and finds that each closure is +all of V(P). That census matches Section 7; it is not a search over pattern +spaces. The width scans certify this pool and the parity pool only. + +Question 2 of #7139, the coordinate classification of the dimension-6 pools +at pattern dimension 4, is not this result. Question 3 of #7139, paid-rank +accounting after a relation split, remains question 1 of #6921 and is not +answered here. The original card still asks for a new register alphabet; +that gate is unmet. + +## Open next questions + +1. **Is 7 an upper bound?** Does every complete no-edge pool of pattern + dimension 5 have total joint image at most 7? The witness shows that 6 + is too small, and the zero-edge quotient bound is still 31. The missing + step is to show that a unit-free one-dimensional extension of a + dimension-6 pattern space adds at most one image dimension. This package + does not prove that estimate. + +2. **Is the dimension-7 pool unique up to coordinates?** Is every + irreducible complete no-edge pool of pattern dimension 5 and joint-image + dimension 7 a coordinate permutation of the seven projectors in Section + 1? The existence proof does not identify the pools. The first step is to + match the two normal-form blocks and the linking vector. Nothing in + Section 7 classifies other links. diff --git a/research/no-edge-dim5-irreducible-seven/README.md b/research/no-edge-dim5-irreducible-seven/README.md new file mode 100644 index 0000000000..a6d9cd1a29 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/README.md @@ -0,0 +1,107 @@ +# No-edge pattern dimension 5 has an irreducible image of dimension 7 + +**Result.** For every ambient width at least 7, the seven projectors + +```text +(e0+e2)(e1+e2)^T, +(e1+e2)(e0+e2)^T, +(e0+e1+e2)(e0+e1+e2)^T, +(e3+e5)(e4+e5)^T, +(e4+e5)(e3+e5)^T, +(e3+e4+e5)(e3+e4+e5)^T, +(e2+e5+e6)(e2+e5+e6)^T +``` + +are the complete pool of their pattern span. That span is five-dimensional +and contains no matrix unit. The joint image is seven-dimensional and the +action is irreducible. **No new κ.** The selected value remains +`363005817/100000000000`. + +A complete no-edge pool of pattern dimension 5 therefore need not have total +joint image at most 6, and its irreducible image can have dimension 7. The +parity construction one dimension above the pattern-dimension-4 example still +has total image 6 and is reducible, so it does not decide either question. + +## Scope and evidence + +Catalogue card: `bit-new-register-model`, priority revision 8, base commit +`e54523517d0f03e58352e647c403a5af3e525a57`. Scope status: **changed**. The +card asks for a new register alphabet. This package answers open question 1 +of #7139: whether a complete no-edge pool of pattern dimension 5 still has +total joint image at most 6, and whether its irreducible image can exceed 5. +The reason is recorded in [TASK.json](TASK.json). The original native +acceptance gate is unmet, and the selected frontier is unchanged. Question 2 +of #7139, the coordinate classification at pattern dimension 4, and question +3, the paid-rank split, are not this result. + +[PROOF.md](PROOF.md) is the argument. Sections 2–6 identify the pattern space +and prove that the complete pool is exactly these seven projectors at every +width at least 7. Section 7 proves the action is irreducible: a vector hit +by the linking covector generates the whole image, and a subspace killed by +that covector cannot contain a block image, which forces it to be zero. +Section 8 records the even-weight column of dimension 5: total image 6, with +the even-weight space invariant. That is the parity construction named in +the question. It is a comparison, not a bound. + +[verify.py](verify.py) repeats the finite parts: the pattern-space weights, +the six linking entries on every odd coset vector, the dual bases, the +complete pools at widths 7, 8 and 9, the closure of all 127 nonzero image +vectors, the deleted-link control, and the parity pool at widths 7 and 8. +Deleting the linking projector leaves the coordinate block on {0,1,2} +invariant. The parity pool's even-weight line is invariant, while closing an +image vector under that pool spans the whole image, so the reducible control +is not an arbitrary seed. These checks certify the two explicit pools. They +do not enumerate five-dimensional pattern spaces. Sections 4–7 are what +cover every width. + +Source pins are in [SOURCES.json](SOURCES.json). The catalogue is provenance +at the base commit, and the selected record is an input because the verifier +reads it. Full Git history is needed to resolve the pins. Nothing here reruns +the selected baseline as a scientific replay. + +Overlap was checked on 2026-11-11. A local `find_overlap.py --offline` search +at base `e54523517d0f03e58352e647c403a5af3e525a57` covered 10178 notes with a +complete head inventory. The matches are the predecessor packages for pattern +dimension at most 4. The remote overlap cache was not available in that run. +A live GitHub search of `CrocSwap/integer-mult-bounds` for the pattern-dimension-5 +no-edge question returned the predecessor chain and open #7094 and #7139, which +ask the question and do not answer it. Open #7138 is the weight-1 pattern-dimension-4 +bound. Recent comments on discussion #1166, checked the same day, do not take +this question. No match is not a novelty certificate. + +## Reproduce + +From the repository root, with Python 3.12 and the standard library only: + +```sh +python3 -B research/no-edge-dim5-irreducible-seven/verify.py +python3 -I -O -B research/no-edge-dim5-irreducible-seven/verify.py +python3 -B scripts/research_package.py --package research/no-edge-dim5-irreducible-seven --check-only +python3 -B scripts/research_package.py --package research/no-edge-dim5-irreducible-seven +``` + +The verifier prints `PASS_NO_EDGE_DIM5_IRREDUCIBLE_SEVEN`. + +## Open next questions + +1. **Is 7 an upper bound at pattern dimension 5?** Does every complete no-edge + pool of pattern dimension 5 have total joint image at most 7? This witness + shows that 6 is too small. The zero-edge quotient bound is still 31. The + smallest next step is the one-dimensional extension of a dimension-6 + pattern space. A width-bounded search would not prove the bound. + +2. **Is the dimension-7 pool unique up to coordinates?** Is every irreducible + complete no-edge pool of pattern dimension 5 and joint-image dimension 7 a + coordinate permutation of these seven projectors? The existence proof does + not identify the pools. The smallest next step is to match the two + normal-form blocks and the linking vector. + +## Credit + +The fiber lemma is Nick Petalas, #5921. The parity construction compared in +Section 8 is CubeJerry, #6838, moved up to pattern dimension 5. The normal-form +triple is the one classified in #6921; this proof uses only the displayed +projectors and the fiber lemma. #7139 asked the question and proved the +pattern-dimension-4 bound; that bound is not an input. #6782 supplies the +zero-edge quotient bound 31. Prepared by unpaidmoon with substantial Cursor +Grok assistance. New work is Apache-2.0. diff --git a/research/no-edge-dim5-irreducible-seven/SOURCES.json b/research/no-edge-dim5-irreducible-seven/SOURCES.json new file mode 100644 index 0000000000..eb24483944 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/no-edge-dim5-irreducible-seven/TASK.json b/research/no-edge-dim5-irreducible-seven/TASK.json new file mode 100644 index 0000000000..addce4aba8 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/TASK.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. 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": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Existence of a complete no-edge binary rank-one idempotent pool of pattern dimension 5 whose joint image has dimension 7 and is irreducible.", + "scope_change_reason": "The card asks for a larger or nonabelian register alphabet. This package stays in the abelian F2 rank-one idempotent model and answers open question 1 of #7139: whether a complete no-edge pool of pattern dimension 5 still has total joint image at most 6, and whether its irreducible image can exceed 5. No new alphabet, word, or kappa is claimed. The same card was already moved to scalar pattern-pool questions by #5921, #6838, #6921, #6962, and #7094.", + "bottleneck_link": "Side result. The scalar pool does not by itself price a word, so the original native acceptance gate remains unmet. A later word argument can no longer assume that every pattern-dimension-5 no-edge pool has total image at most 6 or irreducible image at most 5. The selected frontier is unchanged.", + "budget_minutes": 60, + "stop_rule": "Stop once the seven-projector pool is identified at every width at least 7 and its action is proved irreducible, with the parity column recorded as the reducible comparison of total image 6. Do not start an upper-bound proof or a coordinate classification.", + "outcome": "completed", + "evidence": "PROOF.md shows that the seven explicit projectors are the complete pool of a unit-free pattern space of dimension 5, that the joint image has dimension 7, and that the action is irreducible. verify.py repeats the pattern arithmetic, the width scans, the 127-vector closure, and the deleted-link and parity controls.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance with the pool construction, the irreducibility argument, and the package verifier. Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Does every complete no-edge pool of pattern dimension 5 have total joint image at most 7?", + "why_it_matters": "The seven-projector witness shows that 6 is too small, while the zero-edge quotient bound is still 31. A matching upper bound would make 7 sharp.", + "first_step": "Show that a unit-free one-dimensional extension of a dimension-6 no-edge pattern space adds at most one image dimension.", + "blocked_by": "The extension estimate is not proved in this package. A width-bounded search would not be a proof." + }, + { + "question": "Is every irreducible complete no-edge pool of pattern dimension 5 and joint-image dimension 7 a coordinate permutation of the seven projectors exhibited here?", + "why_it_matters": "The existence proof does not say whether another linking geometry reaches the same dimension.", + "first_step": "Match the two normal-form blocks and the linking vector to the coordinates used here.", + "blocked_by": "Section 7 of the proof uses one linking vector and does not classify other links." + } + ] +} diff --git a/research/no-edge-dim5-irreducible-seven/VERIFY.json b/research/no-edge-dim5-irreducible-seven/VERIFY.json new file mode 100644 index 0000000000..21df724c80 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/VERIFY.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Witness pattern space, complete pools at widths 7 through 9, all 127 cyclic subspaces, deleted-link control, and the reducible parity pool at widths 7 and 8." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The same checks with assert statements disabled; the verifier raises SystemExit instead of using assert." + } + ] +} diff --git a/research/no-edge-dim5-irreducible-seven/verify.py b/research/no-edge-dim5-irreducible-seven/verify.py new file mode 100644 index 0000000000..cbbfdb3a20 --- /dev/null +++ b/research/no-edge-dim5-irreducible-seven/verify.py @@ -0,0 +1,352 @@ +#!/usr/bin/env python3 +"""Finite checks for one irreducible no-edge pool of pattern dimension 5. + +PROOF.md is the all-width argument. This program repeats the explicit +matrix arithmetic, the complete-pool scans, the 127-vector irreducibility +census, and the reducible controls. It raises SystemExit instead of using +assert, so python -O does not skip checks. Standard library only. +""" + +import json +from pathlib import Path + +MARKER = "PASS_NO_EDGE_DIM5_IRREDUCIBLE_SEVEN" +SELECTED = Path(__file__).resolve().parents[2] / "certificates" / "selected-result.json" +KAPPA = "363005817/100000000000" +DECIMAL = "0.00363005817" + +# Two normal-form triples and the linking projector z z^T, z = e2+e5+e6. +WITNESS = ( + (0b0000101, 0b0000110), # (e0+e2)(e1+e2)^T + (0b0000110, 0b0000101), # (e1+e2)(e0+e2)^T + (0b0000111, 0b0000111), # (e0+e1+e2)(e0+e1+e2)^T + (0b0101000, 0b0110000), # (e3+e5)(e4+e5)^T + (0b0110000, 0b0101000), # (e4+e5)(e3+e5)^T + (0b0111000, 0b0111000), # (e3+e4+e5)(e3+e4+e5)^T + (0b1100100, 0b1100100), # (e2+e5+e6)(e2+e5+e6)^T +) +STAR_POSITIONS = ((2, 5), (2, 6), (5, 2), (5, 6), (6, 2), (6, 5)) +BLOCK_A = WITNESS[:3] +BLOCK_B = WITNESS[3:6] + + +def fail(message): + raise SystemExit("FAIL: " + message) + + +def require(condition, message): + if not condition: + fail(message) + + +def weight(mask): + return mask.bit_count() + + +def dot(left, right): + return weight(left & right) & 1 + + +def gaussian(vectors): + pivots = {} + for vector in vectors: + current = vector + while current: + bit = current & -current + if bit not in pivots: + for other_bit, other in list(pivots.items()): + if other & bit: + pivots[other_bit] = other ^ current + pivots[bit] = current + break + current ^= pivots[bit] + return pivots + + +def in_span(pivots, mask): + current = mask + while current: + bit = current & -current + if bit not in pivots: + return False + current ^= pivots[bit] + return True + + +def rank(vectors): + return len(gaussian(vectors)) + + +def pattern_mask(image, covector, width): + mask = 0 + row = 0 + remaining = image + while remaining: + if remaining & 1: + column = 0 + columns = covector + while columns: + if columns & 1 and column != row: + mask |= 1 << (row * width + column) + columns >>= 1 + column += 1 + remaining >>= 1 + row += 1 + return mask + + +def position_bit(row, column, width): + return 1 << (row * width + column) + + +def complete_pool(patterns, width): + pivots = gaussian(patterns) + found = [] + for image in range(1, 1 << width): + pivot = (image & -image).bit_length() - 1 + free = [index for index in range(width) if index != pivot] + for choice in range(1 << (width - 1)): + covector = 0 + for bit, index in enumerate(free): + if (choice >> bit) & 1: + covector |= 1 << index + if dot(image, covector) == 0: + covector |= 1 << pivot + mask = pattern_mask(image, covector, width) + if mask and in_span(pivots, mask): + found.append((image, covector)) + return found + + +def contains_unit(patterns, width): + pivots = gaussian(patterns) + for row in range(width): + for column in range(width): + if row != column and in_span(pivots, position_bit(row, column, width)): + return True + return False + + +def space_weights(patterns): + basis = list(gaussian(patterns).values()) + weights = [] + for choice in range(1 << len(basis)): + total = 0 + for index, vector in enumerate(basis): + if (choice >> index) & 1: + total ^= vector + weights.append(weight(total)) + return weights + + +def generated_dimension(seed, pool): + if seed == 0: + return 0 + pivots = gaussian([seed]) + while True: + members = [0] + for vector in pivots.values(): + members += [old ^ vector for old in members] + grew = False + for image, covector in pool: + if any(dot(covector, vector) for vector in members) and not in_span(pivots, image): + current = image + while current: + bit = current & -current + if bit not in pivots: + for other_bit, other in list(pivots.items()): + if other & bit: + pivots[other_bit] = other ^ current + pivots[bit] = current + break + current ^= pivots[bit] + grew = True + break + if not grew: + return len(pivots) + + +def is_invariant(space, pool): + members = set(space) + for image, covector in pool: + if any(dot(covector, vector) for vector in members) and image not in members: + return False + return True + + +def check_selected_frontier(): + payload = json.loads(SELECTED.read_text(encoding="utf-8")) + require(payload.get("kappa") == KAPPA, "selected kappa changed") + require(payload.get("decimal") == DECIMAL, "selected decimal changed") + + +def check_witness_arithmetic(width): + patterns = [pattern_mask(image, covector, width) for image, covector in WITNESS] + require(len(set(patterns)) == 7, "the seven patterns are not distinct") + for image, covector in WITNESS: + require(dot(image, covector) == 1, "a witness factor is not idempotent") + require(rank(patterns) == 5, "witness pattern rank is not 5") + weights = space_weights(patterns) + require(weights[0] == 0 and min(weights[1:]) >= 3, + "a nonzero witness pattern has weight below 3") + require(not contains_unit(patterns, width), "witness pattern space contains a matrix unit") + star = patterns[6] + block_basis = [patterns[0], patterns[1], patterns[3], patterns[4]] + block_span = gaussian(block_basis) + require(rank(block_basis) == 4, "the four block patterns do not span the even space") + require(not in_span(block_span, star), "the linking pattern lies in the block span") + for row, column in STAR_POSITIONS: + require((star >> (row * width + column)) & 1, "linking pattern misses a forced entry") + require(all(((other >> (row * width + column)) & 1) == 0 for other in patterns[:6]), + "a block pattern meets a linking position") + # Every odd pattern carries all six linking entries; no even pattern carries any. + basis = block_basis + [star] + require(rank(basis) == 5, "explicit basis is not the full pattern space") + for choice in range(32): + total = 0 + for index, vector in enumerate(basis): + if (choice >> index) & 1: + total ^= vector + odd = (choice & 16) != 0 + for row, column in STAR_POSITIONS: + bit = (total >> (row * width + column)) & 1 + require(bit == (1 if odd else 0), "linking entries are not constant on a coset") + images = [image for image, _covector in WITNESS] + require(rank(images) == 7, "witness images do not span dimension 7") + require(set(range(128)) == set(span_points(images)), "witness image is not the coordinate 7-space") + linking = WITNESS[6][0] + for image, covector in WITNESS[:6]: + require(dot(linking, image) == 1, "a block image misses the linking covector") + require(dot(covector, linking) == 1, "a block covector misses the linking image") + require(dot(linking, linking) == 1, "the linking projector is not idempotent on itself") + return patterns + + +def span_points(vectors): + points = [0] + for vector in gaussian(vectors).values(): + points += [old ^ vector for old in points] + return points + + +def check_dual_bases(): + # Rows are the block covectors on coordinates (0,1,2) and (3,4,5). + left = ( + (0, 1, 1), + (1, 0, 1), + (1, 1, 1), + ) + right = ( + (0, 1, 1), + (1, 0, 1), + (1, 1, 1), + ) + require(matrix_rank(left) == 3, "block A covectors do not span the dual") + require(matrix_rank(right) == 3, "block B covectors do not span the dual") + left_images = (0b101, 0b110, 0b111) + right_images = (0b0101000, 0b0110000, 0b0111000) + require(rank(left_images) == 3, "block A images do not span the block") + require(rank(right_images) == 3, "block B images do not span the block") + + +def matrix_rank(rows): + masks = [] + for row in rows: + mask = 0 + for index, bit in enumerate(row): + if bit: + mask |= 1 << index + masks.append(mask) + return rank(masks) + + +def check_complete_pool(width): + patterns = check_witness_arithmetic(width) + pool = complete_pool(patterns, width) + require(sorted(pool) == sorted(WITNESS), + "complete pool at width %s is not the seven projectors" % width) + require(rank([image for image, _covector in pool]) == 7, "image rank changed") + require(rank([covector for _image, covector in pool]) == 7, "covector rank changed") + + +def check_irreducibility(): + pool = list(WITNESS) + points = span_points([image for image, _covector in pool]) + require(len(points) == 128, "irreducibility census domain is not the 128-point image") + proper = 0 + for seed in points: + if seed == 0: + continue + dimension = generated_dimension(seed, pool) + if dimension != 7: + proper += 1 + require(proper == 0, "a nonzero vector generates a proper invariant subspace") + + +def check_deleted_projector(): + pool = list(WITNESS[:-1]) + patterns = [pattern_mask(image, covector, 7) for image, covector in pool] + found = complete_pool(patterns, 7) + require(sorted(found) == sorted(pool), "deleting the link changed the remaining pool") + require(rank([image for image, _covector in pool]) == 6, "deleted pool is not 6-dimensional") + block = span_points([image for image, _covector in BLOCK_A]) + require(len(block) == 8, "block A is not 3-dimensional") + require(is_invariant(block, pool), "block A is not invariant after deleting the link") + require(generated_dimension(BLOCK_A[0][0], pool) <= 3, + "a block vector escaped its block after the link was deleted") + + +def even_column_patterns(width): + patterns = [] + for mask in range(64): + if weight(mask) % 2 or mask == 0: + continue + image = 1 | (mask << 1) # e0 plus an even vector on coordinates 1..6 + patterns.append(pattern_mask(image, 1, width)) + return patterns + + +def check_parity_control(width): + patterns = even_column_patterns(width) + require(rank(patterns) == 5, "parity pattern rank is not 5") + require(min(space_weights(patterns)[1:]) >= 2, "parity space contains a unit or zero") + require(not contains_unit(patterns, width), "parity space contains a matrix unit") + pool = complete_pool(patterns, width) + require(len(pool) == 31, "parity pool does not have the 31 even patterns") + require(all(covector == 1 for _image, covector in pool), "parity covector is not e0") + images = [image for image, _covector in pool] + require(rank(images) == 6, "parity image rank is not 6") + # Every covector is e0, so the even-weight vector e1+e2 is killed and its + # cyclic subspace is a line. An image vector is not a valid control: e0 + # hits every image, and closing under those hits spans the whole image. + kernel_line = 0b110 + require(in_span(gaussian(images), kernel_line), "parity kernel vector is outside the image") + require(all(dot(covector, kernel_line) == 0 for _image, covector in pool), + "parity kernel vector is not killed") + require(generated_dimension(kernel_line, pool) == 1, + "parity control failed to find a proper invariant subspace") + + +def check_unit_detector(): + require(contains_unit([position_bit(0, 1, 4)], 4), "unit detector missed a matrix unit") + require(not contains_unit( + [pattern_mask(image, covector, 7) for image, covector in WITNESS], 7), + "unit detector fired on the witness") + + +def main(): + check_selected_frontier() + check_dual_bases() + for width in (7, 8, 9): + check_complete_pool(width) + check_irreducibility() + check_deleted_projector() + for width in (7, 8): + check_parity_control(width) + check_unit_detector() + print(MARKER) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())