From 0cd5324c41490b856d0e94daa8b011683fc153f6 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 11 Nov 2026 13:49:43 +0000 Subject: [PATCH] Show odd-fresh hub links give further irreducible no-edge images of dimension 7. The fresh-size-3 square on the two normal-form blocks is a complete unit-free pool of pattern dimension 5 and image dimension 7, and it is not a coordinate permutation of the fresh-size-1 witness. Selected kappa is unchanged. Co-authored-by: unpaidmoon --- research/no-edge-dim5-fresh-link/PROOF.md | 402 ++++++++++++++++ research/no-edge-dim5-fresh-link/README.md | 129 ++++++ research/no-edge-dim5-fresh-link/SOURCES.json | 18 + research/no-edge-dim5-fresh-link/TASK.json | 85 ++++ research/no-edge-dim5-fresh-link/VERIFY.json | 36 ++ research/no-edge-dim5-fresh-link/verify.py | 435 ++++++++++++++++++ 6 files changed, 1105 insertions(+) create mode 100644 research/no-edge-dim5-fresh-link/PROOF.md create mode 100644 research/no-edge-dim5-fresh-link/README.md create mode 100644 research/no-edge-dim5-fresh-link/SOURCES.json create mode 100644 research/no-edge-dim5-fresh-link/TASK.json create mode 100644 research/no-edge-dim5-fresh-link/VERIFY.json create mode 100644 research/no-edge-dim5-fresh-link/verify.py diff --git a/research/no-edge-dim5-fresh-link/PROOF.md b/research/no-edge-dim5-fresh-link/PROOF.md new file mode 100644 index 0000000000..1a3297d4d9 --- /dev/null +++ b/research/no-edge-dim5-fresh-link/PROOF.md @@ -0,0 +1,402 @@ +# Odd fresh links on two normal-form blocks + +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 not a new κ. The selected frontier stays +`363005817/100000000000`. The argument does not bound every +pattern-dimension-5 pool, and it does not list those pools. It classifies +one family of links and gives one coordinate counterexample to uniqueness. + +## 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. Write V(P) for the span of the +images. The action is reducible when some subspace 0 < U < V(P) is invariant +under every pool projector. + +Let A = {0,1,2} and B = {3,4,5}. The normal-form triple on A is + +```text +u = e1+e2, v = e0+e2, o = e0+e1+e2, +``` + +with projectors u v^T, v u^T and o o^T. The hub is coordinate 2 and the +leaves are 0 and 1. The same formulas shifted by 3 give the triple on B, +with hub 5 and leaves 3 and 4. These six projectors are the block pool. +Their off-diagonal patterns span a 4-dimensional space H = Q_A ⊕ Q_B, the +sum of the two 2-dimensional block pattern spaces. This is the same pair of +blocks as in the seven-projector witness of #7237. + +For an odd positive integer k, let F_k = {6, 7, ..., 5+k} and + +```text +z_k = e2 + e5 + sum_{t in F_k} e_t. +``` + +**Theorem 1.** For every odd integer k ≥ 1 and every width W ≥ 6+k, let P +be the span of H and off(z_k z_k^T). Then dim P = 5, P contains no matrix +unit, C(P) is exactly the six block projectors and z_k z_k^T, dim V(P) = 7, +and the action on V(P) is irreducible. + +**Theorem 2.** Let z be any vector with z·z = 1 and weight at least 3 whose +support meets A in at most one coordinate and B in at most one coordinate. +Let P be the span of H and off(z z^T), in any width large enough to contain +A ∪ B ∪ supp(z). Then dim P = 5, P contains no matrix unit, C(P) is the six +block projectors and z z^T, and dim V(P) = 7. The action is irreducible if +and only if supp(z) contains both hubs. In that case the fresh set +supp(z) \ (A ∪ B) is nonempty of odd cardinality, and the pool is Theorem 1 +after renaming those fresh coordinates. + +**Corollary.** The k = 3 pool is not a coordinate permutation of the k = 1 +pool. The k = 1 pool is the seven-projector witness of #7237. Therefore an +irreducible complete no-edge pool of pattern dimension 5 and joint-image +dimension 7 need not be a coordinate permutation of that witness. + +Sections 2–6 prove Theorem 1. Section 7 proves Theorem 2. Section 8 is the +corollary. Section 9 records an incidence matrix that does not see k. +Section 10 is a separate exhaustive finite census. It is not an all-width +classification of links that meet a block in two or more coordinates. + +## 2. The pattern space + +The three A-patterns are the ones written in #7237: + +```text +p_u = E10 + E12 + E20, +p_v = E01 + E02 + E21, +p_o = E01 + E02 + E10 + E12 + E20 + E21. +``` + +They have weights 3, 3 and 6. The first two are disjoint and their sum is +the third, so they span Q_A. The translate by 3 spans Q_B. The blocks use +disjoint positions, so H is 4-dimensional. + +The vector z_k has weight 2+k. That weight is odd, so z_k·z_k = 1 and +z_k z_k^T is a rank-one idempotent. Let S = {2,5} ∪ F_k, so |S| = 2+k. +The pattern p_* = off(z_k z_k^T) is 1 on every ordered pair of distinct +points of S, and 0 elsewhere. It has weight |S|(|S|-1) = (2+k)(1+k). + +No position of p_* is internal to A or internal to B: S meets A only at the +hub 2 and B only at the hub 5. Coordinate 6 lies in F_k and in no block, so +column 6 of every matrix in H is zero, while column 6 of p_* is nonzero. +Thus p_* is outside H. Let P = H ⊕ span(p_*). Then dim P = 5. + +A general element is q_A + q_B + λ p_*. If λ = 0 and the element is +nonzero, its weight is a sum of a weight in {0,3,6} from each block, not +both zero, hence at least 3. If λ = 1, every position of p_* survives, +because neither block meets those positions, and there are at least 3·2 = 6 +of them. Every nonzero element has weight at least 3. In particular P +contains no matrix unit. + +## 3. Support of the factors + +Let x y^T be a pool element, and let T = A ∪ B ∪ F_k. Every matrix in P is +zero in every row and every column indexed by t not in T. If x_t = 1, then +y_j = 0 for all j ≠ t, so y = e_t. Then y·x = 1 forces the diagonal entry, +and the off-diagonal pattern is zero, which is not a pool pattern. If +y_t = 1 and x_t = 0 has already been proved, column t is zero, so x = 0, +which is impossible. Thus both factors are supported on T. + +The same reading applies to a fresh coordinate f in F_k when the pattern is +even, meaning λ = 0. An even pattern has zero row f and zero column f, so +x_f = y_f = 0. An even pattern also has no entry between A and B: those +cross positions lie in p_*, not in H. + +## 4. The odd coset + +Every odd pattern contains every position of p_*. Fix the fresh coordinate +f = 6. Column f of H is zero, so column f of every odd pattern equals +column f of p_*: it is 1 on S \ {f} and 0 off S. The entries of column f, +off the diagonal, are x_i y_f. Therefore y_f = 1, x_i = 1 for every i in +S \ {f}, and x_i = 0 for every i outside S. + +Row f of the same pattern is 1 on S \ {f}. Those entries are x_f y_j, so +x_f = 1 and y_j = 1 on S \ {f}. Off S the row is 0, so y_j = 0 outside S. +Thus x = y = z_k. + +The projector is z_k z_k^T, whose pattern is exactly p_*. An odd pattern +with a nonzero block summand differs from p_* on an internal A or B +position, so it is not this pattern. The six entries of one fresh column +already forced the factors. The only odd pool element is z_k z_k^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 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 and some y_a' equal 1. 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. The three nonzero elements of Q_A are p_u, p_v +and p_o. They are realized by u v^T, v u^T and o o^T, and 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 A-projectors, and the same holds for Q_B. There +is no further even pool element. + +The odd-coset forcing in Section 4 does not use the fiber lemma. The +identification of the even pool at every width does. The verifier +enumerates the pool at the widths it checks and does not replace this +citation. + +## 6. Image and irreducibility + +Sections 4 and 5 give, for every W ≥ 6+k, + +```text +C(P) = the six block projectors and z_k z_k^T. +``` + +The three A-images are u, v and o. On coordinates (e0,e1,e2) they are the +rows (0,1,1), (1,0,1) and (1,1,1). Adding the first two produces (1,1,0); +adding the third produces (0,0,1); back-substitution produces the identity. +They are a basis of L = span(e0,e1,e2). The three B-images are a basis of +R = span(e3,e4,e5). The vector z_k is not in L ⊕ R, because it has a fresh +coordinate. Therefore + +```text +V(P) = L ⊕ R ⊕ span(z_k). +``` + +Since e2 lies in L and e5 lies in R, + +```text +V(P) = L ⊕ R ⊕ span(sum_{t in F_k} e_t), dim V(P) = 7. +``` + +Let ζ be the covector z_k, so ζ(w) = z_k·w. Every A-image contains the hub +e2, and every B-image contains the hub e5, so ζ equals 1 on all six block +images. The three A-covectors are v, u and o, each of which contains e2, so +each equals 1 on z_k. The three B-covectors likewise equal 1 on z_k. Also +ζ(z_k) = 1 because the weight 2+k is odd. + +The same three-by-three matrix shows that the A-covectors are a basis of +L*. They vanish on R and on the fresh sum. The B-covectors are a basis of +R* and vanish on L and on the fresh sum. + +Let U be a nonzero invariant subspace of V(P). + +If some w in U has ζ(w) = 1, the linking projector sends w to z_k, so z_k +is in U. Every block covector is 1 on z_k, so every block image is in U. +Those images span L ⊕ R. Then + +```text +sum_{t in F_k} e_t = z_k + e2 + e5 +``` + +lies in U, and U = V(P). + +If instead ζ vanishes on U, no block image lies 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, so every block covector vanishes +on U. The A-covectors span L*, so the L-component of every vector in U is +zero. The same holds for R. A vector of V(P) with both components zero is +λ times the fresh sum, and ζ of that vector equals λ, because the fresh +set has odd size. Thus λ = 0 and U = 0, a contradiction. + +Every nonzero invariant subspace equals V(P). The action is irreducible. + +Deleting the linking projector leaves the six block projectors. 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 fresh +link is what makes the seven-projector action irreducible. The dots in +this section never use a fresh coordinate, so the same deletion leaves L +invariant for every k. + +## 7. The other disjoint-support squares + +Let z have z·z = 1 and weight at least 3, and suppose |supp(z) ∩ A| ≤ 1 +and |supp(z) ∩ B| ≤ 1. Let S = supp(z) and let F = S \ (A ∪ B). Then +|S| ≥ 3 forces F to be nonempty: A ∪ B can contribute at most two points +under the intersection bounds. Let p = off(z z^T). Its positions are the +ordered pairs of distinct points of S. None is internal to A or to B. +A fresh coordinate has zero column in H and nonzero column in p, so +p is outside H and P = H ⊕ span(p) has dimension 5. + +The weight argument of Section 2 still applies: p is disjoint from the +internal block positions, and |S|(|S|-1) ≥ 6. Thus P contains no matrix +unit. Sections 3 and 4 used only that some fresh column of H is zero and +that p is the complete off-diagonal of S. They give the same odd coset: +the only odd pool element is z z^T. Section 5 did not use which point of +A or B lies in S. The even pool is still the six block projectors, by the +same appeal to the fiber lemma. Hence C(P) is those six projectors and +z z^T, and V(P) = L ⊕ R ⊕ span(z) has dimension 7. + +Write h_A = e2 and h_B = e5. + +Suppose S contains both hubs. The intersection bounds then exclude both +leaves, and |F| = weight(z) - 2 is odd and at least 1. Renaming F to +F_k puts this pool under Theorem 1, which is irreducible. + +Suppose S does not contain h_A. There are two cases. + +If S misses A, the linking covector z vanishes on L. Every B-covector is +supported on B, so it vanishes on L. Every A-projector maps into L. Thus +L is invariant. It is nonzero and proper in the 7-dimensional image. + +If S meets A in a leaf ℓ, let m be the other leaf and let u_ℓ = e_m + h_A. +This is the weight-2 A-image that omits ℓ. Its covector is e_ℓ + h_A, which +dots u_ℓ to 1, so that projector sends u_ℓ to itself. The other weight-2 +covector is u_ℓ itself, and u_ℓ·u_ℓ = 0. The full covector o meets u_ℓ in +the two coordinates m and h_A, so the dot is 0. Every B-covector vanishes +on u_ℓ. The link meets A only at ℓ, which u_ℓ omits, so z·u_ℓ = 0. Thus +span(u_ℓ) is invariant. It is a proper nonzero subspace of V(P). + +The symmetric argument applies when S does not contain h_B. Therefore the +action is reducible unless both hubs lie in S. Combined with the previous +paragraph, both hubs are necessary and sufficient. + +## 8. Not a coordinate permutation + +A coordinate permutation preserves the multiset of Hamming weights of the +pool images, and the multiset of Hamming weights of their off-diagonal +patterns. Padding by unused coordinates does not change either multiset. + +For k = 1 the seven image weights are 2, 2, 2, 2, 3, 3, 3 and the seven +pattern weights are 3, 3, 3, 3, 6, 6, 6. The linking image is e2+e5+e6, +of weight 3, and the linking pattern has weight 6. This is the witness +written in #7237. + +For k = 3 the linking image has weight 5 and the linking pattern has +weight 20. The image weights are 2, 2, 2, 2, 3, 3, 5 and the pattern +weights are 3, 3, 3, 3, 6, 6, 20. + +These multisets differ. The k = 3 pool is not a coordinate permutation of +the k = 1 pool. Theorem 1 says the k = 3 pool is an irreducible complete +no-edge pool of pattern dimension 5 and joint-image dimension 7. That is +the corollary in Section 1. + +The same weight comparison separates every two distinct odd fresh sizes. +The linking image weight is 2+k and the linking pattern weight is +(2+k)(1+k). Both strictly increase with k. + +## 9. The incidence matrix does not see the fresh set + +Order the seven projectors as the three A-projectors, the three +B-projectors, and the link. Let G_ij be the dot of covector i with image j. +Section 6 shows that the six block rows form the 6×6 identity in the first +six columns, that every block covector meets the linking image, and that +the linking covector meets every image. Thus + +```text +G = [ I_6 1 ] + [ 1^T 1 ] +``` + +for every odd k. The fresh coordinates never enter these dots. As operators +on the 7-dimensional joint image, the pools therefore have one and the same +incidence matrix. This package does not claim a new configuration of lines, +and it does not claim that the pools are inequivalent under GL(W). The +corollary is only coordinate inequivalence, which is what question 2 of +#7237 asks. The no-edge condition and the pattern dimension are statements +about the standard basis. + +## 10. Exhaustive censuses at widths 7, 8 and 9 + +These censuses fix the two blocks on A and B. They do not range over other +5-dimensional pattern spaces. Each one has a finite domain, and the +verifier visits every element of that domain. + +**Width 7, every idempotent link.** An idempotent is a pair (x, y) with +x ≠ 0 and y·x = 1. There are (2^7 − 1) 2^6 = 8128 such pairs. For each +pair the verifier forms p = off(x y^T). Pairs with p in H, or with p = 0, +are skipped. Each remaining pattern is adjoined to H. If the span contains +a matrix unit or has rank other than 5, it is discarded. Otherwise the +complete pool is enumerated by the same 8128-pair scan, the image rank is +computed, and, when that rank is 7, every nonzero vector of the image is +closed under the pool. The only pattern for which every closure has +dimension 7 is off((e2+e5+e6)(e2+e5+e6)^T). + +This is an exhaustive census of one-idempotent extensions of these two +blocks at width 7. It is not, by itself, a census of every 5-dimensional +pattern space containing H. The reduction is as follows. If P contains H, +has dimension 5, and is unit-free, the quotient P/H is 1-dimensional, so +the patterns outside H are exactly one nonzero pattern p. The six block +images span the 6-dimensional space L ⊕ R. Joint image dimension 7 +therefore requires a pool element whose image lies outside L ⊕ R, and that +element's pattern must be p. So p is realizable and is not a matrix unit. +The fiber lemma gives it one rank-one idempotent lift, which the census +has already tested. At width 7, with these two blocks fixed, the only +irreducible image of dimension 7 is the k = 1 witness. Squares that meet a +block in two or more coordinates are inside this census, because every +idempotent was visited, and none of them is irreducible of image dimension 7. + +**Widths 8 and 9, every square.** A square link is z z^T with z·z = 1, so +z runs through the odd-weight vectors. There are 2^{W-1} of them: 128 at +width 8 and 256 at width 9. The same adjoining test is applied. The +irreducible image-7 hits are + +```text +width 8: e2+e5+e6, e2+e5+e7 +width 9: e2+e5+e6, e2+e5+e7, e2+e5+e8, e2+e5+e6+e7+e8. +``` + +These are exactly the Theorem 1 squares whose fresh coordinates are chosen +from the coordinates beyond B: one fresh coordinate, or, at width 9, all +three fresh coordinates. No square that meets a block in two or more +coordinates is an irreducible image-7 extension at these two widths. That +is a finite census, not a proof for every larger width, and it does not +include non-square idempotents x y^T with x ≠ y. The width-7 census does +include those non-squares, and finds none. + +## 11. 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 original card asks for a new register alphabet. That gate is +unmet. This is a scalar pattern-pool question, and the family expansion +gate is not a reason to start another construction round from this example. + +The theorems do not say that every complete no-edge pool of pattern +dimension 5 has joint image at most 7. The zero-edge quotient bound of +#6782 still gives only dim V ≤ 2^5 − 1 = 31. Theorem 1 attains 7 and does +not exceed it. A search through links on two fixed blocks is not an upper +bound. + +The theorems do not classify a pattern space that does not contain these +two blocks. They do not classify, at every width, a square whose support +meets A or B in two or more coordinates. Section 10 does that only for +squares at widths 8 and 9, and for every idempotent at width 7. They do +not classify non-square idempotent extensions at width 8 or more. + +Question 1 of #7237, whether 7 is an upper bound, remains open. Question 2 +of #7139, the coordinate classification at pattern dimension 4, is not this +result. The dimension-6 pools of #7221 are not these seven-projector pools. + +## 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? + The odd-fresh family shows that 7 is attained and that 6 is too small. + The zero-edge quotient bound is still 31. The missing step is a + one-dimensional extension of a pattern space of dimension 6, not another + fresh set on these two blocks. + +2. **Is there an irreducible image of dimension 7 whose pattern space + contains no two disjoint normal-form blocks?** The width-7 census fixes + the blocks. A pool that is not a coordinate permutation of any odd-fresh + link would be a different coordinate class. The first step is to decide + whether every irreducible image-7 pattern space of dimension 5 contains + at least one normal-form triple. The Grassmannian of 5-planes in the + 42-dimensional space of 7×7 zero-diagonal matrices is not a feasible + enumeration, so that decision needs a structural reduction. + +3. **At width 8, does a non-square idempotent extension of these two blocks + have irreducible image dimension 7?** The width-7 census says no + non-square works at width 7. Width 8 has (2^8 − 1) 2^7 = 32640 + idempotents. This package did not enumerate them. The first step is the + same complete-pool test used at width 7. A partial sample would not be + that census. diff --git a/research/no-edge-dim5-fresh-link/README.md b/research/no-edge-dim5-fresh-link/README.md new file mode 100644 index 0000000000..6367ae870f --- /dev/null +++ b/research/no-edge-dim5-fresh-link/README.md @@ -0,0 +1,129 @@ +# Odd fresh links give further irreducible no-edge pools of image dimension 7 + +**Result.** On two fixed disjoint normal-form blocks, a square link that meets +each block in at most one coordinate has a 5-dimensional unit-free pattern +space, a complete pool of seven projectors, and joint image of dimension 7. +The action is irreducible if and only if both of those coordinates are the +hubs and the remaining support is a nonempty fresh set of odd size. Every +such odd size works, at every large enough width. **No new κ.** The selected +value remains `363005817/100000000000`. + +The fresh-size-1 pool is the seven-projector witness of open PR #7237. The +fresh-size-3 pool has linking image weight 5 and linking pattern weight 20, +while the witness has linking image weight 3 and linking pattern weight 6. +A coordinate permutation preserves both weight multisets, so the size-3 pool +is not a coordinate permutation of the witness. Question 2 of #7237 therefore +has a negative answer: an irreducible complete no-edge pool of pattern +dimension 5 and joint-image dimension 7 need not be a coordinate permutation +of those seven projectors. + +The seven projectors have the same covector-image incidence for every odd +fresh size. This package does not claim a new configuration of lines, and it +does not claim inequivalence under an arbitrary linear change of basis. + +## 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 2 +of #7237 by the link-matching step named there. The reason is recorded in +[TASK.json](TASK.json). The original native acceptance gate is unmet, and +the selected frontier is unchanged. Question 1 of #7237, whether 7 is an +upper bound, is not answered. The dimension-6 coordinate classes of #7221 +are not these pools. + +[PROOF.md](PROOF.md) is the argument. Theorem 1 constructs the odd-fresh +family. Sections 2–4 identify the pattern space and the odd coset without +the fiber lemma. Section 5 cites the fiber lemma of #5921 for the even +coset, which is what extends the pool identification to every width. +Section 6 proves irreducibility. Theorem 2 classifies every other square +whose support meets each block in at most one coordinate: the complete pool +is still seven projectors and the image still has dimension 7, but a missed +block leaves that block's coordinate space invariant, and a leaf leaves the +weight-2 image that omits the leaf invariant. Section 8 separates fresh +sizes by Hamming weight. Section 9 records the common incidence matrix. + +Section 10 is an exhaustive finite census, not a substitute for those +proofs. With the two blocks fixed, every one of the 8128 idempotents at +width 7 was adjoined. The only irreducible image of dimension 7 is the +fresh-size-1 witness. Every odd-weight square at widths 8 and 9 was +adjoined. The irreducible hits are the fresh-size-1 squares on the +available fresh coordinates, and, at width 9, the single fresh-size-3 +square on all three fresh coordinates. Squares that meet a block twice are +inside those domains and are not hits. Non-square idempotents at width 8 +or more were not enumerated. + +[verify.py](verify.py) repeats the family at fresh sizes 1, 3 and 5, +including one padded width for sizes 1 and 3, the incidence matrix, the +weight multisets, the leaf and missed-block controls, the deleted-link +control, and both censuses. These checks certify the stated pools and the +stated finite domains. They do not enumerate five-dimensional pattern +spaces that do not contain the two blocks. + +Source pins are in [SOURCES.json](SOURCES.json). The catalogue is provenance +at the base commit. The selected record is a live 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 with `find_overlap.py` at base +`e54523517d0f03e58352e647c403a5af3e525a57`, while this package was still +untracked. Local coverage searched 10180 notes against a complete head +inventory of 10178; the two extra notes are this package. The open-PR +snapshot had 570 records and the discussion snapshot had 7245, both with +complete pagination. The matches are this package, the pattern-dimension +at most 3 and 4 predecessors, and open #7094, #7138, #7139, #7218, #7221 +and #7237. +#7237 asks the uniqueness question and exhibits the fresh-size-1 witness; +it does not classify other links. #7221 separates dimension-6 pools at +pattern dimension 4. Closed work was searched through local notes and the +ledger, not through a separate closed-PR body fetch. 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-fresh-link/verify.py +python3 -I -O -B research/no-edge-dim5-fresh-link/verify.py +python3 -B scripts/research_package.py --package research/no-edge-dim5-fresh-link --check-only +python3 -B scripts/research_package.py --package research/no-edge-dim5-fresh-link +``` + +The verifier prints `PASS_NO_EDGE_DIM5_FRESH_LINK`. + +## 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 family + attains 7 and shows that 6 is too small. The zero-edge quotient bound is + still 31. The smallest next step is a one-dimensional extension of a + dimension-6 pattern space. Another fresh set on these two blocks does not + decide the bound. + +2. **Is there an irreducible image of dimension 7 with no two disjoint + normal-form blocks?** The width-7 census fixes the blocks. A pool that is + not a coordinate permutation of any odd-fresh link would be a different + coordinate class. The smallest next step is to decide whether every + irreducible image-7 pattern space of dimension 5 contains a normal-form + triple. Enumerating 5-planes in the 42-dimensional space of 7×7 + zero-diagonal matrices is not a feasible substitute for that reduction. + +3. **At width 8, does a non-square idempotent extension of these two blocks + have irreducible image dimension 7?** The width-7 census includes + non-squares and finds none. Width 8 has 32640 idempotents, and this + package did not enumerate them. The smallest next step is the same + complete-pool test. A partial sample would not be that census. + +## Credit + +The fiber lemma is Nick Petalas, #5921. The normal-form triple and the +irreducible bound 3 at pattern dimension at most 3 are #6921. The +pattern-dimension-4 irreducible image is #6962. #7139 proved the +pattern-dimension-4 total-image bound and asked the pattern-dimension-5 +questions; that bound is not an input. #6782 supplies the zero-edge quotient +bound 31. Open #7237 exhibits the fresh-size-1 witness and asks the +uniqueness question answered here; its existence proof is not redone. Open +#7221 classifies dimension-6 pools and is not this seven-projector family. +Prepared by unpaidmoon with substantial Cursor Grok assistance. New work is +Apache-2.0. diff --git a/research/no-edge-dim5-fresh-link/SOURCES.json b/research/no-edge-dim5-fresh-link/SOURCES.json new file mode 100644 index 0000000000..eb24483944 --- /dev/null +++ b/research/no-edge-dim5-fresh-link/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-fresh-link/TASK.json b/research/no-edge-dim5-fresh-link/TASK.json new file mode 100644 index 0000000000..251a86b010 --- /dev/null +++ b/research/no-edge-dim5-fresh-link/TASK.json @@ -0,0 +1,85 @@ +{ + "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": "Classify square links on two fixed disjoint normal-form blocks inside a pattern-dimension-5 no-edge pool, and decide whether the irreducible image-dimension-7 witness is unique up to coordinate permutation.", + "scope_change_reason": "The card asks for a larger or nonabelian register alphabet. This package changes that premise to open question 2 of the pattern-dimension-5 no-edge witness: whether every irreducible complete pool of pattern dimension 5 and joint-image dimension 7 is a coordinate permutation of the seven projectors in open PR #7237. 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 the open #7237 witness.", + "bottleneck_link": "Side result. A second coordinate realization shows that the dimension-7 witness is not unique, so a later argument cannot quote uniqueness as a classification. It does not change a paid identity or the selected kappa. The original native acceptance gate remains unmet.", + "budget_minutes": 60, + "stop_rule": "Stop once the odd-fresh family, the disjoint-support reducibility statement, and the width 7-9 censuses are checked. Do not start an upper bound or a non-square width-8 enumeration.", + "outcome": "completed", + "evidence": "PROOF.md Theorem 1 shows that every odd fresh size on the two hubs gives an irreducible seven-projector pool of pattern dimension 5 and image dimension 7. Theorem 2 shows that every other square meeting each block in at most one coordinate has the same pool shape and image dimension but is reducible, with an explicit invariant subspace. The fresh-size-3 pool is not a coordinate permutation of the fresh-size-1 witness. Section 10 records exhaustive censuses: all 8128 idempotents at width 7, and all odd squares at widths 8 and 9. verify.py repeats those checks. The fiber lemma is cited for the even coset at every width and is not reproved.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance with the case analysis, the width 7-9 censuses, 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 odd-fresh family attains 7, so 6 is too small, but it does not prove an upper bound. The zero-edge quotient bound is still 31.", + "first_step": "Test a one-dimensional extension of one pattern space of dimension 6, and look for an invariant-subspace argument that is not restricted to two normal-form blocks.", + "blocked_by": "Theorems 1 and 2 classify only squares that meet each of two fixed blocks in at most one coordinate." + }, + { + "question": "Is there an irreducible image of dimension 7 whose pattern space contains no two disjoint normal-form blocks?", + "why_it_matters": "Such a pool would be a coordinate class different from every odd-fresh link, including the fresh-size-1 witness.", + "first_step": "Decide whether every irreducible image-7 pattern space of dimension 5 contains at least one normal-form triple.", + "blocked_by": "The Grassmannian of 5-planes in the 42-dimensional space of 7 by 7 zero-diagonal matrices is not a feasible enumeration." + }, + { + "question": "At width 8, does a non-square idempotent extension of these two blocks have irreducible image dimension 7?", + "why_it_matters": "The width-7 census includes non-squares and finds only the fresh-size-1 square. Width 8 was enumerated for squares only.", + "first_step": "Enumerate all (2^8-1)2^7 = 32640 idempotents at width 8 with the same complete-pool test used at width 7.", + "blocked_by": "This package did not run that finite census. A partial sample would not answer the question." + } + ], + "coordination": { + "thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166", + "question_source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7237", + "depends_on": [ + "https://github.com/CrocSwap/integer-mult-bounds/pull/5921", + "https://github.com/CrocSwap/integer-mult-bounds/pull/6921", + "https://github.com/CrocSwap/integer-mult-bounds/pull/7237" + ] + } +} diff --git a/research/no-edge-dim5-fresh-link/VERIFY.json b/research/no-edge-dim5-fresh-link/VERIFY.json new file mode 100644 index 0000000000..09d3f1ba83 --- /dev/null +++ b/research/no-edge-dim5-fresh-link/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": 300, + "checks": "Odd-fresh pools at sizes 1, 3 and 5, reducible leaf and missed-block controls, width-7 idempotent census, and square censuses at widths 8 and 9." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "The same checks with assert statements disabled; the verifier raises SystemExit instead of using assert." + } + ] +} diff --git a/research/no-edge-dim5-fresh-link/verify.py b/research/no-edge-dim5-fresh-link/verify.py new file mode 100644 index 0000000000..08d56f5c75 --- /dev/null +++ b/research/no-edge-dim5-fresh-link/verify.py @@ -0,0 +1,435 @@ +#!/usr/bin/env python3 +"""Finite checks for odd-fresh links on two normal-form blocks. + +PROOF.md is the all-width argument. This program repeats the explicit +arithmetic, the complete pools, the irreducibility closures, the reducible +controls, and two exhaustive censuses. 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_FRESH_LINK" +SELECTED = Path(__file__).resolve().parents[2] / "certificates" / "selected-result.json" +KAPPA = "363005817/100000000000" +DECIMAL = "0.00363005817" + +# Normal-form projectors on A = {0,1,2} and B = {3,4,5}. +# Images omit one leaf or none: e0+e2 omits leaf 1, e1+e2 omits leaf 0. +BLOCK = ( + (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 +) +HUB_A = 2 +HUB_B = 5 +LEAVES_A = (0, 1) +LEAVES_B = (3, 4) + + +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 + shift = 0 + remaining = image + while remaining: + if remaining & 1: + mask |= (covector & ~(1 << row)) << shift + remaining >>= 1 + row += 1 + shift += width + return mask + + +def position_bit(row, column, width): + return 1 << (row * width + column) + + +def complete_pool(patterns, width): + """Every rank-one idempotent whose off-diagonal pattern lies in the span.""" + pivots = gaussian(patterns) + found = [] + for image in range(1, 1 << width): + pivot = (image & -image).bit_length() - 1 + for choice in range(1 << (width - 1)): + low = choice & ((1 << pivot) - 1) + high = choice >> pivot + covector = low | (high << (pivot + 1)) + 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 span_points(vectors): + points = [0] + for vector in gaussian(vectors).values(): + points += [old ^ vector for old in points] + return points + + +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 fresh_bits(count): + return ((1 << count) - 1) << 6 + + +def hub_link(count): + return (1 << HUB_A) | (1 << HUB_B) | fresh_bits(count) + + +def support_size(mask): + return weight(mask) + + +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 space_vectors(patterns): + basis = list(gaussian(patterns).values()) + vectors = [] + for choice in range(1 << len(basis)): + total = 0 + for index, vector in enumerate(basis): + if (choice >> index) & 1: + total ^= vector + vectors.append(total) + return vectors + + +def check_family(count, width): + require(count % 2 == 1 and count >= 1, "fresh count is not a positive odd integer") + require(width >= 6 + count, "width does not hold the fresh coordinates") + link = hub_link(count) + require(weight(link) == 2 + count, "hub link has the wrong weight") + require(dot(link, link) == 1, "hub link is not idempotent") + pool_factors = BLOCK + ((link, link),) + patterns = [pattern_mask(image, covector, width) for image, covector in pool_factors] + require(rank(patterns) == 5, "fresh-link pattern rank is not 5 at k=%s width=%s" % (count, width)) + block_basis = [patterns[0], patterns[1], patterns[3], patterns[4]] + require(rank(block_basis) == 4, "the two blocks are not a 4-dimensional pattern space") + require(not in_span(gaussian(block_basis), patterns[6]), "the link pattern lies in the block span") + weights = [weight(vector) for vector in space_vectors(patterns)] + require(weights.count(0) == 1 and min(weight for weight in weights if weight) >= 3, + "a nonzero fresh-link pattern has weight below 3") + require(not contains_unit(patterns, width), "fresh-link pattern space contains a matrix unit") + require(weight(patterns[6]) == (2 + count) * (1 + count), + "link pattern weight is not |S|(|S|-1)") + found = complete_pool(patterns, width) + require(sorted(found) == sorted(pool_factors), + "complete pool at k=%s width=%s is not the seven projectors" % (count, width)) + images = [image for image, _covector in found] + require(rank(images) == 7, "fresh-link image rank is not 7") + require(rank([covector for _image, covector in found]) == 7, "fresh-link covector rank is not 7") + points = span_points(images) + require(len(points) == 128, "fresh-link image is not 7-dimensional") + for seed in points: + if seed == 0: + continue + require(generated_dimension(seed, found) == 7, + "a fresh-link vector generates a proper subspace at k=%s" % count) + block_a = span_points([image for image, _covector in BLOCK[:3]]) + require(len(block_a) == 8, "block A is not 3-dimensional") + require(not is_invariant(block_a, found), "block A stayed invariant after the hub link was added") + return found + + +def gram_matrix(pool): + images = [image for image, _covector in pool] + covectors = [covector for _image, covector in pool] + rows = [] + for covector in covectors: + row = 0 + for index, image in enumerate(images): + if dot(covector, image): + row |= 1 << index + rows.append(row) + return rows + + +def check_gram_and_weights(): + small = BLOCK + ((hub_link(1), hub_link(1)),) + large = BLOCK + ((hub_link(3), hub_link(3)),) + require(gram_matrix(small) == gram_matrix(large), + "the image/covector incidence changed with the fresh set") + expected = [0b1111111] + [1 << index for index in range(6)] + # Row i bit j means covector i meets image j. The 6x6 block is the + # identity and the link row and link column are all ones. + actual = gram_matrix(small) + require(actual[6] == 0b1111111, "the link covector misses a pool image") + for index in range(6): + require(actual[index] == (1 << index) | (1 << 6), + "a block covector does not meet only its image and the link") + small_images = sorted(weight(image) for image, _covector in small) + large_images = sorted(weight(image) for image, _covector in large) + require(small_images == [2, 2, 2, 2, 3, 3, 3], "k=1 image weights changed") + require(large_images == [2, 2, 2, 2, 3, 3, 5], "k=3 image weights changed") + small_patterns = sorted( + weight(pattern_mask(image, covector, 7)) for image, covector in small) + large_patterns = sorted( + weight(pattern_mask(image, covector, 9)) for image, covector in large) + require(small_patterns == [3, 3, 3, 3, 6, 6, 6], "k=1 pattern weights changed") + require(large_patterns == [3, 3, 3, 3, 6, 6, 20], "k=3 pattern weights changed") + require(expected[0] == 0b1111111, "gram control constant drifted") + + +def avoiding_image(leaf): + if leaf in LEAVES_A: + other = LEAVES_A[0] if leaf == LEAVES_A[1] else LEAVES_A[1] + return (1 << other) | (1 << HUB_A) + if leaf in LEAVES_B: + other = LEAVES_B[0] if leaf == LEAVES_B[1] else LEAVES_B[1] + return (1 << other) | (1 << HUB_B) + fail("avoiding image asked for a non-leaf") + + +def check_square_pool(link, width, label): + require(dot(link, link) == 1, label + " is not idempotent") + factors = BLOCK + ((link, link),) + patterns = [pattern_mask(image, covector, width) for image, covector in factors] + require(rank(patterns) == 5, label + " pattern rank is not 5") + require(not contains_unit(patterns, width), label + " pattern space contains a unit") + found = complete_pool(patterns, width) + require(sorted(found) == sorted(factors), label + " pool is not the seven projectors") + require(rank([image for image, _covector in found]) == 7, label + " image rank is not 7") + return found + + +def check_reducible_controls(): + # Every one-from-A, one-from-B, one-fresh square at width 7. + for point_a in (0, 1, 2): + for point_b in (3, 4, 5): + link = (1 << point_a) | (1 << point_b) | (1 << 6) + found = check_square_pool(link, 7, "leaf link %s,%s" % (point_a, point_b)) + if point_a == HUB_A and point_b == HUB_B: + points = span_points([image for image, _covector in found]) + require(all(generated_dimension(seed, found) == 7 for seed in points if seed), + "the hub-hub link was reducible") + continue + leaf = point_a if point_a != HUB_A else point_b + line = avoiding_image(leaf) + require(dot(link, line) == 0, "a leaf link meets the avoiding image") + require(is_invariant([0, line], found), "the avoiding line is not invariant") + require(generated_dimension(line, found) == 1, "the avoiding line grew") + # Hub on one block only, or on neither. + miss_a = (1 << HUB_B) | (1 << 6) | (1 << 7) + found = check_square_pool(miss_a, 8, "link missing A") + block_a = span_points([image for image, _covector in BLOCK[:3]]) + require(is_invariant(block_a, found), "L is not invariant when the link misses A") + require(generated_dimension(BLOCK[0][0], found) <= 3, "L grew when the link misses A") + miss_b = (1 << HUB_A) | (1 << 6) | (1 << 7) + found = check_square_pool(miss_b, 8, "link missing B") + block_b = span_points([image for image, _covector in BLOCK[3:6]]) + require(is_invariant(block_b, found), "R is not invariant when the link misses B") + leaf_fresh = (1 << 0) | (1 << 6) | (1 << 7) + found = check_square_pool(leaf_fresh, 8, "leaf plus two fresh") + line = avoiding_image(0) + require(is_invariant([0, line], found), "leaf-plus-fresh avoiding line is not invariant") + three_fresh = (1 << 6) | (1 << 7) | (1 << 8) + found = check_square_pool(three_fresh, 9, "three fresh coordinates") + require(is_invariant(block_a, found), "L is not invariant for a link outside both blocks") + # Deleting the k=3 link restores the block invariant subspace. + deleted = list(BLOCK) + patterns = [pattern_mask(image, covector, 9) for image, covector in deleted] + found = complete_pool(patterns, 9) + require(sorted(found) == sorted(deleted), "deleting the k=3 link changed the block pool") + require(is_invariant(block_a, found), "block A is not invariant after deleting the k=3 link") + + +def irreducible_image7(patterns, width): + if rank(patterns) != 5 or contains_unit(patterns, width): + return None + pool = complete_pool(patterns, width) + images = [image for image, _covector in pool] + if rank(images) != 7: + return None + for seed in span_points(images): + if seed and generated_dimension(seed, pool) != 7: + return None + return pool + + +def check_width7_idempotent_census(): + """Every idempotent at width 7, adjoined to the two fixed blocks.""" + width = 7 + base = [pattern_mask(image, covector, width) for image, covector in BLOCK] + base_pivots = gaussian(base) + seen = set() + hits = [] + visited = 0 + for image in range(1, 1 << width): + pivot = (image & -image).bit_length() - 1 + for choice in range(1 << (width - 1)): + visited += 1 + low = choice & ((1 << pivot) - 1) + high = choice >> pivot + covector = low | (high << (pivot + 1)) + if dot(image, covector) == 0: + covector |= 1 << pivot + mask = pattern_mask(image, covector, width) + if mask == 0 or mask in seen or in_span(base_pivots, mask): + continue + seen.add(mask) + pool = irreducible_image7(base + [mask], width) + if pool is not None: + hits.append(mask) + require(visited == 127 * 64, "width-7 idempotent count is not (2^7-1)2^6 = 8128") + witness = pattern_mask(hub_link(1), hub_link(1), width) + require(hits == [witness], "width-7 irreducible image-7 extensions are not exactly the k=1 link") + + +def predicted_square_hits(width): + hits = [] + for fresh in range(6, width): + hits.append((1 << HUB_A) | (1 << HUB_B) | (1 << fresh)) + fresh_count = width - 6 + if fresh_count >= 3 and fresh_count % 2 == 1: + hits.append(hub_link(fresh_count)) + return hits + + +def check_square_census(width): + base = [pattern_mask(image, covector, width) for image, covector in BLOCK] + base_pivots = gaussian(base) + hits = [] + visited = 0 + for link in range(1 << width): + if weight(link) % 2 == 0: + continue + visited += 1 + mask = pattern_mask(link, link, width) + if mask == 0 or in_span(base_pivots, mask): + continue + pool = irreducible_image7(base + [mask], width) + if pool is not None: + hits.append(link) + require(visited == 1 << (width - 1), "odd-vector count at width %s drifted" % width) + require(sorted(hits) == sorted(predicted_square_hits(width)), + "square hits at width %s are not the predicted hub links: %s" + % (width, [format(link, "b") for link in hits])) + + +def check_unit_detector(): + require(contains_unit([position_bit(0, 1, 4)], 4), "unit detector missed a matrix unit") + witness = [pattern_mask(image, covector, 7) for image, covector in BLOCK] + witness.append(pattern_mask(hub_link(1), hub_link(1), 7)) + require(not contains_unit(witness, 7), "unit detector fired on the k=1 witness") + + +def main(): + check_selected_frontier() + check_family(1, 7) + check_family(1, 8) + check_family(3, 9) + check_family(3, 10) + check_family(5, 11) + check_gram_and_weights() + check_reducible_controls() + check_unit_detector() + check_width7_idempotent_census() + check_square_census(8) + check_square_census(9) + print(MARKER) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())