From a581f0a11bf63fcafe5a0eec555a103546cc4262 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 11 Nov 2026 10:43:11 +0000 Subject: [PATCH 1/2] Prove two rank-q maps in one gap can fill every helped core block. The complementary copies of the rank-q witness do not reach rank 2q. With invertible off-diagonal blocks an explicit pair makes each helped block the identity, so the uniform q(g-1) lift does not survive. No kappa change. Co-authored-by: unpaidmoon --- research/two-rank-q-same-gap/PROOF.md | 342 +++++++++++++ research/two-rank-q-same-gap/README.md | 107 ++++ research/two-rank-q-same-gap/SOURCES.json | 18 + research/two-rank-q-same-gap/TASK.json | 90 ++++ research/two-rank-q-same-gap/VERIFY.json | 31 ++ research/two-rank-q-same-gap/verify.py | 588 ++++++++++++++++++++++ 6 files changed, 1176 insertions(+) create mode 100644 research/two-rank-q-same-gap/PROOF.md create mode 100644 research/two-rank-q-same-gap/README.md create mode 100644 research/two-rank-q-same-gap/SOURCES.json create mode 100644 research/two-rank-q-same-gap/TASK.json create mode 100644 research/two-rank-q-same-gap/VERIFY.json create mode 100644 research/two-rank-q-same-gap/verify.py diff --git a/research/two-rank-q-same-gap/PROOF.md b/research/two-rank-q-same-gap/PROOF.md new file mode 100644 index 0000000000..818d678a9f --- /dev/null +++ b/research/two-rank-q-same-gap/PROOF.md @@ -0,0 +1,342 @@ +# Two rank-q maps in one internal gap + +This is a proof in characteristic two under the hypotheses below. It is not a +search over words and not a heuristic. The exhaustive check at `q = 1` is a +finite census of one 8-dimensional matrix domain. It supports the proof and +does not replace it. + +No new kappa is claimed. The selected frontier stays +`363005817/100000000000 = 0.00363005817`. + +## 1. Question + +Use the paired-star one-gap schedule of open PR #7025, with the three core +blocks named in open PR #7053. The core and each leaf have dimension `d = 2q`. +Stage `t` has complementary half projectors `P_f` and `P_s`. In the +eigenbasis of open PR #7025 their off-diagonal blocks are arbitrary `q` by +`q` matrices `B12` and `B21`. A thin map is `I + e Z` with `e^2 = 0`. The +single internal gap may contain several thin maps. Their sum is what enters +the coefficient, but the rank bound below is a bound on each map, not on the +sum. + +Write `N`, `P` and `O` for the three helped core blocks of a matrix `Z`: + +- `N = pi_core P_f Z` on leaf `t + 1`, when that leaf exists, +- `P = pi_core P_s Z` on leaf `t - 1`, when that leaf exists, +- `O = pi_core (P_f Z P_f + P_s Z P_s)` on leaf `t`. + +Open PR #7053 proved that one matrix of rank at most `q` with +`P_s Z P_f = 0` has all three ranks at most `q`, and therefore external rank +at least `q(g - 1)`. Its first open question is the one answered here. + +**Question.** Do there exist two matrices `Z_1`, `Z_2`, each of rank at most +`q` and each satisfying `P_s Z_i P_f = 0`, such that every helped block of +`Z_1 + Z_2` has rank `2q`? + +The first step requested by that question is to add two copies of the +rank-`q` witness on complementary core coordinates. Section 3 records that +this step does not reach rank `2q`. That failure is not an unrestricted +nonexistence claim. Section 4 gives an explicit pair that does reach rank +`2q`, for invertible off-diagonal blocks. Section 5 records what that does +to the external count: the uniform lift to `q(g - 1)` does not survive, and +`q(g - 3)` still applies. + +## 2. The projector image caps the outside blocks + +Order the stage coordinates as `(c+, c-, s+, s-)`, each of dimension `q`. +For `P_+` the core output of a stage vector is + +```text +c+ = z_c+ + B12 z_c- + B12 z_s-, +c- = B21 z_c+ + B21 z_s+. +``` + +Thus `c-` lies in `im B21`. Conversely, every pair `(t+, B21 u)` occurs: +set `z_c+ = t+`, `z_s+ = u + t+`, and `z_c- = z_s- = 0`. In characteristic +two the minus coordinate is `B21 u` and the plus coordinate is `t+`. +Therefore + +```text +im(pi_core P_+) = C+ ⊕ im(B21), +rank(pi_core P_+) = q + rank(B21). +``` + +The same expansion for `P_-` gives + +```text +im(pi_core P_-) = im(B12) ⊕ C-, +rank(pi_core P_-) = q + rank(B12). +``` + +The outside blocks factor through these maps. For any matrices in the gap, +and either half order, + +```text +rank(N) <= q + rank(B21 of P_f's sign), +rank(P) <= q + rank(B12 of P_s's sign). +``` + +In particular, if `P_f = P_+` and `rank(B21) < q`, then no choice and no +number of internal matrices can make the next-leaf block have rank `2q`. +The symmetric statement holds for `B12` and the previous-leaf block. Both +caps are statements about the image of a projector. They do not use +`P_s Z P_f = 0`. + +## 3. Complementary copies of the rank-q witness + +The witness of open PR #7053 uses `B12 = B21 = 0` and `P_f = P_+`. For each +index `i` it writes `e_{c+,i} + e_{c-,i}` from the three sources +`n+,i`, `p-,i` and `s-,i`. Each of its three blocks has rank `q`, and +`P_- W P_+ = 0`. + +Two copies on complementary coordinates do not reach rank `2q`. + +- Move the three sources to the other leaf half, `n-,i`, `p+,i` and + `s+,i`, and keep the same diagonal image. Call this copy `W'`. With + `B = 0`, `im P_+` is the set of stage vectors with `c- = s- = 0`. The + functional of `W'` reads `s+`, which does not vanish there, and the image + `e_{c+} + e_{c-}` is not in `im P_+`. So `P_- W' P_+` is not zero. The sum + `W + W'` fails the same equation. Its next-leaf and previous-leaf blocks + each have rank `q`, not `2q`: both copies write the diagonal vector, and + `pi_core P_+` keeps only the plus half. +- Split the image onto the two core halves. The plus copy writes only + `e_{c+,i}` from the original sources and does satisfy the square + equation. The minus copy writes only `e_{c-,i}` from the shifted sources + and does not. The sum of the two splits still has every helped block of + rank less than `2q`. + +Section 2 already forbids every repair that keeps `B12 = B21 = 0`. The +next-leaf block of an arbitrary sum then has rank at most `q`. Adding +copies, complementary or otherwise, cannot make every helped block rank +`2q` for this choice of halves. + +## 4. An explicit pair whose blocks are the identity + +The obstruction in section 2 disappears when `B12` and `B21` are invertible. +Take both equal to `I_q`, over an arbitrary field of characteristic two. +The same formulas with scalar `1` give the `q = 1` pair, and the matrices +below are the direct sum of that pair across the `q` indices. Because +`I_q` does not mix indices, there are no cross terms. It is therefore +enough to check one index and then reassemble. + +Write `e_sigma` for the corresponding basis vector of that index. All +additions are characteristic two. + +### Plus half applied first + +```text +Z1 = e_{c+} (e_{c-} + e_{s-} + e_{p-} + e_{n+})^T, +Z2 = (e_{c+} + e_{c-}) (e_{c+} + e_{c-} + e_{s+} + e_{p+} + e_{n+} + e_{n-})^T. +``` + +A vector of `im P_+` has stage coordinates `(x, y, x + y, y)`. The stage +part of the functional of `Z1` is `y + y = 0`. The stage part of the +functional of `Z2` is `x + y + (x + y) = 0`. Both maps kill `im P_+`, so +`P_- Z_i P_+ = 0`. + +The core output of `P_+` on these images is + +```text +pi_core P_+ e_{c+} = (1, 1), +pi_core P_+ (e_{c+} + e_{c-}) = (0, 1). +``` + +Leaf `t + 1` has coordinates `(n+, n-)`. The sum sends `n+` to +`(1, 1) + (0, 1) = (1, 0)` and `n-` to `(0, 1)`. That block is `I_2`. + +The core output of `P_-` is + +```text +pi_core P_- e_{c+} = (0, 1), +pi_core P_- (e_{c+} + e_{c-}) = (1, 0). +``` + +Leaf `t - 1` has coordinates `(p+, p-)`. The sum sends `p+` through `Z2` +to `(1, 0)` and `p-` through `Z1` to `(0, 1)`. That block is `I_2`. + +For the own leaf, both maps kill `im P_+`, so +`P_+ Z_i P_+ = 0` and the degree-1 block is `pi_core P_- Z_i P_-`. On the +own-leaf basis, + +```text +P_- e_{s+} = e_{c-} + e_{s-}, +P_- e_{s-} = e_{c+} + e_{s+} + e_{s-}. +``` + +`Z1` reads `c-` and `s-`, so it kills the first of these vectors and sends +the second to `e_{c+}`. Then `pi_core P_- e_{c+} = (0, 1)`. `Z2` reads +`c-` but not `s-`, so it sends the first vector to `e_{c+} + e_{c-}` and +kills the second. Then `pi_core P_-` of that image is `(1, 0)`. The own +block is `I_2`. + +### Minus half applied first + +```text +Z1 = e_{c+} (e_{c+} + e_{s+} + e_{p+} + e_{n-})^T, +Z2 = (e_{c+} + e_{c-}) (e_{c-} + e_{s+} + e_{s-} + e_{p+} + e_{p-} + e_{n+})^T. +``` + +A vector of `im P_-` has stage coordinates `(x, y, x, x + y)`. Both stage +functionals vanish on it: `x + x = 0`, and `y + x + (x + y) = 0`. Thus +`P_+ Z_i P_- = 0`. The same three expansions as above, with the two +projectors exchanged, give `I_2` on each helped block. The registered +checker multiplies the matrices rather than trusting the exchange. + +### Every q + +Index the direct sum by `i = 0, ..., q - 1`, using `B12 = B21 = I_q`. +Each `Z_j` has rank `q`: the private next-leaf column of index `i` produces +a distinct image vector, and those `q` vectors are independent. The three +blocks of the sum are `I_q` on the plus coordinates and `I_q` on the minus +coordinates, hence `I_{2q}`. Each block has rank `2q`. Each factor has rank +`q`, so the sum has rank `2q` as well: the identity block forces the lower +bound, and the sum of two rank-`q` maps forces the upper bound. + +The same local matrices serve an endpoint stage. Whichever of the three +leaves exist, the corresponding block is still `I_{2q}`. + +One map is not enough. Each factor has rank `q`, and the one-map theorem of +open PR #7053 caps each of its blocks by `q`. The checker records that +these explicit summands meet that cap. + +## 5. The external count + +On a successful word, leaf `j` still requires `A_j + B_j = I_d`, where +`B_j` is the internal block when leaf `j` is helped and is zero otherwise, +and `A_j` is the sum of the external blocks in gaps `j` and `j + 1`. Rank +subadditivity gives + +```text +r_j + r_{j + 1} >= 2q - rank(B_j). +``` + +Open PR #7025 never uses an upper bound on the internal blocks. It drops +the helped leaves and keeps at least `g - 3` leaves of demand `2q`. That +argument still gives + +```text +R_ext >= q(g - 3) +``` + +for every placement, whether or not the two maps of section 4 are used. + +The uniform lift of open PR #7053 is a different count. It needs demand at +least `q` on every helped leaf, which is the one-map cap. Section 4 meets +the leaf equation on each helped leaf by `B_j = I_d` and `A_j = 0`. Those +demands are zero, so that lift does not apply to every placement of two +rank-at-most-`q` maps. + +The parity count with those zero demands is still exact, and it is not +uniformly `q(g - 3)`. + +Let the helped leaves be the existing members of `{t - 1, t, t + 1}`. They +form one consecutive block. The unhelped leaves split into a left run of +length `a` and a right run of length `b`. A leaf in the left run uses only +gaps `0, ..., a`. A leaf in the right run uses only gaps from the first +right leaf onward. Those two gap sets are disjoint, so a feasible tuple is +a cover of each run separately. A path of `m` edges has an edge cover by +`ceil(m / 2)` vertices: select the right endpoint of edges `0, 2, 4, ...`. +The resulting gaps have weight `2q`, and the total external rank is + +```text +2q (ceil(a / 2) + ceil(b / 2)). +``` + +This equals the heavier parity of the demands. The left run is the initial segment `0, ..., a - 1`, so it contributes +`ceil(a / 2)` even leaves and `floor(a / 2)` odd leaves. Write `U_even` and +`U_odd` for the unhelped counts, and write `s` for the first right-hand +leaf. Then `s = t + 2` when `t` is interior, `s = 2` when `t = 0`, and +there is no right run when `t = g - 1`. + +- If `t` is even and interior, then `a = t - 1` is odd and `s` is even. + The left run has `t / 2` even leaves and `t / 2 - 1` odd leaves. The + right run has `ceil(b / 2)` even leaves. Hence `U_even` equals + `t / 2 + ceil(b / 2)` and is strictly larger than `U_odd`. The cover has + the same number of gaps. +- If `t` is odd and interior, then `a = t - 1` is even and `s` is odd. + Each side of the left run has `(t - 1) / 2` leaves, and the right run has + `ceil(b / 2)` odd leaves. Hence `U_odd` equals + `(t - 1) / 2 + ceil(b / 2)` and is at least `U_even`. The cover matches + `U_odd`. A helped block that touches an end is the same arithmetic with + `a = 0` or `b = 0`, in whichever of the two bullets has the parity of `t`. +- If `t = 0` or `t = g - 1`, one run is empty and the other has length + `g - 2`. The cover has `ceil((g - 2) / 2)` gaps, which is the heavier of + the two unhelped counts on an initial or final segment of that length. + +In every case + +```text +ceil(a / 2) + ceil(b / 2) = max(U_even, U_odd). +``` + +The heavier parity sum of the demands is `2q` times that maximum. The lower +bound is the disjoint sum of one parity's leaf inequalities, so the tuple +is sharp for the inequalities. It is not a word. + +The closed form is: + +- if `g` is odd and `t` is even, `R_ext >= q(g - 1)`, and the tuple meets it, +- if `g` is odd and `t` is odd, `R_ext >= q(g - 3)`, and the tuple meets it, +- if `g` is even, `R_ext >= q(g - 2)` for every stage, and the tuple meets it. + +The even-stage bound for odd `g` does not need section 4. An even stage +helps only one even leaf, so the remaining `(g - 1) / 2` even leaves each +demand `2q` and already sum to `q(g - 1)`, for any internal matrices. Full +block rank makes that bound sharp as an inequality. It does not remove it. + +At `g = 31` and `q = 26` the two odd-`g` numbers are `780` and `728`. The +uniform claim "every placement forces external rank `780`" is the lift that +does not survive. The placement-dependent even-stage obligation `780` +remains, and every odd stage is feasible for the inequalities at `728`. + +## 6. The q = 1 census + +The three helped leaves and the core are eight coordinates over `F_2`. +Every rank-1 matrix is uniquely an outer product of two nonzero vectors, so +there are `(2^8 - 1)^2` of them. Rank 0 is the zero matrix. For each of the +four scalar pairs `(B12, B21)` and both half orders, the projector has rank +2. Its image is a plane in the stage and is zero on the other four +coordinates, so `2^2 * 2^4 - 1 = 63` nonzero vectors have stage part in the +image. The annihilator of that plane in the dual of `F_2^8` has +`2^6 - 1 = 63` nonzero functionals. A rank-1 map `x y^T` satisfies +`P_s Z P_f = 0` exactly when the stage part of `x` lies in the image or +`y` kills the image. The admissible count per half is + +```text +63 * 255 + (255 - 63) * 63 = 28161. +``` + +The checker enumerates the whole domain. Under the square equation every +own-leaf block has rank at most 1. The two identity seeds of section 4 sit +in the domain, and for one half the same enumeration agrees entrywise with +dense multiplication. This is a census of that 8-by-8 family. It is not a +census of words and not a proof at `q = 26`. + +## 7. What this does not prove + +- It does not construct a paired-star word, of external rank `728` or of + any other rank. The identity blocks are local. The monomial transport + that carries them to the target is not rebuilt here. +- It does not say that every legal half admits block rank `2q`. Section 2 + forbids it whenever the relevant off-diagonal block is singular. +- It does not say that every pair of rank-at-most-`q` maps has block rank + `2q`. Most pairs do not. The claim is existence. +- It does not replace the one-map theorem of open PR #7053, the dropped-leaf + bound of open PR #7025, or the every-stage theorems of open PRs #7050 and + #7126. +- A failed complementary copy is not nonexistence of a `2q` sum. Section 4 + is the existence proof, and it uses a different half from the witness. +- Native transport, frames, and the selected frontier are untouched. + +## 8. Credit + +The one-gap schedule and the bound `q(g - 3)` are open PR #7025. The three +blocks, the one-map cap, the rank-`q` witness, and the question are open PR +#7053. The even-stage parity count uses only the helped-leaf support proved +there. The paired-star contract and the commuting map-count are from PR +#5747 (Ali Romman), with the predecessor statements in PR #5673, PR #5631, +and PR #5617. Cinna Davis supplied the controller and simplex lineage those +packages retain. Open PR #7005 is the consecutive-halves bound and is not +rerun. Open PR #7126 is the every-stage factor and is not rerun. + +Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0. diff --git a/research/two-rank-q-same-gap/README.md b/research/two-rank-q-same-gap/README.md new file mode 100644 index 0000000000..47739c8571 --- /dev/null +++ b/research/two-rank-q-same-gap/README.md @@ -0,0 +1,107 @@ +# Two rank-q maps in one internal gap + +**No new kappa.** On the paired-star one-gap schedule, two matrices of rank +at most `q` in the same internal gap, each with `P_s Z P_f = 0`, can make +every helped core block equal `I_{2q}`. The selected frontier stays +`363005817/100000000000`. + +The prescribed first step does not. Two copies of the rank-`q` witness of +open PR #7053, placed on complementary leaf halves or on complementary core +directions, do not reach rank `2q` while obeying the square equation. With +`B12 = B21 = 0` the next-leaf block of every internal sum has rank at most +`q`, because it factors through a projector image of dimension `q`. That +negative step is not an unrestricted nonexistence claim. + +The positive pair uses `B12 = B21 = I_q`. Each factor has rank `q`, kills +the image of the first half, and the three blocks of the sum are `I_{2q}` +for both half orders and every `q >= 1`. A helped leaf can therefore meet +`A_j + B_j = I_d` with no external rank. The uniform lift of open PR #7053 +to external rank `q(g - 1)` does not apply to every placement. The +dropped-leaf bound `q(g - 3)` of open PR #7025 still applies. + +With those identity blocks the parity count is sharp for the inequalities, +and it depends on the stage: + +- odd `g`, even stage: external rank at least `q(g - 1)`, +- odd `g`, odd stage: external rank at least `q(g - 3)`, +- even `g`: external rank at least `q(g - 2)` at every stage. + +At `g = 31` and `q = 26` the odd-`g` numbers are **780** and **728**. The +even-stage number `780` holds for any internal matrices, because an even +stage helps only one even leaf. The tuples that meet these counts are +solutions of the gap inequalities, not words. + +This is a proof under those hypotheses. The statement, the case split, and +the limits are in [PROOF.md](PROOF.md). The `q = 1` census is an exhaustive +check of the rank-at-most-1 matrices on eight `F_2` coordinates. It is not +a census of words. + +The question is the first open question of open PR #7053. The every-stage +theorems of open PRs #7050 and #7126, and the second open question of +#7053, are not taken. + +## Evidence + +The argument is a proof in the projector algebra and in elementary linear +rank, over any field of characteristic two. The registered checker also +records four finite checks: + +- the explicit pair at `q` in `{1, 2, 3, 8, 26}`, both half orders, with + the three blocks equal to `I_{2q}`; +- the projector-image cap `q + rank(B21)` on several explicit blocks, + including singular ones; +- the two complementary copies of the rank-`q` witness, which miss rank + `2q`; +- an exhaustive census, over `F_2` at `q = 1`, of every rank-at-most-1 + matrix on the eight coordinates, for every scalar pair `(B12, B21)` and + both half orders. + +The gap tuples are checked for every `g` from `3` through `40` and every +stage. The closed form is proved for every `g >= 3` in +[PROOF.md](PROOF.md). The census is complete for its finite domain. It is +not a proof for general `q`. + +## Reproduce + +Python 3.12, standard library only. From the repository root: + +```sh +python3 -B scripts/research_package.py --package research/two-rank-q-same-gap +``` + +Expected status: `PASS_TWO_RANK_Q_SAME_GAP`, with `blocks=I_2q`, +`odd_stage_external=728` and `even_stage_external=780`. The same command +under `python3 -O -B` is registered. The checks raise `SystemExit`, so +optimized mode does not drop them. + +## Open next questions + +- At an odd stage, can external gaps of total rank `q(g - 3)`, together + with the two maps of [PROOF.md](PROOF.md), meet `A_j + B_j = I_d` on + every leaf at `g = 31`, `q = 26`? The inequality count is sharp at 728, + and no word is constructed. First step: at stage `1`, place the two + maps, set the three helped external blocks to zero, and test the cover + of [PROOF.md](PROOF.md) on the remaining leaves. The monomial transport + is not rebuilt in this package, so a passing rank tuple would still not + be a word. This is not the every-stage question, and it is not the + one-matrix gap tuple of open PR #7053. +- For `0 < rank(B21) < q`, can two rank-at-most-`q` maps attain next-block + rank `q + rank(B21)` and own-block rank `2q` at once? The image cap is + proved for every off-diagonal block, and the extremes `0` and `q` are + attained. First step: at `q = 4`, take `B21` of rank 1 and `B12 = I_4`, + and test whether a sum of two rank-at-most-4 maps meets both ranks while + killing `im P_f`. The identity witness uses `B21 = I_q`, so its + functionals need not kill the smaller image. + +## Credit + +The one-gap schedule and `q(g - 3)` are open PR #7025. The three blocks, +the one-map cap, the rank-`q` witness, and this question are open PR +#7053. The paired-star contract and the commuting map-count are from PR +#5747 (Ali Romman), including PR #5673, PR #5631, and PR #5617. Cinna Davis +supplied the controller and simplex lineage those packages retain. Open PR +#7005 is the consecutive-halves bound. Open PR #7126 is the every-stage +factor. Neither is rerun. + +Prepared by unpaidmoon with substantial Cursor Grok assistance. +Independent human review and a proof-assistant proof are unclaimed. diff --git a/research/two-rank-q-same-gap/SOURCES.json b/research/two-rank-q-same-gap/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/two-rank-q-same-gap/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/two-rank-q-same-gap/TASK.json b/research/two-rank-q-same-gap/TASK.json new file mode 100644 index 0000000000..bbddabb50b --- /dev/null +++ b/research/two-rank-q-same-gap/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "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" + ], + "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 source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "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": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "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": "Two rank-at-most-q matrices in one paired-star internal gap, each with P_s Z P_f = 0: can every helped core block of their sum have rank 2q? Start from two copies of the rank-q witness on complementary coordinates.", + "scope_change_reason": "The catalogue card asks whether a changed query demand or caller removes work. This package does not change a caller or a supplier bill. It answers open question 1 of open PR #7053, a rank question on the one-gap paired-star schedule already in that card's predecessor line (#5747, #7025, #7053).", + "bottleneck_link": "Side result, not a supplier invoice. The selected signed bill and kappa are unchanged. The calculation prices one internal gap of the paired-star schedule and does not claim a paid-profile improvement.", + "budget_minutes": 60, + "stop_rule": "Stop after the complementary-copy test and either an explicit pair whose three blocks have rank 2q or a proof that no such pair exists under the stated square equation. Do not search words, retake the one-map theorem, or move to an every-stage schedule.", + "outcome": "completed", + "evidence": "Proof in PROOF.md over any characteristic-2 field. verify.py checks the identity pair, the singular image cap, the failed complementary copies, the parity tuples, and an exhaustive q=1 census. No new kappa.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance: the matrix search, the proof writeup, and the registered checker.", + "open_questions": [ + { + "question": "At an odd stage, can external gaps of total rank q(g-3), together with the two exhibited maps, meet A_j + B_j = I_d on every leaf at g=31, q=26?", + "why_it_matters": "The inequality system is feasible at 728, which is the #7025 count. A block solution would show that two maps can return the external equations to that count at odd stages. It would still not be a word.", + "first_step": "At stage t=1, place the two maps, set the three helped external blocks to zero, and test the cover in PROOF.md on the remaining leaves.", + "blocked_by": "This package does not rebuild the monomial transport. A passing rank tuple is not a word. This is not the one-matrix gap tuple of #7053 and not the every-stage question." + }, + { + "question": "For 0 < rank(B21) < q, can two rank-at-most-q maps attain next-block rank q+rank(B21) and own-block rank 2q at the same time?", + "why_it_matters": "The image cap is proved for every off-diagonal block. The extremes rank 0 and rank q are attained. Intermediate ranks would price every legal half rather than only the singular and invertible cases.", + "first_step": "At q=4, take B21 of rank 1 and B12 = I_4, and test whether a sum of two rank-at-most-4 maps meets both ranks while killing im P_f.", + "blocked_by": "The identity witness uses B21 = I_q. A singular slot changes im P_f, so those functionals need not remain admissible." + } + ] +} diff --git a/research/two-rank-q-same-gap/VERIFY.json b/research/two-rank-q-same-gap/VERIFY.json new file mode 100644 index 0000000000..c3658f8ad8 --- /dev/null +++ b/research/two-rank-q-same-gap/VERIFY.json @@ -0,0 +1,31 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Identity blocks for both half orders at q in {1,2,3,8,26}, projector-image cap, failed complementary copies of the rank-q witness, parity tuples for g=3..40, and the exhaustive q=1 rank-at-most-1 census. Mutating one column or dropping one map must leave the identity." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same checks as the unoptimized command. Failures raise SystemExit, so optimized mode does not drop them." + } + ] +} diff --git a/research/two-rank-q-same-gap/verify.py b/research/two-rank-q-same-gap/verify.py new file mode 100644 index 0000000000..6ece340ff3 --- /dev/null +++ b/research/two-rank-q-same-gap/verify.py @@ -0,0 +1,588 @@ +#!/usr/bin/env python3 +"""Two rank-at-most-q maps in one paired-star internal gap. + +Proof checks over GF(2), plus one exhaustive q=1 census. Checks raise +SystemExit, so python -O does not drop them. No kappa is computed. +""" + +from __future__ import annotations + +G = 31 +Q = 26 + + +def fail(message): + raise SystemExit(message) + + +def expect_fail(name, fn): + try: + fn() + except SystemExit: + return + fail("control did not fail: " + name) + + +def zeros(rows, cols=None): + width = rows if cols is None else cols + return [[0] * width for _ in range(rows)] + + +def eye(size): + return [[1 if row == col else 0 for col in range(size)] for row in range(size)] + + +def mat_add(left, right): + return [[a ^ b for a, b in zip(row_a, row_b)] for row_a, row_b in zip(left, right)] + + +def mat_mul(left, right): + rows = len(left) + mid = len(right) + cols = len(right[0]) + out = zeros(rows, cols) + for i in range(rows): + for k in range(mid): + if left[i][k]: + row = out[i] + src = right[k] + for j in range(cols): + row[j] ^= src[j] + return out + + +def is_zero(matrix): + return all(entry == 0 for row in matrix for entry in row) + + +def rank_rows(rows): + active = [row[:] for row in rows if any(row)] + if not active: + return 0 + height = len(active) + width = len(active[0]) + rank = 0 + col = 0 + while col < width and rank < height: + pivot = next((row for row in range(rank, height) if active[row][col]), None) + if pivot is None: + col += 1 + continue + active[rank], active[pivot] = active[pivot], active[rank] + for row in range(height): + if row != rank and active[row][col]: + active[row] = [a ^ b for a, b in zip(active[row], active[rank])] + rank += 1 + col += 1 + return rank + + +def block_matrix(q, blocks): + """Place a 4-by-4 array of q-by-q blocks into the stage coordinates.""" + size = 8 * q + matrix = zeros(size) + for block_row in range(4): + for block_col in range(4): + block = blocks[block_row][block_col] + for row in range(q): + for col in range(q): + matrix[block_row * q + row][block_col * q + col] = block[row][col] + return matrix + + +def half(q, plus, b12, b21): + zero = zeros(q) + ident = eye(q) + if plus: + blocks = ( + (ident, b12, zero, b12), + (b21, zero, b21, zero), + (zero, b12, ident, b12), + (b21, zero, b21, zero), + ) + else: + blocks = ( + (zero, b12, zero, b12), + (b21, ident, b21, zero), + (zero, b12, zero, b12), + (b21, zero, b21, ident), + ) + return block_matrix(q, blocks) + + +def scalar_block(q, bit): + return [[bit if row == col else 0 for col in range(q)] for row in range(q)] + + +def projectors(q, b12_bit, b21_bit, plus_first): + b12 = scalar_block(q, b12_bit) + b21 = scalar_block(q, b21_bit) + if plus_first: + return half(q, True, b12, b21), half(q, False, b12, b21) + return half(q, False, b12, b21), half(q, True, b12, b21) + + +def at(q, block, index): + return block * q + index + + +def put(matrix, row, col): + matrix[row][col] ^= 1 + + +def witness_pair(q, plus_first): + """Two rank-q maps. Each kills im P_f. Their three core blocks sum to I.""" + size = 8 * q + first = zeros(size) + second = zeros(size) + for index in range(q): + c_plus = at(q, 0, index) + c_minus = at(q, 1, index) + s_plus = at(q, 2, index) + s_minus = at(q, 3, index) + p_plus = at(q, 4, index) + p_minus = at(q, 5, index) + n_plus = at(q, 6, index) + n_minus = at(q, 7, index) + if plus_first: + for col in (c_minus, s_minus, p_minus, n_plus): + put(first, c_plus, col) + for col in (c_plus, c_minus, s_plus, p_plus, n_plus, n_minus): + put(second, c_plus, col) + put(second, c_minus, col) + else: + for col in (c_plus, s_plus, p_plus, n_minus): + put(first, c_plus, col) + for col in (c_minus, s_plus, s_minus, p_plus, p_minus, n_plus): + put(second, c_plus, col) + put(second, c_minus, col) + return first, second + + +def predecessor_witness(q, complementary_sources): + """The rank-q witness of PR #7053, or the same pattern on the other leaf halves.""" + size = 8 * q + matrix = zeros(size) + for index in range(q): + if complementary_sources: + sources = (at(q, 7, index), at(q, 4, index), at(q, 2, index)) + else: + sources = (at(q, 6, index), at(q, 5, index), at(q, 3, index)) + for source in sources: + put(matrix, at(q, 0, index), source) + put(matrix, at(q, 1, index), source) + return matrix + + +def core_slice(matrix, q, col_start): + return [row[col_start:col_start + 2 * q] for row in matrix[: 2 * q]] + + +def three_blocks(matrix, first, second, q): + nxt = mat_mul(first, matrix) + prev = mat_mul(second, matrix) + pinch = mat_add( + mat_mul(first, mat_mul(matrix, first)), + mat_mul(second, mat_mul(matrix, second)), + ) + return core_slice(nxt, q, 6 * q), core_slice(prev, q, 4 * q), core_slice(pinch, q, 2 * q) + + +def square_clear(matrix, first, second): + return is_zero(mat_mul(second, mat_mul(matrix, first))) + + +def require_identity_pair(q, plus_first): + first, second = projectors(q, 1, 1, plus_first) + if mat_mul(first, first) != first or mat_mul(second, second) != second: + fail("halves are not idempotent") + if not is_zero(mat_mul(first, second)) or not is_zero(mat_mul(second, first)): + fail("halves do not annihilate") + stage = eye(4 * q) + top = [row[: 4 * q] for row in mat_add(first, second)[: 4 * q]] + if top != stage: + fail("halves do not resolve the stage") + left, right = witness_pair(q, plus_first) + for name, matrix in (("first", left), ("second", right)): + if not square_clear(matrix, first, second): + fail(name + " map failed P_s Z P_f = 0") + if rank_rows(matrix) != q: + fail(name + " map does not have rank q") + total = mat_add(left, right) + if not square_clear(total, first, second): + fail("the sum failed P_s Z P_f = 0") + if rank_rows(total) != 2 * q: + fail("the sum does not have rank 2q") + ident = eye(2 * q) + blocks = three_blocks(total, first, second, q) + names = ("next", "previous", "own") + for name, block in zip(names, blocks): + if block != ident: + fail(name + " block is not I_2q") + # One map alone cannot fill a block: each block of each summand has rank q. + for matrix in (left, right): + for block in three_blocks(matrix, first, second, q): + if rank_rows(block) != q: + fail("a single summand block is not rank q") + return left + + +def check_identity_family(): + for q in (1, 2, 3, 8, Q): + for plus_first in (True, False): + require_identity_pair(q, plus_first) + + +def check_direct_sum_shape(): + """Every index of the q-witness is the q=1 witness, with no cross terms.""" + for plus_first in (True, False): + seed_left, seed_right = witness_pair(1, plus_first) + left, right = witness_pair(Q, plus_first) + for matrix, seed in ((left, seed_left), (right, seed_right)): + for index in range(Q): + for block_row in range(8): + for block_col in range(8): + entry = matrix[at(Q, block_row, index)][at(Q, block_col, index)] + if entry != seed[block_row][block_col]: + fail("index slice differs from the q=1 witness") + for row in range(8 * Q): + for col in range(8 * Q): + if (row % Q) != (col % Q) and matrix[row][col]: + fail("witness has a cross term") + + +def check_singular_cap(): + """pi_core P_+ has image dimension q + rank(B21), for several explicit B.""" + q = 4 + samples = ( + (zeros(q), 0), + (eye(q), q), + ([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], 1), + ([[1, 1, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], 3), + ) + for b21, expected in samples: + for b12, _rank in samples: + plus = half(q, True, b12, b21) + minus = half(q, False, b12, b21) + plus_rank = rank_rows(plus[: 2 * q]) + minus_rank = rank_rows(minus[: 2 * q]) + if plus_rank != q + expected: + fail("pi_core P_+ rank is not q + rank(B21)") + if minus_rank != q + rank_rows(b12): + fail("pi_core P_- rank is not q + rank(B12)") + if expected < q and plus_rank >= 2 * q: + fail("singular B21 had full core image") + + +def check_first_step(): + """Complementary copies of the PR #7053 witness do not reach rank 2q.""" + for q in (1, 2, Q): + first, second = projectors(q, 0, 0, True) + original = predecessor_witness(q, False) + shifted = predecessor_witness(q, True) + if not square_clear(original, first, second): + fail("the rank-q witness failed the square condition") + ranks = tuple(rank_rows(block) for block in three_blocks(original, first, second, q)) + if ranks != (q, q, q): + fail("the rank-q witness blocks are not (q, q, q)") + if square_clear(shifted, first, second): + fail("the complementary-source copy unexpectedly satisfied the square condition") + summed = mat_add(original, shifted) + if square_clear(summed, first, second): + fail("the complementary-source sum unexpectedly satisfied the square condition") + sum_ranks = tuple(rank_rows(block) for block in three_blocks(summed, first, second, q)) + if sum_ranks[0] == 2 * q or sum_ranks[1] == 2 * q: + fail("complementary sources reached rank 2q on an outside block") + if sum_ranks[0] != q or sum_ranks[1] != q: + fail("complementary-source outside blocks are not rank q") + # Image split onto the two core halves. The minus copy is not admissible. + plus_only = zeros(8 * q) + minus_only = zeros(8 * q) + for index in range(q): + for source in (at(q, 6, index), at(q, 5, index), at(q, 3, index)): + put(plus_only, at(q, 0, index), source) + for source in (at(q, 7, index), at(q, 4, index), at(q, 2, index)): + put(minus_only, at(q, 1, index), source) + if not square_clear(plus_only, first, second): + fail("the plus-core copy failed the square condition") + if square_clear(minus_only, first, second): + fail("the minus-core copy unexpectedly satisfied the square condition") + split = mat_add(plus_only, minus_only) + split_ranks = tuple(rank_rows(block) for block in three_blocks(split, first, second, q)) + if split_ranks[0] >= 2 * q or split_ranks[1] >= 2 * q or split_ranks[2] >= 2 * q: + fail("complementary core directions reached rank 2q") + + +def helped_leaves(leaves, stage): + values = [] + if stage > 0: + values.append(stage - 1) + values.append(stage) + if stage + 1 < leaves: + values.append(stage + 1) + return values + + +def full_cancel_demands(leaves, stage): + values = [2] * leaves + for leaf in helped_leaves(leaves, stage): + values[leaf] = 0 + return values + + +def parity_coefficient(values): + even = sum(values[index] for index in range(0, len(values), 2)) + odd = sum(values[index] for index in range(1, len(values), 2)) + return max(even, odd) + + +def predicted_coefficient(leaves, stage): + if leaves % 2 == 0: + return leaves - 2 + if stage % 2 == 0: + return leaves - 1 + return leaves - 3 + + +def run_lengths(leaves, stage): + """Unhelped leaves form a left run and a right run, separated by the helped block.""" + helped = helped_leaves(leaves, stage) + left = helped[0] + right = leaves - 1 - helped[-1] + return left, right + + +def cover_tuple(leaves, stage): + """Weight-2 gaps: ceil(m/2) on each unhelped run, on disjoint gap sets.""" + left, right = run_lengths(leaves, stage) + helped = helped_leaves(leaves, stage) + ranks = [0] * (leaves + 1) + for offset in range(0, left, 2): + ranks[offset + 1] = 2 + start = helped[-1] + 1 + for offset in range(0, right, 2): + ranks[start + offset + 1] = 2 + return ranks + + +def check_counting(): + for leaves in range(3, 41): + for stage in range(leaves): + values = full_cancel_demands(leaves, stage) + coefficient = parity_coefficient(values) + if coefficient != predicted_coefficient(leaves, stage): + fail("parity coefficient mismatch at g=%d stage=%d" % (leaves, stage)) + left, right = run_lengths(leaves, stage) + hits = (left + 1) // 2 + (right + 1) // 2 + if 2 * hits != coefficient: + fail("hitting-set size differs from the heavier parity") + ranks = cover_tuple(leaves, stage) + for leaf in range(leaves): + if ranks[leaf] + ranks[leaf + 1] < values[leaf]: + fail("cover tuple missed a leaf") + if sum(ranks) != coefficient: + fail("cover tuple has the wrong total") + for gap, rank in enumerate(ranks): + if rank == 0: + continue + trial = ranks[:] + trial[gap] -= 1 + if all(trial[leaf] + trial[leaf + 1] >= values[leaf] for leaf in range(leaves)): + fail("a minimum tuple had a spare gap") + if leaves % 2 == 1: + for stage in range(0, leaves, 2): + values = full_cancel_demands(leaves, stage) + unhelped_even = sum(1 for leaf in range(0, leaves, 2) if values[leaf] == 2) + if 2 * unhelped_even != leaves - 1: + fail("even stage unhelped count is not g-1") + if predicted_coefficient(G, 1) != G - 3 or predicted_coefficient(G, 2) != G - 1: + fail("g=31 coefficients changed") + if (G - 3) * Q != 728 or (G - 1) * Q != 780: + fail("profile ranks changed") + + +def bits_of(matrix): + columns = [] + for col in range(8): + value = 0 + for row in range(8): + if matrix[row][col]: + value |= 1 << row + columns.append(value) + return columns + + +def span_basis(columns): + basis = [] + for column in columns: + value = column + for pivot in basis: + if value & pivot[0]: + value ^= pivot[1] + if value: + lead = value & -value + basis.append((lead, value)) + return basis + + +def in_span(vector, basis): + value = vector + for lead, row in basis: + if value & lead: + value ^= row + return value == 0 + + +def dot(left, right): + return (left & right).bit_count() & 1 + + +def projected_core(columns, vector): + """Core coordinates of a projector applied to a vector.""" + out = 0 + bit = vector + index = 0 + while bit: + if bit & 1: + out ^= columns[index] + bit >>= 1 + index += 1 + return out & 3 + + +def own_block(image, functional, first_cols, second_cols): + """Own-leaf core block of the rank-1 map image * functional^T.""" + + def pinch(col): + left = projected_core(first_cols, image) if dot(functional, first_cols[col]) else 0 + right = projected_core(second_cols, image) if dot(functional, second_cols[col]) else 0 + return left ^ right + + return [[(pinch(col) >> row) & 1 for col in (2, 3)] for row in range(2)] + + +def census_q1(): + """Every rank-at-most-1 matrix on the eight F2 coordinates.""" + admissible = 0 + own_exceed = 0 + for b12 in (0, 1): + for b21 in (0, 1): + for plus_first in (0, 1): + first, second = projectors(1, b12, b21, plus_first == 1) + if rank_rows(first) != 2 or rank_rows(second) != 2: + fail("a scalar half does not have rank 2") + first_cols = bits_of(first) + second_cols = bits_of(second) + basis = span_basis(first_cols) + for image in range(256): + for functional in range(256): + if image == 0 or functional == 0: + continue + # P_s Z P_f = 0 iff the stage part of the image lies in + # im P_f, or the functional kills im P_f. Outside-leaf + # coordinates of the image are free. + conditioned = in_span(image & 15, basis) or all( + dot(functional, column) == 0 for column in first_cols + ) + if not conditioned: + continue + admissible += 1 + own = own_block(image, functional, first_cols, second_cols) + if rank_rows(own) > 1: + own_exceed += 1 + if own_exceed: + fail("q=1 census: a conditioned rank-1 own block exceeded rank 1") + # im P_f has dimension 2 inside the stage and is zero outside it, so 2^2 + # stage vectors times 2^4 outside vectors, excluding zero, meet the image + # branch. The annihilator of that plane in the dual of F^8 has 2^{6}-1 + # nonzero functionals. Inclusion-exclusion over the two branches: + good_images = (1 << 2) * (1 << 4) - 1 + good_functionals = (1 << 6) - 1 + per_half = good_images * 255 + (255 - good_images) * good_functionals + if admissible != 8 * per_half: + fail("q=1 admissible count changed: %d" % admissible) + # The exhibited identity pair sits in this finite domain. + for plus_first, seeds in ( + (True, ((1, 106), (3, 215))), + (False, ((1, 149), (3, 126))), + ): + first, second = projectors(1, 1, 1, plus_first) + first_cols = bits_of(first) + second_cols = bits_of(second) + basis = span_basis(first_cols) + for image, functional in seeds: + if image == 0 or functional == 0: + fail("seed is not rank 1") + if not (in_span(image & 15, basis) or all(dot(functional, column) == 0 for column in first_cols)): + fail("identity seed is outside the conditioned domain") + matrix = [ + [((image >> row) & 1) & ((functional >> col) & 1) for col in range(8)] + for row in range(8) + ] + dense_own = three_blocks(matrix, first, second, 1)[2] + if dense_own != own_block(image, functional, first_cols, second_cols): + fail("bit own block disagrees with dense multiplication") + + +def check_condition_agreement(): + """The rank-1 stage-image test agrees with dense P_s Z P_f = 0.""" + first, second = projectors(1, 1, 1, True) + first_cols = bits_of(first) + basis = span_basis(first_cols) + for image in range(256): + for functional in range(256): + if image == 0 or functional == 0: + continue + bit = in_span(image & 15, basis) or all( + dot(functional, column) == 0 for column in first_cols + ) + matrix = [ + [((image >> row) & 1) & ((functional >> col) & 1) for col in range(8)] + for row in range(8) + ] + if bit != square_clear(matrix, first, second): + fail("rank-1 square test disagrees with dense multiplication") + + +def check_controls(): + def cleared_column(): + first, second = projectors(1, 1, 1, True) + left, right = witness_pair(1, True) + left[0][6] = 0 + block = three_blocks(mat_add(left, right), first, second, 1)[0] + if block != eye(2): + fail("mutated next block is not I") + + def zero_matrix_still_identity(): + first, second = projectors(Q, 1, 1, True) + _left, right = witness_pair(Q, True) + if three_blocks(right, first, second, Q)[0] != eye(2 * Q): + fail("one map is not the next identity") + + expect_fail("cleared column", cleared_column) + expect_fail("single map", zero_matrix_still_identity) + + +def main(): + check_identity_family() + check_direct_sum_shape() + check_singular_cap() + check_first_step() + check_counting() + census_q1() + check_condition_agreement() + check_controls() + print( + "PASS_TWO_RANK_Q_SAME_GAP" + " blocks=I_2q" + " singular_next_cap=q+rank(B21)" + " odd_stage_external=%d" + " even_stage_external=%d" + " uniform_q(g-1)_lift=does_not" + " kappa=363005817/100000000000" + % ((G - 3) * Q, (G - 1) * Q) + ) + + +if __name__ == "__main__": + main() From 66405802f1eaac23d7b19759db1fc5d68b409397 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 11 Nov 2026 10:43:48 +0000 Subject: [PATCH 2/2] State the outside-block rank caps by which half is applied first. Co-authored-by: unpaidmoon --- research/two-rank-q-same-gap/PROOF.md | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/research/two-rank-q-same-gap/PROOF.md b/research/two-rank-q-same-gap/PROOF.md index 818d678a9f..fbf206839b 100644 --- a/research/two-rank-q-same-gap/PROOF.md +++ b/research/two-rank-q-same-gap/PROOF.md @@ -69,18 +69,17 @@ rank(pi_core P_-) = q + rank(B12). ``` The outside blocks factor through these maps. For any matrices in the gap, -and either half order, ```text -rank(N) <= q + rank(B21 of P_f's sign), -rank(P) <= q + rank(B12 of P_s's sign). +rank(N) <= rank(pi_core P_f), +rank(P) <= rank(pi_core P_s). ``` -In particular, if `P_f = P_+` and `rank(B21) < q`, then no choice and no -number of internal matrices can make the next-leaf block have rank `2q`. -The symmetric statement holds for `B12` and the previous-leaf block. Both -caps are statements about the image of a projector. They do not use -`P_s Z P_f = 0`. +If `P_f = P_+`, the next-leaf cap is `q + rank(B21)` and the previous-leaf +cap is `q + rank(B12)`. If `P_f = P_-`, the two caps exchange. In +particular, `B12 = B21 = 0` forces both outside blocks to have rank at most +`q`, for either half order. No choice and no number of internal matrices +can raise them to `2q`. These caps do not use `P_s Z P_f = 0`. ## 3. Complementary copies of the rank-q witness