From 043b334e7249e8b79e437a0765773a7e2fc8b8e8 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Tue, 10 Nov 2026 09:03:46 +0000
Subject: [PATCH] Witness a characteristic-3 rank-32 pattern on P120.

The free-zero point of one hyperplane of the #6953 degree-2 column span is a 1-block pattern of rank 32, with a 120 by 32 factorisation over F_3. The same matrix has principal rank 32 on P104 and both P112 extensions. No kappa change.

Co-authored-by: unpaidmoon <unpaidmoon@users.noreply.github.com>
---
 research/p120-char3-rank32-window/NOTICE      |   5 +
 research/p120-char3-rank32-window/PROOF.md    | 205 +++++++++
 research/p120-char3-rank32-window/README.md   | 100 +++++
 .../p120-char3-rank32-window/SOURCES.json     |  24 +
 research/p120-char3-rank32-window/TASK.json   |  81 ++++
 research/p120-char3-rank32-window/VERIFY.json |  20 +
 research/p120-char3-rank32-window/verify.py   | 420 ++++++++++++++++++
 7 files changed, 855 insertions(+)
 create mode 100644 research/p120-char3-rank32-window/NOTICE
 create mode 100644 research/p120-char3-rank32-window/PROOF.md
 create mode 100644 research/p120-char3-rank32-window/README.md
 create mode 100644 research/p120-char3-rank32-window/SOURCES.json
 create mode 100644 research/p120-char3-rank32-window/TASK.json
 create mode 100644 research/p120-char3-rank32-window/VERIFY.json
 create mode 100644 research/p120-char3-rank32-window/verify.py

