# AMRAL × Lebesgue Universal Covering — Round 11
## Global Atlas Partition Strategy and Parallel Certificate Sharding

**Document ID:** AMRAL-LUC-FC-R11  
**Version:** v0.1  
**Date:** 2026-09-18  
**Research status:** Round 11 / Global proof-state orchestration / Sharded certificate architecture  
**Research mode:** Human-Directed + Semi-Autonomous AI Mathematical Research  
**Research initiation & methodology source:** Neo.K  
**AI collaborating researcher & primary executor:** Aletheia / ChatGPT, GPT-5.6 Sol  
**Prerequisite documents:** AMRAL-LUC-FC-R00 v0.2; R01–R10 v0.1  

---

# 0. Round Summary Verdict

Round 10 first actually ran end to end:

$$
\text{base leaf}
\to
\text{B7 lift tree}
\to
\text{certificate bytes}
\to
\text{independent replay}.
$$

But a truly global computation of

$$
T=0.8350
$$

must not be tied to a single process, a single machine, or a single AI conversation.

Round 11 establishes:

$$
\boxed{
\text{Prefix-Free Certified Frontier}
}
$$

and:

$$
\boxed{
\text{Shard / Resume / Merge proof state}.
}
$$

This round's main results:

1. the global root can be represented by a prefix-free complete seed frontier;
2. a hard seed can legally be replaced by its descendants at any time;
3. scheduling, work stealing, and machine failure do not enter the theorem premise;
4. as long as shards exactly partition the frontier, they can be independently verified and then merged;
5. a global forest identity is established:

   $$
   N=2L-S;
   $$

6. a content-addressed shard manifest + Merkle root is established;
7. a cross-machine deterministic seed identity is established;
8. Round 10's 4-leaf reference certificate has actually been split into $3$ shards, then independently merge-replayed successfully.

Therefore:

$$
\boxed{
\text{SHARDED CERTIFICATE ARCHITECTURE: CLOSED}
}
$$

$$
\boxed{
\text{GLOBAL }0.8350\text{ HEAVY RUN: COMPUTE-DEFERRED}
}
$$

---

# 1. Seed path

Write the global base root as the empty path:

$$
\epsilon.
$$

For every deterministic binary split:

- the left child appends:

  $$
  0;
  $$

- the right child appends:

  $$
  1.
  $$

So every descendant box has a unique path:

$$
p\in\{0,1\}^\star.
$$

If the production grammar uses an explicit split axis, the full seed identity should record:

$$
\boxed{
(\text{axis}_1,b_1),
(\text{axis}_2,b_2),
\ldots
}
$$

rather than just the bit.

This round's reference demo uses a fixed split rule, so it can use just the bit path.

---

# 2. Prefix-free frontier

Let:

$$
\mathcal P
\subset
\{0,1\}^\star
$$

be a finite set of seed paths.

$$
\mathcal P
$$

is called prefix-free if there do not exist:

$$
p,q\in\mathcal P,
\qquad
p\ne q,
$$

such that:

$$
p
$$

is a prefix of:

$$
q.
$$

This prevents an ancestor and a descendant from being treated as two independent proof roots at the same time.

---

# 3. Complete frontier

A prefix-free:

$$
\mathcal P
$$

is called a complete frontier if, recursing downward from the root:

- if a node's path:

  $$
  p\in\mathcal P,
  $$

  then that branch stops;

- otherwise, both child branches:

  $$
  p0
  $$

  and:

  $$
  p1
  $$

  must continue and eventually hit the frontier.

Equivalently:

> from the root, every infinite binary descent path first meets exactly one frontier prefix.

---

# 4. Complete-Frontier Coverage Theorem

## Theorem 4.1

Assume every split satisfies:

$$
\boxed{
B(p)
\subseteq
B(p0)\cup B(p1).
}
$$

If:

$$
\mathcal P
$$

is a complete frontier, then:

$$
\boxed{
B(\epsilon)
\subseteq
\bigcup_{p\in\mathcal P}
B(p).
}
$$

### Proof

Structural induction on the finite frontier tree.

If:

$$
\epsilon\in\mathcal P,
$$

this is trivial.

Otherwise, the root's two branches are both covered by complete frontiers.

By:

$$
B(\epsilon)
\subseteq
B(0)\cup B(1)
$$

and induction, the conclusion follows.

Q.E.D.

---

# 5. Frontier Replacement Invariant

## Theorem 5.1

If:

$$
\mathcal P
$$

is a complete prefix-free frontier, and:

$$
p\in\mathcal P,
$$

let:

