# AMRAL × Lebesgue Universal Covering — Round 10
## Reference Atlas Emitter and End-to-End Conditional-Lift Dry Run

**Document ID:** AMRAL-LUC-FC-R10  
**Version:** v0.1  
**Date:** 2026-09-18  
**Research status:** Round 10 / Executable reference certificate / Local-domain dry run  
**Research mode:** Human-Directed + Semi-Autonomous AI Mathematical Research  
**Research initiation and methodology source:** Neo.K  
**AI collaborating researcher and primary executor:** Aletheia / ChatGPT, GPT-5.6 Sol  
**Prior documents:** AMRAL-LUC-FC-R00 v0.2; R01–R09 v0.1  

---

# 0. Purpose of this round

Round 08–09 already completed:

$$
\text{certificate grammar}
+
\text{adaptive cost logic}.
$$

Round 10's goal is not to pretend the global bound is already done:

$$
a_{\mathrm{Leb}}\ge0.8350.
$$

This round does something of more engineering value:

$$
\boxed{
\text{Actually run the whole nested certificate pipeline through, once, end to end.}
}
$$

So this round chooses:

- a **local** five-dimensional base neighborhood;
- but every base leaf launches the **complete $B_7$ relevant placement root**;
- the emitter genuinely generates finite DFS certificate bitstreams;
- an independent verifier genuinely replays every box;
- the final summary genuinely checks tree identity, hashes, leaf lower bounds, and stream exhaustion.

This is:

$$
\boxed{
\text{LOCAL-DOMAIN REFERENCE CERTIFICATE}
}
$$

not a global Lebesgue theorem.

---

# 1. Local base domain

Centered on the officially exhibited:

$$
D+B_3+B_5
$$

near-minimum placement.

normalized:

$$
q^\dagger
=
(
x_3,y_3,\phi_5,x_5,y_5
)
$$

where:

$$
x_3
=
-0.01215883209899,
$$

$$
y_3
\approx
-3.7082\times10^{-8},
$$

$$
\phi_5
\approx
2.4128951083\times10^{-5},
$$

$$
x_5
=
0.02299660691706,
$$

$$
y_5
\approx
-3.89698\times10^{-6}.
$$

reference local halfwidth:

$$
\boxed{
(
4\times10^{-5},
4\times10^{-5},
4\times10^{-4},
4\times10^{-5},
4\times10^{-5}
).
}
$$

This domain is just a small neighborhood around the officially exhibited placement.

So:

$$
\boxed{
\text{Round 10 does not cover the full five-dimensional base domain.}
}
$$

---

# 2. Base atlas tree

To test the nested grammar, this round fixes the base tree at two levels:

First cut:

$$
\phi_5.
$$

Second cut:

$$
x_5
$$

applied once on each of the two $\phi_5$ children.

This gives:

$$
\boxed{
4
}
$$

local base leaves.

leaf ids:

$$
00,\ 01,\ 10,\ 11.
$$

All four leaves are labeled:

`LIFT-CLOSED`

rather than:

`BASE-PRUNED`

because this round's main purpose is precisely to test the B7 nested lift path.

---

# 3. B7 root is complete

For every local base leaf, B7 uses the complete Round 08 relevant root:

$$
\boxed{
\phi_7
\in
[0,2\pi/7),
}
$$

and:

$$
\boxed{
x_7,y_7
\in
[-0.19693504677116785,\ 
+0.19693504677116785].
}
$$

So Round 10 is not:

> verifying only around some B7 search optimum.

but rather:

> for the local base cell, fully covering B7's relevant 3-D root.

---

# 4. Lift tree split rule

For a B7 witness box halfwidth:

$$
(h_\phi,h_x,h_y),
$$

motion radius:

$$
\delta_7
=
\sqrt{
h_x^2+h_y^2
}
+
2R_7
\sin\frac{h_\phi}{2}.
$$

Each time, three axis bisections are considered, and the one giving the smallest child motion radius is chosen:

$$
\boxed{
a^\star
=
\arg\min_a
\delta_7^{(a)}.
}
$$

So the tree is fully deterministic.

The verifier can, from:

- the root;
- the bitstream;
- the split rule;

regenerate every lift box.

---

# 5. Leaf lower witness

For each lift leaf:

1. for the base leaf, generate:

   $$
   C_3,
   C_5;
   $$

2. for the B7 placement box, generate:

   $$
   C_7;
   $$

3. the disk uses radius:

   $$
   1/2;
   $$

4. for each curved core, take verified boundary contact points along:

   $$
   96
   $$

   normal directions;

5. likewise take, for the disk:

   $$
   96
   $$

   points as the inscribed polygon;

6. take the convex hull over all finite points.

finite-point hull:

$$
P_{\rm inner}
$$

satisfies:

