Bound the E8 label pairing rank by 9 and screen it.

research/e8-label-pairing-rank-cap/PROOF.md

@@ -0,0 +1,77 @@
+# Pairing rank of the E8 label alphabet is at most 9
+
+This note bounds one support alphabet. It does not construct a decoder, price a
+frame or a restoration, or change κ. The selected exponent stays
+`0.001672660197076918`.
+
+## Alphabet
+
+Use the 240 doubled E8 roots and their 120 lines, with the integer inner
+product normalized by 4. Off the diagonal those products lie in `{-1, 0, 1}`,
+and each line has norm 2. The PR717 label pairing is the `120 × 120` matrix
+over `F_2`
+
+```text
+B_ij = (<r_i, r_j> + 1) mod 2.
+```
+
+`verify.py` rebuilds this matrix from the roots. It does not import the
+frame-pair decoder checker.
+
+## Rank cap
+
+Gaussian elimination produces nine independent rows. Every one of the 120 rows
+reduces to zero against that basis, so the row space has dimension 9 and
+`rank(B) = 9`.
+
+Any term support is a row set `X` and a column set `Y`. The corresponding
+block is a column restriction of a set of vectors in a 9-dimensional space, so
+
+```text
+rank B[X, Y] <= 9.
+```
+
+The same nine basis rows, kept against all 120 columns, have rank 9. The cap
+is attained by those supports. A synthetic extra column of rank 10 is rejected
+by the rank routine and is not a row of `B`.
+
+If a child in this alphabet is priced by this pairing rank, no such child has
+rank 10 or more. Copies, frame conversions and restoration that are not
+themselves pairing-rank terms of `B` are outside the alphabet.
+
+## Favorable screen on the selected template
+
+The pinned ceiling record fixes the selected template: width 73, `2 · 4 · 112`
+families, nine stages, centre charge 64, local mass 5586 and idle mass 1646.
+The outer halving guard leaves idle rank 51. The published local profile is
+`{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}`.
+
+For `a > 0`, the per-unit child cost `r^{-a} m^{a-1}` is strictly decreasing
+in the child rank `r`. The checker compares the pinned enclosures at
+`a = 1/99` for every rank `1..8` against rank 9. Among local histograms of
+mass 5586 whose ranks are at most 9, the fractional histogram
+
+```text
+{9: 5586/9}
+```
+
+is therefore strictly cheapest at that saving. It keeps the same idle mass
+1646, packed at rank 51. Its relaxation moment is strictly above 1. The
+integer histogram `{9:620, 6:1}` has the same mass and is also strictly above
+1. The certified ceiling bracket of the fractional histogram, on the pinned
+`1e-15` grid, lies strictly below `1/99`.
+
+The same screen accepts the fractional rank-44 histogram at `a = 1/99`. The
+rank-9 failure is not a comparator that rejects every profile.
+
+Extra local children of rank at most 9, including unpaid frame or restoration
+children inside this alphabet, add a nonnegative moment and cannot bring the
+relaxation back through 1. A child whose rank is not a pairing rank of `B` is
+a different alphabet.
+
+## What this does not say
+
+The cap is not a bound on multiplication width, on idle children, or on a
+block climb whose rank is a tensor or frame dimension. It does not say that an
+exact eight-term decoder uses a rank-9 term. It does not meet the card's
+five-percent construction gate. No new κ is claimed.

research/e8-label-pairing-rank-cap/README.md