diff --git a/research/p120-char3-rank32-window/NOTICE b/research/p120-char3-rank32-window/NOTICE
new file mode 100644
index 0000000000..29708f305e
--- /dev/null
+++ b/research/p120-char3-rank32-window/NOTICE
@@ -0,0 +1,5 @@
+Characteristic-3 rank-32 witness for the P120 port window.
+Prepared by unpaidmoon with substantial Cursor Grok assistance.
+The port list is the P104 set published in PR #6933 and vendored by #6953.
+The rank-37 degree-at-most-2 pattern is PR #6953.
+New exposition and checks are Apache-2.0.
diff --git a/research/p120-char3-rank32-window/PROOF.md b/research/p120-char3-rank32-window/PROOF.md
new file mode 100644
index 0000000000..cfb1a2464b
--- /dev/null
+++ b/research/p120-char3-rank32-window/PROOF.md
@@ -0,0 +1,205 @@
+# Characteristic 3 admits a rank-32 pattern on P120
+
+No new κ. The selected record stays `781451/250000000`. This note does not
+build a word, a decoder, or a paid profile, and it does not change the
+selected frontier.
+
+The window is the block-mask window of PR #6933. A physical decoder for
+`k > 1` is not derived.
+
+## 0. Definitions
+
+`P120` is the 120 vectors in `F_2^9` of weight congruent to 3 mod 4. Two
+distinct vectors are adjacent when their `F_2` dot product is 1 and orthogonal
+when it is 0. `P104` is the port list of #6933, the same file vendored by
+#6953, sha256
+`691c7b7d212112115b1bfc76db89f90d304ec448dc8c4a0c43d9a5954317146c`. Its
+complement is the two 8-cliques recorded in #6953.
+
+A **1-block pattern** has nonzero diagonal and a zero in both off-diagonal
+positions of every orthogonal pair. Adjacent entries are free, and the matrix
+need not be symmetric. Write `w_1(S; F)` for the minimum rank of a 1-block
+pattern on `S` over `F`, and `w(S; F)` for the infimum of `rank(B)/k` over
+k-block patterns in the sense of #6933. Then `w(S; F) ≤ w_1(S; F)`.
+
+#6953 proves `w_1(P120; F_3) ≤ 37` and `w_1(P104; F_3) ≤ 36` by one
+degree-at-most-2 point, and proves that every class-constant pattern on
+`P120` has rank 120 in characteristic 3. The lower bounds `w(P104) ≥ 13`,
+`w(P112) ≥ 14` and `w(P120) ≥ 15` in odd characteristic are #6933, Theorem 4.
+They are cited and not replayed. This note does not extend those lower bounds.
+
+## 1. The degree-at-most-2 chart
+
+Order monomials as the constant `1`, the coordinates `x_0, …, x_8`, and the
+products `x_i x_j` for `0 ≤ i < j ≤ 8`. Evaluate them at a vector as integers
+in `{0, 1}` and read the values in `F_3`.
+
+**Lemma 1.** On `P120`, `sum_{i<j} x_i x_j = 0` as a function to `F_3`. The
+remaining 45 monomials, with `x_7 x_8` omitted, have evaluation rank 45.
+
+*Proof.* For a 0-1 vector the pair sum equals `binom(wt(v), 2)`. That binomial
+coefficient is 3 at weight 3 and 21 at weight 7, both divisible by 3.
+`verify.py` evaluates the sum at all 120 vectors and row-reduces the 45-column
+evaluation matrix. The domain is finite and every vector is visited once. ∎
+
+Every degree-at-most-2 function therefore has a unique coefficient vector in
+this 45-coordinate chart. Call that space of functions `E`.
+
+## 2. The witness span of the previous point
+
+For each vertex `v`, let the legal equations require value 1 at `v` and value
+0 at every vertex orthogonal to `v`. Gaussian elimination over `F_3`, with
+free variables set to 0, produces a solution `q_v` in the 45-chart. This is
+the point constructed in #6953. The matrix `M^0_{uv} = φ(u) · q_v` is a
+1-block pattern of rank 37. The vectors `q_v` span a 37-dimensional subspace
+`S ⊆ E`. Both statements are the row counts of the reduced forms in
+`verify.py`.
+
+The reduced row echelon form is unique: elimination runs left to right, each
+pivot is scaled to 1, and the pivot column is cleared above and below. The
+kernel basis used below is the standard one for that unique form. For each
+free column, in increasing order, the basis vector has a 1 in that free
+column, 0 in the other free columns, and pivot entries equal to the negation
+of the reduced coefficient. It does not depend on row order.
+
+## 3. Eight rigid columns
+
+**Lemma 2.** Inside `S`, the eight weight-7 vectors that do not contain
+coordinate 8 have no legal direction. Each has a unique legal column in `S`,
+namely its witness column `q_v`, and those eight columns are linearly
+independent.
+
+The eight vectors are
+
+```
+127, 191, 223, 239, 247, 251, 253, 254.
+```
+
+*Proof.* A direction in `S` is a linear combination of an RREF basis of `S`.
+`verify.py` imposes vanishing on `{v} ∪ orth(v)` and counts the kernel. The
+kernel is zero at exactly these eight vertices, and the eight witness
+coordinate vectors have rank 8. The vertex list is the full set of weight-7
+vectors with bit 8 clear: a weight-7 vector with bit 8 clear has its single
+other zero among the first eight coordinates, so there are eight of them. ∎
+
+This uniqueness is inside `S`. It is not a uniqueness statement in `E`, and
+not a uniqueness statement among all patterns.
+
+## 4. One hyperplane of the witness span
+
+Let `U` be the span of those eight rigid columns, and let `π_0, …, π_28` be
+the canonical kernel basis of `U` in the 37 coordinates of `S`.
+
+**Lemma 3.** The hyperplane `ker(π_1)` is the unique hyperplane in this
+29-element basis that still meets every legal affine flat of `S`. The space
+`W = ker(π_1) ∩ S` has dimension 36.
+
+*Proof.* `verify.py` tests each of the 29 basis vectors. For a form `π`, it
+solves the legal equations inside `S` together with `π · c = 0`. The system
+is consistent for every vertex if and only if `i = 1`. The two nonzero scales
+of `π_1` determine the same kernel. Consistency is checked at all 120
+vertices. This is an exhaustive census of this basis, not of every hyperplane
+of `S`. ∎
+
+The same space `W` is the set of coefficient vectors satisfying the nine
+independent equations
+
+```
+c + a_8 = 0,
+sum_{i=0}^{7} a_i + 2 a_8 + 2 sum_{0≤i<j≤7} b_{ij} = 0,
+b_{i8} = 0 for i = 0, …, 6,
+```
+
+with `b_78 = 0` already built into the chart. `verify.py` checks that these
+nine rows span the annihilator of `W`.
+
+## 5. The rank-32 pattern
+
+Let `ψ_1, …, ψ_36` be the canonical kernel basis of `π_1` inside `S`, lifted
+to the 45-chart, and let `Φ` be their `120 × 36` evaluation matrix. For each
+vertex `v`, let `y_v` be the solution of the legal equations `Φ y = e_v` with
+free coordinates set to 0. Define `M_uv = Φ_u · y_v`.
+
+**Theorem 1.** `M` is a 1-block pattern over `F_3` of rank 32. Its pivot
+columns and the coordinates of the remaining columns are a `120 × 32`
+factorisation of `M` over `F_3`. Extending scalars does not change the rank,
+so for every field `F` of characteristic 3,
+
+```
+w(P120; F) ≤ w_1(P120; F) ≤ 32.
+```
+
+The same matrix has principal rank 32 on `P104` and on both `P112`
+extensions. A principal submatrix of a pattern is a pattern, so the same
+upper bound 32 holds for those three sets.
+
+*Proof.* `verify.py` rebuilds `Φ` and every `y_v`, checks every diagonal
+entry and both off-diagonal entries of every orthogonal pair, and counts
+pivots of `M`, of the column-reversed matrix, and of the transpose. All three
+counts are 32. The sha256 of `M`, entries in `{0, 1, 2}` in increasing vertex
+order, row by row, is
+
+```
+81e209bb5be3c3e9b9a5d593190fd9b19540656bb0162164f4df7a1f0bf4a8c4
+```
+
+The 32 pivot columns are linearly independent, and every column of `M` reduces
+into their span, which is the factorisation. A minor vanishes over `F_3` if
+and only if it vanishes over an extension, and a nonzero value stays nonzero,
+so the rank is unchanged by scalar extension. The port-file principal
+submatrix and both 112-vertex principals are checked in the same way. ∎
+
+`M` is not class-constant: it is asymmetric, and the adjacent entries take
+more than one value. The class-constant matrices `I + β A` still have rank
+120, as in #6953. The pure quadratic monomials remain inconsistent, so this
+is not that smaller map.
+
+## 6. What the rank is attached to
+
+`W` is 36-dimensional, but the free-zero rule depends on the basis. In the
+canonical kernel basis of the nine relations of section 4, the same legal
+systems have a solution, and that other point is a 1-block pattern of rank
+36. `verify.py` rebuilds it. Rank 32 belongs to the basis carried from `S`
+in Theorem 1. It is not an invariant of the set of all patterns with columns
+in `W`.
+
+Inside that basis the legal solution spaces have affine dimensions 0 at 36
+vertices, 2 at 56 vertices, and 5 at 28 vertices. `verify.py` counts these
+nullities. The witness uses one point of each affine space, the free-zero
+point. It was not minimized over those spaces. The checked rank-36 point of
+the previous paragraph already shows that `W` does not by itself force rank
+32.
+
+So three statements stay distinct:
+
+1. **Proof, one witness.** The matrix of Theorem 1 has rank 32. The checks
+   that identify it are exhaustive on a finite domain: every vertex, every
+   orthogonal pair, one reduced form, and all 29 vectors of one kernel basis.
+2. **Proof, one other point of the same space.** Another explicit basis of
+   `W` gives a legal pattern of rank 36.
+3. **Not settled.** Whether some pattern, inside `W` or outside `E`, has
+   rank at most 31, and whether every 1-block pattern on `P120` has rank at
+   least 32. A search that did not find a smaller pattern would not decide
+   either question. This note does not report one.
+
+Accepting #6933, Theorem 4, without replaying it, the characteristic-3
+intervals are now
+
+| set | lower bound, cited | upper bound proved here |
+|---|---|---|
+| P104 | 13 | 32 |
+| either P112 extension | 14 | 32 |
+| P120 | 15 | 32 |
+
+#6953 had upper bounds 36, 36, 37 and 37 on these four sets. The upper end
+32 is strictly smaller than the rank of `3I − A` off characteristic 3, which
+is 36. No equality is claimed. Characteristic 2 stays inside #6933.
+
+## 7. What this does not say
+
+A rank-32 pattern is not a multiplication algorithm, not a paid profile, and
+not a change to the selected frontier. It does not show that 32 is the
+minimum on `P120` or on `P104`. It does not touch the `F_5` rank-13
+factorisation. The construction uses the coordinate chart of `F_2^9` and is
+not claimed to be invariant under a larger automorphism group. No human has
+reviewed this note.
diff --git a/research/p120-char3-rank32-window/README.md b/research/p120-char3-rank32-window/README.md
new file mode 100644
index 0000000000..f3110564b5
--- /dev/null
+++ b/research/p120-char3-rank32-window/README.md
@@ -0,0 +1,100 @@
+# Characteristic-3 rank-32 pattern on P120 (no new κ)
+
+**No new κ.** The selected record stays `781451/250000000`. This package
+exhibits one 1-block pattern of rank 32 on `P120` over every field of
+characteristic 3, together with a `120 × 32` factorisation over `F_3`. The
+same matrix has principal rank 32 on `P104` and on both copies of `P112`.
+It does not build a word or a paid profile.
+
+The argument is in [PROOF.md](PROOF.md). The exact checks are in
+[verify.py](verify.py).
+
+## Result
+
+`P120` is the odd graph on the 120 vectors in `F_2^9` of weight 3 or 7.
+`P104` is the port list of PR #6933, the file already vendored by #6953.
+A 1-block pattern has nonzero diagonal and zeros on both off-diagonal
+positions of every orthogonal pair.
+
+1. **The previous point still has rank 37.** The free-zero degree-at-most-2
+   pattern of #6953 is rebuilt and still has rank 37 on `P120`. Its columns
+   span a 37-dimensional space `S`.
+2. **Eight columns are rigid inside that span.** The weight-7 vectors that
+   omit coordinate 8 have a unique legal column in `S`. Those eight columns
+   are independent.
+3. **One canonical hyperplane of `S` has a rank-32 pattern.** In the kernel
+   basis of those eight columns, the second basis vector cuts `S` to a
+   36-dimensional space that still meets every legal flat. The free-zero
+   point in the basis carried from `S` is a 1-block pattern of rank 32.
+   Scalar extension preserves the rank, so `w(P120; F) ≤ 32` for every field
+   `F` of characteristic 3. The principal submatrices on `P104` and both
+   `P112` extensions also have rank 32.
+4. **The same space has another point of rank 36.** Free-zero coordinates in
+   the kernel basis of the nine coefficient relations give a different legal
+   pattern, of rank 36. Rank 32 is attached to the basis in item 3, not to
+   every pattern with columns in the space.
+
+Accepting the lower bounds in #6933, Theorem 4, without replaying them, the
+characteristic-3 window now satisfies `w(P120; F) ∈ [15, 32]`, and the same
+upper bound 32 holds for `P104` and both copies of `P112`. #6953 had upper
+bounds 37, 36, 36 and 37 on these sets. No equality is claimed. No κ changes.
+
+The census of the 29 kernel-basis vectors is exhaustive for that basis. It
+is not a census of all hyperplanes, and a failed search for a smaller
+pattern is not part of the claim.
+
+## Scope
+
+Original card: `complex-rank-shape-decoder`. Scope status: **changed**. The
+card asks whether a decoder or coframe change improves the signed moment.
+This package does not change a word or a moment. It answers the P120 half of
+the question left open by #6953: whether characteristic 3 admits a 1-block
+pattern of rank 36 on `P120`. The witness here has rank 32, which is stronger
+than that requested ceiling. Base commit
+`17469fff78c22941280f04d39dc5a1faee09c840`, priority revision 8. The selected
+κ in `certificates/selected-result.json` is `781451/250000000`; the older
+decimal quoted in `docs/research/current-priorities.md` is not the live
+frontier.
+
+The `F_5` rank-13 factorisation is open in #7014 and is not investigated.
+The degree-at-most-2 family is not searched beyond the two explicit points.
+Characteristic 2 is not reopened.
+
+## Reproduce
+
+From the repository root, CPython 3.12, standard library only:
+
+```sh
+python3 -B research/p120-char3-rank32-window/verify.py
+python3 -I -O -B research/p120-char3-rank32-window/verify.py
+python3 -B scripts/research_package.py --package research/p120-char3-rank32-window
+```
+
+Expected final line: `PASS_P120_CHAR3_RANK32 rank=32 p104=32 p112=[32, 32]`,
+then `PASS_REGISTERED_RESEARCH_PACKAGE` with outcome `partial`.
+
+The port file is a live input, the bytes already pinned by #6953. The
+catalogue and the selected record are provenance pins at the base commit.
+
+## Open next questions
+
+1. Does `P120` admit a 1-block pattern of rank at most 31 in characteristic 3?
+   The witness is one free-zero point of one hyperplane of the #6953 column
+   span. Inside that 36-dimensional space the legal fibers have affine
+   dimensions 0, 2 and 5, and this point was not minimized over them. Another
+   basis of the same space has a legal point of rank 36. A first step is one
+   other explicit pattern of rank at most 31, inside this space or outside
+   degree at most 2. A failed search is not a lower bound.
+2. Does every 1-block pattern on `P120` in characteristic 3 have rank at
+   least 32? The cited lower bound is 15, and the class-constant ansatz has
+   rank 120. The rank-36 point in the same space shows that this column space
+   does not by itself force rank 32. A first step is one linear condition
+   satisfied by every legal column, strong enough to force rank at least 32,
+   with the hypotheses written down.
+
+## Credit
+
+DreamingOfClouds, PR #6933, for the window, the port list, and Theorem 4.
+The predecessor pattern of rank 37 on `P120` and rank 36 on `P104` is
+#6953. Prepared by unpaidmoon with substantial Cursor Grok assistance.
+New work is Apache-2.0.
diff --git a/research/p120-char3-rank32-window/SOURCES.json b/research/p120-char3-rank32-window/SOURCES.json
new file mode 100644
index 0000000000..037aa8a1bf
--- /dev/null
+++ b/research/p120-char3-rank32-window/SOURCES.json
@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "17469fff78c22941280f04d39dc5a1faee09c840",
+  "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"
+    },
+    {
+      "path": "research/p104-char3-rank36-window/data/ports_p104.json",
+      "usage": "input",
+      "git_blob": "8037fd10877f49063a1c8a530b40c27f2453dac0",
+      "sha256": "691c7b7d212112115b1bfc76db89f90d304ec448dc8c4a0c43d9a5954317146c"
+    }
+  ]
+}
diff --git a/research/p120-char3-rank32-window/TASK.json b/research/p120-char3-rank32-window/TASK.json
new file mode 100644
index 0000000000..aa27e736b5
--- /dev/null
+++ b/research/p120-char3-rank32-window/TASK.json
@@ -0,0 +1,81 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 8,
+  "base_commit": "17469fff78c22941280f04d39dc5a1faee09c840",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a legal decoder or coframe change improve the full signed moment, including changed helper targets?",
+    "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",
+      "docs/research/recursive-invoice-preflight.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": "Price one complete changed itinerary with both paid and productive histograms. Check #5693/#5698 for overlap and their exact hypotheses before another coframe search. Use the signed invoice preflight where its boundary contract agrees; an inconclusive concave comparison is not a power crossing. Stop if an optimistic complete budget fails at the chosen target or native delivery remains unspecified.",
+    "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": [
+      "coframe",
+      "signed moment",
+      "5693",
+      "5698"
+    ],
+    "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": "Exhibit one 1-block pattern of rank 32 on P120 over F_3, with a 120 by 32 factorisation. No word, moment, or kappa.",
+  "scope_change_reason": "The card asks whether a decoder or coframe change improves the signed moment. This package does not change a word or a moment. It answers the P120 question left open by PR 6953: the recorded degree-at-most-2 point has rank 37 there, and the off-characteristic ceiling is 36. The result is a rank upper bound for that window, not a supplier admission.",
+  "bottleneck_link": "A k-block decoder mask on these ports is the fractional Haemers window of the odd graph. Characteristic 3 was the only odd characteristic whose recorded P120 pattern sat strictly above the off-character ceiling 36. A rank-32 pattern there lowers that ceiling. This is a scoped rank witness, not a signed-moment improvement.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after one explicit characteristic-3 pattern on P120 whose rank is checked exactly, together with the 120 by 32 factorisation and the same-space rank-36 comparison point. Do not search the affine fibers for a smaller rank, and do not reopen the F_5 rank-13 factorisation.",
+  "outcome": "partial",
+  "evidence": "PROOF.md Theorem 1. verify.py prints PASS_P120_CHAR3_RANK32 rank=32 p104=32 p112=[32, 32]. The lower bounds 13, 14 and 15 are cited from PR 6933 Theorem 4 and are not replayed. Rank 32 is one witness, not a minimum.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Substantial Cursor Grok assistance.",
+  "open_questions": [
+    {
+      "question": "Does P120 admit a 1-block pattern of rank at most 31 over a field of characteristic 3?",
+      "why_it_matters": "The witness has rank 32, below the off-characteristic ceiling 36 and below the rank-37 point of PR 6953. The same 36-dimensional space also contains a legal point of rank 36, so this basis was not minimized.",
+      "first_step": "Exhibit one other pattern of rank at most 31, either another point of this affine family or a column space outside degree at most 2.",
+      "blocked_by": "Only two explicit points of the space were evaluated, of ranks 32 and 36. The legal fibers have affine dimensions 0, 2 and 5. An incomplete search would not be a lower bound."
+    },
+    {
+      "question": "Does every 1-block pattern on P120 in characteristic 3 have rank at least 32?",
+      "why_it_matters": "An upper bound of 32 leaves the cited lower bound at 15. Equality is not claimed, and the rank-36 point in the same space shows that this column space does not force rank 32.",
+      "first_step": "Prove rank at least 32 under explicit hypotheses that apply to every 1-block pattern, not only to this space.",
+      "blocked_by": "The class-constant ansatz has rank 120, which does not force 32. No linear condition satisfied by every legal column is proved here."
+    }
+  ]
+}
diff --git a/research/p120-char3-rank32-window/VERIFY.json b/research/p120-char3-rank32-window/VERIFY.json
new file mode 100644
index 0000000000..1a193fe3d8
--- /dev/null
+++ b/research/p120-char3-rank32-window/VERIFY.json
@@ -0,0 +1,20 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/p104-char3-rank36-window/data/ports_p104.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Exhaustive check of the degree-2 syzygy and evaluation rank 45; the #6953 free-zero point still has rank 37; the eight weight-7 vectors omitting coordinate 8 are exactly the rigid columns of that span; the second vector of their 29-element kernel basis is the unique line whose hyperplane meets every legal flat; the free-zero pattern in the carried basis has rank 32, affine nullities 0, 2 and 5, and sha256 81e209bb5be3c3e9b9a5d593190fd9b19540656bb0162164f4df7a1f0bf4a8c4; its pivot columns are a 120 by 32 factorisation; P104 and both P112 principals have rank 32; the same space in the relation-kernel basis has a legal point of rank 36; controls reject a planted orthogonal entry, a zero diagonal, pure quadrics, and report class-constant rank 120."
+    }
+  ]
+}
diff --git a/research/p120-char3-rank32-window/verify.py b/research/p120-char3-rank32-window/verify.py
new file mode 100644
index 0000000000..a879c23ddb
--- /dev/null
+++ b/research/p120-char3-rank32-window/verify.py
@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""Rank-32 characteristic-3 pattern on P120.
+
+No kappa claim. Standard library only.
+
+The pattern is one explicit 1-block pattern. Legality is checked on every
+vertex and every orthogonal pair. Rank is the number of pivots in Gaussian
+elimination over F_3. This is not a census of all patterns, and it is not a
+proof that every pattern has rank at least 32.
+"""
+
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+REPO = ROOT.parents[1]
+PORTS = REPO / "research" / "p104-char3-rank36-window" / "data" / "ports_p104.json"
+PORTS_SHA256 = "691c7b7d212112115b1bfc76db89f90d304ec448dc8c4a0c43d9a5954317146c"
+MATRIX_SHA256 = "81e209bb5be3c3e9b9a5d593190fd9b19540656bb0162164f4df7a1f0bf4a8c4"
+# Principal ranks of this same witness, in port-file order and clique order.
+P104_RANK = 32
+P112_RANKS = {
+    (7, 25, 42, 52, 76, 82, 97, 127): 32,
+    (67, 104, 137, 162, 266, 289, 448, 491): 32,
+}
+
+
+def require(ok, message):
+    if not ok:
+        raise SystemExit("FAIL: " + message)
+
+
+def weight(v):
+    return v.bit_count()
+
+
+def odd_dot(a, b):
+    return ((a & b).bit_count() & 1) == 1
+
+
+def vertices():
+    return [v for v in range(512) if weight(v) % 4 == 3]
+
+
+def pairs():
+    return [(i, j) for i in range(9) for j in range(i + 1, 9)]
+
+
+def rref(matrix, width):
+    """Reduced row echelon form. pivot_of[col] is the row of that pivot, or None.
+
+    Elimination runs left to right. The pivot is scaled to 1 and cleared above
+    and below. The result is the unique reduced row echelon form.
+    """
+    mat = [row[:] for row in matrix]
+    extra = len(mat[0]) - width
+    pivot_of = [None] * width
+    rank = 0
+    for col in range(width):
+        pivot = None
+        for row in range(rank, len(mat)):
+            if mat[row][col] % 3:
+                pivot = row
+                break
+        if pivot is None:
+            continue
+        mat[rank], mat[pivot] = mat[pivot], mat[rank]
+        inverse = pow(mat[rank][col], -1, 3)
+        for k in range(col, width + extra):
+            mat[rank][k] = mat[rank][k] * inverse % 3
+        for row in range(len(mat)):
+            if row == rank or mat[row][col] % 3 == 0:
+                continue
+            factor = mat[row][col] % 3
+            for k in range(col, width + extra):
+                mat[row][k] = (mat[row][k] - factor * mat[rank][k]) % 3
+        pivot_of[col] = rank
+        rank += 1
+    return mat, pivot_of
+
+
+def rank_of(rows):
+    if not rows:
+        return 0
+    _, pivots = rref(rows, len(rows[0]))
+    return sum(pivot is not None for pivot in pivots)
+
+
+def kernel_basis(rows, width):
+    """Canonical kernel basis of a row space, one vector per free column.
+
+    Free columns are taken in increasing order. The vector for a free column
+    has a 1 there, 0 in every other free column, and pivot entries equal to
+    the negation of the reduced-row-echelon coefficient. It does not depend
+    on the order of the input rows, because the reduced form is unique.
+    """
+    if not rows:
+        return [[1 if i == j else 0 for i in range(width)] for j in range(width)]
+    reduced, pivots = rref(rows, width)
+    basis = []
+    for free in [col for col, pivot in enumerate(pivots) if pivot is None]:
+        vector = [0] * width
+        vector[free] = 1
+        for col, pivot in enumerate(pivots):
+            if pivot is not None:
+                vector[col] = (-reduced[pivot][free]) % 3
+        basis.append(vector)
+    return basis
+
+
+def solve_free_zero(rows, width):
+    """Particular solution with free variables set to 0, or None if inconsistent."""
+    reduced, pivots = rref(rows, width)
+    rank = sum(pivot is not None for pivot in pivots)
+    for row in range(rank, len(reduced)):
+        if reduced[row][width] % 3:
+            return None
+    solution = [0] * width
+    for col, pivot in enumerate(pivots):
+        if pivot is not None:
+            solution[col] = reduced[pivot][width]
+    return solution
+
+
+def dot(left, right):
+    return sum(x * y for x, y in zip(left, right)) % 3
+
+
+def features(v):
+    """45 coordinates: 1, x0..x8, and x_i x_j for every pair except (7, 8)."""
+    bits = [(v >> i) & 1 for i in range(9)]
+    coords = [1]
+    coords.extend(bits)
+    for i, j in pairs():
+        if (i, j) != (7, 8):
+            coords.append(bits[i] * bits[j])
+    return [c % 3 for c in coords]
+
+
+def orthogonal(verts):
+    lists = [[] for _ in verts]
+    for i, u in enumerate(verts):
+        for j in range(i + 1, len(verts)):
+            if not odd_dot(u, verts[j]):
+                lists[i].append(j)
+                lists[j].append(i)
+    return lists
+
+
+def legal_rows(phi, orth, j, rhs_self):
+    return [phi[i][:] + [0] for i in orth[j]] + [phi[j][:] + [rhs_self]]
+
+
+def valid_pattern(matrix, verts):
+    for i, u in enumerate(verts):
+        if matrix[i][i] % 3 == 0:
+            return False
+        for j in range(i + 1, len(verts)):
+            if odd_dot(u, verts[j]):
+                continue
+            if matrix[i][j] % 3 or matrix[j][i] % 3:
+                return False
+    return True
+
+
+def principal(matrix, index):
+    return [[matrix[i][j] for j in index] for i in index]
+
+
+def relation_rows():
+    """Nine coefficient relations that cut out the same 36-dimensional space.
+
+    Layout: c, a0..a8, then b_ij for pairs other than (7, 8), in pair order.
+    """
+    width = 45
+    pair_index = {}
+    cursor = 10
+    for i, j in pairs():
+        if (i, j) == (7, 8):
+            continue
+        pair_index[(i, j)] = cursor
+        cursor += 1
+    rows = []
+    constant = [0] * width
+    constant[0] = 1
+    constant[9] = 1
+    rows.append(constant)
+    trace = [0] * width
+    for i in range(8):
+        trace[1 + i] = 1
+    trace[9] = 2
+    for i, j in pairs():
+        if j <= 7:
+            trace[pair_index[(i, j)]] = 2
+    rows.append(trace)
+    for i in range(7):
+        row = [0] * width
+        row[pair_index[(i, 8)]] = 1
+        rows.append(row)
+    return rows
+
+
+def main():
+    verts = vertices()
+    require(len(verts) == 120, "P120 count")
+    require(sum(weight(v) == 3 for v in verts) == 84, "weight-3 count")
+    require(sum(weight(v) == 7 for v in verts) == 36, "weight-7 count")
+    orth = orthogonal(verts)
+    phi = [features(v) for v in verts]
+    require(len(phi[0]) == 45, "chart width")
+
+    # The dropped monomial is redundant on P120: every pair product sums to 0.
+    syzygy_values = []
+    for v in verts:
+        bits = [(v >> i) & 1 for i in range(9)]
+        total = 0
+        for i, j in pairs():
+            total += bits[i] * bits[j]
+        syzygy_values.append(total % 3)
+    require(syzygy_values == [0] * 120, "pair-sum syzygy")
+    require(rank_of(phi) == 45, "degree-2 evaluation rank")
+    print("PASS_CHART rank45 syzygy=0")
+
+    witness = []
+    for j in range(len(verts)):
+        solution = solve_free_zero(legal_rows(phi, orth, j, 1), 45)
+        require(solution is not None, "degree-2 system inconsistent at %d" % j)
+        witness.append(solution)
+    witness_matrix = [
+        [dot(phi[u], witness[v]) for v in range(len(verts))] for u in range(len(verts))
+    ]
+    require(valid_pattern(witness_matrix, verts), "degree-2 witness is not a pattern")
+    require(rank_of(witness_matrix) == 37, "degree-2 free-zero rank is not 37")
+    print("PASS_PREDECESSOR_POINT rank37")
+
+    reduced, pivots = rref(witness, 45)
+    span_dim = sum(pivot is not None for pivot in pivots)
+    require(span_dim == 37, "witness column span %d" % span_dim)
+    basis = [reduced[row][:45] for row in range(span_dim)]
+    evaluation = [[dot(phi[u], basis[t]) for t in range(span_dim)] for u in range(len(verts))]
+
+    def coordinates(vector):
+        rows = [[basis[t][i] for t in range(span_dim)] + [vector[i]] for i in range(45)]
+        solution = solve_free_zero(rows, span_dim)
+        require(solution is not None, "vector outside the witness span")
+        return solution
+
+    witness_coords = [coordinates(column) for column in witness]
+    direction_dim = []
+    for j in range(len(verts)):
+        rows = [evaluation[i][:] for i in orth[j] + [j]]
+        direction_dim.append(len(kernel_basis(rows, span_dim)))
+    rigid_index = [j for j, dim in enumerate(direction_dim) if dim == 0]
+    rigid_vertices = [verts[j] for j in rigid_index]
+    expected_rigid = [v for v in verts if weight(v) == 7 and ((v >> 8) & 1) == 0]
+    require(rigid_vertices == expected_rigid, "rigid set %s" % rigid_vertices)
+    require(len(rigid_vertices) == 8, "rigid count")
+    require(rank_of([witness_coords[j] for j in rigid_index]) == 8, "rigid columns")
+    print("PASS_RIGID_COLUMNS count=8 bit8_clear_weight7")
+
+    dual = kernel_basis([witness_coords[j] for j in rigid_index], span_dim)
+    require(len(dual) == 29, "annihilator of the rigid columns")
+
+    def meets_every_flat(form):
+        if all(entry == 0 for entry in form):
+            return False
+        for j in range(len(verts)):
+            rows = [evaluation[i][:] + [0] for i in orth[j]] + [evaluation[j][:] + [1]]
+            # Restrict the unknown to ker(form) by one extra equation form·c = 0,
+            # and test consistency of the legal system inside the witness span.
+            rows.append(form[:] + [0])
+            if solve_free_zero(rows, span_dim) is None:
+                return False
+        return True
+
+    good_lines = [i for i, form in enumerate(dual) if meets_every_flat(form)]
+    require(good_lines == [1], "hyperplane lines %s" % good_lines)
+    print("PASS_HYPERPLANE_LINE index=1 of 29")
+
+    form = dual[1]
+    space = []
+    for coord in kernel_basis([form], span_dim):
+        ambient = [0] * 45
+        for t, scale in enumerate(coord):
+            if scale:
+                for i in range(45):
+                    ambient[i] = (ambient[i] + scale * basis[t][i]) % 3
+        space.append(ambient)
+    require(len(space) == 36 and rank_of(space) == 36, "hyperplane dimension")
+    relation_rank = rank_of(relation_rows() + kernel_basis(space, 45))
+    # The nine declared relations and the annihilator of the space are the same.
+    require(rank_of(relation_rows()) == 9, "relation rank")
+    require(rank_of(kernel_basis(space, 45)) == 9, "annihilator rank")
+    require(relation_rank == 9, "relations do not cut out the hyperplane")
+    print("PASS_COEFFICIENT_RELATIONS n=9")
+
+    factor = [[dot(phi[u], column) for column in space] for u in range(len(verts))]
+    require(rank_of(factor) == 36, "evaluation of the hyperplane")
+    coefficients = []
+    affine = {}
+    for j in range(len(verts)):
+        rows = legal_rows(factor, orth, j, 1)
+        solution = solve_free_zero(rows, 36)
+        require(solution is not None, "hyperplane system inconsistent at %d" % j)
+        _, pivots = rref(rows, 36)
+        freedom = 36 - sum(pivot is not None for pivot in pivots)
+        affine[freedom] = affine.get(freedom, 0) + 1
+        coefficients.append(solution)
+    require(affine == {0: 36, 2: 56, 5: 28}, "affine dimensions %s" % affine)
+    print("PASS_AFFINE_DIMENSIONS 0=36 2=56 5=28")
+    matrix = [
+        [dot(factor[u], coefficients[v]) for v in range(len(verts))]
+        for u in range(len(verts))
+    ]
+    require(valid_pattern(matrix, verts), "rank-32 candidate is not a pattern")
+    pattern_rank = rank_of(matrix)
+    reversed_rank = rank_of([row[::-1] for row in matrix])
+    transpose_rank = rank_of([list(column) for column in zip(*matrix)])
+    require(pattern_rank == reversed_rank == transpose_rank == 32, "ranks %s" % pattern_rank)
+    digest = hashlib.sha256(bytes(entry for row in matrix for entry in row)).hexdigest()
+    require(digest == MATRIX_SHA256, "matrix sha256 %s" % digest)
+
+    # Literal 120 by 32 factorisation: pivot columns of the pattern, then coordinates.
+    _, row_pivots = rref(matrix, len(verts))
+    independent = [c for c, pivot in enumerate(row_pivots) if pivot is not None]
+    require(len(independent) == 32, "pivot column count")
+    narrow = [[matrix[r][c] for c in independent] for r in range(len(verts))]
+    require(rank_of(narrow) == 32, "narrow factor rank")
+    for c in range(len(verts)):
+        target = [matrix[r][c] for r in range(len(verts))]
+        rows = [narrow[r][:] + [target[r]] for r in range(len(verts))]
+        require(solve_free_zero(rows, 32) is not None, "column %d outside the 32-factor" % c)
+    print("PASS_FACTORISATION shape=120x32 rank=32 sha256=%s" % digest)
+
+    edge_values = {
+        matrix[i][j]
+        for i in range(len(verts))
+        for j in range(len(verts))
+        if i != j and odd_dot(verts[i], verts[j])
+    }
+    asymmetric = any(
+        matrix[i][j] != matrix[j][i]
+        for i in range(len(verts))
+        for j in range(i + 1, len(verts))
+    )
+    require(asymmetric and len(edge_values) > 1, "pattern collapsed to a class-constant matrix")
+
+    raw = PORTS.read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == PORTS_SHA256, "P104 port bytes")
+    ports = json.loads(raw)["ports"]
+    deleted = set(verts) - set(ports)
+    require(len(ports) == 104 and len(deleted) == 16, "port counts")
+    require(set().union(*P112_RANKS) == deleted, "deleted cliques")
+    index = {v: i for i, v in enumerate(verts)}
+    port_index = [index[v] for v in ports]
+    p104 = principal(matrix, port_index)
+    require(valid_pattern(p104, ports), "P104 principal submatrix")
+    p104_rank = rank_of(p104)
+    require(p104_rank == P104_RANK, "P104 rank %d" % p104_rank)
+    seen = {}
+    for clique, expected in P112_RANKS.items():
+        block = list(ports) + list(clique)
+        rows = principal(matrix, [index[v] for v in block])
+        require(valid_pattern(rows, block), "P112 pattern")
+        require(all(odd_dot(a, b) for a in clique for b in clique if a < b), "clique")
+        seen[clique] = rank_of(rows)
+        require(seen[clique] == expected, "P112 rank %s for %s" % (seen[clique], clique))
+    print("PASS_PRINCIPAL p104=%d p112=%s" % (P104_RANK, sorted(seen.values())))
+
+    # The same space in the relation-kernel basis has another legal point.
+    # Its rank is 36, so rank 32 is a property of this basis, not of every
+    # pattern whose columns lie in the space.
+    relation_basis = kernel_basis(relation_rows(), 45)
+    require(len(relation_basis) == 36, "relation kernel")
+    relation_factor = [
+        [dot(phi[u], column) for column in relation_basis] for u in range(len(verts))
+    ]
+    relation_columns = []
+    for j in range(len(verts)):
+        solution = solve_free_zero(legal_rows(relation_factor, orth, j, 1), 36)
+        require(solution is not None, "relation basis inconsistent at %d" % j)
+        relation_columns.append(solution)
+    relation_matrix = [
+        [dot(relation_factor[u], relation_columns[v]) for v in range(len(verts))]
+        for u in range(len(verts))
+    ]
+    require(valid_pattern(relation_matrix, verts), "relation-basis point is not a pattern")
+    require(rank_of(relation_matrix) == 36, "relation-basis rank")
+    print("PASS_SAME_SPACE_OTHER_POINT rank36")
+
+    planted = [row[:] for row in matrix]
+    pair = next(i for i in range(1, len(verts)) if not odd_dot(verts[0], verts[i]))
+    planted[0][pair] = (planted[0][pair] + 1) % 3
+    require(not valid_pattern(planted, verts), "control accepted a planted orthogonal entry")
+    killed = [row[:] for row in matrix]
+    killed[0][0] = 0
+    require(not valid_pattern(killed, verts), "control accepted a zero diagonal")
+    pure = []
+    for v in verts:
+        bits = [(v >> i) & 1 for i in range(9)]
+        pure.append([bits[i] * bits[j] % 3 for i, j in pairs()])
+    pure_fail = solve_free_zero(legal_rows(pure, orth, 0, 1), 36)
+    require(pure_fail is None, "control: pure quadrics solved vertex 0")
+    full = []
+    for beta in (0, 1, 2):
+        rows = [[0] * 120 for _ in range(120)]
+        for i, u in enumerate(verts):
+            rows[i][i] = 1
+            for j in range(i + 1, 120):
+                if odd_dot(u, verts[j]):
+                    rows[i][j] = rows[j][i] = beta
+        full.append(rank_of(rows))
+    require(full == [120, 120, 120], "class-constant ranks %s" % full)
+    print("PASS_CONTROLS planted=1 zero_diagonal=1 pure_quadrics=inconsistent class_constant=120")
+    print("PASS_P120_CHAR3_RANK32 rank=32 p104=%d p112=%s" % (P104_RANK, sorted(seen.values())))
+
+
+if __name__ == "__main__":
+    main()