$$
P_{\rm inner}
\subseteq
\operatorname{conv}
(
D,C_3,C_5,C_7
).
$$

so:

$$
\operatorname{Area}(P_{\rm inner})
$$

is a one-sided geometric lower witness.

---

# 6. Search / verifier independence

## Emitter

Uses:

`scipy.spatial.ConvexHull`

to compute the finite-point hull.

## Verifier

Does not use the scipy hull routine at all.

Instead uses a handwritten:

$$
\boxed{
\text{monotone chain}
}
$$

+

shoelace formula.

So, at least at the hull-algorithm layer:

$$
\boxed{
\text{search and verifier code paths differ}.
}
$$

Core reconstruction still relies on the same mathematical formula, but the verifier re-implements and re-checks:

- erosion nonempty;
- all-disk membership.

---

# 7. Search threshold vs verify threshold

target:

$$
T=0.835.
$$

emitter prune threshold:

$$
\boxed{
T_{\rm search}
=
0.8350002.
}
$$

that is, more than the theorem target by:

$$
2\times10^{-7}.
$$

The verifier instead uses:

$$
T=0.835
$$

and additionally subtracts a dry-run floating pad:

$$
\boxed{
e_{\rm dry}
=
10^{-8}.
}
$$

leaf acceptance:

$$
A_{\rm verify}
-
e_{\rm dry}
\ge
0.835.
$$

This round does not claim that:

$$
10^{-8}
$$

is a formally derived, publication-grade floating-point error theorem.

So the final status remains:

`REFERENCE-VERIFIED`

not:

`VERIFIED-THEOREM-APPLICATION`

---

# 8. Actual emitted trees

The lift tree of the four base leaves:

| Base leaf | Nodes | Leaves | Max depth |
|---|---:|---:|---:|
| `00` | 2833 | 1417 | 21 |
| `01` | 2853 | 1427 | 21 |
| `10` | 2833 | 1417 | 21 |
| `11` | 2853 | 1427 | 21 |

total:

$$
\boxed{
11372\text{ lift nodes}
}
$$

$$
\boxed{
5688\text{ lift leaves}
}
$$

Every tree satisfies:

$$
\boxed{
N=2L-1.
}
$$

---

# 9. Independent replay result

The independent verifier successfully passed:

- manifest hash checks;
- all four B7 bitstreams;
- deterministic box regeneration;
- core reconstruction;
- handwritten convex hull;
- shoelace;
- dry-run arithmetic pad;
- tree identities;
- exact node-stream exhaustion.

final verifier status:

$$
\boxed{
\texttt{REFERENCE-VERIFIED}
}
$$

scope:

> local five-dimensional base neighborhood only, with full relevant B7 root for each local base leaf.

---

# 10. Worst local verified slack

In the verifier, the minimum value of:

$$
A_{\rm inner}
-
10^{-8}
-
0.835
$$

is still positive.

This round's actual summary file stores:

$$
\boxed{
\text{worst\_verified\_slack}
}
$$

for future comparison of:

- sampling density;
- arithmetic policy;
- scheduler;
- core strength.

---

# 11. What this dry run actually proves

What it proves is:

> within this round's specified **local base neighborhood**, for every base placement, and for every B7 placement box branch within the B7 root square, the reference one-sided common-core computation can close to $0.835$ within a finite tree.

More precisely:

This round verified that:

$$
\boxed{
\text{nested-certificate implementation semantics}
}
$$

can run end-to-end.

---

# 12. What it does not prove

This round did not cover the full five-dimensional base placement domain of:

$$
D+B_3+B_5.
$$

So it cannot derive:

$$
\Lambda(D,B_3,B_5,B_7)\ge0.835.
$$

Nor can it derive:

$$
a_{\mathrm{Leb}}\ge0.835.
$$

Therefore:

$$
\boxed{
\text{Round 10 is a local implementation proof-of-architecture,
not a global lower-bound theorem.}
}
$$

---

# 13. Why this is still substantive progress

Before Round 08:

the certificate was a specification.

Before Round 09:

adaptive scheduling was a theorem / algorithm proposal.

After Round 10:

there now actually exist:

$$
\boxed{
\text{certificate bytes}
}
$$

+

$$
\boxed{
\text{independent replay}
}
$$

+

$$
\boxed{
\text{finite end-to-end closure sample}.
}
$$

So when the local side later actually runs the global atlas, there is no more need to guess:

- how the certificate tree is encoded;
- how the verifier reconstructs it;
- leaf semantics;
- nested lift reference;
- hash / tree identity;
- stream exhaustion.

This plumbing has already actually passed.

---

# 14. Reference certificate contents

This round adds:

`AMRAL_LUC_FC_Round_10_reference_cert/`

containing:

