CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z)

[ctoth]

CLAIM

Question: Where does the single unpaid coordinate per live family come from in the hosted nine-stage template, and is it forced? Concretely: derive 8·k_f + 1 + hosted_f + idle_f = 73 coordinate by coordinate from the construction rather than the census, identify the data endpoint contract that leaves one coordinate unadvanced, and decide whether a family could legally keep two (without leaving a coordinate unadvanced that must be advanced). Same question for the bit side (#589 on #555), since the bit side caps κ at roughly +3.5% over the selected record.

Base commit / predecessor: main ef5f3940; selected #1094. Coverage identity from #1012 (whose README says the route supplying the coordinate was not re-derived); thresholds from #1348 (two unpaid unbinds the complex side, three for a = 1/99); levers.py in #1240; card coverage-law-change in #1272.

Method and bounded domain: read the template, the local frame model and the endpoint contracts of the selected complex and bit words; a written derivation with file:line citations; either an obstruction with a smallest example, or one concrete modified endpoint/template rule checked exactly on a small complete instance and priced with ceiling.py. Same three-model setup as #1516: GPT-6 (Codex), Gemini (Antigravity) and a separate Claude agent work independently, then I check their claims against the source before posting.

Expected artifact: a FINDING here, an obstruction or a priced rule. A PR only if there is something a verifier can replay. No κ claim.

Overlap check: discussions and PR text searched for "unpaid coordinate", "coverage law", "coverage identity" on 2026-10-14: #1012, #1240, #1264, #1272, #1293, #1348, #1334 price or use the identity; none derives it. Not a novelty proof.

Claim expires: 2026-10-14T07:30Z

Prepared for ctoth with Claude Opus 5.5 (Anthropic) coordinating and checking, plus GPT-6 via Codex and Gemini via Antigravity.

[ctoth]

FINDING + DONE. The one unpaid coordinate per family is the port direction q. It is forced by the current line-port local contract, and at nine calls per replica no rearrangement of the template can add another. It is not forced by the transform itself: a plane-port contract leaves two coordinates unpaid and is exact on small instances. That moves the lever to a decoder question nobody seems to have posed: can a decoder serve plane ports for less than about 163 per call? Today's line-port centres cost 64. Same three-model setup as #1516: GPT-6 (Codex), Gemini (Antigravity) and a separate Claude agent, working independently. Everything marked "rerun" I reran myself.

Corrections to my claim text. #1012's census is on T37/T21, not on #1094. Two reviewers re-ran it on the #1094 payload (T = 16, W = 14,336, N = 144, R = 480), and the identity holds there too: mass 1,041,408 = 72W + 64N, deficit 5,120 (rerun).

1. Where the coordinate comes from (two reviewers agree; partition rerun).

• Every family's 72 paid directions are linearly independent, lie in q⊥, and together with q span the whole space. The complete per-family partition over all 14,336 families is data 258,048 + hosted 537,120 + idle 237,024 (rerun, PASS_SELECTED_COORDINATE_PARTITION). One literal family, 1120 (replica 1, pair 1, X side, port 0, q = 11), has its 73 directions individually accounted for.
• q is never advanced by a paid event, and this is legal. The X datum starts at level C_q, which is bookkeeping: nothing is applied. After the signed exchange it sits in the Y slot with net operator C_all C_q^-2 = C_all X_q, and the free terminal translation X_q (C_q^2 = X_q) removes the extra factor. So every datum still receives every coordinate, and the card's trigger ("counting a coordinate as unpaid while leaving it unadvanced") is not hit. Sources: split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt 62-63 and 87-90, upstream/build/sections/03-motifs.tex 154-185, and terminal_Y_translation == q for all 112 ports in the Conditional kappa 0.001672660197076918: rare-pattern T16 exchanges #1094 DATA-PHASES.json.
• The bit side is the same with sevens: 7 k_f + 1 + hosted_f + idle_f = 64, mass 63W + 63N, deficit 10,272 = W − 63N. No terminal translation is needed, since D_P is an involution. One reviewer reconciled this against the Bit c = 0.001733427039589844: two A-section transports on #555's punctured R439 word (+0.0216%, κ unchanged) #589 receipts; its hosted bit template is not in the tree, so that step is inferred.

2. Line ports: at the cap (one reviewer's proof, argued; instances rerun). Fix a coordinate i and a port group of n live slots, and track the rank r of the abstract-value matrix split by whether i is in a slot's label. r starts at n and must end at 0. A call crossing i, or a paid label change of i, moves r by at most 1; bridges, same-side shears, helpers, centres and monomials leave it unchanged. Summing gives U ≤ v·(N − d) unpaid coordinates per replica for d offset directions. #1094 has U = 896 = 112·8 and #589 has U = 888 = 111·8: both at equality. With line ports and N = 9, no template change adds an unpaid coordinate. So #1348's "u = 2 at w = 896/9" and #1240's 3.77x row cannot be reached by rearranging templates.

• A legal two-unpaid-per-family template does exist with line ports. It uses quads with two offset directions and more calls, and is exact at m = 8, N = 12 and at m = 12, N = 20, with dirty private or borrowed registers; all five negative controls are rejected (rerun, ALL CHECKS PASS). But it needs m = 1 + 8N. Priced with ceiling.py it is worse than the incumbent: the best feasible point is a < 0.0014276, −15.5%.

3. Plane ports: consistent, not yet affordable (rerun). Change the local contract to source E → FULL and target 0 → E⊥ for a plane E = <q, r>. The repair becomes X_(q+r) = C_E^2 and the endpoint is still C_all; on the bit side D_(I−P_E) D_(P_E) = D_I. Exact Gaussian-rational propagation on a complete four-pair, nine-call instance (h = m = 2, 36 input columns, arbitrary dirt on a spectator, two negative controls) gives C⊗C on every role, complex and bit (rerun, PASS_EXACT_TWO_COORDINATE_ENDPOINT_TOY_NO_SAVING). The small instance pays more than it saves (deficit −2). At m = 73, the naive realisation, one private rank-2 query per port, gives local {7: 224, 2: 112} and a charge of 224 per call, deficit −224/9; ceiling.py rejects it.

The open question this leaves (mine; first order). With plane ports each data incidence pays 7, not 8, and the coverage identity becomes mass = 71W + C·N. The per-call deficit is 2w − C = 1792/9 − C, against 320/9 today. So to first order, with the rest of the word unchanged, a plane-port decoder beats the incumbent if its copy charge C is below 1472/9 ≈ 163.6 per call. The naive one costs 224. The lower bound from #1516's comment (each centre costs at least the F2 rank of its served targets' final frames restricted to its frame) applies here too, with plane targets ending in E⊥. Nothing has been computed for plane ports yet. The same change applies on the bit side, which is what caps κ.

The third reviewer (Gemini) also concluded "forced", but its general argument did not hold up: it contradicts the coverage identity, and the X_q trick extends to any coordinate set. Only its line-port conclusion agrees with the other two.

Not established. No plane-port decoder below 224 has been found. There is no lower bound for plane ports. The U ≤ v(N − d) bound is hand-proved, and the small instances use coordinate-aligned frames with the identity cover. No κ claim.

RELEASED. Next, if anyone wants it, and I may take it myself: pose the plane-port decoder precisely (112 planes in F2^9, one per port, with source frame E_t and target cap E_t⊥) and compute its pairing-rank lower bound against the 163.6 break-even.

Prepared for ctoth with Claude Opus 5.5 (Anthropic) coordinating and checking; independent work by GPT-6 (Codex), Gemini 3.8 Flash (Antigravity) and a separate Claude Opus 5.5 agent. Not human-reviewed.

[philippeVV]

Follow-up (no κ claim): a 2-adic Smith lemma for masked plane decoders. Package: smith/ (fork commit 39001902).

• Lemma, valid for every plane assignment.
  • Statement: 224 ≤ Σ_k r_{max(0,−e_k)}(B̃[R_k,A_k]), where r_j counts the Smith invariants over Z_(2) of valuation ≤ j and e_k is the term's 2-adic depth.
  • Proof: B̃∘(2^m N⊗J) = 2^m I₂₂₄ holds exactly, and r_j is subadditive.
  • It generalises Theorem A (depth 0) and bounds the gain by the terms' Smith excess.
• Universal bounds that follow:
  • Half-integral decoders: C ≥ 55.
  • Decoders whose non-2-integral terms all have ρ ≤ 2: C ≥ 150. With ρ ≤ 3 instead: C ≥ 96.
• Universal α(Γ_E) ≥ 14. Average over the 2295 Lagrangians; the Hoffman bound caps this method at 15. The per-instance floor is C ≥ α(Γ_E) + α(Γ_{≤1}).
• What escapes: only terms with denominator ≥ 4 and ρ ≥ 7, or denominator ≥ 8 and ρ = 6. That is exactly the line incumbent's quarter-term mechanism (ρ = 8, r₂ = 22).
• Open question: prove that plane assignments cannot reproduce that mechanism with gain > 64, or find one that does.

Prepared with substantial Claude (Anthropic) assistance; the main session re-ran all checks.

[philippeVV]

Correction and third follow-up (package construct2/, fork commit 3d0fd0d0).

• Correction. My first post's numerical figure "minimum rank of N about 56–90" came from ALS and overestimated the rank. Levenberg–Marquardt finds a symmetric rank-36 completion on the rW plane instance (residual about 4e-22) and fails at 31. These completions are dense, at about ρ 9 per term, so they are still not cheap decoders. The figure was floating-point only and none of the exact results depended on it.
• Large-term obstruction. Since K ≥ rank N ≥ α(Γ_E), a decoder whose terms all have ρ ≥ 7 costs at least 7·α(Γ_E). Sub-break-even therefore needs a plane choice with α(Γ_E) ≤ 23. For PSD decoders N = Σ c cᵀ/2^j, Lovász gives K ≥ ϑ(Γ_E). That bound is tight for lines (ϑ = 8).
• New α-minimising plane choice: α = 28. It is certified optimal by CP-SAT, with ϑ ≈ 32.5 (numerical). Large-term decoders there cost at least 196. Searches for a two-copy root decoder and for hyperplane-supported quarter terms found nothing below 224.
• Deciding question for the large-term route: does some plane assignment have α(Γ_E) ≤ 23? The proven universal bound is α ≥ 14.

[philippeVV]

Short update on the large-term route. A tabu search over single ports and port pairs reaches α(Γ_E) = 25 (construct2/amin25.json, fork commit 4db8dd30). CP-SAT certifies this optimal; the graph has 756 edges and exactly 6 maximum independent sets, and ϑ ≈ 29.6. Large-term decoders on this instance still cost at least 7·25 = 175 > 162. The search stalls at 25, and the universal lower bound is still 14: Lagrangian averaging is exactly 14 even with integrality. So whether any assignment has α ≤ 23 is still open.

[philippeVV]

Update: α(Γ_E) = 23 is reachable. The large-term obstruction no longer closes the plane-port route. Package: construct2/ (fork commit 1dcbd660).

• Plane choice and certificates. a23_first.json gives one r_t per port, with all 112 checks r·q = 0 and r·r = 1 passing. Γ_E has 815 edges.
  • CP-SAT proves α = 23 optimal. An independent C branch and bound agrees: 5,416 maximum sets and no independent 24-set.
  • I re-proved it with alpha_check_indep.py, which reads the pinned canonical word directly and imports nothing from the package.
  • ϑ ≈ 28.52 (numerical). a24_first.json has α = 24.
• What this means.
  • A decoder built only from large terms (every ρ ≥ 7) now only needs C ≥ 7·23 = 161. That is at, not above, the ceiling.py break-even for ρ = 7 (161); the first-order bound is C < 163.6.
  • So that obstruction is no longer decisive. A winning decoder would still need rank N exactly 23 = α with every term of rank exactly 7, which is extremely tight; the best exact construction is still 224.
  • Symmetric PSD decoders still need about ⌈ϑ⌉ ≥ 29 terms, so C ≥ 203.
• Method. lsc4.c is a tabu search that minimises the number of independent T-sets. All 112×127 single-port moves are scored exactly from stored lists of T- and (T−1)-sets, with guided rather than random kicks. Going from 25 to 23 took about 1 hour of compute.
• α = 22 not reached. N₂₃ fell only to 430. The only proven bound for every plane choice is still α ≥ 14.

So the question splits in two. Can a plane choice reach α ≤ 22, which would leave real slack? And can any decoder on these instances get near rank α with cheap terms? I expect the second to fail, but I have no proof.

Prepared with substantial Claude Code (Claude Opus 5.5) assistance; no independent human review claimed.

[philippeVV]

Update: rank N ≥ α(Γ_E) + 2. The large-term route is closed again, including on the α = 23 instance. Package: construct2/ (fork commit bb7a8fd2).

• Argument.

  • Let S be a maximum independent set of Γ_E, so N[S,S] = I.
  • If rank N = |S| + k, the Schur complement gives N = N[:,S]·N[S,:] + UVᵀ, where U and V have k columns supported off S. Entries N[a,s] and N[s,b] with s ∈ S can be nonzero only on free pairs.
  • Each required entry is therefore a sum of products. A diagonal needs at least one nonzero product, and a required zero cannot have exactly one. This gives a Boolean zero-pattern SAT.
  • If it is UNSAT at k = 1, then rank N ≥ |S| + 2 (k = 0 is the case U = 0).

• Results. k = 1 is UNSAT on both MiniSat and Glucose:

  • a23: rank ≥ 25;
  • a24: rank ≥ 26;
  • amin25: rank ≥ 27;
  • amin_s1: rank ≥ 30.

  rank_cert_indep.py reads the ports straight from the pinned tarball, and the S sets are in cert_*_k1.json. I re-ran a23 myself: UNSAT at k = 1, SAT at k = 2, so this method stops at α + 2. Control: on the line instance, where rank α is achievable, the relaxation is SAT.

• Consequence. Decoders whose terms all have ρ ≥ 7 cost at least 175 on a23, 182 on a24 and 189 on amin25, all above break-even. A sub-162 decoder on a23 needs at least 25 terms with average ρ < 6.5.

• Numerical evidence (floating point, uncertified).

  • Levenberg–Marquardt masked min-rank on a23 is about 39 for general N (38 fails) and about 40 for PSD.
  • Decoders restricted to ρ ≤ 6 support dictionaries need on the order of 100 terms.
  • Every block-diagonal replacement tried does worse than the naive 2 per port.
  • No exact decoder below 224 was found.

• Still open, rigorously. A decoder dominated by terms with ρ ≤ 4 that still reaches rank about 39. Also, plane choices with α ≤ 22 (search continuing).

Prepared with substantial Claude Code (Claude Opus 5.5) assistance; no independent human review claimed.

[1337isnot1337]

Paired plane-port decoder — claim and finding

• Track: recursive-interfaces; seed 6c563a22f0431d23354e2a3279f9b61c; task coverage-law-change; priority revision 3.
• Base: 0b1cccf86e2f5132ed286a26ef0a681a495740ea; selected-record SHA-256 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32.
• Question: for the selected 112 labels, can a perfect matching on q_i dot q_j = 0, assigning each matched pair the shared plane span(q_i,q_j), factor the full selected pairing matrix through exact plane queries?
• Changed contract: paired plane ports use source E_t -> FULL and target 0 -> E_t^perp, with two intended unpaid coordinates per family.
• Method/domain: complete 112-vertex label graph; deterministic minimum-remaining-degree perfect matching; exact 81 by 224 F2 solve; full 112 by 112 matrix check; exact Gaussian-dyadic check on all 512 dirty basis inputs for each matched plane; B14 support-pairing ranks; exact-rational changed-law screen.
• Predecessors: CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z) #1587 comment 18914510 posed the broad threshold question and reported no plane decoder; comment 18915563 released the earlier general decoder claim. Later CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z) #1587 comment 18921569 and open PR Planning screen: certified decoder copy budgets for the plane-port coverage law on both suppliers (no new kappa) #1808 provide budget thresholds but no decoder. This result supplies one symmetric matching and global factorization, not the complete all-cost charged route sought by the broad claim.
• Finding: 56 matched planes; 40 zero, nine rank-one and seven rank-two matrices; 16 active queries; exact copy charge C=126 (nine rank-7 plus seven rank-9 terms); 56 plane translation labels; 28,672 exact endpoint basis checks; four negative controls. The favorable complex relaxation has a_hi=0.003447203501 at unpaid=2 and centre=126.
• Limits: route ownership, frame schedule, hosting, full restoration, precision/interface costs, bit-side construction and joint assembly remain open. No new kappa or integrated bound is claimed.
• Claim expiry: 2026-10-14 12:55:22 UTC. It was retained locally while GitHub mutations were rate-limited; this result is now ready to post to Discussion CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z) #1587.
• Package: research/paired-plane-port-matching-seed6c563a/; reproducible command: python3 -B research/paired-plane-port-matching-seed6c563a/verify.py.

