From 9da06cbe0b888293cbb249cb29eef0f37addaa4f Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 04:06:13 -0500 Subject: [PATCH] Prove the irreducible image-basis bound and equality classification --- research/no-edge-image-basis-bound/CREDITS.md | 28 + research/no-edge-image-basis-bound/PROOF.md | 263 +++++++ research/no-edge-image-basis-bound/README.md | 57 ++ .../no-edge-image-basis-bound/RESULT.json | 735 ++++++++++++++++++ .../no-edge-image-basis-bound/SOURCES.json | 18 + research/no-edge-image-basis-bound/TASK.json | 79 ++ .../no-edge-image-basis-bound/VERIFY.json | 34 + research/no-edge-image-basis-bound/verify.py | 312 ++++++++ 8 files changed, 1526 insertions(+) create mode 100644 research/no-edge-image-basis-bound/CREDITS.md create mode 100644 research/no-edge-image-basis-bound/PROOF.md create mode 100644 research/no-edge-image-basis-bound/README.md create mode 100644 research/no-edge-image-basis-bound/RESULT.json create mode 100644 research/no-edge-image-basis-bound/SOURCES.json create mode 100644 research/no-edge-image-basis-bound/TASK.json create mode 100644 research/no-edge-image-basis-bound/VERIFY.json create mode 100644 research/no-edge-image-basis-bound/verify.py diff --git a/research/no-edge-image-basis-bound/CREDITS.md b/research/no-edge-image-basis-bound/CREDITS.md new file mode 100644 index 0000000000..5f15ddf193 --- /dev/null +++ b/research/no-edge-image-basis-bound/CREDITS.md @@ -0,0 +1,28 @@ +# Credit and source boundary + +Prepared by Ali Romman with substantial OpenAI Codex assistance. New work is +Apache-2.0. No predecessor code is imported or copied at runtime. + +- unpaidmoon supplied the normal-form triple and its finite classification in + [PR #6921](https://github.com/CrocSwap/integer-mult-bounds/pull/6921), + [exact proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/6020400853abc110134804fad04b695adc360bcd/research/no-edge-irreducible-image/PROOF.md). + The 168-basis lemma is repeated by the new verifier and is a mathematical + dependency of the equality classification. +- unpaidmoon supplied the seven-projector two-block construction in + [PR #7237](https://github.com/CrocSwap/integer-mult-bounds/pull/7237) and + the fresh-link family and open structural question in + [PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281), + [exact proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/0cd5324c41490b856d0e94daa8b011683fc153f6/research/no-edge-dim5-fresh-link/PROOF.md). +- Nick Petalas supplied the nonsymmetric link in + [PR #7648](https://github.com/CrocSwap/integer-mult-bounds/pull/7648), + [exact source](https://github.com/petalas/integer-mult-bounds/blob/f967555200c111925d48a46b65b124432a762b65/research/no-edge-asymmetric-block-link/README.md). + The exact source of PR #6921 also credits him for the earlier pattern-fiber + lemma in [PR #5921](https://github.com/CrocSwap/integer-mult-bounds/pull/5921). +- Ali Romman, with substantial OpenAI Codex assistance, supplied the fixed + two-block fresh-factor classification in + [PR #7676](https://github.com/CrocSwap/integer-mult-bounds/pull/7676), + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/943c355c233649f77f018e6247e5456584ef715e/research/two-block-fresh-link-classification/PROOF.md). + +The diagonal-kernel bound, forced equality structure and even-block converse +are the new result. Prior two-block examples, their fresh-factor parameters +and the three-coordinate lemma are not claimed as new constructions. diff --git a/research/no-edge-image-basis-bound/PROOF.md b/research/no-edge-image-basis-bound/PROOF.md new file mode 100644 index 0000000000..f07a02ac91 --- /dev/null +++ b/research/no-edge-image-basis-bound/PROOF.md @@ -0,0 +1,263 @@ +# A bound for irreducible image-basis projector collections + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The written proof and the finite checks need independent review. + +## 1. Statement and scope + +Work over F2 in a fixed coordinate space of width W. Let +`P_i = u_i v_i^T`, for `1 <= i <= n`, be rank-one idempotents. Thus +`v_i^T u_i = 1`. Assume that the n image vectors are independent. Let V be +their span. Assume that the collection acts irreducibly on V. Delete the +diagonal of a matrix with the map off. Set + +```text +H = span{off(P_i)}, k = dim(H). +``` + +Assume that each pattern is nonzero and that H contains no off-diagonal +matrix unit. The collection need not be the complete pool of H. + +**Theorem.** `2n <= 3k-1`. + +If equality holds and `n > 1`, there is an even integer `d >= 2` such that +`n=3d+1` and `k=2d+1`. Up to coordinate and projector permutations, the +collection consists of d disjoint normal-form triples and one link: + +```text +On block j, with coordinates (3j,3j+1,3j+2): + u = e_(3j+1)+e_(3j+2), v = e_(3j)+e_(3j+2), + o = e_(3j)+e_(3j+1)+e_(3j+2), + projectors u v^T, v u^T, o o^T. + +h = sum_j e_(3j+2). +Link = (h+a)(h+b)^T, + a,b supported outside the blocks, a dot b = 1. +``` + +Conversely, every such even-block collection attains equality. Its pattern +space contains no matrix unit, its action is irreducible, and its complete +noncoordinate rank-one idempotent pool is exactly this collection. + +In particular, **seven projectors with independent images, irreducible +action and pattern dimension at most five must have the two-block form**. +This resolves the minimum-cardinality case of the open classification in +[PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281), +[exact question 2](https://github.com/unpaidmoon/integer-mult-bounds/blob/0cd5324c41490b856d0e94daa8b011683fc153f6/research/no-edge-dim5-fresh-link/PROOF.md). +It does not show that an arbitrary larger complete pool contains an +irreducible seven-projector subcollection. The general image bound at +pattern dimension five remains open. + +The two-block example and its links are prior work. See +[PR #7237](https://github.com/CrocSwap/integer-mult-bounds/pull/7237), +[PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281), +[PR #7648](https://github.com/CrocSwap/integer-mult-bounds/pull/7648) and +[PR #7676](https://github.com/CrocSwap/integer-mult-bounds/pull/7676). +The new result forces the blocks under the independent-image hypothesis +and gives the general bound and equality classification. + +## 2. Independent covectors and the diagonal kernel + +The common kernel of the restricted covectors on V is invariant. It is not +V, since each projector fixes its own image vector. Irreducibility therefore +makes this kernel zero. There are n covectors on the n-dimensional space V, +so their restrictions are independent. In particular, the matrices +`u_i v_j^T`, for all i,j, are independent: apply the dual basis to the image +factor, and then use independence of the covectors. + +The span A of the projectors has dimension n. Its diagonal subspace +`K = A intersect ker(off)` has dimension `d=n-k`. Choose a basis +`D_1,...,D_d` of K. Express each basis matrix in the projector basis, and let +`r_i in F2^d` contain the coefficients of projector i across these expressions. +These coefficient vectors span F2^d. Otherwise a nonzero linear combination +of the D matrices would have all coefficients zero. + +Every diagonal binary matrix D is idempotent. If +`D = sum_i s_i P_i`, independence of the outer matrices gives + +```text +s_i s_j (v_i dot u_j) = s_i delta_ij. +``` + +Thus two different projectors that occur in the same diagonal sum are +orthogonal in both orders. For any two nonzero vectors `r_i,r_j`, some +linear functional on F2^d takes the value one on both. If they are equal, +choose a functional that is one on that vector. If they differ, they are +independent over F2, so prescribe both values. Apply this functional to the +basis of K. It follows that **all projectors with nonzero coefficient +vectors are mutually orthogonal**. + +At least one coefficient vector is zero. If none were zero, every projector +would be orthogonal to the others, and each image line would be invariant. +This contradicts irreducibility when `n>1`. When `n=1`, a nonzero pattern +gives `d=0`, so its coefficient vector is zero as well. + +## 3. Nonzero classes occupy separate coordinate sectors + +Group the projectors with the same nonzero coefficient vector lambda. Each +projector in this class satisfies + +```text +D_j P_i = P_i D_j = lambda_j P_i. +``` + +This follows by expansion of D_j and the orthogonality just proved. The +coordinate projection onto the simultaneous diagonal eigenspace lambda is + +```text +Q_lambda = product_(lambda_j=1) D_j + product_(lambda_j=0) (I-D_j). +``` + +Since lambda is nonzero, this product contains at least one D factor. +Expansion and orthogonality give +`Q_lambda = sum_(r_i=lambda) P_i` as full ambient matrices. There is no +extra identity term outside V. The rank of this sum equals the number of +projectors in the class, because their images are independent and each +projector is the identity on its image and zero on the other class images. +The matrix Q_lambda is diagonal, so the class occupies exactly that many +coordinate positions. Both factors of each class projector are supported +on those positions. Different classes use disjoint positions. + +A class cannot have size one: its projector would be diagonal. A class +cannot have size two either. In a two-coordinate block, a noncoordinate +rank-one idempotent over F2 has exactly one off-diagonal entry. If both +off-diagonal entries were one, both factors would be `(1,1)`, whose pairing +is zero. Such a size-two class would put a matrix unit in H. + +Thus every nonzero class has at least three members. The coefficient vectors +span F2^d, so there are at least d nonzero classes. Including the zero class +gives `n >= 3d+1 = 3(n-k)+1`, which is the claimed bound. + +## 4. Equality forces normal triples and a star + +Suppose equality holds and `n>1`. Then `d>0`, there are exactly d nonzero +classes, each has size three, and there is exactly one zero-class projector. +The nonzero coefficient vectors are a basis. Each three-coordinate class +is an orthogonal basis of rank-one projectors. + +The normal-form lemma from unpaidmoon's +[PR #6921](https://github.com/CrocSwap/integer-mult-bounds/pull/6921), +[Section 3](https://github.com/unpaidmoon/integer-mult-bounds/blob/6020400853abc110134804fad04b695adc360bcd/research/no-edge-irreducible-image/PROOF.md), +classifies such a triple when its pattern span contains no matrix unit. +It is the triple in Section 1, up to coordinate permutation. For completeness, +the finite step is repeated here: enumerate all 168 ordered bases of F2^3, +take the dual covectors, and discard triples with a zero pattern or a +matrix unit in their span. Exactly 18 bases remain. Their image weights +are 2,2,3. The weight-three vector is `(1,1,1)`; the other two vectors are +distinct weight-two vectors and are dual to each other. This gives the +three unordered coordinate versions and no others. The verifier contains +this complete finite enumeration. The classification uses this finite lemma. + +Write the remaining projector as `x y^T`. For each old projector +`u_i v_i^T`, irreducibility forces both pairings +`y dot u_i = 1` and `v_i dot x = 1`. If the first were zero, the old image +line would be invariant. If the second were zero, the span of every image +except u_i would be an invariant hyperplane. The other old projectors are +orthogonal, so these claims follow directly by applying each projector. + +The core of x is therefore the sum of all old images. The core of y is the +sum of all old covectors. For a normal triple, each sum is its hub coordinate. +Thus `x=h+a` and `y=h+b` with fresh a,b. Independence of the images gives +`a != 0`. In the basis of all image vectors, the covector-pairing matrix is + +```text +B = [ I_(3d) 1 ] + [ 1^T 1 ]. +``` + +It is invertible by Section 2. Adding all old rows to the final row gives +its last diagonal entry `1+3d` in F2. Hence d is even. Idempotence of the +link then gives `a dot b = 1+h dot h = 1`. This also proves `b != 0`. + +For `n=7` and `k<=5`, the bound forces `k=5`, so equality applies and `d=2`. + +## 5. Converse and complete pool + +Take any even `d>=2`, the d normal triples, and a link as in Section 1. +The old images span their `3d` coordinates, and the nonzero fresh image a +makes all `3d+1` images independent. Their covector-pairing matrix is B above. +It is invertible. Its off-diagonal incidence graph is a star with both +directions on every edge. Any nonzero invariant subspace contains some old +or new image: the covectors have no common kernel, so some projector maps +a nonzero vector to its image. The star then gives every image. Thus the +action is irreducible. + +Each normal block contributes pattern dimension two. Their supports are +disjoint, so the old pattern space H0 has dimension `2d`. The link has +nonzero entries outside those blocks, so the full pattern dimension is +`2d+1`. A nonzero pattern in H0 has weight at least three. In the odd coset, +choose a fresh row where a is one. Its entries in the old columns are the +d hub entries, independent of the chosen H0 term. Since `d>=2`, that coset +contains no matrix unit either. + +To check completeness, first take a noncoordinate rank-one idempotent whose +pattern lies in H0. No fresh factor bit can occur: a fresh image bit would +force its covector to that same coordinate, after which the zero outside +column would force a coordinate projector. The same argument applies to a +fresh covector bit. Idempotence gives a coordinate where both factors are +one. The forbidden cross-block entries then force both factors into that +one block. The normal triple is the complete pool in its two-dimensional +pattern space, as the finite three-coordinate check verifies. + +Now take a projector whose pattern lies in `off((h+a)(h+b)^T)+H0`. +A fresh row with a one has old row h. Since h is nonzero, it forces that +image bit to one and forces the entire old covector to h. A fresh column +with a one in b forces the entire old image to h. The remaining fresh rows +and columns then force the fresh factors to be a and b. Thus the only lift +in this coset is the link itself. The complete pool is exactly the stated +collection. This argument also reproves completeness without importing a +runtime predecessor package. + +The fixed two-block fresh-factor classification was established in +[PR #7676](https://github.com/CrocSwap/integer-mult-bounds/pull/7676), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/943c355c233649f77f018e6247e5456584ef715e/research/two-block-fresh-link-classification/PROOF.md). +The nonsymmetric example is due to Nick Petalas in +[PR #7648](https://github.com/CrocSwap/integer-mult-bounds/pull/7648), +[exact source](https://github.com/petalas/integer-mult-bounds/blob/f967555200c111925d48a46b65b124432a762b65/research/no-edge-asymmetric-block-link/README.md). +Those results supply context and credit; they are not new two-block examples +claimed by this package. + +## 6. Checks and limits + +The exact verifier repeats the 168-basis lemma. It checks complete pools for +nine equality fixtures with 2,4,6 blocks and symmetric or nonsymmetric fresh +factors. This covers all 26199 nonzero patterns in those nine spaces. It +checks the diagonal kernel, all coordinate sectors, image and covector rank, +and strong incidence. For the seven-image fixtures it also checks the orbit +of each of the 127 nonzero vectors directly. + +It also checks every image-basis collection at ambient width three, with +projector labels removed by sorting the distinct images: 2156 collections. +Exactly 146 have nonzero unit-free patterns, and 19 of these are irreducible. +For all 146, the incidence test agrees with direct vector-orbit closure. +Every irreducible case satisfies the bound. + +The pool enumeration uses a four-trial lift rule. Choose a one at position +`(i,j)` of a nonzero pattern. Then `x_i=y_j=1`; column j fixes every image +bit except x_j, and row i fixes every covector bit except y_i. Test the four +remaining pairs against the entire pattern and the idempotence condition. +The verifier compares this rule with all noncoordinate rank-one idempotents +at widths 2,3,4: respectively 4,25,116 matrices. This rule is consistent with +Nick Petalas's fiber lemma, credited by the exact source of PR #6921. + +Two boundary controls violate the bound after a hypothesis is removed. +The six old projectors from two normal blocks have `n=6,k=4`, but the action +is reducible. The pairs `(1,3),(3,2),(6,5)` at width three have `n=3,k=2` +and irreducible action, but their pattern space contains a matrix unit. +The bit integers give coordinate supports, with coordinate zero in the low +bit. Three odd-block stars are idempotent and have a one-dimensional common +kernel, which checks the parity obstruction. + +No claim is made about arbitrary dependent-image collections, paid BIT +words, native implementation, complete recursive invoices, or kappa. The +selected frontier and its five assumptions stay unchanged. The finite checks +do not constitute formal-kernel or independent human review. + +## Open next questions + +Can a complete unit-free pattern-dimension-five pool with irreducible image +dimension seven avoid every irreducible seven-projector subcollection? +First examine the incidence and common kernels of image-basis subcollections. +The theorem applies to such a subcollection only after its irreducibility +has been proved. It must not be inferred from irreducibility of the full pool. diff --git a/research/no-edge-image-basis-bound/README.md b/research/no-edge-image-basis-bound/README.md new file mode 100644 index 0000000000..c63b538a8c --- /dev/null +++ b/research/no-edge-image-basis-bound/README.md @@ -0,0 +1,57 @@ +# Irreducible image-basis collections + +An irreducible collection of n binary rank-one idempotents with independent +images satisfies `2n <= 3k-1`, where k is the dimension of its nonzero +off-diagonal pattern span and that span contains no matrix unit. + +Equality, for `n>1`, forces an even number d of disjoint normal-form triples +and one fresh-factor hub link, with `n=3d+1` and `k=2d+1`. Every such family +is a complete pool and attains equality. In particular, a seven-projector +irreducible collection with seven-dimensional image and pattern dimension +at most five must have the known two-block form. + +Read [PROOF.md](PROOF.md) for the proof and source credit, +[RESULT.json](RESULT.json) for exact fixtures and checks, and +[TASK.json](TASK.json) for the task boundary. This answers the +minimum-cardinality case of the open structural question in +[PR #7281](https://github.com/CrocSwap/integer-mult-bounds/pull/7281). +The construction of the two blocks and the classification after those blocks +are fixed are prior work. The new step forces the blocks. + +With CPython 3.12 and its standard library, from the repository root: + +```sh +python3.12 -I -W error -B research/no-edge-image-basis-bound/verify.py +python3.12 -I -W error -B -O research/no-edge-image-basis-bound/verify.py +python3.12 -B scripts/research_package.py --package research/no-edge-image-basis-bound +``` + +Expected markers: + +```text +PASS_NO_EDGE_IMAGE_BASIS_BOUND +PASS_REGISTERED_RESEARCH_PACKAGE +``` + +The verifier checks all 168 three-dimensional bases, all 26199 nonzero +patterns in nine equality fixtures, exact diagonal sectors and irreducibility. +Direct vector-orbit checks cover the seven-dimensional fixtures. Exhaustive +small idempotent scans check the four-trial lift method. Reducible, matrix-unit +and odd-block controls check the required hypotheses. The all-width proof +uses the complete finite three-coordinate classification lemma. + +No new kappa, paid BIT word, native operator or complete invoice is supplied. +The selected frontier and all five assumptions remain unchanged. Larger +pools with dependent images are outside this result. Predecessor scientific +replays, the selected cold replay, Lean and Docker were not run. Independent +human and formal-kernel review are unclaimed. + +## Open next questions + +Can an irreducible complete pool of pattern dimension five and image dimension +seven lack an irreducible image-basis subcollection? First check the incidence +and common kernels of those subcollections. A proof of existence would extend +the classification; the current theorem does not provide it. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. New work is +Apache-2.0. See [CREDITS.md](CREDITS.md) for predecessor sources. diff --git a/research/no-edge-image-basis-bound/RESULT.json b/research/no-edge-image-basis-bound/RESULT.json new file mode 100644 index 0000000000..a04c8bce45 --- /dev/null +++ b/research/no-edge-image-basis-bound/RESULT.json @@ -0,0 +1,735 @@ +{ + "statement": "2n <= 3k-1 for irreducible image-basis collections with nonzero unit-free patterns", + "triple_census": { + "invertible_bases": 168, + "ordered_survivors": 18, + "unordered_triples": 3, + "triples": [ + [ + [ + 3, + 5 + ], + [ + 5, + 3 + ], + [ + 7, + 7 + ] + ], + [ + [ + 3, + 6 + ], + [ + 6, + 3 + ], + [ + 7, + 7 + ] + ], + [ + [ + 5, + 6 + ], + [ + 6, + 5 + ], + [ + 7, + 7 + ] + ] + ] + }, + "complete_width_three_census": { + "image_basis_collections": 2156, + "nonzero_unit_free": 146, + "irreducible": 19 + }, + "lift_cross_checks": [ + { + "width": 2, + "patterns": 2, + "idempotents": 4 + }, + { + "width": 3, + "patterns": 19, + "idempotents": 25 + }, + { + "width": 4, + "patterns": 104, + "idempotents": 116 + } + ], + "sharp_complete_families": [ + { + "blocks": 2, + "width": 7, + "fresh_x": 1, + "fresh_y": 1, + "projectors": 7, + "pattern_dimension": 5, + "diagonal_dimension": 2, + "patterns_checked": 31, + "sector_supports": [ + 7, + 56 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 100, + 100 + ] + ] + }, + { + "blocks": 2, + "width": 8, + "fresh_x": 1, + "fresh_y": 3, + "projectors": 7, + "pattern_dimension": 5, + "diagonal_dimension": 2, + "patterns_checked": 31, + "sector_supports": [ + 7, + 56 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 100, + 228 + ] + ] + }, + { + "blocks": 2, + "width": 9, + "fresh_x": 3, + "fresh_y": 5, + "projectors": 7, + "pattern_dimension": 5, + "diagonal_dimension": 2, + "patterns_checked": 31, + "sector_supports": [ + 7, + 56 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 228, + 356 + ] + ] + }, + { + "blocks": 4, + "width": 13, + "fresh_x": 1, + "fresh_y": 1, + "projectors": 13, + "pattern_dimension": 9, + "diagonal_dimension": 4, + "patterns_checked": 511, + "sector_supports": [ + 7, + 56, + 448, + 3584 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 6436, + 6436 + ] + ] + }, + { + "blocks": 4, + "width": 14, + "fresh_x": 1, + "fresh_y": 3, + "projectors": 13, + "pattern_dimension": 9, + "diagonal_dimension": 4, + "patterns_checked": 511, + "sector_supports": [ + 7, + 56, + 448, + 3584 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 6436, + 14628 + ] + ] + }, + { + "blocks": 4, + "width": 15, + "fresh_x": 3, + "fresh_y": 5, + "projectors": 13, + "pattern_dimension": 9, + "diagonal_dimension": 4, + "patterns_checked": 511, + "sector_supports": [ + 7, + 56, + 448, + 3584 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 14628, + 22820 + ] + ] + }, + { + "blocks": 6, + "width": 19, + "fresh_x": 1, + "fresh_y": 1, + "projectors": 19, + "pattern_dimension": 13, + "diagonal_dimension": 6, + "patterns_checked": 8191, + "sector_supports": [ + 7, + 56, + 448, + 3584, + 28672, + 229376 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 196608, + 163840 + ], + [ + 163840, + 196608 + ], + [ + 229376, + 229376 + ], + [ + 411940, + 411940 + ] + ] + }, + { + "blocks": 6, + "width": 20, + "fresh_x": 1, + "fresh_y": 3, + "projectors": 19, + "pattern_dimension": 13, + "diagonal_dimension": 6, + "patterns_checked": 8191, + "sector_supports": [ + 7, + 56, + 448, + 3584, + 28672, + 229376 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 196608, + 163840 + ], + [ + 163840, + 196608 + ], + [ + 229376, + 229376 + ], + [ + 411940, + 936228 + ] + ] + }, + { + "blocks": 6, + "width": 21, + "fresh_x": 3, + "fresh_y": 5, + "projectors": 19, + "pattern_dimension": 13, + "diagonal_dimension": 6, + "patterns_checked": 8191, + "sector_supports": [ + 7, + 56, + 448, + 3584, + 28672, + 229376 + ], + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 196608, + 163840 + ], + [ + 163840, + 196608 + ], + [ + 229376, + 229376 + ], + [ + 936228, + 1460516 + ] + ] + } + ], + "controls": { + "without_irreducibility": { + "n": 6, + "k": 4 + }, + "with_matrix_unit": { + "n": 3, + "k": 2 + }, + "odd_stars": [ + { + "blocks": 1, + "projectors": 4, + "gram_nullity": 1 + }, + { + "blocks": 3, + "projectors": 10, + "gram_nullity": 1 + }, + { + "blocks": 5, + "projectors": 16, + "gram_nullity": 1 + } + ] + }, + "scope": "Finite checks support the all-width proof; larger dependent-image pools remain outside the theorem.", + "kappa_change": null +} diff --git a/research/no-edge-image-basis-bound/SOURCES.json b/research/no-edge-image-basis-bound/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/no-edge-image-basis-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "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-image-basis-bound/TASK.json b/research/no-edge-image-basis-bound/TASK.json new file mode 100644 index 0000000000..2a4021ec88 --- /dev/null +++ b/research/no-edge-image-basis-bound/TASK.json @@ -0,0 +1,79 @@ +{ + "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": "All-width bound 2n <= 3k-1 for irreducible image-basis collections, with complete equality classification and the seven-projector consequence.", + "scope_change_reason": "Resolve the minimum-cardinality case of the open no-edge structural question. This is a scalar classification, not a new register alphabet or paid word.", + "bottleneck_link": "Force the two-block geometry in the image-basis case and identify the exact dependent-image gap before further BIT word searches.", + "budget_minutes": 60, + "stop_rule": "Stop at the bound, equality proof and exact controls. Do not infer an irreducible basis subcollection of an arbitrary pool or claim a native supplier.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; all 168 three-dimensional bases, nine complete equality pools, 26199 nonzero patterns and hypothesis controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can an irreducible complete pool of image dimension seven and pattern dimension five lack every irreducible image-basis subcollection?", + "why_it_matters": "The present classification needs that subcollection, so it does not settle the full pool question.", + "first_step": "Check incidence connectivity and common kernels of image-basis subcollections.", + "blocked_by": "No subcollection existence theorem is supplied." + } + ], + "family_decision": { + "decision": "Narrow to a structural proof before another construction search.", + "sources": "6921@6020400853abc110134804fad04b695adc360bcd; 7281@0cd5324c41490b856d0e94daa8b011683fc153f6; 7648@f967555200c111925d48a46b65b124432a762b65; 7676@943c355c233649f77f018e6247e5456584ef715e", + "evidence_status": "Author-checked proof with finite exact checks; independent review remains open.", + "boundary": "Binary scalar projectors in a fixed coordinate space; independent images and irreducible action; no word or native state.", + "obligations": { + "scalar_bound": "proved in the written argument", + "small_classification": "complete finite verification", + "paid_word": "unknown", + "native_conversion": "unknown", + "complete_invoice": "unknown" + }, + "alternative": "A further fixed-block link search is already covered by PR7676. This proof tests whether the blocks are necessary.", + "construction_gate": "Unmet. This result does not supply a larger register alphabet, uniform paid identity or full invoice." + } +} diff --git a/research/no-edge-image-basis-bound/VERIFY.json b/research/no-edge-image-basis-bound/VERIFY.json new file mode 100644 index 0000000000..1a3ab1d42b --- /dev/null +++ b/research/no-edge-image-basis-bound/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete small normal-form lemma, complete equality pools, diagonal sectors, irreducibility and hypothesis controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete small normal-form lemma, complete equality pools, diagonal sectors, irreducibility and hypothesis controls." + } + ] +} diff --git a/research/no-edge-image-basis-bound/verify.py b/research/no-edge-image-basis-bound/verify.py new file mode 100644 index 0000000000..c126b9119b --- /dev/null +++ b/research/no-edge-image-basis-bound/verify.py @@ -0,0 +1,312 @@ +"""Exact checks for the image-basis bound over F2. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The normal triple is due to unpaidmoon; see PROOF.md for source links. +""" + +import itertools +import json +from pathlib import Path + + +def require(value, message): + if not value: + raise ValueError(message) + + +def parity(value): + return value.bit_count() & 1 + + +def basis(values): + pivots = {} + for value in values: + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + value ^= pivots[pivot] + else: + pivots[pivot] = value + break + return tuple(pivots.values()) + + +def span(values): + result = [0] + for value in basis(values): + result += [old ^ value for old in result] + return result + + +def outer(x, y, width): + result = 0 + while x: + bit = x & -x + result |= y << ((bit.bit_length() - 1) * width) + x ^= bit + return result + + +def off(matrix, width): + for i in range(width): + matrix &= ~(1 << (i * width + i)) + return matrix + + +def patterns(pairs, width): + return [off(outer(x, y, width), width) for x, y in pairs] + + +def lifts(pattern, width): + """An off-diagonal one fixes all factor bits except two.""" + require(pattern != 0, 'zero pattern is outside the pool') + i, j = divmod((pattern & -pattern).bit_length() - 1, width) + require(i != j, 'diagonal pattern entry') + x = sum(((pattern >> (r * width + j)) & 1) << r for r in range(width)) + y = (pattern >> (i * width)) & ((1 << width) - 1) + result = [] + for xj, yi in itertools.product((0, 1), repeat=2): + xx, yy = x | (xj << j), y | (yi << i) + if parity(xx & yy) and off(outer(xx, yy, width), width) == pattern: + result.append((xx, yy)) + return result + + +def pool(pattern_basis, width): + return sorted(pair for pattern in span(pattern_basis) if pattern + for pair in lifts(pattern, width)) + + +def unit_free(pattern_basis): + return all(value.bit_count() != 1 for value in span(pattern_basis)) + + +def gram(pairs): + return [sum(parity(y & x) << j for j, (x, _) in enumerate(pairs)) + for _, y in pairs] + + +def irreducible(pairs): + """For independent images, use full covector rank and strong incidence.""" + n = len(pairs) + require(len(basis(x for x, _ in pairs)) == n, 'images are not independent') + rows = gram(pairs) + if len(basis(rows)) != n: + return False + for start in range(n): + reached = 1 << start + while True: + new = reached + for j, row in enumerate(rows): + if row & reached: + new |= 1 << j + if new == reached: + break + reached = new + if reached != (1 << n) - 1: + return False + return True + + +def orbit_irreducible(pairs): + """Check all nonzero vectors for small fixtures by direct closure.""" + image_space = span(x for x, _ in pairs) + n = len(basis(image_space)) + for value in image_space[1:]: + vectors = basis([value]) + while True: + expanded = basis((*vectors, *(x for x, y in pairs + if any(parity(y & v) for v in vectors)))) + if len(expanded) == len(vectors): + break + vectors = expanded + if len(vectors) != n: + return False + return True + + +def diagonal_kernel(pairs, width): + pivots, relations = {}, [] + for i, value in enumerate(patterns(pairs, width)): + label = 1 << i + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + old, old_label = pivots[pivot] + value ^= old + label ^= old_label + else: + pivots[pivot] = value, label + break + if not value: + relations.append(label) + matrices = [outer(x, y, width) for x, y in pairs] + for relation in relations: + value = 0 + for i, matrix in enumerate(matrices): + if (relation >> i) & 1: + value ^= matrix + require(value != 0 and off(value, width) == 0, 'diagonal kernel') + groups = {} + for i in range(len(pairs)): + character = sum(((relation >> i) & 1) << j + for j, relation in enumerate(relations)) + groups.setdefault(character, []).append(i) + return relations, groups + + +def family(blocks, fresh_x, fresh_y, fresh_width): + require(blocks >= 2 and blocks % 2 == 0, 'even block count') + require(0 < fresh_x < 1 << fresh_width, 'fresh image') + require(0 < fresh_y < 1 << fresh_width, 'fresh covector') + require(parity(fresh_x & fresh_y), 'fresh pairing') + pairs = [] + hub = 0 + for j in range(blocks): + shift = 3 * j + pairs.extend((x << shift, y << shift) for x, y in ((6, 5), (5, 6), (7, 7))) + hub |= 4 << shift + pairs.append((hub | (fresh_x << (3 * blocks)), + hub | (fresh_y << (3 * blocks)))) + return pairs, 3 * blocks + fresh_width + + +def check_family(blocks, fresh_x, fresh_y, fresh_width): + pairs, width = family(blocks, fresh_x, fresh_y, fresh_width) + ps = patterns(pairs, width) + n, k = len(pairs), len(basis(ps)) + require(all(parity(x & y) for x, y in pairs), 'idempotence') + require(all(ps) and unit_free(ps), 'unit-free noncoordinate patterns') + require(n == 3 * blocks + 1 and k == 2 * blocks + 1, 'family dimensions') + require(pool(ps, width) == sorted(pairs), 'complete pool') + require(irreducible(pairs), 'irreducible family') + if n <= 7: + require(orbit_irreducible(pairs), 'independent orbit check') + relations, groups = diagonal_kernel(pairs, width) + require(len(relations) == blocks, 'diagonal dimension') + require(len(groups[0]) == 1, 'one zero character') + supports = [] + for character, indices in groups.items(): + if not character: + continue + require(len(indices) == 3, 'three projectors per nonzero sector') + matrix = 0 + for i in indices: + matrix ^= outer(*pairs[i], width) + require(off(matrix, width) == 0 and matrix.bit_count() == 3, 'coordinate sector') + support = sum(((matrix >> (i * width + i)) & 1) << i for i in range(width)) + require(all(not support & old for old in supports), 'disjoint sectors') + supports.append(support) + require(2 * n == 3 * k - 1, 'sharp bound') + return {'blocks': blocks, 'width': width, 'fresh_x': fresh_x, 'fresh_y': fresh_y, + 'projectors': n, 'pattern_dimension': k, 'diagonal_dimension': len(relations), + 'patterns_checked': (1 << k) - 1, 'sector_supports': supports, + 'pairs': pairs} + + +def compute(): + gl_count = 0 + survivors = [] + triples = set() + for images in itertools.permutations(range(1, 8), 3): + if len(basis(images)) != 3: + continue + gl_count += 1 + covectors = [next(y for y in range(1, 8) + if all(parity(x & y) == (i == j) for j, x in enumerate(images))) + for i in range(3)] + pairs = tuple(zip(images, covectors)) + ps = patterns(pairs, 3) + if all(ps) and unit_free(ps): + require(sorted(x.bit_count() for x in images) == [2, 2, 3], 'normal weights') + require(len(basis(ps)) == 2, 'normal pattern dimension') + require(pool(ps, 3) == sorted(pairs), 'normal triple complete pool') + survivors.append(images) + triples.add(tuple(sorted(pairs))) + require(gl_count == 168 and len(survivors) == 18 and len(triples) == 3, 'triple census') + + small_count = valid_count = irreducible_count = 0 + for n in (1, 2, 3): + for images in itertools.combinations(range(1, 8), n): + if len(basis(images)) != n: + continue + choices = [[y for y in range(1, 8) if parity(x & y)] for x in images] + for covectors in itertools.product(*choices): + small_count += 1 + pairs = list(zip(images, covectors)) + ps = patterns(pairs, 3) + if not all(ps) or not unit_free(ps): + continue + valid_count += 1 + action = irreducible(pairs) + require(action == orbit_irreducible(pairs), 'small incidence/orbit agreement') + if action: + irreducible_count += 1 + require(2 * n <= 3 * len(basis(ps)) - 1, 'small complete bound check') + + # Compare the four-trial lift method with every small idempotent. + lift_counts = [] + for width in (2, 3, 4): + direct = {} + for x, y in itertools.product(range(1, 1 << width), repeat=2): + if parity(x & y): + pattern = off(outer(x, y, width), width) + if pattern: + direct.setdefault(pattern, []).append((x, y)) + for pattern, values in direct.items(): + require(sorted(lifts(pattern, width)) == sorted(values), 'complete lift comparison') + lift_counts.append({'width': width, 'patterns': len(direct), + 'idempotents': sum(map(len, direct.values()))}) + + cases = [check_family(b, a, c, r) for b in (2, 4, 6) + for a, c, r in ((1, 1, 1), (1, 3, 2), (3, 5, 3))] + + old, width = family(2, 1, 1, 1) + old = old[:-1] + old_k = len(basis(patterns(old, width))) + require(unit_free(patterns(old, width)) and not irreducible(old), 'reducible control') + require(2 * len(old) > 3 * old_k - 1, 'irreducibility is necessary') + require(not orbit_irreducible(old), 'reducible orbit control') + + edge_pairs = [(1, 3), (3, 2), (6, 5)] + edge_k = len(basis(patterns(edge_pairs, 3))) + require(irreducible(edge_pairs) and orbit_irreducible(edge_pairs), 'edge control') + require(not unit_free(patterns(edge_pairs, 3)), 'edge must be present') + require(2 * len(edge_pairs) > 3 * edge_k - 1, 'no-unit hypothesis is necessary') + + odd_cases = [] + for blocks in (1, 3, 5): + pairs = [(x << (3 * j), y << (3 * j)) for j in range(blocks) + for x, y in ((6, 5), (5, 6), (7, 7))] + hub = sum(4 << (3 * j) for j in range(blocks)) + pairs.append((hub | (1 << (3 * blocks)), hub | (2 << (3 * blocks)))) + require(all(parity(x & y) for x, y in pairs), 'odd star is idempotent') + require(not irreducible(pairs), 'odd equality star must be reducible') + require(len(basis(gram(pairs))) == len(pairs) - 1, 'odd-star kernel') + odd_cases.append({'blocks': blocks, 'projectors': len(pairs), 'gram_nullity': 1}) + + return {'statement': '2n <= 3k-1 for irreducible image-basis collections with nonzero unit-free patterns', + 'triple_census': {'invertible_bases': gl_count, 'ordered_survivors': len(survivors), + 'unordered_triples': len(triples), 'triples': sorted(triples)}, + 'complete_width_three_census': {'image_basis_collections': small_count, + 'nonzero_unit_free': valid_count, + 'irreducible': irreducible_count}, + 'lift_cross_checks': lift_counts, 'sharp_complete_families': cases, + 'controls': {'without_irreducibility': {'n': len(old), 'k': old_k}, + 'with_matrix_unit': {'n': len(edge_pairs), 'k': edge_k}, + 'odd_stars': odd_cases}, + 'scope': 'Finite checks support the all-width proof; larger dependent-image pools remain outside the theorem.', + 'kappa_change': None} + + +def main(): + actual = json.loads(json.dumps(compute())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + require(actual == expected, 'receipt mismatch') + print('PASS_NO_EDGE_IMAGE_BASIS_BOUND') + print(json.dumps({'triple_bases': 168, 'sharp_families': len(actual['sharp_complete_families']), + 'patterns_checked': sum(x['patterns_checked'] for x in actual['sharp_complete_families'])}, sort_keys=True)) + + +if __name__ == '__main__': + main()