- `manifest.json`
- `lift_00.bin`
- `lift_01.bin`
- `lift_10.bin`
- `lift_11.bin`
- `verification_summary.json`

---

# 15. Emitter

File:

`AMRAL_LUC_FC_Round_10_reference_emitter.py`

Function:

1. fix the local base root;
2. build the four base leaves;
3. fully run the B7 root for each leaf;
4. deterministic exact-radius split;
5. core lower bound;
6. emit the one-bit DFS tree;
7. write manifest / hashes.

---

# 16. Independent verifier

File:

`AMRAL_LUC_FC_Round_10_reference_verifier.py`

Function:

1. verify the manifest;
2. verify SHA-256;
3. regenerate base leaves;
4. replay lift bits;
5. regenerate every witness box;
6. independent erosion reconstruction;
7. handwritten monotone-chain hull;
8. subtract the dry-run pad;
9. verify every leaf;
10. verify:

   $$
   N=2L-1;
   $$

11. verify stream exhaustion;
12. emit:

   `verification_summary.json`.

---

# 17. Certificate density

Every tree uses:

$$
1\text{ bit/node}
$$

semantic encoding.

Round 10's tree bytes are very small.

The future global certificate can still carry this forward:

- one-bit split/prune stream;
- external index;
- witness id/reference stored separately by the base tree.

This is compatible with Mishra's one-bit-per-node approach.

---

# 18. Pipeline state machine

Round 10 now has an actually executable:

```text
BASE CELL
    |
    v
LIFT ROOT
    |
    +-- lower >= search threshold --> 0 leaf
    |
    +-- otherwise --> 1 split
                       |
                       v
                  child boxes
```

verifier:

```text
0 leaf
    |
    v
recompute common cores
    |
    v
independent inner hull
    |
    v
lower area - pad >= target ?
```

---

# 19. Failure semantics

If the reference emitter encounters:

- `MAX_DEPTH`;
- an unresolved lift box;

it directly:

$$
\boxed{
\text{FAIL}
}
$$

rather than writing the unresolved leaf as a prune.

If the verifier encounters:

- a hash mismatch;
- a leaf lower failure;
- an early stream end;
- extra non-padding nodes;
- the wrong tree identity;

it also rejects directly.

This is the fail-closed semantics that a formal global verifier must retain.

---

# 20. Round 10 claim ledger

## `PROVED-ANALYTIC`

- nested certificate soundness theorem: inherited from R08;
- exact split regeneration logic;
- common-core math: inherited from R08.

## `VERIFIED-COMPUTATIONAL`

Within reference/dry-run scope:

- 4 local base leaves;
- 4 full B7 root trees;
- 11372 nodes;
- 5688 leaves;
- independent replay passes.

## `CONDITIONAL`

- if the same machinery is extended to the full global base atlas and all leaves close, then one can derive:

  $$
  a_{\mathrm{Leb}}\ge0.835.
  $$

## `COMPUTE-DEFERRED`

- full five-dimensional atlas;
- global B7 conditional lift;
- fallback witness batch;
- publication-grade arithmetic bound.

## `REJECTED`

- Treating Round 10's local dry run as a global $0.835$ theorem.

---

# 21. The next computational gate is already very clear

A genuine global $0.835$ certificate is now just one step away from replacing:

$$
\boxed{
\text{local base root}
}
$$

with:

$$
\boxed{
\text{the complete threshold-conditioned five-dimensional atlas}.
}
$$

The nested B7 tree machinery itself has already been run through successfully.

---

# 22. Round 11 assigned topic

## AMRAL-LUC-FC-R11
### Global Atlas Partition Strategy and Parallel Certificate Sharding

If the local side's global atlas has not come back yet:

Round 11 will focus mainly on:

1. how to shard the full 5-D atlas;
2. seed forest structure;
3. deterministic task ordering;
4. base-cell difficulty forecasting;
5. global manifest / shard hashes;
6. resumable verification;
7. multi-machine certificate merging;
8. how a second AI can independently re-verify using only a shard.

If the local side already has a partial atlas:

directly ingest:

- hard-cell distribution;
- B7 close rate;
- unresolved classes.

---

# 23. Shortest handoff conclusion

Round 10, for the first time, actually pushed:

$$
\boxed{
\text{AMRAL LUC-FC proof architecture}
}
$$

from:

$$
\text{methodology}
$$

through to:

$$
\boxed{
\text{emitted certificate bytes}
+
\text{independent replay}.
}
$$

But the scope was deliberately kept local.

The most accurate current status:

$$
\boxed{
\text{REFERENCE PIPELINE: VERIFIED}
}
$$

$$
\boxed{
\text{GLOBAL }0.8350\text{ CERTIFICATE: STILL OPEN}
}
$$

This is the last small end-to-end engineering gate we should complete before we actually pour compute into the global atlas.