From 7541aca683b1c40881a478b9d0bb2b63291949f9 Mon Sep 17 00:00:00 2001
From: conorholds <86416572+conorholds@users.noreply.github.com>
Date: Mon, 19 Oct 2026 04:05:09 -0700
Subject: [PATCH] Prove coupled E8 coordinate and neighbor-supported COPY
 floors

---
 .../e8-coupled-coordinate-floor/EXTENSIONS.md |  198 +
 .../e8-coupled-coordinate-floor/FINITE.md     |  286 +
 .../e8-coupled-coordinate-floor/FORMAL.md     |   40 +
 .../e8-coupled-coordinate-floor/NOTICE.md     |   34 +
 research/e8-coupled-coordinate-floor/PROOF.md |  448 ++
 .../e8-coupled-coordinate-floor/README.md     |  172 +
 .../REFERENCES.json                           |   43 +
 .../e8-coupled-coordinate-floor/RELATIVE.md   |  462 ++
 .../e8-coupled-coordinate-floor/RESULT.json   | 4924 +++++++++++++++++
 .../e8-coupled-coordinate-floor/SHARPNESS.md  |  365 ++
 .../e8-coupled-coordinate-floor/SOURCES.json  |   42 +
 .../e8-coupled-coordinate-floor/TASK.json     |  117 +
 .../e8-coupled-coordinate-floor/VERIFY.json   |   23 +
 .../a9_strict_fixture.py                      |  152 +
 .../cut_basis_audit.py                        |  219 +
 .../cut_excluded_fixture.py                   |  128 +
 .../dimension_audit.py                        |   75 +
 .../e8-coupled-coordinate-floor/factors.py    |  204 +
 .../finite_inputs.py                          |  249 +
 .../formal/CutCore.lean                       |  127 +
 .../formal/PartialBasis.lean                  |   52 +
 .../independent_model.py                      |  318 ++
 .../neighbor_audit.py                         |  470 ++
 .../neighbor_primary.py                       |  135 +
 .../partial_fixture.py                        |  178 +
 .../root_low_audit.py                         |   29 +
 .../root_low_primary.py                       |   48 +
 .../vendor/__init__.py                        |    1 +
 .../vendor/pr3755/CERTIFICATE.json            |  117 +
 .../vendor/pr3755/PROOF.md                    |  603 ++
 .../vendor/pr3755/SPARSE-PAIR.md              |  284 +
 .../vendor/pr3755/__init__.py                 |    1 +
 .../vendor/pr3755/geometry.py                 |  324 ++
 .../e8-coupled-coordinate-floor/verify.py     |  211 +
 34 files changed, 11079 insertions(+)
 create mode 100644 research/e8-coupled-coordinate-floor/EXTENSIONS.md
 create mode 100644 research/e8-coupled-coordinate-floor/FINITE.md
 create mode 100644 research/e8-coupled-coordinate-floor/FORMAL.md
 create mode 100644 research/e8-coupled-coordinate-floor/NOTICE.md
 create mode 100644 research/e8-coupled-coordinate-floor/PROOF.md
 create mode 100644 research/e8-coupled-coordinate-floor/README.md
 create mode 100644 research/e8-coupled-coordinate-floor/REFERENCES.json
 create mode 100644 research/e8-coupled-coordinate-floor/RELATIVE.md
 create mode 100644 research/e8-coupled-coordinate-floor/RESULT.json
 create mode 100644 research/e8-coupled-coordinate-floor/SHARPNESS.md
 create mode 100644 research/e8-coupled-coordinate-floor/SOURCES.json
 create mode 100644 research/e8-coupled-coordinate-floor/TASK.json
 create mode 100644 research/e8-coupled-coordinate-floor/VERIFY.json
 create mode 100644 research/e8-coupled-coordinate-floor/a9_strict_fixture.py
 create mode 100644 research/e8-coupled-coordinate-floor/cut_basis_audit.py
 create mode 100644 research/e8-coupled-coordinate-floor/cut_excluded_fixture.py
 create mode 100644 research/e8-coupled-coordinate-floor/dimension_audit.py
 create mode 100644 research/e8-coupled-coordinate-floor/factors.py
 create mode 100644 research/e8-coupled-coordinate-floor/finite_inputs.py
 create mode 100644 research/e8-coupled-coordinate-floor/formal/CutCore.lean
 create mode 100644 research/e8-coupled-coordinate-floor/formal/PartialBasis.lean
 create mode 100644 research/e8-coupled-coordinate-floor/independent_model.py
 create mode 100644 research/e8-coupled-coordinate-floor/neighbor_audit.py
 create mode 100644 research/e8-coupled-coordinate-floor/neighbor_primary.py
 create mode 100644 research/e8-coupled-coordinate-floor/partial_fixture.py
 create mode 100644 research/e8-coupled-coordinate-floor/root_low_audit.py
 create mode 100644 research/e8-coupled-coordinate-floor/root_low_primary.py
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/__init__.py
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/pr3755/CERTIFICATE.json
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/pr3755/PROOF.md
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/pr3755/SPARSE-PAIR.md
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/pr3755/__init__.py
 create mode 100644 research/e8-coupled-coordinate-floor/vendor/pr3755/geometry.py
 create mode 100644 research/e8-coupled-coordinate-floor/verify.py

diff --git a/research/e8-coupled-coordinate-floor/EXTENSIONS.md b/research/e8-coupled-coordinate-floor/EXTENSIONS.md
new file mode 100644
index 0000000000..b9fa9d85d8
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/EXTENSIONS.md
@@ -0,0 +1,198 @@
+# Normalization-stable partial quotients and high right rank
+
+Use PROOF.md's fixed full-E8 scalar code C, binary labels, COPY tariff and
+singleton left space C+Kδ_v. All results here are in characteristic zero.
+No claim is made that these are all possible right spaces. Actual spaces
+and ranks always discard zero-factor terms as specified in PROOF.md.
+
+## 1. Statements
+
+**Theorem Q (partial coordinate quotients).** Every finite raw exact
+factorization PQ^t=N0 satisfying
+
+```
+col(P)⊂C+Kδ_v,       col(Q)⊂C+D_A
+```
+
+has COPY≥72 in either of the following cases:
+
+1. |A|≤13 and u_v∉span_F2{u_a:a∈A}; or
+2. A⊂H_v and |A|≤28, with no further binary-rank assumption.
+
+The second statement uses the new relative nonroot 27-deletion theorem,
+the root weight-seven threshold 29, and a low-budget support argument,
+proved and certified in RELATIVE.md. The first
+allows coordinates scalar-orthogonal to v and uses only the inherited
+global root-only threshold 14. Both statements handle arbitrary proper
+subspaces of the coordinate quotient, including those created by merging
+proportional encoder columns. They are stronger than requiring the actual
+right space to be a full coordinate extension.
+
+**Theorem H (high actual rank).** If the exceptional left P rays each
+occur at most once, any scalar-active exact PQ^t=N0 with col(P)⊂C+Kδ_v and actual
+rank Q≥24 has COPY≥72. No coordinate hypothesis is imposed on Q.
+In particular this holds after left proportional merging if that actual
+rank is still at least 24. A lower bound on an unnormalized raw rank is
+not enough.
+
+Theorem H follows immediately from the strict basis floor in FINITE.md
+and PROOF.md's strict-floor corollary. Its one-sided counting premise is
+an additional-slack consequence of the PR2962 relaxation. The remainder
+of this file proves Theorem Q, whose equality-basis argument is different.
+
+## 2. Reduction to the actual coefficient space
+
+Apply left proportional merging as in PROOF.md §8. The actual reader
+space S still contains C by exactness and satisfies S⊂C+D_A. Since
+|A|≤28<57 and the code distance is 57, C∩D_A=0. Thus
+
+```
+S=C⊕D',       D'=S∩D_A,       e=dim_K D'.
+```
+
+Indeed the C component of every vector belongs to S, so subtracting it
+leaves its D_A component in S. This is the ACTUAL D' after merging;
+we do not replace it by D_A or by its coordinate support.
+
+In either case of Theorem Q, u_v is outside U_A=span_F2{u_a:a∈A}.
+For neighbors, U_A⊂u_v^⊥ whereas β(u_v,u_v)=1. Consequently every pure
+D' vector has w≤8, v∉A, and no pure vector can have u_v in its binary
+support span.
+
+If e≤1, both actual factor ranks are at most nine and PR3755's existing
+all-odd theorem gives COPY≥72. Suppose e≥2 from now on.
+
+## 3. Mixed low vectors and the feasible normal-rank budget
+
+In case 1, every mixed q=E(h)+d with w(q)≤8 has exactly weight eight
+and admits
+
+```
+h=c r_a,   a∈A, c≠0,    U(q)=u_a^⊥,
+d(a)=−2c,  d(x)=0 at every x≠a orthogonal to r_a.       (1)
+```
+
+Choose a nonzero binary annihilator z. Then Off(h)∩O_z⊂A. A nonroot
+has at most 42 zero root lines and |O_z|≥56, so it requires at least 14
+cancellations. Every nonmatching root character requires at least 24.
+Under |A|≤13 only the root's own character can occur, proving (1), with
+no mixed vector of weight at most seven. The same actual d∈D' witnesses
+that root's eligibility in PR3166 Theorem A.
+
+In case 2, **no mixed vector has weight at most seven** through |A|≤28.
+A nonroot E(h) has support at least 78, so after 28 corrections it retains
+at least 50 sites, exceeding the binary-weight-seven capacity 36. For a
+root normal, RELATIVE.md §8's exact two-character argument says at least
+29 neighbor corrections are required for binary weight at most seven.
+This assertion is weaker than an eligible-root-only classification of
+weight-eight words; that stronger classification already fails at 24.
+Nonroot weight-eight words can occur at 27 and are allowed here.
+
+Let R be the span of the scalar normals of all mixed weight-eight words
+in S, and let r=dim R, γ=c(D'). We claim in BOTH cases
+
+```
+r≤γ,           r≤8.                                  (2)
+```
+
+For γ≥8 this is immediate. For case 1 with γ≤7, all feasible words satisfy
+(1), and PR3166's weighted root-swap Theorem A gives r≤γ.
+For case 2 with γ≤7, recall e≥2. Take a minimum basis of D', with
+positive weights summing to γ. The union B of its coordinate supports
+has at most 21 sites: among partitions of an integer at most seven
+into at least two positive parts, the largest sum of support capacities
+is g(6)+g(1)=20+1=21. The verifier checks all 37 such partitions.
+Every actual correction d∈D' is supported on this SAME B⊂H_v.
+The relative nonroot threshold 27 and root-mismatch threshold 24 now
+force (1) for every feasible mixed weight-eight word, since |B|≤21.
+The weighted root-swap theorem again gives r≤γ.
+
+This minimum basis is used only to bound the support of the entire
+coefficient space. The equality-basis proof below still treats the given
+actual reader basis, with no substitution. The inherited weighted
+root-swap theorem is essential; capacity estimates alone do not prove
+this partial-quotient invoice.
+
+## 4. Every actual equality basis has the required low span
+
+Let F be ANY actual basis of S. Let ℓ be its number of vectors of weight
+at most seven, let κ be their weight sum, and put d=e−ℓ. The low members
+are pure by the no-mixed-weight-at-most-seven conclusion of §3, hence ℓ≤e. All vectors of weight at most eight lie in
+D'+E(R), whose dimension is e+r. If W is the total basis bill, counting
+low, weight-eight and weight-nine members gives
+
+```
+W ≥ κ+8(e+r−ℓ)+9(8−r)
+  = 72+8d+κ−r.                                       (3)
+```
+
+If fewer than e+r members have weight at most eight, this only increases
+the lower bound. Complete the ℓ actual low vectors to a basis of D'.
+Every added pure vector has weight at most eight, so
+
+```
+γ≤κ+8d.
+```
+
+Together with (2), (3) proves W≥72. Moreover, if d=1, e≥2 gives
+ℓ=e−1≥1 and κ≥1; using r≤8 in (3) gives W≥73. If d≥2, the same bound
+gives W≥80. Thus every ACTUAL bill-72 basis has d=0: its actual low
+members form a basis of D', and every high basis coordinate functional
+annihilates D'. This is not a substitution of a preferred minimum basis.
+It also covers binary rank eight; pure weight-eight directions do not
+create an omitted equality case.
+
+## 5. The actual free-pivot cut and the marked contradiction
+
+Take q=E(h)+d∈S supported on H_v. For case 2, d itself is supported
+on H_v. Thus E(h) vanishes on O_{u_v}. Those root rows span all eight
+scalar dimensions by the full-code rank input, so h=0. This proves
+that the cut is pure for ANY neighbor support size, independently of
+the weight-eight classification.
+
+For case 1, if q were mixed, (1) would give U(q)=u_a^⊥⊂u_v^⊥. These
+eight-dimensional hyperplanes are equal; nondegeneracy and distinct labels
+force a=v, contradicting v∉A. Hence again the cut is pure. In both cases
+
+```
+S∩K^{H_v}=D'∩K^{H_v}⊂D'.                              (4)
+```
+
+For neighbor supports this equals all D'. For case 1 the intersection
+may be proper. It need not be spanned by those actual basis members
+individually lying in the cut; functional annihilation is sufficient.
+
+In any actual equality basis, every pure low member has binary support
+span inside U_A and cannot carry u_v. Thus every rebated basis member
+j with u_v∈U(q_j) is high. Its actual coordinate functional annihilates
+D', and hence the cut (4). This is exactly PROOF.md's functional cut
+hypothesis. The generic coupling lemma proves COPY≥72 for the normalized
+factors, and nonincrease under merging proves the original raw bound.
+
+Equivalently, the only unpaid dangerous state has a free δ_v pivot and
+one rebated J_v column, with all other readers an actual bill-72 basis.
+After normalizing those encoders to δ_v and J_v, quotient exactness gives
+λ_J(q_pivot)=−1. Equations (3)–(4) instead give λ_J(q_pivot)=0. These
+statements concern the same actual factorization and the same basis.
+
+## 6. Boundary and genuine tests
+
+The sharp partial-quotient fixture in SHARPNESS.md has dim D'=2, minimum
+bill seven, no coordinate unit rays, seven feasible independent root
+normals, and actual ranks (9,10) with COPY=72. It is normalized on both
+sides. A second pivot variant includes coordinates orthogonal to v and
+has a proper cut; it is left-normalized only and its right merge lowers
+left rank to eight. The verifier records that distinction.
+
+A separate minimum-basis countercontrol shows why one cannot assume a
+cut is spanned by its individually vanishing actual basis columns for
+arbitrary coefficient spaces. RELATIVE.md supplies the 24-neighbor
+failure of the eligible-root-only classification and the 29-neighbor
+failure of the assertion that all mixed low vectors are pure. Neither control is a
+counterexample to Theorem Q, whose hypotheses and supporting boundaries
+remain explicit.
+
+Open: arbitrary partial right quotients of dimensions 10–23 without these
+support conditions; whether a different actual-basis argument crosses the 29-neighbor
+mixed-low boundary; full formal E8 and invoice assembly. Nothing
+here changes the selected frontier or proves the general two-sided C′.
diff --git a/research/e8-coupled-coordinate-floor/FINITE.md b/research/e8-coupled-coordinate-floor/FINITE.md
new file mode 100644
index 0000000000..011aa03187
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/FINITE.md
@@ -0,0 +1,286 @@
+# Finite geometric inputs and the inherited strict dimension screen
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+The support-capacity proof follows PR3166. The prefix counting relaxation is
+DreamingOfClouds' Lemma S in PR2962; its strict dimension-24 consequence is
+used here as an inherited one-sided input, not claimed as new E8 geometry.
+
+## 1. Root model, scalar ranks and binary labels
+
+Let E be the complete 120-line standard E8 inventory, with norm-two rational
+representatives r_x. Let C={E(h):h in K^8}, where E(h)(x)=(r_x,h), and let
+u_x be the fixed nonzero labels in the nine-dimensional nondegenerate
+binary pairing space. The scalar field K has characteristic zero in the
+arguments concerning root-subsystem cardinalities and dimensions below.
+
+The exact model checks identify every standard root line, all integer Gram
+products, and the dense identity
+
+    beta(u_x,u_y)=1 iff x=y or (r_x,r_y)=0.
+
+The scalar code and the binary label space are different objects. Write
+w(q)=rank_F2{u_x:q(x)!=0}. Its possible values on nonzero words are the
+integers 1 through 9, independently of the scalar field.
+
+For any rational root subset, its matrix rank is unchanged between Q and
+any characteristic-zero K: a nonzero rational minor stays nonzero, and
+every vanishing rational minor stays zero. To bound a selected root set
+of rank r, let T_Q be its rational span. Choose a rational functional
+vanishing on T_Q and nonzero on every root outside T_Q; finitely many
+proper hyperplanes can be avoided. Its vanishing root set is exactly the
+roots in T_Q. The stabilizer of that real point in the finite Weyl group
+is parabolic, with precisely those roots. Thus the root set in T_Q is
+Weyl-conjugate to a standard parabolic subsystem of rank r. This proves
+that a maximum over all simple-root subsets bounds every selected root
+set, rather than only standard-position subspaces. The capacities are
+
+| root rank r | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| maximum number N_r of root lines | 0 | 1 | 3 | 6 | 12 | 20 | 36 | 63 | 120 |
+
+The finite parabolic inventory checks all 256 subsets of the pinned simple
+basis. Every root has integral simple coordinates of one sign, and each
+subset's span membership is exact. The table records maxima by the number
+of independent selected simple roots; it is not a table of floating
+dimensions. The proper rank-seven cases above 42 roots consist only of
+E7 with 63 roots, whose perpendicular is a root line.
+
+In particular every nonzero E(h) has at least 57 nonzero coordinates. Its
+zero root rows have scalar rank at most seven, hence number at most 63.
+If h is not a root normal, there are at most 42 zero root rows: an E7 zero
+set would force h onto its one-dimensional root perpendicular. These
+consequences remain valid for arbitrary characteristic-zero K. Here is the
+support-pattern transfer used when a normal is not rational. Let T_Q be
+the rational kernel of all rows vanishing on h. Its extension to K
+contains h. Every designated nonzero root row is a nonzero functional on
+T_Q: if it vanished on T_Q, it would also vanish on T_Q tensor K and hence
+on h. Avoiding their finitely many proper rational hyperplanes produces a
+rational normal with exactly the same zero/nonzero root pattern. If this
+pattern contains an E7 subsystem, its rank seven forces the original
+K-normal into the same one-dimensional K-root perpendicular. Thus the
+root versus nonroot distinction used above also transfers. No ordering
+or positive-valued norm on K is assumed.
+
+## 2. Fourier proof of the binary support capacities
+
+The root labels are the odd-weight vectors u in F2^9 for which
+binom(weight(u),2) is odd. Equivalently, write
+
+    u(x)=(x_1,...,x_8,1+sum_i x_i), x in V=F2^8,
+    Q(x)=sum_{i<j} x_i*x_j.
+
+Then the root labels are exactly u(x) with Q(x)=1. This description gives
+the 84 weight-three and 36 weight-seven labels. The polar form
+
+    B(x,y)=Q(x+y)+Q(x)+Q(y)
+
+has matrix I+J, where J is the all-ones 8 by 8 matrix. It is nondegenerate:
+(I+J)^2=I over F2 because J^2=8J=0. This B is the polar form on V used in
+Fourier summation; it is not being identified without a coordinate change
+with the original nine-dimensional pairing beta.
+
+The exact 256-value quadratic inventory has 120 ones and 136 zeros, so
+
+    G(Q)=sum_{x in V}(-1)^Q(x)=16.
+
+Completing the square gives the full Fourier identity, for every y in V,
+
+    sum_{x in V}(-1)^(Q(x)+B(x,y)) = 16*(-1)^Q(y).          (2.1)
+
+Indeed Q(x)+B(x,y)=Q(x+y)+Q(y), and translation permutes V.
+
+Take a binary subspace T of the label space with dimension w, where
+1<=w<=8. If it has no odd-weight vector, it contains no root labels.
+Otherwise its odd slice is an affine (w-1)-flat. Under the affine map u(x)
+this slice corresponds to A=x_0+U in V, with dim U=w-1. Put
+
+    D=U^perp_B, n=dim D=9-w.
+
+The indicator of A and (2.1) yield
+
+    S_A:=sum_{x in A}(-1)^Q(x)
+        =16/2^n * sum_{y in D}(-1)^(Q(y)+B(x_0,y)).        (2.2)
+
+The restricted function
+
+    f(y)=Q(y)+B(x_0,y), y in D,
+
+is quadratic and, crucially, has f(0)=0. There is no additional constant
+sign in (2.2).
+
+Here is the precise Gauss-sum bound needed. If a zero-constant quadratic
+function f on an n-dimensional binary space has polar rank r, then r is
+even. If f is nonzero on its polar radical, translation by a radical
+element with f-value one negates its Gauss sum, so that sum is zero.
+Otherwise f descends to a nondegenerate quadratic function on a space of
+dimension r. Its Gauss sum has square 2^r, and pulling back through the
+radical gives
+
+    G(f)=plus/minus 2^(n-r/2).
+
+For completeness, the square identity follows by putting y=x+t in the
+double sum G(f)^2: the inner linear-character sum over x vanishes unless
+t is in the polar radical. In the nondegenerate quotient only t=0
+survives, giving 2^r.
+
+If r=0, the zero-constant f is linear. It has Gauss sum 2^n when f=0 and
+zero otherwise; a negative sum is impossible. If r>=2, then
+
+    G(f)>=-2^(n-1).                                      (2.3)
+
+Thus for w=5,6,7, equation (2.2) gives S_A>=-8. The number of root labels
+in T is (|A|-S_A)/2, at most
+
+    (2^(w-1)+8)/2 = 2^(w-2)+4,
+
+namely 12, 20 and 36. For w<=4, the trivial |A|=2^(w-1) bound gives
+1, 2, 4 and 8. For w=8, the dual dimension n is one. Its polar rank is
+zero, so its zero-constant quadratic function has a nonnegative Gauss
+sum. Hence S_A>=0 and at most 2^7/2=64 labels are roots.
+
+We obtain the support bounds
+
+| binary rank w | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| maximum support bound g(w) | 0 | 1 | 2 | 4 | 8 | 12 | 20 | 36 | 64 | 120 |
+
+Only upper bounds are needed in the dimension proof. Explicit affine-flat
+attainers may additionally certify their sharpness; searching for such
+attainers does not replace this uniform Fourier argument. Omitting the
+condition f(0)=0 would invalidate the special w=8 conclusion, since a
+constant-one function on a one-dimensional space has negative Gauss sum.
+
+The same quadratic description gives the full binary character spectrum.
+The character omega=(1,...,1) sees every root label, so |O_omega|=120.
+Every other nonzero character induces a nonconstant affine linear form on
+V; (2.1) makes its root cut size 60+4 or 60-4. Complementary characters
+z and z+omega exchange these sizes. Thus the 511 nonzero characters have
+sizes 56, 64 and 120 with multiplicities 255, 255 and 1 respectively.
+
+## 3. Full codewords and the root remainder input
+
+The retained PR3755 exact rank witnesses certify that each O_z spans all
+eight scalar root dimensions. If a nonzero codeword E(h) had w(E(h))<=8,
+a nonzero binary annihilator z would force h to annihilate all roots in
+O_z, contradiction. Thus every nonzero full-E8 codeword has binary weight
+nine. This fact must not be substituted with a punctured P112 statement.
+
+For a root a, Off(r_a) consists of a and its 56 nonself neighbors. The
+neighbor labels lie in u_a^perp, while u_a itself does not, since
+beta(u_a,u_a)=1. The neighbor labels span that full dimension-eight
+hyperplane: adding u_a gives the weight-nine support of E(r_a).
+
+The finite root-character comparison checks all 120*511 pairs. The
+matching character u_a intersects Off(r_a) exactly at a. Every other
+character intersects the nonself remainder in at least 24 points. For
+each root, the nonself remainder cut-size distribution over nonzero
+characters is
+
+    0:1, 24:126, 28:256, 32:126, 56:2.
+
+The sole zero cut is the character u_a. This is the inherited full-E8
+remainder input used by the eligible-root classification; it is separate
+from the new relative nonroot 27-cut certificate.
+
+## 4. Necessary prefix inequalities for every scalar basis
+
+Let S be any K-subspace of K^E containing C. Put n=dim S and choose an
+arbitrary scalar basis q_1,...,q_n, sorted so its weights satisfy
+
+    1<=w_1<=...<=w_n<=9.
+
+For a prefix J={1,...,n-r}, let X_J be the union of those basis supports.
+At a coordinate x outside X_J, evaluation on every codeword uses only
+the r remaining scalar basis coefficients. Hence the root row
+functional h |-> (r_x,h) lies in the span of r scalar functionals. The
+root rows outside X_J therefore have rank at most r. For r=0,...,7 the
+root capacities in section 1 imply
+
+    |X_J|>=120-N_r.
+
+Since |X_J|<=sum_{i=1}^{n-r}|supp q_i|<=sum_{i=1}^{n-r}g(w_i), every
+basis obeys
+
+    sum_{i=1}^{n-r}g(w_i)>=120-N_r, r=0,...,7.              (4.1)
+
+The eight right sides, starting with the prefix that leaves seven
+entries, are 57, 84, 100, 108, 114, 117, 119 and 120. Prefixes leaving
+at least eight entries have no stronger constraint from ambient rank.
+
+This is a necessary cardinality relaxation. It forgets actual root
+positions, overlaps between supports and scalar coefficient compatibility.
+A feasible weight multiset need not be a realizable basis. Conversely,
+infeasibility of a budget under (4.1) is a valid lower bound for every
+actual basis, including bases with arbitrary characteristic-zero entries.
+
+## 5. Exact finite dynamic-programming coverage
+
+For each fixed n, enumerate all nondecreasing integer weight sequences
+in 1,...,9 satisfying (4.1). Both implementations use the exact state
+
+    (prefix length, last weight, min(120,sum of prefix capacities)).
+
+The prefix sum can be capped at 120 because every required right side
+is at most 120. Future constraints depend only on this state and the
+remaining weights; no omitted geometric information is used by the
+relaxation.
+
+The primary implementation runs forward under bill budget 72. At a
+fixed prefix length it retains the smallest paid bill for each
+(last weight,capped capacity) pair. This is safe dominance: the cheaper
+path can take every suffix available to the more expensive path with the
+same state. Before adding weight w it also uses the necessary lower
+bound that all future weights are at least w. It rejects a completed
+prefix precisely when that prefix fails its required inequality.
+
+The separate implementation runs backward, minimizing the full bill
+from every state, and reconstructs an attaining relaxed profile. Its
+induction is direct: try every allowed next weight, reject exactly the
+failed prefix inequalities, and take the minimum over the remaining
+suffixes. Neither checker imports a predecessor PASS receipt.
+
+The finite strictness obligation comprises all 49 dimensions
+
+    n=24,25,...,72.
+
+Both implementations reject every sequence of bill at most 72 under
+(4.1) for each of these dimensions. Their integrated replay checks all
+49 dimensions and the n=23 boundary controls; the universal range is
+not inferred from a sample.
+For n=73,...,120 no finite search is needed: a basis has n nonzero
+members, each of positive integer weight, so its bill is at least n>=73.
+Together these facts give the inherited strict screen
+
+    S contains C and dim S>=24 => c(S)>=73.                (5.1)
+
+As boundary controls, the relaxation at n=23 has minimum 72, with weight
+multiset
+
+    1^13,5,6^9,
+
+and has no sequence of bill at most 71. At n=24 its relaxed minimum is 73,
+with multiset 1^14,5,6^9. These are controls on the integer relaxation,
+not asserted actual E8 bases. In particular the n=23 profile explains
+why this counting relaxation alone does not prove strict 73 there.
+
+## 6. Source and scope
+
+PR2962, exact head f6e68c9838e21b263223ae61273e381d2c0b92c7,
+research/decoder-certificate-ceilings/README.md section 3 and
+checks/lemmaS_dp.py, supplies the one-sided Rado/prefix counting method.
+Its advertised Lemma S states c(S)>=72 for dim S>=23. The strict
+dimension 24 consequence above is obtained from the same necessary
+integer constraints and is credited accordingly. The new coupled proof
+uses its one-unit slack; it does not rebrand the underlying one-sided
+counting argument as new.
+
+PR3166, exact head 7c2a62363ad4945e8803fedea6ead78e1ad412b2,
+research/e8-d0-root-swaps/PROOF.md section 4, supplies the Fourier support
+argument, parabolic scalar bounds and full remainder context. PR3755
+supplies the explicitly bound full-root model and rank witnesses. Their
+finite inputs remain distinguished from the later coupled scalar-basis
+and marked-coefficient implications.
+
+No positive-characteristic extension of the scalar root-capacity table,
+general L120 theorem, physical supplier, shared COPY bill or new
+multiplication exponent follows from these finite inputs alone.
diff --git a/research/e8-coupled-coordinate-floor/FORMAL.md b/research/e8-coupled-coordinate-floor/FORMAL.md
new file mode 100644
index 0000000000..8702afe5c7
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/FORMAL.md
@@ -0,0 +1,40 @@
+# Partial Lean coverage
+
+`formal/CutCore.lean` imports only `Init` under Lean 4.21.0, pinned by the
+repository input `formal/lean/lean-toolchain`. No Mathlib dependency is needed.
+Run the pinned executable sequentially:
+
+```sh
+lean --threads=1 -DwarningAsError=true research/e8-coupled-coordinate-floor/formal/CutCore.lean
+```
+
+The core declarations are:
+
+| Declaration | Coverage | Reported axioms |
+|---|---|---|
+| `cut_contradiction` | Additive evaluation-map contradiction with its scalar laws explicit | none |
+| `below_floor_forces_critical_state` | Below-floor tariffs force equality, zero surplus, rebate one, free pivot | propext, Classical.choice, Quot.sound |
+| `strict_basis_floor_pays_rebate` | Strict basis slack pays the sole rebate | propext |
+| `floor_of_critical_state_impossible` | Arithmetic reduction plus separately supplied critical-state obstruction | propext, Classical.choice, Quot.sound |
+
+`formal/PartialBasis.lean` additionally proves
+`equality_forces_zero_missing_low`: from r≤8, the actual-basis inequality
+72+8d+κ≤W+r, W=72, and d=1⇒κ≥1, it derives d=0. This is the arithmetic
+step in EXTENSIONS.md §4, with the geometric hypotheses still supplied
+externally. Its reported axiom is propext. Run this file with the same Lean
+command and flags.
+
+The additive map in the first declaration is evaluated on actual abstract
+vectors. Its addition law, scalar zero/one separation, quotient relation and
+annihilation assumptions are explicit hypotheses; they are not generated
+from a Mathlib linear functional here. Likewise the tariff assumptions are
+not linked formally to binary support ranks. Standard axioms are printed
+by the file, and warnings are treated as errors.
+
+Not formalized: the E8 root/label bridge, the singleton classification,
+the root-system/parabolic and Fourier arguments, weighted root-swap input,
+field transfer, actual equality-basis geometry, exact decoder assembly,
+and concavity. Exact Python certificates check their stated finite inputs;
+they are not proof-kernel verification of these written universal arguments.
+The registered Python replay does not silently run Lean. No repository-wide
+Lean build or hosted CI is claimed.
diff --git a/research/e8-coupled-coordinate-floor/NOTICE.md b/research/e8-coupled-coordinate-floor/NOTICE.md
new file mode 100644
index 0000000000..69a3c2e4e1
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/NOTICE.md
@@ -0,0 +1,34 @@
+# Attribution and source roles
+
+New work: conorholds. Substantial OpenAI Codex assistance, including four
+GPT-6.1 SOL agents at xHigh reasoning for separate derivation, implementation,
+proof review and overlap review. Internal AI reviews are not independent
+human certification. New files are Apache-2.0 under the repository license.
+
+- conorholds / PR3755 (pending, exact head 9ab51a1a): uniform one-coset
+  theorem, singleton-ray classification, all-odd rank-at-most-nine consumer,
+  coordinate-pair classification and exact full-E8 binding. The four retained
+  source files preserve their original credits. REFERENCES.json binds their
+  exact bytes and source Git objects; the objects need not be fetched.
+- conorholds / PR3166: weighted root-swap Theorem A, actual-kernel geometry,
+  Fourier capacity argument and characteristic-zero parabolic transfer.
+  Those written dependencies are explicit inputs, not reproved in Lean.
+- DreamingOfClouds / PR2962: one-sided Rado/prefix size relaxation. Its extra
+  strict slack at dimension 24 is used in a new coupled consumer. The relaxation
+  and its method are not claimed as a new one-sided geometric theorem.
+- adamgall / PR2062: A7+A1 family, sharp concave profile and mass-transfer
+  argument. The same numerical expression is credited rather than renamed.
+- PR2798: charged-pure compensation on its fixed P112 completion, including
+  a richer target than a rank statement alone. The distinction here is the
+  full 120-root model, all actual coordinate extensions and new partial spaces.
+- DreamingOfClouds / PR3154: ARCHITECT C′ / RL-s1 compensation obligations
+  and TWINSWAP construction family; the latter explicitly is not a general
+  lower bound. The present theorems close named leaves, not the whole programme.
+- The retained E8 lineage includes PR446/717, PR968/1071/1077, joaqcoo /
+  PR1224's projection/annihilator framework, mightyOil / PR1248's compatible
+  independence method, CubeJerry / PR3095's all-odd power-of-two rank witnesses,
+  and the L120 programme in PR3074/3191 and Discussion3156. No conditional
+  completion of that programme is imported as a premise.
+
+Only the scoped package is added. The scalar code, dense binary tariff,
+selected record and other contributors' frozen packages are unchanged.
diff --git a/research/e8-coupled-coordinate-floor/PROOF.md b/research/e8-coupled-coordinate-floor/PROOF.md
new file mode 100644
index 0000000000..1c246d0689
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/PROOF.md
@@ -0,0 +1,448 @@
+# Coupling a singleton encoder to an actual reader basis
+
+All vector spaces in this file use ordinary transpose, not conjugate transpose.
+Delete terms with a zero scalar factor before taking any **actual** factor
+space, rank or term count below. Thus all listed factors are scalar-active.
+This is essential: a zero encoder could otherwise inflate a reader rank at
+zero cost. Raw ambient-inclusion statements allow this initial deletion.
+Let E be the 120 E8 root lines, with norm-two rational representatives r_x.
+Use the fixed nine-bit dense-COPY labels u_x and nondegenerate dot pairing β.
+Define
+
+```
+E(h)_x = r_x·h,      C=E(K^8),      N0[x,y]=(r_x·r_y)/2,
+U(q)=span_F2{u_x:q(x)≠0},           w(q)=dim U(q),
+D_A=span_K{δ_a:a∈A},
+H_v={x:β(u_v,u_x)=0},              O_z={x:β(z,u_x)=1}.
+```
+
+The binary tariff is fixed before scalar reduction:
+B[x,y]=(1+integerGram[x,y]) mod 2. Thus β(u_x,u_y)=1 precisely for
+x=y or scalar-orthogonal distinct roots. COPY is the sum of binary ranks
+ρ(p,q)=rank B[supp p,supp q] over all scalar-active terms.
+
+## 1. Theorems and inherited inputs
+
+The COPY consumers below are conditional on the retained written premises
+from pending same-author PR3755, identified in this section. Pinning its
+sources and checking its finite rank certificate do not independently
+validate the singleton, low-rank and coordinate-pair proofs.
+
+**Theorem C (all full coordinate extensions).** In characteristic zero,
+if scalar-active PQ^t=N0, col(P)⊂C+Kδ_v, and the actual col(Q)=C+D_A for any A⊂E,
+then COPY≥72, provided each of the two exceptional P rays below occurs
+at most once. Pairwise nonproportional P columns suffice. Q columns may repeat.
+
+**Theorem P (raw coordinate pair).** Over every field of characteristic
+other than two, the same floor holds for raw factors satisfying
+col(P)⊂C+Kδ_v and col(Q)⊂C+span(δ_a,δ_b), for any two distinct a,b.
+No normalization hypothesis is needed in this statement.
+
+The target has image C and rank eight. The retained pending PR3755 source
+at 9ab51a1a supplies the singleton classification: every nonzero C word
+has full binary span; the only deficient rays in C+Kδ_v are
+
+```
+e=δ_v,          J=δ_v−E(r_v)/2,
+U(e)=F2 u_v,    U(J)=u_v^⊥,       β(u_v,u_v)=1.
+```
+
+These inputs hold in every odd characteristic, by its unit-minor/root-label
+certificate and written field argument. Their exact proof/code bytes are
+retained under vendor/pr3755 and authenticated by REFERENCES.json. Replaying
+that certificate is not a new independent proof of its whole written theorem.
+
+In characteristic zero the following inputs are used. FINITE.md explains
+the root-system and quadratic arguments; verify.py recomputes their finite
+inventories. The root rank capacities are (0,1,3,6,12,20,36,63,120), so
+a nonzero codeword has support at least 57. A nonroot scalar normal has
+at most 42 zero root lines. The nonzero binary cuts O_z have sizes 56,64,120.
+Consequently deleting at most 13 coordinates cannot make a nonroot evaluation
+deficient. The 56 nonself nonorthogonal roots at any a span u_a^⊥ and
+have minimum nonzero character support 24. These are the global root-only
+and remainder inputs of PR3166/PR968/PR1071, not new geometry here.
+
+For the full-coordinate theorem, sections 3–5 establish every actual
+bill-72 basis's cut structure for |A|≤8. Section 7 uses a strict basis floor
+for every larger A. EXTENSIONS.md gives the new partial-quotient consumers.
+
+## 2. A reusable abstract coupling lemma
+
+Let a finite coordinate set I carry distinct nonzero labels in an
+h-dimensional nondegenerate binary space `(Λ,β)`. Define U, w, and COPY
+using these labels. Let `C⊂K^I` have dimension d and let `e=δ_v` lie outside
+C. Write `u=u_v`, assume `β(u,u)=1`, and suppose there is a vector
+`J∈C+Ke` with quotient coefficient one, `U(J)=u^⊥`, such that the only
+projective nonzero vectors in `C+Ke` whose support span is not Λ are e and
+J. Put `H={x:β(u,u_x)=0}`.
+
+Let S contain the actual reader columns, and let L be an integer. Assume:
+
+* Every basis B of S has `Σ_{b∈B}w(b)≥L`.
+* For every actual basis B of S attaining L and every b∈B,
+  `u∈U(b)` implies that its coordinate functional λ_b vanishes on
+  `S∩K^H`.
+
+Then any exact factorization
+
+```
+P Q^t=M,       col(M)=C,       col(P)⊂C+Ke,       col(Q)=S,
+```
+
+with finitely many nonzero scalar-active columns and at most one P column
+on each exceptional ray e,J has `COPY≥L`. Pairwise nonproportionality of
+P is sufficient but is not required for its other columns. There is no
+nonproportionality assumption on Q. No transpose-image or entrywise formula
+for M is needed.
+
+The equality cut hypothesis is automatic if `S∩K^H` is spanned by those
+actual basis members that are themselves supported on H. Indeed such a
+member has U contained in `u^⊥`, which cannot contain u because
+`β(u,u)=1`. This is a statement about every actual equality basis, not the
+existence of one adapted basis.
+
+### Proof
+
+For every reader q, the three kinds of encoder columns have exact costs
+
+```
+U(p)=Λ:           ρ(p,q)=w(q),
+p=e:              ρ(e,q)=θ(q):=[supp(q) is not contained in H],
+p=J:              ρ(J,q)=w(q)−ε(q),   ε(q):=[u∈U(q)].     (3)
+```
+
+The second formula is the rank of a one-row pairing. For the third, the
+kernel of `U(q)→(u^⊥)*` is `U(q)∩F2u`, whose dimension is ε(q).
+These identities include zero binary cost and do not delete scalar-active
+terms. Column rescaling, with the inverse rescaling on its reader,
+preserves supports, ranks, actual spans, exactness and costs. Normalize a
+present exceptional encoder to exactly e or J.
+
+Let `χ:C+Ke→K` annihilate C and have χ(e)=1. Then χ(J)=1 and exactness gives
+
+```
+Σ_i χ(p_i)q_i=0.                                        (4)
+```
+
+Write r=dim S. If e is absent, there is at most one unit discount from
+`Σw(q_i)`. If every P column belongs to C, there is no exceptional column
+and a basis subset of Q proves the bound. Otherwise exactness gives
+`C⊂col(P)` and hence `rank P=d+1`. Sylvester's inequality gives `m≥r+1`:
+`d=rank M≥rank P+rank Q−m=d+1+r−m`. A basis subset of Q costs at least L,
+and each additional nonzero reader has weight at least one. Thus
+`Σw(q_i)≥L+1`, which pays the possible J discount.
+
+Now let e occur with reader q_0. Equation (4) shows that every reader except
+q_0 still spans the actual S. Their total weight is at least
+`L+(m−1−r)`. Equation (3) gives
+
+```
+COPY = Σ_{i≠0}w(q_i) − ε(q_J) + θ(q_0),                 (5)
+```
+
+where ε(q_J)=0 when J does not occur. A bill below L can therefore occur
+only if all the following hold simultaneously:
+
+```
+m−1=r;
+B=(q_i)_{i≠0} is the actual basis and has weight sum L;
+J occurs, u∈U(q_J), and q_0∈S∩K^H.                       (6)
+```
+
+The q_J coordinate of (4) is `λ_J(q_0)=−1`, whereas the equality cut
+hypothesis makes that coordinate zero. This contradiction proves the
+lemma. The quotient relation alone suffices; no dual-root normalization or
+row-v equation is used in this abstract argument.
+
+### Strict-floor corollary
+
+If every basis of the actual S has weight sum at least `L+1`, the same
+conclusion `COPY≥L` holds with no equality cut hypothesis. In the e-present
+case, the other readers span S and cost at least `L+1`; the possible J
+discount is only one. In the e-absent case the same sum bound suffices.
+In particular any verified strict one-sided floor 73, for an arbitrary
+actual right space S containing C, immediately gives this coupled floor
+72. This statement is broader than full coordinate extensions.
+
+For E8 take h=9,d=8,L=72,e=δ_v,J=δ_v−E(r_v)/2 and M=N0. If the stronger
+scalar identity is useful for an independent check, the critical actual
+basis also satisfies
+
+```
+λ_J(E(h))=−r_v·h.                                       (7)
+```
+
+Indeed write `p_i=E(h_i)+c_iδ_v`; the C component of the exact identity is
+`Σ_i E(h_i)q_i^t=N0`. With h_0=0, injectivity and transposition give
+`E(h)=2Σ_{i≠0}(h_i·h)q_i`. Since the normalized J column has
+`h_J=−r_v/2`, its coordinate is exactly (7). This checks both the minus
+sign and factor two; neither is an extra hypothesis of the lemma.
+
+## 3. All corrected vectors of weight at most eight for |A|≤8
+
+Set `a=|A|≤8` and `S=C+D_A`. Since every nonzero codeword has binary weight
+nine while a vector in D_A has binary weight at most a, `C∩D_A=0` and
+`dim S=8+a`. Each q has a unique decomposition `q=E(h)+d`, d∈D_A.
+
+Suppose h is nonzero and w(q)≤8. Restricting outside A shows that deleting
+at most eight coordinates from E(h) reduces its label span to at most
+eight. The global root-only input makes h proportional to a root, say
+`h=c r_t`, c≠0. The 56 nonself nonorthogonal coordinates, after deletion
+of at most eight members, still span `u_t^⊥` by the 24-character-support
+bound. Thus
+
+```
+U(q)=u_t^⊥,               w(q)=8.                        (8)
+```
+
+Its own label u_t is outside this hyperplane. Its entry must cancel:
+`0=q(t)=2c+d(t)`. Consequently t∈A and d(t)=−2c. Every other coordinate
+x orthogonal to r_t also has u_x outside this hyperplane, and E(h)(x)=0,
+so d(x)=0. Conversely, corrections at nonorthogonal lines have labels in
+`u_t^⊥`, and at most eight deletions cannot destroy its span. Therefore the
+complete, coefficient-sensitive classification is
+
+```
+q=c(E(r_t)−2δ_t)+d',
+t∈A, c≠0,   d'∈span{δ_x:x∈A∩H_t}.                      (9)
+```
+
+Here t itself is not in H_t because β(u_t,u_t)=1. Every displayed vector
+has weight exactly eight. In particular every vector of weight at most
+seven is in D_A, and the normal directions of weight-eight nonpure vectors
+are precisely roots indexed by A. This is a classification of all actual
+vectors; no minimizing-basis choice has been made.
+
+## 4. Basis lower bound and complete equality structure
+
+Let `s=rank_K{r_t:t∈A}`. By (9), the span of all weight≤7 vectors is D_A,
+of dimension a. The span of all weight≤8 vectors is
+
+```
+F8=D_A+E(span{r_t:t∈A}),        dim F8=a+s.               (10)
+```
+
+The equality follows because all δ_t have weight one and all
+`E(r_t)−2δ_t` have weight eight. Every actual basis of S therefore has
+weight sum at least
+
+```
+a·1+s·8+(8−s)·9 =72+a−s.                               (11)
+```
+
+For a direct counting proof, at most a independent basis members can have
+weight≤7, and at most a+s can have weight≤8. If n7 and n8 denote these
+counts, a basis of dimension 8+a has sum weight at least
+`n7+8(n8−n7)+9(8+a−n8)=72+9a−7n7−n8`, which is minimized at
+`n7=a,n8=a+s`, giving (11). Replacing an intermediate member by a heavier
+member cannot lower this bound.
+
+If s<a, (11) is at least 73, so the abstract coupling lemma applies
+without inspecting equality bases. If s=a, the bound is 72. Any actual
+basis attaining 72 must have exactly
+
+```
+a members of weight 1,
+a members of weight 8,
+8−a members of weight 9.                                (12)
+```
+
+Weight-one vectors are nonzero scalar coordinate units because the labels
+are distinct nonzero vectors. The first group is therefore
+`{α_tδ_t:t∈A}`, α_t≠0, and spans D_A. Every weight-eight member is nonpure,
+as it is independent of that first group. Its scalar normal is a root
+from A by (9). The a such normals must be independent and, since all roots
+of A are independent, there is exactly one such member `b_t` for each
+t∈A. Write it as
+
+```
+b_t=c_t(E(r_t)−2δ_t)+d_t',    c_t≠0,
+d_t'∈span{δ_x:x∈A∩H_t},     U(b_t)=u_t^⊥.               (13)
+```
+
+The eight normal directions of the weight-eight and weight-nine members
+form a basis of K^8, by quotienting S by D_A. This is the full equality
+structure of every actual basis, including arbitrary allowed correction
+coefficients in (13) and arbitrary weight-nine members. It is stronger
+than exhibiting one basis with the desired weights.
+
+## 5. The actual equality basis satisfies the cut condition
+
+Assume a=s≤8 and let B be any actual equality basis described above.
+The cut subspace has the following exact description:
+
+```
+S∩K^{H_v} = D_{A∩H_v}                              if v∉A;
+S∩K^{H_v} = D_{A∩H_v}+K b_v                      if v∈A. (14)
+```
+
+Indeed any vector supported on H_v has weight at most eight. If it is
+nonpure, (8) implies that its support span is `u_t^⊥` for some t∈A.
+Containment in `u_v^⊥` forces equality of those two hyperplanes. The
+nondegenerate binary form gives `F2u_t=F2u_v`, hence t=v. Formula (9)
+then gives (14), using (13) to replace the canonical root-hole by the
+actual b_v. Conversely every generator on the right is supported in H_v.
+
+Every generator on the right of (14) is a scalar multiple of an actual
+member of B supported on H_v. Such a member has binary support span
+contained in `u_v^⊥`, so its span cannot contain u_v. Therefore, for every
+b∈B with `u_v∈U(b)`, its coordinate functional vanishes on all of (14).
+This verifies the strong equality cut condition in the abstract lemma,
+without even using (7).
+
+For a scalar-constant cross-check, suppose b is non-coordinate and obeys
+(7). If v∈A, (13) gives `E(r_v)=c_v^{-1}b_v+d`, d∈D_A, while
+`λ_b(E(r_v))=−r_v·r_v=−2≠0`. As λ_b vanishes on D_A, this forces b=b_v;
+but then `U(b)=u_v^⊥` does not contain u_v. If v∉A, the cut is pure D_A and
+λ_b already vanishes on it. For coordinate b, u_v∈U(b) forces b to be the
+coordinate unit at v, and all cut generators are other basis members.
+This independent cross-check yields the same conclusion.
+
+Combining (11), (14), and the abstract coupling lemma proves
+
+```
+PQ^t=G/2, col(P)⊂C+Kδ_v, col(Q)=C+D_A, |A|≤8
+                         ⇒ COPY(P,Q)≥72                 (16)
+```
+
+for every finite m and every active projectively nonproportional P family.
+No assumption that the actual Q columns are initially nonproportional is
+needed. If a purported counterexample reaches the critical case, exactness
+itself makes all readers except q_0 an actual basis.
+
+## 6. The all-odd coordinate-pair case
+
+### 6.1 Two coordinate lines in every odd characteristic
+
+Let `A={a,b}` be a two-element coordinate set with arbitrary distinct root
+lines a and b. This case extends the coupled result to every field of
+characteristic other than two using only source3755 SPARSE-PAIR, without
+the characteristic-zero deletion census.
+
+That source proves `C∩D_A=0`, scalar independence of r_a,r_b, the basis
+floor 72, and filtered spans of dimensions two and four. Its complete
+singleton/mixed-direction classification says every positive-deficiency
+nonpure vector in `C+D_A` has weight eight and binary support span either
+`u_a^⊥` or `u_b^⊥`, with scalar normal proportional to the corresponding
+root. Consequently every actual equality basis has units at a,b and two
+weight-eight nonpure members b_a,b_b, one of each root normal, followed by
+six weight-nine members. This follows from actual basis independence,
+not a choice of the explicit equality fixture in that source.
+
+Normalize a nonpure member with normal c r_t, t=a or b. Its support in
+`u_t^⊥` forces self cancellation `d(t)=−2c` and permits correction at the
+other coordinate only when that label is in `u_t^⊥`. Thus (13) is valid
+for each actual b_t in every odd characteristic. The proof of (14) now
+applies verbatim using this complete pair classification. Every equality
+cut is spanned by permitted actual singleton columns and, if v is one of
+a,b, its matching actual b_v. The generic lemma therefore gives
+
+```
+PQ^t=G/2, col(P)⊂C+Kδ_v, col(Q)=C+span(δ_a,δ_b)
+                         ⇒ COPY(P,Q)≥72
+```
+
+for every finite m and every char K≠2 under the unique-exceptional-ray
+condition. No dot-product Gram determinant is used to establish root
+independence: that determinant can vanish at characteristic three for a
+nonorthogonal pair. Source3755 proves independence directly from the
+standard root representatives, which is the required field-safe input.
+
+The actual-space condition matters. If only `col(Q)⊂C+D_A` is given,
+exactness still gives C⊂col(Q). At rank eight, Q lies in C; at rank nine
+the existing rank-at-most-nine theorem applies to P,Q; and at rank ten
+the actual span is C+D_A. Thus these exits can separately extend this
+specific pair result to inclusion without claiming that arbitrary
+normalization preserves a prescribed actual full coordinate span.
+
+
+## 7. Complete all-A assembly
+
+For a=|A| between 9 and 15, distance 57 gives C∩D_A=0. Any mixed word
+E(h)+d retains at least 57−a≥42 support sites outside A. Binary weight
+at most seven can support at most 36 root labels, so every mixed word has
+weight at least eight. The minimum basis bill therefore satisfies
+
+```
+c(C+D_A) ≥ a+8·8 ≥73.
+```
+
+Here is the justification that does not replace an arbitrary actual basis.
+The a coordinate units form an independent set of minimum nonzero weight
+one. Start with a minimum-weight basis and successively insert any missing
+unit by basis exchange, removing a vector of weight at least one. This
+produces a minimum basis containing all units. Its remaining eight members
+are mixed and have weight at least eight. The lower bound is on the
+minimum, hence on every actual basis, as required by the coupling lemma.
+
+For a≥16, dim(C+D_A)≥24: if 16≤a≤23, distance 57 gives dimension 8+a;
+if a≥24, the coordinate units alone give dimension at least 24. No
+trivial-intersection assertion is made for arbitrary large A. FINITE.md's
+strict dimension screen says every basis of a space S⊃C of dimension
+at least 24 costs at least 73. The strict-floor corollary in section 2
+therefore applies. Together with sections 3–5 this proves Theorem C for
+every A, including A=∅ and A=E.
+
+The dimension screen is the integer size relaxation of PR2962, used here
+with one extra unit of required slack. It does not classify realizable
+minimum bases, and its dimension-23 optimum is a relaxation witness only.
+
+## 8. Normalization and the raw pair theorem
+
+Group proportional nonzero P columns. If p_i=α_i p on one ray, replace
+those terms by p(Σ_i α_i q_i)^t and delete a zero reader if it results.
+Supports of the sum lie inside the union of the old supports. The pairing
+rank of that union is at most the sum of the old pairing ranks, so COPY
+does not increase. This preserves exactness and both ambient inclusions.
+It may shrink the actual Q space, which is why Theorem C explicitly asks
+for the actual space after this operation.
+
+For a coordinate pair, the new actual S contains C by exactness and lies
+in C+span(δ_a,δ_b), which has dimension ten over every odd field. If dim S≤9,
+PR3755's rank-at-most-nine-on-both-sides theorem gives COPY≥72. If dim S=10,
+S is the full pair extension and section 6.1 applies. The normalized bill
+is at least 72, so the original raw bill is no smaller. This proves
+Theorem P. It does not infer full actual right span merely from ambient
+inclusion for larger coordinate sets.
+
+## 9. Sharp normalized concave bill
+
+In any covered family, suppose the actual left rank is nine, the actual
+right rank n≥10, and the exceptional P rays occur at most once each.
+Sylvester gives m≥n+1. Only the two exceptional P rays can have zero
+tariff; every other term has tariff w(q)≥1. Hence there are at least nine
+positive tariffs in {1,...,9}. COPY≥72 implies for every real 0<q≤1
+
+```
+Σ_i ρ_i^q ≥ 1+8^q+7·9^q.
+```
+
+To see this, reduce positive integer tariffs until their sum is 72 while
+keeping at least nine positive entries. If there are more than nine,
+one may remove a smallest entry and redistribute its mass into the others
+without exceeding 9; concavity cannot increase the bill when mass is
+transferred toward larger entries. Repeating gives nine entries. Among
+nine entries of sum 72 in [1,9], the concave minimum occurs by successively
+saturating the largest entry or the smallest boundary. The resulting
+multiset is (1,8,9,9,9,9,9,9,9). With more than 72 positive entries the
+claim is immediate since each costs at least one. At q=1 this is 72;
+for q<1 it strictly exceeds 8·9^q by 1+8^q−9^q>0.
+
+The expression and mass-transfer method already occur in adamgall's
+PR2062. The new point is the coupled factor-space coverage, not a new
+concavity lemma. SHARPNESS.md gives an exact eleven-term, ranks-(9,10)
+fixture attaining this profile over Q and every odd characteristic.
+No fixed-space sharpness is asserted for larger n. Raw-rank padding can
+inflate both ranks with scalar-active zero-tariff cancellation pairs;
+the executable countercontrol explains why raw ranks cannot replace
+actual ranks after left normalization in this strict concave statement.
+
+## 10. Boundary of the result
+
+Theorem C is an actual-space statement. Arbitrary partial right quotients
+of dimensions 10–23 are not automatically covered. EXTENSIONS.md proves
+two normalization-stable families of those partial quotients, including
+all neighbor supports of size at most 28. General C′, general G1-MFREE,
+L120, masked/punctured supports and a multiplication-exponent improvement
+remain outside these claims. The E8 instantiation and full assembly are
+written proofs, not complete Lean formalizations.
diff --git a/research/e8-coupled-coordinate-floor/README.md b/research/e8-coupled-coordinate-floor/README.md
new file mode 100644
index 0000000000..8b1d01540a
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/README.md
@@ -0,0 +1,172 @@
+# Coupled E8 coordinate floors and a 28-neighbor partial-quotient theorem
+
+Conditional on the retained written premises from pending same-author
+PR3755, this package proves COPY≥72 for new two-sided families of exact full-E8
+factorizations PQ^t=G/2, with any finite number of scalar-active terms.
+The left encoder space lies in C+Kδ_v, where C is the eight-dimensional
+root-evaluation code. The dense binary COPY table is fixed before scalar
+reduction. Ordinary transpose is used.
+
+The load-bearing PR3755 premises are its singleton classification,
+rank-at-most-nine theorem and coordinate-pair classification. Source pins
+and finite certificates preserve these dependencies; they do not independently
+validate their written proofs. The low-budget partial-quotient argument also
+uses PR3166 Theorem A, whose upstream ledger status is partially reviewed.
+The two relative-cut implementations share the Weyl/parabolic reduction
+for the complement-character branch; they do not independently validate
+that written reduction.
+
+The main new mechanism is an **actual-basis coupling lemma**: the only
+unpaid singleton/hole state marks an equality-basis coordinate −1, while
+the actual free-pivot cut forces that same coordinate to be zero. It uses
+the given basis, rather than replacing it by a convenient minimum basis.
+
+## Results and exact scope
+
+| Right-space hypothesis | Field | Normalization | Result |
+|---|---|---|---|
+| Actual col(Q)=C+D_A, any coordinate set A⊂E8 | characteristic zero | Each exceptional P ray occurs at most once | COPY≥72 |
+| col(Q)⊂C+span(δ_a,δ_b), any distinct a,b | every characteristic ≠2 | Raw ambient inclusion; arbitrary terms | COPY≥72 |
+| col(Q)⊂C+D_A, A⊂H_v, card(A)≤28 | characteristic zero | Raw ambient inclusion; arbitrary partial quotient | COPY≥72 |
+| col(Q)⊂C+D_A, card(A)≤13, u_v outside the binary label span of A | characteristic zero | Raw ambient inclusion; arbitrary partial quotient | COPY≥72 |
+| Arbitrary actual col(Q)⊃C, dimension≥24 | characteristic zero | Each exceptional P ray occurs at most once | COPY≥72; inherited strict-floor corollary (PR2962 + coupling) |
+
+Here D_A is the coordinate-unit space and H_v is the 56 nonself roots
+nonorthogonal to v. All actual ranks/spaces discard zero-factor terms.
+Pairwise nonproportional P columns suffice for the stated exceptional-ray
+condition; Q columns may repeat. Full actual space cannot be inferred from
+ambient inclusion after merging. The raw theorems explicitly handle that
+rank drop and the resulting arbitrary coefficient subspace D'.
+
+For normalized actual ranks (9,n), n≥10 in these families, the integer
+COPY floor also gives the sharp bound
+
+```
+Σ_i ρ_i^q ≥ 1+8^q+7·9^q,        0<q≤1.
+```
+
+An eleven-term rank-(9,10) exact decoder attains it over every odd field.
+The numerical expression and concavity argument are inherited from
+adamgall's PR2062; the new assertion is its coupled-space coverage.
+
+## What the additional research established
+
+The 28-neighbor theorem allows noncoordinate partial quotients, not just
+full coordinate extensions. Its proof combines three distinct facts:
+
+- A nonroot corrected word needs **27 neighbor deletions** before it can
+  have binary weight at most eight. This sharp relative bound is new and
+  is checked by two complete reductions.
+- A root corrected word needs **29 neighbor deletions** before it can
+  have weight at most seven. This sharp boundary is checked both for every
+  ordered root pair and by a separate fixed-pivot two-character exhaustion.
+- If dim D'≥2 and its minimum basis bill is at most seven, its entire
+  coordinate support has at most 21 sites. The weighted root-swap theorem
+  then bounds all feasible normal directions. At larger coefficient bill,
+  the ambient scalar rank-eight bound suffices.
+
+The stronger assertion that every deficient mixed word is an eligible root
+hole stops at 23: an explicit 24-neighbor word refutes it. The present
+invoice proof works through 28 anyway, allowing nonroot weight-eight words
+at 27. A normalized rank-(9,17) eighteen-term fixture has actual nonpivot basis
+bill 73 but COPY 72: the one-unit rebate is sharp, and the corresponding
+minimum-basis cut condition really fails at that higher basis floor.
+A further sharp nonroot low-word bound is 55 neighbor deletions, checked
+by a complete parabolic scan and a separate full-support-stratum algorithm.
+Thus the next 29–54 boundary problem involves root normals only.
+The 29-neighbor mixed-low example marks a boundary of this proof,
+not a decoder counterexample.
+
+## Proof map
+
+- [PROOF.md](PROOF.md): generic coupling lemma, every actual equality basis
+  for small full coordinate sets, all-A assembly, all-odd pair, concavity.
+- [EXTENSIONS.md](EXTENSIONS.md): arbitrary partial quotient after merging,
+  actual-basis deficit count, neighbor-28 and cut-excluded-13 consumers.
+- [RELATIVE.md](RELATIVE.md): sharp relative 27 and root-low 29 certificates,
+  characteristic-zero completeness and the explicit 24/29 boundaries.
+- [FINITE.md](FINITE.md): root/parabolic and Fourier capacity arguments,
+  plus PR2962's strict one-sided dimension-24 relaxation.
+- [SHARPNESS.md](SHARPNESS.md): exact normalized and noncoordinate equality
+  fixtures, raw-rank padding and proper-cut examples.
+- [FORMAL.md](FORMAL.md): five partial Init-only Lean declarations and the
+  unformalized geometric/consumer bridges.
+
+## Reproduce
+
+From the repository root, under CPython 3.12, standard library only:
+
+```sh
+python3 -B scripts/research_package.py --package research/e8-coupled-coordinate-floor --check-only
+python3 -B scripts/research_package.py --package research/e8-coupled-coordinate-floor
+```
+
+`verify.py` compares the exact semantic receipt in RESULT.json and all
+package source hashes. `--emit` explicitly regenerates the receipt after
+an intentional source change. Live input SHA256 pins are checked before
+scientific imports. Direct and Git-free invocations use a fresh private
+bytecode namespace, so adjacent stale .pyc files do not replace the
+source-authenticated modules. Package-local vendor namespaces are explicit.
+
+The replay checks 109 power-of-two minors; all 256 proper/full simple-root
+subsets; 256 Fourier values and capacity attainers; 61,320 root/character
+pairs; 49 strict-dimension cases by two DPs; 15,575,280 relative parabolic
+comparisons and a separate exact-kernel algorithm; all 14,400 root-pivot
+pairs plus a fixed-pivot 10,851-plane exhaustion; 32 exact full-coordinate
+fixtures in two models; two noncoordinate fixtures and the rank-(9,17) strict-slack fixture per
+field over Q/F3/F5/F7; and 60 actual equality bases across 7,200 cuts.
+
+Product/compensation faults, actual-space and normalization controls,
+a false general minimum-basis cut assertion, and the classification
+boundaries are tested separately. Finite fixtures and internal cross-checks
+support the written proof; they are not a census of arbitrary scalar
+factorizations or independent human review. Lean is a separate explicit
+check, not part of the Python replay.
+
+Pending PR3755's exact geometry, unit certificate and written premises
+are retained under vendor/pr3755 with original hashes in REFERENCES.json.
+No pending Git object or network fetch is needed for replay. These retained
+premises are reused explicitly, not described as an independent model.
+The second root/factor implementation constructs its own standard inventory
+and exact arithmetic; it is an internal cross-check by the same AI-assisted
+contribution, not independent human certification.
+
+## Task, overlap and limitations
+
+Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90, priority revision 6.
+TASK.json records the handoff-driven change from complex-rank-shape-decoder.
+PR3154's C′ / RL-s1 compensation questions and PR3755's higher-rank residual
+motivate this scoped lower-bound contribution. It does not close general
+C′ or G1-MFREE. In particular arbitrary partial right spaces of dimensions
+10–23 without these support restrictions remain open.
+
+The read-only 01:26 UTC October 19 refresh inspected all five PR updates
+since 00:56 UTC and fully paginated 887 comments plus 124 replies across
+Discussions 3156, 1587, 1166 and 1167. Main and the PR3154/3755 heads were
+unchanged; no matching E8 completion appeared in that delta. Earlier scout
+coverage is broader but historical. This is bounded overlap evidence, not
+a guarantee about all PR diffs, unpublished work or future updates. The
+work remains local under the contributor's publication restriction.
+
+No selected frontier, shared infrastructure, predecessor source or κ is
+changed. The written root-system and weighted root-swap inputs remain
+substantive dependencies. Full E8 instantiation, field transfer and theorem
+assembly are not formalized; no hosted CI or repository-wide build is claimed.
+
+## Open next questions
+
+1. Extend the coupled floor to arbitrary partial right quotients in dimensions
+   10–23. Start by testing the actual equality-basis functional cut, which is
+   false for unrestricted minimum bases; a new structural premise is needed.
+2. Cross the 29-neighbor mixed-low boundary. Classify how corrected root
+   weight-seven words enter an actual bill-72 basis; the eligible-root-only
+   shortcut already fails at 24 and cannot be restored by assertion.
+3. Formalize the E8/linear-functional bridge and actual-basis assembly.
+   The five small Lean declarations expose the missing geometric hypotheses.
+
+## Credit
+
+See [NOTICE.md](NOTICE.md) for the complete source roles and assistance
+record. The coupled compensation and new relative-cut results are by
+conorholds, with substantial OpenAI Codex assistance and GPT-6.1 SOL agents
+at xHigh reasoning. Apache-2.0. No independent human review is claimed.
diff --git a/research/e8-coupled-coordinate-floor/REFERENCES.json b/research/e8-coupled-coordinate-floor/REFERENCES.json
new file mode 100644
index 0000000000..ff33dc9f6e
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/REFERENCES.json
@@ -0,0 +1,43 @@
+{
+  "schema_version": 1,
+  "author": "conorholds",
+  "pending_source_policy": "Exact source bytes are retained locally. Replay requires no pending commit or network; the original source OID is provenance only, not a SOURCES history dependency.",
+  "snapshots": [
+    {
+      "local_path": "vendor/pr3755/geometry.py",
+      "source_commit": "9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52",
+      "source_path": "research/e8-one-coset-deficiency/geometry.py",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52/research/e8-one-coset-deficiency/geometry.py",
+      "git_blob": "9b4a3844d1c0c0e126f54ca9991f1cb158f358e0",
+      "sha256": "c783f6ddaf0bd5381b2345a62fe01f13e3e101ca33d70bc0495c406034782b91",
+      "purpose": "Runtime exact geometry and unit-minor certificate"
+    },
+    {
+      "local_path": "vendor/pr3755/CERTIFICATE.json",
+      "source_commit": "9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52",
+      "source_path": "research/e8-one-coset-deficiency/CERTIFICATE.json",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52/research/e8-one-coset-deficiency/CERTIFICATE.json",
+      "git_blob": "21864b382d37c3e9cb3dac7db69263986f43cc2d",
+      "sha256": "6c3500ed02a57c1203c9f0eea7f3deee078c5e27f2d95d7f860f580b0984ffbc",
+      "purpose": "Runtime exact geometry and unit-minor certificate"
+    },
+    {
+      "local_path": "vendor/pr3755/PROOF.md",
+      "source_commit": "9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52",
+      "source_path": "research/e8-one-coset-deficiency/PROOF.md",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52/research/e8-one-coset-deficiency/PROOF.md",
+      "git_blob": "89c328853b8a7a49dbbd9d8e4a842e1e209974df",
+      "sha256": "d3dcc35205225547c13f8bc0ec3175da7aab41e54c7adc06f0c35c86f00b93e4",
+      "purpose": "Retained written proof premise, not dynamically imported"
+    },
+    {
+      "local_path": "vendor/pr3755/SPARSE-PAIR.md",
+      "source_commit": "9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52",
+      "source_path": "research/e8-one-coset-deficiency/SPARSE-PAIR.md",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52/research/e8-one-coset-deficiency/SPARSE-PAIR.md",
+      "git_blob": "c702ce7e33b2459afd09b6a671be04cdb985643a",
+      "sha256": "0a7c82d97837740c00273fc1261a4bfd2037c68ab05cc0e80f8968a19cfa1723",
+      "purpose": "Retained written proof premise, not dynamically imported"
+    }
+  ]
+}
diff --git a/research/e8-coupled-coordinate-floor/RELATIVE.md b/research/e8-coupled-coordinate-floor/RELATIVE.md
new file mode 100644
index 0000000000..9801ef8feb
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/RELATIVE.md
@@ -0,0 +1,462 @@
+# A sharp relative 27-deletion bound on an E8 neighbor set
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+This is a written characteristic-zero theorem supported by two exact finite
+certificates. Its E8 instantiation is not claimed to be formally verified.
+
+## 1. Model and statements
+
+Let E be all 120 unoriented root lines of E8. Choose norm-two representatives
+r_x in Q^8 and retain the fixed binary labels u_x in the nondegenerate
+nine-dimensional pairing space (Lambda,beta). Thus
+
+    beta(u_x,u_y)=1 iff x=y or (r_x,r_y)=0.
+
+Let K be any field of characteristic zero. Set
+
+    E(h)=((r_x,h))_{x in E},       C=E(K^8),
+    U(q)=span_F2{u_x:q(x)!=0},     w(q)=dim_F2 U(q),
+    O_z={x:beta(z,u_x)=1},
+    H_v=E minus O_{u_v},          W_v=u_v^perp.
+
+Here H_v consists of the 56 nonself root lines nonorthogonal to r_v, and
+its labels lie in the binary hyperplane W_v. A scalar normal h is a
+**root normal** if it is proportional over K to some r_a. A word is
+**deficient** if w(q)<=8. Transposes elsewhere in the decoder model are
+ordinary transposes; no complex conjugation is used.
+
+**Theorem R (relative nonroot deletion bound).** Suppose h in K^8 is
+nonzero and is not a root normal. If d is supported on H_v and
+E(h)+d is deficient, then
+
+    |supp(d)|>=27.                                         (R)
+
+The bound is sharp. More precisely, for every nonzero binary character z,
+
+    Off(h) intersect O_z subset H_v
+        => |Off(h) intersect O_z|>=27,                     (R')
+
+where Off(h)={x:(r_x,h)!=0}. The minimum in (R') is attained by a rational
+nonroot normal. Taking d=-E(h) on this intersection and zero elsewhere
+gives a deficient word with exactly 27 correction coordinates.
+
+**Corollary E (eligible-root classification up to 23 neighbors).** Let
+A subset H_v have |A|<=23, let D' be any scalar subspace supported on A,
+and suppose
+
+    q=E(h)+d, h!=0,d in D', w(q)<=8.
+
+Then h=c r_a for some a in A and c!=0, and
+
+    U(q)=u_a^perp,       w(q)=8,
+    d(a)=-2c!=0,
+    d(x)=0 for every x!=a orthogonal to r_a.                (E)
+
+Thus the SAME vector d in the actual coefficient space D' is a root-swap
+eligibility witness for a. The assertion does not enlarge D' to the full
+coordinate space supported on A, and makes no binary-rank assumption on A.
+
+The number 23 is sharp for this eligible-root-only classification: a
+24-coordinate neighbor correction can create a deficient root word whose
+own root coordinate is not corrected. Section 6 supplies such a word. This
+is a classification boundary, not a counterexample to the COPY floor.
+
+## 2. Reduction to a finite relative cut statement
+
+If q=E(h)+d has w(q)<=8, choose a nonzero z in U(q)^perp. Then q vanishes
+on O_z, and therefore
+
+    Off(h) intersect O_z subset supp(d) subset H_v.         (1)
+
+It suffices to prove (R'). Two different exact finite methods do so. Both
+start from the complete standard E8 root inventory and its integer Gram
+matrix, rather than a floating-rank test or a sampled coefficient grid.
+
+The first method classifies all scalar zero patterns by standard parabolic
+subsystems. The second fixes v and classifies the exact scalar kernels
+forced by (1), with a separate complete parabolic treatment of one
+exceptional character. Their independently constructed minima agree at 27.
+
+## 3. Certificate by all parabolic zero patterns
+
+For a rational nonzero h, its root zero set
+
+    Z(h)={x:(r_x,h)=0}
+
+is Weyl-conjugate to a standard parabolic root subsystem. One proof takes
+the stabilizer of h in the finite real reflection group: it is parabolic,
+and its roots are exactly the roots perpendicular to h. This is the same
+classical parabolic argument used in PR3166, PROOF section 4; no new
+classification theorem is asserted here.
+
+Choose the pinned eight-root simple basis from that source. For every
+proper simple-root subset J, let Z_J be all root lines in its scalar span.
+There are 255 proper subsets. Exactly one has rank 7 and 63 root lines: E7,
+whose perpendicular is a root line. It cannot be Z(h) for a nonroot normal.
+The remaining 254 subsets cover all possible nonroot zero patterns up to
+Weyl action; repeated isomorphic types cause no omission or difficulty.
+
+The executable certificate checks the simple-root coordinate signs of all
+120 roots and builds each Z_J by its exact simple-coordinate support. An
+independent nullspace implementation checks the equivalent membership
+criterion against the same fixed simple basis. In particular Z_J is a
+standard parabolic root set, not an arbitrary root set of that cardinality.
+
+After a Weyl transformation taking Z(h) to Z_J, the distinguished v may
+become any root v'. The transformation also induces an invertible binary
+isometry on Lambda, so z becomes some nonzero z'. Accordingly, enumerate
+all 120 choices v' and all 511 choices z' for each retained J. Write
+
+    F_J=E minus Z_J.
+
+The pair (v',z') is admissible exactly when
+
+    F_J intersect O_{u_{v'}} intersect O_{z'} is empty.      (2)
+
+For an admissible pair, its required correction set is exactly
+F_J intersect O_{z'}, and (2) puts that set inside H_{v'}. The exact
+integer-mask scan records
+
+    254*120*511 = 15,575,280 comparisons,
+    30,492 admissible pairs,
+    minimum |F_J intersect O_{z'}| = 27.                  (3)
+
+These are integer set intersections. The scan is not a numerical
+optimization over possible h: Weyl/parabolic completeness has already
+reduced every scalar support pattern to the finite inventory.
+
+For sharpness, an attaining entry has simple subset 191, a 37-line zero
+subsystem, root index 113, character 463, and standard-coordinate normal
+
+    h=(0,0,0,0,0,1,1,2).
+
+The cofactor kernel computation verifies that this nonroot normal has the
+required exact zero pattern and the 27 listed correction coordinates. Root
+indices and characters here use the declared A8 pair-then-triple ordering
+bound to the standard-coordinate inventory. This witness is stored with
+the full deleted-index list in the certificate; its existence does not
+depend on a floating norm comparison.
+
+## 4. Independent certificate by fixed-root kernel strata
+
+Fix the root at index 0. Every h in (1) annihilates the rows on
+O_{u_v} intersect O_z. Compute the exact rational kernel
+
+    T_z=ker_Q rows(O_{u_v} intersect O_z).
+
+For all 511 nonzero characters, the kernel-dimension counts are
+
+| dimension | characters |
+|---:|---:|
+|0|256|
+|1|198|
+|2|56|
+|8|1|
+
+Dimension 0 admits no nonzero h. For dimension 1 there is only one
+projective normal. All 198 such normals are root normals, with required
+cut sizes 24, 28, 32 in multiplicities 63, 72, 63 respectively.
+
+For dimension 2 choose a rational basis b_0,b_1. Every root x in O_z
+induces a form
+
+    L_x(s,t)=(r_x,b_0)s+(r_x,b_1)t.
+
+Each nonzero form has exactly one projective zero ray; these finitely many
+rays are the complete critical strata. On their complement, every
+nonzero form stays nonzero, so all remaining scalar normals have exactly
+the same support on O_z. This proves completeness over every
+characteristic-zero K, including nonrational projective ratios. Each of
+the 56 two-dimensional kernels has one critical root ray requiring one
+deletion, one critical nonroot ray requiring 27, and a generic stratum
+requiring 28. A rational nonroot witness for the generic stratum is
+constructed outside its finitely many critical and root rays.
+
+The sole large kernel is verified explicitly, rather than skipped. In
+the odd-weight A8 label model let omega=(1,...,1), so O_omega=E. Its
+character is
+
+    z=omega+u_v,
+    O_z=H_v,
+    O_{u_v} intersect O_z is empty.
+
+At index 0 this is character 3, since u_v=508 and omega=511. Its kernel is
+all eight scalar dimensions. To handle it, enumerate the same 255 proper
+simple-root subsets and all 120 root positions, excluding the verified
+root-normal E7 case. The maximum number of zero roots in a neighbor set is
+21, hence every nonroot normal has at least 56-21=35 nonzero neighbor
+coordinates. A generic rational normal realizing the maximizing zero
+pattern is constructed and checked. Thus this exceptional character
+cannot reduce the 27 minimum. Any other kernel of dimension greater than
+two causes the checker to reject; no unclassified stratum is accepted.
+
+This method also checks an exact root-reflection spanning tree connecting
+all 120 root positions. Along an edge |(r,w)|=1, reflection in
+r-sign(r,w)w sends r to plus/minus w. Its action is checked to permute
+the complete root inventory. The recorded 56 distinct reflections give
+6,720 root-image checks. Thus the fixed-root result transports to every v.
+
+## 5. Binary transport and arbitrary characteristic-zero fields
+
+A Weyl root permutation preserves the integer Gram products up to the
+signs used to choose line representatives. Those signs do not change
+orthogonality or B_d, so the dense binary pairing is preserved. Because
+the labels span the full nondegenerate nine-dimensional binary space,
+the root-label permutation extends to an invertible binary isometry:
+pair any transported label relation with every transported root label;
+all pairings vanish, and nondegeneracy forces the transported relation
+to be zero. The inverse permutation gives invertibility. It therefore
+also permutes all 511 nonzero characters. This justifies transporting the
+scalar zero set, the neighbor condition and the binary cut simultaneously.
+
+For general K of characteristic zero, only scalar zero/nonzero patterns
+enter the argument. Let the rows vanishing on h define their rational
+kernel T_Q. Its scalar extension contains h. Every designated nonzero
+row is a nonzero functional on T_Q; otherwise it would also vanish on h.
+Avoiding finitely many proper rational hyperplanes gives a rational
+normal with exactly the same root zero set. If that set were E7, its
+rank 7 would force the original K-normal to the same K-root line,
+contrary to the nonroot hypothesis. Thus a rational nonroot support
+pattern occurs in the 254 retained parabolic cases. This is the rational
+zero-pattern transfer from PR3166, applied to the new relative cuts.
+
+Equivalently, in the fixed-root method the rational kernels T_z extend
+to K with unchanged dimensions, and the one-/two-dimensional critical
+form classification remains exact. These arguments neither put an
+ordering on K nor use positivity of a K-valued norm. No extension of
+Theorem R to positive characteristic is inferred from the rational
+certificate.
+
+Equations(1) and(3), or the independent kernel certificate, now prove(R).
+
+## 6. Eligible-root consequence and its 24-coordinate boundary
+
+For the corollary, Theorem R excludes every nonroot h because |A|<=23<27.
+Write h=c r_a. The full E8 nonself root remainder has minimum nonzero
+binary character cut 24, as recomputed in PR3166. Hence for every
+z!=u_a,
+
+    |Off(r_a) intersect O_z|>=24.                          (4)
+
+The matching cut is Off(r_a) intersect O_{u_a}={a}. Any annihilator of q
+would require canceling its cut inside A. By(4), every nonzero annihilator
+must be u_a. Therefore its annihilator has dimension exactly one, so
+w(q)=8 and U(q)=u_a^perp. Vanishing at a gives d(a)=-2c!=0, proving
+a in A. At any other root orthogonal to r_a, both E(h) and q vanish,
+giving d(x)=0. This is precisely the actual-space eligibility assertion(E).
+
+The following exact word shows why this classification stops at 23. In
+the declared standard-coordinate/A8 ordering take
+
+    v=a=0,  r_v=(0,1,-1,0,0,0,0,0),
+    u_v=508,  z=12,
+    A_minus={1,2,44,45,46,47,48,49,50,51,52,53},
+    A_plus ={8,9,65,66,67,68,69,70,71,72,73,74},
+    A=A_minus union A_plus.
+
+All 24 roots in A are nonself neighbors of v. Their root products with
+r_v are+1 on A_minus and-1 on A_plus. Moreover
+
+    Off(r_v) intersect O_z=A,
+    beta(z,u_v)=0,
+    d=-sum_{x in A_minus}delta_x+sum_{x in A_plus}delta_x,
+    q=E(r_v)+d=E(r_v)-E(r_v)|_A.
+
+Thus q vanishes on O_z and w(q)<=8, while v is not in A and
+q(v)=(r_v,r_v)=2. The root's own coordinate has not been canceled, so
+this is not an eligible root hole for the actual correction space.
+
+The coefficient normalization matters: the stored standard rows are
+R_x=2r_x, so E(r_v)(x)=(R_x,R_v)/4, not (R_x,R_v)/2. Therefore each
+displayed correction coefficient is exactly+1 or-1 and q(v)=2 as stated.
+There is no hidden factor-of-two rescaling of the root or its hole.
+
+This word disproves only the stronger eligible-root-only classification
+at 24 neighboring coordinates. It is not an exact all-pairs decoder and
+does not contradict COPY>=72. It also does not weaken the sharp nonroot
+bound 27: its scalar normal is the root r_v.
+
+## 7. Credit and evidence boundary
+
+PR3166 supplies the weighted root-swap definition, full remainder 24 input,
+the standard simple-root coordinates and the characteristic-zero
+parabolic/zero-pattern argument. PR3755 supplies the fixed full-E8
+root/label binding and singleton context. The new finite statement is
+the relative nonroot minimum 27 under the requirement that all deleted
+coordinates lie in one root's nonself neighbor set. The two finite
+methods above certify it by different complete reductions; their matching
+outputs do not constitute independent human review.
+
+The relative theorem strengthens the neighbor-supported partial-quotient
+consumer's root-only input from 13 to 23 coordinates. Its later COPY proof
+must still retain the actual-basis deficit and low-rank exit arguments;
+the relative cut bound alone is not a decoder theorem. No positive-
+characteristic, physical supplier, shared COPY, masked-universality or
+multiplication-exponent conclusion is asserted here.
+
+## 8. A different threshold: mixed weight at most seven needs 29 neighbors
+
+The eligible-root classification above stops at 23, but the coupled
+consumer needs less than that classification for every weight-eight
+word. The following sharper low-weight statement extends the raw neighbor
+consumer to 28 coordinates without extending Corollary E.
+
+**Theorem L (low mixed words).** If d is supported on H_v, h is nonzero,
+and w(E(h)+d)<=7, then |supp(d)|>=29. The bound is attained by a root
+normal and a 29-coordinate neighbor correction. This remains a statement
+about corrected words, not a decoder counterexample at 29 coordinates.
+
+For a nonroot normal, the global perpendicular-root bound already gives
+|Off(h)|>=78. A word of binary weight at most seven has at most 36 support
+coordinates. Therefore at least 78-36=42 coordinates must be canceled.
+No additional nonroot projective census is needed for Theorem L.
+
+It remains to consider h=c r_a. Scaling by c!=0 does not change any
+support, so take h=r_a. Put
+
+    T_{v,a}=Off(r_a) intersect O_{u_v},
+    Z_{v,a}=span_F2{u_x:x in T_{v,a}}^perp.
+
+The correction is zero on O_{u_v}. Any support annihilator of E(r_a)+d
+must consequently belong to Z_{v,a}. A word of weight at most seven
+has an annihilator of dimension at least two. Thus every independent
+pair z,t in that annihilator requires cancellation of
+
+    Off(r_a) intersect (O_z union O_t).                     (5)
+
+All these required coordinates must lie in H_v. The exact all-position
+certificate root_low_primary.py checks the following complete cases for
+all 120*120 ordered pairs (v,a).
+
+* If a=v, the forced support is {a}, of label rank one. Every allowed
+  character lies in u_a^perp. Its restriction to the 56-line nonself
+  remainder is injective on any two-dimensional allowed character
+  space: the remainder's annihilator is F2 u_a, and u_a is not in
+  u_a^perp. Thus z,t,z+t all cut that remainder nontrivially. Each cut
+  has at least 24 coordinates. Writing N(s)=H_a intersect O_s for these
+  remainder cuts, their union has size
+  (|N(z)|+|N(t)|+|N(z+t)|)/2, hence at least 36.
+* If a!=v and (r_a,r_v)!=0, the forced label rank is seven. Its
+  annihilator is exactly one two-dimensional space, with three nonzero
+  characters. The certificate checks that (5), for a basis of that
+  space, is contained in H_v and has exactly 29 coordinates. After
+  canceling them, the remaining root support has binary rank exactly
+  seven. All 6,720 ordered neighbor pairs have these properties.
+* If (r_a,r_v)=0, the forced label rank is eight. Its annihilator has
+  dimension one, so a corrected word cannot have weight at most seven.
+  This accounts for the remaining 7,560 ordered pairs.
+
+The self-root case accounts for 120 ordered pairs. These counts exhaust
+all 14,400 pairs. The independent root_low_audit.py fixes one pivot and
+enumerates all root normals and every two-dimensional allowed character
+space: 10,851 distinct planes, with minimum required union 29. The
+root-reflection transport in section 5 gives its all-pivot interpretation.
+These are binary annihilator spaces and exact support unions, not a grid
+of scalar coefficients. Root evaluations have unchanged zero patterns
+over every characteristic-zero K, so the argument covers all such fields.
+Together with the nonroot bound 42, this proves Theorem L and its stated
+attainment.
+
+Here is why Theorem L is enough for the stronger coupled result. Let
+A subset H_v, |A|<=28, and let D' be the actual partial coordinate space
+after left proportional merging, as in EXTENSIONS.md. Every pure D' word
+has weight at most eight, and Theorem L says every mixed word has weight
+at least eight. Write gamma=c(D') and let r be the scalar rank of the
+normal directions of all mixed weight-eight words. These normals may
+now include nonroot normals; they are not globally asserted eligible.
+
+If gamma>=8, simply r<=8<=gamma. If gamma<=7 and dim D'>=2, choose a
+minimum basis of D'. The union of its supports has at most 21 coordinates.
+Indeed each basis weight is at most six. If one is six, the other weights
+sum to at most one, giving the capacity bound 20+1. Otherwise every
+weight is at most five, where the displayed capacity table satisfies
+g(w)<=3w, so the union has size at most 3gamma<=21. Every vector of the
+same D' is supported on this union. Corollary E therefore applies to
+every mixed weight-eight word, now with an effective support set of at
+most 21 neighbors. Its same-space eligibility assertion and PR3166
+Theorem A give r<=gamma. Thus in every case relevant to the partial
+consumer,
+
+    r<=c(D'),       r<=8.                                  (6)
+
+The actual-basis count in EXTENSIONS.md needs only the absence of mixed
+words of weight at most seven and (6), rather than eligible-root shape
+for every weight-eight word. It gives every basis bill at least 72 and,
+when dim D'>=2, makes every actual bill-72 basis's low members span D'.
+The dim D'<=1 cases instead use PR3755's rank-at-most-nine theorem.
+
+For neighbor support the free-pivot cut is always exactly D', with no
+support-size or root-only assumption: a cut word E(h)+d supported on H_v
+has E(h)=0 on O_{u_v}, whose root rows have scalar rank eight, so h=0.
+Low members are supported on H_v and cannot carry u_v in their binary
+support spans. Consequently every rebated actual equality-basis coordinate
+annihilates this cut, as required by the generic coupling lemma. This
+completes the raw neighbor-supported COPY>=72 theorem through 28
+coordinates. It does not extend the eligible-root-only classification
+past 23, and it makes no claim that the COPY floor fails at 29.
+
+
+## 9. Completing the nonroot low-word boundary: 55 is sharp
+
+The coarse nonroot lower bound 42 used in Theorem L is sufficient for the
+28-neighbor consumer. A separate exact calculation sharpens it to 55:
+if h is nonroot, d is supported on H_v and w(E(h)+d)≤7, then
+|supp(d)|≥55. Equality occurs. Thus any mixed low word arising with
+29 through 54 neighbor corrections has a root normal. This does not
+extend the decoder invoice past 28 by itself.
+
+For the first complete reduction, take each of the 254 nonroot parabolic
+zero patterns Z_J and every root v, and form the forced binary support
+
+```
+F=(E minus Z_J)∩O_{u_v}.
+```
+
+Over all 30,480 ordered pattern/pivot cases its label rank is eight in
+30,474 cases and seven in six cases. A weight-at-most-seven corrected
+word needs at least two independent support annihilators, all of which
+must annihilate F. The rank-eight cases are therefore impossible. In
+each rank-seven case the allowed character space is exactly two-dimensional;
+its unique plane requires canceling at least 55 neighbor coordinates,
+with equality attained.
+`neighbor_primary.low_weight_run` checks all cases and an explicit
+nonroot normal, correction set and attained remaining binary rank seven.
+Weyl/binary transport and characteristic-zero zero-pattern transfer are
+exactly those justified in sections 3 and 5.
+
+A second algorithm uses the fixed-root scalar kernels T_z from section 4.
+Any two-dimensional binary annihilator plane has a nonzero character z
+other than the sole complement character. Thus its scalar normal lies
+in a kernel of dimension at most two; the omitted dimension-eight kernel
+cannot by itself supply a plane. For each two-dimensional T_z, classify
+the projective zeros of the linear forms from **all 120 root rows**, and
+one generic stratum avoiding those zeros. Dimension-one kernels have one
+ray. This is a complete support-pattern classification for every possible
+two-annihilator word, including nonrational scalar ratios; it is not a
+claim that all scalar normals are covered.
+
+The separate implementation obtains 169 distinct relevant root-support
+patterns, enumerates their allowed binary planes (10,963 in total), and
+minimizes the required union of the two character cuts. It finds root
+minimum 29 and nonroot minimum 55. The complement character is included
+when enumerating allowed binary planes; it is omitted only as a scalar
+kernel entry because every plane also has another nonzero character.
+Both minima have explicit rational attaining words of binary weight seven.
+
+The primary nonroot attainer uses the same normal
+h=(0,0,0,0,0,1,1,2), root index 113 and simple subset 191 as the relative
+27 witness. Its required plane has nonzero characters 224,303,463 and
+55 deleted coordinates, stored in RESULT.json. Set d=−E(h) on those
+coordinates and zero elsewhere. The checker binds the exact zero pattern,
+neighbor containment and remaining label rank, so sharpness is an actual
+word rather than a feasible cardinality profile.
+
+These calculations complete the natural geometric threshold table:
+
+| Scalar normal | Corrected binary weight ≤8 | Corrected binary weight ≤7 |
+|---|---:|---:|
+| nonroot | 27 neighbor deletions, sharp | 55 neighbor deletions, sharp |
+| root | 1 via a matching hole; nonmatching cut starts at 24 | 29 neighbor deletions, sharp |
+
+The still-open next invoice case is therefore a root-normal low-direction
+problem beginning at 29, not a generic nonroot low-direction search.
diff --git a/research/e8-coupled-coordinate-floor/RESULT.json b/research/e8-coupled-coordinate-floor/RESULT.json
new file mode 100644
index 0000000000..a5aa37cadf
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/RESULT.json
@@ -0,0 +1,4924 @@
+{
+  "actual_basis_cut_audit": {
+    "actual_equality_bases": 60,
+    "false_universal_minimum_basis_controls": {
+      "3": {
+        "cut_dimension": 1,
+        "minimum_basis_cost": 5,
+        "root_coordinates": [
+          63,
+          84,
+          99,
+          109
+        ],
+        "universal_minimum_basis_claim_rejected": true,
+        "vanishing_actual_columns": 0
+      },
+      "5": {
+        "cut_dimension": 1,
+        "minimum_basis_cost": 5,
+        "root_coordinates": [
+          63,
+          84,
+          99,
+          109
+        ],
+        "universal_minimum_basis_claim_rejected": true,
+        "vanishing_actual_columns": 0
+      },
+      "7": {
+        "cut_dimension": 1,
+        "minimum_basis_cost": 5,
+        "root_coordinates": [
+          63,
+          84,
+          99,
+          109
+        ],
+        "universal_minimum_basis_claim_rejected": true,
+        "vanishing_actual_columns": 0
+      },
+      "Q": {
+        "cut_dimension": 1,
+        "minimum_basis_cost": 5,
+        "root_coordinates": [
+          63,
+          84,
+          99,
+          109
+        ],
+        "universal_minimum_basis_claim_rejected": true,
+        "vanishing_actual_columns": 0
+      }
+    },
+    "root_character_cuts": 7200,
+    "vanishing_membership_and_copy_checks": 13680
+  },
+  "actual_space_contract_controls": 4,
+  "cut_excluded_partial_fixture": {
+    "all_A_are_neighbors": false,
+    "binary_rank_A": 6,
+    "binary_rank_A_plus_pivot": 7,
+    "doubled_pivot_root": [
+      0,
+      2,
+      0,
+      0,
+      0,
+      0,
+      -2,
+      0
+    ],
+    "fields": {
+      "3": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "failure_controls": 3,
+        "left_normalization_stable": true,
+        "partial_basis_cut_rank": 9,
+        "partial_basis_vanishing_columns": 1,
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 4,
+          "projective_support_strata_over_Q": 4
+        },
+        "right_merged_copy": 72,
+        "right_merged_ranks": [
+          8,
+          10
+        ],
+        "right_merged_terms": 10,
+        "right_normalization_stable": false,
+        "terms": 11
+      },
+      "5": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "failure_controls": 3,
+        "left_normalization_stable": true,
+        "partial_basis_cut_rank": 9,
+        "partial_basis_vanishing_columns": 1,
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 6,
+          "projective_support_strata_over_Q": 4
+        },
+        "right_merged_copy": 72,
+        "right_merged_ranks": [
+          8,
+          10
+        ],
+        "right_merged_terms": 10,
+        "right_normalization_stable": false,
+        "terms": 11
+      },
+      "7": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "failure_controls": 3,
+        "left_normalization_stable": true,
+        "partial_basis_cut_rank": 9,
+        "partial_basis_vanishing_columns": 1,
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 8,
+          "projective_support_strata_over_Q": 4
+        },
+        "right_merged_copy": 72,
+        "right_merged_ranks": [
+          8,
+          10
+        ],
+        "right_merged_terms": 10,
+        "right_normalization_stable": false,
+        "terms": 11
+      },
+      "Q": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "failure_controls": 3,
+        "left_normalization_stable": true,
+        "partial_basis_cut_rank": 9,
+        "partial_basis_vanishing_columns": 1,
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 4,
+          "projective_support_strata_over_Q": 4
+        },
+        "right_merged_copy": 72,
+        "right_merged_ranks": [
+          8,
+          10
+        ],
+        "right_merged_terms": 10,
+        "right_normalization_stable": false,
+        "terms": 11
+      }
+    },
+    "gram_pairing_checks": 14400,
+    "pivot_pairings_against_A": [
+      0,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0
+    ],
+    "root_coordinate_v": 4,
+    "root_coordinates_A": [
+      63,
+      84,
+      99,
+      109,
+      115,
+      30,
+      32
+    ],
+    "scalar_rank_A": 7
+  },
+  "finite_inputs": {
+    "characters": {
+      "minimum_nonmatching_nonself_root_intersection": 24,
+      "minimum_nonmatching_root_intersection": 24,
+      "nonzero_characters": 511,
+      "root_character_pairs": 61320,
+      "spectrum": {
+        "120": 1,
+        "56": 255,
+        "64": 255
+      }
+    },
+    "dimension_screen": {
+      "dimension23_positive_cost": 72,
+      "dimension23_positive_weights": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        5,
+        6,
+        6,
+        6,
+        6,
+        6,
+        6,
+        6,
+        6,
+        6
+      ],
+      "dimension73_through120": "weight>=dimension>=73",
+      "peak_frontier_states": 154,
+      "strict_dimensions": [
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 24
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 25
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 26
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 27
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 28
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 29
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 30
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 31
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 32
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 33
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 34
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 35
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 36
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 37
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 38
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 39
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 40
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 41
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 42
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 43
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 44
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 45
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 46
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 47
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 48
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 49
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 50
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 51
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 52
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 53
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 54
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 55
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 56
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 57
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 58
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 59
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 60
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 61
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 62
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 63
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 64
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 65
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 66
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 67
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 68
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 69
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 70
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 71
+        },
+        {
+          "basis_budget72_feasible_in_relaxation": false,
+          "dimension": 72
+        }
+      ],
+      "transitions": 19610
+    },
+    "fourier": {
+      "attainment_witnesses": [
+        {
+          "affine_origin": 200,
+          "count": 1,
+          "directions": [],
+          "rank": 1,
+          "root_labels": [
+            200
+          ]
+        },
+        {
+          "affine_origin": 200,
+          "count": 2,
+          "directions": [
+            182
+          ],
+          "rank": 2,
+          "root_labels": [
+            200,
+            382
+          ]
+        },
+        {
+          "affine_origin": 65,
+          "count": 4,
+          "directions": [
+            145,
+            35
+          ],
+          "rank": 3,
+          "root_labels": [
+            321,
+            208,
+            98,
+            499
+          ]
+        },
+        {
+          "affine_origin": 35,
+          "count": 8,
+          "directions": [
+            187,
+            97,
+            71
+          ],
+          "rank": 4,
+          "root_labels": [
+            35,
+            152,
+            322,
+            505,
+            100,
+            223,
+            261,
+            446
+          ]
+        },
+        {
+          "affine_origin": 73,
+          "count": 12,
+          "directions": [
+            38,
+            81,
+            122,
+            52
+          ],
+          "rank": 5,
+          "root_labels": [
+            73,
+            367,
+            280,
+            21,
+            98,
+            324,
+            381,
+            44,
+            266,
+            7,
+            289,
+            112
+          ]
+        },
+        {
+          "affine_origin": 66,
+          "count": 20,
+          "directions": [
+            198,
+            68,
+            167,
+            123,
+            58
+          ],
+          "rank": 6,
+          "root_labels": [
+            322,
+            388,
+            262,
+            448,
+            35,
+            161,
+            381,
+            443,
+            88,
+            28,
+            446,
+            506,
+            223,
+            25,
+            259,
+            385,
+            164,
+            98,
+            224,
+            38
+          ]
+        },
+        {
+          "affine_origin": 233,
+          "count": 36,
+          "directions": [
+            120,
+            36,
+            182,
+            255,
+            167,
+            19
+          ],
+          "rank": 7,
+          "root_labels": [
+            145,
+            351,
+            379,
+            259,
+            22,
+            50,
+            74,
+            416,
+            388,
+            508,
+            274,
+            164,
+            493,
+            7,
+            127,
+            35,
+            506,
+            386,
+            478,
+            76,
+            52,
+            104,
+            261,
+            381,
+            289,
+            239,
+            37,
+            491,
+            463,
+            439,
+            162,
+            134,
+            254,
+            276,
+            304,
+            328
+          ]
+        },
+        {
+          "affine_origin": 104,
+          "count": 64,
+          "directions": [
+            158,
+            253,
+            105,
+            103,
+            156,
+            84,
+            19
+          ],
+          "rank": 8,
+          "root_labels": [
+            104,
+            502,
+            11,
+            415,
+            508,
+            98,
+            145,
+            261,
+            265,
+            259,
+            352,
+            254,
+            13,
+            506,
+            100,
+            7,
+            162,
+            193,
+            351,
+            168,
+            56,
+            50,
+            463,
+            81,
+            416,
+            52,
+            164,
+            304,
+            379,
+            134,
+            280,
+            274,
+            140,
+            239,
+            28,
+            386,
+            127,
+            491,
+            392,
+            22,
+            487,
+            26,
+            388,
+            493,
+            381,
+            375,
+            276,
+            138,
+            76,
+            70,
+            443,
+            37,
+            328,
+            289,
+            191,
+            322,
+            208,
+            324,
+            74,
+            41,
+            439,
+            445,
+            35,
+            478
+          ]
+        }
+      ],
+      "binary_support_caps": [
+        0,
+        1,
+        2,
+        4,
+        8,
+        12,
+        20,
+        36,
+        64
+      ],
+      "walsh_coefficients": 256,
+      "walsh_values": {
+        "-16": 120,
+        "16": 136
+      }
+    },
+    "middle_coordinate_sets": [
+      {
+        "basis_floor": 73,
+        "mixed_min_weight": 8,
+        "size": 9
+      },
+      {
+        "basis_floor": 74,
+        "mixed_min_weight": 8,
+        "size": 10
+      },
+      {
+        "basis_floor": 75,
+        "mixed_min_weight": 8,
+        "size": 11
+      },
+      {
+        "basis_floor": 76,
+        "mixed_min_weight": 8,
+        "size": 12
+      },
+      {
+        "basis_floor": 77,
+        "mixed_min_weight": 8,
+        "size": 13
+      },
+      {
+        "basis_floor": 78,
+        "mixed_min_weight": 8,
+        "size": 14
+      },
+      {
+        "basis_floor": 79,
+        "mixed_min_weight": 8,
+        "size": 15
+      },
+      {
+        "basis_floor": 80,
+        "mixed_min_weight": 8,
+        "size": 16
+      },
+      {
+        "basis_floor": 81,
+        "mixed_min_weight": 8,
+        "size": 17
+      },
+      {
+        "basis_floor": 82,
+        "mixed_min_weight": 8,
+        "size": 18
+      },
+      {
+        "basis_floor": 83,
+        "mixed_min_weight": 8,
+        "size": 19
+      },
+      {
+        "basis_floor": 84,
+        "mixed_min_weight": 8,
+        "size": 20
+      },
+      {
+        "basis_floor": 77,
+        "mixed_min_weight": 7,
+        "size": 21
+      },
+      {
+        "basis_floor": 78,
+        "mixed_min_weight": 7,
+        "size": 22
+      },
+      {
+        "basis_floor": 79,
+        "mixed_min_weight": 7,
+        "size": 23
+      },
+      {
+        "basis_floor": 80,
+        "mixed_min_weight": 7,
+        "size": 24
+      },
+      {
+        "basis_floor": 81,
+        "mixed_min_weight": 7,
+        "size": 25
+      },
+      {
+        "basis_floor": 82,
+        "mixed_min_weight": 7,
+        "size": 26
+      },
+      {
+        "basis_floor": 83,
+        "mixed_min_weight": 7,
+        "size": 27
+      },
+      {
+        "basis_floor": 84,
+        "mixed_min_weight": 7,
+        "size": 28
+      },
+      {
+        "basis_floor": 85,
+        "mixed_min_weight": 7,
+        "size": 29
+      },
+      {
+        "basis_floor": 86,
+        "mixed_min_weight": 7,
+        "size": 30
+      },
+      {
+        "basis_floor": 87,
+        "mixed_min_weight": 7,
+        "size": 31
+      },
+      {
+        "basis_floor": 88,
+        "mixed_min_weight": 7,
+        "size": 32
+      },
+      {
+        "basis_floor": 89,
+        "mixed_min_weight": 7,
+        "size": 33
+      },
+      {
+        "basis_floor": 90,
+        "mixed_min_weight": 7,
+        "size": 34
+      },
+      {
+        "basis_floor": 91,
+        "mixed_min_weight": 7,
+        "size": 35
+      },
+      {
+        "basis_floor": 92,
+        "mixed_min_weight": 7,
+        "size": 36
+      },
+      {
+        "basis_floor": 85,
+        "mixed_min_weight": 6,
+        "size": 37
+      },
+      {
+        "basis_floor": 86,
+        "mixed_min_weight": 6,
+        "size": 38
+      },
+      {
+        "basis_floor": 87,
+        "mixed_min_weight": 6,
+        "size": 39
+      },
+      {
+        "basis_floor": 88,
+        "mixed_min_weight": 6,
+        "size": 40
+      },
+      {
+        "basis_floor": 89,
+        "mixed_min_weight": 6,
+        "size": 41
+      },
+      {
+        "basis_floor": 90,
+        "mixed_min_weight": 6,
+        "size": 42
+      },
+      {
+        "basis_floor": 91,
+        "mixed_min_weight": 6,
+        "size": 43
+      },
+      {
+        "basis_floor": 92,
+        "mixed_min_weight": 6,
+        "size": 44
+      },
+      {
+        "basis_floor": 85,
+        "mixed_min_weight": 5,
+        "size": 45
+      },
+      {
+        "basis_floor": 86,
+        "mixed_min_weight": 5,
+        "size": 46
+      },
+      {
+        "basis_floor": 87,
+        "mixed_min_weight": 5,
+        "size": 47
+      },
+      {
+        "basis_floor": 88,
+        "mixed_min_weight": 5,
+        "size": 48
+      },
+      {
+        "basis_floor": 81,
+        "mixed_min_weight": 4,
+        "size": 49
+      },
+      {
+        "basis_floor": 82,
+        "mixed_min_weight": 4,
+        "size": 50
+      },
+      {
+        "basis_floor": 83,
+        "mixed_min_weight": 4,
+        "size": 51
+      },
+      {
+        "basis_floor": 84,
+        "mixed_min_weight": 4,
+        "size": 52
+      },
+      {
+        "basis_floor": 77,
+        "mixed_min_weight": 3,
+        "size": 53
+      },
+      {
+        "basis_floor": 78,
+        "mixed_min_weight": 3,
+        "size": 54
+      }
+    ],
+    "parabolics": {
+      "E7_root_normal_cases": 1,
+      "rank_seven_counts": [
+        14,
+        16,
+        22,
+        23,
+        28,
+        37,
+        42,
+        63
+      ],
+      "root_rank_caps": [
+        0,
+        1,
+        3,
+        6,
+        12,
+        20,
+        36,
+        63,
+        120
+      ],
+      "subsets": 256
+    },
+    "partial_support_budget": {
+      "maximum_bill": 7,
+      "maximum_support_union": 21,
+      "minimum_members": 2,
+      "partitions": 37
+    },
+    "reflection_transport": {
+      "adjacent_generators": 8,
+      "denominators_are_powers_of_two": true,
+      "involution_matrix_entries": 512,
+      "root_line_transports": 960
+    },
+    "unit_certificate": {
+      "all_minors_units_over_Z_half": true,
+      "determinants_absolute": [
+        256,
+        512,
+        1024,
+        2048
+      ],
+      "forbidden_pair_profiles": 100,
+      "nonzero_integer_minors": 109,
+      "single_types": 9,
+      "valid_pair_profiles": 192
+    }
+  },
+  "independent_dimension_relaxation": [
+    {
+      "dimension": 23,
+      "memoized_states": 5142,
+      "minimum_relaxed_bill": 72
+    },
+    {
+      "dimension": 24,
+      "memoized_states": 5598,
+      "minimum_relaxed_bill": 73
+    },
+    {
+      "dimension": 25,
+      "memoized_states": 6053,
+      "minimum_relaxed_bill": 74
+    },
+    {
+      "dimension": 26,
+      "memoized_states": 6507,
+      "minimum_relaxed_bill": 74
+    },
+    {
+      "dimension": 27,
+      "memoized_states": 6961,
+      "minimum_relaxed_bill": 75
+    },
+    {
+      "dimension": 28,
+      "memoized_states": 7416,
+      "minimum_relaxed_bill": 76
+    },
+    {
+      "dimension": 29,
+      "memoized_states": 7871,
+      "minimum_relaxed_bill": 77
+    },
+    {
+      "dimension": 30,
+      "memoized_states": 8325,
+      "minimum_relaxed_bill": 77
+    },
+    {
+      "dimension": 31,
+      "memoized_states": 8781,
+      "minimum_relaxed_bill": 78
+    },
+    {
+      "dimension": 32,
+      "memoized_states": 9245,
+      "minimum_relaxed_bill": 78
+    },
+    {
+      "dimension": 33,
+      "memoized_states": 9708,
+      "minimum_relaxed_bill": 78
+    },
+    {
+      "dimension": 34,
+      "memoized_states": 10166,
+      "minimum_relaxed_bill": 79
+    },
+    {
+      "dimension": 35,
+      "memoized_states": 10619,
+      "minimum_relaxed_bill": 80
+    },
+    {
+      "dimension": 36,
+      "memoized_states": 11069,
+      "minimum_relaxed_bill": 81
+    },
+    {
+      "dimension": 37,
+      "memoized_states": 11514,
+      "minimum_relaxed_bill": 82
+    },
+    {
+      "dimension": 38,
+      "memoized_states": 11954,
+      "minimum_relaxed_bill": 83
+    },
+    {
+      "dimension": 39,
+      "memoized_states": 12389,
+      "minimum_relaxed_bill": 83
+    },
+    {
+      "dimension": 40,
+      "memoized_states": 12819,
+      "minimum_relaxed_bill": 84
+    },
+    {
+      "dimension": 41,
+      "memoized_states": 13244,
+      "minimum_relaxed_bill": 84
+    },
+    {
+      "dimension": 42,
+      "memoized_states": 13664,
+      "minimum_relaxed_bill": 84
+    },
+    {
+      "dimension": 43,
+      "memoized_states": 14079,
+      "minimum_relaxed_bill": 85
+    },
+    {
+      "dimension": 44,
+      "memoized_states": 14489,
+      "minimum_relaxed_bill": 86
+    },
+    {
+      "dimension": 45,
+      "memoized_states": 14894,
+      "minimum_relaxed_bill": 87
+    },
+    {
+      "dimension": 46,
+      "memoized_states": 15293,
+      "minimum_relaxed_bill": 87
+    },
+    {
+      "dimension": 47,
+      "memoized_states": 15687,
+      "minimum_relaxed_bill": 88
+    },
+    {
+      "dimension": 48,
+      "memoized_states": 16077,
+      "minimum_relaxed_bill": 88
+    },
+    {
+      "dimension": 49,
+      "memoized_states": 16463,
+      "minimum_relaxed_bill": 88
+    },
+    {
+      "dimension": 50,
+      "memoized_states": 16844,
+      "minimum_relaxed_bill": 89
+    },
+    {
+      "dimension": 51,
+      "memoized_states": 17220,
+      "minimum_relaxed_bill": 90
+    },
+    {
+      "dimension": 52,
+      "memoized_states": 17591,
+      "minimum_relaxed_bill": 91
+    },
+    {
+      "dimension": 53,
+      "memoized_states": 17957,
+      "minimum_relaxed_bill": 91
+    },
+    {
+      "dimension": 54,
+      "memoized_states": 18317,
+      "minimum_relaxed_bill": 92
+    },
+    {
+      "dimension": 55,
+      "memoized_states": 18673,
+      "minimum_relaxed_bill": 92
+    },
+    {
+      "dimension": 56,
+      "memoized_states": 19025,
+      "minimum_relaxed_bill": 92
+    },
+    {
+      "dimension": 57,
+      "memoized_states": 19372,
+      "minimum_relaxed_bill": 93
+    },
+    {
+      "dimension": 58,
+      "memoized_states": 19714,
+      "minimum_relaxed_bill": 94
+    },
+    {
+      "dimension": 59,
+      "memoized_states": 20052,
+      "minimum_relaxed_bill": 95
+    },
+    {
+      "dimension": 60,
+      "memoized_states": 20386,
+      "minimum_relaxed_bill": 95
+    },
+    {
+      "dimension": 61,
+      "memoized_states": 20721,
+      "minimum_relaxed_bill": 96
+    },
+    {
+      "dimension": 62,
+      "memoized_states": 21047,
+      "minimum_relaxed_bill": 96
+    },
+    {
+      "dimension": 63,
+      "memoized_states": 21366,
+      "minimum_relaxed_bill": 96
+    },
+    {
+      "dimension": 64,
+      "memoized_states": 21678,
+      "minimum_relaxed_bill": 97
+    },
+    {
+      "dimension": 65,
+      "memoized_states": 21982,
+      "minimum_relaxed_bill": 98
+    },
+    {
+      "dimension": 66,
+      "memoized_states": 22280,
+      "minimum_relaxed_bill": 99
+    },
+    {
+      "dimension": 67,
+      "memoized_states": 22572,
+      "minimum_relaxed_bill": 99
+    },
+    {
+      "dimension": 68,
+      "memoized_states": 22858,
+      "minimum_relaxed_bill": 100
+    },
+    {
+      "dimension": 69,
+      "memoized_states": 23138,
+      "minimum_relaxed_bill": 100
+    },
+    {
+      "dimension": 70,
+      "memoized_states": 23412,
+      "minimum_relaxed_bill": 100
+    },
+    {
+      "dimension": 71,
+      "memoized_states": 23680,
+      "minimum_relaxed_bill": 101
+    },
+    {
+      "dimension": 72,
+      "memoized_states": 23941,
+      "minimum_relaxed_bill": 102
+    }
+  ],
+  "noncoordinate_partial_fixture": {
+    "binary_rank_A": 6,
+    "fields": {
+      "3": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "eligible_roots": 7,
+        "failure_controls": 3,
+        "p_support_weights": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          1
+        ],
+        "q_support_weights": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          6
+        ],
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 4,
+          "projective_support_strata_over_Q": 4
+        },
+        "terms": 11
+      },
+      "5": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "eligible_roots": 7,
+        "failure_controls": 3,
+        "p_support_weights": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          1
+        ],
+        "q_support_weights": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          6
+        ],
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 6,
+          "projective_support_strata_over_Q": 4
+        },
+        "terms": 11
+      },
+      "7": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "eligible_roots": 7,
+        "failure_controls": 3,
+        "p_support_weights": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          1
+        ],
+        "q_support_weights": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          6
+        ],
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 8,
+          "projective_support_strata_over_Q": 4
+        },
+        "terms": 11
+      },
+      "Q": {
+        "actual_ranks": [
+          9,
+          10
+        ],
+        "costs": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          0
+        ],
+        "eligible_roots": 7,
+        "failure_controls": 3,
+        "p_support_weights": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          1
+        ],
+        "q_support_weights": [
+          5,
+          2,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          9,
+          6
+        ],
+        "quotient": {
+          "contains_coordinate_unit": false,
+          "dimension": 2,
+          "minimum_basis_cost": 7,
+          "projective_rays_checked": 4,
+          "projective_support_strata_over_Q": 4
+        },
+        "terms": 11
+      }
+    },
+    "gram_pairing_checks": 14400,
+    "orientation_signs_A": [
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      1,
+      1
+    ],
+    "root_coordinate_v": 34,
+    "root_coordinates_A": [
+      63,
+      84,
+      99,
+      109,
+      115,
+      30,
+      32
+    ],
+    "scalar_normal_basis_determinant": 1,
+    "scalar_rank_A": 7
+  },
+  "nonroot_low_neighbor_threshold": {
+    "admissible_planes": 6,
+    "forced_rank_histogram": {
+      "7": 6,
+      "8": 30474
+    },
+    "minimum": 55,
+    "ordered_pattern_pivots": 30480,
+    "patterns": 254,
+    "witness": {
+      "chars": [
+        224,
+        303,
+        463
+      ],
+      "deleted": [
+        3,
+        5,
+        6,
+        10,
+        12,
+        13,
+        16,
+        18,
+        19,
+        21,
+        23,
+        24,
+        29,
+        30,
+        31,
+        34,
+        35,
+        36,
+        37,
+        39,
+        42,
+        43,
+        45,
+        48,
+        50,
+        53,
+        55,
+        56,
+        60,
+        61,
+        64,
+        66,
+        69,
+        71,
+        74,
+        76,
+        77,
+        81,
+        82,
+        86,
+        89,
+        91,
+        92,
+        96,
+        97,
+        101,
+        102,
+        106,
+        107,
+        110,
+        111,
+        114,
+        115,
+        116,
+        119
+      ],
+      "normal": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        2
+      ],
+      "subset": 191,
+      "v": 113
+    }
+  },
+  "package_sha256": {
+    "EXTENSIONS.md": "ec6948b3ed341ee8e5ca4260be71988c0a23c279db4c58bb10e1b731c09260ff",
+    "FINITE.md": "f77bf4a1a9cfdc8d4cf90cad5599e293ee3661e97956ff6121f654f9a4f8a3b8",
+    "FORMAL.md": "0eb6407739dff3cee57729ef23f74ad502a39ab94964b0db4248ed55e5cab61f",
+    "NOTICE.md": "95f5691e46430ca41c3d2245fff29e8bba982e336bdf49eb5b0f13fe69006c31",
+    "PROOF.md": "21dad21baa2f3bd2caad1dafb3945868327ec54b0fcdc63ffccfda73e93dc601",
+    "README.md": "eca37d03405e9a45483dccc963ded53725af8b9976965280c826c3ead6f1fc1d",
+    "REFERENCES.json": "e9a7035bd8c7c3f6846c73d25f00985c3b9d0af77d7cb681082f6333798dbbfa",
+    "RELATIVE.md": "eef835999b7fe56a80306e22e9cf3b386672a7c22fda260eb21759a7a61a1250",
+    "SHARPNESS.md": "71f403572cd118d4f5e0f2221d8873d9fd782f5c8ff93c254abe698f02775c74",
+    "SOURCES.json": "37bef99d6fc7cffe6ed0a1ac2ecb87e81189afb3191ea37cf4461b163251846b",
+    "TASK.json": "ef3a66c160a1df766728ef51109871e481ae2e7091419d7c3c27acca4197068a",
+    "VERIFY.json": "b381f0b111a4c7f2f5eaefdafba9c41d5dcc1c413a35b7e4cede129c376e82e3",
+    "a9_strict_fixture.py": "1a9187dff178d219f851c3573ff9730dac71acfc91a9909b4268f6a1e97c1726",
+    "cut_basis_audit.py": "d2c2211f2d137a24a9fcf4bb946e3357a00e41c423de1a4c98bcc72b240a969c",
+    "cut_excluded_fixture.py": "3cf0c7ac2a42cb85085a3d7c62b13cc0b68f45e9dfd684332567e579cfde5bc4",
+    "dimension_audit.py": "a9b879cf5547ffc1469556398a23b3f9d97ab1ee5f092156dac5fd33c0c3d906",
+    "factors.py": "830828ce4919dde6883a89aa7a59484e12dab5e94c873832ab6a3c6299c9b9e4",
+    "finite_inputs.py": "6c0a24325ec24909ee1a7e92fc7730a2e3c0c01cee28affcdd098082f6f4f2d9",
+    "formal/CutCore.lean": "c0268d5658c412fd4ada942d0fb405317a2560ecaf6b96986fab297b05580fd5",
+    "formal/PartialBasis.lean": "eef349722916f1c689a1a09b9dd855dce5b264479da2d8c51bb9da8e2b1b42c3",
+    "independent_model.py": "ddca90cacb2aa95048da346529e0b5ac504a7ef326f1af9cb7cf29caace446a8",
+    "neighbor_audit.py": "e6ca3d56359d5a9dfdf6e62073c477e3269cf7489a3f8e975803c5ef09e03867",
+    "neighbor_primary.py": "53f19e5612aa35844874d3c4af9bb654f9dda45a22ae8b4782d0c75c0fa6f971",
+    "partial_fixture.py": "ef0e74ade45afa31ac9ab0926dcfded4e5fa26cecb6f2bebb85e5e1e13da5258",
+    "root_low_audit.py": "2f7a20ccf4db9a297b2a9154b3fe9035ef3db1e2a0406f01625e714f5e3a5991",
+    "root_low_primary.py": "e0e2cb520a5fd782e564534d4b1a6c43fe5a03c81d2035eb90353cff11a61043",
+    "vendor/__init__.py": "ce10c97f72fbdf2839d508a78d9e49429f56640f50b54d92e5994411fcbc248d",
+    "vendor/pr3755/CERTIFICATE.json": "6c3500ed02a57c1203c9f0eea7f3deee078c5e27f2d95d7f860f580b0984ffbc",
+    "vendor/pr3755/PROOF.md": "d3dcc35205225547c13f8bc0ec3175da7aab41e54c7adc06f0c35c86f00b93e4",
+    "vendor/pr3755/SPARSE-PAIR.md": "0a7c82d97837740c00273fc1261a4bfd2037c68ab05cc0e80f8968a19cfa1723",
+    "vendor/pr3755/__init__.py": "0d8f96836ffbcaac1e2e0f1f957b53e4b73ac6181edc3b6873a2fd955aec2c64",
+    "vendor/pr3755/geometry.py": "c783f6ddaf0bd5381b2345a62fe01f13e3e101ca33d70bc0495c406034782b91",
+    "verify.py": "5a40699a655a45cc82b0938b4e6e9a2f7e036c7b826acf02ac16c686f7c932ac"
+  },
+  "primary_factorizations": {
+    "3": {
+      "actual_space_contract_controls": 1,
+      "after_left_merge": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9
+        ],
+        "ranks": [
+          8,
+          8
+        ],
+        "terms": 8
+      },
+      "coordinate_family": [
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 1,
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            9,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 2,
+          "ranks": [
+            9,
+            10
+          ],
+          "terms": 11
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            9,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 3,
+          "ranks": [
+            9,
+            11
+          ],
+          "terms": 12
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 4,
+          "ranks": [
+            9,
+            12
+          ],
+          "terms": 13
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 5,
+          "ranks": [
+            9,
+            13
+          ],
+          "terms": 14
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            0
+          ],
+          "k": 6,
+          "ranks": [
+            9,
+            14
+          ],
+          "terms": 15
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            0
+          ],
+          "k": 7,
+          "ranks": [
+            9,
+            15
+          ],
+          "terms": 16
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            0
+          ],
+          "k": 8,
+          "ranks": [
+            9,
+            16
+          ],
+          "terms": 17
+        }
+      ],
+      "product_fault_controls": 3,
+      "raw_rank_counterexample": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          0,
+          0,
+          0,
+          0
+        ],
+        "ranks": [
+          9,
+          10
+        ],
+        "terms": 12
+      }
+    },
+    "5": {
+      "actual_space_contract_controls": 1,
+      "after_left_merge": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9
+        ],
+        "ranks": [
+          8,
+          8
+        ],
+        "terms": 8
+      },
+      "coordinate_family": [
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 1,
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            9,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 2,
+          "ranks": [
+            9,
+            10
+          ],
+          "terms": 11
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            9,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 3,
+          "ranks": [
+            9,
+            11
+          ],
+          "terms": 12
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 4,
+          "ranks": [
+            9,
+            12
+          ],
+          "terms": 13
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 5,
+          "ranks": [
+            9,
+            13
+          ],
+          "terms": 14
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            0
+          ],
+          "k": 6,
+          "ranks": [
+            9,
+            14
+          ],
+          "terms": 15
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            0
+          ],
+          "k": 7,
+          "ranks": [
+            9,
+            15
+          ],
+          "terms": 16
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            0
+          ],
+          "k": 8,
+          "ranks": [
+            9,
+            16
+          ],
+          "terms": 17
+        }
+      ],
+      "product_fault_controls": 3,
+      "raw_rank_counterexample": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          0,
+          0,
+          0,
+          0
+        ],
+        "ranks": [
+          9,
+          10
+        ],
+        "terms": 12
+      }
+    },
+    "7": {
+      "actual_space_contract_controls": 1,
+      "after_left_merge": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9
+        ],
+        "ranks": [
+          8,
+          8
+        ],
+        "terms": 8
+      },
+      "coordinate_family": [
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 1,
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            9,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 2,
+          "ranks": [
+            9,
+            10
+          ],
+          "terms": 11
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            9,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 3,
+          "ranks": [
+            9,
+            11
+          ],
+          "terms": 12
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 4,
+          "ranks": [
+            9,
+            12
+          ],
+          "terms": 13
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 5,
+          "ranks": [
+            9,
+            13
+          ],
+          "terms": 14
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            0
+          ],
+          "k": 6,
+          "ranks": [
+            9,
+            14
+          ],
+          "terms": 15
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            0
+          ],
+          "k": 7,
+          "ranks": [
+            9,
+            15
+          ],
+          "terms": 16
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            0
+          ],
+          "k": 8,
+          "ranks": [
+            9,
+            16
+          ],
+          "terms": 17
+        }
+      ],
+      "product_fault_controls": 3,
+      "raw_rank_counterexample": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          0,
+          0,
+          0,
+          0
+        ],
+        "ranks": [
+          9,
+          10
+        ],
+        "terms": 12
+      }
+    },
+    "Q": {
+      "actual_space_contract_controls": 1,
+      "after_left_merge": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9
+        ],
+        "ranks": [
+          8,
+          8
+        ],
+        "terms": 8
+      },
+      "coordinate_family": [
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 1,
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            9,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 2,
+          "ranks": [
+            9,
+            10
+          ],
+          "terms": 11
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            9,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 3,
+          "ranks": [
+            9,
+            11
+          ],
+          "terms": 12
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 4,
+          "ranks": [
+            9,
+            12
+          ],
+          "terms": 13
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            9,
+            0
+          ],
+          "k": 5,
+          "ranks": [
+            9,
+            13
+          ],
+          "terms": 14
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            9,
+            0
+          ],
+          "k": 6,
+          "ranks": [
+            9,
+            14
+          ],
+          "terms": 15
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            9,
+            0
+          ],
+          "k": 7,
+          "ranks": [
+            9,
+            15
+          ],
+          "terms": 16
+        },
+        {
+          "copy": 72,
+          "costs": [
+            0,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            9,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            8,
+            0
+          ],
+          "k": 8,
+          "ranks": [
+            9,
+            16
+          ],
+          "terms": 17
+        }
+      ],
+      "product_fault_controls": 3,
+      "raw_rank_counterexample": {
+        "copy": 72,
+        "costs": [
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          9,
+          0,
+          0,
+          0,
+          0
+        ],
+        "ranks": [
+          9,
+          10
+        ],
+        "terms": 12
+      }
+    }
+  },
+  "product_fault_controls": 44,
+  "relative_neighbor_threshold": {
+    "admissible_pairs": 30492,
+    "minimum_nonroot_neighbor_deletions": 27,
+    "nonroot_parabolic_patterns": 254,
+    "pattern_minima": [
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 56,
+        "simple_subset": 0,
+        "zero_root_lines": 0
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 1,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 2,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 3,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 4,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 5,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 6,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 7,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 8,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 9,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 10,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 11,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 12,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 13,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 14,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 15,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 16,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 17,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 18,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 19,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 20,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 21,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 22,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 23,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 24,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 25,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 26,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 27,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 28,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 29,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 30,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 31,
+        "zero_root_lines": 20
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 32,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 33,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 34,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 35,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 36,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 37,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 38,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 39,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 40,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 41,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 42,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 43,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 44,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 45,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 46,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 47,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 48,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 49,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 50,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 51,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 52,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 53,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 54,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 55,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 56,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 57,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 58,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 59,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 60,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 61,
+        "zero_root_lines": 15
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 62,
+        "zero_root_lines": 20
+      },
+      {
+        "admissible_root_character_pairs": 126,
+        "minimum_neighbor_deletions": 28,
+        "simple_subset": 63,
+        "zero_root_lines": 36
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 64,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 65,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 66,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 67,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 68,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 69,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 70,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 71,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 72,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 73,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 74,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 75,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 76,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 77,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 78,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 79,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 80,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 81,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 82,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 83,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 84,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 85,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 86,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 87,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 88,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 89,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 90,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 91,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 92,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 93,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 94,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 95,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 96,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 97,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 98,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 99,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 100,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 101,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 102,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 103,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 104,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 105,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 106,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 107,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 108,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 109,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 110,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 111,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 112,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 113,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 114,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 115,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 116,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 117,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 118,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 119,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 120,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 121,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 122,
+        "zero_root_lines": 15
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 123,
+        "zero_root_lines": 16
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 124,
+        "zero_root_lines": 15
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 125,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 40,
+        "simple_subset": 126,
+        "zero_root_lines": 30
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 55,
+        "simple_subset": 128,
+        "zero_root_lines": 1
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 129,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 130,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 131,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 132,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 133,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 134,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 135,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 136,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 137,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 138,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 139,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 140,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 141,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 142,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 143,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 144,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 145,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 146,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 147,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 148,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 149,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 150,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 151,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 152,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 153,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 154,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 155,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 156,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 157,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 158,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 159,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 160,
+        "zero_root_lines": 2
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 161,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 162,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 163,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 164,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 165,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 166,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 167,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 168,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 169,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 170,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 171,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 172,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 173,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 174,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 175,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 176,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 177,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 178,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 179,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 180,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 181,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 182,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 183,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 184,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 185,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 186,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 187,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 188,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 189,
+        "zero_root_lines": 16
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 190,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 126,
+        "minimum_neighbor_deletions": 27,
+        "simple_subset": 191,
+        "zero_root_lines": 37
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 54,
+        "simple_subset": 192,
+        "zero_root_lines": 3
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 193,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 194,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 195,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 196,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 197,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 198,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 199,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 200,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 201,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 202,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 203,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 204,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 205,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 206,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 207,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 53,
+        "simple_subset": 208,
+        "zero_root_lines": 4
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 209,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 210,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 211,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 212,
+        "zero_root_lines": 5
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 213,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 214,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 215,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 216,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 217,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 218,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 219,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 220,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 221,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 222,
+        "zero_root_lines": 15
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 223,
+        "zero_root_lines": 23
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 52,
+        "simple_subset": 224,
+        "zero_root_lines": 6
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 225,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 226,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 227,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 228,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 229,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 230,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 231,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 232,
+        "zero_root_lines": 7
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 51,
+        "simple_subset": 233,
+        "zero_root_lines": 8
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 234,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 235,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 236,
+        "zero_root_lines": 9
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 237,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 238,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 239,
+        "zero_root_lines": 16
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 50,
+        "simple_subset": 240,
+        "zero_root_lines": 10
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 241,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 242,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 243,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 244,
+        "zero_root_lines": 11
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 245,
+        "zero_root_lines": 13
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 49,
+        "simple_subset": 246,
+        "zero_root_lines": 12
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 48,
+        "simple_subset": 247,
+        "zero_root_lines": 14
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 248,
+        "zero_root_lines": 15
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 47,
+        "simple_subset": 249,
+        "zero_root_lines": 16
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 250,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 251,
+        "zero_root_lines": 22
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 44,
+        "simple_subset": 252,
+        "zero_root_lines": 21
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 41,
+        "simple_subset": 253,
+        "zero_root_lines": 28
+      },
+      {
+        "admissible_root_character_pairs": 120,
+        "minimum_neighbor_deletions": 35,
+        "simple_subset": 254,
+        "zero_root_lines": 42
+      }
+    ],
+    "root_character_comparisons": 15575280,
+    "witness": {
+      "character": 463,
+      "deleted_root_indices": [
+        5,
+        6,
+        12,
+        13,
+        18,
+        19,
+        23,
+        24,
+        34,
+        35,
+        36,
+        37,
+        42,
+        43,
+        48,
+        53,
+        61,
+        64,
+        69,
+        74,
+        82,
+        89,
+        97,
+        107,
+        110,
+        111,
+        119
+      ],
+      "deletion_count": 27,
+      "normal": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        2
+      ],
+      "root": 113,
+      "simple_subset": 191,
+      "zero_root_lines": 37
+    }
+  },
+  "root_low_neighbor_threshold": {
+    "forced_label_rank_histogram": {
+      "1": 120,
+      "7": 6720,
+      "8": 7560
+    },
+    "minimum_root_weight_seven_neighbor_deletions": 29,
+    "ordered_root_pairs": 14400,
+    "self_root_lower_bound_from_three_cuts": 36,
+    "unique_neighbor_annihilator_planes": 6720,
+    "witness": {
+      "characters": [
+        3,
+        505,
+        506
+      ],
+      "deleted_indices": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69
+      ],
+      "pivot": 0,
+      "root_normal": 1
+    }
+  },
+  "schema_version": 1,
+  "scope": "Finite E8 inputs, exact constructions and source binding; written theorem assembly",
+  "separate_full_support_stratum_certificate": {
+    "candidates": 169,
+    "eligible_patterns": [
+      {
+        "characters": 3,
+        "kind": "nonroot",
+        "patterns": 112
+      },
+      {
+        "characters": 3,
+        "kind": "root",
+        "patterns": 56
+      },
+      {
+        "characters": 255,
+        "kind": "root",
+        "patterns": 1
+      }
+    ],
+    "kernels": {
+      "0": 256,
+      "1": 198,
+      "2": 56
+    },
+    "minima": {
+      "nonroot": 55,
+      "root": 29
+    },
+    "planes": 10963,
+    "witnesses": {
+      "nonroot": {
+        "characters": [
+          3,
+          13,
+          14
+        ],
+        "deleted": [
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          43,
+          44,
+          45,
+          46,
+          47,
+          48,
+          49,
+          50,
+          51,
+          52,
+          53,
+          54,
+          55,
+          56,
+          57,
+          58,
+          59,
+          60,
+          61,
+          62,
+          63,
+          65,
+          66,
+          67,
+          68,
+          69,
+          70,
+          71,
+          72,
+          73,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          82,
+          83,
+          84
+        ],
+        "normal": [
+          1,
+          3,
+          -3,
+          1,
+          1,
+          -1,
+          -1,
+          -1
+        ],
+        "root": null
+      },
+      "root": {
+        "characters": [
+          3,
+          13,
+          14
+        ],
+        "deleted": [
+          1,
+          2,
+          10,
+          11,
+          12,
+          13,
+          14,
+          43,
+          54,
+          55,
+          56,
+          57,
+          58,
+          59,
+          60,
+          61,
+          62,
+          63,
+          64,
+          65,
+          66,
+          67,
+          68,
+          69,
+          70,
+          71,
+          72,
+          73,
+          74
+        ],
+        "normal": [
+          1,
+          -1,
+          1,
+          1,
+          1,
+          -1,
+          -1,
+          -1
+        ],
+        "root": 64
+      }
+    }
+  },
+  "separate_model": {
+    "additional_eleven_term_fixtures": 4,
+    "agreement_on_all_coordinate_profiles": true,
+    "coordinate_fixtures": 32,
+    "fields": [
+      "Q",
+      "3",
+      "5",
+      "7"
+    ],
+    "gram_pairing_checks": 14400,
+    "root_lines": 120
+  },
+  "separate_relative_kernel_certificate": {
+    "all_minimizers_sha256": "4d7a7fed481fa48a8a19ed762c8d69c9fb8650ecffe0347bf1ba3f1c775cc07f",
+    "characters": 511,
+    "classification_boundary_control": {
+      "binary_weight": 8,
+      "character": 12,
+      "deletion_count": 24,
+      "fixed_root": 0,
+      "negative_correction_indices": [
+        1,
+        2,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53
+      ],
+      "own_root_correction": 0,
+      "own_root_value": 2,
+      "positive_correction_indices": [
+        8,
+        9,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74
+      ],
+      "scope": "eligible-root classification boundary; not an exact decoder"
+    },
+    "complement_nonroot_minimum": 35,
+    "critical_stratum_histogram": [
+      {
+        "deletion_count": 24,
+        "is_root": true,
+        "kernel_dimension": 1,
+        "multiplicity": 63
+      },
+      {
+        "deletion_count": 28,
+        "is_root": true,
+        "kernel_dimension": 1,
+        "multiplicity": 72
+      },
+      {
+        "deletion_count": 32,
+        "is_root": true,
+        "kernel_dimension": 1,
+        "multiplicity": 63
+      },
+      {
+        "deletion_count": 27,
+        "is_root": false,
+        "kernel_dimension": 2,
+        "multiplicity": 56
+      },
+      {
+        "deletion_count": 1,
+        "is_root": true,
+        "kernel_dimension": 2,
+        "multiplicity": 56
+      }
+    ],
+    "fixed_label": 508,
+    "fixed_root": 0,
+    "generic_nonroot_histogram": {
+      "28": 56
+    },
+    "kernel_dimension_histogram": {
+      "0": 256,
+      "1": 198,
+      "2": 56,
+      "8": 1
+    },
+    "matching_root_cases": 56,
+    "minimum_critical_root_mismatch_deletions": 24,
+    "minimum_nonroot_neighbor_deletions": 27,
+    "minimum_nonroot_witness_count": 56,
+    "minimum_nonroot_witnesses": [
+      {
+        "character": 13,
+        "deletion_roots": [
+          1,
+          2,
+          10,
+          11,
+          12,
+          13,
+          14,
+          54,
+          55,
+          56,
+          57,
+          58,
+          59,
+          60,
+          61,
+          62,
+          63,
+          65,
+          66,
+          67,
+          68,
+          69,
+          70,
+          71,
+          72,
+          73,
+          74
+        ],
+        "normal": [
+          1,
+          -3,
+          3,
+          1,
+          1,
+          -1,
+          -1,
+          -1
+        ],
+        "stratum": "critical"
+      }
+    ],
+    "root_lines": 120,
+    "root_mismatch_uniform_source_lower_bound": 24,
+    "special_complement_character": 3,
+    "transport": {
+      "distinct_reflections": 56,
+      "reflection_root_image_checks": 6720,
+      "root_tree_edge_count": 119,
+      "root_tree_edges_sha256": "7d73a8f615f09c0d50ac25b24ea6ee84e493733290d0317ae9aa98f7b5e778ed"
+    }
+  },
+  "separate_root_low_plane_certificate": {
+    "forced_character_counts": {
+      "1": 63,
+      "255": 1,
+      "3": 56
+    },
+    "minimum_deletions_for_root_weight_at_most_seven": 29,
+    "planes": 10851,
+    "root_lines": 120,
+    "witness": {
+      "characters": [
+        3,
+        505,
+        506
+      ],
+      "deleted": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69
+      ],
+      "root": 1
+    }
+  },
+  "sources": {
+    "live_input_count": 4,
+    "live_inputs": [
+      "research/biframe-decoder-ladder/README.md",
+      "research/decoder-certificate-ceilings/README.md",
+      "research/e8-d0-root-swaps/PROOF.md",
+      "formal/lean/lean-toolchain"
+    ],
+    "pending_commit_required_at_runtime": false,
+    "retained_pending_source_files": 4
+  },
+  "strict_basis73_copy72_fixture": {
+    "coordinate_roots": [
+      1,
+      33,
+      7,
+      63,
+      0,
+      8,
+      15,
+      21,
+      26
+    ],
+    "fields": {
+      "3": {
+        "actual_basis_bill": 73,
+        "actual_nonpivot_basis_weights": [
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8
+        ],
+        "actual_ranks": [
+          9,
+          17
+        ],
+        "both_normalizations_stable": true,
+        "coordinate_count": 9,
+        "copy": 72,
+        "copy_costs": [
+          0,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          0
+        ],
+        "failed_product_controls": 2,
+        "terms": 18,
+        "unsheared_after_merge": {
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        }
+      },
+      "5": {
+        "actual_basis_bill": 73,
+        "actual_nonpivot_basis_weights": [
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8
+        ],
+        "actual_ranks": [
+          9,
+          17
+        ],
+        "both_normalizations_stable": true,
+        "coordinate_count": 9,
+        "copy": 72,
+        "copy_costs": [
+          0,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          0
+        ],
+        "failed_product_controls": 2,
+        "terms": 18,
+        "unsheared_after_merge": {
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        }
+      },
+      "7": {
+        "actual_basis_bill": 73,
+        "actual_nonpivot_basis_weights": [
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8
+        ],
+        "actual_ranks": [
+          9,
+          17
+        ],
+        "both_normalizations_stable": true,
+        "coordinate_count": 9,
+        "copy": 72,
+        "copy_costs": [
+          0,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          0
+        ],
+        "failed_product_controls": 2,
+        "terms": 18,
+        "unsheared_after_merge": {
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        }
+      },
+      "Q": {
+        "actual_basis_bill": 73,
+        "actual_nonpivot_basis_weights": [
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8
+        ],
+        "actual_ranks": [
+          9,
+          17
+        ],
+        "both_normalizations_stable": true,
+        "coordinate_count": 9,
+        "copy": 72,
+        "copy_costs": [
+          0,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          1,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          8,
+          0
+        ],
+        "failed_product_controls": 2,
+        "terms": 18,
+        "unsheared_after_merge": {
+          "ranks": [
+            9,
+            9
+          ],
+          "terms": 10
+        }
+      }
+    },
+    "gram_pairing_checks": 14400,
+    "outside_orthogonal_frame": [
+      2,
+      10,
+      17,
+      34,
+      52,
+      77,
+      95,
+      119
+    ],
+    "pivot_root": 1,
+    "simple_graph_adjacency": [
+      [
+        2
+      ],
+      [
+        3
+      ],
+      [
+        0,
+        3
+      ],
+      [
+        1,
+        2,
+        4
+      ],
+      [
+        3,
+        5
+      ],
+      [
+        4,
+        6
+      ],
+      [
+        5,
+        7
+      ],
+      [
+        6
+      ]
+    ],
+    "simple_normal_basis_determinant": 1
+  }
+}
diff --git a/research/e8-coupled-coordinate-floor/SHARPNESS.md b/research/e8-coupled-coordinate-floor/SHARPNESS.md
new file mode 100644
index 0000000000..82b1530062
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/SHARPNESS.md
@@ -0,0 +1,365 @@
+# Exact sharp fixtures and normalization boundaries
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+These constructions establish nonvacuity and sharpness in the stated spaces;
+they do not prove a universal decoder lower bound.
+
+## All odd characteristics, every k from one through eight
+
+Use the full E8 root-evaluation code `C`, norm-two root representatives,
+the fixed dense binary labels, and an orthogonal root frame `h_1,...,h_8`.
+Write `E_i=E(h_i)`, `d_i=delta_{h_i}`, `A={h_1,...,h_k}`,
+`R=E_1-4d_1`, and `H=E_1-2d_1`. Over every field of characteristic other
+than two, take the following `9+k` corresponding columns:
+
+```
+P=(H; E_b/2-R/4 [2<=b<=k]; R/4;
+   -E_b/2 [2<=b<=k]; E_j/4 [j>k]; d_1),
+Q=(d_1; d_b [2<=b<=k]; R+sum_{b=2}^k d_b;
+   d_b-E_b/2 [2<=b<=k]; E_j [j>k]; H).
+```
+
+For each b, its unit and hole terms give
+
+```
+(E_b/2-R/4)d_b^t-(E_b/2)(d_b-E_b/2)^t
+    =E_b E_b^t/4-R d_b^t/4.
+```
+
+The final summands cancel the added units in the middle Q column. Moreover
+`H d_1^t+R R^t/4+d_1 H^t=E_1 E_1^t/4`. Thus the product is
+`sum_i E_i E_i^t/4=G/2`, with all scalar constants explicit.
+
+The coefficient list `(E_1,...,E_8,d_1,...,d_k)` is independent. One way to
+see the only nontrivial part is to show that off-frame roots span the scalar
+root space: each E8 root has 56 nonself nonorthogonal root lines, so for
+each frame root h_i choose a nonorthogonal nonframe root r;
+its reflection `r' = r-(r dot h_i)h_i` is also nonframe and
+`r-r'=+h_i` or `-h_i`. Hence a codeword supported only on the frame vanishes.
+The root frame itself has Gram `2I`, so this argument works over every odd
+characteristic. Consequently `C intersect D_A=0`.
+
+P contains d_1, recovers E_1 from H, and recovers each other frame direction;
+its actual rank is nine and its actual space is `C+K d_1`. Q contains every
+d_i, recovers E_b from the holes and E_1 from R, and contains the remaining
+E_j. Its actual rank is `8+k` and its actual space is exactly `C+D_A`.
+Every term is active. Distinct coefficient patterns prove each factor family
+is pairwise nonproportional: code-only directions use different E_i, all mixed
+b columns use their own E_b, and the two E_1-bearing mixed directions have
+different d_1 coefficients. Their difference is a unit multiple of two,
+so no projective collision appears in characteristic three.
+
+The root-hole support identities are those of PR3755 `SPARSE-PAIR.md` section 2:
+`U(E_i)=Lambda` and `U(d_i-E_i/2)=u_i^perp`, in every odd characteristic.
+The two H/unit pairings cost zero. Each unit d_b costs one, since its P
+factor has value one at b and the dense pairing has diagonal one. Each b-hole
+costs eight against its full-support-span codeword. The middle R term and
+untouched frame terms cost nine: R has exactly the support of E_1, and the
+added orthogonal units do not cancel it. The sorted profile is
+
+```
+0,0, 1^(k-1), 8^(k-1), 9^(9-k),             COPY=72.
+```
+
+At k=2 this is the sharp eleven-term profile `(0,0,1,8,9^7)`, attaining
+`7*9^q+8^q+1` for `0<q<1`. No concave sharpness for fixed k>2 is asserted.
+A distinct eleven-term construction is also
+retained as an independent checker control: its b/E3 shear gives the same profile.
+All identities use only powers of two as denominators.
+
+## Why activity, normalization and actual Q matter
+
+Let `a=h_1`, choose a nonorthogonal root b, and put `H_a=E(h_1)-2d_a`.
+Append to the ordinary eight-term frame the four atoms
+
+```
+(d_a,H_a), (-d_a,H_a), (d_a,d_b), (-d_a,d_b).
+```
+
+Every factor is nonzero, their four products cancel, and all four costs are
+zero: H_a annihilates the binary label of a, while nonorthogonal a,b have
+binary pairing zero. Raw ranks are `(9,10)` and raw Q is the full coordinate
+pair extension. Yet the bill is still `8*9^q`. The repeated left ray violates
+normalization; merging it deletes all four padding atoms and leaves ranks
+`(8,8)`. Thus a strict moment conclusion for arbitrary raw ranks is false.
+
+The k=1 normalized fixture supplies a separate boundary. Its ranks are
+`(9,9)` and its bill is `8*9^q`. It lies inside every larger ambient
+coordinate extension containing a, but does not span that larger space.
+Ambient containment cannot replace actual full-Q equality in the normalized
+full-coordinate theorem.
+
+Finally, zero-factor padding can manufacture raw ranks `(9,10)` with no bill
+change. Conversely an active cost-zero atom generally has a nonzero product
+and cannot be deleted. The independent checker rejects deletion of such an
+atom, omission of a compensating shear, wrong product scaling, and the inactive
+or proportional-padding hypotheses.
+
+## Exact finite evidence
+
+`independent_model.py` independently reconstructs the standard E8 roots in the
+declared PR3755 A8 order and checks all 120 root lines and 14,400 Gram/pairing
+identities. No candidate module or certificate is imported. It directly checks
+every product entry, actual scalar ranks, active factors, both projective
+normalizations, actual Q equality, binary support ranks and actual COPY ranks
+for k=1,...,8 and the distinct earlier eleven-term fixture over Q, F3, F5 and
+F7, together with six semantic controls per field. Explicit exceptions keep
+checks enabled under Python optimization.
+
+These finite-field examples check the algebra above; they do not substitute
+for its all-odd-field argument. The registered package replay runs both
+implementations sequentially, with source authentication.
+
+## A noncoordinate partial quotient attains 72
+
+This construction witnesses the neighbor-supported partial-quotient corollary
+with actual normalized ranks `(9,10)`, rather than a full coordinate extension.
+In standard coordinates put
+
+```
+J_i=e_0-e_i (1<=i<=5),  u=e_6-e_7,  w=e_0+e_6,  v=e_0+e_7,
+q=sum_i delta_{J_i}+delta_u,        b=delta_u+delta_w,
+D'=span(q,b),                      A={J_1,...,J_5,u,w}.
+```
+
+All seven A roots are nonorthogonal to v. Their scalar rank is seven but
+their binary-label rank is **six**: the five J labels are beta-orthonormal,
+`u_label=sum_i J_i_label`, and the w label lies outside their span.
+Consequently `w(q)=5`, `w(b)=2`, and every `q+t b` with t nonzero has weight
+six. The coordinate pattern of `xq+yb` is `(x,x,x,x,x,x+y,y)`, so D' has
+no coordinate unit ray. Its minimum basis cost is exactly seven, attained
+by q,b. Thus D' is a proper noncoordinate subspace of D_A.
+
+The declared model orients the roots as `h_i=-J_i` for i=1,...,5,
+`h_6=u`, `h_7=w`. Complete them with the scalar normal `h_8=e_7`.
+This normal basis has determinant one. Its dot-product dual is explicit:
+
+```
+d_i=e_i (1<=i<=5),
+d_6=-e_0-sum_i e_i+e_6,    d_7=e_0+sum_i e_i,
+d_8=-e_0-sum_i e_i+e_6+e_7.
+```
+
+Set `t_i=E(d_i)/2`, `L_q=2sum_{i=1}^5 t_i`, and
+`L_b=-2sum_{i=1}^5 t_i+2t_6+2t_7`. Define
+
+```
+g_i=E(h_i)-2(q-b) (1<=i<=5),
+g_6=E(h_6)-2b,    g_7=E(h_7)-2b,    g_8=E(h_8),
+P=(L_q-delta_v, L_b-delta_v, t_1,...,t_8, delta_v),
+Q=(q, b, g_1,...,g_8, q+b).
+```
+
+The high terms satisfy
+`sum_i t_i g_i^t=G/2-L_q q^t-L_b b^t`. The two low code terms compensate
+this exactly; subtracting delta_v from each introduces
+`-delta_v(q+b)^t`, canceled by the last atom. Thus `P Q^t=G/2`.
+
+The ten nonpivot Q columns form an actual basis of `C+D'`: their eight code
+components form a scalar basis and q,b supply the quotient. Its dimension is
+ten, since a nonzero codeword has binary support span nine while D' is supported
+in a label span of dimension six. P has actual space `C+K delta_v` and rank
+nine. Distinct high code components prevent proportional high Q columns;
+q,b,q+b are three distinct quotient rays. On P the t_i form a code basis,
+delta_v is outside C, and the two mixed columns have the same nonzero outside
+coefficient but different nonzero code normals. Both families are therefore
+active and pairwise nonproportional.
+
+These facts hold in every odd characteristic. The basis and dual are integral
+and unimodular, and all displayed denominators are powers of two. Every g_i
+for i<=7 has exactly its ordinary root-hole support: the eligible correction
+cancels its own value two, while changes at the other supported A coordinates
+only flip values +1 and -1. Thus these seven columns have weight eight.
+The scalar normal of L_q is `sum_i e_i`, and that of L_b is
+`-sum_i e_i+e_6`. Both pair to zero with h_8, whereas the root v pairs to one.
+Neither mixed P column can therefore be the singleton hole; singleton
+classification gives both weight nine. Every other nonzero code column has
+weight nine. Finally q+b is supported on neighbors of v, so its pivot costs zero.
+The exact term profile is
+
+```
+(5,2,8,8,8,8,8,8,8,9,0),                COPY=72.
+```
+
+`partial_fixture.py` independently checks the actual orientations,
+duality, determinant, eligibility, quotient strata, actual spaces and ranks,
+normalization, all product entries and all binary charges over Q, F3, F5 and
+F7. It also rejects deletion of the active free pivot, omission of a singleton
+compensation, and a wrong quotient sign. The fixture works over all
+odd fields; the broader partial-quotient theorem's field scope is separate.
+
+## A cut-excluded pivot beyond the all-neighbor case
+
+Keep the preceding A, D', dual normals, t_i, L_q, L_b and g_i. Choose a root
+v whose label is outside U_A, with `beta(u_v,u_u)=beta(u_v,u_w)=0` and at
+least one `beta(u_v,u_{J_i})=1`. Such a root exists: the line `e_1+e_6` is
+nonorthogonal to u,w and orthogonal to J_2,...,J_5. Its label is outside U_A.
+Indeed, inside the beta-orthonormal span of the five J labels and w, pairing
+zero with w eliminates the w coefficient, and pairing zero with u (the sum
+of the J labels) would force even binary norm, contradicting a root label's
+norm one. Thus this A is not entirely supported on neighbors of v.
+
+Use the eleven corresponding columns
+
+```
+P=(L_q, L_b-delta_v, t_1,...,t_8, delta_v),
+Q=(q, b, g_1,...,g_8, b).
+```
+
+The original code compensation is unchanged. The sole new error
+`-delta_v b^t` is canceled by the last atom, so the product is G/2.
+The nonpivot Q columns remain an actual ten-column basis of `C+D'`.
+P has actual space `C+K delta_v` and rank nine, and all its columns are
+nonzero and pairwise nonproportional. In particular L_q is a sum of five
+independent dual directions and is proportional to none of the t_i. The
+code normal of L_b is `-sum_i e_i+e_6`, with exactly six nonzero scalar
+coordinates. A standard root has either two or eight nonzero coordinates,
+so this normal cannot become a root direction over any odd field. Singleton
+classification therefore gives `w(L_b-delta_v)=9`.
+
+The same support identities give term costs
+`(5,2,8,8,8,8,8,8,8,9,0)`, totaling 72. The pivot is free because b is
+supported on u,w, both pairing zero with u_v. However q does not vanish on
+O_v, since at least one of its J coordinates lies there. The quotient is
+therefore not contained in the coordinate space supported on v's neighbors.
+This witnesses the broader cut-excluded partial-quotient hypothesis rather
+than the all-neighbor special case. The fixture works over every odd field;
+this does not enlarge the field scope of the general theorem.
+
+This variant is normalized on the **left only**. Its two b readers on the
+right are equal. Merging them replaces `(L_b-delta_v,b),(delta_v,b)` by
+`(L_b,b)`, giving a ten-term, doubly normalized decoder of actual ranks
+`(8,10)` with the same bill. The rank-(9,10) claim must not be attached to
+that fully normalized decoder. In contrast, the preceding all-neighbor
+partial fixture remains rank-(9,10) under normalization on both sides.
+
+`cut_excluded_fixture.py` selects its pivot deterministically from the fixed
+root order. Its audit checks the outside-span and nonneighbor conditions,
+actual factor spaces and ranks, left normalization, repeated right readers,
+all product entries and COPY ranks over Q, F3, F5 and F7. It also checks the
+actual nonpivot basis cut (rank nine, exactly b vanishing), the explicit right
+merge and full normalizer's rank drop, and three failed-product controls.
+
+# A nine-coordinate equality fixture for strict-basis compensation
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+This exact construction works over every field of characteristic other than
+two. Its universal identities and support argument are given below; separate
+finite replays over Q, F3, F5 and F7 check the implementation.
+
+Choose the eight standard E8 simple root lines a_i, retaining the fixed model
+orientations h_i=r_{a_i}, and take v to be the line e_1-e_3, row 1 of the
+fixed model, outside those eight lines. Put
+`A={v,a_1,...,a_8}`. Let d_i be the dot-product dual basis, and write
+
+```
+c_i=(r_v,h_i),       beta_i=(r_v,d_i),
+t_i=E(d_i)/2,        e=delta_v,         J=e-E(r_v)/2.
+```
+
+The simple-normal matrix has determinant plus or minus one. Its graph Γ,
+joining nonorthogonal distinct h_i, is the connected E8 tree. Define
+
+```
+g_i=E(h_i)-2delta_{a_i}+c_i e+sum_{j adjacent i}delta_{a_j},
+H_i=t_i-(beta_i/4)e,
+U_i=2H_i-sum_{j adjacent i}H_j,
+q_0=E(r_v)/4-e/2=-J/2.
+```
+
+Take eighteen corresponding columns
+
+```
+P=(J; U_1,...,U_8; H_1,...,H_8; e),
+Q=(e; delta_{a_1},...,delta_{a_8}; g_1,...,g_8; q_0).
+```
+
+## Exactness and the actual pivot coordinate
+
+The ordinary dual-basis product is `sum_i t_i E(h_i)^t=G/2`.
+Expanding each g_i gives code readers `2t_i-sum_{j adjacent i}t_j` on the
+a_i units and `-sum_i c_i t_i=-E(r_v)/2` on e. The displayed P adds precisely
+the singleton coefficients needed to cancel the pivot e q_0^t.
+Explicitly set `alpha_i=2beta_i-sum_{j adjacent i}beta_j`. Then
+
+```
+q_0=-e+sum_i (alpha_i/4)delta_{a_i}+sum_i (beta_i/4)g_i.
+```
+
+The e coefficient is exactly minus one because
+`sum_i beta_i c_i=(r_v,r_v)=2`. Thus the actual e reader has encoder J,
+the high encoders are H_i, and the remaining unit encoders are U_i.
+This proves `P Q^t=G/2` with the free-pivot sign and all scalar constants fixed.
+
+## Actual spaces and projective normalization
+
+The seventeen nonpivot Q columns span `C+D_A`: the units recover all g_i's
+code components. Row 0 is e_1-e_2 and belongs to the selected simple basis,
+so the checker's first root outside that basis is the stated row 1.
+An explicit orthogonal frame outside this fixed A is
+
+```
+e_0+e_2, e_0-e_2, e_1+e_4, e_1-e_4,
+e_3+e_6, e_3-e_6, e_5+e_7, e_5-e_7.
+```
+
+Its Gram matrix is 2I, so the roots outside A span all eight scalar
+dimensions over every odd field. Consequently `C intersect D_A=0` and
+actual rank Q is seventeen. The checker also returns an explicit outside
+frame with model indices `(2,10,17,34,52,77,95,119)` and checks its integral
+Gram matrix; this is an all-odd-field rank certificate, not an extrapolation
+from the three finite fields.
+
+The eight H_i span the lifted code
+`T={E(n)-(r_v,n)e/2:n in K^8}`. This space contains neither e nor J: the
+code normal of J would be `-r_v/2`, whose lift has e coefficient 1/2 rather
+than one. Thus P has actual rank nine. Singleton classification makes every
+nonzero member of T have binary support weight nine.
+
+In the H_i coordinates, U_i is row i of `2I-Adj(Γ)`. Each row has at least
+two nonzero coordinates, and the eight closed neighborhoods of the connected
+E8 tree are distinct. Therefore the U_i are pairwise nonproportional and
+none is proportional to an H_i, in every odd characteristic. All sixteen
+belong to T, so neither exceptional P ray collides with them. Q's seventeen
+nonpivot members are a basis; q_0 is proportional to none, because its code
+normal is r_v, distinct from every h_i, and it is not pure. Both full factor
+families are active and pairwise nonproportional.
+Here `2I-Adj(Γ)` is the chosen shear coefficient matrix; individual products
+of the model-oriented roots may have either sign.
+
+## Charges and the role of the cross shears
+
+Every g_i lies in the root-hole hyperplane u_{a_i}^perp. Its correction at v
+is allowed only when v is a neighbor; it doubles the old nonzero value.
+Each other correction is at a graph neighbor and can delete at most one
+nonself root-hole coordinate. Degree at most three and the remainder cut
+bound 24 preserve the full binary span of dimension eight. These statements
+hold in every odd field. The actual nonpivot basis weights and term costs are
+
+```
+Q basis: 1^9,8^8,                 actual basis bill=73,
+COPY:    0,1^8,8^8,0,             COPY=72.
+```
+
+Thus the characteristic-zero strict basis floor 73 is sharp for this full
+nine-coordinate space, and its coupled floor 72 is also sharp. The fixture
+itself works over all odd fields; no general positive-characteristic strict
+basis theorem is inferred.
+
+Without the graph cross shears, U_i becomes 2H_i. That exact raw fixture has
+eight repeated left rays and merges to ten terms of actual ranks (9,9).
+The graph shears therefore solve a real normalization obstruction; a raw
+rank assertion alone would not establish this full actual rank-seventeen
+sharpness. The checker verifies this collapse as a positive control.
+
+## Exact finite evidence
+
+`a9_strict_fixture.py` checks all product entries, actual factor spaces and
+ranks, active factors, both projective normalizations, the outside Gram
+certificate, the actual pivot-coordinate expansion, all support weights and
+actual COPY ranks over Q, F3, F5 and F7. It rejects deletion of either active
+free atom and verifies the unsheared normalization collapse. The stated
+minimum basis bill 73 is a characteristic-zero conclusion of the inherited
+distance/capacity floor and this attaining actual basis. Over odd fields
+the fixture certifies the actual basis bill
+73 and COPY72; no universal positive-characteristic basis floor is asserted.
diff --git a/research/e8-coupled-coordinate-floor/SOURCES.json b/research/e8-coupled-coordinate-floor/SOURCES.json
new file mode 100644
index 0000000000..ab899cb3de
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/SOURCES.json
@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "research/biframe-decoder-ladder/README.md",
+      "usage": "input",
+      "git_blob": "65afcf129309dc87e6090557e66d750d19bd5705",
+      "sha256": "95b71fb2e519e258811882d8d06359090da7a697aa77ba4c326c25a66d00bd36"
+    },
+    {
+      "path": "research/decoder-certificate-ceilings/README.md",
+      "usage": "input",
+      "git_blob": "bf5a8fd5d353c304aa42e3333a9799ba082122bb",
+      "sha256": "22c0f68e0b553ce70054ece41a13b18b6e3fb45d84165ec6f0bfe78e2f39cc75"
+    },
+    {
+      "path": "research/e8-d0-root-swaps/PROOF.md",
+      "usage": "input",
+      "git_blob": "79051f9f431863259dd7d714e096ce9e865b151b",
+      "sha256": "531b1dcb0de5f652fa2ca8dca97174c4973face53c877bd919cf584afa632953"
+    },
+    {
+      "path": "formal/lean/lean-toolchain",
+      "usage": "input",
+      "git_blob": "980709bbbae28702ec58c368b84fdf6638093c63",
+      "sha256": "d24fed434d3b13adfaab57724a0a7f270ea8bf1c818b5ae5cf25cbce24dd685c"
+    }
+  ]
+}
diff --git a/research/e8-coupled-coordinate-floor/TASK.json b/research/e8-coupled-coordinate-floor/TASK.json
new file mode 100644
index 0000000000..e13e592704
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/TASK.json
@@ -0,0 +1,117 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 6,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md",
+      "research/selected-k8-unrestricted-ends/README.md",
+      "research/eisenstein-reduction-copy-floor/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Term-count-independent coupled full-E8 COPY floor for singleton left spaces: all actual full coordinate right spaces, raw coordinate pairs, raw neighbor-supported partial quotients through 28 coordinates, cut-excluded supports through 13, and arbitrary actual right rank at least 24.",
+  "scope_change_reason": "Active E8 C-prime/RL-s1 handoff and PR3755 higher-rank residual after a full local overlap scout; a structural lower bound is more actionable than repeating fixed-word rank synthesis.",
+  "bottleneck_link": "Scoped complex-decoder obstruction: identifies canonical larger-rank families that cannot lower the COPY72 bill. Side result; not the original card construction acceptance gate or a new kappa.",
+  "budget_minutes": 60,
+  "stop_rule": "Complete the actual-basis compensation and bounded finite premises; use additional research time to remove easy partial-quotient boundaries, then freeze one locally reviewable commit. Stop before general arbitrary-space C-prime or a frontier change.",
+  "outcome": "completed",
+  "evidence": "PROOF.md, EXTENSIONS.md, RELATIVE.md, FINITE.md and SHARPNESS.md; source-bound RESULT.json replay, two exact models, two relative-cut methods, two dimension DPs, five partial Lean declarations. Sharp nonroot low-word threshold55 by two complete reductions and an attaining rank-(9,17) strict-basis73/COPY72 fixture.",
+  "author": "conorholds",
+  "ai_assistance": "Substantial OpenAI Codex assistance, including GPT-6.1 SOL agents at xHigh reasoning. Internal AI mathematical reviews and exact cross-checks; no independent human review.",
+  "open_questions": [
+    {
+      "question": "Arbitrary partial reader spaces in dimensions 10 through 23",
+      "why_it_matters": "These are the unclosed higher-rank leaves beyond the actual coordinate and support-restricted families.",
+      "first_step": "Analyze the actual bill-72 basis functional cut; retain the minimum-basis cut counterexample.",
+      "blocked_by": "No general equality-basis cut structure or strict basis slack is established."
+    },
+    {
+      "question": "Neighbor supports at or beyond 29",
+      "why_it_matters": "Mixed root weight-seven words appear at29 and invalidate the pure-low actual-basis step; nonroot low words require55, so29 through54 are root-only cases.",
+      "first_step": "Analyze actual basis saturation with the explicit root-low29 witness.",
+      "blocked_by": "New low mixed directions must be charged; the eligible-only classification already fails at24."
+    },
+    {
+      "question": "Full formal E8 and decoder assembly",
+      "why_it_matters": "Current Lean coverage checks only the exposed arithmetic/additive core.",
+      "first_step": "Instantiate the additive cut lemma with scalar linear functionals and binary tariffs.",
+      "blocked_by": "Formal root/label and geometric dependency bridges are not supplied."
+    }
+  ],
+  "coordination": {
+    "publication": "local only; explicit user approval required for every upstream write",
+    "base_refresh_utc": "2026-10-19T00:56:46Z",
+    "overlap_refresh_utc": "2026-10-19T01:26:03Z",
+    "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+    "adjacent_prs": [
+      3755,
+      3154,
+      3166,
+      2962,
+      2062,
+      2798,
+      3074,
+      3191
+    ],
+    "new_delta_prs": [
+      3876,
+      3877,
+      3878
+    ],
+    "discussion_coverage": {
+      "numbers": [
+        3156,
+        1587,
+        1166,
+        1167
+      ],
+      "comments": 887,
+      "replies": 124,
+      "fully_paginated": true
+    },
+    "scope_limit": "All-state recent PR bodies and named threads; no universal novelty guarantee or public claim."
+  }
+}
diff --git a/research/e8-coupled-coordinate-floor/VERIFY.json b/research/e8-coupled-coordinate-floor/VERIFY.json
new file mode 100644
index 0000000000..6ed2304c41
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/VERIFY.json
@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "formal/lean/lean-toolchain",
+    "research/biframe-decoder-ladder/README.md",
+    "research/decoder-certificate-ceilings/README.md",
+    "research/e8-d0-root-swaps/PROOF.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Source authentication; 109 unit minors; root/parabolic and Fourier inputs; two relative-deletion algorithms; exact product/rank/normalization fixtures over Q,F3,F5,F7; actual equality-basis cuts; strict dimension DP by two implementations; semantic failure and classification-boundary controls. Lean is an explicit separate check."
+    }
+  ]
+}
diff --git a/research/e8-coupled-coordinate-floor/a9_strict_fixture.py b/research/e8-coupled-coordinate-floor/a9_strict_fixture.py
new file mode 100644
index 0000000000..ae589e36e9
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/a9_strict_fixture.py
@@ -0,0 +1,152 @@
+"""Exact strict-basis73 / COPY72 fixture, by conorholds.
+
+Apache-2.0; substantial OpenAI Codex assistance. Uses only the independently
+authored root model and exact inverse utility. The actual-basis bill73 is a characteristic-zero minimum; the displayed
+construction and its actual bill work over every odd field.
+"""
+
+from fractions import Fraction
+from pathlib import Path
+import json
+import runpy
+
+
+PARTIAL = runpy.run_path(str(Path(__file__).with_name("partial_fixture.py")),
+                        run_name="partial_fixture")
+M = PARTIAL["M"]
+Field, require = M["Field"], M["require"]
+
+
+def data(rows):
+    targets = [(1, -1, -1, -1, -1, -1, -1, 1),
+               (2, 2, 0, 0, 0, 0, 0, 0), (-2, 2, 0, 0, 0, 0, 0, 0)]
+    targets += [tuple(-2 if j == i else 2 if j == i + 1 else 0 for j in range(8))
+                for i in range(1, 6)]
+    selected = [next(i for i, row in enumerate(rows)
+                     if row == target or row == tuple(-x for x in target))
+                for target in targets]
+    v = next(i for i in range(120) if i not in selected)
+    h = [tuple(Fraction(x, 2) for x in rows[i]) for i in selected]
+    inverse, determinant = PARTIAL["inverse_and_determinant"](h)
+    require(abs(determinant) == 1, "E8 simple normals give a unit determinant")
+    dual = [tuple(inverse[j][i] for j in range(8)) for i in range(8)]
+    neighbors = [tuple(j for j in range(8) if i != j and M["dot"](h[i], h[j]))
+                 for i in range(8)]
+    require(all(neighbors), "no isolated simple root")
+    require(len({frozenset((i,) + neighbors[i]) for i in range(8)}) == 8,
+            "distinct closed neighborhoods give distinct unit-reader rays")
+    reached, pending = {0}, [0]
+    while pending:
+        for j in neighbors[pending.pop()]:
+            if j not in reached:
+                reached.add(j)
+                pending.append(j)
+    require(len(reached) == 8, "connected simple-root graph")
+    require(sum(map(len, neighbors)) == 14 and max(map(len, neighbors)) == 3,
+            "E8 tree edge and degree counts")
+    return selected, v, h, dual, neighbors, int(determinant)
+
+
+def verify_field(rows, labels, selected, v, h, dual, neighbors, field):
+    evaluate = PARTIAL["evaluate"]
+    dv = tuple(field.scalar(int(i == v)) for i in range(120))
+    units = [tuple(field.scalar(int(i == a)) for i in range(120)) for a in selected]
+    rv = tuple(Fraction(x, 2) for x in rows[v])
+    ev = evaluate(rows, rv, field)
+    code = [evaluate(rows, normal, field) for normal in h]
+    c = [M["dot"](rv, normal) for normal in h]
+    beta = [M["dot"](rv, normal) for normal in dual]
+    t = [field.combine((Fraction(1, 2), evaluate(rows, normal, field))) for normal in dual]
+    high_p = [field.combine((1, t[i]), (-beta[i] / 4, dv)) for i in range(8)]
+    unit_p = [field.combine((2, high_p[i]), *((-1, high_p[j]) for j in neighbors[i]))
+              for i in range(8)]
+    holes = [field.combine((1, code[i]), (-2, units[i]), (c[i], dv),
+                           *((1, units[j]) for j in neighbors[i])) for i in range(8)]
+    jv = field.combine((1, dv), (Fraction(-1, 2), ev))
+    q0 = field.combine((Fraction(1, 4), ev), (Fraction(-1, 2), dv))
+    alpha = [2 * beta[i] - sum(beta[j] for j in neighbors[i]) for i in range(8)]
+    expansion = field.combine((-1, dv),
+                              *((alpha[i] / 4, units[i]) for i in range(8)),
+                              *((beta[i] / 4, holes[i]) for i in range(8)))
+    require(expansion == q0, "free pivot has actual unit-v coordinate minus one")
+    left = [jv] + unit_p + high_p + [dv]
+    right = [dv] + units + holes + [q0]
+    require(M["product_equal"](left, right, rows, field), "exact strict-basis compensation product")
+    require(M["normalized"](left, right, field), "both full factor families are normalized")
+    require((field.rank(left), field.rank(right)) == (9, 17), "actual ranks nine and seventeen")
+    require(field.rank(left + code + [dv]) == 9, "actual singleton P space")
+    require(field.rank(right + code + [dv] + units) == 17, "actual full nine-coordinate Q space")
+    require(field.rank(right[:-1]) == 17, "nonpivot Q is the actual seventeen-column basis")
+    basis_weights = [M["support_weight"](vector, labels) for vector in right[:-1]]
+    require(basis_weights == [1] * 9 + [8] * 8 and sum(basis_weights) == 73,
+            "actual nonpivot basis attains the strict73 floor")
+    costs = [M["term_cost"](p, q, labels) for p, q in zip(left, right)]
+    require(costs == [0] + [1] * 8 + [8] * 8 + [0] and sum(costs) == 72,
+            "strict73 minus one rebate attains COPY72")
+    require([M["support_weight"](vector, labels) for vector in left]
+            == [8] + [9] * 16 + [1], "only the two exceptional P rays are deficient")
+    for i, a in enumerate(selected):
+        require(all(not holes[i][x] for x, label in enumerate(labels)
+                    if (label & labels[a]).bit_count() % 2), "actual allowed root-hole cut")
+        require(not c[i] or (labels[a] & labels[v]).bit_count() % 2 == 0,
+                "v correction is allowed only at a neighbor")
+    merged_p, merged_q = M["merge"](left, right, field)
+    require((len(merged_p), field.rank(merged_p), field.rank(merged_q)) == (18, 9, 17),
+            "both-side proportional merging preserves the large actual Q space")
+    require(M["product_equal"](merged_p, merged_q, rows, field), "normalized product exactness")
+    require(not M["product_equal"](left[1:], right[1:], rows, field),
+            "cannot delete the active free J atom")
+    require(not M["product_equal"](left[:-1], right[:-1], rows, field),
+            "cannot delete the active free pivot")
+    # Removing all cross shears keeps exactness but creates eight repeated
+    # P rays, which collapse the actual Q space under proportional merging.
+    plain_holes = [field.combine((1, code[i]), (-2, units[i]), (c[i], dv)) for i in range(8)]
+    plain_p = [jv] + [field.combine((2, vector)) for vector in high_p] + high_p + [dv]
+    plain_q = [dv] + units + plain_holes + [q0]
+    require(M["product_equal"](plain_p, plain_q, rows, field), "unsheared positive exact-product control")
+    require(not M["normalized"](plain_p, plain_q, field), "unsheared repeated P rays are detected")
+    plain_merged_p, plain_merged_q = M["merge"](plain_p, plain_q, field)
+    require((len(plain_merged_p), field.rank(plain_merged_p), field.rank(plain_merged_q)) == (10, 9, 9),
+            "unsheared fixture cannot retain full A9 after normalization")
+    return {"terms": 18, "actual_ranks": [9, 17], "coordinate_count": 9,
+            "actual_nonpivot_basis_weights": basis_weights, "actual_basis_bill": 73,
+            "copy_costs": costs, "copy": 72, "both_normalizations_stable": True,
+            "unsheared_after_merge": {"terms": 10, "ranks": [9, 9]},
+            "failed_product_controls": 2}
+
+
+def outside_frame(rows, excluded):
+    def visit(chosen, candidates):
+        if len(chosen) == 8:
+            return chosen
+        for j, index in enumerate(candidates):
+            future = [x for x in candidates[j + 1:] if M["dot"](rows[index], rows[x]) == 0]
+            if len(future) + len(chosen) + 1 >= 8:
+                result = visit(chosen + [index], future)
+                if result is not None:
+                    return result
+        return None
+    frame = visit([], [i for i in range(120) if i not in excluded])
+    require(frame is not None and len(frame) == 8, "orthogonal frame outside A9")
+    require(all(M["dot"](rows[i], rows[j]) == 8 * int(i == j)
+                for i in frame for j in frame), "outside frame norm-two Gram")
+    return frame
+
+
+def verify():
+    rows, labels = M["root_model"]()
+    M["check_model"](rows, labels)
+    selected, v, h, dual, neighbors, determinant = data(rows)
+    frame = outside_frame(rows, set(selected) | {v})
+    result = {"coordinate_roots": [v] + selected, "outside_orthogonal_frame": frame, "pivot_root": v,
+              "simple_normal_basis_determinant": determinant,
+              "simple_graph_adjacency": neighbors, "gram_pairing_checks": 14400,
+              "fields": {}}
+    for prime in (0, 3, 5, 7):
+        result["fields"][str(prime) if prime else "Q"] = verify_field(
+            rows, labels, selected, v, h, dual, neighbors, Field(prime))
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(verify(), indent=2, sort_keys=True))
diff --git a/research/e8-coupled-coordinate-floor/cut_basis_audit.py b/research/e8-coupled-coordinate-floor/cut_basis_audit.py
new file mode 100644
index 0000000000..0f5a367e24
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/cut_basis_audit.py
@@ -0,0 +1,219 @@
+"""Independent actual-equality-basis cut audit, prepared by conorholds.
+
+Apache-2.0; substantial OpenAI Codex assistance. Uses only the separately
+authored independent_model.py and stdlib, never the primary implementation.
+Finite examples supplement, rather than prove, the universal cut lemma.
+"""
+
+from fractions import Fraction
+from itertools import combinations
+from math import gcd, lcm
+from pathlib import Path
+import json
+import runpy
+
+
+MODEL = runpy.run_path(str(Path(__file__).with_name("independent_model.py")),
+                       run_name="independent_model")
+Field = MODEL["Field"]
+require = MODEL["require"]
+binary_rank = MODEL["binary_rank"]
+support_weight = MODEL["support_weight"]
+term_cost = MODEL["term_cost"]
+
+
+def rational_rank(vectors):
+    """Fraction-free Q elimination, clearing denominators row by row."""
+    basis = {}
+    for vector in vectors:
+        values = [Fraction(x) for x in vector]
+        denominator = lcm(*(x.denominator for x in values))
+        row = [int(x * denominator) for x in values]
+        for pivot, old in sorted(basis.items()):
+            if row[pivot]:
+                divisor = gcd(row[pivot], old[pivot])
+                left, right = old[pivot] // divisor, row[pivot] // divisor
+                row = [left * x - right * y for x, y in zip(row, old)]
+                common = gcd(*row)
+                if common:
+                    row = [x // common for x in row]
+        pivot = next((i for i, x in enumerate(row) if x), None)
+        if pivot is not None:
+            common = gcd(*row)
+            if row[pivot] < 0:
+                common = -common
+            basis[pivot] = [x // common for x in row]
+    return len(basis)
+
+
+def scalar_rank(vectors, field):
+    return field.rank(vectors) if field.prime else rational_rank(vectors)
+
+
+def root_index(rows, target):
+    opposite = tuple(-x for x in target)
+    return next(i for i, row in enumerate(rows) if row in (target, opposite))
+
+
+def geometries(rows):
+    def pair(i, j, sign=-1):
+        return tuple(2 if t == i else 2 * sign if t == j else 0 for t in range(8))
+    orthogonal = [root_index(rows, pair(i, i + 1, sign))
+                  for i in range(0, 8, 2) for sign in (-1, 1)]
+    star = [root_index(rows, pair(0, i)) for i in range(1, 8)]
+    star.append(root_index(rows, (1,) * 8))
+    simple = [root_index(rows, (1, -1, -1, -1, -1, -1, -1, 1)),
+              root_index(rows, pair(0, 1, 1)), root_index(rows, pair(0, 1))]
+    simple += [root_index(rows, pair(i, i + 1)) for i in range(1, 6)]
+    return {"orthogonal": orthogonal, "star": star, "simple": simple}
+
+
+def evaluation(rows, normal, field):
+    return tuple(field.scalar(Fraction(MODEL["dot"](row, normal), 4)) for row in rows)
+
+
+def make_basis(rows, labels, selected, variant, field):
+    """Actual coordinate units, actual holes, and actual code completions."""
+    k = len(selected)
+    normals = [rows[i] for i in selected]
+    require(scalar_rank(normals, field) == k, "independent selected root normals")
+    for row in rows:
+        if len(normals) == 8:
+            break
+        if scalar_rank(normals + [row], field) > len(normals):
+            normals.append(row)
+    require(len(normals) == 8, "scalar completion")
+    code = [evaluation(rows, normal, field) for normal in normals]
+    units = [tuple(field.scalar(int(i == a)) for i in range(120)) for a in selected]
+    holes = [field.combine((1, code[j]), (-2, units[j])) for j in range(k)]
+    completion = code[k:]
+    if variant:
+        coefficients = (Fraction(1, 2), -1, 2, -2)
+        scaled_units, sheared_holes = [], []
+        for j, (a, hole) in enumerate(zip(selected, holes)):
+            terms = [(1, hole)]
+            for b, unit in zip(selected, units):
+                if (labels[a] & labels[b]).bit_count() % 2 == 0:
+                    # Some allowed shears cancel the coordinate exactly.
+                    coefficient = -hole[b] if (a + b) % 2 == 0 else Fraction(1, 2)
+                    terms.append((coefficient, unit))
+            sheared_holes.append(field.combine((coefficients[j % 4], field.combine(*terms))))
+            scaled_units.append(field.combine((coefficients[(j + 1) % 4], units[j])))
+        completion = [field.combine(
+            (coefficients[j % 4], vector),
+            *((coefficients[(j + a) % 4], unit) for a, unit in enumerate(units)))
+            for j, vector in enumerate(completion)]
+        units, holes = scaled_units, sheared_holes
+    basis = units + holes + completion
+    weights = [support_weight(vector, labels) for vector in basis]
+    require(weights == [1] * k + [8] * k + [9] * (8 - k), "actual equality-basis weights")
+    require(sum(weights) == 72, "actual equality-basis cost")
+    require(scalar_rank(basis, field) == 8 + k, "actual equality-basis independence")
+    require(scalar_rank(basis + code + units, field) == 8 + k, "actual space C+D_A")
+    return basis, weights
+
+
+def cut_audit(basis, weights, rows, labels, characters, field):
+    checks, vanishing_checks, dimensions = 0, 0, {}
+    for v, coordinates in enumerate(characters):
+        restriction = [tuple(vector[i] for i in coordinates) for vector in basis]
+        vanishing = [j for j, vector in enumerate(restriction) if not any(vector)]
+        rank = scalar_rank(restriction, field)
+        dimension = len(basis) - rank
+        require(dimension == len(vanishing), f"actual-column cut generation at v={v}")
+        dimensions[dimension] = dimensions.get(dimension, 0) + 1
+        if vanishing:
+            hole = list(evaluation(rows, rows[v], field))
+            hole[v] = field.clean(hole[v] - field.scalar(2))
+            for j in vanishing:
+                supported_labels = [label for value, label in zip(basis[j], labels) if value]
+                require(binary_rank(supported_labels + [labels[v]]) == weights[j] + 1,
+                        "vanishing column excludes u_v from its support span")
+                require(term_cost(hole, basis[j], labels) == weights[j],
+                        "vanishing actual column has no singleton-hole rebate")
+                vanishing_checks += 1
+        checks += 1
+    return {"cuts": checks, "vanishing_membership_and_copy_checks": vanishing_checks,
+            "cut_dimension_histogram": dimensions}
+
+
+def minimum_basis_countercontrol(rows, labels, field):
+    # Four mutually nonorthogonal star roots. The scalar space here is only
+    # two-dimensional; the minimum-basis cut statement is false in general.
+    indices = [root_index(rows, tuple(2 if t == 0 else -2 if t == j else 0
+                                    for t in range(8))) for j in range(1, 5)]
+    v, a, b, c = indices
+    require(all((labels[i] & labels[j]).bit_count() % 2 == int(i == j)
+                for i in indices for j in indices), "four-star binary labels")
+    units = [tuple(field.scalar(int(i == j)) for i in range(120)) for j in indices]
+    f1 = field.combine((1, units[0]), (1, units[1]))
+    f2 = field.combine((-1, units[0]), (1, units[2]), (1, units[3]))
+    basis = [f1, f2]
+    require([support_weight(vector, labels) for vector in basis] == [2, 3], "bad-cut basis cost five")
+    # For x*f1+y*f2 the four coordinates are (x-y,x,y,y).
+    # Over Q the four support strata are y=0, x=0, x=y, and the generic
+    # x*y*(x-y)!=0 stratum. Their representatives below exhaust support costs.
+    coefficients = ([(1, t) for t in range(field.prime)] + [(0, 1)]
+                    if field.prime else [(1, 0), (0, 1), (1, 1), (1, 2)])
+    rays = [field.combine((x, f1), (y, f2)) for x, y in coefficients]
+    minimum = min(support_weight(x, labels) + support_weight(y, labels)
+                  for x, y in combinations(rays, 2) if scalar_rank([x, y], field) == 2)
+    require(minimum == 5, "genuine minimum-cost basis countercontrol")
+    coordinates = [i for i, label in enumerate(labels)
+                   if (label & labels[v]).bit_count() % 2]
+    restriction = [tuple(vector[i] for i in coordinates) for vector in basis]
+    rank = scalar_rank(restriction, field)
+    vanishing = sum(not any(vector) for vector in restriction)
+    require(rank == 1 and vanishing == 0, "countercontrol violates strong cut condition")
+    g = field.combine((1, f1), (1, f2))
+    require(any(g) and all(not g[i] for i in coordinates), "nontrivial cut-kernel vector")
+    require(g == field.combine((1, units[1]), (1, units[2]), (1, units[3])), "explicit cut-kernel identity")
+    return {"root_coordinates": indices, "minimum_basis_cost": minimum,
+            "cut_dimension": 2 - rank, "vanishing_actual_columns": vanishing,
+            "universal_minimum_basis_claim_rejected": True}
+
+
+def verify():
+    rows, labels = MODEL["root_model"]()
+    MODEL["check_model"](rows, labels)
+    geometry = geometries(rows)
+    require(all(rational_rank([rows[i] for i in selected]) == 8 for selected in geometry.values()),
+            "three independent scalar-root geometries")
+    require(MODEL["dot"](rows[geometry["orthogonal"][0]], rows[geometry["orthogonal"][1]]) == 0,
+            "orthogonal pair type")
+    require(MODEL["dot"](rows[geometry["star"][0]], rows[geometry["star"][1]]) != 0,
+            "nonorthogonal pair type")
+    characters = [tuple(i for i, label in enumerate(labels)
+                        if (normal & label).bit_count() % 2) for normal in labels]
+    require(all(len(coordinates) == 64 for coordinates in characters), "root-character sizes")
+    result = {"root_lines": 120, "gram_pairing_checks": 14400, "fields": {}}
+    for prime in (0, 3, 5, 7):
+        field = Field(prime)
+        cases = []
+        for name, selected in geometry.items():
+            if prime and name == "simple":
+                continue
+            sizes = range(1, 9) if not prime else (2,)
+            for k in sizes:
+                for variant in (0, 1):
+                    try:
+                        basis, weights = make_basis(rows, labels, selected[:k], variant, field)
+                        cut = cut_audit(basis, weights, rows, labels, characters, field)
+                    except ValueError as error:
+                        raise ValueError(f"field={prime or 'Q'}, geometry={name}, k={k}, "
+                                         f"variant={variant}: {error}") from error
+                    cases.append({"geometry": name, "k": k, "sheared": bool(variant),
+                                  "basis_dimension": len(basis), "basis_cost": sum(weights), **cut})
+        result["fields"][str(prime) if prime else "Q"] = {
+            "actual_equality_bases": cases,
+            "minimum_basis_countercontrol": minimum_basis_countercontrol(rows, labels, field)}
+    result["basis_count"] = sum(len(value["actual_equality_bases"]) for value in result["fields"].values())
+    result["root_cut_count"] = 120 * result["basis_count"]
+    result["vanishing_membership_and_copy_checks"] = sum(
+        row["vanishing_membership_and_copy_checks"]
+        for field in result["fields"].values() for row in field["actual_equality_bases"])
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(verify(), indent=2, sort_keys=True))
diff --git a/research/e8-coupled-coordinate-floor/cut_excluded_fixture.py b/research/e8-coupled-coordinate-floor/cut_excluded_fixture.py
new file mode 100644
index 0000000000..490883811a
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/cut_excluded_fixture.py
@@ -0,0 +1,128 @@
+"""Independent cut-excluded partial-quotient fixture, by conorholds.
+
+Apache-2.0; substantial OpenAI Codex assistance. Reuses only the independent
+partial fixture/model. Left normalization is stable; right normalization
+merges the repeated b reader and lowers the actual P rank to eight.
+"""
+
+from fractions import Fraction
+from pathlib import Path
+import json
+import runpy
+
+
+PARTIAL = runpy.run_path(str(Path(__file__).with_name("partial_fixture.py")),
+                        run_name="partial_fixture")
+M = PARTIAL["M"]
+Field, require = M["Field"], M["require"]
+
+
+def choose_pivot(rows, labels, selected):
+    span = [labels[i] for i in selected]
+    rank = M["binary_rank"](span)
+    for v, label in enumerate(labels):
+        pairings = [(label & labels[i]).bit_count() % 2 for i in selected]
+        if (M["binary_rank"](span + [label]) == rank + 1
+                and pairings[5:] == [0, 0] and any(pairings[:5])):
+            require(any(M["dot"](rows[v], rows[i]) == 0 for i in selected[:5]),
+                    "some J root is scalar orthogonal to the pivot")
+            return v, pairings
+    raise ValueError("no cut-excluded pivot with free b and a nonneighbor J")
+
+
+def verify_field(rows, labels, selected, v, h, dual, field):
+    evaluate = PARTIAL["evaluate"]
+    units = [tuple(field.scalar(int(i == a)) for i in range(120)) for a in selected]
+    pivot = tuple(field.scalar(int(i == v)) for i in range(120))
+    q = field.combine(*((1, unit) for unit in units[:6]))
+    b = field.combine((1, units[5]), (1, units[6]))
+    q_minus_b = field.combine((1, q), (-1, b))
+    code_h = [evaluate(rows, normal, field) for normal in h]
+    t = [field.combine((Fraction(1, 2), evaluate(rows, normal, field))) for normal in dual]
+    high_q = [field.combine((1, code_h[j]), (-2, q_minus_b)) for j in range(5)]
+    high_q += [field.combine((1, code_h[j]), (-2, b)) for j in (5, 6)] + [code_h[7]]
+    low_q = field.combine(*((2, vector) for vector in t[:5]))
+    low_b = field.combine(*((-2, vector) for vector in t[:5]), (2, t[5]), (2, t[6]))
+    left = [low_q, field.combine((1, low_b), (-1, pivot))] + t + [pivot]
+    right = [q, b] + high_q + [b]
+    require(M["product_equal"](left, right, rows, field), "exact cut-excluded decoder product")
+    require(all(any(vector) for vector in left + right), "all factors active")
+    require(len({field.ray(vector) for vector in left}) == 11,
+            "left normalization is stable")
+    require(len({field.ray(vector) for vector in right}) == 10 and right[1] == right[10],
+            "right b readers genuinely repeat")
+    require((field.rank(left), field.rank(right)) == (9, 10), "actual ranks nine and ten")
+    require(field.rank(left + code_h + [pivot]) == 9, "actual singleton P space")
+    require(field.rank(right + code_h + [q, b]) == 10, "actual Q equals C plus D prime")
+    require(field.rank(right[:-1]) == 10, "nonpivot Q columns form an actual basis")
+    p_weights = [M["support_weight"](vector, labels) for vector in left]
+    q_weights = [M["support_weight"](vector, labels) for vector in right]
+    costs = [M["term_cost"](p, r, labels) for p, r in zip(left, right)]
+    require(p_weights == [9] * 10 + [1], "actual singleton support weights")
+    require(q_weights == [5, 2] + [8] * 7 + [9, 2], "actual partial Q support weights")
+    require(costs == [5, 2] + [8] * 7 + [9, 0] and sum(costs) == 72,
+            "cut-excluded COPY equality profile")
+    b_normal = tuple(-sum(dual[j][i] for j in range(5)) + dual[5][i] + dual[6][i]
+                     for i in range(8))
+    require(field.rank([b_normal, tuple(Fraction(x, 2) for x in rows[v])]) == 2,
+            "mixed low P normal is not the pivot root direction")
+    coordinates = [i for i, label in enumerate(labels)
+                   if (label & labels[v]).bit_count() % 2]
+    require(any(q[i] for i in coordinates) and all(not b[i] for i in coordinates),
+            "quotient is not supported entirely on pivot neighbors")
+    restricted = [tuple(vector[i] for i in coordinates) for vector in right[:-1]]
+    require(field.rank(restricted) == 9 and sum(not any(vector) for vector in restricted) == 1,
+            "actual partial-basis cut kernel is generated by b")
+    quotient = PARTIAL["quotient_audit"](q, b, units, labels, field)
+    # The right merge combines (L_b-delta_v,b) and (delta_v,b).
+    right_merged_p = [low_q, low_b] + t
+    right_merged_q = [q, b] + high_q
+    require(M["product_equal"](right_merged_p, right_merged_q, rows, field),
+            "right merge preserves exactness")
+    require((field.rank(right_merged_p), field.rank(right_merged_q)) == (8, 10),
+            "right merge really lowers the P rank")
+    require(M["normalized"](right_merged_p, right_merged_q, field),
+            "merged fixture is normalized on both sides")
+    merged_p, merged_q = M["merge"](left, right, field)
+    require((len(merged_p), field.rank(merged_p), field.rank(merged_q)) == (10, 8, 10),
+            "independent alternating normalizer agrees with the rank drop")
+    require(M["product_equal"](merged_p, merged_q, rows, field), "full merge exactness")
+    merged_costs = [M["term_cost"](p, r, labels) for p, r in zip(merged_p, merged_q)]
+    require(sorted(merged_costs) == sorted(costs[:-1]) and sum(merged_costs) == 72,
+            "merge preserves the linear bill")
+    require(not M["product_equal"](left[:-1], right[:-1], rows, field),
+            "active free pivot cannot be deleted")
+    wrong_shift = list(left)
+    wrong_shift[1] = low_b
+    require(not M["product_equal"](wrong_shift, right, rows, field),
+            "missing singleton compensation fails")
+    wrong_reader = list(right)
+    wrong_reader[-1] = q
+    require(not M["product_equal"](left, wrong_reader, rows, field),
+            "incorrect pivot reader fails")
+    return {"terms": 11, "actual_ranks": [9, 10], "costs": costs,
+            "left_normalization_stable": True, "right_normalization_stable": False,
+            "right_merged_terms": 10, "right_merged_ranks": [8, 10],
+            "right_merged_copy": 72, "partial_basis_cut_rank": 9,
+            "partial_basis_vanishing_columns": 1, "quotient": quotient,
+            "failure_controls": 3}
+
+
+def verify():
+    rows, labels = M["root_model"]()
+    M["check_model"](rows, labels)
+    selected, _, h, dual, determinant, signs = PARTIAL["selected_data"](rows, labels)
+    v, pairings = choose_pivot(rows, labels, selected)
+    result = {"root_coordinates_A": selected, "root_coordinate_v": v,
+              "doubled_pivot_root": rows[v], "pivot_pairings_against_A": pairings,
+              "scalar_rank_A": 7, "binary_rank_A": 6,
+              "binary_rank_A_plus_pivot": 7, "all_A_are_neighbors": False,
+              "gram_pairing_checks": 14400, "fields": {}}
+    for prime in (0, 3, 5, 7):
+        result["fields"][str(prime) if prime else "Q"] = verify_field(
+            rows, labels, selected, v, h, dual, Field(prime))
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(verify(), indent=2, sort_keys=True))
diff --git a/research/e8-coupled-coordinate-floor/dimension_audit.py b/research/e8-coupled-coordinate-floor/dimension_audit.py
new file mode 100644
index 0000000000..b6fee674f0
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/dimension_audit.py
@@ -0,0 +1,75 @@
+"""Private independent prefix-capacity DP; no E8 geometry is generated here.
+
+Source: PR2962 Lemma S, f6e68c9838e21b263223ae61273e381d2c0b92c7,
+research/decoder-certificate-ceilings/README.md section 3.
+The formulation below minimizes basis weight directly, rather than maximizing
+the predecessor's deficiency sum. Prepared for conorholds; local-only.
+"""
+
+from functools import lru_cache
+
+SUPPORT_CAP = (0, 1, 2, 4, 8, 12, 20, 36, 64, 120)
+ROOT_CAP = (0, 1, 3, 6, 12, 20, 36, 63)
+
+
+def minimum_relaxation_bill(dimension):
+    """Return the exact minimum over sorted positive weights in 1..9.
+
+    For every prefix of dimension-r vectors, r=0..7, its support union
+    leaves roots spanning at most r dimensions. Thus the sum of its support
+    caps must be at least 120-ROOT_CAP[r]. Larger residual ranks give no
+    additional constraint. Capping a prefix sum at 120 loses no information.
+    """
+
+    @lru_cache(None)
+    def visit(position, previous, covered):
+        if position == dimension:
+            return 0
+        answer = None
+        for weight in range(previous, 10):
+            next_covered = min(120, covered + SUPPORT_CAP[weight])
+            remaining = dimension - position - 1
+            if remaining <= 7 and next_covered < 120 - ROOT_CAP[remaining]:
+                continue
+            suffix = visit(position + 1, weight, next_covered)
+            if suffix is None:
+                continue
+            bill = weight + suffix
+            answer = bill if answer is None else min(answer, bill)
+        return answer
+
+    result = visit(0, 1, 0)
+    profile = []
+    position, previous, covered = 0, 1, 0
+    while position < dimension:
+        current = visit(position, previous, covered)
+        for weight in range(previous, 10):
+            next_covered = min(120, covered + SUPPORT_CAP[weight])
+            remaining = dimension - position - 1
+            if remaining <= 7 and next_covered < 120 - ROOT_CAP[remaining]:
+                continue
+            suffix = visit(position + 1, weight, next_covered)
+            if suffix is not None and weight + suffix == current:
+                profile.append(weight)
+                position, previous, covered = position + 1, weight, next_covered
+                break
+        else:
+            raise RuntimeError("No optimal reconstruction transition")
+    return result, tuple(profile), visit.cache_info().currsize
+
+
+def main():
+    results = {}
+    for dimension in range(23, 73):
+        bill, profile, states = minimum_relaxation_bill(dimension)
+        results[dimension] = bill
+        if dimension >= 24 and bill < 73:
+            raise AssertionError((dimension, bill, profile))
+        print(dimension, bill, profile, "states", states)
+    if results[23] != 72 or results[24] != 73:
+        raise AssertionError(results)
+    print("PASS_PRIVATE_STRICT_DIMENSION_SCREEN dimensions24..72")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/e8-coupled-coordinate-floor/factors.py b/research/e8-coupled-coordinate-floor/factors.py
new file mode 100644
index 0000000000..9f7d6671b8
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/factors.py
@@ -0,0 +1,204 @@
+"""Small exact constructions and hypothesis controls for the coupled theorem.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+This primary implementation reuses retained PR3755 geometry. independent_model.py
+constructs its roots and performs all scalar/binary calculations separately.
+"""
+
+from fractions import Fraction
+from math import lcm
+
+from vendor.pr3755 import geometry as g
+
+
+def add(*vectors):
+    return [sum(values) for values in zip(*vectors)]
+
+
+def scale(value, vector):
+    return [value * x for x in vector]
+
+
+def unit(index):
+    return [Fraction(i == index) for i in range(120)]
+
+
+def frame(roots):
+    chosen = []
+    for pair in range(4):
+        for sign in (1, -1):
+            r = [0] * 8
+            r[2 * pair], r[2 * pair + 1] = 2, 2 * sign
+            chosen.append(next(i for i, row in enumerate(roots) if g.canonical(row) == tuple(r)))
+    g.require(len(set(chosen)) == 8, "frame line identification")
+    g.require(all(g.dot(roots[i], roots[j]) == 8 * int(i == j)
+                  for i in chosen for j in chosen), "oriented orthogonal frame")
+    return chosen
+
+
+def construction(roots, k):
+    g.require(1 <= k <= 8, "coordinate-family size")
+    positions = frame(roots)
+    evaluations = [[Fraction(g.dot(row, roots[i]), 4) for row in roots] for i in positions]
+    a = positions[0]
+    R = add(evaluations[0], scale(-4, unit(a)))
+    H = add(evaluations[0], scale(-2, unit(a)))
+    P, Q = [H], [unit(a)]
+    for i in range(1, k):
+        P.append(add(scale(Fraction(1, 2), evaluations[i]), scale(Fraction(-1, 4), R)))
+        Q.append(unit(positions[i]))
+    P.append(scale(Fraction(1, 4), R))
+    Q.append(add(R, *[unit(positions[i]) for i in range(1, k)]))
+    for i in range(1, k):
+        P.append(scale(Fraction(-1, 2), evaluations[i]))
+        Q.append(add(unit(positions[i]), scale(Fraction(-1, 2), evaluations[i])))
+    for i in range(k, 8):
+        P.append(scale(Fraction(1, 4), evaluations[i]))
+        Q.append(evaluations[i])
+    P.append(unit(a))
+    Q.append(H)
+    expected = [0] + [1] * (k - 1) + [9] + [8] * (k - 1) + [9] * (8 - k) + [0]
+    return P, Q, positions[:k], expected
+
+
+def reduce_scalar(value, prime):
+    value = Fraction(value)
+    return value if prime == 0 else value.numerator * pow(value.denominator, -1, prime) % prime
+
+
+def reduce_columns(columns, prime):
+    return [[reduce_scalar(x, prime) for x in column] for column in columns]
+
+
+def scalar_rank(columns, prime):
+    if prime == 0:
+        return g.rational_rank(columns)
+    rows = [list(column) for column in columns]
+    rank = 0
+    for j in range(len(rows[0]) if rows else 0):
+        k = next((i for i in range(rank, len(rows)) if rows[i][j]), None)
+        if k is None:
+            continue
+        rows[rank], rows[k] = rows[k], rows[rank]
+        inv = pow(rows[rank][j], -1, prime)
+        rows[rank] = [x * inv % prime for x in rows[rank]]
+        for i in range(rank + 1, len(rows)):
+            c = rows[i][j]
+            if c:
+                rows[i] = [(x - c * y) % prime for x, y in zip(rows[i], rows[rank])]
+        rank += 1
+        if rank == len(rows):
+            break
+    return rank
+
+
+def normalize_left(P, Q, prime):
+    groups = {}
+    for p, q in zip(P, Q):
+        if not any(p) or not any(q):
+            continue
+        first = next(x for x in p if x)
+        reciprocal = Fraction(1, first) if prime == 0 else pow(first, -1, prime)
+        ray = tuple(reduce_scalar(x * reciprocal, prime) for x in p)
+        scaled_q = [reduce_scalar(first * x, prime) for x in q]
+        if ray in groups:
+            groups[ray] = [reduce_scalar(x + y, prime) for x, y in zip(groups[ray], scaled_q)]
+        else:
+            groups[ray] = scaled_q
+    pairs = [(list(p), q) for p, q in groups.items() if any(q)]
+    return [p for p, q in pairs], [q for p, q in pairs]
+
+
+def product_check(roots, P, Q, prime):
+    g.require(len(P) == len(Q) and all(len(x) == 120 for x in P + Q), "factor dimensions")
+    if prime == 0:
+        dp = lcm(*(x.denominator for p in P for x in p))
+        dq = lcm(*(x.denominator for q in Q for x in q))
+        pints = [[int(x * dp) for x in p] for p in P]
+        qints = [[int(x * dq) for x in q] for q in Q]
+        for i, r in enumerate(roots):
+            for j, s in enumerate(roots):
+                value = sum(p[i] * q[j] for p, q in zip(pints, qints))
+                g.require(8 * value == g.dot(r, s) * dp * dq, "exact decoder product")
+    else:
+        inv8 = pow(8, -1, prime)
+        for i, r in enumerate(roots):
+            for j, s in enumerate(roots):
+                value = sum(p[i] * q[j] for p, q in zip(P, Q)) % prime
+                g.require(value == g.dot(r, s) * inv8 % prime, "exact decoder product")
+
+
+def check_factorization(model, roots, P, Q, prime, actual_coordinates=None):
+    g.require(all(any(p) and any(q) for p, q in zip(P, Q)), "inactive factor term")
+    product_check(roots, P, Q, prime)
+    costs = [g.copy_rank(model, p, q) for p, q in zip(P, Q)]
+    ranks = [scalar_rank(P, prime), scalar_rank(Q, prime)]
+    if actual_coordinates is not None:
+        code = reduce_columns([[Fraction(row[j], 2) for row in roots] for j in range(8)], prime)
+        declared = code + reduce_columns([unit(i) for i in actual_coordinates], prime)
+        g.require(scalar_rank(declared, prime) == scalar_rank(Q + declared, prime) == ranks[1],
+                  "actual right space differs from declared full coordinate space")
+    return {"terms": len(P), "ranks": ranks, "costs": costs, "copy": sum(costs)}
+
+
+def expect_failure(function, message):
+    try:
+        function()
+    except ValueError as error:
+        g.require(message in str(error), "failure control rejected for unrelated reason")
+        return
+    raise ValueError("deliberate mathematical fault was accepted: " + message)
+
+
+def run(model, roots):
+    result = {}
+    for prime in (0, 3, 5, 7):
+        cases = []
+        for k in range(1, 9):
+            p, q, A, expected = construction(roots, k)
+            P, Q = reduce_columns(p, prime), reduce_columns(q, prime)
+            record = check_factorization(model, roots, P, Q, prime, A)
+            g.require(record["costs"] == expected and record["copy"] == 72,
+                      "coordinate-family charge profile")
+            g.require(record["ranks"] == [9, 8 + k], "coordinate-family actual ranks")
+            left, right = normalize_left(P, Q, prime)
+            swapped_q, swapped_p = normalize_left(Q, P, prime)
+            g.require(len(left) == len(swapped_q) == len(P), "equality fixture collapses under a ray merge")
+            g.require(scalar_rank(left, prime) == 9 and scalar_rank(right, prime) == 8 + k,
+                      "merged equality fixture loses actual rank")
+            record["k"] = k
+            cases.append(record)
+        p, q, A, expected = construction(roots, 2)
+        P, Q = reduce_columns(p, prime), reduce_columns(q, prime)
+        expect_failure(lambda: product_check(roots, P[:-1], Q[:-1], prime), "exact decoder product")
+        broken = [list(x) for x in Q]
+        broken[2] = reduce_columns([add(q[2], scale(-1, unit(A[1])))], prime)[0]
+        expect_failure(lambda: product_check(roots, P, broken, prime), "exact decoder product")
+        expect_failure(lambda: product_check(roots, [scale(2, x) for x in P], Q, prime),
+                       "exact decoder product")
+        p1, q1, A1, _ = construction(roots, 1)
+        P1, Q1 = reduce_columns(p1, prime), reduce_columns(q1, prime)
+        expect_failure(lambda: check_factorization(model, roots, P1, Q1, prime, A),
+                       "actual right space")
+        positions = frame(roots)
+        code = [[Fraction(g.dot(row, roots[i]), 4) for row in roots] for i in positions]
+        rawP = [scale(Fraction(1, 4), x) for x in code]
+        rawQ = list(code)
+        v = positions[0]
+        b = next(i for i, r in enumerate(roots) if i != v and g.dot(r, roots[v]))
+        free_hole_reader = add(code[0], scale(-2, unit(v)))
+        for reader in (free_hole_reader, unit(b)):
+            rawP += [unit(v), scale(-1, unit(v))]
+            rawQ += [reader, reader]
+        RP, RQ = reduce_columns(rawP, prime), reduce_columns(rawQ, prime)
+        padded = check_factorization(model, roots, RP, RQ, prime, [v, b])
+        g.require(padded["ranks"] == [9, 10] and padded["costs"] == [9] * 8 + [0] * 4,
+                  "raw-rank cancellation counterexample")
+        NP, NQ = normalize_left(RP, RQ, prime)
+        collapsed = check_factorization(model, roots, NP, NQ, prime)
+        g.require(collapsed["ranks"] == [8, 8] and collapsed["copy"] == 72,
+                  "raw-rank control did not merge back to the frame")
+        result[str(prime) if prime else "Q"] = {"coordinate_family": cases,
+            "product_fault_controls": 3, "actual_space_contract_controls": 1,
+            "raw_rank_counterexample": padded, "after_left_merge": collapsed}
+    return result
diff --git a/research/e8-coupled-coordinate-floor/finite_inputs.py b/research/e8-coupled-coordinate-floor/finite_inputs.py
new file mode 100644
index 0000000000..452cb887be
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/finite_inputs.py
@@ -0,0 +1,249 @@
+"""Exact finite inputs for the written coupled E8 theorem.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+Root geometry, parabolic bounds and Fourier argument credit PR3166/PR968;
+the dimension relaxation is the method of DreamingOfClouds / PR2962.
+The retained PR3755 geometry is used explicitly, not called independent evidence.
+"""
+
+from collections import Counter
+from fractions import Fraction
+from itertools import combinations
+
+from vendor.pr3755 import geometry as g
+
+
+SIMPLE = (
+    (1, -1, -1, -1, -1, -1, -1, 1),
+    (2, 2, 0, 0, 0, 0, 0, 0),
+    (-2, 2, 0, 0, 0, 0, 0, 0),
+    (0, -2, 2, 0, 0, 0, 0, 0),
+    (0, 0, -2, 2, 0, 0, 0, 0),
+    (0, 0, 0, -2, 2, 0, 0, 0),
+    (0, 0, 0, 0, -2, 2, 0, 0),
+    (0, 0, 0, 0, 0, -2, 2, 0),
+)
+
+
+def inverse(rows):
+    n = len(rows)
+    a = [[Fraction(x) for x in row] + [Fraction(i == j) for j in range(n)]
+         for i, row in enumerate(rows)]
+    for j in range(n):
+        k = next((k for k in range(j, n) if a[k][j]), None)
+        g.require(k is not None, "singular simple-root coordinate matrix")
+        a[j], a[k] = a[k], a[j]
+        scale = a[j][j]
+        a[j] = [x / scale for x in a[j]]
+        for k in range(n):
+            if k != j:
+                scale = a[k][j]
+                a[k] = [x - scale * y for x, y in zip(a[k], a[j])]
+    return [row[n:] for row in a]
+
+
+def parabolic_inventory(roots):
+    inv = inverse(list(zip(*SIMPLE)))
+    supports = []
+    for root in roots:
+        coefficients = [sum(x * y for x, y in zip(row, root)) for row in inv]
+        g.require(all(x.denominator == 1 for x in coefficients), "nonintegral simple coordinates")
+        g.require(all(x >= 0 for x in coefficients) or all(x <= 0 for x in coefficients),
+                  "root is not positive or negative in declared simple system")
+        supports.append(sum(1 << i for i, x in enumerate(coefficients) if x))
+    maxima = [0] * 9
+    exceptional = 0
+    proper_seven_counts = []
+    for subset in range(256):
+        indices = [i for i, support in enumerate(supports) if support & ~subset == 0]
+        rank = subset.bit_count()
+        maxima[rank] = max(maxima[rank], len(indices))
+        if rank == 7:
+            proper_seven_counts.append(len(indices))
+            if len(indices) > 42:
+                perpendicular = [r for r in roots if all(g.dot(r, roots[i]) == 0 for i in indices)]
+                g.require(len(indices) == 63 and len(perpendicular) == 1,
+                          "large proper parabolic does not have a root normal")
+                exceptional += 1
+    g.require(maxima == [0, 1, 3, 6, 12, 20, 36, 63, 120], "parabolic root capacities")
+    g.require(exceptional > 0, "missing E7/root-normal positive control")
+    return {"subsets": 256, "root_rank_caps": maxima,
+            "rank_seven_counts": sorted(proper_seven_counts), "E7_root_normal_cases": exceptional}
+
+
+def quadratic(value):
+    odd_label = value | ((1 ^ g.parity(value)) << 8)
+    weight = odd_label.bit_count()
+    return (weight * (weight - 1) // 2) % 2
+
+
+def fourier_capacities(labels):
+    # The odd affine hyperplane in F2^9 is identified with F2^8.
+    values = [quadratic(x) for x in range(256)]
+    expected = {x for x in range(512) if g.parity(x) and (x.bit_count() * (x.bit_count() - 1) // 2) % 2}
+    g.require(set(labels) == expected and sum(values) == 120, "quadric/label identification")
+    polar = [sum((values[(1 << i) ^ (1 << j)] ^ values[1 << i] ^ values[1 << j]) << j
+                 for j in range(8)) for i in range(8)]
+    g.require(g.binary_rank(polar) == 8, "degenerate eight-dimensional polar form")
+    walsh = []
+    for a in range(256):
+        value = sum(1 if values[x] == g.parity(a & x) else -1 for x in range(256))
+        # B^{-1}=B=I+J in these coordinates.
+        dual = a ^ (255 if g.parity(a) else 0)
+        g.require(value == 16 * (-1 if values[dual] else 1), "exact quadratic Fourier identity")
+        walsh.append(value)
+    caps = [0]
+    for rank in range(1, 9):
+        d = rank - 1
+        caps.append(1 if d == 0 else min(1 << d, (1 << (d - 1)) + (4 if d <= 6 else 0)))
+    g.require(caps == [0, 1, 2, 4, 8, 12, 20, 36, 64], "Fourier support cap formula")
+    # Attainment controls only: the upper bound is the written Gauss-sum lemma.
+    state = 3166
+    witnesses = []
+    for rank in range(1, 9):
+        d = rank - 1
+        found = None
+        for trial in range(20000):
+            basis = []
+            while len(basis) < d:
+                state = (1664525 * state + 1013904223) % (1 << 32)
+                value = (state >> 16) & 255
+                if g.binary_rank(basis + [value]) > len(basis):
+                    basis.append(value)
+            state = (1664525 * state + 1013904223) % (1 << 32)
+            origin = (state >> 16) & 255
+            flat = [origin]
+            for value in basis:
+                flat += [x ^ value for x in flat]
+            chosen = [x | ((1 ^ g.parity(x)) << 8) for x in flat if values[x]]
+            if len(chosen) == caps[rank]:
+                g.require(g.binary_rank(chosen) == rank, "capacity witness has wrong support rank")
+                found = {"rank": rank, "affine_origin": origin, "directions": basis,
+                         "root_labels": chosen, "count": len(chosen)}
+                break
+        g.require(found is not None, "capacity attainment control not found")
+        witnesses.append(found)
+    return {"walsh_values": dict(sorted(Counter(walsh).items())), "walsh_coefficients": 256,
+            "binary_support_caps": caps, "attainment_witnesses": witnesses}
+
+
+def root_characters(roots, labels):
+    off = [sum(1 << j for j, r in enumerate(roots) if g.dot(root, r)) for root in roots]
+    spectrum = Counter()
+    minimum = 120
+    nonself_minimum = 120
+    checks = 0
+    for z in range(1, 512):
+        mask = sum(1 << i for i, label in enumerate(labels) if g.parity(z & label))
+        spectrum[mask.bit_count()] += 1
+        for i, label in enumerate(labels):
+            count = (off[i] & mask).bit_count()
+            if z == label:
+                g.require(count == 1, "root's own character does not isolate its line")
+            else:
+                g.require(count >= 24, "root remainder character deletion bound")
+                minimum = min(minimum, count)
+                nonself_minimum = min(nonself_minimum, (off[i] & mask & ~(1 << i)).bit_count())
+            checks += 1
+    # The 9-bit model has complementary characters z and z+omega;
+    # each such pair contributes sizes56 and64. Omega alone sees all120.
+    g.require(dict(sorted(spectrum.items())) == {56: 255, 64: 255, 120: 1}, "character spectrum")
+    g.require(minimum == 24, "root remainder bound is not sharp")
+    g.require(nonself_minimum == 24, "nonself root remainder bound")
+    return {"nonzero_characters": 511, "spectrum": dict(sorted(spectrum.items())),
+            "root_character_pairs": checks, "minimum_nonmatching_root_intersection": minimum,
+            "minimum_nonmatching_nonself_root_intersection": nonself_minimum}
+
+
+def budget_feasible(n, budget, caps, root_caps):
+    """Forward dominance DP; exact in the necessary size relaxation only.
+
+    Sort basis weights increasingly. After n-8+i columns, uncovered root
+    rows lie in a scalar (8-i)-space. Their support union must therefore
+    cover at least120-root_caps[8-i] sites. This is PR2962's relaxation,
+    implemented forwards with a paid-weight budget rather than max deficit.
+    """
+    states = {(1, 0): (0, ())}
+    visited = 0
+    peak = 1
+    for placed in range(1, n + 1):
+        next_states = {}
+        i = placed - (n - 8)
+        required = 120 - root_caps[8 - i] if 1 <= i <= 8 else 0
+        for (previous, covered), (cost, path) in states.items():
+            for weight in range(previous, 10):
+                paid = cost + weight
+                if paid + (n - placed) * weight > budget:
+                    break
+                union = min(120, covered + caps[weight])
+                if union < required:
+                    continue
+                key = (weight, union)
+                old = next_states.get(key)
+                if old is None or paid < old[0]:
+                    next_states[key] = (paid, path + (weight,))
+                visited += 1
+        states = next_states
+        peak = max(peak, len(states))
+        if not states:
+            return None, visited, peak
+    best = min(states.values()) if states else None
+    return best, visited, peak
+
+
+def dimension_screen(caps, root_caps):
+    caps = list(caps) + [120]
+    positive, visited, peak = budget_feasible(23, 72, caps, root_caps)
+    g.require(positive is not None and positive[0] == 72, "dimension23 relaxed positive control")
+    too_small, _, _ = budget_feasible(23, 71, caps, root_caps)
+    g.require(too_small is None, "dimension23 relaxed minimum is not72")
+    rows = []
+    for n in range(24, 73):
+        feasible, count, maximum = budget_feasible(n, 72, caps, root_caps)
+        g.require(feasible is None, "unpaid strict dimension screen")
+        visited += count
+        peak = max(peak, maximum)
+        rows.append({"dimension": n, "basis_budget72_feasible_in_relaxation": False})
+    return {"strict_dimensions": rows, "dimension23_positive_weights": list(positive[1]),
+            "dimension23_positive_cost": positive[0], "transitions": visited,
+            "peak_frontier_states": peak, "dimension73_through120": "weight>=dimension>=73"}
+
+
+def partial_support_budget():
+    caps = (0, 1, 2, 4, 8, 12, 20, 36)
+    profiles = []
+    def visit(remaining, previous, path):
+        if remaining == 0:
+            if len(path) >= 2:
+                profiles.append(path)
+            return
+        for weight in range(previous, remaining + 1):
+            visit(remaining - weight, weight, path + (weight,))
+    for bill in range(2, 8):
+        visit(bill, 1, ())
+    maximum = max(sum(caps[w] for w in path) for path in profiles)
+    g.require(len(profiles) == 37 and maximum == 21,
+              "low-budget partial-quotient support union bound")
+    return {"partitions": len(profiles), "minimum_members": 2,
+            "maximum_bill": 7, "maximum_support_union": maximum}
+
+
+def run(certificate):
+    model = g.build_model()
+    roots = g.standard_binding(model)
+    certificate_result = g.check_certificate(model, certificate)
+    transport = g.reflection_transport(model)
+    parabolics = parabolic_inventory(roots)
+    fourier = fourier_capacities(model["labels"])
+    characters = root_characters(roots, model["labels"])
+    screen = dimension_screen(fourier["binary_support_caps"], parabolics["root_rank_caps"])
+    middle = []
+    for size in range(9, 55):
+        minimum_weight = next(w for w, cap in enumerate(fourier["binary_support_caps"]) if cap >= 57 - size)
+        floor = size + 8 * minimum_weight
+        g.require(floor >= 73, "middle coordinate-set slack")
+        middle.append({"size": size, "mixed_min_weight": minimum_weight, "basis_floor": floor})
+    return model, roots, {"unit_certificate": certificate_result, "reflection_transport": transport,
+                          "parabolics": parabolics, "fourier": fourier,
+                          "characters": characters, "dimension_screen": screen,
+                          "middle_coordinate_sets": middle, "partial_support_budget": partial_support_budget()}
diff --git a/research/e8-coupled-coordinate-floor/formal/CutCore.lean b/research/e8-coupled-coordinate-floor/formal/CutCore.lean
new file mode 100644
index 0000000000..027cfb9878
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/formal/CutCore.lean
@@ -0,0 +1,127 @@
+/-
+Copyright (c) 2026 conorholds. All rights reserved.
+Released under Apache 2.0 license as described in the repository LICENSE.
+Prepared with substantial OpenAI Codex assistance.
+-/
+import Init
+
+/-!
+# Partial core of the actual-basis cut argument
+
+This file isolates two pieces of the written coupling proof:
+
+* an actual additive evaluation map annihilating a set cannot simultaneously
+  annihilate q0, take value one at qh, and annihilate q0 + qh;
+* natural-number tariffs below the basis floor force an equality basis, zero extra
+  regular readers, a one-unit hole rebate, and a zero singleton-pivot bill.
+
+Addition preservation, zero-addition and zero/one separation are explicit
+laws of the scalar model in this Init-only file. A Mathlib linear-functional
+or submodule bridge is NOT derived here. The E8 singleton-ray classification,
+binary pairing tariffs, existence of the actual reader basis, its basis-weight
+floor, and its support-cut spanning property are also NOT derived here.
+Neither the general exact-factorization theorem nor its E8 application is
+claimed as formalized by this file.
+-/
+
+namespace CoupledCoordinateCut
+
+section LinearCut
+
+variable {K V : Type} [Zero K] [One K] [Add K] [Add V]
+
+/-- The actual evaluation-map contradiction. The map is evaluated on vectors,
+and its addition-preservation law derives the key scalar equation. A future
+linear-map instantiation must discharge these explicit scalar laws. -/
+theorem cut_contradiction (T : V → Prop) (φ : V → K)
+    (q0 qh : V)
+    (map_add : ∀ x y, φ (x + y) = φ x + φ y)
+    (zero_add : ∀ k : K, 0 + k = k)
+    (zero_ne_one : (0 : K) ≠ 1)
+    (annihilates : ∀ t, T t → φ t = 0)
+    (hole_coordinate : φ qh = 1)
+    (quotient_relation : T (q0 + qh))
+    (cut_coordinate : φ q0 = 0) : False := by
+  have hzero := annihilates (q0 + qh) quotient_relation
+  rw [map_add, cut_coordinate, hole_coordinate, zero_add] at hzero
+  exact zero_ne_one hzero.symm
+
+end LinearCut
+
+section NaturalTariffs
+
+/-- Only the critical tariff state can violate the floor. W is the actual
+selected basis weight, extra is the regular-reader surplus bound, rebate is
+the hole rebate, and pivot is the singleton bill. The tariff bound is written
+additively over Nat to avoid truncating subtraction. All links from these
+numbers to decoder supports remain written-proof obligations. -/
+theorem below_floor_forces_critical_state
+    (L W extra rebate pivot COPY : Nat)
+    (basis_floor : L ≤ W)
+    (rebate_at_most_one : rebate ≤ 1)
+    (tariff_bound : W + extra + pivot ≤ COPY + rebate)
+    (below_floor : COPY < L) :
+    W = L ∧ extra = 0 ∧ rebate = 1 ∧ pivot = 0 := by
+  have hupper : COPY + rebate < L + 1 :=
+    Nat.lt_of_lt_of_le (Nat.add_lt_add_right below_floor rebate)
+      (Nat.add_le_add_left rebate_at_most_one L)
+  have htotal : W + extra + pivot ≤ L :=
+    Nat.le_of_lt_succ (Nat.lt_of_le_of_lt tariff_bound hupper)
+  have hWle : W ≤ W + extra + pivot :=
+    Nat.le_trans (Nat.le_add_right W extra) (Nat.le_add_right (W + extra) pivot)
+  have hW : W = L := Nat.le_antisymm (Nat.le_trans hWle htotal) basis_floor
+  have hzero : extra + pivot ≤ 0 := by
+    apply Nat.le_of_add_le_add_left (a := L)
+    simpa [hW, Nat.add_assoc] using htotal
+  have hparts : extra = 0 ∧ pivot = 0 :=
+    Nat.add_eq_zero.mp (Nat.eq_zero_of_le_zero hzero)
+  have hrebate_ne : rebate ≠ 0 := by
+    intro hz
+    have hpaid : L ≤ COPY := by
+      simpa [hW, hparts.1, hparts.2, hz] using tariff_bound
+    exact Nat.not_le_of_lt below_floor hpaid
+  have hrebate : rebate = 1 :=
+    Nat.le_antisymm rebate_at_most_one (Nat.pos_of_ne_zero hrebate_ne)
+  exact ⟨hW, hparts.1, hrebate, hparts.2⟩
+
+/-- A strict one-sided basis floor pays the only possible hole rebate. No
+ equality-basis cut condition is needed in this branch. -/
+theorem strict_basis_floor_pays_rebate
+    (L W extra rebate pivot COPY : Nat)
+    (strict_basis_floor : L + 1 ≤ W)
+    (rebate_at_most_one : rebate ≤ 1)
+    (tariff_bound : W + extra + pivot ≤ COPY + rebate) : L ≤ COPY := by
+  have hWle : W ≤ W + extra + pivot :=
+    Nat.le_trans (Nat.le_add_right W extra) (Nat.le_add_right (W + extra) pivot)
+  have hupper : W ≤ COPY + 1 :=
+    Nat.le_trans (Nat.le_trans hWle tariff_bound)
+      (Nat.add_le_add_left rebate_at_most_one COPY)
+  exact Nat.le_of_add_le_add_right (Nat.le_trans strict_basis_floor hupper)
+
+/-- The tariff reduction combined with a separately supplied obstruction to
+ the critical equality state. The functional cut lemma above supplies the
+ final contradiction once the actual reader basis and its cut geometry have
+ supplied its hypotheses; that geometric bridge is not formalized here. -/
+theorem floor_of_critical_state_impossible
+    (L W extra rebate pivot COPY : Nat)
+    (basis_floor : L ≤ W)
+    (rebate_at_most_one : rebate ≤ 1)
+    (tariff_bound : W + extra + pivot ≤ COPY + rebate)
+    (critical_impossible :
+      W = L → extra = 0 → rebate = 1 → pivot = 0 → False) : L ≤ COPY := by
+  apply Nat.ge_of_not_lt
+  intro below_floor
+  have critical := below_floor_forces_critical_state
+    L W extra rebate pivot COPY basis_floor rebate_at_most_one
+    tariff_bound below_floor
+  exact critical_impossible critical.1 critical.2.1
+    critical.2.2.1 critical.2.2.2
+
+end NaturalTariffs
+
+#print axioms cut_contradiction
+#print axioms below_floor_forces_critical_state
+#print axioms strict_basis_floor_pays_rebate
+#print axioms floor_of_critical_state_impossible
+
+end CoupledCoordinateCut
diff --git a/research/e8-coupled-coordinate-floor/formal/PartialBasis.lean b/research/e8-coupled-coordinate-floor/formal/PartialBasis.lean
new file mode 100644
index 0000000000..03dd8e5993
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/formal/PartialBasis.lean
@@ -0,0 +1,52 @@
+/-
+Copyright (c) 2026 conorholds. All rights reserved.
+Released under Apache 2.0 license as described in the repository LICENSE.
+Prepared with substantial OpenAI Codex assistance.
+-/
+import Init
+
+/-!
+# Partial actual-basis equality arithmetic
+
+This Init-only file proves the natural-number consequence of the written
+actual-basis count. It does not derive the count, feasible-root rank bound,
+or missing-low implication from scalar spaces or E8 geometry.
+-/
+
+namespace CoupledPartialBasis
+
+/-- A bill-72 basis cannot omit a low direction when the scalar root rank
+is at most eight and a single missing direction leaves a positive low bill.
+All links from these numbers to an actual reader basis are explicit premises.
+-/
+theorem equality_forces_zero_missing_low
+    (d κ r W : Nat)
+    (root_rank_cap : r ≤ 8)
+    (actual_basis_count : 72 + 8 * d + κ ≤ W + r)
+    (equality_bill : W = 72)
+    (single_missing_has_low : d = 1 → 1 ≤ κ) : d = 0 := by
+  have hcancel : 8 * d + κ ≤ r := by
+    apply Nat.le_of_add_le_add_left (a := 72)
+    simpa [equality_bill, Nat.add_assoc] using actual_basis_count
+  have hsmall : 8 * d + κ ≤ 8 := Nat.le_trans hcancel root_rank_cap
+  cases d with
+  | zero => rfl
+  | succ d =>
+    cases d with
+    | zero =>
+      have hlow : 1 ≤ κ := single_missing_has_low rfl
+      have hlarge : 9 ≤ 8 + κ := Nat.add_le_add_left hlow 8
+      have hupper : 8 + κ ≤ 8 := by simpa using hsmall
+      exact False.elim ((by decide : ¬ (9 ≤ 8)) (Nat.le_trans hlarge hupper))
+    | succ d =>
+      have htwo : 2 ≤ Nat.succ (Nat.succ d) :=
+        Nat.succ_le_succ (Nat.succ_le_succ (Nat.zero_le d))
+      have hlarge : 16 ≤ 8 * Nat.succ (Nat.succ d) :=
+        Nat.mul_le_mul_left 8 htwo
+      have hupper : 8 * Nat.succ (Nat.succ d) ≤ 8 :=
+        Nat.le_trans (Nat.le_add_right _ κ) hsmall
+      exact False.elim ((by decide : ¬ (16 ≤ 8)) (Nat.le_trans hlarge hupper))
+
+#print axioms equality_forces_zero_missing_low
+
+end CoupledPartialBasis
diff --git a/research/e8-coupled-coordinate-floor/independent_model.py b/research/e8-coupled-coordinate-floor/independent_model.py
new file mode 100644
index 0000000000..17f0b21173
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/independent_model.py
@@ -0,0 +1,318 @@
+"""Independent exact E8 fixture checks, prepared by conorholds with Codex.
+
+Apache-2.0. No candidate implementation, certificate or float rank is imported.
+Root ordering/labels are the declared A8 pair-then-triple ordering of PR3755,
+head 9ab51a1a90da57a55d1ef75f20ecd4b2705b3f52. The standard-coordinate
+realization below is derived directly from an eight-root Gram star.
+"""
+
+from fractions import Fraction
+from itertools import combinations, product
+from math import lcm
+import json
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def dot(x, y):
+    require(len(x) == len(y), "dot dimensions")
+    return sum(a * b for a, b in zip(x, y))
+
+
+def binary_rank(values):
+    pivots = {}
+    for value in values:
+        require(type(value) is int and value >= 0, "binary input")
+        while value:
+            bit = value & -value
+            if bit in pivots:
+                value ^= pivots[bit]
+            else:
+                pivots[bit] = value
+                break
+    return len(pivots)
+
+
+def root_model():
+    # Star s_1,...,s_8 has Gram I+J in norm-two coordinates.
+    # If x in Q^9 has sum zero, r=sum_{i<9} x_i s_i is an isometry.
+    # For triples x=1_T-(1/3)1, sum(2s_i)/3=(5,1,...,1).
+    star = [tuple(2 * int(j in (0, i)) for j in range(8))
+            for i in range(1, 8)] + [(1,) * 8, (0,) * 8]
+    rows, labels = [], []
+    for i, j in combinations(range(9), 2):
+        rows.append(tuple(a - b for a, b in zip(star[i], star[j])))
+        labels.append(511 ^ (1 << i) ^ (1 << j))
+    for triple in combinations(range(9), 3):
+        rows.append(tuple(sum(star[i][j] for i in triple) - (5 if j == 0 else 1)
+                          for j in range(8)))
+        labels.append(sum(1 << i for i in triple))
+    return tuple(rows), tuple(labels)
+
+
+class Field:
+    def __init__(self, prime=0):
+        require(prime in (0, 3, 5, 7), "supported field")
+        self.prime = prime
+
+    def scalar(self, value):
+        q = Fraction(value)
+        return (q.numerator * pow(q.denominator, -1, self.prime) % self.prime
+                if self.prime else q)
+
+    def clean(self, value):
+        return value % self.prime if self.prime else value
+
+    def inverse(self, value):
+        return pow(value, -1, self.prime) if self.prime else 1 / value
+
+    def combine(self, *terms):
+        require(bool(terms) and len({len(v) for _, v in terms}) == 1, "vector dimensions")
+        terms = [(self.scalar(c), v) for c, v in terms]
+        return tuple(self.clean(sum(c * v[i] for c, v in terms))
+                     for i in range(len(terms[0][1])))
+
+    def rank(self, vectors):
+        basis = {}
+        for vector in vectors:
+            work = [self.scalar(x) for x in vector]
+            for pivot, old in sorted(basis.items()):
+                coefficient = work[pivot]
+                if coefficient:
+                    work = [self.clean(x - coefficient * y) for x, y in zip(work, old)]
+            pivot = next((i for i, value in enumerate(work) if value), None)
+            if pivot is not None:
+                inverse = self.inverse(work[pivot])
+                basis[pivot] = [self.clean(x * inverse) for x in work]
+        return len(basis)
+
+    def ray(self, vector):
+        pivot = next((x for x in vector if x), None)
+        if pivot is None:
+            return None
+        inverse = self.inverse(pivot)
+        return tuple(self.clean(x * inverse) for x in vector)
+
+
+def standard_inventory():
+    def positive(row):
+        return row if next(x for x in row if x) > 0 else tuple(-x for x in row)
+    roots = set()
+    for i, j in combinations(range(8), 2):
+        for sign in (-1, 1):
+            roots.add(tuple(2 if t == i else 2 * sign if t == j else 0 for t in range(8)))
+    roots.update(row for row in product((-1, 1), repeat=8)
+                 if row[0] == 1 and sum(x < 0 for x in row) % 2 == 0)
+    return {positive(row) for row in roots}
+
+
+def check_model(rows, labels):
+    require(len(set(rows)) == len(set(labels)) == 120, "model inventory")
+    positive = lambda row: row if next(x for x in row if x) > 0 else tuple(-x for x in row)
+    require({positive(row) for row in rows} == standard_inventory(), "standard E8 binding")
+    require(binary_rank(labels) == 9, "full binary label span")
+    for i, row in enumerate(rows):
+        require(dot(row, row) == 8, "norm-two root")
+        for j, other in enumerate(rows):
+            gram = dot(row, other)
+            require(gram % 4 == 0, "integral norm-two Gram")
+            beta = (labels[i] & labels[j]).bit_count() % 2
+            require(beta == (1 + gram // 4) % 2 == int(i == j or gram == 0),
+                    "dense binary pairing / Gram")
+    require(Field().rank(rows) == 8, "scalar root span")
+
+
+def support_weight(vector, labels):
+    return binary_rank(label for x, label in zip(vector, labels) if x)
+
+
+def term_cost(left, right, labels):
+    supported = [label for x, label in zip(right, labels) if x]
+    return binary_rank(sum(((label & other).bit_count() % 2) << j
+                           for j, other in enumerate(supported))
+                       for x, label in zip(left, labels) if x)
+
+
+def product_equal(left, right, rows, field):
+    require(len(left) == len(right), "term counts")
+    if field.prime:
+        denominator, target_scale = 1, field.scalar(Fraction(1, 8))
+        p, q = left, right
+    else:
+        denominator = lcm(*(Fraction(x).denominator for v in left + right for x in v))
+        p = [tuple(int(x * denominator) for x in v) for v in left]
+        q = [tuple(int(x * denominator) for x in v) for v in right]
+        target_scale = Fraction(denominator * denominator, 8)
+    return all(field.clean(sum(p[t][i] * q[t][j] for t in range(len(p))))
+               == field.clean(target_scale * dot(rows[i], rows[j]))
+               for i in range(120) for j in range(120))
+
+
+def frame_data(rows, field):
+    # Choose the usual D8 orthogonal frame, retaining the model's orientation.
+    indices = []
+    for a in range(0, 8, 2):
+        for sign in (-1, 1):
+            target = tuple(2 if j == a else 2 * sign if j == a + 1 else 0
+                           for j in range(8))
+            indices.append(next(i for i, row in enumerate(rows)
+                                if row == target or row == tuple(-x for x in target)))
+    require(all(dot(rows[i], rows[j]) == 8 * int(i == j) for i in indices for j in indices),
+            "orthogonal frame")
+    code = [tuple(field.scalar(Fraction(dot(row, rows[i]), 4)) for row in rows)
+            for i in indices]
+    units = [tuple(field.scalar(int(j == i)) for j in range(120)) for i in indices]
+    return indices, code, units
+
+
+def extension_fixture(k, code, units, field):
+    require(1 <= k <= 8, "extension size")
+    e, d, f = code, units, field
+    r = f.combine((1, e[0]), (-4, d[0]))
+    h = f.combine((1, e[0]), (-2, d[0]))
+    left = [h] + [f.combine((Fraction(1, 2), e[i]), (Fraction(-1, 4), r))
+                  for i in range(1, k)] + [f.combine((Fraction(1, 4), r))]
+    right = d[:k] + [f.combine((1, r), *((1, d[i]) for i in range(1, k)))]
+    left += [f.combine((Fraction(-1, 2), e[i])) for i in range(1, k)]
+    right += [f.combine((1, d[i]), (Fraction(-1, 2), e[i])) for i in range(1, k)]
+    left += [f.combine((Fraction(1, 4), e[i])) for i in range(k, 8)] + [d[0]]
+    right += e[k:] + [h]
+    return left, right
+
+
+def eleven_fixture(code, units, field):
+    e, d, f = code, units, field
+    left = [f.combine((1, e[0]), (-2, d[0])),
+            f.combine((Fraction(1, 2), e[1]), (Fraction(-1, 4), e[2])),
+            f.combine((Fraction(1, 4), e[0]), (-1, d[0])),
+            f.combine((Fraction(-1, 2), e[1])),
+            f.combine((Fraction(1, 4), e[2]))]
+    right = [d[0], d[1], f.combine((1, e[0]), (-4, d[0])),
+             f.combine((1, d[1]), (Fraction(-1, 2), e[1])),
+             f.combine((1, e[2]), (1, d[1]))]
+    left += [f.combine((Fraction(1, 4), x)) for x in e[3:]] + [d[0]]
+    right += e[3:] + [f.combine((1, e[0]), (-2, d[0]))]
+    return left, right
+
+
+def normalized(left, right, field):
+    return (all(any(v) for v in left + right)
+            and len({field.ray(v) for v in left}) == len(left)
+            and len({field.ray(v) for v in right}) == len(right))
+
+
+def merge(left, right, field):
+    """Independent alternating ray aggregation; nonzero zero-cost atoms stay."""
+    left, right = list(left), list(right)
+    while True:
+        previous = len(left)
+        for side in range(2):
+            groups = {}
+            for p, q in zip(left, right):
+                if not any(p) or not any(q):
+                    continue
+                key = field.ray(p)
+                scalar = next(x for x in p if x)
+                contribution = field.combine((scalar, q))
+                groups[key] = (field.combine((1, groups[key]), (1, contribution))
+                               if key in groups else contribution)
+            surviving = [(p, q) for p, q in groups.items() if any(q)]
+            if not surviving:
+                return [], []
+            left, right = [list(x) for x in zip(*surviving)]
+            left, right = right, left
+        if len(left) == previous:
+            return left, right
+
+
+def check_fixture(left, right, k, rows, labels, code, units, field):
+    require(product_equal(left, right, rows, field), "exact all-pairs product")
+    require(normalized(left, right, field), "active pairwise nonproportional factors")
+    require((field.rank(left), field.rank(right)) == (9, 8 + k), "actual ranks")
+    require(field.rank(left + code + units[:1]) == 9, "singleton containment")
+    require(field.rank(right + code + units[:k]) == 8 + k, "actual full coordinate Q")
+    costs = [term_cost(p, q, labels) for p, q in zip(left, right)]
+    require(sum(costs) == 72, "linear COPY equality")
+    require(sum(c == 0 for c in costs) == 2, "two active zero-cost atoms")
+    for p, q, cost in zip(left, right, costs):
+        require(cost <= min(support_weight(p, labels), support_weight(q, labels)),
+                "pairing rank bound")
+    merged_p, merged_q = merge(left, right, field)
+    require(len(merged_p) == len(left) and product_equal(merged_p, merged_q, rows, field),
+            "normalizer stability")
+    return costs
+
+
+def check_controls(rows, labels, code, units, field):
+    f = field
+    left, right = eleven_fixture(code, units, f)
+    require(not product_equal(left[1:], right[1:], rows, f), "deleted nonzero free atom")
+    broken = list(left)
+    broken[1] = f.combine((Fraction(1, 2), code[1]))
+    require(not product_equal(broken, right, rows, f), "omitted shear compensation")
+    require(not product_equal([f.combine((2, p)) for p in left], right, rows, f),
+            "wrong target scaling")
+    ordinary_p = [f.combine((Fraction(1, 4), x)) for x in code]
+    ordinary_q = list(code)
+    a = next(i for i, x in enumerate(units[0]) if x)
+    b = next(i for i, row in enumerate(rows) if i != a and dot(row, rows[a]) != 0)
+    delta_b = tuple(f.scalar(int(i == b)) for i in range(120))
+    h = f.combine((1, code[0]), (-2, units[0]))
+    padded_p = ordinary_p + [units[0], f.combine((-1, units[0]))] * 2
+    padded_q = ordinary_q + [h, h, delta_b, delta_b]
+    require(product_equal(padded_p, padded_q, rows, f), "raw cancellation product")
+    require((f.rank(padded_p), f.rank(padded_q)) == (9, 10), "raw padding ranks")
+    require(f.rank(padded_q + code + [units[0], delta_b]) == 10, "raw full pair space")
+    require(all(any(v) for v in padded_p + padded_q), "padding atoms really nonzero")
+    require([term_cost(p, q, labels) for p, q in zip(padded_p, padded_q)] == [9] * 8 + [0] * 4,
+            "padding charges")
+    require(not normalized(padded_p, padded_q, f), "padding rejected by normalization")
+    mp, mq = merge(padded_p, padded_q, f)
+    require((len(mp), f.rank(mp), f.rank(mq)) == (8, 8, 8), "padding rank drop")
+    require(product_equal(mp, mq, rows, f), "padding merge exactness")
+    one_p, one_q = extension_fixture(1, code, units, f)
+    require(f.rank(one_q + code + units[:2]) == 10 and f.rank(one_q) == 9,
+            "ambient inclusion is not actual full Q")
+    require(sorted(term_cost(p, q, labels) for p, q in zip(one_p, one_q)) == [0, 0] + [9] * 8,
+            "ambient-only concave equality countercontrol")
+    zero = (f.scalar(0),) * 120
+    inactive_p = ordinary_p + [zero, zero, units[0]]
+    inactive_q = ordinary_q + [units[0], units[1], zero]
+    require(product_equal(inactive_p, inactive_q, rows, f), "inactive padding product")
+    require((f.rank(inactive_p), f.rank(inactive_q)) == (9, 10), "inactive padding raw ranks")
+    require(not normalized(inactive_p, inactive_q, f), "inactive atoms rejected")
+    return {"raw_padding_ranks": [9, 10], "merged_padding_ranks": [8, 8],
+            "raw_padding_charges": [9] * 8 + [0] * 4,
+            "ambient_only_actual_ranks": [9, 9], "failure_controls": 6}
+
+
+def verify():
+    rows, labels = root_model()
+    check_model(rows, labels)
+    result = {"root_lines": 120, "gram_pairing_checks": 14400, "fields": {}}
+    for prime in (0, 3, 5, 7):
+        f = Field(prime)
+        indices, code, units = frame_data(rows, f)
+        require(f.rank(code) == 8, "code dimension in field")
+        fixtures = []
+        for k in range(1, 9):
+            p, q = extension_fixture(k, code, units, f)
+            costs = check_fixture(p, q, k, rows, labels, code, units, f)
+            expected = [0, 0] + [1] * (k - 1) + [8] * (k - 1) + [9] * (9 - k)
+            require(sorted(costs) == sorted(expected), "k-family exact charge profile")
+            fixtures.append({"k": k, "terms": len(p), "ranks": [9, 8 + k], "costs": costs})
+        p, q = eleven_fixture(code, units, f)
+        sharp = check_fixture(p, q, 2, rows, labels, code, units, f)
+        require(sorted(sharp) == [0, 0, 1, 8] + [9] * 7, "sharp concave profile")
+        result["fields"][str(prime) if prime else "Q"] = {
+            "frame_coordinates": indices, "extension_family": fixtures,
+            "eleven_term_sharp_costs": sharp,
+            "controls": check_controls(rows, labels, code, units, f)}
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(verify(), indent=2, sort_keys=True))
diff --git a/research/e8-coupled-coordinate-floor/neighbor_audit.py b/research/e8-coupled-coordinate-floor/neighbor_audit.py
new file mode 100644
index 0000000000..ce55d056ed
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/neighbor_audit.py
@@ -0,0 +1,470 @@
+"""Exact small-stratum neighbor deletion threshold.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+Imports only the separately written independent E8 model.
+No predecessor executable, float arithmetic, external solver, or file write.
+Run standalone or through the sequential source-bound package replay.
+"""
+
+from collections import Counter
+from fractions import Fraction
+from functools import reduce
+from math import gcd, lcm
+import json
+
+from independent_model import root_model, check_model, dot, require, binary_rank
+
+
+# Exact doubled simple roots from PR3166 verify.py at the pinned source head
+# 7c2a62363ad4945e8803fedea6ead78e1ad412b2. The inventory/base property is
+# independently checked below; no predecessor executable is imported.
+SIMPLE = (
+    (1, -1, -1, -1, -1, -1, -1, 1),
+    (2, 2, 0, 0, 0, 0, 0, 0),
+    (-2, 2, 0, 0, 0, 0, 0, 0),
+    (0, -2, 2, 0, 0, 0, 0, 0),
+    (0, 0, -2, 2, 0, 0, 0, 0),
+    (0, 0, 0, -2, 2, 0, 0, 0),
+    (0, 0, 0, 0, -2, 2, 0, 0),
+    (0, 0, 0, 0, 0, -2, 2, 0),
+)
+
+
+def primitive(vector):
+    """Canonical integer representative of a nonzero rational ray."""
+    vector = tuple(Fraction(x) for x in vector)
+    require(any(vector), "zero ray")
+    scale = lcm(*(x.denominator for x in vector))
+    integers = tuple(int(x * scale) for x in vector)
+    divisor = reduce(gcd, (abs(x) for x in integers))
+    sign = 1 if next(x for x in integers if x) > 0 else -1
+    return tuple(sign * x // divisor for x in integers)
+
+
+def nullspace(rows, width=8):
+    """Exact echelon elimination plus back-substitution over Q."""
+    echelon = {}
+    for original in rows:
+        work = [Fraction(x) for x in original]
+        for pivot, old in sorted(echelon.items()):
+            coefficient = work[pivot]
+            if coefficient:
+                work = [x - coefficient * y for x, y in zip(work, old)]
+        pivot = next((i for i, x in enumerate(work) if x), None)
+        if pivot is not None:
+            factor = work[pivot]
+            echelon[pivot] = tuple(x / factor for x in work)
+    result = []
+    for free in range(width):
+        if free in echelon:
+            continue
+        vector = [Fraction(0)] * width
+        vector[free] = Fraction(1)
+        for pivot, row in sorted(echelon.items(), reverse=True):
+            vector[pivot] = -sum(row[j] * vector[j]
+                                 for j in range(pivot + 1, width))
+        integer = primitive(vector)
+        require(all(dot(row, integer) == 0 for row in rows), "kernel witness")
+        result.append(integer)
+    require(len(result) + len(echelon) == width, "kernel rank-nullity")
+    return tuple(result)
+
+
+def combine(left, right, s, t):
+    return primitive(tuple(s * x + t * y for x, y in zip(left, right)))
+
+
+def parabolic_neighbor_certificate(rows, labels):
+    """All proper standard parabolics versus all 120 neighbor stars.
+
+    Every rational hyperplane root intersection is Weyl-conjugate to one
+    of these parabolics. Exclude exactly the rank-seven E7 intersections,
+    since their scalar perpendicular is a root ray. All remaining proper
+    parabolics can occur as the exact zero set of a nonroot normal.
+    """
+    root_rays = {primitive(row): index for index, row in enumerate(rows)}
+    require(not nullspace(SIMPLE), "simple roots form a scalar basis")
+    require(all(primitive(row) in root_rays for row in SIMPLE), "simple root inventory")
+    require(all(dot(row, row) == 8 for row in SIMPLE), "simple root norms")
+    require(all(dot(a, b) in (0, -4) for i, a in enumerate(SIMPLE)
+                for j, b in enumerate(SIMPLE) if i != j), "simple Cartan off-diagonal")
+    dual_normals = []
+    for omitted in range(8):
+        kernel = nullspace([row for i, row in enumerate(SIMPLE) if i != omitted])
+        require(len(kernel) == 1 and dot(SIMPLE[omitted], kernel[0]) != 0,
+                "simple dual coordinate")
+        dual_normals.append(kernel[0])
+    coordinates = []
+    for row in rows:
+        coordinate = tuple(Fraction(dot(row, normal), dot(simple, normal))
+                           for simple, normal in zip(SIMPLE, dual_normals))
+        require(all(value.denominator == 1 for value in coordinate),
+                "root has integral simple coordinates")
+        require(all(value >= 0 for value in coordinate)
+                or all(value <= 0 for value in coordinate), "simple positive-root base")
+        require(all(sum(coordinate[i] * SIMPLE[i][j] for i in range(8)) == row[j]
+                    for j in range(8)), "simple-coordinate reconstruction")
+        coordinates.append(coordinate)
+    neighbor_masks = [sum(1 << j for j, other in enumerate(rows)
+                          if i != j and dot(row, other) != 0)
+                      for i, row in enumerate(rows)]
+    require(all(mask.bit_count() == 56 for mask in neighbor_masks), "all neighbor stars")
+    reports = []
+    excluded_e7 = []
+    maximum = -1
+    attaining = None
+    size_histogram = Counter()
+    for subset in range(255):
+        selected_simple = [row for i, row in enumerate(SIMPLE) if subset >> i & 1]
+        kernel = nullspace(selected_simple)
+        rank = subset.bit_count()
+        require(len(kernel) == 8 - rank, "parabolic scalar rank")
+        selected = [i for i, row in enumerate(rows)
+                    if all(dot(row, normal) == 0 for normal in kernel)]
+        require(selected == [i for i, coordinate in enumerate(coordinates)
+                             if all(not value or subset >> j & 1
+                                    for j, value in enumerate(coordinate))],
+                "independent parabolic membership formulations")
+        root_normal = (root_rays.get(primitive(kernel[0])) if rank == 7 else None)
+        if rank == 7 and len(selected) == 63:
+            require(root_normal is not None, "E7 perpendicular is a root line")
+            excluded_e7.append({"subset": subset, "normal_root": root_normal})
+            continue
+        require(root_normal is None, "unexpected root-normal proper parabolic")
+        size_histogram[(rank, len(selected))] += 1
+        mask = sum(1 << i for i in selected)
+        intersections = [(mask & neighbors).bit_count() for neighbors in neighbor_masks]
+        largest = max(intersections)
+        arg_root = intersections.index(largest)
+        reports.append({"subset": subset, "rank": rank, "root_lines": len(selected),
+                        "maximum_neighbor_intersection": largest,
+                        "arg_root": arg_root})
+        if largest > maximum:
+            maximum = largest
+            attaining = (subset, arg_root, kernel, selected)
+    require(len(reports) + len(excluded_e7) == 255, "all proper parabolics")
+    require(excluded_e7, "rank-seven root-normal parabolic present")
+    subset, arg_root, kernel, selected = attaining
+    selected_set = set(selected)
+    dimension = len(kernel)
+    # A generic moment-curve normal avoids every root outside the subsystem:
+    # each such row is a nonzero polynomial in t of degree <=dimension-1.
+    # Thus at most (120-|selected|)*(dimension-1) rational t are forbidden.
+    normal = None
+    trial_bound = (120 - len(selected)) * (dimension - 1) + 1
+    for t in range(trial_bound):
+        candidate = primitive(tuple(sum((t ** i) * basis[j]
+                                        for i, basis in enumerate(kernel))
+                                    for j in range(8)))
+        zero_roots = {i for i, row in enumerate(rows) if dot(row, candidate) == 0}
+        if zero_roots == selected_set:
+            normal = candidate
+            break
+    require(normal is not None and normal not in root_rays, "generic nonroot parabolic witness")
+    deletion = [i for i, row in enumerate(rows)
+                if neighbor_masks[arg_root] >> i & 1 and dot(row, normal)]
+    require(len(deletion) == 56 - maximum, "attained complement-character distance")
+    return {"proper_parabolics": 255, "included_parabolics": len(reports),
+            "excluded_E7": excluded_e7, "all_root_positions": 120,
+            "maximum_nonroot_zero_neighbor_intersection": maximum,
+            "minimum_nonroot_neighbor_support": 56 - maximum,
+            "attaining_witness": {"subset": subset, "fixed_root": arg_root,
+                                   "normal": normal, "deletion_roots": deletion,
+                                   "character": 511 ^ labels[arg_root]},
+            "parabolic_size_histogram": [
+                {"rank": rank, "root_lines": size, "multiplicity": count}
+                for (rank, size), count in sorted(size_histogram.items())],
+            "parabolic_neighbor_maxima": reports}
+
+
+def transport_certificate(rows, labels, fixed):
+    """Root-graph connectivity plus exact reflections proves all-v transport.
+
+    An edge r,w with |(r,w)|=1 is transported by reflection in r-sign*w,
+    another E8 root. Closure on all root rays is checked for each reflector
+    used by a spanning tree. Orthogonal reflections preserve integer Gram,
+    hence B_d. Since labels span a nondegenerate rank-nine pairing space,
+    each such B_d-preserving permutation induces an invertible binary
+    isometry on their span and therefore permutes all 511 characters.
+    """
+    rays = {primitive(row): i for i, row in enumerate(rows)}
+    seen, queue, edges, reflectors = {fixed}, [fixed], [], {}
+    for parent in queue:
+        for child, other in enumerate(rows):
+            gram = dot(rows[parent], other)
+            if child in seen or abs(gram) != 4:
+                continue
+            sign = 1 if gram > 0 else -1
+            alpha = tuple(x - sign * y for x, y in zip(rows[parent], other))
+            require(dot(alpha, alpha) == 8 and primitive(alpha) in rays,
+                    "connecting reflection is an E8 root")
+            alpha = rows[rays[primitive(alpha)]]
+            key = primitive(alpha)
+            if key not in reflectors:
+                permutation = []
+                for row in rows:
+                    product = dot(row, alpha)
+                    require(product % 4 == 0, "integral root reflection")
+                    reflected = tuple(x - (product // 4) * a
+                                      for x, a in zip(row, alpha))
+                    require(dot(reflected, reflected) == 8, "reflection norm")
+                    require(primitive(reflected) in rays, "root-set reflection closure")
+                    permutation.append(rays[primitive(reflected)])
+                require(len(set(permutation)) == 120, "reflection permutation")
+                reflectors[key] = permutation
+            permutation = reflectors[key]
+            require(permutation[parent] == child, "connecting reflection image")
+            # The scalar reflection is an isometry by its norm-two formula;
+            # check its label pairing with all roots at the transported edge.
+            for x in range(120):
+                before = (labels[parent] & labels[x]).bit_count() % 2
+                after = (labels[child] & labels[permutation[x]]).bit_count() % 2
+                require(before == after, "edge binary-pairing transport")
+            seen.add(child)
+            queue.append(child)
+            edges.append([parent, child, rays[key]])
+    require(len(seen) == 120 and len(edges) == 119, "root transitivity certificate")
+    return {"root_tree_edges": edges, "distinct_reflections": len(reflectors),
+            "reflection_root_image_checks": 120 * len(reflectors)}
+
+
+def classification_boundary_control(rows, labels):
+    """A 24-neighbor word refuting eligible-root-only classification there.
+
+    This is a scalar word, not an all-pairs decoder or a COPY counterexample.
+    Doubled standard rows R give E(r_v)(x)=dot(R_x,R_v)/4.
+    """
+    fixed, character = 0, 12
+    negative = (1, 2, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53)
+    positive = (8, 9, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74)
+    expected = set(negative) | set(positive)
+    require(rows[fixed] == (0, 2, -2, 0, 0, 0, 0, 0)
+            and labels[fixed] == 508, "boundary model/orientation binding")
+    oz = {i for i, label in enumerate(labels) if (label & character).bit_count() % 2}
+    deleted = {i for i in oz if dot(rows[i], rows[fixed])}
+    require(deleted == expected and len(deleted) == 24, "exact boundary deleted set")
+    require(fixed not in deleted and fixed not in oz, "root's own site is uncorrected")
+    require(all(i != fixed and dot(rows[i], rows[fixed]) != 0 for i in deleted),
+            "all boundary correction sites are nonself neighbors")
+    code = [Fraction(dot(row, rows[fixed]), 4) for row in rows]
+    require(code[fixed] == 2, "norm-two self value / doubled-row scale")
+    require(all(code[i] == 1 for i in negative)
+            and all(code[i] == -1 for i in positive), "boundary correction signs")
+    correction = [-1 if i in negative else 1 if i in positive else 0 for i in range(120)]
+    word = [value + delta for value, delta in zip(code, correction)]
+    require(all(word[i] == 0 for i in oz), "boundary character annihilates corrected word")
+    require(word[fixed] == 2 and correction[fixed] == 0,
+            "boundary word is not an eligible own-root hole")
+    weight = binary_rank(label for value, label in zip(word, labels) if value)
+    require(weight <= 8, "boundary word is binary-deficient")
+    return {"fixed_root": fixed, "character": character, "negative_correction_indices": negative,
+            "positive_correction_indices": positive, "deletion_count": 24,
+            "own_root_value": 2, "own_root_correction": 0, "binary_weight": weight,
+            "scope": "eligible-root classification boundary; not an exact decoder"}
+
+
+def calculate(fixed=0, include_details=True):
+    rows, labels = root_model()
+    check_model(rows, labels)
+    require(0 <= fixed < 120, "fixed root index")
+    root_rays = {primitive(row): index for index, row in enumerate(rows)}
+    ov = [i for i, label in enumerate(labels)
+          if (label & labels[fixed]).bit_count() % 2]
+    hv = set(range(120)) - set(ov)
+    require(len(ov) == 64 and len(hv) == 56, "root character support/remainder")
+    kernel_histogram = Counter()
+    critical_histogram = Counter()
+    generic_histogram = Counter()
+    nonroot_minimum = None
+    minimum_witnesses = []
+    root_mismatch_minimum = None
+    root_match_cases = 0
+    characters = []
+    complement_character = 511 ^ labels[fixed]
+    complement_report = None
+
+    def record_nonroot(count, witness):
+        nonlocal nonroot_minimum, minimum_witnesses
+        if nonroot_minimum is None or count < nonroot_minimum:
+            nonroot_minimum, minimum_witnesses = count, [witness]
+        elif count == nonroot_minimum:
+            minimum_witnesses.append(witness)
+
+    for z in range(1, 512):
+        oz = [i for i, label in enumerate(labels) if (label & z).bit_count() % 2]
+        forced = [i for i in ov if (labels[i] & z).bit_count() % 2]
+        basis = nullspace([rows[i] for i in forced])
+        dimension = len(basis)
+        kernel_histogram[dimension] += 1
+        report = {"character": z, "forced_zero_roots": len(forced),
+                  "kernel_dimension": dimension, "kernel_basis": basis,
+                  "critical_rays": []}
+        if dimension > 2:
+            require(dimension == 8 and z == complement_character
+                    and not forced and set(oz) == hv,
+                    "unclassified large kernel is not the verified complement character")
+            require(complement_report is None, "multiple complement-character kernels")
+            certificate = parabolic_neighbor_certificate(rows, labels)
+            report["special_case"] = "complement character; all proper parabolic zero sets"
+            report["minimum_nonroot_deletions"] = certificate["minimum_nonroot_neighbor_support"]
+            report["parabolic_certificate"] = certificate
+            complement_report = report
+            witness = dict(certificate["attaining_witness"])
+            witness["stratum"] = "complement_parabolic_all_root_positions"
+            record_nonroot(certificate["minimum_nonroot_neighbor_support"], witness)
+            characters.append(report)
+            continue
+        if not dimension:
+            characters.append(report)
+            continue
+
+        if dimension == 1:
+            critical_normals = [primitive(basis[0])]
+            generic = None
+        else:
+            forms = [(dot(rows[i], basis[0]), dot(rows[i], basis[1])) for i in oz]
+            distinct_forms = {primitive(form) for form in forms if any(form)}
+            critical_normals = sorted({combine(basis[0], basis[1], form[1], -form[0])
+                                       for form in distinct_forms})
+            # A generic rational nonroot ray exists off the finitely many
+            # critical and root rays. Testing (1,t) has at most one forbidden
+            # t for each critical ray and each of the 120 root rays.
+            generic = None
+            for t in range(len(distinct_forms) + len(root_rays) + 1):
+                normal = combine(basis[0], basis[1], 1, t)
+                if normal in root_rays:
+                    continue
+                if any(s + t * u == 0 for s, u in forms if s or u):
+                    continue
+                generic = normal
+                break
+            require(generic is not None, "generic nonroot rational witness")
+            generic_count = sum(any(form) for form in forms)
+            generic_actual = [i for i in oz if dot(rows[i], generic)]
+            require(len(generic_actual) == generic_count, "generic support stratum")
+            require(set(generic_actual) <= hv, "generic deletion is neighbor-supported")
+            generic_histogram[generic_count] += 1
+            report["generic"] = {"normal": generic, "deletion_count": generic_count}
+            record_nonroot(generic_count, {"character": z, "stratum": "generic",
+                                          "normal": generic,
+                                          "deletion_roots": generic_actual})
+
+        for normal in critical_normals:
+            deletion = [i for i in oz if dot(rows[i], normal)]
+            require(set(deletion) <= hv, "critical deletion is neighbor-supported")
+            root_index = root_rays.get(normal)
+            critical_histogram[(dimension, root_index is not None, len(deletion))] += 1
+            detail = {"normal": normal, "deletion_count": len(deletion),
+                      "root_line": root_index}
+            report["critical_rays"].append(detail)
+            if root_index is None:
+                record_nonroot(len(deletion), {"character": z, "stratum": "critical",
+                                              "normal": normal,
+                                              "deletion_roots": deletion})
+            elif z == labels[root_index]:
+                require(deletion == [root_index], "matching root single-hole cut")
+                require(root_index in hv, "matching root is a nonself neighbor")
+                root_match_cases += 1
+            else:
+                root_mismatch_minimum = (len(deletion) if root_mismatch_minimum is None
+                                         else min(root_mismatch_minimum, len(deletion)))
+        characters.append(report)
+
+    require(sum(kernel_histogram.values()) == 511, "all nonzero characters covered")
+    require(complement_report is not None, "verified complement character covered")
+    result = {"fixed_root": fixed, "fixed_label": labels[fixed],
+              "root_lines": 120, "characters": 511,
+              "kernel_dimension_histogram": dict(sorted(kernel_histogram.items())),
+              "critical_stratum_histogram": [
+                  {"kernel_dimension": d, "is_root": root, "deletion_count": count,
+                   "multiplicity": multiplicity}
+                  for (d, root, count), multiplicity in sorted(critical_histogram.items())],
+              "generic_nonroot_histogram": dict(sorted(generic_histogram.items())),
+              "minimum_nonroot_neighbor_deletions": nonroot_minimum,
+              "minimum_nonroot_witnesses": minimum_witnesses,
+              "minimum_critical_root_mismatch_deletions": root_mismatch_minimum,
+              "matching_root_cases": root_match_cases,
+              "root_mismatch_uniform_source_lower_bound": 24,
+              "special_complement_character": complement_character,
+              "complement_nonroot_minimum": complement_report["minimum_nonroot_deletions"],
+              "classification_boundary_control": classification_boundary_control(rows, labels),
+              "transport": transport_certificate(rows, labels, fixed)}
+    if include_details:
+        result["character_strata"] = characters
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(calculate(), indent=2, sort_keys=True))
+
+
+def low_weight_calculate():
+    """Complete full-support strata for every possible two-annihilator word."""
+    rows, labels = root_model()
+    check_model(rows, labels)
+    v = 0
+    ov = {i for i, u in enumerate(labels) if (u & labels[v]).bit_count() % 2}
+    hv = set(range(120)) - ov
+    oz = [0] + [sum((1 << i for i, u in enumerate(labels) if (u & z).bit_count() % 2)) for z in range(1, 512)]
+    complement = 511 ^ labels[v]
+    root_rays = {primitive(r): i for i, r in enumerate(rows)}
+    candidates = {}
+    kernels = Counter()
+    for z in range(1, 512):
+        if z == complement:
+            continue
+        forced = [rows[i] for i in ov if oz[z] >> i & 1]
+        basis = nullspace(forced)
+        kernels[len(basis)] += 1
+        require(len(basis) <= 2, 'only complement may have large kernel')
+        if not basis:
+            continue
+        if len(basis) == 1:
+            normals = [primitive(basis[0])]
+        else:
+            forms = [(dot(row, basis[0]), dot(row, basis[1])) for row in rows]
+            distinct = {primitive(form) for form in forms if any(form)}
+            normals = [combine(basis[0], basis[1], f[1], -f[0]) for f in distinct]
+            for t in range(len(distinct) + 121):
+                n = combine(basis[0], basis[1], 1, t)
+                if n not in root_rays and all((a + t * b for a, b in distinct)):
+                    break
+            else:
+                raise ValueError('generic witness not found')
+            normals.append(n)
+        for normal in normals:
+            off = sum((1 << i for i, r in enumerate(rows) if dot(r, normal)))
+            candidates.setdefault(off, normal)
+    minima = {'root': 121, 'nonroot': 121}
+    witnesses = {}
+    eligible = Counter()
+    planes = 0
+    for off, normal in candidates.items():
+        forced = sum((1 << i for i in ov if off >> i & 1))
+        allowed = [z for z in range(1, 512) if not forced & oz[z]]
+        kind = 'root' if normal in root_rays else 'nonroot'
+        eligible[kind, len(allowed)] += 1
+        seen = set()
+        for z in allowed:
+            for t in allowed:
+                if z >= t:
+                    continue
+                key = tuple(sorted((z, t, z ^ t)))
+                if key in seen:
+                    continue
+                seen.add(key)
+                planes += 1
+                deleted = off & (oz[z] | oz[t])
+                count = deleted.bit_count()
+                if count < minima[kind]:
+                    minima[kind] = count
+                    witnesses[kind] = {'normal': normal, 'root': root_rays.get(normal), 'characters': key, 'deleted': [i for i in range(120) if deleted >> i & 1]}
+    require(dict(kernels) == {0: 256, 1: 198, 2: 56}, 'all noncomplement character kernels covered')
+    require(len(candidates) == 169 and planes == 10963, 'complete two-annihilator support strata')
+    require(minima == {'root': 29, 'nonroot': 55}, 'sharp mixed low-weight thresholds')
+    for kind, witness in witnesses.items():
+        normal = witness['normal']
+        deleted = set(witness['deleted'])
+        support = [i for i, row in enumerate(rows) if dot(row, normal) and i not in deleted]
+        require(binary_rank((labels[i] for i in support)) == 7, 'attaining low-word support rank')
+    return {'candidates': len(candidates), 'kernels': dict(kernels), 'eligible_patterns': [{'kind': k, 'characters': n, 'patterns': m} for (k, n), m in sorted(eligible.items())], 'planes': planes, 'minima': minima, 'witnesses': witnesses}
diff --git a/research/e8-coupled-coordinate-floor/neighbor_primary.py b/research/e8-coupled-coordinate-floor/neighbor_primary.py
new file mode 100644
index 0000000000..5ee228dba9
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/neighbor_primary.py
@@ -0,0 +1,135 @@
+"""Parabolic-pattern proof certificate for the relative 27-deletion bound.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+The scalar support classification is the Weyl/parabolic argument of PR3166.
+This scan is distinct from neighbor_audit.py's fixed-root kernel strata.
+"""
+
+from collections import Counter
+from functools import reduce
+from math import gcd
+
+from finite_inputs import SIMPLE, inverse
+from vendor.pr3755 import geometry as g
+
+
+def run(roots, labels):
+    inv = inverse(list(zip(*SIMPLE)))
+    supports = []
+    for root in roots:
+        coeff = [sum(x * y for x, y in zip(row, root)) for row in inv]
+        g.require(all(x >= 0 for x in coeff) or all(x <= 0 for x in coeff),
+                  "positive simple-root pattern")
+        supports.append(sum(1 << i for i, x in enumerate(coeff) if x))
+    characters = [sum(1 << i for i, u in enumerate(labels) if g.parity(u & z))
+                  for z in range(1, 512)]
+    stars = [characters[label - 1] for label in labels]
+    g.require(all(x.bit_count() == 64 for x in stars), "root character has wrong size")
+    full = (1 << 120) - 1
+    minimum = 120
+    witness = None
+    patterns = []
+    comparisons = 0
+    accepted = 0
+    for subset in range(255):
+        zero = sum(1 << i for i, support in enumerate(supports) if support & ~subset == 0)
+        if subset.bit_count() == 7 and zero.bit_count() == 63:
+            # Precisely the rank-seven root-normal (E7) class.
+            g.require(sum(all(g.dot(root, roots[i]) == 0
+                              for i in range(120) if zero >> i & 1) for root in roots) == 1,
+                      "excluded E7 class is not a root-normal class")
+            continue
+        off = full ^ zero
+        best = 120
+        valid = 0
+        for v, ov in enumerate(stars):
+            forced = off & ov
+            for z, oz in enumerate(characters, 1):
+                comparisons += 1
+                if forced & oz:
+                    continue
+                valid += 1
+                deleted = off & oz
+                count = deleted.bit_count()
+                g.require(deleted & ov == 0, "relative deletion leaves neighbor set")
+                best = min(best, count)
+                if count < minimum:
+                    minimum = count
+                    witness = {"simple_subset": subset, "zero_root_lines": zero.bit_count(),
+                               "root": v, "character": z, "deletion_count": count,
+                               "deleted_root_indices": [i for i in range(120) if deleted >> i & 1]}
+        accepted += valid
+        patterns.append({"simple_subset": subset, "zero_root_lines": zero.bit_count(),
+                         "minimum_neighbor_deletions": best, "admissible_root_character_pairs": valid})
+    g.require(len(patterns) == 254 and minimum == 27, "relative nonroot deletion threshold")
+    g.require(witness is not None and witness["simple_subset"].bit_count() == 7,
+              "minimum needs a concrete one-dimensional normal witness")
+    rows = [SIMPLE[i] for i in range(8) if witness["simple_subset"] >> i & 1]
+    normal = [(-1) ** j * g.determinant([row[:j] + row[j + 1:] for row in rows]) for j in range(8)]
+    divisor = reduce(gcd, (abs(x) for x in normal))
+    normal = [x // divisor for x in normal]
+    if next(x for x in normal if x) < 0:
+        normal = [-x for x in normal]
+    g.require(all(sum(a * b for a, b in zip(row, normal)) == 0 for row in rows), "cofactor normal")
+    g.require(not any(g.rational_rank([root, normal]) == 1 for root in roots), "nonroot witness is a root")
+    oz = characters[witness["character"] - 1]
+    actual = [i for i, root in enumerate(roots) if oz >> i & 1 and g.dot(root, normal)]
+    g.require(actual == witness["deleted_root_indices"], "relative threshold witness support")
+    witness["normal"] = normal
+    return {"nonroot_parabolic_patterns": len(patterns), "root_character_comparisons": comparisons,
+            "admissible_pairs": accepted, "minimum_nonroot_neighbor_deletions": minimum,
+            "witness": witness, "pattern_minima": patterns}
+
+
+def low_weight_run(roots, labels):
+    """All nonroot parabolic zero patterns and all pivots for binary weight seven."""
+    inv = inverse(list(zip(*SIMPLE)))
+    supports = []
+    for root in roots:
+        coeff = [sum((x * y for x, y in zip(row, root))) for row in inv]
+        supports.append(sum((1 << i for i, x in enumerate(coeff) if x)))
+    chars = [0] + [sum((1 << i for i, u in enumerate(labels) if g.parity(u & z))) for z in range(1, 512)]
+    full = (1 << 120) - 1
+    hist = Counter()
+    minimum = 121
+    witness = None
+    patterns = 0
+    admissible = 0
+    for subset in range(255):
+        zero = sum((1 << i for i, s in enumerate(supports) if not s & ~subset))
+        if subset.bit_count() == 7 and zero.bit_count() == 63:
+            continue
+        patterns += 1
+        off = full ^ zero
+        for v, label in enumerate(labels):
+            forced = off & chars[label]
+            rank = g.binary_rank((labels[i] for i in range(120) if forced >> i & 1))
+            hist[rank] += 1
+            if rank >= 8:
+                continue
+            g.require(rank == 7, 'nonroot forced binary rank belowseven')
+            allowed = [z for z in range(1, 512) if not forced & chars[z]]
+            g.require(len(allowed) == 3 and allowed[0] ^ allowed[1] == allowed[2], 'nonroot uniqueannplane')
+            deleted = off & (chars[allowed[0]] | chars[allowed[1]])
+            count = deleted.bit_count()
+            admissible += 1
+            g.require(not deleted & chars[label], 'allrequireddeletionsinneighbors')
+            if count < minimum:
+                minimum = count
+                witness = {'subset': subset, 'v': v, 'chars': allowed, 'deleted': [i for i in range(120) if deleted >> i & 1]}
+    g.require(patterns == 254 and minimum == 55, 'nonroot neighborweightseven threshold55')
+    g.require(dict(hist) == {7: 6, 8: 30474} and admissible == 6, 'all nonroot low-weight pattern pivots')
+    rows = [SIMPLE[i] for i in range(8) if witness['subset'] >> i & 1]
+    g.require(len(rows) == 7, 'attaining nonroot zero pattern has a one-dimensional kernel')
+    normal = [(-1) ** j * g.determinant([row[:j] + row[j + 1:] for row in rows]) for j in range(8)]
+    divisor = reduce(gcd, (abs(x) for x in normal))
+    normal = [x // divisor for x in normal]
+    if next((x for x in normal if x)) < 0:
+        normal = [-x for x in normal]
+    g.require(not any((g.rational_rank([r, normal]) == 1 for r in roots)), 'nonroot low witness is a root')
+    off_normal = {i for i, r in enumerate(roots) if g.dot(r, normal)}
+    required = [i for i in off_normal if any((chars[z] >> i & 1 for z in witness['chars']))]
+    g.require(sorted(required) == witness['deleted'], 'explicit nonroot low support witness')
+    g.require(g.binary_rank((labels[i] for i in off_normal - set(required))) == 7, 'attained nonroot low weight')
+    witness['normal'] = normal
+    return {'patterns': patterns, 'ordered_pattern_pivots': patterns * 120, 'forced_rank_histogram': dict(hist), 'admissible_planes': admissible, 'minimum': minimum, 'witness': witness}
diff --git a/research/e8-coupled-coordinate-floor/partial_fixture.py b/research/e8-coupled-coordinate-floor/partial_fixture.py
new file mode 100644
index 0000000000..c47a16f182
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/partial_fixture.py
@@ -0,0 +1,178 @@
+"""Independent noncoordinate partial-quotient fixture, by conorholds.
+
+Apache-2.0; substantial OpenAI Codex assistance. This file imports only its
+separately authored sibling model and stdlib. Explicit scalar identities,
+rather than finite-field extrapolation, supply the all-odd-field construction.
+"""
+
+from fractions import Fraction
+from itertools import combinations
+from pathlib import Path
+import json
+import runpy
+
+
+M = runpy.run_path(str(Path(__file__).with_name("independent_model.py")),
+                 run_name="independent_model")
+require, Field = M["require"], M["Field"]
+
+
+def inverse_and_determinant(matrix):
+    size = len(matrix)
+    require(all(len(row) == size for row in matrix), "square scalar basis")
+    work = [[Fraction(x) for x in row] + [Fraction(i == j) for j in range(size)]
+            for i, row in enumerate(matrix)]
+    determinant = Fraction(1)
+    for j in range(size):
+        pivot = next((i for i in range(j, size) if work[i][j]), None)
+        require(pivot is not None, "invertible scalar basis")
+        if pivot != j:
+            work[j], work[pivot] = work[pivot], work[j]
+            determinant = -determinant
+        coefficient = work[j][j]
+        determinant *= coefficient
+        work[j] = [x / coefficient for x in work[j]]
+        for i in range(size):
+            if i != j and work[i][j]:
+                coefficient = work[i][j]
+                work[i] = [x - coefficient * y for x, y in zip(work[i], work[j])]
+    return [row[size:] for row in work], determinant
+
+
+def selected_data(rows, labels):
+    targets = [tuple(2 if j == 0 else -2 if j == i else 0 for j in range(8))
+               for i in range(1, 6)]
+    targets += [(0, 0, 0, 0, 0, 0, 2, -2), (2, 0, 0, 0, 0, 0, 2, 0)]
+    target_v = (2, 0, 0, 0, 0, 0, 0, 2)
+    find = lambda target: next(i for i, row in enumerate(rows)
+                               if row == target or row == tuple(-x for x in target))
+    selected, v = [find(target) for target in targets], find(target_v)
+    h = [tuple(Fraction(x, 2) for x in rows[i]) for i in selected]
+    h.append(tuple(Fraction(j == 7) for j in range(8)))
+    inverse, determinant = inverse_and_determinant(h)
+    require(abs(determinant) == 1, "unimodular scalar-normal basis")
+    dual = [tuple(inverse[j][i] for j in range(8)) for i in range(8)]
+    require(all(M["dot"](h[i], dual[j]) == int(i == j)
+                for i in range(8) for j in range(8)), "exact rational duality")
+    require(M["binary_rank"](labels[i] for i in selected) == 6, "A binary rank six")
+    require(Field().rank([rows[i] for i in selected]) == 7, "A scalar rank seven")
+    relation = 0
+    for i in selected[:5]:
+        relation ^= labels[i]
+    require(relation == labels[selected[5]], "u label is the sum of the five J labels")
+    require(M["binary_rank"]([labels[i] for i in selected[:5]]) == 5, "independent J labels")
+    require(M["binary_rank"]([labels[i] for i in selected[:5]] + [labels[selected[6]]]) == 6,
+            "w label lies outside the J span")
+    require(all((labels[v] & labels[i]).bit_count() % 2 == 0 for i in selected),
+            "all A roots are binary neighbors of the pivot")
+    require(all(M["dot"](rows[v], rows[i]) != 0 for i in selected),
+            "all A roots are scalar nonorthogonal to the pivot")
+    signs = [1 if rows[i] == target else -1 for i, target in zip(selected, targets)]
+    return selected, v, h, dual, int(determinant), signs
+
+
+def evaluate(rows, normal, field):
+    return tuple(field.scalar(sum(Fraction(row[j], 2) * normal[j] for j in range(8)))
+                 for row in rows)
+
+
+def quotient_audit(q, b, units, labels, field):
+    require(field.rank([q, b]) == 2, "two-dimensional partial quotient")
+    require(all(field.rank([q, b, unit]) == 3 for unit in units),
+            "partial quotient has no coordinate unit ray")
+    coefficients = list(range(field.prime)) if field.prime else [0, -1, 1]
+    rays = [b] + [field.combine((1, q), (t, b)) for t in coefficients]
+    require(M["support_weight"](b, labels) == 2, "b weight two")
+    for t, vector in zip(coefficients, rays[1:]):
+        require(M["support_weight"](vector, labels) == (5 if not t else 6),
+                "complete quotient weight strata")
+        require(sum(bool(x) for x in vector) >= 2, "no hidden coordinate ray")
+    # Over Q, (q+t*b) has coordinates (1,1,1,1,1,1+t,t):
+    # t=0,-1 and t outside {0,-1} exhaust support patterns. In finite fields
+    # every projective ray is enumerated, including the b ray at infinity.
+    minimum = min(M["support_weight"](x, labels) + M["support_weight"](y, labels)
+                  for x, y in combinations(rays, 2) if field.rank([x, y]) == 2)
+    require(minimum == 7, "minimum partial-quotient basis cost seven")
+    return {"dimension": 2, "minimum_basis_cost": minimum,
+            "projective_support_strata_over_Q": 4,
+            "projective_rays_checked": len(rays), "contains_coordinate_unit": False}
+
+
+def verify_field(rows, labels, selected, v, h, dual, field):
+    units = [tuple(field.scalar(int(i == a)) for i in range(120)) for a in selected]
+    pivot = tuple(field.scalar(int(i == v)) for i in range(120))
+    q = field.combine(*((1, unit) for unit in units[:6]))
+    b = field.combine((1, units[5]), (1, units[6]))
+    q_minus_b = field.combine((1, q), (-1, b))
+    q_plus_b = field.combine((1, q), (1, b))
+    code_h = [evaluate(rows, normal, field) for normal in h]
+    t = [field.combine((Fraction(1, 2), evaluate(rows, normal, field))) for normal in dual]
+    high_q = [field.combine((1, code_h[j]), (-2, q_minus_b)) for j in range(5)]
+    high_q += [field.combine((1, code_h[j]), (-2, b)) for j in (5, 6)] + [code_h[7]]
+    low_q = field.combine(*((2, vector) for vector in t[:5]))
+    low_b = field.combine(*((-2, vector) for vector in t[:5]), (2, t[5]), (2, t[6]))
+    left = [field.combine((1, low_q), (-1, pivot)),
+            field.combine((1, low_b), (-1, pivot))] + t + [pivot]
+    right = [q, b] + high_q + [q_plus_b]
+    require(M["product_equal"](left, right, rows, field), "exact noncoordinate decoder product")
+    require(M["normalized"](left, right, field), "active pairwise nonproportional factors")
+    require((field.rank(left), field.rank(right)) == (9, 10), "actual factor ranks nine and ten")
+    require(field.rank(left + code_h + [pivot]) == 9, "actual singleton P space")
+    require(field.rank(right + code_h + [q, b]) == 10, "actual Q equals C plus the partial quotient")
+    require(field.rank(code_h + [q, b]) == 10, "direct code/quotient sum")
+    require(field.rank([rows[i] for i in selected]) == 7, "selected scalar rank survives field reduction")
+    # Eligibility is tested on the actual oriented root at its own coordinate.
+    for j, a in enumerate(selected):
+        lam = q_minus_b if j < 5 else b
+        require(lam[a] == field.scalar(1), "eligibility coefficient is exactly one")
+        require(all(not high_q[j][i] for i, label in enumerate(labels)
+                    if (label & labels[a]).bit_count() % 2), "actual high column vanishes on its root cut")
+    q_normal = tuple(sum(dual[j][i] for j in range(5)) for i in range(8))
+    b_normal = tuple(-sum(dual[j][i] for j in range(5)) + dual[5][i] + dual[6][i]
+                     for i in range(8))
+    require(M["dot"](q_normal, h[7]) == M["dot"](b_normal, h[7]) == 0,
+            "low normals have zero eighth dual coordinate")
+    require(abs(M["dot"](tuple(Fraction(x, 2) for x in rows[v]), h[7])) == 1,
+            "pivot root has nonzero eighth dual coordinate")
+    p_weights = [M["support_weight"](vector, labels) for vector in left]
+    q_weights = [M["support_weight"](vector, labels) for vector in right]
+    costs = [M["term_cost"](p, r, labels) for p, r in zip(left, right)]
+    require(p_weights == [9] * 10 + [1], "actual singleton support weights")
+    require(q_weights == [5, 2] + [8] * 7 + [9, 6], "actual partial-Q support weights")
+    require(costs == [5, 2] + [8] * 7 + [9, 0] and sum(costs) == 72,
+            "noncoordinate sharp linear COPY profile")
+    merged_p, merged_q = M["merge"](left, right, field)
+    require(len(merged_p) == 11 and M["product_equal"](merged_p, merged_q, rows, field),
+            "proportional-normalization stability")
+    require(not M["product_equal"](left[:-1], right[:-1], rows, field),
+            "cannot delete the active zero-cost pivot")
+    uncompensated = list(left)
+    uncompensated[0] = low_q
+    require(not M["product_equal"](uncompensated, right, rows, field),
+            "omitting one singleton compensation fails")
+    wrong_sign = list(right)
+    wrong_sign[2] = field.combine((1, code_h[0]), (-2, q_plus_b))
+    require(not M["product_equal"](left, wrong_sign, rows, field),
+            "wrong eligible-quotient sign fails exactness")
+    return {"terms": 11, "actual_ranks": [9, 10], "costs": costs,
+            "p_support_weights": p_weights, "q_support_weights": q_weights,
+            "quotient": quotient_audit(q, b, units, labels, field),
+            "eligible_roots": 7, "failure_controls": 3}
+
+
+def verify():
+    rows, labels = M["root_model"]()
+    M["check_model"](rows, labels)
+    selected, v, h, dual, determinant, signs = selected_data(rows, labels)
+    result = {"root_coordinates_A": selected, "root_coordinate_v": v,
+              "orientation_signs_A": signs, "scalar_normal_basis_determinant": determinant,
+              "scalar_rank_A": 7, "binary_rank_A": 6, "gram_pairing_checks": 14400,
+              "fields": {}}
+    for prime in (0, 3, 5, 7):
+        result["fields"][str(prime) if prime else "Q"] = verify_field(
+            rows, labels, selected, v, h, dual, Field(prime))
+    return result
+
+
+if __name__ == "__main__":
+    print(json.dumps(verify(), indent=2, sort_keys=True))
diff --git a/research/e8-coupled-coordinate-floor/root_low_audit.py b/research/e8-coupled-coordinate-floor/root_low_audit.py
new file mode 100644
index 0000000000..c3cbc34aa2
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/root_low_audit.py
@@ -0,0 +1,29 @@
+"""Independent root-normal neighbor correction rank-seven boundary, conorholds."""
+from independent_model import root_model, check_model, dot, binary_rank, require
+from collections import Counter
+import json
+
+def run():
+ rows,labels=root_model();check_model(rows,labels)
+ v=0; ov={i for i,u in enumerate(labels) if (u&labels[v]).bit_count()%2}; hv=set(range(120))-ov
+ oz=[0]+[sum(1<<i for i,u in enumerate(labels) if (u&z).bit_count()%2) for z in range(1,512)]
+ hist=Counter();minimum=121;witness=None;planes=0
+ for a,row in enumerate(rows):
+  off=sum(1<<i for i,r in enumerate(rows) if dot(row,r))
+  forced=sum(1<<i for i in ov if off>>i&1)
+  chars=[z for z in range(1,512) if not forced&oz[z]]
+  hist[len(chars)]+=1
+  seen=set()
+  for z in chars:
+   for t in chars:
+    if z>=t: continue
+    key=tuple(sorted((z,t,z^t)))
+    if key in seen: continue
+    seen.add(key);planes+=1
+    deleted=off&(oz[z]|oz[t]);count=deleted.bit_count()
+    require(all(i in hv for i in range(120) if deleted>>i&1),'neighbor support')
+    if count<minimum:
+     minimum=count;witness={'root':a,'characters':key,'deleted':[i for i in range(120) if deleted>>i&1]}
+ require(minimum==29,'root mixed weight-seven threshold29')
+ return {'root_lines':120,'forced_character_counts':dict(hist),'planes':planes,'minimum_deletions_for_root_weight_at_most_seven':minimum,'witness':witness}
+if __name__=='__main__': print(json.dumps(run(),sort_keys=True,indent=2))
diff --git a/research/e8-coupled-coordinate-floor/root_low_primary.py b/research/e8-coupled-coordinate-floor/root_low_primary.py
new file mode 100644
index 0000000000..0fc71a0c1f
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/root_low_primary.py
@@ -0,0 +1,48 @@
+"""All-position exact root-normal rank-seven correction certificate.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+The self-root branch uses the written union-of-three-cuts argument and the
+full remainder24 input recomputed by finite_inputs. The neighbor branch
+checks its unique two-dimensional annihilator, independently of the fixed-v
+all-plane audit in root_low_audit.py.
+"""
+from collections import Counter
+from vendor.pr3755 import geometry as g
+
+def run(roots, labels):
+    cuts = [0] + [sum(1 << i for i, u in enumerate(labels) if g.parity(z & u))
+                  for z in range(1, 512)]
+    off = [sum(1 << i for i, row in enumerate(roots) if g.dot(row, root)) for root in roots]
+    hist = Counter()
+    checked = 0
+    witness = None
+    for v, label in enumerate(labels):
+        ov = cuts[label]
+        for a, root in enumerate(roots):
+            forced = off[a] & ov
+            rank = g.binary_rank(labels[i] for i in range(120) if forced >> i & 1)
+            expected = 1 if a == v else 7 if g.dot(roots[v], root) else 8
+            g.require(rank == expected, "forced outside-neighbor root rank type")
+            hist[rank] += 1
+            if expected != 7:
+                continue
+            allowed = [z for z in range(1, 512) if not cuts[z] & forced]
+            g.require(len(allowed) == 3 and allowed[0] ^ allowed[1] == allowed[2],
+                      "unique two-dimensional annihilator")
+            deleted = off[a] & (cuts[allowed[0]] | cuts[allowed[1]])
+            g.require(deleted & ov == 0 and deleted.bit_count() == 29,
+                      "neighbor root weight-seven correction threshold")
+            remaining = off[a] & ~deleted
+            g.require(g.binary_rank(labels[i] for i in range(120) if remaining >> i & 1) == 7,
+                      "attaining corrected root word has binary weight seven")
+            if witness is None:
+                witness = {"pivot": v, "root_normal": a, "characters": allowed,
+                           "deleted_indices": [i for i in range(120) if deleted >> i & 1]}
+            checked += 1
+    g.require(dict(hist) == {1: 120, 7: 6720, 8: 7560} and checked == 6720,
+              "all ordered root-pivot pairs covered")
+    return {"ordered_root_pairs": 14400, "forced_label_rank_histogram": dict(sorted(hist.items())),
+            "unique_neighbor_annihilator_planes": checked,
+            "minimum_root_weight_seven_neighbor_deletions": 29,
+            "self_root_lower_bound_from_three_cuts": 36,
+            "witness": witness}
diff --git a/research/e8-coupled-coordinate-floor/vendor/__init__.py b/research/e8-coupled-coordinate-floor/vendor/__init__.py
new file mode 100644
index 0000000000..76ac00dc23
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/__init__.py
@@ -0,0 +1 @@
+"""Retained source namespace for this package; conorholds, Apache-2.0."""
diff --git a/research/e8-coupled-coordinate-floor/vendor/pr3755/CERTIFICATE.json b/research/e8-coupled-coordinate-floor/vendor/pr3755/CERTIFICATE.json
new file mode 100644
index 0000000000..21864b382d
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/pr3755/CERTIFICATE.json
@@ -0,0 +1,117 @@
+{
+  "schema_version": 1,
+  "model": "Standard E8 roots scaled by 2; A8 label order",
+  "single_types": [
+    {"weight":1,"normal":1,"rows":[8,9,10,11,12,13,14,36],"determinant":-512},
+    {"weight":2,"normal":3,"rows":[1,2,3,4,5,6,7,43],"determinant":-256},
+    {"weight":3,"normal":7,"rows":[0,1,21,22,23,24,36,49],"determinant":512},
+    {"weight":4,"normal":15,"rows":[3,4,5,6,7,10,16,36],"determinant":-256},
+    {"weight":5,"normal":31,"rows":[0,1,2,3,30,31,32,36],"determinant":-1024},
+    {"weight":6,"normal":63,"rows":[5,6,7,12,18,23,27,36],"determinant":-256},
+    {"weight":7,"normal":127,"rows":[0,1,2,3,4,5,35,36],"determinant":-512},
+    {"weight":8,"normal":255,"rows":[7,14,20,25,29,32,34,36],"determinant":-256},
+    {"weight":9,"normal":511,"rows":[0,1,2,3,4,5,6,36],"determinant":256}
+  ],
+  "forbidden_pairs": [
+    {"counts":[0,0,2,7],"a":511,"b":508,"rows":[0,15,16,17,18,19,20,36],"determinant":1024},
+    {"counts":[0,0,4,5],"a":511,"b":496,"rows":[0,1,2,26,27,28,29,38],"determinant":512},
+    {"counts":[0,0,6,3],"a":511,"b":448,"rows":[0,1,2,3,4,33,40,119],"determinant":-512},
+    {"counts":[0,0,8,1],"a":511,"b":256,"rows":[0,1,2,3,4,5,6,42],"determinant":-512},
+    {"counts":[0,1,1,7],"a":510,"b":509,"rows":[0,85,86,87,88,89,90,100],"determinant":512},
+    {"counts":[0,1,3,5],"a":510,"b":497,"rows":[0,1,2,65,66,67,68,69],"determinant":512},
+    {"counts":[0,1,5,3],"a":510,"b":449,"rows":[0,1,2,3,4,67,68,119],"determinant":-512},
+    {"counts":[0,1,7,1],"a":510,"b":257,"rows":[0,1,2,3,4,5,6,69],"determinant":-512},
+    {"counts":[0,2,0,7],"a":508,"b":511,"rows":[0,15,16,17,18,19,20,36],"determinant":1024},
+    {"counts":[0,2,2,5],"a":508,"b":499,"rows":[0,15,26,27,28,29,38,85],"determinant":-1024},
+    {"counts":[0,2,4,3],"a":508,"b":451,"rows":[0,15,16,17,33,34,40,119],"determinant":2048},
+    {"counts":[0,2,6,1],"a":508,"b":259,"rows":[0,15,16,17,18,19,42,89],"determinant":1024},
+    {"counts":[0,3,1,5],"a":504,"b":503,"rows":[2,9,15,38,39,40,41,42],"determinant":512},
+    {"counts":[0,3,3,3],"a":504,"b":455,"rows":[2,3,4,9,15,40,41,119],"determinant":-512},
+    {"counts":[0,3,5,1],"a":504,"b":263,"rows":[2,3,4,5,6,9,15,42],"determinant":-512},
+    {"counts":[0,4,0,5],"a":496,"b":511,"rows":[0,1,2,26,27,28,29,38],"determinant":512},
+    {"counts":[0,4,2,3],"a":496,"b":463,"rows":[0,1,2,26,33,34,40,119],"determinant":1024},
+    {"counts":[0,4,4,1],"a":496,"b":271,"rows":[0,1,2,26,27,28,42,112],"determinant":1024},
+    {"counts":[0,5,1,3],"a":480,"b":479,"rows":[4,11,17,22,26,40,41,119],"determinant":-512},
+    {"counts":[0,5,3,1],"a":480,"b":287,"rows":[4,5,6,11,17,22,26,42],"determinant":-512},
+    {"counts":[0,6,0,3],"a":448,"b":511,"rows":[0,1,2,3,4,33,40,119],"determinant":-512},
+    {"counts":[0,6,2,1],"a":448,"b":319,"rows":[0,1,2,3,4,33,42,119],"determinant":1024},
+    {"counts":[0,7,1,1],"a":384,"b":383,"rows":[6,13,19,24,28,31,33,42],"determinant":-512},
+    {"counts":[0,8,0,1],"a":256,"b":511,"rows":[0,1,2,3,4,5,6,42],"determinant":-512},
+    {"counts":[1,0,1,7],"a":510,"b":508,"rows":[0,85,86,87,88,89,90,100],"determinant":512},
+    {"counts":[1,0,3,5],"a":510,"b":496,"rows":[0,1,2,65,66,67,68,69],"determinant":512},
+    {"counts":[1,0,4,4],"a":510,"b":480,"rows":[4,5,6,7,66,71,75,86],"determinant":512},
+    {"counts":[1,0,5,3],"a":510,"b":448,"rows":[0,1,2,3,4,67,68,119],"determinant":-512},
+    {"counts":[1,0,7,1],"a":510,"b":256,"rows":[0,1,2,3,4,5,6,69],"determinant":-512},
+    {"counts":[1,1,0,7],"a":508,"b":510,"rows":[0,85,86,87,88,89,90,100],"determinant":512},
+    {"counts":[1,1,2,5],"a":508,"b":498,"rows":[0,16,17,18,19,20,21,36],"determinant":1024},
+    {"counts":[1,1,4,3],"a":508,"b":450,"rows":[0,18,19,20,23,27,30,36],"determinant":1024},
+    {"counts":[1,1,6,1],"a":508,"b":258,"rows":[0,20,25,29,32,34,35,36],"determinant":1024},
+    {"counts":[1,2,1,5],"a":504,"b":502,"rows":[2,10,11,12,13,14,16,37],"determinant":1024},
+    {"counts":[1,2,2,4],"a":504,"b":486,"rows":[4,5,6,7,9,10,15,37],"determinant":-512},
+    {"counts":[1,2,3,3],"a":504,"b":454,"rows":[2,3,4,12,13,14,18,37],"determinant":512},
+    {"counts":[1,2,5,1],"a":504,"b":262,"rows":[2,3,4,5,6,14,37,69],"determinant":512},
+    {"counts":[1,2,6,0],"a":504,"b":6,"rows":[9,10,11,12,13,14,15,37],"determinant":512},
+    {"counts":[1,3,0,5],"a":496,"b":510,"rows":[0,1,2,65,66,67,68,69],"determinant":512},
+    {"counts":[1,3,2,3],"a":496,"b":462,"rows":[0,1,2,27,28,29,30,38],"determinant":512},
+    {"counts":[1,3,4,1],"a":496,"b":270,"rows":[0,1,2,29,32,34,35,38],"determinant":512},
+    {"counts":[1,4,0,4],"a":480,"b":510,"rows":[4,5,6,7,66,71,75,86],"determinant":512},
+    {"counts":[1,4,1,3],"a":480,"b":478,"rows":[4,12,13,14,18,23,27,39],"determinant":1024},
+    {"counts":[1,4,3,1],"a":480,"b":286,"rows":[4,5,6,14,20,25,29,39],"determinant":512},
+    {"counts":[1,4,4,0],"a":480,"b":30,"rows":[11,12,13,14,17,22,26,39],"determinant":512},
+    {"counts":[1,5,0,3],"a":448,"b":510,"rows":[0,1,2,3,4,67,68,119],"determinant":-512},
+    {"counts":[1,5,2,1],"a":448,"b":318,"rows":[0,1,2,3,4,34,40,119],"determinant":512},
+    {"counts":[1,6,1,1],"a":384,"b":382,"rows":[6,14,20,25,29,32,34,41],"determinant":1024},
+    {"counts":[1,6,2,0],"a":384,"b":126,"rows":[13,14,19,24,28,31,33,41],"determinant":512},
+    {"counts":[1,7,0,1],"a":256,"b":510,"rows":[0,1,2,3,4,5,6,69],"determinant":-512},
+    {"counts":[2,0,2,5],"a":508,"b":496,"rows":[0,15,26,27,28,29,38,85],"determinant":-1024},
+    {"counts":[2,0,4,3],"a":508,"b":448,"rows":[0,15,16,17,33,34,40,119],"determinant":2048},
+    {"counts":[2,0,6,1],"a":508,"b":256,"rows":[0,15,16,17,18,19,42,89],"determinant":1024},
+    {"counts":[2,1,1,5],"a":504,"b":500,"rows":[3,4,5,6,7,10,15,38],"determinant":-512},
+    {"counts":[2,1,3,3],"a":504,"b":452,"rows":[5,6,7,12,15,16,17,40],"determinant":-1024},
+    {"counts":[2,1,5,1],"a":504,"b":260,"rows":[7,14,15,16,17,18,42,43],"determinant":512},
+    {"counts":[2,2,0,5],"a":496,"b":508,"rows":[0,15,26,27,28,29,38,85],"determinant":-1024},
+    {"counts":[2,2,2,3],"a":496,"b":460,"rows":[0,15,26,33,34,40,44,87],"determinant":1024},
+    {"counts":[2,2,4,1],"a":496,"b":268,"rows":[0,15,26,27,28,42,44,89],"determinant":1024},
+    {"counts":[2,3,1,3],"a":480,"b":476,"rows":[5,6,7,12,17,22,26,40],"determinant":-1024},
+    {"counts":[2,3,3,1],"a":480,"b":284,"rows":[7,14,17,18,19,22,42,45],"determinant":-512},
+    {"counts":[2,4,0,3],"a":448,"b":508,"rows":[0,15,16,17,33,34,40,119],"determinant":2048},
+    {"counts":[2,4,2,1],"a":448,"b":316,"rows":[0,15,16,17,33,42,46,119],"determinant":-1024},
+    {"counts":[2,5,1,1],"a":384,"b":380,"rows":[7,14,19,24,28,31,42,47],"determinant":-512},
+    {"counts":[2,6,0,1],"a":256,"b":508,"rows":[0,15,16,17,18,19,42,89],"determinant":1024},
+    {"counts":[3,0,1,5],"a":504,"b":496,"rows":[2,9,15,38,39,40,41,42],"determinant":512},
+    {"counts":[3,0,3,3],"a":504,"b":448,"rows":[2,3,4,9,15,40,41,119],"determinant":-512},
+    {"counts":[3,0,4,2],"a":504,"b":384,"rows":[6,7,13,19,41,102,105,107],"determinant":512},
+    {"counts":[3,0,5,1],"a":504,"b":256,"rows":[2,3,4,5,6,9,15,42],"determinant":-512},
+    {"counts":[3,1,0,5],"a":496,"b":504,"rows":[2,9,15,38,39,40,41,42],"determinant":512},
+    {"counts":[3,1,2,3],"a":496,"b":456,"rows":[2,9,15,27,28,29,30,40],"determinant":512},
+    {"counts":[3,1,4,1],"a":496,"b":264,"rows":[2,9,15,29,32,34,35,42],"determinant":512},
+    {"counts":[3,2,1,3],"a":480,"b":472,"rows":[4,11,17,23,24,25,27,40],"determinant":512},
+    {"counts":[3,2,2,2],"a":480,"b":408,"rows":[6,7,13,19,22,23,26,41],"determinant":1024},
+    {"counts":[3,2,3,1],"a":480,"b":280,"rows":[4,5,6,11,17,25,42,103],"determinant":512},
+    {"counts":[3,3,0,3],"a":448,"b":504,"rows":[2,3,4,9,15,40,41,119],"determinant":-512},
+    {"counts":[3,3,2,1],"a":448,"b":312,"rows":[2,3,4,9,15,34,42,119],"determinant":512},
+    {"counts":[3,4,0,2],"a":384,"b":504,"rows":[6,7,13,19,41,102,105,107],"determinant":512},
+    {"counts":[3,4,1,1],"a":384,"b":376,"rows":[6,13,19,25,29,32,34,42],"determinant":512},
+    {"counts":[3,5,0,1],"a":256,"b":504,"rows":[2,3,4,5,6,9,15,42],"determinant":-512},
+    {"counts":[4,0,2,3],"a":496,"b":448,"rows":[0,1,2,26,33,34,40,119],"determinant":1024},
+    {"counts":[4,0,4,1],"a":496,"b":256,"rows":[0,1,2,26,27,28,42,112],"determinant":1024},
+    {"counts":[4,1,1,3],"a":480,"b":464,"rows":[5,6,7,12,18,23,26,40],"determinant":-512},
+    {"counts":[4,1,3,1],"a":480,"b":272,"rows":[7,14,20,25,26,27,28,42],"determinant":-1024},
+    {"counts":[4,2,0,3],"a":448,"b":496,"rows":[0,1,2,26,33,34,40,119],"determinant":1024},
+    {"counts":[4,2,2,1],"a":448,"b":304,"rows":[0,1,2,26,33,42,112,119],"determinant":2048},
+    {"counts":[4,3,1,1],"a":384,"b":368,"rows":[7,14,20,25,28,31,33,42],"determinant":-1024},
+    {"counts":[4,4,0,1],"a":256,"b":496,"rows":[0,1,2,26,27,28,42,112],"determinant":1024},
+    {"counts":[5,0,1,3],"a":480,"b":448,"rows":[4,11,17,22,26,40,41,119],"determinant":-512},
+    {"counts":[5,0,3,1],"a":480,"b":256,"rows":[4,5,6,11,17,22,26,42],"determinant":-512},
+    {"counts":[5,1,0,3],"a":448,"b":480,"rows":[4,11,17,22,26,40,41,119],"determinant":-512},
+    {"counts":[5,1,2,1],"a":448,"b":288,"rows":[4,11,17,22,26,34,42,119],"determinant":512},
+    {"counts":[5,2,1,1],"a":384,"b":352,"rows":[6,13,19,24,28,32,42,117],"determinant":512},
+    {"counts":[5,2,2,0],"a":384,"b":96,"rows":[31,32,33,59,80,95,105,111],"determinant":-512},
+    {"counts":[5,3,0,1],"a":256,"b":480,"rows":[4,5,6,11,17,22,26,42],"determinant":-512},
+    {"counts":[6,0,2,1],"a":448,"b":256,"rows":[0,1,2,3,4,33,42,119],"determinant":1024},
+    {"counts":[6,1,1,1],"a":384,"b":320,"rows":[7,14,20,25,29,32,33,42],"determinant":-512},
+    {"counts":[6,2,0,1],"a":256,"b":448,"rows":[0,1,2,3,4,33,42,119],"determinant":1024},
+    {"counts":[7,0,1,1],"a":384,"b":256,"rows":[6,13,19,24,28,31,33,42],"determinant":-512},
+    {"counts":[7,1,0,1],"a":256,"b":384,"rows":[6,13,19,24,28,31,33,42],"determinant":-512}
+  ]
+}
diff --git a/research/e8-coupled-coordinate-floor/vendor/pr3755/PROOF.md b/research/e8-coupled-coordinate-floor/vendor/pr3755/PROOF.md
new file mode 100644
index 0000000000..89c328853b
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/pr3755/PROOF.md
@@ -0,0 +1,603 @@
+# A uniform one-coset deficiency budget on full E8
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+This is a written proof with explicit finite integer certificates; its E8
+instantiation is not claimed to be a formally verified theorem.
+
+## 1. Statements and exact model
+
+Let K be any field of characteristic different from two. Let L be the 120
+root lines of E8, choose standard norm-two representatives r_v over Z[1/2],
+and evaluate them in K. Define G and N₀ over K, and define B_d from the
+integer root products before scalar reduction:
+
+```text
+G_Z[v,w] = the integer product of the standard rational roots,
+G = G_Z evaluated in K,            N₀ = G/2,
+B_d[v,w] = (1 + G_Z[v,w]) mod 2.
+```
+
+Thus B_d[v,w] is one exactly when v=w or v is orthogonal to w. The matrix
+B_d is the dense binary COPY table. Orientations of representatives do not
+change B_d. Let C ⊆ K^L be the eight-dimensional scalar root-evaluation code:
+the vectors (r_v·h)_{v∈L}, for h∈K^8. This scalar code is distinct from the
+binary label space Λ defined below.
+
+For X⊆L, write U_X for its binary label span and w(X)=dim_F₂ U_X. For p∈K^L,
+write w(p)=w(supp p) and δ(p)=9−w(p). A term p qᵀ costs
+
+```text
+ρ(supp p,supp q) = rank_F₂ B_d[supp p,supp q].
+```
+
+**Uniform deficiency theorem.** If λ∉C and (p_i) is any finite family of
+pairwise nonproportional nonzero vectors in C+Kλ, then
+
+```text
+Σ_i δ(p_i) ≤ 9.                                             (1)
+```
+
+Every nonzero vector in C has deficiency zero.
+
+**Exact-decoder consequence.** If P,Q∈K^{L×m}, m finite, satisfy
+
+```text
+PQᵀ = N₀,             rank_K P ≤ 9,       rank_K Q ≤ 9,       (2)
+```
+
+then COPY(P,Q)≥72. This floor is sharp in this class. Transposes are ordinary
+transposes, including over the complex numbers. The hypotheses concern the actual factor
+ranks, rather than the number of terms or a choice of presentation.
+The alternative convention PQᵀ=2G=4N₀ has exactly the same result: multiplying
+one factor by four changes neither supports, factor ranks nor COPY.
+
+We prove both statements directly. No catalogue, retraction, or pending
+general masked-realization theorem is a premise.
+
+Sections 2–7 first give the proof in characteristic zero, using a rational
+A8 model. Section 8 transports the finite facts to every characteristic
+different from two and replaces that scalar model by standard K^8. In
+particular the A8 divisions by three are not performed in characteristic three.
+
+## 2. A rational A8 realization and its canonical identification
+
+Until section 8 assume that K has characteristic zero.
+Write ω=(1,…,1)∈K^9 and V={x:Σ_j x_j=0}. Its dot product is nondegenerate:
+V⊥=Kω and ω·ω=9≠0. Use these oriented root representatives:
+
+```text
+r_ij = e_i−e_j                 (0≤i<j≤8),
+r_S  = 1_S−ω/3                (S⊆{0,…,8}, |S|=3).
+```
+
+There are 36+84=120 lines. All have squared norm two. Their integer rows
+R_v=3r_v have respectively entries (3,−3,0,…,0) and entries 2 on S, −1 off S.
+Pair roots already span V. Below R also denotes the 120×9 matrix of these
+integer rows. Its image is C: scaling evaluations by three does not change
+the code, and evaluation restricts to an injective map from V.
+
+Here is an explicit rational isometry to the standard E8 model. In Q^8 take
+the 56 lines e_a±e_b and the 64 half-root lines (±1,…,±1)/2 with an even
+number of minus signs. Choose the eight star roots
+
+```text
+s_j=e_0+e_j   (1≤j≤7),        s_8=(1,…,1)/2.
+```
+
+Their Gram matrix is I₈+J₈, of determinant nine. The eight vectors
+a_j=e_{j−1}−e_8 in V have the same Gram matrix. Therefore the unique rational
+linear map T with T(s_j)=a_j is an isometry. Explicitly, for a standard root x,
+put d_j=x·s_j and D=Σ_{j=1}^8 d_j. Then
+
+```text
+T(x) = (d_1−D/9,…,d_8−D/9,−D/9),
+3T(x) = (3d_1−D/3,…,3d_8−D/3,−D/3).                       (3)
+```
+
+For standard doubled roots A=2x and doubled stars S_j=2s_j,
+d_j=(A·S_j)/4. Enumerate e_a±e_b and the half-roots with first sign positive,
+apply (3), and choose the sign with first nonzero entry positive. The resulting
+120 integer rows are exactly the canonical signs of the rows R above. This
+finite equality is checked explicitly, together with the star Gram identity.
+Thus row permutations and individual row signs transport scalar evaluations,
+supports, and exact Gram factorizations between the two models.
+
+The label model is especially simple in A8 coordinates. Set Λ=F₂^9 with
+β(z,z′)=Σ_j z_j z′_j and assign
+
+```text
+u_ij = ω+e_i+e_j,              u_S = 1_S.                    (4)
+```
+
+All 120 labels are nonzero. They span Λ: differences of triples sharing two
+coordinates generate every e_i+e_j, hence the eight-dimensional even-weight
+space, and a triple adds an odd vector. Direct multiplication gives
+
+```text
+β(u_v,u_w) = (1+r_v·r_w) mod 2 = B_d[v,w].                  (5)
+```
+
+For pair/pair and pair/triple, the parity of the scalar product is the parity
+of the intersection of the indicated index sets; the extra ω contributes
+one. For triple/triple, r_S·r_T=|S∩T|−1, giving (5) as well. This includes
+the diagonal. Isometry (3) transfers the identity to canonical E8 roots.
+Because the labels span Λ and β is nondegenerate, B_d has rank nine.
+Thus (4) realizes the full canonical dense table, including all COPY ranks;
+it is not merely a label convention for a different incidence table.
+
+## 3. The three finite facts and complete profile coverage
+
+For nonzero z∈Λ define
+
+```text
+O_z = {v∈L : β(z,u_v)=1}.
+```
+
+Call distinct nonzero z,z′ **compatible** when the scalar roots indexed by
+O_z∩O_z′ have rank at most seven. For an even-weight vector set
+q(z)=wt(z)/2 mod 2. The required finite facts are:
+
+1. The roots indexed by O_z span V for every nonzero z.
+2. Compatible z,z′ satisfy β(z,z′)=0.
+3. If compatible z,z′ both have even weight, then q(z)≠q(z′).
+
+Fact 1, including its validity in every characteristic different from two,
+was already certified by CubeJerry / PR3095 with power-of-two integer minors.
+The present certificate independently reconstructs that premise together with
+the forbidden-pair witnesses needed for facts 2 and 3.
+
+Only full-rank witnesses are needed to prove these statements. The attached
+[CERTIFICATE.json](CERTIFICATE.json) gives nine single-character witnesses and
+100 forbidden-pair witnesses, each an explicit nonzero integer 8×8 minor
+in standard doubled-root coordinates, with row IDs in the A8 label order.
+Here is the entire reduction from these witnesses to all characters and pairs.
+
+Permutations of nine coordinates act on V, its root lines, and the labels
+(4). A pair root can change orientation; this multiplies a scalar row by −1
+and does not change its binary label. A coordinate permutation σ maps O_z
+to O_{σz} and preserves scalar ranks, β, and q. Nonzero single characters have exactly nine orbits,
+specified by their weight k=1,…,9. The representative z_k has its first k
+bits equal to one, that is integer bitmask 2^k−1 with bit zero first.
+
+For ordered pairs (z,z′), simultaneous coordinate permutation is classified
+completely by the four counts n_ab of coordinates with (z_j,z′_j)=(a,b).
+Two pairs with the same counts are related by a permutation, obtained by
+matching each of the four coordinate classes. There are
+
+```text
+#{(n_00,n_01,n_10,n_11)≥0 : Σ n_ab=9} = binom(12,3)=220.
+```
+
+Delete the profiles with z=0, z′=0, or z=z′. Each condition gives ten
+profiles. Every intersection of two or three conditions is the single
+all-zero pair profile, so their union has 30−3+1=28 profiles. Exactly
+220−28=192 valid ordered profiles remain. For each one use contiguous
+coordinate blocks 00,01,10,11 of their stated lengths to define a,b.
+
+The forbidden predicate on these representatives is precisely
+
+```text
+n_11 odd
+or [wt(a),wt(b) both even and wt(a)/2 ≡ wt(b)/2 (mod 2)].      (6)
+```
+
+Exactly 100 of the 192 profiles satisfy (6). The certificate contains exactly
+this inventory, without omissions or duplicates, and binds each a,b to its
+four counts. For each listed pair it selects eight standard doubled-root
+rows lying in O_a∩O_b with the stated nonzero determinant.
+Thus every forbidden profile has scalar rank eight. Its contrapositive proves
+facts 2 and 3 for all pairs; no assertion that the remaining profiles are
+compatible is required.
+
+For completeness the certificate's nine single-character determinants are
+
+| k | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+|---|---|---|---|---|---|---|---|---|---|
+| det | −512 | −256 | 512 | −256 | −1024 | −256 | −512 | −256 | 256 |
+
+Rows are indexed from zero: first pair roots in lexicographic order of (i,j),
+then triple roots in lexicographic order of S. Every witness index must be
+distinct, in 0,…,119, and satisfy its stated character conditions. The verifier
+uses (3) to bind each indexed A8 line to its standard eight-dimensional
+doubled-root row. Nonzero determinants give fact 1 and all forbidden
+rank-eight assertions. Every absolute determinant is a power of two,
+belonging to {256,512,1024,2048}; this permits the extension in section 8.
+
+The displayed formulas reconstruct every finite input: enumerate the roots,
+labels, nine singles and 220 four-count tuples; select the 100 tuples by (6);
+check witness membership and recompute every determinant. [verify.py](verify.py)
+enforces these complete inventories. [independent.py](independent.py) separately
+reconstructs the standard D8-plus-half-root model and exhausts all nonzero
+characters and unordered distinct pairs in intrinsic dense-table coordinates.
+
+Every doubled-root entry and every witness determinant is an integer. A nonzero
+integer remains nonzero in every characteristic-zero field. Consequently
+these facts hold for scalar rank over any such K, including fields not
+embedded in R or C. No reduction-mod-prime assumption is used for this
+transfer; modular rank can select a witness, but the exact determinant
+certifies it.
+
+## 4. Every compatibility clique is linearly independent
+
+Credit mightyOil / PR1248's compatible-edge independence argument as the
+method ancestor. Here it is applied to arbitrary compatible cliques, then
+grouped across all support annihilators in section 5.
+
+Let E be a set of distinct pairwise compatible nonzero binary vectors.
+Fact 2 says that its off-diagonal β pairings vanish. For an odd-weight member
+z, β(z,z)=1. Pairing a linear relation among E with z therefore makes its
+coefficient zero. All odd-weight members disappear from any relation.
+
+The remaining members have even weight. By fact 3, any two have opposite
+q values. There are only two values, so there are at most two such members
+in E. A single nonzero vector is independent, and two distinct nonzero
+vectors over F₂ are independent. The remaining relation is therefore zero.
+This proves independence of E, and in particular |E|≤9.
+
+## 5. Annihilator packing proves the uniform theorem
+
+For any scalar vector p define its binary support annihilator
+
+```text
+Z(p) = {z∈Λ : β(z,u_v)=0 for every v∈supp p}.
+```
+
+Nondegeneracy gives dim Z(p)=9−w(p)=δ(p). Equivalently, z∈Z(p) means p
+vanishes on O_z. If 0≠p∈C and 0≠z∈Z(p), the evaluation defining p
+vanishes on roots spanning V by fact 1, forcing p=0. Thus Z(p)=0 for
+every nonzero p∈C.
+
+It remains to consider the members outside C. Each has a unique expression
+p_i=a_i λ+R h_i with a_i≠0 and h_i∈V. Divide by a_i, which preserves support
+and annihilator, and rename h_i to obtain
+
+```text
+p_i = λ+R h_i.
+```
+
+Here Rω=0 because every A8 root row has coordinate sum zero. Together with
+the direct sum K^9=V⊕Kω in characteristic zero and injectivity on V, this
+justifies taking each evaluation representative uniquely in V.
+
+These normalized vectors are distinct: equality would make the original
+members proportional. Thus h_i−h_j≠0 for i≠j. Write Z_i=Z(p_i).
+
+First, Z_i∩Z_j=0. Indeed a common nonzero z would make both vectors vanish
+on O_z. Their difference R(h_i−h_j) would vanish there as well, contradicting
+fact 1 and injectivity of evaluation on V.
+
+Second, every nonzero z∈Z_i and z′∈Z_j with i≠j form a compatible pair.
+They are distinct by the preceding paragraph. Both p_i and p_j vanish on
+O_z∩O_z′. The nonzero linear functional defined by h_i−h_j therefore
+vanishes on every scalar root there. Its kernel in V is a hyperplane, so
+that root set has rank at most seven. This is compatibility by definition.
+
+Pairwise trivial intersection alone would not suffice to add dimensions.
+Here the stronger cross-pair property supplies the missing step. Suppose
+there is a relation Σ_i z_i=0 with z_i∈Z_i. Discard its zero summands. The
+remaining z_i are distinct nonzero vectors, one from each participating
+space, and every two are compatible. Section 4 makes them independent,
+contradicting this nonempty relation. Hence the sum of all Z_i is direct in
+the nine-dimensional Λ, and
+
+```text
+Σ_i δ(p_i) = Σ_i dim Z_i = dim(⊕_i Z_i) ≤ 9.
+```
+
+Members inside C contribute zero, proving (1) for the entire finite family.
+The proof imposes no bound on its cardinality and makes no assumption about
+the weights or support shapes of the individual vectors.
+
+The budget nine is attained. Set λ=0 on pair roots and λ=−2 on triple roots,
+and let p_j=λ+R_column_j for j=0,…,8. The pair roots force λ∉C: a codeword
+vanishing on all pair roots is zero. These nine vectors have different
+supports, hence are nonproportional. Their nonzero triple entries are exactly
+the triples avoiding j; their nonzero pair entries are exactly pairs incident
+to j. All corresponding labels lie in e_j⊥. The triples on the other eight
+coordinates span that eight-dimensional space by the same even-space plus
+odd-vector argument used after (4). Therefore w(p_j)=8 and Σ_j δ(p_j)=9.
+This is sharpness of the family budget, not an exact-decoder fixture.
+
+## 6. Normalization of an exact factorization preserves the needed bounds
+
+Start with (2). Drop any term having a zero factor, since its scalar outer
+product and its COPY cost are both zero. If p_j=μp_i with μ≠0, replace
+
+```text
+p_i q_iᵀ+p_j q_jᵀ  by  p_i(q_i+μq_j)ᵀ.
+```
+
+The new column support is contained in supp q_i∪supp q_j. For a fixed row
+support, binary pairing rank is monotone under restricting columns and
+subadditive under taking their union. Hence the new cost is at most the sum
+of the two old costs. The new columns of either factor lie in its old column
+span, so neither actual factor rank increases. The symmetric operation merges
+proportional q columns. Remove any zero factor created by a merge.
+
+Repeat merges on either side until neither side has a proportional pair.
+Each operation decreases the number of terms, so this terminates. Denote the
+remaining number by m′. Both final families consist of pairwise
+nonproportional nonzero vectors; exactness is preserved and cost has not
+increased. Retain every term with two nonzero factors, even if its binary
+COPY cost is zero: such an outer product can be nonzero and can be necessary
+for exact equality to N₀. There is no deletion of off-mask scalar entries.
+
+The standard root matrix R₀ has full column rank: its rows include the basis
+e_0±e_1,…,e_6±e_7. Thus R₀ is injective and R₀ᵀ is surjective. Their product
+G=R₀R₀ᵀ has rank eight and image C, without requiring R₀ᵀR₀ to be invertible.
+Exactness and its transpose imply
+
+```text
+C = col(N₀) ⊆ col(P),              C ⊆ col(Q).
+```
+
+For the normalized factors their ranks are consequently 8+s and 8+t with
+s,t∈{0,1}. If s=0, all p columns are in C and their total deficiency is zero.
+If s=1, their span is C+Kλ_P for some λ_P∉C; apply (1) to the normalized
+family. The same argument applies on the q side. In both cases,
+
+```text
+Σ_k δ(p_k)≤9s,      Σ_k δ(q_k)≤9t.                         (7)
+```
+
+The values s,t here are the final ranks: normalization can lower a rank,
+and (7) covers (9,9) and every exit into (8,8), (9,8), or (8,9).
+
+## 7. The COPY floor, sharpness, and the boundary of the result
+
+For binary subspaces U,W⊆Λ, the pairing map U→W* has kernel U∩W⊥. Hence
+
+```text
+ρ(U,W)=dim U−dim(U∩W⊥) ≥ dim U+dim W−9.
+```
+
+This also applies to cost-zero terms. Summing it and using (7) gives
+
+```text
+COPY ≥ Σ_k [w(p_k)+w(q_k)−9]
+     = 9m′−Σ_k δ(p_k)−Σ_k δ(q_k)
+     ≥ 9(m′−s−t).                                          (8)
+```
+
+Sylvester's inequality, applied to the normalized exact product, gives
+
+```text
+8=rank(PQᵀ) ≥ rank P+rank Q−m′ = 16+s+t−m′.
+```
+
+For clarity this follows by restricting P:K^{m′}→K^L to im(Qᵀ): its kernel
+has dimension at most m′−rank P. Thus m′≥8+s+t, and (8) is at least 72.
+The original factorization has no smaller cost, proving the consequence.
+
+The one-sided slices are low-dimensional instances of the L120 basis-cost
+programme. If S contains C and dim S=8+s with s in {0,1}, any basis of S is
+nonproportional. The uniform theorem gives total basis deficiency at most 9s,
+so every such basis costs at least 9(8+s)-9s=72. SPARSE-PAIR.md proves the
+specified dimension-ten instance. These statements do not prove L120 for
+arbitrary S; the genuinely two-sided consumer here is the (s,t)=(1,1) cell.
+
+Sharpness requires only the ordinary rank-(8,8) decoder. In standard root
+coordinates use the orthogonal norm-two frame f_k=e_{2a}±e_{2a+1}, a=0,…,3.
+Let X[v,k]=r_v·f_k. Since Σ_k f_k f_kᵀ=2I₈, the factors P=Q=X/2 satisfy
+PQᵀ=G/2. They have rank eight. Every nonzero column is a scalar codeword,
+so its support has label span Λ by section 5. Each of the eight terms
+therefore costs nine, for total 72. No rank-(9,9), ten-term equality fixture
+is needed for this sharpness claim. There is also the following normalized
+two-sided equality construction, retained in [fixtures.py](fixtures.py).
+
+### 7.1. Normalized rank-(9,9), ten-term equality
+
+Write E(h)=(r_x·h)_{x∈L} for scalar evaluation in standard root coordinates.
+Choose v=e_0+e_1 and w=e_0+e_2, so v·w=1, and their root lines a,b. The
+actual oriented representatives at those lines may be ±v and ±w. Use the
+following dual bases; inspection gives h_i·d_j=δ_ij:
+
+```text
+(h_1,…,h_8) = (v, e_1, e_0−e_2, e_3,…,e_7),
+(d_1,…,d_8) = (w, −e_0+e_1−e_2, −e_2, e_3,…,e_7).
+```
+
+Let δ_a,δ_b denote coordinate unit vectors in K^L and define nine terms by
+
+```text
+λ=E(v)_a δ_a,      p_0=λ,             p_j=λ−E(h_j)  (1≤j≤8),
+q_j=−E(d_j)/2      (1≤j≤8),          q_0=−Σ_{j=1}^8 q_j.
+```
+
+Since E(v)_a=±2, λ≠0. It is outside C because its binary support weight is
+one, whereas every nonzero scalar codeword has weight nine. Duality gives
+
+```text
+Σ_{i=0}^8 p_i q_iᵀ
+  = −Σ_{j=1}^8 E(h_j)q_jᵀ
+  = (1/2)Σ_{j=1}^8 E(h_j)E(d_j)ᵀ = G/2.                   (9)
+```
+
+The p columns span C+Kλ: their differences with p_0 give the basis E(h_j).
+They are pairwise nonproportional, since all have the same nonzero quotient
+modulo C and the h_j, together with zero, are distinct. The q_1,…,q_8 are
+a basis of C; q_0 is their negative sum, hence nonzero and nonproportional
+to each of them. This is therefore a normalized rank-(9,8) decoder.
+
+The support of p_1=λ−E(v) is exactly the roots nonorthogonal to v with line
+a omitted. Its labels lie in u_a⊥. Adding label u_a gives the support of
+E(v), whose label span is Λ, so w(p_1)=8. Thus δ(p_0)=8 and δ(p_1)=1.
+The family theorem forces all other p_j to have weight nine. Since each q_i
+is a nonzero codeword, these nine terms have costs (1,8,9,9,9,9,9,9,9).
+
+Now put μ=δ_b and c=N₀[:,b], and replace the nine q columns, adding one term:
+
+```text
+q_i′ = q_i−q_i(b)μ   (0≤i≤8),       (p_9,q_9′)=(c,μ).
+```
+
+Equation (9) implies Σ_i p_i q_i(b)=c, so this changes the product by
+−cμᵀ+cμᵀ=0. The p rank is still nine, since c∈C. The new q columns span
+C+Kμ: μ is present and each old q_i is q_i′+q_i(b)μ. This has dimension
+nine, since the singleton μ is outside C.
+
+All ten terms are normalized. The old p columns are outside C and pairwise
+nonproportional, so none is proportional to the new nonzero c∈C. On the
+other side, a relation q_i′=αq_j′ would give q_i−αq_j∈C∩Kμ=0, contradicting
+the old nonproportionality. No q_i′ is zero or proportional to μ for the same
+reason. Thus neither side admits a proportional merge.
+
+Because d_1=w, q_1′ has exactly the nonorthogonal-to-w support with line b
+omitted. As above its label span is u_b⊥ of dimension eight. Together with
+q_9′=μ of weight one this saturates the q-side deficiency budget nine, so
+all other q_i′ have weight nine. Both p_1 and q_1′ consequently have
+hyperplane label spans. Since v·w=1, equation (5) gives β(u_a,u_b)=0, and
+
+```text
+ρ(p_1,q_1′) = 8−dim_F₂(u_a⊥∩F₂u_b) = 7.
+```
+
+The first and last terms pair a singleton with a full label span and cost
+one each. The seven remaining terms have both label spans full and cost
+nine each. The ten costs are therefore
+
+```text
+(1,7,9,9,9,9,9,9,9,1),                total COPY = 72.
+```
+
+This is an explicit equality example in the strict normalized (9,9), m=10
+class, rather than an enumeration of arbitrary coefficient choices.
+
+### 7.2. Necessary structure of every equality case
+
+Suppose an original factorization in (2) has COPY=72. Any completed
+normalization still costs 72: cost cannot rise, and the proved floor applies
+to its final ranks. For those ranks 8+s,8+t, the two inequalities in section
+7 force
+
+```text
+m′=8+s+t,       Σ_i δ(p_i)=9s,       Σ_i δ(q_i)=9t.
+```
+
+Indeed m′>8+s+t would force COPY≥81; with equality in the term count, any
+unsaturated deficiency budget would make (8) strictly greater than 72.
+Every individual pairing inequality is also an equality, since all their
+nonnegative gaps sum to zero. In annihilator notation this is equivalent to
+
+```text
+Z(q_i) ⊆ U_supp(p_i),   or equivalently β(Z(p_i),Z(q_i))=0.
+```
+
+For either factor with excess one, its annihilators form a β-orthogonal
+direct-sum decomposition of all Λ. Orthogonality follows from fact 2 and
+the cross-compatibility in section 5; their dimensions sum to nine by
+budget saturation. Consequently β restricts nondegenerately to each nonzero
+annihilator: a vector in its radical would be orthogonal to every summand,
+hence all Λ, and would be zero. These are necessary equality conditions;
+they do not classify the scalar coefficient families. The exact fixtures
+check the dimensions, same-side orthogonality, restricted nondegeneracy,
+and matched cross-side orthogonality after every normalization exit.
+
+As a useful unrestricted-rank corollary, every exact ten-term decoder whose
+two factors both leave C costs at least 72. Indeed write their ranks as
+8+s,8+t with s,t≥1. Sylvester gives s+t≤2, so s=t=1 and the theorem applies.
+A cheaper exact decoder with both factors outside C would therefore need at
+least eleven terms. A rank-(10,8) ten-term decoder is outside this result.
+
+The theorem is for the full E8 root set and exact N₀, with dense table B_d.
+It does not prove the general masked P120 floor, a punctured-root floor,
+or an unrestricted floor with a factor of rank ten or more. The separate
+[SPARSE-PAIR.md](SPARSE-PAIR.md) derives a restricted rank-(10,8) extension:
+one factor lies in C and the other in C plus two root-coordinate unit vectors.
+This is a consequence of the one-coset theorem, not a uniform two-direction
+family budget. Singleton padding of a
+punctured decoder can raise the factor ranks beyond nine. Nor does the
+family budget extend to two arbitrary outside directions: over an infinite
+field the vectors δ_a+tδ_b for arbitrarily many distinct nonzero t have support size two,
+are pairwise nonproportional, and all have deficiency seven. There is no
+new κ, physical realization, supplier admission, or multiplication theorem.
+
+## 8. Extension to every scalar field of characteristic different from two
+
+Both the uniform theorem and the exact-decoder COPY floor hold for every
+field K with char K≠2, using the standard E8 roots over Z[1/2]. Define C as
+their scalar evaluation code over K and retain the fixed integer-incidence
+table B_d and the binary labels (4). In particular B_d is defined before
+scalar reduction, rather than by taking parity of a field element.
+
+The 109 standard-coordinate determinant witnesses are powers of two, hence
+remain nonzero in K. To transport their profiles when char K=3, do not reduce
+the rational A8 isometry or its sum-zero scalar space: those were only used
+over Q to index the root lines. Instead use the following integral reflection
+identities. For each adjacent transposition of the nine A8 coordinates, let
+α be the standard doubled E8 root corresponding to that pair root. Its
+reflection is H=I−ααᵀ/4. For N=4I−ααᵀ the verifier checks
+
+```text
+N²=16I,             4u−(u·α)α = ε·4u′    (ε∈{1,−1})
+```
+
+for all 120 standard doubled-root rows u, with u′ the A8-permuted line,
+and checks that its binary label is the same coordinate permutation of u's
+label. These are eight generator checks, 960 signed root-image identities,
+and 512 matrix-entry identities. They hold over Z, so H is an invertible
+root-line permutation over every K of odd characteristic. The generators
+give the full S9 action needed for the nine single and 192 pair profiles.
+Thus the same unit witnesses prove all three finite facts over K, defining
+compatibility by scalar rank over K itself.
+
+In sections 4–7 replace the scalar A8 space V by standard K^8 and its
+evaluation map R₀. Its dot product is nondegenerate, and R₀ has rank eight
+because the orthogonal frame basis has determinant ±16. The annihilator,
+grouped-relation, merge, binary rank and Sylvester arguments are unchanged.
+In particular rank N₀=8 follows from injectivity of R₀ and surjectivity of
+R₀ᵀ, even in characteristics three and five where R₀ᵀR₀=30I is singular.
+The ordinary rank-(8,8) decoder still attains 72. This extension does not
+assert that the nine A8 integer vectors in section 5 retain their stated
+supports after reduction at three, and makes no characteristic-two claim.
+
+The sparse-pair consequence in SPARSE-PAIR.md uses this all-odd-field theorem
+directly; its singleton-ray classification, binary orthogonality and filtered
+basis argument require no further field-transfer premise.
+
+The strict normalized rank-(9,9), ten-term equality construction in section
+7.1 also persists over every such field: its integral dual bases remain bases,
+its quotient-space nonproportionality arguments remain valid, and the two
+distinguished support hyperplanes still saturate the deficiency budgets.
+Their nonzero root pairings are ±1 or ±2, so exactly the same single root
+line is removed on each side in every characteristic different from two.
+
+## 9. Predecessors and proof dependencies
+
+Credit joaqcoo / PR1224 for the all-m projection equations, one-sided
+annihilator constraints and original compatible-pair census; mightyOil /
+PR1248 for the fixed-A8-frame deficiency-nine theorem and compatible-edge
+independence method; adamgall / PR2062 for the fixed A7+A1 family; CubeJerry /
+PR3095 for the single-character rank premise in every odd characteristic;
+and bbMisk / PR1633
+for the sharp factor excess-rank budget and full two-sided ten-term residual
+form. PR717 and PR446 supply the exact-decoder and per-term pairing-rank COPY
+model; PR968 and PR1077 supply earlier exact-root decoder floors. The new
+assembly proves an arbitrary one-coset family budget and its all-m,
+rank-at-most-nine exact-N₀ consumer; the rank and merge arguments are rederived.
+
+The one-sided slices belong to L120, the programme documented in PR3074 and
+PR3154's B-prime node. PR3191's draft completion claim still has an unfilled
+implementation slot at its pinned head; conorholds / PR3166 supplies C7 in
+that programme. None of that conditional chain is a premise here. The
+two-sided (1,1) result addresses PR3154's C-prime node and its requested
+term-count-independent deficiency budget. philippeVV's restricted clean
+lift-family credit-at-most-nine argument in Discussion 1587 is related prior
+work; the arbitrary-family theorem here does not assume its lift hypotheses.
+
+The proof uses only the explicitly constructed root/label model, the 109
+finite rank witnesses and their orbit coverage, and the linear algebra in
+sections 4–7. It imports none of the C1–C5, catalogue, capacity, root-swap,
+or retraction assertions in the later master-floor programme. Reproduction
+and the distinction between executable checks and formal coverage are recorded
+in the package README and verification records. [FORMAL.md](FORMAL.md) describes
+the checked Init-only Lean core for odd-coefficient elimination, the Boolean
+even-color argument, and absence of nonempty zero relations among compatible
+cliques and nonzero grouped choices from trivially intersecting subspaces. It does
+not formalize the E8 finite facts, their geometric instantiation, the connection
+to Mathlib linear independence or finrank, the dimension budget, or the
+exact-factorization COPY consequence. A second Init-only file checks the final
+natural-number implication from the two displayed budget inequalities to
+COPY≥72, with both inequalities left as explicit premises. The first file also
+instantiates the addition and pairing laws on Fin 9→Bool; the E8 geometric
+orthogonality and even-color hypotheses remain explicit premises.
diff --git a/research/e8-coupled-coordinate-floor/vendor/pr3755/SPARSE-PAIR.md b/research/e8-coupled-coordinate-floor/vendor/pr3755/SPARSE-PAIR.md
new file mode 100644
index 0000000000..c702ce7e33
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/pr3755/SPARSE-PAIR.md
@@ -0,0 +1,284 @@
+# A sharp COPY floor for two singleton outside directions
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+This is a written corollary of the uniform theorem; full proof-assistant
+verification is not claimed.
+
+## 1. Statement and inputs
+
+Let K be any field of characteristic different from two. Let L be the 120
+standard E8 root lines with oriented norm-two representatives r_x over
+Z[1/2], and retain their fixed binary labels u_x in Lambda=F2^9. Their
+nondegenerate binary pairing beta gives the dense table B_d. Put
+
+```text
+E(h)=(r_x dot h)_{x in L},       C=E(K^8),
+G[x,y]=r_x dot r_y,             N0=G/2,
+U(p)=span_F2{u_x:p(x)!=0},      Z(p)=U(p)^perp,
+w(p)=dim U(p),                 delta(p)=9-w(p).
+```
+
+For distinct lines a,b let delta_a,delta_b be the coordinate unit vectors,
+and set S=C+span_K(delta_a,delta_b).
+
+**Theorem.** For any finite m, if P,Q in K^{L x m} satisfy
+
+```text
+P Q^t=N0,       col(P) subset S,       col(Q) subset C,
+```
+
+then COPY(P,Q)>=72, where each term costs the binary pairing rank
+rho(supp p_i,supp q_i)=rank_F2 B_d[supp p_i,supp q_i]. The floor is sharp,
+including an actual rank-(10,8), ten-term factorization. The transposed
+statement holds as well. Transposes are ordinary transposes over every K.
+
+The inputs are the uniform deficiency theorem and annihilator argument in
+[PROOF.md](PROOF.md)
+section 5, extended to these fields in section 8. Every nonzero codeword
+has weight nine. For any lambda outside C, a finite nonproportional family
+in C+K lambda has total deficiency at most nine. Moreover, for distinct
+normalized outside vectors p=lambda+E(h), p'=lambda+E(h'), their
+annihilators have trivial intersection and are beta-orthogonal: every
+nonzero cross-pair is compatible, so finite fact 2 applies. The root-hole
+support calculation below also occurs in PROOF.md section 7.1.
+
+## 2. Independence and the singleton classification
+
+The evaluation map E is injective: standard roots include the orthogonal
+frame e_0+e_1,e_0-e_1,...,e_6+e_7,e_6-e_7 of determinant plus or minus 16.
+Distinct standard root lines remain nonproportional over K. Pair roots
+have support two and half-roots have support eight. Within either type,
+comparison at a nonzero coordinate forces proportionality scalar +1 or
+-1; odd characteristic preserves all distinct sign patterns. Thus
+E(r_a),E(r_b) are independent. This avoids a Gram-determinant argument,
+which would fail for nonorthogonal roots in characteristic three.
+
+Write u=u_a, v=u_b. Distinct root lines have distinct nonzero binary labels,
+so u!=v and they are independent over F2. Put D=span_K(delta_a,delta_b).
+A nonzero vector in D
+has binary weight one or two, so D intersect C=0 and dim S=10.
+
+Because E(r_a)_a=r_a dot r_a=2, define the singleton hole
+
+```text
+A=delta_a-E(r_a)/2,        B=delta_b-E(r_b)/2.
+```
+
+The support of A is exactly the nonorthogonal-to-r_a roots with line a
+omitted. Its labels lie in u^perp. Adding u restores the support of the
+nonzero codeword E(r_a), whose label span is Lambda. Hence U(A)=u^perp,
+w(A)=8 and Z(A)=F2 u. This calculation survives every characteristic
+different from two: at line a the product r_a dot r_a is 2 and is exactly
+cancelled; at every other nonorthogonal line the product is +1 or -1 and
+remains nonzero. Similarly
+w(B)=8 and Z(B)=F2 v.
+
+The vectors delta_a and A are nonproportional and have deficiencies eight
+and one. They saturate the uniform budget in C+K delta_a. Therefore they
+are the only positive-deficiency projective rays in that extension.
+Likewise delta_b and B are the only such rays in C+K delta_b.
+
+## 3. Classification in a mixed singleton direction
+
+Fix s,t in K nonzero and lambda=s delta_a+t delta_b. Since D intersect C=0,
+lambda is outside C. Its support has label span W=span_F2(u,v), so
+
+```text
+delta(lambda)=7,       Z(lambda)=W^perp.
+```
+
+Consider any other positive-deficiency ray in C+K lambda. It has a unique
+representative p=lambda+E(h), different from lambda; codewords themselves
+have deficiency zero. The annihilator properties in section 1 imply
+
+```text
+Z(p) subset Z(lambda)^perp=W,       Z(p) intersect W^perp=0. (1)
+```
+
+First suppose the scalar root lines a,b are nonorthogonal. Then
+beta(u,v)=0, while beta(u,u)=beta(v,v)=1. Put
+
+```text
+p_a=lambda-(s/2)E(r_a)=sA+t delta_b,
+p_b=lambda-(t/2)E(r_b)=s delta_a+tB.
+```
+
+The first vector vanishes on O_u={x:beta(u,u_x)=1}: its entry at a cancels,
+all other roots there are orthogonal to r_a, and b is not there. Thus
+u belongs to Z(p_a). Similarly v belongs to Z(p_b). Both deficiencies
+are at least one. These vectors and lambda are nonproportional: their
+quotient coefficients modulo C are all one, and E(r_a),E(r_b) are
+independent. Their deficiencies sum to at least 7+1+1=9. The uniform
+theorem forces both new deficiencies to equal one and excludes every
+other positive-deficiency ray in C+K lambda.
+
+Now suppose the root lines are orthogonal, so beta(u,v)=1. On W the
+pairing matrix is [[1,1],[1,1]], with radical F2(u+v)=W intersect W^perp.
+By (1), a nonzero Z(p) must have dimension one and generator u or v.
+Suppose it is u; the other case is symmetric. The vector
+
+```text
+p'=p-sA=t delta_b+E(h+(s/2)r_a)
+```
+
+still vanishes on O_u. It is nonzero and outside C, because t!=0 and
+delta_b is outside C. It is therefore a positive-deficiency vector in
+C+K delta_b and must be proportional to delta_b or B by section 2.
+But delta_b does not vanish on O_u, since beta(u,v)=1; and B has
+annihilator F2 v, which does not contain u. This contradiction proves
+that lambda itself is the only positive-deficiency ray in this case.
+
+## 4. Filtered spans and the basis bound
+
+Every nonzero p in S is a codeword or lies in one of the quotient
+directions just classified. Consequently
+
+```text
+{p in S:w(p)<=7} subset D,
+{p in S:w(p)<=8} subset H=D+span_K(E(r_a),E(r_b)).
+```
+
+The first set spans D, and the second spans H because it contains
+delta_a,delta_b,A,B. Thus these filtered spans have dimensions two and
+four respectively; dim H=4 follows from D intersect C=0 and the root
+independence proved above. The weight-one vectors also span D.
+
+Any ten-vector basis of S therefore contains at most two vectors of
+weight at most seven and at most four of weight at most eight. Nonzero
+vectors have weight at least one. Its ordered weights are bounded below by
+
+```text
+(1,1,8,8,9,9,9,9,9,9),       sum=72.                    (2)
+```
+
+## 5. Every finite exact factorization and sharpness
+
+Delete terms with a zero factor. Each remaining q_i is a nonzero codeword,
+so U(q_i)=Lambda and its term costs exactly w(p_i). Exactness implies
+C=col(N0) subset col(P): the standard root matrix is injective and its
+transpose is surjective, so N0 has rank eight and image C.
+
+If the remaining P has rank at most nine, the rank-at-most-nine
+floor applies, since Q has rank eight. Otherwise its rank is ten and its
+columns span S. Choose a ten-column basis subset. Its weights sum to at
+least 72 by (2); all other costs are nonnegative. This proves the theorem,
+including rank drops caused by deleting zero-reader columns.
+
+### 5.1 Equality survives proportional normalization
+
+The sheared variant below was suggested and computationally checked in the
+local Claude Fable 5.1 AI-assisted audit; this is not human peer review.
+
+Extend h_1=r_a,h_2=r_b to any basis h_1,...,h_8 of K^8, and let d_1,...,d_8
+be its dot-product dual. Such an extension exists also in characteristic three:
+the two root representatives are independent, as proved in section 2; a
+two-root Gram determinant is not needed. Put
+
+```text
+A=delta_a-E(h_1)/2,       B=delta_b-E(h_2)/2,
+y_3=E(h_3)+delta_a,       y_4=E(h_4)+delta_b,
+
+P=(delta_a,delta_b,A,B,y_3,y_4,E(h_5),...,E(h_8)),
+Q=(E(d_1-d_3/2),E(d_2-d_4/2),-E(d_1),-E(d_2),
+   E(d_3)/2,E(d_4)/2,E(d_5)/2,...,E(d_8)/2).
+```
+
+Every P column lies in S=C+span_K(delta_a,delta_b). The unsheared columns
+delta_a,delta_b,A,B,E(h_3),...,E(h_8) form a basis of S: their span contains
+delta_a,delta_b and E(h_1),...,E(h_8), while dim S=10. Adding delta_a to
+E(h_3), and delta_b to E(h_4), are invertible column operations. Hence the
+displayed P has rank ten, all its columns are nonzero, and they are pairwise
+nonproportional.
+
+The two modified columns still have weight nine. By section 2, the only
+positive-deficiency rays in C+K delta_a are delta_a and A. The normal h_3
+is independent of h_1, so y_3 is proportional to neither: comparison modulo
+C would force the proportionality coefficient to be one, and then would
+force h_3=0 or h_3=-h_1/2, respectively, by injectivity of E. Thus w(y_3)=9.
+The same argument with h_4,h_2 gives w(y_4)=9. The full P weight list is
+therefore
+
+```text
+(1,1,8,8,9,9,9,9,9,9),       sum=72.
+```
+
+For the Q columns, use the dual basis as coordinates. Their normal supports
+are respectively
+
+```text
+{1,3}, {2,4}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}.
+```
+
+Every displayed coefficient is nonzero in characteristic different from two.
+These supports are nonempty and distinct, so these normals are nonzero and
+pairwise nonproportional. Injectivity of E gives the same facts for Q. Its
+last eight normals, -d_1,-d_2,d_3/2,...,d_8/2, form a basis, so rank Q=8.
+Every reader is a nonzero codeword and has binary support weight nine.
+Consequently the actual binary pairing rank of each term equals the weight
+of its P column, and COPY=72.
+
+Exactness follows directly by grouping terms:
+
+```text
+PQ^t
+ = (delta_a-A)E(d_1)^t + (delta_b-B)E(d_2)^t
+   + (y_3-delta_a)E(d_3)^t/2
+   + (y_4-delta_b)E(d_4)^t/2
+   + sum_{j=5}^8 E(h_j)E(d_j)^t/2
+ = sum_{j=1}^8 E(h_j)E(d_j)^t/2 = G/2 = N0.
+```
+
+Neither zero-term deletion nor proportional-factor merging on either side
+can change this factorization: all ten terms are active and both factor
+families are pairwise nonproportional. Thus the rank-(10,8) equality example
+already survives that normalization. These statements use no characteristic
+restrictions beyond 2 being invertible and apply to both orthogonal and
+nonorthogonal a,b.
+
+The unsheared fixture retained in `sparse_pair.py` is a useful positive control:
+remove the added units from y_3,y_4 and restore the first readers E(d_1),E(d_2).
+Its two pairs of proportional readers merge to eight code-code terms of ranks
+(8,8), with COPY still 72. The finite verifier retains those six controls
+and adds the sheared construction for both pair types over F3, F5, F7. Each
+new fixture checks all 14,400 product entries, actual binary term ranks,
+scalar factor ranks, active terms, both families' proportionality, and the
+result of an independent proportional normalizer. Omitting the compensating
+changes to the first two readers is explicitly rejected by the product check:
+its product error is
+
+```text
+(delta_a E(d_3)^t + delta_b E(d_4)^t)/2 != 0.
+```
+
+The two nonzero rows lie at distinct coordinates a,b, so the error cannot
+cancel in any permitted characteristic. The finite fixtures do not exhaust
+F5 or F7 or all root pairs; the argument above supplies the universal claim.
+
+The theorem concerns the specific space C+span(delta_a,delta_b) and exact
+N0 on full E8, with fixed B_d. It makes no assertion for arbitrary two
+outside directions, all rank-ten factors, masked identities, punctures,
+or a physical multiplication construction.
+
+## 6. Relation to earlier singleton and root-swap work
+
+DreamingOfClouds's [PR2816](https://github.com/CrocSwap/integer-mult-bounds/pull/2816),
+`research/one-sided-decoders-all-m/README.md` sections 5.2, 6 and 9, already
+analyzes singleton root swaps and `T=span(delta_t,delta_u)` in the P112
+characteristic-zero, low-excess correction programme. Those geometric
+observations are antecedents, not discoveries claimed here. The floor of 68 in PR2862 is a historical
+full-E8 lift baseline, rather than the current status of the one-sided programme. The present statement is full E8, all finite
+term counts and every characteristic different from two, in the explicitly
+restricted coordinate-pair extension. Its proof uses the uniform theorem
+directly, without importing their correction, minimum-basis or survivor-list
+hypotheses. These results do not supply a general one-sided rank-ten floor.
+
+The relevant broader programme is **L120**, the basis-cost bound for every
+scalar space containing C. PR3074 states its sufficiency for the one-sided
+problem, and PR3154 separates that B-prime node from the two-sided C-prime
+node. Draft PR3191 claims completion of its one-sided ledger conditional on
+an implementation slot that remains unfilled at head `9c9e094`; conorholds'
+PR3166 supplies its C7 branch. In characteristic zero a completed L120 proof
+would imply the present sparse-pair corollary. Here this dimension-ten case
+is proved directly, in every characteristic different from two, without that
+conditional chain. The main new theorem of the package is the arbitrary-family
+one-coset budget; its genuinely two-sided application is the rank-(9,9) cell.
diff --git a/research/e8-coupled-coordinate-floor/vendor/pr3755/__init__.py b/research/e8-coupled-coordinate-floor/vendor/pr3755/__init__.py
new file mode 100644
index 0000000000..c961810794
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/pr3755/__init__.py
@@ -0,0 +1 @@
+"""Authenticated PR3755 snapshot; see ../../REFERENCES.json for provenance."""
diff --git a/research/e8-coupled-coordinate-floor/vendor/pr3755/geometry.py b/research/e8-coupled-coordinate-floor/vendor/pr3755/geometry.py
new file mode 100644
index 0000000000..9b4a3844d1
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/vendor/pr3755/geometry.py
@@ -0,0 +1,324 @@
+"""Exact A8 model and small witnesses for the one-coset theorem.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+The model/deficiency setup credits PR1224 and PR1248; no source code is imported.
+Normal functions are pure and never read or write files.
+"""
+
+from fractions import Fraction
+from itertools import combinations, product
+
+
+OMEGA = 511
+MODEL = "Standard E8 roots scaled by 2; A8 label order"
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def parity(value):
+    return value.bit_count() % 2
+
+
+def dot(left, right):
+    require(len(left) == len(right), "dot-product dimensions differ")
+    return sum(x * y for x, y in zip(left, right))
+
+
+def binary_rank(values):
+    pivots = {}
+    for initial in values:
+        value = initial
+        require(type(value) is int and value >= 0, "binary vector is not a nonnegative integer")
+        while value:
+            pivot = value.bit_length() - 1
+            if pivot in pivots:
+                value ^= pivots[pivot]
+            else:
+                pivots[pivot] = value
+                break
+    return len(pivots)
+
+
+def rational_rank(rows):
+    """Forward Gaussian elimination over Q; not a modular deficiency test."""
+    if not rows:
+        return 0
+    width = len(rows[0])
+    require(all(len(row) == width for row in rows), "ragged rational matrix")
+    work = [[Fraction(x) for x in row] for row in rows]
+    rank = 0
+    for column in range(width):
+        pivot = next((i for i in range(rank, len(work)) if work[i][column]), None)
+        if pivot is None:
+            continue
+        work[rank], work[pivot] = work[pivot], work[rank]
+        for i in range(rank + 1, len(work)):
+            if work[i][column]:
+                factor = work[i][column] / work[rank][column]
+                for j in range(column, width):
+                    work[i][j] -= factor * work[rank][j]
+        rank += 1
+        if rank == len(work):
+            break
+    return rank
+
+
+def determinant(rows):
+    """Bareiss determinant with exact divisions and explicit row swaps."""
+    n = len(rows)
+    require(all(len(row) == n for row in rows), "determinant matrix is not square")
+    if not n:
+        return 1
+    work = [list(row) for row in rows]
+    previous, sign = 1, 1
+    for column in range(n - 1):
+        pivot = next((i for i in range(column, n) if work[i][column]), None)
+        if pivot is None:
+            return 0
+        if pivot != column:
+            work[column], work[pivot] = work[pivot], work[column]
+            sign = -sign
+        value = work[column][column]
+        for i in range(column + 1, n):
+            for j in range(column + 1, n):
+                numerator = value * work[i][j] - work[i][column] * work[column][j]
+                require(numerator % previous == 0, "nonexact Bareiss division")
+                work[i][j] = numerator // previous
+            work[i][column] = 0
+        previous = value
+    return sign * work[-1][-1]
+
+
+def build_model():
+    roots, labels = [], []
+    for i, j in combinations(range(9), 2):
+        row = [0] * 9
+        row[i], row[j] = 3, -3
+        roots.append(tuple(row))
+        labels.append(OMEGA ^ (1 << i) ^ (1 << j))
+    for subset in combinations(range(9), 3):
+        roots.append(tuple(2 if i in subset else -1 for i in range(9)))
+        labels.append(sum(1 << i for i in subset))
+    require(len(roots) == len(set(roots)) == len(set(labels)) == 120, "A8 root inventory")
+    require(binary_rank(labels) == 9, "binary label span is not nine")
+    require(all(sum(row) == 0 and dot(row, row) == 18 for row in roots), "A8 root norm")
+    for i, row in enumerate(roots):
+        for j, other in enumerate(roots):
+            value = dot(row, other)
+            require(value % 9 == 0, "root Gram entry is not integral after rescaling")
+            require(parity(labels[i] & labels[j]) == (1 + value // 9) % 2,
+                    "label/Gram identity")
+            require(parity(labels[i] & labels[j]) == int(i == j or value == 0),
+                    "labels do not represent canonical dense COPY pairing")
+    return {"roots": tuple(roots), "labels": tuple(labels)}
+
+
+def standard_roots():
+    """Standard E8 representatives, with scalar coordinates multiplied by two."""
+    result = []
+    for i, j in combinations(range(8), 2):
+        for sign in (-1, 1):
+            row = [0] * 8
+            row[i], row[j] = 2, 2 * sign
+            result.append(tuple(row))
+    result += [row for row in product((-1, 1), repeat=8)
+               if row[0] == 1 and sum(x < 0 for x in row) % 2 == 0]
+    require(len(result) == len(set(result)) == 120, "standard root inventory")
+    return tuple(result)
+
+
+def canonical(row):
+    return tuple(row) if next(x for x in row if x) > 0 else tuple(-x for x in row)
+
+
+def standard_binding(model):
+    """Rational star isometry; return standard roots in oriented A8 row order."""
+    star = []
+    for j in range(1, 8):
+        row = [0] * 8
+        row[0] = row[j] = 2
+        star.append(tuple(row))
+    star.append((1,) * 8)
+    require(all(dot(x, y) == 4 * (1 + int(i == j))
+                for i, x in enumerate(star) for j, y in enumerate(star)), "star Gram matrix")
+    lookup = {canonical(row): i for i, row in enumerate(model["roots"])}
+    oriented = [None] * 120
+    for root in standard_roots():
+        raw = [dot(root, other) for other in star]
+        require(all(value % 4 == 0 for value in raw), "nonintegral star pairing")
+        inner = [value // 4 for value in raw]
+        total = sum(inner)
+        require(total % 3 == 0, "nonintegral A8 image")
+        image = tuple(3 * value - total // 3 for value in inner) + (-total // 3,)
+        require(canonical(image) in lookup, "standard root missing from A8 alphabet")
+        index = lookup[canonical(image)]
+        sign = 1 if image == model["roots"][index] else -1
+        require(oriented[index] is None, "standard/A8 line map not injective")
+        oriented[index] = tuple(sign * value for value in root)
+    require(all(row is not None for row in oriented), "standard/A8 line map not onto")
+    for i, row in enumerate(oriented):
+        for j, other in enumerate(oriented):
+            require(9 * dot(row, other) == 4 * dot(model["roots"][i], model["roots"][j]),
+                    "standard/A8 isometry scaling")
+    return tuple(oriented)
+
+
+def pair_profiles():
+    for n00 in range(10):
+        for n01 in range(10 - n00):
+            for n10 in range(10 - n00 - n01):
+                n11 = 9 - n00 - n01 - n10
+                a = ((1 << (n10 + n11)) - 1) << (n00 + n01)
+                b = (((1 << n01) - 1) << n00) | (
+                    ((1 << n11) - 1) << (n00 + n01 + n10))
+                if a and b and a != b:
+                    yield (n00, n01, n10, n11), a, b
+
+
+def forbidden(a, b):
+    """Pairs that MUST have scalar intersection rank eight, not an iff edge test."""
+    return bool(parity(a & b) or (
+        parity(a) == parity(b) == 0
+        and (a.bit_count() // 2) % 2 == (b.bit_count() // 2) % 2))
+
+
+def _selected_minor(model, a, b=None):
+    """Use F3 to select standard-coordinate witnesses, then certify over Z."""
+    scalar_rows = standard_binding(model)
+    basis, selected = {}, []
+    for index, (label, row) in enumerate(zip(model["labels"], scalar_rows)):
+        if not parity(label & a) or (b is not None and not parity(label & b)):
+            continue
+        values = [value % 3 for value in row]
+        for pivot, old in sorted(basis.items()):
+            factor = values[pivot]
+            values = [(x - factor * y) % 3 for x, y in zip(values, old)]
+        pivot = next((i for i, value in enumerate(values) if value), None)
+        if pivot is None:
+            continue
+        scale = pow(values[pivot], -1, 3)
+        basis[pivot] = [value * scale % 3 for value in values]
+        selected.append(index)
+        if len(selected) == 8:
+            value = determinant([scalar_rows[i] for i in selected])
+            require(value != 0, "selected minor has zero integer determinant")
+            require(abs(value) & (abs(value) - 1) == 0, "selected minor is not a unit over Z[1/2]")
+            return {"rows": selected, "determinant": value}
+    raise ValueError("no eight-row witness for required character/profile")
+
+
+def make_certificate(model):
+    singles = [{"weight": k, "normal": (1 << k) - 1,
+                **_selected_minor(model, (1 << k) - 1)} for k in range(1, 10)]
+    pairs = [{"counts": list(counts), "a": a, "b": b,
+              **_selected_minor(model, a, b)}
+             for counts, a, b in pair_profiles() if forbidden(a, b)]
+    return {"schema_version": 1, "model": MODEL,
+            "single_types": singles, "forbidden_pairs": pairs}
+
+
+def check_certificate(model, certificate):
+    scalar_rows = standard_binding(model)
+    require(type(certificate) is dict and set(certificate) == {
+        "schema_version", "model", "single_types", "forbidden_pairs"}, "certificate schema")
+    require(type(certificate["schema_version"]) is int and certificate["schema_version"] == 1
+            and certificate["model"] == MODEL, "certificate model/version")
+    singles, pairs = certificate["single_types"], certificate["forbidden_pairs"]
+    require(type(singles) is list and len(singles) == 9, "single inventory count")
+    require(type(pairs) is list and len(pairs) == 100, "forbidden inventory count")
+    expected = {tuple(counts): (a, b) for counts, a, b in pair_profiles() if forbidden(a, b)}
+    require(len(list(pair_profiles())) == 192 and len(expected) == 100, "profile enumeration")
+    seen_single, seen_pair, determinants = set(), set(), []
+    for item, kind in [(row, "single") for row in singles] + [(row, "pair") for row in pairs]:
+        fields = {"weight", "normal", "rows", "determinant"} if kind == "single" else {
+            "counts", "a", "b", "rows", "determinant"}
+        require(type(item) is dict and set(item) == fields, "witness schema")
+        if kind == "single":
+            weight = item["weight"]
+            require(type(weight) is int and 1 <= weight <= 9, "single weight")
+            a, b = item["normal"], None
+            require(type(a) is int and a == (1 << weight) - 1, "single normal binding")
+            require(weight not in seen_single, "duplicate single type")
+            seen_single.add(weight)
+        else:
+            counts = item["counts"]
+            require(type(counts) is list and len(counts) == 4
+                    and all(type(n) is int and 0 <= n <= 9 for n in counts), "profile counts")
+            key = tuple(counts)
+            require(key in expected and key not in seen_pair, "unknown/duplicate forbidden profile")
+            a, b = item["a"], item["b"]
+            require(type(a) is type(b) is int and (a, b) == expected[key], "normal/profile binding")
+            seen_pair.add(key)
+        rows, value = item["rows"], item["determinant"]
+        require(type(rows) is list and len(rows) == 8
+                and all(type(i) is int and 0 <= i < 120 for i in rows)
+                and len(set(rows)) == 8, "minor root indices")
+        require(type(value) is int and value != 0, "minor determinant type/value")
+        for index in rows:
+            label = model["labels"][index]
+            require(parity(label & a) and (b is None or parity(label & b)), "witness support membership")
+        require(determinant([scalar_rows[i] for i in rows]) == value, "integer minor determinant")
+        require(abs(value) & (abs(value) - 1) == 0, "minor is not a unit over Z[1/2]")
+        determinants.append(abs(value))
+    require(seen_single == set(range(1, 10)) and seen_pair == set(expected), "incomplete type coverage")
+    return {"single_types": 9, "valid_pair_profiles": 192,
+            "forbidden_pair_profiles": 100, "nonzero_integer_minors": len(determinants),
+            "determinants_absolute": sorted(set(determinants)),
+            "all_minors_units_over_Z_half": True}
+
+
+def reflection_transport(model):
+    """Check all S9 generators over Z[1/2], without reducing the A8 isometry at3."""
+    scalar = standard_binding(model)
+    lookup = {canonical(row): i for i, row in enumerate(scalar)}
+    root_lookup = {row: i for i, row in enumerate(model["roots"])}
+    for k in range(8):
+        pair = tuple(3 if j == k else -3 if j == k + 1 else 0 for j in range(9))
+        alpha = scalar[root_lookup[pair]]
+        # Numerator of the reflection I - alpha alpha^T / 4.
+        numerator = [[4 * int(i == j) - alpha[i] * alpha[j] for j in range(8)]
+                     for i in range(8)]
+        require(all(sum(numerator[i][t] * numerator[t][j] for t in range(8)) == 16 * int(i == j)
+                    for i in range(8) for j in range(8)), "reflection is not invertible over Z[1/2]")
+        for i, row in enumerate(scalar):
+            product = dot(row, alpha)
+            require(product % 4 == 0, "root reflection quotient is not integral")
+            image = tuple(x - (product // 4) * y for x, y in zip(row, alpha))
+            require(canonical(image) in lookup, "root reflection leaves the fixed alphabet")
+            target = lookup[canonical(image)]
+            label = model["labels"][i]
+            swap = ((label >> k) ^ (label >> (k + 1))) & 1
+            label_image = label ^ ((1 << k) | (1 << (k + 1))) if swap else label
+            require(model["labels"][target] == label_image, "reflection/S9 label action differs")
+            require(all(4 * image[j] == sum(numerator[j][t] * row[t] for t in range(8))
+                        for j in range(8)), "reflection integer transport identity")
+    return {"adjacent_generators": 8, "root_line_transports": 960,
+            "involution_matrix_entries": 512, "denominators_are_powers_of_two": True}
+
+
+def certificate_text(certificate):
+    """Keep each explicit witness on one line so the certificate is reviewable."""
+    import json
+    blocks = ['{', '  "schema_version": 1,', '  "model": ' + json.dumps(MODEL) + ',']
+    for name in ("single_types", "forbidden_pairs"):
+        blocks.append('  ' + json.dumps(name) + ': [')
+        rows = certificate[name]
+        for index, row in enumerate(rows):
+            blocks.append('    ' + json.dumps(row, separators=(',', ':')) + (',' if index + 1 < len(rows) else ''))
+        blocks.append('  ]' + (',' if name == "single_types" else ''))
+    return '\n'.join(blocks + ['}', ''])
+
+
+def support_weight(model, values):
+    require(len(values) == 120, "support vector length")
+    return binary_rank(label for label, value in zip(model["labels"], values) if value)
+
+
+def copy_rank(model, p, q):
+    require(len(p) == len(q) == 120, "factor length")
+    columns = [label for label, value in zip(model["labels"], q) if value]
+    return binary_rank(sum(parity(label & column) << j for j, column in enumerate(columns))
+                       for label, value in zip(model["labels"], p) if value)
diff --git a/research/e8-coupled-coordinate-floor/verify.py b/research/e8-coupled-coordinate-floor/verify.py
new file mode 100644
index 0000000000..880bf3b40f
--- /dev/null
+++ b/research/e8-coupled-coordinate-floor/verify.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Source-bound replay for the coupled E8 COPY theorem.
+
+Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0.
+Checks certify finite premises and constructions; universal assembly is written.
+"""
+
+import argparse
+import gc
+from hashlib import sha256
+import json
+from pathlib import Path
+import sys
+import tempfile
+
+PACKAGE = Path(__file__).resolve().parent
+REPOSITORY = PACKAGE.parent.parent
+sys.path.insert(0, str(PACKAGE))
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def canonical(value):
+    return json.loads(json.dumps(value, sort_keys=True))
+
+
+def source_hashes():
+    result = {}
+    for path in sorted(PACKAGE.rglob("*")):
+        if not path.is_file() or "__pycache__" in path.parts or path.suffix == ".pyc":
+            continue
+        if path == PACKAGE / "RESULT.json":
+            continue
+        require(not path.is_symlink(), "package contains a source symlink")
+        result[path.relative_to(PACKAGE).as_posix()] = sha256(path.read_bytes()).hexdigest()
+    return result
+
+
+def authenticate():
+    pins = json.loads((PACKAGE / "SOURCES.json").read_text())
+    live = []
+    for item in pins["files"]:
+        if item.get("usage") == "input":
+            path = REPOSITORY / item["path"]
+            require(path.is_file() and not path.is_symlink(), "missing or aliased live source input")
+            require(sha256(path.read_bytes()).hexdigest() == item["sha256"], "live source pin mismatch")
+            live.append(item["path"])
+    refs = json.loads((PACKAGE / "REFERENCES.json").read_text())
+    for item in refs["snapshots"]:
+        path = PACKAGE / item["local_path"]
+        require(path.is_file() and not path.is_symlink(), "missing or aliased retained source")
+        require(sha256(path.read_bytes()).hexdigest() == item["sha256"], "retained source pin mismatch")
+    return {"live_input_count": len(live), "live_inputs": live,
+            "retained_pending_source_files": len(refs["snapshots"]),
+            "pending_commit_required_at_runtime": False}
+
+
+def run():
+    sources = authenticate()
+    # Pending-source bytes are authenticated before importing their code.
+    import finite_inputs
+    import factors
+    import independent_model
+    import cut_basis_audit
+    import dimension_audit
+    import partial_fixture
+    import cut_excluded_fixture
+    import neighbor_primary
+    import neighbor_audit
+    import root_low_primary
+    import root_low_audit
+    import a9_strict_fixture
+
+    certificate = json.loads((PACKAGE / "vendor/pr3755/CERTIFICATE.json").read_text())
+    model, roots, finite = finite_inputs.run(certificate)
+    independent_roots, independent_labels = independent_model.root_model()
+    require(tuple(roots) == tuple(independent_roots), "independent root ordering/orientation differs")
+    require(tuple(model["labels"]) == tuple(independent_labels), "independent dense labels differ")
+    primary = factors.run(model, roots)
+    second = independent_model.verify()
+    for field, record in primary.items():
+        other = second["fields"][field]["extension_family"]
+        require(len(other) == len(record["coordinate_family"]) == 8, "fixture inventory mismatch")
+        for left, right in zip(record["coordinate_family"], other):
+            for key in ("k", "terms", "ranks", "costs"):
+                require(left[key] == right[key], "independent sharp construction disagrees: " + key)
+    cuts = cut_basis_audit.verify()
+    partial = partial_fixture.verify()
+    cut_excluded = cut_excluded_fixture.verify()
+    strict_fixture = a9_strict_fixture.verify()
+    relative = neighbor_primary.run(roots, model["labels"])
+    relative_second = neighbor_audit.calculate(include_details=False)
+    require(relative["minimum_nonroot_neighbor_deletions"]
+            == relative_second["minimum_nonroot_neighbor_deletions"] == 27,
+            "independent relative nonroot threshold differs")
+    require(relative_second["minimum_critical_root_mismatch_deletions"] == 24,
+            "relative root mismatch classification boundary")
+    require(relative_second["matching_root_cases"] == 56
+            and relative_second["complement_nonroot_minimum"] == 35,
+            "relative exceptional character coverage")
+    nonroot_low = neighbor_primary.low_weight_run(roots, model["labels"])
+    nonroot_low_second = neighbor_audit.low_weight_calculate()
+    require(nonroot_low["minimum"] == nonroot_low_second["minima"]["nonroot"] == 55,
+            "independent nonroot low-word threshold differs")
+    root_low = root_low_primary.run(roots, model["labels"])
+    root_low_second = root_low_audit.run()
+    require(root_low["minimum_root_weight_seven_neighbor_deletions"]
+            == root_low_second["minimum_deletions_for_root_weight_at_most_seven"] == 29,
+            "independent root low-weight neighbor threshold differs")
+    # Keep one concrete minimizer, not 56 repeated orbit attainers. Bind the
+    # complete lists by canonical digest; calculate() can emit full details.
+    minimizers = relative_second["minimum_nonroot_witnesses"]
+    relative_second["minimum_nonroot_witness_count"] = len(minimizers)
+    relative_second["all_minimizers_sha256"] = sha256(
+        json.dumps(canonical(minimizers), sort_keys=True).encode()).hexdigest()
+    relative_second["minimum_nonroot_witnesses"] = minimizers[:1]
+    edges = relative_second["transport"].pop("root_tree_edges")
+    relative_second["transport"]["root_tree_edge_count"] = len(edges)
+    relative_second["transport"]["root_tree_edges_sha256"] = sha256(
+        json.dumps(edges).encode()).hexdigest()
+    dimensions = []
+    for dimension in range(23, 73):
+        bill, profile, states = dimension_audit.minimum_relaxation_bill(dimension)
+        require(bill == sum(profile) and tuple(sorted(profile)) == profile,
+                "independent relaxed optimum reconstruction")
+        require(bill >= (72 if dimension == 23 else 73), "independent strict dimension screen")
+        dimensions.append({"dimension": dimension, "minimum_relaxed_bill": bill,
+                           "memoized_states": states})
+        gc.collect()
+    require(dimensions[0]["minimum_relaxed_bill"] == 72
+            and dimensions[1]["minimum_relaxed_bill"] == 73,
+            "dimension23/24 boundary controls")
+    math_faults = sum(x["product_fault_controls"] for x in primary.values())
+    math_faults += sum(x["failure_controls"] for x in partial["fields"].values())
+    math_faults += sum(x["failure_controls"] for x in cut_excluded["fields"].values())
+    math_faults += sum(x["failed_product_controls"] for x in strict_fixture["fields"].values())
+    return canonical({
+        "schema_version": 1,
+        "scope": "Finite E8 inputs, exact constructions and source binding; written theorem assembly",
+        "sources": sources, "finite_inputs": finite, "primary_factorizations": primary,
+        "separate_model": {"root_lines": second["root_lines"],
+            "gram_pairing_checks": second["gram_pairing_checks"], "fields": list(second["fields"]),
+            "coordinate_fixtures": 32, "additional_eleven_term_fixtures": 4,
+            "agreement_on_all_coordinate_profiles": True},
+        "actual_basis_cut_audit": {"actual_equality_bases": cuts["basis_count"],
+            "root_character_cuts": cuts["root_cut_count"],
+            "vanishing_membership_and_copy_checks": cuts["vanishing_membership_and_copy_checks"],
+            "false_universal_minimum_basis_controls": {
+                field: data["minimum_basis_countercontrol"] for field, data in cuts["fields"].items()}},
+        "independent_dimension_relaxation": dimensions,
+        "noncoordinate_partial_fixture": partial,
+        "cut_excluded_partial_fixture": cut_excluded,
+        "strict_basis73_copy72_fixture": strict_fixture,
+        "relative_neighbor_threshold": relative,
+        "root_low_neighbor_threshold": root_low,
+        "nonroot_low_neighbor_threshold": nonroot_low,
+        "separate_full_support_stratum_certificate": nonroot_low_second,
+        "separate_root_low_plane_certificate": root_low_second,
+        "separate_relative_kernel_certificate": relative_second,
+        "product_fault_controls": math_faults,
+        "actual_space_contract_controls": sum(x["actual_space_contract_controls"] for x in primary.values()),
+        "package_sha256": source_hashes(),
+    })
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--emit", action="store_true", help="write a local receipt for the exact current sources")
+    args = parser.parse_args()
+    result_path = PACKAGE / "RESULT.json"
+    expected = None
+    if not args.emit:
+        expected = json.loads(result_path.read_text())
+        require(expected.get("package_sha256") == source_hashes(), "receipt source binding differs; explicit re-emit required")
+    # -B prevents cache writes, not reads. Route all package imports through a
+    # fresh empty namespace so direct and Git-free runs use authenticated source.
+    old_prefix, old_write = sys.pycache_prefix, sys.dont_write_bytecode
+    with tempfile.TemporaryDirectory(prefix="e8-coupled-pycache-") as cache:
+        sys.pycache_prefix = cache
+        sys.dont_write_bytecode = True
+        try:
+            actual = run()
+        finally:
+            sys.pycache_prefix, sys.dont_write_bytecode = old_prefix, old_write
+    if args.emit:
+        result_path.write_text(json.dumps(actual, indent=2, sort_keys=True) + "\n")
+    else:
+        # Python container equality identifies True with 1. Preserve JSON
+        # types as well as mathematical counters in the exact semantic receipt.
+        require(json.dumps(actual, sort_keys=True, separators=(",", ":"), allow_nan=False)
+                == json.dumps(expected, sort_keys=True, separators=(",", ":"), allow_nan=False),
+                "semantic replay receipt differs")
+    print("PASS_E8_COUPLED_COORDINATE_FLOOR", json.dumps({
+        "roots": 120, "fields": ["Q", "F3", "F5", "F7"],
+        "actual_equality_bases": actual["actual_basis_cut_audit"]["actual_equality_bases"],
+        "root_cuts": actual["actual_basis_cut_audit"]["root_character_cuts"],
+        "relative_nonroot_threshold": 27, "neighbor_support_limit": 28,
+        "strict_dimension_cases": 49, "noncoordinate_sharp_fixture": True,
+        "receipt_emitted": args.emit,
+    }, sort_keys=True))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (ValueError, OSError, KeyError, TypeError) as error:
+        print("FAIL_E8_COUPLED_COORDINATE_FLOOR:", error, file=sys.stderr)
+        raise SystemExit(1) from error