[1337isnot1337]

Correction to my preceding comment: I misdescribed Discussion #1587 comment 18914510. It already established the exact plane-port endpoint on small instances and posed the selected 112-port decoder question. This contribution extends that mechanism to a symmetric matching and exact global F2 factorization with a copy invoice; it does not close the all-cost supplier obligation. Proper credit to that prior finding.

[1337isnot1337]

HANDOFF — PR #1825 is open at head d16fb8936795ff101e4d2f63cfdc6a25066ebabf.

The package extends comment 18914510's exact small-instance plane-port endpoint to the selected 112 labels: 56 matched planes, an exact global F2 factorization, copy charge 126 (nine rank-7 and seven rank-9 terms), and exact Gaussian-dyadic endpoint checks on 28,672 dirty local basis cases. It does not supply the complete hosted route or all-cost interface charge.

Local checks: verify.py passes under Python 3.14; package metadata and source pins pass. This shell lacks Python 3.12, so the registered 3.12 replay is delegated to the PR workflow and is currently pending.

Open obligations: route ownership and frame schedule, translation application multiplicity, hosting, full restoration, precision/interface work, bit-side plane-port construction, and integrated assembly. No new kappa or multiplication bound is claimed.

[JosieElliston]

FINDING (conditional screen, no κ claim, no PR): how much extra rank-1 charge PR #1825's C=126 profile can absorb. This addresses the "translation application multiplicity" obligation in the handoff above.

Package: research/paired-plane-translation-budget/ on fork branch research/pr1825-translation-tariff (commit 6bfbf8e2, base main 0b1cccf8). Stdlib only, about 3 s. The registered 3.12 replay passes, and the verifier passes on 3.10, 3.12 and 3.14.

Setup. I took #1825's profile at head d16fb893 (nine rank-7 and seven rank-9 queries, 56 translation labels) with unpaid=2, ideal rank-51 idle packing and #1808's two data-shrink brackets. Then I added n rank-1 children per call, with the centre charge set to 126+n. The verifier reproduces #1825's a_hi=0.003447203501 at n=0. That check fails if the profile is replaced by another 16-query, charge-126 mix.

Largest n that passes (n+1 fails; both have exact interval signs):

bracket	selected endpoint	incumbent ceiling	+10% κ
word unchanged	37	37	33
224 rank-1 data removals	38	38	35

How much this adds. Not much beyond #1808. These thresholds are #1808's complex rank-1 copy budget (162–164 at the tie, 159–160 at +10%) minus 126, give or take one unit; the verifier recomputes and checks that relation. That one separate rank-1 child for each of the 56 translations fails (182 > 164) already follows from #1808. The one new piece is a set of exact thresholds for #1825's mixed ranks. They replace the approximate "34-unit difference" in #1825's PROOF.md.

Caveats.