$$
\boxed{
\mathcal P'
=
(\mathcal P\setminus\{p\})
\cup
\{p0,p1\}.
}
$$

Then:

$$
\mathcal P'
$$

is still a complete prefix-free frontier.

So a hard seed can legally:

$$
\boxed{
p
\rightsquigarrow
\{p0,p1\}.
}
$$

Applying this repeatedly can split one hard shard into a complete descendant frontier of arbitrary depth.

---

# 6. Resume semantics

A worker does not need to pretend that an incomplete seed already has closure.

If a node cap, wall-time limit, or machine preemption occurs, the worker only needs to output:

```text
status = EXPANDED
old_seed = p
replacement_frontier = {p_1,...,p_k}
```

where:

$$
\{p_1,\ldots,p_k\}
$$

is a complete prefix-free frontier of the subtree of:

$$
p.
$$

The global coordinator performs the frontier replacement.

So:

$$
\boxed{
\text{interrupt}
\neq
\text{proof failure}.
}
$$

Only mislabeling an unresolved seed as a certified leaf is a proof failure.

---

# 7. Shard

A shard:

$$
S_a
$$

is a finite seed subset:

$$
\mathcal P_a
\subseteq\mathcal P.
$$

Each seed has:

- a seed identity;
- a reconstructed root box;
- certificate bytes / subtree;
- a hash;
- a verification summary.

Shards are responsible only for work packaging.

They do not change the mathematical domain.

---

# 8. Shard Partition Theorem

## Theorem 8.1

If:

$$
\mathcal P
$$

is a complete frontier, and the shards satisfy:

$$
\boxed{
\mathcal P
=
\bigsqcup_{a=1}^s
\mathcal P_a,
}
$$

that is:

- every frontier seed belongs to exactly one shard;
- there are no duplicate seeds;
- there are no missing seeds;

and every seed in every shard has been independently proved:

$$
\forall q\in B(p),
\quad
A(q)\ge T,
$$

then:

$$
\boxed{
\forall q\in B(\epsilon),
\quad
A(q)\ge T.
}
$$

This is the core soundness theorem for the global merge.

---

# 9. Shard order does not matter

The proof depends only on:

$$
\boxed{
\text{frontier coverage}
+
\text{seed certificate validity}.
}
$$

So:

- shard order;
- worker id;
- completion time;
- machine;
- AI agent;
- queue discipline;

are all outside the theorem premise.

This lets:

$$
\boxed{
\text{distributed computation}
}
$$

and:

$$
\boxed{
\text{proof semantics}
}
$$

be completely separated.

---

# 10. Forest structural identity

For a set of:

$$
S
$$

independent binary certificate roots:

if every internal node of every tree has exactly two children,

with total nodes:

$$
N,
$$

and total leaves:

$$
L,
$$

then:

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

This is exactly what the Mishra verifier uses:

$$
2L-n_{\rm seed}=N
$$

as its global structural audit.

Round 11 requires:

- one verification per shard;
- one more verification of the full frontier after the merge.

---

# 11. Dynamic reshard identity

If a seed certificate is not yet complete and is replaced with:

$$
k
$$

complete descendant seeds,

the global root count:

$$
S
$$

increases by:

$$
k-1.
$$

The final forest identity must still use the final frontier size:

$$
\boxed{
S=|\mathcal P_{\rm final}|.
}
$$

So the proof does not need to remember how it was resharded along the way.

Only the final frontier and every terminal certificate are needed.

---

# 12. Content-addressed shard

After canonicalizing the shard manifest payload:

$$
H_a
=
\operatorname{SHA256}
(
\text{canonical shard payload}
).
$$

The payload includes at least:

- shard id;
- target;
- seed ids;
- root-box identities;
- certificate hashes;
- node / leaf metadata;
- proof policy version.

Any change in content:

$$
\Rightarrow
H_a
$$

changes.

---

# 13. Merkle binding

Sort all shard hashes:

$$
H_1,\ldots,H_s.
$$

Build a binary Merkle root:

$$
\boxed{
H_{\rm root}.
}
$$

The global manifest stores:

$$
H_{\rm root}.
$$

This lets:

- shard replacement;
- stale results;
- accidental mismatch;

be detected before the merge.

A Merkle root is not a substitute for mathematical correctness — it is only a data-integrity binding.

---

# 14. Deterministic seed identity

The most dangerous thing about cross-machine replay is not the mathematics, but:

> does the same seed id really represent the same box?

Production has two optional modes.

---

## Mode A: Implicit deterministic split

The seed path stores only:

$$
0/1
$$

