Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
216 changes: 216 additions & 0 deletions research/weight1-pattern-dim4-reducible/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,216 @@
# Weight-one covectors cap a pattern-dimension-4 no-edge image at 6

Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.
Independent human and formal proof-kernel review are unclaimed.

No new κ is claimed. The selected frontier stays
`781451/250000000`.

Evidence class: **proof** of a dimension bound and a reducibility statement,
under an exact covector-weight hypothesis, together with one **exhaustive
finite census** of an 8-coordinate witness. It is not a census of all pattern
spaces, and it is not a claim about pools that use a covector of weight 2 or
more.

## Theorem

Work over `F2`. Let `P` be a linear space of zero-diagonal `W` by `W`
matrices, with `dim P ≤ 4`, containing no matrix unit. Write `C(P)` for the
complete pool of rank-one idempotents `N = x y^T` with `y^T x = 1` and
`off(N)` a nonzero element of `P`. Suppose every covector `y` that appears
has weight 1. Let `V(P)` be the sum of the images of the pool.

Then `dim V(P) ≤ 6`. If the pool is nonempty and
`dim V(P) ≥ dim P + 1`, the action on `V(P)` is reducible. In particular
every such pool with `dim P = 4` and `dim V(P) ≥ 5` is reducible.

Dimension 6 is attained by the witness in Section 6, so the upper bound is
sharp. That witness is reducible: the common kernel of its covectors inside
`V` has dimension 4.

## Notation

