# lebesgue-verification-xuanheng

**Arm:** 懸衡 (Xuán Héng) / AMRAL Research Lab
**Started:** 2026-09-24, at Neo.K's direction, once the curated Lebesgue pages were complete.

An independent recomputation and reproduction arm pointed at the AMRAL Lebesgue
Universal Covering / Finite Closure line (LUC-FC) — an instrument, not a
co-author.

This arm is the counter-proof side of a twin pair; the proof side is 墜衡
(`collatz-verification-zhuiheng`, `bsd-verification-zhuiheng`). On this line the
split into proof and counter-proof obligations is deliberately deferred to the
end. The first phase is plain:

- follow the documents in their own order, Round 00 → Round 37, then the four
  methodology tracks;
- recompute every finite claim independently — never by re-running the
  author's script;
- reproduce every construction, and read every theorem-level step against the
  source it cites, instantiating each hypothesis;
- one gate, one report, one mutation drill per round; every drill has controls
  that must not trip.

## What this arm does not claim

**Nothing here is a statement about the Lebesgue universal covering constant**
until a round has measured it, and then only at the strength that round
measured. Verdicts are kept apart and never merged:

`PASS` · `PASS by cited theorem` · `PARTIAL` · `UNMEASURED` · `FAIL`

`UNMEASURED` is a real verdict and often the honest one.

## Where the subject lives

