# RUN-033 — Round 30: the whole shard passes again here, and the second implementation's lower ledger comes back leaf for leaf from its own rule; that rule keeps one contact point per direction, so its thinnest leaf measures the rule's loss, not the geometry

**Arm:** 懸衡 (Xuán Héng) / AMRAL Research Lab
**Date:** 2026-09-26
**Subject:** `AMRAL_Lebesgue_Finite_Closure_Round_30_A1_Backend_Pinning_v0.1.md` (AMRAL-LUC-FC-R30, dated 2026-09-20) and its package, read from the archive:

- `A1_ROOT_REPLAY.json`, `A1_MARKER70_REPLAY.json`, `A1_LOWER_REPLAY.json`, `BACKEND_LOCK.json`,
  `A1_WHOLE_SHARD_70.json`, `CORRECTION_LEDGER.json`, `VALIDATION.json`, `State_Crystal`;
- the ten `a1_lower_*.json` chunks (9,278 leaf records), and Round 28's and Round 29's files again;
- three scripts, read only after this tree's replays were computed, and never run.

**Tools:** [`run033_round30_a1_replay.py`](../code/run033_round30_a1_replay.py) — RUN-031's directed root, intended boxes and integer-interval certificates on this tree's lift of cell 0; the replay's own rule rebuilt on this tree's contact points; RUN-032's outer certificate for marker 70; the corrected exact kernel
**Logs:** [`run033-round30-a1-replay.json`](../data/gate-logs/run033-round30-a1-replay.json)

**Verdict: PASS for the root replay (its intervals lie inside Round 28's, and this tree's brackets inside its own), marker 70's bound, all 9,278 lower leaves, the root correction, 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 root.**
  - The replay's d⋆, t₃, t₅ and t₇ (2.8–4.0×10⁻⁷³ wide) lie inside Round 28's intervals (3.1×10⁻⁶¹
    for d⋆, 3.2–4.3×10⁻⁶⁴ for t_n), and this tree's brackets (about 10⁻⁹⁰, RUN-031) inside the
    replay's. That is containment, which the "overlap" of §0 does not by itself say. The widths are
    as stated.
  - The correction's cause reproduces. Cast either end of either d⋆ interval to binary64 and d⋆
    moves 1.70×10⁻¹⁷; this tree's t₃, t₅ and t₇ at that point land 2.43, 1.90 and 1.80×10⁻¹⁷ above
    Round 28's intervals — all three outside, as §12 says. §12 calls the cast interval about 10⁻⁶⁴
    wide: that is the width of Round 28's t_n intervals, the d⋆ intervals being 3.1×10⁻⁶¹ (Round 28)
    and 2.8×10⁻⁷³ (the replay) wide.
  - The tree the lower replay walks is Round 28's (topology and axis-stream digests, a base path of
    depth 40). So are its root intervals: its script reads Round 28's `tmax_intervals`, not the
    replay's own root.
