# AMRAL × Lebesgue Universal Covering — Round 15
## Global Proof Capacity and Automatic Threshold Ladder

**Document ID:** AMRAL-LUC-FC-R15  
**Version:** v0.1  
**Date:** 2026-09-19  
**Research Status:** Round 15 / Capacity-aware lower-bound ladder  
**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–R14 v0.1  

---

# 0. This Round's Verdict Summary

Round 14 already took every claim beyond a bare:

`PASS / FAIL`

and gave it a quantitative proof capacity.

Round 15's core question:

> Without recomputing every shard, how far can the existing distributed evidence graph push the lower target? Once that point is exceeded, exactly which proof regions actually need to be recomputed?

This round obtains:

1. Root-Domain Capacity;
2. Recursive Evidence Capacity;
3. the Global Capacity Theorem;
4. Free Promotion;
5. the Capacity Staircase;
6. the Bottleneck / Deficit Frontier;
7. the Minimum-Cost Repair Dynamic Program;
8. the phase-master root strategy;
9. an actual reference capacity planner.

This round's verdict:

$$
\boxed{
\text{PROOF CAPACITY ALGEBRA: CLOSED}
}
$$

$$
\boxed{
\text{THRESHOLD LADDER AUTOMATION: CLOSED}
}
$$

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

---

# 1. The First Limitation That Cannot Be Ignored: the Root Also Has a Capacity

If the global proof performs exhaustive certification only within:

$$
|t_3|\le t_3(0.835),
\qquad
|t_5|\le t_5(0.835)
$$

then the legitimacy of the outside-root region comes from:

$$
\text{a-priori bound}\ge0.835.
$$

Even if all internal shards later carry enormous slack,

the theorem target still cannot simply be raised to:

$$
0.8353
$$

unless:

- the outside-root proof also supports $0.8353$;
- or the root was built with a higher master target to begin with.

So:

$$
\boxed{
\text{shard slack is not the only capacity}.
}
$$

---

# 2. Root-Domain Capacity

Definition:

$$
\boxed{
C_{\mathrm{root}}
}
$$

is the highest target that the current root + outside-root exclusion theorem can support.

If the root is built directly from the phase target:

$$
T_M
$$

as:

$$
t_n=t_n(T_M),
$$

then at least:

$$
\boxed{
C_{\mathrm{root}}\ge T_M.
}
$$

In this program the phase contract is usually written directly as:

$$
C_{\mathrm{root}}=T_M.
$$

This is conservative and clear.

---

# 3. Direct Claim Capacity

For a proof-tree node:

$$
p,
$$

the set of current-compatible claims that directly prove:

$$
B(p)
$$

is:

$$
\mathcal C(p).
$$

Round 14 assigns every:

$$
c
$$

a capacity:

$$
\operatorname{Cap}(c).
$$

Definition:

$$
\boxed{
D(p)
=
\max_{c\in\mathcal C(p)}
\operatorname{Cap}(c).
}
$$

If:

$$
\mathcal C(p)
$$

is empty, then:

$$
D(p)=-\infty.
$$

---

# 4. Recursive Evidence Capacity

If node:

$$
p
$$

has a complete child partition:

$$
p0,p1,
$$

then:

$$
\boxed{
C(p)
=
\max
\left\{
D(p),
\min
\{
C(p0),C(p1)
\}
\right\}.
}
$$

If there is no complete child evidence branch:

$$
C(p)=D(p).
$$

The root is:

$$
\epsilon.
$$

So:

$$
\boxed{
C_{\mathrm{evidence}}
=
C(\epsilon).
}
$$

---

# 5. Why It Is Max-Min

There are two legitimate proof routes.

## Route A: Direct Ancestor

Use the claim directly:

$$
c_p.
$$

It supports at most:

$$
D(p).
$$

## Route B: Split Composition

To cover the parent using the children,

both the left and right sides must hold.

So the threshold is limited by the weaker child:

$$
\min
\{
C(p0),C(p1)
\}.
$$

Between the two routes we may choose the stronger one:

$$
\max.
$$

This is exactly why we get the max-min recursion.

---

# 6. The Evidence Capacity Theorem

## Theorem 6.1

For any:

$$
T\le C(p),
$$

the registered evidence graph proves:

$$
\forall x\in B(p),
\quad
\Phi(x)\ge T.
$$

### Proof

By induction on the structure of the proof tree.

If:

$$
C(p)=D(p),
$$

there exists a direct compatible claim supporting at least:

$$
T.
$$

If:

$$
C(p)
=
\min
\{
C(p0),C(p1)
\},
$$

then both children prove:

$$
\ge T.
$$

And:

$$
B(p)
\subseteq
B(p0)\cup B(p1).
$$

So the parent holds.

