diff --git a/research/no-edge-basis-extraction-failure/CREDITS.md b/research/no-edge-basis-extraction-failure/CREDITS.md new file mode 100644 index 0000000000..b2f0d20b2a --- /dev/null +++ b/research/no-edge-basis-extraction-failure/CREDITS.md @@ -0,0 +1,27 @@ +# Credit and source boundary + +Ali Romman prepared this package with substantial OpenAI Codex assistance. +New work is Apache-2.0. Independent human and formal-kernel review are +unclaimed. + +The question follows the scope boundary of Ali Romman's +[PR #7686](https://github.com/CrocSwap/integer-mult-bounds/pull/7686), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/9da06cbe0b888293cbb249cb29eef0f37addaa4f/research/no-edge-image-basis-bound/PROOF.md). +The binary matrix, span, orbit and four-trial lift primitives are reused +from its [exact verifier](https://github.com/aliromman/integer-mult-bounds/blob/9da06cbe0b888293cbb249cb29eef0f37addaa4f/research/no-edge-image-basis-bound/verify.py). +They are included here, with no runtime dependency on that package. + +unpaidmoon supplied the earlier cyclic complete-pool example in +[PR #6962](https://github.com/CrocSwap/integer-mult-bounds/pull/6962), +[exact proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/46dbf04cae1140f33bd6a12fa6967a54f8d2c417/research/pattern-dim4-irreducible-image/PROOF.md). +That example is an irreducible basis. It is related context for the present +failure of basis extraction. No source code from that package is reused. + +The source record of PR #7686 credits Nick Petalas for the earlier +pattern-fiber lemma and unpaidmoon for the normal-form and two-block pool +results. Those results motivate the restricted pattern-dimension-five +question. They are not reproved or extended to larger dependent-image pools +by the present counterexample. + +The cycle plus one extra projector, the exact three-copy pool embedding and +the all-dimension extraction counterexample are the new result here. diff --git a/research/no-edge-basis-extraction-failure/PROOF.md b/research/no-edge-basis-extraction-failure/PROOF.md new file mode 100644 index 0000000000..b47e2eb6c3 --- /dev/null +++ b/research/no-edge-basis-extraction-failure/PROOF.md @@ -0,0 +1,199 @@ +# Irreducibility need not survive image-basis extraction + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +## 1. Result + +For every integer `n>=3`, there is a binary off-diagonal pattern space H +with these properties: + +- H has dimension `n+1` and contains no matrix unit. Its minimum nonzero + pattern weight is six. +- Its complete noncoordinate rank-one idempotent pool has exactly `n+1` + projectors and joint-image dimension n. +- The full pool acts irreducibly on that image. +- There are exactly two proper subcollections with full joint image. Each + has n independent images and is reducible. + +The construction uses width `3n` and permits arbitrary zero padding. It +therefore gives, at every image dimension `n>=3`, a complete no-edge pool +with no irreducible image-basis subcollection. Its excess of one projector +is the least possible for that property: a full-image collection of n +projectors is itself an image-basis collection. + +This disproves a general basis-extraction premise that could otherwise be +used to extend the theorem in +[PR #7686](https://github.com/CrocSwap/integer-mult-bounds/pull/7686), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/9da06cbe0b888293cbb249cb29eef0f37addaa4f/research/no-edge-image-basis-bound/PROOF.md). +At image dimension seven, the new family has pattern dimension eight. +**It does not answer the extraction question at pattern dimension five.** +A proof that uses that extra restriction remains possible. + +## 2. A three-copy embedding preserves exact complete pools + +Let A be any linear subspace of `M_n(F2)`. Let E send each coordinate vector +to the sum of three new coordinate vectors in its own block. Thus +`E^T E=I`. Define + +```text +R(B) = E B E^T = B tensor J_3, +Phi(B) = off(R(B)), +``` + +where J_3 is the all-one three-by-three matrix. Over F2, `J_3^2=J_3`, so +R is an injective algebra map. It preserves ranks and idempotence. On the +replicated coordinate space `E(F2^n)`, its action agrees with that of B +under E. + +The map Phi is injective. An off-block entry of B appears in all nine +positions of its three-by-three block. A diagonal entry appears in the six +off-diagonal positions of its own block. These supports are disjoint. +For a matrix B with d diagonal ones and o off-diagonal ones, + +```text +weight(Phi(B)) = 6d + 9o. +``` + +Consequently `dim Phi(A)=dim A`, and every nonzero pattern has weight at +least six. In particular, Phi(A) contains no matrix unit. + +**Exact pool lemma.** The complete noncoordinate rank-one idempotent pool of +Phi(A) is precisely the image under R of the rank-one idempotents in A, +including coordinate projectors in A. + +To prove the reverse inclusion, suppose `x y^T` is a rank-one idempotent +with nonzero pattern `Phi(B)` for `B in A`. Choose a nonzero entry `B_ij`. +If `i!=j`, the corresponding off-block rectangle consists of nine ones. +All image bits in block i and all covector bits in block j are therefore +one. If `i=j`, the six off-diagonal ones in that block force all three image +bits and all three covector bits there to be one. + +Use the block of three known image bits. For any ambient column s, choose +a row in that block different from s. The corresponding off-diagonal +entry forces y_s to the B entry for that column's block. Thus y is constant +on each three-coordinate block. The known block of covector ones gives the +same conclusion for x. Write `x=E u`, `y=E v`. Then +`x y^T=R(u v^T)`, and injectivity of Phi gives `B=u v^T`. Since +`y^T x=v^T u`, B is a rank-one idempotent in A. The forward inclusion follows +from rank preservation, idempotence and injectivity of Phi. + +This proof also treats extra zero coordinates: the known nonzero blocks force +all factors on the zero rows and columns to vanish. No new noncoordinate +pool member arises from padding. There is no ambient irreducibility claim: +the action under study is on the joint image, which lies in `E(F2^n)`. + +## 3. The small matrix space + +Index coordinates by `0,...,n-1`, with subscripts taken modulo n. Define + +```text +C_i = e_i (e_i+e_(i+1))^T, 0 <= i < n, +Q = e_0 e_0^T, +A = span{C_0,...,C_(n-1),Q}. +``` + +All listed matrices are rank-one idempotents. They are independent. For each +row `i>=1`, its coefficient is determined by its off-diagonal entry in column +`i+1`. The two row-zero vectors `e_0+e_1` and `e_0` are independent. Thus +`dim A=n+1`. + +A general matrix in A has row i, for `i>=1`, either zero or +`r_i=e_i+e_(i+1)`. Row zero is one of + +```text +0, e_0, e_1, e_0+e_1. +``` + +The nonzero rows r_i are pairwise distinct when `n>=3`, and none is in the +row-zero list. A rank-one binary matrix has all its nonzero rows equal. +Hence a rank-one matrix in A has just one nonzero row. The possible +idempotents are C_i for `i>=1`, Q and C_0. The remaining row-zero possibility +`e_0 e_1^T` is nilpotent and is not an idempotent. Thus **A contains exactly +the n+1 listed rank-one idempotents**. + +Apply the exact pool lemma to `H=Phi(A)`. Its complete pool is exactly +`R(C_0),...,R(C_(n-1)),R(Q)`. Its joint image is `E(F2^n)`, of dimension n, +and its pattern dimension is `n+1`. + +The full pattern-weight enumerator is + +```text +(1 + z^6 + z^9 + z^15) (1 + z^15)^(n-1). +``` + +The first factor describes the four row-zero choices. Each other row +contributes either zero or one diagonal and one off-diagonal entry, of +replicated weight fifteen. This also proves that weight six is attained. + +## 4. Full irreducibility and failure of each basis + +It suffices to work in the small coordinate space. Suppose a nonzero +subspace is invariant under all C_i and Q. If it contains a vector v on +which some C_i is nonzero, it contains e_i. Successive cycle projectors +send this coordinate vector around the cycle, so the subspace contains all +coordinate vectors. + +If every C_i kills v, the equations `v_i+v_(i+1)=0` make v the all-one vector +w. But `Qw=e_0`, which again gives every coordinate vector by the cycle. +Thus the full action is irreducible. Replication preserves this action on +the joint image. + +Any full-image subcollection must contain C_i for every `i>=1`: it is the +only projector whose image is e_i. It must also contain at least one of C_0 +and Q. There are exactly three choices, including the full collection. + +If Q is omitted, all C_i kill the nonzero vector w. Its line is a proper +invariant subspace. If C_0 is omitted, the line spanned by e_1 is invariant: +C_1 fixes e_1, every other retained C_i kills it, and Q kills it. Thus both +proper full-image subcollections are reducible. These are exactly the two +image-basis subcollections. No choice of a different image basis from this +pool repairs the defect. + +The mechanisms differ: the cycle alone has a common kernel, while the +cycle with C_0 replaced by Q has an invariant line despite full covector +rank. A test that checks only image and covector ranks would miss the latter. + +## 5. Exact verification and source boundary + +The verifier checks the complete pool for every n from three through twelve. +It enumerates all 16358 nonzero patterns and all 16368 projector subsets +across those ten cases. Exactly three subsets per case have full image; +the two proper subsets have the explicit kernel or invariant-line witness. +Full covector rank and strong incidence certify each full action. Direct +closure of every nonzero vector orbit also checks the full and reduced +actions for n from three through eight. + +The embedding lemma is tested on every one of the 67 subspaces of +`M_2(F2)`. The verifier compares the complete lifted pool with all original +rank-one idempotents in each subspace, for 96 pool memberships. It also checks +the algebra law on all 256 ordered matrix pairs. A two-copy control sends +a nonzero idempotent to a nilpotent. A one-copy control loses diagonal +information under off and permits a matrix unit. These checks are finite; +the proof in Section 2 supplies the universal statement. + +The four-trial rank-one lift rule and binary matrix primitives are reused +from [PR #7686](https://github.com/CrocSwap/integer-mult-bounds/pull/7686), +[exact verifier](https://github.com/aliromman/integer-mult-bounds/blob/9da06cbe0b888293cbb249cb29eef0f37addaa4f/research/no-edge-image-basis-bound/verify.py). +The new verifier has no runtime dependency on that package. Nick Petalas's +earlier fiber lemma is credited by the sources of PR #7686. + +unpaidmoon's cyclic complete-pool example in +[PR #6962](https://github.com/CrocSwap/integer-mult-bounds/pull/6962), +[exact proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/46dbf04cae1140f33bd6a12fa6967a54f8d2c417/research/pattern-dim4-irreducible-image/PROOF.md), +is related prior work. It uses a four-cycle with two next-coordinate reads +and is itself an irreducible basis. The present cycle plus one extra +projector and exact replication address the opposite extraction question. +No earlier cyclic example is claimed as new. + +No paid BIT word, native operation, complete invoice or kappa improvement +is supplied. The selected frontier and all five assumptions stay unchanged. +Predecessor scientific replays, the selected cold replay, Lean and Docker +were not run. Independent human and formal-kernel review are unclaimed. + +## Open next questions + +Does the additional condition of pattern dimension five force an irreducible +seven-dimensional complete pool to contain an irreducible image-basis +subcollection? The present counterexample uses pattern dimension eight at +that image dimension. A proof must use the smaller pattern space; the general +extraction premise is false. diff --git a/research/no-edge-basis-extraction-failure/README.md b/research/no-edge-basis-extraction-failure/README.md new file mode 100644 index 0000000000..d99a3c270a --- /dev/null +++ b/research/no-edge-basis-extraction-failure/README.md @@ -0,0 +1,53 @@ +# A complete pool can require more than an image basis + +For every `n>=3`, this package gives a complete binary projector pool with +`n+1` members, joint-image dimension n and irreducible action. Its pattern +space has dimension `n+1`, minimum nonzero weight six and no matrix unit. +Both of its image-basis subcollections are reducible. The construction uses +width `3n` and permits zero padding. + +Thus irreducibility of a complete pool does not imply the existence of an +irreducible image-basis subcollection. The excess of one projector is the +least possible for this failure. The proof includes a three-copy embedding +that preserves the exact complete pool of any binary matrix subspace. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), and +[TASK.json](TASK.json). The result marks a boundary of the image-basis theorem +in [PR #7686](https://github.com/CrocSwap/integer-mult-bounds/pull/7686). +At image dimension seven, the new pattern dimension is eight. This does not +settle basis extraction at pattern dimension five. + +With CPython 3.12 and its standard library, from the repository root: + +```sh +python3.12 -I -W error -B research/no-edge-basis-extraction-failure/verify.py +python3.12 -I -W error -B -O research/no-edge-basis-extraction-failure/verify.py +python3.12 -B scripts/research_package.py --package research/no-edge-basis-extraction-failure +``` + +Expected markers: + +```text +PASS_NO_EDGE_BASIS_EXTRACTION_FAILURE +PASS_REGISTERED_RESEARCH_PACKAGE +``` + +The verifier checks all 16358 nonzero patterns and all 16368 subsets for ten +family instances, `3<=n<=12`. Exact rank, incidence and invariant-subspace +witnesses pass. Direct orbit checks cover `3<=n<=8`. All 67 subspaces of +`M_2(F2)` check the exact replication lemma, and all 256 matrix pairs check +the algebra law. Even-copy and single-copy controls reject invalid variants. + +No new kappa, paid BIT word, native operation or full invoice is supplied. +The selected frontier and all five assumptions remain unchanged. Predecessor +scientific replays, the selected cold replay, Lean and Docker were not run. +Independent human and formal-kernel review are unclaimed. + +## Open next questions + +Does pattern dimension five force basis extraction for an irreducible +seven-dimensional image? The counterexample has larger pattern dimension. +A proof must use the extra restriction instead of the false general premise. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. New work is +Apache-2.0. See [CREDITS.md](CREDITS.md) for source credit. diff --git a/research/no-edge-basis-extraction-failure/RESULT.json b/research/no-edge-basis-extraction-failure/RESULT.json new file mode 100644 index 0000000000..f7351f3e9e --- /dev/null +++ b/research/no-edge-basis-extraction-failure/RESULT.json @@ -0,0 +1,820 @@ +{ + "statement": "For every n>=3, a complete unit-free pool of n+1 projectors acts irreducibly on an n-dimensional image but has no irreducible image-basis subcollection.", + "replication_lemma_checks": { + "all_M2_subspaces": 67, + "subspaces_by_dimension": { + "0": 1, + "1": 15, + "2": 35, + "3": 15, + "4": 1 + }, + "pool_memberships": 96, + "product_pairs": 256 + }, + "family_checks": [ + { + "image_dimension": 3, + "ambient_width": 9, + "pattern_dimension": 4, + "complete_pool_size": 4, + "patterns_checked": 15, + "all_subsets_checked": 16, + "full_image_subsets": [ + 7, + 14, + 15 + ], + "cycle_kernel": 511, + "broken_cycle_line": 56, + "cycle_covector_rank": 2, + "broken_cycle_covector_rank": 3, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 455 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 3, + "21": 2, + "24": 2, + "30": 3, + "36": 1, + "39": 1, + "45": 1 + } + }, + { + "image_dimension": 4, + "ambient_width": 12, + "pattern_dimension": 5, + "complete_pool_size": 5, + "patterns_checked": 31, + "all_subsets_checked": 32, + "full_image_subsets": [ + 15, + 30, + 31 + ], + "cycle_kernel": 4095, + "broken_cycle_line": 56, + "cycle_covector_rank": 3, + "broken_cycle_covector_rank": 4, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 3591 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 4, + "21": 3, + "24": 3, + "30": 6, + "36": 3, + "39": 3, + "45": 4, + "51": 1, + "54": 1, + "60": 1 + } + }, + { + "image_dimension": 5, + "ambient_width": 15, + "pattern_dimension": 6, + "complete_pool_size": 6, + "patterns_checked": 63, + "all_subsets_checked": 64, + "full_image_subsets": [ + 31, + 62, + 63 + ], + "cycle_kernel": 32767, + "broken_cycle_line": 56, + "cycle_covector_rank": 4, + "broken_cycle_covector_rank": 5, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 28679 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 5, + "21": 4, + "24": 4, + "30": 10, + "36": 6, + "39": 6, + "45": 10, + "51": 4, + "54": 4, + "60": 5, + "66": 1, + "69": 1, + "75": 1 + } + }, + { + "image_dimension": 6, + "ambient_width": 18, + "pattern_dimension": 7, + "complete_pool_size": 7, + "patterns_checked": 127, + "all_subsets_checked": 128, + "full_image_subsets": [ + 63, + 126, + 127 + ], + "cycle_kernel": 262143, + "broken_cycle_line": 56, + "cycle_covector_rank": 5, + "broken_cycle_covector_rank": 6, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 229383 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 6, + "21": 5, + "24": 5, + "30": 15, + "36": 10, + "39": 10, + "45": 20, + "51": 10, + "54": 10, + "60": 15, + "66": 5, + "69": 5, + "75": 6, + "81": 1, + "84": 1, + "90": 1 + } + }, + { + "image_dimension": 7, + "ambient_width": 21, + "pattern_dimension": 8, + "complete_pool_size": 8, + "patterns_checked": 255, + "all_subsets_checked": 256, + "full_image_subsets": [ + 127, + 254, + 255 + ], + "cycle_kernel": 2097151, + "broken_cycle_line": 56, + "cycle_covector_rank": 6, + "broken_cycle_covector_rank": 7, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 1835015 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 7, + "21": 6, + "24": 6, + "30": 21, + "36": 15, + "39": 15, + "45": 35, + "51": 20, + "54": 20, + "60": 35, + "66": 15, + "69": 15, + "75": 21, + "81": 6, + "84": 6, + "90": 7, + "96": 1, + "99": 1, + "105": 1 + } + }, + { + "image_dimension": 8, + "ambient_width": 24, + "pattern_dimension": 9, + "complete_pool_size": 9, + "patterns_checked": 511, + "all_subsets_checked": 512, + "full_image_subsets": [ + 255, + 510, + 511 + ], + "cycle_kernel": 16777215, + "broken_cycle_line": 56, + "cycle_covector_rank": 7, + "broken_cycle_covector_rank": 8, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 16515072 + ], + [ + 14680064, + 14680071 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 8, + "21": 7, + "24": 7, + "30": 28, + "36": 21, + "39": 21, + "45": 56, + "51": 35, + "54": 35, + "60": 70, + "66": 35, + "69": 35, + "75": 56, + "81": 21, + "84": 21, + "90": 28, + "96": 7, + "99": 7, + "105": 8, + "111": 1, + "114": 1, + "120": 1 + } + }, + { + "image_dimension": 9, + "ambient_width": 27, + "pattern_dimension": 10, + "complete_pool_size": 10, + "patterns_checked": 1023, + "all_subsets_checked": 1024, + "full_image_subsets": [ + 511, + 1022, + 1023 + ], + "cycle_kernel": 134217727, + "broken_cycle_line": 56, + "cycle_covector_rank": 8, + "broken_cycle_covector_rank": 9, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 16515072 + ], + [ + 14680064, + 132120576 + ], + [ + 117440512, + 117440519 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 9, + "21": 8, + "24": 8, + "30": 36, + "36": 28, + "39": 28, + "45": 84, + "51": 56, + "54": 56, + "60": 126, + "66": 70, + "69": 70, + "75": 126, + "81": 56, + "84": 56, + "90": 84, + "96": 28, + "99": 28, + "105": 36, + "111": 8, + "114": 8, + "120": 9, + "126": 1, + "129": 1, + "135": 1 + } + }, + { + "image_dimension": 10, + "ambient_width": 30, + "pattern_dimension": 11, + "complete_pool_size": 11, + "patterns_checked": 2047, + "all_subsets_checked": 2048, + "full_image_subsets": [ + 1023, + 2046, + 2047 + ], + "cycle_kernel": 1073741823, + "broken_cycle_line": 56, + "cycle_covector_rank": 9, + "broken_cycle_covector_rank": 10, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 16515072 + ], + [ + 14680064, + 132120576 + ], + [ + 117440512, + 1056964608 + ], + [ + 939524096, + 939524103 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 10, + "21": 9, + "24": 9, + "30": 45, + "36": 36, + "39": 36, + "45": 120, + "51": 84, + "54": 84, + "60": 210, + "66": 126, + "69": 126, + "75": 252, + "81": 126, + "84": 126, + "90": 210, + "96": 84, + "99": 84, + "105": 120, + "111": 36, + "114": 36, + "120": 45, + "126": 9, + "129": 9, + "135": 10, + "141": 1, + "144": 1, + "150": 1 + } + }, + { + "image_dimension": 11, + "ambient_width": 33, + "pattern_dimension": 12, + "complete_pool_size": 12, + "patterns_checked": 4095, + "all_subsets_checked": 4096, + "full_image_subsets": [ + 2047, + 4094, + 4095 + ], + "cycle_kernel": 8589934591, + "broken_cycle_line": 56, + "cycle_covector_rank": 10, + "broken_cycle_covector_rank": 11, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 16515072 + ], + [ + 14680064, + 132120576 + ], + [ + 117440512, + 1056964608 + ], + [ + 939524096, + 8455716864 + ], + [ + 7516192768, + 7516192775 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 11, + "21": 10, + "24": 10, + "30": 55, + "36": 45, + "39": 45, + "45": 165, + "51": 120, + "54": 120, + "60": 330, + "66": 210, + "69": 210, + "75": 462, + "81": 252, + "84": 252, + "90": 462, + "96": 210, + "99": 210, + "105": 330, + "111": 120, + "114": 120, + "120": 165, + "126": 45, + "129": 45, + "135": 55, + "141": 10, + "144": 10, + "150": 11, + "156": 1, + "159": 1, + "165": 1 + } + }, + { + "image_dimension": 12, + "ambient_width": 36, + "pattern_dimension": 13, + "complete_pool_size": 13, + "patterns_checked": 8191, + "all_subsets_checked": 8192, + "full_image_subsets": [ + 4095, + 8190, + 8191 + ], + "cycle_kernel": 68719476735, + "broken_cycle_line": 56, + "cycle_covector_rank": 11, + "broken_cycle_covector_rank": 12, + "minimum_pattern_weight": 6, + "pairs": [ + [ + 7, + 63 + ], + [ + 56, + 504 + ], + [ + 448, + 4032 + ], + [ + 3584, + 32256 + ], + [ + 28672, + 258048 + ], + [ + 229376, + 2064384 + ], + [ + 1835008, + 16515072 + ], + [ + 14680064, + 132120576 + ], + [ + 117440512, + 1056964608 + ], + [ + 939524096, + 8455716864 + ], + [ + 7516192768, + 67645734912 + ], + [ + 60129542144, + 60129542151 + ], + [ + 7, + 7 + ] + ], + "weight_histogram": { + "0": 1, + "6": 1, + "9": 1, + "15": 12, + "21": 11, + "24": 11, + "30": 66, + "36": 55, + "39": 55, + "45": 220, + "51": 165, + "54": 165, + "60": 495, + "66": 330, + "69": 330, + "75": 792, + "81": 462, + "84": 462, + "90": 924, + "96": 462, + "99": 462, + "105": 792, + "111": 330, + "114": 330, + "120": 495, + "126": 165, + "129": 165, + "135": 220, + "141": 55, + "144": 55, + "150": 66, + "156": 11, + "159": 11, + "165": 12, + "171": 1, + "174": 1, + "180": 1 + } + } + ], + "hypothesis_controls": [ + "Two-fold replication is nilpotent.", + "One-fold off projection loses diagonal information and can contain units.", + "Deleting the extra projector leaves a common kernel.", + "Replacing the first cycle projector leaves an invariant line." + ], + "scope": "At image dimension seven this family has pattern dimension eight; it does not settle the pattern-dimension-five extraction question.", + "kappa_change": null +} diff --git a/research/no-edge-basis-extraction-failure/SOURCES.json b/research/no-edge-basis-extraction-failure/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/no-edge-basis-extraction-failure/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-basis-extraction-failure/TASK.json b/research/no-edge-basis-extraction-failure/TASK.json new file mode 100644 index 0000000000..d160e76f0b --- /dev/null +++ b/research/no-edge-basis-extraction-failure/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-dimension complete unit-free projector pools with irreducible action and no irreducible image-basis subcollection.", + "scope_change_reason": "Test and refute the general basis-extraction premise left outside PR7686. Retain the larger pattern dimension instead of inferring a pattern-five result.", + "bottleneck_link": "Prevent an invalid extension of a structural bound from irreducible image bases to arbitrary complete pools.", + "budget_minutes": 60, + "stop_rule": "Stop at the complete counterexample family and exact embedding lemma. The pattern-dimension-five case and native word remain open.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; all 67 M2 subspaces, 256 algebra pairs, 16358 patterns, 16368 subsets and explicit invariant witnesses.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Does pattern dimension five force an irreducible image-basis subcollection when the complete pool has irreducible image dimension seven?", + "why_it_matters": "The unrestricted extraction statement is false, but the tighter pattern space could impose additional structure.", + "first_step": "Use the diagonal-pattern relations specific to dimension five.", + "blocked_by": "The counterexample at image dimension seven uses pattern dimension eight." + } + ], + "family_decision": { + "decision": "Narrow to a counterexample to a proposed proof step.", + "sources": "7686@9da06cbe0b888293cbb249cb29eef0f37addaa4f; related 6962@46dbf04cae1140f33bd6a12fa6967a54f8d2c417", + "evidence_status": "Author-checked written proof and finite exact checks.", + "boundary": "Complete binary scalar projector pools; irreducibility on the joint image; no paid word or physical state.", + "obligations": { + "complete_pool": "proved in the written argument", + "irreducibility_and_failure_of_bases": "proved with explicit witnesses", + "paid_word": "unknown", + "native_conversion": "unknown", + "complete_invoice": "unknown" + }, + "alternative": "Direct extraction in the dimension-five case remains possible but must use that additional restriction.", + "construction_gate": "Unmet. No new alphabet, paid identity or full invoice is supplied." + } +} diff --git a/research/no-edge-basis-extraction-failure/VERIFY.json b/research/no-edge-basis-extraction-failure/VERIFY.json new file mode 100644 index 0000000000..9a4da01040 --- /dev/null +++ b/research/no-edge-basis-extraction-failure/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 replication-pool checks, exact cycle family, all subcollections, invariant witnesses and invalid replication controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete replication-pool checks, exact cycle family, all subcollections, invariant witnesses and invalid replication controls." + } + ] +} diff --git a/research/no-edge-basis-extraction-failure/verify.py b/research/no-edge-basis-extraction-failure/verify.py new file mode 100644 index 0000000000..e648d929b3 --- /dev/null +++ b/research/no-edge-basis-extraction-failure/verify.py @@ -0,0 +1,283 @@ +"""Exact checks for the no-edge basis-extraction counterexample. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Binary matrix and four-trial lift primitives are reused from PR7686. +See CREDITS.md for the exact source and mathematical predecessors. +""" + +import itertools +import json +import math +from collections import Counter +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 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 replicate_vector(value, copies=3): + mask = (1 << copies) - 1 + return sum(mask << (copies * i) for i in range(value.bit_length()) + if (value >> i) & 1) + + +def replicate_matrix(matrix, width, copies=3): + result = 0 + for i in range(width): + for j in range(width): + if (matrix >> (i * width + j)) & 1: + result ^= outer(replicate_vector(1 << i, copies), + replicate_vector(1 << j, copies), copies * width) + return result + + +def multiply(left, right, width): + result = 0 + mask = (1 << width) - 1 + for i in range(width): + row = 0 + for j in range(width): + if (left >> (i * width + j)) & 1: + row ^= (right >> (j * width)) & mask + result |= row << (i * width) + return result + + +def all_subspaces(width): + spaces = {frozenset({0})} + frontier = list(spaces) + while frontier: + old = frontier.pop() + for value in range(1, 1 << width): + if value not in old: + new = frozenset(old | {x ^ value for x in old}) + if new not in spaces: + spaces.add(new) + frontier.append(new) + return sorted(spaces, key=lambda x: (len(x), sorted(x))) + + +def strong_incidence(pairs): + for start in range(len(pairs)): + reached = {start} + while True: + new = reached | {j for j, (_, y) in enumerate(pairs) + if any(parity(y & pairs[i][0]) for i in reached)} + if new == reached: + break + reached = new + if len(reached) != len(pairs): + return False + return True + + +def family(n): + require(n >= 3, 'dimension at least three') + small = [(1 << i, (1 << i) | (1 << ((i + 1) % n))) for i in range(n)] + small.append((1, 1)) + return [(replicate_vector(x), replicate_vector(y)) for x, y in small] + + +def weight_formula(n): + result = Counter() + for j in range(n): + for offset in (0, 6, 9, 15): + result[15 * j + offset] += math.comb(n - 1, j) + return result + + +def check_family(n): + pairs = family(n) + width = 3 * n + ps = patterns(pairs, width) + pattern_space = span(ps) + require(len(basis(ps)) == n + 1, 'pattern dimension') + require(Counter(p.bit_count() for p in pattern_space) == weight_formula(n), 'weight enumerator') + require(min(p.bit_count() for p in pattern_space if p) == 6, 'minimum pattern weight') + require(pool(ps, width) == sorted(pairs), 'complete pool') + require(all(parity(x & y) for x, y in pairs), 'idempotence') + require(len(basis(x for x, _ in pairs)) == n, 'joint image') + restricted_rows = [sum(parity(y & replicate_vector(1 << i)) << i for i in range(n)) + for _, y in pairs] + require(len(basis(restricted_rows)) == n and strong_incidence(pairs), 'full irreducibility certificate') + require(len(basis(restricted_rows[:-1])) == n - 1, 'cycle covector rank') + require(len(basis(restricted_rows[1:])) == n, 'broken-cycle covector rank') + + cycle = pairs[:-1] + kernel = replicate_vector((1 << n) - 1) + require(all(parity(y & kernel) == 0 for _, y in cycle), 'cycle common kernel') + broken = pairs[1:] + line = replicate_vector(2) + require(all(not parity(y & line) or x == line for x, y in broken), 'broken-cycle invariant line') + require(parity(pairs[0][1] & line) and pairs[0][0] != line, 'extra cycle row breaks invariant line') + require(parity(pairs[-1][1] & kernel), 'extra projector breaks common kernel') + if n <= 8: + require(orbit_irreducible(pairs), 'direct full orbit check') + require(not orbit_irreducible(cycle), 'direct cycle orbit control') + require(not orbit_irreducible(broken), 'direct broken-cycle orbit control') + + full_image_subsets = [] + for mask in range(1 << len(pairs)): + subset = [p for i, p in enumerate(pairs) if (mask >> i) & 1] + if len(basis(x for x, _ in subset)) == n: + full_image_subsets.append(mask) + expected = [(1 << n) - 1, ((1 << (n + 1)) - 1) ^ 1, (1 << (n + 1)) - 1] + require(sorted(full_image_subsets) == sorted(expected), 'all full-image subcollections') + return {'image_dimension': n, 'ambient_width': width, 'pattern_dimension': n + 1, + 'complete_pool_size': n + 1, 'patterns_checked': len(pattern_space) - 1, + 'all_subsets_checked': 1 << len(pairs), 'full_image_subsets': full_image_subsets, + 'cycle_kernel': kernel, 'broken_cycle_line': line, + 'cycle_covector_rank': n - 1, 'broken_cycle_covector_rank': n, + 'minimum_pattern_weight': 6, 'pairs': pairs, + 'weight_histogram': {str(k): v for k, v in sorted(weight_formula(n).items())}} + + +def compute(): + # Every matrix subspace of M_2(F2), including coordinate and nilpotent parts. + matrix_spaces = all_subspaces(4) + require(len(matrix_spaces) == 67, 'complete matrix-subspace count') + original_idempotents = [(x, y) for x, y in itertools.product(range(1, 4), repeat=2) + if parity(x & y)] + pool_total = 0 + dimensions = Counter() + for space in matrix_spaces: + matrices = basis(space) + lifted_patterns = [off(replicate_matrix(a, 2), 6) for a in matrices] + require(len(basis(lifted_patterns)) == len(matrices), 'replication preserves dimension') + require(all(p.bit_count() >= 6 for p in span(lifted_patterns) if p), 'replication removes units') + expected = sorted((replicate_vector(x), replicate_vector(y)) for x, y in original_idempotents + if outer(x, y, 2) in space) + actual = pool(lifted_patterns, 6) + require(actual == expected, 'replication retains the exact complete pool') + pool_total += len(actual) + dimensions[len(matrices)] += 1 + product_checks = 0 + for a, b in itertools.product(range(16), repeat=2): + require(multiply(replicate_matrix(a, 2), replicate_matrix(b, 2), 6) + == replicate_matrix(multiply(a, b, 2), 2), 'algebra homomorphism') + product_checks += 1 + + # Even replication changes idempotents into nilpotents. + q = outer(1, 1, 2) + even = replicate_matrix(q, 2, copies=2) + require(even != 0 and multiply(even, even, 4) == 0, 'even replication control') + require(off(q, 2) == 0, 'single-copy diagonal information loss') + require(off(outer(1, 2, 2), 2).bit_count() == 1, 'single-copy matrix unit') + + cases = [check_family(n) for n in range(3, 13)] + return {'statement': 'For every n>=3, a complete unit-free pool of n+1 projectors acts irreducibly on an n-dimensional image but has no irreducible image-basis subcollection.', + 'replication_lemma_checks': {'all_M2_subspaces': len(matrix_spaces), + 'subspaces_by_dimension': {str(k): v for k, v in sorted(dimensions.items())}, + 'pool_memberships': pool_total, 'product_pairs': product_checks}, + 'family_checks': cases, + 'hypothesis_controls': ['Two-fold replication is nilpotent.', + 'One-fold off projection loses diagonal information and can contain units.', + 'Deleting the extra projector leaves a common kernel.', + 'Replacing the first cycle projector leaves an invariant line.'], + 'scope': 'At image dimension seven this family has pattern dimension eight; it does not settle the pattern-dimension-five extraction question.', + '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_BASIS_EXTRACTION_FAILURE') + print(json.dumps({'matrix_subspaces': 67, 'family_dimensions': 10, + 'patterns_checked': sum(x['patterns_checked'] for x in actual['family_checks']), + 'subsets_checked': sum(x['all_subsets_checked'] for x in actual['family_checks'])}, sort_keys=True)) + + +if __name__ == '__main__': + main()