# SDRPC-PRIME-001 Validation Phase I — Round 12
## Adaptive Proof Architecture

**日期：** 2026-09-23  
**Domain：** odd `3 ≤ n ≤ 2,000,000`

**作者：** Neo.K  
**機構：** EveMissLab／一言諾科技有限公司  
**版本：** 原稿未標註（本次整理版）  

---

## 1. 從 Static State 轉成 Conditional Proof Policy

Round 11 的 architecture 還可以被看成固定 probe family。

Round 12 把它改成真正的序列決策：

```text
atom_1
  fail -> emit composite witness -> stop
  pass -> atom_2
            fail -> witness -> stop
            pass -> atom_3
                       ...
all pass -> positive certificate / factor fallback
```

因此 proof object 不再只是 bit vector，而是一條帶 short-circuit semantics 的 operator policy。

## 2. Search Scope

本輪 atom grammar：

```text
D3, D5, D7, S2, S3, S5, S7
```

其中 `D*` 是 cheap divisibility routing atoms，`S*` 是 strong probable-prime relational atoms。

完整枚舉所有 depth ≤ 3 的 ordered policies，另加少量有意義的 depth-4 escalation policies。

總評估 policy 數：**266**。
Pareto non-dominated：**51**。

## 3. Zero-Fallback Policies

| Rank | Policy | Depth | Avg atoms | Avg probe cost | Fallback |
|---:|---|---:|---:|---:|---:|
| 1 | `S3 → S2 → S7` | 3 | 1.298 | 26.967 | 0 |
| 2 | `S3 → S7 → S2` | 3 | 1.298 | 26.967 | 0 |
| 3 | `S3 → S2 → S5` | 3 | 1.298 | 26.967 | 0 |
| 4 | `S3 → S5 → S2` | 3 | 1.298 | 26.967 | 0 |
| 5 | `D3 → S2 → S3 → S5` | 4 | 1.965 | 27.633 | 0 |
| 6 | `S5 → S2 → S3` | 3 | 1.298 | 30.545 | 0 |
| 7 | `S5 → S2 → S7` | 3 | 1.298 | 30.545 | 0 |
| 8 | `S5 → S3 → S2` | 3 | 1.298 | 30.545 | 0 |
| 9 | `S5 → S7 → S2` | 3 | 1.298 | 30.545 | 0 |
| 10 | `D5 → S2 → S3 → S5` | 4 | 2.098 | 31.344 | 0 |

這些 policy 在本有限域沒有 composite 穿過全部 registered atoms，因此 composite side 不需要 factor fallback。

最省平均 probe-generation 的 zero-fallback policy 是：

```text
S3 → S2 → S7
```

平均只執行 **1.298 個 atoms**，雖然最大深度是 3。

這就是 adaptive policy 與固定 vector 最大的差別：大部分輸入根本走不到最後一層。

## 4. 為什麼 S3 放第一層反而很強

`S3` atom 內含 base-divisibility precheck。

所以大量 `3 | n` 的 composites 可以在 very cheap precheck 直接退出；剩餘樣本才支付 modular-exponentiation burden。

因此 `S3 → S2 → S5/7` 在本 cost model 下比 `S2 → S3 → S5` 更省平均 probe cost。

這不是新的 primality theorem，而是 **proof-policy ordering optimization**。

## 5. Order Effect

同一 atom set 換順序，結果：

- `D3+D5+D7`：best `D3 → D5 → D7` = 2.200; worst `D7 → D5 → D3` = 2.543; worst/best = 1.156×
- `S2+S3+S5`：best `S3 → S2 → S5` = 26.967; worst `S2 → S3 → S5` = 35.912; worst/best = 1.332×
- `D3+S2+S3`：best `S3 → S2 → D3` = 23.048; worst `S2 → D3 → S3` = 31.993; worst/best = 1.388×

最明顯的 registered example：

```text
S2 + S3 + S5
```

最佳與最差排列的平均 probe-generation burden 相差約 **1.332×**。

所以：

```text
{A,B,C} as a set != A→B→C as a proof policy
```

**composition order 本身具有 proof semantics。**

## 6. Adaptive vs Static

- `S2 → S3 → S5`：adaptive=35.912, static=69.035, saving=47.981%, fallback=0
- `D3 → D5 → D7`：adaptive=2.200, static=3.000, saving=26.667%, fallback=308213
- `D3 → S2 → S3`：adaptive=23.565, static=47.616, saving=50.510%, fallback=3

例如：

```text
S2 → S3 → S5
```

相對於三個 atoms 對所有 n 全部執行，adaptive short-circuit 約省：