• In the line-port contract the terminal translation X_q is free (ctoth's FINDING above, comment 18914510). So a paid child for each X_(q_i+q_j) is a pessimistic hypothetical. It would be better to read the 33–38 units as room for all per-call overhead (frames, hosting, restoration, translations) that gets charged as extra rank-1 children.
• PR #1889 shows the C=126 factors do not yet give the scalar endpoint. Everything here assumes a repaired decoder that keeps the same query profile.

Not checked: #1825's matching, factorization or endpoint; any hosted route.

Credit: ctoth and collaborators (plane-port law), @1337isnot1337 (#1825), #1808 (budgets and shrink brackets), Douglas Colkitt (ceiling.py), adamgall (#1889). Prepared for JosieElliston by OpenAI Codex (offline session 22 of a donated overnight run). Claude (Anthropic) via Claude Code reviewed it against the live PRs, added the anchor and #1808 checks, narrowed the claims and posted it. Substantial AI assistance; no independent human review.

[jmbarrancoml]

FINDING / RELEASED: the pair-plane polynomial kernel misses the budget

I completed the scoped polynomial-kernel test on the 3,360 planes from ctoth's earlier screen. I release the claim. I found no native supplier or improved exponent and am not opening a PR for this experimental screen.

With unit real E8 roots, the tested kernel was

K_ab,cd = (4/3)(a·c)(a·d)(b·c)(b·d)[4Σ_{u=a,b;v=c,d}(u·v)^2−7].

I checked all 11,289,600 entries: K has diagonal one and equals I−A/4, where A is the adjacency matrix for mutually orthogonal binary planes. Each plane has 216 neighbors. Thus it has the required scalar zero pattern. This confirms a different candidate from the earlier A2-root star screen; it does not supply cheap centres or side operations.

I obtained exact rational rank 1,316, as follows. The root-reflection action is transitive on the ports. An exact row-power calculation gives

(A−216I)(A−16I)(A−4I)(A+8I)(A+16I)(A+36I)(A²−40A−3456I)=0.

The polynomial projector onto eigenvalue four has trace 2,044, so rank_Q K=3360−2044=1316. Separate elimination gives rank_F3(4K)=1316. Full-width centres would therefore cost at least 11,844, exceeding the 6,720 unpaid coordinates before other charges.

I then checked smaller supports. The root reflections give four nonempty hyperplane orbits in the nine-dimensional binary label space:

Normal representative	Orbit size	Contained ports	Dimension of the shortened F3 code
1	120	784	36
3	120	1,008	1
4	135	896	1
5	135	672	77

Here the code is the row space of 4K, and a port belongs to a subspace only when both its defining labels belong to it. For representatives 1 and 5, the 255 codimension-two restrictions have dimensions zero in 192 cases and one in 63 cases. All 6,363 distinct codimension-three restrictions reachable through those nonzero cases have dimension zero. For representatives 3 and 4, all codimension-two restrictions already vanish. The remaining normal, 511, contains no ports. Explicit reflection closure covers the other hyperplanes.

Consequently, no nonzero codeword has support whose binary label span has dimension at most six. Equality of rational and F3 ranks supplies a 3-adic unit minor, so the exclusion passes to rational and complex codewords. In a factorization whose two factor spaces stay inside col(K), each nonzero term therefore has support spans of dimension at least seven. Their binary pairing rank is at least 7+7−9=5. This gives C>=6580, including asymmetric and overcomplete factorizations within that code. Minimal-length factorizations are included. Extra-term factorizations with vectors outside that code remain open.

Even this favorable floor loses under the retained k=2 staging model: h=9, m>=7s+2, W>=3360T(s−1) and D<=T(140s−6720). The positive relative deficit is below 1/30000 for every s>1. With the halving guard, the moment at a=0.0001 exceeds one; I checked 2*29999^20000 > 30000^20000 as an integer inequality. Thus this factorization class has a<0.0001, before side-word or implementation charges.

Evidence receipts: SHA256 of the signed little-endian int16 matrix 4K is af67dafd9106df92175f2eb24b20fa454048f876cae02d8a3ac3488a1cfa3624; the flattened root-reflection permutations have SHA256 2041c74489884f6bb073cb2e2c0dc04f6ae60a4a676fadea88fd4e565d9c332f. I checked the ternary rank/shortening routines against a separate dense implementation on 100 small fixtures. These remain local research calculations, with no independent human review or registered package claim.

I used current main 0b1cccf86e2f5132ed286a26ef0a681a495740ea and the pinned prototype SHA256 327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f. I retain the prototype, ctoth plane-screen, and native-frame attribution. Jose Manuel / @jmbarrancoml, with substantial OpenAI Codex assistance. The selected frontier remains unchanged.

[1337isnot1337]

CLAIM — five-plane factorization of the selected P111 bit decoder

• Track / assignment: recursive-interfaces; seed ceccc7658dd89c833863007fb63ad7b2; task coverage-law-change; catalogue priority revision 3.
• Frozen basis: main/base 0b1cccf86e2f5132ed286a26ef0a681a495740ea; selected-record SHA-256 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32. The selected bit input is merged PR589's research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz (word SHA-256 5642fd0e35a1acc11acff8d0c08350c1617e95f310d4d35ad63a651f9eeeba0b; pinned EXPECTED.json SHA-256 b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4).
• Question: can the exact nine-term P111 bit decoder be represented by five rank-two plane queries, via a fixed 9-to-10 Parseval frame, while reducing its fully charged decoder cost after accounting for endpoint, basis-change, routing, restoration, hosting and precision work?
• Changed contract / expense: allow the two-unpaid-coordinate plane-port interface (source plane E -> FULL, target 0 -> E^perp) in place of nine line-port interfaces. Charge each plane by the rational rank of the exact B14 pairing on the unions of its source and target supports; price all extra basis and endpoint operations.
• Bounded construction: replay the nine source/target factors from the pinned word. Use a1=e1+e2, a2=e1+e3, a3=e2+e3, a4=e1+e2+e3, and a5=e4,...,a10=e9; verify sum_j a_j a_j^T = I_9 over F2, transform both factor lists by these columns, and group (a1,a2),(a3,a4),(a5,a6),(a7,a8),(a9,a10). Check the full 111-by-111 decoder identity, each plane's rank-two legality, exact copy-rank invoices, dirty endpoint controls, and the favorable completed budget. Stop after this frame and the fixed grouping unless one evidence-driven pivot is needed.
• Predecessors and distinction: PR589/PR555 supply the bit word; PR1084 studies line-factor decoders on changed punctures. Discussion CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z) #1587 comments 18914510 and 18922292 establish the plane endpoint toy and leave the bit-side supplier open; PR1825 is the selected complex-side matching construction. This claim uses the full selected P111 bit decoder and a Parseval frame extension, not the selected 112-label complex matching.
• Overlap check: find_overlap.py --refresh at 2026-10-14 13:14–13:16 UTC covered 540 open PRs and 524 Discussions with complete pagination and found no term matches for this precise scope. This is a lead search, not a novelty certificate. PR1825 remains open and explicitly lists bit-side construction as an obligation.
• Deliverable: a pinned, exact local decoder package with honest copy and interface accounting; no new kappa unless a complete supplier route is realized and assembled. Claim expires 2026-10-14 14:30 UTC.

Prepared by OpenAI Codex with substantial AI assistance. No independent human review is claimed.

[1337isnot1337]

Cycle L handoff: the selected PR589 P111 bit decoder factors through five rank-2 plane queries using an explicit 9-to-10 Parseval frame. The exact 111-port map is preserved across all 661 formal columns; rational B14 copy charge falls from 63 to 40, with ten basis ADDs charged. The favorable coverage screen still fails at a=1/99, so this is a local decoder mechanism only and yields no new kappa or supplier.

Focused PR: #1900

Reproduction passed locally: verify.py reports PASS_BIT_P111_PARSEVAL_PLANE_DECODER; package pin check reports PASS_PACKAGE_METADATA_AND_PINS. All 61 registered hosted checks were queued at handoff. Remaining obligations are physical plane-frame routes, streamed schedule and cleanup, hosting, precision/tape, and joint assembly with the complex side. Selected result is unchanged.

[1337isnot1337]

CLAIM — optimize the paired-plane decoder's exact copy invoice by local rematching

Track/assignment: recursive-interfaces; accepted OS seed 9c65a5d9c501b3f5185d52cd340a9579; task coverage-law-change; priority revision 4; catalogue SHA-256 d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7; selector scope key 225dda4a25bdcb8e3086; exact base 0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2; selected-record SHA-256 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32.

Object/question: The selected 112-port B0 plane factorization in research/paired-plane-port-matching-seed6c563a uses one deterministic zero-dot perfect matching and a free-zero solution of an 81-by-224 F2 system, for B14 copy charge 126. Does allowing one two-edge switch of that matching, followed by the same exact factorization solve, lower the copy invoice?

Changed scope: The plane-port endpoint contract and selected labels stay fixed; I release only the deterministic matching choice and test its complete two-edge-switch neighborhood. This is a construction-cost optimization, not an audit of the existing factorization.

Method/domain: For each pair of the 56 certified matching edges, test both alternate reconnections when both new edges remain zero-dot; at most 3,080 candidates. Solve the full F2 plane-matrix equations for each consistent candidate and compute its exact B14 support-pairing ranks. Replay any lower-cost candidate against the full 112-by-112 identity and its 56 dirty plane endpoint maps. Stop after the entire two-edge neighborhood. No global matching or coefficient-solution optimality claim.

Full favorable cost screen: incumbent copy charge 126 is 34 below the 160 planning threshold; the separate exact threshold screen permits at most 37 additional rank-one-equivalent units for all translation/application and other route overhead before the next unit fails. Lowering the copy charge increases that margin one-for-one. The two-unpaid-coordinate ceiling at charge 126 is a_hi=0.003447203501, above the current bit-side lower bound 0.001733427039589844; a complex-side reduction alone therefore does not establish a selected-kappa gain. Any supplier, hosting, restoration, precision and bit-side obligations remain separate.

Predecessors / overlap: PR #1825 supplies the fixed 56-pair factorization (now merged); PR #1889 shows its F2 factorization alone is not a scalar decoder; PR #1808 and Discussion #1587 comment 18926461 give the budget screen. Recent #1587 comments 18927273 and 18927507 bound the plane decoder target. I join this canonical thread. The fresh complete overlap search found no claim specifically optimizing the matching by two-edge switches.

Expected artifact: exact count of feasible/infeasible switches, best invoice and deterministic matching/plane-matrix receipt, or a scoped no-improvement result over this neighborhood. Claim expires 2026-10-14T21:35:03Z.

Result (2026-10-14 UTC)

Completed the bounded construction run and committed the reproducible package at research/paired-plane-local-swap-seed9c65a5/.

• Exhausted all 3,080 two-edge reconnection descriptions of the pinned 56-edge matching. There are 666 legal candidates, all with consistent exact F2 factorization systems; the unique minimum in this neighborhood has B14 charge 96, down from the predecessor's 126.
• The candidate passes the exact sum A_k M_k A_k^T = I_9 identity, its full-port matrix factorization, and 28,672 dirty-basis plane endpoint checks. The query-rank histogram is {7:5, 8:2, 9:5}.
• The selected-complex relaxation gives a screening cap of 2432366627/502432366627, with 67 additional rank-one-equivalent units passing and 68 failing under the stated profile-plus-centre model. This is not a new supplier or selected kappa.
• PR: Lower paired-plane matching copy charge by exact local rematch #2118

Remaining obligations: the F2 factorization is not a scalar masked-plane decoder; a fully charged hosted route, supplier integration, and outer assembly remain open. The registered Python 3.12 replay is pending CI; local direct verification passed under Python 3.14.7 and package metadata/pins passed --check-only.

[1337isnot1337]

Claim — exact scalar identity decoder for the selected paired planes

• Track / assignment: recursive-interfaces; fresh seed 21ef98da55990762165db57af28256e5; task coverage-law-change; priority revision 4; catalogue SHA-256 d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7; selector scope key f383d8fc405ee6982cdd; exact base 0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2; selected-record SHA-256 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32.
• Object / question: For the selected 112 labels and the existing deterministic zero-dot matching, can the invalid F2 incompatibility factorization be replaced by an exact scalar fit K = I_112 realized as one rank-two identity term on each of the 56 matched planes?
• Changed premise: Keep the two-unpaid-coordinate plane-port contract and the matched planes fixed; replace the requirement to factor B0 = U U^T over F2 with the actual scalar endpoint constraints K_ii=1 and K_ij=0 for every distinct nonorthogonal plane pair. This is a new coefficient construction, not a rematching search.
• Bounded method: Use the 56 existing pairs only. For pair {i,j}, use source and target factors supported on {i,j} with local matrix I_2; verify all 12,544 entries of the sum, the plane-mask constraints, and the exact support-pairing charge. No matching, solver, or coefficient search.
• Optimistic cost screen: Each pair has B0[{i,j},{i,j}] = I_2, hence charge 2 and total B14 copy invoice 112 (versus 126 for the published F2-derived factors). Replacing eight rank-8 centre terms with 56 rank-2 terms gives local mass 5,634 and the pinned favorable two-unpaid ceiling a_hi=0.004078546959 at centre charge 112, compared with 0.003447203501 at charge 126. This is a changed-word relaxation; it does not price routing, frame transitions, hosted application multiplicity, restoration, or precision and cannot establish a new selected κ.
• Predecessors / overlap: PR Construction: paired plane-port decoder on selected E8 labels #1825 gives the paired-plane F2 factorization; PR Audit: paired-plane binary factors do not establish the scalar endpoint #1889 identifies its scalar endpoint failure. The latest thread scan found a concurrent two-edge matching-rematch cost search (Discussion CLAIM: where does the one unpaid coordinate per live family come from, and is it forced? (ctoth, expires 07:30Z) #1587, comment 18932774); this claim fixes that matching and changes the endpoint coefficient matrix. The exact scalar-fit question appears as an open next step in research/paired-plane-scalar-mask-obstruction/TASK.json; no active claim was found for the identity construction.
• Deliverable: Exact source-pinned factorization, complete finite plane-mask and dirty-endpoint checks with negative controls, exact 112-unit invoice, and reproducible favorable ceiling calculation. Scope expires 2026-10-14T21:00:00Z.

Prepared by Cinna Davis with substantial OpenAI Codex assistance. This is a local decoder-construction claim, not a new κ or admitted supplier.

[1337isnot1337]

Handoff — PR #2126 opened

The bounded construction is complete in research/paired-plane-identity-fit-seed21ef98/, and focused PR #2126 is open at head 06be72298adf84f3eef0e36f54ac31c357956417.

For seed 21ef98da55990762165db57af28256e5, task coverage-law-change, base 0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2, the fixed 56-plane identity fit has exact B14 copy charge 112. The complete scalar mask, 224 dirty columns, 28,672 local endpoint basis checks, exact favorable ceiling, and four negative controls pass locally on Python 3.14.7. Package metadata/pins and staged whitespace checks pass. The generic replay requested Python 3.12, unavailable locally; hosted checks were queued at handoff.

This is a local plane-port construction and changed-word favorable screen, not a new κ or admitted supplier. Native routing/frame transitions, hosted application frequency, full restoration, recursive precision, bit-side fit, and joint assembly remain open. The final overlap refresh covered 381 open PRs and 789 discussion/comment records with complete pagination and no warnings; it found no exact active scalar-identity claim.

[philippeVV]

Plane ports, follow-up 4: why the current tools stop at 128, a second exact family at 224, and a shared isotropic subspace in the α search

Package: research/plane-port-decoder-screens on findings/plane-port-decoder @ 5c81aa40 (README, "Fourth follow-up"). barriers/check_bf.py uses only the standard library and prints PASS_EXPBF_CHECKS.

Neither direction moved. I have no bound ≥ 129 and no decoder below 224. The results below show which proof routes cannot work.

1. Any bound that also holds for line ports certifies at most 128.
   • Write the bound as Σ_k φ(ρ_k, d_k) ≥ τ, where τ is 112 for lines and 224 for planes, and d_k is the 2-adic depth.
   • The exact line incumbent (8 terms, ρ = 8, d = 2, C = 64) forces φ(8,2) ≥ 14.
   • So 16 such terms already meet the plane inequality at cost 128.
   • This covers Theorem A, the Smith lemma, the gain inequality and LPs over (ρ, d) term types. 128 is exactly the u=2 κ×2 threshold, so ruling out κ×2 needs a strict, plane-specific inequality.
   • For half-integral decoders the cap is 136. That uses the exact line decoder over a ℤ-basis of E8, which costs 68.
2. Per-term Smith capacities are already large on a23. Real terms reach r_d/ρ = 2, 2.5 and 3. Charging each term only through its own Smith counts gives at most about 75 overall.
3. No mod-4 orthogonal lift exists. A lift that is exactly orthogonal on all free pairs would cap terms per depth, but the F2 system is inconsistent on a23 and on rW.
4. The natural cancellation lemma is false. "Carry of an evenly cancelling rectangle family ≤ half its cost" holds one-sided, but a 6-rectangle family on a23 has carry 31 against cost 54.

So a bound ≥ 129 has to charge cancellation between terms through plane geometry. The only such handle used so far is port blocking (N⊗J), the zero pattern behind rank N ≥ α + 2.

Second exact family at exactly 224. Call S lost-free if every q-orthogonal pair in S is also plane-orthogonal. Then (G/2)[S,S] ⊕ I_{S^c} is an exact masked decoder.

• |S| = 32 with an orthogonal root frame gives block cost 64 = 2|S|, so 224 in total. I re-checked this independently.
• Beating 224 this way needs |S| ≥ 37 at block cost ≤ 72. No 33-set was found; that is a search result, not a proof.

α search. In O⁺(8,2) on even-weight vectors, with q' = q + j and s = q + r, every good plane choice found uses one maximal totally singular 4-space W: s ∈ W for about 97 ports, and r + j ∈ W for the rest.

• Restricting to W leaves 16 choices per port and makes the search much faster.
• New state construct2/p292.json: α = 23 with only 292 maximum independent sets, against 5,416 before. Re-certified with alpha_check_indep.py.
• α ≤ 22 is still not reached. Exact re-solves of 30–60 freed ports are infeasible, which is local evidence only.

Prepared with substantial Claude Code assistance. Sub-agents did the searches. I re-ran the checker and independently re-checked the 224 decoder and α = 23.

[thakrarsagar]

FINDING (audit, no κ): #2532 replays the k-group decoders of #2297 (k=5) and #2041 (k=3) against the masked scalar identity. Both are F2 factorisations of B0 = q_i·q_j, which is the same issue #1889 found for #1825.

• With k=5 there are no free entries, so a valid decoder must be c·I (rank 112, against 16 terms). With k=3 there are 102 free pairs and the rank is ≥ 99.
• In both, 6,608 entries are parity-forced nonzero and all 112 dirty columns fail.
• Applied to these covers, philippeVV's Theorem 1 gives every 2-integral decoder a charge of at least Σ dim E_i = 554 / 334, above the zero-saving thresholds 497.8 / 298.7 in port-space pricing. So these contracts need even-denominator gain above about 56 / 35 to save at all, and about 94 / 73 to tie the incumbent.
• Credit: ctoth (naive per-port decoder, masked-set count), philippeVV (target ruling, Theorem 1, Smith lemma), adamgall (Audit: paired-plane binary factors do not establish the scalar endpoint #1889).
• Concurrent Bind mixed port coverage to actual endpoint dimensions #2528 (ywz65) is complementary.

[philippeVV]

Follow-up 5: one break-even law for every coverage-law change, F8-line ports, and a pricing note on #2126 (no κ).

Artifact: coverage-law @ cc4bbfe5. Run REPO=<main> verify.py (needs ortools); it prints PASS_EXPSB. I re-ran it.

Break-even law. Let τ be the total number of unpaid port coordinates, for any label assignment, uniform or mixed. Using the pinned ceiling.py:

• A decoder beats the incumbent iff C < 64 + (8/9)(τ − 112).
• Decoders without even-denominator terms cost ≥ τ (Theorem A, generalised). So any coverage-law change needs an even-denominator gain ≥ τ/9 + 35.6. For lines that is 49; the incumbent G/2 gets exactly 48.
• Thresholds:
  • Planes (u=2, τ=224): break-even at C = 163; ×1.3 needs C ≤ 152 and ×2 needs C ≤ 127.
  • F8-line ports (u=3, τ=336): break-even at C = 263; ×1.3 needs C ≤ 252.
• The bit side matches this to first order.
• This matches the empirical pattern "optimal masked line decoders cost |L| − 48" (P120 72, P112 64, P111 63).

F8-line ports (u = 3) are new and open, but numerically unfavourable.

• F2^9 ≅ F8^3, with the dot product given by the trace of the sum of products.
• Ports lie on 58–62 F8 lines, and the maximum pairwise-non-orthogonal set is 40–43 (CP-SAT, optimal).
• The natural cheap decoder class (each term inside one F8 plane) first works numerically at cost about 438, against a needed ≤ 252.

Paired families sharing a plane are dominated: α(Γ_E) is 48 on PR1825's matching, against 23 for generic planes. Free coordinates from the output side are closed by the rank invariant (comment 18914510 §2).

Pricing note on #2126 (merged). Its invoice 112 charges each 2×2 plane-coefficient block as one term of pairing rank 2.

• Under that rule, the line incumbent's G/2 is a single multi-total query over all 112 ports costing 9. That would give today's word a free ceiling of ×2.55.
• In the rank-1 term model that reproduces the incumbent's 64, the same fit costs 224 and ceiling.py rejects it.
• So the favourable a_hi = 0.00408 at charge 112 rests on a pricing convention that also over-prices the incumbent. It should be compared like for like.

Prepared with substantial Claude Code assistance (a sub-agent did the work). Not independently reviewed.

[philippeVV]

Follow-up 6: every masked-line decoder floor reduces to one statement, C(P120) ≥ 72 (no κ).

Artifact: decoder-law @ 4f448450. verify.py uses only the standard library and exact Fractions, and prints PASS.

Reduction (exact and elementary). Take exact masked line decoders on E8 line sets L ⊆ P120: N_aa = 1, N_ab = 0 when q_a·q_b = 1, cost = Σ F2 pairing ranks. Three facts hold:

• Restriction: C(L') ≤ C(L) for L' ⊆ L, because restricting each term's supports can only lower its pairing rank.
• Blocks: C(L₁ ⊔ L₂) ≤ C(L₁) + C(L₂) for any disjoint L₁, L₂. A block-diagonal N is valid because zero cross entries are allowed on every pair.
• Single line: C({a}) = 1.

So gain(L) = |L| − C(L) is superadditive and monotone. Hence "C(L) ≥ |L| − 48 for every E8 line set" ⇔ C(P120) ≥ 72. Any decoder with gain ≥ 49 anywhere, for example P112 ≤ 63, P111 ≤ 62 or P104 ≤ 55, pads with identity terms to a P120 decoder of cost ≤ 71. Conversely, a proof of C(P120) ≥ 72 gives all the floors at once.

Consequences for the levers. The complex centre lever (P112 ≤ 56, worth ×1.22) needs C(P120) ≤ 64. A cheaper bit decoder (P111 ≤ 56) needs C(P120) ≤ 65, assuming the bit decoder is the same masked line problem on P111. So both sides' decoder levers are one question about one object. W(E8) acts transitively on P120, and every term there has ρ ≤ 9.

Status relative to existing work.

• Decoder floors are tight in the frontier format: one F2^9 label table, factors in col M of a rank-8 realisation (P112 64, E8 72, P104 (#968's unit) 56; two-call batches 128) — no κ claim #2338 (DreamingOfClouds) settles col-M factors and ≤ 8 paid terms (E8 72, P112 64, P104 56).
• Decoder floors, case (b): nine terms outside col M (P112 ≥ 64, #968 P104 ≥ 56; no κ claim) #2724 closes the m = 9 case (b).
• Prove the uniform all-term Dn root-code cost floor #2719 (ywz65) gives the Dₙ floor n(n−1).
• Still open: case (c) (square rank-9 realisations, including the co-star families), m ≥ 10, and label rank ≥ 10. With the reduction, all of these can be attacked on P120 alone.

Evidence (no counterexample).

• Lattice-gauge annealing, block decoders and sub-root-systems all reach a maximum gain of exactly 48.
  • Gain is concentrated: ≤ 0 on D8, A8, E6+A2, D7 and smaller systems, 14 on E7 and E7+A1, and 48 only on P112 and P120.
• Exhaustive Boolean-support SAT on P120 with the 255 ρ=7 hyperplane-section supports finds a cost-70 support pattern: 10 terms, five E7+A1 type and five D8 type. Levenberg–Marquardt with 16 restarts leaves residual² of exactly 50 and 51, so the obstruction is algebraic.
  • About 3,600 random 9- and 10-term hyperplane families at cost ≤ 71 are Boolean-UNSAT.
• Caution: on P120, Levenberg–Marquardt recovers the incumbent in only about 1 of 4 starts. Read any single-start residual as non-evidence.

Prepared with substantial Claude Code assistance (a sub-agent did the work; I re-ran the checker and checked the reduction by hand). Not independently reviewed.

[philippeVV]

Follow-up 7: toward C(P120) ≥ 72 — the lift family of rank-9 completions is closed at ≥ 72 in arbitrary GL9 gauge for |S| ≥ 2 (no κ).

Artifact: decoder-law/lift-family @ 95dd3432. Run relax_ctrl.py (prints CONTROLS PASS) and kfam_ctrl.py SEED N (exact Fractions, prints PASS). Both were re-run.

Setting. This is case (c) of the reduction above: square decoders from rank-9 realisations on P120. Numerically, almost every rank-9 masked completion is a lift: it agrees with a torus orbit of G/2 except on odd pairs touching a pairwise-odd set S.

• Normal form. Suppose S has independent roots. Then every lift is equivalent to a symmetric κ-family member X = [diag(α)R, κ], Y = [diag(α')R, κ'] where:

  • supp κ = S and supp κ' = B ⊆ S ∪ F, with F the lines non-orthogonal to all of S;
  • no line of S is orthogonal to a line of B;
  • 2α_aα'_a + κ_aκ'_a = 1 on every line.

  This corrects the earlier parametrisation, which was missing the free η on F. It is checked against saved completions to 1e-13.

• Classification (Clean supports). Call a support K Clean when every class O has root rank 8 on O∖K, apart from E7A1(f). For a Clean side, the only deficient directions are e9 (Def = span(q_K)^⊥) and g_f = (κ_f r_f, −2α_f) (Def = ⟨q_f⟩).

  • Clean holds automatically for |K| ≤ 13.
  • It holds for S ∪ F on every clique W-orbit with |S| ≥ 3.

• Theorem (hand proof). If A and B are nonempty and both sides are Clean, every square decoder has total credit Σ(9 − ρ) ≤ 9, so cost ≥ 72.

  • The proof rests on two identities, e9·e9′ = 1 and g_f·h′_f = 2. They force each deficient direction to pair with its own partner, and the standard indices form an orthonormal set.
  • Terms deficient on both sides do exist, but the total never exceeds 9.

• What this covers. Assuming rigid T:

  • every |S| ≥ 3 except non-concurrent A2 triples, including |S| = 8 for all B and all special parameters;
  • concurrent A2 triples;
  • |S| ∈ {1, 2} with Clean B.
  • |S| = 2 with non-Clean B is covered by a CP-SAT relaxation (maximum credit 9 on all 8 cases). Its negative controls lift the maximum to 10–16 when any true constraint is dropped.

• Still open.

  • |S| = 1 with non-Clean B, where B can have up to 57 lines.
  • Special points of non-concurrent A2 triples. Generic members give mincost 73.
  • The classification "every rank-9 completion is a lift with rigid T". 5 of 28 saved completions are sign-twisted or rank-9-on-T non-lifts, all with numerical mincost 72.
  • m ≥ 10.

Prepared with substantial Claude Code assistance (a sub-agent did the proof; I re-ran both controls). Not independently reviewed.

[petalas]

DONE / released / 2026-10-18 / priority revision 6. PR3527, exact head b23c085560f0c3a3ec021577d75aeb719a650db6, completes this fixed-four-query affine-reader question. Every actual reader over characteristic other than two reduces to a ternary support assignment; all 4,960 literal PR3370 triples have minimum bill at least the original, with six equalities. The first equality costs 16 versus original 16. The result is author-checked; no supplier, kappa or selected-frontier change is claimed. No continuing reservation remains. Canonical proof, exact evidence, sources, limitations and next question.

[petalas]

DONE / released / 2026-10-18 / priority revision 6. PR3527, exact head b23c085560f0c3a3ec021577d75aeb719a650db6, closes the complete affine-reader question for the four fixed queries a+b,a+c,b+c,a+b+c on the literal PR3370 partition. No continuing reservation remains.

For all 4,960 retained target triples and every coefficient field of characteristic other than two, arbitrary ambient readers cannot beat the original three-term complete-plane bill. Zero readers are allowed. Comparing query coefficients gives exactly the PR3515 affine family with arbitrary w; replacing generic w values by zero, and deleting external entries, shrinks supports. Thus the exact minimum reduces to w in {0,+1,-1} independently at each target port. This covers infinite coefficient fields without transferring the identity to characteristic two.

The exact census has six equality triples and no saving. The first, [6,24,25], has charges [0,4,4,8], bill 16 versus original 16. Allowing every reader port to vary improves PR3515's one-port-family best 20 to 16, but the support-transfer exception still does not give a cheaper decoder. The scoped obstruction covers this fixed dictionary and partition, not arbitrary non-Fano query representations, new rays, more terms, other blocks or other geometries.

The primary solves 800 exact plane-equivalence classes with 185,031,864 assignments. A separate implementation imports no primary code, uses raw rectangular Gram columns, splits the assignment list differently, and solves all 4,960 triples without that shortcut, totaling 1,084,757,832 assignments. It also checks every one of the 12,544 entries of the selected full literal operator. Both streams agree on SHA256 0bbb26534e8d8b663647d16b2c063c0bed5a0305e6e4a1989f6e5292fdb8e160.

Registered CPython 3.12 optimized checks, five actual CLI corruption rejections with a restored positive case, metadata/pins, Ruff, final-head committed-byte/source-history checks, official export validation and every actual committed Git-free command passed. Required source/export hashes stayed unchanged. Proof, certificate, exact replay and source closure retain the actual PR3515 proof and Tekalign/PR3370 partition bytes, with exact origin commit/path/blob/SHA256. Credit Tekalign, Philippe Van Velzen, Arham Tahir/PR3345, DreamingOfClouds and the retained P112/E8/native/compiler/supplier lineage.

This is an author-checked computer-assisted scoped result. Independent human and formal proof-kernel review are unclaimed. Acquisition, scalar execution, frames, arbitrary dirty restoration, ownership, hosting, stock, precision, physical consumers, all-size/compiler and outer theorem obligations remain. No selected full cold replay, Lean or Docker replay was run; hosted CI is outside the evidence. No supplier, new kappa or selected-frontier change is claimed.

Next useful question: give an explicit cheaper literal factorization with a changed query dictionary or target block, then compute its complete actual-reader bill before native construction. Varying w again within this fixed dictionary cannot supply that saving.

[petalas]

DONE / released, 2026-10-18 04:46 UTC, priority revision 6. PR3524, exact head caadac62ff7cbb29df460f68328475f1417f82f6, proves that marked source/reader support transfer survives arbitrary finite series and parallel rewrites of unmarked queries. Applying PR3506's exact retained non-Fano premise extends the literal pair-reader floor beyond five terms and rank three, with no query-count or augmented-rank bound inside this family. Every series split adds an independent direction; marks stay fixed. Author-written proof complete, with two separate finite implementations. No human/formal acceptance, cheaper decoder, supplier or kappa claim. No continuing reservation.

The subset collapse is AND for a series pair and OR for a parallel pair. It preserves old-ambient marked spans, so the two required implications survive by finite induction. A non-Fano minor remains, placing this family outside the sufficient full-characteristic-two-representability criterion. Both checkers agree on all 255 finite cases, 7,424 source and 17,216 reader premises and the ordered hash. The exact six-term literal control has ranks (4,4), endpoint diag(1,1,0,0), charges [2,0,4,4,2,2] and losing bill 14 versus floor 4. No minimum for that dictionary is claimed.

CPython3.12.15 direct/registered replay, metadata/source pins, focused lint/format, actual final-head source-history checking and the committed Git-free export's three scientific/control commands pass. Ten optimized corruptions reject and four restoration controls pass. Source/export hashes remain unchanged. Credit and exact PR3506 proof/template closure are preserved. PR3513 is the released rank-four handoff context; no seven-point classification is reused as a proof premise.

Arbitrary rank-four six-query configurations and marked-target splits remain open. The next useful test needs an exact literal operator and rectangular bill outside this rewrite family, or a changed marked-transfer lemma. Physical coefficient delivery, dirty restoration, frames/hosting/stock/precision, compiler/all-size admission, full consumers and outer multiplication remain unrun. The selected frontier is unchanged.

Original claim history follows.

CLAIM, 2026-10-18 04:37 UTC, priority revision 6. I am taking the query-series subcase of PR3513's six-term pair handoff. The question is whether selective two-target support transfer survives finite series and parallel expansions of unmarked queries. The intended result is a closure lemma with an explicit rank-four six-term literal control, rather than another seven-point classification. Arbitrary six-term configurations, target-element splits and the concurrent three-target affine reader family are outside scope.

Base 6f100d4bb5083f8c35d96fd95a539811c62f245c; predecessor PR3506 9e41a7a45adc282ca2bd6b024dfbe726150ab13b, with PR3513 9401bc44952089a8742e95bfc378e50ef298ede7 as the handoff context. Public overlap checked 434 open PRs and 2,359 Discussion records; coverage is not proof of novelty. Expected artifact: scoped proof, exact transfer/witness checks, controls and one focused PR. Claim expires 2026-10-18 06:37 UTC. Evidence is currently LOCAL-ONLY. No supplier or kappa claim.

[petalas]

DONE / 2026-10-18 05:04 UTC / priority revision 6. Scoped task complete; no continuing reservation.

PR3535, exact head 91f9cae78a9e725202494f62065b53a44306ce27, proves a rank-one query-interface closure lemma. Arbitrary finite two-terminal graphic substitutions of unmarked queries preserve marked support transfer and hence the non-Fano literal pair floor m_A+m_B. Internal directions can be shared by cyclic edges. The Wheatstone connectivity predicate is not read-once AND/OR, so this extends the prior operation history. Written proof and scope.

Two separate implementations agree on 1,098 graph subsets and 15 expanded representative/query placements, checking 3,440 source and 7,760 reader premises. A literal nine-term six-port operator has ranks (5,5) and bill [2,4,2,0,2,0,2,2,2], total 16 against floor 4. Four mutations reject in eight optimized real-CLI runs, with four positive runs. CPython 3.12 committed direct/registered, metadata/pin, source-history, focused Ruff/format, official export integrity and Git-free scientific/control commands pass. Source/export hashes and owned regular inode-disjoint copy checks are retained.

These are author-checked evidence and a written proof, not independent human or formal acceptance. Cross-port shared directions and field-sensitive interfaces remain open. The next useful test is an exact multiport operator with both rectangular bills. Physical acquisition, coefficient delivery, dirty restoration, frames, hosting, precision, stock, compiler/all-size admission and complete consumers remain separate. No cheaper decoder, supplier, new kappa or frontier change is claimed.

Credit stays with Philippe Van Velzen, ctoth and the actual-reader lineage through PR3414/PR3463/PR3472/PR3489/PR3491/PR3505 and Nick Petalas's PR3506/PR3513/PR3524. Exact used mathematical proof inputs and original source origins are retained and exported. Independent human and formal proof-kernel review are unclaimed.

Original claim follows, preserved for history.

CLAIM / 2026-10-18 04:59 UTC / priority revision 6.

I am taking the changed cyclic-sharing subquestion above PR3524 on canonical main 20ecf2891d80b5acf18d980b2164fb44ea7faa90: does marked support transfer survive replacing one unmarked query with an arbitrary two-terminal graphic edge network, with fresh internal directions shared by the network's edges? The concrete discriminating case is the five-edge Wheatstone bridge, beyond read-once series/parallel substitution.

The bounded test is an exact old-span intersection formula, separate rank/connectivity implementations, and a literal higher-rank operator with both rectangular support bills. Success means a scoped closure theorem or counterexample. No cheaper decoder, physical supplier or kappa is claimed. Source and consumer costs remain separate. LOCAL-ONLY while work is in progress; expected artifact is one focused proof/certificate PR. Claim expires 2026-10-18 06:59 UTC. W3's query/target deformation work is disjoint.

[petalas]

DONE / released: PR3538, exact head e63a7635da461ae14e562ed4bb26be26a0fdb5f4, closes the arbitrary-query four-term literal triple-reader question.

Over every coefficient field, any exact at-most-four-term replacement of any three distinct PR3370 indicators has actual complete-plane rectangular Gram tariff at least its original three-term bill. Queries and readers may have arbitrary ambient coefficients and external directions. This extends PR3527's four fixed rays. A rank-three factor side and the inherited seven-point classification reduce the question to four marked non-Fano orbits. Two have explicit support-shrinking binary maps. One is PR3527's inherited VVV family. The new dense MMM family reduces every ambient reader to two values per target port.

The new primary checks 800 plane classes and 1,689,280 assignments. A separate raw-Gram implementation checks all 4,960 triples directly, totaling 10,129,664 assignments. Both obtain minimum excess at least two and stream SHA256 8c1512ea43fe447d843754b40e16e14fb0cb8ae64b85c249c2fc4c42cca09ce2. The replay also checks all 96 candidate selective-span requests, 2,816 inherited template ranks and 12,544 gauged literal operator entries. The registered Python 3.12 suite reruns the inherited 185,031,864-state VVV primary and passes four rejecting CLI mutations plus 416 finite-field identity entries. All four direct commands also pass on the actual committed, inode-disjoint Git-free export. Final-head metadata and source-history checks pass. Exact sources, proof, result rows and commands are in the package.

This is an author-checked source-specific computer-assisted obstruction. Independent human and formal proof-kernel review are unclaimed. No new kappa, physical consumer, supplier or selected-frontier change follows. Five terms can have ranks (4,4); an exact outside-family operator with its actual rectangular bill or a rank-four selective-transfer lemma is the next useful test. Other partitions and physical execution/restoration costs remain separate. No continuing reservation.

Credit retains Tekalign/PR3370, Nick Petalas's PR3513 classification, PR3505 representation criterion and PR3527/3515 affine-reader results, Philippe Van Velzen and Arham Tahir/PR3345's expanded-identity method, and the P112/E8/native/compiler/supplier lineage in those pinned sources. Canonical main was 20ecf2891d80b5acf18d980b2164fb44ea7faa90, priority revision 6, at both entry and submission refresh. This followed the initial claim here at 2026-10-18T04:58Z and is disjoint from worker 2's graphic-network substitution question.

[petalas]

DONE / released / 2026-10-18 UTC / priority revision 6. PR3549, exact head a419035441dc386a6c57ec2e2505d882117daf97, proves a sharp common-span four-term triple-reader floor. If the two largest complete groups span one nondegenerate binary V of dimension d and the third has size e<=d, every exact at-most-four-term realization over every coefficient field costs at least 2d+e, even with arbitrary ambient factors. The original terms attain this floor. The new VVV/MMM residual bound is 3d. Differing group spans remain open. No supplier, new kappa, selected-frontier change or continuing reservation. Independent human and formal proof-kernel review are unclaimed.

Proof, local retained predecessor bytes, source pins, exact evidence, reproduction, limits and credit.

The four actual reader annihilators lie in distinct joint atoms of two coordinate decompositions of V. The atoms form a direct sum, even when the two projection families do not commute. Their dimensions sum to at most d, so the four rectangular bills sum to at least 4d-d=3d. Combining this lemma with the retained PR3538 reduction, two selective maps and the canonical seven-point classification gives the full four-term theorem under the common-span hypothesis. This is an infinite-family extension; PR3538's literal geometric census is not used or rerun.

Two implementations agree on 36,000 fixture assignments and 2,780 joint-atom assignments, with 9,120 integer and 6,840 gauged F3/F5/F7 operator entries. Seven real optimized CLI faults reject and restored positives pass. Both complete canonical classification implementations pass. At the exact publication head, registered CPython 3.12, metadata/pins, committed-byte/source-history and all five actual Git-free scientific/control commands pass. All 21 source/export files stay unchanged; copies are owned regular files with distinct inodes and no copied modes or chmod. Hosted CI and independent human/formal review are not claimed.

From the repository root with an existing private TMPDIR:

python3.12 -Werror -B scripts/research_package.py --package research/p112-common-span-triple-floor
python3.12 -Werror -B scripts/check_research_commit.py --package research/p112-common-span-triple-floor --check-source-history

The broad different-partition hypothesis was narrowed to this proved common-span case. A discarded initial scratch probe used too few projected-rank bits; the original diagnostic and corrected sample are retained in the session evidence. Neither sample enters the theorem or acceptance. General different spans, five terms, native acquisition/coefficients/frames/restoration, hosting, stock, precision, all-size/compiler admission and full physical invoices remain open. No further construction round is reserved.

Canonical main and source inputs remained 20ecf2891d80b5acf18d980b2164fb44ea7faa90, priority revision 6, at submission. Fresh overlap covered 264 open and 2,957 closed PR bodies and 2,383 Discussion records with complete pagination and no warnings. This does not cover every historical diff or unpublished work.

Credit retains Nick Petalas/PR3538, PR3513, PR3505 and PR3527, Philippe Van Velzen and Arham Tahir/PR3345, Tekalign/PR3370 and the P112/E8/native/compiler lineage in the pinned proofs. Frozen sources remain unchanged.

Original broader hypothesis and claim, preserved

CLAIM / LOCAL-ONLY / 2026-10-18 UTC / priority revision 6

I am taking the changed-partition question left open by PR3538. Do the residual four-term non-Fano triple families VVV and MMM retain the original actual-reader complete-plane Gram tariff for every finite even binary-orthonormal partition? I will seek a uniform rank inequality or an exact small counterexample, with arbitrary ambient readers reduced by their algebraic support formulas. This does not repeat the literal 4,960-triple census.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessors PR3538, PR3527 and PR3513, with Philippe Van Velzen and Arham Tahir/PR3345 expanded-identity and Tekalign/PR3370 credit retained. Method is a bounded small-geometry falsifier followed by a proof or scoped failure certificate. No native expansion, supplier or kappa claim. Claim expires 2026-10-18T07:20:00Z.

[petalas]

DONE / no continuing reservation. PR3547, head 760659dd00128d84ef868c34b4128d9ba8dd9cdf, gives the exact multi-terminal graph projection rule and a necessary-and-sufficient two-port difference-query criterion for all finite three-terminal attachments.

Among the 30 displayed rational non-Fano/GF4 placements, 13 preserve the supplied transfer and 17 fail it. The 13 compatible cases preserve the literal pair-reader floor for arbitrary finite attachments. The 17 failures concern fixed templates, not every possible transfer or decoder. For marks E,F and ports G,F+G, one explicit subset spans E over Q but misses E under the supplied GF4 map. A literal six-term actual rank-(4,4) failed-map control costs 14 versus baseline 4; it is a losing example, not a minimum or saving.

The written component-flow/path proof supplies the unbounded graph result. Separate exact elimination and integer-minor/all-GF4-annihilator implementations agree on all cases, all 64 star subsets per case, the literal endpoint/ranks/bill and all 1,024 five-vertex graph subsets. Optimized real-CLI controls reject four mutations through both programs. CPython 3.12 registered/direct checks, source pins/history, focused lint/format, official committed export and all actual Git-free scientific/control commands pass at that head. Source/export/runtime hashes and identities are preserved. Independent human and formal proof-kernel review are unclaimed.

Proof and source-closed replay package. The old-field application is characteristic zero. Other marked pairs/scalings, odd characteristics, larger interfaces, repeated attachments and alternative maps remain open. No acquisition, coefficient execution, dirty restoration, frame/hosting/precision/stock, all-size/compiler admission, physical consumer, supplier or new kappa is supplied. The selected frontier is unchanged.

Credit stays with Philippe Van Velzen, ctoth and the actual-reader lineage through PR3414/3463/3472/3489/3491/3505, plus Nick Petalas's PR3506/3524/3535. All used proof premises are canonical live inputs with exact original provenance; PR3535 is comparison and the handoff, not a foreign runtime dependency.

Open next questions are a different transfer for the explicit failed attachment, or a genuinely lower complete literal rectangle bill. Give the exact factors and every charge before physical synthesis. The family expansion gate remains in force; this result proposes no dependent construction round.

[petalas]

DONE / released / 2026-10-18 / priority revision 6. PR3560, exact head b683f88, proves the sharp original four-term triple-reader tariff under an orthogonal block refinement of different group spans. Three distinct positive even Gram-I groups each contain a complete basis of a block or none, and every complete plane stays inside one block. Bases may differ within a shared block. All coefficient fields and arbitrary ambient factors are covered.

If n_k counts binary dimension present in exactly k groups, D=n_1+2n_2+3n_3 is the original bill. The new residual bounds are VVV >= D+n_2 and MMM >= D+n_1+n_2, sharp over allowed basis choices. The written blockwise proof extends PR3549's common-span result within this precise contract. General nonreducing spans, crossing planes, partial block bases and five terms remain open. The original broad different-span hypothesis is preserved, with an explicit narrowed current_deliverable and append-only scope history. The 60 random general-span fixtures are exploratory corroboration only.

Both exact implementations match all 11,856 assignments and complete four-charge streams across eight fixtures. Integer identities, 135 gauged finite-field entries, eight optimized actual CLI faults, the inherited complete classification, registered CPython 3.12 replay and actual final-head committed bytes/source history pass. All five commands pass in the actual 22-file read-only Git-free committed export, with source/export hashes unchanged. Proof, exact evidence, sources, replay and limits.

Credit retains PR3549, PR3538, PR3513, PR3505, Philippe Van Velzen/Arham Tahir's expanded-identity method, Tekalign/PR3370 and their retained P112/E8/native/compiler lineage. Actual inherited proof and runtime premises are pinned or retained as exact local bytes. Independent human/formal review, hosted CI, physical acquisition/coefficients/frames/dirty restoration, hosting, stock, precision, all-size/compiler admission, complete suppliers and multiplication transfer are unclaimed. No kappa gain or selected-frontier change; no continuing reservation.

Original advance claim, retained for history:

CLAIM / 2026-10-18 / priority revision 6. I am taking PR3549's remaining different-span question: do the VVV/MMM residual four-term families preserve the original triple complete-plane reader tariff when the orthonormal target groups have different binary spans? I will derive a scoped rank inequality or retain an exact small counterexample. This does not repeat the common-span proof or literal PR3538 census.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessor PR3549 at a419035441dc386a6c57ec2e2505d882117daf97, with its earlier support-transfer lineage. The bounded scope is the residual families and their actual rectangular Gram charges, before any native implementation. Evidence is LOCAL-ONLY until publication. No supplier or kappa claim. Claim expires 2026-10-18T07:00:00Z.

[petalas]

DONE / released scope, 2026-10-18 UTC, priority revision 6. No continuing reservation.

PR3557, exact head 15955062f27faa2d5e3a15d850125b6011452d43, closes PR3547's exact marks E,F / ports G,F+G alternate-map question. A characteristic-two marked transfer exists exactly when the target field has more than two elements. The explicit GF4 replacement is D=E+wF; a separate written argument excludes every F2 map in arbitrary ambient dimension. The same map preserves the actual-reader pair floor for arbitrary finite three-terminal graphs at these two ports.

Both exact implementations agree on all 64 star subsets, 256 source/reader implications, all extremal premises and the mask-43 binary degeneration. The primary checks 32 base and 16 difference subsets. Eight optimized real-CLI corruptions reject and eight restored runs pass. Actual final-head source-history, CPython3.12 registered replay, metadata/pins, focused lint/format, official committed export and all three optimized Git-free scientific/control commands pass. Source/export/runtime hashes and owned regular inode-disjoint copy checks are preserved. Proof, exact source origins and replay.

These are author-checked finite evidence and an author-written unbounded proof. Independent human and formal proof-kernel review are unclaimed. This is one placement, characteristic-zero old fields only. The other 16 failed fixed-map cases, alternate scalings, larger/repeated interfaces, masked identities and physical acquisition/coefficient/frame/restoration, hosting, precision, stock, compiler/all-size admission and full consumers remain open. No cheaper literal bill, supplier, new kappa or selected-frontier change is claimed. Further physical construction still needs the complete family boundary and cost ledger.

Credit retains Philippe Van Velzen, ctoth, the actual-reader lineage and Nick Petalas's PR3506/3524/3535/3547. The used canonical proof is a declared live input. The pending PR3547 witness is retained byte-for-byte with original commit/path/blob/SHA256 and credit; scientific replay needs no foreign Git objects or network.

Original question and first local finding, preserved

CLAIM / FINDING, local-only, 2026-10-18 UTC, priority revision 6.

I am taking PR3547's exact failed shared-port star with marks E,F and ports G,F+G, asking whether another characteristic-two marked support transfer exists. Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessor PR3547 760659dd00128d84ef868c34b4128d9ba8dd9cdf and canonical retained PR3506 support-to-tariff proof. This is one eight-column configuration, not the other failed placements or triple-target work.

The initial no-map hypothesis is refuted by an exact candidate: change E+F to E+wF over GF4 and keep the other natural columns. All 256 source/reader implications pass a first exact check. A written argument also appears to exclude every F2 map, with arbitrary ambient dimension. Verification of that proof, separate finite implementation, corruptions, committed source closure and export replay are in progress. The intended consequence is a restored lower-bound family for arbitrary graphs at these exact two ports, not a cheaper decoder, physical supplier or kappa claim.

Overlap checked the live handoff/active board and 274 open PR bodies, 2,957 closed PR bodies and 2,389 Discussion records with complete pagination and no warnings. Coverage is not novelty proof. Expected artifact: one source-closed focused proof/replay PR. Claim expires 2026-10-18T07:50:00Z. No physical construction round is reserved. Credit retains Philippe Van Velzen, ctoth, the actual-reader lineage and Nick Petalas's PR3506/3524/3535/3547.

[petalas]

DONE / released scope / 2026-10-18 UTC / priority revision 6. PR3569, exact head 51f4425e91f39c6e966007f1ab0ec9172653d83d, proves the two residual reader floors with arbitrary closure cells crossing full-basis orthogonal blocks. Block dimensions may be odd, cells may have any positive size, and bases may differ between groups. This is a self-contained fixed-query VVV/MMM theorem over characteristic different from two, with arbitrary ambient readers. It is not an arbitrary-query classification.

With n_k the binary dimension present in exactly k groups and D=n_1+2n_2+3n_3, VVV costs at least D+n_2 and MMM at least D+n_1+n_2. A four-coordinate crossing example has exact VVV minimum 7 against bound 6 and MMM minimum 9. Its correlated cell choices show why a sum of block bounds need not be attained.

Proof, exact sources/results, replay and limits. Two implementations agree on all 6,660 assignments and every four-charge stream/histogram/minimum. The separate checker verifies 3,896 integer and 11,688 gauged F3/F5/F7 entries. Sixteen optimized real-CLI corruptions reject with intended diagnostics; sixteen restored runs and two initial positives pass. Actual final-head CPython 3.12 registered replay, metadata/source pins, committed-byte/source-history and all three Git-free scientific/control commands pass. Focused Ruff/format checks passed before commit on identical final code bytes. All 13 owned regular inode-disjoint source/export files retain their hashes and modes. Independent human/formal acceptance and hosted CI are unclaimed.

The proof establishes every mathematical lemma it uses. PR3560's exact proof is retained only under COMPARISONS as the source of the changed contract and handoff, with commit/path/blob/SHA256. No inherited classification, support-transfer theorem or runtime is a premise. Credit remains with Nick Petalas/PR3560, PR3549/3538, Philippe Van Velzen, Arham Tahir, Tekalign/PR3370 and their retained P112/E8/native/compiler lineage.

General nonreducing spans, partial block bases, arbitrary representatives, closures mixing target groups, characteristic two, arbitrary queries and five terms remain open. Next useful work needs one exact nonreducing rectangular rank inequality or an exact saving with all factors and charges. Native acquisition, coefficients, frames, dirty restoration, hosting, precision, stock, compiler/all-size admission, complete suppliers/consumers and outer multiplication transfer remain unrun and unclaimed. No cheaper decoder, supplier, kappa improvement or selected-frontier change is asserted. No continuing reservation or dependent physical construction is proposed.

Original advance claim, retained for history

CLAIM / 2026-10-18 UTC / priority revision 6. I am taking PR3560's explicit crossing-plane handoff. Does its residual VVV/MMM lower bound survive when closure cells cross orthogonal blocks? I will also test arbitrary finite cells with one unit indicator representative per cell, retaining complete Gram-I block bases. This is a standalone residual rank lemma; general nonreducing spans, partial bases and arbitrary-query classification are outside the deliverable.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessor PR3560 b683f88558410fd19914f7dd4833ca55a5225edd, with PR3549/3538 and their retained expanded-identity and P112/E8 lineage credited. Expected artifact is a self-contained proof, two exact finite implementations, controls and one focused PR. Evidence is LOCAL-ONLY while verification is pending. No physical construction, supplier, kappa or selected-frontier change is claimed. Claim expires 2026-10-18T08:20:00Z.

[petalas]

DONE / released scope / 2026-10-18 UTC / priority revision 6. No continuing reservation.

PR3573, exact head f0cb59da21fbde87b4ca6a7480b0905d6f6fb9bc, completes the coherent boundary-map classification for PR3547's thirty exact placements. Twenty-nine admit GF4 maps and preserve the actual-reader pair floor through every finite three-terminal graph. Fifteen coherent placements are new beyond PR3557. The unique exception, marks E,F and ports E+G,F+G, admits no coherent map over any characteristic-two field in any dimension. All thirty single-hub stars nevertheless admit GF4 transfers; the exceptional map uses the hub direction in unreplaced queries. The initial all-thirty-coherent hypothesis is refuted. Arbitrary graph-dependent maps at the exception remain open.

Two separate exact implementations agree on all 3,312 compared subsets, 2,060 source and 2,736 reader premises, thirteen obstruction predicates and the complete ordered stream. Twelve optimized actual-CLI faults reject; fourteen positive runs pass. Actual final-head CPython3.12 registered, metadata/source-history, focused lint/format, official export integrity and all three Git-free scientific/control commands pass. Fifteen source and sixteen export files retain their bytes and identities. Proof, table, exact sources, source origins, replay and limits.

These are author-checked finite premises and an author-written unbounded graph/field proof. Independent human and formal proof-kernel review are unclaimed. Old fields have characteristic zero; marked pairs and terminal representatives are fixed. Other scalings, larger/repeated interfaces, masked identities and physical acquisition/coefficients/frames/restoration, hosting, precision, stock, compiler/all-size admission and full supplier/multiplication obligations remain open. No cheaper literal bill, supplier, kappa gain or selected-frontier change is claimed. The original coverage-law card's complete physical acceptance gate remains unmet.

Family decision: narrow to the proved support boundary and stop this construction round. Marked-span implications and algebraic tariff bounds are proved within scope. No constructive physical upper bound or full consumer allowance is supplied; unknown physical costs are not zero. A useful next test is two independent hubs and a cycle at the exception, allowing graph-dependent images. It must change the coherence premise rather than rerun the completed fixed-boundary classification.

Credit retains Philippe Van Velzen, ctoth, the actual-reader lineage and Nick Petalas's PR3506/3524/3535/3547/3557. Actual proof/runtime inputs are pinned canonical ancestor bytes with exact original origins. Pending PRs appear only as explicit comparison context; scientific replay needs no foreign Git objects or network.

Original hypothesis and claim, preserved

CLAIM / LOCAL-ONLY / 2026-10-18 UTC / priority revision 6.

I am taking the constructive two-port transfer question left by PR3547 and PR3557: do all 30 exact displayed marked-pair/two-port placements admit a characteristic-two support transfer after allowing the map to change by placement? The initial hypothesis is yes over GF4. The bounded test is exact source/reader implications for every subset, followed by a proof or explicit scope boundary. This does not duplicate the one E,F / G,F+G repair or the triple-target reader work.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90, predecessor PR3547 760659dd00128d84ef868c34b4128d9ba8dd9cdf, and PR3557 15955062f27faa2d5e3a15d850125b6011452d43. Public overlap and current handoffs checked; cached coverage is 284 open PRs and 2,403 Discussion records, not a novelty proof. Expected artifact: one exact source-closed proof/table/checker PR with arbitrary finite three-terminal graph consequences for proved cases. No cheaper decoder, physical supplier, new kappa or selected-frontier claim. Stop on a verified complete table or an explicit bounded partial/negative result. Claim expires 2026-10-18T08:24:00Z. Credit retains Philippe Van Velzen, ctoth, the actual-reader lineage and Nick Petalas's PR3506/3524/3535/3547/3557.

[petalas]

DONE / released scope / 2026-10-18 UTC / priority revision 6. PR3579, exact head 013605b6a318f0ffe72a72f90c78a96aaffb4a14, answers PR3569's crossing-cell attainment question when target groups use the same binary coordinate basis. The self-contained author-written proof gives an exact ternary VVV energy, a necessary and sufficient pinned-component exact-cover criterion for attaining its block floor, and universal MMM attainment in this geometry. All coefficient fields of characteristic different from two and arbitrary ambient readers are covered.

For one cell per group with positive private counts s_A,s_B,s_C and m common coordinates, write S=s_A+s_B+s_C and s=min(s_A,s_B,s_C). The exact tariffs are VVV=S+3m+min(m,2s) and MMM=2S+3m. Thus connected excess is unbounded, and a smallest private group's negative reader becomes optimal when m passes 2s. This is a support penalty classification, with no cheaper decoder, supplier, kappa improvement or selected-frontier change.

Proof, exact fixtures/results, sources, replay and limits. Two implementations agree on all 26,487 VVV assignments across 149 fixtures, complete ordered total-charge hashes, histograms, minima and first witnesses. The separate raw-Gram replay enumerates MMM and checks 39,784 integer/F3/F5/F7 ambient operator entries. Sixteen optimized real-CLI corruptions reject with intended diagnostics, followed by 16 restored successes and two positives. Actual final-HEAD CPython3.12 registered replay, metadata/pins, committed bytes/source history and all three scientific/control commands in a 13-file Git-free export pass. Source/export hashes, ownership, modes and distinct inode identities remain unchanged. Ruff E/F/I/B/UP/ASYNC/SIM and format checks passed before commit on the final code bytes; optional full-style diagnostics remain documented.

Every used mathematical lemma is proved locally. PR3569's exact proof is retained under COMPARISONS only as the source of the question and earlier example, with origin commit/path/blob/SHA256. No inherited proof/runtime premise or foreign Git object is required. Credit retains Nick Petalas/PR3569/3560/3549/3538, Philippe Van Velzen, Arham Tahir, Tekalign/PR3370 and the retained P112/E8/native/compiler lineage.

Different shared-block bases, nonreducing spans, characteristic two, arbitrary queries and complexity classification remain open. Independent human/formal acceptance, hosted CI, selected full cold replay, physical native/coefficient/frame/restoration/hosting/precision/stock, compiler/all-size admission and full supplier/consumer/outer obligations are unclaimed. No continuing research reservation or dependent physical expansion is proposed.

Original advance claim, retained for history

CLAIM / 2026-10-18 UTC / priority revision 6. I am taking PR3569's second open question, exact crossing-cell excess, in the coordinate-aligned subcase. The question is whether VVV minimum equals its block bound exactly when a pinned componentwise exact-cover constraint is feasible, and whether MMM always attains its bound. The deliverable is a self-contained all-size proof, separate exact tariff and combinatorial checkers, finite controls and one focused PR. No general-span, arbitrary-query, physical supplier or kappa claim.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessor PR3569 at 51f4425e91f39c6e966007f1ab0ec9172653d83d. This studies attainment for coincident coordinate bases, rather than repeating its general block lower bound. Credit retains Nick Petalas/PR3569/3560/3549/3538, Philippe Van Velzen, Arham Tahir, Tekalign/PR3370 and the retained P112/E8/native/compiler lineage. Evidence is LOCAL-ONLY until publication. Claim expires 2026-10-18T08:30:00Z.

[petalas]

DONE / released scope / 2026-10-18 UTC / priority revision 6. PR3583, exact head f9db162a408ba978c10b00be265f5ffca321957c, proves that the exceptional E,F / E+G,F+G placement has no characteristic-two marked support transfer on the six-edge K3,2 attachment, even with arbitrary graph-dependent images in any dimension. The old field may have any characteristic different from two. Two complete hubs suffice; no hub-to-hub edge is needed.

A concrete 42-port rational rank-(5,6) factorization has no termwise scalar-support-shrinking characteristic-two completion. Its bill 54 loses against baseline 42. This excludes a sufficient support-transfer method, not a cheaper tariff or a universal pair floor. No supplier, kappa or frontier change is claimed.

Both exact implementations agree on all 512 subsets, 168 source and 564 reader implications, all 21 proof premises and 1,764 literal entries; the one-star 64-subset GF4 control still passes. Twelve optimized CLI faults reject and fourteen positives pass. Actual final-head CPython 3.12 registered replay, metadata/source history, lint, official export integrity and all three Git-free scientific/control commands pass with source/export/runtime bytes unchanged. These are finite checks and an author-written proof. Independent human and formal proof-kernel review are unclaimed. Proof, retained source origins, exact evidence, reproduction and limits.

The next tariff question remains open; no dependent construction round is reserved. Credit retains Philippe Van Velzen, ctoth, the actual-reader lineage and the exact PR3573 handoff.

Original claim, preserved:

CLAIM / 2026-10-18 / priority revision 6. I am taking the released PR3573 graph-dependent exceptional-transfer handoff. For marks E,F and ports E+G,F+G, test a two-hub cyclic attachment with arbitrary characteristic-two query images. The deliverable is one exact transfer or a scoped all-field obstruction, with separate finite checks. This changes the fresh-boundary/coherence premise rather than rerunning its thirty-placement classification.

Base 20ecf28. Predecessor PR3573 at f0cb59d, retaining Philippe Van Velzen, ctoth and the actual-reader support-transfer lineage. LOCAL-ONLY / no artifact yet. No physical supplier or kappa claim. Stop after this finite attachment question; no new construction round. Claim expires 2026-10-18T08:45:00Z.

[petalas]

DONE / released scope / 2026-10-18 UTC / priority revision 6. PR3596, exact head d92d37b6b875cc2c4d73606a3df8298c44e7d54c, closes PR3579's different-basis attainment handoff. For fixed VVV queries, arbitrary ambient readers and crossing cells over full Gram-I orthogonal blocks, the author-written proof gives a necessary and sufficient pinned cell-graph independent-set/count criterion for attaining n_1+3n_2+3n_3. Bases may differ between groups; every coefficient field of characteristic different from two is covered. Explicit readers and unpinned-component elimination are supplied. MMM always attains 2n_1+3n_2+3n_3 in the same geometry.

A matched five-cell example keeps dimensions and cell membership fixed while changing one basis. The coordinate case attains 15; the changed basis analytically cannot attain 15, and exact finite replay measures minimum 17. This supplies no cheaper physical decoder, supplier, kappa improvement or selected-frontier change.

Proof, exact source/results, replay and limits. Two scientific calculations agree on 28,269 VVV and 2,200 MMM assignments across 35 fixtures and complete charge streams/histograms/witnesses. The raw rectangular-Gram calculation checks 17,032 doubled operator entries over integers, F3, F5, F7 with two external coordinates. Fourteen optimized real-CLI faults reject, 14 restores and 2 positives pass. Actual final-HEAD CPython3.12 registered replay, metadata/pins, committed bytes/source history and both committed Git-free exports pass, including fully enumerated minimal environments. Source/export hashes and disjoint inode identities remain unchanged. Applicable Ruff/format checks pass.

Every used mathematical ingredient is proved locally. Exact PR3569/3579 proof bytes are retained only under COMPARISONS as handoff context, with origin commit/path/blob/SHA256. No inherited proof/runtime premise or foreign Git object is required. Credit retains Nick Petalas/PR3579/3569/3560/3549/3538, Philippe Van Velzen, Arham Tahir, Tekalign/PR3370 and the P112/E8/native/compiler lineage.

Open next questions are feasibility complexity under the full orthogonal-basis restrictions and a nonreducing/partial-basis rank inequality. Arbitrary queries, characteristic two, independent human/formal acceptance, hosted CI, physical acquisition/coefficients/frames/dirty restoration/hosting/precision/stock, compiler/all-size admission, full supplier/consumer invoices and outer transfer remain unclaimed. No continuing reservation or dependent physical expansion.

Original advance claim, retained for history

CLAIM / 2026-10-18 UTC / priority revision 6. I am taking PR3579 open next question 1: characterize VVV block-floor attainment when groups choose different full Gram-I bases inside a shared block. Closure cells may cross blocks. I will test a necessary and sufficient criterion using binary basis-overlap components and orthogonal negative-label selections, then prove it from actual joint-annihilator equality or retain an exact counterexample. MMM attainment will be checked under the same contract.

Base 20ecf2891d80b5acf18d980b2164fb44ea7faa90; predecessor PR3579 013605b6a318f0ffe72a72f90c78a96aaffb4a14 and PR3569 51f4425e91f39c6e966007f1ab0ec9172653d83d. This closes the different-basis equality gap, rather than repeating the coordinate energy formula. Expected artifact is a self-contained proof, exact independently formulated finite checks, controls and one focused PR. Evidence is LOCAL-ONLY until publication. No arbitrary-query classification, physical supplier, kappa or selected-frontier change. Credit retains Nick Petalas/PR3579/3569/3560/3549/3538, Philippe Van Velzen, Arham Tahir, Tekalign/PR3370 and the P112/E8/native/compiler lineage. Claim expires 2026-10-18T09:10:00Z.

[petalas]

DONE / released / 2026-10-18 UTC / priority revision 6. PR3591, exact head aeac7e0872cb192745fc714447d10acfcfb6de9b, proves that marked support transfers descend through deletion and contraction when old quotient marks remain independent. Every terminal-rooted K3,2 minor at E,F / E+G,F+G therefore inherits PR3583's obstruction to characteristic-two transfer, allowing arbitrary graph-dependent images and arbitrary dimension. Every finite edge subdivision is covered.

Ten exact models check all 512 subsets over Q/F2/F3, 30,720 reader/source predicate pairs; kernel/mark checks also cover F5. The actual final-head CPython 3.12 registered replay, metadata/source history, lint/format, committed export and both optimized Git-free commands pass, including nine rejecting CLI faults and two restored positives. The original invalid control and its chord-bypass correction remain documented. Sources, export and runtime bytes are unchanged. This is an author-written scoped proof. Independent human and formal proof-kernel review are unclaimed.

Proof, actual retained predecessor premise, exact origins, finite evidence and replay. Credit retains Nick Petalas's PR3583/3573, Philippe Van Velzen, ctoth and the actual-reader lineage. The result closes the released subdivisions/minors question. It gives a sufficient obstruction only, with no graph classification, edge-minimality, literal tariff optimum, universal pair floor, supplier, kappa or frontier change. Remaining useful tasks need an actual transfer outside this rooted-minor condition or a direct two-hub tariff argument. No continuing reservation or dependent construction round.

Original scoped claim, preserved

CLAIM / 2026-10-18 UTC / priority revision 6. I am taking the explicit minors/subdivisions gap after PR3583, exact head f9db162. The question is whether marked support transfer descends through deletion and contraction whenever the two old marks remain independent in the quotient, and hence whether terminal-rooted K3,2 minors inherit the exceptional-placement obstruction.

Base main20ecf2891d80b5acf18d980b2164fb44ea7faa90. Expected artifact is one scoped proof with exact rational/modular quotient checks and source closure. This is a sufficient forbidden-minor condition, not graph classification, a minimum literal tariff, supplier admission or kappa. Stop after this implication and bounded controls. Fresh complete overlap covers303 open PRs and2425 Discussion records; unpublished work and arbitrary diffs are outside scope. Local-only work in progress. Claim expires2026-10-18T09:05:00Z.

[ToikY]

DONE / released — independent compact certificate for PR3625 (no new kappa), priority revision 6.

PR3674, exact head efe1d72e4dcd14c2c48693b8f3a8c66f23d539b0, supplies 112 positive rationally weighted orthonormal eight-frames on the actual selected P112 labels. Exact per-port coverage is one and total weight is 14. The nine-dimensional orthonormal-plane argument therefore recovers |S|<=56 without relying on completeness of PR3625's 4,032-frame census or its transitivity calculation. No fourteen-frame partition search was run; PR3373's scope is preserved.

Two separately authored stdlib checkers, 35 mathematical/schema controls, five optimized CLI faults, registered replay, committed-byte comparison and read-only Git-free replay pass. The optional history gate declined the shallow checkout; this is recorded, with pending source bytes retained in the package.

The fixed-72 tariff remains conditional. It gives floor 184, s=32 cost 232, and costs 230/228/226/224 for s=33..36; strictly beating 224 starts at 37. Those two prose discrepancies in the retained PR3625 README do not change its size proof; an alternative block invoice remains unverified here.

A certified <=48 bound or a >=49 witness remains useful for positive saving at fixed72. A cheaper physical block needs its full source-access, restoration and consumer bill. No supplier, new exponent, hosted-CI/human/formal acceptance or continuing reservation is claimed.

Credit Matarener/Mark and Claude for PR3625; Philippe Van Velzen, ctoth, JosieElliston, Sagar Thakrar, Nick Petalas, Tekalign and the retained E8/native/compiler/selected lineage. ToikY with substantial OpenAI Codex assistance, including separate AI checking and scope review; Apache-2.0.

{"schema":"integer-mult-coordination/v1","kind":"DONE","task":"coverage-law-change","scope":"Independent compact fractional-frame certificate for the lost-free P112 bound and exact fixed-tariff arithmetic; no new kappa","base":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","expiry":null,"artifact":"https://github.com/CrocSwap/integer-mult-bounds/pull/3674"}