bits.

The verifier reconstructs the axis and the box from:

- the root;
- the split rule version;
- the tie-break rule.

Advantage:

- minimal metadata.

Disadvantage:

- sensitive to cross-language / cross-floating-point implementation.

---

## Mode B: Explicit split-axis path

Each step records:

$$
(a,b)
$$

where:

- $a$ = split axis;
- $b\in\{0,1\}$ = side.

The verifier only needs to:

1. reconstruct the specified axis's midpoint split;
2. check that the children cover the parent.

Advantage:

- better suited to multi-runtime / multi-AI settings.

Round 11 recommends that the production global certificate prioritize:

$$
\boxed{
\text{Mode B}.
}
$$

A few extra bits buy noticeably better portability.

---

# 15. Exact / dyadic interval state

If the root endpoints are fixed as outward-rounded decimal rationals,

then every midpoint split can be represented exactly at the dyadic-rational level.

So the seed box can be exactly reconstructed from:

$$
\boxed{
\text{root rational constants}
+
\text{axis/side path}
}
$$

Floating point appears only in the geometric lower-bound calculation.

This reduces:

- box drift;
- platform-dependent midpoints;
- serialize / deserialize mismatches.

---

# 16. Global 0.835 base root

Round 07 / 08 already fixed:

$$
T=0.835.
$$

Base:

$$
D+B_3+B_5.
$$

Safe translation radial domains:

$$
|t_3|
\le
0.194856180909,
$$

$$
|t_5|
\le
0.197820670401.
$$

Orientation:

$$
\phi_5
\in
[0,2\pi/5).
$$

The global production atlas root can use the enclosing box:

$$
x_3,y_3
\in
[-t_3,t_3],
$$

$$
x_5,y_5
\in
[-t_5,t_5],
$$

then prune the square's corners with the a-priori radial proof.

---

# 17. Initial seeding strategy

It is not recommended to start by fixing, as Mishra does, a depth of:

$$
d=22
$$

cutting out:

$$
2^{22}
$$

seeds.

Mishra's depth of 22 was measured against his own monolithic family-B emitter and workload.

Round 11 recommends:

1. choose a modest initial depth:

   $$
   d_0;
   $$

2. estimate seed cost with a pilot run;
3. dynamic frontier replacement for hard seeds;
4. no extra fragmentation for easy seeds.

So the final seed sizes can be highly non-uniform.

The proof fully allows this.

---

# 18. Work-cap continuation

For a shard worker, set a node budget:

$$
N_{\rm cap}.
$$

Worker DFS:

```text
while stack:
    if certified:
        record certificate leaf
    elif work < N_cap:
        split and continue
    else:
        return unresolved complete frontier
```

Unfinished work is not written as a proof leaf.

The coordinator re-enqueues the returned frontier.

This is compatible with the idea behind the official `certgen.py`'s unfinished-DFS-stack requeue.

Round 11 rewrites it as content-addressed proof state.

---

# 19. Difficulty forecast from Round 09

If a cell has:

- uncertainty:

  $$
  \tau(C);
  $$

- a representative rigorous margin:

  $$
  m(C)>0;
  $$

then there is a closure-required radius:

$$
\tau_\star(m,T).
$$

One can define the predicted refinement cycles:

$$
\boxed{
r_{\rm pred}(C)
=
\max
\left\{
0,
\left\lceil
\log_2
\frac{
S(C)
}{
\tau_\star(m,T)
}
\right\rceil
\right\}.
}
$$

where:

$$
S(C)
$$

is Round 09's linear-motion surrogate.

This is a theorem-derived upper-depth forecast.

If:

$$
m(C)\le0,
$$

mark it:

`ACTIVE/HARD`

— do not pretend there is a closure-depth estimate.

---

# 20. Scheduling heuristic

The proof does not depend on the scheduler.

One may use:

```text
priority:
    ACTIVE/HARD first
    then large predicted depth
    then high historical nodes/seed
```

or the reverse order, clearing easy seeds first.

This is purely a throughput strategy.

---

# 21. Shard output states

Every shard can only be one of:

## `COMPLETE`

All terminal seeds in the shard already have complete certificates.

## `EXPANDED`

The shard does not claim completion.

It only outputs a new complete descendant frontier for rescheduling.

## `FAILED`

One of the following occurred:

- invalid geometry;
- an arithmetic failure;
- a corrupt stream;
- an inconsistent root.

The final global proof accepts only

`COMPLETE`

terminal shards.

---

# 22. Global merge checklist

The merger must verify:

1. the global manifest hash;
2. target / policy consistency;
3. that the frontier is prefix-free;
4. that the frontier is complete;
5. that every frontier seed appears exactly once;
6. the shard payload hashes;
7. the Merkle root;
8. each seed's root-box reconstruction;
9. each seed's certificate;
10. the per-shard forest identity;
11. the global forest identity;
12. that no terminal state is `EXPANDED`/`FAILED`/`UNRESOLVED`;
13. that verifier versions / arithmetic policies are compatible.

---

# 23. Multi-AI independent replay

Round 11's dual-track cloud architecture maps directly onto shards.

Frontier AI:

- emits / improves shards;
- maintains the global manifest.

Lagged verifier AI:

- samples shards randomly or systematically;
- independently replays from the seed root;
- does not read the emitter's search heuristics;
- returns:

  - `PASS`
  - `CORRECTION`
  - `COUNTEREXAMPLE`
  - `ARITHMETIC-DISAGREEMENT`

A third, local verifier can perform a full replay.

This is not a majority vote.

Any single valid counterexample is enough to reject a shard.

---

# 24. Shard ancestry

Recomputing or splitting a shard must not overwrite history.

Record:

```text
shard_id
parent_shard_id
replaces_seed_paths
new_frontier_paths
reason
source_hash
result_hash
verifier_hash
```

If an old shard has an error,

mark it:

`CORRECTED`

or:

`REJECTED`

Do not delete the old version.

---

# 25. Reference sharding dry run

Round 10's local reference frontier:

$$
\boxed{
\mathcal P
=
\{00,01,10,11\}.
}
$$

It is a depth-two complete prefix-free frontier.

Round 11 deliberately splits it non-uniformly into:

### Shard A

$$
\{00,11\}
$$

### Shard B

$$
\{01\}
$$

### Shard C

$$
\{10\}
$$

Neither order nor adjacency matters.

---

# 26. Actual reference shard replay

Round 11's standalone reference package duplicates Round 10's:

- independent verifier;
- certificate bytes;
- source manifest.

Then:

1. build $3$ shard manifests;
2. SHA-256-bind each payload;
3. build the shard Merkle root;
4. have the merge verifier reconstruct:

   $$
   \{00,01,10,11\};
   $$

5. check that the frontier is prefix-free and complete;
6. independently replay all $4$ lift certificates;
7. check the per-shard forest identities;
8. check the global forest identity.

Result:

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

---

# 27. Reference counts

Globally:

$$
\boxed{
S=4
}
$$

roots.

$$
\boxed{
N=11372
}
$$

nodes.

$$
\boxed{
L=5688
}
$$

leaves.

Check:

$$
2L-S
=
2(5688)-4
=
11372
=
N.
$$

PASS.

---

# 28. Per-shard identities

## Shard A

Two roots:

$$
00,\ 11.
$$

Its:

$$
N_A
=
2833+2853
=
5686,
$$

$$
L_A
=
1417+1427
=
2844.
$$

Check:

$$
2L_A-2
=
5686.
$$

---

## Shard B

One root:

$$
01.
$$

$$
N_B=2853,
\qquad
L_B=1427.
$$

$$
2L_B-1=2853.
$$

---

## Shard C

One root:

$$
10.
$$

$$
N_C=2833,
\qquad
L_C=1417.
$$

$$
2L_C-1=2833.
$$

All PASS.

---

# 29. Reference scope remains local

Round 11's actual shard replay is still bound only to Round 10's local base neighborhood.

So:

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

is not:

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

The production global run needs to swap the frontier root for the complete Round 07 global base domain.

---

# 30. Production shard manifest minimum fields

```text
program_id
round
target

root_domain_hash
split_policy_hash
arithmetic_policy_hash
witness_catalog_hash

shard_id
shard_status

seed_entries:
    seed_path
    seed_box_hash
    certificate_hash
    nodes
    leaves
    worst_slack

payload_sha256
```

---

# 31. Global manifest minimum fields

```text
global_root_hash
target
proof_policy_version

frontier_seed_paths

shards:
    shard_id
    shard_payload_hash
    seed_paths

shard_merkle_root

verifier_requirements
```

---

# 32. Checkpoint manifest

A non-final checkpoint can additionally store:

```text
complete_shards
expanded_shards
pending_frontier
failed_shards
total_verified_nodes
total_pending_seeds
```

But in the final theorem manifest:

$$
\boxed{
\text{pending}=0.
}
$$

---

# 33. Why sharding does not weaken the proof

The global theorem originally requires:

$$
\forall q\in B_{\rm root},
\quad
A(q)\ge T.
$$