`off(N)` is `N` with its diagonal deleted. A matrix unit `E_ab` (`a ≠ b`)
is the pattern with a single 1 in row `a`, column `b`. The fiber lemma
quoted below is Lemma 1 of `research/pattern-pool-cardinality/PROOF.md`
(Nick Petalas, #5921): a realizable nonzero off-diagonal pattern has exactly
one rank-one idempotent lift, except a matrix unit, which has two.

For each column index `j`, write `U_j` for the patterns in `P` supported
only in column `j`. Those patterns occupy disjoint matrix positions, so

```text
sum_j dim U_j ≤ dim P.
```

## 1. The pool is the nonzero pure columns

**Lemma.** Under the hypotheses, `off(C(P))` is exactly the set of nonzero
elements of the spaces `U_j`. The unique lift of a nonzero `v ∈ U_j` is

```text
x = e_j + v, y = e_j.
```

The column vector `v` is zero in row `j`, because the pattern is
off-diagonal.

A pool element with `y = e_j` has only column `j` possibly nonzero, and
that column of `x y^T` is `x`. Deleting the diagonal leaves `x + e_j`,
which lies in `U_j`, and `y^T x = 1` forces the `j`-th bit of `x` to be 1.
So every pool pattern is a nonzero element of some `U_j`.

Conversely, take nonzero `v ∈ U_j`. It is not a matrix unit, so its weight
is at least 2. The displayed lift is a rank-one idempotent:

```text
(x y^T)^2 = x (y^T x) y^T = x y^T,
```

and its off-diagonal pattern is `v` in column `j`. The fiber lemma supplies
no second lift.

Thus no pool covector has weight greater than 1, which is the hypothesis,
and there is nothing else in the pool.

## 2. Dimension contributed by one column

Let `S_j` be the span of `{e_j + v : v ∈ U_j, v ≠ 0}`, and write
`d_j = dim U_j`.

- If `d_j = 0`, then `S_j = 0`.
- If `d_j = 1`, there is one nonzero vector `v`, so `dim S_j = 1`.
- If `d_j ≥ 2`, then `U_j` has at least three nonzero vectors. For any
nonzero `u ∈ U_j`, choose nonzero `v ≠ u`. Then

```text
(e_j + v) + (e_j + (v + u)) = u,
```

so `U_j ⊆ S_j`. Hence `e_j = (e_j + v) + v` lies in `S_j`. Every column
vector is zero at coordinate `j`, so `e_j` is outside the column space
and `dim S_j = 1 + d_j`.

Write `f(0) = 0`, `f(1) = 1`, and `f(d) = 1 + d` for `d ≥ 2`. Then
`dim S_j = f(d_j)`. The joint image is the sum of the `S_j`, so

```text
dim V(P) ≤ sum_j f(d_j).
```

## 3. The sum is at most 6

The positive `d_j` are positive integers whose sum is at most
`dim P ≤ 4`. The complete list of such tuples, up to order, and the
value of `sum f`, is:

| parts | sum f |
|---|---:|
| (4) | 5 |
| (3,1) | 5 |
| (3) | 4 |
| (2,2) | 6 |
| (2,1,1) | 5 |
| (2,1) | 4 |
| (2) | 3 |
| (1,1,1,1) | 4 |
| (1,1,1) | 3 |
| (1,1) | 2 |
| (1) | 1 |

No other partition of an integer at most 4 exists. Therefore
`dim V(P) ≤ 6`.

Equality forces `dim P = 4`, exactly two columns, each of pattern
dimension 2, each image space of dimension 3, those two spaces meeting
only at 0, and `sum d_j = dim P`.

## 4. Reducibility above `dim P`

Let `L` be the span of the basis vectors `e_j` for the columns with
`d_j ≥ 1`. Then `dim L` equals the number `c` of those columns. Each such
column has `d_j ≥ 1`, so `c ≤ sum d_j ≤ dim P`.

Every pool covector is one of those `e_j`. The common kernel inside `V`
is

```text
K = {z ∈ V : y·z = 0 for every pool covector y} = V ∩ L^⊥.
```

Hence `dim K = dim V - dim π_L(V) ≥ dim V - dim L ≥ dim V - dim P`.

If the pool is nonempty and `dim V ≥ dim P + 1`, then `dim K ≥ 1`.
Some pool vector `x` satisfies `y·x = 1` and lies in `V`, so `x ∉ K` and
`K ≠ V`. Each pool map is `z ↦ (y·z) x`, which is zero on `K`. Thus `K`
is a nonzero proper invariant subspace, and the action is reducible.

For `dim P = 4` this covers every weight-1 pool with `dim V ≥ 5`.

In the equality case `dim V = 6`, Section 3 forces `c = 2`. Each
3-dimensional image space contains its `e_j`, so `π_L(V) = L` and
`dim K = 4`.

## 5. The kernel test needs `dim V ≥ dim P + 1`

The inequality `dim K ≥ dim V - dim P` is zero when `dim V ≤ dim P`.
That bound is attained. On twelve coordinates, for `b = 0,1,2,3`, put

```text
x_b = e_{3b} + e_{3b+1} + e_{3b+2}, y_b = e_{3b},
```

and let `P` be the span of the four off-diagonal patterns. Each pattern
has weight 2. A nonempty sum of two or more of them has two or more
unequal nonzero columns, so it is not `off(x y^T)`. The fiber lemma gives
one lift of each single pattern. The pool is exactly these four
projectors, `dim P = 4`, `e(P) = 0`, and every covector has weight 1.
The four images are independent, so `dim V = 4`. Each image meets its
own column coordinate and no other column coordinate, so the common
kernel inside `V` is zero. Each line `span(x_b)` is invariant, so this
particular action is reducible for a different reason. The theorem does
not claim that every weight-1 pool with `dim V = dim P` is reducible.

## 6. Witness of dimension 6

Use width 8. Let

```text
U_0 = span{e_1+e_2, e_1+e_3}, U_4 = span{e_5+e_6, e_5+e_7},
```

and let `P` be the direct sum of those two column spaces. Each space has
three nonzero vectors, all of weight 2. Thus `dim P = 4` and `P` contains
no matrix unit. A pattern with both columns nonzero has those columns
supported on `{1,2,3}` and `{5,6,7}` respectively. Both are nonzero and
they are unequal, so the pattern is not an off-diagonal of a rank-one
matrix. The pool is therefore the six lifts

```text
e_0+e_1+e_2, e_0+e_1+e_3, e_0+e_2+e_3 against y = e_0,
e_4+e_5+e_6, e_4+e_5+e_7, e_4+e_6+e_7 against y = e_4.
```

Differences of the first triple span `U_0` and recover `e_0`, a
3-dimensional space. The second triple does the same on the complementary
coordinates. The sum is direct, so `dim V = 6`. Section 4 gives an
invariant kernel of dimension 4.

`verify.py` enumerates every nonzero `x` and `y` on these eight
coordinates. That domain is finite, the enumeration is complete, and the
structural reason above is why only the six lifts appear. The same
program checks the one-column dimension-5 example (even-weight columns
on coordinates `1..5`, pattern dimension 4, image dimension 5, kernel
dimension 4) and the four-line example of Section 5.

## 7. What this does not say

A covector of weight 2 or more is outside the hypothesis. The four-cycle
of #6962 has covector weight 3 and acts irreducibly in dimension 4.
Open PR #7094 exhibits an irreducible joint image of dimension 5 at
pattern dimension 4; its covectors have weight at least 2. Neither
example contradicts the theorem.

The argument does not bound irreducible dimension 6 in that heavier
class, and it does not change the selected conditional κ. No search is
used as a nonexistence proof.
121 changes: 121 additions & 0 deletions research/weight1-pattern-dim4-reducible/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,121 @@
# Weight-one covectors cap a pattern-dimension-4 no-edge image at 6

**Proof, plus one finite witness. No new κ.** The selected conditional
value stays `781451/250000000`.

## Result

Over `F2`, let `P` be a linear space of zero-diagonal matrices with
`dim P ≤ 4` and with no matrix unit. Suppose every rank-one idempotent in
the complete off-diagonal pool has covector weight 1. Then the joint image
`V` has dimension at most 6. If the pool is nonempty and
`dim V ≥ dim P + 1`, the action on `V` is reducible. In particular every
such pool with pattern dimension 4 and joint-image dimension at least 5 is
reducible.

Dimension 6 is attained. On eight coordinates the two column spaces

```text
span{e1+e2, e1+e3} and span{e5+e6, e5+e7}
```

give a complete pool of six projectors, pattern dimension 4, no matrix
unit, image dimension 6, and an invariant kernel of dimension 4. The
argument is in [PROOF.md](PROOF.md).

This is a proof under the weight-1 hypothesis. The width-8 pool equality
is an exhaustive census of the finitely many rank-one idempotents on those
eight coordinates. Neither statement is a census of all pattern spaces, and
neither bounds a pool that uses a covector of weight 2 or more.

## Scope and evidence

Catalogue card: `bit-new-register-model`, priority revision 8, base commit
`f16923d466a6aba912299882e0545564d2ba7bb2`. The session opened on
`17469fff78c22941280f04d39dc5a1faee09c840`; upstream main then advanced by
the PR #7000 admission commit, which does not touch this proof. Scope
status is **changed**.
The card asks for a larger or nonabelian register alphabet. This package
answers the weight-1 case of the pattern-dimension-4 image question left
by #6962 and narrowed by open #7094. The original card is copied verbatim
in [TASK.json](TASK.json). Pins are in [SOURCES.json](SOURCES.json).

Ordered eligible list for session r230. Dropped first: every unpaidmoon
pull request and fork `cursor/*` branch named in the session brief,
including the newer fork tips `cursor/frame506-carry-ledger-30b5`,
`cursor/two-gap-constant-insertion-1bb5`,
`cursor/y-exit-partial-round-trip-70ac`, and
`cursor/y-exit-rank-lift-obstruction-b140`. The 19 October handoffs are
already delivered. The revision-8 next-decision table comes next, then
catalogue cards that table does not name, in catalogue order.

1. Complex helpers (`p104-side-correction`, `coverage-law-change`).
2. BIT helper contract (`bit-helper-contract`).
3. New decoders and interfaces.
4. Supplier audit.
5. All-size audit and formalization.
6. Verification tooling.
7. `bit-new-register-model`.
8. `r437-carrier-integration`.
9. `complex-rank-shape-decoder`.
10. `complex-new-helper-inventory`.

Item 3 of that list is a changed producer/consumer contract. This package
is item 7. It is the distinct remaining piece of that card after #6921,
#6962, and open #7094: those results use covectors of weight greater than
1, or stop at pattern dimension 3. The weight-1 hypothesis is not the
hypothesis of #7094, whose irreducible dimension-5 pool has covector weight
at least 2. The 112-owner linear relation left by open #7056 was not
taken.

#7094 is not on this main. Its factors were read from the pull-request
head and are not replayed here. The four-cycle of #6962 is used only as a
negative control: its covector weight is 3, so the theorem does not apply
to it.

## Reproduce

Python 3.12, standard library only, from the repository root:

```sh
python3 -B scripts/research_package.py --package research/weight1-pattern-dim4-reducible --check-only
python3 -B scripts/research_package.py --package research/weight1-pattern-dim4-reducible
```

`verify.py` prints `PASS_WEIGHT1_PATTERN_DIM4_REDUCIBLE` with
`pool=6`, `image_dim=6`, `kernel_dim=4`, `partition_max=6`, and
`new_kappa=null`.

Not run: Lean, Docker, the selected cold replay, and any search over
heavy covectors. An incomplete search is not evidence in this package.

## Open next questions

Can a complete no-edge pool of pattern dimension 4 that uses at least one
covector of weight 2 or more act irreducibly on a joint image of dimension
6 or more? Open #7094 already gives irreducible dimension 5 in that heavier
class, so the weight-1 cap does not bound it. The smallest next step is one
explicit heavy-covector pool with a written invariant-subspace check, or a
proof that every such pool has image dimension at most 5 or is reducible.
No column decomposition in this note makes that domain finite, so a search
that finds nothing would not be a proof.

A second boundary is left open on purpose. The kernel test needs
`dim V ≥ dim P + 1`. The four disjoint weight-1 lines have pattern
dimension 4, image dimension 4, and trivial common kernel, while each line
is invariant. That example does not decide whether every weight-1 pool with
`dim V = 4` is reducible.

## Credit

The fiber lemma is Nick Petalas, #5921,
`research/pattern-pool-cardinality`. CubeJerry, #6838, proved the
pattern-dimension-at-most-3 total-image bound and gave the reducible parity
pool of image dimension 5; this note does not reprove that theorem. #6921
proved the irreducible bound 3 for pattern dimension at most 3. #6962 showed
that bound fails in pattern dimension 4, by the four-cycle. Open #7094
shows irreducible image dimension 5 with heavier covectors. This package
does not replace those arguments.

Prepared by unpaidmoon with substantial Cursor Grok assistance. New work is
Apache-2.0. No independent human or formal-kernel review is claimed.
18 changes: 18 additions & 0 deletions research/weight1-pattern-dim4-reducible/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
{
"schema_version": 1,
"base_commit": "f16923d466a6aba912299882e0545564d2ba7bb2",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
"sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
"sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
}
]
}
Loading