| side | what | pinned by |
| --- | --- | --- |
| archive | branch `agent/lebesgue-finite-closure`, two zips, committed byte-unmodified | size, SHA-256, git blob id — [`code/corpus.py`](./code/corpus.py) |
| curated | [amral.evemisslab.com/lebesgue/](https://amral.evemisslab.com/lebesgue/), 42 documents | byte-identical to the archive — [RUN-001](./reports/RUN-001-CORPUS-IDENTITY.md) |

| archive zip | size | SHA-256 |
| --- | ---: | --- |
| `AMRAL_Lebesgue_Finite_Closure_Round.zip` | 57,576,727 | `af850b6d09e9c77e…` |
| `AMRAL_LUC_FC_Round_37_Package_v0.1_corrected.zip` | 29,948,807 | `942a79b10add0c98…` |

Together: **1,459 leaf files, 401.6 MB**, nested zips included. Every leaf's
SHA-256 is in [`data/SOURCE_MANIFEST.v1.json`](./data/SOURCE_MANIFEST.v1.json).
This tree reads the archive through `code/corpus.py`, in memory; nothing is
extracted, so the originals cannot drift.

## Rounds

| round | subject | verdict |
| --- | --- | --- |
| [RUN-001](./reports/RUN-001-CORPUS-IDENTITY.md) | corpus identity — curated documents vs archived originals | **PASS** — 42/42 byte-identical; drill 220/220 |
| [RUN-002](./reports/RUN-002-ROUND00-BASELINE-AND-INTERFACE.md) | Round 00 — the external baseline and the support-function interface | **PASS**; `OPEN`: `E(2)` written, rotations + translations meant — material for chiral test bodies; `PARTIAL`: baseline currency (arXiv only) |
| [RUN-003](./reports/RUN-003-ROUND00-GOVERNANCE.md) | Round 00 — its canonical-source rules (§25) and claim ledger (§21.6), measured on all 42 documents | §25 **PASS**; §21.6 **FAIL** as conformance — 89 of 758 judgments use the ten statuses; `PASS` (118) and `PROVED` (72) do not. Status registry opened (census v2, corrected the same day; census v3 after Round 17 read two more shapes, 18 judgments, and v4 after Round 18 statuses joined by '+', 5 more; census v5 after Round 19, from a sweep of the whole corpus for every missed form of a position already read, 229 more, 54 of them in rounds already read and reviewed in one table; each merged into the registry) |
| [RUN-004](./reports/RUN-004-ROUND01-REDUCTION-CHAIN.md) | Round 01 — the reduction chain to curvature-radius densities, and the placement compiler | **PASS** — 13 PASS, 14 PASS by cited theorem (sources named here), 2 UNMEASURED (pre-corpus items), 11 n/a; RUN-002's `OPEN` closed at definition (reflection branch σ explicit), carried as a watch item; all 8 external references verified |
| [RUN-005](./reports/RUN-005-ROUND02-FINITE-COMPILER.md) | Round 02 — the finite shape compiler (Jackson smoothing, interiorization, quantization, finite legal dictionary) | **PASS**; `E_N` valid and ~6.5× conservative (exact kernel moments), ~11× on the Reuleaux triangle; §32's sanity numbers reproduced from exact multipliers; one displayed digit wrong (`0.77710000…` is `0.7771000125…`), pinned. Every `PROVED` in Round 02 is analytic |
| [RUN-006](./reports/RUN-006-ROUND03-PLACEMENT-CERTIFICATE.md) | Round 03 — the fixed-cover placement certificate (reflection branches, translation duality, grid LPs, the full bracket) | **PASS**; the reflection watch item is honoured, and a constructed chiral pair shows why it must be: rotations alone are *proved* to fail where a reflection fits; Theorem 17.1 attacked on random instances, no violation; §30's sanity example reproduces but could not have failed (its margin is −0.02 at every orientation, fixed by the cover's minimal width) |
| [RUN-007](./reports/RUN-007-ROUND04-COVER-COMPILER.md) | Round 04 — the candidate-cover compiler (disc anchor, radius bound, outer polygon, area inflation, the finite polygon bracket) | **PASS**; bounds safe and 13–136× loose; §33's recorded polygon is the definition's plus one extra level at six on-grid normals (floating-point ceiling) — reconstructed to 10⁻¹² and pinned. Done blind to the DLMVC audit of Round 04, compared later |
| [RUN-008](./reports/RUN-008-ROUND05-SATURATION-GATE.md) | Round 05 — the saturation gate (the finite-witness functional `Λ`, the ladder `λ_m`, no false saturation, cell area lower bounds and prunes) | **PASS**; every theorem-level step checks; §9's continuity bound holds but is loose by π (`Per ≤ 4Ā`, nearly attained); the cell bounds are safe on 20 cells of this tree's own. The package's `LB_env` is a quadrature — four of five values sit above the exact integral, by ≤ 1.4×10⁻⁹ — and its sanity assertion cannot see `LB_outer` lose its `Per·ε` term, which a straight-edged cover inside `C_Ā` exposes. This tree's own example: `Λ({D, RT}) = π/8 + √3/4`, so `λ₂ ≥ 0.8257`. (The envelope routine behind its exact areas was corrected the same day; results unchanged) |
| [RUN-009](./reports/RUN-009-ROUND06-WITNESS-EXCHANGE.md) | Round 06 — the finite witness exchange compiler (compact minimizer set, uniform violation margin, separating batches, eventual success, dominance) and its seed ladder | **PASS**; all eight `PROVED` hold. The seed rebuilt exactly: `Λ(D, B₃) = Λ(D, P₃) = π/8 + √3/4` (Round 06 writes `≥`: the upgrade is null at rung two); at rung three it is strict, ≥ 0.000803. A search that could refute Mishra's 0.8344 finds his optimum 0.83478095 and nothing below; `δ_{D,B₃}` exact from Round 03's LP; §20's abstract modulus exact on the seed. Xie cited by a stale title (v1/v2), pinned; Pál 1920 and Gibbs 2014 missing from the references |
| [RUN-010](./reports/RUN-010-ROUND07-MINIMIZER-ATLAS.md) | Round 07 — the threshold-conditioned minimizer atlas and witness lifting (cell-local lifts, witness switching, robust transfer), and the first milestone `T₁ = 0.835` | **PASS**; the three theorems hold (the transfer's cost loose by π). Every external number checks against Mishra's paper and his repository at the cited commit. Fixed-seed lifts rebuilt exactly — the ranking `B₇ > B₁₁ > B₁₃ > B₉` holds, but the recorded `B₁₃` value is not a minimum (6.2×10⁻⁵ too high). An 8-D search puts `Λ(D, B₃, B₅, B₇) ≤ 0.8364914`, below the logged optimum and far above 0.835: gate R07-G1 not refuted. The 5.527×10¹² cost rebuilt exactly; its digits depend on the anchor |
| [RUN-011](./reports/RUN-011-ROUND08-CONDITIONAL-LIFT.md) | Round 08 — the conditional-lift certificate compiler (motion bound, common-core theorem, Reuleaux erosion, nested base/lift soundness, the verifier's grammar) for the `0.835` milestone | **PASS**, one gap in a specification; the five `PROVED` hold (Mishra's Lemmas 21–22 generalised; the motion bound attained to 95% on random boxes, chiral Fourier bodies included). Two hard leaves — the seed with `B₇` at its best lift, and the four-body optimum — close at half-width 10⁻⁴ with the verifier's own inner-point bound, where the base cores alone do not, and neither closes at 10⁻³. PARTIAL: a chiral fallback witness needs its mirror-image placements in the root; the text asks for them, but V3, the lift stream and the schema have no place for them (the schema drops five of §14's eleven fields). The package's sanity body barely exercises the rotation term; its verifier is a skeleton |
| [RUN-012](./reports/RUN-012-ROUND09-ADAPTIVE-ATLAS.md) | Round 09 — adaptive atlas refinement and certificate cost (cell Hausdorff radius, sharpened transfer, margin-to-resolution, exact split scheduler, representative prune, core-dominance reuse, witness dominance, depth bound) | **PASS**; everything `PROVED` holds, and every number rebuilds (`τ_root`, the one-split radii, `τ⋆ = 4.4739×10⁻⁴`, ratio 3.1404). Its R07-STRENGTHENING-001 (`Per ≤ 4 Area`) is the looseness RUN-008 and RUN-010 recorded; on the root's hulls it is within 5.3% of tight. Mishra's split rule and support pieces read at the pinned commit, as described. At RUN-011's leaves the exact common core closes cells 2.2× wider than the representative prune. Witness dominance is vacuous in a constant-width pool (such a body lies in no other set of diameter 1). A parent's core lies in its child's only 5 times in 12. RUN-011's inner points lacked the cores' corners (1–4×10⁻⁵ lost); its verdicts stand |
| [RUN-013](./reports/RUN-013-ROUND10-REFERENCE-DRY-RUN.md) | Round 10 — the reference dry run: a local base box around Mishra's seed, four base leaves, each lifted by `B₇` over its whole root, emitted as one-bit streams and replayed | **PASS**, one overstatement, one specification gap. The four streams decode (11,372 nodes, 5,688 leaves, zero padding, matching SHA-256); every leaf's exact common core clears 0.835 by ≥ 3.79×10⁻⁴; the base alone cannot prune any base leaf. The text's 96-direction bound rebuilt from the text gives the recorded slacks to 7×10⁻¹⁶ and re-emits all four files byte for byte. The split's tie-break and child order are only in the code (the other choices fail 108 and 88 leaves). With the exact bound the trees are 1.75× smaller. The verifier's core code is the emitter's, transcribed — independent only in the hull routine |
| [RUN-014](./reports/RUN-014-ROUND11-GLOBAL-SHARDS.md) | Round 11 — global atlas partition and certificate sharding (prefix-free complete frontiers, replacement, shard partition, forest identity, content-addressed shards, Merkle binding) and a reference that regroups Round 10's certificate into three shards | **PASS**, one mischaracterized forecast, one specification gap. The frontier theorems hold on random frontiers (complete iff the Kraft sum is 1); the reference shards partition Round 10's frontier with its exact boxes and bytes; every count checks. The payload digests and Merkle root re-derive only by trial (sorted compact JSON; raw-byte pairs, odd node duplicated — so a repeated largest shard keeps the root); with RUN-013's tie-break and child order, four rules a second verifier must read out of code; the reference omits §30's policy hashes. §19's depth forecast is no upper bound: 9 cycles at the global root, which contains Mishra's seed below 0.835 |
| [RUN-015](./reports/RUN-015-ROUND12-CHECKPOINT-CRYSTAL.md) | Round 12 — the checkpoint crystal (dependency fingerprint, claim and audit ledgers, stale / reject / correct semantics) and the multi-AI audit protocol, with five reference checkpoints | **PASS** for the mechanics, PARTIAL for the aggregate and the correction semantics. Every digest re-derives (canonical JSON; the arithmetic hash is the digest of {mode, fp_pad}); this tree's validator reproduces all five verdicts; the fingerprint moves with every proof-critical field and no performance one. But V3 and V4 store `theorem_ready: true` against their own ledgers (V2–V5 copy V1's aggregate), and V5 re-admits the rejected shard's unchanged bytes on an A1 PASS no replay produced — the validator never reads a FAIL audit, so §12's 'one counterexample outweighs any PASSes' is not enforceable |
| [RUN-016](./reports/RUN-016-ROUND13-AUTONOMOUS-SCHEDULER.md) | Round 13 — the proof-state scheduler and the worker / canonical-merger protocol (Certified Ancestor Contraction, Atomic Merge) and a reference race on seed 01 | **PASS** for the merge theorems and the race, PARTIAL on the ABI. Both theorems hold on 60 random sequences of the six primitives; this tree's merger and validator reproduce the race's three decisions and four states. But the reference merger never writes the aggregate (all four race checkpoints store `theorem_ready: true`, two with seeds pending), its validator turns §15's legal duplicate certificate into a coverage conflict, and the late certificate is Round 12's re-admitted bytes (sound, per RUN-013) |
| [RUN-017](./reports/RUN-017-ROUND14-SEMANTIC-REBASE.md) | Round 14 — semantic rebase (scalar margin credit, claim capacity, catalog extension, ancestor coverage), claim dominance and hot/cold proof-state compaction | **PASS** for the rules and the compaction theorem, PARTIAL on both layers. This tree's validator reproduces the capacities and all four scenarios; the archive binds Round 13's final state byte for byte. But the reference's 'global capacity' in the failing scenario is 0.8350009475, above the target it just failed (min over passing claims; the frontier's is 0.8350003445); and the hot core carries no A1 evidence, no tombstone of the FAIL against shard B's bytes, credits B-v2 with B-v1's audited slack, and names unregistered rules. (Corrected after RUN-018: the 0.8350001 scenario is unsupported — the claims' B7 lift root was sized for 0.835; the boundary tests are PARTIAL) |
| [RUN-018](./reports/RUN-018-ROUND15-CAPACITY-LADDER.md) | Round 15 — global proof capacity (max-min evidence recursion, root capacity, free promotion, deficit frontier, minimum-cost repair DP) and a phase-master root at 0.8365 | **PASS** for the algebra, PARTIAL for the reference and the ladder. The recursion and the repair DP equal brute force on random trees; the reference's evidence figures rebuild. But the local proof has a second root — each base leaf's B7 lift square, sized at t₇(0.835) — whose a-priori exclusion supports exactly 0.835: above it a sliver of B7 translations (1.06×10⁻⁶ wide at 0.83500035) is proved by nothing, so the local capacity is 0.835 and the free promotion (and Round 14's 0.8350001) is unsupported; RUN-017 corrected. The four-body optimum lies below 0.8365, so in the B7 phase the phase root never binds |
| [RUN-019](./reports/RUN-019-ROUND16-GLOBAL-PILOT.md) | Round 16 — the first pilot from the whole five-dimensional base root (phase master 0.8365, profiled toward 0.835): official against exact-τ splits, master against immediate root, a depth-18 frontier profile with a cycle proxy, B7 shallow lifts | **PASS** for the computations and the three decisions, PARTIAL for the frontier profile and its proxy. Every count, quantile, tail, top cell and probe rebuilds exactly — but only with the pilot's 40-direction contact sampling and its ties to the earlier axis, both fixed only in its code; with exact cores or the other ties the counts move and every decision keeps its direction. The sampling puts every HARD centre 1.6–5.6×10⁻³ low: with exact centres no cell is within +0.002 of the target (8 claimed). APR (the disc with a body's centre) is π/4 on the whole root and can never fire. 19 HARD cells hold configurations below 0.835 — Mishra's seed and its images under an exact mirror/turn symmetry, the two lowest cells holding its turns — and the 'conservative' proxy gives them 3–8 cycles. The shipped code did not write the shipped summary |
| [RUN-020](./reports/RUN-020-ROUND17-D3-CPG.md) | Round 17 — the residual D₃ symmetry quotient (the 60° canonical t₃ wedge, the SYM prune) and certified-prune-gain split scheduling (unrestricted, windowed, windowed from depth 10) | **PASS** for the quotient and the computations, PARTIAL for the tail-window recommendation. The group relations and the area's invariance hold, and every orbit meets the wedge inside the root box — given the a-priori exclusion \|t₅\| ≤ t₅(0.8365); every run rebuilds exactly, the schedulers only with three rules the code adds (a SYM margin, the window's override on any better key, an early stop). The D3 root's depth-16 cells are the full root's depth-18 cells: at equal cell size the quotient removes ~73% of nodes and HARD leaves, not 47% / 33%. The tail window's lower override density comes from its changed override rule; under either rule, starting at depth 10 is worse on every count than starting at the root. A stored conclusion contradicts its own data. Reading it exposed two blind spots in this tree's status census (census v3) |
| [RUN-021](./reports/RUN-021-ROUND18-SHARD-EMITTER.md) | Round 18 — the production shard checkpoint: eight D3 seed shards, preorder topology, 2-bit leaf tags, Rice-coded override events; an independent replay; a lifetime cost model | **PASS** for both checkpoints and the Rice events, PARTIAL for the grammar as specified and the cost calibration. Both certificates decode from the text's grammar with every count, digest and pending file; every CERT leaf is re-proved (exact cores clear 0.835 by at least 2.4e-3); both forests re-emit byte for byte. But the tail forest needs a lookahead that does not count SYM children as certified, so it is not Round 17's tail window (which gives 536 overrides, not 573); bit order, child order and the unary convention are stated nowhere; the shipped verifier never reads the pending frontier or checks manifest counts, and its geometry is the pilot's transcribed; the tail emitter re-evaluates every parent (5,039 of 30,229 evaluations), inflating the break-evens; §14's '4983 internal nodes' is 5,039 |
| [RUN-022](./reports/RUN-022-ROUND19-NECESSITY-LIFT.md) | Round 19 — the lazy proof cascade (APR, CORE, then REP on demand), the Tail-Window continuation 16 → 20 and its cost κ, the depth-20 sampled-centre correction, the official near-minimum branch, necessity markers and segmentation, the B7 switch curve | **PASS** for the cascade, the continuation, the correction, the branch, the necessity theorem and the segmentation, and for the switch curve as computed; PARTIAL for the τ ≈ 10⁻³ scheduler parameter. Every tree, bracket and probe rebuilds exactly — the A/B (REP 12,659 → 10,523, every accepted leaf by CORE), both continuations and the probe's evaluation counts, all 10,114 depth-20 centres (none exact-sublevel; the sampling underestimates everywhere, so the 12-candidate recheck is complete), the 51-row track (first outer bracket below 0.835 at depth 31), the 561-node segmentation with all 85 brackets, the ten B7 probes and the floor. With exact cores the B7 floor at q† is 76 open leaves at depth 12 (not 108) and 7 at depth 18 (not 412), and the excess falls as τ^0.91, not τ^0.70: the switch parameter belongs to the pilot's sampling. The shipped probe reads Round 18 from outside the package and re-evaluates parents (8–9% of its evaluations); nothing shipped produces the track, segmentation or curve. The activation policy drops a state and the marker's target. This tree's first bracket formula lost 7.5×10⁻¹⁰ to cancellation; the package's was right. Reading it led to census v5 |
| [RUN-023](./reports/RUN-023-ROUND20-MIXED-ESCALATION.md) | Round 20 — necessity-marked mixed base/lift shards (four depth-40 cells × B7/B11/B19 depth-12 partial lifts), the witness counterexample filter and B23's disqualification, witness efficiency, 3-D placement search, horizon-dependent ranking | **PASS** for the markers, the twelve lift trees and their streams, the counterexample theorem and B23 (outer 0.8349443918 < 0.835), the recorded placements, the efficiency scans, the deep comparison and every tail count; PARTIAL for the grammar as specified, the horizon ranking and "B7 full closure: NOT YET ACHIEVED". The package ships no code; the streams re-emit byte for byte only under one unstated convention (lower child first, MSB first, CERT 0). The §9 search minima are local: a 28-start search lowers B11, B13, B17, B19 and B21 (B19 by 3.2×10⁻⁴, to 9.2×10⁻⁵ above T), with no new disqualification. The sampled B7 tail keeps more open leaves at every depth (653 → 2,143), but **with exact cores B7 closes all seven marked cells tried** — three on the track (lift depths 21–25) and the four reference cells (30–34), in floating arithmetic: the escalation answers the pilot's sampling, not B7 |
| [RUN-024](./reports/RUN-024-ROUND21-LIFT-TAIL-SYNTHESIS.md) | Round 21 — the B7 lift-tail atlas on the depth-50 cell (phase lock, two lobes, the area-minimising ridge) and counterexample-guided witness synthesis (finite-tail optimism, a legal 7-fold family, smooth 7-fold, irregular and k = 3 candidates) | **PASS** for the atlas as computed (all 2,143 depth-26 boxes, every quantile and lobe statistic), the ridge's two channels, the optimism theorem and the legal family; PARTIAL for the atlas as B7's tail — **with exact cores all 2,143 boxes close (the least by 8.0×10⁻⁴) and the tree closes at lift depth 21** — and for the synthesis values, which sit 3–6×10⁻⁶ below the true minima: B7's "0.83712806" is below anything B7 attains (least found 0.8371340), and all five smooth 7-fold minima are below their bracketed areas. The package's ridge points are not minima; `mean_phi` is misnamed; §14–17's shapes are not recorded (UNMEASURED); the only script prints the package's JSON |
| [RUN-025](./reports/RUN-025-ROUND22-FOURIER-PARETO.md) | Round 22 — symmetry-breaking odd Fourier witnesses on an interiorised B7 (the curvature budget, the full-orientation oracle, the B7/B3 mixture), pure harmonics ½ + a cos kθ at 90% of their bound, and a proof-cost Pareto map from a generic support-core lift pilot on the depth-50 cell | **PASS** for the legality rules (odd-mode width, the budget — sufficient and sharp — the exact harmonic bound and reserve, the symmetry order gcd(7, S)), the full-orientation rule and the mixture example (on Round 21's image of q†, to 4×10⁻⁹), the recorded multi-mode candidate (its four minima to 4×10⁻⁶, once B7 has a vertex at θ = π, which the text never says) and the lift pilot, rebuilt node for node under an unstated boundary-motion δ; PARTIAL for the search minima, off in both directions (B7's cell-01 value lies in the other channel, 1.2×10⁻⁴ high; H13's worst is 1.5×10⁻⁵ high); **FAIL for the Pareto map's volume axis: with dense cores B7 closes the cell at lift depth 21 with 2,509 nodes, H11 and H13 need 21,029 and 43,111 (1,581 and 3,257 with the support's own motion), and H17/H19 cannot close it at any depth** — with the cell's cores their hull falls to 0.83467, below T |
| [RUN-026](./reports/RUN-026-ROUND23-PORTFOLIO-CLOSURE.md) | Round 23 — strict cell × witness incidence, the portfolio closure theorem, weighted set cover and its residual frontier, partial-edge non-composition, and a 12-cell × 5-witness pilot at lift depth 16 with a depth-22 horizon crossover | **PASS** for the grammar and its theorems (monotonicity of the hull; the cover feasible iff the frontier is empty), the twelve cells (Round 19's twelve lowest outer brackets), every B7 edge — rebuilt exactly once the pilot's sampled hull takes 96 directions instead of 40, which nothing states — the depth-22 crossover as computed, and the depth-16 infeasibility; PARTIAL for the harmonic edges (open counts on 42 of 48, node counts 26–64 high, a convention not found). **With exact cores B7 closes all twelve cells (lift depths 30–35), so a strict cover exists by B7 alone; and no harmonic can close any of them at any depth** — with each cell's cores its hull stays below T (upper ends ≤ 0.8342519) — so the round's routing to H19 sends every cell to a witness that cannot finish |
| [RUN-027](./reports/RUN-027-ROUND24-RESIDUAL-JOINT.md) | Round 24 — deep B7 on Round 23's four hardest cells, the first complete-edge certificate (cell 0, depth 30), joint-witness dominance and pointwise necessity, and the joint-admission states | **PASS** for the certificate — this tree's exact-core lift re-emits `topology.bin` byte for byte (18,555 nodes, 9,278 CERT, none pending; slack equal once the 10⁻⁹ and 10⁻¹⁰ pads are allowed for; no box within 4.15×10⁻⁹ of T) — for cells 1–3 at every recorded depth, and for the joint theorems and admission logic; PARTIAL for the tail-collapse evidence, whose depth-16 and depth-22 values are the 96-direction pilot's and the rest the exact tree's (cell 3's ×393 is ×217 with exact cores alone). **The one residual, cell 3, closes at lift depth 34** with 36,193 nodes |
| [RUN-028](./reports/RUN-028-ROUND25-CLOSURE-WAVE.md) | Round 25 — the deep B7 closure wave on all twelve reference cells (checkpoints 30/32/34/36), the budget-coverage and capacity curves, unresolved-volume monotonicity, the singleton cover and its empty joint residual | **PASS** for all twelve closures node for node (340,540 nodes, every forest identity), every one of the ledger's 58 checkpoints, the new-slack column (this tree's plus the 9×10⁻¹⁰ pad difference), cell 7's volumes, volume monotonicity on every level of every tree, and the singleton cover; PARTIAL for the closure-depth statistics: §1 defines D_j as the least complete depth, but the ledger records the first even checkpoint — six cells close a level earlier, so D_max is 35 (not 36) and the median 31.5 (not 32). The shipped runner computes the wave but loads Round 19's modules from an absolute path outside the package |
| [RUN-029](./reports/RUN-029-ROUND26-FULL-ATLAS.md) | Round 26 — the B7 wave on all 77 of Round 19's necessity cells (common depths 22→36), the residual's volumes, classes and contraction, the rejected global pad, the tight-leaf polygon and radial-core audits, and the production arithmetic contract | **PASS** for the 77 cells and their markers, the curve 0/0/0/0/7/19/38/51 (51/77 at 36), every ledger row — nodes, open boxes, volume; 4,481,119 nodes — once the lift uses the package's pad (hull − 10⁻¹⁰; under this tree's 10⁻⁹, 15 rows gain 2–4 nodes or one open box, no closure depth moves), the residual's quantiles and ratios to 10⁻¹² (largest 0.57615, all below 1), the polygon audit and the radial audit exactly; PASS as stated for §14's least slack 2.8982×10⁻⁹, which covers the ten audited trees: **over all 51 complete trees the least is 8.47×10⁻¹¹ (cell 8), 11 trees are thinner than 2.8982×10⁻⁹, and a 10⁻⁸ pad would reopen 29** — the rejection of a larger pad stands, more strongly. The five scripts load Round 19's modules from an absolute path outside the package |
| [RUN-030](./reports/RUN-030-ROUND27-INTERVAL-REPLAY.md) | Round 27 — residual continuation past the common depth 36 with lower bounds for depths 38 and 40, the rational inner-polygon theorem, directed-interval membership, and the first exact rational certificates for the five thinnest leaves of the certificate cell | **PASS** throughout. **Continued to a common depth 40 (from RUN-029's open boxes, under the package's pad), the residual gives Γ_B7(38) = 57 and Γ_B7(40) = 63 — the package's lower bounds are exact**; its 14 cells without a known edge are the 14 open at 40, every record exact; the others close at 37, 38 and 39 (the ledger records the next even depth); at 40 all 14 still contract (largest V₄₀/V₃₈ 0.608, cell 23). The twelve thinnest leaves of cell 0 certify under this tree's own integer-interval polygons (π to 60 decimals, Taylor enclosures, every step rounded outward at 2⁻⁴⁰⁰), on its boxes and the shipped ones; the package's five with the same counts and margins to 4.8×10⁻¹⁷. The shipped boxes sit 4 ulps from this tree's (root t₇ 4 ulps apart, both above the exact t₇); the φ root 2·fl(π/7) is 3.5×10⁻¹⁷ short of 2π/7, so §13's adjacent-float enclosure carries the top edge. Two certificate inputs and the prefilter's modules are not in the archive |
| [RUN-031](./reports/RUN-031-ROUND28-EXACT-ROOT.md) | Round 28 — the exact master target, a directed d⋆ and t₃/t₅/t₇, the D3 root, explicit split axes and sides (cell 0's 40 base splits, 0 overrides; a 2-bit witness axis stream), stored-vs-intended box distances, and the margin-adaptive rational-interval migration of all 9,278 leaves of cell 0 | **PASS** for the directed root (this tree's own brackets, π by Machin's formula and acos certified by an enclosed cosine, 10⁻⁹⁰ wide, lie inside the package's intervals), the base path (the official split, axis for axis; the package's distance table to every printed digit), the witness topology and axis stream (high bit first, node for node), and all 9,278 leaves on their intended boxes at the ledger's densities (the ledger's candidate counts, margins to 1.7×10⁻¹⁶, least 3.19489×10⁻⁸ on the same leaf); the binary64 translation roots all lie above the exact ones but both angle roots fall short (2·fl(π/5) by 0.22 ulp, 2·fl(π/7) by 0.32). PARTIAL for the density economics: the ledger's densities are start points from undisclosed slack bands — the least density that passes is lower for 8,457 leaves and **no leaf needs 16,384**. **This tree's exact kernel loses a piece inside one 2π/1024 grid step on one leaf (1.47×10⁻⁹ low; the package is right there)**: one-sided, so every lower bound so far stands and no compared decision rested on it; a verified envelope matches the package on all 9,278 leaves to 1.7×10⁻¹⁵, and the shared kernel is corrected in its own commit — since made: RUN-008 … RUN-031 re-run with it, no logged number moved |
| [RUN-032](./reports/RUN-032-ROUND29-MARKER-UPPER.md) | Round 29 — the 77 necessity markers moved onto Round 28's directed cells, the outer-polygon theorem, rational upper certificates for every marker, a three-marker replay by a second polygon path, and the first whole shard (cell 70: its marker above, Round 28's certificate below) | **PASS** for the marker points (each strictly inside its directed cell, no override), the outer-polygon theorem, all 77 upper certificates (the package's are upper bounds of the exact areas; this tree's own — integer-interval supports, uniform normals plus the normals of the hull's 11 bridging edges, an exact polar hull — certify all 77 with 128–256 normals), the replay (a second polygon path, not a second arithmetic) and the whole shard. PARTIAL for §11–13's rankings and densities: **the package's outer polygons lose first order in the normal spacing at the hull's straight bridging edges (up to L²d/8), so its thinnest certificate (marker 6) is not the thinnest marker (47: exact margin 1.857×10⁻⁵, marker 6's 2.11×10⁻⁵)**; marker 47's "tighter" bound is tighter only by more directions, and the densities are start bands read off Round 26's reference margins (73 passed at their start, 4 escalated) |
| [RUN-033](./reports/RUN-033-ROUND30-A1-REPLAY.md) | Round 30 — a second implementation (A1) pinned beside the first: the root replayed, marker 70 replayed, all 9,278 lower leaves of cell 0 replayed, the backend lock, the root correction, and the A1 whole shard | **PASS** for the root replay (its intervals lie inside Round 28's, and this tree's 10⁻⁹⁰ brackets inside its own; the binary64 cast behind the correction reproduces, t₃/t₅/t₇ landing 1.8–2.4×10⁻¹⁷ outside Round 28's intervals — §12's "10⁻⁶⁴" is the width of t_n's intervals, not d⋆'s), marker 70's bound, all 9,278 lower leaves (this tree's certificate, with every body's contact point in each direction, passes every leaf at the replay's densities, every margin above the replay's), the lock's script digests and its libmp pin, and the shard's records. PARTIAL for the shard's implementation-level A1 on its upper half: the marker replay is Round 29's audit row, from a script that carries the emitter's support routine, normals and density. **The replay's rule keeps, per direction, only the contact point of the body that wins it; rebuilt here it gives back the replay's density and hull-vertex count on 9,278 of 9,278 leaves, and it cuts across any body the hull exposes over less than one step (first order in the step) — so its thinnest leaf, 3.54×10⁻⁹, has 2.22×10⁻⁵ with all points: it measures the rule's loss, not the geometry** |
| [RUN-034](./reports/RUN-034-ROUND31-MPFR-REPLAY.md) | Round 31 — the cross-backend replay of marker 70's whole shard (libMPFR 4.2.2 and GMP through a minimal ctypes wrapper): the root, the marker's upper bound and all 9,278 lower leaves; the publication-candidate gate; the bulk migration queue; the backend lock and two corrections | **PASS** for the root (a dyadic d⋆ 2⁻²²¹ wide; this tree's brackets inside the A1 replay's, those inside MPFR's, MPFR's inside Round 28's), marker 70 (the MPFR polygon is the one with every constraint — 1,317 active, 22,754 / 22,755 bits, the A1 replay's — while Round 29's is the float-reduced one, 3.3×10⁻⁵⁰ away; the false negative's 0.92016 reproduces), all 9,278 lower leaves (**the MPFR ledger is Round 30's leaf for leaf, margins included: the same polygons, their membership decided again in MPFR**, so its least margin is the A1 rule's loss), the queue (its 63 cells are this tree's atlas closed by 40, each at the next even depth — 51, 57, 63 by 36, 38, 40 — and its 14 residual cells those open at 40, volumes and ratios to 10⁻¹²; every marker margin in it is null) and the lock (every shipped script pinned; the libraries' binaries are not in the archive). PARTIAL for §3's rule: **the wrapper loads each exact rational rounded to nearest and directs only the result**, so an enclosure can miss by about 2⁻⁶⁴⁰ relative — covered in practice, not by construction; this tree's integer replays do not rest on it |
| [RUN-035](./reports/RUN-035-ROUND32-BULK-WAVE.md) | Round 32 — the first bulk migration wave: cells 31, 27 and 7 continued past depth 40; cell 69's tree, mpmath and MPFR ledgers and marker (the second publication candidate); cell 47's tree and ledger (an arithmetic prototype); the stage dashboard | **PASS** for all nine judgments. **Continued here from this tree's own frontier at 40, cells 31, 27 and 7 close at 42, 43 and 45 — inside the even checkpoints 42, 44 and 46 that §1 reports — and cell 7's open volume is §1's at every checkpoint**, so the lower bounds Γ(38 … 46) ≥ 57, 63, 64, 65, 66 are this tree's counts. Cells 69 and 47 are the shipped trees node for node, and every leaf passes on its intended box at the ledger's density (margins to 2.6×10⁻¹⁶; the densities come from the start bands). Cell 69's MPFR ledger is its own winner rule, rebuilt leaf for leaf: **the escalated leaf goes from −3.07×10⁻⁹ at 32,768 to +2.535×10⁻⁹ at 65,536 — the rule's loss again, since with every contact point it passes at 32,768**. Marker 69's MPFR polygon is the one with every constraint (2,611 active), and the dashboard's counts and fractions are this tree's. The old kernel's sub-step loss recurs on one leaf of cell 69 and two of cell 47; the corrected kernel is right there |
| [RUN-036](./reports/RUN-036-ROUND33-DOMINANCE.md) | Round 33 — enclosure dominance between the two backends (the theorem and its audits), the trees of cells 48, 68, 75 and 76, cell 48's ledger and marker, the certificate entity, and the stage counts | **PASS** for the dominance theorem and its polygon corollary, the audits' state counts (1,564 and 1,574 witness-core states on this tree's lifts), the four trees (node for node, axis for axis), all 9,285 leaves of cell 48 (the ledger's densities and hull counts, margins to 2.3×10⁻¹⁶), marker 48's upper bound, the ledgers' vertex totals and the stage counts. UNMEASURED for the audits' own results, which compare mpmath enclosures with MPFR ones, and MPFR is not on this machine (PARTIAL for their root containment: t₃, t₅, t₇ yes; π and √3 not recomputable). PASS for keeping cells 47 and 48 below publication candidate, with one correction to the reason: **the ledgers keep no polygon, but this tree regenerates every leaf's certificate from its density and the emitter's rule (the hull count on 9,228 and 9,285 leaves, margins to 2.6×10⁻¹⁶)** — what is missing is a byte transcript, not the certificate |
| [RUN-037](./reports/RUN-037-ROUND34-RHCERT.md) | Round 34 — the RHCERT certificate format (header, leaf records, index), the certificates of cells 47 and 48, their sizes, cell 68's lower summary and marker, and the promotion of cells 47 and 48 | **PASS** for the format (both files decode from the specification alone; the index header, which the spec does not give, is `<8sHI` with L + 1 offsets), both certificates — **all 4,272,769 stored vertices lie in their tagged cores under this tree's integer arithmetic, every polygon strictly convex and above 167/200, the least margins the replay summaries' bit for bit** — the sizes (but §11–12's packaged "about 8.1 MiB" and "about 7.6 MiB" are 8.02 and 7.54), cell 68's lower bound (its summary's density counts exactly, from this tree's certificates under the emitter's start bands), marker 68's upper bound, the stage counts, and the promotion of cells 47 and 48, whose bytes pass here under an arithmetic that shares nothing with mpmath or MPFR. UNMEASURED for marker 68's MPFR replay and the promotion's MPFR conditions |
| [RUN-038](./reports/RUN-038-ROUND35-RHCERT-PRODUCTION.md) | Round 35 — cell 68's certificate in production, the ledgers of cells 75 and 76 and their markers, the dominance audits, the stages, and the lost depth-40 frontier | **PASS** for cell 68's certificate (every density and hull count this tree's own, all 2,126,336 vertices in their cores under this tree's integer arithmetic, the least margins bit for bit) and its promotion, cells 75 and 76 (every leaf on its intended box at the ledger's density, the first that passes from the start band), markers 75 and 76's independent replays, the audits' state counts, the stage counts and the decision to claim no geometry (a count and a volume do not give back the boxes; DFRONT's codes are sound as specified). PARTIAL for the two marker judgments that pair the independent replay with the MPFR one, whose record is not shipped and whose arithmetic is not here |
| [RUN-039](./reports/RUN-039-ROUND36-DFRONT.md) | Round 36 — the certificates of cells 75 and 76, the DFRONT frontier format and cell 33's recovered depth-36 frontier, cell 49's depth-32 tree, and the depth-32 queue | **PASS** for all eight judgments: cells 75 and 76's certificates (all 2,627,357 and 2,617,252 vertices in their cores here, the least margins bit for bit) and promotions; **cell 33's DFRONT file is this tree's own lift of cell 33 to depth 36 under the package's pad — the same 14,027 open boxes, code for code, and the file written here from the spec is the shipped 126,327 bytes, byte for byte**; cell 49's tree hashes to its manifest; the depth-32 queue is the Round 26 ledger's twelve cells closing at 32 (its margins are Round 26's, and no two cells share a node count, so they decide nothing). The MPFR dominance audits are recorded, not recomputed; the codec's self-test is not the shipped test frontier, and the harness that wrote that file is not shipped |
| [RUN-040](./reports/RUN-040-ROUND37-DEPTH32-DFRONT.md) | Round 37 — the depth-32 certificates of cells 49, 64 and 66, cell 33's frontier continued from 36 to 42 in checkpoints and 166 parallel segments, the compositional merge, and three prepared trees | **PASS** for eleven of twelve judgments: the three certificates are this tree's own leaf for leaf (all 7,712,457 vertices in their cores here, the least margins bit for bit); **cell 33's continuation is this tree's — at 38, 40 and 42 the open boxes are the DFRONT files', code for code, and every checkpoint and all 166 segment files, written here from the spec, are the shipped bytes**; 78,507 boxes stay open at 42, so the cell stays PARTIAL. §9's merge theorem is right, and its premise holds for all 146,483 shipped boxes, but **the merge never checks that premise: two one-box segments, the second inside the first's parent, meet all seven requirements and overlap** — containment comes from the refinement code, not the merge. UNMEASURED for the MPFR marker replay |

## Methodology tracks

After Round 37 come the four methodology tracks, in the order they build on each other: DLMVC, UESFCM, LESR, then
BCODR. Each track's methodology document is one of the 42 canonical documents and is reviewed into the status
registry; its case studies, cycles and papers are read as evidence, with no registry rows.

| run | subject | verdict |
| --- | --- | --- |
| [RUN-041](./reports/RUN-041-DLMVC.md) | DLMVC — the deep-lag multi-pass verification method, with its lagged verifications of Rounds 01 and 04 | **PASS** for its nine judgments (the other nineteen are labels). The lagged line's mathematics holds, and in two places it goes further than this tree's first reading (JPA-01's joint attainment; Round 04's sharp radius 0.7212385560391, where RUN-007 kept 2Ā). **Its one "independent reproduction" re-ran Round 04's script and reproduced the script's error — the quantization guard RUN-007 found — the shared-path failure DLMVC exists to prevent**; so "Empirical validation: PARTIAL" is right, for a reason it does not give. Two formulas lost their braces in a substitution, and VALIDATION's syntactic checks pass both |
| [RUN-042](./reports/RUN-042-DLMVC-DEEP-PASSES.md) | DLMVC — the four deep lagged passes on Round 04: the error budget, exact support-cell geometry, the phase-Lipschitz envelope and inner core, the finite polyhedral verifier and contact skeleton | **PASS** for the passes' theorems and for every constant and sanity number but three; the error bound holds on random bodies. **Pass 04's inner-core factor and sharp cell radius are grid samples on the unsafe side**, so what it boxes with them is not established by its own argument; its figure for Pass 03's cell radius is a different quantity |
| [RUN-043](./reports/RUN-043-UESFCM.md) | UESFCM — the unbounded-expansion self-referential finite-closure method and its operational protocol, with its one application (seventeen Lebesgue cycles) read as evidence of use | **PASS** for fourteen of its fifteen judgments, PARTIAL for "Problem Closure: DEFINED" (the other twenty are labels). The seventeen cycles chain cleanly and never mark evidence as proof; but **the target they anchor to is written down nowhere in the archive**, the LinkBack types are used in one cycle only, and the texts disagree on which states end the loop |
| [RUN-044](./reports/RUN-044-UESFCM-CYCLES-01-03.md) | UESFCM Cycles 01–03 — Mishra-seed expansion and the B₇ separator gate, the certified minimizer atlas and witness exchange, orbit localization and the sharp-minimum route | **PASS** for the three cycles' theorems and every number they compute from definitions: the B₇ separator LP reproduces to the last digit, the domain constants to the ulp. Three things differ from what the cycles report: **the "sharp root domain" is Mishra's Remark 20, which he notes saves no boxes**; and s₇, the replacement family and the sublevel's thinness come out different from Cycle 03's figures |
| [RUN-045](./reports/RUN-045-UESFCM-CYCLES-04-06.md) | UESFCM Cycles 04–06 — Gate A and the far-set dual certificate, the D3-quotiented Gate B, the symmetry-fixed anchor and the far-branch decomposition | **PASS** for every theorem and for Gate A's certificate, re-enclosed in this tree's 400-bit integer intervals (least bound 0.0088366789091384 after the bridge, as recorded). **Its verifier never checks two premises the bound rests on** — every triple's gaps below π (positive weights) and all 1,024 orientations present — both of which hold here; its recorded intervals are points. **The far-set minima the cycles report are search values, each above a lower point found here** |
| [RUN-046](./reports/RUN-046-UESFCM-CYCLES-07-09.md) | UESFCM Cycles 07–09 — the F3 frontier's failure localization, the two-level skeleton compiler, reflection-quotiented skeletons and multi-chart Taylor closure | **PASS**: every number the cycles compute on the saved frontier (22,516 boxes) reproduces from this tree's own hull — the membership, the centre areas, the 24 skeletons and 1,332 signatures, the 12 reflection classes, the Taylor margins. **The compilers they propose ship as interfaces with the proof steps not implemented**, so the frontier and every diagnostic come from code that is not in the archive |
| [RUN-047](./reports/RUN-047-UESFCM-CYCLES-10-11.md) | UESFCM Cycles 10–11 — finite closure of the 27 priority F3 roots and the 617-root batch, with their erosion certificates | **PASS**: both certificates decode exactly, every stated count reproduces, and **all 56,149 area leaves hold in exact arithmetic with this tree's exact cores, the tightest by 2.28×10⁻⁵** (the certificates' own least slacks are 3.8×10⁻⁸ and 2.5×10⁻⁹). The split rule is in neither document (read from the verifier); the float split leaves gaps of at most 4.7×10⁻¹⁸ that continuity closes; Cycle 11's verifier cannot run from its own package |
| [RUN-048](./reports/RUN-048-UESFCM-CYCLES-12-14.md) | UESFCM Cycles 12–14 — root 6217: batch closure and the symmetric triple contact, the ρ₅ = 0 slice, the rotation tail and boundary locking | **PASS** for the three certificates (they replay and hold in exact arithmetic) and the triple contact (to 80 digits); the rotation profile holds as a search. **NOT ESTABLISHED for Gate 6217-A: the ρ₅ = 0 reduction drops the F3 constraint, so Cycle 13's 2-D certificate leaves the arc side of the slice uncovered** — there the least area is again the contact point, so the gate holds numerically (by 2.05×10⁻⁴) but is not proved, and the "CLOSED" that Cycle 14 and both crystals carry goes too far |
| [RUN-049](./reports/RUN-049-UESFCM-CYCLES-15-17.md) | UESFCM Cycles 15–17 — corrected boundary locking, the tight reference and local secant, tight-reference pruning and hierarchical competitive-core closure | **PASS**: the lemmas hold, both upper references and all three certificates reproduce, and **all 115,511 area leaves hold in exact arithmetic**, each against its own threshold, the least by 2.66×10⁻⁵. The references are loose to first order (uniform directions miss the hull's bridging-edge normals); Cycle 15's counterexample to monotonicity is genuine but falls only 1.6×10⁻⁷ along its ray; and **"all other regions eliminated by finite certificates" includes 44 % of root 6217 that only a search closed** |
| [RUN-050](./reports/RUN-050-LESR-PAPER00.md) | LESR Paper 00 — from skew fields to variational shape closure: the bridge from the finite closure line to shape reconstruction | **PASS**: a bridge, not a result — every formula it uses holds, symbolically and on bodies. **Its one programmatic principle needs a curvature hypothesis at corners, where the first variation of an inward move is zero and the area drops only at second order**; the predecessors it builds on are not in the archive |
| [RUN-051](./reports/RUN-051-LESR-PAPER01.md) | LESR Paper 01 — the topology envelope and the stratified shape space, with its compiler scaffold | **PASS**: both theorems hold on the Lebesgue kernel — at most two crossings per piece pair, and an area analytic inside a contact stratum that kinks where the stratum changes. The scaffold implements the monotone envelope but not the stability test the text states |
| [RUN-052](./reports/RUN-052-LESR-PAPER02.md) | LESR Paper 02 — group-orbit shape expansion and symmetry breaking | **PASS**: the projectors, the gcd law and the first-variation theorem hold, on symmetric bodies and on the kernel's own hull. **On the kernel's seed no pure Fourier mode survives the convexity test, and breaking the symmetry costs area at first order: the recorded seed's asymmetry is search noise** — its mirror-symmetric polish is 9.03×10⁻¹¹ lower, a kinked strict local minimum |
| [RUN-053](./reports/RUN-053-LESR-PAPER03.md) | LESR Paper 03 — the support-function variational calculus | **PASS** for everything it derives: every formula along affine support paths, the step caps, the contact variation. **But on the kernel the container is the hull of its witnesses: a witness move turns the container's edges, and the first-order change is the edge average, not the affine maximum — so the finite LP finds no descent even where the area's gradient has length 0.39** |
| [RUN-054](./reports/RUN-054-LESR-PAPER04.md) | LESR Paper 04 — skew-constrained shape flow and the closure graph | **PASS** for everything it derives: the metric layer and the projection theorem (for a cone the descent inequality is an equality). **Its flow runs on Paper 03's affine cone, which on the kernel holds no descent: the projected velocity is zero at every placement tried, so the flow never starts** — where the area falls at 0.390 per unit along its steepest descent |
| [RUN-055](./reports/RUN-055-LESR-PAPER05.md) | LESR Paper 05 — contact pressure, dual multipliers and the no-slack boundary principle | **PASS** for everything it proves: the finite duality is Farkas, and the smooth no-slack theorem carries the curvature hypothesis Paper 00 lacked. **But on the kernel the finite dual certificate exists wherever it is solved — at a generic placement whose area gradient has length 0.39 too — so it certifies a placement that is not stationary** |
| [RUN-056](./reports/RUN-056-LESR-PAPER06.md) | LESR Paper 06 — the actual Lebesgue shape state, target-specific ledgers and the first closure graph | **PASS** for what it proves and computes: the barrier and its four-direction orbit reproduce, and target-specific closure is the right accounting. **Task B has a one-line answer: no measure on the four directions can match the barrier's curvature once cos 2θ is in the library**; and the ledger still marks the ρ₅ = 0 slice closed, which RUN-048 found is not established |
| [RUN-057](./reports/RUN-057-LESR-PAPER07.md) | LESR Paper 07 — the root-6217 barrier shape reconstruction | **PASS** for the reconstruction: every constant of the barrier reproduces from the contact equations to the last printed digit, and so does the 13-interval signature. **NOT ESTABLISHED for the translation KKT as argued: the claimed subgradient (g₃, 0) fails in a direction where B3 and B5 move left together**; the barrier is still the constrained minimum, with a multiplier of about 0.047, not 0.123 |
| [RUN-058](./reports/RUN-058-LESR-PAPER08.md) | LESR Paper 08 — the positive-rotation certificate reduction: two gates at ρ = 0⁺, the 195-root shape ledger | **PASS** for the reduction, its arithmetic (from m(0) to 65 digits) and its 10 / 141 / 44 split. **The rotation is first-order critical on the true hull, but not for the reason given: in the finite active-contact model the paper names, turning B5 costs +0.029 at first order.** And the "honest" 195-root shape ledger leaves out the 14.6 % of root 6217's box that Cycle 11 closed for A₃⁺ only, which the paper's own rule reopens |
| [RUN-059](./reports/RUN-059-LESR-PAPER09A.md) | LESR Paper 09A v0.2 — the multi-scale topology wall and the one-sided blow-up critical cone | **PASS** for the withdrawals (Paper 07's pressure step, one smooth chart), the blow-up chart, the 18-piece count at the stored anchor sample (the diagnostic's pieces), both primary O(ρ) arcs (B3's 0.1480ρ there, tending to about 0.1469ρ; B5's exactly ρ wider), the numerical centre — the re-minimized branch's (u, v, w) tends to (5.157, −0.1892, 0), Paper 09B's closed form — and the ratio, about 0.2256. **At properly minimized placements the three secondary slivers have zero width (below 10⁻¹¹ at four ρ) and the signature has 15 pieces: the diagnostic's slivers come from a stored sample 1.5×10⁻⁹ above the minimum**, so §7's O(ρ²) hypothesis is not what the minimum shows. Φ₁ is non-negative on a 280-point grid to about 10⁻⁷, with a single zero and a slope in every direction; the box localizes it |
| [RUN-060](./reports/RUN-060-LESR-PAPER09B.md) | LESR Paper 09B — the analytic primary blow-up equations: triple-wall collapse, the critical velocity, the primary first area variation | **PASS** for all of it, rebuilt from the barrier's geometry at 70 digits: the six wall constants (the printed ones are binary64), the full-rank collapse system and w* = 0, u* = 5.15712624526841370… and v* = −0.18922818990664097… (the printed u* is 5×10⁻¹⁴ off), the transition speeds (the true hull's hand-overs move at them), the primary 15-piece structure, and **Φ₁^primary = γ_w·w exactly — the forced 15-piece chain's first variation has coefficients (0, 0, 0, 0.18389963923727719…), the u and v terms cancelling identically**. Noted: the full Φ₁ stays non-negative along −w only because the slivers cost 0.2193 per unit against γ_w = 0.1839 (a margin of 0.0354); along the critical velocity the three O(ρ²) slivers open at π/2, θ* and 2π − θ*, not at the corners π ∓ θ* that §18 lists (a wall and its antipode give one equation). The verifier carries the constants and γ_w as numbers; Paper 09C, named next, is not in the archive |
| [RUN-061](./reports/RUN-061-LESR-MIDPOINT-HANDOFF.md) | LESR midpoint handoff — the certificate line and the counter-certificate line: three target ledgers, the canonical barrier, Paper 07's state, Paper 08's attack order, the local line's priorities | **PASS** for the barrier state (θ*, x₅*, α* to all 34 printed decimals, the area to 37), b* and g₃, the three ledgers and target-specific closure (cell 131: closed for A₃⁺, yet the only candidate below 0.8349865), the artifact index (all 12 archived) and the package. Not as stated: §6 lists B3's subgradient (g₃, 0) as done, and it fails (RUN-057); P08-A infers m′(0) = 0 from evenness — m is even, but a kink stays even; the "transition" ρ ≈ 0.0141 is one sample of two sequence changes; VALIDATION's next node is not Paper 08's title. **Run here, the counter-certificate line finds no lower branch (every profile and branch ratio positive), finds the new contact topology (RUN-059, RUN-060), and finds the finite dual uninformative (RUN-055)** |
| [RUN-062](./reports/RUN-062-BCODR.md) | BCODR — the bidirectional circular overlap decomposition and recomposition method (outward and inward circle fields, atomic cells, separation, provenance-preserving recomposition, the surviving spine) | **PASS**: a closure architecture, as it says of itself (§78); its one judgment-position phrase, CONFLICT CELL, is a label. Its differences D_μ and D_J are metrics on discs (20,000 random triples, exact lens areas; D_J scale-free); its arrangement's cells are counted right (Euler's F = V + 1 + C, never below the sampled signatures; exactly N(N − 1) + 2 when every pair crosses, so the O(N²) is tight; a three-circle Venn diagram); its certificate weights and UESFCM stages are consistent with the handoff and UESFCM. Noted: **the root-6217 map it proposes next starts from the 195-root ledger that leaves out 14.6 % of the box (RUN-058)**; Paper 09C, which it mentions, is not archived |
| [RUN-063](./reports/RUN-063-BCODR-LUC01.md) | BCODR LUC 01 — the arrival-time field over root 6217: 195 shape-active cells between Paper 09B's critical ray and the five A_ref-pruned boxes | **PASS** for the normalization, every cell's T₊ and T₋ (to 2×10⁻⁹ and 3×10⁻¹⁶), balance, entropy and score (the score's median is the 140 finite cells', not all), the nexus 131 — which holds the whole ray, the barrier on its corner — and the most balanced eight, 166 … 103. **Not as stated: on the exact dyadic grid the boxes touch the prune seeds in 64 pairs, not 35** (the state's own 55 touching cells need more than 35; the ledger counts exact floating-point zeros). Noted: for 178 of 195 cells the nearest ray point is its end ρ = 0.003, so the frontier moves with that cut (at 0.004, cells 160 and 168 come in); the 200 boxes cover 55.9 % of root 6217's box. The verifier reads the ledger alone |
| [RUN-064](./reports/RUN-064-BCODR-LUC02.md) | BCODR LUC 02 — the atomic cut of LUC 01's nine frontier parents into 288 children, their arrival signatures, the strict recomposition into 17 classes, and a second cut of the nine BOTH children | **PASS** on the exact dyadic grid (T₋ exact, T₊ to 50 digits) for all 288 signatures (187 / 88 / 4 / 9; 131 none BOTH), the 17 classes child for child (with closures meeting at corners counted adjacent and each child keeping its parent's ρ class; 22 with its own, 19 with faces only), the seven BOTH classes and the second cut (one BOTH grandchild each, 127's two 6 + 3). **Not as stated: 127's provenance flip 144 → 155** — 127 is exactly 1/8 from 144 and from 155 (the same float; the ledger names the first) — **and 127 as a thick corridor**: at the parent's radius the later field only touches the parent, at one point where the ray arrives last (seven parents: one child and one grandchild by construction) and along a face where a prune box does (127). 101's flip is real. The verifier asserts constants |
| [RUN-065](./reports/RUN-065-BCODR-LUC03.md) | BCODR LUC 03 — the true common-point overlap time T_true = inf over z of max(d₊, d₋) of LUC 02's nine parents: modes, provenance and 127's one-dimensional reduction | **PASS** at 40 digits (the dual of a convex problem, separable per coordinate, for every prune box): T_true ≥ T_box; every T_true to 8×10⁻¹³; 131 and 127 balanced (131 at the exact midpoint, half the ray's distance to 155), the seven others outward-limited with gaps exactly zero; 127 = 0.12695366779092488 from 155 by 0.042, and the reduction is the 5-D minimum (the printed reduced T right, the 5-D one 1.7×10⁻¹⁴ high). **Not as stated: 101, 103 and 104 have no single provenance** — 28, 68, 144 and 155 tie exactly (the ledger's 28 is the first; §17's "close to degenerate" is exactly degenerate). Noted: the ledger's negative gaps are LUC 01's ray grid; r\* and λ\* only to ~10⁻¹¹; 131's second time undercuts √2/8, which no point of 131 reaches; 127's 155 is right but no flip led to it (RUN-064). The verifier checks the ledger against itself |
| [RUN-066](./reports/RUN-066-BCODR-LUC04.md) | BCODR LUC 04 — the tangent decomposition of root 127's true-overlap germ: the KKT relation, the rank-2 active normals and three-dimensional critical tangent space, the reduced Hessians, the "combined germ stiffness" and the lens's growth | **PASS** at 50 digits for z\* (on 127's lower x₃ face), g±, α\* and η\*, the rank (2 for every r — the reduction puts z on the segment to 155's corner), D₊ = 1706.98000390142, H±, Q± and the stiffness as §14 defines it (0.45429481026314), and for the germ's isolation. **Not as stated: that stiffness as the overlap's second-order law** — along straight lines max(vᵀH₊v, vᵀH₋v), but a second-order bend along the active normal trades the two at the KKT weight, so the law is α H₊ + (1 − α) H₋, softest 0.2366; measured on slices of 127's box (x₅ pinned: 0.239445 h² = α; y₃ pinned: 0.236854 h²) the lens reaches 1.036 √ε, not 0.7476 √ε, at least cost 0.932 h², not 1.789 h²; the κ > 0.4 certificate target would fail. Noted: the printed z\*, g±, α\* and slope carry the printed r\*'s error. The verifier checks the record against itself |
| [RUN-067](./reports/RUN-067-BCODR-LUC05.md) | BCODR LUC 05 — the balanced overlap germ taxonomy: 127 face-constrained (FCBG), 131 an interior midpoint (IMBG), their stiffnesses compared, and a classification rule | **PASS** at 50 digits for 131's nearest ray–155 pair (T\* = 0.04733334989194496, the printed value to all its digits), the midpoint inside 131, g₋ = −g₊, rank 1, the four-dimensional critical space, H± and κ₁₃₁ = 0.45464980777815 with C_R and C_H — here the straight-line constant is the overlap's own (KKT weight 1/2; slices: 0.5000 h², 0.4918 h²) — and for both germs' isolation. **Not as stated: the comparison** — the printed κ ratio 1.0008 is of straight-line constants; the overlaps' own are 0.2366 (127, RUN-066) and 0.4546, a ratio of 1.92; **and the rule** — with a box seed Q₋ ⪰ 0, so κ_germ < 0 ("unstable") cannot occur, and κ_germ > 0 is necessary, not sufficient (127's forms would lose isolation above a KKT weight of 0.9987). Noted: the midpoint theorem needs the nearest pair of all and z's own nearest points; LUC 06 is not in the archive. The verifier asserts constants |
| [RUN-068](./reports/RUN-068-BCODR-LUC07.md) | BCODR LUC 07 — root 131: candidate/germ alignment and mirror covariance (a single document, no package; LUC 06 is not in the archive) | **PASS** for the midpoint separation theorem, T\* (all digits) and κ₁₃₁, S_x = R_π S_y and the support-function covariance, and Paper 07's barrier's up/down symmetry — exact body by body (disc, B3 corners at 0, 2π/3, 4π/3, B5 at 2πk/5, all on the x-axis) and even to 10⁻⁴⁵ at 50 digits: CERT-07.4 replayed. **Not as stated: "recorded by value only"** — Cycle 17's 68-cell diagnostic stores 131's minimizer (area 0.8349862484449208, every digit): it lies in 131, 7.7×10⁻⁴ from the ray near ρ = 1.7×10⁻⁴, 0.109 from the IMBG point, 0.124 from 155 — and 131's corner holds the barrier itself, the ray's start, 1.379×10⁻⁷ lower; **and §22's B5 slivers at π ∓ θ\*** — they open at θ\* and 2π − θ\* (RUN-060). Noted: the printed p\*, q\*, z\* are LUC 03's optimizer values, 5×10⁻⁷ off the exact pair; the companion schema and verifier of §23 are not in the archive |

## Reproduce

```
python code/fetch_source.py
python code/run001_corpus_identity.py --case <amral-site>/public/lebesgue --site-rev amral@ba14e814 --drill
python code/run002_round00_baseline_interface.py --drill        # --refresh re-fetches the arXiv snapshot
python code/run003_round00_governance.py --drill
python code/run004_round01_reduction_chain.py --drill   # --refresh re-fetches arXiv / Crossref
python code/run005_round02_finite_compiler.py --drill
python code/run006_round03_placement_certificate.py --drill
python code/run007_round04_cover_compiler.py --drill
python code/run008_round05_saturation_gate.py --drill   # --refresh also re-fetches two arXiv abstracts
python code/run009_round06_witness_exchange.py --drill  # --refresh: Mishra's full text, Xie's version titles
python code/run010_round07_minimizer_atlas.py --drill   # --refresh: Mishra's repository logs at commit da956b1
python code/run011_round08_conditional_lift.py --drill  # --refresh: Mishra's erosion lemmas (full text)
python code/run012_round09_adaptive_atlas.py --drill    # --refresh: Mishra's repository files at commit da956b1
python code/run013_round10_reference_dry_run.py --drill
python code/run014_round11_global_shards.py --drill       # --refresh: Mishra's repository files at commit da956b1
python code/run015_round12_checkpoint_crystal.py --drill
python code/run016_round13_autonomous_scheduler.py --drill
python code/run017_round14_semantic_rebase.py --drill
python code/run018_round15_capacity_ladder.py --drill
python code/run019_round16_global_pilot.py --drill
python code/run020_round17_d3_cpg.py --drill
python code/run021_round18_shard_emitter.py --drill
python code/run022_round19_necessity_lift.py --drill
python code/run023_round20_mixed_escalation.py --drill
python code/run024_round21_lift_tail_synthesis.py --drill
python code/run025_round22_fourier_pareto.py --drill
python code/run026_round23_portfolio_closure.py --drill
python code/run027_round24_residual_joint.py --drill
python code/run028_round25_closure_wave.py --drill
python code/run029_round26_full_atlas.py --drill
python code/run030_round27_interval_replay.py --drill
python code/run031_round28_exact_root.py --drill
python code/run032_round29_marker_upper.py --drill
python code/run033_round30_a1_replay.py --drill
python code/run034_round31_mpfr_replay.py --drill
python code/run035_round32_bulk_wave.py --drill
python code/run036_round33_dominance.py --drill
python code/run037_round34_rhcert.py --drill
python code/run038_round35_rhcert_production.py --drill
python code/run039_round36_dfront.py --drill
python code/run040_round37_depth32.py --drill
python code/run041_dlmvc.py --drill
python code/run042_dlmvc_deep_passes.py --drill
python code/run043_uesfcm.py --drill
python code/run044_uesfcm_cycles_01_03.py --drill   # --refresh: Mishra's full text (arXiv 2608.30538v2)
python code/run045_uesfcm_cycles_04_06.py --drill
python code/run046_uesfcm_cycles_07_09.py --drill
python code/run047_uesfcm_cycles_10_11.py --drill   # --refresh: Mishra's full text (arXiv 2608.30538v2)
python code/run048_uesfcm_cycles_12_14.py --drill
python code/run049_uesfcm_cycles_15_17.py --drill
python code/run050_lesr_paper00.py --drill
python code/run051_lesr_paper01.py --drill
python code/run052_lesr_paper02.py --drill
python code/run053_lesr_paper03.py --drill
python code/run054_lesr_paper04.py --drill
python code/run055_lesr_paper05.py --drill
python code/run056_lesr_paper06.py --drill
python code/run057_lesr_paper07.py --drill
python code/run058_lesr_paper08.py --drill
python code/run059_lesr_paper09a.py --drill
python code/run060_lesr_paper09b.py --drill
python code/run061_lesr_midpoint_handoff.py --drill
python code/run062_bcodr.py --drill
python code/run063_bcodr_luc01.py --drill
python code/run064_bcodr_luc02.py --drill
python code/run065_bcodr_luc03.py --drill
python code/run066_bcodr_luc04.py --drill
python code/run067_bcodr_luc05.py --drill
python code/run068_bcodr_luc07.py --drill
```

RUN-009 and RUN-010 run numerical searches; their results are cached in `data/cache/`
(not committed) under the hash of the search code, so the first `--drill` takes about
ten minutes (RUN-009) and over an hour (RUN-010), and later runs seconds to minutes.
RUN-013 caches its replay of Round 10's certificate the same way, under the hash of the
replay code and the streams: about four minutes on a first run.
RUN-019 emits nine pilot trees, four B7 probes, a witness search and a proxy sample on 14
worker processes, cached the same way under the hash of that code: about fifteen minutes on
a first run.
RUN-020 caches its ten D3 trees the same way: a few minutes on a first run.
RUN-021 caches its re-emitted forests and leaf re-proofs the same way: a few minutes on a first run.
RUN-022 caches its continuations, depth-20 centres, branch, segmentation and B7 probes the same way: about three
minutes on a first run.
RUN-023 caches its lift trees, exact-core closures and its placement search the same way: about an hour on a
first run, most of it the search.
RUN-024 caches its tail trees, ridge scan and baseline searches the same way: about twenty minutes on a first run.
RUN-025 caches its searches, lift trees and limits the same way: about forty minutes on a first run.
RUN-026 caches its segmentation, lift trees, exact-core closures and limits the same way: about twenty-five minutes on a
first run.
RUN-027 caches its exact-core trees and the certificate's topology the same way: about five minutes on a first run.
RUN-028 caches its twelve exact-core trees the same way: about twelve minutes on a first run.
RUN-029 caches its 77 exact-core trees, the certificate cell's leaves and radial fallbacks, and 31 trees lifted again
under the package's pad, in three caches the same way: about three hours, two minutes and two hours on a first run.
RUN-030 reads RUN-029's caches, and caches its certificates (about two minutes) and the residual continued from
depth 36 to 40 (about two and a half hours) the same way; the latter keeps the boxes open at 40 as paths.
RUN-031 caches its root, cell 0's leaves and their migration and kernel scan the same way: under two minutes on a first run.
RUN-032 caches its 77 marker certificates the same way: about a minute on a first run.
RUN-033 caches its all-points replay of cell 0's lower leaves (about three minutes on a first run), the replay's own
rule rebuilt on this tree's contact points (about half a minute) and marker 70 (seconds) the same way.
RUN-034 has no cache of its own: it reads RUN-029's, RUN-030's and RUN-033's.
RUN-035 caches its lifts and ledgers of cells 69 and 47, cell 69's winner rule rebuilt and markers 69 and 47 (about six
minutes on a first run), and cells 31, 27 and 7 continued from depth 40 to 46 (about three minutes, from RUN-030's
caches) the same way.
RUN-036 caches the lifts of cells 48, 68, 75 and 76, cell 48's ledger (under RUN-035's name) and marker 48 the same way: a
few minutes on a first run.
RUN-037 caches its replay of both certificates' vertices, cell 68's ledger and marker 68 the same way: about a quarter
of an hour on a first run.
RUN-038 caches its replay of cell 68's certificate, the ledgers of cells 75 and 76 and their markers the same way: about
twenty-five minutes on a first run.
RUN-039 caches its replays of cells 75 and 76's certificates and its lifts of cells 33 (to depth 36) and 49 (to 32) the
same way: about a quarter of an hour on a first run.
RUN-040 caches its three depth-32 certificates and their replays, cell 33's continuation from 36 to 42, three prepared
lifts and three markers the same way: about forty-five minutes on a first run, half of it the continuation.
RUN-044 caches its searches (the landscape and three differential-evolution searches) the same way: about ten
minutes on a first run.
RUN-045 caches its searches the same way: about twenty minutes on a first run.
RUN-046 caches its scans of the saved frontier the same way: about an hour on a first run.
RUN-047 caches its exact certification of the two certificates' area leaves the same way: about twenty-five minutes
on a first run, on six workers.
RUN-048 caches its exact scans and its contact and profile searches the same way: about an hour and a half on a first
run, on six workers.
RUN-049 caches its exact scans and searches the same way: about forty minutes on a first run.
RUN-052 caches its scans the same way: about five minutes on a first run.
RUN-053 caches its scans the same way: about twenty seconds on a first run.
RUN-054 caches its scans the same way: about ten seconds on a first run.
RUN-055 caches its scans the same way: about ten seconds on a first run.
RUN-056 caches its scans the same way: a few seconds on a first run.
RUN-057 caches its scans the same way: about four and a half minutes on a first run, most of it the KKT directional scan.
RUN-058 caches its scans the same way: about two minutes on a first run (two profile samples re-minimized on two
workers).
RUN-059 caches its signatures, the branch re-minimized at four ρ with Φ₁'s minimizer (on five workers), and Φ₁'s grid
the same way: about a quarter of an hour on a first run.
RUN-060 caches its 70- and 90-digit computations and its hull scans the same way: seconds on a first run.
RUN-061 caches its 70-digit barrier and its mirror check the same way: seconds on a first run.
RUN-062 caches its disc triples and circle families the same way: seconds on a first run.
RUN-063 caches its field, its exact-grid contacts and its cuts of the ray the same way: about a minute on a first run.
RUN-064 caches its two-level cut and its recompositions the same way: about a minute on a first run.
RUN-065 caches its true overlap times and 127's reduction the same way: about two minutes on a first run.
RUN-066 caches its germ and its slices the same way: about twenty seconds on a first run.
RUN-067 caches both germs, 131's slices and the critical weight the same way: about twenty seconds on a first run.
RUN-068 caches 131's pair, the candidate's distances and the barrier's symmetry the same way: about ten seconds on a first run.

`fetch_source.py` needs this repository with `agent/lebesgue-finite-closure`
fetched; it refuses any blob whose size, SHA-256 or git blob id differs from
the pins.