- **Marker 70.**
  - The replay's record is Round 29's audit row for marker 70, field for field, method string
    included, from the same script (same digest) — §19's "已经 PASS".
  - It reproduces marker 70's file (density 4,096, area, margin) and names the file by digest. Its
    area, 0.8349075, lies above the exact area 0.8348018.
  - It counts 1,317 active constraints. The file and this tree's uniform normals at 4,096 both count
    1,284, and this tree's polygon comes within 5.2×10⁻¹¹ of the replay's area.
  - This tree's own certificate needs 128 normals and the 11 bridging normals, with a margin of
    1.37×10⁻⁴ (RUN-032's construction).
- **The 9,278 lower leaves.**
  - Their paths are this tree's lift of cell 0.
  - This tree's certificate takes every body's contact point in each direction and checks each point
    inside its body on the intended box. At the replay's densities, all 9,278 leaves pass, no candidate
    is refused, and every margin is above the replay's by 2.1×10⁻⁸ to 1.6×10⁻⁴.
  - The least margin there is Round 28's thinnest leaf, 3.19489×10⁻⁸ at 16,384, within 2×10⁻¹⁹ of
    Round 28's own figure. The replay's thinnest leaf has 2.22×10⁻⁵ here, at its density of 2,048.
  - On the ladder both share (from 512), the replay's density is above the least that passes here on
    974 leaves, and below it on none.
- **The replay's rule, rebuilt.**
  - The script keeps, in each direction, only the contact point of the body whose support wins it:
    N points where this tree's certificate has 4N.
  - The same rule on this tree's contact points and boxes gives the replay's density on 9,278 of
    9,278 leaves and its hull-vertex count on all of them. Every margin is the replay's plus
    1.57–1.67×10⁻¹²: points move 10⁻¹² inward here, 2×10⁻¹² there. No candidate is refused at any
    density, and the density counts are the replay's: 8,174, 869, 163, 56, 12 and 4.
  - The rule loses every body that the hull exposes over less than one step. No direction falls
    inside the window, so that body contributes no point and the polygon cuts across it. The cut is
    about ½·L₁·L₂·ψ, where L₁ and L₂ are the two hull edges that meet there and ψ is the window. That
    is first order in the step, and all or nothing per feature.
  - On the replay's thinnest leaf, 11 hull vertices in 10 such runs account for the whole 2.221×10⁻⁵.
    The largest is a stretch of the disc exposed over 1.85×10⁻³ rad (the step is 3.07×10⁻³), between
    edges 0.267 and 0.084 long, which cuts 2.105×10⁻⁵ (½·L₁·L₂·ψ = 2.077×10⁻⁵). The first leaf loses
    1.74×10⁻⁵ in 6 runs, and Round 28's thinnest leaf 2.52×10⁻⁸ in 12.
  - So §11 is right that the new ordering says nothing about the true minimum. The replay's thinnest
    leaf is the one whose margin the rule's loss nearly uses up.
  - This is the inner-polygon side of the loss RUN-032 found in the package's outer polygons, and the
    same blind spot as this tree's own kernel before its correction: something exposed between two
    grid directions.
- **The lock.**
  - Its two script digests are the scripts shipped, and the marker script's is also Round 29's copy.
    The 10-line marker driver is shipped but not pinned, and none of its output is shipped. No shipped
    script computes the root replay.
  - This machine runs mpmath 1.3.0, and the lock's nine libmp digests are its files', one for one:
    the pin is the stock release.
  - The whole-package digest does not say how it is formed, and none of twelve natural ways of
    forming it over the same sources gives it.
  - `fractions.py` is CPython 3.13.5's. This machine runs 3.14.5, so it is not compared.
- **What the package ships.**
  - `r30_a1_lower_chunk.py` (212 lines, absolute path) works in mp.iv at 75 digits, on a 10⁻¹⁷
    grid, with points moved 2×10⁻¹² inward, trying densities from 512 to 32,768 until the first one
    passes.
  - For each body and direction it takes one point: a valid arc point, or a corner of two defining
    circles when that corner's support is larger. It then keeps the union winner's point, and checks
    membership against directed centre rectangles.
  - Its exact fractions reach mp.iv through 120-digit decimal strings rounded to nearest (the rotation
    interval, the sine of a half-width, the argument of a square root). That is §13's "exact → float
    → interval" shape at 10⁻¹²⁰. In practice the interval's own 75-digit outward rounding covers it,
    but not by construction. Nothing here rests on it.
  - `r29_marker_a1_verify.py` (92 lines) is Round 29's, byte for byte. It finds support sectors by an
    interval atan2 and imports no scipy.
- **This tree's side of §21.**
  - The 33 functions that this tree's root, marker and lower certificates rest on use mpmath only in
    `acos_iv` and `d_star_iv`. Each takes a 150-digit guess from mpmath, then brackets it and asserts
    the bracket with this tree's own integer cosine. π is Machin's, inside RUN-030's 60 decimals.
  - So this tree's replays of the shard's three parts share no arithmetic with mpmath/libmp: the root
    and the 9,278 leaves (RUN-031, here) and marker 70 (RUN-032, here). They are this tree's code and
    not audited; whether they count as §21's second backend is not for this tree to say.

Drill: 18 / 18 plants caught by exactly the named checks, 4 / 4 controls undisturbed,
199 / 199 must-stay-green assertions held. Each of the ten checks was blinded in turn, and each
was reported blind in exactly as many cases as plants name it.

This run uses the exact kernel as corrected after RUN-031 (every envelope segment checked in
closed form); the correction is committed before it.

---

## What Round 30 claims

1. **Root/path A1** (§0, §12–13). From T_M = 1673/2000, a monotone directed bisection; t₃, t₅, t₇
   recomputed. After fixing R30-A1-ROOT-001 — an ultra-narrow d⋆ interval, "about 10⁻⁶⁴" wide, had
   been cast to binary64 and moved at the 10⁻¹⁷ scale — all three overlap Round 28's.
2. **Marker 70 upper A1** (§0, §19).
   - An exact cyclic polar hull over all the rational support constraints, with no scipy reduction.
   - PASS: outer 0.8349075014501105, margin 9.24985499×10⁻⁵.
   - A1 for all 77 markers is not a gate this round.
3. **Lower A1** (§0, §2–11).
   - A second implementation: defining disks; arc and corner candidates; the union winner per
     direction; a 10⁻¹⁷ grid; an exact integer monotone hull; directed membership; an exact area.
   - 9,278/9,278 A1-PASS, none inconclusive.
   - Densities 512: 8,174; 1,024: 869; 2,048: 163; 4,096: 56; 8,192: 12; 16,384: 4. None needs
     32,768.
   - The thinnest margin is 3.54237075×10⁻⁹, on another leaf than Round 28's (3.1949×10⁻⁸):
     "different inner polygons, different losses".
4. **Backend** (§1, §14–16).
   - Implementation A1 and backend independence are separate requirements.
   - Pinned: mpmath 1.3.0, libmp, `fractions.py` and the scripts. The backend id is
     PINNED-MPMATH-LIBMP-PROTOTYPE-v0.1; the state is PINNED-REPRODUCIBLE-PROTOTYPE with
     TRUST-AUDIT-OPEN.
5. **Status** (§17–18, §20–23).
   - The shard is A1-VERIFIED-PINNED-PROTOTYPE-SHARD. It is not a PUBLICATION-CANDIDATE until a
     second backend replays the root, the upper bound and the 9,278 lower memberships.
   - The global state is unchanged: 51/77 at d = 36, Γ(38) ≥ 57, Γ(40) ≥ 63.
   - a_Leb ≥ 0.835 is NOT CERTIFIED.

## A — sources

**A0.** 48 anchors. Round 30 has no reference list.

## W — rebuilt

| check | Round 30 | rebuilt | result |
| --- | --- | --- | --- |
| W1 | §0, §12–13 | the replay's root between this tree's brackets and Round 28's; the cast | PASS; nested, not only overlapping |
| W2 | §0, §19 | marker 70's replay against its file, Round 29's audit and this tree's certificate | PASS; Round 29's audit row |
| W3 | §2–11 | the 9,278 leaves under this tree's certificate; the replay's rule rebuilt | PASS; the rule's loss is sub-step exposures |
| W4 | §14–16 | the lock against the scripts and the stock mpmath | PASS; the whole-package digest not reproducible |
| W5 | — | the scripts | the lower replay reads Round 28's root; the marker replay is Round 29's |
| W6 | §21 | this tree's certificates' backend | mpmath only for guesses, each checked in integers |

**W3 — three leaves, three polygons.** Margins above 167/200 at the replay's density:

| leaf | density | the replay | the replay's rule here | every contact point here | the rule's loss (runs) |
| --- | ---: | ---: | ---: | ---: | ---: |
| `11010110100110101001110111` (the replay's thinnest) | 2,048 | 3.5424×10⁻⁹ | 3.5440×10⁻⁹ | 2.2211×10⁻⁵ | 2.221×10⁻⁵ (10) |
| `1101011010010011111001110` (Round 28's thinnest) | 16,384 | 6.7795×10⁻⁹ | 6.7812×10⁻⁹ | 3.1949×10⁻⁸ | 2.517×10⁻⁸ (12) |
| `00000` (the first leaf) | 512 | 1.30945×10⁻³ | 1.30945×10⁻³ | 1.32682×10⁻³ | 1.738×10⁻⁵ (6) |

In each row the loss, measured on binary64 hulls, is the gap between the rule's margin and that of
every contact point, and the runs' cuts sum to it.

## P — the package

**P1.**

- Each chunk's summary is its rows': count, passes, inconclusive and density counts. The ten chunks
  are the ten that `A1_LOWER_REPLAY.json` lists.
- The replay file's totals, density counts, least margin and its path are the rows'. It lists no
  inconclusive example.
- The shard record names the root, marker, lower and lock files by their archive digests.
  - Its marker and lower figures are the replay files', and its emitter count is Round 28's 9,278.
  - Its flags are A1-VERIFIED-PINNED-PROTOTYPE-SHARD, not a publication candidate, not theorem-ready,
    and no global claim; its lock status is the lock's.
- The correction ledger's second entry closes the scope question as a boundary, with backend trust
  left open.
- The crystal carries 9,278/9,278, 3.54237075×10⁻⁹, the thinnest path and the lock status.

**P2.**

- `VALIDATION.json` describes the document and the crystal correctly: SHA-256, bytes, `$$` counts,
  both flags.
- Its six digests are the archive's, and its ten checks follow from the data.

## Round 30, read

| Round 30 | statement | verdict | note |
| --- | --- | --- | --- |
| §0, §12–13 | the root replay overlaps Round 28's | PASS | nested: the replay inside Round 28's, this tree inside the replay (W1) |
| §12 | R30-A1-ROOT-001 | PASS | the cause reproduced; the width it gives is t_n's, not d⋆'s (W1) |
| §0, §19 | marker 70's upper replay PASS | PASS | Round 29's audit row, from the same script (W2) |
| §1 | implementation A1: nothing shared in candidates, hull, density or ledger | PARTIAL | true of the lower replay (W3, W5); the marker replay shares the emitter's support routine, normals and density (W2, W5) |
| §2–8 | the second lower implementation | PASS | the script is as described (W5); its rule rebuilt here gives back its ledger (W3) |
| §9–10 | 9,278/9,278, none inconclusive; the density counts | PASS | W3 |
| §11 | another weakest leaf; different polygons, different losses | PASS | the loss is the rule's sub-step exposures (W3) |
| §14–16 | the backend pinned; not audited | PASS | libmp as stock 1.3.0; the whole-package digest cannot be checked (W4) |
| §17–18 | A1-VERIFIED-PINNED-PROTOTYPE-SHARD | PARTIAL | the upper half's replay carries the emitter's support code (W2, W5); every part passes here (W1–W3, W6) |
| §19–23 | marker scope; global state unchanged; what remains; Round 31 | PASS / n/a | |

## The status registry

Round 30's 28 judgments are reviewed, and its 8 first-used phrases defined:
`A1-VERIFIED-PINNED-PROTOTYPE`, `A1-INCONCLUSIVE`, `R30-A1-ROOT-001`,
`A1-VERIFIED-PINNED-PROTOTYPE-SHARD`, `A1-PASS`, `PINNED`, `PINNED-REPRODUCIBLE-PROTOTYPE` and
`TRUST-AUDIT-OPEN`. Census v5 adds none.

| verdict | judgments |
| --- | ---: |
| PASS | 19 |
| PARTIAL | 4 |
| n/a | 5 |

The four PARTIAL judgments are "A1 PASS" for the marker upper and the three occurrences of
A1-VERIFIED-PINNED-PROTOTYPE-SHARD.

## The drill

| kind | cases | named checks |
| --- | ---: | --- |
| the document's 3.54237075 | 1 | A0 |
| a replay interval; the correction record; the topology digest | 3 | W1 |
| marker 70's area | 1 | W2 (also P1) |
| the marker file's digest | 1 | W2 |
| the thinnest leaf's margin; a leaf's density | 2 | W3 (also P1) |
| a pinned script digest; a pinned libmp digest | 2 | W4 |
| the scripts' facts | 1 | W5 |
| the backend claim | 1 | W6 |
| a chunk's pass count; the shard's lower digest; the crystal's 9278/9278 | 3 | P1 |
| a VALIDATION digest; a VALIDATION check | 2 | P2 |
| a review dropped | 1 | R1 |

Four controls:

- the unmodified inputs;
- the document with CRLF line endings;
- the lower replay file with its keys sorted;
- the shard with its keys sorted.

**18 / 18 plants, 4 / 4 controls, 199 / 199 must-stay-green assertions; no check without a
plant.**

| check blinded | cases reported blind | plants naming it |
| --- | ---: | ---: |
| A0 | 1 | 1 |
| W1 | 3 | 3 |
| W2 | 2 | 2 |
| W3 | 2 | 2 |
| W4 | 2 | 2 |
| W5 | 1 | 1 |
| W6 | 1 | 1 |
| P1 | 6 | 6 |
| P2 | 2 | 2 |
| R1 | 1 | 1 |

W4 compares the libmp digests only where the pinned mpmath version is installed. Elsewhere it
records "not compared", and its libmp plant goes uncaught.

## What this round does not establish

- **A second backend.** This tree's replays use no mpmath, but they are one implementation, by one
  hand, and not audited. §21's gate is the package's to judge.
- **A1 for the other 76 markers**, as §19 says. RUN-032 certified all 77 with this tree's own
  polygons.
- **Anything beyond cell 0's shard.** The global state is unchanged: 51/77 at d = 36.