From d581e77beafa014ec22b54a9afc31c08504ddd7c Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 12:27:40 +0900
Subject: [PATCH 1/7] Prove asymmetric hypercube star obstruction and local
 puncture threshold

---
 .../asymmetric-hypercube-decoder/CLAIM.json   |  33 +
 .../asymmetric-hypercube-decoder/README.md    | 204 ++++++
 .../asymmetric-hypercube-decoder/SOURCES.json |  44 ++
 .../asymmetric-hypercube-decoder/results.json | 590 ++++++++++++++++++
 .../asymmetric-hypercube-decoder/verify.py    | 287 +++++++++
 5 files changed, 1158 insertions(+)
 create mode 100644 research/asymmetric-hypercube-decoder/CLAIM.json
 create mode 100644 research/asymmetric-hypercube-decoder/README.md
 create mode 100644 research/asymmetric-hypercube-decoder/SOURCES.json
 create mode 100644 research/asymmetric-hypercube-decoder/results.json
 create mode 100644 research/asymmetric-hypercube-decoder/verify.py

diff --git a/research/asymmetric-hypercube-decoder/CLAIM.json b/research/asymmetric-hypercube-decoder/CLAIM.json
new file mode 100644
index 0000000000..e84a1a4fc2
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CLAIM.json
@@ -0,0 +1,33 @@
+{
+  "track": "Structural decoder research",
+  "assignment_seed": 48,
+  "randomness": "Python secrets.randbelow(100), operating-system randomness",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "object": "Arbitrary target-dependent coefficients on global stars of degree less than k; exact fixed-target puncture threshold for the target-local subfamily, focusing on k=4 and k=8",
+  "method": "Boolean-lattice coefficient equations and exact F2 linear algebra; quantify the fixed-target puncture threshold",
+  "deliverable": "Scoped negative result with written proof, deterministic exact checker, source pins and negative controls; no kappa claim",
+  "expected_finish": "2026-10-13T12:53:00+09:00",
+  "coordination": "GitHub pinnedIssues query returned none; local claim only, no reservation issue opened",
+  "candidates_considered": [
+    {
+      "task": "E8 deeper star punctures",
+      "decision": "Not selected: overlaps pending PR631 exact flat census"
+    },
+    {
+      "task": "P120 ten-total non-star decoder",
+      "decision": "Not selected: PR620 already records an unresolved 40-minute SAT run; no distinct bounded method ready"
+    },
+    {
+      "task": "Nonuniform stars on paired hypercube ports",
+      "decision": "Selected: removes the coefficient symmetry assumption of PR231 and quantifies fixed-target erasure robustness"
+    }
+  ],
+  "seed_use": "48 selects structural track and prioritizes k=4 and k=8 power-of-two cases; finite sampling, if used, is seeded 48",
+  "prior_work": {
+    "231": "Merged hypercube-decoder-parity note by Joel Pulikkan / GamingPuzzled; symmetric coefficient family",
+    "631": "E8 root-line punctures, different geometry; reviewed at fb893b5ee1317c2da3b297e6fe78eca0857d1a76",
+    "620": "E8 decoder research; partially reviewed in current ledger; head e9cf03bbdf7094b5a83f6dbd1d74bfd77a05fb87",
+    "231_head": "3c11e696a2fb2c454585d72710de27cd6bd3be68"
+  },
+  "status": "claimed"
+}
diff --git a/research/asymmetric-hypercube-decoder/README.md b/research/asymmetric-hypercube-decoder/README.md
new file mode 100644
index 0000000000..4dad05a71c
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/README.md
@@ -0,0 +1,204 @@
+# Asymmetric stars do not evade the hypercube parity obstruction
+
+**Scoped negative result; no new κ.** The symmetric-coefficient result in
+[PR #231](https://github.com/CrocSwap/integer-mult-bounds/pull/231), by
+Joel Pulikkan / GamingPuzzled, extends to arbitrary target-dependent coefficients
+on **all stars of degree less than k, including off-target stars**. For the
+smaller target-local star family, the exact minimum number of deleted ports
+needed to decode one retained target at a power-of-two k is **2(p − k) + 1**.
+
+The first result closes an algebraic escape route: asymmetric reweighting or
+off-target proper stars cannot rescue an unpunctured 4- or 8-dimensional paired
+hypercube decoder. The second quantifies how fragile that obstruction can be
+under puncturing, without claiming a construction for all remaining targets.
+
+## Model and predecessor
+
+Let p ≥ k ≥ 2. The coordinates are p disjoint pairs. A port is a k-element set
+containing one coordinate from each of k distinct pairs. Write P for all
+2^k binom(p,k) ports. The independent input symbols x_S take values in F₂.
+For a surviving family F ⊆ P containing a fixed target T, define
+
+```text
+star_L(F) = sum_{S in F, L subset S} x_S
+C_j(T,F) = sum_{S in F, |S intersect T| = j} x_S.
+```
+
+All sums and coefficients below are in F₂. A global proper-star decoder has
+the form
+
+```text
+x_T = sum_{L: 0 < |L| < k} a_(T,L) star_L(F)
+      + sum_{j=1}^{k-1} b_(T,j) C_j(T,F).                 (1)
+```
+
+Here L may use any coordinates; sets containing both coordinates of a pair
+give a zero star and can be omitted. Coefficients may depend independently on
+T and L. Within each correction C_j, the same coefficient applies to every
+source of that intersection size. The target-local family additionally
+requires L ⊂ T. Degree-k stars and the j=0 and j=k correction classes are
+excluded. A degree-k star would directly supply x_T; the j=k correction would
+do the same. Allowing an empty-set star does not change the unpunctured
+obstruction below.
+
+[The retained #231 note](../hypercube-decoder-parity/README.md) restricts to
+target-local stars with a_(T,L) = a_|L| and establishes existence exactly when
+k is not a power of two. We retain that result and attribution. The new points
+are the larger coefficient/support class in Theorem 1 and the sharp local
+puncture threshold in Theorem 2. This is not a repeat of #231's coefficient
+enumeration. Pending [#631](https://github.com/CrocSwap/integer-mult-bounds/pull/631)
+studies E8 root-line punctures, a different port geometry.
+
+## Theorem 1: arbitrary global proper stars, full port family
+
+For F=P, a decoder of form (1) exists if and only if k is not a power of two.
+
+**Necessity, without a symmetry assumption.** Fix T. Let Q_T be the 2^k ports
+obtained by independently flipping the chosen coordinate in each of T's k
+pairs. XOR the coefficient equations of (1) for all source ports S ∈ Q_T.
+
+For a star_L with |L|<k, the number of such ports containing L is either zero
+(if L uses an outside pair or incompatible coordinates) or 2^(k−|L|). Thus
+every allowed star contributes zero to the summed equation. The same holds
+for the empty star. The correction C_j contributes binom(k,j), since exactly
+that many sign-flip ports intersect T in j coordinates.
+
+If k is a power of two, every binom(k,j), 0<j<k, is even. The right side
+therefore sums to zero, whereas the desired coefficient vector of x_T sums
+to one: **0=1**. This is an explicit binary linear inconsistency certificate,
+not an argument that averages coefficients over symmetries.
+
+**Sufficiency, inherited from #231.** If k is not a power of two, choose
+0<l<k with binom(k,l) odd. Set all local size-l star coefficients to one and
+other star coefficients to zero; set b_(T,j)=binom(j,l) mod 2. For a source
+with j<k intersections, the two coefficients cancel (and j=0 contributes
+zero); at S=T the coefficient is binom(k,l)=1.
+
+For completeness, the binomial parity criterion follows in F₂[z] from
+(1+z)^k = product_{r: bit_r(k)=1}(1+z^(2^r)). With one set bit there are no
+interior terms. With at least two set bits, the least set bit gives an odd
+interior coefficient. The proof applies to every p≥k, not only checked sizes.
+
+## Theorem 2: sharp puncture threshold for target-local stars
+
+Let k≥2 be a power of two, p≥k, and retain a specified T. Restrict to
+0<|L|<k with L⊂T in (1). The smallest possible deletion set D⊆P\{T} for
+which T admits a decoder on F=P\D has size
+
+```text
+min |D| = 1 + 2(p-k).                                  (2)
+```
+
+Both stars and corrections are defined over the surviving family F. This
+statement does **not** cover off-target stars after puncturing.
+
+**Cell sizes.** For J⊂T, |J|=j<k, let P_J be the ports with S∩T=J. Put
+d=k−j and q=p−k. To complete J to such a port, select a of the remaining d
+target pairs (using their opposite coordinates), then d−a outside pairs,
+with two signs each. With out-of-range binomial coefficients taken as zero,
+
+```text
+|P_J| = N_j = sum_{a=0}^d binom(d,a) binom(q,d-a) 2^(d-a)
+            = sum_{u=0}^d binom(d,u) binom(q,u) 2^u.
+```
+
+For every nonempty proper J, d≥1. The u=0 and u=1 terms give
+N_j≥1+2dq≥1+2q, with equality at j=k−1. Thus fewer than 1+2q deletions
+leave at least one representative in every nonempty proper intersection cell.
+
+**Why surviving cells force local symmetry.** For each such J, the coefficient
+equation is
+
+```text
+sum_{empty != L subset J} a_(T,L) = b_(T,|J|).          (3)
+```
+
+Induction on |J| forces a_(T,J) to depend only on |J|: singletons all equal
+b_(T,1); thereafter (3) expresses a_(T,J) as b_(T,|J|) plus the already
+level-constant contributions of proper subsets of J. Write the resulting
+coefficients a_l. The target coefficient must then be
+sum_{l=1}^{k-1} binom(k,l)a_l=0, contradicting the required value one.
+This proves the lower bound in (2). It also shows that any successful local
+puncture must empty at least one entire nonempty proper intersection cell.
+
+In fact, emptying **any** such cell P_J suffices for local decoding of T:
+use the sum of star_L over J⊆L⊊T. Its source coefficient is one precisely
+when S∩T is J or T. For J⊆K⊊T this follows from
+sum_{J⊆L⊆K}1=2^(|K|−|J|); at K=T the excluded term L=T changes the parity
+to one. With P_J deleted this is x_T. Thus the cell criterion characterizes
+local feasibility; a smallest deletion set uses |J|=k−1.
+
+**Sharpness.** Choose a fixed (k−1)-subset J⊂T and delete exactly P_J. These
+are the 1+2(p−k) ports other than T that contain J. Among surviving ports,
+star_J(F)=x_T. Use that single star with coefficient one and set every other
+coefficient to zero. This attains (2).
+
+For comparison, on the full family the same induction proves that all local
+decoders are level-constant at each target. For a non-power-of-two k, the
+k−1 level coefficients satisfy one nonzero binary equation, so there are
+exactly 2^(k−2) local decoders per target. The correction coefficients are
+then determined. This count does not apply to the larger global-star class.
+
+## Verification
+
+Run from the repository root, using only the Python 3.10+ standard library:
+
+```sh
+python3 -B research/asymmetric-hypercube-decoder/verify.py --negative-controls --write /tmp/asymmetric-hypercube.json
+cmp research/asymmetric-hypercube-decoder/results.json /tmp/asymmetric-hypercube.json
+```
+
+The expected result is a PASS message and an identical deterministic receipt.
+The committed receipt covers 9 compressed coefficient systems, 11 actual port
+families, all 131,336 coefficient vectors in its three small cases, all 3,413
+deletion sets in its four bounded puncture cases, and five negative-control
+categories. Fresh runs on Python 3.11.13 and 3.14.5, including Python 3.14.5
+with `-O`, produced identical receipts; no check relies on Python assertions.
+The checker generates actual ports independently of the cell-count formula,
+forms unrestricted target-local coefficient systems, and performs exact F₂
+elimination. It also checks the global-star XOR certificate directly on
+actual sign-flip cubes. Finite coverage and negative controls are enumerated
+in [results.json](results.json); they support the written all-parameter proofs
+above and are not a formal proof of the multiplication theorem.
+
+The experiment domain and stopping rule are fixed by the verifier's case lists:
+complete finite cases, no heuristic search or time-dependent stopping. Seed 48
+selects the structural track and focuses on k=4 and k=8; the verifier records
+its deterministic target choices. Source pins and the starting accepted
+construction are in [SOURCES.json](SOURCES.json), with the sprint scope in
+[CLAIM.json](CLAIM.json). Neither the selected certificate nor `upstream/` is
+changed. The full supplier cold replay is outside this standalone decoder
+result; no new supplier profile is asserted.
+
+## Interpretation and limits
+
+- For the full paired-port family at power-of-two k, arbitrary asymmetric
+  proper-star preparation already fails at the scalar identity. Giving every
+  helper, copy, source read, frame change, restoration and recursive child
+  zero cost cannot repair that failure. There is therefore no positive
+  complete-cost candidate to price or claim as a κ improvement here.
+- The local puncture upper bound decodes only one specified target. Its
+  isolated-star witness says nothing about simultaneously decoding all live
+  ports, restoring arbitrary scratch inputs or improving copied-information
+  cost. It supplies neither a paid recursive profile nor an assembly bound.
+- After puncturing, arbitrary off-target stars are outside Theorem 2. Other
+  correction classes, source-dependent coefficients within a class, degree-k
+  totals, nonlinear mechanisms and different port geometries are outside the
+  obstruction as stated. In particular this is not an E8 decoder ceiling.
+- The selected construction at the base commit has conditional
+  κ=51110230636731/31250000000000000. Its compiler, physical realization,
+  hosting, precision/tape and analytic assumptions are neither used to prove
+  these finite algebraic statements nor discharged by them.
+
+## Attribution and license
+
+Prepared by Sam Sung (@the-missionary-company), with substantial OpenAI Codex
+assistance in the proofs, implementation and independent review. The prior
+symmetric obstruction and parity criterion are Joel Pulikkan / GamingPuzzled's
+#231 contribution, building on icekylinx's #144 paired-cube work and eumemic's
+paired-cube bit identity. The repository preserves those predecessor notices.
+The selected-frontier context credits Chafik Boukhalfa's #626, Jeremy Kothe's
+#622/#623 and eumemic's #543, with the cumulative lineage in its maintainer
+review; this note does not independently re-certify that construction.
+
+New files are licensed under the repository's Apache-2.0 license.
diff --git a/research/asymmetric-hypercube-decoder/SOURCES.json b/research/asymmetric-hypercube-decoder/SOURCES.json
new file mode 100644
index 0000000000..5fed94787a
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/SOURCES.json
@@ -0,0 +1,44 @@
+{
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "repository": "https://github.com/CrocSwap/integer-mult-bounds",
+  "source_sha256_at_base": {
+    "research/hypercube-decoder-parity/README.md": "2dc89289d1d979aec6709b8c55a2af7cd39d97297bc20fb94adc7d4cdf867cd1",
+    "research/hypercube-decoder-parity/check.py": "82b7ad8d54662db3e159301aaf3cf87edfbe934b6ed5bdc01243812966b2ea40",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53",
+    "docs/research/community-k492-review.md": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47",
+    "docs/research/current-status.md": "197319a6edf04340ec3623d09d03714fcd6a981359f22bdcefdd06e7e2f4174d",
+    "docs/research/pr-ledger.md": "2e811684201e08007377ee97b1c35c0f0b3c026dd8207e7b0de3ff7cd1e13a91"
+  },
+  "predecessor": {
+    "pr": 231,
+    "head": "3c11e696a2fb2c454585d72710de27cd6bd3be68",
+    "author": "Joel Pulikkan / GamingPuzzled",
+    "contribution": "Symmetric star/overlap decoder parity obstruction, following icekylinx and eumemic paired-cube work"
+  },
+  "selected_context": {
+    "kappa": "51110230636731/31250000000000000",
+    "source_prs": [
+      626,
+      623,
+      622,
+      543
+    ],
+    "reviewed_pr626_head": "660de893d27bb7abd1d5b01b1640207528a5c851",
+    "scope": "Context only; no supplier replay or changed frontier claim"
+  },
+  "overlap_checks": {
+    "pr620_head": "e9cf03bbdf7094b5a83f6dbd1d74bfd77a05fb87",
+    "pr631_head": "fb893b5ee1317c2da3b297e6fe78eca0857d1a76",
+    "paths": [
+      "research/experiment-log/campaign-100",
+      "research/experiment-log/negative-searches",
+      "docs/research/research-notes-20261011.md"
+    ],
+    "scope": "Narrow searches for hypercube, nonuniform star, power-of-two and puncture work; not a global novelty certification"
+  },
+  "runtime_dependencies": "Python >=3.10 standard library only. No predecessor implementation is imported or executed.",
+  "pin_scope": "These are historical source/context pins at the exact base, not assertions that mutable selected-status files retain those hashes on later main commits.",
+  "license": "Apache-2.0",
+  "contributor": "Sam Sung (@the-missionary-company)",
+  "ai_assistance": "Substantial OpenAI Codex assistance in proof development, implementation and review."
+}
diff --git a/research/asymmetric-hypercube-decoder/results.json b/research/asymmetric-hypercube-decoder/results.json
new file mode 100644
index 0000000000..b10204b8c8
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/results.json
@@ -0,0 +1,590 @@
+{
+  "actual_port_systems": [
+    {
+      "cell_sizes_by_overlap": [
+        1,
+        1,
+        1
+      ],
+      "k": 2,
+      "p": 2,
+      "ports": 4,
+      "rank": 2,
+      "target": [
+        1,
+        2
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        5,
+        3,
+        1
+      ],
+      "k": 2,
+      "p": 3,
+      "ports": 12,
+      "rank": 2,
+      "target": [
+        2,
+        4
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        7,
+        5,
+        3,
+        1
+      ],
+      "k": 3,
+      "p": 4,
+      "ports": 32,
+      "rank": 7,
+      "target": [
+        1,
+        4,
+        6
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "k": 4,
+      "p": 4,
+      "ports": 16,
+      "rank": 14,
+      "target": [
+        1,
+        2,
+        5,
+        6
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        9,
+        7,
+        5,
+        3,
+        1
+      ],
+      "k": 4,
+      "p": 5,
+      "ports": 80,
+      "rank": 14,
+      "target": [
+        2,
+        5,
+        7,
+        8
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        41,
+        25,
+        13,
+        5,
+        1
+      ],
+      "k": 4,
+      "p": 6,
+      "ports": 240,
+      "rank": 14,
+      "target": [
+        1,
+        5,
+        8,
+        10
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        11,
+        9,
+        7,
+        5,
+        3,
+        1
+      ],
+      "k": 5,
+      "p": 6,
+      "ports": 192,
+      "rank": 31,
+      "target": [
+        0,
+        5,
+        7,
+        8,
+        10
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        13,
+        11,
+        9,
+        7,
+        5,
+        3,
+        1
+      ],
+      "k": 6,
+      "p": 7,
+      "ports": 448,
+      "rank": 63,
+      "target": [
+        0,
+        3,
+        7,
+        8,
+        10,
+        12
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "k": 7,
+      "p": 7,
+      "ports": 128,
+      "rank": 127,
+      "target": [
+        1,
+        2,
+        5,
+        6,
+        8,
+        10,
+        12
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      "k": 8,
+      "p": 8,
+      "ports": 256,
+      "rank": 254,
+      "target": [
+        1,
+        2,
+        5,
+        6,
+        8,
+        10,
+        12,
+        15
+      ]
+    },
+    {
+      "cell_sizes_by_overlap": [
+        17,
+        15,
+        13,
+        11,
+        9,
+        7,
+        5,
+        3,
+        1
+      ],
+      "k": 8,
+      "p": 9,
+      "ports": 2304,
+      "rank": 254,
+      "target": [
+        3,
+        5,
+        6,
+        8,
+        10,
+        13,
+        14,
+        17
+      ]
+    }
+  ],
+  "arithmetic": "exact F2 integer bitsets",
+  "assignment_seed": 48,
+  "exhaustive_coefficient_vectors": [
+    {
+      "coefficient_vectors": 8,
+      "k": 2,
+      "p": 2,
+      "solution_count": 0
+    },
+    {
+      "coefficient_vectors": 256,
+      "k": 3,
+      "p": 4,
+      "solution_count": 2
+    },
+    {
+      "coefficient_vectors": 131072,
+      "k": 4,
+      "p": 4,
+      "solution_count": 0
+    }
+  ],
+  "exhaustive_target_retaining_punctures": [
+    {
+      "deletion_sets": 4,
+      "distinct_equation_systems": 4,
+      "feasible_sets": 2,
+      "k": 2,
+      "max_deletions": 1,
+      "p": 2
+    },
+    {
+      "deletion_sets": 232,
+      "distinct_equation_systems": 3,
+      "feasible_sets": 2,
+      "k": 2,
+      "max_deletions": 3,
+      "p": 3
+    },
+    {
+      "deletion_sets": 16,
+      "distinct_equation_systems": 16,
+      "feasible_sets": 14,
+      "k": 4,
+      "max_deletions": 1,
+      "p": 4
+    },
+    {
+      "deletion_sets": 3161,
+      "distinct_equation_systems": 1,
+      "feasible_sets": 0,
+      "k": 4,
+      "max_deletions": 2,
+      "p": 5
+    }
+  ],
+  "full_intersection_systems": [
+    {
+      "affine_dimension": null,
+      "feasible": false,
+      "k": 2,
+      "rank": 2,
+      "solution_count": 0,
+      "variables": 3
+    },
+    {
+      "affine_dimension": 1,
+      "feasible": true,
+      "k": 3,
+      "rank": 7,
+      "solution_count": 2,
+      "variables": 8
+    },
+    {
+      "affine_dimension": null,
+      "feasible": false,
+      "k": 4,
+      "rank": 14,
+      "solution_count": 0,
+      "variables": 17
+    },
+    {
+      "affine_dimension": 3,
+      "feasible": true,
+      "k": 5,
+      "rank": 31,
+      "solution_count": 8,
+      "variables": 34
+    },
+    {
+      "affine_dimension": 4,
+      "feasible": true,
+      "k": 6,
+      "rank": 63,
+      "solution_count": 16,
+      "variables": 67
+    },
+    {
+      "affine_dimension": 5,
+      "feasible": true,
+      "k": 7,
+      "rank": 127,
+      "solution_count": 32,
+      "variables": 132
+    },
+    {
+      "affine_dimension": null,
+      "feasible": false,
+      "k": 8,
+      "rank": 254,
+      "solution_count": 0,
+      "variables": 261
+    },
+    {
+      "affine_dimension": 7,
+      "feasible": true,
+      "k": 9,
+      "rank": 511,
+      "solution_count": 128,
+      "variables": 518
+    },
+    {
+      "affine_dimension": 8,
+      "feasible": true,
+      "k": 10,
+      "rank": 1023,
+      "solution_count": 256,
+      "variables": 1031
+    }
+  ],
+  "global_star_dual_certificates": [
+    {
+      "coefficient_xor": 0,
+      "correction_columns": 3,
+      "cube_rows": 16,
+      "global_star_columns": 131,
+      "k": 4,
+      "p": 5,
+      "rhs_xor": 1
+    },
+    {
+      "coefficient_xor": 0,
+      "correction_columns": 7,
+      "cube_rows": 256,
+      "global_star_columns": 6305,
+      "k": 8,
+      "p": 8,
+      "rhs_xor": 1
+    }
+  ],
+  "negative_controls": [
+    "omitted target equation admits zero; physical target rejects it",
+    "flipped b_1 coefficient is rejected on physical ports",
+    "zeroed sharp star witness is rejected at the retained target",
+    "missing proper intersection breaks full-family premise and permits decoding",
+    "degree-k star and overlap-zero correction each break the dual certificate"
+  ],
+  "scope": "Finite verification only; see README.md for general proofs. No kappa claim.",
+  "sharp_puncture_witnesses": [
+    {
+      "deleted_ports": [
+        [
+          0,
+          2
+        ]
+      ],
+      "k": 2,
+      "p": 2,
+      "star": [
+        2
+      ],
+      "threshold": 1
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          4
+        ],
+        [
+          1,
+          4
+        ],
+        [
+          3,
+          4
+        ]
+      ],
+      "k": 2,
+      "p": 3,
+      "star": [
+        4
+      ],
+      "threshold": 3
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          2,
+          5,
+          6
+        ]
+      ],
+      "k": 4,
+      "p": 4,
+      "star": [
+        2,
+        5,
+        6
+      ],
+      "threshold": 1
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          5,
+          7,
+          8
+        ],
+        [
+          1,
+          5,
+          7,
+          8
+        ],
+        [
+          3,
+          5,
+          7,
+          8
+        ]
+      ],
+      "k": 4,
+      "p": 5,
+      "star": [
+        5,
+        7,
+        8
+      ],
+      "threshold": 3
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          5,
+          8,
+          10
+        ],
+        [
+          2,
+          5,
+          8,
+          10
+        ],
+        [
+          3,
+          5,
+          8,
+          10
+        ],
+        [
+          5,
+          6,
+          8,
+          10
+        ],
+        [
+          5,
+          7,
+          8,
+          10
+        ]
+      ],
+      "k": 4,
+      "p": 6,
+      "star": [
+        5,
+        8,
+        10
+      ],
+      "threshold": 5
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          2,
+          5,
+          6,
+          8,
+          10,
+          12,
+          15
+        ]
+      ],
+      "k": 8,
+      "p": 8,
+      "star": [
+        2,
+        5,
+        6,
+        8,
+        10,
+        12,
+        15
+      ],
+      "threshold": 1
+    },
+    {
+      "deleted_ports": [
+        [
+          0,
+          5,
+          6,
+          8,
+          10,
+          13,
+          14,
+          17
+        ],
+        [
+          1,
+          5,
+          6,
+          8,
+          10,
+          13,
+          14,
+          17
+        ],
+        [
+          2,
+          5,
+          6,
+          8,
+          10,
+          13,
+          14,
+          17
+        ]
+      ],
+      "k": 8,
+      "p": 9,
+      "star": [
+        5,
+        6,
+        8,
+        10,
+        13,
+        14,
+        17
+      ],
+      "threshold": 3
+    }
+  ],
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/verify.py b/research/asymmetric-hypercube-decoder/verify.py
new file mode 100644
index 0000000000..c2642e0d0f
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/verify.py
@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Exact finite checks for README.md; Python >= 3.10, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Prepared with substantial OpenAI assistance.
+Integer bits encode F2 vectors; all checks remain active under python -O.
+"""
+import argparse
+from collections import Counter
+from itertools import combinations, product
+import json
+from math import comb
+from pathlib import Path
+import random
+
+
+HERE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def ports(p, k):
+    return [frozenset(2 * pair + sign for pair, sign in zip(pairs, signs))
+            for pairs in combinations(range(p), k)
+            for signs in product(range(2), repeat=k)]
+
+
+def variable_count(k):
+    return (1 << k) - 2 + k - 1
+
+
+def intersection_row(intersection, k):
+    """Star variable L has index L-1; correction b_j follows all stars."""
+    full = (1 << k) - 1
+    row, subset = 0, intersection
+    while subset:
+        if subset != full:
+            row |= 1 << (subset - 1)
+        subset = (subset - 1) & intersection
+    j = intersection.bit_count()
+    if 0 < j < k:
+        row |= 1 << (full - 1 + j - 1)
+    if intersection == full:
+        row |= 1 << variable_count(k)  # Augmented right-hand side: x_T.
+    return row
+
+
+def solve(rows, n):
+    """Return coefficient rank, one solution (or None), and nullspace basis."""
+    coefficient_mask, rhs = (1 << n) - 1, 1 << n
+    pivots, inconsistent = {}, False
+    for original in rows:
+        row = original
+        while row & coefficient_mask:
+            pivot = (row & coefficient_mask).bit_length() - 1
+            if pivot in pivots:
+                row ^= pivots[pivot]
+            else:
+                pivots[pivot] = row
+                break
+        else:
+            inconsistent |= bool(row & rhs)
+
+    def back_substitute(free, homogeneous):
+        value = free
+        for pivot, row in sorted(pivots.items()):
+            bit = (row & value).bit_count() % 2
+            if not homogeneous:
+                bit ^= bool(row & rhs)
+            value |= int(bit) << pivot
+        return value
+
+    basis = [back_substitute(1 << free, True)
+             for free in range(n) if free not in pivots]
+    return len(pivots), None if inconsistent else back_substitute(0, False), basis
+
+
+def satisfies(rows, n, witness):
+    return all(((row & witness).bit_count() & 1) == ((row >> n) & 1)
+               for row in rows)
+
+
+def symmetric(witness, k):
+    levels = {}
+    for subset in range(1, (1 << k) - 1):
+        size, value = subset.bit_count(), (witness >> (subset - 1)) & 1
+        if size in levels and levels[size] != value:
+            return False
+        levels[size] = value
+    return True
+
+
+def actual_problem(p, k, seed):
+    """Build rows directly from sets of physical coordinates, independently."""
+    family = ports(p, k)
+    target = random.Random(seed).choice(family)
+    coordinates = sorted(target)
+    stars = [frozenset(coordinates[i] for i in range(k) if mask >> i & 1)
+             for mask in range(1, (1 << k) - 1)]
+    rows, intersections = [], []
+    for source in family:
+        row = sum(1 << i for i, star in enumerate(stars) if star <= source)
+        overlap = len(source & target)
+        if 0 < overlap < k:
+            row |= 1 << (len(stars) + overlap - 1)
+        row |= int(source == target) << variable_count(k)
+        rows.append(row)
+        intersections.append(sum(1 << i for i, coordinate in enumerate(coordinates)
+                                 if coordinate in source))
+    return family, target, rows, intersections
+
+
+def cell_size(p, k, j):
+    remaining = k - j
+    return sum(comb(remaining, u) * comb(p - k, u) * 2 ** u
+               for u in range(min(remaining, p - k) + 1))
+
+
+def full_intersections(intersections, k):
+    return set(intersections) == set(range(1 << k))
+
+
+def verify(seed, negative_controls):
+    full_results, actual_results, problems = [], [], {}
+    for k in range(2, 11):
+        rows = [intersection_row(j, k) for j in range(1 << k)]
+        n = variable_count(k)
+        proper_rank, _, proper_basis = solve(rows[:-1], n)
+        require(n - proper_rank == k - 1, f"proper-equation dimension: k={k}")
+        require(all(satisfies(rows[:-1], n, v) for v in proper_basis), "homogeneous solutions")
+        require(all(symmetric(v, k) for v in proper_basis), f"symmetry: k={k}")
+        rank, witness, basis = solve(rows, n)
+        feasible = bool(k & (k - 1))
+        require((witness is not None) == feasible, f"feasibility: k={k}")
+        if feasible:
+            require(len(basis) == k - 2, f"affine dimension: k={k}")
+            require(satisfies(rows, n, witness), f"solution: k={k}")
+            require(symmetric(witness, k), f"affine symmetry: k={k}")
+        full_results.append(dict(k=k, variables=n, rank=rank, feasible=feasible,
+                                 solution_count=2 ** len(basis) if feasible else 0,
+                                 affine_dimension=len(basis) if feasible else None))
+
+    cases = [(2, 2), (3, 2), (4, 3), (4, 4), (5, 4), (6, 4),
+             (6, 5), (7, 6), (7, 7), (8, 8), (9, 8)]  # (p, k)
+    for p, k in cases:
+        family, target, rows, intersections = actual_problem(p, k, seed)
+        problems[p, k] = family, target, rows, intersections
+        counts = Counter(intersections)
+        require(len(family) == 2 ** k * comb(p, k), "port count")
+        require(full_intersections(intersections, k), "full-family assumption")
+        require(all(row == intersection_row(j, k) for row, j in zip(rows, intersections)),
+                "physical incidence disagrees with compressed rows")
+        require(all(counts[j] == cell_size(p, k, j.bit_count())
+                    for j in range(1 << k)), "intersection cell cardinality")
+        rank, witness, _ = solve(rows, variable_count(k))
+        require((witness is not None) == bool(k & (k - 1)), "physical feasibility")
+        actual_results.append(dict(p=p, k=k, ports=len(family), rank=rank,
+                                   target=sorted(target),
+                                   cell_sizes_by_overlap=[cell_size(p, k, j)
+                                                          for j in range(k + 1)]))
+
+    coefficient_exhaustion = []
+    for p, k in [(2, 2), (4, 3), (4, 4)]:
+        rows, n = problems[p, k][2], variable_count(k)
+        count = sum(satisfies(rows, n, candidate) for candidate in range(1 << n))
+        require(count == (0 if k & (k - 1) == 0 else 2 ** (k - 2)),
+                "brute-force coefficient count")
+        coefficient_exhaustion.append(dict(p=p, k=k, coefficient_vectors=1 << n,
+                                           solution_count=count))
+
+    puncture_results = []
+    for p, k in [(2, 2), (3, 2), (4, 4), (5, 4), (6, 4), (8, 8), (9, 8)]:
+        family, target, rows, intersections = problems[p, k]
+        full, n = (1 << k) - 1, variable_count(k)
+        threshold = 2 * (p - k) + 1
+        counts = Counter(intersections)
+        require(min(counts[j] for j in range(1, full)) == threshold, "cell minimum")
+        require(solve(set(rows), n)[1] is None, "all-cell obstruction")
+        missing = full ^ 1  # One fixed (k-1)-subset of the selected target.
+        deleted = [i for i, j in enumerate(intersections) if j == missing]
+        remaining = [row for i, row in enumerate(rows) if i not in deleted]
+        witness = 1 << (missing - 1)
+        require(len(deleted) == threshold, "sharp deletion count")
+        require(all(family[i] != target for i in deleted), "target retained")
+        require(satisfies(remaining, n, witness), "sharp star witness")
+        require(solve(remaining, n)[1] is not None, "punctured feasibility")
+        puncture_results.append(dict(p=p, k=k, threshold=threshold,
+                                     star=sorted(target - {min(target)}),
+                                     deleted_ports=[sorted(family[i]) for i in deleted]))
+
+    exhaustive_results = []
+    for p, k, budget in [(2, 2, 1), (3, 2, 3), (4, 4, 1), (5, 4, 2)]:
+        family, target, rows, intersections = problems[p, k]
+        counts, cache, examined, feasible = Counter(intersections), {}, 0, 0
+        deletable = [i for i, source in enumerate(family) if source != target]
+        for size in range(budget + 1):
+            for deleted in combinations(deletable, size):
+                removed = Counter(intersections[i] for i in deleted)
+                surviving = tuple(j for j in sorted(counts) if removed[j] < counts[j])
+                if surviving not in cache:
+                    cache[surviving] = solve([intersection_row(j, k) for j in surviving],
+                                             variable_count(k))[1] is not None
+                possible = cache[surviving]
+                expected = any(removed[j] == counts[j] for j in range(1, (1 << k) - 1))
+                require(possible == expected, "exhaustive puncture feasibility")
+                require(not possible or size >= 2 * (p - k) + 1, "threshold lower bound")
+                examined += 1
+                feasible += possible
+        exhaustive_results.append(dict(p=p, k=k, max_deletions=budget,
+                                       deletion_sets=examined, feasible_sets=feasible,
+                                       distinct_equation_systems=len(cache)))
+
+    dual_results = []
+    for p, k in [(5, 4), (8, 8)]:
+        target = problems[p, k][1]
+        target_pairs = sorted(coordinate // 2 for coordinate in target)
+        cube = [frozenset(2 * pair + sign for pair, sign in zip(target_pairs, signs))
+                for signs in product(range(2), repeat=k)]
+        global_stars = [star for degree in range(k) for star in ports(p, degree)]
+        parities = [sum(star <= source for source in cube) % 2 for star in global_stars]
+        correction_parities = [sum(len(source & target) == j for source in cube) % 2
+                               for j in range(1, k)]
+        require(not any(parities + correction_parities), "dual column XOR")
+        require(sum(source == target for source in cube) == 1, "dual RHS XOR")
+        dual_results.append(dict(p=p, k=k, cube_rows=len(cube),
+                                 global_star_columns=len(global_stars),
+                                 correction_columns=k - 1, coefficient_xor=0, rhs_xor=1))
+
+    controls = []
+    if negative_controls:
+        rows = [intersection_row(j, 4) for j in range(16)]
+        n = variable_count(4)
+        omitted = solve(rows[:-1], n)[1]
+        require(omitted is not None and not satisfies(problems[4, 4][2], n, omitted),
+                "omitted target control")
+        controls.append("omitted target equation admits zero; physical target rejects it")
+        rows3 = problems[4, 3][2]
+        witness3 = solve(rows3, variable_count(3))[1]
+        require(not satisfies(rows3, variable_count(3), witness3 ^ (1 << 6)),
+                "corrupted correction coefficient control")
+        controls.append("flipped b_1 coefficient is rejected on physical ports")
+        _, _, rows4, intersections4 = problems[4, 4]
+        punctured = [row for row, j in zip(rows4, intersections4) if j != 14]
+        require(not satisfies(punctured, n, 0), "corrupted sharp witness control")
+        controls.append("zeroed sharp star witness is rejected at the retained target")
+        altered = [j for j in intersections4 if j != 14]
+        require(not full_intersections(altered, 4), "missing intersection control")
+        escaped = solve(punctured, n)[1]
+        require(escaped is not None and not satisfies(rows4, n, escaped), "false full-family control")
+        controls.append("missing proper intersection breaks full-family premise and permits decoding")
+        cube = ports(4, 4)
+        target = cube[0]
+        require(sum(target <= source for source in cube) % 2 == 1, "full-degree star control")
+        require(sum(len(source & target) == 0 for source in cube) % 2 == 1, "disjoint correction control")
+        controls.append("degree-k star and overlap-zero correction each break the dual certificate")
+
+    return dict(status="PASS", assignment_seed=seed, arithmetic="exact F2 integer bitsets",
+                scope="Finite verification only; see README.md for general proofs. No kappa claim.",
+                full_intersection_systems=full_results, actual_port_systems=actual_results,
+                exhaustive_coefficient_vectors=coefficient_exhaustion,
+                sharp_puncture_witnesses=puncture_results,
+                exhaustive_target_retaining_punctures=exhaustive_results,
+                global_star_dual_certificates=dual_results, negative_controls=controls)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path, help="write deterministic receipt to this path")
+    parser.add_argument("--negative-controls", action="store_true", help="exercise invalid certificates")
+    args = parser.parse_args()
+    claim = json.loads((HERE / "CLAIM.json").read_text())
+    result = verify(claim["assignment_seed"], args.negative_controls)
+    output = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    if args.write:
+        args.write.write_text(output)
+    print(f"PASS: {len(result['full_intersection_systems'])} compressed systems; "
+          f"{len(result['actual_port_systems'])} physical port systems; "
+          f"{sum(case['coefficient_vectors'] for case in result['exhaustive_coefficient_vectors'])} "
+          f"coefficient vectors; "
+          f"{sum(case['deletion_sets'] for case in result['exhaustive_target_retaining_punctures'])} "
+          f"puncture sets; {len(result['negative_controls'])} negative controls")
+
+
+if __name__ == "__main__":
+    main()

From 308f1e6ec3bb0b6ec0584cf7bfe219addc219b1e Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 12:28:17 +0900
Subject: [PATCH 2/7] Record completed seed-48 sprint result and review link

---
 research/asymmetric-hypercube-decoder/CLAIM.json | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/research/asymmetric-hypercube-decoder/CLAIM.json b/research/asymmetric-hypercube-decoder/CLAIM.json
index e84a1a4fc2..e2c6d713f5 100644
--- a/research/asymmetric-hypercube-decoder/CLAIM.json
+++ b/research/asymmetric-hypercube-decoder/CLAIM.json
@@ -29,5 +29,9 @@
     "620": "E8 decoder research; partially reviewed in current ledger; head e9cf03bbdf7094b5a83f6dbd1d74bfd77a05fb87",
     "231_head": "3c11e696a2fb2c454585d72710de27cd6bd3be68"
   },
-  "status": "claimed"
+  "status": "completed; submitted for review",
+  "result": "Proved the global proper-star obstruction and exact local missing-cell characterization with sharp threshold 2(p-k)+1; no new kappa.",
+  "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/669",
+  "completed_at": "2026-10-13T12:28:03+09:00",
+  "verification": "9 compressed systems, 11 physical port systems, 131336 coefficient vectors, 3413 deletion sets, 2 global-star certificates and 5 negative-control categories. Python 3.11.13, 3.14.5 and optimized mode produce identical receipts; independent proof/code review completed."
 }

From 8bcbaafe8590d30eff9c0ae5fd9e49479c84038c Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 15:53:29 +0900
Subject: [PATCH 3/7] Prove global-star rigidity and exact two-target puncture
 geometry

---
 .../EQUALITY-PAIR.md                          | 273 ++++++
 .../EXTENSION-CLAIM.json                      |  89 ++
 .../GLOBAL-RESULTS.json                       | 786 ++++++++++++++++++
 .../MINIMUM-WORDS.md                          | 413 +++++++++
 .../asymmetric-hypercube-decoder/README.md    |  96 ++-
 .../global_verify.py                          | 369 ++++++++
 6 files changed, 2021 insertions(+), 5 deletions(-)
 create mode 100644 research/asymmetric-hypercube-decoder/EQUALITY-PAIR.md
 create mode 100644 research/asymmetric-hypercube-decoder/EXTENSION-CLAIM.json
 create mode 100644 research/asymmetric-hypercube-decoder/GLOBAL-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/MINIMUM-WORDS.md
 create mode 100644 research/asymmetric-hypercube-decoder/global_verify.py

diff --git a/research/asymmetric-hypercube-decoder/EQUALITY-PAIR.md b/research/asymmetric-hypercube-decoder/EQUALITY-PAIR.md
new file mode 100644
index 0000000000..fbfbb7b21d
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/EQUALITY-PAIR.md
@@ -0,0 +1,273 @@
+# Optimal two-target decoders and the exact prescribed-pair threshold
+
+**Uniform equality classification for `q=p-k>=2`; no new κ.** In either
+proper-star code, every two-dimensional subcode attaining the second
+generalized Hamming weight `4q+3` is the span of two `(k-1)`-stars whose
+supports intersect in one port. Consequently, for power-of-two k and every
+prescribed pair of distinct retained targets `T,T'`, the exact number of
+deletions needed to decode both is
+
+```text
+4q+1,  if |T intersect T'| >= k-2;
+4q+2,  if |T intersect T'| <  k-2.                      (1)
+```
+
+The intersection in (1) counts identical signed coordinates, not merely
+original pair indices. Every other port remains an independent nuisance
+input. The theorem concerns scalar identities with arbitrary global proper
+stars and the permitted uniform overlap corrections. It does not price a
+physical implementation or assert simultaneous decoding of every survivor.
+
+## Prerequisites and notation
+
+Use `C^+_{p,k}` and `C^-_{p,k}` from
+[MINIMUM-WORDS.md](MINIMUM-WORDS.md): the binary evaluation spans of all
+proper stars, with and without the empty star. We use three results proved
+there, for `k>=2` and `q=p-k>=2`:
+
+1. The minimum distance is `d=2q+2`.
+2. Every minimum word is exactly one signed `(k-1)`-star `m_J`.
+3. The second generalized Hamming weight is `d_2=4q+3`.
+
+The first result and the generalized-cube parity argument are credited to
+Luke Mansoor's [PR #732](https://github.com/CrocSwap/integer-mult-bounds/pull/732),
+at `80431a74c31e807581f5c2258c87abe2084caacd`. The second and third are the
+uniform extensions proved in this package. The finite one-target
+classification in Alishan Ladhani's
+[PR #747](https://github.com/CrocSwap/integer-mult-bounds/pull/747), and the
+uniform rank and all-target threshold in ellipsi2's
+[PR #772](https://github.com/CrocSwap/integer-mult-bounds/pull/772), remain
+distinct credited results; neither supplies the prescribed-pair statement
+proved here. Exact predecessor pins are recorded in MINIMUM-WORDS.md.
+
+For a two-dimensional subcode V, write U for its support union and
+`n=|U|`. Its three nonzero words f,g,h=f+g satisfy
+
+```text
+wt(f)+wt(g)+wt(h)=2n.                                  (2)
+```
+
+We first prove the equality classification in the larger code `C^+`.
+All attaining generators are nonempty stars, so the result then holds for
+`C^-` as well.
+
+## A parity lemma for small blocks
+
+Suppose every port of U contains a fixed set K of k-1 original pair indices.
+For a pair r outside K, let `U_r` be the block using precisely `K union {r}`.
+If every block has at most four ports, every block has even cardinality.
+
+Ordinary sign-cube parity says that the three words each have even weight
+on `U_r`. A one-point block is therefore impossible. If a block has three
+points, their three nonzero evaluation labels in `F_2^2` must be distinct:
+their sum is zero, and the only way three nonzero binary two-vectors sum to
+zero is to use all three. Each nonzero word consequently has weight two on
+that block.
+
+Fix i in K and choose a pair s outside `K union {r}`. Replace the i slot
+of the ordinary cube on `K union {r}` by the choices `i^a,s^b`, and keep
+ordinary sign choices in all other slots. Its s half omits universal pair
+i, so has zero evaluations. Generalized-cube parity therefore says that
+each word has even weight on the i=a face of `U_r`. Its two support points
+must agree at i. Doing this for every i and every nonzero word forces each
+pair of the three block points to agree on all of K. But only two ports
+have any specified signs on K and use r, one for each sign of r. Three
+distinct points are impossible. Thus block sizes are only zero, two, or
+four, proving the lemma.
+
+## Theorem: every optimum is a span of two intersecting stars
+
+For every q>=2, the optimal two-dimensional subcodes are exactly the spans
+of two `(k-1)`-stars whose supports meet in one port. The boundary q=2
+needs a separate argument because the second-weight formula used in the
+inductive range starts at q=2.
+
+### The boundary q=2
+
+Here n=11 and the minimum weight is six. By (2), evenness, and the minimum
+distance, the three nonzero weights are either `(6,6,10)` or `(6,8,8)`.
+The first pattern already supplies two minimum stars. Suppose the second
+occurs, with `f=m_J` of weight six and g,h of weight eight. Put L for J's
+k-1 original pair indices. Both g and h intersect f in exactly three ports.
+
+A nonuniversal pair for a weight-eight word occurs in at most four support
+ports: avoiding it leaves a nonzero word at unused-pair count one, hence
+weight at least four. If c pairs are universal, incidence counting gives
+
+```text
+8k <= 8c+4(p-c),    hence c>=k-2,    since p=k+2.        (3)
+```
+
+No pair outside L can be universal for g or h: each meets f in three
+ports, whereas f uses such a pair in only two ports. On a pair in L, f
+vanishes on all avoiding ports, so the avoiding restrictions of g and h
+are identical. Thus g and h have the same universal-pair set K, contained
+in L, with size either k-2 or k-1.
+
+If `|K|=k-2`, each word uses exactly two of the four pairs outside K in
+each support port. Its sixteen incidences on those four pairs saturate
+their individual upper bounds of four, so every such pair occurs exactly
+four times. For each residual pair r outside L, the restrictions to ports
+using r consequently have weights two, four, and four for f,g,h. Since
+h=f+g, f and g intersect in exactly one port using r. On the ordinary
+cube with pair set `L union {r}`, g therefore has at least one nonzero
+evaluation, and cube parity requires another. This holds for all three
+residual pairs. All six of these distinct ports use the one pair in
+`L\K`, contradicting that pair's degree four in g.
+
+If `K=L`, every support port contains L. Consider g or h separately and,
+for a residual pair r, define the function on signs of L
+
+```text
+b_r(a) = w(a,r^+) + w(a,r^-),    where w is g or h.
+```
+
+Its weight is at most four, since the word uses r in at most four ports.
+Every face fixing at most two signs of L has even b_r parity. To see this,
+use the ordinary two-sign slot for r, replace each fixed core slot by its
+fixed sign versus a coordinate of a distinct other residual pair, and
+keep all remaining slots ordinary. There are two other residual pairs.
+Every replacement branch omits a universal pair of L and has zero word
+value, so generalized-cube parity gives the asserted even-face condition.
+The even-face lemma forces a nonzero b_r to have weight at least eight,
+or rules it out directly by singleton faces when `|L|<=2`. Hence b_r=0.
+Both independent word values repeat across the two signs of r at each
+fixed a. Every residual block of their support union is therefore even,
+contradicting n=11. The pattern `(6,8,8)` is impossible.
+
+Thus the q=2 optimum also contains two minimum stars, whose intersection
+has size `6+6-11=1`.
+
+### The range q>=3
+
+Assume `q>=3`, and let V have `n=4q+3`. For a pair r, let `d_r` count
+ports of U using r. If restriction to ports avoiding r is injective on V,
+its image is a two-dimensional subcode with unused-pair count q-1. The
+second-weight theorem at q-1 therefore gives
+
+```text
+n-d_r >= 4(q-1)+3 = 4q-1,    so d_r <= 4.               (4)
+```
+
+**There is a minimum word in V.** Suppose otherwise. Each nonzero word has
+even weight at least `2q+4`. If a pair is universal for one word f but not
+another word g, then g restricted to ports avoiding that pair is nonzero,
+has weight at least `2q`, and has support disjoint from f. This would give
+
+```text
+n >= (2q+4)+2q = 4q+4,
+```
+
+a contradiction. Thus all three nonzero words have the same set K of
+universal pair indices. Put `c=|K|` and `t=k-c`. Every pair outside K has
+injective avoidance restriction, since all three nonzero words survive it.
+Counting pair incidences and applying (4) gives
+
+```text
+k n <= c n+4(p-c),    or t(n-4) <= 4q.
+```
+
+Since `n-4=4q-1`, we have t<=1. If t=0, U lies in one ordinary sign cube.
+The generalized-face argument in MINIMUM-WORDS.md forces each nonzero word
+to have weight at least `2^(q+1)>4q+3` for q>=3, or forces zero support
+directly when q>=k. Both alternatives are impossible. If t=1, all blocks
+on `K union {r}` have size at most four by (4). The small-block lemma makes
+their sum n even, contradicting `n=4q+3`. A minimum word must exist.
+
+**There are two minimum words in V.** Let `f=m_J` be a minimum word, let A
+be its support, and suppose the other two words g,h are not minimum.
+Their weights are at least `2q+4`. Since any two nonzero words have support
+union U, both intersections with A have size at least three:
+
+```text
+|A intersect supp(g)| = wt(f)+wt(g)-n >= 3,
+|A intersect supp(h)| = wt(f)+wt(h)-n >= 3.              (5)
+```
+
+There are q+1 residual pairs outside J's k-1 pair indices. The star f uses
+each residual pair in exactly two ports. Therefore avoiding any residual
+pair leaves all three words nonzero, by (5), and (4) applies. At most two
+ports of `B=U\A` use each residual pair. But
+
+```text
+|B| = (4q+3)-(2q+2) = 2q+1,
+sum_(residual r) |{S in B: S uses r}| <= 2(q+1)=|B|+1.
+```
+
+Every port of B uses at least one residual pair, so there are only two
+possibilities. If all use exactly one, every port of U contains J's k-1
+pair indices. Each residual block has at most four ports, and the
+small-block lemma again contradicts odd n.
+
+Otherwise exactly one port E of B uses two residual pairs, and every other
+port of B uses one. The port E omits exactly one of J's pair indices. Its
+ordinary sign cube contains no other port of U: all other ports contain
+all of J's pair indices. Some word of V is nonzero at E, so that word has
+odd parity on this cube, a contradiction. A second minimum word exists.
+
+By minimum-word rigidity, these two words are `m_{J_1},m_{J_2}`. Each has
+weight `2q+2`, and their union has size `4q+3`, so their intersection has
+exactly one port. Equivalently, their defining signed faces are distinct,
+their intersection has size k-2, and `J_1 union J_2` is an admissible k-port.
+Conversely, any such two stars attain `4q+3`. This completes the equality
+classification.
+
+There are exactly
+
+```text
+2^k binom(p,k) binom(k,2)
+```
+
+optimal two-dimensional subcodes. Choose their unique shared k-port W and
+the two different coordinates omitted to obtain `J_1,J_2`. This counts
+each subcode once: its two generating stars are its only minimum words,
+because their sum has weight `4q+2>2q+2`.
+
+## Exact threshold for every prescribed target pair
+
+With proper-star observations alone, formula (1) holds for every k>=2.
+The extra power-of-two hypothesis in the decoder statement is needed only
+to absorb the permitted overlap corrections into the same observation span.
+
+Now assume additionally that k is a power of two. The permitted overlap
+corrections belong to `C^-`, as shown in MINIMUM-WORDS.md. If distinct
+retained targets T,T' can both be decoded after deleting D, their two unit
+vectors lift to independent full-family codewords supported in
+`D union {T,T'}`. Thus `|D|>=d_2-2=4q+1`.
+
+If equality holds, their subcode has optimal support `D union {T,T'}` and
+is spanned by two intersecting stars. Every port in that union contains
+their common signed `(k-2)`-face. In particular, T and T' share at least
+k-2 signed coordinates. This proves necessity in the first line of (1).
+
+For sufficiency, first suppose `|T intersect T'|=k-2`, and put
+`A=T intersect T'`. Choose `a in T\T'` and `b in T'\T` from different
+original pairs. Such a choice exists because each difference contains two
+coordinates from distinct pairs. The faces `J_1=A union {a}` and
+`J_2=A union {b}` are compatible and their union is a k-port. T belongs
+only to the first star and T' only to the second. Delete their union of
+supports except T,T'. Exactly `4q+1` ports are deleted, and the two stars
+on the surviving family give the two target symbols directly.
+
+If `|T intersect T'|=k-1`, let `J_1=T intersect T'`, choose `a in J_1`, and
+put `J_2=T\{a}`. The two star supports intersect at T. Their values at
+`(T,T')` are `(1,1)` and `(1,0)`, respectively. After deleting the other
+`4q+1` ports in their union, use `m_{J_2}` for T and
+`m_{J_1}+m_{J_2}` for T'. Distinct k-ports cannot intersect in k
+coordinates, so this exhausts the first line of (1).
+
+Finally suppose `|T intersect T'|<k-2`. Equality at `4q+1` is impossible
+by the classification, so at least `4q+2` deletions are required. Choose
+any `(k-1)`-face J of T and any `(k-1)`-face J' of T'. Their union has size
+at least k+1, so no k-port extends both and their star supports are
+disjoint. Neither target lies in the other star. Delete the two supports
+except T,T', using exactly `2(2q+2)-2=4q+2` deletions. The two surviving
+stars isolate T and T', proving the second line of (1).
+
+All witnesses use nonempty proper stars. Granting the empty star therefore
+changes none of these conclusions. Arbitrary nonlinear postprocessing of
+the same linear observations changes no exact-recovery threshold, by the
+kernel argument in MINIMUM-WORDS.md. Additional observables, other port
+geometries, restricted inputs, and approximate recovery are outside scope.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/EXTENSION-CLAIM.json b/research/asymmetric-hypercube-decoder/EXTENSION-CLAIM.json
new file mode 100644
index 0000000000..7cd2f77245
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/EXTENSION-CLAIM.json
@@ -0,0 +1,89 @@
+{
+  "status": "completed; research note with uniform proofs and exact finite verification",
+  "assignment_seed": 48,
+  "track": "Structural decoder research; continuation of existing claim",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "starting_pr_head": "308f1e6ec3bb0b6ec0584cf7bfe219addc219b1e",
+  "started_at": "2026-10-13T15:11:22+09:00",
+  "research_window_ends": "2026-10-13T17:11:22+09:00",
+  "verification_reserved_minutes": 30,
+  "goal": "Uniform classification of every minimum global proper-star function for p>=k+2, including consequences for arbitrary postprocessing and multi-target punctures.",
+  "overlap_pivot": "PRs725,732,747,772 completed the initially planned global minimum-distance and all-target-rank questions after PR669. Build on their pinned results; do not claim those as new.",
+  "new_scope": "Universal-pair counting and sign rigidity for all p>=k+2; exact second generalized support weights where provable; independent finite support census and decoder certificates.",
+  "sources": [
+    {
+      "commit": "80431a74c31e807581f5c2258c87abe2084caacd",
+      "path": "research/global-star-puncture/README.md",
+      "sha256": "87825a4dd666d8c32df025fe838aca4cdc23a5d3965f79c9aca4913567dba6d4"
+    },
+    {
+      "commit": "6eadc4eb4ebc355b13fa36a3138d97a583ea7f37",
+      "path": "research/global-star-puncture/README.md",
+      "sha256": "b50aa319fff5f22a8b29745d17bac0b9f650f1129310722deea6dbae1d82c7fa"
+    },
+    {
+      "commit": "aeaf0899179a14644b412e838ede14db967c765e",
+      "path": "research/global-star-punctures/README.md",
+      "sha256": "ab6cf6e7885f31d7601b6d686e1a543ceaf887e29207c3af08955e457a9656da"
+    },
+    {
+      "commit": "02b59e553649c333072b5dd4dfb97e43942efa14",
+      "path": "research/paired-star-rank/RANK-PROOF.md",
+      "sha256": "ebd01b082c5b9adbca6dbd5fa9dd3d8df83270e26a26af76d260fb134fc03d97"
+    }
+  ],
+  "coordination": "No pinned sprint issue at refresh; claim recorded locally. Only existing PR669 will be updated.",
+  "publication": "https://github.com/CrocSwap/integer-mult-bounds/pull/669",
+  "attribution": "Sam Sung, substantial OpenAI Codex assistance. Predecessor credits: Luke Mansoor (#732), Sagar Thakrar (#725), Alishan Ladhani (#747), ellipsi2 (#772), Joel Pulikkan (#231), icekylinx, eumemic.",
+  "orientation_main_snapshot": "7ee02b7c96d85f22b38d28bd7ed49bb8c1aeb261",
+  "orientation_selected_kappa": "1661202643272239/1000000000000000000",
+  "final_main_snapshot": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+  "final_selected_kappa": "1661634653669567/1000000000000000000",
+  "final_frontier_context": "Maintainer-reviewed conditional PR799 with PR741 and PR589; read the selected certificate and maintainer review. No claim to have replayed this unrelated supplier.",
+  "research_completed_at": "2026-10-13T15:49:35+09:00",
+  "results": [
+    "For every k>=2 and q=p-k>=2, every minimum proper-star evaluation vector is a single (k-1)-star; every target has exactly k optimal one-target deletion patterns.",
+    "The second generalized Hamming weight is 4q+3, with or without the empty star.",
+    "Every optimal two-dimensional subcode is spanned by two adjacent (k-1)-stars; exactly 2^k binom(p,k) binom(k,2) such subcodes exist.",
+    "Every prescribed target pair requires exactly 4q+1 deletions if its signed intersection has size at least k-2, and 4q+2 otherwise.",
+    "The code results hold for all k>=2. Uniform overlap corrections are covered at power-of-two k. Exact nonlinear postprocessing of the same linear observations cannot improve these thresholds."
+  ],
+  "verification": {
+    "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/global_verify.py --self-test",
+    "expected_prefix": "PASS_GLOBAL_EQUALITY",
+    "scope": "Finite verification supports the written all-parameter proofs; it is not a proof-assistant verification or a multiplication-supplier replay.",
+    "equality_model_candidates": 123774104,
+    "equality_model_solutions": 30,
+    "exhaustive_two_dimensional_subcodes": 2979201,
+    "prescribed_target_pairs": 202136,
+    "witness_grid_cases": 25,
+    "restoration_controls": 425,
+    "python_versions": [
+      "3.11.13",
+      "3.14.5"
+    ],
+    "receipt_comparison": "Byte-identical optimized isolated executions on both Python versions; relocated replay, corrupted-receipt rejection, and output preservation pass.",
+    "legacy_check": "Original verify.py negative controls and byte-identical results.json replay pass. Original-base scripts/verify_selected_result.py passes; this does not certify the later PR799 snapshot.",
+    "source_pins": "All four concurrent proof-source SHA256 pins verified against Git objects.",
+    "review": "Independent proof and code reviews completed, including two independently derived arguments for the q=2 equality boundary."
+  },
+  "stopping_rule": "Stop after the uniform minimum-word, second-weight, optimal-subcode and prescribed-pair theorems are proved and independently reviewed, and all fixed finite verifier domains finish. No unbounded search or unimplemented supplier claim.",
+  "final_overlap_check": "Refreshed all-state PR metadata through PR833 before publication. Relevant PR725, PR732, PR747 and PR772 heads remain at the pinned commits; no newer overlapping uniform equality or prescribed-pair theorem was identified.",
+  "context_sources": [
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "certificates/selected-result.json",
+      "sha256": "9873519224e2db72d6a8c926f51e3e75129671e467948c6f6b03744f8bcfc699"
+    },
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "docs/research/community-frontier799-review.md",
+      "sha256": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052"
+    },
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "research/community-frontier799-audit/SELECTED-SOURCE.json",
+      "sha256": "839f686bf192a7654370d947bb8dd5c1343c89d3947fbb8a8be0956b482182ca"
+    }
+  ]
+}
diff --git a/research/asymmetric-hypercube-decoder/GLOBAL-RESULTS.json b/research/asymmetric-hypercube-decoder/GLOBAL-RESULTS.json
new file mode 100644
index 0000000000..e0f8c95ed9
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/GLOBAL-RESULTS.json
@@ -0,0 +1,786 @@
+{
+  "arithmetic": "exact F2 integer bitsets",
+  "cases": [
+    {
+      "all_members_are_literal_stars": true,
+      "distinct_pair_sums": 36,
+      "generalized_cubes": 6,
+      "generator_rows_sha256": "da949b8ff08fee6c21243b73e9918eb0213091dc036c0a2a9aaf029e873281a9",
+      "k": 2,
+      "logical_supports": 216,
+      "member_supports": 2,
+      "nonempty_star_rank": 7,
+      "p": 4,
+      "pairs_per_block": 6,
+      "ports": 24,
+      "rank_with_empty_star": 8,
+      "representative_support": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          0,
+          7
+        ]
+      ],
+      "support_census_sha256": "bb0a1e97ff940b7ac37f99a48cede09b917dae27b8a5f7808e98b894e349c6ee"
+    },
+    {
+      "all_members_are_literal_stars": true,
+      "distinct_pair_sums": 784,
+      "generalized_cubes": 12,
+      "generator_rows_sha256": "66ea82781390e9ad33e75fa351b9c39bc0108e72a2af66dccb1f26e8dd8d53cf",
+      "k": 3,
+      "logical_supports": 21952,
+      "member_supports": 4,
+      "nonempty_star_rank": 40,
+      "p": 5,
+      "pairs_per_block": 28,
+      "ports": 80,
+      "rank_with_empty_star": 40,
+      "representative_support": [
+        [
+          0,
+          2,
+          4
+        ],
+        [
+          0,
+          2,
+          5
+        ],
+        [
+          0,
+          2,
+          6
+        ],
+        [
+          0,
+          2,
+          7
+        ],
+        [
+          0,
+          2,
+          8
+        ],
+        [
+          0,
+          2,
+          9
+        ]
+      ],
+      "support_census_sha256": "2655fa49c207cb1931bb5c2c05ce7628d413b14a23008d393c7536fc9f69d84c"
+    },
+    {
+      "all_members_are_literal_stars": true,
+      "distinct_pair_sums": 14400,
+      "generalized_cubes": 18,
+      "generator_rows_sha256": "356946499017ed2183610787e5933ced89bfc6edaa266e263e855af1ef0f058d",
+      "k": 4,
+      "logical_supports": 1728000,
+      "member_supports": 8,
+      "nonempty_star_rank": 155,
+      "p": 6,
+      "pairs_per_block": 120,
+      "ports": 240,
+      "rank_with_empty_star": 155,
+      "representative_support": [
+        [
+          0,
+          2,
+          4,
+          6
+        ],
+        [
+          0,
+          2,
+          4,
+          7
+        ],
+        [
+          0,
+          2,
+          4,
+          8
+        ],
+        [
+          0,
+          2,
+          4,
+          9
+        ],
+        [
+          0,
+          2,
+          4,
+          10
+        ],
+        [
+          0,
+          2,
+          4,
+          11
+        ]
+      ],
+      "support_census_sha256": "742ab5ae115c0adff803f82d3a044d9e1df6cf464c750c67103347072fe53e97"
+    },
+    {
+      "all_members_are_literal_stars": true,
+      "distinct_pair_sums": 246016,
+      "generalized_cubes": 24,
+      "generator_rows_sha256": "85569fee4c2531a405d517ce8fb3cbedfa1e93f16371f788f77eeca136d3dea5",
+      "k": 5,
+      "logical_supports": 122023936,
+      "member_supports": 16,
+      "nonempty_star_rank": 511,
+      "p": 7,
+      "pairs_per_block": 496,
+      "ports": 672,
+      "rank_with_empty_star": 511,
+      "representative_support": [
+        [
+          0,
+          2,
+          4,
+          6,
+          8
+        ],
+        [
+          0,
+          2,
+          4,
+          6,
+          9
+        ],
+        [
+          0,
+          2,
+          4,
+          6,
+          10
+        ],
+        [
+          0,
+          2,
+          4,
+          6,
+          11
+        ],
+        [
+          0,
+          2,
+          4,
+          6,
+          12
+        ],
+        [
+          0,
+          2,
+          4,
+          6,
+          13
+        ]
+      ],
+      "support_census_sha256": "c1de9496a70640f10ac66638667fe54a7ff07ad1aab571b841f6092238f2eb56"
+    }
+  ],
+  "exhaustive_second_weights": [
+    {
+      "attaining_weight_triples": {
+        "(6, 6, 10)": 24
+      },
+      "code": "C+ including empty star",
+      "codewords": 256,
+      "k": 2,
+      "minimum_word_weight": 6,
+      "p": 4,
+      "ports": 24,
+      "rank": 8,
+      "second_weight": 11,
+      "subcodes": 10795
+    },
+    {
+      "attaining_weight_triples": {
+        "(8, 8, 14)": 40
+      },
+      "code": "C+ including empty star",
+      "codewords": 1024,
+      "k": 2,
+      "minimum_word_weight": 8,
+      "p": 5,
+      "ports": 40,
+      "rank": 10,
+      "second_weight": 15,
+      "subcodes": 174251
+    },
+    {
+      "attaining_weight_triples": {
+        "(10, 10, 18)": 60
+      },
+      "code": "C+ including empty star",
+      "codewords": 4096,
+      "k": 2,
+      "minimum_word_weight": 10,
+      "p": 6,
+      "ports": 60,
+      "rank": 12,
+      "second_weight": 19,
+      "subcodes": 2794155
+    }
+  ],
+  "negative_controls": [
+    "corrupt support rejected in all four cases",
+    "omitting between-block parity admits false supports in all four cases",
+    "q=1 non-star minimum support invalidates a weakened hypothesis",
+    "nonzero 11-coefficient vector has zero evaluated function",
+    "all 425 one-port restorations break the respective two-target witnesses",
+    "unsigned pair-index overlap falsely predicts attainable nearby-target decoders"
+  ],
+  "prescribed_pair_coverage": [
+    {
+      "adjacent_spans": 24,
+      "covered_pairs_sha256": "3a79611814abe8e95705a120d958c2ac4a54be5848f0ddc724d4b0a6dc370f5d",
+      "distant_deletions": 10,
+      "distant_target_pairs": 0,
+      "k": 2,
+      "near_decoder_checks": 840,
+      "near_deletions": 9,
+      "near_target_pairs": 276,
+      "p": 4,
+      "ports": 24,
+      "q": 2,
+      "unsigned_intersection_counterexample": null
+    },
+    {
+      "adjacent_spans": 40,
+      "covered_pairs_sha256": "9cd1df197078c7309bf8294ba83c5462a6d5409365176a1c20347bd5b40c279b",
+      "distant_deletions": 14,
+      "distant_target_pairs": 0,
+      "k": 2,
+      "near_decoder_checks": 2520,
+      "near_deletions": 13,
+      "near_target_pairs": 780,
+      "p": 5,
+      "ports": 40,
+      "q": 3,
+      "unsigned_intersection_counterexample": null
+    },
+    {
+      "adjacent_spans": 240,
+      "covered_pairs_sha256": "1bb73017cf3189c9ff29f2759150d11383a1bc0c3781f260fbdc6fb65ae9043f",
+      "distant_deletions": 10,
+      "distant_target_pairs": 1000,
+      "k": 3,
+      "near_decoder_checks": 8400,
+      "near_deletions": 9,
+      "near_target_pairs": 2160,
+      "p": 5,
+      "ports": 80,
+      "q": 2,
+      "unsigned_intersection_counterexample": [
+        [
+          0,
+          2,
+          4
+        ],
+        [
+          1,
+          3,
+          5
+        ]
+      ]
+    },
+    {
+      "adjacent_spans": 480,
+      "covered_pairs_sha256": "98ea8cd8bbe7cacbf29ec7ae74c3ad8e61feed7f52f962e954f0bd9e5d7c5dd6",
+      "distant_deletions": 14,
+      "distant_target_pairs": 5040,
+      "k": 3,
+      "near_decoder_checks": 30240,
+      "near_deletions": 13,
+      "near_target_pairs": 7680,
+      "p": 6,
+      "ports": 160,
+      "q": 3,
+      "unsigned_intersection_counterexample": [
+        [
+          0,
+          2,
+          4
+        ],
+        [
+          1,
+          3,
+          5
+        ]
+      ]
+    },
+    {
+      "adjacent_spans": 1440,
+      "covered_pairs_sha256": "5c856dd4cb7c539090c1a828ebb16ea4415ddbc87be21f5d493c66175b68ce66",
+      "distant_deletions": 10,
+      "distant_target_pairs": 16920,
+      "k": 4,
+      "near_decoder_checks": 50400,
+      "near_deletions": 9,
+      "near_target_pairs": 11760,
+      "p": 6,
+      "ports": 240,
+      "q": 2,
+      "unsigned_intersection_counterexample": [
+        [
+          0,
+          2,
+          4,
+          6
+        ],
+        [
+          0,
+          3,
+          5,
+          7
+        ]
+      ]
+    },
+    {
+      "adjacent_spans": 3360,
+      "covered_pairs_sha256": "0237900e593a7b7dc979119e83a1dad4b95428f90e05228c7f8e12ec239d4469",
+      "distant_deletions": 14,
+      "distant_target_pairs": 106680,
+      "k": 4,
+      "near_decoder_checks": 211680,
+      "near_deletions": 13,
+      "near_target_pairs": 49840,
+      "p": 7,
+      "ports": 560,
+      "q": 3,
+      "unsigned_intersection_counterexample": [
+        [
+          0,
+          2,
+          4,
+          6
+        ],
+        [
+          0,
+          3,
+          5,
+          7
+        ]
+      ]
+    }
+  ],
+  "prescribed_pair_scope": "All target pairs checked for proper-star observations in the listed cases; uniform classification is proved in EQUALITY-PAIR.md. Overlap corrections preserve these thresholds only at power-of-two k.",
+  "q1_nonstar_counterexample": {
+    "coefficient_stars": [
+      [
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        8
+      ],
+      [
+        0,
+        2,
+        9
+      ]
+    ],
+    "k": 4,
+    "p": 5,
+    "role": "q=1 counterexample to extending equality rigidity below q=2",
+    "support": [
+      [
+        0,
+        2,
+        4,
+        6
+      ],
+      [
+        0,
+        2,
+        4,
+        7
+      ],
+      [
+        0,
+        2,
+        5,
+        6
+      ],
+      [
+        0,
+        2,
+        5,
+        7
+      ]
+    ]
+  },
+  "scope": "Equality census fixes k-1 common pairs at q=2; it is not a full codeword search. Second-weight enumeration is complete for the listed k=2 codes. General proofs are in MINIMUM-WORDS.md.",
+  "status": "PASS",
+  "two_target_scope": "Grid entries verify attaining witnesses; uniform lower bounds are proved in MINIMUM-WORDS.md.",
+  "two_target_witness": {
+    "deleted_mask_sha256": "20d774a2a7898126f160a154fe3964b5d0e619280e65bff8d24673cfb697d3a9",
+    "deleted_ports": [
+      [
+        0,
+        2,
+        4,
+        6
+      ],
+      [
+        0,
+        3,
+        4,
+        6
+      ],
+      [
+        1,
+        2,
+        4,
+        6
+      ],
+      [
+        0,
+        4,
+        6,
+        9
+      ],
+      [
+        0,
+        4,
+        6,
+        10
+      ],
+      [
+        0,
+        4,
+        6,
+        11
+      ],
+      [
+        2,
+        4,
+        6,
+        9
+      ],
+      [
+        2,
+        4,
+        6,
+        10
+      ],
+      [
+        2,
+        4,
+        6,
+        11
+      ]
+    ],
+    "deletions": 9,
+    "k": 4,
+    "p": 6,
+    "ports": 240,
+    "q": 2,
+    "restoration_failures": 9,
+    "stars": [
+      [
+        2,
+        4,
+        6
+      ],
+      [
+        0,
+        4,
+        6
+      ]
+    ],
+    "targets": [
+      [
+        2,
+        4,
+        6,
+        8
+      ],
+      [
+        0,
+        4,
+        6,
+        8
+      ]
+    ],
+    "union_weight": 11
+  },
+  "two_target_witness_grid": [
+    {
+      "deleted_mask_sha256": "45fca0632010ad8aabe1e1b0146914ba73c5d3d49a179bfa86e5c7fc9d87cc1c",
+      "deletions": 9,
+      "k": 2,
+      "p": 4,
+      "ports": 24,
+      "q": 2,
+      "restoration_failures": 9,
+      "union_weight": 11
+    },
+    {
+      "deleted_mask_sha256": "1b9397849d46b3c37135ac0ead61cb57a5cb615779362d12415de8a0c2d0c2b2",
+      "deletions": 13,
+      "k": 2,
+      "p": 5,
+      "ports": 40,
+      "q": 3,
+      "restoration_failures": 13,
+      "union_weight": 15
+    },
+    {
+      "deleted_mask_sha256": "c81b4e6d6af7dd7d61a96fda3ad0f45b54d15c04f533786fe6cbe4f88ea5a573",
+      "deletions": 17,
+      "k": 2,
+      "p": 6,
+      "ports": 60,
+      "q": 4,
+      "restoration_failures": 17,
+      "union_weight": 19
+    },
+    {
+      "deleted_mask_sha256": "326906cd312ebc64b5b2fccd05c8047c399447548884607173f0ebf0be6bf4a1",
+      "deletions": 21,
+      "k": 2,
+      "p": 7,
+      "ports": 84,
+      "q": 5,
+      "restoration_failures": 21,
+      "union_weight": 23
+    },
+    {
+      "deleted_mask_sha256": "99ac2f2be6301d34e5dbad7298c3260ce46be0fa066e889fad4c0192f71564f0",
+      "deletions": 25,
+      "k": 2,
+      "p": 8,
+      "ports": 112,
+      "q": 6,
+      "restoration_failures": 25,
+      "union_weight": 27
+    },
+    {
+      "deleted_mask_sha256": "57fdef56f7ee7f8ea940d092077f34f78aaf5adc5328a5141dda58b5a46d9f2e",
+      "deletions": 9,
+      "k": 3,
+      "p": 5,
+      "ports": 80,
+      "q": 2,
+      "restoration_failures": 9,
+      "union_weight": 11
+    },
+    {
+      "deleted_mask_sha256": "b1872114a6ebb3266c57efd8e5df3423d4641087174f9e55ca830dd2e78d78dc",
+      "deletions": 13,
+      "k": 3,
+      "p": 6,
+      "ports": 160,
+      "q": 3,
+      "restoration_failures": 13,
+      "union_weight": 15
+    },
+    {
+      "deleted_mask_sha256": "2b48fdd0aeb8b72fe8544b2cc58a62caf3a0ff720c47e61fb86f44071c8d40a1",
+      "deletions": 17,
+      "k": 3,
+      "p": 7,
+      "ports": 280,
+      "q": 4,
+      "restoration_failures": 17,
+      "union_weight": 19
+    },
+    {
+      "deleted_mask_sha256": "d10ea4b3017fae25a7e8071161320342245e087305f85e46bcb4badb0305c7cb",
+      "deletions": 21,
+      "k": 3,
+      "p": 8,
+      "ports": 448,
+      "q": 5,
+      "restoration_failures": 21,
+      "union_weight": 23
+    },
+    {
+      "deleted_mask_sha256": "8f6800ba52e82175ddc9576e3eb5aa382be7c594f85cb59ef857286b3579bcd1",
+      "deletions": 25,
+      "k": 3,
+      "p": 9,
+      "ports": 672,
+      "q": 6,
+      "restoration_failures": 25,
+      "union_weight": 27
+    },
+    {
+      "deleted_mask_sha256": "20d774a2a7898126f160a154fe3964b5d0e619280e65bff8d24673cfb697d3a9",
+      "deletions": 9,
+      "k": 4,
+      "p": 6,
+      "ports": 240,
+      "q": 2,
+      "restoration_failures": 9,
+      "union_weight": 11
+    },
+    {
+      "deleted_mask_sha256": "b121b537e001cdf1dfd41e2eae373640ae093c49fbdf198326e3af0642716a8d",
+      "deletions": 13,
+      "k": 4,
+      "p": 7,
+      "ports": 560,
+      "q": 3,
+      "restoration_failures": 13,
+      "union_weight": 15
+    },
+    {
+      "deleted_mask_sha256": "1dd22ad3ddab0611774635b58d90e0900593455c8172826dbfa3bd4b301d3567",
+      "deletions": 17,
+      "k": 4,
+      "p": 8,
+      "ports": 1120,
+      "q": 4,
+      "restoration_failures": 17,
+      "union_weight": 19
+    },
+    {
+      "deleted_mask_sha256": "80ccf44c41401de3302f788ef39711d50462102adae7bac119a66e90a1889884",
+      "deletions": 21,
+      "k": 4,
+      "p": 9,
+      "ports": 2016,
+      "q": 5,
+      "restoration_failures": 21,
+      "union_weight": 23
+    },
+    {
+      "deleted_mask_sha256": "7c44327df2e1025b2fc52ee76d6b823561bb7d3db88b6dc2c2185079d8b58e13",
+      "deletions": 25,
+      "k": 4,
+      "p": 10,
+      "ports": 3360,
+      "q": 6,
+      "restoration_failures": 25,
+      "union_weight": 27
+    },
+    {
+      "deleted_mask_sha256": "542dbe7e504c3a078b5b6dea00bebf9bb33d4c547f1ee26dd1b07fc8f649fd5d",
+      "deletions": 9,
+      "k": 5,
+      "p": 7,
+      "ports": 672,
+      "q": 2,
+      "restoration_failures": 9,
+      "union_weight": 11
+    },
+    {
+      "deleted_mask_sha256": "a248fa0076dc0ebbc0baa897f1f68c82485cd3215c427ac0bf69a7eaacc85fe0",
+      "deletions": 13,
+      "k": 5,
+      "p": 8,
+      "ports": 1792,
+      "q": 3,
+      "restoration_failures": 13,
+      "union_weight": 15
+    },
+    {
+      "deleted_mask_sha256": "7ade575c24f7eae4c25ef598195316ba8c7e32fe7babac632ef76febb46ca364",
+      "deletions": 17,
+      "k": 5,
+      "p": 9,
+      "ports": 4032,
+      "q": 4,
+      "restoration_failures": 17,
+      "union_weight": 19
+    },
+    {
+      "deleted_mask_sha256": "2b4a4768395d92cb919a5642a72c12df446a9961749aedcdf251088bc1b8618d",
+      "deletions": 21,
+      "k": 5,
+      "p": 10,
+      "ports": 8064,
+      "q": 5,
+      "restoration_failures": 21,
+      "union_weight": 23
+    },
+    {
+      "deleted_mask_sha256": "52ac9177ba8e4327b10cd8f2b328a6fbaa802e297ff07e11cd4cd54dae639570",
+      "deletions": 25,
+      "k": 5,
+      "p": 11,
+      "ports": 14784,
+      "q": 6,
+      "restoration_failures": 25,
+      "union_weight": 27
+    },
+    {
+      "deleted_mask_sha256": "94beb608a83b5bf832cbf2151925c9eeade9d70d6b111ce2c581441c031347c4",
+      "deletions": 9,
+      "k": 6,
+      "p": 8,
+      "ports": 1792,
+      "q": 2,
+      "restoration_failures": 9,
+      "union_weight": 11
+    },
+    {
+      "deleted_mask_sha256": "23bd4121961602871b4542c3074cfc1675490541623acec5d7d83441c2015b3d",
+      "deletions": 13,
+      "k": 6,
+      "p": 9,
+      "ports": 5376,
+      "q": 3,
+      "restoration_failures": 13,
+      "union_weight": 15
+    },
+    {
+      "deleted_mask_sha256": "c1317713c80ef39a159408fd1a3531b4ede0b270abfc8dc39f3c3cb43aa0f2a7",
+      "deletions": 17,
+      "k": 6,
+      "p": 10,
+      "ports": 13440,
+      "q": 4,
+      "restoration_failures": 17,
+      "union_weight": 19
+    },
+    {
+      "deleted_mask_sha256": "5e245dbb8389142258371651d14a4c1fce9c8d8dbf4a2485c99e78d98122e928",
+      "deletions": 21,
+      "k": 6,
+      "p": 11,
+      "ports": 29568,
+      "q": 5,
+      "restoration_failures": 21,
+      "union_weight": 23
+    },
+    {
+      "deleted_mask_sha256": "a5c84d37d460312d17e8186be3742557765a5974cc3f76e1dcf5187ef6ae9fd7",
+      "deletions": 25,
+      "k": 6,
+      "p": 12,
+      "ports": 59136,
+      "q": 6,
+      "restoration_failures": 25,
+      "union_weight": 27
+    }
+  ]
+}
diff --git a/research/asymmetric-hypercube-decoder/MINIMUM-WORDS.md b/research/asymmetric-hypercube-decoder/MINIMUM-WORDS.md
new file mode 100644
index 0000000000..7dd1311ce6
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/MINIMUM-WORDS.md
@@ -0,0 +1,413 @@
+# Minimum global-star words are rigid beyond one unused pair
+
+**Uniform equality classification and a two-target consequence; no new κ.**
+For every `k >= 2` and `p >= k+2`, the minimum-weight vectors in the global
+proper-star evaluation code are exactly the individual `(k-1)`-star vectors.
+Thus, at a power-of-two k, arbitrary off-target stars admit exactly **k**
+minimum deletion patterns for a fixed retained target, and all k patterns
+already have a target-local one-star decoder.
+
+For every `p>=k+2`, the second generalized Hamming weight is exactly
+**`4(p-k)+3`**. At a power-of-two k this forces at least **`4(p-k)+1`
+deletions** to decode two distinct retained targets; explicit target pairs
+attain this bound. The companion [equality classification](EQUALITY-PAIR.md)
+determines the exact threshold for every prescribed target pair throughout
+`p-k>=2`.
+
+These statements classify evaluation vectors and supports. They do not claim
+unique coefficient representations: dependent star generators can give many
+expressions for the same vector. No paid supplier or multiplication-bound
+improvement is inferred.
+
+## Model and relation to concurrent work
+
+Use the signed-port model in [README.md](README.md). A port in `P_{p,k}`
+chooses k of p disjoint coordinate pairs and one coordinate from each chosen
+pair. For a signed partial port L, write
+
+```text
+m_L(S) = 1[L subset S].
+```
+
+Let `C^+_{p,k}` be the binary evaluation code generated by all `m_L` with
+`0 <= |L| < k`, including `m_empty=1`. Let `C^-_{p,k}` omit that empty
+generator. We first prove the result for the larger space `C^+`; because all
+attaining vectors are nonempty stars, the same equality classification then
+holds for `C^-`.
+
+Luke Mansoor's [PR #732](https://github.com/CrocSwap/integer-mult-bounds/pull/732),
+inspected at `80431a74c31e807581f5c2258c87abe2084caacd`, proves the uniform
+distance formula `d(C^+_{p,k})=2(p-k+1)` and the resulting global one-target
+puncture threshold. Its generalized-cube parity and even-face arguments are
+reproduced below as credited prerequisites, not new results here.
+
+Sagar Thakrar's [PR #725](https://github.com/CrocSwap/integer-mult-bounds/pull/725),
+at `6eadc4eb4ebc355b13fa36a3138d97a583ea7f37`, classifies the 67 minimum
+target-containing supports at `(p,k)=(5,4)`. Alishan Ladhani's
+[PR #747](https://github.com/CrocSwap/integer-mult-bounds/pull/747), at
+`aeaf0899179a14644b412e838ede14db967c765e`, gives the finite `(6,4)`
+classification: 160 minimum words and four optimal patterns per target.
+The theorem below extends that equality classification uniformly to every
+`p>=k+2`, rather than re-claiming the finite `(6,4)` result.
+
+ellipsi2's [PR #772](https://github.com/CrocSwap/integer-mult-bounds/pull/772),
+at `02b59e553649c333072b5dd4dfb97e43942efa14`, proves uniform proper-star ranks
+and algebraic all-target puncture thresholds. Rank and all-target information
+sets are a different question from the minimum one- or two-target supports
+studied here. We do not re-prove or claim those rank results.
+
+## Credited prerequisites: generalized cubes and distance
+
+A **generalized cube** has k slots, each with two distinct coordinate choices.
+The original pair indices used by different slots must be disjoint; the two
+choices within a slot can belong to one original pair or to two different
+pairs. All `2^k` choices of one coordinate per slot are then distinct valid
+k-ports.
+
+For any monomial `m_L` with `|L|<k`, its sum over a generalized cube is zero.
+Either L is incompatible with the slots, giving zero occurrences, or it fixes
+`|L|` slots and occurs `2^(k-|L|)` times. This count is even, also for the
+empty monomial. Therefore every word of `C^+_{p,k}` has even parity on every
+generalized cube. In particular, ordinary sign cubes on fixed k pair indices
+partition the port family, so every codeword has even total weight.
+
+We also use the following even-face fact. If a nonempty subset W of a binary
+m-cube has even cardinality on every face fixing at most r coordinates, with
+`0<=r<m`, then `|W|>=2^(r+1)`. If `r>=m`, no such nonempty W exists, since a
+singleton face would violate parity. For the bound, induct on m. At r=0,
+nonempty even cardinality is at least two. Otherwise split on one coordinate.
+If both slices are nonempty, each inherits the property for r-1 further fixed
+coordinates and has at least `2^r` points. If only one slice is nonempty, it
+inherits the property for r coordinates on the remaining m-1 coordinates;
+induction gives the asserted bound, or a singleton-face contradiction if
+`r>=m-1`.
+
+For completeness, here is #732's distance argument. Put `q=p-k` and induct
+on q for fixed k. At q=0, ordinary-cube parity gives weight at least two,
+attained by a `(k-1)`-star. For q>=1, suppose a nonzero word has weight
+`w<2(q+1)`. Evenness gives `w<=2q`. Choose a support port T with pair set Q.
+For each outside pair r, restricting to ports avoiding r gives a nonzero word
+of `C^+_{p-1,k}`, still containing T, with weight at least `2q` by induction.
+It follows that w=2q and no support uses r. Thus the entire support lies in
+the ordinary cube on Q.
+
+Any face of that cube fixing s signs, for `s<=min(q,k)`, is its intersection
+with a generalized cube: replace the alternative at each fixed slot with a
+coordinate of a distinct outside pair, and leave the other slots ordinary.
+The word vanishes on the added ports, so each such face has even support.
+For `q>=k` this contradicts a singleton face. For `q<k` the even-face fact
+gives `w>=2^(q+1)>2q`, also a contradiction. Finally, a `(k-1)`-star has
+`2(p-k+1)` extensions. Hence
+
+```text
+d(C^+_{p,k}) = d(C^-_{p,k}) = 2(p-k+1).                 (1)
+```
+
+The equality for `C^-` follows from containment and the same nonempty-star
+witness. This distance formula is the inherited result of #732.
+
+## Theorem: uniform classification of the minimum words
+
+**For `k>=2` and `p>=k+2`, the minimum nonzero words in either `C^+_{p,k}`
+or `C^-_{p,k}` are exactly `m_J`, where J ranges over the signed
+`(k-1)`-ports.**
+
+Put `q=p-k>=2`. Let W be the support of a minimum word in `C^+`, so
+`w=|W|=2(q+1)`. Call an original coordinate pair **universal** if every port
+of W uses that pair. Let c be the number of universal pairs, and let `d_r`
+count support ports using pair r.
+
+For a nonuniversal pair r, the restriction to ports avoiding r is nonzero
+and belongs to `C^+_{p-1,k}`. By (1), its weight is at least `2q`. Consequently
+
+```text
+w-d_r >= 2q,    so d_r <= 2.
+```
+
+Count original-pair incidences in W:
+
+```text
+k w = sum_r d_r <= c w + 2(p-c).
+```
+
+Substitution of `w=2(q+1)` and `p=k+q` gives `q(k-c-1)<=0`, so `c>=k-1`.
+Certainly `c<=k`.
+
+If `c=k`, W lies in one ordinary sign cube. The generalized-face construction
+from the distance proof again forces even parity on every face fixing at
+most q signs. If `q>=k`, singleton faces give a contradiction. Otherwise
+
+```text
+|W| >= 2^(q+1) > 2(q+1),    since q>=2,
+```
+
+contradicting minimal weight. Thus `c=k-1`.
+
+Let K be these k-1 universal pair indices. Every support port contains K and
+one additional pair r. There are q+1 possible r, each with `d_r<=2`, and
+their counts sum to `2(q+1)`. Hence each r occurs in exactly two support
+ports. Write `W_r` for this two-point block in the cube on `K union {r}`.
+
+**Each block is an edge.** Fix i in K and choose s outside `K union {r}`.
+For any signs a,b, form a generalized cube with slot `{i^a,s^b}` and ordinary
+two-sign slots on every other pair of `K union {r}`. The half using s omits
+universal pair i, so contains no support. Thus the i=a face of `W_r` has even
+cardinality. The two points of `W_r` must agree at i. Applying this to every
+i in K shows that these distinct points agree on K and differ only at r.
+Let `a_i(r)` denote their common sign at i.
+
+**All edges have the same signs on K.** Choose distinct r,s outside K and a
+third outside pair t; this is possible because `q+1>=3`. Fix i in K. Build
+a generalized cube with slots `{r^b,s^c}` and `{i^a,t^d}`, and ordinary slots
+on the pairs in `K\{i}`. Branches using t omit universal pair i, so contain
+no support. The other branches meet `W_r` in one point precisely when
+`a_i(r)=a`, and meet `W_s` in one point precisely when `a_i(s)=a`. Parity gives
+
+```text
+1[a_i(r)=a] + 1[a_i(s)=a] = 0.
+```
+
+Therefore `a_i(r)=a_i(s)`. This holds for all i,r,s. The common signed
+coordinates on K form a `(k-1)`-port J, and W consists of exactly all its
+extensions. Hence the evaluation vector is `m_J`. Every such star has
+minimum weight, completing the classification for `C^+`. Containment and
+the nonempty witnesses give precisely the same minima for `C^-`.
+
+The support determines J by intersecting all its ports. Thus different J
+give different words, and the exact total is
+
+```text
+number of minimum words = 2^(k-1) binom(p,k-1).          (2)
+```
+
+A fixed target T contains exactly k signed `(k-1)`-subsets, so it belongs to
+exactly k minimum supports. This recovers #747's count of 160 words and four
+patterns at `(p,k)=(6,4)` and extends it to all the stated parameters.
+
+### Why the unused-pair hypothesis matters
+
+At `p=k+1`, the strict inequality above becomes equality. For example, let m
+be the missing pair of an ordinary k-cube, let `z_m` be the sum of its two
+coordinate indicators, and fix k-2 signed coordinates J inside that cube.
+Then `(1+z_m)m_J` has degree at most k-1 and is supported on exactly four
+ports in that single cube. It is a minimum word, but is not a `(k-1)`-star.
+For k>=3 its expansion uses only nonempty stars. In particular, at `(5,4)`
+it supplies the kind of additional minimum pattern classified in #725.
+For k=2 this particular expression uses the empty generator; no claim that
+the two codes have identical q=1 classifications is being made.
+
+## Consequence for a specified retained target
+
+Suppose k is a power of two. For `0<j<k`, the overlap indicator has expansion
+
+```text
+1[|S intersect T|=j]
+  = sum_{l=j}^k (binom(l,j) mod 2)
+      sum_{L subset T, |L|=l} m_L(S).
+```
+
+At intersection size r the right side evaluates to
+`binom(r,j)2^(r-j)`, which is one exactly at r=j. The top coefficient
+`binom(k,j)` vanishes at a power-of-two k, so these corrections already lie
+in `C^-`. This absorption identity is credited to #725/#732.
+
+For a surviving family `F=P\D` containing T, a decoder gives a full-family
+word f with `f(T)=1` and support contained in `{T} union D`. Therefore
+`|D|>=2(p-k)+1` by (1). At equality, f is a minimum word, so the new theorem
+forces it to equal `m_J` for one of the k subsets `J subset T`, `|J|=k-1`.
+Its support has size `|D|+1`; thus D is exactly all other extensions of J.
+
+There are consequently **exactly k optimal deletion sets**, all attained by
+a target-local single star. Global stars do not add optimal deletion patterns
+when `p>=k+2`. They may provide other coefficient expressions, and the
+classification says nothing about patterns with more deletions.
+
+All other ports remain in the surviving family as independent nuisance
+inputs: this is one specified target with the stated D removed, not an
+all-target information-set construction. For non-power-of-two k the minimum
+codeword theorem still holds, but the decoder consequence does not: permitted
+overlap corrections can then isolate a target on the unpunctured family.
+
+## Two targets: uniform second generalized weight
+
+For a binary code C, its second generalized Hamming weight `d_2(C)` is the
+smallest size of the union of supports of a two-dimensional linear subcode.
+This is a support-union invariant; it is not the second-smallest nonzero
+codeword weight.
+
+**For every `k>=2` and `q=p-k>=2`, both `C^+` and `C^-` have
+`d_2=4q+3`.** In particular, the values at q=2 and q=3 are eleven and fifteen.
+
+### The lower bound eleven at p=k+2
+
+Here (1) gives minimum weight six, and the classification says every word of
+weight six is a `(k-1)`-star. Two distinct such stars intersect in at most
+one port: their defining sets have union of size at least k, and a common
+extension exists only when that union is an admissible k-port, in which case
+it is the unique extension.
+
+Let U be the support union of a two-dimensional subcode. Its three nonzero
+words f,g,f+g satisfy
+
+```text
+wt(f) + wt(g) + wt(f+g) = 2|U|,                         (3)
+```
+
+because every coordinate in U is one on exactly two of those three words.
+All three weights are even and at least six. If `|U|<=10`, their sum is at
+most twenty. There must then be at least two weight-six words: otherwise
+the sum is at least `6+8+8=22`. But two distinct weight-six stars have union
+at least `6+6-1=11`, a contradiction. Hence `d_2>=11`.
+
+### Induction for every q>=3
+
+Induct on q, using the q=2 lower bound just proved. Suppose a two-dimensional
+subcode of `C^+_{p,k}` has support union U of size `n<=4q+2`. Its three
+nonzero words have even weights at least `2q+2`. For any original pair r,
+let `d_r` count ports of U using r. Whenever restriction to ports avoiding r
+is injective on this subcode, its image is a two-dimensional subcode of
+`C^+_{p-1,k}`. The induction hypothesis then gives
+
+```text
+n-d_r >= 4(q-1)+3 = 4q-1,    hence d_r <= 3.            (4)
+```
+
+There are two cases.
+
+**Case 1: a nonzero word has minimum weight.** Two distinct minimum stars
+already have union at least `2(2q+2)-1=4q+3`, so there is exactly one such
+word `f=m_J`. Write A for its support and g,h=f+g for the other words.
+Evenness implies `wt(g),wt(h)>=2q+4`. Because any two distinct nonzero words
+of the subcode have support union U,
+
+```text
+|A intersect supp(g)| = wt(f)+wt(g)-n >= 4,
+|A intersect supp(h)| = wt(f)+wt(h)-n >= 4.
+```
+
+There are q+1 residual pairs outside J's k-1 pair indices, and f uses each in
+exactly two ports. After avoiding any such pair, f is still nonzero, and g
+and h each retain at least two support points inside A. All three nonzero
+words survive, so the restriction is injective and (4) applies. Since two of
+the at most three ports using that pair already lie in A, at most one lies
+in `B=U\A`.
+
+On the other hand, (3) gives
+
+```text
+n >= ((2q+2)+(2q+4)+(2q+4))/2 = 3q+5,
+|B| = n-(2q+2) >= q+3.
+```
+
+Every k-port of B uses at least one of the q+1 residual pairs. Their combined
+capacity in B is at most q+1, contradicting `|B|>=q+3`.
+
+**Case 2: there is no minimum-weight word.** All three nonzero weights are
+at least `2q+4`, so (3) gives `n>=3q+6`.
+
+Say that a pair is universal for a nonzero word when every port in its
+support uses that pair. If pair r is universal for one word f but not for
+another g, the restriction of g to ports avoiding r is nonzero and has
+weight at least `2q` by (1). That support is disjoint from the support of f,
+so
+
+```text
+n >= wt(f) + wt(g restricted away from r)
+  >= (2q+4)+2q = 4q+4,
+```
+
+a contradiction. Therefore all three words have the same set K of universal
+pair indices. Write `c=|K|`. For each pair outside K, all three nonzero words
+survive restriction, so (4) applies. For each pair in K, all n support ports
+use it. Counting original-pair incidences gives
+
+```text
+k n <= c n + 3(p-c),    or (k-c)(n-3) <= 3q.
+```
+
+But `n-3>=3q+3>3q`. Since `k-c` is a nonnegative integer, it must be zero.
+Thus c=k and the entire support U lies in one ordinary sign cube. For each
+nonzero word, generalized-cube parity forces even support on every face
+fixing at most q signs, as in the distance proof. If `q>=k`, singleton faces
+contradict nonzero support. If `q<k`, the even-face bound gives
+
+```text
+wt(f) >= 2^(q+1) > 4q+2 >= n,    for q>=3,
+```
+
+again a contradiction. Both cases are impossible. This completes the
+inductive lower bound `d_2(C^+)>=4q+3`, also valid for the subcode `C^-`.
+
+### A general upper witness and precise target-pair interpretation
+
+Put `q=p-k>=1`. Take any admissible k-port W and omit two different
+coordinates to form `(k-1)`-sets `J_1,J_2`. Their stars each have weight
+`2(q+1)` and intersect exactly at W. They span a two-dimensional subcode
+with support union
+
+```text
+2(q+1) + 2(q+1) - 1 = 4q+3.
+```
+
+This proves `d_2(C^+)<=d_2(C^-)<=4q+3`, attaining the lower bound for every
+q>=2. The uniform exact formula therefore holds with or without the empty
+generator. The same construction gives an upper bound at q=1, where no exact
+second-weight statement is claimed here.
+
+At a power-of-two k, if two distinct retained targets are decodable after
+deleting D, their two unit coordinate vectors on F lift to independent
+full-family codewords whose support union is contained in `D union {T_1,T_2}`.
+It follows that **`|D|>=d_2-2=4q+1`** for every q>=2: nine deletions at q=2,
+thirteen at q=3, and so on.
+
+Here are attaining target pairs, making the sharpness quantifier explicit.
+Write `W={w_1,...,w_k}`, choose a signed coordinate v from a pair outside W,
+and set
+
+```text
+J_1 = W\{w_1},          T_1 = J_1 union {v},
+J_2 = W\{w_2},          T_2 = J_2 union {v}.
+```
+
+Then `T_1` lies in the first star support but not the second, and conversely
+for `T_2`. Delete the other `4q+1` ports in the union of the two star supports.
+On the surviving family the two stars equal `x_{T_1}` and `x_{T_2}`. Every
+other port outside that union is retained and contributes zero to both totals.
+Thus `4q+1` deletions are attainable for these explicit pairs, sharply for
+every q>=2. This generalized-weight argument alone does not establish the
+optimum for every prescribed pair. [EQUALITY-PAIR.md](EQUALITY-PAIR.md) gives
+that additional classification for every q>=2. These results do not supply
+the all-target information sets of #747/#772.
+
+## Nonlinear postprocessing of the same observations gives no escape
+
+Fix the surviving family and collect the available binary linear totals as
+rows of an observation matrix A. Inputs range over all independent binary
+assignments. An arbitrary exact function g satisfying `g(Ax)=x_T` exists if
+and only if the target coordinate row `e_T` belongs to `rowspace(A)`.
+
+Indeed, for every `h in ker(A)`, x and x+h yield identical observations, so
+exact recovery requires `h_T=0`. Thus `ker(A) subset ker(e_T)`, equivalently
+`e_T in rowspace(A)` by finite-dimensional binary linear algebra. Conversely,
+a row-space representation supplies a linear decoder. The same argument
+applies to each coordinate of a multiple-target output.
+
+Consequently arbitrary nonlinear postprocessing of these same linear star
+and overlap observations cannot evade the threshold, equality classification,
+or two-target lower bound. This does not include new nonlinear helper
+observables, restricted input distributions, approximate recovery, or external
+side information.
+
+## Interpretation and limits
+
+The new results are the uniform minimum-word equality classification and
+its stated second-generalized-weight consequence. The inherited distance,
+finite `(6,4)` classification, uniform ranks and all-target thresholds retain
+the credits above. Finite checks can corroborate the arguments but do not
+replace the all-parameter proofs.
+
+Neither the number of generator terms nor existence of a scalar decoder
+prices preparation, source reads, copies, dirty restoration, legal frames,
+hosting, recursive calls, or analytic transfer. The results therefore do not
+construct a paid supplier, change the selected construction, or improve κ.
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/README.md b/research/asymmetric-hypercube-decoder/README.md
index 4dad05a71c..105da1bbf8 100644
--- a/research/asymmetric-hypercube-decoder/README.md
+++ b/research/asymmetric-hypercube-decoder/README.md
@@ -1,4 +1,85 @@
-# Asymmetric stars do not evade the hypercube parity obstruction
+# Sharp global-star punctures and optimal decoder geometry
+
+**Uniform structural theorems; no new κ.** Put `q=p-k`. For every `k>=2`
+and `q>=2`, this package now proves:
+
+- Every minimum nonzero proper-star evaluation vector is a single
+  `(k-1)`-star. There are exactly `2^(k-1) binom(p,k-1)` such vectors.
+- The smallest support of a two-dimensional proper-star subcode is exactly
+  `4q+3`. Every attaining subcode is generated by two adjacent `(k-1)`-stars;
+  there are exactly `2^k binom(p,k) binom(k,2)` attaining subcodes.
+- For any two distinct prescribed targets T,T', the exact number of deletions
+  required to decode both from proper-star observations is
+
+  ```text
+  4q+1   if |T intersect T'| >= k-2,
+  4q+2   otherwise.
+  ```
+
+The intersection counts **signed coordinates**, not just original pair
+indices. The code statements hold with or without the empty star. For
+power-of-two k they also cover the uniform overlap corrections in (1) below;
+those corrections already belong to the nonempty-star span. Arbitrary exact
+postprocessing of these same linear observations cannot improve the thresholds.
+The inputs at all other surviving ports remain unrestricted.
+
+[MINIMUM-WORDS.md](MINIMUM-WORDS.md) proves minimum-word rigidity and the
+second generalized weight. [EQUALITY-PAIR.md](EQUALITY-PAIR.md) classifies
+all optimal two-dimensional subcodes and proves the prescribed-pair formula,
+including the boundary `q=2`. These are proofs for the whole stated parameter
+range; the finite checker below provides separate, reproducible evidence.
+
+For example, `(p,k)=(8,4)` has 1,120 ports. One target has exactly four optimal
+nine-deletion patterns. Two prescribed targets need 17 deletions when they
+share at least two signed coordinates, and 18 otherwise. Decoding **every**
+surviving port is a separate rank question: the nonempty-star threshold of
+673 deletions is inherited from ellipsi2's
+[PR #772](https://github.com/CrocSwap/integer-mult-bounds/pull/772), not a new
+claim here. No helper, source-access, copy, frame, restoration, recursive-child
+or assembly cost is inferred from these scalar identities.
+
+## Reproduce the extension
+
+From the repository root, using Python 3.10+ and only its standard library:
+
+```sh
+python3 -I -O -B research/asymmetric-hypercube-decoder/global_verify.py --self-test
+```
+
+Expected: a `PASS_GLOBAL_EQUALITY` line after comparison with
+[GLOBAL-RESULTS.json](GLOBAL-RESULTS.json). The replay checks:
+
+- Four complete `q=2` equality-support models, `k=2,...,5`: 123,774,104
+  possible supports with fixed common pair indices, exactly 30 literal stars.
+  This is an exact meet-in-the-middle census of the reduced models, not an
+  enumeration of every word in the full codes. The proof supplies the reduction.
+- All 2,979,201 two-dimensional subcodes in the full empty-allowed `k=2`
+  codes at `p=4,5,6`, including their minima and attaining weight patterns.
+- 25 literal two-target decoders, `k=2,...,6` and `q=2,...,6`, with all 425
+  single-port restorations rejected.
+- All 202,136 prescribed target pairs for `k=2,3,4` and `q=2,3`, checked
+  against adjacent-star coverage and explicit decoders for both distance cases.
+- Corrupted supports, omitted cross-block constraints, the genuine `q=1`
+  nonstar exception, redundant coefficient representations, and an incorrect
+  unsigned-intersection criterion. The self-test also checks isolated optimized
+  replay, receipt corruption detection, and preservation of existing output
+  when a receipt check fails.
+
+The finite domains are exhaustive and fixed in the script; there is no random
+or timed search. Seed 48 is the original track assignment. The new checker
+uses integer coordinate masks and does not import the earlier verifier or a
+predecessor's implementation. To export a checked receipt, add
+`--check research/asymmetric-hypercube-decoder/GLOBAL-RESULTS.json --write /tmp/global-star-results.json`.
+
+The exact original base is `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+[EXTENSION-CLAIM.json](EXTENSION-CLAIM.json) pins the concurrent source texts
+and the later main-branch snapshot. Luke Mansoor's #732 already proves the
+global minimum distance; Sagar Thakrar's #725 treats the `q=1` exception;
+Alishan Ladhani's #747 classifies the finite `(6,4)` minimum words; #772 gives
+the uniform ranks. This extension credits and builds on those results. It
+adds uniform equality classifications and the exact two-target geometry.
+
+## Original result: the unpunctured obstruction and target-local punctures
 
 **Scoped negative result; no new κ.** The symmetric-coefficient result in
 [PR #231](https://github.com/CrocSwap/integer-mult-bounds/pull/231), by
@@ -181,10 +262,12 @@ result; no new supplier profile is asserted.
   isolated-star witness says nothing about simultaneously decoding all live
   ports, restoring arbitrary scratch inputs or improving copied-information
   cost. It supplies neither a paid recursive profile nor an assembly bound.
-- After puncturing, arbitrary off-target stars are outside Theorem 2. Other
-  correction classes, source-dependent coefficients within a class, degree-k
-  totals, nonlinear mechanisms and different port geometries are outside the
-  obstruction as stated. In particular this is not an E8 decoder ceiling.
+- The original Theorem 2 is restricted to target-local stars; the extension
+  linked above covers global stars after puncturing and exact postprocessing
+  of the same observations. Other correction classes, source-dependent
+  coefficients within a class, degree-k totals, nonlinear helper observations,
+  restricted inputs and different port geometries remain outside these results.
+  In particular this is not an E8 decoder ceiling.
 - The selected construction at the base commit has conditional
   κ=51110230636731/31250000000000000. Its compiler, physical realization,
   hosting, precision/tape and analytic assumptions are neither used to prove
@@ -200,5 +283,8 @@ paired-cube bit identity. The repository preserves those predecessor notices.
 The selected-frontier context credits Chafik Boukhalfa's #626, Jeremy Kothe's
 #622/#623 and eumemic's #543, with the cumulative lineage in its maintainer
 review; this note does not independently re-certify that construction.
+The extension additionally credits Luke Mansoor (#732), Sagar Thakrar (#725),
+Alishan Ladhani (#747) and ellipsi2 (#772), as detailed in the proof notes and
+the pinned extension claim.
 
 New files are licensed under the repository's Apache-2.0 license.
diff --git a/research/asymmetric-hypercube-decoder/global_verify.py b/research/asymmetric-hypercube-decoder/global_verify.py
new file mode 100644
index 0000000000..ef95433c29
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/global_verify.py
@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""Independent finite equality-model verification; Python 3.10+, stdlib only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+No assertion statements: checks remain active with -I -O.
+"""
+import argparse
+from collections import defaultdict
+import hashlib
+from itertools import combinations, product
+import json
+from math import comb
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def ports(p, degree):
+    return [sum(1 << (2 * pair + sign) for pair, sign in zip(pairs, signs))
+            for pairs in combinations(range(p), degree)
+            for signs in product(range(2), repeat=degree)]
+
+
+def coordinates(port):
+    return [i for i in range(port.bit_length()) if port >> i & 1]
+
+
+def row(star, family):
+    return sum(1 << i for i, port in enumerate(family) if port & star == star)
+
+
+def basis(rows):
+    pivots = {}
+    for value in rows:
+        while value:
+            pivot = value.bit_length() - 1
+            if pivot not in pivots:
+                pivots[pivot] = value
+                break
+            value ^= pivots[pivot]
+    return pivots
+
+
+def residual(value, pivots):
+    for pivot in sorted(pivots, reverse=True):
+        if value >> pivot & 1:
+            value ^= pivots[pivot]
+    return value
+
+
+def model(p, k):
+    family = ports(p, k)
+    stars = [s for degree in range(1, k) for s in ports(p, degree)]
+    rows = [row(star, family) for star in stars]
+    return family, stars, rows, basis(rows + [(1 << len(family)) - 1])
+
+
+def cube_mask(dimensions, family):
+    cube = [sum(1 << coordinate for coordinate in choice)
+            for choice in product(*dimensions)]
+    require(len(set(cube)) == 2 ** len(dimensions), "degenerate generalized cube")
+    require(set(cube) <= set(family), "cube contains an inadmissible port")
+    return sum(1 << i for i, port in enumerate(family) if port in set(cube))
+
+
+def rigidity_cubes(k, family):
+    """Two geometric parity families: constant signs within/between blocks."""
+    within, between = [], []
+    extras = list(range(k - 1, k + 2))
+    for a in range(k - 1):
+        other = [(2 * i, 2 * i + 1) for i in range(k - 1) if i != a]
+        for b in extras:
+            c = next(c for c in extras if c != b)
+            within.append(cube_mask(other + [(2 * a, 2 * c), (2 * b, 2 * b + 1)], family))
+        for b, c in combinations(extras, 2):
+            d = next(d for d in extras if d not in (b, c))
+            between.append(cube_mask(other + [(2 * a, 2 * d), (2 * b, 2 * c)], family))
+    return within, between
+
+
+def parity_valid(word, checks):
+    return all((word & check).bit_count() % 2 == 0 for check in checks)
+
+
+def census(k):
+    p = k + 2
+    family, stars, rows, pivots = model(p, k)
+    index = {port: i for i, port in enumerate(family)}
+    blocks = []
+    for extra in range(k - 1, p):
+        mask = sum(3 << (2 * pair) for pair in [*range(k - 1), extra])
+        block = [port for port in family if port & mask == port]
+        require(len(block) == 2 ** k, "block cardinality")
+        syndromes = [residual(1 << index[port], pivots) for port in block]
+        blocks.append([(syndromes[a] ^ syndromes[b], (block[a], block[b]))
+                       for a, b in combinations(range(len(block)), 2)])
+    pair_sums = defaultdict(list)
+    for a, (sa, _) in enumerate(blocks[0]):
+        for b, (sb, _) in enumerate(blocks[1]):
+            pair_sums[sa ^ sb].append((a, b))
+    within, between = rigidity_cubes(k, family)
+    require(all(parity_valid(generator, within + between)
+                for generator in rows + [(1 << len(family)) - 1]), "dual cube certificate")
+    solutions = []
+    for sc, pairc in blocks[2]:
+        for a, b in pair_sums.get(sc, []):
+            support = sorted((*blocks[0][a][1], *blocks[1][b][1], *pairc))
+            word = sum(1 << index[port] for port in support)
+            common = support[0]
+            for port in support[1:]:
+                common &= port
+            require(common.bit_count() == k - 1, "non-star member of equality model")
+            require(row(common, family) == word, "literal global-star evaluation")
+            require(word.bit_count() == 6, "sharp star weight at q=2")
+            require(parity_valid(word, within + between), "member violates geometric parity")
+            solutions.append(support)
+    require(len(solutions) == 2 ** (k - 1), "equality-model solution count")
+    representative = solutions[0]
+    word = sum(1 << index[port] for port in representative)
+    corrupt = word ^ (1 << index[representative[0]])
+    require(residual(corrupt, pivots) != 0, "corrupt-support control")
+    # Flip one common sign in both ports of one block. Each block stays rigid,
+    # but the altered block disagrees with the other two blocks.
+    block_pair = [port for port in representative if port & (3 << (2 * (k - 1)))]
+    altered_support = set(representative) - set(block_pair)
+    altered_support.update(port ^ 3 for port in block_pair)
+    altered = sum(1 << index[port] for port in altered_support)
+    require(parity_valid(altered, within) and not parity_valid(altered, between),
+            "missing cross-block parity control")
+    require(residual(altered, pivots) != 0, "asymmetric-sign support control")
+    return dict(k=k, p=p, ports=len(family), nonempty_star_rank=len(basis(rows)),
+                rank_with_empty_star=len(pivots), pairs_per_block=comb(2 ** k, 2),
+                logical_supports=comb(2 ** k, 2) ** 3,
+                distinct_pair_sums=len(pair_sums), member_supports=len(solutions),
+                all_members_are_literal_stars=True,
+                generalized_cubes=len(within) + len(between),
+                generator_rows_sha256=digest(rows), support_census_sha256=digest(solutions),
+                representative_support=[coordinates(port) for port in representative])
+
+
+def two_target_case(k, q, literal=False):
+    p = k + q
+    family = ports(p, k)
+    index = {port: i for i, port in enumerate(family)}
+    common_port = sum(1 << (2 * pair) for pair in range(k))
+    stars = [common_port ^ (1 << coordinate) for coordinate in (0, 2)]
+    words = [row(star, family) for star in stars]
+    require(all(word.bit_count() == 2 * (q + 1) for word in words), "two-target star weights")
+    require((words[0] & words[1]).bit_count() == 1, "two stars must meet once")
+    targets = [index[star | (1 << (2 * k))] for star in stars]
+    target_mask = sum(1 << i for i in targets)
+    deleted = (words[0] | words[1]) ^ target_mask
+    require(deleted.bit_count() == 4 * q + 1, "two-target deletion count")
+    require(all(word & ~deleted == 1 << targets[a] for a, word in enumerate(words)),
+            "two-target decoder identity on every surviving port")
+    restored = [i for i in range(len(family)) if deleted >> i & 1]
+    require(all(any(word & ~(deleted ^ (1 << i)) != 1 << targets[a]
+                    for a, word in enumerate(words)) for i in restored), "restoration controls")
+    result = dict(p=p, k=k, q=q, ports=len(family),
+                  union_weight=(words[0] | words[1]).bit_count(), deletions=deleted.bit_count(),
+                  restoration_failures=len(restored), deleted_mask_sha256=digest(hex(deleted)))
+    if literal:
+        result.update(stars=[coordinates(s) for s in stars],
+                      targets=[coordinates(family[i]) for i in targets],
+                      deleted_ports=[coordinates(family[i]) for i in restored])
+    return result
+
+
+def small_second_weights():
+    results = []
+    for p in range(4, 7):
+        family, _, _, pivots = model(p, 2)
+        words = [0]
+        for generator in pivots.values():
+            words += [word ^ generator for word in words]
+        require(len(set(words)) == 2 ** len(pivots), "independent codeword enumeration")
+        weights = [word.bit_count() for word in words]
+        minimum, examined, attaining = len(family), 0, defaultdict(int)
+        for a in range(1, len(words)):
+            for b in range(a + 1, len(words)):
+                c = a ^ b
+                if b >= c:  # Exactly the two smallest labels of each 2D subspace.
+                    continue
+                examined += 1
+                support_size = (words[a] | words[b]).bit_count()
+                if support_size < minimum:
+                    minimum, attaining = support_size, defaultdict(int)
+                if support_size == minimum:
+                    attaining[tuple(sorted((weights[a], weights[b], weights[c])))] += 1
+        expected_count = (len(words) - 1) * (len(words) - 2) // 6
+        require(examined == expected_count, "complete two-dimensional subcode count")
+        require(minimum == 4 * (p - 2) + 3, "exhaustive second generalized weight")
+        distance = 2 * (p - 1)
+        require(min(weights[1:]) == distance, "exhaustive minimum word weight")
+        require(attaining == {(distance, distance, 2 * distance - 2): len(family)},
+                "optimal subcodes must be exactly the adjacent-star spans")
+        results.append(dict(k=2, p=p, ports=len(family), code="C+ including empty star",
+                            rank=len(pivots), codewords=len(words), subcodes=examined,
+                            minimum_word_weight=min(weights[1:]), second_weight=minimum,
+                            attaining_weight_triples={str(key): count for key, count in sorted(attaining.items())}))
+    return results
+
+
+def boundary_and_two_targets():
+    family, _, _, pivots = model(5, 4)
+    low_star, outside = (1 << 0) | (1 << 2), (8, 9)
+    coefficient_stars = [low_star] + [low_star | (1 << c) for c in outside]
+    exceptional = 0
+    for star in coefficient_stars:
+        exceptional ^= row(star, family)
+    support = [port for i, port in enumerate(family) if exceptional >> i & 1]
+    require(len(support) == 4 and residual(exceptional, pivots) == 0, "q=1 exception")
+    require(all(row(star, family) != exceptional for star in ports(5, 3)),
+            "q=1 exception must be non-star")
+    exception = dict(p=5, k=4, coefficient_stars=[coordinates(s) for s in coefficient_stars],
+                     support=[coordinates(port) for port in support],
+                     role="q=1 counterexample to extending equality rigidity below q=2")
+    family = ports(6, 4)
+    # A nonzero coefficient vector can represent the zero function.
+    singleton = 1 << 0
+    redundant = [singleton] + [s for s in ports(6, 2) if s & singleton]
+    zero_word = 0
+    for star in redundant:
+        zero_word ^= row(star, family)
+    require(len(redundant) > 0 and zero_word == 0, "coefficients are not codewords")
+    return exception, two_target_case(4, 2, literal=True), len(redundant)
+
+
+def prescribed_pairs(k, q):
+    p = k + q
+    family = ports(p, k)
+    size = len(family)
+    star_rows = {star: row(star, family) for star in ports(p, k - 1)}
+    covered, spans, evaluations = set(), set(), 0
+
+    def indices(mask):
+        result = []
+        while mask:
+            bit = mask & -mask
+            result.append(bit.bit_length() - 1)
+            mask ^= bit
+        return result
+
+    for port in family:
+        for a, b in combinations(coordinates(port), 2):
+            stars = tuple(sorted((port ^ (1 << a), port ^ (1 << b))))
+            require(stars not in spans, "duplicate adjacent-star span")
+            spans.add(stars)
+            left, right = [star_rows[star] for star in stars]
+            require((left & right).bit_count() == 1, "adjacent-star intersection")
+            columns = {1: indices(left & ~right), 2: indices(right & ~left), 3: indices(left & right)}
+            combinations_of_rows = {1: left, 2: right, 3: left ^ right}
+            for first, second in combinations(columns, 2):
+                decoder = [next(word for c, word in combinations_of_rows.items()
+                                if (c & own).bit_count() % 2 == 1
+                                and (c & other).bit_count() % 2 == 0)
+                           for own, other in [(first, second), (second, first)]]
+                for i, j in product(columns[first], columns[second]):
+                    deleted = (left | right) ^ (1 << i) ^ (1 << j)
+                    require(deleted.bit_count() == 4 * q + 1, "near-target deletion count")
+                    require(decoder[0] & ~deleted == 1 << i and decoder[1] & ~deleted == 1 << j,
+                            "near-target full-port unit identities")
+                    covered.add(min(i, j) * size + max(i, j))
+                    evaluations += 1
+    require(len(spans) == size * comb(k, 2), "adjacent-span count")
+    expected, distant, unsigned_control = set(), 0, None
+    for i, j in combinations(range(size), 2):
+        pair_id = i * size + j
+        if (family[i] & family[j]).bit_count() >= k - 2:
+            expected.add(pair_id)
+            continue
+        words = [star_rows[family[t] ^ (1 << (family[t].bit_length() - 1))] for t in (i, j)]
+        require(words[0] & words[1] == 0, "distant stars must be disjoint")
+        deleted = (words[0] | words[1]) ^ (1 << i) ^ (1 << j)
+        require(deleted.bit_count() == 4 * q + 2, "distant-target deletion count")
+        require(words[0] & ~deleted == 1 << i and words[1] & ~deleted == 1 << j,
+                "distant-target full-port unit identities")
+        distant += 1
+        pair_sets = [{c // 2 for c in coordinates(family[t])} for t in (i, j)]
+        if len(pair_sets[0] & pair_sets[1]) >= k - 2 and unsigned_control is None:
+            require(pair_id not in covered, "unsigned intersection incorrectly accepted")
+            unsigned_control = [coordinates(family[i]), coordinates(family[j])]
+    require(covered == expected, "prescribed-pair signed-intersection criterion")
+    require(k == 2 or unsigned_control is not None, "missing unsigned-intersection control")
+    return dict(k=k, p=p, q=q, ports=size, adjacent_spans=len(spans), near_target_pairs=len(covered),
+                distant_target_pairs=distant, near_decoder_checks=evaluations,
+                near_deletions=4 * q + 1, distant_deletions=4 * q + 2,
+                covered_pairs_sha256=digest(sorted(covered)),
+                unsigned_intersection_counterexample=unsigned_control)
+
+
+def verify():
+    cases = [census(k) for k in range(2, 6)]
+    exception, two_targets, relation_size = boundary_and_two_targets()
+    witness_grid = [two_target_case(k, q) for k in range(2, 7) for q in range(2, 7)]
+    return dict(status="PASS", arithmetic="exact F2 integer bitsets", cases=cases,
+                scope="Equality census fixes k-1 common pairs at q=2; it is not a full codeword search. "
+                      "Second-weight enumeration is complete for the listed k=2 codes. "
+                      "General proofs are in MINIMUM-WORDS.md.",
+                q1_nonstar_counterexample=exception, two_target_witness=two_targets,
+                two_target_witness_grid=witness_grid, exhaustive_second_weights=small_second_weights(),
+                two_target_scope="Grid entries verify attaining witnesses; uniform lower bounds are proved in MINIMUM-WORDS.md.",
+                prescribed_pair_coverage=[prescribed_pairs(k, q) for k in range(2, 5) for q in (2, 3)],
+                prescribed_pair_scope="All target pairs checked for proper-star observations in the listed cases; "
+                                      "uniform classification is proved in EQUALITY-PAIR.md. "
+                                      "Overlap corrections preserve these thresholds only at power-of-two k.",
+                negative_controls=["corrupt support rejected in all four cases",
+                                   "omitting between-block parity admits false supports in all four cases",
+                                   "q=1 non-star minimum support invalidates a weakened hypothesis",
+                                   f"nonzero {relation_size}-coefficient vector has zero evaluated function",
+                                   "all 425 one-port restorations break the respective two-target witnesses",
+                                   "unsigned pair-index overlap falsely predicts attainable nearby-target decoders"])
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / "global_verify.py"
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / "GLOBAL-RESULTS.json"
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"minimal relocated optimized replay: {run.stderr}")
+        damaged = dict(result, status="CORRUPTED")
+        receipt.write_text(json.dumps(damaged))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "tampered receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path, help="write receipt only after all requested checks pass")
+    parser.add_argument("--check", type=Path, help="compare this receipt before any output write")
+    parser.add_argument("--self-test", action="store_true", help="test relocation and failure preservation")
+    args = parser.parse_args()
+    result = verify()
+    if args.check or not args.write:
+        receipt = args.check or HERE / "GLOBAL-RESULTS.json"
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS_GLOBAL_EQUALITY: 4 complete equality models; "
+          f"{sum(case['logical_supports'] for case in result['cases'])} candidate supports; "
+          "30 stars; 3 complete k=2 codes; 25 two-target witnesses; "
+          f"{sum(case['near_target_pairs'] + case['distant_target_pairs'] for case in result['prescribed_pair_coverage'])} "
+          "prescribed target pairs; 6 control categories")
+
+
+if __name__ == "__main__":
+    main()

From 76f007ab01e73d5752edec7d39a5c19bfed13de6 Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:32:07 +0900
Subject: [PATCH 4/7] Determine complete graph-star hierarchies with
 independent exact checks

---
 .../HIGHER-GRAPH.md                           |  246 ++
 .../HIGHER-RESULTS.json                       | 3274 +++++++++++++++++
 .../higher_verify.py                          |  409 ++
 3 files changed, 3929 insertions(+)
 create mode 100644 research/asymmetric-hypercube-decoder/HIGHER-GRAPH.md
 create mode 100644 research/asymmetric-hypercube-decoder/HIGHER-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/higher_verify.py

diff --git a/research/asymmetric-hypercube-decoder/HIGHER-GRAPH.md b/research/asymmetric-hypercube-decoder/HIGHER-GRAPH.md
new file mode 100644
index 0000000000..46f3857025
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/HIGHER-GRAPH.md
@@ -0,0 +1,246 @@
+# The complete higher-target hierarchy for signed two-ports
+
+**All generalized weights for `k=2`; no new κ.** The first two generalized
+weights do not distinguish the proper-star code with and without the empty
+star when `p>=4`. Higher weights do. This note determines both complete
+hierarchies and gives their precise interpretation as deletion thresholds
+for a selectable set of targets. It also supplies upper bounds for higher
+k by fixing a common signed face; those bounds are not asserted to be exact.
+
+## The theorem
+
+A signed two-port chooses one coordinate from each of two different original
+pairs. Let `C^-_{p,2}` be the binary evaluation span of the nonempty proper
+stars, and let `C^+_{p,2}` also include the empty star. For a binary code C,
+write `d_r(C)` for the smallest union of supports of an r-dimensional
+subcode. Put
+
+```text
+n = 2p,
+E = 2p(p-1),
+A_r = E - binom(2p-r,2) + max(0,p-r).
+```
+
+For every `p>=2`, the nonempty-star code has dimension `2p-1`, and
+
+```text
+d_r(C^-_{p,2}) = A_r,                   1<=r<=2p-1.       (1)
+```
+
+For every `p>=3`, the empty-allowed code has dimension `2p`, and
+
+```text
+d_1(C^+_{p,2}) = 2p-2,
+d_r(C^+_{p,2}) = min(A_r, E-floor((2p-r+1)^2/4)),
+                                        2<=r<=2p-1,
+d_(2p)(C^+_{p,2}) = E.                                    (2)
+```
+
+At `p=2`, the two codes coincide and have hierarchy `(2,3,4)`. This is a
+separate boundary case, not an extra rank in (2).
+
+For example, `p=4` gives 24 signed two-ports:
+
+| r | `d_r(C^-)` | `d_r(C^+)` | Selectable-target deletions, `C^-` | Selectable-target deletions, `C^+` |
+| --- | --- | --- | --- | --- |
+| 1 | 6 | 6 | 5 | 5 |
+| 2 | 11 | 11 | 9 | 9 |
+| 3 | 15 | 15 | 12 | 12 |
+| 4 | 18 | 18 | 14 | 14 |
+| 5 | 21 | 20 | 16 | 15 |
+| 6 | 23 | 22 | 17 | 16 |
+| 7 | 24 | 23 | 17 | 16 |
+| 8 | — | 24 | — | 16 |
+
+The last two columns are `d_r-r`. A selectable target set means that some
+set of r retained coordinates attains the bound. An arbitrary prescribed
+set of r targets can require a different number of deletions.
+
+## Relation to the known graph-code theorem
+
+The signed two-ports are the edges of the graph obtained from the complete
+graph on `2p` vertices by removing the original p matched pairs. Each
+singleton star is a vertex-incidence row. Thus `C^-` is the binary cut code
+of this graph, sometimes called the cocktail-party graph.
+
+The general connection between binary incidence codes and graph cuts is
+established in José Martínez-Bernal, Miguel A. Valencia-Bucio, and Rafael H.
+Villarreal, [*Generalized Hamming weights of projective Reed–Muller-type
+codes over graphs*](https://arxiv.org/html/1812.04106v2), arXiv:1812.04106v2,
+16 August 2019, Corollary 2.13. For a connected graph with n vertices, that
+corollary identifies the r-th generalized weight of its binary incidence
+code with the minimum number of edges whose removal creates r+1 connected
+components, for `1<=r<=n-1`.
+
+We credit that general bridge. The proof below derives the explicit
+matched-pair formulas and treats the extra constant row directly; it does
+not infer (2) by applying the incidence-code theorem to a different code.
+No claim of literature-wide novelty for the graph invariant is needed.
+
+## Restriction kernels turn weights into an edge optimization
+
+Let G be the graph above. Let H retain any subset of its edges, on all n
+vertices; isolated vertices count as components. Write `c(H)` for its
+number of connected components. The binary incidence matrix of H has rank
+`n-c(H)`: a vertex labeling lies in its left kernel precisely when it is
+constant on each component.
+
+The all-one edge row belongs to that incidence row span exactly when H is
+bipartite. Indeed, expressing that row is the system `a_u+a_v=1` on all
+edges, which is precisely a two-coloring. Put `epsilon(H)=0` when H is
+bipartite and `epsilon(H)=1` otherwise. The matrix with the constant row
+adjoined therefore has rank `n-c(H)+epsilon(H)`.
+
+G is connected for `p>=2`. For `p>=3` it also contains a triangle, so its
+constant row is independent of the incidence rows. This proves the code
+dimensions stated above. The kernels of restriction from the full code to
+the coordinates retained in H have dimensions
+
+```text
+C^-: c(H)-1,
+C^+: c(H)-epsilon(H).                                    (3)
+```
+
+An r-dimensional subcode supported on deleted coordinates exists exactly
+when the corresponding restriction kernel has dimension at least r.
+Consequently, `d_r(C^-)` is E minus the largest number of edges that can be
+retained in a graph with at least r+1 components. For `C^+` there is one
+additional possibility: a bipartite retained graph with at least r
+components. We now optimize these two possibilities.
+
+## Arbitrary retained components
+
+A set of s vertices contains at least `max(0,s-p)` complete original matched
+pairs. Its induced graph therefore has at most
+
+```text
+f(s) = binom(s,2)-max(0,s-p)
+```
+
+edges. This bound is attained by choosing as few complete matched pairs as
+possible. For `s>=1`, the increments
+
+```text
+f(s+1)-f(s) = s - 1[s>=p]
+```
+
+are nondecreasing, and `f(1)=0`. If a partition has two nonsingleton blocks,
+move a vertex from a smaller one to a largest one. The sum of f over its
+block sizes cannot decrease. Repeating shows that, for r+1 blocks, that
+sum is at most `f(n-r)`. A partition into more blocks has the same upper
+bound, for example by grouping its blocks into r+1 parts.
+
+Take one vertex block of size n-r that attains f, and r isolated vertices.
+Retain all induced edges in the large block. This reaches `f(n-r)` edges,
+while retaining at least r+1 components. Thus
+
+```text
+d_r(C^-) = E-f(n-r)
+          = E-binom(n-r,2)+max(0,p-r),
+```
+
+proving (1). These witnesses can equally be obtained from the independent
+singleton-star rows at the r isolated vertices.
+
+## Bipartite retained components
+
+A bipartite component on s vertices has at most `floor(s^2/4)` edges. This
+function also has nondecreasing increments for positive integer s and is
+zero at s=1. The preceding concentration argument shows that a bipartite
+graph with at least r components has at most
+
+```text
+floor((n-r+1)^2/4)
+```
+
+edges.
+
+For `r>=2` this bound is attained inside G. Set `s=n-r+1` and take a complete
+bipartite graph with side sizes `floor(s/2)` and `ceil(s/2)`, leaving r-1
+isolated vertices. Place whole original matched pairs within each side.
+For each side of odd size, place one additional vertex there and its
+matched partner among the isolates. There are enough isolates: odd s needs
+one; if both side sizes are odd, then `s=2 mod 4`, so r is odd and `r>=3`,
+providing two. Thus no removed matched edge crosses the bipartition. At
+`r=n`, this construction is just the empty graph on n vertices.
+
+For `r=1`, no isolate is available, so the parity correction matters. Any
+bipartite subgraph is contained in a cut of G. If p is even, a balanced cut
+can keep every original matched pair on one side, retaining `p^2` edges.
+If p is odd, a balanced cut has two odd side sizes and must separate at
+least one matched pair, retaining at most `p^2-1` edges. An unbalanced cut
+also has at most `p^2-1` possible crossing pairs. This bound is attained by
+sides of sizes p-1 and p+1, both made of whole matched pairs. Hence the
+maximum retained bipartite edge count at r=1 is
+
+```text
+p^2 - (p mod 2).
+```
+
+Its deletion cost is `p(p-2)+(p mod 2)`, which is at least `2p-2` for
+`p>=3`. Taking the smaller deletion cost from the arbitrary-component
+and bipartite-component constructions proves (2), including its first
+and last entries.
+
+When `p=2`, G is the four-cycle, so its constant edge row is already a cut.
+The two codes therefore coincide, and (1) gives `(2,3,4)`.
+
+## What the hierarchy says about decoding
+
+Let C be either observation-row span, with its rows evaluated over the
+full port family. Suppose r distinct retained target symbols can be decoded
+exactly after deleting D, while all other surviving input symbols remain
+unrestricted. The r surviving unit rows lift to independent words of C
+supported on `D union {the r targets}`. Thus
+
+```text
+|D| >= d_r(C)-r.                                          (4)
+```
+
+Conversely, take an r-dimensional subcode attaining `d_r(C)`. Its generator
+matrix has r independent coordinate columns. Choose those coordinates as
+targets and delete the rest of its support. A change of basis makes its
+surviving rows the r unit vectors. All coordinates outside its support
+remain and contribute zero. Thus (4) is attained for some selectable target
+set, proving that the last two columns of the table are exact.
+
+For k=2 the permitted overlap correction is `C_1(T)`. If `T={a,b}`, its
+full-family row is `m_{a}+m_{b}`; the target contributes twice and cancels.
+The same identity holds after deletion. Therefore adding those corrections
+does not change either hierarchy. Arbitrary exact postprocessing of these
+same linear observations also gives no improvement, by the kernel argument
+in [MINIMUM-WORDS.md](MINIMUM-WORDS.md).
+
+This is an observation-span statement. It assigns no physical cost to
+helpers, access to input symbols, copying, restoration, or assembly, and
+it makes no multiplication-bound claim.
+
+## Lifting gives upper bounds for higher k
+
+Fix a signed `(k-2)`-face A. The ports containing A correspond exactly to
+signed two-ports on the remaining `p-k+2` original pairs. Multiplying a
+residual singleton variable by `m_A` gives a global `(k-1)`-star. This
+embeds the residual nonempty-star cut code into either global proper-star
+code, with identical support sizes and dimensions. Consequently, for every
+rank available in the residual code,
+
+```text
+d_r(C^-_{p,k}) <= d_r(C^-_{p-k+2,2}),
+d_r(C^+_{p,k}) <= d_r(C^-_{p-k+2,2}).                       (5)
+```
+
+When `k>=3`, A is nonempty. The residual constant row then becomes the
+allowed nonempty star `m_A`, so the stronger bounds hold:
+
+```text
+d_r(C^-_{p,k}) <= d_r(C^+_{p-k+2,2}),
+d_r(C^+_{p,k}) <= d_r(C^+_{p-k+2,2}),    k>=3.              (6)
+```
+
+The right sides are given completely by (1)–(2), with their stated boundary
+cases and rank ranges. An information set in any lifted witness supplies
+selectable r-target decoders with the same deletion count. These are upper
+bounds for general k, not a claim that all higher-k optimizers arise this
+way or that every prescribed target set attains them.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/HIGHER-RESULTS.json b/research/asymmetric-hypercube-decoder/HIGHER-RESULTS.json
new file mode 100644
index 0000000000..d5deaa994e
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/HIGHER-RESULTS.json
@@ -0,0 +1,3274 @@
+{
+  "arithmetic": "exact F2 integer bitsets",
+  "exhaustive_edge_sets": [
+    {
+      "dimension": 3,
+      "edge_sets": 16,
+      "empty_star": false,
+      "hierarchy": [
+        2,
+        3,
+        4
+      ],
+      "p": 2
+    },
+    {
+      "dimension": 3,
+      "edge_sets": 16,
+      "empty_star": true,
+      "hierarchy": [
+        2,
+        3,
+        4
+      ],
+      "p": 2
+    },
+    {
+      "dimension": 5,
+      "edge_sets": 4096,
+      "empty_star": false,
+      "hierarchy": [
+        4,
+        7,
+        9,
+        11,
+        12
+      ],
+      "p": 3
+    },
+    {
+      "dimension": 6,
+      "edge_sets": 4096,
+      "empty_star": true,
+      "hierarchy": [
+        4,
+        6,
+        8,
+        10,
+        11,
+        12
+      ],
+      "p": 3
+    }
+  ],
+  "exhaustive_subspaces": [
+    {
+      "dimension": 5,
+      "empty_star": false,
+      "generator_rows_sha256": "e41ddc4dcdb0c25142f9ca2804b11edc651635571cd68e98d802a0d5763bca71",
+      "hierarchy": [
+        4,
+        7,
+        9,
+        11,
+        12
+      ],
+      "minimum_subspaces_by_rank": [
+        6,
+        12,
+        8,
+        12,
+        1
+      ],
+      "nonzero_subspaces": 373,
+      "p": 3,
+      "ranks": [
+        1,
+        2,
+        3,
+        4,
+        5
+      ],
+      "subspaces_by_rank": [
+        31,
+        155,
+        155,
+        31,
+        1
+      ]
+    },
+    {
+      "dimension": 6,
+      "empty_star": true,
+      "generator_rows_sha256": "a2ff5c3a4148220ef99a82f73232c52b7d4ba40a19839e28425b722144da64ff",
+      "hierarchy": [
+        4,
+        6,
+        8,
+        10,
+        11,
+        12
+      ],
+      "minimum_subspaces_by_rank": [
+        15,
+        12,
+        15,
+        66,
+        12,
+        1
+      ],
+      "nonzero_subspaces": 2824,
+      "p": 3,
+      "ranks": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6
+      ],
+      "subspaces_by_rank": [
+        63,
+        651,
+        1395,
+        651,
+        63,
+        1
+      ]
+    },
+    {
+      "dimension": 7,
+      "empty_star": false,
+      "generator_rows_sha256": "f8b738ba7f386f5aa8955c01ddab88e4ce12efdf0344150a40589cfb62264fcf",
+      "hierarchy": [
+        6,
+        11,
+        15,
+        18,
+        21,
+        23,
+        24
+      ],
+      "minimum_subspaces_by_rank": [
+        8,
+        24,
+        32,
+        16,
+        32,
+        24,
+        1
+      ],
+      "nonzero_subspaces": 29211,
+      "p": 4,
+      "ranks": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7
+      ],
+      "subspaces_by_rank": [
+        127,
+        2667,
+        11811,
+        11811,
+        2667,
+        127,
+        1
+      ]
+    },
+    {
+      "dimension": 8,
+      "empty_star": true,
+      "generator_rows_sha256": "7215bc89a76e13e4d4058d6f46d0203c15fe6b7d466054278336a3a62395c9e5",
+      "hierarchy": [
+        6,
+        11,
+        15,
+        18,
+        20,
+        22,
+        23,
+        24
+      ],
+      "minimum_subspaces_by_rank": [
+        8,
+        24,
+        80,
+        192,
+        102,
+        276,
+        24,
+        1
+      ],
+      "nonzero_subspaces": 417198,
+      "p": 4,
+      "ranks": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8
+      ],
+      "subspaces_by_rank": [
+        255,
+        10795,
+        97155,
+        200787,
+        97155,
+        10795,
+        255,
+        1
+      ]
+    }
+  ],
+  "full_graph_spectra": [
+    {
+      "dimension": 9,
+      "empty_star": false,
+      "p": 5,
+      "weight_distribution": {
+        "0": 1,
+        "14": 40,
+        "16": 5,
+        "18": 80,
+        "20": 136,
+        "22": 200,
+        "24": 40,
+        "8": 10
+      },
+      "words": 512
+    },
+    {
+      "dimension": 10,
+      "empty_star": true,
+      "p": 5,
+      "weight_distribution": {
+        "0": 1,
+        "14": 40,
+        "16": 45,
+        "18": 280,
+        "20": 272,
+        "22": 280,
+        "24": 45,
+        "26": 40,
+        "32": 10,
+        "40": 1,
+        "8": 10
+      },
+      "words": 1024
+    },
+    {
+      "dimension": 11,
+      "empty_star": false,
+      "p": 6,
+      "weight_distribution": {
+        "0": 1,
+        "10": 12,
+        "18": 60,
+        "20": 6,
+        "24": 160,
+        "26": 60,
+        "28": 240,
+        "30": 464,
+        "32": 735,
+        "34": 300,
+        "36": 10
+      },
+      "words": 2048
+    },
+    {
+      "dimension": 12,
+      "empty_star": true,
+      "p": 6,
+      "weight_distribution": {
+        "0": 1,
+        "10": 12,
+        "18": 60,
+        "20": 6,
+        "24": 170,
+        "26": 360,
+        "28": 975,
+        "30": 928,
+        "32": 975,
+        "34": 360,
+        "36": 170,
+        "40": 6,
+        "42": 60,
+        "50": 12,
+        "60": 1
+      },
+      "words": 4096
+    },
+    {
+      "dimension": 13,
+      "empty_star": false,
+      "p": 7,
+      "weight_distribution": {
+        "0": 1,
+        "12": 14,
+        "22": 84,
+        "24": 7,
+        "30": 280,
+        "32": 84,
+        "36": 560,
+        "38": 420,
+        "40": 693,
+        "42": 1632,
+        "44": 2562,
+        "46": 1680,
+        "48": 175
+      },
+      "words": 8192
+    },
+    {
+      "dimension": 14,
+      "empty_star": true,
+      "p": 7,
+      "weight_distribution": {
+        "0": 1,
+        "12": 14,
+        "22": 84,
+        "24": 7,
+        "30": 280,
+        "32": 84,
+        "36": 735,
+        "38": 2100,
+        "40": 3255,
+        "42": 3264,
+        "44": 3255,
+        "46": 2100,
+        "48": 735,
+        "52": 84,
+        "54": 280,
+        "60": 7,
+        "62": 84,
+        "72": 14,
+        "84": 1
+      },
+      "words": 16384
+    },
+    {
+      "dimension": 15,
+      "empty_star": false,
+      "p": 8,
+      "weight_distribution": {
+        "0": 1,
+        "14": 16,
+        "26": 112,
+        "28": 8,
+        "36": 448,
+        "38": 112,
+        "44": 1120,
+        "46": 672,
+        "48": 28,
+        "50": 1792,
+        "52": 2240,
+        "54": 2128,
+        "56": 5632,
+        "58": 8848,
+        "60": 7896,
+        "62": 1680,
+        "64": 35
+      },
+      "words": 32768
+    },
+    {
+      "dimension": 16,
+      "empty_star": true,
+      "p": 8,
+      "weight_distribution": {
+        "0": 1,
+        "112": 1,
+        "14": 16,
+        "26": 112,
+        "28": 8,
+        "36": 448,
+        "38": 112,
+        "44": 1120,
+        "46": 672,
+        "48": 63,
+        "50": 3472,
+        "52": 10136,
+        "54": 10976,
+        "56": 11264,
+        "58": 10976,
+        "60": 10136,
+        "62": 3472,
+        "64": 63,
+        "66": 672,
+        "68": 1120,
+        "74": 112,
+        "76": 448,
+        "84": 8,
+        "86": 112,
+        "98": 16
+      },
+      "words": 65536
+    },
+    {
+      "dimension": 17,
+      "empty_star": false,
+      "p": 9,
+      "weight_distribution": {
+        "0": 1,
+        "16": 18,
+        "30": 144,
+        "32": 9,
+        "42": 672,
+        "44": 144,
+        "52": 2016,
+        "54": 1008,
+        "56": 36,
+        "60": 4032,
+        "62": 4032,
+        "64": 504,
+        "66": 5376,
+        "68": 10080,
+        "70": 7632,
+        "72": 18772,
+        "74": 30816,
+        "76": 33264,
+        "78": 11760,
+        "80": 756
+      },
+      "words": 131072
+    },
+    {
+      "dimension": 18,
+      "empty_star": true,
+      "p": 9,
+      "weight_distribution": {
+        "0": 1,
+        "100": 144,
+        "102": 672,
+        "112": 9,
+        "114": 144,
+        "128": 18,
+        "144": 1,
+        "16": 18,
+        "30": 144,
+        "32": 9,
+        "42": 672,
+        "44": 144,
+        "52": 2016,
+        "54": 1008,
+        "56": 36,
+        "60": 4032,
+        "62": 4032,
+        "64": 1260,
+        "66": 17136,
+        "68": 43344,
+        "70": 38448,
+        "72": 37544,
+        "74": 38448,
+        "76": 43344,
+        "78": 17136,
+        "80": 1260,
+        "82": 4032,
+        "84": 4032,
+        "88": 36,
+        "90": 1008,
+        "92": 2016
+      },
+      "words": 262144
+    }
+  ],
+  "negative_controls": [
+    "every single deleted-edge restoration breaks its simultaneous decoder",
+    "p=2 has redundant empty star and dimension three",
+    "odd p=3 loses one edge against the naive balanced complete cut",
+    "omitting the bipartite branch gives a false fifth weight at p=4"
+  ],
+  "optimal_triangle_census": [
+    {
+      "dimension": 9,
+      "empty_star": false,
+      "generator_rows_sha256": "f0955388513288dd82d9543a47ae7414219c46123ca4aca2efc2c01a2d1889db",
+      "hierarchy": [
+        21
+      ],
+      "minimum_subspaces_by_rank": [
+        80
+      ],
+      "nonzero_subspaces": 788035,
+      "p": 5,
+      "ranks": [
+        3
+      ],
+      "subspaces_by_rank": [
+        788035
+      ]
+    },
+    {
+      "dimension": 10,
+      "empty_star": true,
+      "generator_rows_sha256": "8da2a5054de080b624bc53d32a28f374deeee16087e1e55fc8cb46cfe712956d",
+      "hierarchy": [
+        21
+      ],
+      "minimum_subspaces_by_rank": [
+        80
+      ],
+      "nonzero_subspaces": 6347715,
+      "p": 5,
+      "ranks": [
+        3
+      ],
+      "subspaces_by_rank": [
+        6347715
+      ]
+    }
+  ],
+  "partition_cases": [
+    {
+      "bipartite_retained_by_block_count": [
+        8,
+        6,
+        4,
+        2,
+        1,
+        0
+      ],
+      "codes": [
+        {
+          "dimension": 5,
+          "empty_star": false,
+          "hierarchy": [
+            4,
+            7,
+            9,
+            11,
+            12
+          ],
+          "observation_basis_rows": [
+            15,
+            240,
+            785,
+            3106,
+            1348
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                240
+              ],
+              "deletions": 3,
+              "information_edge_indices": [
+                4
+              ],
+              "rank": 1,
+              "retained_edge_mask": 3855,
+              "support_size": 4
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                993,
+                240
+              ],
+              "deletions": 5,
+              "information_edge_indices": [
+                0,
+                4
+              ],
+              "rank": 2,
+              "retained_edge_mask": 3086,
+              "support_size": 7
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                993,
+                1348,
+                240
+              ],
+              "deletions": 6,
+              "information_edge_indices": [
+                0,
+                2,
+                4
+              ],
+              "rank": 3,
+              "retained_edge_mask": 2058,
+              "support_size": 9
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                993,
+                3106,
+                1348,
+                240
+              ],
+              "deletions": 7,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4
+              ],
+              "rank": 4,
+              "retained_edge_mask": 8,
+              "support_size": 11
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                31,
+                2
+              ],
+              "decoder_word_masks": [
+                993,
+                3106,
+                1348,
+                2696,
+                240
+              ],
+              "deletions": 7,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4
+              ],
+              "rank": 5,
+              "retained_edge_mask": 0,
+              "support_size": 12
+            }
+          ]
+        },
+        {
+          "dimension": 6,
+          "empty_star": true,
+          "hierarchy": [
+            4,
+            6,
+            8,
+            10,
+            11,
+            12
+          ],
+          "observation_basis_rows": [
+            15,
+            240,
+            785,
+            3106,
+            1348,
+            4095
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                240
+              ],
+              "deletions": 3,
+              "information_edge_indices": [
+                4
+              ],
+              "rank": 1,
+              "retained_edge_mask": 3855,
+              "support_size": 4
+            },
+            {
+              "coefficient_masks": [
+                44,
+                2
+              ],
+              "decoder_word_masks": [
+                204,
+                240
+              ],
+              "deletions": 4,
+              "information_edge_indices": [
+                2,
+                4
+              ],
+              "rank": 2,
+              "retained_edge_mask": 3843,
+              "support_size": 6
+            },
+            {
+              "coefficient_masks": [
+                6,
+                43,
+                2
+              ],
+              "decoder_word_masks": [
+                993,
+                802,
+                240
+              ],
+              "deletions": 5,
+              "information_edge_indices": [
+                0,
+                1,
+                4
+              ],
+              "rank": 3,
+              "retained_edge_mask": 3084,
+              "support_size": 8
+            },
+            {
+              "coefficient_masks": [
+                37,
+                8,
+                2,
+                35
+              ],
+              "decoder_word_masks": [
+                3297,
+                3106,
+                240,
+                3840
+              ],
+              "deletions": 6,
+              "information_edge_indices": [
+                0,
+                1,
+                4,
+                8
+              ],
+              "rank": 4,
+              "retained_edge_mask": 12,
+              "support_size": 10
+            },
+            {
+              "coefficient_masks": [
+                37,
+                8,
+                51,
+                2,
+                35
+              ],
+              "decoder_word_masks": [
+                3297,
+                3106,
+                2628,
+                240,
+                3840
+              ],
+              "deletions": 6,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                8
+              ],
+              "rank": 5,
+              "retained_edge_mask": 8,
+              "support_size": 11
+            },
+            {
+              "coefficient_masks": [
+                37,
+                8,
+                51,
+                31,
+                2,
+                35
+              ],
+              "decoder_word_masks": [
+                3297,
+                3106,
+                2628,
+                2696,
+                240,
+                3840
+              ],
+              "deletions": 6,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                8
+              ],
+              "rank": 6,
+              "retained_edge_mask": 0,
+              "support_size": 12
+            }
+          ]
+        }
+      ],
+      "edge_order": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          1,
+          4
+        ],
+        [
+          1,
+          5
+        ],
+        [
+          2,
+          4
+        ],
+        [
+          2,
+          5
+        ],
+        [
+          3,
+          4
+        ],
+        [
+          3,
+          5
+        ]
+      ],
+      "p": 3,
+      "ports": 12,
+      "searches": {
+        "block_choices": 364,
+        "cut_assignments": 301,
+        "partition_transitions": 610,
+        "vertex_subsets": 64
+      },
+      "unrestricted_retained_by_block_count": [
+        12,
+        8,
+        5,
+        3,
+        1,
+        0
+      ]
+    },
+    {
+      "bipartite_retained_by_block_count": [
+        16,
+        12,
+        9,
+        6,
+        4,
+        2,
+        1,
+        0
+      ],
+      "codes": [
+        {
+          "dimension": 7,
+          "empty_star": false,
+          "hierarchy": [
+            6,
+            11,
+            15,
+            18,
+            21,
+            23,
+            24
+          ],
+          "observation_basis_rows": [
+            63,
+            4032,
+            61505,
+            983170,
+            3215620,
+            12722696,
+            5522448
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                4032
+              ],
+              "deletions": 5,
+              "information_edge_indices": [
+                6
+              ],
+              "rank": 1,
+              "retained_edge_mask": 16773183,
+              "support_size": 6
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                4032
+              ],
+              "deletions": 9,
+              "information_edge_indices": [
+                0,
+                6
+              ],
+              "rank": 2,
+              "retained_edge_mask": 16711742,
+              "support_size": 11
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                3215620,
+                4032
+              ],
+              "deletions": 12,
+              "information_edge_indices": [
+                0,
+                2,
+                6
+              ],
+              "rank": 3,
+              "retained_edge_mask": 13500474,
+              "support_size": 15
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                3215620,
+                5522448,
+                4032
+              ],
+              "deletions": 14,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6
+              ],
+              "rank": 4,
+              "retained_edge_mask": 9044010,
+              "support_size": 18
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                983170,
+                3215620,
+                5522448,
+                4032
+              ],
+              "deletions": 16,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                6
+              ],
+              "rank": 5,
+              "retained_edge_mask": 8388648,
+              "support_size": 21
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                983170,
+                3215620,
+                12722696,
+                5522448,
+                4032
+              ],
+              "deletions": 17,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                6
+              ],
+              "rank": 6,
+              "retained_edge_mask": 32,
+              "support_size": 23
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                127,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                983170,
+                3215620,
+                12722696,
+                5522448,
+                11044896,
+                4032
+              ],
+              "deletions": 17,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6
+              ],
+              "rank": 7,
+              "retained_edge_mask": 0,
+              "support_size": 24
+            }
+          ]
+        },
+        {
+          "dimension": 8,
+          "empty_star": true,
+          "hierarchy": [
+            6,
+            11,
+            15,
+            18,
+            20,
+            22,
+            23,
+            24
+          ],
+          "observation_basis_rows": [
+            63,
+            4032,
+            61505,
+            983170,
+            3215620,
+            12722696,
+            5522448,
+            16777215
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                4032
+              ],
+              "deletions": 5,
+              "information_edge_indices": [
+                6
+              ],
+              "rank": 1,
+              "retained_edge_mask": 16773183,
+              "support_size": 6
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                4032
+              ],
+              "deletions": 9,
+              "information_edge_indices": [
+                0,
+                6
+              ],
+              "rank": 2,
+              "retained_edge_mask": 16711742,
+              "support_size": 11
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                3215620,
+                4032
+              ],
+              "deletions": 12,
+              "information_edge_indices": [
+                0,
+                2,
+                6
+              ],
+              "rank": 3,
+              "retained_edge_mask": 13500474,
+              "support_size": 15
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                3215620,
+                5522448,
+                4032
+              ],
+              "deletions": 14,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6
+              ],
+              "rank": 4,
+              "retained_edge_mask": 9044010,
+              "support_size": 18
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                163,
+                2
+              ],
+              "decoder_word_masks": [
+                65409,
+                983170,
+                3215620,
+                4051464,
+                4032
+              ],
+              "deletions": 15,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                6
+              ],
+              "rank": 5,
+              "retained_edge_mask": 12582960,
+              "support_size": 20
+            },
+            {
+              "coefficient_masks": [
+                133,
+                8,
+                147,
+                32,
+                2,
+                131
+              ],
+              "decoder_word_masks": [
+                16715649,
+                983170,
+                13558020,
+                12722696,
+                4032,
+                16773120
+              ],
+              "deletions": 16,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                6,
+                12
+              ],
+              "rank": 6,
+              "retained_edge_mask": 48,
+              "support_size": 22
+            },
+            {
+              "coefficient_masks": [
+                133,
+                8,
+                147,
+                32,
+                64,
+                2,
+                131
+              ],
+              "decoder_word_masks": [
+                16715649,
+                983170,
+                13558020,
+                12722696,
+                5522448,
+                4032,
+                16773120
+              ],
+              "deletions": 16,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                6,
+                12
+              ],
+              "rank": 7,
+              "retained_edge_mask": 32,
+              "support_size": 23
+            },
+            {
+              "coefficient_masks": [
+                133,
+                8,
+                147,
+                32,
+                64,
+                127,
+                2,
+                131
+              ],
+              "decoder_word_masks": [
+                16715649,
+                983170,
+                13558020,
+                12722696,
+                5522448,
+                11044896,
+                4032,
+                16773120
+              ],
+              "deletions": 16,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                12
+              ],
+              "rank": 8,
+              "retained_edge_mask": 0,
+              "support_size": 24
+            }
+          ]
+        }
+      ],
+      "edge_order": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          0,
+          7
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          1,
+          4
+        ],
+        [
+          1,
+          5
+        ],
+        [
+          1,
+          6
+        ],
+        [
+          1,
+          7
+        ],
+        [
+          2,
+          4
+        ],
+        [
+          2,
+          5
+        ],
+        [
+          2,
+          6
+        ],
+        [
+          2,
+          7
+        ],
+        [
+          3,
+          4
+        ],
+        [
+          3,
+          5
+        ],
+        [
+          3,
+          6
+        ],
+        [
+          3,
+          7
+        ],
+        [
+          4,
+          6
+        ],
+        [
+          4,
+          7
+        ],
+        [
+          5,
+          6
+        ],
+        [
+          5,
+          7
+        ]
+      ],
+      "p": 4,
+      "ports": 24,
+      "searches": {
+        "block_choices": 3280,
+        "cut_assignments": 3025,
+        "partition_transitions": 7363,
+        "vertex_subsets": 256
+      },
+      "unrestricted_retained_by_block_count": [
+        24,
+        18,
+        13,
+        9,
+        6,
+        3,
+        1,
+        0
+      ]
+    },
+    {
+      "bipartite_retained_by_block_count": [
+        24,
+        20,
+        16,
+        12,
+        9,
+        6,
+        4,
+        2,
+        1,
+        0
+      ],
+      "codes": [
+        {
+          "dimension": 9,
+          "empty_star": false,
+          "hierarchy": [
+            8,
+            15,
+            21,
+            26,
+            30,
+            34,
+            37,
+            39,
+            40
+          ],
+          "observation_basis_rows": [
+            255,
+            65280,
+            4129025,
+            264241666,
+            4030792708,
+            64433031176,
+            210738876432,
+            833794613280,
+            361919168576
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                65280
+              ],
+              "deletions": 7,
+              "information_edge_indices": [
+                8
+              ],
+              "rank": 1,
+              "retained_edge_mask": 1099511562495,
+              "support_size": 8
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                65280
+              ],
+              "deletions": 13,
+              "information_edge_indices": [
+                0,
+                8
+              ],
+              "rank": 2,
+              "retained_edge_mask": 1099507433726,
+              "support_size": 15
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                65280
+              ],
+              "deletions": 18,
+              "information_edge_indices": [
+                0,
+                2,
+                8
+              ],
+              "rank": 3,
+              "retained_edge_mask": 1095476707578,
+              "support_size": 21
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                210738876432,
+                65280
+              ],
+              "deletions": 22,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                8
+              ],
+              "rank": 4,
+              "retained_edge_mask": 885006532842,
+              "support_size": 26
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                210738876432,
+                361919168576,
+                65280
+              ],
+              "deletions": 25,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                8
+              ],
+              "rank": 5,
+              "retained_edge_mask": 592881647786,
+              "support_size": 30
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                210738876432,
+                361919168576,
+                65280
+              ],
+              "deletions": 28,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                6,
+                8
+              ],
+              "rank": 6,
+              "retained_edge_mask": 592705487016,
+              "support_size": 34
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                64433031176,
+                210738876432,
+                361919168576,
+                65280
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                6,
+                8
+              ],
+              "rank": 7,
+              "retained_edge_mask": 549755814048,
+              "support_size": 37
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                64433031176,
+                210738876432,
+                833794613280,
+                361919168576,
+                65280
+              ],
+              "deletions": 31,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                8
+              ],
+              "rank": 8,
+              "retained_edge_mask": 128,
+              "support_size": 39
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                511,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                64433031176,
+                210738876432,
+                833794613280,
+                361919168576,
+                723838337152,
+                65280
+              ],
+              "deletions": 31,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8
+              ],
+              "rank": 9,
+              "retained_edge_mask": 0,
+              "support_size": 40
+            }
+          ]
+        },
+        {
+          "dimension": 10,
+          "empty_star": true,
+          "hierarchy": [
+            8,
+            15,
+            21,
+            26,
+            30,
+            34,
+            36,
+            38,
+            39,
+            40
+          ],
+          "observation_basis_rows": [
+            255,
+            65280,
+            4129025,
+            264241666,
+            4030792708,
+            64433031176,
+            210738876432,
+            833794613280,
+            361919168576,
+            1099511627775
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                65280
+              ],
+              "deletions": 7,
+              "information_edge_indices": [
+                8
+              ],
+              "rank": 1,
+              "retained_edge_mask": 1099511562495,
+              "support_size": 8
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                65280
+              ],
+              "deletions": 13,
+              "information_edge_indices": [
+                0,
+                8
+              ],
+              "rank": 2,
+              "retained_edge_mask": 1099507433726,
+              "support_size": 15
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                65280
+              ],
+              "deletions": 18,
+              "information_edge_indices": [
+                0,
+                2,
+                8
+              ],
+              "rank": 3,
+              "retained_edge_mask": 1095476707578,
+              "support_size": 21
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                210738876432,
+                65280
+              ],
+              "deletions": 22,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                8
+              ],
+              "rank": 4,
+              "retained_edge_mask": 885006532842,
+              "support_size": 26
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                4030792708,
+                210738876432,
+                361919168576,
+                65280
+              ],
+              "deletions": 25,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                8
+              ],
+              "rank": 5,
+              "retained_edge_mask": 592881647786,
+              "support_size": 30
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                210738876432,
+                361919168576,
+                65280
+              ],
+              "deletions": 28,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                6,
+                8
+              ],
+              "rank": 6,
+              "retained_edge_mask": 592705487016,
+              "support_size": 34
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                643,
+                2
+              ],
+              "decoder_word_masks": [
+                4193793,
+                264241666,
+                4030792708,
+                64433031176,
+                210738876432,
+                265716965408,
+                65280
+              ],
+              "deletions": 29,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                8
+              ],
+              "rank": 7,
+              "retained_edge_mask": 824633721024,
+              "support_size": 36
+            },
+            {
+              "coefficient_masks": [
+                517,
+                8,
+                531,
+                32,
+                64,
+                128,
+                2,
+                515
+              ],
+              "decoder_word_masks": [
+                1099507498497,
+                264241666,
+                1095480771588,
+                64433031176,
+                210738876432,
+                833794613280,
+                65280,
+                1099511562240
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                8,
+                16
+              ],
+              "rank": 8,
+              "retained_edge_mask": 192,
+              "support_size": 38
+            },
+            {
+              "coefficient_masks": [
+                517,
+                8,
+                531,
+                32,
+                64,
+                128,
+                256,
+                2,
+                515
+              ],
+              "decoder_word_masks": [
+                1099507498497,
+                264241666,
+                1095480771588,
+                64433031176,
+                210738876432,
+                833794613280,
+                361919168576,
+                65280,
+                1099511562240
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                8,
+                16
+              ],
+              "rank": 9,
+              "retained_edge_mask": 128,
+              "support_size": 39
+            },
+            {
+              "coefficient_masks": [
+                517,
+                8,
+                531,
+                32,
+                64,
+                128,
+                256,
+                511,
+                2,
+                515
+              ],
+              "decoder_word_masks": [
+                1099507498497,
+                264241666,
+                1095480771588,
+                64433031176,
+                210738876432,
+                833794613280,
+                361919168576,
+                723838337152,
+                65280,
+                1099511562240
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                16
+              ],
+              "rank": 10,
+              "retained_edge_mask": 0,
+              "support_size": 40
+            }
+          ]
+        }
+      ],
+      "edge_order": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          0,
+          7
+        ],
+        [
+          0,
+          8
+        ],
+        [
+          0,
+          9
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          1,
+          4
+        ],
+        [
+          1,
+          5
+        ],
+        [
+          1,
+          6
+        ],
+        [
+          1,
+          7
+        ],
+        [
+          1,
+          8
+        ],
+        [
+          1,
+          9
+        ],
+        [
+          2,
+          4
+        ],
+        [
+          2,
+          5
+        ],
+        [
+          2,
+          6
+        ],
+        [
+          2,
+          7
+        ],
+        [
+          2,
+          8
+        ],
+        [
+          2,
+          9
+        ],
+        [
+          3,
+          4
+        ],
+        [
+          3,
+          5
+        ],
+        [
+          3,
+          6
+        ],
+        [
+          3,
+          7
+        ],
+        [
+          3,
+          8
+        ],
+        [
+          3,
+          9
+        ],
+        [
+          4,
+          6
+        ],
+        [
+          4,
+          7
+        ],
+        [
+          4,
+          8
+        ],
+        [
+          4,
+          9
+        ],
+        [
+          5,
+          6
+        ],
+        [
+          5,
+          7
+        ],
+        [
+          5,
+          8
+        ],
+        [
+          5,
+          9
+        ],
+        [
+          6,
+          8
+        ],
+        [
+          6,
+          9
+        ],
+        [
+          7,
+          8
+        ],
+        [
+          7,
+          9
+        ]
+      ],
+      "p": 5,
+      "ports": 40,
+      "searches": {
+        "block_choices": 29524,
+        "cut_assignments": 28501,
+        "partition_transitions": 84676,
+        "vertex_subsets": 1024
+      },
+      "unrestricted_retained_by_block_count": [
+        40,
+        32,
+        25,
+        19,
+        14,
+        10,
+        6,
+        3,
+        1,
+        0
+      ]
+    },
+    {
+      "bipartite_retained_by_block_count": [
+        36,
+        30,
+        25,
+        20,
+        16,
+        12,
+        9,
+        6,
+        4,
+        2,
+        1,
+        0
+      ],
+      "codes": [
+        {
+          "dimension": 11,
+          "empty_star": false,
+          "hierarchy": [
+            10,
+            19,
+            27,
+            34,
+            40,
+            45,
+            50,
+            54,
+            57,
+            59,
+            60
+          ],
+          "observation_basis_rows": [
+            1023,
+            1047552,
+            267387905,
+            68451043330,
+            4329596522500,
+            277077469175816,
+            4226592494600208,
+            67562930098438176,
+            220975728093626432,
+            874297020414820480,
+            379499754109010176
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                1047552
+              ],
+              "deletions": 9,
+              "information_edge_indices": [
+                10
+              ],
+              "rank": 1,
+              "retained_edge_mask": 1152921504605799423,
+              "support_size": 10
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                1047552
+              ],
+              "deletions": 17,
+              "information_edge_indices": [
+                0,
+                10
+              ],
+              "rank": 2,
+              "retained_edge_mask": 1152921504338412542,
+              "support_size": 19
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                1047552
+              ],
+              "deletions": 24,
+              "information_edge_indices": [
+                0,
+                2,
+                10
+              ],
+              "rank": 3,
+              "retained_edge_mask": 1152917174742942714,
+              "support_size": 27
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                1047552
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                10
+              ],
+              "rank": 4,
+              "retained_edge_mask": 1148690650972029930,
+              "support_size": 34
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                1047552
+              ],
+              "deletions": 35,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                10
+              ],
+              "rank": 5,
+              "retained_edge_mask": 927996672749863850,
+              "support_size": 40
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 39,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 6,
+              "retained_edge_mask": 621681512164623018,
+              "support_size": 45
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 43,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 7,
+              "retained_edge_mask": 621681466530595496,
+              "support_size": 50
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 46,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 8,
+              "retained_edge_mask": 621496748577129120,
+              "support_size": 54
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 48,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                8,
+                10
+              ],
+              "rank": 9,
+              "retained_edge_mask": 576460752303424128,
+              "support_size": 57
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                512,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                874297020414820480,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 49,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                10
+              ],
+              "rank": 10,
+              "retained_edge_mask": 512,
+              "support_size": 59
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                512,
+                1024,
+                2047,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                874297020414820480,
+                379499754109010176,
+                758999508218020352,
+                1047552
+              ],
+              "deletions": 49,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10
+              ],
+              "rank": 11,
+              "retained_edge_mask": 0,
+              "support_size": 60
+            }
+          ]
+        },
+        {
+          "dimension": 12,
+          "empty_star": true,
+          "hierarchy": [
+            10,
+            19,
+            27,
+            34,
+            40,
+            45,
+            50,
+            54,
+            56,
+            58,
+            59,
+            60
+          ],
+          "observation_basis_rows": [
+            1023,
+            1047552,
+            267387905,
+            68451043330,
+            4329596522500,
+            277077469175816,
+            4226592494600208,
+            67562930098438176,
+            220975728093626432,
+            874297020414820480,
+            379499754109010176,
+            1152921504606846975
+          ],
+          "witnesses": [
+            {
+              "coefficient_masks": [
+                2
+              ],
+              "decoder_word_masks": [
+                1047552
+              ],
+              "deletions": 9,
+              "information_edge_indices": [
+                10
+              ],
+              "rank": 1,
+              "retained_edge_mask": 1152921504605799423,
+              "support_size": 10
+            },
+            {
+              "coefficient_masks": [
+                6,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                1047552
+              ],
+              "deletions": 17,
+              "information_edge_indices": [
+                0,
+                10
+              ],
+              "rank": 2,
+              "retained_edge_mask": 1152921504338412542,
+              "support_size": 19
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                1047552
+              ],
+              "deletions": 24,
+              "information_edge_indices": [
+                0,
+                2,
+                10
+              ],
+              "rank": 3,
+              "retained_edge_mask": 1152917174742942714,
+              "support_size": 27
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                1047552
+              ],
+              "deletions": 30,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                10
+              ],
+              "rank": 4,
+              "retained_edge_mask": 1148690650972029930,
+              "support_size": 34
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                1047552
+              ],
+              "deletions": 35,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                10
+              ],
+              "rank": 5,
+              "retained_edge_mask": 927996672749863850,
+              "support_size": 40
+            },
+            {
+              "coefficient_masks": [
+                6,
+                16,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 39,
+              "information_edge_indices": [
+                0,
+                2,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 6,
+              "retained_edge_mask": 621681512164623018,
+              "support_size": 45
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 43,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 7,
+              "retained_edge_mask": 621681466530595496,
+              "support_size": 50
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                256,
+                1024,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                220975728093626432,
+                379499754109010176,
+                1047552
+              ],
+              "deletions": 46,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                6,
+                8,
+                10
+              ],
+              "rank": 8,
+              "retained_edge_mask": 621496748577129120,
+              "support_size": 54
+            },
+            {
+              "coefficient_masks": [
+                6,
+                8,
+                16,
+                32,
+                64,
+                128,
+                256,
+                2563,
+                2
+              ],
+              "decoder_word_masks": [
+                268433409,
+                68451043330,
+                4329596522500,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                278624484191240320,
+                1047552
+              ],
+              "deletions": 47,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                10
+              ],
+              "rank": 9,
+              "retained_edge_mask": 864691128455136000,
+              "support_size": 56
+            },
+            {
+              "coefficient_masks": [
+                2053,
+                8,
+                2067,
+                32,
+                64,
+                128,
+                256,
+                512,
+                2,
+                2051
+              ],
+              "decoder_word_masks": [
+                1152921504339458049,
+                68451043330,
+                1152917175009284100,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                874297020414820480,
+                1047552,
+                1152921504605798400
+              ],
+              "deletions": 48,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                10,
+                20
+              ],
+              "rank": 10,
+              "retained_edge_mask": 768,
+              "support_size": 58
+            },
+            {
+              "coefficient_masks": [
+                2053,
+                8,
+                2067,
+                32,
+                64,
+                128,
+                256,
+                512,
+                1024,
+                2,
+                2051
+              ],
+              "decoder_word_masks": [
+                1152921504339458049,
+                68451043330,
+                1152917175009284100,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                874297020414820480,
+                379499754109010176,
+                1047552,
+                1152921504605798400
+              ],
+              "deletions": 48,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                10,
+                20
+              ],
+              "rank": 11,
+              "retained_edge_mask": 512,
+              "support_size": 59
+            },
+            {
+              "coefficient_masks": [
+                2053,
+                8,
+                2067,
+                32,
+                64,
+                128,
+                256,
+                512,
+                1024,
+                2047,
+                2,
+                2051
+              ],
+              "decoder_word_masks": [
+                1152921504339458049,
+                68451043330,
+                1152917175009284100,
+                277077469175816,
+                4226592494600208,
+                67562930098438176,
+                220975728093626432,
+                874297020414820480,
+                379499754109010176,
+                758999508218020352,
+                1047552,
+                1152921504605798400
+              ],
+              "deletions": 48,
+              "information_edge_indices": [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                20
+              ],
+              "rank": 12,
+              "retained_edge_mask": 0,
+              "support_size": 60
+            }
+          ]
+        }
+      ],
+      "edge_order": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          0,
+          6
+        ],
+        [
+          0,
+          7
+        ],
+        [
+          0,
+          8
+        ],
+        [
+          0,
+          9
+        ],
+        [
+          0,
+          10
+        ],
+        [
+          0,
+          11
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          1,
+          4
+        ],
+        [
+          1,
+          5
+        ],
+        [
+          1,
+          6
+        ],
+        [
+          1,
+          7
+        ],
+        [
+          1,
+          8
+        ],
+        [
+          1,
+          9
+        ],
+        [
+          1,
+          10
+        ],
+        [
+          1,
+          11
+        ],
+        [
+          2,
+          4
+        ],
+        [
+          2,
+          5
+        ],
+        [
+          2,
+          6
+        ],
+        [
+          2,
+          7
+        ],
+        [
+          2,
+          8
+        ],
+        [
+          2,
+          9
+        ],
+        [
+          2,
+          10
+        ],
+        [
+          2,
+          11
+        ],
+        [
+          3,
+          4
+        ],
+        [
+          3,
+          5
+        ],
+        [
+          3,
+          6
+        ],
+        [
+          3,
+          7
+        ],
+        [
+          3,
+          8
+        ],
+        [
+          3,
+          9
+        ],
+        [
+          3,
+          10
+        ],
+        [
+          3,
+          11
+        ],
+        [
+          4,
+          6
+        ],
+        [
+          4,
+          7
+        ],
+        [
+          4,
+          8
+        ],
+        [
+          4,
+          9
+        ],
+        [
+          4,
+          10
+        ],
+        [
+          4,
+          11
+        ],
+        [
+          5,
+          6
+        ],
+        [
+          5,
+          7
+        ],
+        [
+          5,
+          8
+        ],
+        [
+          5,
+          9
+        ],
+        [
+          5,
+          10
+        ],
+        [
+          5,
+          11
+        ],
+        [
+          6,
+          8
+        ],
+        [
+          6,
+          9
+        ],
+        [
+          6,
+          10
+        ],
+        [
+          6,
+          11
+        ],
+        [
+          7,
+          8
+        ],
+        [
+          7,
+          9
+        ],
+        [
+          7,
+          10
+        ],
+        [
+          7,
+          11
+        ],
+        [
+          8,
+          10
+        ],
+        [
+          8,
+          11
+        ],
+        [
+          9,
+          10
+        ],
+        [
+          9,
+          11
+        ]
+      ],
+      "p": 6,
+      "ports": 60,
+      "searches": {
+        "block_choices": 265720,
+        "cut_assignments": 261625,
+        "partition_transitions": 934117,
+        "vertex_subsets": 4096
+      },
+      "unrestricted_retained_by_block_count": [
+        60,
+        50,
+        41,
+        33,
+        26,
+        20,
+        15,
+        10,
+        6,
+        3,
+        1,
+        0
+      ]
+    }
+  ],
+  "scope": "Finite independent graph-code checks only. Partition DP exhausts all labeled vertex partitions and all cuts within blocks for p=3,4,5,6. Literal edge-subset ranks are exhaustive at p=2,3; literal code subspaces are exhaustive at p=3,4, and rank-three subspaces at p=5. Full graph-code weight distributions are checked at p=5,...,9. Uniform formulas require the separate mathematical proof; no supplier or kappa claim.",
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/higher_verify.py b/research/asymmetric-hypercube-decoder/higher_verify.py
new file mode 100644
index 0000000000..8517b72d21
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/higher_verify.py
@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""Exact independent k=2 hierarchy verification; Python 3.10+, stdlib only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+No assertions or imports from the predecessor verifiers. The searches do not
+use the proposed hierarchy formulas; formulas are compared only afterward.
+"""
+import argparse
+from collections import Counter
+import hashlib
+from itertools import combinations
+import json
+from math import comb
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def basis(rows):
+    pivots = {}
+    for word in rows:
+        while word:
+            pivot = word.bit_length() - 1
+            if pivot in pivots:
+                word ^= pivots[pivot]
+            else:
+                pivots[pivot] = word
+                break
+    return pivots
+
+
+def belongs(word, pivots):
+    for pivot in sorted(pivots, reverse=True):
+        if word >> pivot & 1:
+            word ^= pivots[pivot]
+    return word == 0
+
+
+def combine(coefficients, rows):
+    word = 0
+    for i, row in enumerate(rows):
+        if coefficients >> i & 1:
+            word ^= row
+    return word
+
+
+def graph_model(p):
+    edges = [(u, v) for u, v in combinations(range(2 * p), 2) if u // 2 != v // 2]
+    rows = [sum(1 << e for e, edge in enumerate(edges) if v in edge) for v in range(2 * p)]
+    return edges, rows
+
+
+def code_basis(rows, empty):
+    generators = rows + ([(1 << max(row.bit_length() for row in rows)) - 1] if empty else [])
+    independent = []
+    for row in generators:
+        if not belongs(row, basis(independent)):
+            independent.append(row)
+    return independent
+
+
+def formula(p, empty):
+    n, size = 2 * p, 2 * p * (p - 1)
+    cut = [size - comb(n - r, 2) + max(0, p - r) for r in range(1, n)]
+    if not empty or p == 2:
+        return cut
+    return [cut[0]] + [min(cut[r - 1], size - (n - r + 1) ** 2 // 4)
+                      for r in range(2, n)] + [size]
+
+
+def graph_components(n, edges, edge_mask):
+    adjacent = [[] for _ in range(n)]
+    for e, (u, v) in enumerate(edges):
+        if edge_mask >> e & 1:
+            adjacent[u].append(v)
+            adjacent[v].append(u)
+    colors, components, bipartite = {}, 0, True
+    for root in range(n):
+        if root in colors:
+            continue
+        components += 1
+        colors[root] = 0
+        stack = [root]
+        while stack:
+            u = stack.pop()
+            for v in adjacent[u]:
+                if v not in colors:
+                    colors[v] = 1 - colors[u]
+                    stack.append(v)
+                elif colors[v] == colors[u]:
+                    bipartite = False
+    return components, bipartite
+
+
+def partition_tables(n, edges):
+    """All labeled vertex partitions, via subset DP; all cuts in every block.
+
+    A transition chooses the block containing the lowest remaining vertex.
+    No block-size, convexity, symmetry or optimal-component assumption is used.
+    Disconnected block realizations are permitted: their true component count
+    can only be greater, so maximizing over at least the required blocks is valid.
+    """
+    order = 1 << n
+    induced, cut = [0] * order, [0] * order
+    block_visits, cut_visits, transitions = 0, 0, 0
+    tables = [[[0]], [[0]]]
+    choices = [[[0]], [[0]]]
+    for mask in range(1, order):
+        anchor = mask & -mask
+        vertex = anchor.bit_length() - 1
+        rest = mask ^ anchor
+        induced[mask] = induced[rest]
+        for e, (u, v) in enumerate(edges):
+            if vertex == u and rest >> v & 1 or vertex == v and rest >> u & 1:
+                induced[mask] |= 1 << e
+        left = (mask - 1) & mask
+        while left:
+            if left & anchor:
+                candidate = induced[mask] ^ induced[left] ^ induced[mask ^ left]
+                cut_visits += 1
+                if candidate.bit_count() > cut[mask].bit_count():
+                    cut[mask] = candidate
+            left = (left - 1) & mask
+        for kind in range(2):
+            tables[kind].append([-1] * (mask.bit_count() + 1))
+            choices[kind].append([0] * (mask.bit_count() + 1))
+        block = mask
+        while block:
+            if block & anchor:
+                block_visits += 1
+                remainder = mask ^ block
+                for count in range(len(tables[0][remainder])):
+                    if tables[0][remainder][count] < 0:
+                        continue
+                    transitions += 1
+                    for kind, weights in enumerate((induced, cut)):
+                        value = weights[block].bit_count() + tables[kind][remainder][count]
+                        if value > tables[kind][mask][count + 1]:
+                            tables[kind][mask][count + 1] = value
+                            choices[kind][mask][count + 1] = block
+            block = (block - 1) & mask
+    require(block_visits == (3 ** n - 1) // 2, "complete anchored-block census")
+    require(cut_visits == (3 ** n - 2 ** (n + 1) + 1) // 2, "complete nontrivial-cut census")
+    return tables, choices, (induced, cut), dict(
+        vertex_subsets=order, block_choices=block_visits,
+        cut_assignments=cut_visits, partition_transitions=transitions)
+
+
+def retained_witness(n, required, kind, tables, choices, weights):
+    if required > n:
+        return -1, 0
+    mask = (1 << n) - 1
+    count = max(range(required, n + 1), key=lambda count: tables[kind][mask][count])
+    retained = tables[kind][mask][count]
+    witness = 0
+    while mask:
+        block = choices[kind][mask][count]
+        require(block and block & mask == block, "invalid partition reconstruction")
+        witness |= weights[kind][block]
+        mask ^= block
+        count -= 1
+    require(count == 0 and witness.bit_count() == retained, "partition edge count")
+    return retained, witness
+
+
+def kernel(rows, zero_edges, size):
+    equations = [sum(((row >> e) & 1) << j for j, row in enumerate(rows))
+                 for e in range(size) if zero_edges >> e & 1]
+    pivots = basis(equations)
+    vectors = []
+    for free in range(len(rows)):
+        if free in pivots:
+            continue
+        vector = 1 << free
+        for pivot in sorted(pivots):
+            if (pivots[pivot] & vector).bit_count() % 2:
+                vector ^= 1 << pivot
+        require(all((equation & vector).bit_count() % 2 == 0 for equation in equations),
+                "restriction-kernel vector")
+        vectors.append(vector)
+    return vectors
+
+
+def decoder_witness(rows, zero_edges, rank, size):
+    coefficients = kernel(rows, zero_edges, size)[:rank]
+    require(len(coefficients) == rank, "insufficient kernel dimension")
+    words = [combine(vector, rows) for vector in coefficients]
+    information = []
+    for column in range(size):
+        found = next((i for i in range(len(information), rank) if words[i] >> column & 1), None)
+        if found is None:
+            continue
+        pivot = len(information)
+        words[pivot], words[found] = words[found], words[pivot]
+        coefficients[pivot], coefficients[found] = coefficients[found], coefficients[pivot]
+        for i in range(rank):
+            if i != pivot and words[i] >> column & 1:
+                words[i] ^= words[pivot]
+                coefficients[i] ^= coefficients[pivot]
+        information.append(column)
+    require(len(information) == rank, "dependent decoder rows")
+    support = 0
+    for word in words:
+        support |= word
+    require(support.bit_count() == size - zero_edges.bit_count(), "non-sharp witness support")
+    selected = sum(1 << e for e in information)
+    deleted = support ^ selected
+    surviving = ((1 << size) - 1) ^ deleted
+    for coefficient, word, target in zip(coefficients, words, information):
+        require(combine(coefficient, rows) == word, "literal observation combination")
+        require(word & surviving == 1 << target, "simultaneous target identity")
+    for edge in range(size):
+        if deleted >> edge & 1:
+            restored = surviving | 1 << edge
+            restricted = basis(row & restored for row in rows)
+            require(not all(belongs(1 << target, restricted) for target in information),
+                    "single-edge restoration still decodes every target")
+    return dict(rank=rank, support_size=support.bit_count(), retained_edge_mask=zero_edges,
+                information_edge_indices=information, coefficient_masks=coefficients,
+                decoder_word_masks=words, deletions=deleted.bit_count())
+
+
+def partition_case(p):
+    n = 2 * p
+    edges, stars = graph_model(p)
+    size = len(edges)
+    tables, choices, weights, counts = partition_tables(n, edges)
+    cases = []
+    for empty in (False, True):
+        rows = code_basis(stars, empty)
+        require(len(rows) == n - 1 + empty, "graph-code rank")
+        witnesses = []
+        for rank in range(1, len(rows) + 1):
+            candidates = [retained_witness(n, rank + 1, 0, tables, choices, weights)]
+            if empty:
+                candidates.append(retained_witness(n, rank, 1, tables, choices, weights))
+            _, retained = max(candidates, key=lambda pair: pair[0])
+            witnesses.append(decoder_witness(rows, retained, rank, size))
+        hierarchy = [witness["support_size"] for witness in witnesses]
+        require(hierarchy == formula(p, empty), "formula versus exact partition hierarchy")
+        cases.append(dict(empty_star=empty, dimension=len(rows), hierarchy=hierarchy,
+                          observation_basis_rows=rows, witnesses=witnesses))
+    return dict(p=p, ports=size, searches=counts,
+                unrestricted_retained_by_block_count=tables[0][-1][1:],
+                bipartite_retained_by_block_count=tables[1][-1][1:],
+                edge_order=[list(edge) for edge in edges], codes=cases)
+
+
+def exhaustive_edge_sets(p):
+    edges, stars = graph_model(p)
+    n, size = 2 * p, len(edges)
+    output = []
+    for empty in (False, True):
+        rows = code_basis(stars, empty)
+        hierarchy = [size + 1] * len(rows)
+        for mask in range(1 << size):
+            dimension = len(rows) - len(basis(row & mask for row in rows))
+            components, bipartite = graph_components(n, edges, mask)
+            predicted = components - 1 + (empty and p >= 3 and bipartite)
+            require(dimension == predicted, "graph kernel formula versus literal restriction rank")
+            for rank in range(dimension):
+                hierarchy[rank] = min(hierarchy[rank], size - mask.bit_count())
+        require(hierarchy == formula(p, empty), "all edge subsets versus hierarchy formula")
+        output.append(dict(p=p, empty_star=empty, dimension=len(rows),
+                           edge_sets=1 << size, hierarchy=hierarchy))
+    return output
+
+
+def exhaustive_subspaces(p, empty, ranks=None):
+    edges, stars = graph_model(p)
+    rows = code_basis(stars, empty)
+    dimension, size = len(rows), len(edges)
+    evaluations = [combine(vector, rows) for vector in range(1 << dimension)]
+    hierarchy, counts, minimum_counts = [], [], []
+    checked_ranks = list(ranks or range(1, dimension + 1))
+    for rank in checked_ranks:
+        minimum, count, attaining = size + 1, 0, 0
+        for pivots in combinations(range(dimension), rank):
+            slots = [(i, column) for i, pivot in enumerate(pivots)
+                     for column in range(pivot + 1, dimension) if column not in pivots]
+            for assignments in range(1 << len(slots)):
+                vectors = [1 << pivot for pivot in pivots]
+                for bit, (i, column) in enumerate(slots):
+                    if assignments >> bit & 1:
+                        vectors[i] |= 1 << column
+                support = 0
+                for vector in vectors:
+                    support |= evaluations[vector]
+                weight = support.bit_count()
+                count += 1
+                if weight < minimum:
+                    minimum, attaining = weight, 1
+                elif weight == minimum:
+                    attaining += 1
+        numerator, denominator = 1, 1
+        for i in range(rank):
+            numerator *= (1 << dimension) - (1 << i)
+            denominator *= (1 << rank) - (1 << i)
+        require(count == numerator // denominator, "Gaussian binomial subspace count")
+        hierarchy.append(minimum)
+        counts.append(count)
+        minimum_counts.append(attaining)
+    require(hierarchy == [formula(p, empty)[rank - 1] for rank in checked_ranks],
+            "RREF full-code hierarchy")
+    if p >= 5 and 3 in checked_ranks:
+        require(minimum_counts[checked_ranks.index(3)] == 8 * comb(p, 3),
+                "complete optimal rank-three census versus triangle classification")
+    return dict(p=p, empty_star=empty, dimension=dimension, ranks=checked_ranks, hierarchy=hierarchy,
+                subspaces_by_rank=counts, minimum_subspaces_by_rank=minimum_counts,
+                nonzero_subspaces=sum(counts), generator_rows_sha256=digest(rows))
+
+
+def spectrum_case(p, empty):
+    _, stars = graph_model(p)
+    rows = code_basis(stars, empty)
+    words = [0]
+    for row in rows:
+        words += [word ^ row for word in words]
+    require(len(set(words)) == 1 << len(rows), "complete distinct graph-word census")
+    distribution = Counter(word.bit_count() for word in words)
+    positive_weights = sorted(weight for weight in distribution if weight)
+    require(positive_weights[:2] == [2 * p - 2, 4 * p - 6], "first two graph weights")
+    return dict(p=p, empty_star=empty, dimension=len(rows), words=len(words),
+                weight_distribution={str(weight): count for weight, count in sorted(distribution.items())})
+
+
+def verify():
+    partitions = [partition_case(p) for p in range(3, 7)]
+    edges = [case for p in (2, 3) for case in exhaustive_edge_sets(p)]
+    subspaces = [exhaustive_subspaces(p, empty) for p in (3, 4) for empty in (False, True)]
+    triangles = [exhaustive_subspaces(5, empty, ranks=(3,)) for empty in (False, True)]
+    spectra = [spectrum_case(p, empty) for p in range(5, 10) for empty in (False, True)]
+    require(partitions[1]["codes"][0]["hierarchy"][4] == 21 and
+            partitions[1]["codes"][1]["hierarchy"][4] == 20, "empty-star distinction control")
+    require(partitions[0]["bipartite_retained_by_block_count"][0] == 8,
+            "odd-p rank-one balanced-cut obstruction")
+    require(edges[1]["dimension"] == 3, "p=2 redundant constant control")
+    return dict(status="PASS", arithmetic="exact F2 integer bitsets",
+                scope="Finite independent graph-code checks only. Partition DP exhausts all labeled vertex "
+                      "partitions and all cuts within blocks for p=3,4,5,6. Literal edge-subset ranks "
+                      "are exhaustive at p=2,3; literal code subspaces are exhaustive at p=3,4, and rank-three "
+                      "subspaces at p=5. Full graph-code weight distributions are checked at p=5,...,9. "
+                      "Uniform formulas require the separate mathematical proof; no supplier or kappa claim.",
+                partition_cases=partitions, exhaustive_edge_sets=edges, exhaustive_subspaces=subspaces,
+                optimal_triangle_census=triangles, full_graph_spectra=spectra,
+                negative_controls=["every single deleted-edge restoration breaks its simultaneous decoder",
+                                   "p=2 has redundant empty star and dimension three",
+                                   "odd p=3 loses one edge against the naive balanced complete cut",
+                                   "omitting the bipartite branch gives a false fifth weight at p=4"])
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / "higher_verify.py"
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / "HIGHER-RESULTS.json"
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path, help="write receipt after checks pass")
+    parser.add_argument("--check", type=Path, help="compare receipt before writing output")
+    parser.add_argument("--self-test", action="store_true", help="check relocation and failure preservation")
+    args = parser.parse_args()
+    result = verify()
+    if args.check or not args.write:
+        receipt = args.check or HERE / "HIGHER-RESULTS.json"
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    witnesses = [witness for case in result['partition_cases']
+                 for code in case['codes'] for witness in code['witnesses']]
+    print("PASS_HIGHER_GRAPH: 4 exact partition DPs; "
+          f"{sum(case['edge_sets'] for case in result['exhaustive_edge_sets'])} edge restrictions; "
+          f"{sum(case['nonzero_subspaces'] for case in result['exhaustive_subspaces'])} code subspaces; "
+          f"{sum(case['nonzero_subspaces'] for case in result['optimal_triangle_census'])} rank-three census subspaces; "
+          f"{sum(case['words'] for case in result['full_graph_spectra'])} spectral words; "
+          f"{len(witnesses)} optimal simultaneous decoder witnesses; "
+          f"{sum(witness['deletions'] for witness in witnesses)} restoration controls")
+
+
+if __name__ == "__main__":
+    main()

From 7d526020fc368ce4157cd436995c2f4fcf683318 Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:33:16 +0900
Subject: [PATCH 5/7] Prove uniform star-code weight gap and optimal
 three-target geometry

---
 .../BOUNDARY-RESULTS.json                     |  106 ++
 .../CUBE-RESULTS.json                         | 1436 +++++++++++++++++
 .../HIGHER-CLAIM.json                         |  149 ++
 .../HIGHER-COST.md                            |   73 +
 .../HIGHER-WEIGHTS.md                         |  489 ++++++
 .../asymmetric-hypercube-decoder/README.md    |   75 +-
 .../boundary_verify.py                        |  212 +++
 .../cube_verify.py                            |  248 +++
 8 files changed, 2787 insertions(+), 1 deletion(-)
 create mode 100644 research/asymmetric-hypercube-decoder/BOUNDARY-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/CUBE-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/HIGHER-CLAIM.json
 create mode 100644 research/asymmetric-hypercube-decoder/HIGHER-COST.md
 create mode 100644 research/asymmetric-hypercube-decoder/HIGHER-WEIGHTS.md
 create mode 100644 research/asymmetric-hypercube-decoder/boundary_verify.py
 create mode 100644 research/asymmetric-hypercube-decoder/cube_verify.py

diff --git a/research/asymmetric-hypercube-decoder/BOUNDARY-RESULTS.json b/research/asymmetric-hypercube-decoder/BOUNDARY-RESULTS.json
new file mode 100644
index 0000000000..68b8611a1a
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/BOUNDARY-RESULTS.json
@@ -0,0 +1,106 @@
+{
+  "arithmetic": "exact F2 integer bitsets",
+  "extended_minimum_word_masks": [
+    15,
+    240,
+    3840,
+    61440,
+    983040,
+    15728640
+  ],
+  "extended_quotient_rank": 2,
+  "extended_rank": 10,
+  "extended_weight_distribution": {
+    "0": 1,
+    "10": 288,
+    "12": 340,
+    "14": 288,
+    "16": 15,
+    "18": 32,
+    "20": 6,
+    "24": 1,
+    "4": 6,
+    "6": 32,
+    "8": 15
+  },
+  "extended_words": 1024,
+  "global_degree_at_most_two_generators": 51,
+  "global_nonempty_rank": 40,
+  "global_ports": 80,
+  "global_rank": 40,
+  "negative_controls": [
+    "the graph-only slice space rejects valid shortened words",
+    "every weight-four E word is a single unsigned block",
+    "distinct weight-four E words have disjoint supports",
+    "the k=3 global empty star is already in the nonempty span"
+  ],
+  "residual_graph_rank": 8,
+  "residual_graph_words": 256,
+  "residual_ports": 24,
+  "scope": "Complete finite linear-space audit of the k=3,p=5 shortening at all five original pairs. Every shortening basis vector is checked; linearity extends containment and quotient agreement to its full span. All residual E words are enumerated. This is not an enumeration of every global codeword or rank-three subcode; the proof in HIGHER-WEIGHTS.md supplies the third-weight conclusion.",
+  "shortening_cases": [
+    {
+      "avoidance_rank": 22,
+      "avoided_port_count": 32,
+      "selected_pair": 0,
+      "shortening_basis_sha256": "583dd87859755b8839ebf64fc4791401708060c93235586b5988cbfc9041da92",
+      "shortening_rank": 18,
+      "slice_basis_sha256": "898105a106a456c8756c2cb8bc7933fa9fe95a416908b80d840a559ce6af5a4d",
+      "slice_projection_ranks": [
+        10,
+        10
+      ]
+    },
+    {
+      "avoidance_rank": 22,
+      "avoided_port_count": 32,
+      "selected_pair": 1,
+      "shortening_basis_sha256": "5b799813e6e3005ec41e287b55afabd32e8705df9809ea727a143f9b4fee6423",
+      "shortening_rank": 18,
+      "slice_basis_sha256": "935a684e5de50c1ff0328ceacecc2b96b6f9fdfb26afc3cdfc4f617b1a950c3c",
+      "slice_projection_ranks": [
+        10,
+        10
+      ]
+    },
+    {
+      "avoidance_rank": 22,
+      "avoided_port_count": 32,
+      "selected_pair": 2,
+      "shortening_basis_sha256": "61753ecabc8e0aac1482fbc6a4c23f6e7090209940c5056ea138a1875b23b74f",
+      "shortening_rank": 18,
+      "slice_basis_sha256": "2ff8a65de9f350a47db24db117a5f9b95e5fa4f0662c187d433406c4f0549066",
+      "slice_projection_ranks": [
+        10,
+        10
+      ]
+    },
+    {
+      "avoidance_rank": 22,
+      "avoided_port_count": 32,
+      "selected_pair": 3,
+      "shortening_basis_sha256": "c3f2f744b45df7ec5aa26112084c5b7b54000dbbf5ad30e123f286b10ad9b209",
+      "shortening_rank": 18,
+      "slice_basis_sha256": "ffc2f874bea8e4a7d1c2d0e615188cb4b1745c338bab8ce1a9c56a8eff197ab8",
+      "slice_projection_ranks": [
+        10,
+        10
+      ]
+    },
+    {
+      "avoidance_rank": 22,
+      "avoided_port_count": 32,
+      "selected_pair": 4,
+      "shortening_basis_sha256": "97fc780bf5a73c052c38bc09e5fd48e0d32febd16fab0f77f040fb1b273ad038",
+      "shortening_rank": 18,
+      "slice_basis_sha256": "ae2121fa4c42049fcfdf757fb8d0f870837d32480ee4aa98ce9a6991dd784dd2",
+      "slice_projection_ranks": [
+        10,
+        10
+      ]
+    }
+  ],
+  "status": "PASS",
+  "unsigned_block_rank": 6,
+  "unsigned_graph_intersection_rank": 4
+}
diff --git a/research/asymmetric-hypercube-decoder/CUBE-RESULTS.json b/research/asymmetric-hypercube-decoder/CUBE-RESULTS.json
new file mode 100644
index 0000000000..4952261822
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CUBE-RESULTS.json
@@ -0,0 +1,1436 @@
+{
+  "arithmetic": "exact binary evaluations on every full-family port",
+  "cubes": [
+    {
+      "k": 4,
+      "p": 6,
+      "port_order_sha256": "a0d5f2a8944b2bda7ffc86012421153ab6be360328a205dbb44e5b8ced17a546",
+      "ports": 240,
+      "witnesses": [
+        {
+          "basis_rows_sha256": "308d10a63af089d371b1d389bea384b395efb59d9d7ea0ebb1ecc431e9e7c971",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 4,
+            "direct_unit_row_xors": 60,
+            "distinct_observations": 27,
+            "independent_helper_input_contributions": 583,
+            "independent_helper_sum_xors": 556,
+            "original_row_xors": 24
+          },
+          "decoder_coefficients": [
+            7,
+            5,
+            3
+          ],
+          "decoder_proper_star_faces": [
+            [
+              1,
+              4,
+              16,
+              257,
+              260,
+              272,
+              513,
+              516,
+              528,
+              1025,
+              1028,
+              1040,
+              1281,
+              1284,
+              1296,
+              1537,
+              1540,
+              1552,
+              2049,
+              2052,
+              2064,
+              2305,
+              2308,
+              2320,
+              2561,
+              2564,
+              2576
+            ],
+            [
+              1,
+              16,
+              257,
+              272,
+              513,
+              528,
+              1025,
+              1040,
+              1281,
+              1296,
+              1537,
+              1552,
+              2049,
+              2064,
+              2305,
+              2320,
+              2561,
+              2576
+            ],
+            [
+              1,
+              4,
+              257,
+              260,
+              513,
+              516,
+              1025,
+              1028,
+              1281,
+              1284,
+              1537,
+              1540,
+              2049,
+              2052,
+              2305,
+              2308,
+              2561,
+              2564
+            ]
+          ],
+          "deleted_indices": [
+            1,
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+          ],
+          "deleted_ports": [
+            149,
+            165,
+            153,
+            105,
+            169,
+            86,
+            150,
+            102,
+            166,
+            90,
+            154
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            2,
+            4
+          ],
+          "information_ports": [
+            85,
+            101,
+            89
+          ],
+          "original_proper_star_faces": [
+            [
+              1,
+              1025,
+              2049,
+              257,
+              1281,
+              2305,
+              513,
+              1537,
+              2561
+            ],
+            [
+              4,
+              1028,
+              2052,
+              260,
+              1284,
+              2308,
+              516,
+              1540,
+              2564
+            ],
+            [
+              16,
+              1040,
+              2064,
+              272,
+              1296,
+              2320,
+              528,
+              1552,
+              2576
+            ]
+          ],
+          "rank": 3,
+          "support_size": 14
+        },
+        {
+          "basis_rows_sha256": "02ad51b2fe0bae0cf39501c41e4510fc94b48c6b81bac5e61caed75084793a81",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 5,
+            "direct_unit_row_xors": 77,
+            "distinct_observations": 36,
+            "independent_helper_input_contributions": 781,
+            "independent_helper_sum_xors": 745,
+            "original_row_xors": 32
+          },
+          "decoder_coefficients": [
+            14,
+            9,
+            5,
+            3
+          ],
+          "decoder_proper_star_faces": [
+            [
+              4,
+              16,
+              64,
+              260,
+              272,
+              320,
+              516,
+              528,
+              576,
+              1028,
+              1040,
+              1088,
+              1284,
+              1296,
+              1344,
+              1540,
+              1552,
+              1600,
+              2052,
+              2064,
+              2112,
+              2308,
+              2320,
+              2368,
+              2564,
+              2576,
+              2624
+            ],
+            [
+              1,
+              64,
+              257,
+              320,
+              513,
+              576,
+              1025,
+              1088,
+              1281,
+              1344,
+              1537,
+              1600,
+              2049,
+              2112,
+              2305,
+              2368,
+              2561,
+              2624
+            ],
+            [
+              1,
+              16,
+              257,
+              272,
+              513,
+              528,
+              1025,
+              1040,
+              1281,
+              1296,
+              1537,
+              1552,
+              2049,
+              2064,
+              2305,
+              2320,
+              2561,
+              2576
+            ],
+            [
+              1,
+              4,
+              257,
+              260,
+              513,
+              516,
+              1025,
+              1028,
+              1281,
+              1284,
+              1537,
+              1540,
+              2049,
+              2052,
+              2305,
+              2308,
+              2561,
+              2564
+            ]
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+          ],
+          "deleted_ports": [
+            165,
+            153,
+            105,
+            169,
+            86,
+            150,
+            102,
+            166,
+            90,
+            154,
+            106
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4
+          ],
+          "information_ports": [
+            85,
+            149,
+            101,
+            89
+          ],
+          "original_proper_star_faces": [
+            [
+              1,
+              1025,
+              2049,
+              257,
+              1281,
+              2305,
+              513,
+              1537,
+              2561
+            ],
+            [
+              4,
+              1028,
+              2052,
+              260,
+              1284,
+              2308,
+              516,
+              1540,
+              2564
+            ],
+            [
+              16,
+              1040,
+              2064,
+              272,
+              1296,
+              2320,
+              528,
+              1552,
+              2576
+            ],
+            [
+              64,
+              1088,
+              2112,
+              320,
+              1344,
+              2368,
+              576,
+              1600,
+              2624
+            ]
+          ],
+          "rank": 4,
+          "support_size": 15
+        },
+        {
+          "basis_rows_sha256": "b8af428dd743ccbaa6ffe7b3902befc5240229a35d57f113fba848ea4b87172c",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 9,
+            "direct_unit_row_xors": 121,
+            "distinct_observations": 45,
+            "independent_helper_input_contributions": 977,
+            "independent_helper_sum_xors": 932,
+            "original_row_xors": 40
+          },
+          "decoder_coefficients": [
+            23,
+            16,
+            28,
+            26,
+            25
+          ],
+          "decoder_proper_star_faces": [
+            [
+              1,
+              4,
+              16,
+              128,
+              257,
+              260,
+              272,
+              384,
+              513,
+              516,
+              528,
+              640,
+              1025,
+              1028,
+              1040,
+              1152,
+              1281,
+              1284,
+              1296,
+              1408,
+              1537,
+              1540,
+              1552,
+              1664,
+              2049,
+              2052,
+              2064,
+              2176,
+              2305,
+              2308,
+              2320,
+              2432,
+              2561,
+              2564,
+              2576,
+              2688
+            ],
+            [
+              128,
+              384,
+              640,
+              1152,
+              1408,
+              1664,
+              2176,
+              2432,
+              2688
+            ],
+            [
+              16,
+              64,
+              128,
+              272,
+              320,
+              384,
+              528,
+              576,
+              640,
+              1040,
+              1088,
+              1152,
+              1296,
+              1344,
+              1408,
+              1552,
+              1600,
+              1664,
+              2064,
+              2112,
+              2176,
+              2320,
+              2368,
+              2432,
+              2576,
+              2624,
+              2688
+            ],
+            [
+              4,
+              64,
+              128,
+              260,
+              320,
+              384,
+              516,
+              576,
+              640,
+              1028,
+              1088,
+              1152,
+              1284,
+              1344,
+              1408,
+              1540,
+              1600,
+              1664,
+              2052,
+              2112,
+              2176,
+              2308,
+              2368,
+              2432,
+              2564,
+              2624,
+              2688
+            ],
+            [
+              1,
+              64,
+              128,
+              257,
+              320,
+              384,
+              513,
+              576,
+              640,
+              1025,
+              1088,
+              1152,
+              1281,
+              1344,
+              1408,
+              1537,
+              1600,
+              1664,
+              2049,
+              2112,
+              2176,
+              2305,
+              2368,
+              2432,
+              2561,
+              2624,
+              2688
+            ]
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+          ],
+          "deleted_ports": [
+            165,
+            153,
+            105,
+            169,
+            150,
+            102,
+            166,
+            90,
+            154,
+            106,
+            170
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4,
+            8
+          ],
+          "information_ports": [
+            85,
+            149,
+            101,
+            89,
+            86
+          ],
+          "original_proper_star_faces": [
+            [
+              1,
+              1025,
+              2049,
+              257,
+              1281,
+              2305,
+              513,
+              1537,
+              2561
+            ],
+            [
+              4,
+              1028,
+              2052,
+              260,
+              1284,
+              2308,
+              516,
+              1540,
+              2564
+            ],
+            [
+              16,
+              1040,
+              2064,
+              272,
+              1296,
+              2320,
+              528,
+              1552,
+              2576
+            ],
+            [
+              64,
+              1088,
+              2112,
+              320,
+              1344,
+              2368,
+              576,
+              1600,
+              2624
+            ],
+            [
+              128,
+              1152,
+              2176,
+              384,
+              1408,
+              2432,
+              640,
+              1664,
+              2688
+            ]
+          ],
+          "rank": 5,
+          "support_size": 16
+        }
+      ]
+    },
+    {
+      "k": 5,
+      "p": 7,
+      "port_order_sha256": "e4471ec7eec99a4f79973f784f875e8acc4fc9eae51deb24dc90e0190dadc2ae",
+      "ports": 672,
+      "witnesses": [
+        {
+          "basis_rows_sha256": "308d10a63af089d371b1d389bea384b395efb59d9d7ea0ebb1ecc431e9e7c971",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 4,
+            "direct_unit_row_xors": 60,
+            "distinct_observations": 27,
+            "independent_helper_input_contributions": 583,
+            "independent_helper_sum_xors": 556,
+            "original_row_xors": 24
+          },
+          "decoder_coefficients": [
+            7,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            1,
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            2,
+            4
+          ],
+          "rank": 3,
+          "support_size": 14
+        },
+        {
+          "basis_rows_sha256": "02ad51b2fe0bae0cf39501c41e4510fc94b48c6b81bac5e61caed75084793a81",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 5,
+            "direct_unit_row_xors": 77,
+            "distinct_observations": 36,
+            "independent_helper_input_contributions": 781,
+            "independent_helper_sum_xors": 745,
+            "original_row_xors": 32
+          },
+          "decoder_coefficients": [
+            14,
+            9,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4
+          ],
+          "rank": 4,
+          "support_size": 15
+        },
+        {
+          "basis_rows_sha256": "b8af428dd743ccbaa6ffe7b3902befc5240229a35d57f113fba848ea4b87172c",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 9,
+            "direct_unit_row_xors": 121,
+            "distinct_observations": 45,
+            "independent_helper_input_contributions": 977,
+            "independent_helper_sum_xors": 932,
+            "original_row_xors": 40
+          },
+          "decoder_coefficients": [
+            23,
+            16,
+            28,
+            26,
+            25
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4,
+            8
+          ],
+          "rank": 5,
+          "support_size": 16
+        }
+      ]
+    },
+    {
+      "k": 6,
+      "p": 8,
+      "port_order_sha256": "cc76e1519461e6abba109927bdf89398562b2f20e0461d99b94044505d7389e2",
+      "ports": 1792,
+      "witnesses": [
+        {
+          "basis_rows_sha256": "308d10a63af089d371b1d389bea384b395efb59d9d7ea0ebb1ecc431e9e7c971",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 4,
+            "direct_unit_row_xors": 60,
+            "distinct_observations": 27,
+            "independent_helper_input_contributions": 583,
+            "independent_helper_sum_xors": 556,
+            "original_row_xors": 24
+          },
+          "decoder_coefficients": [
+            7,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            1,
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            2,
+            4
+          ],
+          "rank": 3,
+          "support_size": 14
+        },
+        {
+          "basis_rows_sha256": "02ad51b2fe0bae0cf39501c41e4510fc94b48c6b81bac5e61caed75084793a81",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 5,
+            "direct_unit_row_xors": 77,
+            "distinct_observations": 36,
+            "independent_helper_input_contributions": 781,
+            "independent_helper_sum_xors": 745,
+            "original_row_xors": 32
+          },
+          "decoder_coefficients": [
+            14,
+            9,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4
+          ],
+          "rank": 4,
+          "support_size": 15
+        },
+        {
+          "basis_rows_sha256": "b8af428dd743ccbaa6ffe7b3902befc5240229a35d57f113fba848ea4b87172c",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 9,
+            "direct_unit_row_xors": 121,
+            "distinct_observations": 45,
+            "independent_helper_input_contributions": 977,
+            "independent_helper_sum_xors": 932,
+            "original_row_xors": 40
+          },
+          "decoder_coefficients": [
+            23,
+            16,
+            28,
+            26,
+            25
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4,
+            8
+          ],
+          "rank": 5,
+          "support_size": 16
+        }
+      ]
+    },
+    {
+      "k": 7,
+      "p": 9,
+      "port_order_sha256": "c0100d0b7059f80443972f0fda0198df9993c75dd7626b713c831f9287392bc3",
+      "ports": 4608,
+      "witnesses": [
+        {
+          "basis_rows_sha256": "308d10a63af089d371b1d389bea384b395efb59d9d7ea0ebb1ecc431e9e7c971",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 4,
+            "direct_unit_row_xors": 60,
+            "distinct_observations": 27,
+            "independent_helper_input_contributions": 583,
+            "independent_helper_sum_xors": 556,
+            "original_row_xors": 24
+          },
+          "decoder_coefficients": [
+            7,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            1,
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            2,
+            4
+          ],
+          "rank": 3,
+          "support_size": 14
+        },
+        {
+          "basis_rows_sha256": "02ad51b2fe0bae0cf39501c41e4510fc94b48c6b81bac5e61caed75084793a81",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 5,
+            "direct_unit_row_xors": 77,
+            "distinct_observations": 36,
+            "independent_helper_input_contributions": 781,
+            "independent_helper_sum_xors": 745,
+            "original_row_xors": 32
+          },
+          "decoder_coefficients": [
+            14,
+            9,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4
+          ],
+          "rank": 4,
+          "support_size": 15
+        },
+        {
+          "basis_rows_sha256": "b8af428dd743ccbaa6ffe7b3902befc5240229a35d57f113fba848ea4b87172c",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 9,
+            "direct_unit_row_xors": 121,
+            "distinct_observations": 45,
+            "independent_helper_input_contributions": 977,
+            "independent_helper_sum_xors": 932,
+            "original_row_xors": 40
+          },
+          "decoder_coefficients": [
+            23,
+            16,
+            28,
+            26,
+            25
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4,
+            8
+          ],
+          "rank": 5,
+          "support_size": 16
+        }
+      ]
+    },
+    {
+      "k": 8,
+      "p": 10,
+      "port_order_sha256": "2f8d3f5a12a230a00afe1ed5787b513db9ac68e896b30a10c06e776eaf40f06d",
+      "ports": 11520,
+      "witnesses": [
+        {
+          "basis_rows_sha256": "308d10a63af089d371b1d389bea384b395efb59d9d7ea0ebb1ecc431e9e7c971",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 4,
+            "direct_unit_row_xors": 60,
+            "distinct_observations": 27,
+            "independent_helper_input_contributions": 583,
+            "independent_helper_sum_xors": 556,
+            "original_row_xors": 24
+          },
+          "decoder_coefficients": [
+            7,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            1,
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            2,
+            4
+          ],
+          "rank": 3,
+          "support_size": 14
+        },
+        {
+          "basis_rows_sha256": "02ad51b2fe0bae0cf39501c41e4510fc94b48c6b81bac5e61caed75084793a81",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 5,
+            "direct_unit_row_xors": 77,
+            "distinct_observations": 36,
+            "independent_helper_input_contributions": 781,
+            "independent_helper_sum_xors": 745,
+            "original_row_xors": 32
+          },
+          "decoder_coefficients": [
+            14,
+            9,
+            5,
+            3
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4
+          ],
+          "rank": 4,
+          "support_size": 15
+        },
+        {
+          "basis_rows_sha256": "b8af428dd743ccbaa6ffe7b3902befc5240229a35d57f113fba848ea4b87172c",
+          "costs_for_naive_scalar_evaluation_only": {
+            "cached_basis_to_unit_xors": 9,
+            "direct_unit_row_xors": 121,
+            "distinct_observations": 45,
+            "independent_helper_input_contributions": 977,
+            "independent_helper_sum_xors": 932,
+            "original_row_xors": 40
+          },
+          "decoder_coefficients": [
+            23,
+            16,
+            28,
+            26,
+            25
+          ],
+          "deleted_indices": [
+            3,
+            5,
+            6,
+            7,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+          ],
+          "deletions": 11,
+          "information_indices": [
+            0,
+            1,
+            2,
+            4,
+            8
+          ],
+          "rank": 5,
+          "support_size": 16
+        }
+      ]
+    }
+  ],
+  "negative_controls": [
+    "all single-deletion restorations break the displayed simultaneous span",
+    "missing outside-pair exclusion leaks nuisance ports",
+    "missing proper-star monomial changes the evaluation",
+    "k=3 two-exclusion linear selector fails the proper-degree limit"
+  ],
+  "port_encoding": "bit 2*i+s denotes sign s of pair i; combinations then lexicographic signs",
+  "scope": "Constructive witnesses only; uniform lower bounds are separate written proofs. Restoration controls concern the displayed subcode, not a full ambient-code search. Costs price naive scalar sums only; no complete supplier or kappa claim.",
+  "status": "PASS",
+  "triangles": [
+    {
+      "evaluation_sha256": "fef42b902223087d7fafefba98746e8b47337fca50825cddfcfb587ee42666c5",
+      "k": 2,
+      "ports": 24,
+      "q": 2,
+      "star_faces": [
+        1,
+        4,
+        16
+      ],
+      "support_size": 15
+    },
+    {
+      "evaluation_sha256": "f67d1d2b9aae80b4b832eff4020db158b45e0e4fa1761e482006d222d2ae0df4",
+      "k": 2,
+      "ports": 40,
+      "q": 3,
+      "star_faces": [
+        1,
+        4,
+        16
+      ],
+      "support_size": 21
+    },
+    {
+      "evaluation_sha256": "e3c5a2ea2eeef67621e31208aaceb5a78de487d91d1300ef2bd8e705ec990998",
+      "k": 2,
+      "ports": 60,
+      "q": 4,
+      "star_faces": [
+        1,
+        4,
+        16
+      ],
+      "support_size": 27
+    },
+    {
+      "evaluation_sha256": "b2d0a902b690cf95a006de2adafe38daab65c44bba896c801685b21f1b3a16ef",
+      "k": 2,
+      "ports": 84,
+      "q": 5,
+      "star_faces": [
+        1,
+        4,
+        16
+      ],
+      "support_size": 33
+    },
+    {
+      "evaluation_sha256": "21a2f72cdbb85cba47a2ee3b79a7a28d5f4ef9fb7c04066437bdc1180f027108",
+      "k": 2,
+      "ports": 112,
+      "q": 6,
+      "star_faces": [
+        1,
+        4,
+        16
+      ],
+      "support_size": 39
+    },
+    {
+      "evaluation_sha256": "5dd0e3ae10bfd9821a9c7e5dad11a82c2801995383fd5cb201e70f4aeb7ae60c",
+      "k": 3,
+      "ports": 80,
+      "q": 2,
+      "star_faces": [
+        5,
+        17,
+        65
+      ],
+      "support_size": 15
+    },
+    {
+      "evaluation_sha256": "16b96a912c79e463d7f5993bb06b91afa1a66be4c1ebc9bffa5e0553bbefe141",
+      "k": 3,
+      "ports": 160,
+      "q": 3,
+      "star_faces": [
+        5,
+        17,
+        65
+      ],
+      "support_size": 21
+    },
+    {
+      "evaluation_sha256": "9f5e61eb55c731b18cf0598d81b41d72bc92d884169917f2c1d424d62f35c6c8",
+      "k": 3,
+      "ports": 280,
+      "q": 4,
+      "star_faces": [
+        5,
+        17,
+        65
+      ],
+      "support_size": 27
+    },
+    {
+      "evaluation_sha256": "465efb2903f00713dca5ac52afcbeec7f840f764b6e592f537e3c0ef7fa11a56",
+      "k": 3,
+      "ports": 448,
+      "q": 5,
+      "star_faces": [
+        5,
+        17,
+        65
+      ],
+      "support_size": 33
+    },
+    {
+      "evaluation_sha256": "b39c41654f7736d701898239d1b6a5cf685e3070b4a45ed8646aebfad6d9b121",
+      "k": 3,
+      "ports": 672,
+      "q": 6,
+      "star_faces": [
+        5,
+        17,
+        65
+      ],
+      "support_size": 39
+    },
+    {
+      "evaluation_sha256": "3a6fe57cee7e155f8bd252477974c7b8cb65454e123f39f6e992576730ddde47",
+      "k": 4,
+      "ports": 240,
+      "q": 2,
+      "star_faces": [
+        21,
+        69,
+        261
+      ],
+      "support_size": 15
+    },
+    {
+      "evaluation_sha256": "cd80c3ee7feb3dc44f6dfabe8b5cf244e68aee4225c17fbd537414e0abf1163f",
+      "k": 4,
+      "ports": 560,
+      "q": 3,
+      "star_faces": [
+        21,
+        69,
+        261
+      ],
+      "support_size": 21
+    },
+    {
+      "evaluation_sha256": "9b3b695ea57fcfa4c81f21473eee87810f97f1da0ada80ac461a2521321fd31c",
+      "k": 4,
+      "ports": 1120,
+      "q": 4,
+      "star_faces": [
+        21,
+        69,
+        261
+      ],
+      "support_size": 27
+    },
+    {
+      "evaluation_sha256": "afdf6e745f1ac51764b1312141afd3578b521b00e85eb1b6710c62560b0ebb2b",
+      "k": 4,
+      "ports": 2016,
+      "q": 5,
+      "star_faces": [
+        21,
+        69,
+        261
+      ],
+      "support_size": 33
+    },
+    {
+      "evaluation_sha256": "66a7ad09bb3896d640372d33610dff8ee048eecbf360e9976d6d3edd71c3eb6f",
+      "k": 4,
+      "ports": 3360,
+      "q": 6,
+      "star_faces": [
+        21,
+        69,
+        261
+      ],
+      "support_size": 39
+    },
+    {
+      "evaluation_sha256": "f319faf9c04d7bedb496fee3a33765929414a5843aacfbb745da82bb1f9bd130",
+      "k": 5,
+      "ports": 672,
+      "q": 2,
+      "star_faces": [
+        85,
+        277,
+        1045
+      ],
+      "support_size": 15
+    },
+    {
+      "evaluation_sha256": "735153a09e74f1735f14d3fe9519e5e8a551d98e2c6e39cce73cd006c745ba3b",
+      "k": 5,
+      "ports": 1792,
+      "q": 3,
+      "star_faces": [
+        85,
+        277,
+        1045
+      ],
+      "support_size": 21
+    },
+    {
+      "evaluation_sha256": "79659ea01ad84cc525f43e6d9464f4a4efd016719715f15763534bc081326eef",
+      "k": 5,
+      "ports": 4032,
+      "q": 4,
+      "star_faces": [
+        85,
+        277,
+        1045
+      ],
+      "support_size": 27
+    },
+    {
+      "evaluation_sha256": "7d692756bb510f33ceb7efa7320c8732432f3f5efb6e7e24119092b285ba6a70",
+      "k": 5,
+      "ports": 8064,
+      "q": 5,
+      "star_faces": [
+        85,
+        277,
+        1045
+      ],
+      "support_size": 33
+    },
+    {
+      "evaluation_sha256": "b11a7722e3635c24954fc0f203ab60082aefb16c50c1dcb8b92654978d6e4695",
+      "k": 5,
+      "ports": 14784,
+      "q": 6,
+      "star_faces": [
+        85,
+        277,
+        1045
+      ],
+      "support_size": 39
+    },
+    {
+      "evaluation_sha256": "7ef22d35e245f743a458924e90108cba250dd1f120c1b3c8aa7683a2a3a7a33a",
+      "k": 6,
+      "ports": 1792,
+      "q": 2,
+      "star_faces": [
+        341,
+        1109,
+        4181
+      ],
+      "support_size": 15
+    },
+    {
+      "evaluation_sha256": "f8fc519d0a498d9bfd1c0a4f503d3ec071efbd2ca76031fa18ee944ea1255688",
+      "k": 6,
+      "ports": 5376,
+      "q": 3,
+      "star_faces": [
+        341,
+        1109,
+        4181
+      ],
+      "support_size": 21
+    },
+    {
+      "evaluation_sha256": "9ebddbaaf245d90555d482dd1444bbe240eb62a5ace40beb23b1cf8281fbd77c",
+      "k": 6,
+      "ports": 13440,
+      "q": 4,
+      "star_faces": [
+        341,
+        1109,
+        4181
+      ],
+      "support_size": 27
+    },
+    {
+      "evaluation_sha256": "fb3a5fe8d020014d5460c05fe0d927a20ade6508ce19097c93d560edf2af2a38",
+      "k": 6,
+      "ports": 29568,
+      "q": 5,
+      "star_faces": [
+        341,
+        1109,
+        4181
+      ],
+      "support_size": 33
+    },
+    {
+      "evaluation_sha256": "3adfebe553fe0bd30f3d906bf186be0e3ed186bc8137d3fc749485eb5d336d95",
+      "k": 6,
+      "ports": 59136,
+      "q": 6,
+      "star_faces": [
+        341,
+        1109,
+        4181
+      ],
+      "support_size": 39
+    }
+  ]
+}
diff --git a/research/asymmetric-hypercube-decoder/HIGHER-CLAIM.json b/research/asymmetric-hypercube-decoder/HIGHER-CLAIM.json
new file mode 100644
index 0000000000..5dc48f085a
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/HIGHER-CLAIM.json
@@ -0,0 +1,149 @@
+{
+  "status": "completed research contribution; published through the existing PR669",
+  "assignment_seed": 48,
+  "track": "Structural decoder research; higher-target continuation",
+  "base_commit": "8bcbaafe8590d30eff9c0ae5fd9e49479c84038c",
+  "original_repository_base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "current_main_snapshot": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+  "selected_kappa_at_start": "1661634653669567/1000000000000000000",
+  "started_at": "2026-10-13T17:44:33+09:00",
+  "research_window_ends": "2026-10-13T23:44:33+09:00",
+  "verification_reserved_minutes": 90,
+  "goal": "Determine generalized support weights and decoder geometry beyond two targets, including an all-rank graph hierarchy and uniform higher-dimensional results; investigate the first structural departure from optimal single-star decoders.",
+  "candidate_tasks": [
+    "Complete generalized-weight hierarchy of both k=2 proper-star codes via graph partitions and bipartite zero sets.",
+    "Uniform higher-target weights for arbitrary k, including counterexamples to star-cluster optimality and cube-localized alternatives.",
+    "Exact prescribed-triple geometry and information-set witnesses, after the generalized weights are resolved."
+  ],
+  "selected_scope": "A coherent higher-target hierarchy: use the complete graph-case solution as a benchmark, prove uniform higher-dimensional weights where possible, and certify the first strict improvement over star clusters. Price any claimed supplier mechanism before a bound claim.",
+  "initial_findings": "For q=2,k>=4, three localized affine cube observations give support14, below the natural three-star support15. This must be verified and developed rather than assumed to imply a supplier improvement.",
+  "coordination": "No pinned coordination issue. All-state PR metadata refreshed through PR871; no overlapping higher-target hierarchy identified. Existing PR669 remains open and will carry the focused extension.",
+  "publication": "https://github.com/CrocSwap/integer-mult-bounds/pull/669",
+  "stopping_rule": "Complete the all-rank k=2 hierarchy and a substantial uniform higher-dimensional theorem or exact obstruction, with adversarial proof review and fixed-domain exact verification. Reserve the final quarter for packaging and handoff; do not claim unresolved generalizations.",
+  "attribution": "Sam Sung with substantial OpenAI Codex assistance. Preserve predecessor credits and immutable source pins from EXTENSION-CLAIM.json; add primary literature credits for graph/code connections.",
+  "research_completed_at": "2026-10-13T18:31:43+09:00",
+  "verification_completed_at": "2026-10-13T18:31:43+09:00",
+  "final_main_snapshot": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+  "final_selected_kappa": "1661634653669567/1000000000000000000",
+  "final_frontier_context": "Maintainer-reviewed conditional PR799 with PR741 and PR589. Selected certificate and actual maintainer review read; no replay of that unrelated physical supplier is claimed.",
+  "results": [
+    "Complete generalized-weight hierarchy of both signed k=2 proper-star codes at every available rank, including the distinct empty-star and p=2 cases.",
+    "For every k>=2,q>=3, the first two nonzero codeword weights are 2q+2 and 4q+2, with no intermediate weights.",
+    "For every k>=2,q>=3, d3=6q+3 and every optimal three-dimensional subcode is a triangle of minimum stars. Exactly 2^(k+1) binom(p,k-2) binom(q+2,3) optima exist.",
+    "A prescribed triple at q>=3 attains 6q deletions exactly when its columns have rank three on an optimal triangle; the larger budgets for failing triples are not classified.",
+    "At q=2, d3=15 for k=2,3, while k>=4 has exact prefix (d1,d2,d3,d4,d5)=(6,11,14,15,16). A localized affine cube beats all three-minimum-star spans.",
+    "Three, four, and five selectable targets at q=2,k>=4 all need exactly eleven deletions. Explicit nonempty proper-star decoders and naive scalar cost receipts are supplied.",
+    "Code results hold for both C-minus and C-plus; original overlap corrections are absorbed only at power-of-two k. No new supplier or kappa is claimed."
+  ],
+  "scope_not_completed": [
+    "Complete hierarchy for k>2 beyond the stated ranks.",
+    "Classification of every q=2 optimal higher-target subcode.",
+    "Exact larger deletion budgets for prescribed triples failing the q>=3 triangle criterion.",
+    "Physical helper acquisition, frames, copy/restoration schedule, recursive-child invoice, whole supplier and assembly."
+  ],
+  "final_overlap_check": "Refreshed 500 all-state PR entries through PR876. Relevant PR725,732,747,772 heads unchanged. Inspected new PR875: E8 root-line rank-five punctures, a different geometry and model. No overlapping signed proper-star higher-target hierarchy identified; this is a scoped overlap search, not a literature novelty certification.",
+  "literature": [
+    {
+      "authors": "Jose Martinez-Bernal, Miguel A. Valencia-Bucio, Rafael H. Villarreal",
+      "title": "Generalized Hamming weights of projective Reed-Muller-type codes over graphs",
+      "version": "arXiv:1812.04106v2, 16 August 2019",
+      "url": "https://arxiv.org/html/1812.04106v2",
+      "used": "Corollary 2.13: binary incidence-code generalized weights equal r-th edge connectivities. Credited bridge; explicit formulas and constant-row branch proved here."
+    }
+  ],
+  "verification": {
+    "command": "for check in higher cube boundary; do python3 -I -O -B \"research/asymmetric-hypercube-decoder/${check}_verify.py\" --self-test || exit; done",
+    "expected_prefixes": [
+      "PASS_HIGHER_GRAPH",
+      "PASS_CUBE",
+      "PASS_K3_BOUNDARY"
+    ],
+    "graph_partition_cases": 4,
+    "graph_partition_transitions": 1026766,
+    "graph_internal_cut_assignments": 293452,
+    "graph_edge_restrictions": 8224,
+    "complete_small_graph_subspaces": 449606,
+    "graph_rank_three_census_subspaces": 7135750,
+    "optimal_rank_three_subcodes_per_p5_code": 80,
+    "full_graph_spectral_words": 523776,
+    "optimal_graph_decoders": 68,
+    "full_code_graph_restoration_controls": 1511,
+    "cube_full_port_families": 5,
+    "literal_cube_decoders": 15,
+    "cube_subcode_restoration_controls": 165,
+    "triangle_witnesses": 25,
+    "boundary_shortening_spaces": 5,
+    "boundary_basis_vectors": 90,
+    "boundary_extended_space_words": 1024,
+    "python_versions": [
+      "3.11.13",
+      "3.14.5"
+    ],
+    "receipt_comparison": "Byte-identical on isolated optimized Python3.11 and Python3.14; relocated replay, corrupted-receipt rejection, and failed-check output preservation pass.",
+    "inherited_replay": "Original verify.py and global_verify.py --self-test pass with unchanged receipts. Seven inherited immutable predecessor/context SHA256 pins rechecked against Git objects.",
+    "independent_review": "Separate AI-assisted proof and checker reviews; not independent human review. Root reviewed delegated source files and reran their checkers. No proof assistant used.",
+    "omitted": "Unrelated repository-wide regeneration, selected supplier cold replay, and hosted CI are not claimed; no selected construction or generator was changed."
+  },
+  "predecessor_sources": [
+    {
+      "commit": "80431a74c31e807581f5c2258c87abe2084caacd",
+      "path": "research/global-star-puncture/README.md",
+      "sha256": "87825a4dd666d8c32df025fe838aca4cdc23a5d3965f79c9aca4913567dba6d4"
+    },
+    {
+      "commit": "6eadc4eb4ebc355b13fa36a3138d97a583ea7f37",
+      "path": "research/global-star-puncture/README.md",
+      "sha256": "b50aa319fff5f22a8b29745d17bac0b9f650f1129310722deea6dbae1d82c7fa"
+    },
+    {
+      "commit": "aeaf0899179a14644b412e838ede14db967c765e",
+      "path": "research/global-star-punctures/README.md",
+      "sha256": "ab6cf6e7885f31d7601b6d686e1a543ceaf887e29207c3af08955e457a9656da"
+    },
+    {
+      "commit": "02b59e553649c333072b5dd4dfb97e43942efa14",
+      "path": "research/paired-star-rank/RANK-PROOF.md",
+      "sha256": "ebd01b082c5b9adbca6dbd5fa9dd3d8df83270e26a26af76d260fb134fc03d97"
+    }
+  ],
+  "selected_context_sources": [
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "certificates/selected-result.json",
+      "sha256": "9873519224e2db72d6a8c926f51e3e75129671e467948c6f6b03744f8bcfc699"
+    },
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "docs/research/community-frontier799-review.md",
+      "sha256": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052"
+    },
+    {
+      "commit": "f567884aeb8851b6e794af1184119a3bfbe1e631",
+      "path": "research/community-frontier799-audit/SELECTED-SOURCE.json",
+      "sha256": "839f686bf192a7654370d947bb8dd5c1343c89d3947fbb8a8be0956b482182ca"
+    }
+  ],
+  "prior_phase_dependencies": [
+    {
+      "commit": "8bcbaafe8590d30eff9c0ae5fd9e49479c84038c",
+      "path": "research/asymmetric-hypercube-decoder/MINIMUM-WORDS.md",
+      "sha256": "12f527654266ee1d7dac471fe955b05f36f2f3d922ad97bc52f74514e68acdaa"
+    },
+    {
+      "commit": "8bcbaafe8590d30eff9c0ae5fd9e49479c84038c",
+      "path": "research/asymmetric-hypercube-decoder/EQUALITY-PAIR.md",
+      "sha256": "a9e2a542f835c551927f297236fdc3680cfd1bcc35adbc8718c355e124cff64b"
+    }
+  ],
+  "result_files_sha256": {
+    "HIGHER-GRAPH.md": "b1fab5e859209b983ca6374e11f41988e2146e3ab843e649a668b49c6443d739",
+    "HIGHER-WEIGHTS.md": "7dd0ea3eea0cb3f4ed4075da8a1648589aac995f4f7fda0674924368c5de40ff",
+    "HIGHER-COST.md": "23a68e4dfd772244021f8cfcabb39a05bd4bec38415376c6bffd197b55e9a278",
+    "higher_verify.py": "1e5505decfd70719f5c309fe9bf060ca6a9df779d1c1a70e7181f32b09fdb198",
+    "HIGHER-RESULTS.json": "dca3417b8777fe1faa93d448614828ba03c6919f3a6285a9815c7ba552955df5",
+    "cube_verify.py": "4d1dde2737f45d883f94d1f8cec4c3741eed77a7e37ac7cd5a58e7199112716b",
+    "CUBE-RESULTS.json": "5d1405ca90350eb12f27cfb4ea4a826e5ff8165b8c940a43d665b68694442572",
+    "boundary_verify.py": "90cfb76dc27c34f5b0207dd134c4357fb2d3bdf5b2af3157ccf3d0a34d720105",
+    "BOUNDARY-RESULTS.json": "b9503e902925abf4244aa9f4236485b7c8a3184072369bb5ee68e4b7bafdefb1"
+  }
+}
diff --git a/research/asymmetric-hypercube-decoder/HIGHER-COST.md b/research/asymmetric-hypercube-decoder/HIGHER-COST.md
new file mode 100644
index 0000000000..a0fe1fcc4e
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/HIGHER-COST.md
@@ -0,0 +1,73 @@
+# What the higher-target witnesses cost, and what remains unpriced
+
+The new cube mechanism changes the support geometry of simultaneous decoding.
+At `q=2,k>=4`, a three-dimensional subcode on fourteen ports beats every span
+of three minimum stars, whose union has at least fifteen ports. The ambient proper-star codes have first
+five generalized weights `(6,11,14,15,16)`, so three, four, and five
+selectable targets share the same optimal eleven-deletion count.
+
+This is a scalar observation-span result. It is not a supplier improvement.
+We have not found a complete physical supplier interface that turns the
+support improvement into a favorable recursive invoice.
+
+## Explicit scalar accounting
+
+Use the selector `M=m_fixed(1+z_a)(1+z_b)` from
+[HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md). Choose the basis rows
+
+```text
+M*x_1, M*x_2, M*x_3, M*x_4, M*x_4-opposite.
+```
+
+The last two rows sum to M on the selected cube. Each row expands into nine
+nonempty proper stars; their degrees are at most `k-1`. Thus no free empty
+star is needed, even at k=4. The first r rows give the r-target witness.
+The exact information set and basis change are committed in
+[CUBE-RESULTS.json](CUBE-RESULTS.json).
+
+For these particular information sets, evaluate each distinct star total
+independently on the surviving family, evaluate each cached basis row once,
+and then XOR cached rows to obtain the unit decoders. The following are
+ordinary binary scalar additions, assuming input access and cached storage
+are available. They are explicit costs of this naive schedule, not minima.
+
+| Targets r | Distinct star totals | Input contributions to those totals | XORs forming totals | XORs forming basis rows | XORs changing basis | Total scalar XORs |
+| --- | --- | --- | --- | --- | --- | --- |
+| 3 | 27 | 583 | 556 | 24 | 4 | 584 |
+| 4 | 36 | 781 | 745 | 32 | 5 | 782 |
+| 5 | 45 | 977 | 932 | 40 | 9 | 981 |
+
+The table is the same for every checked `k=4,...,8`, because fixing an
+additional signed coordinate lifts the identical residual six-pair problem.
+The mathematical lifting argument extends that fact to every k>=4.
+Without cached basis-row reuse, directly summing the expanded unit decoders
+would take 60, 77, or 121 XORs after the star totals are available. Neither
+schedule is asserted to be XOR-optimal, and the counts do not price copying
+or preserving mutable operands. An even more favorable model could treat
+existing star totals as supplied; that still leaves their upstream invoice
+and interfaces to establish.
+
+## Why no κ follows
+
+A usable multiplication supplier would need an explicit physical word and
+recursive interfaces that account for all of the following:
+
+- Producing each required star total from permitted sources, including access
+  multiplicity and any recursive children that supply those totals.
+- Copying or preserving operands, their readable frames, and their live widths.
+- Restoring helpers and sources, including any work hidden by a cached sum.
+- Hosting the chosen deletion pattern and targets in a complete supplier, then
+  checking the other supplier and all assembly constraints.
+
+The present row identities do not provide those objects or prove they can be
+free. Replacing the current supplier's invoice with the deletion count eleven
+would therefore be invalid. The scalar counts above also cannot be inserted
+as physical gate counts in the selected construction's cost model.
+
+The current selected frontier remains the maintainer-reviewed conditional
+PR799 construction, with PR741 and PR589; the exact context snapshot is in
+[HIGHER-CLAIM.json](HIGHER-CLAIM.json). We make no claim to have re-audited that
+unrelated physical construction. The contribution here is the exact new
+hierarchy, its exceptional optimizer, and reproducible decoder certificates.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/HIGHER-WEIGHTS.md b/research/asymmetric-hypercube-decoder/HIGHER-WEIGHTS.md
new file mode 100644
index 0000000000..abf5be278d
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/HIGHER-WEIGHTS.md
@@ -0,0 +1,489 @@
+# The third generalized weight and a five-weight boundary prefix
+
+**Exact higher-target thresholds; no new κ.** This note determines the
+third generalized Hamming weight of both signed proper-star codes for every
+`k>=2` and `q=p-k>=2`. At `q=2`, it also determines the first five weights
+for every `k>=4`. For `q>=3` it also determines the exact gap above minimum
+weight and classifies every optimal three-dimensional subcode.
+These are scalar linear-information statements; the
+attaining subcodes are explicit, but no paid supplier or complete
+multiplication construction is asserted.
+
+## Results and scope
+
+Use the signed-port model and notation of [MINIMUM-WORDS.md](MINIMUM-WORDS.md).
+A port chooses one signed coordinate from each of k different original
+pairs among p pairs. The star `m_L` indicates containment of the signed
+partial port L. The binary code `C^+_{p,k}` spans the stars of degrees
+`0<=|L|<k`; `C^-_{p,k}` omits the empty star. For either code C, `d_r(C)` is
+the smallest union support of an r-dimensional subcode.
+
+For all `k>=2` and `q>=2`,
+
+```text
+d_3(C^-_{k+q,k}) = d_3(C^+_{k+q,k}) =
+    15,       q=2 and k in {2,3},
+    14,       q=2 and k>=4,
+    6q+3,     q>=3.
+```
+
+For every `k>=4` at `q=2`, the first five generalized weights of both codes
+are exactly
+
+```text
+(d_1,d_2,d_3,d_4,d_5) = (6,11,14,15,16).
+```
+
+At power-of-two k, the original overlap-class corrections lie in the
+nonempty proper-star code. The usual information-set argument therefore
+turns `d_r-r` into the minimum number of deletions for **some selectable
+set of r retained targets**. Thus three selectable targets need exactly
+`6q` deletions for `q>=3`. At `q=2,k>=4`, three, four, and five selectable
+targets each need exactly eleven deletions. The exact budget for a
+prescribed larger target set can be different.
+For `q>=3`, we additionally classify every optimal three-dimensional
+subcode and give an exact criterion for a prescribed triple to attain
+`6q` deletions. The [pair classification](EQUALITY-PAIR.md) gives the
+separate exact result for every prescribed pair.
+
+## Inputs and attribution
+
+We use the minimum distance `d_1=2q+2`, minimum-word rigidity for `q>=2`,
+`d_2=4q+3`, and the classification of optimal two-dimensional subcodes as
+spans of adjacent `(k-1)`-stars. Their proofs and credited inputs are in
+[MINIMUM-WORDS.md](MINIMUM-WORDS.md) and [EQUALITY-PAIR.md](EQUALITY-PAIR.md).
+In particular, two distinct minimum stars meet in at most one port; three
+distinct minimum stars are independent, since the sum of two has weight
+at least `4q+2>2q+2`.
+
+Luke Mansoor's [PR #732](https://github.com/CrocSwap/integer-mult-bounds/pull/732),
+inspected at `80431a74c31e807581f5c2258c87abe2084caacd`, supplies the uniform
+minimum-distance and generalized-cube arguments. We use its even-face
+consequence: a binary function whose every face fixing at most t signs has
+even parity is either zero or has weight at least `2^(t+1)`. If t reaches
+the number of sign variables, singleton faces force the function to vanish.
+Generalized cubes have k slots, each containing two distinct coordinates.
+The original pair indices used by different slots must be disjoint, so
+all `2^k` choices are valid ports. Every proper star has even parity on
+such a cube. Ordinary cubes partition the ports, so all codeword weights
+are even.
+
+The [complete k=2 hierarchy](HIGHER-GRAPH.md) supplies the graph-code boundary
+used below. The formulas here extend beyond that graph case and beyond
+the all-target rank calculation of
+[PR #772](https://github.com/CrocSwap/integer-mult-bounds/pull/772), inspected
+at `02b59e553649c333072b5dd4dfb97e43942efa14`.
+
+In lower bounds we work in the larger code `C^+`. All attaining constructions
+belong to `C^-`, so equality follows for both spaces. Avoiding an original
+pair restricts a codeword to `C^+_{p-1,k}`, replacing q by `q-1`. A pair is
+*universal* for a word or subcode if every port in its support uses that
+pair. Its *degree* in a support union is the number of ports using it.
+
+## Two boundary lemmas at q=2
+
+First, every three-dimensional subcode has support at least fourteen.
+Its seven planes each have support at least eleven. Every occupied
+coordinate belongs to the support of six of these planes, so 6n>=77,
+hence n>=13. If n=13, the seven plane supports sum to 78, forcing six
+planes of support eleven and one of support twelve. Each optimal plane
+contains exactly two minimum words. A word lies in three planes, so there
+are at least four distinct minimum words. Any three distinct minimum stars
+are independent: the sum of two has weight at least ten, not six. Their
+support union is at least 3*6-3=15 because pairwise intersections have size
+at most one. This contradicts n=13.
+
+Second, a three-dimensional subcode containing a minimum word has support
+at least fifteen. Suppose n<=14 and fix its minimum word f, of support A
+and weight six. There cannot be three minimum words, by the preceding
+three-star observation, so there are at most two. Restrict the subcode
+outside A. Its kernel is exactly <f>, since a nonzero word supported on A
+must equal f. The image is two-dimensional; its three nonzero supports
+are the supports outside A of the three planes through f. A plane with
+support eleven must contain two minimum words. Thus at most one of the
+three planes has support eleven, and the other two have support at least
+twelve. Their outside-A support sizes are therefore at least 5,6,6. But
+the three nonzero words of a binary two-dimensional code have total weight
+twice their union size. Consequently 2(n-6)>=17, impossible for n<=14.
+
+In particular, every three-dimensional support-fourteen subcode at q=2
+has no minimum word. All seven of its nonzero words then have weight eight,
+since their weights sum to 4*14=56.
+
+## Small common-core lemma
+
+Suppose q>=3, a subcode V is supported on ports containing a fixed set K
+of k-1 original pair indices, and every residual-pair block of its support
+union has at most six ports. Then the union has size at least
+
+    2(q+1) dim V.
+
+Choose a basis and label each port by its vector of basis evaluations.
+For a residual pair r and signs a on K, denote the two vector labels by
+F_r^+(a), F_r^-(a). Their sum H_r(a) has even parity on every face fixing
+at most q signs of K: replace each fixed core slot by that sign versus a
+coordinate from a distinct other residual pair, keep r ordinary, and
+apply generalized-cube parity. Every branch using a replacement omits a
+universal core pair and vanishes. Each scalar component of H_r has weight
+at most six. The even-face lemma would force a nonzero component to have
+weight at least 2^(q+1)>6, or rules it out directly by singleton faces.
+Thus F_r^+=F_r^-=F_r. Its vector-valued support has at most three points.
+
+For residual pairs r,s, the vector function F_r+F_s has even parity on
+every face fixing at most q-1 core signs. Use a mixed slot with one chosen
+coordinate from r and one from s, and replace the fixed core slots using
+distinct residual pairs other than r,s. There are q-1 available pairs.
+Its scalar components have weight at most six, whereas the even-face
+bound is 2^q>=8. Hence F_r=F_s. All q+1 residual blocks have the same
+vector labels on the same core-sign positions, each repeated twice.
+If there are m such positions, the whole evaluation matrix has at most
+m distinct nonzero column labels. Therefore dim V<=m and its support
+union has size 2(q+1)m, proving the lemma.
+
+## The complete gap above minimum weight for q>=3
+
+For every `q>=3`, the second smallest nonzero weight in either code is
+exactly `4q+2`: no word has weight strictly between `2q+2` and `4q+2`.
+The sum of two adjacent minimum stars has weight `4q+2`, so it suffices
+to prove the exclusion in `C^+`.
+
+### A small nonminimum word cannot restrict to a minimum star
+
+Suppose a nonminimum word w has weight `b<4q+2`, and avoiding an original
+pair r gives a minimum word. At `q-1>=2`, minimum-word rigidity makes this
+restriction a star `m_J` of weight `2q`. Let F be the same star in the full
+p-pair space. It has weight `2q+2` and exactly two extensions using r.
+The word `h=w+F` vanishes away from r. Write t for the number of those two
+extensions also in w. Then
+
+```text
+wt(h) = b-2q+2-2t <= 2q+2,
+```
+
+because evenness gives `b<=4q`. The word h is nonzero, since w is not the
+minimum word F. Minimum distance forces equality throughout: `b=4q`,
+`t=0`, and h is another minimum star. But F and h then share both
+r-extensions of F. Distinct minimum stars meet in at most one port, a
+contradiction. Therefore every nonzero avoidance restriction of w is
+nonminimum.
+
+### Induction on q
+
+At `q=3`, the only weights to exclude are ten and twelve. The preceding
+observation makes every nonzero avoidance restriction a nonminimum word
+at `q=2`, hence of weight at least eight. If c pairs are universal for w
+and `t=k-c`, each of the remaining `t+3` pairs has degree at most `b-8`.
+Counting incidences gives
+
+```text
+t b <= (t+3)(b-8),    hence    8t <= 3(b-8).
+```
+
+For `b=10` this forces `t=0`; for `b=12` it forces `t<=1`. A word with
+`t=0` lies in one ordinary cube and has weight at least sixteen by the
+even-face bound, or is zero when singleton faces apply. If `t=1`, all
+residual blocks have size at most four. The common-core lemma's proof
+shows more than its stated bound: all residual signs are paired and all
+four residual blocks have identical labels. The total weight is therefore
+a multiple of eight, which cannot be twelve. This proves the q=3 case.
+
+For `q>=4`, assume the asserted gap at `q-1`. A hypothetical nonminimum
+word with `b<4q+2` has `b>=2q+4`. Every nonzero avoidance restriction is
+nonminimum and therefore has weight at least `4q-2` by induction. Every
+nonuniversal pair consequently has degree at most
+
+```text
+b-(4q-2) <= 2.
+```
+
+Again let t count the nonuniversal slots of a support port. Incidence
+counting gives `t b<=2(t+q)`, or `t(b-2)<=2q`. Since `b-2>=2q+2`, this
+forces `t=0`. The support lies in one ordinary cube; the even-face bound
+then gives `b>=2^(q+1)>4q`, or singleton faces force it to vanish. Both
+contradict the assumed weight. This completes the induction and proves
+the exact second nonzero weight for both codes.
+
+## Third-weight equality and its complete classification for q>=3
+
+Let V have dimension three and union support size `n<=6q+3`. Its seven
+nonzero words have total weight `4n`, because each occupied coordinate
+appears in exactly four words. If at most two words were minimum, the
+spectral gap would give
+
+```text
+4n >= 2(2q+2) + 5(4q+2) = 24q+14 > 4(6q+3),
+```
+
+an impossibility. Hence V contains at least three distinct minimum stars.
+These are independent. Each has size `d=2q+2`, and pairwise intersections
+have size at most one, so their union has size at least `3d-3=6q+3`.
+This proves `d_3>=6q+3`.
+
+At equality, the three pairwise intersections must be distinct singleton
+ports and the triple intersection must be empty. To identify the possible
+faces, let `J_1,J_2,J_3` be their signed `(k-1)`-faces. Pairwise adjacency
+means any two differ by replacing one coordinate, with compatible signs.
+Write `J_1=K+a` and `J_2=K+b`, where `|K|=k-2`. If `J_3` contains K, then
+it is `K+c` for a third signed coordinate c, and a,b,c lie in distinct
+original pairs. If `J_3` omits a coordinate i of K, adjacency to both
+`J_1,J_2` forces
+
+```text
+J_3 = (K without i) union {a,b}.
+```
+
+In the latter case all three faces lie in the same k-port `K union {a,b}`,
+so their three stars have a common support point, contrary to equality.
+Thus every optimal subcode is exactly the span of
+
+```text
+m_(K+a), m_(K+b), m_(K+c),
+```
+
+for a signed `(k-2)`-core K and three signed coordinates from distinct
+outside original pairs. Conversely these three stars have union `6q+3`,
+so every such triangle is optimal.
+
+The three pairwise sums have weight `4q+2`, and their triple sum has weight
+`6q`; both exceed `2q+2` for `q>=3`. Thus the triangle's three generators
+are its only minimum words. They uniquely recover K and the unordered
+three signed coordinates. The exact number of optimal three-dimensional
+subcodes is consequently
+
+```text
+2^(k+1) binom(p,k-2) binom(q+2,3).
+```
+
+### Which prescribed triples attain the minimum deletion budget?
+
+For `q>=3`, under proper-star observations, three distinct prescribed
+targets `T_1,T_2,T_3` attain the minimum `6q` deletions if and only if some
+triangle above has an invertible
+three-by-three evaluation matrix
+
+```text
+A_ij = 1[K union {a_i} is contained in T_j],
+(a_1,a_2,a_3) = (a,b,c),
+```
+
+over `F_2`. At power-of-two k it also applies to the original overlap-class
+model. This is a finite structural criterion, not an assertion that
+all triples attain the same budget. It is enough to enumerate signed
+`(k-2)`-subsets K of `T_1 intersect T_2 intersect T_3`, and three residual
+signed coordinates from different original pairs: invertibility forces
+each target to lie in the triangle support, hence to contain K.
+
+For sufficiency, multiply the three star rows by `A^(-1)` so that their
+restrictions to the prescribed targets are unit rows. Delete the other
+`6q` support ports. For necessity, three unit decoders after exactly `6q`
+deletions span a subcode with support at most `6q+3`. It must be optimal,
+hence a triangle by the classification, and its target columns must be
+independent. A triple failing the criterion requires at least `6q+1`
+deletions. No exact larger budget for such a triple is claimed here.
+
+## The exceptional boundary k=3, q=2
+
+The three-star triangle gives the upper bound 15. Suppose a three-dimensional
+subcode V of C-plus has union support 14. The preceding q=2 lemmas show that
+all seven nonzero words have weight eight. We prove a contradiction.
+
+### A common original pair
+
+For an original pair i, let s_i be the dimension of the subcode of V
+supported entirely on ports using i. Dimension two is impossible: that
+kernel needs at least d_2(C^+_{5,3})=11 ports, while its nonzero avoidance
+image needs at least d_1(C^+_{4,3})=4 disjoint ports. Thus s_i is 0, 1, or 3.
+
+More generally, at q=2 a weight-eight word has at least k-2 universal original
+pairs. Indeed every nonuniversal pair occurs at most four times, since its
+avoidance leaves a nonzero word of weight at least four. If c(w) is the
+universal-pair count, 8k<=8c(w)+4(p-c(w)) gives c(w)>=k-2.
+
+Let c be the number of pairs universal for the whole V, equivalently s_i=3.
+Double-count universal incidences across the seven nonzero words. Each of
+these c pairs contributes seven incidences and each remaining pair at most
+one, so
+
+    7(k-2) <= 7c+(p-c) = 6c+k+2.
+
+Since c is integral, c>=k-2. For k=3 there is a common original pair i.
+All codewords vanish on ports avoiding i.
+
+### The two sign slices
+
+There are four residual original pairs. Let C be their k=2 code with the
+empty star allowed. It has dimension eight, minimum distance six, and
+third generalized weight fifteen, by [HIGHER-GRAPH.md](HIGHER-GRAPH.md). Let B be the
+six-dimensional space of functions constant on each unsigned residual
+pair block (each block consists of its four sign choices), and set
+
+    E = C+B.
+
+We establish two facts about restricting a degree-at-most-two polynomial
+that vanishes on all three-ports avoiding i:
+
+1. Each of its two i-sign slices belongs to E.
+2. Those slices have the same image in E/C.
+
+Here are details to avoid assuming a shortening theorem. For each original
+pair j let z_j be its occupancy indicator (the sum of its two coordinate
+variables) and x_j one chosen sign variable. On paired ports, x_j z_j=x_j
+and x_j^2=x_j, so any degree-at-most-two evaluation can be expressed as
+
+    A(z) + sum_j x_j B_j(z) + sum_(j<l) c_jl x_j x_l,
+
+where A has degree at most two, B_j is affine in occupancies other than
+z_j, and the c_jl are scalars.
+
+Restrict to any three of the four residual pairs, avoiding i. The selected
+signs are independent bits. The zero evaluation therefore forces c_jl=0
+for every two residual indices j,l. For each residual j, it also forces
+B_j to vanish whenever precisely two of the other three residual indices
+are occupied, with z_i=0. Write the constant term of B_j as b and those
+three coefficients as u,v,w. The equations
+
+    b+u+v = b+u+w = b+v+w = 0
+
+give u=v=w and b=0. On an i-containing port, exactly one residual index
+besides j is occupied. Thus B_j evaluates to a constant independent of
+that second residual index. Terms c_ij x_i x_j add another constant
+coefficient of x_j on each fixed i-sign slice. These are vertex-star
+functions in C.
+
+The term x_i B_i(z), on a fixed i-sign slice, is an affine combination of
+residual occupancy indicators and the constant function, also in C.
+Finally A(z), with z_i=1, is an arbitrary function of the unsigned residual
+pair block and is identical on the two i-sign slices. This proves both
+claims.
+
+### A small quotient and its weight-four words
+
+Every function of E can be written as an arbitrary unsigned block function
+plus sum_j a_j x_j over the four residual indices. If any a_j is nonzero,
+the function is nonconstant in the j-sign on all three blocks incident to
+j. It therefore has exactly two nonzero values in each such four-point
+block, and total weight at least six. If all a_j vanish, weights are
+multiples of four. Consequently E has minimum distance four, and its
+weight-four words are exactly the individual unsigned block indicators.
+Distinct such words have disjoint supports.
+
+An element of C is unsigned precisely when its residual sign coefficients
+vanish; its remaining expression is a constant plus a linear combination
+of residual occupancies. These functions have dimension four: the four
+occupancy rows have their one relation sum_j z_j=0 on two-ports, and the
+constant is independent of them (the pair graph K4 has triangles).
+Hence
+
+    dim(E/C) = dim B - dim(B intersect C) = 6-4 = 2.
+
+### The quotient contradiction
+
+Map V to E/C using the common class of its two slices. Its kernel K_0 has
+dimension at least one. A nonzero word in K_0 has both slices in C. Since
+C has minimum distance six and the whole word has weight eight, precisely
+one slice is nonzero, of weight eight. All nonzero words of K_0 use the
+same i-sign: two using opposite signs would sum to weight sixteen. Call
+that sign plus.
+
+K_0 cannot be all V, because V would then embed in the plus copy of C with
+support fourteen, contrary to d_3(C)=15. For any h outside K_0, both its
+slices have nonzero quotient class and hence are nonzero in E. Their
+minimum weights are four and their sum is eight, so both have weight four.
+For every nonzero f in K_0, the word h+f also lies outside K_0. Therefore
+its plus slice has weight four. Since h-plus has weight four and f-plus
+has weight eight, this forces supp(h-plus) to be contained in supp(f-plus).
+
+If dim K_0>=2, take independent f_1,f_2 in it. The supports of f_1, f_2,
+and f_1+f_2 have empty triple intersection, contradicting containment of
+the nonempty h-plus support in all three. Hence dim K_0=1.
+
+The minus-slice projection now embeds the two-dimensional quotient V/K_0
+in E, and each of its three nonzero words has weight four. But any two
+distinct weight-four words of E are disjoint unsigned block indicators,
+whose sum has weight eight. This is the final contradiction.
+
+Thus d_3(C-plus)>=15. The three nonempty-star triangle attains fifteen,
+so the same exact value holds for C-minus.
+
+## Attainment, lifting, and the five-weight prefix
+
+### Three-star construction
+
+Choose a signed `(k-2)`-core K and signed coordinates a,b,c from three
+different outside pairs. The three nonempty stars `K+a`, `K+b`, `K+c` are
+independent: a fourth outside pair supplies a port private to each star.
+Each star has weight `d=2q+2`, their three pairwise intersections are
+distinct single ports, and their triple intersection is empty. Their
+union has size `3d-3=6q+3`. This proves the upper bound for both codes,
+and attains the exact third weight for `q>=3` and for `q=2,k in {2,3}`.
+
+### A cube subcode at q=2
+
+For `q=2,k>=4`, fix `k-4` signed coordinates and four more original pairs Q.
+Let a,b be the two pairs outside the resulting ordinary k-pair cube. Write
+`z_a,z_b` for their occupancy indicators and set
+
+```text
+M = m_fixed (1+z_a)(1+z_b).
+```
+
+This selector has degree `k-2` and is supported on exactly sixteen ports:
+the fixed signs on the fixed core, and all signs on Q. Choose four sign
+variables `x_1,...,x_4` on Q. The rows `M x_1,...,M x_r` are independent;
+for `r=3,4`, their common zero set inside the selected cube has size
+`2^(4-r)`. They give dimensions three and four with support sizes fourteen
+and fifteen, respectively. Adding M to the four rows gives dimension five
+and support sixteen. Every generator has degree less than k.
+
+For `k>4`, every expanded monomial is a nonempty star. At `k=4,p=6`, the
+empty star is redundant. Indeed, for any three original pairs a,b,c, every
+four-pair port meets that set, so `(1+z_a)(1+z_b)(1+z_c)=0`. Equivalently,
+
+```text
+1 = (z_a+z_b+z_c) + (z_a z_b+z_a z_c+z_b z_c) + z_a z_b z_c.
+```
+
+The right side expands into nonempty stars of degree at most three.
+Thus these witnesses also lie in `C^-` at the smallest k.
+
+Generalized weights are strictly increasing. To see this without invoking
+a separate theorem, take any `(r+1)`-dimensional subcode and any coordinate
+occupied by it. The kernel of evaluation at that coordinate has dimension
+r and loses at least that coordinate from its support. Applying this to
+an optimal `(r+1)`-dimensional subcode gives `d_r<=d_(r+1)-1`.
+The lower bound `d_3>=14` at q=2 and the three cube witnesses therefore
+force `d_3,d_4,d_5=(14,15,16)`. Together with the known first two weights,
+this proves the claimed five-weight prefix.
+
+### Signed-face lifting
+
+There is also a general way to transport explicit subcodes to higher k
+without changing q. Start with a subcode of `C^+_{q+k_0,k_0}`. Add `k-k_0`
+new pairs, fix one signed coordinate in each, and multiply every generator
+by their joint star. A nonzero resulting evaluation occurs exactly on a
+port containing this fixed signed face, with its remaining `k_0`
+coordinates forming an original port. Hence support sizes, dimensions,
+and information sets are preserved. Degrees increase from at most `k_0-1`
+to at most `k-1`; if `k>k_0`, all resulting stars are nonempty.
+
+Consequently every explicit hierarchy witness in
+[HIGHER-GRAPH.md](HIGHER-GRAPH.md) gives an upper bound at the same q and
+higher k. The bounds need not be sharp: the cube construction gives
+`d_3=14` at `q=2,k>=4`, whereas the graph witness has support fifteen.
+
+## From subcode witnesses to simultaneous targets
+
+For completeness, an r-dimensional subcode with support W has an
+information set T of r coordinates: select r independent columns of an
+evaluation matrix. Change its row basis so that restriction to T is the
+identity. Deleting `D=W\T` then makes these rows unit decoders for all
+r retained targets. Conversely, r simultaneous unit decoders supported
+on `D union T` are independent and span an r-dimensional subcode, so
+`|D|+r>=d_r`. This proves the selectable-target equality `|D|_min=d_r-r`.
+
+The explicit star and cube rows above make these information sets finite,
+ordinary linear-algebra choices. This establishes the precise scalar
+threshold; it does not charge for acquiring the required star totals,
+synthesize a complete paid supplier, or improve κ.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/README.md b/research/asymmetric-hypercube-decoder/README.md
index 105da1bbf8..d4bc9d5286 100644
--- a/research/asymmetric-hypercube-decoder/README.md
+++ b/research/asymmetric-hypercube-decoder/README.md
@@ -1,4 +1,77 @@
-# Sharp global-star punctures and optimal decoder geometry
+# Global-star decoding: sharp punctures and higher-target hierarchies
+
+**Uniform structural theorems with exact replay; no new κ.** The higher-target
+extension determines a complete hierarchy at `k=2`, the third generalized
+weight for every `k>=2,q=p-k>=2`, and a five-weight prefix at `q=2`.
+A generalized weight `d_r` measures the smallest support of r independent
+observation rows. The exact deletion threshold for **some selectable r-target
+set** is `d_r-r`; arbitrary prescribed target sets are a separate problem.
+
+| Result | Parameter range | Proof |
+| --- | --- | --- |
+| Complete generalized-weight hierarchies, with and without the empty star | `k=2,p>=2`, every available rank | [HIGHER-GRAPH.md](HIGHER-GRAPH.md) |
+| First two nonzero word weights are `2q+2` and `4q+2` | `k>=2,q>=3` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
+| `d_3=6q+3`; every optimum is a triangle of minimum stars | `k>=2,q>=3` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
+| `d_3=15` for `k=2,3`; `d_3=14` for `k>=4` | `q=2` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
+| `(d_1,...,d_5)=(6,11,14,15,16)` | `q=2,k>=4` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
+
+The boundary is a real change in optimizer structure: every span of three
+minimum stars needs at least fifteen ports, but a localized affine cube has
+three independent rows on fourteen ports. At `q=2,k>=4`, three, four, or five
+selectable targets therefore all need exactly **eleven deletions**. At `(p,k)=(8,4)`,
+three selectable targets instead need exactly 24 deletions. Code results apply
+to both proper-star spaces; overlap-class corrections are covered at
+power-of-two k only. For `q>=3`, there are exactly
+`2^(k+1) binom(p,k-2) binom(q+2,3)` optimal three-dimensional subcodes. A
+prescribed triple attains `6q` deletions exactly when its three columns on
+some triangle have rank three. The larger budgets required by triples
+failing that criterion are not classified.
+
+The general incidence-code/cut connection is credited to Martínez-Bernal,
+Valencia-Bucio, and Villarreal in the graph note. The uniform minimum distance
+is inherited from Luke Mansoor's #732. Earlier one- and two-target results,
+concurrent source credits, and the original obstruction remain below.
+
+## Reproduce the higher-target results
+
+From the repository root, Python 3.10+ with its standard library:
+
+```sh
+for check in higher cube boundary; do
+  python3 -I -O -B "research/asymmetric-hypercube-decoder/${check}_verify.py" --self-test || exit
+done
+```
+
+Expected output prefixes: `PASS_HIGHER_GRAPH`, `PASS_CUBE`, and `PASS_K3_BOUNDARY`.
+The independent checks compare their deterministic receipts before reporting
+success. Every self-test also checks relocation, optimized execution,
+corruption rejection, and preservation of an existing output on failure.
+
+- [higher_verify.py](higher_verify.py): all labeled vertex partitions and all
+  internal cuts at `p=3,...,6`; 8,224 literal edge restrictions at `p=2,3`;
+  all 449,606 nonzero subspaces of the two graph codes at `p=3,4`; all
+  7,135,750 rank-three subspaces at `p=5`, including exactly eighty optima
+  in each code, matching the triangle count; complete weight distributions for 523,776 words
+  at `p=5,...,9`; 68 optimal simultaneous-decoder witnesses with 1,511
+  full-code restoration controls.
+- [cube_verify.py](cube_verify.py): fifteen literal three-, four-, and five-target
+  decoders, evaluated on every port at `q=2,k=4,...,8`; 165 restoration controls
+  within the displayed subcodes; 25 three-star constructions at `k,q=2,...,6`.
+  The smallest cube certificates include the actual proper-star expansions,
+  targets, deletions, and decoder coefficients in [CUBE-RESULTS.json](CUBE-RESULTS.json).
+- [boundary_verify.py](boundary_verify.py): all five shortening spaces of the
+  full `p=5,k=3` code, 90 basis vectors, and all 1,024 words of its residual
+  extension E. This checks the exceptional boundary lemma; it does not
+  enumerate all global three-dimensional subcodes.
+
+These finite checks support the separate written proofs. They do not replace
+them or constitute a proof-assistant verification. [HIGHER-CLAIM.json](HIGHER-CLAIM.json)
+records the continuation base `8bcbaafe8590d30eff9c0ae5fd9e49479c84038c`,
+source pins, review coverage, and stopping rule. [HIGHER-COST.md](HIGHER-COST.md)
+prices the displayed scalar evaluation and explains the unresolved supplier
+interface. There is no changed multiplication bound or selected certificate.
+
+## One- and two-target geometry
 
 **Uniform structural theorems; no new κ.** Put `q=p-k`. For every `k>=2`
 and `q>=2`, this package now proves:
diff --git a/research/asymmetric-hypercube-decoder/boundary_verify.py b/research/asymmetric-hypercube-decoder/boundary_verify.py
new file mode 100644
index 0000000000..2376b334aa
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/boundary_verify.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Independent k=3,q=2 shortening audit; Python 3.10+, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+This verifies the finite shortening lemma, not all rank-three global subcodes.
+"""
+import argparse
+from collections import Counter
+import hashlib
+from itertools import combinations, product
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def ports(p, k):
+    return [sum(1 << (2 * i + sign) for i, sign in zip(indices, signs))
+            for indices in combinations(range(p), k)
+            for signs in product((0, 1), repeat=k)]
+
+
+def basis(rows):
+    pivots = {}
+    for word in rows:
+        while word:
+            pivot = word.bit_length() - 1
+            if pivot in pivots:
+                word ^= pivots[pivot]
+            else:
+                pivots[pivot] = word
+                break
+    return pivots
+
+
+def belongs(word, pivots):
+    for pivot in sorted(pivots, reverse=True):
+        if word >> pivot & 1:
+            word ^= pivots[pivot]
+    return word == 0
+
+
+def combine(coefficients, rows):
+    word = 0
+    for i, row in enumerate(rows):
+        if coefficients >> i & 1:
+            word ^= row
+    return word
+
+
+def nullspace(equations, dimension):
+    pivots = basis(equations)
+    vectors = []
+    for free in range(dimension):
+        if free in pivots:
+            continue
+        vector = 1 << free
+        for pivot in sorted(pivots):
+            if (pivots[pivot] & vector).bit_count() % 2:
+                vector ^= 1 << pivot
+        require(all((equation & vector).bit_count() % 2 == 0 for equation in equations),
+                "invalid restriction-kernel vector")
+        vectors.append(vector)
+    require(len(basis(vectors)) == dimension - len(pivots), "incomplete restriction kernel")
+    return vectors
+
+
+def words_from_basis(pivots):
+    words = [0]
+    for row in pivots.values():
+        words += [word ^ row for word in words]
+    require(len(set(words)) == len(words), "dependent enumeration basis")
+    return words
+
+
+def verify():
+    full_ports, residual_ports = ports(5, 3), ports(4, 2)
+    generators = [sum(1 << j for j, port in enumerate(full_ports) if port & face == face)
+                  for degree in range(3) for face in ports(5, degree)]
+    full_rows = list(basis(generators).values())
+    require(len(full_ports) == 80 and len(full_rows) == 40, "full global code")
+    require(belongs(generators[0], basis(generators[1:])), "empty-star redundancy at odd k=3")
+
+    graph_rows = [(1 << len(residual_ports)) - 1]
+    graph_rows += [sum(1 << j for j, port in enumerate(residual_ports) if port >> vertex & 1)
+                   for vertex in range(8)]
+    graph_basis = basis(graph_rows)
+    blocks = [sum(1 << j for j, port in enumerate(residual_ports)
+                  if {vertex // 2 for vertex in range(8) if port >> vertex & 1} == set(indices))
+              for indices in combinations(range(4), 2)]
+    block_basis, extended_basis = basis(blocks), basis(graph_rows + blocks)
+    require(len(graph_basis) == 8 and len(block_basis) == 6 and len(extended_basis) == 10,
+            "residual graph, block, and extended-space dimensions")
+    intersection_dimension = len(graph_basis) + len(block_basis) - len(extended_basis)
+    require(intersection_dimension == 4, "unsigned intersection dimension")
+    graph_words, extended_words = words_from_basis(graph_basis), words_from_basis(extended_basis)
+    require(min(word.bit_count() for word in graph_words if word) == 6, "graph minimum distance")
+    require(min(word.bit_count() for word in extended_words if word) == 4, "extended minimum distance")
+    minimum_words = {word for word in extended_words if word.bit_count() == 4}
+    require(minimum_words == set(blocks), "extended minimum words are precisely unsigned blocks")
+    require(all(not (left & right) for left, right in combinations(blocks, 2)), "block disjointness")
+
+    residual_index = {port: j for j, port in enumerate(residual_ports)}
+    cases = []
+    for selected_pair in range(5):
+        pair_mask = 3 << (2 * selected_pair)
+        zero_columns = [j for j, port in enumerate(full_ports) if not port & pair_mask]
+        equations = [sum(((row >> column) & 1) << i for i, row in enumerate(full_rows))
+                     for column in zero_columns]
+        coefficients = nullspace(equations, len(full_rows))
+        shortened_rows = [combine(vector, full_rows) for vector in coefficients]
+        require(len(basis(shortened_rows)) == 18, "shortened-space dimension")
+        remaining_pairs = [pair for pair in range(5) if pair != selected_pair]
+        slices = []
+        for word in shortened_rows:
+            plus, minus = 0, 0
+            for column, port in enumerate(full_ports):
+                if not (word >> column & 1):
+                    continue
+                require(port & pair_mask, "shortened word survives outside selected pair")
+                residual = sum(((port >> (2 * pair)) & 3) << (2 * j)
+                               for j, pair in enumerate(remaining_pairs))
+                bit = 1 << residual_index[residual]
+                if port >> (2 * selected_pair) & 1:
+                    plus |= bit
+                else:
+                    minus |= bit
+            require(belongs(plus, extended_basis) and belongs(minus, extended_basis),
+                    "slice does not belong to extended residual space")
+            require(belongs(plus ^ minus, graph_basis), "two slices have different quotient classes")
+            slices.append((plus, minus))
+        projection_ranks = [len(basis(pair[sign] for pair in slices)) for sign in (0, 1)]
+        require(projection_ranks == [10, 10], "slice projection dimensions")
+        require(any(not belongs(word, graph_basis) for pair in slices for word in pair),
+                "unsigned extension is necessary, not just a redundant presentation")
+        cases.append(dict(selected_pair=selected_pair, avoided_port_count=len(zero_columns),
+                          avoidance_rank=len(basis(equations)), shortening_rank=len(shortened_rows),
+                          slice_projection_ranks=projection_ranks,
+                          shortening_basis_sha256=digest(shortened_rows), slice_basis_sha256=digest(slices)))
+
+    return dict(status="PASS", arithmetic="exact F2 integer bitsets",
+                scope="Complete finite linear-space audit of the k=3,p=5 shortening at all five original pairs. "
+                      "Every shortening basis vector is checked; linearity extends containment and quotient "
+                      "agreement to its full span. All residual E words are enumerated. This is not an "
+                      "enumeration of every global codeword or rank-three subcode; the proof in "
+                      "HIGHER-WEIGHTS.md supplies the third-weight conclusion.",
+                global_ports=len(full_ports), global_degree_at_most_two_generators=len(generators),
+                global_rank=len(full_rows), global_nonempty_rank=len(basis(generators[1:])),
+                residual_ports=len(residual_ports), residual_graph_rank=len(graph_basis),
+                unsigned_block_rank=len(block_basis), extended_rank=len(extended_basis),
+                unsigned_graph_intersection_rank=intersection_dimension,
+                extended_quotient_rank=len(extended_basis) - len(graph_basis),
+                residual_graph_words=len(graph_words), extended_words=len(extended_words),
+                extended_weight_distribution={str(weight): count for weight, count in
+                                              sorted(Counter(word.bit_count() for word in extended_words).items())},
+                extended_minimum_word_masks=sorted(minimum_words), shortening_cases=cases,
+                negative_controls=["the graph-only slice space rejects valid shortened words",
+                                   "every weight-four E word is a single unsigned block",
+                                   "distinct weight-four E words have disjoint supports",
+                                   "the k=3 global empty star is already in the nonempty span"])
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script, receipt = directory / "boundary_verify.py", directory / "BOUNDARY-RESULTS.json"
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        replay = subprocess.run(command, capture_output=True, text=True)
+        require(replay.returncode == 0, f"isolated optimized replay failed: {replay.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve existing output\n")
+        replay = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                                capture_output=True, text=True)
+        require(replay.returncode != 0, "corrupted receipt was accepted")
+        require(protected.read_text() == "preserve existing output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path, help="write a deterministic receipt after checks pass")
+    parser.add_argument("--check", type=Path, help="compare with this receipt before writing output")
+    parser.add_argument("--self-test", action="store_true", help="check optimized relocation and failure preservation")
+    args = parser.parse_args()
+    result = verify()
+    if args.check or not args.write:
+        receipt = args.check or HERE / "BOUNDARY-RESULTS.json"
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS_K3_BOUNDARY: 5 complete shortening spaces; 90 basis vectors; "
+          "1024 residual E words; 6 literal weight-four blocks; 4 control categories")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/asymmetric-hypercube-decoder/cube_verify.py b/research/asymmetric-hypercube-decoder/cube_verify.py
new file mode 100644
index 0000000000..6a2ef2ae1a
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/cube_verify.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""Literal localized-cube and three-star witnesses; Python 3.10+, stdlib.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+This verifies constructions, not the uniform lower bounds in HIGHER-WEIGHTS.md.
+"""
+import argparse
+import hashlib
+from itertools import combinations, product
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def ports(p, k):
+    return [sum(1 << (2 * pair + sign) for pair, sign in zip(pairs, signs))
+            for pairs in combinations(range(p), k) for signs in product((0, 1), repeat=k)]
+
+
+def star(face, family):
+    return sum(1 << i for i, port in enumerate(family) if port & face == face)
+
+
+def xor(words):
+    value = 0
+    for word in words:
+        value ^= word
+    return value
+
+
+def basis(words):
+    pivots = {}
+    for word in words:
+        while word:
+            pivot = word.bit_length() - 1
+            if pivot in pivots:
+                word ^= pivots[pivot]
+            else:
+                pivots[pivot] = word
+                break
+    return pivots
+
+
+def belongs(word, pivots):
+    for pivot in sorted(pivots, reverse=True):
+        if word >> pivot & 1:
+            word ^= pivots[pivot]
+    return word == 0
+
+
+def combination(mask, words):
+    return xor(word for i, word in enumerate(words) if mask >> i & 1)
+
+
+def support(words):
+    union = 0
+    for word in words:
+        union |= word
+    return union
+
+
+def valid_faces(faces, k):
+    return all(0 < face.bit_count() < k and
+               all((face >> (2 * i)) & 3 != 3 for i in range(face.bit_length() // 2 + 1))
+               for face in faces)
+
+
+def cube_rows(k, family):
+    fixed = sum(1 << (2 * i) for i in range(k - 4))
+    variable = list(range(k - 4, k))
+    outside = (k, k + 1)
+    selectors = [1 << (2 * i) for i in variable] + [1 << (2 * variable[-1] + 1)]
+    faces, rows = [], []
+    selected_cube = sum(1 << i for i, port in enumerate(family)
+                        if port & fixed == fixed and port >> (2 * k) == 0)
+    require(selected_cube.bit_count() == 16, "localized cube size")
+    for selector in selectors:
+        terms = [fixed | selector | left | right
+                 for left in (0, 1 << (2 * outside[0]), 1 << (2 * outside[0] + 1))
+                 for right in (0, 1 << (2 * outside[1]), 1 << (2 * outside[1] + 1))]
+        require(valid_faces(terms, k) and len(set(terms)) == 9, "nine allowed nonempty stars")
+        row = xor(star(face, family) for face in terms)
+        require(row == selected_cube & star(selector, family), "expanded versus factored selector")
+        require(row.bit_count() == 8, "affine cube row weight")
+        faces.append(terms)
+        rows.append(row)
+    require(rows[3] ^ rows[4] == selected_cube, "empty-free constant on localized cube")
+    leaked = star(fixed | selectors[0], family) ^ xor(
+        star(fixed | selectors[0] | (1 << (2 * outside[0] + sign)), family) for sign in (0, 1))
+    require(bool(leaked & ~selected_cube), "omitting one exclusion must leak nuisance ports")
+    require(rows[0] ^ star(faces[0][-1], family) != rows[0], "dropped term must change identity")
+    return faces, rows
+
+
+def decoder_case(k, family, faces, rows, rank):
+    original = rows[:rank]
+    words = original[:]
+    coefficients = [1 << i for i in range(rank)]
+    information = []
+    for column in range(len(family)):
+        pivot = len(information)
+        found = next((i for i in range(pivot, rank) if words[i] >> column & 1), None)
+        if found is None:
+            continue
+        words[pivot], words[found] = words[found], words[pivot]
+        coefficients[pivot], coefficients[found] = coefficients[found], coefficients[pivot]
+        for i in range(rank):
+            if i != pivot and words[i] >> column & 1:
+                words[i] ^= words[pivot]
+                coefficients[i] ^= coefficients[pivot]
+        information.append(column)
+    require(len(information) == rank, "independent cube rows")
+    union = support(original)
+    expected = {3: 14, 4: 15, 5: 16}[rank]
+    require(union.bit_count() == expected, "higher-weight witness support")
+    target_mask = sum(1 << i for i in information)
+    deleted = union ^ target_mask
+    require(deleted.bit_count() == 11, "eleven deletions")
+    surviving = ((1 << len(family)) - 1) ^ deleted
+    expanded = []
+    helper_words = {face: star(face, family) for terms in faces[:rank] for face in terms}
+    for coefficient, word, target in zip(coefficients, words, information):
+        terms = set()
+        for i in range(rank):
+            if coefficient >> i & 1:
+                terms.symmetric_difference_update(faces[i])
+        require(xor(helper_words[face] for face in terms) == word == combination(coefficient, original),
+                "literal decoder expansion")
+        require(word & surviving == 1 << target, "retained unit decoder")
+        expanded.append(sorted(terms))
+    for column in range(len(family)):
+        if deleted >> column & 1:
+            restored = surviving | 1 << column
+            row_basis = basis(word & restored for word in original)
+            require(not all(belongs(1 << target, row_basis) for target in information),
+                    "single restoration must break simultaneous decoding within witness span")
+    deleted_indices = [i for i in range(len(family)) if deleted >> i & 1]
+    costs = dict(distinct_observations=len(helper_words),
+                 original_row_xors=sum(len(terms) - 1 for terms in faces[:rank]),
+                 direct_unit_row_xors=sum(len(terms) - 1 for terms in expanded),
+                 cached_basis_to_unit_xors=sum(mask.bit_count() - 1 for mask in coefficients),
+                 independent_helper_input_contributions=sum((word & surviving).bit_count()
+                                                            for word in helper_words.values()),
+                 independent_helper_sum_xors=sum(max(0, (word & surviving).bit_count() - 1)
+                                                 for word in helper_words.values()))
+    result = dict(rank=rank, support_size=expected, deletions=11,
+                  information_indices=information, deleted_indices=deleted_indices,
+                  decoder_coefficients=coefficients, basis_rows_sha256=digest(original),
+                  costs_for_naive_scalar_evaluation_only=costs)
+    if k == 4:
+        result.update(information_ports=[family[i] for i in information],
+                      deleted_ports=[family[i] for i in deleted_indices],
+                      original_proper_star_faces=faces[:rank], decoder_proper_star_faces=expanded)
+    return result
+
+
+def cube_case(k):
+    family = ports(k + 2, k)
+    faces, rows = cube_rows(k, family)
+    require([combination(mask, rows[:3]).bit_count() for mask in range(1, 8)] == [8] * 7,
+            "all seven third-weight witness words have weight eight")
+    return dict(k=k, p=k + 2, ports=len(family), port_order_sha256=digest(family),
+                witnesses=[decoder_case(k, family, faces, rows, rank) for rank in (3, 4, 5)])
+
+
+def triangle_case(k, q):
+    family = ports(k + q, k)
+    fixed = sum(1 << (2 * i) for i in range(k - 2))
+    faces = [fixed | 1 << (2 * i) for i in range(k - 2, k + 1)]
+    words = [star(face, family) for face in faces]
+    require(valid_faces(faces, k) and len(basis(words)) == 3, "independent triangle stars")
+    require([word.bit_count() for word in words] == [2 * (q + 1)] * 3, "triangle star weights")
+    require(all((a & b).bit_count() == 1 for a, b in combinations(words, 2)), "triangle pair overlaps")
+    require(words[0] & words[1] & words[2] == 0, "empty triple intersection")
+    require(support(words).bit_count() == 6 * q + 3, "triangle support")
+    return dict(k=k, q=q, ports=len(family), support_size=6 * q + 3,
+                star_faces=faces, evaluation_sha256=digest(words))
+
+
+def verify():
+    cubes = [cube_case(k) for k in range(4, 9)]
+    triangles = [triangle_case(k, q) for k in range(2, 7) for q in range(2, 7)]
+    # A two-exclusion selector times a sign reaches forbidden degree k at k=3.
+    require(not valid_faces([1 << 0 | 1 << 6 | 1 << 8], 3), "invalid k=3 degree rejected")
+    return dict(status="PASS", arithmetic="exact binary evaluations on every full-family port",
+                scope="Constructive witnesses only; uniform lower bounds are separate written proofs. "
+                      "Restoration controls concern the displayed subcode, not a full ambient-code search. "
+                      "Costs price naive scalar sums only; no complete supplier or kappa claim.",
+                port_encoding="bit 2*i+s denotes sign s of pair i; combinations then lexicographic signs",
+                cubes=cubes, triangles=triangles,
+                negative_controls=["all single-deletion restorations break the displayed simultaneous span",
+                                   "missing outside-pair exclusion leaks nuisance ports",
+                                   "missing proper-star monomial changes the evaluation",
+                                   "k=3 two-exclusion linear selector fails the proper-degree limit"])
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / "cube_verify.py"
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / "CUBE-RESULTS.json"
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = verify()
+    if args.check or not args.write:
+        receipt = args.check or HERE / "CUBE-RESULTS.json"
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS_CUBE: 15 literal simultaneous decoders on 5 full port families; "
+          "165 restoration controls; 25 triangle witnesses; forbidden-degree and leakage controls")
+
+
+if __name__ == "__main__":
+    main()

From 697e4d36a6a8c34727677ffdfc4164929fb7c870 Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Tue, 13 Oct 2026 23:21:30 +0900
Subject: [PATCH 6/7] Prove fourth-weight optimizers and weighted copy
 obstruction

---
 .../BLOCK-RESULTS.json                        | 200 +++++
 .../CAMPAIGN-18H.json                         | 103 +++
 .../COPY-OBSTRUCTION-RESULTS.json             | 150 ++++
 .../COPY-OBSTRUCTION.md                       | 345 +++++++++
 .../CUBE-OPTIMIZERS.md                        | 378 +++++++++
 .../FOURTH-WEIGHT.md                          | 722 ++++++++++++++++++
 .../OPTIMIZER-RESULTS.json                    |  36 +
 .../asymmetric-hypercube-decoder/README.md    |  59 +-
 .../SHORTENING-RESULTS.json                   | 510 +++++++++++++
 .../block_verify.py                           | 270 +++++++
 .../copy_obstruction_verify.py                | 224 ++++++
 .../optimizer_verify.py                       | 173 +++++
 .../shortening_verify.py                      | 142 ++++
 13 files changed, 3310 insertions(+), 2 deletions(-)
 create mode 100644 research/asymmetric-hypercube-decoder/BLOCK-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
 create mode 100644 research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
 create mode 100644 research/asymmetric-hypercube-decoder/CUBE-OPTIMIZERS.md
 create mode 100644 research/asymmetric-hypercube-decoder/FOURTH-WEIGHT.md
 create mode 100644 research/asymmetric-hypercube-decoder/OPTIMIZER-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/SHORTENING-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/block_verify.py
 create mode 100644 research/asymmetric-hypercube-decoder/copy_obstruction_verify.py
 create mode 100644 research/asymmetric-hypercube-decoder/optimizer_verify.py
 create mode 100644 research/asymmetric-hypercube-decoder/shortening_verify.py

diff --git a/research/asymmetric-hypercube-decoder/BLOCK-RESULTS.json b/research/asymmetric-hypercube-decoder/BLOCK-RESULTS.json
new file mode 100644
index 0000000000..cebb011d25
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/BLOCK-RESULTS.json
@@ -0,0 +1,200 @@
+{
+  "cases": [
+    {
+      "accepted_supports": 4,
+      "all_accepted_slices_unsigned": true,
+      "all_codewords_enumerated": true,
+      "all_rank3_support14_spaces_in_one_block": true,
+      "allowed_ports": 16,
+      "codewords": 8,
+      "constant_weight8_planes": 4,
+      "geometry": "complementary",
+      "global_stars": 51,
+      "k": 3,
+      "logical_4_plus_4_supports": 4900,
+      "negative_controls": [
+        "projected two-point star is not shortened codeword",
+        "even 4+4 affine slices with varying core rejected"
+      ],
+      "p": 5,
+      "ports": 80,
+      "quadruples_per_block": [
+        70,
+        70
+      ],
+      "rank3_support14_spaces": 0,
+      "shortened_dimension": 3,
+      "universal_pair_histogram": {
+        "1": 4,
+        "3": 2
+      },
+      "weight_eight_words": 6,
+      "weight_histogram": {
+        "0": 1,
+        "8": 6,
+        "16": 1
+      }
+    },
+    {
+      "all_codewords_enumerated": true,
+      "all_rank3_support14_spaces_in_one_block": true,
+      "allowed_ports": 32,
+      "codewords": 64,
+      "constant_weight8_planes": 8,
+      "fixed_core_per_block_supports": 512,
+      "geometry": "four_cycle",
+      "global_stars": 51,
+      "includes_both_3_4_orientations": true,
+      "k": 3,
+      "negative_controls": [
+        "rank3 constant-weight8 four-cycle passes block parity but fails full code"
+      ],
+      "p": 5,
+      "ports": 80,
+      "rank3_support14_candidates_admitted": 0,
+      "rank3_support14_spaces": 0,
+      "shortened_dimension": 6,
+      "shortened_dimension_histogram": {
+        "1": 512
+      },
+      "universal_pair_histogram": {
+        "1": 8,
+        "3": 4
+      },
+      "weight_eight_words": 12,
+      "weight_histogram": {
+        "0": 1,
+        "8": 12,
+        "16": 38,
+        "24": 12,
+        "32": 1
+      }
+    },
+    {
+      "accepted_supports": 16,
+      "all_accepted_slices_unsigned": true,
+      "all_codewords_enumerated": true,
+      "all_rank3_support14_spaces_in_one_block": true,
+      "allowed_ports": 32,
+      "codewords": 2048,
+      "constant_weight8_planes": 328,
+      "geometry": "complementary",
+      "global_stars": 233,
+      "k": 4,
+      "logical_4_plus_4_supports": 3312400,
+      "negative_controls": [
+        "projected two-point star is not shortened codeword",
+        "even 4+4 affine slices with varying core rejected"
+      ],
+      "p": 6,
+      "ports": 240,
+      "quadruples_per_block": [
+        1820,
+        1820
+      ],
+      "rank3_support14_spaces": 240,
+      "shortened_dimension": 11,
+      "universal_pair_histogram": {
+        "2": 16,
+        "4": 60
+      },
+      "weight_eight_words": 76,
+      "weight_histogram": {
+        "0": 1,
+        "8": 76,
+        "12": 192,
+        "16": 1510,
+        "20": 192,
+        "24": 76,
+        "32": 1
+      }
+    },
+    {
+      "all_codewords_enumerated": true,
+      "all_rank3_support14_spaces_in_one_block": true,
+      "allowed_ports": 64,
+      "codewords": 4194304,
+      "constant_weight8_planes": 656,
+      "fixed_core_per_block_supports": 8192,
+      "geometry": "four_cycle",
+      "global_stars": 233,
+      "includes_both_3_4_orientations": true,
+      "k": 4,
+      "negative_controls": [
+        "rank3 constant-weight8 four-cycle passes block parity but fails full code"
+      ],
+      "p": 6,
+      "ports": 240,
+      "rank3_support14_candidates_admitted": 0,
+      "rank3_support14_spaces": 480,
+      "shortened_dimension": 22,
+      "shortened_dimension_histogram": {
+        "1": 8192
+      },
+      "universal_pair_histogram": {
+        "2": 32,
+        "4": 120
+      },
+      "weight_eight_words": 152,
+      "weight_histogram": {
+        "0": 1,
+        "8": 152,
+        "12": 384,
+        "16": 8796,
+        "20": 29568,
+        "24": 266536,
+        "28": 609024,
+        "32": 2365382,
+        "36": 609024,
+        "40": 266536,
+        "44": 29568,
+        "48": 8796,
+        "52": 384,
+        "56": 152,
+        "64": 1
+      }
+    },
+    {
+      "accepted_supports": 64,
+      "all_accepted_slices_unsigned": true,
+      "all_codewords_enumerated": false,
+      "allowed_ports": 64,
+      "geometry": "complementary",
+      "global_stars": 939,
+      "k": 5,
+      "logical_4_plus_4_supports": 1293121600,
+      "negative_controls": [
+        "projected two-point star is not shortened codeword",
+        "even 4+4 affine slices with varying core rejected"
+      ],
+      "p": 7,
+      "ports": 672,
+      "quadruples_per_block": [
+        35960,
+        35960
+      ],
+      "shortened_dimension": 33
+    },
+    {
+      "all_codewords_enumerated": false,
+      "allowed_ports": 128,
+      "fixed_core_per_block_supports": 131072,
+      "geometry": "four_cycle",
+      "global_stars": 939,
+      "includes_both_3_4_orientations": true,
+      "k": 5,
+      "negative_controls": [
+        "rank3 constant-weight8 four-cycle passes block parity but fails full code"
+      ],
+      "p": 7,
+      "ports": 672,
+      "rank3_support14_candidates_admitted": 0,
+      "shortened_dimension": 66,
+      "shortened_dimension_histogram": {
+        "1": 131072
+      }
+    }
+  ],
+  "scope": "Full-generator complementary-block and four-cycle shortenings for k=3,4,5 at q=2. Full word enumeration only when dimension<=22. Complementary 4+4 candidates use exact syndrome meet-in-the-middle; cycle support candidates have fixed core signs separately in each block. Case counts overlap and are not global distinct-subcode counts.",
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json b/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
new file mode 100644
index 0000000000..da2dff3b51
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
@@ -0,0 +1,103 @@
+{
+  "status": "active",
+  "assignment_seed": 48,
+  "track": "Structural decoder research; sustained higher-rank and supplier-interface continuation",
+  "base_commit": "7d526020fc368ce4157cd436995c2f4fcf683318",
+  "current_main_snapshot": "91a2094f2e022930069e8cfdc810a3ea1b81cd09",
+  "selected_kappa_at_start": "1661634653669567/1000000000000000000",
+  "selected_review": "docs/research/community-frontier799-review.md",
+  "started_at": "2026-10-13T22:16:53+09:00",
+  "minimum_duration_hours": 18,
+  "earliest_completion_at": "2026-10-14T16:16:53+09:00",
+  "research_phase_minimum_hours": 13.5,
+  "verification_phase_minimum_hours": 4.5,
+  "candidate_tasks": [
+    "Uniform fourth and higher generalized weights, starting with the q>=3 d4=8q+2 hypothesis and its unresolved q=3 boundary.",
+    "Exact geometry of exceptional q=2 subcodes and prescribed multi-target deletion budgets.",
+    "Physical realization and complete recursive pricing of simultaneous proper-star decoders under the selected supplier interfaces."
+  ],
+  "objective": "Develop a general, physically accountable multi-target decoder theory: higher-rank theorems and exact certificates, plus either a verified complete supplier improvement or a rigorous obstruction for a clearly defined enlarged decoder class.",
+  "success_standard": "An early theorem is a milestone, not campaign completion. Continue substantive unresolved work for the minimum period and independently verify the final claims. Do not manufacture a kappa improvement, idle to consume time, or label unresolved central obligations complete.",
+  "publication": "https://github.com/CrocSwap/integer-mult-bounds/pull/669",
+  "constraints": [
+    "Preserve upstream and selected frontier.",
+    "Only update existing PR669; do not merge.",
+    "Record exact sources and predecessor credit.",
+    "No finite replay promoted to a uniform proof.",
+    "No unpriced helper/source/frame/copy/restoration/recursive work."
+  ],
+  "first_assignments": {
+    "geometry": "Fourth-weight theorem and higher-rank structure, initially scratch only.",
+    "supplier": "Actual physical supplier interface and optimistic complete invoice, initially scratch only.",
+    "lead": "Refresh overlap, coordinate exact experiments, maintain checkpoints and independently review all proposed results."
+  },
+  "attribution": "Sam Sung with substantial OpenAI Codex assistance, including independent AI-assisted review.",
+  "checkpoint": {
+    "recorded_at": "2026-10-13T23:13:47+09:00",
+    "phase": "research and construction; the reserved final verification phase has not begun",
+    "campaign_status": "active; minimum duration and remaining research obligations are not complete",
+    "reviewed_milestones": [
+      {
+        "claim": "Uniform fourth generalized weight d4=8q+2 and complete four-star optimizer classification for k>=2,q>=3.",
+        "proof": "FOURTH-WEIGHT.md",
+        "review": "Independent AI-assisted review of theorem, q>=4 equality, q=3 equality, and final text; lead reviewed boundary argument."
+      },
+      {
+        "claim": "Exact ordinary-cube shortening and all q2 rank3/4/5 optimizers; prescribed target criterion for eleven deletions.",
+        "proof": "CUBE-OPTIMIZERS.md",
+        "review": "Separate AI-assisted proof review, finite implementation independent of reduction, and exact-text drift review."
+      },
+      {
+        "claim": "Integral separating-pairing weighted COPY obstruction, including chronological copy-to-zero innovations and even paired-port corollary.",
+        "proof": "COPY-OBSTRUCTION.md",
+        "review": "Lead independently checked rank decomposition, integral specialization, source-column invariant, and template scope; separate checker review and replay."
+      }
+    ],
+    "verification": [
+      {
+        "script": "shortening_verify.py",
+        "script_sha256": "99f969307eb7c120a32aff6503c8787c768d3e7cc79551427ecc23ea421c22e1",
+        "receipt": "SHORTENING-RESULTS.json",
+        "receipt_sha256": "b4eb4a08ab3ac033eb460756fa6f40f267725a2197a19b20cf4a00f279a88829",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/shortening_verify.py --self-test",
+        "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      },
+      {
+        "script": "optimizer_verify.py",
+        "script_sha256": "2ab6fe919c4af03b0f13941685604d5f51c5ef8f1c9857f8a1c6fdf1e82ecd5a",
+        "receipt": "OPTIMIZER-RESULTS.json",
+        "receipt_sha256": "8b116c4e79d51ea38e239e66396eba083fdf420bddc2b710e8330dcf5fa8921d",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/optimizer_verify.py --self-test",
+        "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      },
+      {
+        "script": "block_verify.py",
+        "script_sha256": "f6663116d672d7bdc78fc4ff4a3ab84818337c3c9639959ed16261f36e03d66b",
+        "receipt": "BLOCK-RESULTS.json",
+        "receipt_sha256": "9fbca06918ff2c41ce25c10ff09dcc4f28b8d276723cc106d80b650305c6f603",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/block_verify.py --self-test",
+        "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      },
+      {
+        "script": "copy_obstruction_verify.py",
+        "script_sha256": "f23ae7783bbbef4171da3c153393af3f4d95b0493a738c021893d21d549eb366",
+        "receipt": "COPY-OBSTRUCTION-RESULTS.json",
+        "receipt_sha256": "b166a48db0cfbb7fe8b9929a248e73018f7d535f0b71757ae4553255d62b2ce1",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/copy_obstruction_verify.py --self-test",
+        "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      }
+    ],
+    "next_unresolved_work": [
+      "Uniform fifth and higher generalized weights: q3 support29 is the active boundary; new weight14 and common-original-core lemmas are under development.",
+      "Exact prescribed-target budgets outside the optimum criteria: graph triples/quads have new scratch results needing proof review and integration.",
+      "Common-original-core shortening with unrestricted signs: determine a uniform residual-code filtration rather than assume signed-face shortening.",
+      "Odd-size paired-port supplier: price the known scalar identities under shared monotone source routes and actual odd-stage moments; do not duplicate older unshared screens.",
+      "Continue the full minimum research period, then perform the reserved independent verification, current-source/overlap refresh and publication through PR669."
+    ],
+    "publication_status": "New milestone files are local; published PR head remains 7d526020fc368ce4157cd436995c2f4fcf683318 at this checkpoint.",
+    "environment": {
+      "python": "3.14.5",
+      "arithmetic": "Python integers, exact F2 elimination, and Fraction rational elimination; standard library only"
+    }
+  }
+}
diff --git a/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION-RESULTS.json b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION-RESULTS.json
new file mode 100644
index 0000000000..fe5eab2fad
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION-RESULTS.json
@@ -0,0 +1,150 @@
+{
+  "cases": [
+    {
+      "k": 2,
+      "observations": 4,
+      "p": 3,
+      "ports": 12,
+      "term_types": {
+        "(1, 2, 4, 4)": 2,
+        "(1, 4, 4, 4)": 2
+      },
+      "tight_individual_copy_cost": 12,
+      "total_literal_frame_rank": 16,
+      "total_term_rank": 12
+    },
+    {
+      "k": 2,
+      "observations": 6,
+      "p": 4,
+      "ports": 24,
+      "term_types": {
+        "(1, 2, 6, 6)": 2,
+        "(1, 4, 6, 6)": 2,
+        "(1, 6, 6, 6)": 2
+      },
+      "tight_individual_copy_cost": 24,
+      "total_literal_frame_rank": 36,
+      "total_term_rank": 24
+    },
+    {
+      "k": 2,
+      "observations": 8,
+      "p": 5,
+      "ports": 40,
+      "term_types": {
+        "(1, 2, 8, 8)": 2,
+        "(1, 4, 8, 8)": 2,
+        "(1, 6, 8, 8)": 2,
+        "(1, 8, 8, 8)": 2
+      },
+      "tight_individual_copy_cost": 40,
+      "total_literal_frame_rank": 64,
+      "total_term_rank": 40
+    },
+    {
+      "k": 2,
+      "observations": 10,
+      "p": 6,
+      "ports": 60,
+      "term_types": {
+        "(1, 10, 10, 10)": 2,
+        "(1, 2, 10, 10)": 2,
+        "(1, 4, 10, 10)": 2,
+        "(1, 6, 10, 10)": 2,
+        "(1, 8, 10, 10)": 2
+      },
+      "tight_individual_copy_cost": 60,
+      "total_literal_frame_rank": 100,
+      "total_term_rank": 60
+    },
+    {
+      "k": 4,
+      "observations": 38,
+      "p": 4,
+      "ports": 16,
+      "term_types": {
+        "(1, 2, 4, 4)": 2,
+        "(2, 2, 3, 3)": 12,
+        "(3, 2, 2, 2)": 24
+      },
+      "tight_individual_copy_cost": 16,
+      "total_literal_frame_rank": 92,
+      "total_term_rank": 76
+    },
+    {
+      "k": 4,
+      "observations": 104,
+      "p": 5,
+      "ports": 80,
+      "term_types": {
+        "(1, 4, 8, 8)": 2,
+        "(1, 8, 8, 8)": 2,
+        "(2, 3, 6, 6)": 12,
+        "(2, 5, 6, 6)": 16,
+        "(3, 2, 4, 4)": 24,
+        "(3, 4, 4, 4)": 48
+      },
+      "tight_individual_copy_cost": 80,
+      "total_literal_frame_rank": 488,
+      "total_term_rank": 380
+    },
+    {
+      "k": 4,
+      "observations": 206,
+      "p": 6,
+      "ports": 240,
+      "term_types": {
+        "(1, 10, 10, 10)": 2,
+        "(1, 4, 10, 10)": 2,
+        "(1, 8, 10, 10)": 2,
+        "(2, 3, 8, 8)": 12,
+        "(2, 6, 8, 8)": 16,
+        "(2, 7, 8, 8)": 20,
+        "(3, 2, 6, 6)": 24,
+        "(3, 4, 6, 6)": 48,
+        "(3, 6, 6, 6)": 80
+      },
+      "tight_individual_copy_cost": 240,
+      "total_literal_frame_rank": 1356,
+      "total_term_rank": 1036
+    },
+    {
+      "k": 4,
+      "observations": 352,
+      "p": 7,
+      "ports": 560,
+      "term_types": {
+        "(1, 10, 12, 12)": 2,
+        "(1, 12, 12, 12)": 2,
+        "(1, 4, 12, 12)": 2,
+        "(1, 8, 12, 12)": 2,
+        "(2, 3, 10, 10)": 12,
+        "(2, 6, 10, 10)": 16,
+        "(2, 8, 10, 10)": 20,
+        "(2, 9, 10, 10)": 24,
+        "(3, 2, 8, 8)": 24,
+        "(3, 4, 8, 8)": 48,
+        "(3, 6, 8, 8)": 80,
+        "(3, 8, 8, 8)": 120
+      },
+      "tight_individual_copy_cost": 560,
+      "total_literal_frame_rank": 2992,
+      "total_term_rank": 2256
+    }
+  ],
+  "negative_controls": [
+    "odd-k diagonal vanishes",
+    "overlap-zero correction survives certificate",
+    "overlap-two correction survives certificate",
+    "missing observation loses identity rank"
+  ],
+  "scope": "Exact finite rank-certificate and anchored decoder checks; not a physical supplier replay or a substitute for the uniform proof.",
+  "sequential_copy_fragment": {
+    "charged_native_rank": 12,
+    "copy_episodes": 12,
+    "raw_copies_exceeding_native_frame_rank": 11,
+    "scope": "Chronological source-row invariant on a copy-reuse fragment; not a complete restored supplier schedule."
+  },
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
new file mode 100644
index 0000000000..dac5b589b4
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
@@ -0,0 +1,345 @@
+# A weighted COPY obstruction from an integral separating pairing
+
+The scalar decoder can be enlarged to permit arbitrary copied linear
+observations, arbitrary target-dependent readable corrections, and exact
+nonlinear decoding. For the even-size paired-port geometry, this enlargement
+still requires total COPY frame rank at least the number of live targets.
+The same bound survives chronological reuse of previous copies in a specified
+monotone, copy-to-zero protocol. Under the inherited odd-stage rank ledger,
+this already prevents a positive saving, before any scalar or restoration
+costs are added.
+
+This is a conditional obstruction for an explicitly stated physical model.
+It does not exclude the selected E8 supplier, whose primitive integral labels
+have even self-pairing. The source values below are independent scalar inputs;
+geometric dependencies among their address labels do not identify those values.
+
+## 1. Fixed observations and a general pairing
+
+Let \(P\) be a finite set of \(v\) source/target indices. The source vector
+\(x\in\mathbb F_2^P\) is arbitrary. Give source \(S\) a rational label
+\(u_S\) in a common rational vector space \(U\). For each target \(T\), fix
+a rational linear functional \(\ell_T:U\to\mathbb Q\) and a set \(R_T\)
+of individually readable sources. Suppose
+
+\[
+ M_{TS}=\ell_T(u_S)\in\mathbb Z,\qquad
+ M_{TT}\text{ is odd},\qquad
+ M_{TS}=0\quad(S\in R_T).                         \tag{1}
+\]
+
+Let \(H_1,\ldots,H_b\in\mathbb F_2^P\) be any fixed linear observations.
+Every target receives all \(H_i x\) and all individual \(x_S\) with
+\(S\in R_T\). Observation \(i\) has support \(A_i\), is sourced from a
+frame \(F_i\subseteq U\) containing every \(u_S\), \(S\in A_i\), and is
+charged \(r_i=\dim_{\mathbb Q}F_i\). The observations may be repeated,
+dependent, nonsymmetric, globally shared, or obtained by arbitrary recoding.
+
+**Theorem 1.** If every target recovers its own \(x_T\) exactly on every input,
+even using nonlinear postprocessing, then
+
+\[
+                         \sum_{i=1}^b r_i\ge v.       \tag{2}
+\]
+
+**Proof.** A linear coordinate recoverable from fixed linear observations
+must lie in their row span. Indeed, two inputs with the same observations
+differ by a vector in their common kernel. Exact recovery says that the
+desired coordinate vanishes on this kernel, and the kernel's annihilator is
+the observation row space. Apply this separately at each target, including
+its readable individual coordinates. There are binary matrices \(A,B\) with
+
+\[
+                  I_v=AH+B,\qquad
+                  B_{TS}=0\quad(S\notin R_T),          \tag{3}
+\]
+
+where the rows of \(H\) are the observations. Write \(\overline M\) for the
+reduction of the integer matrix \(M\) modulo two. Its diagonal is one and
+\(B\circ\overline M=0\), where \(\circ\) is entrywise multiplication.
+Taking the entrywise product of (3) with \(\overline M\) gives
+
+\[
+ I_v=\sum_{i=1}^b
+       \operatorname{diag}(A_{:i})\,\overline M\,
+       \operatorname{diag}(H_{i:}).                    \tag{4}
+\]
+
+For each summand, deleting its zero columns and then bounding its rank gives
+
+\[
+\begin{aligned}
+ \operatorname{rank}_{\mathbb F_2}
+   (\operatorname{diag}(A_{:i})\overline M
+      \operatorname{diag}(H_{i:}))
+ &\le \operatorname{rank}_{\mathbb F_2}\overline M_{:,A_i}\\
+ &\le \operatorname{rank}_{\mathbb Q}M_{:,A_i}\\
+ &\le \dim_{\mathbb Q}\operatorname{span}\{u_S:S\in A_i\}
+ \le r_i.
+\end{aligned}                                                    \tag{5}
+\]
+
+The second inequality holds because a nonzero integer minor modulo two is
+nonzero over \(\mathbb Q\). The third follows by factoring the matrix through
+the source labels and the linear map \(u\mapsto(\ell_T(u))_T\). Rank
+subadditivity in (4) proves (2). \(\square\)
+
+Symmetry, positivity, and a common Gram form are unnecessary. An integral
+Gram matrix with odd diagonal is a sufficient special case. A common
+injective rational change of source coordinates, with the corresponding
+change of functionals, preserves the hypotheses and frame dimensions.
+Unrelated per-source relabellings are not such a change. Arbitrary rational
+matrix entries cannot simply be reduced modulo two: the integral matrix and
+odd diagonal in (1) are substantive requirements.
+
+The bound is sharp at this observation/frame level. Copying each source
+separately from its line has total rank \(v\). This says nothing about the
+additional cost of completing that implementation as a supplier.
+
+## 2. Sequential reuse through copy-to-zero innovations
+
+Direct support containment need not hold for a later copied row: some of its
+data may already have descended through an earlier COPY. The following
+separate protocol theorem accounts for that reuse.
+
+Use the labels and readable relation in (1). Consider a fixed binary linear
+protocol with these rules:
+
+1. Source \(x_S\) begins at frame \(\operatorname{span}(u_S)\). The source
+   coefficient rows of helpers and targets are initially zero at frame zero.
+2. Ordinary operations are binary ADDs at a common frame and climbs through
+   nested frames. A climb never shrinks the frame.
+3. COPY episode \(i\) reads a row \(w_i\) at frame \(F_i\) into a fresh
+   frame-zero readable register and costs \(\dim F_i\). All earlier copied
+   values may be reused and shared without further charge in this lower bound.
+4. The final source coefficient row at target \(T\) is \(e_T\), at a frame
+   contained in \(\ker\ell_T\). Any native source label in that frame is
+   individually readable; enlarging \(R_T\) to all such labels is allowed.
+
+Arbitrary initial helper dirt and target values are projected away when
+tracking source coefficients. A valid arbitrary-input supplier must still
+satisfy this necessary source-column condition. We also retain erased copies
+as free observations, thereby giving the protocol additional power.
+
+**Theorem 2.** Every protocol with these rules satisfies
+\(\sum_i\dim F_i\ge v\).
+
+**Proof.** Let \(W_i\) be the binary span of source coefficient rows copied
+through episode \(i\). Maintain the invariant that every register at frame
+\(F\), modulo \(W_i\), has a representative supported on labels contained
+in \(F\). Initially this is immediate. A common-frame ADD sums two such
+representatives, and a climb preserves containment.
+
+Just before copy \(i\), choose such a representative \(h_i\) for \(w_i\).
+Then
+
+\[
+ w_i=h_i+\sum_{j<i}c_{ij}w_j,\qquad
+ \{u_S:S\in\operatorname{supp}h_i\}\subseteq F_i.     \tag{6}
+\]
+
+Adding \(w_i\) to the copied span preserves the invariant for every old
+register. The fresh frame-zero copy represents zero modulo the new span, so
+it also satisfies the invariant. The triangular change in (6) implies
+\(\operatorname{span}(h_1,\ldots,h_i)=W_i\).
+
+At completion the invariant at target \(T\) expresses \(e_T\) as a
+combination of the innovations \(h_i\), plus a row supported on labels in
+\(\ker\ell_T\). Thus (3) holds for these innovations. Each has supporting
+label span of dimension at most \(\dim F_i\), and Theorem 1 applies.
+\(\square\)
+
+This class permits arbitrary linear reuse, global sharing and even
+target-to-helper feedback. It contains the selected D/A/scatter/B/C word
+shape when instantiated in a geometry satisfying (1), despite allowing more
+feedback and more free access than that word's actual interface.
+
+It does not cover a primitive charged only for a partial drop to a nonzero
+destination frame, input-dependent nonlinear copy contents or routing, free
+nonmonotone frame changes, or promised dependencies among source values.
+The theorem does not assert that every physical supplier belongs to its
+copy-to-zero class.
+
+## 3. Even paired ports and arbitrary readable corrections
+
+Take any live subset \(P\) of the signed \(k\)-ports on \(p\) coordinate
+pairs. A port chooses \(k\) distinct pairs and one coordinate from each.
+Its label is the incidence vector \(\chi_S\in\mathbb Q^{2p}\). Grant
+target \(T\) every individual source with \(|S\cap T|=1\). Define
+
+\[
+ \ell_T(u)=\chi_T\cdot u-\frac1k\sum_j u_j,
+ \qquad M_{TS}=|S\cap T|-1.                          \tag{7}
+\]
+
+For **every positive even \(k\)**, the diagonal \(k-1\) is odd. Therefore
+Theorems 1 and 2 imply total COPY rank at least \(v=|P|\), including after
+arbitrary punctures. This covers arbitrary recoded proper-star observations,
+all other star degrees including the empty star, and observations not arising
+from stars at all. Corrections may vary independently with both source and
+target. The result is substantially wider than a uniform overlap-class
+decoder restriction.
+
+Indeed, individually readable corrections remove that earlier scalar
+obstruction. For every \(k\ge2\), fix \(a\in T\) and write
+\(z_b(S)=\mathbf1[b\in S]\). Over \(\mathbb F_2\),
+
+\[
+ f_T(z)=\prod_{b\in T}z_b+
+        z_a\prod_{b\in T\setminus\{a\}}(1+z_b)
+       =z_a\sum_{L\subsetneq T\setminus\{a\}}\prod_{b\in L}z_b
+       =\mathbf1[S=T]+\mathbf1[S\cap T=\{a\}].       \tag{8}
+\]
+
+The top terms cancel, leaving only nonempty stars of degrees at most
+\(k-1\). Equation (8) supplies an unpunctured scalar decoder with the
+granted corrections. For even \(k\), it cannot make the requisite physical
+COPY rank smaller than \(v\).
+
+The rational symmetric form \(I-J/k^2\) realizes (7) as pairing with
+\(\chi_T\). When \(2p=k^2\) that form is singular; no admissible frame
+construction is claimed there or elsewhere merely from the formula. The
+obstruction only needs the linear functionals and remains valid in this
+favorable algebraic model. More generally, readability at intersection
+\(a\) gives \(M_{TS}=|S\cap T|-a\), so the same obstruction applies when
+\(k-a\) is odd.
+
+For odd \(k\) with readability at intersection one, (7) has even diagonal
+and this certificate is unavailable. That is consistent with the inherited
+paired-triple construction and the selected E8 norm-two labels. It is an
+escape from this obstruction, not a positive-cost certificate. In particular,
+the known odd-\(k\) binomial decoder identities do not supply their own
+source-branching, restoration or hosting invoice.
+
+## 4. Comparison with the actual selected supplier ledger
+
+This source trace is pinned to main commit
+`91a2094f2e022930069e8cfdc810a3ea1b81cd09`. Its selected certificate names
+Jeremy Kothe's PR #799 complex word, Chafik Boukhalfa's PR #741 frames, and
+DreamingOfClouds' PR #589 bit tuning of eumemic's PR #555 construction. The
+conditional selected value is still \(1661634653669567/10^{18}\).
+Nothing here changes that selection.
+
+The selected bit word has ambient dimension \(h=8\), \(v=111\) sources
+and targets, \(R=439\) dirty helpers, and nine COPY ranks equal to seven:
+\(C=63\). Its independent checker initializes all \(2v+R=661\) scalar
+columns independently and checks restored sources/helpers and final target
+\(y_T+x_T\). The rational labels describe address geometry; they are not
+linear dependency promises on these input values.
+
+The local word compensates dirty helpers in D at frame zero; A acts on
+sources/helpers; scatter uses retained copied totals; B may interleave target
+reads with more source/helper operations; C literally reverses the
+source/helper-destination gates at full frame. Its H1--H5 conditions also
+exclude target feedback into sources/helpers and require exact target-to-target
+identity. All common-frame operations, COPY/ERASE episodes, dirt compensation,
+cleanup and restoration belong to the actual supplier invoice.
+
+The selected local rank profile obeys
+
+\[
+ \sum_r rH_{\rm local}(r)=hR+C+2v(h-1)=5129.         \tag{9}
+\]
+
+With \(L=9=2K+1\), \(K=4\), \(T=32\) replicas, address dimension
+\(m=64\), and \(W=28416\) live data families, its whole-call hosting ledger
+gives
+
+\[
+ D=mW-\sum_r rH_{\rm global}(r)
+   =T(2Kv-LC)=10272.                               \tag{10}
+\]
+
+The bit endpoint is already nonbinding in this selected assembly. An
+isolated bit saving would still require the complex and outer inequalities
+to be reassembled before any claim about the selected exponent.
+
+For a proposed paired-port replacement, **conditionally retain this same
+odd-stage endpoint and whole-call rank accounting**, with general
+\(L=2K+1\), \(m=1+(h-1)L\). Its favorable deficit is
+
+\[
+                  D=T[(L-1)v-LC].                   \tag{11}
+\]
+
+Theorem 2 gives \(C\ge v\) for even paired \(k\), hence
+\(D\le-Tv<0\). Thus the rank mass alone is at least \(mW\). In the
+corresponding normalized rank moment, with recursive child ranks \(0<r<m\),
+
+\[
+ \frac{\sum_r H(r)r^{1-c}}{Wm^{1-c}}
+ =\sum_r\frac{rH(r)}{Wm}(m/r)^c\ge1\qquad(c\ge0).  \tag{12}
+\]
+
+Any inherited bad-branch allowance or other nonnegative charge worsens this
+bound. Consequently this class cannot yield a positive exponent saving under
+(11), even if all preparation, scalar gates, source access, restoration,
+helpers, hosting and finite compilation costs are optimistically granted for
+free. These charges are not actually free: granting them zero is what makes
+the rejection favorable to the proposed construction.
+
+Equation (11) is a stated template hypothesis, not an assertion that every
+new label system has a legal selected-style hosting/compiler implementation.
+The actual selected E8 model does not satisfy the odd-diagonal hypothesis,
+so its \(C=63<111\) is consistent with the theorem.
+
+## 5. Predecessors, verification scope and immutable sources
+
+The underlying same-field entrywise-product rank obstruction is already in
+[`rank-product-core.md`, section 3](../../docs/research/rank-product-core.md).
+It gives the unweighted rank-product inequality and explains why the rational
+and binary fields cannot be silently identified. The result here is its
+**support-sensitive weighted refinement** \(\sum_i r_i\ge v\), using an
+integral rational-to-binary reduction, individually readable corrections,
+nonlinear postprocessing of fixed linear observations, and the chronological
+innovation argument. There is no claim that the entrywise-product rank
+inequality itself is new.
+
+The general binomial incidence expansion is already in
+[`single-intersection.md`](../../docs/research/single-intersection.md).
+The paired-cube geometry is credited to icekylinx and eumemic. The selected
+interface also inherits Zhihao Chen's source-mutability work (PR #425), DaysSky's
+whole-call hosting (PR #442) and later chafreaky compositions, Dylan Crow's
+independent-column checks (PR #370), and DreamingOfClouds' recursive moment
+work (PR #315). Those underlying construction and validation contributions
+are retained, not re-proved by this obstruction.
+
+The all-parameter claims in sections 1--3 are the proofs above. The selected
+numerical comparison is a read-only source trace, not a fresh end-to-end
+supplier replay. Run the independent finite checker from the repository root:
+
+```sh
+python3 -I -O -B research/asymmetric-hypercube-decoder/copy_obstruction_verify.py --self-test
+```
+
+It checks all ports in eight cases: `k=2,p=3..6` and `k=4,p=4..7`. For one
+anchored decoder per target it evaluates the actual star observations,
+readable corrections, each entrywise-product summand, binary/rational ranks
+and the reconstructed identity. Individual source copies check sharpness.
+Four negative controls test the odd-k diagonal, intersection-zero and
+intersection-two corrections, and a missing observation. A twelve-copy prefix
+fragment checks triangular innovation replacement where raw copied supports
+exceed their charged native-frame ranks. That fragment is not a restored
+supplier schedule. The self-test checks isolated optimized relocation,
+corrupt-receipt rejection and output preservation on failure. The expected
+result is `PASS copy_obstruction_verify.py`, with the exact finite receipt in
+[`COPY-OBSTRUCTION-RESULTS.json`](COPY-OBSTRUCTION-RESULTS.json).
+
+These finite checks supplement the proofs; they do not establish the
+all-parameter statements or certify an unimplemented physical supplier.
+
+All files in the following table are read at the pinned main commit above;
+the Git blob makes each individual source immutable.
+
+| Source | Git blob |
+| --- | --- |
+| `certificates/selected-result.json` | `1f107b55a2f045fa66d9c35d658b3b79549f5ba6` |
+| `docs/research/rank-product-core.md` | `9b683864233d79b4d9d982a48bdefd1a1bc875d0` |
+| `docs/research/single-intersection.md` | `7cdf4555e9f9e043debbfe1e3a49fa201234d710` |
+| `research/paired-cube-bit-fast/paired_cube_bit_word.py` | `fc7fb270d7598ea65722ae700676b0b67086a624` |
+| `research/e8-bit-p111-tuned/README.md` | `40dff2216e65ebba0be490ad962e869876a45286` |
+| `research/e8-bit-p111-tuned/tune/README.md` | `5b1554369682c8344d4f0767111d9b2b35eecbec` |
+| `research/e8-bit-p111-tuned/code/xcheck_p.py` | `184f5dcf94a486cc7db91ca4db5865916bf26009` |
+| `research/e8-bit-p111-tuned/code/adapt9p.py` | `96bbc2ba9bb11984736e34db8b65c1a91e8f842e` |
+| `research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py` | `238226c568742dd5723b03eabae564a2eaa2bda9` |
+| `research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py` | `3df12bd632f1fdba825ced57110a1fee82eb2857` |
diff --git a/research/asymmetric-hypercube-decoder/CUBE-OPTIMIZERS.md b/research/asymmetric-hypercube-decoder/CUBE-OPTIMIZERS.md
new file mode 100644
index 0000000000..3f18f88629
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CUBE-OPTIMIZERS.md
@@ -0,0 +1,378 @@
+# Ordinary-cube shortening and exceptional optimal decoders
+
+**Exact structural results; no new κ or paid supplier.** For `q=p-k=2`
+and `k>=4`, this note classifies every subcode attaining the third, fourth,
+or fifth generalized weight of either signed proper-star code. It also
+determines exactly which prescribed target sets attain eleven deletions.
+The proof uses an exact shortening theorem valid for every `k>=2,q>=0`.
+
+This extends the thresholds in [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md).
+All code arithmetic is over `F_2`. A port chooses one signed coordinate
+from each of k distinct pairs among p pairs. The code `C+` is generated by
+all proper stars, including the empty star; `C-` omits the empty star.
+An ordinary cube consists of all sign choices on one fixed set of k pairs.
+Shortening to a set means requiring a codeword to vanish everywhere else,
+then restricting it to that set. Merely projecting a codeword is different.
+
+The common factor
+
+```text
+F(k) = binom(k+2,k) * 2^(k-4) * GaussianBinomial(k,4;2)
+```
+
+counts affine four-dimensional flats inside all ordinary k-cubes. The
+complete optimizer classification is:
+
+| Rank | Minimum support | Optimal subcode on an affine four-flat Q | Count |
+| --- | --- | --- | --- |
+| 3 | 14 | All affine functions on Q vanishing on one affine line L | `120 F(k)` |
+| 4 | 15 | All affine functions on Q vanishing at one point P | `16 F(k)` |
+| 5 | 16 | All affine functions on Q | `F(k)` |
+
+Functions are extended by zero outside Q. For example, at `(p,k)=(6,4)`
+the counts are `(1800,240,15)`; at `(7,5)` they are
+`(156240,20832,1302)`. Each optimizer determines its Q and its zero set
+uniquely.
+
+## Dependencies and attribution
+
+We use the minimum-word classification and second generalized weight in
+[MINIMUM-WORDS.md](MINIMUM-WORDS.md) and
+[EQUALITY-PAIR.md](EQUALITY-PAIR.md), the boundary lemmas in
+[HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md), and the complete `k=2` hierarchy in
+[HIGHER-GRAPH.md](HIGHER-GRAPH.md). In particular:
+
+- At q=2, minimum words are `(k-1)`-stars of weight six, and `d_2=11`.
+- A rank-three subcode has support at least fourteen. If it contains a
+  minimum word, it has support at least fifteen.
+- Every nonzero word in a rank-three support-fourteen subcode has weight
+  eight; its seven nonzero column labels each occur twice.
+- For `k>=4,q=2`, `(d_3,d_4,d_5)=(14,15,16)`.
+- At `k=2,q=2`, `d_3=15`.
+
+The generalized-cube parity and even-face minimum-weight lemma come from
+Luke Mansoor's [PR #732](https://github.com/CrocSwap/integer-mult-bounds/pull/732),
+at `80431a74c31e807581f5c2258c87abe2084caacd`, as credited in the preceding
+notes. The empty-star boundary uses ellipsi2's
+[PR #772](https://github.com/CrocSwap/integer-mult-bounds/pull/772), at
+`02b59e553649c333072b5dd4dfb97e43942efa14`. Reed–Muller duality and its
+minimum-word affine-flat description are standard results; elementary
+proofs of the instances used here are included below. The new claims are
+their exact realization in the signed-port shortening, global localization
+of all exceptional optimizers, and the resulting prescribed-target criterion.
+
+Sam Sung with substantial OpenAI Codex assistance, including separate
+AI-assisted proof review and independent finite verification. Neither is
+a proof-assistant formalization.
+
+## 1. Exact ordinary-cube shortening
+
+Write `RM(d,k)` for evaluations of Boolean polynomials of degree at most d
+on `F_2^k`, with `RM(d,k)=0` when `d<0`. For any ordinary k-cube Q,
+
+```text
+shorten_Q(C+) = RM(k-q-1,k).
+```
+
+For `C-`, the same equality holds when `k>=q+2`. At the boundary `k=q+1`,
+the `C+` shortening is the repetition code; the `C-` shortening is zero
+when k is a power of two and is the repetition code otherwise. For
+`q>=k`, both shortenings are zero.
+
+For necessity, generalized-cube parity forces the restriction f to have
+even sum on every face fixing at most q signs. Indeed, replace each fixed
+sign's alternative with a coordinate from a distinct pair outside Q;
+every other branch is outside the support. These face indicators span
+`RM(q,k)` when `q<k`; when `q>=k`, singleton faces force f to vanish.
+The orthogonal complement of `RM(q,k)` is `RM(k-q-1,k)`: products of
+monomials of combined degree at most `k-1` have even total evaluation,
+giving containment, and the dimensions sum to `2^k`.
+
+For sufficiency, let `z_r` indicate occupancy of an outside original pair
+and put
+
+```text
+M = product_(r outside Q) (1+z_r).
+```
+
+Multiplying M by an inside sign polynomial of degree at most `k-q-1`
+gives a proper-star polynomial supported exactly within Q. This proves
+sufficiency in `C+`. To handle `C-` when `k>=q+2`, its only potentially
+empty term is a constant multiple of M. On the port domain, `M=M z_i`
+for any inside original pair i. The latter has degree `q+1<=k-1` and no
+empty monomial. At `k=q+1`, M differs from the global empty star by
+nonempty proper stars, so membership of M in `C-` is exactly the
+empty-star question. PR #772 supplies the stated power-of-two distinction.
+
+## 2. Two local parity facts
+
+Suppose all support contains a fixed original-pair set K of size `k-2`.
+At q=2 there are four remaining pairs, denoted a,b,c,d. An *edge block*
+ab consists of all ports using K,a,b, with arbitrary signs. Ordinary-cube
+parity says the vector column labels in each block sum to zero.
+
+Each block also has even parity after fixing one core sign. Replace that
+core slot's alternative by a coordinate from a pair outside the block.
+Every added branch omits a universal core pair and therefore vanishes.
+This applies to each scalar component of a subcode's column labels.
+
+### A four-point slice on complementary blocks
+
+Suppose a word is supported on just ab and cd, and its ab restriction h
+has weight four. Then h consists of all four a,b sign choices at one
+fixed signed core K.
+
+First, every face of h fixing one sign has even parity. Core signs were
+handled above. For sign a, replace its alternative by a coordinate from c
+while keeping b ordinary. The added cb branch belongs to neither allowed
+block; similarly for b. Thus the four sign vectors in h sum to zero and
+form an affine two-flat P in `F_2^k`.
+
+Every face fixing two signs also has even parity, except possibly the
+pair `{a,b}`. For two core signs, use c and d as replacements. For a core
+sign and a, use distinct replacements c and d; added branches either omit
+the core sign or use a forbidden residual pair set. The case of b is the
+same.
+
+Parameterize P by two bits. Write `v_j in F_2^2` for the linear part of
+coordinate j. The parity of the product of two coordinates on P is
+`det(v_i,v_j)`. All these determinants vanish except possibly for a,b.
+Since P is two-dimensional, some two coordinate linear parts are
+independent; they must be a,b. Every core linear part is dependent with
+both, so is zero. This proves the claim. Such four-point slices are
+pairwise disjoint or equal.
+
+## 3. A gap in the universal-pair count of weight-eight words
+
+Every q=2 weight-eight word has at least `k-2` universal original pairs.
+Avoiding a nonuniversal pair gives a nonzero word at q=1 of weight at
+least four, so each such pair has degree at most four. If c pairs are
+universal, counting occupied pair incidences gives
+
+```text
+8k <= 8c + 4(k+2-c), hence c>=k-2.
+```
+
+It cannot have exactly `k-1` universal pairs. To see this, split its
+support over the three residual pairs. Each block has at most four
+ports. Summing its two residual signs gives a core-sign function whose
+faces fixing at most two signs have even parity, using the other two
+residual pairs as replacements. A nonzero such function would have
+weight at least eight, so it vanishes. Hence each block has paired signs
+and corresponds to a core-sign set `F_r` of size at most two. Their
+three sizes sum to four.
+
+For distinct residual pairs r,s, `F_r+F_s` has even parity on every face
+fixing at most one core sign: mix r,s in one slot and use the third pair
+as a replacement. Its nonzero weight is therefore at least four. But the
+only size distributions are `(2,2,0)` and `(2,1,1)`, up to order. In the
+first, compare a size-two set with the empty set; in the second, compare
+size two with size one. Each gives a nonzero difference of weight below
+four, a contradiction. Thus the universal-pair count is k or `k-2`.
+
+## 4. Global localization of every rank-three support-fourteen subcode
+
+Let V be such a subcode. All seven nonzero words have weight eight, and
+each nonzero `F_2^3` column label occurs twice. For an original pair i,
+consider the kernel of restriction to ports avoiding i. It cannot have
+dimension two: its support is at least eleven and its nonzero avoidance
+image has support at least four, on disjoint coordinates. Thus its
+dimension is zero, one, or three.
+
+If c pairs are universal for V, count universal-pair incidences over its
+seven nonzero words. A nonglobal pair can be universal for at most one
+word, so
+
+```text
+7(k-2) <= 7c + (p-c) = 6c+k+2, hence c>=k-2.
+```
+
+The case c=k already gives one ordinary cube. If `c=k-1`, Section 3 makes
+each word cube-supported. Words in different residual blocks would be
+disjoint and sum to weight sixteen. Thus all words use one block, again
+giving an ordinary cube. It remains to exclude `c=k-2`.
+
+### Case A: some word lies in one edge block
+
+Let f be supported in ab. Any other cube-supported word lies there too,
+since it meets f in four points. A word g that is not cube-supported has
+degree four at every residual pair. Its intersection with f already
+accounts for four points in ab, saturating a and b; its remaining four
+points must lie in cd.
+
+Let `V_0` be the nonzero subspace supported in ab. If `V=V_0`, localization
+holds. Otherwise every word outside `V_0` has a weight-four cd slice.
+Section 2 makes these slices unsigned blocks at fixed core signs. Distinct
+slices are disjoint, and their sum would have weight eight, so the image
+on cd has dimension at most one. Thus `dim V_0>=2`.
+
+Fix g outside `V_0` and independent `f_1,f_2 in V_0`. For every nonzero
+f in `V_0`, the words g and g+f have weight-four ab slices while f has
+weight eight there. Therefore the ab support of g is contained in the
+support of each of `f_1,f_2,f_1+f_2`. Those three supports have empty
+triple intersection, a contradiction.
+
+### Case B: every word uses all four residual pairs
+
+At each residual pair, all seven nonzero restrictions have weight four.
+The restriction is therefore rank three on seven points, with each
+nonzero column label occurring once. Each residual vertex has union
+degree seven, with distinct incident labels.
+
+Every edge block has label sum zero. A nonempty block cannot have one
+point, or two points with distinct labels, so its size is at least three.
+A weighted graph on four vertices with weighted degrees seven and every
+positive edge weight at least three has only two forms: two complementary
+edges of weight seven, or a four-cycle with alternating weights three and
+four. A degree-one vertex forces its weight-seven edge to isolate both
+endpoints; otherwise all vertices have ordinary degree two.
+
+The complementary case is impossible by Section 2: all nonzero slices
+would be weight-four unsigned blocks, which cannot span rank three while
+keeping all nonzero weights four.
+
+On a size-three block, the distinct nonzero labels sum to zero and give
+the even-weight `[3,2]` code. On a size-four block they span rank three
+and give the even-weight `[4,3]` code. In both cases every pair of positions
+occurs as a weight-two restriction. The core-face parity from Section 2
+then forces those two ports to agree on every core sign. Thus each block
+has one fixed signed core, possibly different between blocks.
+
+Adjacent blocks ab and bc must have the same core signs. If they differ
+at core index i, choose the i-sign of ab, use the mixed slot
+`{a^alpha,c^gamma}`, keep b ordinary, and replace i's alternative by a
+coordinate from d. All replacement branches omit universal pair i;
+the bc block has the wrong i-sign. Generalized-cube parity therefore
+forces the labels in every a-sign slice of ab to sum to zero. A size-three
+block has a singleton slice; a size-four block has two distinct labels
+in each slice. Either is a contradiction. Connectivity makes all four
+blocks share one signed core.
+
+Shortening to this signed core gives `C+_(4,2)`, whose third generalized
+weight is fifteen. It cannot contain V of support fourteen. The signed
+shortening assertion follows directly from derivatives: for a word
+supported on `i+`, its `i-` slice is zero, so its `i+` slice equals the
+signed derivative, lowering degree, p and k by one. Conversely multiply
+a smaller proper-star polynomial by the fixed signed coordinate. Iterate
+over the core. A nonempty fixed core also makes every lifted monomial
+nonempty, so this shortening is the same for `C+` and `C-`.
+
+Both cases are excluded. Every optimal rank-three subcode lies in one
+ordinary k-cube.
+
+## 5. Affine classification at ranks three, four and five
+
+The exact shortened code is now `RM(k-3,k)`. Its minimum words have
+weight eight and are indicators of affine three-flats. Here is an
+elementary proof of the standard minimum-word description. A nonzero
+degree-r Boolean polynomial in m variables has weight at least
+`d=2^(m-r)`, by the even-face lemma. If it attains d and t is a difference
+of two support points, its translated derivative has degree at most
+`r-1`. Were it nonzero, its weight would be at least 2d; the intersecting
+supports of the two translates give strictly less than 2d. Therefore the
+derivative vanishes. Translating one support point to zero makes the
+support closed under addition, so it is a linear `(m-r)`-space. Conversely
+an affine `(m-r)`-flat indicator is a product of r affine equations.
+Constants and the degree-m boundary are immediate.
+
+We also need exact shortening to an affine four-flat Q. An invertible
+affine change of coordinates preserves degree and sends Q to
+`x_5=...=x_k=0`. A function supported there has unique multilinear form
+
+```text
+product_(j=5..k)(1+x_j) * h(x_1,x_2,x_3,x_4).
+```
+
+For nonzero h its degree is `k-4+deg(h)`, so membership in `RM(k-3,k)`
+is equivalent to `deg(h)<=1`. The shortening is exactly `RM(1,4)`.
+
+For rank three, two independent support flats A,B meet in four points;
+their affine hull is a unique four-flat Q. Their symmetric difference
+is another three-flat inside Q. A third support flat C meets each of
+`A,B,A+B` in four points. If C were not contained in Q, its intersection
+with Q would have dimension at most two. Its intersections with A and B
+would then be the same plane, leaving no intersection with their
+symmetric difference. Hence all words lie in Q. Their affine functions
+form a rank-three space with no nonzero constant, whose common zero set
+is an affine line L. This is precisely the first family in the table.
+
+For rank four of support fifteen, its fifteen rank-three hyperplanes
+have supports summing to `14*15=210`. Each is at least fourteen, so every
+one attains fourteen. Shared nonzero words force any two such hyperplanes
+into the same ordinary cube. Every nonzero word has weight eight. Taking
+two independent words in one hyperplane and any word outside it, the
+preceding flat argument puts all words into one Q. The rank-four affine
+space has one common zero P, giving the second family.
+
+For rank five of support sixteen, its 31 rank-four hyperplanes have
+supports fifteen or sixteen and total `30*16=480`. Exactly sixteen have
+support fifteen. Two such hyperplanes share nonzero words and together
+span V, putting V in one ordinary cube. One already has support `Q\{P}`.
+The full support can add only one point. If that point c were outside Q,
+an affine function vanishing on Q but equal to one at c would pair oddly
+with a word using c. This contradicts orthogonality of `RM(k-3,k)` to
+linear functions. Thus V is the full five-dimensional shortening on Q.
+
+Finally, an ordinary k-cube has `2^(k-4) GaussianBinomial(k,4;2)` affine
+four-flats. Each has 120 affine lines and sixteen points. Multiplying by
+the `binom(k+2,k)` ordinary cubes proves the counts stated above.
+
+## 6. Prescribed targets attaining eleven deletions
+
+For `q=2,k>=4` and `r in {3,4,5}`, r distinct prescribed targets attain
+`d_r-r=11` deletions if and only if they use the same k original pairs
+and their sign vectors are affinely independent.
+
+This is a statement for observation rows in the proper-star code. Applying
+it to the original uniform overlap-corrected decoder retains the existing
+power-of-two-k hypothesis, unless its observation model already absorbs
+those corrections. Arbitrary independently weighted cap-readable sources
+form a larger model; this deletion theorem does not bound that model.
+
+Necessity follows from the optimizer classification. An eleven-deletion
+decoder supplies an r-dimensional subcode supported within the targets
+and deletions, with rank r on the target columns. It must attain `d_r`.
+Its columns are affine evaluations on one Q, so an affine dependence
+among targets would contradict rank r.
+
+For sufficiency, their affine hull A has dimension `r-1`; extend it to a
+four-flat Q inside the common k-cube. For r=3, take coordinates with
+`A=<e_1,e_2>` and choose `L=e_4+<e_3>`. The three functions
+`x_1,x_2,1+x_4` vanish on L and have full rank on any affine basis of A.
+For r=4, choose P outside the three-flat A; functions vanishing at P
+restrict isomorphically to all affine functions on A. For r=5, use all
+affine functions on Q. In each case delete the support outside the
+targets, and change row basis to obtain retained unit vectors.
+
+Three distinct binary points are automatically affinely independent.
+Four distinct points are independent exactly when their XOR is nonzero.
+For five points use rank five of their augmented columns `(1,t)`.
+Failure proves that more than eleven deletions are required; the larger
+optimal budget is not determined here.
+
+## Verification boundary
+
+Run these commands from the repository root with Python 3.10+:
+
+```sh
+for check in shortening optimizer block; do
+  python3 -I -O -B "research/asymmetric-hypercube-decoder/${check}_verify.py" --self-test || exit
+done
+```
+
+Each prints `PASS` followed by its filename. The independently generated
+receipts are [SHORTENING-RESULTS.json](SHORTENING-RESULTS.json),
+[OPTIMIZER-RESULTS.json](OPTIMIZER-RESULTS.json), and
+[BLOCK-RESULTS.json](BLOCK-RESULTS.json). The scripts respectively check
+42 full-generator ordinary-cube shortenings; all 187 rank-three through
+rank-five subspaces and all 6,748 target sets of `RM(1,4)`; and six
+complementary-block/four-cycle models, with exact coverage stated in the
+[README](README.md#reproduce-the-current-campaign-milestone).
+
+The block checker is a separate full-generator/syndrome implementation.
+It rejects projected stars that are not shortened words and a false
+rank-three constant-weight cycle that passes ordinary-cube parity but
+fails global membership. All self-tests also verify receipt corruption
+rejection and preservation of an existing output on failure. These finite
+checks supplement the written proof; they do not replace its global
+localization argument. This is a milestone in the ongoing campaign.
diff --git a/research/asymmetric-hypercube-decoder/FOURTH-WEIGHT.md b/research/asymmetric-hypercube-decoder/FOURTH-WEIGHT.md
new file mode 100644
index 0000000000..f330310e56
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/FOURTH-WEIGHT.md
@@ -0,0 +1,722 @@
+# The fourth generalized weight and all optimal four-target subcodes
+
+**Exact scalar thresholds; no new κ.** For every `k>=2` and `q=p-k>=3`, this
+note determines the fourth generalized Hamming weight of both signed
+proper-star codes and classifies every attaining subcode:
+
+```text
+d_4(C^-_{p,k}) = d_4(C^+_{p,k}) = 8q+2.
+```
+
+Every optimum is the span of four minimum stars whose defining faces share a
+signed `(k-2)`-face and add four signed coordinates from four distinct
+original pairs. The exact number of optimal subcodes is
+
+```text
+2^(k+2) binom(p,k-2) binom(q+2,4).
+```
+
+Four selectable targets therefore require exactly `8q-2` deletions in the
+scalar star-information model. Four prescribed targets attain that budget
+precisely when one of these four-star evaluation matrices is invertible on
+the target set. The final section makes this criterion and its decoding
+construction explicit.
+
+## Notation, inputs, and attribution
+
+A port chooses one signed coordinate from each of k distinct original pairs
+among p pairs. For a signed partial port L, the star `m_L` indicates
+containment of L. The binary code `C^+_{p,k}` spans the stars with
+`0<=|L|<k`; `C^-_{p,k}` omits the empty star. For a binary code C, `d_r(C)`
+is the minimum support union of an r-dimensional subcode. All dimensions and
+linear combinations are over `F_2`.
+
+We prove lower bounds in `C^+` and construct witnesses in `C^-`, so the
+results hold for both. Put `d=2q+2` and `s=4q+2`. We use these previously
+proved results:
+
+- [MINIMUM-WORDS.md](MINIMUM-WORDS.md) gives minimum distance d and the
+  classification of minimum words as `(k-1)`-stars for `q>=2`.
+- [EQUALITY-PAIR.md](EQUALITY-PAIR.md) gives `d_2=4q+3` and classifies
+  optimal planes as spans of two adjacent minimum stars. Distinct
+  minimum stars intersect in at most one port.
+- [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) gives the complete spectral gap:
+  every nonminimum nonzero word has weight at least s for `q>=3`.
+  It also gives `d_3=6q+3` for `q>=3`; at `q=2`, it gives `d_3>=14`,
+  improved to fifteen for a subcode containing a minimum word.
+  Strict monotonicity consequently gives `d_4>=15` at `q=2`.
+- [HIGHER-GRAPH.md](HIGHER-GRAPH.md) gives the complete `k=2` hierarchy
+  and the retained-graph rank formula used in the boundary proofs.
+
+The generalized-cube and even-face parity arguments originate in Luke
+Mansoor's [PR
+#732](https://github.com/CrocSwap/integer-mult-bounds/pull/732), inspected
+at `80431a74c31e807581f5c2258c87abe2084caacd`; the earlier notes record the
+other credited inputs. A generalized cube has k slots, each containing two
+distinct signed coordinates, and original pair indices used by different
+slots are disjoint. All its choices are therefore valid ports. Every proper
+star has even parity on this cube. A binary function whose every face fixing
+at most t signs has even parity is either zero or has weight at least
+`2^(t+1)`. If t reaches the number of sign variables, singleton faces force
+the function to vanish. Ordinary cubes partition the port set, so every
+codeword has even weight.
+
+Avoiding an original pair restricts the code to `C^+_{p-1,k}` and decreases
+q by one. A pair is *universal* for a word or subcode when every port in its
+support uses that pair. Its *degree* in a support union is the number of
+those ports using it. Label each port by the vector of basis evaluations of
+a subcode; vector parity means parity in every component.
+
+Every binary r-dimensional subcode has sum of nonzero word weights `2^(r-1)`
+times its union size. If a subcode of dimension r has support A, an affine
+coset of it has total weight
+
+```text
+2^(r-1)|A| + 2^r wt(the common restriction outside A).
+```
+
+These averaging identities will also be used for restriction images.
+
+## The attaining construction
+
+Fix a signed face K of size `k-2`, and four signed coordinates `a,b,c,e`
+from distinct original pairs outside K. The four stars defined by `K+a`,
+`K+b`, `K+c`, and `K+e` have support union
+
+```text
+4(2q+2) - binom(4,2) = 8q+2.
+```
+
+Each pair meets in one distinct port, and no three meet. There are `q+2>=5`
+residual original pairs; an unused pair supplies a private port for each
+generator. The four rows are therefore independent and belong to `C^-`. This
+proves the upper bound.
+
+## Preliminary lemmas
+
+### Signed-face shortening
+
+For any word w, the signed derivative at an original pair i is
+
+    Delta_i w(R) = w(R union {i+}) + w(R union {i-}).
+
+It lies in C-plus_(p-1,k-1): monomials avoiding i cancel, and monomials
+containing one sign of i lose that coordinate and have degree at most k-2.
+If every port in the support of w contains one fixed signed coordinate i+,
+its minus slice is zero, so its plus slice equals this derivative. Iteration
+shows that shortening to a fixed signed face of size c is exactly the lifted
+code C-plus_(p-c,k-c). Inclusion one way follows from derivatives, and
+multiplication by the fixed face gives the converse.
+
+### Small residual blocks with a common original core
+
+The [small common-core proof](HIGHER-WEIGHTS.md#small-common-core-lemma)
+uses residual sign-sum functions H_r and collapsed block functions F_r. We
+need two immediate extensions. If q>=3 and V has a universal original core K
+of size k-1, with each residual-pair block of its union of size at most
+seven, then
+
+    |supp(V)| >= 2(q+1) dim V.
+
+Indeed the sign-sum H_r in that proof has each scalar component of weight at
+most seven, below 2^(q+1). Hence the two residual signs have equal vector
+labels. Every block has even size, so is actually at most six, and the cited
+common-core lemma applies.
+
+For q=3 we also use a weaker statement with blocks at most ten: their
+sign-sum still vanishes, since ten<16. Thus all blocks, and their total
+union, have even size; identical labels across different blocks are not
+asserted at this larger size.
+
+### Shortening to the fifteen-port q=2 triangle
+
+Consider the union of three minimum stars having a common signed (k-2)-core
+and three signed residual coordinates from distinct pairs, at q=2. Its size
+is fifteen. The full C-plus code shortened to this union has dimension
+exactly three.
+
+By signed-face shortening, reduce to the k=2 code on four original pairs,
+whose graph has eight vertices and omits the four matched edges. The
+triangle union is all edges incident to the three selected vertices. Every
+C-plus row is c plus a graph cut (vertex potential sum). To vanish outside
+the union, its restriction to the graph induced by the other five vertices
+is zero. That graph is connected and has a triangle. The triangle forces
+c=0; connectivity forces all five unselected vertex potentials equal. Modulo
+the global constant potential, only the three selected potentials remain.
+This proves the asserted shortening dimension.
+
+## Universal pair-kernel exclusions
+
+Suppose V has dimension four and union U of size n<=8q+1. For each original
+pair r, let L_r be the kernel of restriction to ports avoiding r. Its
+support uses r; its image avoids r, so their supports are disjoint.
+
+A two-dimensional kernel would give
+
+    n >= d_2(q)+d_2(q-1) = (4q+3)+(4q-1) = 8q+2.
+
+A three-dimensional kernel would give
+
+    n >= d_3(q)+d_1(q-1) = (6q+3)+2q = 8q+3.
+
+A one-dimensional kernel generated by a nonminimum word has weight at least
+4q+2. For q=3 its three-dimensional image has support at least 14, giving
+n>=28>25. For q>=4 its image has support at least 6q-3, giving
+n>=10q-1>8q+1. Therefore every pair restriction has kernel zero, the span of
+a minimum star, or all V.
+
+At most three minimum words lie in V: any four would have union at least
+4d-6=8q+2, by pair intersections at most one. If a pair is universal for two
+minimum words, its kernel has dimension at least two and hence is all V. In
+particular it is universal for every minimum word in V.
+
+## Base q=3, by induction on k
+
+At k=2 the complete graph-code hierarchy gives d_4=26. Assume the result for
+smaller k when needed below. Suppose n<=25. Minimum words have weight 8 and
+other words at least 14. If V had at most one minimum word, its fifteen
+nonzero weights would sum to at least 8+14*14=204>8*25. Thus V has either
+two or three minimum words.
+
+### Exactly two minimum words
+
+Call them f,g. Their weights contribute 16, and the other thirteen words
+contribute at least 182. Hence n>=ceil(198/8)=25, so n=25. Exactly one word
+v has weight 16 and the other twelve nonminimum words have weight 14.
+
+We first prove v=f+g and determine the column multiplicities. Choose a basis
+of V, identifying coefficient vectors with F_2^4, and write m_a for the
+number of columns with a nonzero evaluation label a. For a nonzero a,
+Fourier inversion of the word weights gives
+
+    8m_a = 14 + 6(-1)^(f.a) + 6(-1)^(g.a) - 2(-1)^(v.a).
+
+Integrality forces the three signs on the right to have product +1: after
+dividing by two and reducing modulo four, their sum must be 3 modulo 4. Thus
+(-1)^(v.a)=(-1)^((f+g).a) for every a, proving v=f+g. In particular, f and g
+have disjoint supports A_f,A_g, each of size 8.
+
+Use f,g as the first two basis vectors. The same formula gives m_a=3 when
+(a_f,a_g)=(0,0), m_a=2 when exactly one of these bits is 1, and m_a=0 when
+both are 1. (The zero label is excluded.) Thus the remaining set B=U without
+(A_f union A_g) has size 9. On either eight-point minimum-star support, each
+of the four possible remaining two-bit labels appears exactly twice.
+Consequently any word of V restricts to that support with weight zero, four,
+or eight.
+
+Let K_f,K_g be the original-pair cores of the two stars.
+
+If K_f=K_g, those k-1 pairs are universal for all V by the kernel
+exclusions. Every outside pair has injective avoidance restriction, whose
+four-dimensional q=2 image has support at least 15. Its degree in U is
+therefore at most 10. The weaker common-core sign-pairing observation makes
+n even, contradicting n=25.
+
+Otherwise put c=|K_f intersect K_g| and u=k-1-c>=1. A pair a in K_f without
+K_g has degree at least 8+2=10 in U. Its kernel is <f>, and its
+three-dimensional q=2 image contains the restriction of g, a minimum word of
+weight 6, so has support at least 15. Thus its degree is exactly 10, all
+accounted for by f and g. The set B avoids a. The same argument applies to
+every pair in the symmetric difference of the two cores.
+
+The c common pairs are universal for V. Hence each B-port must use u+1
+further pairs while avoiding the 2u pairs in the core symmetric difference.
+There are only 4-u available pairs outside both cores. Since B is nonempty,
+
+    u+1 <= 4-u,
+
+which forces u=1. Write the common original-pair core as K, of size k-2, and
+the two differing pairs as a,b. The signed faces defining f,g therefore have
+the form K(signs 1)+a and K(signs 2)+b. Their supports are disjoint, so some
+i in K has opposite prescribed signs in the two faces.
+
+Apply Delta_i to V. Pair i is universal for all V, so its image union has
+size at most 25. We claim Delta_i is injective. If w lies in its kernel, its
+values on each two-port i-sign fiber agree. For a port of A_f, the
+opposite-i port cannot lie in A_f. It cannot lie in B either, because B
+avoids pair a. It can lie in A_g at at most one port: the f-port must extend
+by g's prescribed signed b-coordinate, and all the other core signs must
+agree. Thus w restricts to A_f with weight at most one. The column-label
+calculation above forces that restriction to be zero. Similarly it is zero
+on A_g. A nonzero such w would therefore be supported on B of size 9; it is
+neither minimum word f nor g, contrary to the gap 14.
+
+The derivative is consequently a four-dimensional subcode of
+C-plus_(p-1,k-1), still at q=3, with support at most 25. This contradicts
+the induction on k. (This subcase automatically has k>=3 because i exists.)
+
+### Exactly three minimum words
+
+Let their original-pair cores have common intersection K of size c. No pair
+can occur in exactly two of the three cores, by the kernel exclusions. Thus
+each core consists of K plus a disjoint set of u=k-1-c private original
+pairs, with all three private sets of the same size.
+
+If u=0, all three stars have the same original-pair core and different
+signed cores, so their supports are disjoint and have total size 24. All
+outside-pair avoidance maps are injective, giving block degrees at most 10.
+Sign-pairing makes n even. Since 24<=n<=25, n=24 and the union is exactly
+the three stars. Every residual block then has size 6. The common-core lemma
+would require n>=8*4=32, a contradiction.
+
+Suppose u>=1 and choose a pair r private to the first star f. Its avoidance
+image has dimension three and contains either other minimum star, so the q=2
+conditional bound gives degree_r(U)<=n-15<=10. The first star supplies 8
+ports using r; each other star supplies 2. Their mutual intersection cannot
+use r, because r is in neither defining face. Each can overlap f in at most
+one port. Hence the union degree is at least 10, with equality only when f
+intersects both other stars. Repeating for private pairs of the other stars
+shows all three are pairwise adjacent. This forces u=1, a common signed
+(k-2)-core, and three distinct residual signed coordinates a,b,c. (The
+alternative common-k-port configuration would have some original pair in
+exactly two cores, already excluded.)
+
+Their union A is the triangle of size 21, and each selected residual pair
+has degree 10 in A. The preceding bound forces n=25 and no extra port in B=U
+without A to use any of a,b,c. All U ports contain K's original pair
+indices, so each of the four extra ports uses both of the other two residual
+pairs d,e.
+
+Avoiding d is injective: its kernel contains no minimum word, and all other
+nonzero proper kernel types were excluded. The image has dimension four, but
+is supported on the fifteen-port q=2 triangle A restricted away from d. That
+shortening has dimension three by the preliminary lemma. This final
+contradiction proves the q=3 base for every k.
+
+## Induction step q>=4
+
+Assume d_4(q-1)=8q-6 for every k>=2. An injective pair-avoidance map now
+gives degree_r(U)<=n-(8q-6)<=7. A pair whose kernel is generated by a
+minimum star has degree at most n-d_3(q-1)<=8q+1-(6q-3)=d+2. Let m be the
+number of minimum words in V, between zero and three.
+
+### m=0
+
+Every pair is either universal for all V or has injective avoidance map. Let
+c be the number of universal pairs and t=k-c. The fifteen nonzero weights
+are each at least s, so n>=ceil(15s/8). Incidence counting gives
+
+    t(n-7) <= 7q.
+
+The lower bound on n implies 2(n-7)>7q, so t<=1. If t=0, all support lies in
+one ordinary cube. Every nonzero word has weight at least 2^(q+1), or
+singleton faces force it zero. Averaging gives n>=15*2^(q-2)>8q+1 for q>=4.
+If t=1, all residual blocks have size at most 7. The extended common-core
+lemma gives n>=4d=8q+8, also impossible.
+
+### m=1
+
+Let f be the unique minimum star, A its support, and B=U without A. The
+restriction of V outside A has kernel <f>, hence dimension three. Each
+nonzero outside word comes from a coset {h,h+f}, both nonminimum. The coset
+sum identity gives
+
+    2s <= 2 wt(h outside A)+d,
+
+so every such image word has weight at least 3q+1. Summing its seven words,
+
+    |B| >= ceil(7(3q+1)/4).
+
+Let K be the c original pairs universal for all V, and t=k-c. They are among
+the k-1 core pairs of f. Each of the other t-1 core pairs has kernel <f>,
+and therefore degree at most 2 in B. Each of the q+1 pairs outside f's core
+has injective avoidance, and has degree at most 7-2=5 in B. Counting the t
+remaining pair incidences of every B-port gives
+
+    t|B| <= 2(t-1)+5(q+1),
+    t(|B|-2) <= 5q+3.
+
+The lower bound on |B| forces t<=1, because 2(|B|-2)>5q+3. Thus t=1, all
+f-core pairs are universal for V, and the residual blocks have size at most
+7. The extended common-core lemma again gives n>=4d>8q+1.
+
+### m=2
+
+Let the minimum words be f,g, with supports meeting in e in {0,1} points.
+Their union A has size 2d-e. Put B=U without A. The subcode <f,g> is the
+full kernel of restriction outside A: any independent word supported there
+would form a three-dimensional subcode supported on A, but
+|A|<=4q+4<d_3(q)=6q+3 for q>=3. Thus the outside image has dimension two.
+Each of its three nonzero words comes from four nonminimum words. The coset
+identity gives its weight at least
+
+    s-|A|/2 = 2q+e/2,
+
+hence at least 2q+e. Their three weights sum to 2|B|, so
+
+    |B| >= 3q+2e.
+
+If the two original-pair cores coincide, they are universal for V and the
+outside blocks have degree at most 7; common-core contradiction applies.
+Otherwise let their intersection size be c=k-1-u, with u>=1. These c pairs
+are universal for V. For each of the 2u core-symmetric-difference pairs, the
+minimum-star kernel bound is d+2, while A already has d+2-e ports using it.
+Its degree in B is at most e. For each of the q+1-u pairs outside both
+cores, A has degree 4 and U has degree at most 7, so B has degree at most 3.
+Every B-port has u+1 slots outside the common core. Therefore
+
+    (u+1)|B| <= 2u e + 3(q+1-u).
+
+If e=0, the left side is at least 6q while the right is at most 3q. If e=1,
+the stars are adjacent, so u=1; the left side is at least 6q+4 while the
+right is 3q+2. Both cases are impossible.
+
+### m=3
+
+As in the q=3 base, a pair belongs to zero, one, or all three minimum-star
+cores. Write their common original core as K, and each private core size as
+u. If u=0, common-core contradiction applies directly.
+
+If u>=1, a pair private to one minimum star has union degree at most d+2,
+while that star contributes d and the other two contribute 2 each. The
+latter two cannot intersect on that pair. Thus equality forces the first
+star to intersect each of the other two. Consequently all three stars are
+pairwise adjacent, u=1, and they have a common signed (k-2)-core with three
+distinct signed residual coordinates a,b,c. Their support A is the triangle
+of size 3d-3=6q+3. The selected residual-pair degrees are exactly d+2, so
+B=U without A uses none of a,b,c.
+
+For every one of the q-1 other residual pairs, A has degree 6 while U has
+degree at most 7. Hence B has degree at most 1 there. Every B-port uses two
+of those pairs, giving 2|B| <= q-1.
+
+On the other hand, the single coset of the three-dimensional triangle
+subcode outside it contains eight nonminimum words, each of weight at least
+s. Its total weight is 4|A|+8|B|, so
+
+    |B| >= ceil(s-|A|/2) = q+1.
+
+This is incompatible with the incidence bound. All four cases are excluded,
+completing the induction and the fourth-weight proof.
+
+## Equality: pair kernels at support N=8q+2
+
+At support N=8q+2, a three-dimensional avoidance kernel is still impossible,
+since d_3(q)+d_1(q-1)=8q+3. A one-dimensional nonminimum kernel is
+impossible since its support plus the three-dimensional image has size at
+least 28 when q=3, and at least (4q+2)+(6q-3)=10q-1>N when q>=4. Thus kernel
+dimensions are 0,1,2,4, with a one-dimensional kernel generated by a minimum
+star.
+
+Suppose some pair r has a two-dimensional kernel L. The kernel and image
+lower bounds sum exactly to N:
+
+    d_2(q)+d_2(q-1)=(4q+3)+(4q-1)=N.
+
+Therefore both are optimal planes and every occupied port using r lies in
+supp(L). The two minimum stars in L contribute two minimum words of V. The
+avoidance image has two distinct minimum words, each of weight 2q. For
+either such image word, its four lifts form a coset of L. Their sum of
+weights is 2(4q+3)+4(2q)=16q+6.
+
+If all four lifts were nonminimum, the gap would give at least
+4(4q+2)=16q+8. Hence each image minimum word has a minimum lift. These two
+lifts are independent modulo L. Consequently V contains four independent
+minimum stars.
+
+## Equality for q>=4: excluding fewer than four minimum words
+
+For the rest of this section assume q>=4 and that no pair has a
+two-dimensional kernel. An injective avoidance map has union degree at most
+N-d_4(q-1)=8. A minimum-star kernel gives degree at most N-d_3(q-1)=d+3.
+
+A common original core of size k-1 with residual blocks at most 8 is again
+rigid when q>=4. Sign sums have weight at most 8<2^(q+1), so signs pair;
+collapsed blocks have at most 4 positions. Differences of two collapsed
+blocks have weight at most 8<2^q, hence vanish by even-face parity. All
+blocks are identical and support has size at least d*dim(V)=4d>N.
+
+If there are no minimum words, the gap gives n=N>=ceil(15s/8), while the
+incidence inequality for t nonuniversal slots is t(N-8)<=8q. It forces t<=1
+for q>=4. The t=0 single-cube alternative is excluded by the same averaged
+even-face lower bound as before; t=1 is excluded by the preceding
+common-core rigidity.
+
+If there is one minimum star, the outside support B still has size at least
+ceil(7(3q+1)/4). The global-core incidence inequality becomes
+
+    t(|B|-3) <= 6q+3,
+
+because nonglobal core pairs have B-degree at most 3 and the q+1 outside
+pairs at most 6. This forces t<=1, hence common-core rigidity excludes it.
+
+If there are two minimum stars intersecting in e in {0,1}, the same coset
+argument gives |B|>=3q+2e outside their union. Coincident original cores are
+excluded by common-core rigidity. Otherwise use core difference u>=1. The
+symmetric-difference pairs now have B-degree at most 1+e; the outside pairs
+at most 4. Thus
+
+    (u+1)|B| <= 2u(1+e)+4(q+1-u)
+              = 4q+4+2u(e-1).
+
+For e=0, the left is at least 6q and the right at most 4q+2. For e=1, u=1,
+and the left is at least 6q+4 while the right is 4q+4. Both are impossible.
+
+If there are three minimum stars, each original pair belongs to zero, one,
+or all three defining cores. Let the common core have size c and private
+core sizes u=k-1-c. If u=0, common-core rigidity excludes it. If u>=1, the
+degree bound d+3 means each minimum star must intersect at least one other:
+its private pair has union degree
+
+    d+4-(number of its intersections with the other two stars).
+
+An intersection forces u=1, because the private original-pair sets are
+disjoint. Then every core has the same k-2 original pairs plus one distinct
+private pair. Two stars intersect precisely when their common-core signs
+agree. Thus their intersection graph is a disjoint union of cliques. A
+three-vertex graph with no isolated vertex must be a triangle, so all three
+stars share the same signed core.
+
+Their union A has size 6q+3. The nontrivial coset of their span still forces
+|B|>=q+1. Each of the three selected residual pairs has degree d+2 in A and
+at most d+3 in V, giving B-degree at most 1. Each of the q-1 other residual
+pairs has A-degree 6 and V-degree at most 8, giving B-degree at most 2.
+Every B-port uses two residual pairs, so
+
+    2|B| <= 3+2(q-1)=2q+1,
+
+contradicting |B|>=q+1. This excludes all cases with at most three minima.
+
+## Equality at q=3, by induction on k
+
+It remains to exclude optimal subcodes with fewer than four minimum words at
+q=3. We use induction on k.
+
+### Base k=2
+
+Here p=5 and the paired graph has ten vertices and forty edges. A subcode of
+dimension four with support 26 leaves a retained graph H with 14 edges. The
+graph-code rank calculation requires either at least five components, or a
+bipartite graph with at least four components. The bipartite option has at
+most floor(7^2/4)=12 edges, so is impossible. For p=5, a set of v vertices
+induces at most `f(v)=binom(v,2)-max(0,v-5)` edges. The component
+concentration bound in HIGHER-GRAPH.md shows that at least six components
+would have at most f(5)=10 edges. With five components and two nonsingleton
+components, it gives at most f(5)+f(2)=11 edges. Thus the components must
+have sizes 6,1,1,1,1. The large component has fourteen edges, so is an
+induced six-vertex paired graph with precisely one missing matched edge.
+Consequently the four isolates lie in distinct original pairs. The full
+shortening on the deleted edges has dimension four and is exactly their four
+singleton-star span. This proves the base.
+
+### Preliminary reductions at n=26
+
+The dimension-two pair-kernel argument in the preceding equality section
+also works at q=3: its optimal kernel and image supply four independent
+minimum stars by the same four-lift weight average. Hence assume there is no
+such pair kernel. Dimensions three and one-nonminimum remain excluded. Every
+pair has kernel zero, one minimum-star span, or all V.
+
+Injective avoidance has four-dimensional q=2 image of support at least 15,
+so its degree is at most 11. A minimum-star kernel has three-dimensional q=2
+image of support at least 14, hence degree at most 12. If another minimum
+word survives that avoidance, the conditional bound 15 improves the degree
+to at most 11.
+
+At most four minimum words occur in V. Four already imply the desired
+four-star geometry by the argument in the next section. No minima is
+impossible because 15*14>8*26. Thus it suffices to exclude one, two, or
+three minimum words.
+
+### A common-core parity observation at support 26
+
+Suppose all V has a universal original core of size k-1 and contains at
+least one minimum star. Each residual block has size at most 11, since
+outside-core avoidance is injective. Its sign sum vanishes by the q=3
+even-face bound 16. Each block therefore has even size at most 10. Collapse
+its residual sign pairs to a vector function F_r on core signs. The four
+collapsed support sizes sum 13, so a smallest one has size at most 3 and all
+others have size at most 5.
+
+All blocks contain the core-sign point of the fixed minimum star. The union
+of a smallest support and any other therefore has size at most 3+5-1=7. The
+difference F_r+F_s has even parity on every face fixing at most two core
+signs, and a nonzero scalar component would need weight 8. Thus each block
+equals the smallest block. Their four sizes would sum to a multiple of four,
+contrary to 13. This excludes such a common core.
+
+### One minimum word
+
+Call the minimum word f, of weight 8. The other fourteen words have weight
+at least 14. Their total weight is 208, so the excess above 8+14*14=204 is
+4. There are only two possible spectra: one word of weight 18 with the rest
+14, or two words of weight 16 with the rest 14.
+
+For any nonzero column label a, Fourier inversion in the first case gives
+
+    8m_a=14+6(-1)^(f.a)-4(-1)^(v.a).
+
+Whenever f.a=1, the numerator is 4 or 12, contradicting integrality. In the
+second case, with weight 16 words v,w, inversion gives
+
+    8m_a=14+6(-1)^(f.a)-2(-1)^(v.a)-2(-1)^(w.a).
+
+For f.a=0, integrality forces the last two signs equal; for f.a=1, it forces
+them opposite. Thus v+w=f. Moreover every one of the eight labels with f.a=1
+occurs exactly once. The eight columns on A=supp(f) are therefore all the
+points of one affine hyperplane in F_2^4 and span the full dual space. In
+particular they are distinct, and a word vanishing on A is zero. The
+remaining support B has size 18.
+
+Let c be the number of global universal original pairs and t=k-c. Each of
+the t-1 nonglobal core pairs of f has B-degree at most 12-8=4. Each of the
+four pairs outside f's core has B-degree at most 11-2=9. Therefore
+
+    18t <= 4(t-1)+4*9,    or    14t<=32.
+
+Thus t is one or two. The common-core observation excludes t=1. If t=2, let
+K be the global original core of size k-2, and write f's defining face as
+one fixed signed K plus coordinate a. The pair a has degree at most 12, so
+at most four B-ports use a. Its four ordinary cubes K+a+r each contain two
+A-ports with distinct vector labels. Vector ordinary-cube parity requires at
+least one B-port in each, so there is exactly one in each.
+
+Those four B-ports have the same signed K as f. Indeed, for any i in K,
+core-face parity in the corresponding block would fail if its lone B-port
+had the other i-sign: the two A-labels have nonzero sum. To obtain this
+face parity, replace the opposite choice in the i-slot by a coordinate
+from an unused residual pair. The branch taking that coordinate omits the
+universal core pair i and is zero, so generalized-cube parity gives the
+claimed fixed-sign parity. Thus no opposite-i
+mate of an A-port lies in U, for any i in K. If k=2 the base already
+applies; otherwise choose such an i. A word in ker(Delta_i) must vanish on
+A, hence is zero because A's columns span all four dimensions. The
+derivative is injective.
+
+Its four-dimensional image at the same q=3 and k-1 has support at most 26,
+so the scalar theorem makes that support exactly 26. No occupied i-sign
+fiber can then contain two ports, since collapsing two occupied ports would
+strictly reduce union size. Therefore all word weights are preserved. The
+induction hypothesis gives four minimum words in the image, contrary to the
+single minimum word in V.
+
+### Two minimum words
+
+Call them f,g, with intersection size e in {0,1}. Their union A has size
+16-e and B=U without A has size 10+e. The outside-A image has dimension two,
+since d_3(q=3)=21>|A| excludes a larger kernel than <f,g>. Every nonzero
+image word comes from four nonminimum words. The coset identity gives its
+weight at least 14-|A|/2=6+e/2,
+
+hence at least 6+e. The three image weights sum 2|B|=20+2e, so each is at
+most 8. This upper bound is important for the derivative argument.
+
+Coincident original-pair cores are excluded by the common-core observation.
+Otherwise let their intersection have size c=k-1-u, u>=1. A symmetric-
+difference core pair has a minimum-star kernel and its image contains the
+other restricted minimum star, so its union degree is at most 11. It has
+A-degree 10-e, hence B-degree at most 1+e. A pair outside both cores has
+A-degree 4 and union degree at most 11, hence B-degree at most 7. Thus
+
+    (u+1)(10+e) <= 2u(1+e)+7(4-u).
+
+For e=0 this forces u<=1. For e=1 adjacency already gives u=1. In either
+case there is a common original core K of size k-2 and distinct private
+pairs a,b.
+
+If e=1, the signed K agrees for both stars. Choose any i in K. For a word in
+ker(Delta_i), every nonzero A-position must have an opposite-i mate in B.
+Such a mate uses a or b. There are at most two B-ports using each of those
+pairs, so the word's restriction to A has weight at most 4.
+
+If e=0, the two prescribed sign patterns on K differ. Choose a conflicting
+i. An A_f position can have an opposite-i mate in A_g in at most one case,
+namely f's extension by g's prescribed b-coordinate. It can have a mate in B
+at at most one position, since B-degree_a<=1. Hence a derivative- kernel
+word has weight at most 2 on A_f, and similarly at most 2 on A_g. Again its
+restriction to A has weight at most 4.
+
+In either case a kernel word with nonzero outside-A projection has total
+weight at most 4+8=12, contradicting the nonminimum gap 14. The derivatives
+of f,g are distinct minimum stars, so their span contains no derivative-
+kernel word either. Delta_i is injective. As before, scalar d_4 forces
+support 26 in the image, all occupied fibers are singletons, and all word
+weights are preserved. The induction hypothesis's four minimum words
+contradict the presence of only two here. If K is empty, k=2 and the base
+already supplies the contradiction.
+
+### Three minimum words
+
+By the pair-kernel exclusions, original pairs occur in zero, one, or all
+three defining cores. Let their common core have size c and each private set
+have size u=k-1-c. The u=0 case is excluded by the common-core observation.
+
+For u>=1, a private pair has union degree at most 11 because its avoidance
+image contains another restricted minimum word. Its degree in the union of
+the three stars is 12 minus the number of intersections of its own star with
+the other two. Thus every star intersects at least one other. As in the
+preceding q>=4 classification, this forces u=1, and the intersection graph
+is a union of cliques indexed by the signed common core. With three vertices
+and no isolates it must be a triangle.
+
+The triangle's signed core K has size k-2 and its union A has size 21. There
+are only five points in B=U without A. If k>=3, choose any i in K. All
+A-points have the same i-sign, so any nonzero two-sign fiber of a word in
+ker(Delta_i) must use at least one B-point. Its total weight is therefore at
+most 2|B|=10. A nonzero such word cannot be one of the three minimum stars,
+whose derivatives are nonzero, and cannot be nonminimum by the gap 14. Thus
+Delta_i is injective. The same support and weight preservation argument
+contradicts the induction hypothesis's four minimum words. The k=2 case was
+handled by the graph base.
+
+All cases with fewer than four minimum stars are excluded. This completes
+the equality argument at q=3.
+
+## Four-star geometry and the count
+
+There cannot be five minimum stars: their union would have size at least
+5d-10=10q>N for q>=3. Thus every optimal subcode has exactly four minimum
+stars, and they are independent. Indeed any sum of two is nonzero; three are
+independent by prior rigidity; a sum of three cannot be a fourth minimum
+word since its weight is at least 3d-6=6q>d.
+
+The union of four stars has size at least 4d-6=N. Equality in this two-term
+inclusion-exclusion bound forces all six pair intersections to be single
+ports and no port to lie in three or more stars. Any first three therefore
+form a triangle with common signed core K of size k-2. A fourth face
+adjacent to all three must contain K: if it omitted one coordinate of K,
+adjacency to the first two would force their two private coordinates,
+leaving intersection too small with the third face. Thus it is K plus a
+fourth signed coordinate, from a fourth original pair by compatibility. This
+proves the asserted geometric classification.
+
+The four generators are the only minimum words: their pair, triple, and
+quadruple sums have weights 4q+2,6q,8q-4 respectively, all larger than d.
+The subcode therefore uniquely recovers its signed core and its unordered
+four residual signed coordinates. Counting these choices gives
+2^(k-2)*binom(p,k-2)*16*binom(q+2,4), as asserted, for every q>=3.
+
+## Prescribed four targets and explicit decoders
+
+Let `T={T_1,T_2,T_3,T_4}` be four distinct prescribed ports. Choose a signed
+`(k-2)`-face K and four residual signed coordinates `a_1,...,a_4` from four
+distinct original pairs. Define the binary matrix
+
+```text
+E_ij = 1[K union {a_i} is contained in T_j].
+```
+
+Exactly `8q-2` deletions suffice for T **if and only if** some such E is
+invertible. This is a finite geometric criterion, with no assertion that
+every prescribed quadruple satisfies it.
+
+For sufficiency, take the four star rows f and their support union W. If E
+is invertible, every target lies in W. Replace the column of rows f by
+`E^(-1) f`; their restriction to T is the identity matrix. Delete `D=W \ T`.
+The four transformed rows are simultaneous unit decoders, and `|D|=8q-2`.
+
+Conversely, four unit decoders supported on `D union T` are independent.
+Their span has support at least `d_4=8q+2`. If `|D|=8q-2`, it is an optimal
+subcode and hence one of the four-star spans classified above. Its
+restriction to T has rank four, so the associated E is invertible. If no
+such E exists, the deletion budget is at least `8q-1`; this note does not
+determine the exact larger budget in that case.
+
+For selectable targets, private ports from an unused residual pair give an
+identity evaluation matrix immediately. Thus `d_4-4=8q-2` is attained. At
+power-of-two k the original overlap-class corrections lie in the nonempty
+proper-star span, so these statements apply to that corrected scalar decoder
+as well. Acquiring the required star totals, synthesizing a complete paid
+supplier, and improving κ are separate obligations; none is asserted here.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/OPTIMIZER-RESULTS.json b/research/asymmetric-hypercube-decoder/OPTIMIZER-RESULTS.json
new file mode 100644
index 0000000000..a357d4b075
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/OPTIMIZER-RESULTS.json
@@ -0,0 +1,36 @@
+{
+  "cases": [
+    {
+      "all_subspaces": 155,
+      "feasible": 560,
+      "optimal_subspaces": 120,
+      "rank": 3,
+      "rejected": 0,
+      "single_restoration_controls": 6160,
+      "support_minimum": 14,
+      "target_sets": 560
+    },
+    {
+      "all_subspaces": 31,
+      "feasible": 1680,
+      "optimal_subspaces": 16,
+      "rank": 4,
+      "rejected": 140,
+      "single_restoration_controls": 18480,
+      "support_minimum": 15,
+      "target_sets": 1820
+    },
+    {
+      "all_subspaces": 1,
+      "feasible": 2688,
+      "optimal_subspaces": 1,
+      "rank": 5,
+      "rejected": 1680,
+      "single_restoration_controls": 29568,
+      "support_minimum": 16,
+      "target_sets": 4368
+    }
+  ],
+  "scope": "All subspaces of RM(1,4) of ranks3,4,5 and all target subsets. This is finite cube verification, not global optimizer localization.",
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/README.md b/research/asymmetric-hypercube-decoder/README.md
index d4bc9d5286..5f0f743fe3 100644
--- a/research/asymmetric-hypercube-decoder/README.md
+++ b/research/asymmetric-hypercube-decoder/README.md
@@ -2,7 +2,9 @@
 
 **Uniform structural theorems with exact replay; no new κ.** The higher-target
 extension determines a complete hierarchy at `k=2`, the third generalized
-weight for every `k>=2,q=p-k>=2`, and a five-weight prefix at `q=2`.
+weight for every `k>=2,q=p-k>=2`, the fourth weight and all its optimizers
+for `q>=3`, and a five-weight prefix at `q=2` with all rank-three through
+rank-five optimizers classified.
 A generalized weight `d_r` measures the smallest support of r independent
 observation rows. The exact deletion threshold for **some selectable r-target
 set** is `d_r-r`; arbitrary prescribed target sets are a separate problem.
@@ -14,6 +16,9 @@ set** is `d_r-r`; arbitrary prescribed target sets are a separate problem.
 | `d_3=6q+3`; every optimum is a triangle of minimum stars | `k>=2,q>=3` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `d_3=15` for `k=2,3`; `d_3=14` for `k>=4` | `q=2` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `(d_1,...,d_5)=(6,11,14,15,16)` | `q=2,k>=4` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
+| `d_4=8q+2`; every optimum is a four-star clique | `k>=2,q>=3` | [FOURTH-WEIGHT.md](FOURTH-WEIGHT.md) |
+| Every optimal rank-three, four and five subcode is an affine four-flat code; exact prescribed-target criterion | `q=2,k>=4` | [CUBE-OPTIMIZERS.md](CUBE-OPTIMIZERS.md) |
+| Exact ordinary-cube shortening to a Reed–Muller code, with the empty-star boundary distinguished | `k>=2,q>=0` | [CUBE-OPTIMIZERS.md](CUBE-OPTIMIZERS.md) |
 
 The boundary is a real change in optimizer structure: every span of three
 minimum stars needs at least fifteen ports, but a localized affine cube has
@@ -27,12 +32,62 @@ prescribed triple attains `6q` deletions exactly when its three columns on
 some triangle have rank three. The larger budgets required by triples
 failing that criterion are not classified.
 
+For `q=2,k>=4`, prescribed sets of three, four or five targets attain eleven
+deletions exactly when they use the same original pairs and their sign vectors
+are affinely independent. For `q>=3`, prescribed quadruples attain `8q-2`
+deletions exactly when their columns are independent on an optimal four-star
+clique. These statements concern the specified proper-star observation model.
+
+[COPY-OBSTRUCTION.md](COPY-OBSTRUCTION.md) addresses a much larger physical
+class. An integral separating pairing with odd diagonal forces total copied
+frame rank `C>=v`, even with arbitrary recoded linear observations, individually
+readable corrections and chronological copy-to-zero reuse. Every even-size
+paired-port geometry with intersection-one readability satisfies that condition.
+Under the inherited odd-stage rank ledger, `C>=v` prevents a positive saving.
+The actual selected E8 supplier has even diagonal and is outside this obstruction.
+
 The general incidence-code/cut connection is credited to Martínez-Bernal,
 Valencia-Bucio, and Villarreal in the graph note. The uniform minimum distance
 is inherited from Luke Mansoor's #732. Earlier one- and two-target results,
 concurrent source credits, and the original obstruction remain below.
 
-## Reproduce the higher-target results
+## Reproduce the current campaign milestone
+
+From the repository root, Python 3.10+ with its standard library:
+
+```sh
+for check in shortening optimizer block copy_obstruction; do
+  python3 -I -O -B "research/asymmetric-hypercube-decoder/${check}_verify.py" --self-test || exit
+done
+```
+
+Each prints `PASS` followed by its filename after checking the saved receipt,
+isolated optimized relocation, corruption rejection, and output preservation.
+
+- [shortening_verify.py](shortening_verify.py): 42 full-generator shortenings,
+  comparing both inclusions with independently generated Reed–Muller spaces and
+  checking full ranks against the pinned PR #772 formula.
+- [optimizer_verify.py](optimizer_verify.py): all 187 rank-three through
+  rank-five subspaces of `RM(1,4)`, all 6,748 target sets of those sizes, and
+  54,208 single-deletion restoration controls in that full cube code.
+- [block_verify.py](block_verify.py): six complementary-block/four-cycle
+  models at `q=2,k=3,4,5`; 4,196,424 complete codewords in the four models
+  of dimension at most 22; exact syndrome matching over 1,296,438,900 logical
+  complementary 4+4 support candidates; 139,776 alternating 3/4 cycle support
+  candidates with separately fixed core signs in each block. Its 720
+  support-fourteen subcode case instances overlap between models and are not
+  a global distinct-subcode count. Nine adversarial controls reject false
+  shortening and parity-only models.
+- [copy_obstruction_verify.py](copy_obstruction_verify.py): eight exact
+  binary/rational matrix checks at `k=2,p=3,...,6` and `k=4,p=4,...,7`, plus
+  hypothesis-failure controls and a sequential copy fragment requiring the
+  innovation argument. This is not a full physical supplier replay.
+
+The campaign remains active. [CAMPAIGN-18H.json](CAMPAIGN-18H.json) records
+its scope and minimum research period. These completed mathematical milestones
+do not settle the remaining higher-rank and odd-size physical questions.
+
+## Reproduce the earlier higher-target results
 
 From the repository root, Python 3.10+ with its standard library:
 
diff --git a/research/asymmetric-hypercube-decoder/SHORTENING-RESULTS.json b/research/asymmetric-hypercube-decoder/SHORTENING-RESULTS.json
new file mode 100644
index 0000000000..70b3462028
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/SHORTENING-RESULTS.json
@@ -0,0 +1,510 @@
+{
+  "cases": [
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 4,
+      "k": 2,
+      "p": 2,
+      "ports": 4,
+      "q": 0,
+      "rank": 3,
+      "rm_order": 1,
+      "shortened_rank": 3
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 5,
+      "k": 2,
+      "p": 2,
+      "ports": 4,
+      "q": 0,
+      "rank": 3,
+      "rm_order": 1,
+      "shortened_rank": 3
+    },
+    {
+      "empty": false,
+      "empty_star_exception": true,
+      "generators": 6,
+      "k": 2,
+      "p": 3,
+      "ports": 12,
+      "q": 1,
+      "rank": 5,
+      "rm_order": 0,
+      "shortened_rank": 0
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 7,
+      "k": 2,
+      "p": 3,
+      "ports": 12,
+      "q": 1,
+      "rank": 6,
+      "rm_order": 0,
+      "shortened_rank": 1
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 8,
+      "k": 2,
+      "p": 4,
+      "ports": 24,
+      "q": 2,
+      "rank": 7,
+      "rm_order": -1,
+      "shortened_rank": 0
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 9,
+      "k": 2,
+      "p": 4,
+      "ports": 24,
+      "q": 2,
+      "rank": 8,
+      "rm_order": -1,
+      "shortened_rank": 0
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 10,
+      "k": 2,
+      "p": 5,
+      "ports": 40,
+      "q": 3,
+      "rank": 9,
+      "rm_order": -2,
+      "shortened_rank": 0
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 11,
+      "k": 2,
+      "p": 5,
+      "ports": 40,
+      "q": 3,
+      "rank": 10,
+      "rm_order": -2,
+      "shortened_rank": 0
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 18,
+      "k": 3,
+      "p": 3,
+      "ports": 8,
+      "q": 0,
+      "rank": 7,
+      "rm_order": 2,
+      "shortened_rank": 7
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 19,
+      "k": 3,
+      "p": 3,
+      "ports": 8,
+      "q": 0,
+      "rank": 7,
+      "rm_order": 2,
+      "shortened_rank": 7
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 32,
+      "k": 3,
+      "p": 4,
+      "ports": 32,
+      "q": 1,
+      "rank": 22,
+      "rm_order": 1,
+      "shortened_rank": 4
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 33,
+      "k": 3,
+      "p": 4,
+      "ports": 32,
+      "q": 1,
+      "rank": 22,
+      "rm_order": 1,
+      "shortened_rank": 4
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 50,
+      "k": 3,
+      "p": 5,
+      "ports": 80,
+      "q": 2,
+      "rank": 40,
+      "rm_order": 0,
+      "shortened_rank": 1
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 51,
+      "k": 3,
+      "p": 5,
+      "ports": 80,
+      "q": 2,
+      "rank": 40,
+      "rm_order": 0,
+      "shortened_rank": 1
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 72,
+      "k": 3,
+      "p": 6,
+      "ports": 160,
+      "q": 3,
+      "rank": 60,
+      "rm_order": -1,
+      "shortened_rank": 0
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 73,
+      "k": 3,
+      "p": 6,
+      "ports": 160,
+      "q": 3,
+      "rank": 60,
+      "rm_order": -1,
+      "shortened_rank": 0
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 64,
+      "k": 4,
+      "p": 4,
+      "ports": 16,
+      "q": 0,
+      "rank": 15,
+      "rm_order": 3,
+      "shortened_rank": 15
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 65,
+      "k": 4,
+      "p": 4,
+      "ports": 16,
+      "q": 0,
+      "rank": 15,
+      "rm_order": 3,
+      "shortened_rank": 15
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 130,
+      "k": 4,
+      "p": 5,
+      "ports": 80,
+      "q": 1,
+      "rank": 65,
+      "rm_order": 2,
+      "shortened_rank": 11
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 131,
+      "k": 4,
+      "p": 5,
+      "ports": 80,
+      "q": 1,
+      "rank": 65,
+      "rm_order": 2,
+      "shortened_rank": 11
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 232,
+      "k": 4,
+      "p": 6,
+      "ports": 240,
+      "q": 2,
+      "rank": 155,
+      "rm_order": 1,
+      "shortened_rank": 5
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 233,
+      "k": 4,
+      "p": 6,
+      "ports": 240,
+      "q": 2,
+      "rank": 155,
+      "rm_order": 1,
+      "shortened_rank": 5
+    },
+    {
+      "empty": false,
+      "empty_star_exception": true,
+      "generators": 378,
+      "k": 4,
+      "p": 7,
+      "ports": 560,
+      "q": 3,
+      "rank": 279,
+      "rm_order": 0,
+      "shortened_rank": 0
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 379,
+      "k": 4,
+      "p": 7,
+      "ports": 560,
+      "q": 3,
+      "rank": 280,
+      "rm_order": 0,
+      "shortened_rank": 1
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 210,
+      "k": 5,
+      "p": 5,
+      "ports": 32,
+      "q": 0,
+      "rank": 31,
+      "rm_order": 4,
+      "shortened_rank": 31
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 211,
+      "k": 5,
+      "p": 5,
+      "ports": 32,
+      "q": 0,
+      "rank": 31,
+      "rm_order": 4,
+      "shortened_rank": 31
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 472,
+      "k": 5,
+      "p": 6,
+      "ports": 192,
+      "q": 1,
+      "rank": 171,
+      "rm_order": 3,
+      "shortened_rank": 26
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 473,
+      "k": 5,
+      "p": 6,
+      "ports": 192,
+      "q": 1,
+      "rank": 171,
+      "rm_order": 3,
+      "shortened_rank": 26
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 938,
+      "k": 5,
+      "p": 7,
+      "ports": 672,
+      "q": 2,
+      "rank": 511,
+      "rm_order": 2,
+      "shortened_rank": 16
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 939,
+      "k": 5,
+      "p": 7,
+      "ports": 672,
+      "q": 2,
+      "rank": 511,
+      "rm_order": 2,
+      "shortened_rank": 16
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 1696,
+      "k": 5,
+      "p": 8,
+      "ports": 1792,
+      "q": 3,
+      "rank": 1106,
+      "rm_order": 1,
+      "shortened_rank": 6
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 1697,
+      "k": 5,
+      "p": 8,
+      "ports": 1792,
+      "q": 3,
+      "rank": 1106,
+      "rm_order": 1,
+      "shortened_rank": 6
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 664,
+      "k": 6,
+      "p": 6,
+      "ports": 64,
+      "q": 0,
+      "rank": 63,
+      "rm_order": 5,
+      "shortened_rank": 63
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 665,
+      "k": 6,
+      "p": 6,
+      "ports": 64,
+      "q": 0,
+      "rank": 63,
+      "rm_order": 5,
+      "shortened_rank": 63
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 1610,
+      "k": 6,
+      "p": 7,
+      "ports": 448,
+      "q": 1,
+      "rank": 420,
+      "rm_order": 4,
+      "shortened_rank": 57
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 1611,
+      "k": 6,
+      "p": 7,
+      "ports": 448,
+      "q": 1,
+      "rank": 420,
+      "rm_order": 4,
+      "shortened_rank": 57
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 3488,
+      "k": 6,
+      "p": 8,
+      "ports": 1792,
+      "q": 2,
+      "rank": 1512,
+      "rm_order": 3,
+      "shortened_rank": 42
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 3489,
+      "k": 6,
+      "p": 8,
+      "ports": 1792,
+      "q": 2,
+      "rank": 1512,
+      "rm_order": 3,
+      "shortened_rank": 42
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 6882,
+      "k": 6,
+      "p": 9,
+      "ports": 5376,
+      "q": 3,
+      "rank": 3864,
+      "rm_order": 2,
+      "shortened_rank": 22
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 6883,
+      "k": 6,
+      "p": 9,
+      "ports": 5376,
+      "q": 3,
+      "rank": 3864,
+      "rm_order": 2,
+      "shortened_rank": 22
+    },
+    {
+      "empty": false,
+      "empty_star_exception": false,
+      "generators": 2850,
+      "k": 5,
+      "p": 9,
+      "ports": 4032,
+      "q": 4,
+      "rank": 2016,
+      "rm_order": 0,
+      "shortened_rank": 1
+    },
+    {
+      "empty": true,
+      "empty_star_exception": false,
+      "generators": 2851,
+      "k": 5,
+      "p": 9,
+      "ports": 4032,
+      "q": 4,
+      "rank": 2016,
+      "rm_order": 0,
+      "shortened_rank": 1
+    }
+  ],
+  "scope": "Exact full-generator shortenings on 42 ordinary cubes; both inclusions against independently generated Reed-Muller spaces. Full ranks are also compared with the pinned PR772 formula.",
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/block_verify.py b/research/asymmetric-hypercube-decoder/block_verify.py
new file mode 100644
index 0000000000..02d5f43aa8
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/block_verify.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Exact finite research verification; Python 3.10+, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement the written proofs; they are not formal proofs.
+"""
+import argparse
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from itertools import combinations, product
+from collections import Counter, defaultdict
+import json
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+def partials(p, size):
+    for pairs in combinations(range(p), size):
+        for signs in product((0, 1), repeat=size):
+            yield sum(1 << (2 * pair + sign) for pair, sign in zip(pairs, signs))
+
+def echelon(rows):
+    pivots = {}
+    for word in rows:
+        while word:
+            pivot = word.bit_length() - 1
+            if pivot not in pivots:
+                pivots[pivot] = word
+                break
+            word ^= pivots[pivot]
+    return list(pivots.values())
+
+def shortened(rows, allowed):
+    outside_pivots, inside = {}, []
+    for original in rows:
+        word = original
+        while word & ~allowed:
+            pivot = (word & ~allowed).bit_length() - 1
+            if pivot not in outside_pivots:
+                outside_pivots[pivot] = word
+                break
+            word ^= outside_pivots[pivot]
+        else:
+            inside.append(word)
+    return echelon(inside)
+
+def positions(word):
+    result = []
+    while word:
+        bit = word & -word
+        result.append(bit.bit_length() - 1)
+        word ^= bit
+    return result
+
+def constant_weight_spaces(eight, masks):
+    ordered, available, spaces, planes = sorted(eight), set(eight), set(), 0
+    for i, a in enumerate(ordered):
+        for b in ordered[i+1:]:
+            if a ^ b not in available or b >= a ^ b:
+                continue
+            planes += 1
+            for c in ordered:
+                if c <= b:
+                    continue
+                coset = (c, c ^ a, c ^ b, c ^ a ^ b)
+                if c != min(coset) or not all(word in available for word in coset):
+                    continue
+                signature = tuple(sorted((a, b, a ^ b, *coset)))
+                require(signature not in spaces, "duplicate canonical rank-three subspace")
+                spaces.add(signature)
+                union = a | b | c
+                require(union.bit_count() == 14, "constant-weight subspace support")
+                require(any(union & ~mask == 0 for mask in masks), "nonlocalized optimizer")
+    return dict(constant_weight8_planes=planes,rank3_support14_spaces=len(spaces),
+                all_rank3_support14_spaces_in_one_block=True)
+
+def complementary_census(masks, family, syndromes, core_mask):
+    buckets, quadruples = [], []
+    for mask in masks:
+        table = defaultdict(list)
+        count = 0
+        for quad in combinations(positions(mask), 4):
+            syndrome, word = 0, 0
+            for index in quad:
+                syndrome ^= syndromes[index]
+                word |= 1 << index
+            table[syndrome].append(word)
+            count += 1
+        buckets.append(table)
+        quadruples.append(count)
+    accepted = 0
+    for syndrome, left in buckets[0].items():
+        for first in left:
+            for second in buckets[1].get(syndrome, []):
+                require(all(len({family[i] & core_mask for i in positions(word)}) == 1
+                            for word in (first, second)), "weight-four slice not unsigned")
+                accepted += 1
+    return dict(quadruples_per_block=quadruples,logical_4_plus_4_supports=quadruples[0]*quadruples[1],
+                accepted_supports=accepted,all_accepted_slices_unsigned=True)
+
+def cycle_census(k, edges, family, syndromes):
+    index = {port: i for i, port in enumerate(family)}
+    options = {}
+    for edge in edges:
+        for width in (3,4):
+            choices = []
+            for core in partials(k-2,k-2):
+                block = [index[core | (1 << (2*edge[0]+a)) | (1 << (2*edge[1]+b))]
+                         for a,b in product((0,1),repeat=2)]
+                choices += [tuple(quad) for quad in combinations(block,width)]
+            options[edge,width] = choices
+    histogram, examined = Counter(), 0
+    for widths in ((3,4,3,4),(4,3,4,3)):
+        for blocks in product(*(options[edge,width] for edge,width in zip(edges,widths))):
+            support = tuple(i for block in blocks for i in block)
+            dimension = 14-len(echelon(syndromes[i] for i in support))
+            require(dimension < 3, f"cycle optimizer survived: k={k}, support={support}")
+            histogram[dimension] += 1
+            examined += 1
+    require(examined == 32 * 2**(4*(k-2)), "complete alternating-block coverage")
+    return dict(fixed_core_per_block_supports=examined,shortened_dimension_histogram=dict(histogram),
+                rank3_support14_candidates_admitted=0,includes_both_3_4_orientations=True)
+
+def build(k):
+    p = k + 2
+    family = list(partials(p, k))
+    stars = [star for size in range(k) for star in partials(p, size)]
+    rows = [sum(1 << i for i, port in enumerate(family) if port & star == star)
+            for star in stars]
+    global_basis = sorted(echelon(rows),key=int.bit_length,reverse=True)
+    def residual(word):
+        for pivot in global_basis:
+            if word >> (pivot.bit_length()-1) & 1:
+                word ^= pivot
+        return word
+    syndromes = [residual(1 << i) for i in range(len(family))]
+    core = set(range(k - 2))
+    block_masks = {}
+    for pair in combinations(range(k - 2, p), 2):
+        required = core | set(pair)
+        block_masks[pair] = sum(1 << i for i, port in enumerate(family)
+                                if {coordinate // 2 for coordinate in range(2 * p)
+                                    if port >> coordinate & 1} == required)
+    a, b, c, d = range(k - 2, p)
+    core_mask = sum(3 << (2*i) for i in core)
+    geometries = {"complementary": [(a,b), (c,d)], "four_cycle": [(a,b),(b,c),(c,d),(a,d)]}
+    results = []
+    for name, edges in geometries.items():
+        masks = [block_masks[edge] for edge in edges]
+        allowed = sum(masks)
+        basis = shortened(rows, allowed)
+        require(all(word & ~allowed == 0 for word in basis), "shortening outside coordinates")
+        require(len(basis) == len(global_basis)-len(echelon(word & ~allowed for word in rows)),
+                "independent shortening rank identity")
+        entry = dict(k=k,p=p,geometry=name,ports=len(family),global_stars=len(stars),
+                     allowed_ports=allowed.bit_count(),shortened_dimension=len(basis),
+                     all_codewords_enumerated=len(basis)<=22)
+        if len(basis) <= 22:
+            weights, word, eight = Counter({0: 1}), 0, []
+            for step in range(1, 1 << len(basis)):
+                word ^= basis[(step & -step).bit_length() - 1]
+                weight = word.bit_count()
+                weights[weight] += 1
+                if weight == 8:
+                    eight.append(word)
+            require(sum(weights.values()) == 1 << len(basis), "complete codeword census")
+            require(min(weight for weight in weights if weight) == 8, "reduced-model minimum weight")
+            universal_counts = Counter()
+            for word in eight:
+                universal = (1 << p)-1
+                for i in positions(word):
+                    pair_set = sum(1 << pair for pair in range(p) if family[i] & (3 << (2*pair)))
+                    universal &= pair_set
+                universal_counts[universal.bit_count()] += 1
+                require(universal.bit_count() in (k-2,k), "weight-eight universal-pair gap")
+            entry.update(codewords=1 << len(basis),weight_histogram=dict(sorted(weights.items())),
+                         weight_eight_words=len(eight),universal_pair_histogram=dict(universal_counts),
+                         **constant_weight_spaces(eight,masks))
+        if name == "complementary":
+            entry.update(complementary_census(masks,family,syndromes,core_mask))
+            fixed_core = sum(1 << (2*i) for i in core)
+            projected_star = sum(1 << i for i, port in enumerate(family)
+                                 if port & (fixed_core | (1 << (2*a))) == fixed_core | (1 << (2*a))) & allowed
+            require(projected_star.bit_count() == 2 and residual(projected_star) != 0,
+                    "projection-versus-shortening control")
+            wrong_first = [fixed_core ^ (1 << 0) ^ (1 << sign)
+                           | (1 << (2*a+sa)) | (1 << (2*b)) for sign,sa in product((0,1),repeat=2)]
+            other = [fixed_core | (1 << (2*c+sc)) | (1 << (2*d+sd)) for sc,sd in product((0,1),repeat=2)]
+            wrong = sum(1 << family.index(port) for port in wrong_first+other)
+            require(all((wrong & mask).bit_count() == 4 for mask in masks) and residual(wrong) != 0,
+                    "ordinary cube parity insufficient control")
+            entry["negative_controls"] = ["projected two-point star is not shortened codeword",
+                                           "even 4+4 affine slices with varying core rejected"]
+        else:
+            entry.update(cycle_census(k,edges,family,syndromes))
+            fixed_core = sum(1 << (2*i) for i in core)
+            vector_words = [0,0,0]
+            for j, edge in enumerate(edges):
+                block = [fixed_core | (1 << (2*edge[0]+s)) | (1 << (2*edge[1]+t))
+                         for s,t in product((0,1),repeat=2)]
+                labels = (1,2,3) if j%2 == 0 else (4,5,6,7)
+                for port,label in zip(block,labels):
+                    for bit in range(3):
+                        if label >> bit & 1:
+                            vector_words[bit] |= 1 << family.index(port)
+            false_span = [0]
+            for word in vector_words:
+                false_span += [word ^ existing for existing in false_span]
+            require(len(set(false_span)) == 8 and all(word.bit_count() == 8 for word in false_span[1:]),
+                    "false geometric model not constant weight")
+            require(all(all((word & mask).bit_count()%2 == 0 for mask in masks) for word in vector_words),
+                    "false model should satisfy ordinary cube parity")
+            require(any(residual(word) != 0 for word in vector_words), "false cycle model escaped")
+            entry["negative_controls"] = ["rank3 constant-weight8 four-cycle passes block parity but fails full code"]
+        results.append(entry)
+    return results
+
+
+def verify():
+    return dict(status="PASS", scope="Full-generator complementary-block and four-cycle "
+                "shortenings for k=3,4,5 at q=2. Full word enumeration only when dimension<=22. "
+                "Complementary 4+4 candidates use exact syndrome meet-in-the-middle; "
+                "cycle support candidates have fixed core signs separately in each block. "
+                "Case counts overlap and are not global distinct-subcode counts.",
+                cases=[case for k in (3,4,5) for case in build(k)])
+
+RECEIPT = 'BLOCK-RESULTS.json'
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay failed: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS", Path(__file__).name)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/asymmetric-hypercube-decoder/copy_obstruction_verify.py b/research/asymmetric-hypercube-decoder/copy_obstruction_verify.py
new file mode 100644
index 0000000000..ca5733a163
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/copy_obstruction_verify.py
@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Exact finite research verification; Python 3.10+, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement the written proofs; they are not formal proofs.
+"""
+import argparse
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from fractions import Fraction
+from itertools import combinations, product
+import json
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def ports(p, k):
+    return [sum(1 << (2*i+s) for i, s in zip(pairs, signs))
+            for pairs in combinations(range(p), k) for signs in product((0, 1), repeat=k)]
+
+
+def binary_rank(rows):
+    pivots = {}
+    for row in rows:
+        while row:
+            pivot = row.bit_length() - 1
+            if pivot in pivots:
+                row ^= pivots[pivot]
+            else:
+                pivots[pivot] = row
+                break
+    return len(pivots)
+
+
+def rational_rank(columns):
+    pivots = {}
+    for column in columns:
+        column = [Fraction(x) for x in column]
+        for pivot in sorted(pivots):
+            coefficient = column[pivot]
+            if coefficient:
+                column = [x - coefficient*y for x, y in zip(column, pivots[pivot])]
+        pivot = next((i for i, value in enumerate(column) if value), None)
+        if pivot is not None:
+            coefficient = column[pivot]
+            pivots[pivot] = [x/coefficient for x in column]
+    return len(pivots)
+
+
+def xor(words):
+    result = 0
+    for word in words:
+        result ^= word
+    return result
+
+
+def check_case(p, k):
+    family = ports(p, k)
+    count = len(family)
+    certificate = [sum(((1 + (target & source).bit_count()) % 2) << j
+                       for j, source in enumerate(family)) for target in family]
+    require(all(row >> i & 1 for i, row in enumerate(certificate)), "certificate diagonal")
+    require(all(not (row >> j & 1) for target, row in zip(family, certificate)
+                for j, source in enumerate(family) if (target & source).bit_count() == 1),
+            "certificate fails to annihilate cap-readable entries")
+    # Independently expand one anchored proper-star formula per target.
+    recipes = []
+    used = set()
+    for target in family:
+        coordinates = [i for i in range(2*p) if target >> i & 1]
+        anchor, others = coordinates[0], coordinates[1:]
+        recipe = []
+        for degree in range(k - 1):
+            for subset in combinations(others, degree):
+                face = (1 << anchor) | sum(1 << i for i in subset)
+                recipe.append(face)
+                used.add(face)
+        recipes.append(recipe)
+    faces = sorted(used)
+    observations = {face: sum(1 << j for j, source in enumerate(family) if source & face == face)
+                    for face in faces}
+    coefficients = {face: [i for i, recipe in enumerate(recipes) if face in recipe] for face in faces}
+    decoder = [xor(observations[face] for face in recipe) for recipe in recipes]
+    require(all(row >> i & 1 for i, row in enumerate(decoder)), "missing own-source coefficient")
+    for i, row in enumerate(decoder):
+        correction = row ^ (1 << i)
+        require(all((family[i] & source).bit_count() == 1 for j, source in enumerate(family)
+                    if correction >> j & 1), "non-readable correction in decoder")
+        require(row & certificate[i] == 1 << i, "Hadamard identity failed")
+    reconstructed = [0] * count
+    total_frame_rank = 0
+    total_term_rank = 0
+    term_summary = {}
+    for face, observation in observations.items():
+        target_indices = coefficients[face]
+        terms = [certificate[i] & observation for i in target_indices]
+        term_rank = binary_rank(terms)
+        sources = [source for j, source in enumerate(family) if observation >> j & 1]
+        augmented_binary_rank = binary_rank(1 | source << 1 for source in sources)
+        coordinates = [[(source >> i) & 1 for i in range(2*p)] for source in sources]
+        label_rank = rational_rank(coordinates)
+        augmented_rational_rank = rational_rank([[1] + column for column in coordinates])
+        require(label_rank == augmented_rational_rank, "constant-weight rational augmentation")
+        require(term_rank <= augmented_binary_rank <= augmented_rational_rank,
+                "binary/rational rank bridge")
+        for i, term in zip(target_indices, terms):
+            reconstructed[i] ^= term
+        total_frame_rank += label_rank
+        total_term_rank += term_rank
+        key = (face.bit_count(), term_rank, augmented_binary_rank, label_rank)
+        term_summary[str(key)] = term_summary.get(str(key), 0) + 1
+    require(reconstructed == [1 << i for i in range(count)], "rank-one sum is not identity")
+    require(count <= total_term_rank <= total_frame_rank, "summed copy-rank bound")
+    # The broader fixed-observation lower bound is tight: copy each source alone.
+    require(all(rational_rank([[(source >> i) & 1 for i in range(2*p)]]) == 1
+                for source in family), "singleton-frame tightness")
+    return dict(p=p, k=k, ports=count, observations=len(faces),
+                total_term_rank=total_term_rank, total_literal_frame_rank=total_frame_rank,
+                tight_individual_copy_cost=count, term_types=term_summary)
+
+
+def negative_controls():
+    odd = ports(4, 3)
+    require(all((1 + target.bit_count()) % 2 == 0 for target in odd), "odd-k control")
+    family = ports(6, 4)
+    require(any((a & b).bit_count() == 0 and (1+(a & b).bit_count()) % 2 == 1
+                for a in family for b in family), "overlap-zero readability must violate annihilation")
+    require(any((a & b).bit_count() == 2 and (1+(a & b).bit_count()) % 2 == 1
+                for a in family for b in family), "overlap-two readability must violate annihilation")
+    # Recovering all targets cannot be certified after deleting a required summand.
+    require(binary_rank([1 << i for i in range(7)]) < 8, "missing-observation rank control")
+    return ["odd-k diagonal vanishes", "overlap-zero correction survives certificate",
+            "overlap-two correction survives certificate", "missing observation loses identity rank"]
+
+
+def sequential_innovations():
+    """A protocol fragment where raw copy supports exceed their native frames."""
+    family = ports(3, 2)
+    copied = []
+    innovations = []
+    violations = 0
+    for i, source in enumerate(family):
+        # Add the prior frame-zero copied prefix to the next native source.
+        # The new copy comes from that source's rank-one frame.
+        word = (1 << (i+1)) - 1
+        innovation = word
+        for previous in reversed(copied):
+            pivot = previous.bit_length() - 1
+            if innovation >> pivot & 1:
+                innovation ^= previous
+        require(innovation == 1 << i, "chronological native representative")
+        require(binary_rank(copied + [word]) == binary_rank(copied + [innovation]),
+                "triangular copied-span replacement")
+        copied.append(word)
+        innovations.append(innovation)
+        raw_labels = [[(label >> bit) & 1 for bit in range(6)] for label in family[:i+1]]
+        violations += int(rational_rank(raw_labels) > 1)
+        require(rational_rank([[(source >> bit) & 1 for bit in range(6)]]) == 1,
+                "native innovation frame rank")
+    recovered = [word ^ (copied[i-1] if i else 0) for i, word in enumerate(copied)]
+    require(recovered == innovations == [1 << i for i in range(len(family))],
+            "prefix copy decoding")
+    require(violations > 0, "raw support containment must fail after copy reuse")
+    return dict(copy_episodes=len(copied), charged_native_rank=len(copied),
+                raw_copies_exceeding_native_frame_rank=violations,
+                scope="Chronological source-row invariant on a copy-reuse fragment; "
+                      "not a complete restored supplier schedule.")
+
+
+
+def verify():
+    cases = [check_case(p, 2) for p in range(3, 7)]
+    cases += [check_case(p, 4) for p in range(4, 8)]
+    return dict(status="PASS", scope="Exact finite rank-certificate and anchored decoder checks; "
+                "not a physical supplier replay or a substitute for the uniform proof.",
+                cases=cases, negative_controls=negative_controls(),
+                sequential_copy_fragment=sequential_innovations())
+
+RECEIPT = 'COPY-OBSTRUCTION-RESULTS.json'
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay failed: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS", Path(__file__).name)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/asymmetric-hypercube-decoder/optimizer_verify.py b/research/asymmetric-hypercube-decoder/optimizer_verify.py
new file mode 100644
index 0000000000..070572510d
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/optimizer_verify.py
@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Exact finite research verification; Python 3.10+, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement the written proofs; they are not formal proofs.
+"""
+import argparse
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from itertools import combinations, product
+import json
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def rank(rows):
+    pivots = {}
+    for row in rows:
+        while row:
+            pivot = row.bit_length() - 1
+            if pivot in pivots:
+                row ^= pivots[pivot]
+            else:
+                pivots[pivot] = row
+                break
+    return len(pivots)
+
+
+def rref_spaces(dimension, size):
+    for pivots in combinations(range(dimension), size):
+        free = [(i, j) for i, pivot in enumerate(pivots)
+                for j in range(pivot + 1, dimension) if j not in pivots]
+        for values in product((0, 1), repeat=len(free)):
+            rows = [1 << pivot for pivot in pivots]
+            for value, (i, j) in zip(values, free):
+                rows[i] |= value << j
+            yield tuple(rows)
+
+
+def evaluate(coefficient):
+    return sum(1 << point for point in range(16)
+               if (coefficient & (1 | point << 1)).bit_count() % 2)
+
+
+def union(rows):
+    result = 0
+    for row in rows:
+        result |= row
+    return result
+
+
+def restrict(row, targets):
+    return sum(((row >> point) & 1) << i for i, point in enumerate(targets))
+
+
+def unit_decoders(rows, targets):
+    rows = list(rows)
+    for i, point in enumerate(targets):
+        pivot = next(j for j in range(i, len(rows)) if rows[j] >> point & 1)
+        rows[i], rows[pivot] = rows[pivot], rows[i]
+        for j in range(len(rows)):
+            if j != i and rows[j] >> point & 1:
+                rows[j] ^= rows[i]
+    require(all(restrict(row, targets) == 1 << i for i, row in enumerate(rows)),
+            "target elimination failed")
+    return rows
+
+
+def verify():
+    counts = {3: (155, 120, 560), 4: (31, 16, 1680), 5: (1, 1, 2688)}
+    minimum = {3: 14, 4: 15, 5: 16}
+    all_rows = [evaluate(1 << i) for i in range(5)]
+    results = []
+    for size in (3, 4, 5):
+        spaces = [tuple(evaluate(c) for c in coefficients)
+                  for coefficients in rref_spaces(5, size)]
+        supports = [union(rows) for rows in spaces]
+        require(min(mask.bit_count() for mask in supports) == minimum[size],
+                "wrong generalized weight")
+        optimal = [(rows, mask) for rows, mask in zip(spaces, supports)
+                   if mask.bit_count() == minimum[size]]
+        require((len(spaces), len(optimal)) == counts[size][:2], "subspace count")
+        feasible = 0
+        restored = 0
+        rejected = 0
+        total = 0
+        for targets in combinations(range(16), size):
+            total += 1
+            witness = next(((rows, mask) for rows, mask in optimal
+                            if rank(restrict(row, targets) for row in rows) == size), None)
+            affine_independent = rank(1 | point << 1 for point in targets) == size
+            require(bool(witness) == affine_independent, "affine criterion disagreement")
+            if witness is None:
+                rejected += 1
+                continue
+            feasible += 1
+            rows, mask = witness
+            target_mask = sum(1 << point for point in targets)
+            require(mask & target_mask == target_mask, "target outside support")
+            deleted = mask ^ target_mask
+            require(deleted.bit_count() == 11, "incorrect deletion count")
+            surviving = ((1 << 16) - 1) ^ deleted
+            decoders = unit_decoders(rows, targets)
+            require(all(row & surviving == 1 << point
+                        for row, point in zip(decoders, targets)), "retained unit identity")
+            for point in range(16):
+                if not (deleted >> point) & 1:
+                    continue
+                restored += 1
+                new_surviving = surviving | 1 << point
+                restrictions = [row & new_surviving for row in all_rows]
+                old_rank = rank(restrictions)
+                require(any(rank(restrictions + [1 << target]) > old_rank for target in targets),
+                        "one restored deletion unexpectedly allows full-cube recovery")
+        require(feasible == counts[size][2], "feasible target count")
+        results.append(dict(rank=size, all_subspaces=len(spaces), optimal_subspaces=len(optimal),
+                            support_minimum=minimum[size], target_sets=total,
+                            feasible=feasible, rejected=rejected,
+                            single_restoration_controls=restored))
+    # Four vertices of an affine plane defeat the tempting distinct-target rule.
+    require(rank(1 | point << 1 for point in (0, 1, 2, 3)) == 3,
+            "affine-plane negative control")
+    return dict(status="PASS", scope="All subspaces of RM(1,4) of ranks3,4,5 and all target subsets. "
+                "This is finite cube verification, not global optimizer localization.", cases=results)
+
+
+
+RECEIPT = 'OPTIMIZER-RESULTS.json'
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay failed: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS", Path(__file__).name)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/asymmetric-hypercube-decoder/shortening_verify.py b/research/asymmetric-hypercube-decoder/shortening_verify.py
new file mode 100644
index 0000000000..71564084ed
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/shortening_verify.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Exact finite research verification; Python 3.10+, standard library only.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement the written proofs; they are not formal proofs.
+"""
+import argparse
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+from itertools import combinations, product
+from math import comb
+import json
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def ports(p, k):
+    return [sum(1 << (2*i+s) for i,s in zip(pairs, signs))
+            for pairs in combinations(range(p),k) for signs in product((0,1),repeat=k)]
+
+
+def add(word, pivots):
+    while word:
+        p=word.bit_length()-1
+        if p in pivots:
+            word ^= pivots[p]
+        else:
+            pivots[p]=word
+            return True
+    return False
+
+
+def contains(word, pivots):
+    while word:
+        p=word.bit_length()-1
+        if p not in pivots:
+            return False
+        word ^= pivots[p]
+    return True
+
+
+def shorten(p, k, empty):
+    family=ports(p,k)
+    cube=[j for j,t in enumerate(family) if t >> (2*k)==0]
+    require(len(cube)==1<<k,'cube cardinality')
+    # The first ordinary cube is first in this explicit port order.
+    require(cube==list(range(1<<k)),'chosen cube column order')
+    cube_mask=(1<<(1<<k))-1
+    outside_pivots={}
+    shortened={}
+    generators=0
+    for degree in range(0 if empty else 1,k):
+        for face in ports(p,degree):
+            generators+=1
+            word=sum(1<<j for j,t in enumerate(family) if t&face==face)
+            # Reduce by outside pivot while preserving the entire codeword.
+            while word >> (1<<k):
+                pivot=word.bit_length()-1
+                if pivot not in outside_pivots:
+                    outside_pivots[pivot]=word
+                    break
+                word ^= outside_pivots[pivot]
+            else:
+                require(word&~cube_mask==0,'outside reduction')
+                add(word,shortened)
+    rm={}
+    degree_bound=k-(p-k)-1
+    for degree in range(max(0,degree_bound+1)):
+        for variables in combinations(range(k),degree):
+            face=sum(1<<(2*i) for i in variables)
+            word=sum(1<<j for j in cube if family[j]&face==face)
+            add(word,rm)
+    exceptional=(not empty and degree_bound==0 and k&(k-1)==0)
+    if exceptional:
+        rm={}
+    require(len(shortened)==len(rm),f'dimension p={p} k={k} empty={empty}: {len(shortened)} != {len(rm)}')
+    require(all(contains(w,rm) for w in shortened.values()),'shortening subset RM')
+    require(all(contains(w,shortened) for w in rm.values()),'RM subset shortening')
+    rank=len(outside_pivots)+len(shortened)
+    expected_rank=sum(comb(p,j)*comb(p-j,min(k-1-j,p-k)) for j in range(k))
+    expected_rank-=int(not empty and k&(k-1)==0 and p>=2*k-1)
+    require(rank==expected_rank,'independent full rank crosscheck of PR772 formula')
+    return dict(p=p,k=k,q=p-k,empty=empty,ports=len(family),generators=generators,
+                rank=rank,shortened_rank=len(shortened),rm_order=degree_bound,
+                empty_star_exception=exceptional)
+
+
+
+def verify():
+    cases = [shorten(k+q, k, empty) for k in range(2, 7) for q in range(4)
+             for empty in (False, True)]
+    cases += [shorten(9, 5, empty) for empty in (False, True)]
+    return dict(status="PASS", scope="Exact full-generator shortenings on 42 ordinary cubes; "
+                "both inclusions against independently generated Reed-Muller spaces. "
+                "Full ranks are also compared with the pinned PR772 formula.", cases=cases)
+
+RECEIPT = 'SHORTENING-RESULTS.json'
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay failed: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS", Path(__file__).name)
+
+
+if __name__ == "__main__":
+    main()

From 8f4600b41bf1f0f5d07f209e5d3950eb22ef5cad Mon Sep 17 00:00:00 2001
From: the-missionary-company
 <133953178+the-missionary-company@users.noreply.github.com>
Date: Wed, 14 Oct 2026 00:10:49 +0900
Subject: [PATCH 7/7] Prove fifth weights, exact forest target budgets, and odd
 native bounds

---
 .../CAMPAIGN-18H.json                         |   81 +-
 .../COPY-OBSTRUCTION.md                       |   12 +-
 .../CORE-SHORTENING-RESULTS.json              |  209 ++
 .../CORE-SHORTENING.md                        |  222 ++
 .../FIFTH-WEIGHT.md                           |  641 ++++
 .../GRAPH-TARGETS-RESULTS.json                | 2888 +++++++++++++++++
 .../GRAPH-TARGETS.md                          |  435 +++
 .../ODD-NATIVE-COST.md                        |  304 ++
 .../asymmetric-hypercube-decoder/README.md    |   40 +-
 .../core_shortening_verify.py                 |  263 ++
 .../graph_targets_verify.py                   |  512 +++
 11 files changed, 5595 insertions(+), 12 deletions(-)
 create mode 100644 research/asymmetric-hypercube-decoder/CORE-SHORTENING-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/CORE-SHORTENING.md
 create mode 100644 research/asymmetric-hypercube-decoder/FIFTH-WEIGHT.md
 create mode 100644 research/asymmetric-hypercube-decoder/GRAPH-TARGETS-RESULTS.json
 create mode 100644 research/asymmetric-hypercube-decoder/GRAPH-TARGETS.md
 create mode 100644 research/asymmetric-hypercube-decoder/ODD-NATIVE-COST.md
 create mode 100644 research/asymmetric-hypercube-decoder/core_shortening_verify.py
 create mode 100644 research/asymmetric-hypercube-decoder/graph_targets_verify.py

diff --git a/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json b/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
index da2dff3b51..1f712a3fea 100644
--- a/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
+++ b/research/asymmetric-hypercube-decoder/CAMPAIGN-18H.json
@@ -6,6 +6,37 @@
   "current_main_snapshot": "91a2094f2e022930069e8cfdc810a3ea1b81cd09",
   "selected_kappa_at_start": "1661634653669567/1000000000000000000",
   "selected_review": "docs/research/community-frontier799-review.md",
+  "source_refresh": {
+    "recorded_at": "2026-10-13T23:28:46+09:00",
+    "main_commit": "007664306fff84fbb1c9a1b4053b69f439764034",
+    "selected_kappa": "1661957774647029/1000000000000000000",
+    "selected_review": "docs/research/community-frontier890-review.md",
+    "audited_source_head": "4b3bd8cbe8e3e81c44161017c9b72c905a8040a8",
+    "bit_supplier": "PR589 on PR555, unchanged by the refreshed composition",
+    "scope": "Read-only inspection of selected certificate and actual integration review; no new cold supplier replay claimed.",
+    "overlap": [
+      {
+        "pr": 938,
+        "head": "df645942469e6a739ec94010a6068c398f4a6c86",
+        "distinction": "Dirty-fanout connector-query star census; a different object from signed proper-star evaluation codes."
+      },
+      {
+        "pr": 939,
+        "head": "3a8ec54d62fb8824c658dc7ed356f99423cac8cf",
+        "distinction": "E8 binary-root star-reader COPY obstruction; E8 lies outside our integral odd-diagonal paired-port theorem."
+      },
+      {
+        "pr": 954,
+        "head": "a98219aa708e1bd2ae4ca90e720e66569f7f0147",
+        "distinction": "E8 fixed-star first-decoder rank drops on 56 punctures; outside the odd-diagonal paired-port hypothesis."
+      },
+      {
+        "pr": 958,
+        "head": "28d68c88f0184835d8c8a7266ab8d0dad3f18a8a",
+        "distinction": "Read the actual proof: five-port point-only decoder uses quadratic labels and overlap-one plus overlap-three corrections. Our literal odd-star theorem uses incidence labels, additional copied proper stars, and only overlap-one corrections."
+      }
+    ]
+  },
   "started_at": "2026-10-13T22:16:53+09:00",
   "minimum_duration_hours": 18,
   "earliest_completion_at": "2026-10-14T16:16:53+09:00",
@@ -33,7 +64,7 @@
   },
   "attribution": "Sam Sung with substantial OpenAI Codex assistance, including independent AI-assisted review.",
   "checkpoint": {
-    "recorded_at": "2026-10-13T23:13:47+09:00",
+    "recorded_at": "2026-10-14T00:08:33+09:00",
     "phase": "research and construction; the reserved final verification phase has not begun",
     "campaign_status": "active; minimum duration and remaining research obligations are not complete",
     "reviewed_milestones": [
@@ -51,6 +82,26 @@
         "claim": "Integral separating-pairing weighted COPY obstruction, including chronological copy-to-zero innovations and even paired-port corollary.",
         "proof": "COPY-OBSTRUCTION.md",
         "review": "Lead independently checked rank decomposition, integral specialization, source-column invariant, and template scope; separate checker review and replay."
+      },
+      {
+        "claim": "Uniform fifth generalized weight d5=10q and all second-weight words for k>=2,q>=3; all fifth-weight optimizers and prescribed-target criterion for q>=4.",
+        "proof": "FIFTH-WEIGHT.md",
+        "review": "Independent AI-assisted proof and final-text reviews; lead checked boundary kernels, low-word span, Fourier contradiction, induction and optimizer cases."
+      },
+      {
+        "claim": "Exact unrestricted original-core shortening filtration at q3, its dimension formula, and sharp weight16 barrier for extra layers.",
+        "proof": "CORE-SHORTENING.md",
+        "review": "Two separate AI-assisted mathematical reviews plus lead review; full-generator finite checker independently authored and integrated with failure controls."
+      },
+      {
+        "claim": "Native literal odd-star decoder ceiling c<107/66606 for all odd k>=5 in the inherited L>=5 template; conditional L3 extension c<53/32958 for odd k>=7.",
+        "proof": "ODD-NATIVE-COST.md",
+        "review": "Independent derivation and lead audit of source/idle schedule, hosting refinement and actual bank denominator; both ran exact rational log and discriminant checks."
+      },
+      {
+        "claim": "Exact prescribed-target partition formulas for every paired two-port target set, a matching formula for every forest, and complete three-target budgets.",
+        "proof": "GRAPH-TARGETS.md",
+        "review": "Independent AI-assisted proof review and full checker review, lead review of complete proof and code, independent optimized self-test with byte-identical receipt."
       }
     ],
     "verification": [
@@ -85,16 +136,32 @@
         "receipt_sha256": "b166a48db0cfbb7fe8b9929a248e73018f7d535f0b71757ae4553255d62b2ce1",
         "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/copy_obstruction_verify.py --self-test",
         "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      },
+      {
+        "script": "core_shortening_verify.py",
+        "script_sha256": "050c05331014c4c08446dbbc90a9a13bc969b4e1363d6d682eba51a51d37d2de",
+        "receipt": "CORE-SHORTENING-RESULTS.json",
+        "receipt_sha256": "d6d33689671a0506e7da1f4928044807010657590848ab886302bf5d742b72b4",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/core_shortening_verify.py --self-test",
+        "status": "PASS including isolated optimized relocation, corruption rejection and failure output preservation"
+      },
+      {
+        "script": "graph_targets_verify.py",
+        "script_sha256": "8b0816e6f5b3e4fcc0d904846cc3e27a12af12f11c940c0055dee8c812845d6d",
+        "receipt": "GRAPH-TARGETS-RESULTS.json",
+        "receipt_sha256": "9c457657cfa21ad903e31d3592c79557653661a0cc6d253c18a39a880e477f52",
+        "command": "python3 -I -O -B research/asymmetric-hypercube-decoder/graph_targets_verify.py --self-test",
+        "status": "PASS: 4112 complete target sets, 73 p4 target orbits covering 12650 sets, 4329472 direct decoder assignments; isolated optimized relocation, corruption rejection, failure output preservation and atomic replacement failure cleanup."
       }
     ],
     "next_unresolved_work": [
-      "Uniform fifth and higher generalized weights: q3 support29 is the active boundary; new weight14 and common-original-core lemmas are under development.",
-      "Exact prescribed-target budgets outside the optimum criteria: graph triples/quads have new scratch results needing proof review and integration.",
-      "Common-original-core shortening with unrestricted signs: determine a uniform residual-code filtration rather than assume signed-face shortening.",
-      "Odd-size paired-port supplier: price the known scalar identities under shared monotone source routes and actual odd-stage moments; do not duplicate older unshared screens.",
-      "Continue the full minimum research period, then perform the reserved independent verification, current-source/overlap refresh and publication through PR669."
+      "Classify q3 fifth-weight optimizers and resolve the rank6 boundary, where ordinary-cube constructions already beat the star-clique upper bound for k>=5.",
+      "Extend prescribed-target geometry beyond two-ports and the classified optimal higher-rank subcodes; the all-r forest matching theorem is now integrated.",
+      "Complete independent finite verification of the proved native odd-three point-space recoding invoice and its complete-template ceilings; investigate remaining physical helper/source costs.",
+      "Construct or exclude remaining odd-size physical schedules with complete source/helper/frame/copy/restoration and recursive accounting; the native-cost ceilings exclude only their stated classes.",
+      "Continue the full minimum research period, then perform the reserved independent verification, source/overlap refresh and publication through PR669."
     ],
-    "publication_status": "New milestone files are local; published PR head remains 7d526020fc368ce4157cd436995c2f4fcf683318 at this checkpoint.",
+    "publication_status": "First local checkpoint is commit 697e4d36a6a8c34727677ffdfc4164929fb7c870; additional reviewed milestones remain local. Published PR head is still 7d526020fc368ce4157cd436995c2f4fcf683318 at this checkpoint.",
     "environment": {
       "python": "3.14.5",
       "arithmetic": "Python integers, exact F2 elimination, and Fraction rational elimination; standard library only"
diff --git a/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
index dac5b589b4..b032d93931 100644
--- a/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
+++ b/research/asymmetric-hypercube-decoder/COPY-OBSTRUCTION.md
@@ -217,8 +217,16 @@ This source trace is pinned to main commit
 `91a2094f2e022930069e8cfdc810a3ea1b81cd09`. Its selected certificate names
 Jeremy Kothe's PR #799 complex word, Chafik Boukhalfa's PR #741 frames, and
 DreamingOfClouds' PR #589 bit tuning of eumemic's PR #555 construction. The
-conditional selected value is still \(1661634653669567/10^{18}\).
-Nothing here changes that selection.
+conditional selected value at that campaign-start checkpoint was
+\(1661634653669567/10^{18}\).
+
+A read-only refresh at main commit
+`007664306fff84fbb1c9a1b4053b69f439764034` finds the selected PR #890
+composition at \(1661957774647029/10^{18}\). Its
+[pinned integration review](https://github.com/CrocSwap/integer-mult-bounds/blob/007664306fff84fbb1c9a1b4053b69f439764034/docs/research/community-frontier890-review.md)
+retains the same PR #589 / PR #555 bit supplier. The bit ledger traced below
+therefore remains applicable. This refresh is a source inspection, not a new
+cold replay of the selected assembly; nothing here changes that selection.
 
 The selected bit word has ambient dimension \(h=8\), \(v=111\) sources
 and targets, \(R=439\) dirty helpers, and nine COPY ranks equal to seven:
diff --git a/research/asymmetric-hypercube-decoder/CORE-SHORTENING-RESULTS.json b/research/asymmetric-hypercube-decoder/CORE-SHORTENING-RESULTS.json
new file mode 100644
index 0000000000..5737ff2f8c
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CORE-SHORTENING-RESULTS.json
@@ -0,0 +1,209 @@
+{
+  "cases": [
+    {
+      "ANF_component_dimensions": [
+        10,
+        10
+      ],
+      "full_codewords_enumerated": 1048576,
+      "full_ports": 160,
+      "global_rank": 60,
+      "global_star_generators": 73,
+      "k": 3,
+      "naive_tensor_dimension": 20,
+      "nonzero_spectrum_below16": {
+        "14": 80,
+        "8": 20
+      },
+      "p": 6,
+      "predicted_ANF_basis_sha256": "7548b32bc3a6318367586d6af15aca1d631572920f144a4d93eabd0f5ea9532d",
+      "sharp_extra_word_weight": null,
+      "shortening_coordinates": 80,
+      "shortening_dimension": 20
+    },
+    {
+      "ANF_component_dimensions": [
+        15,
+        10,
+        10,
+        10
+      ],
+      "full_codewords_enumerated": 0,
+      "full_ports": 560,
+      "global_rank": 280,
+      "global_star_generators": 379,
+      "k": 4,
+      "naive_tensor_dimension": 40,
+      "nonzero_spectrum_below16": null,
+      "p": 7,
+      "predicted_ANF_basis_sha256": "3953b0dc152c89dcfb531ee031a3283bf0607953296fd0f6e8d6d2d01e36f4af",
+      "sharp_extra_word_weight": 16,
+      "shortening_coordinates": 160,
+      "shortening_dimension": 45
+    },
+    {
+      "ANF_component_dimensions": [
+        30,
+        15,
+        15,
+        10,
+        15,
+        10,
+        10,
+        10
+      ],
+      "full_codewords_enumerated": 0,
+      "full_ports": 1792,
+      "global_rank": 1106,
+      "global_star_generators": 1697,
+      "k": 5,
+      "naive_tensor_dimension": 80,
+      "nonzero_spectrum_below16": null,
+      "p": 8,
+      "predicted_ANF_basis_sha256": "7d0a10006c0deb8f9491b9b2515f25264bab706c54a15d956c96a8d2afb68ab0",
+      "sharp_extra_word_weight": 16,
+      "shortening_coordinates": 320,
+      "shortening_dimension": 115
+    },
+    {
+      "ANF_component_dimensions": [
+        40,
+        30,
+        30,
+        15,
+        30,
+        15,
+        15,
+        10,
+        30,
+        15,
+        15,
+        10,
+        15,
+        10,
+        10,
+        10
+      ],
+      "full_codewords_enumerated": 0,
+      "full_ports": 5376,
+      "global_rank": 3864,
+      "global_star_generators": 6883,
+      "k": 6,
+      "naive_tensor_dimension": 160,
+      "nonzero_spectrum_below16": null,
+      "p": 9,
+      "predicted_ANF_basis_sha256": "e1f1cca8f4b976bfe1c918da7a7f3d61c0e86b98b0341dbbb20b65eeea4dd3e7",
+      "sharp_extra_word_weight": 16,
+      "shortening_coordinates": 640,
+      "shortening_dimension": 300
+    }
+  ],
+  "core_polynomial_distances": [
+    {
+      "core_bits": 2,
+      "dimension": 1,
+      "enumerated_polynomials": 2,
+      "layer": 2,
+      "minimum_weight": 4
+    },
+    {
+      "core_bits": 3,
+      "dimension": 4,
+      "enumerated_polynomials": 16,
+      "layer": 2,
+      "minimum_weight": 4
+    },
+    {
+      "core_bits": 3,
+      "dimension": 1,
+      "enumerated_polynomials": 2,
+      "layer": 3,
+      "minimum_weight": 8
+    },
+    {
+      "core_bits": 4,
+      "dimension": 11,
+      "enumerated_polynomials": 2048,
+      "layer": 2,
+      "minimum_weight": 4
+    },
+    {
+      "core_bits": 4,
+      "dimension": 5,
+      "enumerated_polynomials": 32,
+      "layer": 3,
+      "minimum_weight": 8
+    },
+    {
+      "core_bits": 4,
+      "dimension": 1,
+      "enumerated_polynomials": 2,
+      "layer": 4,
+      "minimum_weight": 16
+    }
+  ],
+  "negative_controls": [
+    "unsigned residual block is outside C+_(5,2)",
+    "naive tensor omits a verified weight16 shortened word for every tested k>=4"
+  ],
+  "residual_spectra": {
+    "0": {
+      "0": 1,
+      "14": 40,
+      "16": 45,
+      "18": 280,
+      "20": 272,
+      "22": 280,
+      "24": 45,
+      "26": 40,
+      "32": 10,
+      "40": 1,
+      "8": 10
+    },
+    "2": {
+      "0": 1,
+      "12": 600,
+      "14": 1280,
+      "16": 1410,
+      "18": 8960,
+      "20": 7996,
+      "22": 8960,
+      "24": 1410,
+      "26": 1280,
+      "28": 600,
+      "32": 125,
+      "36": 10,
+      "4": 10,
+      "40": 1,
+      "8": 125
+    }
+  },
+  "scope": "Exact full-generator q3 shortening for k3..6, elementary unsigned ladder, residual spaces and finite low-weight checks; uniform proof is separate.",
+  "status": "PASS",
+  "unsigned_shortening_ladder": [
+    {
+      "degree_bound": 2,
+      "dimension": 15,
+      "excluded_vertices": 0,
+      "remaining_coordinates": 20
+    },
+    {
+      "degree_bound": 1,
+      "dimension": 5,
+      "excluded_vertices": 1,
+      "remaining_coordinates": 10
+    },
+    {
+      "degree_bound": 0,
+      "dimension": 1,
+      "excluded_vertices": 2,
+      "remaining_coordinates": 4
+    },
+    {
+      "degree_bound": -1,
+      "dimension": 0,
+      "excluded_vertices": 3,
+      "remaining_coordinates": 1
+    }
+  ]
+}
diff --git a/research/asymmetric-hypercube-decoder/CORE-SHORTENING.md b/research/asymmetric-hypercube-decoder/CORE-SHORTENING.md
new file mode 100644
index 0000000000..36c67d47b8
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/CORE-SHORTENING.md
@@ -0,0 +1,222 @@
+# q=3 shortening to a common original-pair core
+
+**Uniform shortening theorem; no new κ.** Let p=k+3, let K be k−2 original pairs, and
+shorten C+_(p,k) to ports containing every pair in K, with their signs
+unrestricted. Put c=k−2. The remaining five original pairs carry a signed
+two-port, identified with an edge of the ten-vertex cocktail-party graph.
+Write s∈F2^c for the core signs, and expand a shortened word uniquely as
+
+    f(s,e) = sum_(S subset K) s_S g_S(e),
+    s_S = product_(i in S) s_i.
+
+## Exact filtration
+
+Define nested residual spaces V0⊂V2⊂V3⊂V4 on the forty residual ports:
+
+* V0 is C+_(5,2), dimension 10, minimum nonzero weight 8.
+* V2 adds arbitrary functions of the unsigned residual original-pair edge
+  to V0. It has dimension 15 and minimum weight 4.
+* V3 consists of arbitrary affine functions of the two residual signs on
+  each of the ten unsigned pair-edge blocks. Dimension 30, minimum weight 2.
+* V4 is the full forty-coordinate space. Dimension 40, minimum weight 1.
+
+Then the exact shortened code is the following direct sum, with completely
+independent choices for every core ANF coefficient:
+
+    g_S ∈ V0             if c−|S| = 0 or 1;
+    g_S ∈ V2             if c−|S| = 2;
+    g_S ∈ V3             if c−|S| = 3;
+    g_S ∈ V4             if c−|S| ≥ 4.                     (1)
+
+Its dimension, with binomial coefficients outside their range set to zero,
+is
+
+    40·2^c − 30(1+c) − 25 binom(c,2) − 10 binom(c,3).
+
+For c=0,1,2,3,4 this gives 10,20,45,115,300. The naive tensor space of
+arbitrary core-sign functions with V0 has dimension 10·2^c, so it is exact
+only for c≤1 and is strictly too small for every c≥2.
+
+## Sign coefficients reduce the proof to an unsigned shortening ladder
+
+For original pair i, use occupancy z_i=x_(i,0)+x_(i,1) and sign coordinate
+x_i=x_(i,1). Products x_A z_B with A and B disjoint, total degree at most
+k−1, span exactly the proper-star observations (including the empty star).
+On the occupancy block I, x_A contributes the sign monomial indexed by A.
+Its coefficient is an arbitrary degree-at-most k−1−|A| polynomial in the
+remaining occupancies, evaluated on subsets of size k−|A|.
+
+These sign-ANF components are independent: vanishing on any occupancy block
+means that every sign coefficient vanishes separately on that block.
+Consequently shortening also separates over A. On our allowed ports write
+A=S union B, where S⊆K, B consists of b residual sign indices, and b≤2.
+Let t=c−|S|. The remaining occupancy problem has
+
+    n=t+5−b vertices,
+    m=t+2−b occupied vertices,
+    degree bound d=t+1−b.
+
+There are exactly three absent vertices. Replacing occupancies by one plus
+absence indicators preserves degree, so the coefficient code is the
+polynomial code of degree at most d on the three-subsets of n=d+4 vertices,
+shortened to subsets avoiding the t core vertices.
+
+For d≥3 this unsigned code is full: each individual absence triple is the
+evaluation of its degree-three monomial. For d<0 it is zero. The remaining
+three cases follow from the ladder
+
+    degree≤2 on triples of 6 --avoid one vertex--> degree≤1 on triples of 5
+                            --avoid one vertex--> constants on triples of 4
+                            --avoid one vertex--> zero on triples of 3. (2)
+
+Here is a direct proof of the first arrow. Write a quadratic as Q(y)+x L(y),
+where x is the avoided vertex and y comprises five others. Vanishing at
+x=1 on every two-subset of y means R=Q+L vanishes on every two-subset.
+Writing
+
+    R(y)=a + sum_i b_i y_i + sum_(i<j) c_ij y_i y_j
+
+gives c_ij=a+b_i+b_j. On any three-subset, R equals sum_i b_i y_i, hence
+Q=R+L restricts to an affine linear function. Conversely multiplying any
+such affine linear function by (1+x) provides a quadratic supported away
+from x. For the second arrow, an affine linear function vanishing at x=1
+on all two-subsets of four remaining vertices has equal coefficients on
+those four vertices, and therefore is constant on their three-subsets.
+The reverse inclusion is (1+x). The final arrow is immediate.
+
+Apply (2) t times when d≤2. For b=0 the surviving coefficient space is the
+affine linear code on residual triples of five vertices, equivalently the
+cut-plus-constant code on their complementary unsigned edges, dimension 5.
+For b=1 it consists of constants across the four possible partner pairs,
+dimension 1. For b=2 it is zero. A coefficient becomes arbitrary precisely
+when its initial degree d≥3, namely t≥b+2. Thus:
+
+* unsigned block coefficients become arbitrary at t=2;
+* each residual linear-sign coefficient becomes independently arbitrary
+  across partner blocks at t=3;
+* residual bilinear-sign coefficients become arbitrary at t=4.
+
+This proves (1), including independence of all coefficients.
+
+## The 16-weight barrier for every extra word
+
+Choose vector-space complements along the nested residual spaces, so every
+word has a unique decomposition into its V0 part and its new V2, V3, V4
+layers. The new Vj layer has coefficient functions in the core variables
+of degree at most c−j, for j∈{2,3,4}. This follows directly from (1).
+
+Suppose a word has a nonzero extra layer, and let j be its highest nonzero
+layer. Choose a residual linear functional that annihilates the previous
+space but detects this layer. Applying it separately at every core sign
+s gives a nonzero Boolean polynomial of degree at most c−j. It is nonzero
+on at least 2^j core assignments. On every such assignment, the residual
+word is nonzero and lies in Vj. Its weight is at least 4,2,1 for j=2,3,4,
+respectively. The total word weight is therefore at least 16 in all cases.
+
+The polynomial weight bound used here has an elementary induction proof.
+If P=P0+x P1 and P1≠0, then deg P1≤d−1; every input where P1 is nonzero
+contributes exactly one nonzero value among the two x choices. If P1=0,
+P is duplicated over x. These two cases give weight(P)≥2^(c−d).
+
+The residual distances are elementary. V3 is a direct sum of ten length-four
+affine codes, each of distance two; V4 is full. A V2 word has the form
+
+    alpha_ij + beta_i epsilon_i + beta_j epsilon_j
+
+on block ij. If all beta_i vanish, any nonzero block has weight four. If
+some beta_i is nonzero, the four blocks incident to i each have a nonzero
+linear part and therefore weight two, so total weight is at least eight.
+Thus V2 has distance four. V0 has distance eight by the cut-code calculation
+below. The extra-layer barrier is sharp when c≥2: multiply one unsigned
+residual block by a core monomial of degree c−2. It is an allowed V2-layer
+word of weight 4·4=16, outside the naive tensor space.
+
+## Consequence: every weight-14 word fixes the entire core sign
+
+Any word of weight less than 16 lies in the naive tensor space: every
+core-sign branch independently carries a word of V0. Since V0 has minimum
+weight eight, a weight-14 word has exactly one nonzero core branch.
+
+To classify that branch, write a V0 word as a cut delta(A), or its complement,
+and replace A by its complement so a=|A|≤5. If A contains t complete original
+matched pairs, the cut weight is
+
+    a(10−a)−(a−2t)=a(9−a)+2t.
+
+For a=1 the weight is eight. The only way to get weight fourteen is a=2,
+t=0: A contains two vertices from different original pairs, so these are
+adjacent signed vertices. For a≥3 the cut weight is at least eighteen.
+The maximum cut weight is twenty-four, so complements have weight at least
+sixteen. Hence a weight-14 residual word is exactly the sum of two adjacent
+singleton stars. There are forty such residual words.
+
+After restoring the fixed signed core, every weight-14 shortened word is
+therefore the sum of two adjacent (k−1)-stars sharing that signed core.
+There are exactly 40·2^c such words. This is a uniform statement for every
+k≥2 at q=3, conditional only on the support containing the specified common
+original-pair core, not a global second-weight classification outside that
+shortening.
+
+## Independent finite checks
+
+Run:
+
+    python3 -I -O -B research/asymmetric-hypercube-decoder/core_shortening_verify.py --self-test
+
+The standard-library verifier generates every global proper-star evaluation
+row directly, then eliminates outside coordinates to obtain the actual
+shortened code. A separate rank-difference identity checks its dimension.
+It transforms the result to core-sign ANF, compares every component space
+with the explicit residual generators above, and reinserts those components
+to verify that there are no hidden couplings.
+
+| k | p | Full ports | Global star generators | Global rank | Shortened rank | Naive tensor rank |
+| --- | --- | --- | --- | --- | --- | --- |
+| 3 | 6 | 160 | 73 | 60 | 20 | 20 |
+| 4 | 7 | 560 | 379 | 280 | 45 | 40 |
+| 5 | 8 | 1,792 | 1,697 | 1,106 | 115 | 80 |
+| 6 | 9 | 5,376 | 6,883 | 3,864 | 300 | 160 |
+
+This covers 9,032 global generators and all thirty core ANF components.
+The verifier separately checks the unsigned shortening ladder, enumerates
+all 1,024 words of V0 and all 32,768 words of V2, and verifies their exact
+minimum weights. It checks all forty residual weight-14 words against
+adjacent-star sums. For c≤4 it also exhaustively checks the relevant core
+polynomial distance bounds, enumerating 2,102 polynomials across six cases.
+
+Finally it enumerates all 1,048,576 words of the k=3 shortened code. The
+only nonzero weights below sixteen are eight (twenty words) and fourteen
+(eighty words), and every such word fixes the core sign. The larger cases
+are exact space checks, not exhaustive word enumerations. Negative controls
+verify that one unsigned residual block does not belong to V0, while its
+suitable core-monomial lift really is an extra weight-sixteen word for each
+of k=4,5,6. Thus removing the extra filtration layers would be detected.
+Normal and optimized (`-I -O -B`) executions produced byte-identical JSON.
+All checks use explicit exceptions, not removable assertions. The self-test
+also checks isolated optimized relocation, corrupt-receipt rejection, and
+preservation of an existing output on a failed check. Expected output is
+`PASS core_shortening_verify.py`; the deterministic receipt is
+[CORE-SHORTENING-RESULTS.json](CORE-SHORTENING-RESULTS.json).
+
+
+## Dependencies, interpretation and attribution
+
+The signed proper-star definitions, paired-cube geometry, and predecessor
+attribution follow [MINIMUM-WORDS.md](MINIMUM-WORDS.md) and
+[HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md). The graph identification used for
+V0 is proved in [HIGHER-GRAPH.md](HIGHER-GRAPH.md). The shortening
+filtration above is proved directly from the proper-star generators,
+without assuming that fixing original pairs also fixes their signs.
+
+This note concerns C+ exactly. C− is a subspace, so it inherits the
+weight-sixteen barrier and the weight-fourteen classification, but no
+equality of the full two shortened spaces is asserted. The global
+second-weight classification, without a preassigned common core, has
+a separate proof in [FIFTH-WEIGHT.md](FIFTH-WEIGHT.md).
+
+These are scalar information statements. They do not price source access,
+helpers, frame changes, copies, restoration, or recursive children.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance, including
+separate AI-assisted proof review and an independently written finite
+checker; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/FIFTH-WEIGHT.md b/research/asymmetric-hypercube-decoder/FIFTH-WEIGHT.md
new file mode 100644
index 0000000000..765d74a3e0
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/FIFTH-WEIGHT.md
@@ -0,0 +1,641 @@
+# The fifth generalized weight and the second-weight codewords
+
+**A uniform five-weight prefix; no new κ.** For every `k>=2` and `q=p-k>=3`,
+both signed proper-star codes have
+
+```text
+d_5(C^-_{p,k}) = d_5(C^+_{p,k}) = 10q.
+```
+
+Together with the preceding notes, this determines their first five weights
+for the whole range:
+
+```text
+(d_1,d_2,d_3,d_4,d_5) = (2q+2, 4q+3, 6q+3, 8q+2, 10q).
+```
+
+The proof also classifies every word of the second nonzero weight `4q+2`: it
+is exactly the sum of two adjacent minimum stars. These are scalar
+linear-information statements. Five selectable targets therefore need
+exactly `10q-5` deletions. No cost for acquiring the star totals, complete
+paid supplier, or improvement to κ is asserted.
+
+## Notation and dependencies
+
+A port chooses k signed coordinates from distinct original pairs among p
+pairs. A star `m_L` is the binary containment indicator of a signed partial
+port L. The code `C^+_{p,k}` spans stars with `0<=|L|<k`, and `C^-_{p,k}`
+omits the empty star. For a code C, `d_r(C)` is the minimum support union of
+an r-dimensional subcode. All vector spaces are over `F_2`. Lower bounds are
+proved in `C^+`; the attaining constructions lie in `C^-`.
+
+We use the following results with their existing proofs and attribution:
+
+- [MINIMUM-WORDS.md](MINIMUM-WORDS.md): minimum distance `2q+2` and
+  minimum-star rigidity for `q>=2`; the `q=1` minimum-distance bound.
+- [EQUALITY-PAIR.md](EQUALITY-PAIR.md): `d_2=4q+3`, with optimal planes
+  generated by two adjacent minimum stars.
+- [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md): the full gap above minimum
+  weight, `d_3=6q+3` for `q>=3`, and the `q=2` boundary values.
+- [FOURTH-WEIGHT.md](FOURTH-WEIGHT.md): `d_4=8q+2` and classification
+  of all optimal four-dimensional subcodes for `q>=3`.
+- [CUBE-OPTIMIZERS.md](CUBE-OPTIMIZERS.md): at `q=2,k>=4`, every optimal
+  rank-three support-fourteen and rank-four support-fifteen subcode is
+  localized to one ordinary cube, and all its nonzero words have weight
+  eight. The first five weights at this boundary are `(6,11,14,15,16)`.
+- [HIGHER-GRAPH.md](HIGHER-GRAPH.md): the complete `k=2` hierarchy.
+
+Generalized-cube and even-face parity are used in the form stated and
+credited in [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md#inputs-and-attribution).
+An original pair is universal for a word or subcode if every occupied port
+uses it. Its degree in a support union is the number of occupied ports using
+it. Avoiding a pair decreases q by one; taking the sum of the two sign
+slices at a universal pair decreases p and k by one and preserves q.
+Shortening on a fixed signed face is exactly the lifted smaller proper-star
+code, as proved in
+[FOURTH-WEIGHT.md](FOURTH-WEIGHT.md#signed-face-shortening).
+
+Every codeword has even weight. The weights of all nonzero words of an
+r-dimensional subcode sum to `2^(r-1)` times its support size. An affine
+coset of an r-dimensional subcode supported on A has total weight
+`2^(r-1)|A|+2^r b`, where b is the weight of its common restriction outside
+A. We use these averaging identities repeatedly.
+
+## The attaining five-star construction
+
+Fix a signed `(k-2)`-face K and five signed coordinates `a_1,...,a_5` from
+distinct original pairs outside K. The five stars `m_(K+a_i)` have pairwise
+intersections of size one, all distinct, and no triple intersections. Their
+support union has size
+
+```text
+5(2q+2) - binom(5,2) = 10q.
+```
+
+They are independent. For each i, choose any j different from i and extend
+`K+a_i` by the coordinate opposite to `a_j`. This port belongs to star i and
+to none of the other four stars, giving an identity evaluation matrix. This
+also works when `q=3`, where all five residual pairs are selected. All five
+rows lie in `C^-`.
+
+## An individual weight-eight lemma at q=2
+
+For a word w of weight 8, every nonuniversal original pair has degree at
+most 4: its avoidance is nonzero at q=1 and has minimum weight 4. If c
+original pairs are universal and t=k-c, incidence gives
+
+    8t <= 4(t+2),
+
+so t<=2. Thus there are at least k-2 universal pairs.
+
+There cannot be exactly k-1. In that case there are three residual-pair
+blocks, each of weight at most 4. In the common-core notation, each residual
+sign sum H_r has even parity on core faces fixing at most 2 signs, and
+weight at most 4<8, hence vanishes. Collapse paired residual signs to scalar
+functions F_r on core signs; each has support at most 2, and the three
+support sizes sum 4. Every difference F_r+F_s has even parity on faces
+fixing at most 1 sign, so if nonzero has weight at least 4.
+
+If some F_r is zero, all other F_s have weight at most 2 and must also be
+zero, contradiction. Otherwise the support sizes are 2,1,1. A size-one
+function differs from any other on at most 3 positions, forcing all three
+functions equal, again contradiction. Singleton-face cases are included in
+the same even-face argument. Therefore the universal-pair count is exactly k
+or exactly k-2.
+
+If exactly k-2, fix the common original core K. The four residual pairs are
+all nonuniversal and each has degree at most 4. Every occupied port uses two
+of them, so their total degrees equal 16 and all four degrees are 4. Every
+ordinary residual-edge block has even weight. Divide its weight by two and
+form a weighted graph on the four residual pair indices. Every vertex has
+degree 2. Consequently the graph is either two disjoint edges of weight 2,
+or a four-cycle whose edges have weight 1.
+
+The four-cycle is impossible. Write it r-s-t-u-r, each edge block having two
+distinct occupied ports. In the r-s block these two ports agree on every
+sign of K: fix a core sign by replacing its opposite choice in the
+corresponding generalized-cube slot with a coordinate from one of the unused
+residual pairs. The replacement branch omits a universal pair and vanishes,
+so both fixed-sign parities are even.
+
+Now take ordinary core slots, an ordinary r-slot, and the mixed slot
+{s^a,t^b}. The r-t block is absent, so generalized-cube parity forces the
+number of the two r-s ports with s-sign a to be even. Their s-signs are
+therefore equal. An ordinary s-slot and mixed {r^a,u^b}, using the absent
+s-u block, force equal r-signs too. They agree on all k coordinates and are
+the same port, contradiction.
+
+Thus an individual weight-eight word either lies in one ordinary cube, or
+has exactly k-2 universal pairs and is supported on two complementary
+residual-edge ordinary cubes, with four ports in each. We do not need any
+further classification of those four-port slices here.
+
+## Every second-weight word is an adjacent-star sum
+
+For all k>=2 and q>=3, every word of weight 4q+2 is the sum of two adjacent
+minimum stars. In particular its universal original-pair set has exactly k-2
+elements, and all its ports fix the signs on that set.
+
+First suppose avoiding some nonuniversal pair r leaves a minimum word of
+weight 2q. Lift that minimum star to the full port set, obtaining a minimum
+star g of weight d=2q+2. The lift has exactly two ports using r, and agrees
+with w away from r. The word h=w+g is supported on r. The r-part of w has
+size (4q+2)-2q=d, so
+
+    wt(h)=d+2-2e,    e in {0,1,2}.
+
+The full spectral gap excludes d+2<4q+2 and the minimum-distance bound
+excludes d-2. Thus e=1 and h is a minimum star. Their intersection has size
+1, since wt(w)=2d-2. Hence w is the claimed adjacent-star sum.
+
+It remains to prove that such a minimum avoidance exists.
+
+At q=3, suppose none exists. Every nonuniversal pair then has avoidance
+weight at least 8, so degree at most 6. If c is the universal-pair count,
+incidence gives
+
+    (k-c)(14-6)<=6q=18,
+
+forcing c>=k-2. The c=k case is impossible by the single-cube even-face
+bound 16. If c=k-1, residual blocks have size at most 6. Common-core
+sign-pairing and block equality make the weight a multiple of 2(q+1)=8, not
+14. Thus c=k-2.
+
+On the five residual pairs form the graph whose edge weights are half the
+even ordinary-block weights. Its total edge weight is 7, and every vertex
+degree is at most 3. The degree sequence must be (3,3,3,3,2). Delete any
+degree-three vertex r. The remaining word has weight 8 at q=2, and contains
+the same k-2 universal core pairs. By the weight-eight lemma it is either
+one ordinary cube or two complementary four-port blocks. The former would
+require an edge of graph weight 4, exceeding its endpoints' original degree
+bound 3. Thus the latter holds, and every edge away from r has weight 0 or 2.
+Every edge of the five-vertex graph avoids at least one of its four
+degree-three vertices. All edge weights are consequently even, contradicting
+the odd vertex degrees. This proves the q=3 base.
+
+For q>=4 the existing gap theorem at q-1 suffices directly. If there is no
+minimum avoidance, every nonuniversal pair has avoidance weight at least
+4(q-1)+2=4q-2, and hence degree at most 4. Incidence gives
+
+    (k-c)(4q-2)<=4q,
+
+so c>=k-1. The one-cube case is excluded by its bound 2^(q+1)>4q+2. For
+c=k-1, block sizes at most 4 give the common-core divisibility 2(q+1) |
+(4q+2), which is impossible. The claim follows for all q>=3.
+
+## The fifth-weight lower bound at q=3: pair kernels
+
+Suppose V has dimension five and support U of size n<=29. We will derive a
+contradiction. Minimum stars have weight 8; nonminimum words have weight at
+least 14. Any five distinct minimum stars have union at least
+5*8-binom(5,2)=30, so V contains at most four minimum words.
+
+For a pair r, let L_r be the kernel of restriction to ports avoiding r.
+Kernel support and avoidance support are disjoint. Kernel dimensions three
+or four would give respectively
+
+    d_3(q=3)+d_2(q=2)=21+11=32,
+    d_4(q=3)+d_1(q=2)=26+6=32,
+
+both impossible. A dimension-two kernel needs at least 15+14=29 ports. A
+nonminimum dimension-one kernel needs at least 14+15=29. We now exclude
+these equality cases using the q=2 optimizer classification.
+
+### Excluding a two-dimensional kernel
+
+Attaining rank-three support 14 or rank-four support 15 at q=2 forces k>=4:
+the established k=2,3 third weight is 15 and generalized weights are
+strictly increasing. Thus every invocation of the q=2 optimizer
+classification below is inside its stated k>=4 domain.
+
+Such a kernel can occur only when n=29. Its support A has size 15 and is an
+optimal plane generated by two adjacent minimum stars f,g. The avoidance
+image has support B of size 14 and dimension three; its seven nonzero words
+all have weight 8, and its support is contained in an ordinary cube on a set
+J of k original pairs, excluding r. Every occupied port using r belongs to
+A.
+
+Every global minimum word of V lies wholly in A or wholly in B: its
+restriction to B is zero or has weight 8, its entire minimum weight. Fix i
+in J and suppose i is not universal for V. The avoidance-i image is
+supported inside A, so has support at most 15.
+
+Its kernel cannot have dimension zero: a rank-five q=2 image needs at least
+16 ports. It cannot have dimension two either. Such a kernel would be an
+optimal plane with two adjacent minimum stars. They cannot lie one in A and
+one in B because those supports are disjoint. They cannot both lie in B
+because their union would have size 15>14. If both lie in A, their span is
+L_r; then A uses i, as does B, making i universal after all.
+
+A nonminimum kernel line would have weight 14. Equality in the support bound
+forces all occupied i-ports to be precisely its support. Since B consists of
+14 such ports, that word is the indicator of B. Its image under avoidance of
+r would have weight 14, contradicting the constant weight 8 of the q=2 image
+on B.
+
+The remaining possibility is a minimum-star kernel line. Its rank-four q=2
+image must have support at least 15, and hence exactly A; in particular all
+of A avoids i. By the q=2 rank-four optimizer classification, every nonzero
+word of that image has weight 8. But f+g, of weight 14, survives unchanged
+on A, contradiction.
+
+Therefore every i in J is universal for V. A port in A would then have to
+use those k pairs and also r, impossible. This excludes every
+two-dimensional pair kernel.
+
+### Excluding a nonminimum kernel line
+
+Again equality is required: n=29, its word has weight 14 on A, and its
+rank-four q=2 image has support B of size 15. That optimizer is localized to
+an ordinary cube on k pair indices J excluding r. For i in J, the
+avoidance-i image is supported in A and has size at most 14. If i were
+nonuniversal, a zero kernel would leave rank-five and need at least 16
+ports; a one-dimensional kernel would leave rank-four and need at least 15.
+Kernel dimension two was just excluded, as were three and four. Thus i is
+universal for every i in J, incompatible with A's ports using r.
+
+Consequently every original-pair avoidance kernel is zero, a line generated
+by a minimum star, or all V.
+
+## The fifth-weight lower bound at q=3: low-weight words
+
+There is a word of weight 14 in V. Otherwise all nonzero weights are 8 or at
+least 16. With m<=4 minimum words, their sum is at least 496-8m>=464. Since
+it equals 16n<=464, equality requires n=29, m=4, and all other words of
+weight 16. But the four minimum stars have total individual size 32 and
+union at most 29, so some two intersect. Their sum has weight 14 after all.
+
+By the second-weight classification a weight 14 word fixes a signed core K
+of size k-2, which is exactly its universal original-pair set. A pair in K
+has an avoidance kernel containing this nonminimum word; by the pair-kernel
+exclusions that kernel must be all V. Thus K is universal for V. It is
+exactly V's universal pair set, since no additional pair is universal for
+the weight 14 word.
+
+Every minimum star in V contains K in its defining face. Otherwise one could
+extend that face using an available pair different from the omitted core
+pair, contradicting universality. It therefore fixes the signs on K. The
+second-weight classification likewise shows that every weight 14 word of V
+fixes all K signs. Shortening on any fixed signed assignment to K is exactly
+the lift of the graph code C+_(5,2). Hence the subcode W spanned by all
+weight 8 and weight 14 words lies in the direct sum, over core-sign
+assignments, of those lifted graph codes. Put a=dim W.
+
+We first prove a>=4. If a<=3 there are at most 7 nonzero words in W. Also
+m<=3: any four distinct minimum stars are independent, since a sum of three
+has weight at least 3*8-2*3=18>8. Every nonzero word outside W has weight at
+least 16. Consequently the total word weight is at least
+
+    8m+14(7-m)+24*16 = 482-6m >= 464.
+
+Using seven slots for W can only lower this bound when a<3. Since the actual
+sum is 16n<=464, equality forces n=29, m=3, a=3, and all four remaining
+nonzero words of W to have weight 14. The three minimum stars span W, but
+their sum has weight at least 18. Contradiction.
+
+If a=5, then V itself lies in that direct sum of graph codes. Let r_sigma be
+the ranks of its projections into nonzero sign sectors. Their sum is at
+least five; choose smaller nonnegative ranks summing exactly five. The first
+five graph weights at q=3 are
+
+    d_r(C+_(5,2))=8r-binom(r,2),    1<=r<=5.
+
+The support in the direct sum is at least the sum of these weights. For any
+partition sum r_sigma=5 this sum equals
+
+    (85-sum r_sigma^2)/2 >= (85-25)/2 = 30,
+
+contradicting n<=29. Thus a=4.
+
+## The fifth-weight lower bound at q=3: the final coset
+
+Let A be the support of W and B=U\A. The scalar fourth-weight theorem gives
+|A|>=26. All sixteen words in the other coset of W have weight at least 16.
+Their total weight is 8|A|+16|B|=16n-8|A|. Therefore
+
+    256 <= 16n-8|A|,    so |A| <= 2n-32 <= 26.
+
+Every inequality is an equality: n=29, |A|=26, |B|=3, and all sixteen coset
+words have weight 16. By the fourth-weight equality classification, W is a
+four-star clique. Its four private column labels each occur 5 times, and its
+six pair-intersection column labels each occur once.
+
+Choose a representative h of the other coset. Since W vanishes on B and B is
+the union's outside support, h is one at all three B-ports. Thus h+w has
+weight 13 on A for every w in W. Label A by its nonzero evaluation vectors x
+in F_2^4. For each label x define
+
+    c_x = sum over ports with label x of (-1)^(h(port)).
+
+The equality wt((h+w)|A)=13 for every w says
+
+    sum_x c_x (-1)^(w.x) = |A|-2*13 = 0
+
+for every w in F_2^4. Fourier inversion forces every c_x=0. Thus every
+nonzero label occurs an even number of times, half with each h-value. This
+contradicts the multiplicity-one pair-intersection labels (and also the
+multiplicity-five private labels) of the four-star clique.
+
+All rank-five supports of size at most 29 are excluded. The five-star
+construction gives support 30, proving `d_5=30` at `q=3` for every `k>=2`.
+
+## Induction to every q>=4
+
+For q>=4 put d=2q+2, s=4q+2, and suppose a rank-five subcode V has union U
+of size n<=10q-1. Assume d_5(q-1)=10q-10. Pair avoidance kernels of ranks
+2,3,4 would give respectively
+
+    d_2(q)+d_3(q-1)=10q,
+    d_3(q)+d_2(q-1)=10q+2,
+    d_4(q)+d_1(q-1)=10q+2.
+
+A rank-one nonminimum kernel gives at least s+d_4(q-1)=12q-4>n. Thus every
+kernel is zero, a minimum-star line, or all V. Injective avoidance gives
+pair degree at most 9; a minimum-star kernel gives at most n-d_4(q-1)<=d+3.
+A pair in two minimum-star cores is therefore universal for V. There are at
+most four minimum words, since any five minimum-star supports have union at
+least 5d-10=10q.
+
+Exactly k-1 universal original pairs are impossible. Each residual block has
+degree at most 9 (none of these pairs lies in a minimum-star core; any
+minimum word in its kernel would have its full core among the universal
+pairs, making the residual pair nonuniversal for that word). Sign-sum parity
+forces even blocks, hence degree at most 8. Collapsing residual signs gives
+vector blocks of size at most 4; pairwise differences have weight at most
+8<2^q, so are zero. All q+1 blocks are identical, hence n>=5d>10q-1.
+
+Let m be the number of minimum stars in V.
+
+### m=0
+
+Let c be the global universal-pair count and t=k-c. Incidence gives
+
+    t(n-9)<=9q.
+
+All 31 nonzero words have weight at least s, so n>=ceil(31s/16). For q>=4,
+2(n-9)>9q, forcing t<=1. The t=1 case is the common-core contradiction. If
+t=0, ordinary-cube even-face parity gives every nonzero word weight at least
+2^(q+1), or zero if singleton faces apply. Averaging forces
+n>=31*2^(q-3)>10q-1. Contradiction.
+
+### m=1
+
+Let A be the minimum star's support and B=U\A. The outside image has rank 4.
+Each nonzero image word comes from two nonminimum words, so has weight at
+least s-d/2=3q+1. Averaging gives
+
+    |B|>=ceil(15(3q+1)/8).
+
+For global-core deficit t, the t-1 nonglobal defining pairs have B-degree at
+most 3, and the q+1 other pairs at most 9-2=7. Thus
+
+    t(|B|-3)<=7q+4.
+
+Twice the left factor's lower bound exceeds 7q+4 for q>=4, so t<=1. The
+common-core contradiction applies.
+
+### m=2
+
+Let the two stars meet in e in {0,1}; their union A has size 2d-e. The full
+kernel outside A is their span since |A|<d_3(q). The image has rank 3. Each
+nonzero image word comes from four nonminimum words, so has weight at least
+ceil(s-|A|/2)=2q+e. Therefore
+
+    4|B|>=7(2q+e).
+
+Coincident original cores give the common-core contradiction. Otherwise
+write their intersection size k-1-u, u>=1. The 2u private core pairs have
+B-degree at most 1+e; the q+1-u other pairs have B-degree at most 9-4=5.
+Every B-port uses u+1 slots outside the universal intersection, yielding
+
+    (u+1)|B|<=2u(1+e)+5(q+1-u)=5q+5+u(2e-3).
+
+For e=0, the left is at least 7q while the right is at most 5q+2,
+impossible. For e=1, adjacency gives u=1; the left is at least 7q+4 while
+the right is 5q+4, also impossible.
+
+### m=3
+
+Pairs occur in zero, one, or all three cores. Let the common core be K and
+each private core have size u. If u=0, common-core contradiction applies. A
+private pair has A-degree d+4 minus its star's number of intersections with
+the other two. Since its union degree is at most d+3, each star has an
+adjacent neighbor. Disjoint private cores force u=1, and intersection is
+equality of the signs on K, so the three-star adjacency graph is a union of
+cliques with no isolated vertex: it is a triangle.
+
+Thus A has size 6q+3. The outside kernel is exactly this rank 3 span, since
+|A|<d_4(q), and the image has rank 2. Each of its three nonzero words comes
+from eight nonminimum words, so has weight at least ceil(s-|A|/2)=q+1. Hence
+
+    2|B|>=3(q+1).
+
+The three selected residual pairs have B-degree at most 1, and the other q-1
+residual pairs have B-degree at most 9-6=3. Incidence gives
+
+    2|B|<=3+3(q-1)=3q,
+
+contradiction.
+
+### m=4
+
+Pairs occur in zero, one, or all four minimum-star cores. Write their common
+core K and private sets of equal size u. If u=0, common-core contradiction
+applies. A private pair has union degree at least d+6-j, where j is that
+star's number of neighbors among the other three; those other stars cannot
+intersect on this private pair. The bound d+3 forces j=3 for each star. Thus
+u=1 and the four stars share one signed (k-2)-core, with four distinct
+residual coordinates. Their union A has size 8q+2.
+
+Their span has rank 4; the other sixteen words are nonminimum. The coset
+identity gives
+
+    |B|>=s-|A|/2=1.
+
+Every selected residual pair already has A-degree d+3, so B avoids all four.
+Each of the other q-2 residual pairs has A-degree 8 and union degree at most
+9, so its B-degree is at most 1. Each B-port uses two of these pairs. Any
+ordinary cube containing such a port has exactly one occupied point, since
+the degree bound permits no other B-port on either residual pair and A uses
+a selected pair. This contradicts vector ordinary-cube parity. The q=3 base
+is proved above, so this completes the induction.
+
+## All rank-five optimizers for q>=4
+
+For every k>=2,q>=4, an optimal rank-five subcode is exactly the span of
+five minimum stars with a common signed (k-2)-core and five residual signed
+coordinates from distinct original pairs. The count is
+
+    2^(k+3) binom(p,k-2) binom(q+2,5).
+
+Prescribed five targets attain 10q-5 deletions exactly when some such
+five-star matrix has rank five on those targets.
+
+### Pair kernels
+
+Put N=10q, d=2q+2, s=4q+2. A pair-avoidance kernel of rank three or four would
+give at least 10q+2 ports. A nonminimum line would give s+d_4(q-1)=12q-4>N
+for q>=4. Thus proper kernels have rank one, generated by a minimum star, or
+rank two.
+
+If a pair has rank two kernel L, the kernel and image bounds sum exactly N:
+
+    d_2(q)+d_3(q-1) = (4q+3)+(6q-3)=10q.
+
+Both are optimal: L contains two minimum stars, and the image is a
+three-star triangle with three independent minimum words of weight 2q. Each
+such image word has four lifts. Their sum of weights is
+
+    2(4q+3)+4(2q)=16q+6 < 4s.
+
+Thus one lift is a minimum star. Choosing one for each of the three
+independent image minima gives five independent minimum stars in V.
+
+It remains to rule out fewer minima when no rank two pair kernel exists.
+Every injective avoidance has pair degree at most N-d_5(q-1)=10. A
+minimum-star kernel gives degree at most N-d_4(q-1)=d+4. A pair lying in at
+least two minimum-star defining cores is universal for all V. There are at
+most five minimum stars, since six would have union at least 6d-15=12q-3>N.
+
+### Common-core exclusion
+
+If exactly k-1 original pairs are universal for V, every other pair has
+injective avoidance: a minimum star supported on the common original core is
+not universal on any residual pair. Every residual block has size at most 10.
+Its sign sum vanishes by even-face weight bound 2^(q+1)>10. The collapsed
+blocks have size at most 5; their pairwise differences have weight at most
+10<2^q and vanish. All q+1 blocks are identical. Rank five therefore needs at
+least five distinct nonzero labels and N>=5d=10q+10, contradiction.
+
+### Zero or one minimum word
+
+With no minima, let t=k-c, where c is the global universal-pair count.
+Incidence gives t(N-10)<=10q, forcing t<=1. The t=1 case is the preceding
+common-core contradiction. For t=0, the single-cube even-face bound and
+averaging give N>=31*2^(q-3)>10q, also impossible.
+
+With one minimum star, its support A has size d, and B=U\A has size
+N-d=8q-2. If t=k-c, the t-1 nonglobal defining pairs have B-degree at most 4,
+and the q+1 other pairs at most 8. Thus
+
+    t(|B|-4)<=8q+4.
+
+For q>=4 this forces t<=1, again the common-core contradiction.
+
+### Two minimum words
+
+Let their intersection size be e in {0,1}. Their union A has size 2d-e, so
+|B|=6q-4+e. Coincident original-pair cores are excluded by the common-core
+argument. Otherwise write the common core size as k-1-u, u>=1. The 2u private
+pairs have B-degree at most 2+e; the q+1-u pairs outside both cores have
+B-degree at most 6. Therefore
+
+    (u+1)(6q-4+e) <= 2u(2+e)+6(q+1-u)
+                       = 6q+6+2u(e-1).
+
+For e=0 the left is at least 12q-8 and the right at most 6q+4. For e=1,
+adjacency gives u=1, and the left is 12q-6 while the right is 6q+6. Both are
+impossible for q>=4.
+
+### Three minimum words
+
+Every original pair belongs to zero, one, or all three defining cores. Write
+the common core as K and the three disjoint private core sets as having
+equal size u. The case u=0 is the common-core contradiction.
+
+If u>=2, no two stars can intersect. Their union A has size 3d=6q+6, and
+|B|=4q-6. A private pair already has A-degree d+4, its full allowance, so B
+avoids all 3u private pairs. There are q+1-2u original pairs outside all
+three cores. Each has A-degree 6 and union degree at most 10, so its
+B-degree is at most 4. Every B-port uses u+1 such pairs. Hence
+
+    (u+1)(4q-6)<=4(q+1-2u),
+
+impossible for q>=4,u>=2.
+
+If u=1, let e be the number of pairwise star intersections. Their
+intersection graph is a union of cliques indexed by agreement of the signs
+on K, so e is 0, 1, or 3. The three pair intersections, when present, are
+distinct, and no triple intersection occurs. Thus
+
+    |A|=3d-e,    |B|=4q-6+e.
+
+For a selected residual pair, its A-degree is d+4 minus its star's number of
+neighbors. Its B-degree is consequently at most that number of neighbors.
+These three capacities sum 2e. The q-1 other residual pairs have B-degree at
+most 4. Counting two residual slots per B-port gives
+
+    2(4q-6+e)<=2e+4(q-1),
+
+which would require q<=2. Contradiction.
+
+### Four minimum words
+
+Pairs again occur in zero, one, or all four defining cores. Write their
+common core as K, with disjoint private sets of size u. The case u=0 was
+excluded. A private pair of a star with j neighbors among the other three
+has A-degree d+6-j. Since its union degree is at most d+4, j>=2. An
+intersection forces u=1, and the intersection graph is a union of cliques
+indexed by the signs on K. A graph on four vertices whose components are
+cliques and whose minimum degree is at least 2 must be K4. Thus the four
+stars form a clique with
+
+    |A|=8q+2,    |B|=2q-2.
+
+Each of the four selected residual pairs has A-degree d+3 and B-degree at
+most 1. Each of the q-2 other residual pairs has A-degree 8 and B-degree at
+most 2. Incidence gives
+
+    2|B|<=4+2(q-2)=2q,
+
+contradicting 2|B|=4q-4 for q>=4.
+
+### Geometry, uniqueness, and targets
+
+All cases with fewer than five minimum stars are excluded. The five are
+independent: any sum of j of them,2<=j<=4, has weight at least
+jd-2*binom(j,2)>d, so cannot be another minimum star. Their union bound
+5d-binom(5,2)=N is attained. Hence every pair intersects in one port, and no
+three share a port. As in the fourth-weight classification, these faces have
+a common signed (k-2)-core and five distinct residual signed coordinates
+from distinct original pairs.
+
+A sum of j of these five stars has weight j(2q+3-j),1<=j<=5. Only j=1 is
+minimum. Thus the five generators, their core, and their unordered residual
+coordinates are recovered from the subcode. The count is
+
+    2^(k-2) binom(p,k-2) * 2^5 binom(q+2,5),
+
+as claimed. For prescribed targets `T_1,...,T_5`, form
+
+```text
+E_ij = 1[K union {a_i} is contained in T_j].
+```
+
+Exactly `10q-5` deletions suffice if and only if some such E is invertible.
+For sufficiency, left-multiply the column of star rows by `E^(-1)` and
+delete their union outside the target set. For necessity, five unit
+decoders at that budget span an optimal subcode and thus have the stated
+five-star form. Their restriction to the targets must have full rank.
+Failure of the criterion gives a lower bound of `10q-4` deletions; no exact
+larger budget is claimed.
+
+## Simultaneous targets and the scalar scope
+
+An r-dimensional subcode with support W has r independent evaluation
+columns. Selecting those coordinates as targets and changing the row basis
+makes their evaluation matrix the identity. Deleting the other `|W|-r`
+coordinates then gives simultaneous unit decoders. Conversely, r unit
+decoders supported on the targets and deletions are independent, so their
+combined support has size at least `d_r`.
+
+Consequently the five-star witness and lower bound give exactly `10q-5`
+deletions for five selectable targets. The private ports in the construction
+give an explicit information set. At power-of-two k, the original
+overlap-class corrections are already in the nonempty proper-star span, so
+the same statement applies to that corrected scalar model.
+
+This threshold does not charge for supplying the underlying star totals. It
+does not constitute a paid multiplication construction or improve κ.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/GRAPH-TARGETS-RESULTS.json b/research/asymmetric-hypercube-decoder/GRAPH-TARGETS-RESULTS.json
new file mode 100644
index 0000000000..dcf600fc51
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/GRAPH-TARGETS-RESULTS.json
@@ -0,0 +1,2888 @@
+{
+  "arithmetic": "exact F2 integer bitsets",
+  "forest_formula": "E-r-binomial(2p-r,2)+p-nu(T); nu checked by matching and root-choice DP",
+  "integer_inequality_cases": 9996,
+  "literal_controls": {
+    "p3_square_budgets": [
+      null,
+      null
+    ],
+    "p3_triangle_budgets": [
+      null,
+      5
+    ]
+  },
+  "negative_controls": [
+    "omitting the constant row loses triangle units",
+    "an even target cycle is impossible in both models",
+    "two edge-disjoint odd cycles cancel global parity",
+    "target-column independence alone does not isolate targets",
+    "every one-deletion restoration of each p4 optimum loses a required unit"
+  ],
+  "p2": {
+    "all_budgets_sha256": "a7c5cc5026890408e914ed336706794a9c805a95f13a78bc46dc69257789230d",
+    "budget_histograms": [
+      {
+        "0": 1,
+        "1": 14,
+        "None": 1
+      },
+      {
+        "0": 1,
+        "1": 14,
+        "None": 1
+      }
+    ],
+    "by_target_size": {
+      "0": [
+        {
+          "0": 1
+        },
+        {
+          "0": 1
+        }
+      ],
+      "1": [
+        {
+          "1": 4
+        },
+        {
+          "1": 4
+        }
+      ],
+      "2": [
+        {
+          "1": 6
+        },
+        {
+          "1": 6
+        }
+      ],
+      "3": [
+        {
+          "1": 4
+        },
+        {
+          "1": 4
+        }
+      ],
+      "4": [
+        {
+          "None": 1
+        },
+        {
+          "None": 1
+        }
+      ]
+    },
+    "forest_target_sets": 15,
+    "model_target_cases": 32,
+    "partition_records": [
+      15,
+      49
+    ],
+    "retained_graphs": 16,
+    "target_sets": 16
+  },
+  "p3": {
+    "all_budgets_sha256": "0934d3ae73bdf97e0b831b6b8c37b93814709c698d965df5a00852271fd4dd20",
+    "budget_histograms": [
+      {
+        "0": 1,
+        "3": 12,
+        "5": 66,
+        "6": 200,
+        "7": 804,
+        "None": 3013
+      },
+      {
+        "0": 1,
+        "3": 12,
+        "4": 66,
+        "5": 220,
+        "6": 1648,
+        "None": 2149
+      }
+    ],
+    "by_target_size": {
+      "0": [
+        {
+          "0": 1
+        },
+        {
+          "0": 1
+        }
+      ],
+      "1": [
+        {
+          "3": 12
+        },
+        {
+          "3": 12
+        }
+      ],
+      "10": [
+        {
+          "None": 66
+        },
+        {
+          "None": 66
+        }
+      ],
+      "11": [
+        {
+          "None": 12
+        },
+        {
+          "None": 12
+        }
+      ],
+      "12": [
+        {
+          "None": 1
+        },
+        {
+          "None": 1
+        }
+      ],
+      "2": [
+        {
+          "5": 66
+        },
+        {
+          "4": 66
+        }
+      ],
+      "3": [
+        {
+          "6": 200,
+          "7": 12,
+          "None": 8
+        },
+        {
+          "5": 220
+        }
+      ],
+      "4": [
+        {
+          "7": 408,
+          "None": 87
+        },
+        {
+          "6": 480,
+          "None": 15
+        }
+      ],
+      "5": [
+        {
+          "7": 384,
+          "None": 408
+        },
+        {
+          "6": 672,
+          "None": 120
+        }
+      ],
+      "6": [
+        {
+          "None": 924
+        },
+        {
+          "6": 496,
+          "None": 428
+        }
+      ],
+      "7": [
+        {
+          "None": 792
+        },
+        {
+          "None": 792
+        }
+      ],
+      "8": [
+        {
+          "None": 495
+        },
+        {
+          "None": 495
+        }
+      ],
+      "9": [
+        {
+          "None": 220
+        },
+        {
+          "None": 220
+        }
+      ]
+    },
+    "forest_target_sets": 1083,
+    "model_target_cases": 8192,
+    "partition_records": [
+      203,
+      1539
+    ],
+    "retained_graphs": 4096,
+    "target_sets": 4096
+  },
+  "p3_literal_triple_witnesses": [
+    {
+      "left": [
+        1,
+        2
+      ],
+      "orbit_size": 24,
+      "quotient_columns": [
+        5,
+        7,
+        1
+      ],
+      "right": [
+        4,
+        5
+      ],
+      "target": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        2
+      ],
+      "orbit_size": 12,
+      "quotient_columns": [
+        4,
+        6,
+        5
+      ],
+      "right": [
+        4,
+        5
+      ],
+      "target": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          3
+        ],
+        [
+          1,
+          2
+        ]
+      ]
+    },
+    {
+      "left": [
+        2,
+        3
+      ],
+      "orbit_size": 48,
+      "quotient_columns": [
+        5,
+        1,
+        6
+      ],
+      "right": [
+        4,
+        5
+      ],
+      "target": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          1,
+          2
+        ]
+      ]
+    },
+    {
+      "left": [
+        1,
+        2
+      ],
+      "orbit_size": 48,
+      "quotient_columns": [
+        7,
+        1,
+        4
+      ],
+      "right": [
+        4,
+        5
+      ],
+      "target": [
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          1,
+          2
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        4
+      ],
+      "orbit_size": 24,
+      "quotient_columns": [
+        4,
+        6,
+        1
+      ],
+      "right": [
+        2,
+        3
+      ],
+      "target": [
+        [
+          0,
+          4
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          1,
+          2
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        1
+      ],
+      "orbit_size": 8,
+      "quotient_columns": [
+        5,
+        6,
+        7
+      ],
+      "right": [
+        3,
+        5
+      ],
+      "target": [
+        [
+          0,
+          2
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          2,
+          4
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        1
+      ],
+      "orbit_size": 24,
+      "quotient_columns": [
+        5,
+        6,
+        2
+      ],
+      "right": [
+        2,
+        5
+      ],
+      "target": [
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          4
+        ],
+        [
+          2,
+          4
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        1
+      ],
+      "orbit_size": 24,
+      "quotient_columns": [
+        5,
+        6,
+        4
+      ],
+      "right": [
+        2,
+        4
+      ],
+      "target": [
+        [
+          0,
+          3
+        ],
+        [
+          0,
+          5
+        ],
+        [
+          2,
+          4
+        ]
+      ]
+    },
+    {
+      "left": [
+        0,
+        1
+      ],
+      "orbit_size": 8,
+      "quotient_columns": [
+        6,
+        5,
+        4
+      ],
+      "right": [
+        2,
+        4
+      ],
+      "target": [
+        [
+          0,
+          5
+        ],
+        [
+          1,
+          3
+        ],
+        [
+          2,
+          4
+        ]
+      ]
+    }
+  ],
+  "p4": {
+    "by_target_size": {
+      "3": [
+        {
+          "12": 1968,
+          "13": 24,
+          "None": 32
+        },
+        {
+          "12": 2000,
+          "13": 24
+        }
+      ],
+      "4": [
+        {
+          "14": 8124,
+          "15": 1728,
+          "None": 774
+        },
+        {
+          "14": 10524,
+          "None": 102
+        }
+      ]
+    },
+    "cases": [
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          12643911,
+          12643911
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 64,
+        "retained_masks": [
+          9046719,
+          9046719
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          13,
+          13
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 24,
+        "retained_masks": [
+          15728767,
+          15728767
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          13500543,
+          13500543
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          12640383,
+          12640383
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          4001228,
+          4001228
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          9046782,
+          9046782
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          12
+        ],
+        "decoder_assignments": [
+          0,
+          32768
+        ],
+        "orbit_size": 32,
+        "retained_masks": [
+          null,
+          925245
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          12648006,
+          12648006
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          4005258,
+          4005258
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          9050811,
+          9050811
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8436347,
+          8436347
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          4617968,
+          4617968
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 32,
+        "retained_masks": [
+          4001982,
+          4001982
+        ],
+        "target": [
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          8436473,
+          8436473
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          12,
+          12
+        ],
+        "decoder_assignments": [
+          4096,
+          32768
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          4617275,
+          4617275
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 24,
+        "retained_masks": [
+          52303,
+          52287
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          8432215,
+          8432215
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          12583039,
+          57471
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          786559,
+          835709
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          49279,
+          52350
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          9044095,
+          9044095
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          8429695,
+          8429695
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          2689500,
+          2689500
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          null
+        ],
+        "decoder_assignments": [
+          0,
+          0
+        ],
+        "orbit_size": 6,
+        "retained_masks": [
+          null,
+          null
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            3
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          12583165,
+          57597
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            3
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 24,
+        "retained_masks": [
+          49405,
+          52476
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            3
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          8429821,
+          8429821
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            3
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          null
+        ],
+        "decoder_assignments": [
+          0,
+          0
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          null,
+          null
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          12583294,
+          57726
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          49531,
+          52602
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          9044347,
+          9044347
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          8429947,
+          8429947
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          14
+        ],
+        "decoder_assignments": [
+          0,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          null,
+          7743
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          56395,
+          7487
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8436307,
+          8436307
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          14
+        ],
+        "decoder_assignments": [
+          0,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          null,
+          6847
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8436310,
+          8436310
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          2693530,
+          2693530
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          4593329,
+          4593329
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          4224626,
+          4224626
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          12587134,
+          7806
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          53371,
+          7550
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          790654,
+          7422
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          8433787,
+          8433787
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          9048190,
+          9048190
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          2691198,
+          2691198
+        ],
+        "target": [
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          4593392,
+          4593392
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          14
+        ],
+        "decoder_assignments": [
+          0,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          null,
+          7869
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            4
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          56521,
+          7613
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          53435,
+          839866
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            5
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          8436433,
+          8436433
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8433851,
+          8433851
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8436436,
+          8436436
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          2691262,
+          2691262
+        ],
+        "target": [
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          4224752,
+          4224752
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          14
+        ],
+        "decoder_assignments": [
+          0,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          null,
+          7162
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            2
+          ],
+          [
+            1,
+            4
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8434105,
+          8434105
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            1,
+            4
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          2691766,
+          2691766
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            3
+          ],
+          [
+            1,
+            5
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          9049147,
+          9049147
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          8434747,
+          8434747
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          4592699,
+          4592699
+        ],
+        "target": [
+          [
+            0,
+            2
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 384,
+        "retained_masks": [
+          4224059,
+          4224059
+        ],
+        "target": [
+          [
+            0,
+            3
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          15,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          144443,
+          422963
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          1390000,
+          1390000
+        ],
+        "target": [
+          [
+            0,
+            6
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            5
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          1389622,
+          1389622
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            5
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          null,
+          null
+        ],
+        "decoder_assignments": [
+          0,
+          0
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          null,
+          null
+        ],
+        "target": [
+          [
+            0,
+            4
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          2709912,
+          2709912
+        ],
+        "target": [
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            6
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 96,
+        "retained_masks": [
+          2709928,
+          2709928
+        ],
+        "target": [
+          [
+            0,
+            5
+          ],
+          [
+            0,
+            7
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          4608314,
+          4608314
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            4
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 192,
+        "retained_masks": [
+          2710432,
+          2710432
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            5
+          ],
+          [
+            2,
+            4
+          ],
+          [
+            2,
+            6
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 12,
+        "retained_masks": [
+          1143861,
+          1143861
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            6
+          ],
+          [
+            2,
+            5
+          ],
+          [
+            3,
+            4
+          ]
+        ]
+      },
+      {
+        "budgets": [
+          14,
+          14
+        ],
+        "decoder_assignments": [
+          4096,
+          65536
+        ],
+        "orbit_size": 48,
+        "retained_masks": [
+          2218848,
+          2218848
+        ],
+        "target": [
+          [
+            0,
+            7
+          ],
+          [
+            1,
+            5
+          ],
+          [
+            2,
+            6
+          ],
+          [
+            3,
+            4
+          ]
+        ]
+      }
+    ],
+    "decoder_assignments": [
+      266240,
+      4063232
+    ],
+    "forest_orbits": 65,
+    "one_deletion_restorations_rejected": 1845,
+    "orbits": 73,
+    "partition_records": [
+      4140,
+      75905
+    ],
+    "target_sets": 12650
+  },
+  "scope": "Proper-star observations for k=2, with and without the empty star. All target sets at p=2,3 and all triples/quadruples at p=4 are checked. The uniform theorems are proved in GRAPH-TARGETS.md; no physical-cost or kappa claim.",
+  "status": "PASS"
+}
diff --git a/research/asymmetric-hypercube-decoder/GRAPH-TARGETS.md b/research/asymmetric-hypercube-decoder/GRAPH-TARGETS.md
new file mode 100644
index 0000000000..65b566326e
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/GRAPH-TARGETS.md
@@ -0,0 +1,435 @@
+# Exact prescribed-target deletion budgets for signed two-ports
+
+**All prescribed forests in C−; exact partition optimization in C±. No new κ.**
+
+The selectable-target hierarchies and graph-code literature context are in
+[HIGHER-GRAPH.md](HIGHER-GRAPH.md). Here the target coordinates are prescribed
+in advance, which can change the optimal deletion budget.
+
+## Model
+
+Let p≥2. The vertices of G are 0,…,2p−1, with original matched pairs
+{0,1},{2,3},…,{2p−2,2p−1}. The edges are all pairs of vertices from distinct
+original pairs; there are E=2p(p−1) edges. These edges are the signed two-ports.
+The code C− is the binary row span of the vertex-incidence matrix, and C+
+also contains the constant edge row. For p≥3 that row is independent; at
+p=2 the graph is a four-cycle and the two codes coincide.
+
+For a prescribed target edge set T, delete a set D disjoint from T and
+retain F=G\D. Every nontarget input on F remains unrestricted. The targets
+are individually decodable precisely when every unit row e_t, t∈T, belongs
+to the observation row span restricted to F. Define δ±(T) to be the minimum
+|D|, or infinity if there is no such D. Independence of the target columns
+by themselves is necessary but does not imply this unit-row condition on F.
+
+All ranks, sums, and parity statements below are over F2.
+
+## The exact optimization theorem
+
+Let P partition the 2p vertices into h nonempty blocks, and let b(v) denote
+the block of v. Let z(P) count the edges of G whose endpoints share a block.
+For each target uv define its ordinary quotient column
+
+    q_P(uv) = e_b(u) + e_b(v) ∈ F2^h.
+
+Also color each block by s_v∈F2, allowing empty color classes. Let z(P,s)
+count the edges of G inside blocks that join opposite colors. Define the
+colored quotient column
+
+    q_(P,s)(uv) = (e_b(u)+e_b(v), 1+s_u+s_v) ∈ F2^(h+1).
+
+Colorings differing by a flip of an entire block are equivalent and may be
+represented once. Define maxima only over partitions/colorings whose |T|
+target quotient columns are linearly independent. Give an empty family
+maximum −infinity, so an infinite resulting budget means infeasibility. Then
+
+    δ−(T) = E−|T|−max_P z(P),                                  (1)
+    δ+(T) = E−|T|−max{ max_P z(P), max_(P,s) z(P,s) }.          (2)
+
+These formulas give an exact finite combinatorial optimization for every
+prescribed target set and every p. Independence excludes a target from the
+counted zero edges, because such an edge has zero quotient column.
+
+To prove completeness, combine the desired unit decoders into a vector
+output in F2^r, r=|T|, with target outputs the r standard basis vectors.
+Their coefficients are vertex labels a_v∈F2^r and a constant vector b,
+where b=0 in C−. The output at edge uv is a_u+a_v+b. Every retained
+nontarget edge has zero output.
+
+If b=0, group vertices with equal labels. Saturating every block with all
+available induced edges adds only zero-output edges. The quotient target
+columns map to distinct standard basis vectors and therefore are independent.
+If b≠0, group labels into unordered pairs {a,a+b}, and color each block by
+which label occurs. Saturating all opposite-color edges inside these blocks
+again adds only zero-output edges, and the colored quotient columns are
+independent. This proves that every feasible decoder is bounded by (1)–(2).
+Conversely, independent quotient columns admit a linear map taking them to
+the r standard basis vectors. Composing this map with the quotient columns
+produces actual vertex coefficients and, in the colored case, a constant
+coefficient. Retain the counted zero edges and T. This gives the required
+unit rows and proves attainment. The argument remains valid if a saturated
+block happens to split into several graph components.
+
+## Feasibility and cycle interpretation
+
+For a retained graph F, the nullspace of its incidence matrix is the binary
+cycle space Z(F), namely all even-degree edge subsets. Its augmented
+incidence nullspace consists of those z∈Z(F) with even cardinality. Write
+π(z)=|z| mod 2 and ε_t(z)=z_t. Row-space/nullspace duality shows
+
+    t is decodable in C−|F iff ε_t=0 on Z(F),
+    t is decodable in C+|F iff ε_t vanishes on ker π.
+
+The first condition says exactly that t is a bridge. The second says
+ε_t=0 or ε_t=π as functionals on Z(F). Thus the constant row can supply
+one global odd-cycle parity. For example, two edge-disjoint odd cycles
+sum to an even dependency, so no edge on either can supply a target unit.
+If odd cycles overlap, only their symmetric-difference edges are ruled out
+by that particular dependency; shared edges must still be tested against
+all cycles.
+
+Consequently, prescribed T is feasible in C− iff T is a forest. It is
+feasible in C+ iff it is a forest or has exactly one cycle in total and
+that cycle is odd. For necessity, any dependence among columns of T
+survives every deletion. The cycle space of T must have dimension zero in
+C−; in C+ the parity map must be injective on that cycle space, forcing
+dimension at most one and odd parity in dimension one. For sufficiency,
+retain only T. This statement includes multiple tree components alongside
+one odd unicyclic component.
+
+## Every prescribed forest has an exact matching formula
+
+If T contains a cycle, δ−(T)=infinity. Otherwise let T be a forest of r edges,
+including isolated vertices among its components Q_1,…,Q_s. Then
+
+    s=2p−r.
+
+Construct a bipartite graph with these components on the left and the p
+original matched pairs on the right. Give Q_i capacity |Q_i|−1 and each
+original pair capacity one. Join Q_i to an original pair when Q_i contains
+at least one of that pair's vertices. Let ν(T) be the maximum integral
+b-matching size. Then
+
+    B(T) = binom(s,2) − p + ν(T),
+    δ−(T) = E − r − B(T).                                  (F)
+
+In particular this is an exact polynomial-time combinatorial formula for
+any prescribed target forest, not just a generalized-weight bound for a
+selectable target set. The empty forest has ν=0 and δ−=0.
+
+## Matching interprets the best root construction
+
+Choose one root in each Q_i, and let R be the r nonroot vertices. The
+maximum possible number of original pairs hit by R is exactly ν(T).
+
+For one direction, choose one representative vertex from R for each original
+pair hit. Assign that representative to its target component. Each component
+receives at most |Q_i|−1 representatives, giving a feasible b-matching.
+For the converse, realize a maximum b-matching by choosing, for each matched
+component/pair incidence, one vertex in their intersection. Different matched
+pairs give distinct vertices. Fill each component's chosen vertices to its
+capacity |Q_i|−1, leaving one root. This extension cannot hit more than ν(T)
+original pairs by the first direction, and it already hits ν(T), so equality
+holds.
+
+The s roots contain exactly p−ν(T) complete original matched pairs: a pair
+is wholly among the roots exactly when R does not hit it. Retain all graph
+edges induced by the roots, and retain T. There are B(T) zero edges. Every
+target component meets the root block once, so contracting that block leaves
+a forest. Hence every target edge is a bridge and supplies its unit row.
+This constructs the budget on the right side of the forest formula.
+
+## Any retained witness has no more zero edges
+
+Let F be an arbitrary feasible retained graph and H=F\T its nontarget graph.
+Every target edge must be a bridge in F, because the nullspace of a graph's
+binary incidence matrix is its cycle space. Removing the r bridges creates
+r additional components, so H has at least r+1 components.
+
+Also every component of H meets each target tree Q_i at most once. Otherwise
+the target path between two such vertices, together with an H-path joining
+them, would put a target edge on a cycle, contradicting the bridge condition.
+
+If H has at most one nonsingleton component, that component is therefore a
+partial root transversal. Extend it to one root in every Q_i, and saturate
+the resulting root block. This retains at least as many zero edges and
+is bounded by B(T). This handles H with more than r+1 components as well.
+
+It remains to bound H with at least two nonsingleton components. A set of
+v vertices induces at most
+
+    f(v)=binom(v,2)−max(0,v−p)
+
+edges. The increments f(v+1)−f(v)=v−1[v≥p] are nondecreasing. Concentrating
+vertices into one largest block while preserving a second nonsingleton
+block, and making all other blocks singletons, gives
+
+    |H| ≤ f(s−1)+f(2)=f(s−1)+1,                            (M)
+
+provided s≥3. If s≤2, H cannot have two nonsingleton components, since its
+at least r+1=2p−s+1 components leave at most s−1≤1 vertices beyond one per
+component.
+
+The gap between the unrestricted one-block maximum and (M) is
+
+    Δ=f(s)−f(s−1)−1=s−2−1[s−1≥p].                        (G)
+
+We compare it with the loss f(s)−B(T).
+
+### When r≤p
+
+Here s≥p and
+
+    f(s)−B(T)=r−ν(T).
+
+Any r vertices hit at least ceil(r/2) original pairs. Thus ν(T)≥ceil(r/2)
+and the loss is at most floor(r/2). If r≤p−1, equation (G) gives
+Δ=2p−r−3≥p−2≥floor(r/2) for p≥3. If r=p, it gives
+Δ=p−2≥floor(p/2), also for every p≥3. Consequently
+
+    f(s−1)+1 ≤ B(T).
+
+### When r≥p
+
+Here s≤p, and
+
+    f(s)−B(T)=p−ν(T).
+
+This is the number of complete original pairs in an optimal s-vertex root
+set, at most floor(s/2). For s≥3, equation (G) gives
+Δ=s−2≥floor(s/2), so (M) is again at most B(T). The case s≤2 was already
+handled without a two-block comparison.
+
+Thus every feasible H has at most B(T) edges. Together with the root
+construction this proves (F) for p≥3. Ties with multiblock witnesses are
+allowed and do occur; the theorem only needs existence of a root optimum.
+For p=2, G is a four-cycle: every nonempty proper edge subset is a forest
+and requires exactly one deletion. Directly ν=1 when r=1 and ν=2 when
+r=2 or 3, so (F) gives one in each case. The empty set gives zero.
+
+## When the constant row provably cannot improve a forest budget
+
+Let C+ also include the constant row, and suppose r≥1. A vector decoder
+assigns vertex coefficients a_v∈F2^r and a constant b∈F2^r, with edge output
+a_u+a_v+b. If b=0, its optimum is already (F). If b≠0, every zero edge
+satisfies a_u+a_v=b, so the zero graph H is bipartite.
+
+For h components of H, the target quotient columns have an incidence part
+of dimension at most h−1 plus one parity coordinate. Independent target
+units therefore require h≥r. The largest possible bipartite edge count
+with at least r components is bounded above by
+
+    floor((2p−r+1)^2/4)=floor((s+1)^2/4),
+
+using the nondecreasing increments of floor(v²/4) to concentrate component
+sizes. It follows that
+
+    B(T) ≥ floor((s+1)^2/4)  implies  δ+(T)=δ−(T).          (C)
+
+This is a sufficient criterion, not asserted to be necessary.
+
+In particular, for every p≥6 and every forest with 1≤r≤p, condition (C)
+always holds. Indeed,
+
+    B(T) ≥ binom(s,2)−p+ceil(r/2)
+         = binom(s,2)−floor(s/2),
+
+and s≥p≥6. For even s=2a the difference from floor((s+1)^2/4) is a(a−3),
+nonnegative for a≥3. For odd s=2a+1 it is (a−1)^2−2, nonnegative for a≥3.
+Thus adding the constant row never changes any such prescribed-forest
+budget. This statement makes no claim for arbitrary r>p or for infeasible
+C− target sets such as odd cycles.
+
+## Prescribed triples, including the constant row
+
+Suppose p≥3 and |T|=3. Call T exceptional if it is a three-edge path in the
+K_(2,2) formed by two original matched pairs. Then:
+
+| Targets | δ−(T) | δ+(T), p≥4 |
+| --- | --- | --- |
+| Triangle | infinity | p²−4 |
+| Exceptional forest | 6p−11 | 6p−11 |
+| Any other forest | 6p−12 | 6p−12 |
+
+At p=3, δ+(T)=5 for every triple; the C− column remains valid. At p=2 every
+triple consists of three edges of the four-cycle, and both budgets are one.
+
+### The forest matching number for triples
+
+At r=3 the forest formula becomes δ−=6p−9−ν(T). The exceptional connected
+path meets just two original pairs, so ν=2. Every other forest triple has
+ν=3, as the following explicit choices of three isolates show:
+
+* A connected three-edge tree has four vertices. Unless exceptional it
+  meets at least three original pairs. Isolate vertices from three different
+  pairs and take the fourth as root. A three-edge star cannot use only two
+  original pairs, since the pair opposite its center supplies at most two leaves.
+* For a two-edge path plus a separate edge, if the path meets three original
+  pairs, choose an endpoint of the separate edge, then isolate path vertices
+  from two different pairs avoiding that endpoint's pair. If the path uses
+  two original pairs, its repeated pair is exhausted by its endpoints. The
+  separate edge therefore has an endpoint in a third pair; select it and
+  one path vertex from each of the other two pairs.
+* For three disjoint edges, select one endpoint from each with distinct
+  original-pair indices. Hall's condition holds: two edges involve at least
+  two original pairs, and three disjoint edges cannot fit into two pairs
+  because that would put six vertices into four positions.
+
+### The nonzero-constant bound
+
+A decoder with nonzero constant has a bipartite zero graph H with at least
+three components, so |H|≤(p−1)² and its deletion budget is at least p²−4.
+For p≥5 this is greater than 6p−11 because
+p²−4−(6p−11)=(p−3)²−2>0. Thus it cannot improve a forest triple's C− budget.
+At p=4 the bound is twelve: all ordinary forest triples already attain it,
+while the exceptional thirteen-deletion case requires the argument below.
+
+### Triangle targets attain p²−4 for every p≥3
+
+Adding the three target unit equations around a triangle forces
+b=e_1+e_2+e_3≠0, so p²−4 is a lower bound. For attainment isolate two triangle
+vertices, and on the remaining 2p−2 vertices retain a complete bipartite
+graph with sides p−1,p−1, along with the three target edges.
+
+The isolates come from distinct original pairs, so the large block consists
+of p−2 full matched pairs and two orphan vertices. If p is even, place one
+orphan on each side and split full pairs equally. If p is odd, place both
+orphans on one side and fill both sides with whole pairs. No missing matched
+edge crosses sides, so all (p−1)² bipartite edges exist. The quotient target
+triangle has three independent augmented columns: its sole cycle has odd
+parity. Thus the construction gives actual units and exactly p²−4 deletions.
+
+### Why the exceptional p=4 path cannot improve to twelve
+
+If it had a twelve-deletion decoder with b≠0, its bipartite zero graph H
+would have nine edges and at least three components. Concentrating component
+sizes shows that nine requires a six-vertex K_(3,3) plus two isolates: a
+second nonsingleton block allows at most floor(25/4)+1=7 edges, and four
+components allow at most floor(25/4)=6. Full original matched pairs inside H
+must lie on the same side, hence their vertex decoder labels are equal. In the target
+path, the two vertices of each of its original pairs are joined by a target
+path of length two. Those two unit equations force their labels to differ
+by the sum of two distinct standard basis vectors. Therefore each target
+original pair must contribute an isolate. The two isolates are exactly one
+vertex from each of the two target pairs.
+
+The remaining target vertices are H's two orphans. As both bipartition sides
+have odd size three and full matched pairs stay on one side, the two orphans
+must lie on opposite sides. Their joining edge is therefore in H. If it is
+a target this contradicts H∩T=∅. Otherwise it is the fourth edge of the
+original K_(2,2), and together with T forms an even four-cycle, again giving
+a target dependence. Thus thirteen deletions are necessary, and the C−
+witness attains them.
+
+### A hand-checkable p=3 boundary certificate
+
+The lower bound is five: b=0 requires at least six deletions by the forest
+formula, and b≠0 requires at least five by the bipartite bound. The following
+table supplies an upper bound for all triples. Matched pairs are
+{0,1},{2,3},{4,5}; notation 02
+means edge {0,2}. Retain H=K_(L,R) and the targets. Every listed H has four
+edges, so F has seven and exactly five edges are deleted.
+
+| Orbit size | Target edges, in order | L | R | Reduced target columns |
+| --- | --- | --- | --- | --- |
+| 24 | 02,03,04 | 1,2 | 4,5 | 5,7,1 |
+| 12 | 02,03,12 | 0,2 | 4,5 | 4,6,5 |
+| 48 | 02,04,12 | 2,3 | 4,5 | 5,1,6 |
+| 48 | 03,04,12 | 1,2 | 4,5 | 7,1,4 |
+| 24 | 04,05,12 | 0,4 | 2,3 | 4,6,1 |
+| 8 | 02,04,24 | 0,1 | 3,5 | 5,6,7 |
+| 24 | 03,04,24 | 0,1 | 2,5 | 5,6,2 |
+| 24 | 03,05,24 | 0,1 | 2,4 | 5,6,4 |
+| 8 | 05,13,24 | 0,1 | 2,4 | 6,5,4 |
+
+For the last column, use color zero on L and color one on R. Color the two
+isolates zero, order them numerically, and assign them block coordinates
+1 and 2; assign the large component coordinate zero. The parity coordinate
+is the bit 4. Each displayed integer is the corresponding three-bit column
+from the optimization theorem. Every triple consists of distinct nonzero
+vectors whose XOR is nonzero, so every triple has rank three. This verifies
+the individual target units on the entire retained graph.
+
+The nine orbits are under permutations of the three original pairs and
+independent swaps inside them (48 automorphisms). Their sizes sum to
+220=binom(12,3). Completeness can also be seen by shape: one star orbit;
+three connected-path orbits (two original pairs, or a repeated pair at
+path distance two or three); three two-edge-path-plus-edge orbits (repeated
+path-end pair, or the separate edge joining partners of center/end versus
+both ends); one triangle orbit; and one perfect-matching orbit. The table
+therefore proves δ+=5 for every p=3 triple without a large computational
+assumption.
+
+## Standalone finite verifier and receipt
+
+Python 3.10 or later is required. From the repository root:
+
+```sh
+python3 -I -B research/asymmetric-hypercube-decoder/graph_targets_verify.py
+python3 -I -O -B research/asymmetric-hypercube-decoder/graph_targets_verify.py --self-test
+python3 -I -B research/asymmetric-hypercube-decoder/graph_targets_verify.py --write /tmp/graph-targets.json
+python3 -I -B research/asymmetric-hypercube-decoder/graph_targets_verify.py --check /tmp/graph-targets.json
+```
+
+The standard-library script imports no repository or scratch modules. By
+default it recomputes and compares [GRAPH-TARGETS-RESULTS.json](GRAPH-TARGETS-RESULTS.json).
+`--write` writes only after all computations and requested checks pass;
+`--check EXISTING --write OUTPUT` verifies EXISTING before touching OUTPUT.
+Writes use a same-directory temporary file and atomic replacement. The
+self-test copies only the script and receipt into an otherwise empty
+directory, performs an isolated optimized replay, rejects a corrupted
+mathematical receipt field while preserving an existing output, and checks
+cleanup and preservation after a simulated atomic replacement failure.
+Every mathematical check uses an explicit exception, not a removable assertion.
+
+The finite coverage is independent of the uniform proofs:
+
+* For p=2 and p=3, enumerate every retained graph and test each target unit
+  by exact binary column rank. A maximum superset transform obtains exact
+  budgets for all 16 and 4,096 target sets. Compare both models with separate
+  partition optimization: 8,224 model/target cases. The cycle-functional
+  characterization is checked on every retained graph in both models.
+* For p=4, enumerate all 16 triple and 57 quadruple target orbits, covering
+  2,024 triples and 10,626 quadruples. Compare partition optimization with
+  exhaustive decoder vertex-label assignments satisfying the actual distinct
+  standard-basis target values: 266,240 C− and 4,063,232 C+ assignments.
+  All 146 model/orbit exact optima agree. Every attaining witness retains
+  its targets and passes direct unit-row tests.
+* Independently compute ν by augmenting-path capacity matching and literal
+  root-choice dynamic programming. Their forest formula agrees with all
+  p=2/p=3 targets (15/1,083 forests) and all p=4 orbits (65 forest orbits).
+  The concentration and constant-row arithmetic is also checked for the
+  9,996 pairs 3≤p≤100, 1≤r≤2p−1 in the respective stated domains.
+* Verify the nine literal p=3 witnesses above, their orbit sizes, and their
+  reduced target columns. Reject all 1,845 one-deletion restorations of the
+  p=4 optimum witnesses. Other adversarial checks reject omission of the
+  constant row, even target cycles, two edge-disjoint odd cycles, and the
+  false inference from target-column independence to retained unit decoding.
+
+The receipt includes all 73 p=4 representatives and literal retained masks,
+plus complete budget histograms and hashes of the p=2/p=3 budget tables.
+The quadruple results below are exact finite findings; no uniform
+prescribed-quadruple theorem for C+ is inferred from them.
+
+| Domain | C− budgets, with target-set counts | C+ budgets, with target-set counts |
+| --- | --- | --- |
+| p=3 triples | 6:200; 7:12; infinity:8 | 5:220 |
+| p=3 quadruples | 7:408; infinity:87 | 6:480; infinity:15 |
+| p=4 triples | 12:1968; 13:24; infinity:32 | 12:2000; 13:24 |
+| p=4 quadruples | 14:8124; 15:1728; infinity:774 | 14:10524; infinity:102 |
+
+## Interpretation and attribution
+
+For k=2, the permitted overlap correction C_1({a,b}) equals the sum of the
+two singleton-star rows at a and b, including after deletion. Adding such
+corrections changes neither observation span. Arbitrary exact postprocessing
+of the same linear observations also cannot defeat the unit-row condition:
+if a target coordinate does not vanish on the observation kernel, two inputs
+with the same observations have different target values.
+
+These are observation-span deletion budgets. They assign no physical cost
+to helper creation, access, copying, or restoration, and make no claim about
+multiplication bounds or κ.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance. Copyright
+2026 Sam Sung; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/ODD-NATIVE-COST.md b/research/asymmetric-hypercube-decoder/ODD-NATIVE-COST.md
new file mode 100644
index 0000000000..13ce17c98f
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/ODD-NATIVE-COST.md
@@ -0,0 +1,304 @@
+# Whole-template cost ceilings for native odd-size star observations
+
+The known paired odd-size decoder escapes the even-size COPY obstruction,
+but for every odd `k>=5` its literal odd-degree proper-star observations
+cannot improve the campaign-start selected bound in the inherited odd-stage
+template with at least five stages. Even granting arbitrarily efficient
+shared native helpers, free scalar work and restoration, and favorable
+unsplit frame climbs, its bit saving satisfies
+
+```text
+c < 107/66606 = 0.0016064618803110831...
+```
+
+This is below the pinned campaign-start selected value
+`1661634653669567/10^18`. The result rejects a specified observation and
+compiler class. A separately stated conditional three-stage extension also
+excludes odd `k>=7`. Three stages at `k=5`, arbitrary recoded observations,
+and later copies whose innovations have smaller frames remain outside these
+bounds. No new κ or physically admissible supplier is claimed.
+
+## 1. Observation and compiler hypotheses
+
+Use the full paired k-port family for odd `k>=5` on p original coordinate
+pairs, with `v=2^k binom(p,k)` independent scalar sources and rational
+incidence labels `chi_S` in dimension `h=2p`. The proposed decoder acquires
+every star of each odd degree `1,3,...,k-2` once per local invocation as a
+**native observation**: its COPY frame contains every source label in that
+star's support. Target corrections at intersection one are granted free.
+
+Preparation may use arbitrarily shared and efficient monotone helpers. Their
+scalar work, dirt compensation, restoration and finite compilation charges
+are granted zero for this upper bound. However, the required native copies
+still pay their frame dimensions. The native condition matters: if a later
+literal star is synthesized using earlier copied observations, its innovation
+may have a smaller frame than its full source support. Such COPY-assisted
+recoding is not covered by the frame lower bound below.
+
+Conditionally retain the inherited odd-stage source/target endpoint schedule
+and whole-call hosting accounting, with
+
+```text
+L=2K+1 >= 5,    a=h-1=2p-1,    m=1+La,
+```
+
+and T replicas. Source and target frame climbs have total rank a in every
+local invocation. Whole-call hosting replaces idle ranks by helper residual
+widths and the remaining idle complement. Additional whole banks add one
+full address dimension m of rank mass for each new live family, leaving the
+rank deficit unchanged. These are explicit compiler hypotheses, checked
+against the pinned predecessor sources in Section 6. A different compiler
+or different endpoint accounting is outside the theorem.
+
+The scalar identity itself is inherited binomial incidence algebra. For
+odd k, summing the odd proper stars contained in T evaluates to
+`sum_(odd l<k) binom(j,l)` on a source with `j=|S intersect T|`. This is one
+at `j=1,k` and zero elsewhere: the full odd sum is `2^(j-1)` for `j>=1`,
+and the omitted top term changes the value at `j=k`. Thus these observations
+give the target indicator plus the whole intersection-one class. This note
+contributes the uniform cost ceiling for the stated physical class, not
+that identity or a new construction of its helper word.
+
+## 2. Native COPY rank
+
+For `p>k`, a literal l-star with `1<=l<k` has rational support-label rank
+exactly `2(p-l)`. To prove this, fix its defining face J and write its
+source labels as `chi_J+chi_A`, with A a signed `(k-l)`-port on the `p-l`
+residual pairs. Differences of these labels span the sum-zero subspace of
+the residual coordinates. Sign flips give within-pair differences, and
+single-pair substitutions give differences between distinct pairs, since
+`0<k-l<p-l`. One source label adds the final independent direction.
+
+Conversely, all coordinates in J have the same value, their opposite
+coordinates vanish, and the residual-coordinate sum is `k-l` times that
+value. This gives the matching dimension upper bound. Keeping only the
+required degree `k-2` observations gives
+
+```text
+rho = C/v >= [2^(k-2) binom(p,k-2) * 2(p-k+2)]
+             / [2^k binom(p,k)]
+          = k(k-1)/[2(p-k+1)]
+          >= 10/(p-4),    odd k>=5, p>k.             (1)
+```
+
+At `p=k`, the degree `k-2` observations alone are nonzero and number
+`2^(k-2) binom(k,2)`. Rank at least one per required native copy gives
+`C/v>=k(k-1)/8>1`, already excluding positive rank deficit.
+
+As a worked case, at `k=5,p>5`, point and three-coordinate stars give the
+more precise native COPY bound
+
+```text
+C >= 4p(p-1) + 16(p-3) binom(p,3),
+rho >= 10/(p-4) + 15/[(p-2)(p-3)(p-4)].
+```
+
+The weaker uniform inequality (1) is sufficient for the cost ceiling.
+
+## 3. A favorable full rank moment
+
+The inherited schedule has `W_0=(L-1)vT` data families and rank deficit
+
+```text
+D = T[(L-1)v-LC].                                   (2)
+```
+
+The following derivation also checks the mass behind that expression.
+For each local invocation, grant each source and target climb as one
+unsplit child of rank a. At `0<c<1`, splitting a climb only increases the
+sum of child ranks to the power `1-c`.
+
+The actual inherited idle schedule contributes, for each `j=1,...,K-1`,
+`4vT` children of rank `2aj` and `2vT` children of rank a. Including all
+L local invocations, an optimistic source/idle profile is therefore
+
+```text
+rank a:    2vT[L+(K-1)] = 6KvT children,
+rank 2aj:  4vT children, for j=1,...,K-1.             (3)
+```
+
+Its rank mass is `La(L-1)vT`. Adding the `LTC` required native COPY mass
+makes the total `mW_0-D`, as asserted in (2).
+
+For whole-call hosting, an idle rank r is replaced by helper climb pieces
+whose total widths are `w_1,...,w_t`, and a residual idle rank
+`r-sum_i w_i`. All pieces are nonnegative and sum to r. Since
+
+```text
+sum_i r_i^(1-c) >= (sum_i r_i)^(1-c),    0<c<1,
+```
+
+this refinement cannot improve the moment relative to the unsplit profile.
+It also cannot reduce its first logarithmic derivative: for pieces summing
+to r,
+
+```text
+sum_i r_i log(m/r_i) - r log(m/r)
+    = sum_i r_i log(r/r_i) >= 0.
+```
+
+Extra whole banks may increase the actual family count `W_actual` beyond
+`W_0`. Each adds mass m per family, so the actual mass remains
+`m W_actual-D`. Their logarithmic derivative is nonnegative. This explicitly
+accounts for the denominator change: the argument below uses the actual
+mass and actual family count, not a comparison that silently fixes W.
+All other positive work only worsens the favorable profile.
+
+## 4. A uniform ceiling without a parameter search
+
+Let B denote `sum_r r H(r) log(m/r)` for the source/idle profile (3),
+ignoring the positive derivative from native COPY terms. In the actual
+normalized moment, `exp(cz)>=1+cz` gives
+
+```text
+moment(c) >= 1-D/(m W_actual) + c B/(m W_actual).
+```
+
+Consequently any strict saving with `0<c<1` requires `c<D/B`. As `m/a>L`,
+profile (3) gives
+
+```text
+B > (L-1)vT a F(K),
+F(K) = 3 log(2K+1)
+       +(4/K) sum_(j=1..K-1) j log[(2K+1)/(2j)].      (4)
+```
+
+For every `K>=2`,
+
+```text
+F(K) > 6.6606.                                      (5)
+```
+
+No monotonicity assumption is needed. At `K=2`, use
+`F(2)=3 log5+2 log(5/2)>6.6606`. For `K=3`, keep the `j=2` term to get
+`3 log7+(8/3)log(7/4)>7.3299`. For `K=4`, keep `j=3` to get
+`3 log9+3log(3/2)>7.8078`. For `K>=5`, use
+`3log(2K+1)>=3log11>7.1934`. Each exceeds the common lower bound required
+below.
+
+If `p<=14`, equation (1) gives `rho>=1`, hence `D<0`. Otherwise, weakening
+both the numerator and the COPY bound in a favorable direction yields
+
+```text
+c < (1-rho)/[(2p-1)*6.6606]
+  <= (p-14)/[(p-4)(2p-1)*6.6606].                   (6)
+```
+
+The quadratic `214p^2-10963p+140428` is strictly positive for every real p:
+its leading coefficient is positive and its discriminant is `-18999`.
+For `p>14`, this is exactly the inequality
+
+```text
+(p-14)/[(p-4)(2p-1)] < 107/10000.
+```
+
+Thus
+
+```text
+c < 107/66606 < 1661634653669567/10^18.              (7)
+```
+
+The bit saving must exceed the assembled κ in the inherited assembly.
+Therefore this class cannot improve even the campaign-start selected bound.
+The bit half also remains subject to the complex and outer assembly; none
+of those costs is removed by this argument.
+
+The displayed logarithm lower bounds have exact rational certificates.
+For rational `x>1`, set `z=(x-1)/(x+1)`. The positive series gives
+
+```text
+log x > 2 sum_(j=0..99) z^(2j+1)/(2j+1).
+```
+
+Using this finite rational sum verifies all four lower bounds above. The
+quadratic discriminant and comparison (7) are integer/rational identities.
+They were independently checked with standard-library `Fraction` arithmetic;
+no floating-point estimate is needed for the ceiling. The numerical decimal
+is for orientation only.
+
+## 5. A conditional three-stage extension for odd k>=7
+
+The pinned compiler implements `L>=5`. This section is a conditional
+extension of its rank schedule to `L=3`, not an assertion that it emits a
+legal three-stage physical supplier. Retain the same endpoint and complete
+bank accounting. Now `K=1`, there are no idle intervals, and formula (3)
+consists only of the six source/target climbs per port. Formula (4) remains
+valid with `F(1)=3log3>3.2958`; for `K>=2` the stronger previous bound applies.
+
+For every odd `k>=7`, the highest required degree gives
+
+```text
+rho >= k(k-1)/[2(p-k+1)] >= 21/(p-6),    p>k.
+```
+
+The `p=k` boundary was already excluded. Positive deficit now requires
+`p>27`. The same favorable argument gives
+
+```text
+c < (p-27)/[(p-6)(2p-1)*3.2958].
+```
+
+The quadratic `106p^2-10689p+270318` has discriminant `-360111` and is
+positive everywhere. Therefore
+
+```text
+(p-27)/[(p-6)(2p-1)] < 53/10000,
+c < 53/32958 = 0.001608107288063596...
+              < 1661634653669567/10^18.
+```
+
+The logarithm series from Section 4 certifies `3log3>3.2958` exactly;
+the discriminant and final comparison are rational checks. This excludes
+odd `k>=7` even in that favorable three-stage extension. It leaves
+`k=5,L=3` and the paired-triple case open in the stated cost model.
+
+## 6. Scope, predecessors and immutable sources
+
+The compiler and hosting trace is pinned to main commit
+`91a2094f2e022930069e8cfdc810a3ea1b81cd09`. The same pinned selected
+certificate supplies the comparison value in (7); it is a historical
+campaign-start reference, not a claim that the selected frontier is frozen.
+Any later increase of that bound remains above this ceiling.
+
+The odd-stage kernel is DreamingOfClouds' generalization of earlier
+chafreaky, Zhihao Chen and eumemic integration. The whole-call hosting
+mechanism is inherited from DaysSky and subsequent hosting refinements.
+The paired-cube geometry and scalar decoder are credited to icekylinx and
+eumemic, and the general binomial expansion is already recorded in
+[`single-intersection.md`](../../docs/research/single-intersection.md).
+The older bounded unshared three-tensor-stage screen in
+[`network-screens.md`](../../docs/research/network-screens.md) is a different
+cost class. This note uses the inherited shared odd-stage idle schedule and
+its full moment instead of repeating that screen.
+
+Concurrent [PR #958 by Ross Richardson](https://github.com/CrocSwap/integer-mult-bounds/pull/958),
+at head `28d68c88f0184835d8c8a7266ab8d0dad3f18a8a`, studies the five-port
+**point-star-only** decoder. It needs readable corrections at overlaps one
+and three and uses the quadratic pairing `2(j-1)(j-3)` to realize both
+zero classes. Its separate-star copy trees and active-frame rank witnesses
+give a distinct cost ceiling. Here the extra three-star observations at
+`k=5` cancel the overlap-three terms, so the stated readability hypothesis
+is only overlap one and the labels are the original incidence vectors.
+Neither note's geometry or accounting bound is silently applied to the
+other. The comparison is based on the actual proof at the pinned PR head.
+
+| Pinned source | Git blob |
+| --- | --- |
+| `certificates/selected-result.json` | `1f107b55a2f045fa66d9c35d658b3b79549f5ba6` |
+| `research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py` | `3df12bd632f1fdba825ced57110a1fee82eb2857` |
+| `research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py` | `8864ca9b942a3507171edca0cf6cbaaf10fcf434` |
+| `research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py` | `68b536daa9e6546c0aa046934bf840aaa3c3fde3` |
+| `docs/research/single-intersection.md` | `7cdf4555e9f9e043debbfe1e3a49fa201234d710` |
+| `docs/research/network-screens.md` | `bc69870f7cfa30752ee898719055db6a8b6903f7` |
+
+This is not an end-to-end supplier replay or a general lower bound on
+odd-k decoding. The genuine remaining alternatives include three-stage
+odd-five helper/bank designs, the paired-triple case, a cheaper native
+recoded observation family, and COPY-assisted innovations. They require
+their own frame histories and
+complete invoices. The even-size result in
+[COPY-OBSTRUCTION.md](COPY-OBSTRUCTION.md) covers a different, wider
+observation class through its odd integral diagonal; that certificate is
+unavailable for the present intersection-one odd-k geometry.
+
+Prepared by Sam Sung with substantial OpenAI Codex assistance; Apache-2.0.
diff --git a/research/asymmetric-hypercube-decoder/README.md b/research/asymmetric-hypercube-decoder/README.md
index 5f0f743fe3..95a6e3ba8e 100644
--- a/research/asymmetric-hypercube-decoder/README.md
+++ b/research/asymmetric-hypercube-decoder/README.md
@@ -2,8 +2,9 @@
 
 **Uniform structural theorems with exact replay; no new κ.** The higher-target
 extension determines a complete hierarchy at `k=2`, the third generalized
-weight for every `k>=2,q=p-k>=2`, the fourth weight and all its optimizers
-for `q>=3`, and a five-weight prefix at `q=2` with all rank-three through
+weight for every `k>=2,q=p-k>=2`, the first five weights for every `q>=3`,
+all fourth-weight optimizers, and all fifth-weight optimizers for `q>=4`.
+At `q=2` it determines a five-weight prefix with all rank-three through
 rank-five optimizers classified.
 A generalized weight `d_r` measures the smallest support of r independent
 observation rows. The exact deletion threshold for **some selectable r-target
@@ -12,13 +13,17 @@ set** is `d_r-r`; arbitrary prescribed target sets are a separate problem.
 | Result | Parameter range | Proof |
 | --- | --- | --- |
 | Complete generalized-weight hierarchies, with and without the empty star | `k=2,p>=2`, every available rank | [HIGHER-GRAPH.md](HIGHER-GRAPH.md) |
+| Exact prescribed-forest matching formula in `C-`, partition optimization in both codes, and every prescribed triple | `k=2,p>=2` | [GRAPH-TARGETS.md](GRAPH-TARGETS.md) |
 | First two nonzero word weights are `2q+2` and `4q+2` | `k>=2,q>=3` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `d_3=6q+3`; every optimum is a triangle of minimum stars | `k>=2,q>=3` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `d_3=15` for `k=2,3`; `d_3=14` for `k>=4` | `q=2` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `(d_1,...,d_5)=(6,11,14,15,16)` | `q=2,k>=4` | [HIGHER-WEIGHTS.md](HIGHER-WEIGHTS.md) |
 | `d_4=8q+2`; every optimum is a four-star clique | `k>=2,q>=3` | [FOURTH-WEIGHT.md](FOURTH-WEIGHT.md) |
+| `d_5=10q`; every second-weight word is an adjacent-star sum | `k>=2,q>=3` | [FIFTH-WEIGHT.md](FIFTH-WEIGHT.md) |
+| Every rank-five optimum is a five-star clique; exact prescribed-five-target criterion | `k>=2,q>=4` | [FIFTH-WEIGHT.md](FIFTH-WEIGHT.md) |
 | Every optimal rank-three, four and five subcode is an affine four-flat code; exact prescribed-target criterion | `q=2,k>=4` | [CUBE-OPTIMIZERS.md](CUBE-OPTIMIZERS.md) |
 | Exact ordinary-cube shortening to a Reed–Muller code, with the empty-star boundary distinguished | `k>=2,q>=0` | [CUBE-OPTIMIZERS.md](CUBE-OPTIMIZERS.md) |
+| Exact original-pair-core shortening with unrestricted core signs; all extra layers have weight at least sixteen | `q=3,k>=2`, shortening `C+` on `k-2` original pairs | [CORE-SHORTENING.md](CORE-SHORTENING.md) |
 
 The boundary is a real change in optimizer structure: every span of three
 minimum stars needs at least fifteen ports, but a localized affine cube has
@@ -37,6 +42,9 @@ deletions exactly when they use the same original pairs and their sign vectors
 are affinely independent. For `q>=3`, prescribed quadruples attain `8q-2`
 deletions exactly when their columns are independent on an optimal four-star
 clique. These statements concern the specified proper-star observation model.
+For `q>=4`, prescribed five-target sets attain `10q-5` deletions exactly
+when their columns are independent on a five-star clique. The rank-five
+optimizer classification at `q=3` remains open in this milestone.
 
 [COPY-OBSTRUCTION.md](COPY-OBSTRUCTION.md) addresses a much larger physical
 class. An integral separating pairing with odd diagonal forces total copied
@@ -46,6 +54,21 @@ paired-port geometry with intersection-one readability satisfies that condition.
 Under the inherited odd-stage rank ledger, `C>=v` prevents a positive saving.
 The actual selected E8 supplier has even diagonal and is outside this obstruction.
 
+[ODD-NATIVE-COST.md](ODD-NATIVE-COST.md) gives a separate uniform ceiling
+for acquiring every literal odd-degree proper star natively. For every odd
+`k>=5`, its bit saving is less than `107/66606` under the inherited schedule
+with at least five stages, even with favorable helper sharing and hosting.
+A separately stated conditional three-stage extension excludes odd `k>=7`.
+Both ceilings are below the campaign-start selected bound. Arbitrary recoded
+observations and COPY-assisted innovations remain outside this result.
+
+For prescribed graph targets, [GRAPH-TARGETS.md](GRAPH-TARGETS.md) goes
+beyond selectable-target weights. Every forest T with r edges has exact
+nonempty-star deletion budget
+`2p(p-1)-r-binom(2p-r,2)+p-nu(T)`, where `nu(T)` is a capacity-matching
+number between target-tree components and original coordinate pairs.
+The empty star does not improve this budget when `p>=6,r<=p`.
+
 The general incidence-code/cut connection is credited to Martínez-Bernal,
 Valencia-Bucio, and Villarreal in the graph note. The uniform minimum distance
 is inherited from Luke Mansoor's #732. Earlier one- and two-target results,
@@ -56,7 +79,7 @@ concurrent source credits, and the original obstruction remain below.
 From the repository root, Python 3.10+ with its standard library:
 
 ```sh
-for check in shortening optimizer block copy_obstruction; do
+for check in shortening optimizer block copy_obstruction core_shortening graph_targets; do
   python3 -I -O -B "research/asymmetric-hypercube-decoder/${check}_verify.py" --self-test || exit
 done
 ```
@@ -82,6 +105,17 @@ isolated optimized relocation, corruption rejection, and output preservation.
   binary/rational matrix checks at `k=2,p=3,...,6` and `k=4,p=4,...,7`, plus
   hypothesis-failure controls and a sequential copy fragment requiring the
   innovation argument. This is not a full physical supplier replay.
+- [core_shortening_verify.py](core_shortening_verify.py): full-generator
+  original-core shortenings at `q=3,k=3,...,6`, all thirty independent
+  sign-polynomial components, all 1,048,576 words of the smallest shortened
+  code, and exact residual-code and core-polynomial distance checks.
+  Its negative controls detect the extra weight-sixteen layers omitted by
+  a model that simply repeats the signed-core graph code.
+- [graph_targets_verify.py](graph_targets_verify.py): all 4,112 target sets
+  at `p=2,3`, all 73 triple/quadruple orbits at `p=4` covering 12,650 target
+  sets, 4,329,472 actual decoder assignments, and 1,845 restoration controls.
+  The exact forest formula is checked independently by capacity matching,
+  root-choice dynamic programming, and full retained-graph or decoder oracles.
 
 The campaign remains active. [CAMPAIGN-18H.json](CAMPAIGN-18H.json) records
 its scope and minimum research period. These completed mathematical milestones
diff --git a/research/asymmetric-hypercube-decoder/core_shortening_verify.py b/research/asymmetric-hypercube-decoder/core_shortening_verify.py
new file mode 100644
index 0000000000..675bc7c958
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/core_shortening_verify.py
@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Independent exact checks of original-core shortening; Python 3.10+.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement CORE-SHORTENING.md; they are not formal proofs.
+"""
+import argparse
+import subprocess
+import tempfile
+from collections import Counter
+from hashlib import sha256
+from itertools import combinations, product
+from math import comb
+from pathlib import Path
+import json
+import sys
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def partials(p, size):
+    for pairs in combinations(range(p), size):
+        for signs in product((0, 1), repeat=size):
+            yield sum(1 << (2 * pair + sign) for pair, sign in zip(pairs, signs))
+
+
+def echelon(rows):
+    pivots = {}
+    for word in rows:
+        while word:
+            pivot = word.bit_length() - 1
+            if pivot not in pivots:
+                pivots[pivot] = word
+                break
+            word ^= pivots[pivot]
+    return sorted(pivots.values(), key=int.bit_length, reverse=True)
+
+
+def remainder(word, basis):
+    for pivot in basis:
+        if word >> (pivot.bit_length() - 1) & 1:
+            word ^= pivot
+    return word
+
+
+def shorten(rows, allowed):
+    pivots, inside = {}, []
+    for word in rows:
+        while word & ~allowed:
+            pivot = (word & ~allowed).bit_length() - 1
+            if pivot not in pivots:
+                pivots[pivot] = word
+                break
+            word ^= pivots[pivot]
+        else:
+            inside.append(word)
+    return echelon(inside)
+
+
+def same_space(left, right):
+    return len(left) == len(right) and all(remainder(word, right) == 0 for word in left)
+
+
+def words(basis):
+    word = 0
+    yield word
+    for index in range(1, 1 << len(basis)):
+        word ^= basis[(index & -index).bit_length() - 1]
+        yield word
+
+
+def unsigned_ladder():
+    family = [sum(1 << i for i in subset) for subset in combinations(range(6), 3)]
+    rows = [sum(1 << i for i, point in enumerate(family) if point & monomial == monomial)
+            for degree in range(3)
+            for subset in combinations(range(6), degree)
+            for monomial in [sum(1 << j for j in subset)]]
+    result = []
+    for excluded in range(4):
+        mask = (1 << excluded) - 1
+        allowed = sum(1 << i for i, point in enumerate(family) if point & mask == 0)
+        actual = shorten(rows, allowed)
+        degree_bound = 2 - excluded
+        expected = echelon(sum(1 << i for i, point in enumerate(family)
+                              if point & mask == 0 and point & monomial == monomial)
+                           for degree in range(degree_bound + 1)
+                           for subset in combinations(range(excluded, 6), degree)
+                           for monomial in [sum(1 << j for j in subset)])
+        require(same_space(actual, expected), 'unsigned shortening ladder')
+        result.append({'excluded_vertices': excluded, 'remaining_coordinates': allowed.bit_count(),
+                       'dimension': len(actual), 'degree_bound': degree_bound})
+    return result
+
+
+def residual_spaces():
+    family = list(partials(5, 2))
+    vertex_stars = [sum(1 << i for i, port in enumerate(family) if port & star == star)
+                    for degree in (0, 1) for star in partials(5, degree)]
+    blocks, affine = [], []
+    for a, b in combinations(range(5), 2):
+        block = sum(1 << i for i, port in enumerate(family)
+                    if port & (3 << (2 * a)) and port & (3 << (2 * b)))
+        blocks.append(block)
+        affine.extend((block, block & vertex_stars[2 * a + 2], block & vertex_stars[2 * b + 2]))
+    spaces = {0: echelon(vertex_stars), 2: echelon(vertex_stars + blocks),
+              3: echelon(affine), 4: echelon(1 << i for i in range(40))}
+    require([len(spaces[j]) for j in (0, 2, 3, 4)] == [10, 15, 30, 40], 'residual dimensions')
+    for previous, following in ((0, 2), (2, 3), (3, 4)):
+        require(all(remainder(word, spaces[following]) == 0 for word in spaces[previous]), 'nested spaces')
+    spectra = {j: Counter(word.bit_count() for word in words(spaces[j])) for j in (0, 2)}
+    require(min(w for w in spectra[0] if w) == 8 and spectra[0][14] == 40, 'residual cut weights')
+    require(min(w for w in spectra[2] if w) == 4, 'unsigned extension distance')
+    adjacent = {vertex_stars[i + 1] ^ vertex_stars[j + 1]
+                for i, j in combinations(range(10), 2) if i // 2 != j // 2}
+    require({word for word in words(spaces[0]) if word.bit_count() == 14} == adjacent, 'weight14 residual classification')
+    require(remainder(blocks[0], spaces[0]) != 0, 'unsigned block must defeat naive tensor')
+    return family, spaces, blocks, spectra
+
+
+def build(k, residual, spaces, blocks):
+    p, c = k + 3, k - 2
+    family = list(partials(p, k))
+    stars = [star for degree in range(k) for star in partials(p, degree)]
+    rows = [sum(1 << i for i, port in enumerate(family) if port & star == star) for star in stars]
+    allowed = sum(1 << i for i, port in enumerate(family)
+                  if all(port & (3 << (2 * j)) for j in range(c)))
+    basis = shorten(rows, allowed)
+    full_rank = len(echelon(rows))
+    require(len(basis) == full_rank - len(echelon(row & ~allowed for row in rows)), 'independent shortening rank identity')
+    residual_index = {port: i for i, port in enumerate(residual)}
+    coordinates = []
+    for i, port in enumerate(family):
+        if allowed >> i & 1:
+            sign = sum(((port >> (2 * j + 1)) & 1) << j for j in range(c))
+            coordinates.append((i, sign, residual_index[port >> (2 * c)]))
+    def transform(word):
+        components = [0] * (1 << c)
+        for i, sign, index in coordinates:
+            if word >> i & 1:
+                components[sign] |= 1 << index
+        for j in range(c):
+            for sign in range(1 << c):
+                if sign >> j & 1:
+                    components[sign] ^= components[sign ^ (1 << j)]
+        return sum(component << (40 * sign) for sign, component in enumerate(components))
+    transformed = echelon(transform(word) for word in basis)
+    require(len(transformed) == len(basis), 'ANF transform injective')
+    dimensions, predicted_rows = [], []
+    for sign in range(1 << c):
+        omitted = c - sign.bit_count()
+        layer = 0 if omitted < 2 else min(omitted, 4)
+        projection = echelon((word >> (40 * sign)) & ((1 << 40) - 1) for word in transformed)
+        require(same_space(projection, spaces[layer]), 'full-generator ANF projection versus filtration')
+        dimensions.append(len(projection))
+        predicted_rows.extend(word << (40 * sign) for word in spaces[layer])
+    predicted = echelon(predicted_rows)
+    require(same_space(transformed, predicted), 'independence of ANF components')
+    formula = 40 * (1 << c) - 30 * (1 + c) - 25 * comb(c, 2) - 10 * comb(c, 3)
+    require(len(basis) == formula, 'dimension formula')
+    naive = echelon(word << (40 * sign) for sign in range(1 << c) for word in spaces[0])
+    require(all(remainder(word, transformed) == 0 for word in naive), 'naive tensor inclusion')
+    extra_weight = None
+    if c >= 2:
+        monomial = (1 << (c - 2)) - 1
+        extra = blocks[0] << (40 * monomial)
+        require(remainder(extra, transformed) == 0 and remainder(extra, naive) != 0, 'extra layer control')
+        extra_weight = 4 * (1 << (c - monomial.bit_count()))
+        require(extra_weight == 16, 'sharp extra-word weight')
+    enumerated = 0
+    low_spectrum = None
+    if k == 3:
+        low_spectrum = Counter()
+        for word in words(basis):
+            enumerated += 1
+            weight = word.bit_count()
+            if weight and weight < 16:
+                low_spectrum[weight] += 1
+                core_signs = {sign for i, sign, index in coordinates if word >> i & 1}
+                require(len(core_signs) == 1, 'low weight must fix core sign')
+        require(dict(low_spectrum) == {8: 20, 14: 80}, 'complete k3 low-weight census')
+    return {'k': k, 'p': p, 'full_ports': len(family), 'global_star_generators': len(stars),
+            'global_rank': full_rank, 'shortening_coordinates': allowed.bit_count(),
+            'shortening_dimension': len(basis), 'ANF_component_dimensions': dimensions,
+            'naive_tensor_dimension': len(naive), 'sharp_extra_word_weight': extra_weight,
+            'full_codewords_enumerated': enumerated, 'nonzero_spectrum_below16': low_spectrum,
+            'predicted_ANF_basis_sha256': sha256(json.dumps(predicted).encode()).hexdigest()}
+
+
+def rm_distances():
+    result = []
+    for c in range(2, 5):
+        for layer in range(2, min(c, 4) + 1):
+            degree = c - layer
+            rows = echelon(sum(1 << point for point in range(1 << c) if point & monomial == monomial)
+                           for size in range(degree + 1)
+                           for subset in combinations(range(c), size)
+                           for monomial in [sum(1 << j for j in subset)])
+            distance = min(word.bit_count() for word in words(rows) if word)
+            require(distance == 1 << layer, 'core polynomial weight bound')
+            result.append({'core_bits': c, 'layer': layer, 'dimension': len(rows),
+                           'enumerated_polynomials': 1 << len(rows), 'minimum_weight': distance})
+    return result
+
+
+def verify():
+    residual, spaces, blocks, spectra = residual_spaces()
+    return {
+        'status': 'PASS',
+        'scope': 'Exact full-generator q3 shortening for k3..6, elementary unsigned ladder, residual spaces and finite low-weight checks; uniform proof is separate.',
+        'unsigned_shortening_ladder': unsigned_ladder(),
+        'residual_spectra': spectra,
+        'core_polynomial_distances': rm_distances(),
+        'cases': [build(k, residual, spaces, blocks) for k in (3, 4, 5, 6)],
+        'negative_controls': [
+            'unsigned residual block is outside C+_(5,2)',
+            'naive tensor omits a verified weight16 shortened word for every tested k>=4',
+        ],
+    }
+
+RECEIPT = 'CORE-SHORTENING-RESULTS.json'
+
+
+def self_test(result):
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result))
+        command = [sys.executable, "-I", "-O", "-B", str(script)]
+        run = subprocess.run(command, capture_output=True, text=True)
+        require(run.returncode == 0, f"isolated optimized relocated replay failed: {run.stderr}")
+        receipt.write_text(json.dumps(dict(result, status="CORRUPTED")))
+        protected = directory / "protected.json"
+        protected.write_text("preserve this output\n")
+        run = subprocess.run(command + ["--check", str(receipt), "--write", str(protected)],
+                             capture_output=True, text=True)
+        require(run.returncode != 0, "corrupt receipt accepted")
+        require(protected.read_text() == "preserve this output\n", "failed check overwrote output")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    parser.add_argument("--check", type=Path)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text()) == result, f"receipt mismatch: {receipt}")
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        args.write.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    print("PASS", Path(__file__).name)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/asymmetric-hypercube-decoder/graph_targets_verify.py b/research/asymmetric-hypercube-decoder/graph_targets_verify.py
new file mode 100644
index 0000000000..853144b7a7
--- /dev/null
+++ b/research/asymmetric-hypercube-decoder/graph_targets_verify.py
@@ -0,0 +1,512 @@
+#!/usr/bin/env python3
+"""Verify prescribed-target deletion budgets for signed two-ports (Python >=3.10).
+
+The graph optimizer uses vertex partitions (with component colorings for C+).
+The independent p=3 oracle enumerates every retained edge set and tests units
+by binary column rank.  The independent p=4 oracle enumerates every decoder
+labeling satisfying the prescribed unit values, modulo common translation.
+
+Copyright 2026 Sam Sung. Apache-2.0. Substantial OpenAI Codex assistance.
+Finite checks supplement GRAPH-TARGETS.md; they do not prove the uniform claims.
+"""
+import argparse
+from collections import Counter
+from hashlib import sha256
+from itertools import combinations, permutations, product
+import json
+from math import comb
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def rank(values):
+    basis = {}
+    for value in values:
+        while value:
+            pivot = value.bit_length() - 1
+            if pivot not in basis:
+                basis[pivot] = value
+                break
+            value ^= basis[pivot]
+    return len(basis)
+
+
+def graph(p):
+    return [(u, v) for u, v in combinations(range(2 * p), 2) if u // 2 != v // 2]
+
+
+def positions(mask):
+    while mask:
+        bit = mask & -mask
+        yield bit.bit_length() - 1
+        mask ^= bit
+
+
+def columns(edges, n, plus):
+    return [(1 << u) ^ (1 << v) ^ ((1 << n) if plus else 0) for u, v in edges]
+
+
+def units(retained, cols):
+    ids = list(positions(retained))
+    dimension = rank(cols[i] for i in ids)
+    return sum(1 << i for i in ids if rank(cols[j] for j in ids if j != i) < dimension)
+
+
+def cycle_units(retained, edges, n, plus):
+    """Fundamental-cycle coordinate functionals, without binary elimination."""
+    adjacency = [[] for _ in range(n)]
+    for i in positions(retained):
+        u, v = edges[i]
+        adjacency[u].append((v, i))
+        adjacency[v].append((u, i))
+    paths = [None] * n
+    tree = 0
+    for root in range(n):
+        if paths[root] is not None:
+            continue
+        paths[root] = 0
+        stack = [root]
+        while stack:
+            u = stack.pop()
+            for v, i in adjacency[u]:
+                if paths[v] is None:
+                    paths[v] = paths[u] ^ (1 << i)
+                    tree |= 1 << i
+                    stack.append(v)
+    cycles = [paths[edges[i][0]] ^ paths[edges[i][1]] ^ (1 << i)
+              for i in positions(retained & ~tree)]
+    parity = sum((c.bit_count() % 2) << j for j, c in enumerate(cycles))
+    answer = 0
+    for i in positions(retained):
+        functional = sum(((c >> i) & 1) << j for j, c in enumerate(cycles))
+        if functional == 0 or (plus and functional == parity):
+            answer |= 1 << i
+    return answer
+
+
+def partitions(n):
+    labels = [0] * n
+    def walk(i, count):
+        if i == n:
+            yield tuple(labels), count
+            return
+        for label in range(count + 1):
+            labels[i] = label
+            yield from walk(i + 1, max(count, label + 1))
+    yield from walk(1, 1)
+
+
+def partition_records(n, edges, plus):
+    records = []
+    for labels, count in partitions(n):
+        free = [i for i in range(n) if i != labels.index(labels[i])]
+        for color_bits in range(1 << len(free)) if plus else (0,):
+            colors = [0] * n
+            for j, i in enumerate(free):
+                colors[i] = (color_bits >> j) & 1
+            reduced = tuple((1 << labels[u]) ^ (1 << labels[v]) ^
+                            (((1 ^ colors[u] ^ colors[v]) << count) if plus else 0)
+                            for u, v in edges)
+            zero = sum(1 << i for i, value in enumerate(reduced) if value == 0)
+            records.append((zero.bit_count(), zero, reduced))
+    records.sort(key=lambda item: (-item[0], item[1], item[2]))
+    return records
+
+
+def partition_optimum(target, cols, records, baseline=None):
+    ids = list(positions(target))
+    if rank(cols[i] for i in ids) != len(ids):
+        return None
+    best = baseline
+    for count, zero, reduced in records:
+        if best is not None and count + len(ids) <= best[0]:
+            break
+        if not zero & target and rank(reduced[i] for i in ids) == len(ids):
+            best = (count + len(ids), zero | target)
+            break
+    require(best is not None, 'a target-independent set needs a retained witness')
+    return best
+
+
+def all_retained_oracle(p, edges):
+    size = 1 << len(edges)
+    best = [[-1] * size for _ in range(2)]
+    witnesses = [[0] * size for _ in range(2)]
+    cols = [columns(edges, 2 * p, plus) for plus in (False, True)]
+    for retained in range(size):
+        weight = retained.bit_count()
+        for plus in (0, 1):
+            decodable = units(retained, cols[plus])
+            require(decodable == cycle_units(retained, edges, 2 * p, plus), 'cycle characterization')
+            if weight > best[plus][decodable]:
+                best[plus][decodable] = weight
+                witnesses[plus][decodable] = retained
+    for plus in (0, 1):
+        for bit in range(len(edges)):
+            for target in range(size):
+                superset = target | (1 << bit)
+                if best[plus][superset] > best[plus][target]:
+                    best[plus][target] = best[plus][superset]
+                    witnesses[plus][target] = witnesses[plus][superset]
+    return best, witnesses
+
+
+def target_orbits(p, edges, sizes):
+    edge_id = {edge: i for i, edge in enumerate(edges)}
+    maps = []
+    for perm in permutations(range(p)):
+        for flips in product(range(2), repeat=p):
+            vertices = [2 * perm[i // 2] + ((i % 2) ^ flips[i // 2]) for i in range(2 * p)]
+            maps.append([1 << edge_id[tuple(sorted((vertices[u], vertices[v])))] for u, v in edges])
+    for size in sizes:
+        todo = {sum(1 << i for i in ids) for ids in combinations(range(len(edges)), size)}
+        while todo:
+            target = min(todo)
+            ids = list(positions(target))
+            orbit = {sum(mapping[i] for i in ids) for mapping in maps}
+            require(orbit <= todo, 'automorphism orbits must be disjoint')
+            todo.difference_update(orbit)
+            yield target, len(orbit)
+
+
+def decoder_oracle(target, edges, n, plus):
+    """Enumerate actual row combinations giving each target its own unit."""
+    ids = list(positions(target))
+    dimension = len(ids)
+    alphabet = 1 << dimension
+    adjacency = [[] for _ in range(n)]
+    for j, i in enumerate(ids):
+        u, v = edges[i]
+        adjacency[u].append((v, 1 << j))
+        adjacency[v].append((u, 1 << j))
+    best = None
+    assignments = 0
+    for constant in range(alphabet) if plus else (0,):
+        offsets = [None] * n
+        components = [None] * n
+        count = 0
+        consistent = True
+        for root in range(n):
+            if offsets[root] is not None:
+                continue
+            offsets[root] = 0
+            components[root] = count
+            count += 1
+            stack = [root]
+            while stack:
+                u = stack.pop()
+                for v, value in adjacency[u]:
+                    expected = offsets[u] ^ value ^ constant
+                    if offsets[v] is None:
+                        offsets[v] = expected
+                        components[v] = components[u]
+                        stack.append(v)
+                    elif offsets[v] != expected:
+                        consistent = False
+        if not consistent:
+            continue
+        for rest in product(range(alphabet), repeat=count - 1):
+            roots = (0,) + rest
+            labels = [offsets[i] ^ roots[components[i]] for i in range(n)]
+            retained = target
+            for i, (u, v) in enumerate(edges):
+                if labels[u] ^ labels[v] ^ constant == 0:
+                    retained |= 1 << i
+            assignments += 1
+            score = retained.bit_count()
+            if best is None or score > best[0]:
+                best = (score, retained)
+    return best, assignments
+
+
+def histogram(values):
+    return {str(key): value for key, value in sorted(Counter(values).items(), key=lambda item: str(item[0]))}
+
+
+def components(n, edges, target):
+    parent = list(range(n))
+    def root(v):
+        while parent[v] != v:
+            v = parent[v]
+        return v
+    for i in positions(target):
+        u, v = map(root, edges[i])
+        if u == v:
+            return None
+        parent[u] = v
+    blocks = {}
+    for v in range(n):
+        blocks.setdefault(root(v), []).append(v)
+    return list(blocks.values())
+
+
+def matching_number(blocks, p):
+    slots = [sorted({v // 2 for v in block}) for block in blocks for _ in range(len(block) - 1)]
+    owner = [-1] * p
+    def augment(slot, seen):
+        for pair in slots[slot]:
+            if pair in seen:
+                continue
+            seen.add(pair)
+            if owner[pair] < 0 or augment(owner[pair], seen):
+                owner[pair] = slot
+                return True
+        return False
+    return sum(augment(slot, set()) for slot in range(len(slots)))
+
+
+def root_choice_number(blocks):
+    states = {0}
+    for block in blocks:
+        options = {sum(1 << pair for pair in {v // 2 for v in block if v != root}) for root in block}
+        states = {state | option for state in states for option in options}
+    return max(state.bit_count() for state in states)
+
+
+def forest_budget(p, edges, target):
+    blocks = components(2 * p, edges, target)
+    if blocks is None:
+        return None
+    nu = matching_number(blocks, p)
+    require(nu == root_choice_number(blocks), 'capacity matching versus literal root choices')
+    r = target.bit_count()
+    return len(edges) - r - comb(2 * p - r, 2) + p - nu
+
+
+def small_case(p):
+    edges = graph(p)
+    cols = [columns(edges, 2 * p, plus) for plus in (False, True)]
+    records = [partition_records(2 * p, edges, plus) for plus in (False, True)]
+    best, _ = all_retained_oracle(p, edges)
+    budgets, forests = [], 0
+    for target in range(1 << len(edges)):
+        minus = partition_optimum(target, cols[0], records[0])
+        plus = partition_optimum(target, cols[1], records[1], minus)
+        row = [target]
+        for model, result in enumerate((minus, plus)):
+            expected = best[model][target]
+            require((-1 if result is None else result[0]) == expected,
+                    'partition optimum versus complete retained-graph oracle')
+            if result is not None:
+                require(result[1] & target == target, 'targets must survive')
+                require(units(result[1], cols[model]) & target == target, 'witness unit rows')
+            row.append(None if expected < 0 else len(edges) - expected)
+        proposed = forest_budget(p, edges, target)
+        require(proposed == row[1], 'forest formula versus retained-graph oracle')
+        forests += proposed is not None
+        budgets.append(row)
+    result = dict(retained_graphs=1 << len(edges), target_sets=len(budgets),
+                  model_target_cases=2 * len(budgets), forest_target_sets=forests,
+                  partition_records=[len(x) for x in records],
+                  budget_histograms=[histogram(row[m + 1] for row in budgets) for m in (0, 1)],
+                  by_target_size={str(r): [histogram(row[m + 1] for row in budgets
+                                                    if row[0].bit_count() == r) for m in (0, 1)]
+                                  for r in range(len(edges) + 1)},
+                  all_budgets_sha256=sha256(json.dumps(budgets, separators=(',', ':')).encode()).hexdigest())
+    return result, budgets
+
+
+def larger_case():
+    edges = graph(4)
+    cols = [columns(edges, 8, plus) for plus in (False, True)]
+    records = [partition_records(8, edges, plus) for plus in (False, True)]
+    cases, assignments, restorations, forests = [], [0, 0], 0, 0
+    weighted = {r: [Counter(), Counter()] for r in (3, 4)}
+    for target, orbit_size in target_orbits(4, edges, (3, 4)):
+        minus = partition_optimum(target, cols[0], records[0])
+        plus = partition_optimum(target, cols[1], records[1], minus)
+        case = dict(target=[edges[i] for i in positions(target)], orbit_size=orbit_size,
+                    budgets=[], retained_masks=[], decoder_assignments=[])
+        for model, result in enumerate((minus, plus)):
+            direct, count = decoder_oracle(target, edges, 8, bool(model))
+            assignments[model] += count
+            case['decoder_assignments'].append(count)
+            require((None if result is None else result[0]) ==
+                    (None if direct is None else direct[0]), 'partition versus decoder oracle')
+            budget = None if result is None else len(edges) - result[0]
+            case['budgets'].append(budget)
+            case['retained_masks'].append(None if result is None else result[1])
+            weighted[target.bit_count()][model][str(budget)] += orbit_size
+            if result is not None:
+                retained = result[1]
+                require(retained & target == target, 'prescribed targets retained')
+                require(units(retained, cols[model]) & target == target, 'direct retained unit check')
+                for i in positions(((1 << len(edges)) - 1) ^ retained):
+                    require(units(retained | (1 << i), cols[model]) & target != target,
+                            'one deletion restoration must fail')
+                    restorations += 1
+        proposed = forest_budget(4, edges, target)
+        require(proposed == case['budgets'][0], 'forest formula versus independent decoder oracle')
+        forests += proposed is not None
+        cases.append(case)
+    require(len(cases) == 73 and sum(c['orbit_size'] for c in cases) == 12650,
+            'complete triple/quadruple orbit coverage')
+    return dict(target_sets=12650, orbits=len(cases), forest_orbits=forests,
+                partition_records=[len(x) for x in records], decoder_assignments=assignments,
+                by_target_size={str(r): [dict(sorted(c.items())) for c in weighted[r]] for r in (3, 4)},
+                one_deletion_restorations_rejected=restorations, cases=cases)
+
+
+def boundary_table():
+    literal = [('02 03 04', '12', '45', 24, [5, 7, 1]),
+               ('02 03 12', '02', '45', 12, [4, 6, 5]),
+               ('02 04 12', '23', '45', 48, [5, 1, 6]),
+               ('03 04 12', '12', '45', 48, [7, 1, 4]),
+               ('04 05 12', '04', '23', 24, [4, 6, 1]),
+               ('02 04 24', '01', '35', 8, [5, 6, 7]),
+               ('03 04 24', '01', '25', 24, [5, 6, 2]),
+               ('03 05 24', '01', '24', 24, [5, 6, 4]),
+               ('05 13 24', '01', '24', 8, [6, 5, 4])]
+    edges = graph(3)
+    edge_id = {edge: i for i, edge in enumerate(edges)}
+    orbits = dict(target_orbits(3, edges, (3,)))
+    checked, rows = set(), []
+    for names, left, right, size, expected in literal:
+        targets = [tuple(map(int, name)) for name in names.split()]
+        left, right = set(map(int, left)), set(map(int, right))
+        target = sum(1 << edge_id[edge] for edge in targets)
+        zero = sum(1 << edge_id[tuple(sorted((u, v)))] for u in left for v in right)
+        require(zero.bit_count() == 4 and zero & target == 0, 'literal bipartite witness')
+        require(orbits[target] == size and target not in checked, 'literal orbit count')
+        checked.add(target)
+        coordinates = {v: 0 for v in left | right}
+        for i, v in enumerate(sorted(set(range(6)) - left - right)):
+            coordinates[v] = 1 << i
+        reduced = [coordinates[u] ^ coordinates[v] ^ ((1 ^ int(u in right) ^ int(v in right)) << 2)
+                   for u, v in targets]
+        require(reduced == expected and rank(reduced) == 3, 'literal independent target columns')
+        require(units(zero | target, columns(edges, 6, True)) & target == target, 'literal full unit rows')
+        rows.append(dict(target=targets, left=sorted(left), right=sorted(right),
+                         orbit_size=size, quotient_columns=reduced))
+    require(checked == set(orbits), 'literal table covers every p3 triple orbit')
+    return rows
+
+
+def arithmetic_checks():
+    count = 0
+    for p in range(3, 101):
+        for r in range(1, 2 * p):
+            s = 2 * p - r
+            if s >= 3:
+                gap = s - 2 - int(s - 1 >= p)
+                loss = r // 2 if r <= p else s // 2
+                require(gap >= loss, 'multiple-component gap bound')
+            if p >= 6 and r <= p:
+                require(comb(s, 2) - s // 2 >= (s + 1)**2 // 4,
+                        'uniform constant-row irrelevance criterion')
+            count += 1
+    return count
+
+
+def verify():
+    p2, _ = small_case(2)
+    p3, budgets = small_case(3)
+    edges = graph(3)
+    ids = {edge: i for i, edge in enumerate(edges)}
+    def mask(edge_set):
+        return sum(1 << ids[tuple(sorted(edge))] for edge in edge_set)
+    triangle = mask([(0, 2), (2, 4), (0, 4)])
+    square = mask([(0, 2), (2, 1), (1, 3), (3, 0)])
+    two_triangles = triangle | mask([(1, 3), (3, 5), (1, 5)])
+    cols = [columns(edges, 6, plus) for plus in (False, True)]
+    require(units(triangle, cols[0]) == 0 and units(triangle, cols[1]) == triangle,
+            'constant row control')
+    require(units(square, cols[0]) == units(square, cols[1]) == 0, 'even target cycle infeasible')
+    require(units(two_triangles, cols[1]) == 0, 'two odd cycles have an even dependency')
+    require(rank([cols[1][0]]) == 1 and units((1 << len(edges)) - 1, cols[1]) & 1 == 0,
+            'target-column independence does not imply unit decoding')
+    require(budgets[triangle][1] is None and budgets[triangle][2] == 5, 'triangle feasibility')
+    return dict(status='PASS', arithmetic='exact F2 integer bitsets',
+                scope='Proper-star observations for k=2, with and without the empty star. '
+                      'All target sets at p=2,3 and all triples/quadruples at p=4 are checked. '
+                      'The uniform theorems are proved in GRAPH-TARGETS.md; no physical-cost or kappa claim.',
+                p2=p2, p3=p3, p4=larger_case(), p3_literal_triple_witnesses=boundary_table(),
+                forest_formula='E-r-binomial(2p-r,2)+p-nu(T); nu checked by matching and root-choice DP',
+                integer_inequality_cases=arithmetic_checks(),
+                negative_controls=['omitting the constant row loses triangle units',
+                                   'an even target cycle is impossible in both models',
+                                   'two edge-disjoint odd cycles cancel global parity',
+                                   'target-column independence alone does not isolate targets',
+                                   'every one-deletion restoration of each p4 optimum loses a required unit'],
+                literal_controls=dict(p3_triangle_budgets=budgets[triangle][1:],
+                                      p3_square_budgets=budgets[square][1:]))
+
+
+RECEIPT = 'GRAPH-TARGETS-RESULTS.json'
+
+
+def atomic_write(path, payload):
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', dir=path.parent,
+                                         prefix=path.name + '.', suffix='.tmp', delete=False) as handle:
+            temporary = Path(handle.name)
+            handle.write(payload)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
+def self_test(result):
+    from unittest.mock import patch
+    with tempfile.TemporaryDirectory() as directory:
+        directory = Path(directory)
+        script = directory / Path(__file__).name
+        script.write_bytes(Path(__file__).read_bytes())
+        receipt = directory / RECEIPT
+        receipt.write_text(json.dumps(result), encoding='utf-8')
+        command = [sys.executable, '-I', '-O', '-B', str(script)]
+        run = subprocess.run(command, cwd=directory, capture_output=True, text=True)
+        require(run.returncode == 0, f'minimal relocated optimized replay failed: {run.stderr}')
+        damaged = json.loads(json.dumps(result))
+        damaged['p3']['all_budgets_sha256'] = '0' * 64
+        receipt.write_text(json.dumps(damaged), encoding='utf-8')
+        protected = directory / 'protected.json'
+        protected.write_text('preserve this output\n', encoding='utf-8')
+        run = subprocess.run(command + ['--check', str(receipt), '--write', str(protected)],
+                             cwd=directory, capture_output=True, text=True)
+        require(run.returncode != 0 and 'receipt mismatch' in run.stderr, 'corrupt receipt accepted')
+        require(protected.read_text() == 'preserve this output\n', 'failed check overwrote output')
+        before = set(directory.iterdir())
+        with patch('os.replace', side_effect=OSError('simulated replacement failure')):
+            try:
+                atomic_write(protected, 'must not replace the output\n')
+            except OSError:
+                pass
+            else:
+                raise ValueError('atomic replacement failure was not propagated')
+        require(protected.read_text() == 'preserve this output\n', 'failed replacement lost output')
+        require(set(directory.iterdir()) == before, 'failed replacement left a temporary file')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--write', type=Path, help='atomically write a receipt after all requested checks pass')
+    parser.add_argument('--check', type=Path, help='compare this receipt before any output write')
+    parser.add_argument('--self-test', action='store_true', help='check relocation, corruption rejection, and output preservation')
+    args = parser.parse_args()
+    result = json.loads(json.dumps(verify()))
+    if args.check or not args.write:
+        receipt = args.check or Path(__file__).resolve().with_name(RECEIPT)
+        require(json.loads(receipt.read_text(encoding='utf-8')) == result, f'receipt mismatch: {receipt}')
+    if args.self_test:
+        self_test(result)
+    if args.write:
+        atomic_write(args.write, json.dumps(result, sort_keys=True, indent=2) + '\n')
+    print('PASS graph targets: 4,112 complete target sets; 73 p4 orbits covering 12,650 targets; '
+          f"{sum(result['p4']['decoder_assignments']):,} decoder assignments; forest formula verified")
+
+
+if __name__ == '__main__':
+    main()