If the two routes have equal capacity, either one may be taken.

Q.E.D.

---

# 7. Relative Optimality

Holding fixed:

- the registered evidence graph;
- the registered semantic migration rules;
- the direct-claim / binary-child composition grammar;

$$
C(p)
$$

is exactly the highest derivable threshold.

This is not saying that no other, not-yet-incorporated new mathematical proof could exist.

It is only saying:

$$
\boxed{
\text{the proof ceiling of the current evidence graph}.
}
$$

---

# 8. Global Proof Capacity

The global theorem target is simultaneously constrained by:

- the root;
- the evidence;

So:

$$
\boxed{
C_{\mathrm{global}}
=
\min
\{
C_{\mathrm{root}},
C_{\mathrm{evidence}}
\}.
}
$$

This is Round 15's central quantity.

---

# 9. The Free Promotion Theorem

If the current canonical target:

$$
T_0
<
T_1
\le
C_{\mathrm{global}},
$$

then no new geometry certificate is needed.

All that is required is:

1. the semantic validator recomputes eligibility using:

   $$
   T_1
   $$

2. a global merge;
3. the publication arithmetic gate.

So:

$$
\boxed{
T_0\to T_1
}
$$

is a free proof promotion.

---

# 10. The Capacity Staircase

As the target moves from low to high,

a claim's eligibility only changes at its own capacity breakpoint.

So evidence reuse is stepwise:

$$
\boxed{
T_1<T_2<\cdots<T_k.
}
$$

Each time a breakpoint is crossed,

only the bottleneck evidence near that breakpoint needs new work.

---

# 11. The Target Feasibility Boolean

For a target:

$$
T,
$$

define:

$$
F_T(p).
$$

If directly:

$$
D(p)\ge T,
$$

then:

$$
F_T(p)=1.
$$

Otherwise, if complete children exist:

$$
F_T(p)
=
F_T(p0)\land F_T(p1).
$$

With no available route:

$$
F_T(p)=0.
$$

---

# 12. The Deficit Frontier

If:

$$
F_T(\epsilon)=0,
$$

descend along the proof tree to find the first layer of obligations not closed by existing evidence.

Call:

$$
\boxed{
\Delta_T
}
$$

the target deficit frontier.

The scheduler only needs to issue new jobs for:

$$
\Delta_T
$$

---

# 13. Reference Capacity

Round 14's local reference, currently:

$$
e=10^{-8}.
$$

Leaf direct capacities:

## Seed `00`

From shard-A:

$$
0.8350003869877956.
$$

## Seed `01`

From the corrected shard-B:

$$
0.8350009574949350.
$$

## Seed `10`

From shard-C:

$$
\boxed{
0.8350003545377508.
}
$$

## Seed `11`

From shard-A:

$$
0.8350003869877956.
$$

---

# 14. Reference Tree Calculation

Child:

$$
0
$$

capacity:

$$
\min
(
C(00),C(01)
)
=
0.8350003869877956.
$$

Child:

$$
1
$$

capacity:

$$
\min
(
C(10),C(11)
)
=
0.8350003545377508.
$$

Root:

$$
\boxed{
C(\epsilon)
=
0.8350003545377508.
}
$$

Because the local reference scope carries no outside-global-root obligation,

this example's root capacity is treated as scope-fixed.

So the reference proof capacity is:

$$
\boxed{
C_{\mathrm{ref}}
=
0.8350003545377508.
}
$$

This is not the global Lebesgue lower bound.

---

# 15. Reference Free Promotion

Original target:

$$
0.835.
$$

Existing evidence, with no new certificate, already supports:

$$
\boxed{
0.83500035
}
$$

within the local reference scope.

Machine planner verdict:

`READY`

---

# 16. First Bottleneck

If the target is:

$$
0.83500036,
$$

then:

- `00`: pass;
- `01`: pass;
- `10`: fail;
- `11`: pass.

So:

$$
\boxed{
\Delta_T=\{10\}.
}
$$

Only shard-C / seed-10 needs new evidence.

---

# 17. Second Capacity Step

Target:

$$
0.83500039.
$$

At this point shard-A's capacity also falls below the target.

Deficit:

$$
\boxed{
\{00,10,11\}.
}
$$

But:

`00`

and:

`11`

share the same shard-A claim.

So the job planner should recognize:

$$
\boxed{
\text{upgrade shard-A}
+
\text{upgrade shard-C}
}
$$

rather than three fully independent jobs.

---

# 18. Higher Reference Targets

Target:

$$
0.83500095
$$

still gives:

- B pass;
- A/C fail.

Target:

$$
0.83500096
$$

then B also exceeds its capacity:

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

— all four now need new evidence.

---

# 19. The Minimum-Cost Repair DP

Now we want to know not just:

> Which seeds fail?

but also:

> Is it cheaper to prove the ancestor, or to repair the descendants individually?

Let:

$$
J_T(p)
$$

be the estimated cost of directly re-proving:

$$
B(p)
$$

to target:

$$
T
$$

Define:

$$
K_T(p).
$$

If already:

$$
F_T(p)=1,
$$

then:

$$
K_T(p)=0.
$$

Otherwise, when complete children exist:

$$
\boxed{
K_T(p)
=
\min
\left\{
J_T(p),
K_T(p0)+K_T(p1)
\right\}.
}
$$

If there is no child decomposition:

$$
K_T(p)=J_T(p).
$$

---

# 20. The Repair DP Theorem

Under the following job grammar:

- direct recertification at a node;
- independent child repairs;
- additive cost forecasting;

the above:

$$
K_T(p)
$$

is the minimum forecast cost.

### Proof

A node has only two ways to close:

1. directly;
2. via both children.

Take the minimum cost of the two.

The children are in turn recursively optimal.

This is standard dynamic-programming induction.

Q.E.D.

---

# 21. The Planning Version of Ancestor Contraction

Round 13:

Certified Ancestor Contraction is a race-safe merge rule.

Round 15:

$$
J_T(p)
$$

lets the planner actively ask:

> Rather than recomputing many descendants, would it be cheaper to directly re-prove the ancestor $p$?

So ancestor contraction is promoted from:

`race recovery`

to:

$$
\boxed{
\text{a cost optimization option}.
}
$$

---

# 22. Cost Does Not Enter the Proof

$$
J_T(p)
$$

may be inaccurate.

At worst this only slows scheduling.

It does not affect:

- certificate validity;
- the target;
- domain coverage.

So the planner is free to use a learned cost model.

---

# 23. Phase Master Root

If the global root were re-expanded every time the target increases by:

$$
10^{-4}
$$

this would cause:

- massive churn in frontier identity;
- shards that cannot be directly reused;
- scheduler reshuffling.

So Round 15 recommends choosing, at the start of a phase:

$$
\boxed{
T_M>T_{\rm immediate}.
}
$$

---

# 24. Reuleaux Phase Example

This round's design example:

$$
\boxed{
T_M=0.8365.
}
$$

This is not a new lower bound.

It is only a phase root ceiling.

For the a-priori formula:

$$
d_\star
\approx
0.699860544061.
$$

translating to:

$$
\boxed{
t_3
\approx
0.201023529007,
}
$$

$$
\boxed{
t_5
\approx
0.202618286230,
}
$$

$$
\boxed{
t_7
\approx
0.201473445786.
}
$$

---

# 25. Master-Root Overhead

Relative to the:

$$
T=0.835
$$

root:

$$
t_3
\approx
0.194856180909,
$$

$$
t_5
\approx
0.197820670401,
$$

$$
t_7
\approx
0.196935046771.
$$

Half-width ratios:

$$
\frac{t_3(0.8365)}{t_3(0.835)}
\approx
1.03165,
$$

$$
\frac{t_5(0.8365)}{t_5(0.835)}
\approx
1.02425,
$$

$$
\frac{t_7(0.8365)}{t_7(0.835)}
\approx
1.02305.
$$

The enclosing-box volume over the four base translation coordinates grows by about:

$$
\boxed{
11.66\%.
}
$$

The B7 translation square grows by about:

$$
\boxed{
4.66\%.
}
$$

This is a domain-amortization tradeoff.

---

# 26. Why 0.8365 Is Only a Phase Design

The official four-body:

$$
D+B_3+B_5+B_7
$$

numerical search ceiling is about:

$$
0.836494901.
$$

So:

$$
0.8365
$$

is a natural B7-phase engineering ceiling.

But:

- the numerical ceiling is not the rigorous family minimum;
- a future witness batch may exceed the B7-only phase.

Therefore this is a:

`PHASE-DESIGN-CHOICE`

not a theorem.

---

# 27. The Root Capacity Wall

If, in the future:

$$
C_{\mathrm{evidence}}
=
0.8366
$$

but:

$$
C_{\mathrm{root}}
=
0.8365,
$$

then:

$$
C_{\mathrm{global}}
=
0.8365.
$$

At that point, recomputing shards further is useless.

The true bottleneck:

$$
\boxed{
\text{the master root}.
}
$$

A new phase is required.

---

# 28. The Automatic Threshold Ladder

The production loop:

```text
load Hot Proof Core
compute claim capacities
compute evidence-tree capacity
compute root capacity
global_capacity = min(root,evidence)

if desired target <= global_capacity:
    free semantic promotion
else:
    compute target deficit frontier
    compute minimum-cost repair plan
    issue only selected jobs
    merge
    repeat
```

---