@@ -0,0 +1,80 @@
+# The E8 label alphabet cannot emit a local child of rank above 9
+
+**Scoped obstruction. No new κ.** Selected κ stays `0.001672660197076918`.
+
+On the 120 root lines of E8, the PR717 label pairing
+`B_ij = (<r_i, r_j> + 1) mod 2` has `F_2` rank 9. Every row lies in that
+9-dimensional row space, so every support pair has pairing rank at most 9.
+Nine basis lines against all 120 columns attain rank 9. The argument is in
+[PROOF.md](PROOF.md).
+
+On the selected template pinned by
+`research/complex-local-word-ceiling/RESULT.json` (width 73, 896 families,
+nine stages, centre 64, local mass 5586, idle mass 1646, idle cap 51), the
+cheapest local histogram whose children have rank at most 9 is the fractional
+profile `{9: 5586/9}`. Its relaxation at `a = 1/99` is strictly above 1, and
+its ceiling on the pinned `1e-15` grid is the bracket
+`(1409316073/488281250000, 577255863501/200000000000000)`, whose upper end is
+strictly below `1/99`. The integer
+histogram `{9: 620, 6: 1}` fails the same saving. A fractional rank-44
+histogram passes that one-point screen, so the failure is specific to the cap.
+
+This is the catalogue method “bound the best effective child rank for one
+fixed support alphabet,” narrowed to the PR717 label pairing. Frame,
+restoration and copy children that are not pairing-rank terms of `B` are
+outside the alphabet. Inside it, those extra children of rank at most 9
+cannot repair a moment that is already above 1.
+
+## Scope and evidence
+
+Original card: `complex-rank-shape-decoder`. Scope is **refined**: one
+alphabet and the favorable rank-cap screen, not a block-climb construction.
+The connection to the bottleneck is the rank-shape lever. Rank-1 children are
+about half of the selected recursive cost; this alphabet cannot replace them
+by children of rank 10 or more, and rank 9 still misses `a = 1/99` before any
+frame or restoration charge.
+
+`verify.py` rebuilds the 240 roots, checks the pairing rank and the row-space
+certificate, and evaluates the pinned `ceiling.py` enclosures. It does not
+import the frame-pair decoder package.
+
+## Reproduce
+
+Python 3.12, standard library, from the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/e8-label-pairing-rank-cap
+```
+
+Expected marker:
+
+```text
+PASS_E8_LABEL_PAIRING_RANK_CAP
+```
+
+The registered replay also repeats the checker under `-O`. Direct
+`python3 -B research/e8-label-pairing-rank-cap/verify.py` prints the witness
+line indices, the `1/99` relaxation lower bound and the ceiling bracket.
+
+## Open next questions
+
+1. Does exactness of an eight-term all-pairs decoder force every term’s
+   pairing rank to be at most 8, or does some live support attain 9? A single
+   dual-basis term of rank 9 would show the alphabet cap is realized by an
+   exact term; a proof that exactness stops at 8 would tighten this screen.
+   No decoder search is run here.
+2. Can a block-climb child whose rank is a multiplication width, rather than
+   a pairing rank of `B`, exceed 9 on this template without leaving the
+   coverage law? The first step is one legal width-10 child with its frame
+   and restoration bill. This package has no such itinerary.
+
+## Credit
+
+The E8 line model and the rank-9 pairing fact are the PR717 alphabet as
+recorded by themilkman216 in `research/complex-frame-pair-decoders`. The
+selected-template ceiling engine and the published local mass are Douglas
+Colkitt’s `research/complex-local-word-ceiling`, with Claude assistance. The
+rank-cap question left open by that ceiling is Nick Petalas’s discussion
+comment on PR #3701. New rank-space certificate and screen by unpaidmoon,
+with substantial Cursor Grok assistance. Apache-2.0. No independent human or
+formal-kernel review is claimed.

research/e8-label-pairing-rank-cap/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/RESULT.json",
+      "usage": "input",
+      "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9",
+      "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/ceiling.py",
+      "usage": "input",
+      "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+      "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+    }
+  ]
+}

research/e8-label-pairing-rank-cap/TASK.json

@@ -0,0 +1,78 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 6,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md",
+      "research/selected-k8-unrestricted-ends/README.md",
+      "research/eisenstein-reduction-copy-floor/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "PR717 E8 label pairing on 120 root lines: every support pair has F2 rank at most 9, the bound is attained, and the favorable selected-template local histogram of mass 5586 under that cap misses a=1/99.",
+  "scope_change_reason": "The card's second method asks for the best effective child rank of one fixed support alphabet, with copies, frames and restoration counted. This package takes the PR717 E8 label pairing as that alphabet and proves its pairing rank is at most 9. The moment screen prices only those pairing-rank children. Frame and restoration children inside the alphabet can only raise the moment; children whose rank is not a pairing rank are outside the alphabet and are named as an open question.",
+  "bottleneck_link": "Rank-1 children are about half of the selected recursive cost. This alphabet cannot replace them by pairing-rank children above 9, and rank 9 still misses the planning target a=1/99 before frame or restoration charges.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop once the row-space certificate, the attained rank-9 witness, and the favorable 1/99 screen are checked. Do not search for an exact decoder term of rank 9 or a width-10 block climb.",
+  "outcome": "negative-result",
+  "evidence": "verify.py rebuilds B, reduces every row into a 9-dimensional basis, attains rank 9 on that basis, and evaluates pinned ceiling.relax at a=1/99 for {9:5586/9} and {9:620,6:1}. Both lie strictly above 1. The 1e-15 ceiling bracket lies strictly below 1/99. A rank-44 fractional control passes the same one-point screen.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Substantial Cursor Grok assistance. No independent human or formal-kernel review.",
+  "open_questions": [
+    {
+      "question": "Does an exact eight-term all-pairs decoder on a live E8 set attain pairing rank 9 on any term, or does exactness force every term to rank at most 8?",
+      "why_it_matters": "The alphabet cap is 9 and is attained by some supports. If exact terms stop at 8, the favorable screen on this template gets stricter.",
+      "first_step": "Exhibit one dual-basis term whose live supports have pairing rank 9, or prove that AB^T=2I forces every term rank to be at most 8.",
+      "blocked_by": "This package does not search decoders or replay the eight-term census."
+    },
+    {
+      "question": "Can a block-climb child whose rank is a multiplication width, rather than a pairing rank of B, exceed 9 under the selected coverage law?",
+      "why_it_matters": "A width-10 child would leave this alphabet. The rank-9 screen does not forbid it, and the published cap curve says rank 44 is the first cap that can clear a=1/99 when idle stays at rank 51.",
+      "first_step": "Name one legal width-10 child on the selected template and charge its frame and restoration before screening the profile.",
+      "blocked_by": "No source-bound width-10 itinerary is an input of this package."
+    }
+  ]
+}

research/e8-label-pairing-rank-cap/VERIFY.json

@@ -0,0 +1,33 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/complex-local-word-ceiling/RESULT.json",
+    "research/complex-local-word-ceiling/ceiling.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Rebuild the 120 E8 label rows, certify pairing rank 9 and attainment, reject a synthetic rank-10 row, and screen the favorable rank-9 local histogram against a=1/99 with the pinned ceiling engine. The rank-44 control must pass that one-point screen."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Repeat the same certificate with interpreter optimization enabled. Rejection checks do not use assertions."
+    }
+  ]
+}