**47.981%** 的 probe-generation proxy。

而 exactness/certificate policy 沒有因此改變。

## 7. Cheap Filters 的位置被重新校準

`D3/D5/D7` 單獨當 prime state 很弱。

但放在 adaptive proof tree 裡，它們可以成為：

```text
cheap routing operators
```

也就是先把 obvious composite branch 剪掉，再把昂貴 MR operator 留給較小 survivor set。

這比把 `6k±1` / wheel 類結構硬解讀成 prime ontology 更合理。

## 8. Pareto Preview

- `S3 → S2 → S7` | depth=3, avg probe=26.967, repair=0.000, fallback=0
- `S3 → S7 → S2` | depth=3, avg probe=26.967, repair=0.000, fallback=0
- `S3 → S5 → S2` | depth=3, avg probe=26.967, repair=0.000, fallback=0
- `S5 → S2 → S3` | depth=3, avg probe=30.545, repair=0.000, fallback=0
- `S5 → S3 → S2` | depth=3, avg probe=30.545, repair=0.000, fallback=0
- `S5 → S7 → S2` | depth=3, avg probe=30.545, repair=0.000, fallback=0
- `S2 → S7 → S3` | depth=3, avg probe=35.912, repair=0.000, fallback=0
- `S2 → S5 → S3` | depth=3, avg probe=35.912, repair=0.000, fallback=0
- `D3 → S5 → S2` | depth=3, avg probe=19.987, repair=0.000, fallback=1
- `D3 → S2 → S5` | depth=3, avg probe=23.565, repair=0.000, fallback=1
- `S5 → S2` | depth=2, avg probe=26.477, repair=0.000, fallback=1
- `S5 → D7 → S2` | depth=3, avg probe=26.626, repair=0.000, fallback=1
- `S5 → D3 → S2` | depth=3, avg probe=26.626, repair=0.000, fallback=1
- `S2 → S5` | depth=2, avg probe=31.844, repair=0.000, fallback=1
- `D3 → S2 → S7` | depth=3, avg probe=23.565, repair=0.000, fallback=1
- `S2 → S7` | depth=2, avg probe=31.844, repair=0.000, fallback=1
- `S3 → S5 → S7` | depth=3, avg probe=26.979, repair=0.000, fallback=1
- `S3 → S7 → S5` | depth=3, avg probe=26.979, repair=0.000, fallback=1
- `S5 → S7 → S3` | depth=3, avg probe=30.557, repair=0.000, fallback=1
- `S5 → S3 → S7` | depth=3, avg probe=30.557, repair=0.000, fallback=1

frontier 保留的是不同 proof policies 的不可全面支配 trade-off，不存在一個脫離 burden axes 的單一『最佳順序』。

## 9. Policy-EMTS*

前面我們得到：

```text
EMTS* = Pareto-minimal exact certificate-carrying architectures
```

這輪應再升級：

```text
Policy-EMTS*(Q; D, G, C)
  = Pareto-minimal adaptive proof policies
    under domain D, grammar G, certificate policy C
```

最小物件不再必須是一個 state；它可以是一棵 decision/proof tree。

## 10. 這直接接回算子本體論

現在不只有『哪個算子存在』，還有：

```text
which operator is applied first?
under which branch condition?
which operator is skipped?
where is the certificate handoff?
```

所以 proof ontology 開始具有：

```text
operator + composition order + branch semantics
```

而不只是 operator set。

## 11. 可序列化物件再擴張

現在應序列化：

- policy graph；
- branch predicate；
- atom provenance；
- stop reason；
- witness；
- fallback reason；
- certificate handoff；
- verifier。

這已經很接近一個 replayable mathematical runtime。

## 12. 下一輪：讓 Policy 自己長出來

Round 13 最自然的是：

```text
Counterexample-Guided Adaptive Policy Synthesis
```

流程：

1. 從 cheapest policy 開始；
2. 找 state-pass composite；
3. 在該 branch 搜尋最便宜、能分裂 witness 的新 atom；
4. 只把 atom 插進需要的 branch；
5. 重新計算 burden；
6. 重複直到 zero-repair 或 Pareto 停止。

這會把之前的 CGPR 真正轉成 proof-policy synthesis algorithm。

## 13. Round 12 結論

```text
proof state can be a policy, not merely a vector;
probe ordering changes computational burden;
cheap insufficient probes can be valuable routing operators;
adaptive short-circuiting can materially reduce average burden;
the natural optimization object is an adaptive proof tree.
```

---

```text
Round 12: COMPLETE
Next: Round 13 — Counterexample-Guided Adaptive Policy Synthesis
```