From 57e24923b609d2588b83321f530fa2a1e75ed364 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 09:04:00 -0500 Subject: [PATCH] Prove sharp even-difference image maxima and the small exception --- .../edge-matching-even-attainment/CREDITS.md | 56 + .../edge-matching-even-attainment/PROOF.md | 281 +++ .../edge-matching-even-attainment/README.md | 100 + .../edge-matching-even-attainment/RESULT.json | 1698 +++++++++++++++++ .../SOURCES.json | 18 + .../edge-matching-even-attainment/TASK.json | 83 + .../VALIDATION.md | 56 + .../edge-matching-even-attainment/VERIFY.json | 34 + .../edge-matching-even-attainment/verify.py | 338 ++++ 9 files changed, 2664 insertions(+) create mode 100644 research/edge-matching-even-attainment/CREDITS.md create mode 100644 research/edge-matching-even-attainment/PROOF.md create mode 100644 research/edge-matching-even-attainment/README.md create mode 100644 research/edge-matching-even-attainment/RESULT.json create mode 100644 research/edge-matching-even-attainment/SOURCES.json create mode 100644 research/edge-matching-even-attainment/TASK.json create mode 100644 research/edge-matching-even-attainment/VALIDATION.md create mode 100644 research/edge-matching-even-attainment/VERIFY.json create mode 100644 research/edge-matching-even-attainment/verify.py diff --git a/research/edge-matching-even-attainment/CREDITS.md b/research/edge-matching-even-attainment/CREDITS.md new file mode 100644 index 0000000000..65e27fc64e --- /dev/null +++ b/research/edge-matching-even-attainment/CREDITS.md @@ -0,0 +1,56 @@ +# Sources and attribution + +- Ali Romman, with substantial OpenAI Codex assistance, + [PR #7692](https://github.com/CrocSwap/integer-mult-bounds/pull/7692), + head `c2870a38841f515db7203a0761cd77f014f7fb7a`: + the [matching proof](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md) + gives the upper bound, disjoint diagonal relations, binary fibers, + pair/triple blocks and the universal extremal family. The proof was read. + It is a mathematical premise; the complete predecessor suite was not run. +- Ali Romman, with substantial OpenAI Codex assistance, + [PR #7703](https://github.com/CrocSwap/integer-mult-bounds/pull/7703), + head `2523029b27d40526b811591ce0fb85f9bc1b1df7`: + the [proof](https://github.com/aliromman/integer-mult-bounds/blob/2523029b27d40526b811591ce0fb85f9bc1b1df7/research/edge-matching-equality-classification/PROOF.md) + classifies first equality and gives the sharp odd-difference maxima. + Its [checker](https://github.com/aliromman/integer-mult-bounds/blob/2523029b27d40526b811591ce0fb85f9bc1b1df7/research/edge-matching-equality-classification/verify.py) + supplies the adapted binary matrix, basis, pattern-lift, matching, orbit + and old-core functions. Both files were read. No prior receipt is relabelled + as a new result. The full predecessor suite was not rerun. +- Nick Petalas, + [PR #6785](https://github.com/CrocSwap/integer-mult-bounds/pull/6785), + head `5dbf2c05220bea53d84b510efe5910c4cec8f182`: + the [one-edge proof](https://github.com/petalas/integer-mult-bounds/blob/5dbf2c05220bea53d84b510efe5910c4cec8f182/research/one-edge-pattern-reducibility/PROOF.md), + Git blob `f3e5ddb24517bebacac04442c856aec7dd2f4b40`, gives the upper bound + four at (k,nu)=(3,1) and explicitly leaves attainment open. It was read; + its width-five/six census was not rerun. The new two-link family attains + that bound as one special case. +- unpaidmoon, with substantial Cursor Grok assistance, + [PR #7094](https://github.com/CrocSwap/integer-mult-bounds/pull/7094), + head `b5f0a0df3d22e8ad40d67d6be4d1c7ff24d180c5`: + the [proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/b5f0a0df3d22e8ad40d67d6be4d1c7ff24d180c5/research/no-edge-dim4-image-five/PROOF.md), + Git blob `b2350589eeed011640caebd3b66f0cbb70639a83`, already attains + (k,nu,n)=(4,0,5) with a five-member complete pool. The proof was read; + that literal pool is checked as a source comparison. The full source + suite was not run. The current six-member family does not claim first + attainment of that instance. Retain the source's earlier four-cycle + [PR #6962](https://github.com/CrocSwap/integer-mult-bounds/pull/6962) + and normal-triple [PR #6921](https://github.com/CrocSwap/integer-mult-bounds/pull/6921) + credit. The latter's pinned proof at + `6020400853abc110134804fad04b695adc360bcd` was read for overlap; its full + theorem is not used as a premise here. + +The cited matching proof retains CubeJerry's +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), its +credit to Nick Petalas for the diagonal-deletion fiber lemma, and the +normal-triple lineage. The odd-difference proof retains unpaidmoon and +Nick Petalas's earlier fresh-link and complete-pool work. Those results +and notices remain credited; they are not new claims here. + +The new contribution is the two-link attaining family for all positive even +k-nu, its complete pools including the six-member case, the exceptional +maximum at (2,0), and the zero-difference existence boundary. The odd rows +in the combined maximum table are prior results. + +Source and adapted code are Apache-2.0. Prepared by Ali Romman with +substantial OpenAI Codex assistance. Independent human and formal-kernel +review are unclaimed. diff --git a/research/edge-matching-even-attainment/PROOF.md b/research/edge-matching-even-attainment/PROOF.md new file mode 100644 index 0000000000..cc9fcc0d89 --- /dev/null +++ b/research/edge-matching-even-attainment/PROOF.md @@ -0,0 +1,281 @@ +# Sharp even-difference image maxima + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is a scoped proof about binary projector geometry. No new kappa, +paid word, or native supplier is claimed. + +## 1. Exact scope and result + +At any finite coordinate width, let C be a collection of rank-one +idempotents `xy^T` over F2 with nonzero off-diagonal patterns. Let H be +their actual pattern span, k its dimension, V their joint image, and n +its dimension. The action of C on nonzero V is assumed irreducible. +Put an undirected edge {a,b} in the coordinate graph when H contains +the matrix unit E_ab or E_ba. Let nu be the maximum matching size. +The collection need not be the complete pool of all lifts of H. + +The [matching theorem of PR #7692](https://github.com/aliromman/integer-mult-bounds/blob/c2870a38841f515db7203a0761cd77f014f7fb7a/research/edge-matching-image-bound/PROOF.md) +gives `2n<=3k+nu-1`. Its proof is a consumed premise. For positive even +k-nu, integrality gives `n<=(3k+nu-2)/2`. + +**Theorem.** For every positive even k-nu this last upper bound is sharp, +except at `(k,nu)=(2,0)`, where the exact maximum is one. All positive-even +maxima are attained by complete pools. + +The zero-difference boundary has a different existence condition. At +`k=nu=1`, a one-member collection attains n=1. At `k=nu>1`, no such +irreducible collection exists. The complete pool at `k=nu=1` is reducible; +the allowance for subcollections matters there. + +The [odd-difference theorem of PR #7703](https://github.com/aliromman/integer-mult-bounds/blob/2523029b27d40526b811591ce0fb85f9bc1b1df7/research/edge-matching-equality-classification/PROOF.md) +already gives the sharp maxima for positive odd k-nu. Combining that prior +result with this theorem gives the full table for `k>=1` and `0<=nu<=k`: + +| Condition | Maximum n, or existence | +|---|---| +| k=nu=1 | 1, for a proper subcollection | +| k=nu>1 | No irreducible collection | +| k-nu is 1 modulo 4 | `(3k+nu-1)/2` (prior result) | +| k-nu is 3 modulo 4 | `(3k+nu-3)/2` (prior result) | +| k-nu is positive and even, except (2,0) | `(3k+nu-2)/2` | +| (k,nu)=(2,0) | 1 | + +This table classifies attainable image maxima, not every attaining pool +or a prescribed edge graph. The new constructions are described below. + +## 2. The old disjoint core + +Choose integers t,r>=0 with t+r>0. On each of t disjoint coordinate +pairs use the two image/covector pairs + +```text +(e_a, e_a+e_b), (e_a+e_b, e_b). +``` + +On each of r further disjoint triples use the row-mask pairs + +```text +(6,5), (5,6), (7,7). +``` + +These pair and triple blocks are prior constructions in PR #7692 and +PR #7703. On a pair the common off-pattern is E_ab. On a triple the three +patterns are the nonzero elements of a two-dimensional unit-free space. +The images and covectors form dual bases in each block. Put + +```text +m = 2t+3r, +h_x = sum of the m old image vectors, +h_y = sum of the m old covectors. +``` + +Both sums are nonzero, with a nonzero component on every old block, and +`h_y dot h_x = m modulo 2 = r modulo 2`. More explicitly, each pair +contributes e_b to h_x and e_a to h_y. Each normal triple contributes +its third coordinate vector to both sums. + +Let H0 be the old pattern span. It has dimension t+2r. Its matrix units +are precisely the t chosen, disjoint directed units. Its complete pool +is precisely the old pair and triple members. To see this, a rank-one +idempotent with a nonzero block-diagonal pattern must lie in one block: +choose a coordinate common to its image and covector supports. Any +factor bit in another block would force a forbidden cross entry. +Within a pair, a matrix unit has its two stated lifts. Within a normal +triple, each nonzero pattern has its one stated lift. These fiber facts +are also stated and proved in the cited matching proof. + +## 3. Two fresh links + +Add fresh coordinates f and g. Define a two-by-two matrix Z by + +```text +Z = [[1,0],[0,1]] if r is even, +Z = [[0,1],[1,0]] if r is odd. +``` + +Its rows are covectors z1,z2 on the fresh coordinates. Add projectors + +```text +L1 = (h_x+e_f)(h_y+z1)^T, +L2 = (h_x+e_g)(h_y+z2)^T. (1) +``` + +Each factor pairing is `r+Z_ii=1` in F2, so both links are idempotent. +Their cross rectangles with the old core are nonzero. Their images, +together with the m old images, form a basis of the full ambient space +of dimension m+2. + +The two new patterns are independent modulo H0. Their restrictions +to the old-row/fresh-column rectangle are the two different coordinate +columns h_x, possibly exchanged. Thus every nonzero combination of +the links has a nonzero such rectangle. Each such combination also +has a nonzero fresh-row/old-column rectangle. These are disjoint, so +no pattern in any of the three new cosets is a matrix unit. Therefore + +```text +k = t+2r+2, nu = t, n = m+2 = 2t+3r+2, +2n = 3k+nu-2. (2) +``` + +The old covectors detect every old coordinate. After they vanish, +the two link covectors detect the two fresh coordinates because Z is +invertible. Hence the selected projectors have no common kernel. +Every old projector maps each link image to its own image, since +`y_i dot h_x=1`. Each link maps every old image to its link image, since +`h_y dot x_i=1`. As m>0, this connects every selected image to every other. + +For a nonzero invariant subspace, the zero-common-kernel property gives +some nonzero projector output, hence one projector image in the subspace. +The stated connections then give all m+2 independent images. Thus the +selected collection is irreducible on the full ambient space. Adding +the remaining pool members cannot destroy irreducibility. + +Given positive even k-nu, put `t=nu` and `r=(k-nu-2)/2`. Then (2) gives +the desired parameters whenever t+r>0. The sole missing case is (2,0). + +## 4. The complete pool, including the extra member + +The old coset contributes exactly the old pool. In the coset of either +single link, its two nonzero cross rectangles force both old factors +and all fresh factor bits. The only possible lift is that link itself. + +Consider the sum coset of the two links. Its cross rectangles force +the only possible factors to be + +```text +x = h_x+e_f+e_g, y = h_y+e_f+e_g. (3) +``` + +If r is even, the two fresh off-diagonal entries of the sum coset are +zero. Those of (3) are one, so the coset has no lift. + +If r is odd, those fresh entries are one and agree with (3). The old +block of the two links cancels, so (3) belongs to the coset exactly +when `off(h_x h_y^T)` belongs to H0. With at least two old blocks this +is impossible: h_x and h_y have nonzero components in every block, +so their outer product has a nonzero cross-block entry, whereas H0 +is block diagonal. + +The only single-block odd case is t=0,r=1. There h_x=h_y is the third +coordinate of the normal triple, so its outer product is diagonal. +The extra lift exists and is idempotent. At the displayed coordinate +order it has factors `(28,28)` on five coordinates. + +Thus the complete pool has exactly n members except at `(k,nu,n)=(4,0,5)`, +where it has n+1=6. Its joint image stays n and the action stays irreducible. +This includes all additional lifts; an independent-image list alone +would miss that sixth member. + +Attainment at (k,nu,n)=(4,0,5) is already known from unpaidmoon's +[PR #7094](https://github.com/CrocSwap/integer-mult-bounds/pull/7094), +[pinned proof](https://github.com/unpaidmoon/integer-mult-bounds/blob/b5f0a0df3d22e8ad40d67d6be4d1c7ff24d180c5/research/no-edge-dim4-image-five/PROOF.md). +That different complete pool has five members. Together with the prior +matching bound it already settles that one maximum. The six-member pool +here is part of a new all-parameter construction, not a claim to first +attainment at that instance. The verifier checks the five-member source +pool separately as a comparison. These two pools also show why the maximum +theorem is not a classification of every maximizing pool. + +## 5. The exception (k,nu)=(2,0) + +The inherited bound gives n<=2. Suppose n=2. A nonzero non-unit binary +off-pattern has at most one rank-one-idempotent lift, by the fiber lemma +in the matching proof. The two-dimensional H has only three nonzero +patterns, none a matrix unit. Thus C has at most three members. +Each restricts to a rank-one idempotent on V, because it fixes its +nonzero image vector in V. + +Two rank-one idempotents on F2^2 always have a common invariant line. +If their images agree, use that line. Otherwise use the two images as +a basis. Their covectors have forms `(1,a)` and `(b,1)`. If a=0 or b=0, +one image line is invariant. If a=b=1, they share the kernel line +spanned by `(1,1)`. This also covers repeated restrictions. + +It remains to consider three distinct restrictions. The three ambient +patterns sum to zero, so the sum D of the projectors is diagonal and +idempotent. Its restriction to V is idempotent with trace one, hence +rank one. There are exactly six rank-one idempotents on F2^2. Indeed, +write a matrix as `[[a,b],[c,1+a]]`; rank one requires bc=0, which gives +six choices. They split into three complementary pairs, and the sum +of all six is I. + +D cannot equal any of the three distinct restrictions, since that +would make the other two equal. The other two members of the six, +outside these four, must therefore sum to I. They form a complementary +pair. The four inside consist of the two remaining complementary pairs, +so the original three contain one complete complementary pair. + +In a basis where that pair is E11,E22, the third projector again has +form `[[a,b],[c,1+a]]` with bc=0. It preserves one coordinate line, as +does the complementary pair. This contradicts irreducibility. Thus n=2 +is impossible at every ambient width. + +The complete pool with image/covector pairs `(7,1)` and `(7,2)` at width +three attains n=1. Their patterns are independent, and their nonzero +span contains no matrix unit. The third pattern would require factors +`(7,3)`, whose pairing is zero, so there is no third lift. Both operators +act as the identity on their common image line. This proves the maximum. + +## 6. The boundary k=nu + +A matching of size k supplies k independent directed matrix units in +the k-dimensional H. They are therefore a basis, on disjoint coordinate +pairs. A noncoordinate rank-one-idempotent lift in this span must be +one of the two lifts of one individual unit. This follows from the +same block-support argument in Section 2. + +To span H, the collection must use every pair. At k>1 its nonzero +image components in the disjoint pairs are proper invariant subspaces, +so irreducibility is impossible. At k=1 one unit lift gives an irreducible +one-dimensional image; taking both gives a reducible complete pool. +No assumption about completion of the original collection is made. + +## 7. Evidence and limits + +The verifier constructs all 24 families with `0<=t,r<=4` and t+r>0. +It lifts all 42,256 nonzero patterns, checks the exact complete pools, +matching sizes, ranks and Gram matrices, and checks the connections +between projector images. It also checks every nonzero-vector orbit +when n<=9. For width at most seven, an independent scan of 21,284 raw +factor pairs gives the same pools. The exceptional width-three witness +is checked by both methods as well. + +The small restriction check enumerates all 36 ordered pairs and all +216 ordered triples of the six rank-one idempotents on F2^2. All pairs +and the 168 triples with idempotent sum have a directly checked common +invariant line. A separate orbit check rejects irreducibility whenever +their joint image is two-dimensional. This corroborates the written +argument in Section 5. It does not enumerate ambient embeddings; the +written reduction handles every width. + +For k=nu from one through six, all 126 choices of one lift per edge +and each complete pool have the claimed reducibility status. Choosing +the wrong parity for Z makes both links non-idempotent. Choosing a +singular fresh pairing can leave idempotent links with connected action +but a nonzero common kernel. These controls test both parts of the +irreducibility argument. Exact receipts are in [RESULT.json](RESULT.json). + +The result settles image capacity at these parameters. It does not +classify every maximizing pool, solve a paid relation lattice, or give +native realization, owned state, restoration, a complete BIT invoice, +or a multiplier. All five selected assumptions remain. No selected +cold replay, complete predecessor suite, native, Lean or Docker replay, +independent human review or proof-kernel check was run. + +## Credit and next question + +The matching bound, disjoint relation theorem and basic blocks are from +Ali Romman's PR #7692. PR #7703 supplies the sharp odd case and the +complete-coset method. Nick Petalas's +[one-edge proof](https://github.com/petalas/integer-mult-bounds/blob/5dbf2c05220bea53d84b510efe5910c4cec8f182/research/one-edge-pattern-reducibility/PROOF.md) +in [PR #6785](https://github.com/CrocSwap/integer-mult-bounds/pull/6785) +already gives the upper bound four at (k,nu)=(3,1), without attainment. +The t=1,r=0 construction here attains it. The earlier normal-triple and +fiber credit is retained in [CREDITS.md](CREDITS.md). Binary primitives +are adapted from the pinned prior checker. + +The remaining classification question is which other complete pools +attain the even maximum. That question differs from the maximum itself. +A paid-word use still needs the actual relation lattice and full endpoint; +the existing single-bridge obstruction must not be assumed to settle +the new two-link alphabet. No follow-up is reserved. diff --git a/research/edge-matching-even-attainment/README.md b/research/edge-matching-even-attainment/README.md new file mode 100644 index 0000000000..472180d527 --- /dev/null +++ b/research/edge-matching-even-attainment/README.md @@ -0,0 +1,100 @@ +# Sharp even-difference image maxima + +No new kappa. For irreducible binary rank-one-idempotent collections with +nonzero off-patterns, the exact maximum joint-image dimension at positive +even k-nu is `(3k+nu-2)/2`, except at `(k,nu)=(2,0)`, where it is one. +Here k is the actual pattern-span dimension and nu is the maximum matching +size of its matrix-unit graph. Coordinate projectors are excluded. + +The [proof](PROOF.md) gives two fresh links to disjoint pair and triple +blocks, with complete-pool control at every parameter. The exceptional +small case has an all-width exclusion and an attaining one-dimensional +pool. At k=nu, only k=1 permits an irreducible collection, and it must +be a proper subcollection of its pool. Together with the prior odd case +in [PR #7703](https://github.com/CrocSwap/integer-mult-bounds/pull/7703), +these results give all fixed-(k,nu) maxima and existence cases. + +This is a geometric capacity result. It does not classify every maximizer +or a fixed edge graph, solve a legal paid word, or provide a native supplier. +The selected value stays `363005817/100000000000` and all five assumptions +remain. Preparation, ownership, native action, restoration and the complete +recursive invoice are still separate obligations. + +## Reproduce + +Use CPython 3.12 and the standard library from the repository root: + +```sh +python3 -B scripts/research_package.py --package research/edge-matching-even-attainment +python3 -I -O -W error -B research/edge-matching-even-attainment/verify.py +``` + +The direct marker is `PASS_EDGE_MATCHING_EVEN_ATTAINMENT`. The registered +hook runs normal and optimized modes. Failures raise exceptions. +The only runtime file is [RESULT.json](RESULT.json). The all-width claim +is a written proof, with the inherited matching upper bound stated explicitly. + +Finite checks lift every nonzero pattern in 24 complete attaining families, +42,256 patterns in total. They check the actual ranks, matching numbers, +common-kernel condition and connected projector action. All-vector orbit +checks also run when n<=9. Four smaller families are independently checked +by raw factor enumeration. At (k,nu,n)=(4,0,5), the full pool contains six +projectors; the extra member is retained and checked. + +The two-dimensional restriction census checks all 36 ordered pairs and +216 ordered triples; all 168 triples with idempotent sum have an invariant +line. The one-dimensional exception is checked with two pool algorithms. +All 126 one-per-edge choices for k=nu through six are checked. Wrong-parity +links and idempotent links with a singular fresh pairing are rejected for +the stated reasons. See [VALIDATION.md](VALIDATION.md). + +## Task and overlap + +Base: canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority +revision 8. The contextual card is `bit-helper-contract`, changed to the +remaining local image-capacity question. The selected binding-only check +passes and identifies the catalogue's historical context. It is not a +selected scientific replay. + +The [claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19710038) +states the proof target and stop rule. The refresh on 2026-11-18 searched +1,006 open PRs and 7,650 Discussion records with complete pagination. +Reference intake and the complete 6,175-record closed cache were also +checked. The related sources are the matching upper bound, the odd +classification, and Nick Petalas's earlier one-edge upper bound. The last +source explicitly leaves its four-dimensional attainment open. +No separate even-difference classification was found. Sparse local notes, +unpublished work and semantic search limits prevent a novelty guarantee. + +Final source intake also found unpaidmoon's +[PR #7094](https://github.com/CrocSwap/integer-mult-bounds/pull/7094), which +already attains (4,0,5) with a different five-member complete pool. Its +proof was read and its literal pool is checked separately. That instance +and the prior matching bound already give its maximum; no first-attainment +claim is made for the six-member fixture here. The new claim is the general +even-difference theorem. The full source suite was not rerun. + +This is a bounded proof continuation, not an expansion into a native +implementation. It settles the remaining parity class but makes no claim +that a geometric maximum pays for a useful word. + +## Open next questions + +Which other complete pools attain the even maximum? Start with the two-unit +defect in the disjoint relation identity and account for all lifts, including +dependent-image members. The present theorem gives maxima and one family, +not the classification of all maximizers. + +Can the two-link alphabet support a legal paid word that saves rank? First +state the exact integral relation lattice, full ambient endpoint and dirty +state contract. The existing one-bridge obstruction does not automatically +cover two links. No word or complete invoice is supplied. Neither question +is reserved. + +## Credit + +[CREDITS.md](CREDITS.md) links the consumed proofs and adapted code. +The matching theorem, old blocks, odd maxima, fiber lemma and one-edge +upper bound remain predecessor results. Prepared by Ali Romman with +substantial OpenAI Codex assistance. Apache-2.0. No independent human or +proof-kernel review is claimed. diff --git a/research/edge-matching-even-attainment/RESULT.json b/research/edge-matching-even-attainment/RESULT.json new file mode 100644 index 0000000000..d32645c999 --- /dev/null +++ b/research/edge-matching-even-attainment/RESULT.json @@ -0,0 +1,1698 @@ +{ + "attaining": { + "families": [ + { + "t": 0, + "r": 1, + "k": 4, + "nu": 0, + "image": 5, + "width": 5, + "pool_size": 6, + "selected": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 12, + 20 + ], + [ + 20, + 12 + ] + ], + "extra_members": [ + [ + 28, + 28 + ] + ], + "pool_sha256": "104a50de6d9f70c7e5134735a225438b2dbefbaba9df55d1f7f5b6396473cb65", + "raw_pool_checked": true, + "all_vector_orbits": true + }, + { + "t": 0, + "r": 2, + "k": 6, + "nu": 0, + "image": 8, + "width": 8, + "pool_size": 8, + "selected": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 100, + 100 + ], + [ + 164, + 164 + ] + ], + "extra_members": [], + "pool_sha256": "8b98b7bb9e0cc83b2121b3a9d51cca38eac2f9820ae80665f68cc82fdb9e7aa5", + "raw_pool_checked": false, + "all_vector_orbits": true + }, + { + "t": 0, + "r": 3, + "k": 8, + "nu": 0, + "image": 11, + "width": 11, + "pool_size": 11, + "selected": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 804, + 1316 + ], + [ + 1316, + 804 + ] + ], + "extra_members": [], + "pool_sha256": "ddfa878de65cd9e54c00e3984a578c0f7e69777e5b120e418b3990338e74ce6a", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 0, + "r": 4, + "k": 10, + "nu": 0, + "image": 14, + "width": 14, + "pool_size": 14, + "selected": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 6436, + 6436 + ], + [ + 10532, + 10532 + ] + ], + "extra_members": [], + "pool_sha256": "e6e7297b5bd7f3f95a9b9210882c5f87994473f25b994c0dbd688b940e81cf19", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 1, + "r": 0, + "k": 3, + "nu": 1, + "image": 4, + "width": 4, + "pool_size": 4, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ], + [ + 10, + 9 + ] + ], + "extra_members": [], + "pool_sha256": "f899780f38661ce83f9f71390cca3f040f82bca5904d39adcf7cb5cf67f6d66a", + "raw_pool_checked": true, + "all_vector_orbits": true + }, + { + "t": 1, + "r": 1, + "k": 5, + "nu": 1, + "image": 7, + "width": 7, + "pool_size": 7, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 50, + 81 + ], + [ + 82, + 49 + ] + ], + "extra_members": [], + "pool_sha256": "d9b3ab36cb96670af4a1d1d39c1ade2daa55f0290a7d873bc3e6cbd0349a75e7", + "raw_pool_checked": true, + "all_vector_orbits": true + }, + { + "t": 1, + "r": 2, + "k": 7, + "nu": 1, + "image": 10, + "width": 10, + "pool_size": 10, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 402, + 401 + ], + [ + 658, + 657 + ] + ], + "extra_members": [], + "pool_sha256": "26c667bd74eb1fc9f0859024145ae5cd57547e293645e123cb848043a07b7a41", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 1, + "r": 3, + "k": 9, + "nu": 1, + "image": 13, + "width": 13, + "pool_size": 13, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 3218, + 5265 + ], + [ + 5266, + 3217 + ] + ], + "extra_members": [], + "pool_sha256": "04260f02852a3bd15b15bc38d455a61896df57fe89f8592301c69e900f056568", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 1, + "r": 4, + "k": 11, + "nu": 1, + "image": 16, + "width": 16, + "pool_size": 16, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 25746, + 25745 + ], + [ + 42130, + 42129 + ] + ], + "extra_members": [], + "pool_sha256": "de05095da78ad9e4faec4c447845dd90e3bd7ba17c7371471d3fb5dfa56b324d", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 2, + "r": 0, + "k": 4, + "nu": 2, + "image": 6, + "width": 6, + "pool_size": 6, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ], + [ + 42, + 37 + ] + ], + "extra_members": [], + "pool_sha256": "9a2c755cf2a4539a72a21e760ad405426db218686b661379196ab348d5d0b91a", + "raw_pool_checked": true, + "all_vector_orbits": true + }, + { + "t": 2, + "r": 1, + "k": 6, + "nu": 2, + "image": 9, + "width": 9, + "pool_size": 9, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 202, + 325 + ], + [ + 330, + 197 + ] + ], + "extra_members": [], + "pool_sha256": "8853be7ef139b012e64bad55d704c38ceec5c7a932335c3d958dc4f76834e71c", + "raw_pool_checked": false, + "all_vector_orbits": true + }, + { + "t": 2, + "r": 2, + "k": 8, + "nu": 2, + "image": 12, + "width": 12, + "pool_size": 12, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 1610, + 1605 + ], + [ + 2634, + 2629 + ] + ], + "extra_members": [], + "pool_sha256": "784534ea57146d49d3c0067053821109b4d75d6296207ea32cd312deffb76c2d", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 2, + "r": 3, + "k": 10, + "nu": 2, + "image": 15, + "width": 15, + "pool_size": 15, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 12874, + 21061 + ], + [ + 21066, + 12869 + ] + ], + "extra_members": [], + "pool_sha256": "7cd80f4cb93e2b8cb3be08dbb9831b74120eb973ed12fc4548f60ebd0898f53c", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 2, + "r": 4, + "k": 12, + "nu": 2, + "image": 18, + "width": 18, + "pool_size": 18, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 49152, + 40960 + ], + [ + 40960, + 49152 + ], + [ + 57344, + 57344 + ], + [ + 102986, + 102981 + ], + [ + 168522, + 168517 + ] + ], + "extra_members": [], + "pool_sha256": "9c925b76bac286a0e78df2e768acac95c8569ac9dbf73b9c479d522969ceec96", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 3, + "r": 0, + "k": 5, + "nu": 3, + "image": 8, + "width": 8, + "pool_size": 8, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 85 + ], + [ + 170, + 149 + ] + ], + "extra_members": [], + "pool_sha256": "ec82ec87a3217792e3eb31319ceab23f96f3031be876fc0eda1ec0fed3c97523", + "raw_pool_checked": false, + "all_vector_orbits": true + }, + { + "t": 3, + "r": 1, + "k": 7, + "nu": 3, + "image": 11, + "width": 11, + "pool_size": 11, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 810, + 1301 + ], + [ + 1322, + 789 + ] + ], + "extra_members": [], + "pool_sha256": "ebcbbbe851863b3d41fd0a947ffecd3319c0c8c16145caa20a0d4e5335b34f8c", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 3, + "r": 2, + "k": 9, + "nu": 3, + "image": 14, + "width": 14, + "pool_size": 14, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 6442, + 6421 + ], + [ + 10538, + 10517 + ] + ], + "extra_members": [], + "pool_sha256": "584e265cd45e4eb701fb7a97ffbb2d4ce6748064c796158072cb4511856d1d1d", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 3, + "r": 3, + "k": 11, + "nu": 3, + "image": 17, + "width": 17, + "pool_size": 17, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 51498, + 84245 + ], + [ + 84266, + 51477 + ] + ], + "extra_members": [], + "pool_sha256": "db2dc436208528024c2da686d37b28e86a315825c05b05fa3de1a87065f0b4e8", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 3, + "r": 4, + "k": 13, + "nu": 3, + "image": 20, + "width": 20, + "pool_size": 20, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 196608, + 163840 + ], + [ + 163840, + 196608 + ], + [ + 229376, + 229376 + ], + [ + 411946, + 411925 + ], + [ + 674090, + 674069 + ] + ], + "extra_members": [], + "pool_sha256": "c195fc01d3af71f0cb2d629c2c4f0cfa5567c192939677ddaa0022d98be395ff", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 4, + "r": 0, + "k": 6, + "nu": 4, + "image": 10, + "width": 10, + "pool_size": 10, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 426, + 341 + ], + [ + 682, + 597 + ] + ], + "extra_members": [], + "pool_sha256": "00cfb522164c9812dcf5b7468d6b36f9800794cbe0878ae6ea73533987b83b2e", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 4, + "r": 1, + "k": 8, + "nu": 4, + "image": 13, + "width": 13, + "pool_size": 13, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 3242, + 5205 + ], + [ + 5290, + 3157 + ] + ], + "extra_members": [], + "pool_sha256": "116e52c21ad753100b3d31caf164502e80243450ded588edcd7c55c24ce2c622", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 4, + "r": 2, + "k": 10, + "nu": 4, + "image": 16, + "width": 16, + "pool_size": 16, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 25770, + 25685 + ], + [ + 42154, + 42069 + ] + ], + "extra_members": [], + "pool_sha256": "9e44336fcd2094d0d7ead894c18598dc258445e703602137d47f3812572bbf94", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 4, + "r": 3, + "k": 12, + "nu": 4, + "image": 19, + "width": 19, + "pool_size": 19, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 98304, + 81920 + ], + [ + 81920, + 98304 + ], + [ + 114688, + 114688 + ], + [ + 205994, + 336981 + ], + [ + 337066, + 205909 + ] + ], + "extra_members": [], + "pool_sha256": "817b613183b3272281114ac05c02a33801ceb94a9fa26ae6e8adf7d6e26e08bd", + "raw_pool_checked": false, + "all_vector_orbits": false + }, + { + "t": 4, + "r": 4, + "k": 14, + "nu": 4, + "image": 22, + "width": 22, + "pool_size": 22, + "selected": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 98304, + 81920 + ], + [ + 81920, + 98304 + ], + [ + 114688, + 114688 + ], + [ + 786432, + 655360 + ], + [ + 655360, + 786432 + ], + [ + 917504, + 917504 + ], + [ + 1647786, + 1647701 + ], + [ + 2696362, + 2696277 + ] + ], + "extra_members": [], + "pool_sha256": "b32d9747f5f7f3659998a0255a5ae24259f0b048cd4b32312ab4846c131b151a", + "raw_pool_checked": false, + "all_vector_orbits": false + } + ], + "nonzero_patterns_lifted": 42256, + "raw_factor_pairs": 21284 + }, + "small_exception": { + "restriction_censuses": [ + { + "size": 2, + "visited": 36, + "eligible": 36, + "invariant_line_counts": { + "1": 16, + "2": 12, + "3": 8 + } + }, + { + "size": 3, + "visited": 216, + "eligible": 168, + "invariant_line_counts": { + "1": 64, + "2": 56, + "3": 48 + } + } + ], + "certificate_sha256": "e7cfb6823a384b1b6a6eba40643cbe3134005f4ccdb5f478531187c5bd5f577f", + "maximum": 1, + "witness": [ + [ + 7, + 1 + ], + [ + 7, + 2 + ] + ] + }, + "zero_difference": [ + { + "k": 1, + "nu": 1, + "complete_pool_size": 2, + "one_per_edge_subcollections": 2 + }, + { + "k": 2, + "nu": 2, + "complete_pool_size": 4, + "one_per_edge_subcollections": 4 + }, + { + "k": 3, + "nu": 3, + "complete_pool_size": 6, + "one_per_edge_subcollections": 8 + }, + { + "k": 4, + "nu": 4, + "complete_pool_size": 8, + "one_per_edge_subcollections": 16 + }, + { + "k": 5, + "nu": 5, + "complete_pool_size": 10, + "one_per_edge_subcollections": 32 + }, + { + "k": 6, + "nu": 6, + "complete_pool_size": 12, + "one_per_edge_subcollections": 64 + } + ], + "controls": [ + { + "t": 1, + "r": 0, + "wrong_parity_rejects": 2, + "singular_pairing_common_kernel": 12 + }, + { + "t": 0, + "r": 1, + "wrong_parity_rejects": 2, + "singular_pairing_common_kernel": 8 + }, + { + "t": 0, + "r": 2, + "wrong_parity_rejects": 2, + "singular_pairing_common_kernel": 192 + }, + { + "t": 1, + "r": 1, + "wrong_parity_rejects": 2, + "singular_pairing_common_kernel": 32 + } + ], + "predecessor_comparison": { + "prior_pr": 7094, + "k": 4, + "nu": 0, + "image": 5, + "pool_size": 5, + "selected": [ + [ + 5, + 6 + ], + [ + 6, + 5 + ], + [ + 7, + 7 + ], + [ + 12, + 11 + ], + [ + 29, + 18 + ] + ], + "patterns_lifted": 15, + "raw_factor_pairs": 961, + "scope": "Prior attained instance; the new family has a different six-member pool." + }, + "scope": "Sharp positive-even k-nu image maximum, plus the zero-difference existence boundary." +} diff --git a/research/edge-matching-even-attainment/SOURCES.json b/research/edge-matching-even-attainment/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/edge-matching-even-attainment/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-matching-even-attainment/TASK.json b/research/edge-matching-even-attainment/TASK.json new file mode 100644 index 0000000000..1c2b1860b1 --- /dev/null +++ b/research/edge-matching-even-attainment/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-helper-contract", + "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/g20-helper-split/README.md", + "research/g20-conjugation-admission/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. 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": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "G20", + "helper split", + "5679", + "5708", + "independent target" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the sharp irreducible image maximum for every positive even k-nu, its exceptional small case and the zero-difference existence boundary.", + "scope_change_reason": "The source proof leaves the even-difference maximum open. Two fresh links can change its attainment without a new word search.", + "bottleneck_link": "It settles a missing operator-capacity bound and construction; no legal paid word or native invoice follows.", + "budget_minutes": 60, + "stop_rule": "Stop after the all-width proof, complete attaining pools, small exception and boundary controls. Native and paid obligations stay open.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; complete pattern lifts, independent raw pools, small restriction census and parity/kernel controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance. Binary primitives and old blocks are adapted from the attributed prior checker. No independent human or formal-kernel review is claimed.", + "open_questions": [ + { + "question": "Which other complete pools attain the even maximum?", + "why_it_matters": "A maximum and one family do not classify all alphabets with that capacity.", + "first_step": "Resolve the two-unit defect in the disjoint-relation identity and all complete-pool lifts.", + "blocked_by": "The current proof constructs one family; it does not classify all maximizers." + }, + { + "question": "Can this two-link alphabet support a legal rank-saving paid word?", + "why_it_matters": "Operator capacity does not supply a complete signed bill.", + "first_step": "State the actual integral relation lattice, full endpoint and dirty-state contract.", + "blocked_by": "No legal word, native realization or complete consumer invoice is supplied." + } + ] +} diff --git a/research/edge-matching-even-attainment/VALIDATION.md b/research/edge-matching-even-attainment/VALIDATION.md new file mode 100644 index 0000000000..cbcbc21c16 --- /dev/null +++ b/research/edge-matching-even-attainment/VALIDATION.md @@ -0,0 +1,56 @@ +# Validation record + +Environment: CPython 3.12.16, macOS arm64, standard library only. +Base: `e54523517d0f03e58352e647c403a5af3e525a57`. + +This command passed in normal and optimized isolated modes: + +```sh +python3 -B scripts/research_package.py --package research/edge-matching-even-attainment +``` + +Both direct runs printed `PASS_EDGE_MATCHING_EVEN_ATTAINMENT`. +The registered marker was `PASS_REGISTERED_RESEARCH_PACKAGE` with +`outcome=completed`. AST parsing and `tabnanny` also passed. + +The complete finite domains are: + +- All 24 constructed families at `0<=t,r<=4`, t+r>0. All 42,256 nonzero + patterns are lifted. Each complete pool, rank, matching number, Gram + rank and connected projector action is checked. All-vector orbit + closure also runs for n<=9. The largest fixture has k=14 and n=22. +- All 21,284 nonzero raw factor pairs in the four fixtures of width at + most seven. Their pools equal the pattern-lift pools. Both methods also + check all 49 raw pairs at the exceptional width-three witness. +- All 36 ordered pairs and 216 ordered triples of the six rank-one + idempotents on F2^2. All pairs and the 168 triples with idempotent sum + have a checked common invariant line. A separate orbit method rejects + irreducibility when the joint image has dimension two. +- All 126 choices of one lift per edge for k=nu from one through six, + and each corresponding complete disjoint-edge pool. + +Four wrong-parity fixtures reject both new links as non-idempotent. +Four singular-pairing fixtures retain idempotence and connected action +but have a checked nonzero common kernel. These test why connectivity +alone cannot establish irreducibility. All checks raise exceptions and +remain active under `-O`. + +The five-member pool of PR #7094 is a separate source comparison. Its +15 nonzero patterns, all 961 raw factor pairs at width five, full image, +and every nonzero-vector orbit are checked. Its attained instance is +prior work and is not counted as a new result. + +The upper bound is imported from the pinned matching proof. The written +construction, complete-pool argument, small exception and zero-difference +argument cover every finite ambient width. Finite checks corroborate them; +they do not enumerate all embeddings or all maximizing alphabets. + +The selected binding-only check passed. No complete predecessor suite, +selected cold replay, native or physical replay, Lean, Docker, independent +human review or proof-kernel check was run. No paid word, supplier admission, +complete multiplication theorem or new kappa is claimed. All five selected +assumptions remain. + +Commit-byte, source-history, export, sealed replay and publication checks +are recorded separately in the PR description. Hosted CI is reported +separately and does not replace the local scientific evidence. diff --git a/research/edge-matching-even-attainment/VERIFY.json b/research/edge-matching-even-attainment/VERIFY.json new file mode 100644 index 0000000000..d36f53f2bd --- /dev/null +++ b/research/edge-matching-even-attainment/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": "Check every pattern in 24 attaining families, raw small pools, all two-dimensional pair/triple restrictions, zero-difference subcollections and parity/common-kernel controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check every pattern in 24 attaining families, raw small pools, all two-dimensional pair/triple restrictions, zero-difference subcollections and parity/common-kernel controls." + } + ] +} diff --git a/research/edge-matching-even-attainment/verify.py b/research/edge-matching-even-attainment/verify.py new file mode 100644 index 0000000000..2e46e9b9a8 --- /dev/null +++ b/research/edge-matching-even-attainment/verify.py @@ -0,0 +1,338 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Check the sharp even-difference constructions and their small exception. + +Binary primitives and the disjoint core are adapted from PR7703 by +Ali Romman with substantial OpenAI Codex assistance. See CREDITS.md. +""" +from collections import Counter +from hashlib import sha256 +import itertools +import json +from pathlib import Path +import sys + +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 edges(pattern_basis, width): + return sorted({tuple(sorted(divmod(p.bit_length() - 1, width))) + for p in span(pattern_basis) if p.bit_count() == 1}) + + +def matching(edge_list): + best = () + def visit(i, used, chosen): + nonlocal best + if len(chosen) + len(edge_list) - i <= len(best): + return + if i == len(edge_list): + best = chosen + return + a, b = edge_list[i] + mask = (1 << a) | (1 << b) + if not used & mask: + visit(i + 1, used | mask, chosen + ((a, b),)) + visit(i + 1, used, chosen) + visit(0, 0, ()) + return best + + +def core(t, r): + pairs = [] + offset = 0 + for _ in range(t): + pairs += [(1 << offset, 3 << offset), (3 << offset, 2 << offset)] + offset += 2 + for _ in range(r): + pairs += [(6 << offset, 5 << offset), (5 << offset, 6 << offset), + (7 << offset, 7 << offset)] + offset += 3 + hx = hy = 0 + for x, y in pairs: + hx ^= x + hy ^= y + return pairs, hx, hy, offset + + +def family(t, r, mode=None): + require(t + r > 0, 'the old core must be nonempty') + old, hx, hy, m = core(t, r) + f, g = 1 << m, 2 << m + swapped = r % 2 if mode is None else mode + links = [(hx | f, hy | (g if swapped else f)), + (hx | g, hy | (f if swapped else g))] + return old + links, m + 2 + + +def graph_connected(pairs): + for start in range(len(pairs)): + seen = {start} + while True: + expanded = seen | {j for i in seen for j, (_, y) in enumerate(pairs) + if parity(y & pairs[i][0])} + if expanded == seen: + break + seen = expanded + if len(seen) != len(pairs): + return False + return True + + +def action_rows(pairs): + return [sum(parity(y & x) << j for j, (x, _) in enumerate(pairs)) + for _, y in pairs] + + +def raw_pool(hb, width): + values = set(span(hb)) - {0} + return sorted((x, y) for x in range(1, 1 << width) + for y in range(1, 1 << width) + if parity(x & y) and off(outer(x, y, width), width) in values) + + +def attaining_families(): + receipts = [] + total_patterns = raw_pairs = 0 + for t in range(5): + for r in range(5): + if t + r == 0: + continue + selected, width = family(t, r) + require(all(parity(x & y) for x, y in selected), 'link idempotence') + ps = patterns(selected, width) + require(0 not in ps, 'coordinate projector entered') + hb = basis(ps) + k, n = t + 2 * r + 2, 2 * t + 3 * r + 2 + require(len(hb) == k and len(basis(x for x, _ in selected)) == n, + 'pattern or image dimension') + units = edges(hb, width) + require(len(units) == len(matching(units)) == t, 'matching number') + require(2 * n == 3 * k + t - 2, 'integral upper bound is not attained') + complete = pool(hb, width) + expected = list(selected) + if (t, r) == (0, 1): + expected.append((28, 28)) + require(complete == sorted(expected), 'complete pool differs') + require(len(basis(action_rows(selected))) == n, 'common covector kernel') + require(graph_connected(selected), 'projector action is not connected') + require(len(basis(x for x, _ in complete)) == width, 'full ambient image') + if n <= 9: + require(orbit_irreducible(selected) and orbit_irreducible(complete), + 'all-vector orbit check') + if width <= 7: + require(raw_pool(hb, width) == complete, 'raw and pattern-lift pools differ') + raw_pairs += ((1 << width) - 1) ** 2 + digest = sha256(json.dumps(complete, separators=(',', ':')).encode()).hexdigest() + total_patterns += (1 << k) - 1 + receipts.append({'t': t, 'r': r, 'k': k, 'nu': t, 'image': n, + 'width': width, 'pool_size': len(complete), + 'selected': selected, 'extra_members': sorted(set(complete) - set(selected)), + 'pool_sha256': digest, 'raw_pool_checked': width <= 7, + 'all_vector_orbits': n <= 9}) + return {'families': receipts, 'nonzero_patterns_lifted': total_patterns, + 'raw_factor_pairs': raw_pairs} + + +def apply_matrix(matrix, vector, width): + return sum(parity(((matrix >> (i * width)) & ((1 << width) - 1)) & vector) << i + for i in range(width)) + + +def small_exception(): + raw = [(x, y) for x in range(1, 4) for y in range(1, 4) if parity(x & y)] + require(len(raw) == 6, 'two-dimensional rank-one alphabet') + matrices = [outer(x, y, 2) for x, y in raw] + total = 0 + for matrix in matrices: + total ^= matrix + require(total == 9, 'sum of all six projectors is not I') + receipts = [] + certificates = [] + for size in (2, 3): + visits = eligible = 0 + common_lines = Counter() + for selected in itertools.product(raw, repeat=size): + visits += 1 + if size == 3: + summed = 0 + for x, y in selected: + summed ^= outer(x, y, 2) + if any(apply_matrix(summed, apply_matrix(summed, v, 2), 2) + != apply_matrix(summed, v, 2) for v in (1, 2)): + continue + eligible += 1 + invariant_line = next((v for v in (1, 2, 3) + if all((x if parity(y & v) else 0) in (0, v) + for x, y in selected)), None) + require(invariant_line is not None, 'small irreducible counterexample') + if len(basis(x for x, _ in selected)) == 2: + require(not orbit_irreducible(selected), 'independent orbit check') + common_lines[invariant_line] += 1 + certificates.append((selected, invariant_line)) + receipts.append({'size': size, 'visited': visits, 'eligible': eligible, + 'invariant_line_counts': dict(sorted(common_lines.items()))}) + require([r['eligible'] for r in receipts] == [36, 168], 'restriction census counts') + witness = [(7, 1), (7, 2)] + hb = basis(patterns(witness, 3)) + require(len(hb) == 2 and not edges(hb, 3), 'exception witness parameters') + require(pool(hb, 3) == raw_pool(hb, 3) == witness, 'exception complete pool') + require(len(basis(x for x, _ in witness)) == 1 and orbit_irreducible(witness), + 'exception does not attain one') + return {'restriction_censuses': receipts, + 'certificate_sha256': sha256(json.dumps(certificates, separators=(',', ':')).encode()).hexdigest(), + 'maximum': 1, 'witness': witness} + + +def zero_difference(): + receipts = [] + for k in range(1, 7): + pairs, _, _, width = core(k, 0) + hb = basis(patterns(pairs, width)) + require(len(hb) == k and len(matching(edges(hb, width))) == k, 'zero-difference parameters') + require(pool(hb, width) == sorted(pairs), 'zero-difference complete pool') + for mask in range(1 << k): + one_per_pair = [pairs[2 * i + ((mask >> i) & 1)] for i in range(k)] + require(orbit_irreducible(one_per_pair) == (k == 1), 'disjoint block irreducibility') + require(not orbit_irreducible(pairs), 'complete disjoint-edge pool is reducible') + receipts.append({'k': k, 'nu': k, 'complete_pool_size': 2 * k, + 'one_per_edge_subcollections': 1 << k}) + return receipts + + +def controls(): + receipts = [] + for t, r in ((1, 0), (0, 1), (0, 2), (1, 1)): + bad, width = family(t, r, 1 - r % 2) + require(all(not parity(x & y) for x, y in bad[-2:]), 'wrong parity links were idempotent') + good, _ = family(t, r) + old, hx, hy, m = core(t, r) + fresh_covector = 0 if r % 2 else 3 << m + broken = old + [(hx | (1 << m), hy | fresh_covector), + (hx | (2 << m), hy | fresh_covector)] + require(all(parity(x & y) for x, y in broken), 'singular control is not idempotent') + common = (1 if r % 2 else 3) << m + require(all(not parity(y & common) for _, y in broken), 'singular fresh pairing lost its kernel') + require(graph_connected(broken), 'singular control lost its connected action') + require(not orbit_irreducible(broken) if width <= 9 else + len(basis(action_rows(broken))) < len(broken), 'singular pairing was accepted') + require(graph_connected(good), 'positive control lost connectivity') + receipts.append({'t': t, 'r': r, 'wrong_parity_rejects': 2, + 'singular_pairing_common_kernel': common}) + return receipts + + +def predecessor_comparison(): + selected = [(5, 6), (6, 5), (7, 7), (12, 11), (29, 18)] + hb = basis(patterns(selected, 5)) + require(all(parity(x & y) for x, y in selected), 'PR7094 idempotence') + require(len(hb) == 4 and not edges(hb, 5), 'PR7094 parameters') + require(pool(hb, 5) == raw_pool(hb, 5) == sorted(selected), 'PR7094 complete pool') + require(len(basis(x for x, _ in selected)) == 5 and orbit_irreducible(selected), + 'PR7094 joint image or action') + return {'prior_pr': 7094, 'k': 4, 'nu': 0, 'image': 5, 'pool_size': 5, + 'selected': selected, 'patterns_lifted': 15, 'raw_factor_pairs': 961, + 'scope': 'Prior attained instance; the new family has a different six-member pool.'} + + +def result(): + return {'attaining': attaining_families(), 'small_exception': small_exception(), + 'zero_difference': zero_difference(), 'controls': controls(), + 'predecessor_comparison': predecessor_comparison(), + 'scope': 'Sharp positive-even k-nu image maximum, plus the zero-difference existence boundary.'} + + +def main(): + actual = json.loads(json.dumps(result())) + if sys.argv[1:] == ['--emit']: + print(json.dumps(actual, indent=2)) + return + require(not sys.argv[1:], 'unknown arguments') + require(actual == json.loads(Path(__file__).with_name('RESULT.json').read_text()), 'receipt differs') + print('PASS_EDGE_MATCHING_EVEN_ATTAINMENT') + + +if __name__ == '__main__': + main()