Sharding only rewrites:

$$
B_{\rm root}
$$

as:

$$
\bigcup_{p\in\mathcal P}
B(p).
$$

Every seed is still checked one by one:

$$
\forall q\in B(p).
$$

So there is no:

- sampling;
- statistical assumption;
- majority assumption;
- worker-trust assumption.

A worker can be entirely untrusted.

The verifier only needs to replay the certificate.

---

# 34. Reshard example

Suppose:

$$
p=0101
$$

is too hard.

It can be replaced with:

$$
01010,
\qquad
01011.
$$

If:

$$
01010
$$

is still too hard, then again:

$$
01010
\to
010100,
010101.
$$

The frontier becomes:

$$
\ldots,
010100,
010101,
01011,
\ldots
$$

and remains complete.

So the global queue only ever needs to keep:

$$
\boxed{
\text{the current frontier}
}
$$

— it does not need to keep the scheduling history in order to prove coverage.

---

# 35. Cross-machine arithmetic policy

Different machines may:

- emit;
- verify;
- cross-check.

But within one production theorem layer, the following must be fixed:

$$
\boxed{
\text{arithmetic policy contract}.
}
$$

For example:

- double + a proven error budget;
- interval arithmetic;
- rational inner points;
- a hybrid.

A shard may use a different policy — that is acceptable — but the manifest must state it, and the global verifier must support and verify it shard by shard.

One shard's error theorem must not be applied to another policy.

---

# 36. Cross-version safety

If the geometry kernel is upgraded,

a new shard must carry:

$$
\text{geometry\_hash}.
$$

An old shard may continue to exist.

The global manifest must not silently mix incompatible versions.

The merger must either:

1. have a verifier that supports both versions at once;
2. or require that shard to be recomputed.

---

# 37. COMPUTE-DEFERRED

## C11-1 — Global seed pilot

Run a modest-depth pilot on the complete:

$$
T=0.835
$$

base root.

Output:

- seed count;
- base prune rate;
- predicted hard fraction;
- nodes/seed distribution.

---

## C11-2 — Dynamic reshard

Set a worker cap.

Hard seeds automatically:

$$
p\to\{p0,p1\}.
$$

Save a frontier checkpoint.

---

## C11-3 — B7 lift shards

Launch the B7 lift for retained hard base seeds / leaves.

Lift certificates may be further sub-sharded, but the base seed must keep its references.

---

## C11-4 — Independent shard verifier pool

A second AI / local verifier replays shards independently.

---

## C11-5 — Global merge

Only when:

$$
\text{pending}=0
$$

and every shard has PASSed is it permitted to output

`GLOBAL-CERTIFICATE-CANDIDATE`

After that, a publication-grade arithmetic audit is still required.

---

# 38. Round 12 assigned topic

## AMRAL-LUC-FC-R12
### Global Checkpoint Crystal and Multi-AI Shard Audit Protocol

If the global compute has not yet come back:

1. build a persistent frontier checkpoint format;
2. define a shard claim ledger;
3. define cross-AI revalidation sampling;
4. define correction propagation;
5. define stale-shard invalidation;
6. turn the cloud State Crystal directly into a global distributed proof-state.

If a partial global atlas already exists:

directly ingest:

- complete shards;
- hard-seed distribution;
- B7 closure rate;
- pending frontier.

---

# 39. Reproducibility checklist

## Prefix-free frontier theorem

`PROVED`

## Frontier replacement invariant

`PROVED`

## Shard partition theorem

`PROVED`

## Global forest identity

`PROVED`

## Content-addressed shard binding

`IMPLEMENTED`

## Merkle root binding

`IMPLEMENTED`

## Reference shard replay

`PASS`

## Global 0.835 heavy run

`COMPUTE-DEFERRED`

---

# 40. Shortest handoff conclusion

Round 11 rewrites:

$$
\boxed{
\text{the global exhaustive proof}
}
$$

from one giant monolithic job into:

$$
\boxed{
\text{a complete prefix-free frontier}
+
\text{independently verifiable shards}.
}
$$

The single most important invariant:

$$
\boxed{
p
\rightsquigarrow
\{p0,p1\}
}
$$

may occur any number of times without changing the proof's coverage.

So, going forward:

- machine interruption;
- quota reset;
- a second AI taking over;
- shard recomputation;
- multi-machine parallelism;
- a hard seed being split again;

none of these require destroying or restarting the entire global proof.

The only things that are actually theorem-critical are:

$$
\boxed{
\text{the final frontier is complete}
+
\text{every terminal seed is certified}.
}
$$