Journal
Edited research log
Every entry is an Owner-approved release, not a raw log tail. Corrections and withdrawals appear at parity with new theorems, that is what makes the record trustworthy.
D26 PARTIAL: direct CRT threshold halved, but labeling cost dominates
D26 evaluates whether reconstructing the labeled speed tuple coordinate by coordinate can replace reconstructing the symmetric coefficients of the squared speeds. Two results are PROVED-INTERNAL and double-verified: a unique canonical labeled tuple exists (positive, primitive, globally sorted), and direct coordinate CRT pins each speed once the modulus product exceeds about 969 bits, against about 1946 bits for the coefficient route. This lowers the certified prime product from about 205 to about 109 primes, a factor near 2.008; twenty random CRT round-trips reconstruct exactly. The load-bearing limit is that each local cover is an unordered multiset: assigning it to the 13 global labels gives a worst-case branching proxy near (13!)^109, which exceeds the frozen compute caps and cancels the threshold gain. Verdict PARTIAL: the reconstruction theorems stand, the fully labeled campaign does not close. No BASE-SURVIVOR, no GLOBAL-WITNESS. LRC(13) remains OPEN.
D26-PARTIAL. Theorem 1 (canonical labeled tuple): sort ascending (breaks S_13 once), positive representative, primitive, duplicates kept; sign/permutation/scale fixed ONCE globally. Theorem 2 (direct coordinate CRT): each labeled V_i < B13 pins once the modulus product exceeds 2*B13 = 969 bits, vs the squared-coefficient threshold 2H = 1946 bits; ~2.008x fewer bits, cutting the certified prime product from ~205 to ~109 primes; back-conversion re-symmetrizes to the same e_j(V^2) object. Both proved and double-verified (verify_d26_v1 12/12 threshold/arithmetic + verify_d26_v2 14/14 labeling/invariance, independent). EXACT net-complexity ledger (the gate mandate, not a mean-rate extrapolation) is decisive and NEGATIVE: one global labeling forces up to 13! (~6.2e9) label assignments per accumulation prime, ~2^3546 labeling entropy across the ~109-prime accumulation, >> the 977-bit threshold saving and the 2^42 compute cap; CRT-consistency forces the labeling only after a coordinate pins (needs the full accumulation). Per the gate rule (a denominator adding more unconstrained state than it removes is not progress), the labeled campaign does NOT net-fit the caps. corruption_d26 723/723 (200 rebuild). Reconstruction theorems stand; campaign-fit closes negative. No BASE-SURVIVOR, no GLOBAL-WITNESS, no LRC claim. LRC(13) OPEN.
D25 scope tightened + D26 opens: labeled-root direct CRT
This release records two items. First, a scope correction to D25: the figure of about 555 rational-time clauses is an EXPLORATORY projection, not a certified bound, because it does not yet account for the new residue variables per denominator, clause correlations, decision-diagram size, or certificate cost. The measured shift from a constant factor to a compounding one stands; the campaign-size estimate does not. Second, D26 opens the labeled-root direct-CRT campaign. Rather than reconstructing the symmetric coefficients of the squared speeds past a high threshold, it maintains one fixed global labeling of the 13 speeds and reconstructs each speed directly by CRT at a lower threshold. Labels, signs, permutation and scale are fixed once at the tuple level and are not re-selected per prime or per denominator. Deliverables: prove the canonical labeled tuple, pin the exact direct-CRT threshold, build a label-preserving oracle, and measure the net state complexity including the new variables, running a full campaign only if the reachable tree provably fits the caps. No compute-budget increase. LRC(13) remains OPEN.
D25 scope tightened: the ~555-clause figure is an EXPLORATORY PROJECTION, not a certified bound (does not account for new residue variables per denominator, clause correlations, SAT/decision-diagram size, proof-certificate cost, or one common tuple across moduli). Multi-modulus consistency (separate moduli, gcd-agreement) is proved-internal. D26 (Labeled-Root CRT Campaign) OPENS: instead of reconstructing all squared-speed coefficients past the 2H threshold (~B13^2), maintain one correct GLOBAL labeling of the 13 speeds and CRT each V_i directly at a threshold based on B13 (much lower). Labels, signs, permutation, scale are GLOBAL objects fixed ONCE at the tuple level, NEVER re-canonicalized per prime or denominator. Deliverables: prove the canonical labeled tuple; pin the exact direct-CRT threshold; label-preserving local oracle; prime-power factorized master; integrate rational-time cuts; measure net state complexity exactly incl. new variables; full campaign only if the reachable tree provably fits caps. No compute-budget increase. No GLOBAL-WITNESS; BASE-SURVIVOR -> D20-R. LRC(13) OPEN.
D25 PARTIAL: rational-time cut proved, clauses compound super-constantly
This is the turn from a constant factor to a compounding one. A proved rule says that for any rational time a counterexample must have a runner near the origin, which gives an exact clause on the speeds modulo just that time's denominator, with no giant shared clock. The decisive difference from the previous gate is that adding many such separate clocks multiplies the pruning instead of only shifting it by a fixed amount. Measured on the states the earlier search actually reached, a few dozen well-chosen rational times cut a four-thousand-state sample down to a handful, and the measured rate projects a few hundred clocks to shrink the whole search below the fixed limits. That is a real qualitative gain. It is still partial, not finished: a few sampled states survive the current pool of clocks, and the cost of holding all the clauses together has not yet been measured within the limits. So the direction is validated but the whole search is not yet certified to fit. No configuration survives and no counterexample is claimed. LRC(13) remains open.
D25-PARTIAL. Rational-time cut THEOREM proved: for reduced a/q, B(a,q)={ r : min(a r mod q, q - a r mod q) < q/14 } (strict boundary lonely, integer-exact); counterexample improper => OR_i [ V_i mod q in B(a,q) ] for every a/q; contrapositive cuts a branch lonely at a/q; one disjunction per single modulus, no LCM. B(1,14)={0} = D24 t=1/14 cut, p=197 fires. Multi-modulus master keeps moduli separate, gcd-consistent. MEASURED super-constant compounding: greedy hitting set ~32 rational times reduced a 4000-branch reachable sample to a handful; per-clause survival ~0.95 projects ~555 clauses to bring 2^84 reachable space below 2^42 caps (vs D24 constant factor). verify_d25_v1/v2 ACCEPT, corruption_d25 224/224 (191 rebuild, 18/18 mandatory). PARTIAL: finite pool leaves a few survivors; multi-modulus master SAT/decision-diagram cost at full clause count not yet certified within caps. No BASE-SURVIVOR, no GLOBAL-WITNESS, no LRC claim. LRC(13) OPEN.
D25 opens: adaptive rational-time separation, no giant common modulus
The fixed clocks helped but only by a constant factor, so the next idea is to stop using a fixed handful of clocks and instead invent new ones on the fly, aimed at whichever branches are still alive. Each new clock is a rational time whose denominator is chosen to separate the surviving states, and every real counterexample must have a runner near the origin at that time. The crucial discipline is to keep every clock separate, linking them only loosely through common factors, and never to fold all the denominators into one enormous shared modulus, which would just bring back the earlier explosion. The gate measures, on the states the previous search actually reached, which of these adaptive clocks cut real branches, how much they shrink the search, and how expensive the proofs are, on their own and combined with the arithmetic checks. Nothing about the conjecture is decided by opening this gate, and no larger compute budget is authorized. LRC(13) remains open.
D25 (Adaptive Rational-Time Separation) OPENS. Instead of the three fixed denominators, generate rational-time cuts adaptively on surviving branches: for t=a/q, B(a,q)={ r mod q : dist(a r, q Z) < q/14 }; every global counterexample satisfies OR_i [ V_i mod q in B(a,q) ] for every chosen rational time. Keep moduli SEPARATE, couple only via gcd; NEVER a single giant LCM (returns to state explosion). Measure DIRECTLY on the D24 reachable-state ledger: which rational-time clauses cut branches, real state reduction, proof size, SAT/decision-diagram cost, effect combined with the D23 arithmetic cuts. MANDATORY regression: p=197 base cover YES, t=1/14 lonely YES, adaptive early cut FIRES. No compute-budget increase. No GLOBAL-WITNESS; BASE-SURVIVOR -> D20-R. LRC(13) OPEN.
D24 PARTIAL: fixed-level cuts effective on reachable states, constant factor
The proved early cuts were run where it matters, on the real states the search reaches rather than on random candidates. On that real distribution the fixed checks at the level fourteen, twenty-eight and forty-two clocks remove more than half of the states, and the p=197 example is thrown out at level fourteen exactly as required. This is honest, measured progress. But the reduction is only by a constant factor: cutting half of a very large space still leaves a very large space, beyond the fixed limits. So the search closes on the branches tested but not as a whole, and open branches remain. The remaining size figure describes the current setup, not a hard floor for every possible method. No configuration survives and no counterexample is claimed. LRC(13) remains open.
D24-PARTIAL. Global mod-84 = lcm(14,28,42) state; exact t=1/14 cut (counterexample needs >=1 V_i divisible by 14, verified on p=197). CRT couple mod 84 with each prime (>7) -> mod 84p; refined subproblem REFINED-MATCH/REFINED-EMPTY-CERTIFIED/OPEN-INCOMPLETE. MEASURED on the reachable mod-84 distribution (NOT random): fixed refinement test-times at 14/28/42 cut 55.3% of reachable states; p=197 cut at level 14. Constant-factor pruning: mod-84 space ~2^84, residual ~2^83 vs caps ~2^42 (a scale indicator for the current architecture, NOT a proof every exact representation must materialize that many states). verify_d24_v1/v2 ACCEPT, corruption_d24 204/204 (170 rebuild, 19/19 mandatory). Exact closures on tested branches, certified OPEN branches remain. No BASE-SURVIVOR, no GLOBAL-WITNESS. LRC(13) OPEN.
D24 opens: run the proved cuts on real reachable states
The early cuts are proved safe and prune strongly on a sample, so the next step is to run them where it matters: on the actual states the search reaches, rather than on random candidates. D24 does exactly that. It carries one shared clock residue, a single global pattern modulo eighty-four, which is the least common multiple of the level fourteen, twenty-eight and forty-two grids, and it never re-chooses that pattern separately at each prime. On those real reachable states it measures how much the proved cuts actually prune. Nothing about the conjecture is decided by opening this gate, and no larger compute budget is authorized. LRC(13) remains open.
D24 (Early Cuts on Reachable States) OPENS. Enumerate the REAL reachable states from the global master and apply the D23-proved early cuts (Branch A + B) to them, carrying ONE global residue multiset modulo 84 = lcm(14,28,42), never re-chosen per prime (one common small-modulus clock). Measure the pruning on the actual reachable-state stream (not a random sample), the branching, certificate cost, surviving-state count and projected campaign cost. The 5000/5000 and 7/7 D23 figures remain BOUNDED PILOT MEASUREMENTS, not a statement about all reachable states. No compute-budget increase. No GLOBAL-WITNESS; BASE-SURVIVOR -> D20-R. LRC(13) OPEN.
D23 PASS: early cuts proved sound and prune before reconstruction
For the first time in this stretch the attack takes a forward step. Two independent global checks were built that fire before the expensive reconstruction step, and both are proved safe: neither can ever discard a genuine counterexample. The first checks whether a candidate could even come from thirteen bounded integer squares, using classical inequalities among symmetric functions. The second checks whether the object already fails on the finer level-fourteen time grid, the exact place where the p=197 example died, which it does as required. On a bounded pilot both checks were strongly effective before reconstruction, exactly where the previous approach had none. This establishes an effective early-pruning mechanism. It does not by itself decide the conjecture or close the whole search: whether the strong pruning makes the remaining search small enough to finish within the limits is the next open measurement. No configuration survives and no counterexample is claimed. LRC(13) remains open.
D23-PASS. Cut soundness THEOREM proved: each early cut is a necessary condition for a bounded counterexample; their combination preserves it. Branch A arithmetic realizability (positivity, per-degree bounds, exact Newton + Maclaurin, Newton-identity power sums, auxiliary-modulus square-splitting sieve, primitivity/multiplicity). Branch B refinement levels 14/28/42 via level-l properness on {j/(lp)} without reconstruction; mechanism t=1/14 lonely iff 14 does not divide any speed. MANDATORY regression VERIFIED: p=197 base cover YES, level-14 PROPER (280 lonely, first t=1/14), early cut FIRES at 14. PILOT MEASUREMENTS (bounded sample, NOT all reachable states): Branch A cut 5000/5000 random candidates; Branch B cut 7/7 realistic base covers at 14, both before 2H where D22 had zero. verify_d23_v1/v2 ACCEPT, corruption_d23 190/190 (159 rebuild, 16/16 mandatory). Effective pruning MECHANISM established; full compatible-state campaign OPEN (does pruning bound the surviving set within caps). No BASE-SURVIVOR, no GLOBAL-WITNESS. LRC(13) OPEN.
D23 opens: apply global realizability cuts BEFORE reconstruction
The D22 limit came from waiting until the very end to apply a genuine global check. The correction is that more than one global check is available early. A symbolic state can be ruled out long before the whole tuple is reconstructed, either because its numbers cannot arise from thirteen bounded integer squares, or because it already fails on the finer time grid at level fourteen, the exact place where the p=197 example died. D23 runs both early checks in parallel: an arithmetic branch that tests realizability from thirteen integer squares using classical inequalities among symmetric functions, and a refinement branch that carries the state on the level fourteen, twenty-eight and forty-two grids and certifies whether a finer cover can still hold. The required regression is concrete: the p=197 base cover is proper at level fourteen, so the early cut must fire there, well before any full reconstruction. No compute budget increase. Nothing about the conjecture is decided by opening this gate. LRC(13) remains open.
D23 (Early Global Realizability Cuts) OPENS. Two parallel branches applied BEFORE 2H. Branch A arithmetic realizability from 13 bounded integer squares: per-degree coefficient bounds, Newton + Maclaurin inequalities, power-sum/Hankel (moment) positivity, square-splitting modulo auxiliary moduli, primitivity + multiplicity constraints. Branch B early impropriety on refinement grids: carry the global residue mod (14,28,42) with the residue mod p and certify refined-cover feasibility at levels 14/28/42 without reconstructing the integer tuple. MANDATORY regression: p=197 base cover YES, p=197 level-14 PROPER, D23 early cut FIRES (before full CRT reconstruction). Nonnegotiable: never wait for full reconstruction to ask whether a symbolic state is 13-integer-square realizable or survives level 14. No compute-budget increase. No GLOBAL-WITNESS; BASE-SURVIVOR -> D20-R. LRC(13) OPEN.
D22 PARTIAL: implicit architecture proved sound; CRT alone prunes nothing
The implicit approach was built and tested, and it comes with a proof of safety: no proof-carrying cut can ever discard a real counterexample, because a real counterexample matches the local test at every prime. On a bounded pilot the engine behaves correctly on every required case, stays honest about timeouts, and passes two independent checkers and a full attack suite. But the measurement is clear about the limit. Matching fingerprints prime by prime removes nothing on its own, because separate primes carry independent information, so the number of surviving states is still the full product until a genuine global check comes in. If that check is only the final reconstruction step, the count explodes again exactly as before. So D22 closes the impossible regions but not the whole space. Nothing about the conjecture is decided. No configuration survives and no counterexample is claimed. LRC(13) remains open.
D22-PARTIAL. One-way soundness THEOREM proved: a bounded counterexample survives every certified cut (empty-certified/applicability/square-splitting cuts each exclude it; O-A base-cover-everywhere). Engine: coefficient master E_j + root master X_i; local subproblem via the D21 narrowed oracle (MATCH-WITNESS/EMPTY-CERTIFIED/OPEN-INCOMPLETE); proof-carrying cuts; reconstruction -> BASE-SURVIVOR only. verify_d22_v1/v2 ACCEPT, corruption_d22 179/179 (148 rebuild, 16/16 mandatory). MEASURED CRUX: cross-prime CRT compatibility ALONE prunes nothing (independent moduli => full product), reconstruction/square-split cut fires only past 2H (1946 bits) => implicit master grows as prod|Sigma_p| >= 2^519 before threshold, same wall as D21-S. Cuts close proper/non-cover regions; the compatible-unreconstructed bulk stays OPEN. No BASE-SURVIVOR, no GLOBAL-WITNESS. LRC(13) OPEN.
D21-S accepted; D22 opens, keep the global object symbolic
The blocked-seeding result is accepted, with one careful correction of scope. D21-S proved that the two ways we built to list every starting fingerprint are astronomically large, but that does not prove every method is blocked. The product of the per-prime fingerprint sets is not a state space anyone is forced to write down; constraints that link the primes can rule out most states before they are ever generated. So the next gate reverses the order once more. Instead of listing all starting fingerprints and then filtering, D22 keeps the unknown bounded object as symbols, projects it onto one prime at a time, asks the fast narrowed local question, and cuts away impossible states with a proof for every cut. Two symbolic pictures are tried side by side, one on the coefficients and one on the squared speeds. Nothing about the conjecture is decided by this step. The seed-completeness theorem still stands, no configuration survives, and no counterexample is claimed. LRC(13) remains open.
D21-S-BLOCKED ACCEPTED, scope tightened: the two explicit MATERIALIZATION routes (Cartesian small-prime seed bank; meet-in-the-middle 6+7) exceed caps; this does NOT prove all implicit methods blocked (product of local signature sets is not the mandatory state space; cross-prime constraints may prune most states pre-generation). D22 (Implicit Global-Signature Elimination) OPENS: do NOT materialize the initial signature family; keep the bounded global object SYMBOLIC while prime constraints are added. Two master representations piloted in parallel: coefficient master on E_j=e_j(V_1^2..V_13^2); root master on X_i=V_i^2. Loop: project symbolic state to prime p -> narrowed local feasibility subproblem returning MATCH-WITNESS / EMPTY-CERTIFIED / OPEN-INCOMPLETE -> generate an exact cut. Every pruning cut requires a theorem + proof hash. No compute-budget increase. No GLOBAL-WITNESS; BASE-SURVIVOR -> D20-R. LRC(13) OPEN.
D21-S seeding: completeness proved, generation cost-blocked
D21 removed the per-query wall, and the remaining question was seeding: how to build the complete set of starting fingerprints without going back to full enumeration. Two routes were built and measured against each other, a meet-in-the-middle split and a small-prime seed bank that carefully keeps both the applicable and inapplicable cases. The good news is a proof: every real counterexample must leave at least one starting fingerprint that a complete scan would keep, so seeding cannot silently drop a counterexample. The hard news is measured cost: the number of distinct fingerprints grows explosively, from six at one small prime to over fifteen thousand at the next, and the complete set is their product across enough primes, which is astronomically large. Both routes exceed the fixed resource limits. So the seeding step is blocked by cost, not by mathematics. This mirrors the earlier direct route: the attack is architecturally sound but computationally blocked, one level deeper. No compatibility conclusion, no survivor, no counterexample. LRC(13) remains open.
Seed completeness THEOREM proved: every bounded counterexample enters >=1 retained seed (O-A base cover at every prime; applicable branch keeps full-13-multiset signature under complete enumeration, inapplicable branch records p | speed-product via FA-OB; carries padding, QR-scale orbit, perm/sign by squaring, duplicate roots, all singular strata). Routes: A meet-in-the-middle 6+7 (join by coverage complement); B small-prime seed bank with explicit applicable/inapplicable branching. Both 3-valued (SEEDS-COMPLETE/EMPTY-CERTIFIED/OPEN-INCOMPLETE), cap->OPEN. MEASURED: |Sigma_23|=6, |Sigma_29|=15511; complete Route-B seed set = prod|Sigma_p| over ~70 small primes to pass 2H >= 2^519; Route-A half-space ~3e15..5e17 at p=2267. Verdict D21-S-BLOCKED (both complete routes exceed 6GiB/48GB caps). Theorem holds; complete seed set too large. verify_d21_seed_v1/v2 ACCEPT, corruption_d21_seed 172/172 (142 rebuild, 15/15 mandatory). No GLOBAL-WITNESS, no BASE-SURVIVOR. Future unblock: proved sparsity of realizable global signatures applied lazily, or a larger authorized budget. LRC(13) OPEN.
D21 OPEN, signature-narrowed certified compatibility
D20 was blocked because it asked for the complete local-cover universe before any cross-prime information narrowed the query. D21 reverses the order: fix a partial global signature first, then ask only for local covers compatible with it. Two things carry it. The padding correction: a full thirteen-speed cover is a small core plus filler, and the filler is not harmless because it shifts the very fingerprint the compatibility test relies on, so the oracle must query the full multiset. The narrowed oracle: once a target fingerprint is fixed, the covers are pinned to a small family found by a fast scan, cost linear in the prime rather than the blocked full enumeration; measured on the hard primes up to 2267, each query finishes in a fraction of a second with a replayable certificate. Every query still answers matches-complete, empty-certified or open, a solver refutation without a checkable proof is invalid, and a timeout is open. The honest boundary: the per-query wall is gone, but seeding the whole campaign at the first prime is still open, so no campaign verdict is claimed. LRC(13) remains open.
Padding decomposition PROVED: every 13-multiset cover = minimal core + padding; padding updates e_j via (Y-w^2) factors, changing multiplicity, symmetric coefficients, projective orbit and CRT congruences => full-multiset queries required (brute-verified p=23: 66=66). Narrowed oracle: full signature pins {V_i^2} up to the QR scale action, so all matches found by scanning (p-1)/2 scales, O(p); measured < 0.35s on D20-hard primes to 2267. 3-valued MATCHES-COMPLETE/EMPTY-CERTIFIED/OPEN-INCOMPLETE, exhaustive-scan certificate; partial-signature SAT/ILP backend requires VeriPB/LRAT/Farkas proof, UNSAT-without-proof invalid, timeout OPEN. verify_d21_v1/v2 ACCEPT, corruption 158/158 (126 rebuild, 17/17 mandatory). Pilot PASS incl mandatory padding-required case + timeout injection. Campaign feasibility OPEN: first-prime signature-set seeding still ~D20 unless meet-in-the-middle built + measured. No GLOBAL-WITNESS. LRC(13) OPEN.
D20 BLOCKED, machinery built, enumeration blocked at scale
D20 built the full prime-product lift machinery and then hit a computational wall. The upstream reduction was frozen and independently re-checked with no mismatch. The key correction is that a single-prime cover is a necessary clue for a counterexample but not proof of one, since finer time grids can break it, so the search became a sound one-way filter with mandatory refinement. The applicability, normalization and reconstruction rules were proved and the whole engine, projective atlas, three-valued oracle and complete generator were double-verified. But the decisive fact is measured, not assumed: complete local-cover enumeration does not finish within the resource limits for the required primes, so every campaign block stays open and nothing is certified closed. This is an honest cost-driven block, like the earlier D6 campaign, and it is not a compatibility claim, not a counterexample, and not a solution. The next gate reverses the search order. LRC(13) remains open.
Frozen: reduction predicate LRC(12) & (forall p: J(13,p)=0) & prod p >= B13 => LRC(13); D6 V1/V2 ACCEPT, no restart. O-A: global counterexample => base cover at every p (necessary), but base cover =/=> obstruction (p=197 witness base lonely 0, level-14 lonely 280, proper); sound outer relaxation + refinement escalation. O-B/O-C/O-D: applicable iff p divides no speed; sign via squaring; one global QR scale (no independent per-prime); H_V(Y)=prod(Y-V_i^2); 294-prime inventory [191,2267] > B13*2H. Engine + projective atlas (all strata, no division) + 3-valued oracle + least-uncovered exact-cover generator (complete for minimal, brute-checked) all double-verified; corruption 100..158/... rejected. D20-BLOCKED measured: complete enumeration exceeds caps for p>=191, 10/10 inventory-head blocks OPEN, certified product 0 bits vs 2H 1946 bits. No GLOBAL-WITNESS, no BASE-SURVIVOR. LRC(13) OPEN.
D20 OPEN, simultaneous prime-product lift
With every per-prime route closed as insufficient, D20 opens on the only remaining question. A real counterexample would have to be one single bounded set of 13 speeds that passes the cover test at many primes simultaneously, enough for their product to exceed the frozen reconstruction threshold. Picking a different cover at each prime is not allowed, it must be one global configuration. The work begins by independently re-checking the upstream reduction that defines this threshold before any search. LRC(13) remains open.
Target: rule out one bounded global 13-multiset U inducing compatible local covers across a certified prime family P with product > B13 = 7^156*13^143, or surface one CRT-compatible bounded global witness. Representation: monic root polynomial F_p(X)=prod(X-r_i) mod p; a global tuple induces compatible symmetric-coefficient residues via CRT. Mandated phase 1: freeze + independent replay of D6 reduction and D7R alignment (predicate mismatch => D20-RESTART); no inherited cost proxy/DFS semantics reused without replay. Per-prime program closed as insufficient. No properness prefilter; no support-6. LRC(13) OPEN.
D19 REFUTED, per-prime cyclic-cover infeasibility is false
Returning to the exact source object, thirteen shifts of the bad set really can cover the whole group at individual primes. Explicit covers exist at 48 of the 109 primes, including an exact non-tight improper vector at p=197. These single-prime covers are exactly what upstream enumeration finds and are not real counterexamples, they are eliminated only by requiring one configuration to cover across many primes at once. So both per-prime methods, moment and cover, cannot settle the conjecture. The only remaining route is the prime-product lift. LRC(13) remains open and is not disproven.
Equivalence: improper <=> 13 cyclic translates of B cover G=Z/(p-1). Fractional cover = (p-1)/|B| ~ 7 (all 109, <<13, closes nothing). Greedy integer cover <=13 at 48/109 primes (verified). Witness p=197: 13 distinct non-tight speeds, 0 lonely times, p0=0, B5=0 -> corrects D18 (adaptive dual also fails per-prime; the 20459-vector no-counterexample search was sampling-bounded). Only route = prime-product lift B13=7^156*13^143. V1/V2 ACCEPT, 78/78 corruption.
D18-J PARTIAL, D18 closed as exact reformulation, D19 opens
The region no adaptive certificate covers is exactly the zero-loneliness moment cone. Integer histograms with zero loneliness survive the current outer constraints, and no real counterexample was found in bounded search, but separating real speed vectors from these histograms stays open. D18 closes as an exact reformulation of the remaining obligation, not a solution. The next gate returns to the exact cyclic-covering source. LRC(13) remains open.
Uncovered region U = {S: B5(S)<=0} = moment cone of distributions on {1..13}. Outer polytope from proved bounds still admits p0=0 integer histograms (HISTOGRAM-ONLY). Per-realized-point cover holds (pinned S2..S5 excludes p0=0). No real B5<=0 in 20459-vector search. Missing cut = exact realizable (S2..S5) polytope. V1/V2 ACCEPT, 73/73 corruption. D18 PARTIAL; D19 exact cyclic cover opens.
D18-I PARTIAL, 46 exact dual vertices and primal-dual proved
The adaptive fifth-order dual is now a finite exact object, exactly 46 rational vertices, and the best adaptive bound equals the smallest loneliness probability consistent with the first six moments. On every tested case ten of these certificates suffice, but a proof for all achievable cases is still open. The search used no properness assumption and found no counterexample. LRC(13) remains open.
D5 polyhedron -> 46 exact vertices (C(14,6)=3003 bases). B5 = max_v L_v(S) = min mu_0 matching S0..S5, verified. B5(D18-E)=5/98, B5(D18-H refuter)=487/3528, B5(p0=0 ctrl)=0. min B5=3/98 over 20459 non-tight vectors (no proper filter), 10-vertex empirical cover, both validation-only. Full realizable cover OPEN. V1/V2 ACCEPT, 69/69 corruption.
D18-H REFUTED, fixed signed degree-5 fails, adaptive route
The fixed signed fifth-order closure is refuted by an exact real vector at p=197, and the signed inverse theorem fails as posed. Degree-5 remains necessary. The validated new direction is the adaptive fifth-order dual, choosing the best certificate per vector, which holds on every case tested. A uniform adaptive proof over all vectors remains open. This negative result is published in full. LRC(13) remains open.
Exact refuter u at p=197: fixed Bonferroni M5 = -20/49 < 0 while proper (p0=8/49), adverse A5=S5=129/98 but non-tight, best degree-5 = +0.138. min best-deg5 over ~20000 proper non-tight vectors ~ +0.02 (= p0 at minimizer). Fixed M5 and signed inverse both refuted, best per-vector adaptive degree-5 validated-bounded, uniform proof OPEN. Two verifiers ACCEPT, 65/65 corruption.
Degree-4 refuted, support-5 necessary, coherence cut
An honest counterexample proves a fourth-order certificate can never close the generic branch and the fifth order is the minimal level needed. The support-5 machinery is built and verified. Three natural structural cuts are proved degenerate, and coherence separates the already-handled tight family from the residual, whose control is the still-open signed Fourier bound. LRC(13) remains open.
p=197 witness best degree-4 bound 0, degree-5 recovers 5/98. kappa5 10-partition identity, tensor Fourier, adverse slope -1, witness control. r_{5,H} saturates to 12, support-5 relations dense, mass diffuse, coherence = P5_net/P5_absmass separates tight (1.0) from residual (<0.1). Two verifiers ACCEPT, 62/62 corruption.
Support-4 projective framework opened
The projective method now extends to four-coordinate relations, exact at four small primes, full closure and support-5 remain open.
Support-4 orbit identity (verified p=43), lattice det p, connected 4th cumulant, tau4 < 8/1000 at p=191/193/197/199.
Support-3 closed on the complete universe
Scanning every triple at every one of the 109 primes shows the worst tail is 0.010377 at p=353, correcting both earlier estimates.
Full (p-1)^2 triple universe, exact punctured cumulant, tau3 < 11/1000, supersedes 9/1000 (D14) and 1/100 (D15).
Modular rank correction (F_p, not Q)
A load-bearing correction: structural dimension must be counted modulo p, because the relations hold modulo p. The earlier rational-rank inference was withdrawn.
R u = 0 mod p with u != 0 implies rank_Fp(R) <= 12, so dim_Fp ker = 13 - rank_Fp >= 1, the D15 'generic additive dimension 0' was withdrawn.
Verifier margin reconciliation
Two reported margin numbers were the same quantity measured on two different test vectors, not a mismatch.
+0.1158 / -8.358 = degree-5 Bonferroni punctured dual margin M5 on the AP vector (11/95) vs the tight vector (-794/95).
Projective relation directions and lattice tail
Repeated scalar copies of a relation are compressed into one projective structural direction with a canonical height.
Exact orbit-mass identity sum prod Bhat = sum_D A_p(D), relation lattice det p with exact l-infinity shortest vector.
Connected-support purity lemma
Every correlation splits exactly into a genuine structural relation and a deterministic finite-field term.
kappa_S = [p/(p-1)] sum primitive relation frequencies - (1/(p-1))(1-beta)^|S|, verified kappa_direct == kappa_fourier.
Non-tight margin becomes an exact deficit sum
The gap on the hard (non-tight) side is rewritten as an exact finite sum over pairs and triples of speeds.
Dual-deficit identity margin = sum_{j<=5}(-1)^j mu_j*, per-edge pair correlations, Bonferroni-alternating signs.
Tight side closed uniformly across primes
The tight configurations reduce to 16,171 exact orbit classes, closed at p=191 and transferred uniformly to all primes above 182.
Exact k=13 orbit count 16,171 via fold-class multisets, uniform lattice-point transfer covers all p>182 (P0=78).
Research scan complete, k=9 reproduced
Upstream sources audited and compiled, the k=9 case was reproduced locally, matching the published result exactly.
Four upstream repos cloned/compiled, k=9 output identical to result_10, product-over-primes threshold re-checked with exact integers.