# 29. Ladder Target Selection

There can be two modes.

## Publication Grid

For example:

$$
10^{-4}
$$

or:

$$
10^{-5}
$$

Fixed decimal milestones.

Advantages:

- clarity;
- easy to cite.

## Capacity-Driven

Push the target directly to:

$$
C_{\mathrm{global}}-\epsilon_{\rm guard}.
$$

Advantage:

- no existing slack is wasted.

The recommendation is for internal research to use capacity-driven,

and for public theorems to use easy-to-read decimals.

---

# 30. Bottleneck Claim Groups

The scheduler's output should not only be:

```text
failed seeds
```

it should also output:

```text
shared claims responsible
```

because recertifying one shard may lift multiple seeds at once.

This can reduce the job count.

---

# 31. Claim-Set Alternative Routes

If a node has:

- a direct ancestor claim;
- descendant claims;

the planner automatically selects the route with the higher capacity.

After the target changes, the optimal route may switch.

So the active proof skeleton itself can change together with the target.

There is no need to delete any evidence.

---

# 32. Capacity Snapshot

The Round 15 package includes:

`reference_capacity_snapshot.json`

which stores:

- node capacity;
- optimal modes;
- leaf capacities;
- breakpoints;
- a sample target deficit frontier;
- a free-promotion example.

---

# 33. The Root Capacity Contract

Future global checkpoints must add:

```text
root_capacity
master_target
root_domain_parameters
outside_root_exclusion_rule
```

A capacity planner without:

`root_capacity`

is forbidden from claiming a global target promotion.

---

# 34. Proof Capacity Status Labels

## `FREE-PROMOTABLE`

$$
T\le C_{\mathrm{global}}.
$$

## `SHARD-BOTTLENECK`

$$
C_{\mathrm{evidence}}
<
\min(
T,
C_{\mathrm{root}}
).
$$

## `ROOT-BOTTLENECK`

$$
C_{\mathrm{root}}
<
\min(
T,
C_{\mathrm{evidence}}
).
$$

## `MIXED-BOTTLENECK`

Both are insufficient at the same time.

---

# 35. COMPUTE-DEFERRED

## C15-1

Change the global $0.835$ production root, from the outset, to a phase master:

$$
T_M=0.8365
$$

or a phase target selected after a pilot.

## C15-2

Every global shard stores:

- proved threshold;
- error budget;
- worst-case slack;
- capacity.

## C15-3

Build a real global capacity tree.

## C15-4

Every checkpoint automatically outputs:

- the current global capacity;
- bottleneck seeds;
- bottleneck claims;
- the next free target;
- a repair plan.

---

# 36. Round 16 Assigned Topic

## AMRAL-LUC-FC-R16
### Capacity-Aware Global Pilot and Bottleneck Profiler

If heavy compute has still not returned,

the next round can actually build a:

$$
T_M=0.8365
$$

global master-root pilot emitter,

first running a limited seed depth rather than chasing full $0.835$ closure, and instead measuring:

- the APR prune rate;
- the REP prune rate;
- the CORE prune rate;
- retained hard seeds;
- the predicted B7 lift cost;
- root/master-domain overhead;
- capacity-aware shard sizing.

That would then give the local side a genuine global job package that can actually begin a long run.

---

# 37. Reproducibility Checklist

## Root capacity

`FORMALIZED`

## Recursive evidence capacity

`PROVED`

## Global capacity theorem

`PROVED`

## Free promotion

`PROVED`

## Capacity staircase

`FORMALIZED + REFERENCE TESTED`

## Deficit frontier

`IMPLEMENTED`

## Minimum-cost repair DP

`PROVED`

## Phase-master root

`FORMALIZED`

## Reference capacity planner

`PASS`

## Global $0.8350$ heavy certificate

`COMPUTE-DEFERRED`

---

# 38. Shortest Handoff Conclusion

Round 15, for the first time, turns the distributed proof into:

$$
\boxed{
\text{a quantitative theorem resource}.
}
$$

No longer just:

> Which shards PASS?

but rather:

> How far can all existing evidence jointly prove, at most?

The core:

$$
\boxed{
C(p)
=
\max
\left(
D(p),
\min(C(p0),C(p1))
\right)
}
$$

together with:

$$
\boxed{
C_{\mathrm{global}}
=
\min(
C_{\mathrm{root}},
C_{\mathrm{evidence}}
).
}
$$

When capacity is exceeded,

there is no need to recompute everything either.

It suffices to compute:

$$
\boxed{
\Delta_T
}
$$

and:

$$
\boxed{
K_T(\epsilon)
}
$$

to find the next batch of bottleneck work.

So subsequent lower-bound progress can become a genuinely automated:

$$
\boxed{
\text{threshold ladder}.
}
$$
