diff --git a/research/edge-extremal-pool-classification/CREDITS.md b/research/edge-extremal-pool-classification/CREDITS.md new file mode 100644 index 0000000000..75de65e77d --- /dev/null +++ b/research/edge-extremal-pool-classification/CREDITS.md @@ -0,0 +1,41 @@ +# Sources and credit + +Ali Romman prepared this proof and verifier with substantial OpenAI +Codex assistance. New work is Apache-2.0. No independent human or +formal-kernel review is claimed. + +- Ali Romman's [PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692), + head `c2870a38841f515db7203a0761cd77f014f7fb7a`, supplies the all-width + matching bounds and the all-k attaining family. Its + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md) + is the mathematical dependency used to force the edge count and + preserve the image under completion. Matrix, basis, lift, orbit and + subspace routines are reused from its + [verifier](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/verify.py). + That package credits the disjoint-relation and support arguments in + [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690) + and [PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691), + and their retained predecessor lineage. +- CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), + head `685457252b51b9c7932ece363365bdf0b12c9c31`, supplies the prior + five-dimensional two-edge restricted normal form and its common + cross-block argument. The source notice states that it was prepared + for @CubeJerry with substantial OpenAI assistance. Read its + [exact proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/PROOF.md). + The proof also credits Nick Petalas's + [PR #5921](https://github.com/CrocSwap/integer-mult-bounds/pull/5921) + for the binary fiber theorem. The present edge lifts are the same + two-member fibers, not a new construction. + +The new result forces the edge count and disjointness at every k, +classifies the full ambient link, and proves that an arbitrary +extremal irreducible collection is automatically complete. The pure +matrix-unit graph criterion supplies the boundary case. The k=3 +restricted normal form and the all-k positive family retain their +original credit. + +No external source file is read at runtime. SOURCES.json binds the +selected state and task catalogue on main as provenance. Those +records are not mathematical premises. The matching proof is linked +at its exact public commit; full predecessor package replays are not +part of this verifier. diff --git a/research/edge-extremal-pool-classification/PROOF.md b/research/edge-extremal-pool-classification/PROOF.md new file mode 100644 index 0000000000..bbc1de7e04 --- /dev/null +++ b/research/edge-extremal-pool-classification/PROOF.md @@ -0,0 +1,272 @@ +# The unique extremal irreducible binary projector pool + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is a scoped written proof with finite exact checks. Independent +human and formal-kernel review are unclaimed. + +## 1. Statement and the bound used + +Work over F2 at any finite width W. Let C be a set of rank-one +idempotents `xy^T`, with `y^T x=1` and nonzero off-diagonal patterns. +Let H be their pattern span, of dimension `k>=2`, and let V be their +joint image. Suppose `dim(V)=2k-1` and C acts irreducibly on V. + +**Theorem.** After a coordinate permutation, H contains exactly +`k-1` matrix units `E_a_i,b_i`, on disjoint endpoint pairs. The set C +is the complete pool of all noncoordinate rank-one-idempotent lifts +in H. It consists of the two lifts of each edge and one further member: + +``` +e_a_i(e_a_i+e_b_i)^T, (e_a_i+e_b_i)e_b_i^T, +B = (h_x+a)(h_y+b)^T, +h_x = sum_i e_b_i, h_y = sum_i e_a_i. +``` + +Here a,b use only coordinates outside all edge endpoints and satisfy +`a dot b=1`. Conversely, every such choice gives an attaining complete +irreducible pool. In a basis of V, its set of restricted projectors is +exactly the first `2k-2` coordinate projectors and the all-one matrix +of size `2k-1`. + +This is a parameterization up to coordinate permutation, not a count +of coordinate-permutation orbits. Distinct fresh supports can give +different ambient pools with the same restricted action. No physical +change of basis is declared free. + +The proof uses the all-width matching bound in Ali Romman's +[PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md). +If nu is the maximum matching size among the matrix-unit edges of H, +that theorem gives + +``` +2 dim(V) <= 3k+nu, +2 dim(V) <= 3k+nu-1 for a nonzero irreducible image, +nu <= e <= k, +``` + +where e is the number of directed matrix units in H. Completeness is +not a premise of that bound. Its written proof is an explicit source +dependency here; its whole package is not rerun by this verifier. + +CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[exact proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/PROOF.md), +already classifies the restricted five-dimensional action when k=3 +and there are two edges. The shared cross-block argument below extends +that proof. The new matching bound first forces the edge count and +disjointness at every k. The final argument also forces completeness +and the full ambient fresh-factor form. + +## 2. Completion preserves this extremal image + +Apply the irreducible matching bound to C: + +``` +4k-2 <= 3k+nu-1, so nu >= k-1. +``` + +If `nu=k`, the k disjoint edge units form a basis of H. A noncoordinate +rank-one idempotent with pattern in that span lies in one edge block. +To prove this, choose a coordinate common to its image and covector +supports. Such a coordinate exists by idempotence. Its off-diagonal +row and column put every other factor coordinate in the same block. +If the common coordinate is outside the edge blocks, the projector is +coordinate, which is excluded. The complete pool is therefore exactly +the 2k edge lifts. They are mutually orthogonal after a shear in each +pair. Every subcollection with image dimension greater than one is +reducible. Since `2k-1>1`, this case is impossible. + +Thus `nu=k-1`. Let C(H) be the complete pool. It contains C, whose +patterns span H, so its pattern dimension is also k. Its total-image +bound is + +``` +dim image(C(H)) <= floor((3k+k-1)/2) = 2k-1. +``` + +Its image contains V, so it is exactly V. Any subspace invariant under +C(H) is invariant under C. Thus C(H) is irreducible as well. We may +classify the complete pool first, without assuming that C was complete. + +## 3. The pure matrix-unit boundary + +Suppose H is spanned by directed matrix units, with edge graph G. +The joint image of C(H) is exactly the coordinate span of the edge +endpoints. Each edge's two lifts give both endpoints. Conversely, a +noncoordinate lift cannot use an isolated coordinate: a common factor +coordinate would either join it to another factor through an allowed +edge, or make the projector coordinate. + +Give G the direction from row to column. If a nonempty proper vertex +set S is closed under predecessors, its coordinate span is invariant: +no allowed off-diagonal entry has row outside S and column inside S. +A finite directed graph that is not strongly connected has such a set. +For example, take all predecessors of a vertex that does not have +every vertex as a predecessor. Hence irreducibility on at least two +endpoint coordinates requires G to be strongly connected. Such a +graph has at least as many edges as vertices, since each vertex must +have an outgoing edge. + +For reference, the exact criterion for a nonempty pure-unit pool is +strong connectivity and at least three endpoint vertices. At two +vertices, the line through their sum is invariant under all four +possible noncoordinate lifts. For at least three strongly connected +vertices, the edge lifts themselves act irreducibly. If a nonzero +invariant vector z has different bits at the ends of an edge (a,b), +`e_a(e_a+e_b)^T z=e_a`. From e_a, incoming edges give their predecessor +coordinate vectors, and strong connectivity gives every vertex. +If no edge sees different bits, connectivity forces z to be the +all-one vector. The other lift of any edge sends it to `e_a+e_b`. +With at least three vertices this vector is not constant, so the first +case applies. This proves the criterion. + +Return to the extremal pool. We know `k-1<=e<=k`. If e=k, the matrix +units span H. Its endpoint count would be `dim(V)=2k-1`. Irreducibility +would force `k>=2k-1`, contrary to `k>=2`. Therefore `e=k-1`. A matching +of that size uses every edge, so all edge endpoints are disjoint. + +## 4. The common cross-block restriction + +Put `t=k-1`, and let E be the coordinate space of the 2t endpoints. +The old edge span H0 has dimension t. Its complete pool consists of +the 2t edge lifts. A sum of units from different blocks has no +rank-one-idempotent lift, by the block argument in Section 2. + +These old images span E. Since `dim(V)=2t+1`, choose a nonzero vector +a supported outside E such that `V=E direct-sum F2*a`. This is possible +by subtracting the E coordinates of any vector in V outside E. + +Use the old edge images as a basis of E. Equivalently, apply the +block shear `S=product_i(I+E_a_i,b_i)` within E. It is its own inverse +and sends the old projectors to the 2t coordinate projectors. +Use a as the last basis vector of V. + +There is only one nonzero coset H/H0. All remaining pool projectors +have patterns in that coset. Their off-diagonal differences are +supported within E. Thus their E-to-a and a-to-E blocks on V are +the same. A diagonal difference outside E cannot change either of +these cross blocks, and the shear acts only inside E. Write the common +column and row as alpha and beta. + +If alpha is zero, the line through a is invariant under the whole +pool. If beta is zero, E is invariant. Both alternatives contradict +irreducibility. Hence both cross blocks are nonzero. + +Any remaining rank-one restriction has factors +`(u,epsilon)(v^T,eta)`. Its cross blocks satisfy + +``` +u eta = alpha, epsilon v = beta. +``` + +Over F2 their nonzero values force `epsilon=eta=1`, `u=alpha` and +`v=beta`. Every remaining projector has the same restriction +`(alpha,1)(beta^T,1)`. + +For each old coordinate i, if alpha_i is zero, the hyperplane with +coordinate i zero is invariant under all old coordinate projectors +and this restriction. If beta_i is zero, its coordinate line is +invariant. Thus every entry of alpha and beta is one. The full +restricted family is the first 2t coordinate projectors plus the +all-one matrix of odd size `2t+1`. + +## 5. The ambient link and forced completeness + +Undo the edge shears. Their effect on the all-one old image factor +gives `h_x=sum e_b_i`; the corresponding covector is +`h_y=sum e_a_i`. Every remaining projector therefore has image factor +`h_x+a` and has covector `h_y+b` for some b supported outside E. +Idempotence gives `a dot b=1`, since `h_x dot h_y=0`. + +Different b cannot give different members of this coset. The off-block +rectangle from E rows to outside columns is `h_x b^T`, and is the same +for every pattern in the coset. The vector h_x is nonzero because +`t>=1`; one of its rows fixes all of b. Thus there is exactly one +remaining ambient projector B. This proves the displayed full form, +not just equality of its restrictions. + +The complete pool now has exactly `2t+1=2k-1` members and independent +images. The original C has the same image dimension and is a subset +of this pool. It must contain every member. Completeness and the +existence of an irreducible image basis are conclusions, not premises. + +## 6. Converse and the k=1 boundary + +For disjoint edges and fresh a,b with pairing one, the old pool has +2t members. The link B is idempotent and its pattern is independent +of H0, because its two cross rectangles are nonzero. They fix both +factors of every lift in the added coset, so B is the only added +member. No matrix unit lies in that coset, since both cross rectangles +remain. The complete pattern space has dimension `t+1=k` and exactly +t edges. Its joint image has dimension `2t+1`. + +In the basis in Section 4, the family is the coordinate projectors +and the odd all-one matrix. It is irreducible: any old nonzero +coordinate of an invariant vector gives a coordinate vector and +then the all-one vector. If only its last coordinate is nonzero, +the all-one matrix gives the same vector. The coordinate projectors +then give every old basis vector, and subtraction gives the last one. + +The restriction `k>=2` is necessary for forced completeness. A single +edge lift `e_0(e_0+e_1)^T` has k=1 and irreducible image dimension one, +which is `2k-1`. Its complete pool contains the second edge lift and +has image dimension two. It does not satisfy the classification. +Irreducibility is also necessary: remove one member from k disjoint +edge pairs. The remaining set has k pattern dimensions and image +dimension `2k-1`, but it is reducible and has k edges. + +## 7. Exact verification and limits + +The verifier enumerates all 2825 pattern spaces at width three. +Complete pools from raw rank-one scans agree with separate pattern +lifting. Its image-orbit irreducibility test agrees with direct +closure of every nonzero image vector. Exactly six spaces satisfy +the k=2 extremal hypotheses, and all have the stated form. + +It checks all 4164 directed unit graphs at widths two, three and +four, including disconnected graphs and the ten strong two-vertex +exceptions across those widths. Each proper graph witness is an +explicit invariant coordinate space. The strong graph criterion and +the endpoint image dimension agree with exact pool actions. + +Seven complete link domains fix t disjoint edge pairs and enumerate +all realized added pattern cosets that have an image outside the old +endpoint space. The pairs (t,W) are +`(1,3),(1,4),(1,5),(2,5),(2,6),(3,7),(3,8)`. +There are 30702 spaces, counted within these domains. Separate raw +coset buckets and literal-pattern lifts agree on every complete pool. +The 49 irreducible survivors are exactly the predicted fresh pairs; +1351 direct nonzero-vector orbit checks confirm their action. +All 30653 negatives have a checked common-kernel or proper image-orbit +certificate. The domains include 352 pools with extra members, with +up to nine members. They are not truncated to the generating set. + +For a fixed edge frame with r fresh coordinates, the number of allowed +links is `(2^r-1)2^(r-1)`: choose nonzero a, then a covector b with +pairing one. This is a count in that fixed frame, not an ambient orbit +count. Each of the seven domains has exactly this many survivors. +Twenty-four wider forms through t=8 and width 19 pass complete-pool, +restriction-matrix and image-orbit checks over 2776 nonzero patterns. +They include nonsymmetric fresh supports. + +For the image-orbit test, first compute the common kernel on V. If +it is nonzero, its vector is an invariant line. Otherwise any nonzero +invariant subspace contains the image of some projector. It is then +enough to close the orbit of every projector image. This establishes +the test for dependent images as well as for a basis. + +The all-width classification uses the cited all-width matching bound. +Finite checks cover the stated domains and do not enumerate all +ambient embeddings. Full predecessor package replays, selected cold +replay, Lean and Docker are not included. No paid-word relation +lattice, endpoint reduction, native conversion, dirty-input compiler, +complete invoice or new kappa is supplied. The selected frontier and +all five assumptions remain unchanged. + +## Open next questions + +Does the unique extremal action admit a legal paid word with target +rank greater than paid rank for any larger k? First compare the +five-core word obstruction in PR #6782. State the alphabet, relation +lattice, endpoint coordinates, all counted roles and native interface +before searching words. The normal-form shear is not a free operation. diff --git a/research/edge-extremal-pool-classification/README.md b/research/edge-extremal-pool-classification/README.md new file mode 100644 index 0000000000..2a434105b2 --- /dev/null +++ b/research/edge-extremal-pool-classification/README.md @@ -0,0 +1,63 @@ +# All extremal irreducible edge pools have one form + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +Let a binary noncoordinate rank-one-idempotent collection have pattern +dimension `k>=2` and irreducible joint-image dimension `2k-1`. +It must be the complete pool. Its pattern space contains exactly +`k-1` disjoint matrix-unit edges. The pool consists of their two lifts +each, plus one link with fixed old-coordinate factors and arbitrary +fresh factors a,b with `a dot b=1`. + +Every such family works. Each restricted action is isomorphic to the +first `2k-2` coordinate projectors plus the all-one matrix of size +`2k-1`. This parameterization is not a count of coordinate-permutation +orbits, and the basis change is not declared physically free. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), [CREDITS.md](CREDITS.md) +and [TASK.json](TASK.json). The proof uses the all-width matching bound +in [PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692). +It extends the prior k=3 two-edge restricted normal form in +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782). +That special case remains prior work. + +## Reproduce + +Use CPython 3.12 and its standard library, from the repository root. + +```sh +python3.12 -I -W error -B research/edge-extremal-pool-classification/verify.py +python3.12 -I -W error -B -O research/edge-extremal-pool-classification/verify.py +python3.12 -B scripts/research_package.py --package research/edge-extremal-pool-classification +``` + +Expected markers are `PASS_EDGE_EXTREMAL_POOL_CLASSIFICATION` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. The verifier writes no file and +compares its complete result with the committed receipt. + +It checks all 2825 pattern spaces at width three, all 4164 directed +unit graphs at widths two through four, and 30702 complete link spaces +across seven stated domains. Their 49 irreducible survivors have the +claimed form; all negatives have checked invariant certificates. +The tests include 352 pools with extra members and 24 wider forms +through width 19. A separate all-vector test checks the small +irreducibility algorithm and every positive link-domain survivor. + +## Limits + +The matching theorem is a pinned mathematical dependency. The finite +census does not cover every ambient embedding. Forced completeness +fails at k=1; that boundary and the irreducibility premise have explicit +negative controls. No paid BIT word, native implementation, complete +invoice or new kappa is supplied. The selected frontier and its five +assumptions remain unchanged. Independent human and formal-kernel +review are unclaimed. Full predecessor package replays, selected cold +replay, Lean and Docker are not included. + +## Open next questions + +Can the unique extremal action support a legal paid word with target +rank above paid rank at larger k? First compare the five-core word +obstruction in [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782). +Specify the alphabet, relation lattice, endpoint coordinates, counted +roles and native interface. A scalar normal form does not supply these. diff --git a/research/edge-extremal-pool-classification/RESULT.json b/research/edge-extremal-pool-classification/RESULT.json new file mode 100644 index 0000000000..b838f406bc --- /dev/null +++ b/research/edge-extremal-pool-classification/RESULT.json @@ -0,0 +1,2576 @@ +{ + "status": "PASS_EDGE_EXTREMAL_POOL_CLASSIFICATION", + "scope": "Every irreducible binary noncoordinate projector collection with pattern dimension k>=2 and image dimension 2k-1.", + "claim": "The collection is complete: k-1 disjoint edge pairs and one link with the forced old factors and fresh pairing one.", + "small_pattern_census": { + "counts": { + "common_kernel": 212, + "empty": 336, + "irreducible": 1166, + "proper_image_orbit": 1111, + "spaces": 2825 + }, + "extremizers": [ + { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + }, + { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 2 + ] + ], + "fresh_image": 2, + "fresh_covector": 2 + }, + { + "k": 2, + "n": 3, + "edges": [ + [ + 1, + 0 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + }, + { + "k": 2, + "n": 3, + "edges": [ + [ + 1, + 2 + ] + ], + "fresh_image": 1, + "fresh_covector": 1 + }, + { + "k": 2, + "n": 3, + "edges": [ + [ + 2, + 0 + ] + ], + "fresh_image": 2, + "fresh_covector": 2 + }, + { + "k": 2, + "n": 3, + "edges": [ + [ + 2, + 1 + ] + ], + "fresh_image": 1, + "fresh_covector": 1 + } + ] + }, + "pure_unit_graphs": [ + { + "width": 2, + "counts": { + "graphs": 4, + "irreducible": 0, + "strong_two_vertex_exception": 1 + } + }, + { + "width": 3, + "counts": { + "graphs": 64, + "irreducible": 18, + "strong_two_vertex_exception": 3 + } + }, + { + "width": 4, + "counts": { + "graphs": 4096, + "irreducible": 1678, + "strong_two_vertex_exception": 6 + } + } + ], + "complete_link_domains": [ + { + "edge_pairs": 1, + "width": 3, + "raw_idempotents": 28, + "counts": { + "common_kernel": 2, + "direct_positive_orbits": 7, + "extra_pool_members": 6, + "irreducible": 1, + "maximum_pool_size": 5, + "proper_image_orbit": 8, + "spaces": 11 + }, + "expected_extremizers": 1, + "case_certificate_sha256": "da53d395fc727bab01ce77d7b2b96d597f1600889a41a83c9de43e8f77efe63d", + "examples": { + "proper_image_orbit": { + "key": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 5 + ], + [ + 1, + 7 + ], + [ + 3, + 2 + ], + [ + 5, + 4 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 72, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 7, + 1 + ] + ], + "invariant_basis": [ + 4 + ] + }, + "positive": { + "key": 104, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + } + } + } + }, + { + "edge_pairs": 1, + "width": 4, + "raw_idempotents": 120, + "counts": { + "common_kernel": 27, + "direct_positive_orbits": 42, + "extra_pool_members": 15, + "irreducible": 6, + "maximum_pool_size": 5, + "proper_image_orbit": 50, + "spaces": 83 + }, + "expected_extremizers": 6, + "case_certificate_sha256": "5f592c92a1e85d92ee31df6a1e0c750f2a4eceb3482e3359115af11e386b4f92", + "examples": { + "proper_image_orbit": { + "key": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 5 + ], + [ + 1, + 7 + ], + [ + 3, + 2 + ], + [ + 5, + 4 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 272, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 7, + 1 + ] + ], + "invariant_basis": [ + 4 + ] + }, + "positive": { + "key": 336, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + } + } + } + }, + { + "edge_pairs": 1, + "width": 5, + "raw_idempotents": 496, + "counts": { + "common_kernel": 152, + "direct_positive_orbits": 196, + "extra_pool_members": 28, + "irreducible": 28, + "maximum_pool_size": 5, + "proper_image_orbit": 243, + "spaces": 423 + }, + "expected_extremizers": 28, + "case_certificate_sha256": "b057a3effcc5766548a32beb5281e224e3e8412c10fbd9a520f369b679ec5505", + "examples": { + "proper_image_orbit": { + "key": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 5 + ], + [ + 1, + 7 + ], + [ + 3, + 2 + ], + [ + 5, + 4 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 1056, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 7, + 1 + ] + ], + "invariant_basis": [ + 4 + ] + }, + "positive": { + "key": 1184, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + } + } + } + }, + { + "edge_pairs": 2, + "width": 5, + "raw_idempotents": 496, + "counts": { + "common_kernel": 106, + "direct_positive_orbits": 31, + "extra_pool_members": 18, + "irreducible": 1, + "maximum_pool_size": 7, + "proper_image_orbit": 134, + "spaces": 241 + }, + "expected_extremizers": 1, + "case_certificate_sha256": "423eaea10ea54a6e10096c997434829dff704a5115bcbda224f5299dba1a141e", + "examples": { + "proper_image_orbit": { + "key": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 17 + ], + [ + 1, + 19 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 17, + 16 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 1048608, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 19, + 1 + ] + ], + "invariant_basis": [ + 16 + ] + }, + "positive": { + "key": 5931680, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 16, + "fresh_covector": 16 + } + } + } + }, + { + "edge_pairs": 2, + "width": 6, + "raw_idempotents": 2016, + "counts": { + "common_kernel": 684, + "direct_positive_orbits": 186, + "extra_pool_members": 46, + "irreducible": 6, + "maximum_pool_size": 7, + "proper_image_orbit": 806, + "spaces": 1496 + }, + "expected_extremizers": 6, + "case_certificate_sha256": "53f39ecdb2a2de04bc8d5e7ac43d1018d1a089ead90382e9a2f44bb1ce392b08", + "examples": { + "proper_image_orbit": { + "key": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 17 + ], + [ + 1, + 19 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 17, + 16 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 16777280, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 19, + 1 + ] + ], + "invariant_basis": [ + 16 + ] + }, + "positive": { + "key": 89392448, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 16, + "fresh_covector": 16 + } + } + } + }, + { + "edge_pairs": 3, + "width": 7, + "raw_idempotents": 8128, + "counts": { + "common_kernel": 1959, + "direct_positive_orbits": 127, + "extra_pool_members": 63, + "irreducible": 1, + "maximum_pool_size": 9, + "proper_image_orbit": 2078, + "spaces": 4038 + }, + "expected_extremizers": 1, + "case_certificate_sha256": "66438f1c884ce87890e851ed8e78fcd1f0cd8781fc256f2d03d4c53a3ee0232f", + "examples": { + "proper_image_orbit": { + "key": 64, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 65 + ], + [ + 1, + 67 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 65, + 64 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 4398046511232, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 67, + 1 + ] + ], + "invariant_basis": [ + 64 + ] + }, + "positive": { + "key": 95279732763264, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 85 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 64, + "fresh_covector": 64 + } + } + } + }, + { + "edge_pairs": 3, + "width": 8, + "raw_idempotents": 32640, + "counts": { + "common_kernel": 11934, + "direct_positive_orbits": 762, + "extra_pool_members": 176, + "irreducible": 6, + "maximum_pool_size": 9, + "proper_image_orbit": 12470, + "spaces": 24410 + }, + "expected_extremizers": 6, + "case_certificate_sha256": "a3a604aa80b38a7df6b29ca46d277c058860dde0d81a81816128d4783a093959", + "examples": { + "proper_image_orbit": { + "key": 64, + "pairs": [ + [ + 1, + 3 + ], + [ + 1, + 65 + ], + [ + 1, + 67 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 65, + 64 + ] + ], + "invariant_basis": [ + 1 + ] + }, + "common_kernel": { + "key": 281474976710912, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 67, + 1 + ] + ], + "invariant_basis": [ + 64 + ] + }, + "positive": { + "key": 6004434425369856, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 85 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 64, + "fresh_covector": 64 + } + } + } + } + ], + "wider_forms": [ + { + "width": 3, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 4 + }, + "nonzero_patterns": 3 + }, + { + "width": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 13 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 4, + "fresh_covector": 12 + }, + "nonzero_patterns": 3 + }, + { + "width": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 14, + 5 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 12, + "fresh_covector": 4 + }, + "nonzero_patterns": 3 + }, + { + "width": 5, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 14, + 21 + ] + ], + "normal_form": { + "k": 2, + "n": 3, + "edges": [ + [ + 0, + 1 + ] + ], + "fresh_image": 12, + "fresh_covector": 20 + }, + "nonzero_patterns": 3 + }, + { + "width": 5, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 16, + "fresh_covector": 16 + }, + "nonzero_patterns": 7 + }, + { + "width": 6, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 53 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 16, + "fresh_covector": 48 + }, + "nonzero_patterns": 7 + }, + { + "width": 6, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 58, + 21 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 48, + "fresh_covector": 16 + }, + "nonzero_patterns": 7 + }, + { + "width": 7, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 58, + 85 + ] + ], + "normal_form": { + "k": 3, + "n": 5, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "fresh_image": 48, + "fresh_covector": 80 + }, + "nonzero_patterns": 7 + }, + { + "width": 7, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 85 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 64, + "fresh_covector": 64 + }, + "nonzero_patterns": 15 + }, + { + "width": 8, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 213 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 64, + "fresh_covector": 192 + }, + "nonzero_patterns": 15 + }, + { + "width": 8, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 234, + 85 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 192, + "fresh_covector": 64 + }, + "nonzero_patterns": 15 + }, + { + "width": 9, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 234, + 341 + ] + ], + "normal_form": { + "k": 4, + "n": 7, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ] + ], + "fresh_image": 192, + "fresh_covector": 320 + }, + "nonzero_patterns": 15 + }, + { + "width": 9, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 426, + 341 + ] + ], + "normal_form": { + "k": 5, + "n": 9, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ], + "fresh_image": 256, + "fresh_covector": 256 + }, + "nonzero_patterns": 31 + }, + { + "width": 10, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 426, + 853 + ] + ], + "normal_form": { + "k": 5, + "n": 9, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ], + "fresh_image": 256, + "fresh_covector": 768 + }, + "nonzero_patterns": 31 + }, + { + "width": 10, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 938, + 341 + ] + ], + "normal_form": { + "k": 5, + "n": 9, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ], + "fresh_image": 768, + "fresh_covector": 256 + }, + "nonzero_patterns": 31 + }, + { + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 938, + 1365 + ] + ], + "normal_form": { + "k": 5, + "n": 9, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ] + ], + "fresh_image": 768, + "fresh_covector": 1280 + }, + "nonzero_patterns": 31 + }, + { + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 6826, + 5461 + ] + ], + "normal_form": { + "k": 7, + "n": 13, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + "fresh_image": 4096, + "fresh_covector": 4096 + }, + "nonzero_patterns": 127 + }, + { + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 6826, + 13653 + ] + ], + "normal_form": { + "k": 7, + "n": 13, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + "fresh_image": 4096, + "fresh_covector": 12288 + }, + "nonzero_patterns": 127 + }, + { + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 15018, + 5461 + ] + ], + "normal_form": { + "k": 7, + "n": 13, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + "fresh_image": 12288, + "fresh_covector": 4096 + }, + "nonzero_patterns": 127 + }, + { + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 15018, + 21845 + ] + ], + "normal_form": { + "k": 7, + "n": 13, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ] + ], + "fresh_image": 12288, + "fresh_covector": 20480 + }, + "nonzero_patterns": 127 + }, + { + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 109226, + 87381 + ] + ], + "normal_form": { + "k": 9, + "n": 17, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ], + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + "fresh_image": 65536, + "fresh_covector": 65536 + }, + "nonzero_patterns": 511 + }, + { + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 109226, + 218453 + ] + ], + "normal_form": { + "k": 9, + "n": 17, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ], + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + "fresh_image": 65536, + "fresh_covector": 196608 + }, + "nonzero_patterns": 511 + }, + { + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 240298, + 87381 + ] + ], + "normal_form": { + "k": 9, + "n": 17, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ], + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + "fresh_image": 196608, + "fresh_covector": 65536 + }, + "nonzero_patterns": 511 + }, + { + "width": 19, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 240298, + 349525 + ] + ], + "normal_form": { + "k": 9, + "n": 17, + "edges": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 8, + 9 + ], + [ + 10, + 11 + ], + [ + 12, + 13 + ], + [ + 14, + 15 + ] + ], + "fresh_image": 196608, + "fresh_covector": 327680 + }, + "nonzero_patterns": 511 + } + ], + "boundary_controls": { + "k_one_incomplete_example": [ + [ + 1, + 3 + ] + ], + "reducible_examples": [ + { + "k": 2, + "image": 3, + "edge_count": 2 + }, + { + "k": 3, + "image": 5, + "edge_count": 3 + }, + { + "k": 4, + "image": 7, + "edge_count": 4 + }, + { + "k": 5, + "image": 9, + "edge_count": 5 + }, + { + "k": 6, + "image": 11, + "edge_count": 6 + } + ] + }, + "limitations": [ + "Uses the pinned all-width matching bound in PR7692.", + "The k=3 two-edge restricted normal form is prior work from PR6782.", + "This is not a coordinate-orbit count or a free physical change of basis.", + "No paid word, native realization, complete invoice or kappa improvement." + ] +} diff --git a/research/edge-extremal-pool-classification/SOURCES.json b/research/edge-extremal-pool-classification/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/edge-extremal-pool-classification/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/edge-extremal-pool-classification/TASK.json b/research/edge-extremal-pool-classification/TASK.json new file mode 100644 index 0000000000..dc2212c767 --- /dev/null +++ b/research/edge-extremal-pool-classification/TASK.json @@ -0,0 +1,80 @@ +{ + "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 classification of every irreducible binary noncoordinate projector collection with pattern dimension k>=2 and image dimension 2k-1.", + "scope_change_reason": "Classify the universal extremizers of the new matching bound, with no initial edge-count or completeness premise.", + "bottleneck_link": "Reduce every maximal scalar core to one joint-image action before a legal paid-word search.", + "budget_minutes": 60, + "stop_rule": "Stop after the all-width classification and complete-pool checks. No paid-word or native construction starts in this package.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; 2825 pattern spaces, 4164 pure-unit graphs, 30702 complete link spaces, 49 positive links and 24 wider forms.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can the unique extremal action admit a legal paid word with target rank above paid rank at a larger k?", + "why_it_matters": "The scalar action is fixed, but no paid saving or native supplier follows.", + "first_step": "Compare the PR6782 five-core word obstruction; specify alphabet, relation lattice, endpoint coordinates, all counted roles and native interface.", + "blocked_by": "No paid-word realization or complete native invoice is supplied." + } + ], + "family_decision": { + "decision": "Classify the universal extremizers and stop scalar geometry work on this family.", + "sources": "7692@c2870a38841f515db7203a0761cd77f014f7fb7a; 6782@685457252b51b9c7932ece363365bdf0b12c9c31", + "evidence_status": "Author-checked written proof using the pinned matching theorem, with exact finite corroboration.", + "boundary": "Binary noncoordinate rank-one idempotents, pattern dimension k>=2 and irreducible image dimension 2k-1.", + "obligations": { + "forced_edge_count": "proved", + "full_ambient_form": "proved", + "completeness": "proved", + "paid_word": "unknown", + "native_conversion": "unknown", + "complete_invoice": "unknown" + }, + "alternative": "A blind larger-core word search would not establish which extremal geometries it covers. The matching bound reduces the classification to one pattern coset.", + "construction_gate": "Unmet. No paid identity, native alphabet or complete invoice is supplied." + } +} diff --git a/research/edge-extremal-pool-classification/VERIFY.json b/research/edge-extremal-pool-classification/VERIFY.json new file mode 100644 index 0000000000..b8b55ae52d --- /dev/null +++ b/research/edge-extremal-pool-classification/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 pattern spaces and pure-unit graphs, every member of the seven link domains, invariant certificates, forced full normal forms and hypothesis controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete small pattern spaces and pure-unit graphs, every member of the seven link domains, invariant certificates, forced full normal forms and hypothesis controls." + } + ] +} diff --git a/research/edge-extremal-pool-classification/verify.py b/research/edge-extremal-pool-classification/verify.py new file mode 100644 index 0000000000..2b50e4a090 --- /dev/null +++ b/research/edge-extremal-pool-classification/verify.py @@ -0,0 +1,404 @@ +"""Exact checks for all-dimension extremal projector pools. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Matrix, lift, orbit and subspace primitives are reused from PR7692. +See CREDITS.md for exact sources and predecessor support arguments. +""" + +import hashlib +import itertools +import json +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 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 coordinates(vectors, value): + pivots = {} + for i, row in enumerate(vectors): + label = 1 << i + while row: + bit = row.bit_length() - 1 + if bit not in pivots: + pivots[bit] = row, label + break + other, old = pivots[bit] + row ^= other + label ^= old + require(row != 0, 'coordinate basis independence') + label = 0 + while value: + bit = value.bit_length() - 1 + require(bit in pivots, 'vector is in the image basis') + row, old = pivots[bit] + value ^= row + label ^= old + return label + + +def invariant_certificate(pairs): + """Use the common kernel and every image orbit; no generator is omitted.""" + vectors = basis(x for x, _ in pairs) + n = len(vectors) + if not n: + return False, 'empty', () + rows = basis(sum(parity(y & x) << i for i, x in enumerate(vectors)) for _, y in pairs) + if len(rows) < n: + pivots = {row.bit_length() - 1: row for row in rows} + value = 1 << next(i for i in range(n) if i not in pivots) + for i, row in sorted(pivots.items()): + if parity(row & value): + value ^= 1 << i + require(value and all(not parity(row & value) for row in rows), 'restricted kernel vector') + witness = 0 + for i, vector in enumerate(vectors): + if value >> i & 1: + witness ^= vector + require(witness and all(not parity(y & witness) for _, y in pairs), 'common kernel witness') + return False, 'common_kernel', (witness,) + for start in sorted({x for x, _ in pairs}): + orbit = basis([start]) + while True: + new = basis((*orbit, *(x for x, y in pairs if any(parity(y & v) for v in orbit)))) + if len(new) == len(orbit): + break + orbit = new + if len(orbit) < n: + subspace = set(span(orbit)) + require(all(not parity(y & v) or x in subspace for x, y in pairs for v in orbit), + 'proper orbit is invariant under the whole pool') + return False, 'proper_image_orbit', orbit + return True, 'irreducible', () + + +def directed_units(ps, width): + return sorted(divmod(p.bit_length() - 1, width) for p in span(ps) if p.bit_count() == 1) + + +def edge_projectors(edge_list): + return [(x, y) for a, b in edge_list + for x, y in [((1 << a), (1 << a) | (1 << b)), + ((1 << a) | (1 << b), (1 << b))]] + + +def normal_form(pairs, ps, width): + k = len(basis(ps)) + n = len(basis(x for x, _ in pairs)) + require(k >= 2 and n == 2 * k - 1, 'extremal dimensions') + units = directed_units(ps, width) + require(len(units) == k - 1, 'exactly k-1 directed units') + endpoints = {v for edge in units for v in edge} + require(len(endpoints) == 2 * k - 2, 'disjoint edge endpoints') + core = sum(1 << i for i in endpoints) + old = edge_projectors(units) + remainder = set(pairs) - set(old) + require(set(old) <= set(pairs) and len(remainder) == 1, 'complete pool contains one link') + x, y = next(iter(remainder)) + hx = sum(1 << b for _, b in units) + hy = sum(1 << a for a, _ in units) + require(x & core == hx and y & core == hy, 'forced old-coordinate factors') + a, b = x & ~core, y & ~core + require(a and b and parity(a & b), 'fresh pairing one') + image_basis = [xx for xx, _ in old] + [a] + expected = [1 << (i * n + i) for i in range(n - 1)] + [(1 << (n * n)) - 1] + restrictions = [outer(coordinates(image_basis, xx), + sum(parity(yy & v) << i for i, v in enumerate(image_basis)), n) + for xx, yy in old + [(x, y)]] + require(restrictions == expected, 'coordinate projectors plus J normal form') + require(len(pairs) == n, 'image-basis completeness is forced') + return {'k': k, 'n': n, 'edges': units, 'fresh_image': a, 'fresh_covector': b} + + +def small_pattern_census(): + positions = [i * 3 + j for i in range(3) for j in range(3) if i != j] + raw = [(x, y, off(outer(x, y, 3), 3)) for x, y in itertools.product(range(1, 8), repeat=2) + if parity(x & y) and off(outer(x, y, 3), 3)] + counts, positives = Counter(), [] + for compressed in all_subspaces(6): + literal = {sum(((v >> i) & 1) << pos for i, pos in enumerate(positions)) for v in compressed} + ps = basis(sorted(literal)) + actual = sorted((x, y) for x, y, pattern in raw if pattern in literal) + require(actual == pool(ps, 3), 'small raw pool agrees with lifting') + action, reason, witness = invariant_certificate(actual) + if actual: + require(action == orbit_irreducible(actual), 'image-orbit test agrees with all-vector test') + counts['spaces'] += 1 + counts[reason] += 1 + k, n = len(ps), len(basis(x for x, _ in actual)) + if action and k >= 2 and n == 2 * k - 1: + positives.append(normal_form(actual, ps, 3)) + require(counts['spaces'] == 2825 and len(positives) == 6, 'complete width-three extremal census') + return {'counts': dict(sorted(counts.items())), 'extremizers': positives} + + +def pure_unit_graph_census(width): + positions = [(i, j) for i in range(width) for j in range(width) if i != j] + raw = [(x, y, off(outer(x, y, width), width)) + for x, y in itertools.product(range(1, 1 << width), repeat=2) + if parity(x & y) and off(outer(x, y, width), width)] + counts = Counter() + for mask in range(1 << len(positions)): + selected = [edge for i, edge in enumerate(positions) if mask >> i & 1] + allowed = sum(1 << (a * width + b) for a, b in selected) + vertices = {v for edge in selected for v in edge} + actual = [(x, y) for x, y, pattern in raw if not pattern & ~allowed] + n = len(vertices) + require(len(basis(x for x, _ in actual)) == n, 'pure graph joint image is its endpoint space') + strong = bool(vertices) + for start in sorted(vertices): + reached = {start} + while True: + new = reached | {a for a, b in selected if b in reached} + if new == reached: + break + reached = new + if reached != vertices: + strong = False + coordinate_subspace = sum(1 << i for i in reached) + require(all(not (y & coordinate_subspace) or not (x & ~coordinate_subspace) + for x, y in actual), 'predecessor-closed invariant coordinate space') + break + irreducible, _, _ = invariant_certificate(actual) + require(irreducible == (strong and n >= 3), 'pure-unit graph criterion') + if irreducible: + require(len(selected) >= n, 'irreducible pure-unit edge floor') + if n == 2: + ones = sum(1 << i for i in vertices) + require(all(not parity(y & ones) or x == ones for x, y in actual), 'two-vertex invariant line') + counts['graphs'] += 1 + counts['irreducible'] += irreducible + counts['strong_two_vertex_exception'] += strong and n == 2 + return {'width': width, 'counts': dict(sorted(counts.items()))} + + +def link_domain(t, width): + edge_list = [(2 * i, 2 * i + 1) for i in range(t)] + unit_patterns = [1 << (a * width + b) for a, b in edge_list] + edge_mask = sum(unit_patterns) + core = (1 << (2 * t)) - 1 + buckets, candidates = {}, set() + raw_count = 0 + for x in range(1, 1 << width): + for y in range(1, 1 << width): + if not parity(x & y): + continue + raw_count += 1 + p = off(outer(x, y, width), width) + if not p: + continue + key = p & ~edge_mask + buckets.setdefault(key, []).append((x, y)) + if x & ~core: + candidates.add(key) + require(sorted(buckets.get(0, [])) == sorted(edge_projectors(edge_list)), 'old complete edge pool') + counts, examples = Counter(), {} + digest = hashlib.sha256() + for key in sorted(candidates): + require(key, 'outside image cannot have an old-span pattern') + ps = unit_patterns + [key] + actual = sorted(buckets[0] + buckets[key]) + require(actual == pool(ps, width), 'all odd-coset members agree with literal lifts') + n = len(basis(x for x, _ in actual)) + require(n in (2 * t + 1, 2 * t + 2), 'complete quotient-image dimensions') + irreducible, reason, invariant = invariant_certificate(actual) + counts['spaces'] += 1 + counts[reason] += 1 + counts['extra_pool_members'] += len(actual) > 2 * t + 1 + counts['maximum_pool_size'] = max(counts['maximum_pool_size'], len(actual)) + if irreducible: + require(n == 2 * t + 1, 'extremal image dimension') + form = normal_form(actual, ps, width) + require(orbit_irreducible(actual), 'positive all-vector orbit replay') + counts['direct_positive_orbits'] += (1 << n) - 1 + examples.setdefault('positive', {'key': key, 'pairs': actual, 'normal_form': form}) + else: + examples.setdefault(reason, {'key': key, 'pairs': actual, 'invariant_basis': invariant}) + digest.update((json.dumps({'key': key, 'n': n, 'reason': reason, 'invariant': invariant}, + sort_keys=True) + '\n').encode()) + r = width - 2 * t + expected = ((1 << r) - 1) * (1 << (r - 1)) + require(counts['irreducible'] == expected, 'all and only fresh pairing-one links') + return {'edge_pairs': t, 'width': width, 'raw_idempotents': raw_count, + 'counts': dict(sorted(counts.items())), 'expected_extremizers': expected, + 'case_certificate_sha256': digest.hexdigest(), 'examples': examples} + + +def wider_forms(): + result = [] + for t in (1, 2, 3, 4, 6, 8): + for a, b, r in ((1, 1, 1), (1, 3, 2), (3, 1, 2), (3, 5, 3)): + width = 2 * t + r + edge_list = [(2 * i, 2 * i + 1) for i in range(t)] + old = edge_projectors(edge_list) + hx = sum(1 << v for _, v in edge_list) + hy = sum(1 << u for u, _ in edge_list) + link = (hx | (a << (2 * t)), hy | (b << (2 * t))) + pairs = old + [link] + ps = patterns(pairs, width) + require(pool(ps, width) == sorted(pairs), 'wider complete pool') + form = normal_form(pairs, ps, width) + require(invariant_certificate(pairs)[0], 'wider full action') + # Every deletion loses one independent image. + for i in range(len(pairs)): + subset = pairs[:i] + pairs[i + 1:] + require(len(basis(x for x, _ in subset)) == len(pairs) - 1, 'one omitted member loses image rank') + result.append({'width': width, 'pairs': pairs, 'normal_form': form, + 'nonzero_patterns': (1 << (t + 1)) - 1}) + return result + + +def boundary_controls(): + single = [(1, 3)] + ps = patterns(single, 2) + require(len(basis(ps)) == 1 and invariant_certificate(single)[0], 'k=1 irreducible example') + require(len(pool(ps, 2)) == 2, 'k=1 completion is larger') + rejected = False + try: + normal_form(single, ps, 2) + except ValueError as e: + rejected = str(e) == 'extremal dimensions' + require(rejected, 'k>=2 guard') + reducible = [] + for k in range(2, 7): + pairs = edge_projectors([(2 * i, 2 * i + 1) for i in range(k)])[:-1] + ps = patterns(pairs, 2 * k) + require(len(basis(ps)) == k and len(basis(x for x, _ in pairs)) == 2 * k - 1, + 'reducible extremal dimensions') + require(not invariant_certificate(pairs)[0], 'irreducibility is necessary') + require(len(directed_units(ps, 2 * k)) == k, 'reducible example has k edges') + reducible.append({'k': k, 'image': 2 * k - 1, 'edge_count': k}) + return {'k_one_incomplete_example': single, 'reducible_examples': reducible} + + +def compute(): + return {'status': 'PASS_EDGE_EXTREMAL_POOL_CLASSIFICATION', + 'scope': 'Every irreducible binary noncoordinate projector collection with pattern dimension k>=2 and image dimension 2k-1.', + 'claim': 'The collection is complete: k-1 disjoint edge pairs and one link with the forced old factors and fresh pairing one.', + 'small_pattern_census': small_pattern_census(), + 'pure_unit_graphs': [pure_unit_graph_census(w) for w in (2, 3, 4)], + 'complete_link_domains': [link_domain(t, w) for t, w in ((1, 3), (1, 4), (1, 5), (2, 5), (2, 6), (3, 7), (3, 8))], + 'wider_forms': wider_forms(), + 'boundary_controls': boundary_controls(), + 'limitations': ['Uses the pinned all-width matching bound in PR7692.', + 'The k=3 two-edge restricted normal form is prior work from PR6782.', + 'This is not a coordinate-orbit count or a free physical change of basis.', + 'No paid word, native realization, complete invoice or kappa improvement.']} + + +if __name__ == '__main__': + actual = json.loads(json.dumps(compute())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + require(actual == expected, 'committed exact receipt') + print(actual['status']) + print(json.dumps({'pattern_spaces': actual['small_pattern_census']['counts']['spaces'], + 'pure_graphs': sum(r['counts']['graphs'] for r in actual['pure_unit_graphs']), + 'link_spaces': sum(r['counts']['spaces'] for r in actual['complete_link_domains']), + 'positive_links': sum(r['counts']['irreducible'] for r in actual['complete_link_domains']), + 'wider_forms': len(actual['wider_forms'])}, sort_keys=True))