# OWER Paper 07 v0.1｜形式化落差

## 形式化落差
### The Formalization Gap: From Problem Recognition to Formal Objects, Operators, Algorithms, and Runtime

**Series:** Open-World Epistemic Research  
**Paper:** 07  
**Version:** v0.1  
**Date:** 2026-09-20  
**Language:** zh-TW  
**Status:** Formal Draft / Canonical Markdown Source  
**Authors:** Neo.K × GPT-5.6 Sol  
**Institution:** EveMissLab / 一言諾科技有限公司

---

## 摘要

現代 AI、科學研究與軟體工程中，一個常見但容易被忽略的錯誤，是把「我已經能精確描述問題」誤認成「我已經有了解法」，或進一步誤認成「我已經知道怎麼寫成演算法」。

本文提出 **Formalization Gap**，用來描述從現象辨識、概念形成、形式化、演算法化、實作到 Runtime 化之間的非平凡轉換距離。本文將一條完整轉換鏈寫成：

$$
\boxed{
\text{Phenomenon}
\rightarrow
\text{Recognition}
\rightarrow
\text{Concept}
\rightarrow
\text{Formal Object}
\rightarrow
\text{Operator}
\rightarrow
\text{Algorithm}
\rightarrow
\text{Implementation}
\rightarrow
\text{Runtime}
}
$$

其中每一層都需要新的表示能力與約束，而不是前一層的自然延伸。

例如：

> 「Deep Research 會在錯的局部空間中越研究越深。」

這是一個高品質概念敘述。

但要變成可執行系統，至少還需要：

$$
D_t
$$

表示當前研究域，

$$
\partial D_t
$$

表示未閉合邊界，

$$
U_\tau
$$

表示不同未知型別，

$$
O_\tau
$$

表示認識算子，

再定義：

$$
\operatorname{ExpandBoundary}
$$

$$
\operatorname{ReTypeUnknown}
$$

$$
\operatorname{ChallengeKernel}
$$

等 operator，最後才能形成 algorithm 與 runtime。

因此：

$$
\boxed{
\text{Precise Description}
\neq
\text{Formalization}
}
$$

$$
\boxed{
\text{Formalization}
\neq
\text{Algorithm}
}
$$

$$
\boxed{
\text{Algorithm}
\neq
\text{Runtime}
}
$$

本文進一步分析為何 AI 時代容易產生新的形式化錯覺。大型模型可以在收到自然語言描述後快速產生 code prototype，使「概念到程式」看起來只需要幾分鐘。但真正被壓縮掉的工作，不是 coding 本身，而是：

> **What computation should exist?**

也就是：應該有哪些 state、哪些 variables、哪些 constraints、哪些 operators、哪些 invariants、哪些 transition rules，以及什麼條件算完成。

如果這些物件沒有被正確定義，AI 仍然可以快速寫出大量程式，但只是在錯誤計算空間中高效率執行。

本文因此提出：

$$
\boxed{
\text{Better Code Generation}
\times
\text{Wrong Formal Space}
=
\text{Faster Wrong System}
}
$$

並將形式化視為 AI 原生研究架構中的核心認識轉換，而不是單純數學記號化。

**關鍵詞：** Formalization Gap、Problem Formalization、Algorithmization、Runtime、Formal Object、Operator、Constraint、State Space、AI-Native Research、Epistemic Runtime

---

# 1. 問題：為什麼「說清楚」仍然不等於「做得出來」？

研究者經常有一種經驗：

> 問題已經說得非常清楚，但還是不知道怎麼做。

這並不矛盾。

因為：

$$
\text{Description}
$$

與：

$$
\text{Computation}
$$

並不是同一層。

一句：

> 系統應該主動懷疑自己的分類。

是一個概念要求。

但程式不能直接執行：

```text
doubt_your_categories()
```

除非先定義：

- 什麼是 category；
- 如何表示 category；
- 什麼叫「分類不完整」；
- 哪些 evidence 觸發懷疑；
- 懷疑後做什麼；
- 如何停止；
- 如何驗證新分類是否更好。

所以：

$$
\boxed{
\text{Semantic Precision}
\neq
\text{Operational Precision}
}
$$

。

---

# 2. 從現象到 Runtime 的八層鏈

本文採用：

$$
P_0
\rightarrow
P_1
\rightarrow
P_2
\rightarrow
P_3
\rightarrow
P_4
\rightarrow
P_5
\rightarrow
P_6
\rightarrow
P_7
$$

其中：

$$
P_0=\text{Phenomenon}
$$

$$
P_1=\text{Recognition}
$$

$$
P_2=\text{Concept}
$$

$$
P_3=\text{Formal Object}
$$

$$
P_4=\text{Operator}
$$

$$
P_5=\text{Algorithm}
$$

$$
P_6=\text{Implementation}
$$

$$
P_7=\text{Runtime}
$$

。

每一層都回答不同問題。

---

# 3. Phenomenon

現象層只需要：

> 有事情發生了。

例如：

> Deep Research 有時候搜尋很多資料後，反而對錯誤結論更有信心。

這還不是理論。

只是：

$$
O_0
=
\text{Observed Pattern}
$$

。

---

# 4. Recognition

Recognition 是：

> 這不是偶然 bug，而是一個值得研究的結構問題。

也就是：

$$
O_0
\rightarrow
P_1
$$

。

Recognition 的價值在於把：

$$
\text{noise}
$$

提升成：

$$
\text{problem candidate}
$$

。

---

# 5. Concept

Concept 層開始形成：

> 這可能叫做局部注意力收斂。

或者：

> 未知不是單一狀態。

這些概念可以高度有解釋力。

但仍是：

$$
P_2
$$

而不是：

$$
P_3
$$

。

---

# 6. Formal Object

Formalization 的第一步，是把自然語言概念轉成可區分物件。

例如：

> 未知有很多種。

形式化為：

$$
U
=
\{
U_{\text{data}},
U_{\text{category}},
U_{\text{structure}},
U_{\text{conflict}},
\ldots
\}
$$

。

這一步很重要。

因為只有變成：

$$
U_\tau
$$

之後，系統才能：

- 比較；
- 儲存；
- 轉型；
- 排程；
- 綁定 operator。

---

# 7. 形式化不是加數學符號

一個常見誤解是：

> 把自然語言寫成公式，就叫形式化。

不是。

形式化真正要求：

$$
\boxed{
\text{Ambiguous Semantic Object}
\rightarrow
\text{Explicit Computational Object}
}
$$

。

例如：

> 「世界邊界」

如果只是寫：

$$
B
$$

但不知道：

- $B$ 包含什麼；
- 如何建立；
- 如何更新；
- 如何測量；
- 如何與 query planner 互動；

那只是：

$$
\text{symbolic relabeling}
$$

而不是完整形式化。

---

# 8. Formal Object 的最低條件

本文提出一個 formal object：

$$
X
$$

至少應具有：

$$
X
=
(
\text{identity},
\text{type},
\text{state},
\text{relations},
\text{update rules}
)
$$

。

若沒有 update rules，它可能只是資料結構。

若沒有 relations，它可能只是 isolated variable。

---

# 9. State Space

任何可執行研究系統都需要：

$$
S
$$

state space。

例如：

$$
S_t
=
(
\mathbf K_t,
\mathbf U_t,
\mathcal C_t,
E_t,
B_t
)
$$

。

如果系統沒有顯式 state，就只能依賴模型當前 context 的臨時表示。

---

# 10. State 與自然語言 context 不同

Context：

$$
C_t
$$

通常只是目前送進模型的 token。

State：

$$
S_t
$$

則是：

> 系統認為世界現在處於什麼狀態。

因此：

$$
\boxed{
\text{Context}
\neq
\text{State}
}
$$

。

---

# 11. Variable

形式化還需要把變動因素顯式化。

例如：

$$
u_{\text{category}}
$$

表示分類未知程度。

$$
b_{\text{frontier}}
$$

表示未閉合邊界壓力。

$$
q_{\text{source}}
$$

表示來源品質。

沒有 variable，系統很難 measure 或 route。

---

# 12. Constraint

只有 variable 不夠。

還需要：

$$
C
=
\{c_1,c_2,\ldots,c_n\}
$$

。

例如：

$$
u_{\text{counter}}>0.8
\Rightarrow
\operatorname{Closure}=0
$$

。

或者：

$$
\operatorname{SourceRoots}<2
\Rightarrow
\operatorname{EvidenceIndependence}=\text{low}
$$

。

Constraint 讓系統不只生成可能，而能排除不允許狀態。

---

# 13. Constraint 的價值

假設候選空間：

$$
\Omega
=
\{x_1,x_2,\ldots,x_n\}
$$

加入約束：

$$
C
$$

之後：

$$
\Omega'
=
\{x\in\Omega:x\models C\}
$$

。

如果：

$$
|\Omega'|\ll|\Omega|
$$

則：

$$
\boxed{
\text{Constraint}
=
\text{Search-Space Reduction}
}
$$

。

---

# 14. Operator

有 state、variable、constraint 之後，才有 operator。

Operator：

$$
O:
S_t
\rightarrow
S_{t+1}
$$

。

例如：

$$
\operatorname{Retrieve}
$$

$$
\operatorname{Reclassify}
$$

$$
\operatorname{ExpandBoundary}
$$

$$
\operatorname{ChallengeKernel}
$$

$$
\operatorname{ReopenClosure}
$$

。

---

# 15. Operator 不等於 Tool

Tool：

> Browser。

Operator：

> 搜尋反證。

同一 operator 可使用不同 tool。

$$
O_{\text{counter}}
\rightarrow
\{
\text{Web},
\text{Paper DB},
\text{Experiment},
\text{Simulation}
\}
$$

。

同一 tool 也可支援不同 operator。

因此：

$$
\boxed{
\text{Operator}
\neq
\text{Tool}
}
$$

。

---

# 16. Operator 不等於 Method

Method 可以是一個高階程序：

$$
M
=
O_1
\triangleright
O_2
\triangleright
O_3
$$

。

因此至少在本文架構中：

$$
\text{Operator}
\subset
\text{Method}
$$

。

---

# 17. Transition Rule

如果 operator 改變 state，就需要：

$$
T:
(S_t,O_t,E_t)
\rightarrow
S_{t+1}
$$

。

這是 transition rule。

沒有 transition rule，operator 只是一個 action。

---

# 18. Invariant

研究 Runtime 還需要 invariant。

例如：

$$
\boxed{
\text{Retrieved}
\neq
\text{Verified}
}
$$

是一個 invariant。

又如：

$$
\boxed{
\text{Closure}
\Rightarrow
\text{Reopen Conditions Exist}
}
$$

。

Invariant 保證系統不因局部更新破壞核心認識規則。

---

# 19. Formalization Package

因此完整形式化至少可以表示為：

$$
F
=
(
S,
V,
C,
O,
T,
I
)
$$

其中：

- $S$：states；
- $V$：variables；
- $C$：constraints；
- $O$：operators；
- $T$：transition rules；
- $I$：invariants。

這比一條公式完整得多。

---

# 20. Formalization Gap

定義：

$$
G_F
=
\operatorname{dist}
(
P_2,
F
)
$$

其中：

- $P_2$：conceptual understanding；
- $F$：可執行形式系統。

如果：

$$
G_F\gg0
$$

表示：

> 想法很清楚，但離可計算仍很遠。

---

# 21. Formalization-Speed Projection

對某些研究者：

$$
C_{P_2\rightarrow F}
$$

很低。

也就是：

> 從概念到形式物件的轉換很快。

這容易產生：

$$
\boxed{
\text{Formalization-Speed Projection}
}
$$

：

> 既然我很快能寫出來，別人應該早就寫過。

但：

$$
C_{P_2\rightarrow F}^{A}
\neq
C_{P_2\rightarrow F}^{B}
$$

。

---

# 22. 概念簡單不代表形式化簡單

例如：

> AI 應該知道自己不知道什麼。

概念非常簡單。

但真正形式化：

$$
U_\tau
$$

還需要：

- unknown types；
- classification policy；
- transition rules；
- operator mapping；
- closure relation；
- persistence；
- validation。

因此：

$$
\boxed{
\text{Conceptual Simplicity}
\neq
\text{Formal Simplicity}
}
$$

。

---

# 23. 形式化優雅不代表演算法容易

即使：

$$
U_\tau
$$

定義很乾淨，要可靠判斷：

$$
\tau
$$

仍可能很難。

所以：

$$
\boxed{
\text{Formal Elegance}
\neq
\text{Algorithmic Ease}
}
$$

。

---

# 24. Algorithmization

Algorithmization 需要：

$$
A
=
(
\text{input},
\text{state},
\text{procedure},
\text{termination},
\text{output}
)
$$

。

形式物件只說：

> 世界應該怎麼被表示。

Algorithm 則說：

> 系統下一步應該怎麼做。

---

# 25. Algorithm 的最小結構

可寫：

$$
A:
(S_t,X_t)
\rightarrow
(O_t,S_{t+1})
$$

。

其中：

- $S_t$：current state；
- $X_t$：new input；
- $O_t$：selected operation；
- $S_{t+1}$：updated state。

---

# 26. Algorithm 需要終止條件

若：

$$
A
$$

沒有 stop condition，

研究會：

$$
\text{expand forever}
$$

。

因此：

$$
\operatorname{Stop}(S_t)
$$

是 algorithm 的一部分。

---

# 27. Stop Condition 不等於 Closure

$$
\operatorname{Stop}=1
$$

可能只是：

- budget exhausted；
- deadline；
- user asked；
- marginal gain low。

Closure：

$$
C_E=1
$$

則是認識條件。

因此：

$$
\boxed{
\text{Stop}
\neq
\text{Closure}
}
$$

。

---

# 28. Algorithm 需要 failure handling

例如：

$$
O_t=\operatorname{Retrieve}
$$

失敗後：

$$
F_t
$$

應進：

$$
S_{t+1}
$$

而不是被忽略。

因此：

$$
\boxed{
\text{Failure}
\subset
\text{State Update}
}
$$

。

---

# 29. Algorithm 需要 uncertainty handling

如果：

$$
P(\tau_i)\approx P(\tau_j)
$$

未知型別不確定，

算法不應強行：

$$
\arg\max
$$

後刪掉其他候選。

可保留：

$$
\{\tau_i,\tau_j\}
$$

。

---

# 30. Algorithm 需要 branch management

開放世界研究很容易出現：

$$
b^d
$$

組合爆炸。

因此要：

$$
\operatorname{Prune}
$$

$$
\operatorname{Budget}
$$

$$
\operatorname{Prioritize}
$$

。

這些都屬於 algorithmization。

---

# 31. Implementation

Algorithm：

$$
A
$$

進入程式後：

$$
I
$$

還需要：

- data structure；
- API；
- database；
- scheduler；
- persistence；
- concurrency；
- errors；
- logging；
- authentication；
- tests。

因此：

$$
\boxed{
A
\neq
I
}
$$

。

---

# 32. Implementation Gap

定義：

$$
G_I
=
\operatorname{dist}(A,I)
$$

。

一個 algorithm 可以理論上很好，但：

$$
G_I
$$

仍極大。

---

# 33. Runtime

Runtime 比 implementation 再多一層。

Runtime 是：

$$
\boxed{
\text{Implementation}
+
\text{Persistent State}
+
\text{Environment}
+
\text{Policies}
+
\text{Execution Control}
}
$$

。

所以：

$$
R
\neq
I
$$

。

---

# 34. Why Runtime Matters

同一 implementation：

$$
I
$$

在不同：

$$
E_1,E_2
$$

environment 下，可能行為不同。

因此：

$$
\operatorname{Behavior}
=
f(I,E,P,S)
$$

其中：

- $E$：environment；
- $P$：policy；
- $S$：state。

---

# 35. Runtime 是認識行為真正發生的地方

理論與算法只是 potential。

真正：

$$
\text{observe}
\rightarrow
\text{update}
\rightarrow
\text{act}
$$

發生在 runtime。

所以 Epistemic Runtime 指的是：

> 認識狀態持續存在並驅動行動的執行層。

---

# 36. Runtime State

可定義：

$$
R_t
=
(
W_t,
K_t,
U_t,
C_t,
E_t,
H_t,
P_t
)
$$

其中：

- $W_t$：world representation；
- $K_t$：known state；
- $U_t$：unknown state；
- $C_t$：compression kernels；
- $E_t$：evidence；
- $H_t$：history；
- $P_t$：policy。

---

# 37. Prompt 不是 Runtime

一個 prompt：

> 請主動找反證。

只是 instruction。

如果系統沒有：

- counterevidence state；
- action tracking；
- completion requirement；
- verifier；

那它不保證：

$$
\operatorname{CounterSearch}
$$

每次真的執行。

因此：

$$
\boxed{
\text{Prompt}
\neq
\text{Runtime Constraint}
}
$$

。

---

# 38. Prompt Engineering 與 Algorithm Engineering

Prompt：

$$
P
$$

通常是軟約束。

Algorithm：

$$
A
$$

可建立硬流程。

Runtime：

$$
R
$$

則可持續 enforce。

因此：

$$
P
\rightarrow
A
\rightarrow
R
$$

是一條逐步外顯化約束的路徑。

---

# 39. AI 時代的 Coding Illusion

現代模型可以：

$$
\text{Natural Language}
\rightarrow
\text{Code}
$$

非常快。

這會產生：

$$
\boxed{
\text{Coding Illusion}
}
$$

：

> 好像只要能說清楚，就已經快做完。

但真正被 AI 代勞的是 syntax generation 與部分 implementation detail。

最難的往往仍是：

$$
\boxed{
\text{What computation should exist?}
}
$$

。

---

# 40. What Computation Should Exist?

這個問題包括：

- 什麼 state 必須存在？
- 哪些 variable 必須被追蹤？
- 哪些 unknown 必須分型？
- 哪些 constraint 是硬條件？
- 哪些 operator 必須存在？
- 哪些 invariant 不能被破壞？
- 哪些 transition 是合法的？
- 何時停止？
- 何時重新打開？

這些不是 code generator 自動保證的。

---

# 41. AI 會放大好的 Formalization，也會放大壞的 Formalization

若：

$$
F_{\text{good}}
$$

則：

$$
\text{AI Coding}
\rightarrow
\text{Fast Prototype}
$$

非常有價值。

但若：

$$
F_{\text{bad}}
$$

則：

$$
\boxed{
\text{AI Coding}
\rightarrow
\text{Fast Wrong Prototype}
}
$$

。

所以 AI 時代反而提高 formalization 的槓桿。

---

# 42. Better Intelligence × Wrong State Representation

若模型更強：

$$
I_{\text{model}}\uparrow
$$

但 state representation 錯：

$$
S\neq S^\ast
$$

則：

$$
\boxed{
I_{\text{model}}\uparrow
\Rightarrow
\text{Better Optimization of the Wrong Space}
}
$$

可能成立。

---

# 43. Formalization 決定什麼可以被穩定最佳化

如果：

$$
U_{\text{category}}
$$

根本不存在 state 中，

系統就很難穩定最佳化：

$$
\Delta U_{\text{category}}
$$

。

因此：

$$
\boxed{
\text{What Is Not Represented Cannot Be Reliably Optimized}
}
$$

。

---

# 44. 表示先於最佳化

可以寫成：

$$
\boxed{
\text{Representation}
\prec
\text{Optimization}
}
$$

。

不是時間上必然先後，而是邏輯依賴：

> 先有可計算對象，才有穩定最佳化對象。

---

# 45. 形式化是壓縮核的外顯化

Paper 05 的壓縮核：

$$
C
$$

如果只存在於直覺，

它是：

$$
C_{\text{tacit}}
$$

。

Formalization：

$$
C_{\text{tacit}}
\rightarrow
C_{\text{explicit}}
$$

。

因此：

$$
\boxed{
\text{Formalization}
=
\text{Externalization of Generative Structure}
}
$$

至少在部分情況下成立。

---

# 46. Formalization Loss

$$
C_{\text{tacit}}
\rightarrow
C_{\text{explicit}}
$$

也可能丟失：

$$
L_F
$$

。

例如：

- 模糊邊界；
- 類比；
- implicit assumptions；

可能難完整轉成 formal object。

因此形式化不是永遠無損。

---

# 47. Formalization Overreach

另一種錯誤是：

> 因為寫成公式，所以以為問題已經被理解。

可寫：

$$
\boxed{
\text{Symbolic Precision}
\not\Rightarrow
\text{Ontological Accuracy}
}
$$

。

形式化可以非常精確地描述錯誤模型。

---

# 48. Wrong Ontology, Perfect Mathematics

如果 ontology：

$$
O
$$

錯，

即使數學：

$$
M(O)
$$

完全正確，

仍可能：

$$
M(O)
\neq
W
$$

。

因此：

$$
\boxed{
\text{Formal Correctness}
\neq
\text{World Correctness}
}
$$

。

---

# 49. World Root 與 Formalization

World Root 的作用之一，是保留：

$$
W
\neq
F(W)
$$

。

Formalization：

$$
F(W)
$$

只是對世界的一種可操作表示，不是世界本身。

---

# 50. Formalization 與 World Model 的差異

一個 world model：

$$
M_W
$$

可以很強。

但 Formalization Runtime 問：

> 目前有哪些可操作認識物件？

例如：

$$
U_\tau
$$

$$
C_i
$$

$$
B_t
$$

$$
E_i
$$

。

所以：

$$
\text{World Model}
$$

與：

$$
\text{Epistemic Formalization}
$$

不是同一件事。

---

# 51. 形式化層級

可以有：

### L0 — Linguistic

自然語言概念。

### L1 — Typed Concepts

明確類型。

### L2 — Variables and Relations

變量與關係。

### L3 — Constraints

限制與不變量。

### L4 — Operators

可操作轉換。

### L5 — Algorithms

程序。

### L6 — Runtime Semantics

長期執行語義。

因此：

$$
F_0
\rightarrow
F_1
\rightarrow
\cdots
\rightarrow
F_6
$$

。

---

# 52. 不是所有問題都需要做到 L6

若任務只是理論分析，可能：

$$
F_3
$$

已足夠。

若要做自主研究 Agent，則至少需要：

$$
F_5/F_6
$$

。

因此 formalization depth 應 task-relative。

---

# 53. Formalization Depth

定義：

$$
D_F
$$

表示形式化深度。

可以是：

$$
D_F\in\{0,\ldots,6\}
$$

。

產品評估時，不應只問：

> 有沒有形式化？

而應問：

> 到哪一層？

---

# 54. Precision 不等於 Depth

一篇論文可以在：

$$
F_2
$$

非常精準，

但沒有：

$$
F_4
$$

operator。

另一篇可能符號較少，

但已給完整：

$$
F_5
$$

algorithm。

因此：

$$
\boxed{
\text{Notation Density}
\neq
\text{Formalization Depth}
}
$$

。

---

# 55. Formalization Coverage

同一問題有多個子域：

$$
D_1,\ldots,D_n
$$

。

可能只有：

$$
D_1,D_2
$$

被形式化。

所以還需要：

$$
C_F
=
\frac{
\text{formalized critical domains}
}{
\text{required domains}
}
$$

。

---

# 56. 深度與覆蓋率要分開

$$
D_F
\neq
C_F
$$

。

可能：

$$
D_F\gg0
$$

但：

$$
C_F\ll1
$$

。

這與 Paper 02 的：

$$
\text{Local Depth}
\neq
\text{Global Coverage}
$$

同構。

---

# 57. Formalization Gap Matrix

可建立：

$$
M_F
=
\begin{bmatrix}
d_{11} & \cdots & d_{1m}\\
\vdots & \ddots & \vdots\\
d_{n1} & \cdots & d_{nm}
\end{bmatrix}
$$

其中：

- row：problem domains；
- column：formalization layers。

這比單一「成熟度」更能描述系統。

---

# 58. 形式化與驗證

形式化後要驗證：

$$
V_F
$$

。

例如 Unknown Type classifier 需測：

$$
\operatorname{Accuracy}(\tau)
$$

。

Closure rule 需測：

$$
\operatorname{FalseClosureRate}
$$

。

因此：

$$
\boxed{
\text{Formalized}
\neq
\text{Validated}
}
$$

。

---

# 59. Formalization 與反例

好的 formalization 應讓反例更容易指定。

例如：

$$
u_{\text{counter}}>0.8
\Rightarrow
\operatorname{Closure}=0
$$

就可以測是否存在反例。

形式化使反證更可操作。

---

# 60. Formalization as Falsifiability Amplifier

可以說：

$$
\boxed{
\text{Formalization}
\rightarrow
\text{Sharper Falsification Surface}
}
$$

。

模糊概念很難被精確推翻。

---

# 61. Formalization 與 Modularity

如果：

$$
F
=
(S,V,C,O,T,I)
$$

各自模組化，

可以替換：

$$
O_i
$$

而不重寫全部。

這是 architecture stability。

---

# 62. Formal Objects as First-Class Objects

真正 AI-native Runtime 應讓：

$$
U_\tau
$$

$$
C_i
$$

$$
E_i
$$

$$
B_i
$$

成為 first-class objects。

意味：

- 可讀；
- 可寫；
- 可傳遞；
- 可版本化；
- 可查詢；
- 可驗證。

---

# 63. Natural Language 仍然重要

本文不主張全部都要形式語言。

自然語言仍擅長：

- 提出新概念；
- 描述邊界；
- 表達例外；
- 跨領域類比；
- 高層壓縮。

因此：

$$
\boxed{
\text{Natural Language}
+
\text{Formal Objects}
}
$$

比單一形式更適合研究。

---

# 64. 雙表示層

可建立：

$$
L_N
$$

自然語言層，

與：

$$
L_F
$$

形式化層。

兩者：

$$
L_N
\leftrightarrow
L_F
$$

持續互譯。

---

# 65. 語言層負責生成，形式層負責約束

概念上：

$$
L_N
\rightarrow
\text{candidate expansion}
$$

$$
L_F
\rightarrow
\text{constraint and verification}
$$

。

兩者不是敵對，而是互補。

---

# 66. AI 的特殊優勢

大型模型很適合：

$$
L_N\rightarrow L_F
$$

candidate generation。

例如：

> 幫我把「未知不是一種」轉成 state schema。

AI 可以很快產生候選 formalization。

---

# 67. AI 的特殊風險

AI 也很容易：

$$
\text{plausible language}
\rightarrow
\text{plausible formalization}
$$

但：

$$
\text{plausible}
\neq
\text{correct}
$$

。

所以：

$$
L_N\rightarrow L_F
$$

必須有 validation。

---

# 68. Formalization Compiler

可以把：

$$
\boxed{
\operatorname{FormalizationCompiler}
:
L_N
\rightarrow
F
}
$$

視為未來 Research Runtime 的核心模組。

它不是自動把句子變公式，而是：

1. identify entities；
2. identify states；
3. identify variables；
4. identify constraints；
5. identify operators；
6. identify invariants；
7. identify transition rules；
8. identify unresolved ambiguity。

---

# 69. Ambiguity Ledger

任何 formalization compiler 都應保存：

$$
A_F
$$

未解歧義。

例如：

```yaml
ambiguity:
  phrase: "global coverage"
  candidates:
    - source coverage
    - category coverage
    - world-surface coverage
  unresolved: true
```

。

這比假裝已經形式化更安全。

---

# 70. Partial Formalization

形式化不必一次完成。

可以：

$$
F_t
\rightarrow
F_{t+1}
$$

逐步改善。

所以：

$$
\boxed{
\text{Formalization}
=
\text{Iterative Epistemic Compilation}
}
$$

。

---

# 71. Epistemic Compilation

本文將：

$$
\text{Concept}
\rightarrow
\text{Formal Object}
\rightarrow
\text{Operator}
\rightarrow
\text{Algorithm}
$$

整體稱為：

$$
\boxed{
\text{Epistemic Compilation}
}
$$

。

因為它把可理解思想轉成可執行認識程序。

---

# 72. Compilation Error

若：

$$
C
$$

被錯誤編譯成：

$$
F'
$$

則：

$$
F'\neq C
$$

。

這就是：

$$
\text{Epistemic Compilation Error}
$$

。

例如原理：

> 保留未知類別。

被編譯成：

> 增加 confidence threshold。

這可能根本不是同一件事。

---

# 73. Semantic Preservation

因此要求：

$$
\operatorname{Sem}(C)
\approx
\operatorname{Sem}(F)
$$

。

可定義：

$$
F_S
=
\operatorname{SemanticFidelity}(C,F)
$$

。

---

# 74. Operator Preservation

再要求：

$$
\operatorname{Behavior}(F)
$$

符合：

$$
\operatorname{Intent}(C)
$$

。

即：

$$
F_O
=
\operatorname{OperationalFidelity}
$$

。

---

# 75. Algorithmic Preservation

形式化：

$$
F
$$

轉算法：

$$
A
$$

再檢查：

$$
\operatorname{Sem}(F)
\approx
\operatorname{Behavior}(A)
$$

。

這是一個 compiler correctness 問題。

---

# 76. Runtime Preservation

算法：

$$
A
$$

進 runtime：

$$
R
$$

還要檢查：

$$
\operatorname{Behavior}(R)
\approx
\operatorname{Spec}(A)
$$

。

因為環境與 policy 可能改變結果。

---

# 77. End-to-End Fidelity

完整可以概念化為：

$$
F_{\text{end}}
=
F_S
\cdot
F_O
\cdot
F_A
\cdot
F_R
$$

。

任一層很低，最終產品就可能偏離原始理解。

---

# 78. 這接回 Institutional Epistemic Compression

Paper 06 的 translation loss：

$$
L_i
$$

在 Paper 07 中可以具體理解為：

$$
\text{Compilation Loss}
$$

。

因此：

$$
\boxed{
\text{Institutional Translation}
\approx
\text{Multi-Layer Epistemic Compilation}
}
$$

。

---

# 79. 個人「我懂了」為什麼能很快到 Algorithm Sketch？

Paper 05 的：

$$
C^\ast
$$

壓縮核一旦形成，

如果研究者已有：

- operator vocabulary；
- constraint habits；
- graph thinking；
- runtime concepts；

則：

$$
C^\ast
\rightarrow
F
$$

成本很低。

因此：

$$
\text{Aha}
\rightarrow
\text{Algorithm Sketch}
$$

可以非常快。

---

# 80. 但這不代表別人同樣快

別人可能缺：

$$
\mathcal O_{\text{formal}}
$$

即形式化 operator library。

所以：

$$
C^\ast
$$

雖然理解，仍不會立即變成：

$$
F
$$

。

---

# 81. Formalization Operator Library

可建立：

$$
\mathcal L_F
$$

包含：

- classify；
- type；
- parameterize；
- constrain；
- factor；
- decompose；
- graph；
- bind；
- verify；
- close；
- reopen。

這些是：

$$
\boxed{
\text{Meta-Formalization Operators}
}
$$

。

---

# 82. 形式化能力可以被工具化

如果：

$$
\mathcal L_F
$$

被保存，

同一 AI 在未改 weights 情況下也能更快形式化。

因此 Formalization Skill 可以是 non-parametric capability。

---

# 83. Research Skill 與 Formalization Skill

Research Option：

$$
\Omega_R
$$

告訴：

> 怎麼研究。

Formalization Option：

$$
\Omega_F
$$

告訴：

> 怎麼把研究想法變成可操作形式。

兩者可組合。

---

# 84. Formalization Trajectory Compression

昂貴過程：

$$
C
\rightarrow
F_1
\rightarrow
F_2
\rightarrow
F_3
$$

可以抽成：

$$
\Omega_F
$$

。

因此：

$$
\boxed{
\text{Formalization Experience}
\rightarrow
\text{Reusable Formalization Skill}
}
$$

。

---

# 85. Formalization Debt

如果系統大量靠：

- prompt；
- convention；
- hidden assumptions；

運作，但沒有顯式 formal object，

就會累積：

$$
D_F
$$

Formalization Debt。

未來修改成本：

$$
C_{\text{change}}\uparrow
$$

。

---

# 86. Hidden Assumption Debt

若：

$$
A_{\text{hidden}}
$$

不外顯，

容易導致：

$$
\text{environment change}
\rightarrow
\text{silent failure}
$$

。

因此 assumptions 也應 first-class。

---

# 87. Constraint Debt

如果約束只存在於開發者腦中：

$$
C_{\text{implicit}}
$$

就無法被 Agent 自己檢查。

這是：

$$
\text{Constraint Debt}
$$

。

---

# 88. Runtime Without Formalization

很多現代 Agent 可以：

$$
\text{LLM}
+
\text{tools}
+
\text{prompt}
$$

直接跑。

這很有用。

但如果缺：

$$
F
$$

則：

- state 不穩定；
- failure 不可分類；
- invariants 不明；
- closure 不可檢查。

因此：

$$
\boxed{
\text{Working Agent}
\neq
\text{Formalized Agent}
}
$$

。

---

# 89. Formalization Without Runtime

反過來，一套理論也可能非常完整：

$$
F\gg0
$$

但：

$$
R=0
$$

。

這仍然有學術價值，但不能說已是一個可運作系統。

---

# 90. Research Runtime 的正式角色

在 OWER 中：

$$
R_E
$$

應把：

$$
F
$$

持續實例化。

即：

$$
R_E:
F\times W_t
\rightarrow
S_{t+1}
$$

。

---

# 91. World-Rooted Formalization

如果最新 Omphalos 以：

$$
W
$$

為 root，

則 formalization 不是：

$$
\text{Task}
\rightarrow
F
$$

而是：

$$
\boxed{
W
\rightarrow
\hat W_t
\rightarrow
F_t
\rightarrow
O_t
}
$$

。

這避免 formal objects 脫離世界。

---

# 92. Formalization 只是世界認識的一個投影

$$
F_t
=
\Pi_F(\hat W_t)
$$

。

所以：

$$
F_t
\neq
W
$$

。

這與後續 World Model 番外相容。

---

# 93. Formalization Reopen

若新證據：

$$
E_{new}
$$

使原形式化不夠，

應：

$$
F_t
\rightarrow
F_{t+1}
$$

。

因此 formalization 本身也必須可 reopen。

---

# 94. Static Formalization 問題

如果：

$$
F
$$

被視為永遠正確，

runtime 只會在舊 ontology 中運行。

所以：

$$
\boxed{
\text{Open-World Runtime}
\Rightarrow
\text{Revisable Formalization}
}
$$

。

---

# 95. Meta-Formalization

系統甚至要能問：

> 我的 state schema 本身是不是錯了？

這就是：

$$
\boxed{
\text{Meta-Formalization}
}
$$

。

---

# 96. Schema Rewriting

例如原本：

$$
S_t
=
(K,U,E)
$$

後來發現還需要：

$$
C
$$

compression kernels。

則：

$$
S_t
\rightarrow
S_t'
=
(K,U,E,C)
$$

。

這就是 runtime schema evolution。

---

# 97. Schema Evolution 是 Open-World 的必要條件

封閉系統可以固定 schema。

開放世界：

$$
W_t
$$

可能出現新類別。

所以：

$$
\boxed{
\text{Open World}
\Rightarrow
\text{Potentially Open Schema}
}
$$

。

---

# 98. Schema Explosion 風險

如果遇到每個新東西都加新 field：

$$
|S|\rightarrow\infty
$$

。

因此需要：

$$
\operatorname{Generalize}
$$

$$
\operatorname{Merge}
$$

$$
\operatorname{Refactor}
$$

。

---

# 99. Formalization Refactoring

與程式一樣，

formalization 也需要：

$$
F_t
\rightarrow
F_{t+1}
$$

重構。

目標：

- fewer redundant types；
- clearer invariants；
- better operator reuse；
- lower coupling。

---

# 100. Formalization Minimality

理想希望：

$$
|F|
$$

不要過大。

但 minimal 不能犧牲 coverage。

所以：

$$
\boxed{
\text{Minimal Formalization}
\neq
\text{Under-Specified Formalization}
}
$$

。

---

# 101. 最小充分形式集

可定義：

$$
F^\ast
=
\arg\min_F |F|
$$

subject to：

$$
\operatorname{Coverage}(F)\geq\theta
$$

$$
\operatorname{Operationality}(F)\geq\theta_O
$$

$$
\operatorname{Validation}(F)\geq\theta_V
$$

。

這是一種：

$$
\boxed{
\text{Minimal Sufficient Formalization}
}
$$

問題。

---

# 102. 與 Constraint-Based Thinking 的關係

當問題被形式化成：

$$
\Omega
$$

加：

$$
C
$$

後，

很多 reasoning 可變成：

$$
\Omega
\rightarrow
\Omega'
$$

。

這也是為什麼精細分類、約束與變量消除能大幅降低搜尋空間。

---

# 103. 變量消除

如果：

$$
x_3=f(x_1,x_2)
$$

則：

$$
x_3
$$

可不再獨立搜尋。

同理研究中：

$$
H_3
=
g(H_1,H_2)
$$

可能降低 hypothesis degrees of freedom。

---

# 104. Formalization as Degree-of-Freedom Reduction

可將形式化部分理解成：

$$
\boxed{
\text{Reduce Unnecessary Degrees of Freedom}
}
$$

。

這不是過度限制，而是把已知依賴編譯進 system。

---

# 105. Constraint Propagation

若：

$$
c_1,c_2,c_3
$$

互相關聯，

則新證據：

$$
E
$$

可：

$$
E
\rightarrow
\Delta c_1
\rightarrow
\Delta c_2
\rightarrow
\Delta c_3
$$

。

這就是 constraint propagation。

---

# 106. Research Agent 中的 Constraint Propagation

例如：

$$
\text{source date}=2025
$$

而任務要求：

$$
t=2026
$$

則：

$$
\text{current claim support}
$$

應下降。

這可以自動傳導，而不是等模型每次重新想到。

---

# 107. Formalization 將「想到」變成「必須處理」

這是核心差異。

Prompt：

> 記得注意時間。

Formalization：

$$
\operatorname{TemporalMismatch}>0
\Rightarrow
\operatorname{FreshnessCheck}=1
$$

。

前者是：

$$
\text{may remember}
$$

後者是：

$$
\text{must process}
$$

。

---

# 108. 從人格要求到算法要求

很多 Agent prompt 說：

- be critical；
- be skeptical；
- consider alternatives；
- verify sources。

這些像人格要求。

Formalization 把它變成：

$$
\text{counterevidence queue}
$$

$$
\text{alternative hypothesis set}
$$

$$
\text{source-root graph}
$$

。

這是：

$$
\boxed{
\text{Behavioral Instruction}
\rightarrow
\text{Computational Obligation}
}
$$

。

---

# 109. 這是 AI 原生研究的重要轉折

當「批判思考」仍是 prompt，

它只是：

$$
\text{soft behavior}
$$

。

當它變成：

$$
O_{\text{challenge}}
$$

與：

$$
I_{\text{counter}}
$$

它才變成：

$$
\text{runtime property}
$$

。

---

# 110. Formalization 與自由度

過強 formalization 也可能限制創造性。

所以需要：

$$
\epsilon_{\text{free}}
$$

free exploration。

即：

$$
\text{formal constraints}
+
\text{open exploratory channel}
$$

。

---

# 111. Formalization 不應關閉未知世界

如果：

$$
F
$$

限制：

$$
W
$$

只能符合既有 type，

那麼：

$$
U_{\text{world}}
$$

永遠無法被發現。

所以：

$$
\boxed{
\text{Formalization Must Preserve Open-Set Capacity}
}
$$

。

---

# 112. Open-Type Slot

可以在 schema 中保留：

$$
U_{\text{novel}}
$$

或：

$$
\text{untyped object}
$$

。

這讓系統可以：

$$
\text{new observation}
\rightarrow
\text{new type candidate}
$$

。

---

# 113. Formalization 與 Meta-Unknown

Paper 03 的：

$$
U_{\text{meta}}
$$

要求 formalization 本身承認：

> schema 可能不完整。

因此：

$$
F
$$

應有：

$$
\operatorname{SchemaUnknown}
$$

。

---

# 114. 自我修改形式化

更高階系統可：

$$
F_t
\xrightarrow{\operatorname{MetaOp}}
F_{t+1}
$$

。

即不只更新資料，也更新認識語言本身。

---

# 115. 但 MetaOp 需要治理

如果 Agent 可任意改：

$$
F
$$

可能破壞 invariant。

因此：

$$
\operatorname{MetaOp}
$$

需要：

- validation；
- versioning；
- rollback；
- audit。

---

# 116. Formalization Governance

可定義：

$$
G_F
=
(
\text{proposal},
\text{test},
\text{review},
\text{promote},
\text{rollback}
)
$$

。

這使 schema evolution 可控。

---

# 117. 可證偽預測

## 預測一

僅使用自然語言「請更批判」的 Agent，其反證行為穩定性應低於具有 explicit counterevidence state 的 Agent。

## 預測二

加入 typed unknown + operator mapping 後，對異質未知任務的 operator selection accuracy 應提高。

## 預測三

具有 explicit state / transition / invariant 的 Agent，在長時研究中應比 prompt-only Agent 有更低 state drift。

## 預測四

若 state representation 缺少 category unknown，增加模型推理能力不保證提高 hidden-category recall。

## 預測五

形式化層深度與 notation density 不應高度等價；符號較少的系統也可能具有更高 executable formalization depth。

## 預測六

保留 open-type slot 的系統，在 novel ontology task 中應較少出現強制錯分類。

## 預測七

加入 formalization lineage 與 rollback 的 runtime，應比不可追溯 schema update 更容易從錯誤 ontology 修復。

---

# 118. Benchmark 草案

建立任務：

### Type A — Concept Only

只要求發現正確概念。

### Type B — Formal Object

要求定義 state / variable / type。

### Type C — Constraint

要求建立不變量。

### Type D — Operator

要求把原理變成可執行操作。

### Type E — Algorithm

要求完整 transition 與 stop condition。

### Type F — Runtime

要求持久 state、reopen、logging、version。

比較：

1. language-only reasoning；
2. code-generation baseline；
3. formalization-aware agent；
4. runtime-aware agent。

評估：

$$
\text{Semantic Fidelity}
$$

$$
\text{Operational Fidelity}
$$

$$
\text{Invariant Preservation}
$$

$$
\text{State Drift}
$$

$$
\text{False Closure Rate}
$$

$$
\text{Schema Adaptation}
$$

。

---

# 119. 主要命題

## 命題一

$$
\boxed{
\text{Precise Description}
\neq
\text{Formalization}
}
$$

。

## 命題二

$$
\boxed{
\text{Formalization}
\neq
\text{Algorithmization}
}
$$

。

## 命題三

$$
\boxed{
\text{Algorithm}
\neq
\text{Runtime}
}
$$

。

## 命題四

Formalization 至少需要：

$$
F
=
(S,V,C,O,T,I)
$$

的部分結構，而不只是符號替換。

## 命題五

若重要認識狀態沒有被表示，系統無法穩定最佳化它。

$$
\text{Not Represented}
\Rightarrow
\text{Not Reliably Optimized}
$$

。

## 命題六

AI code generation 降低 implementation cost，但不自動降低 conceptual-formalization cost。

$$
C_{\text{code}}\downarrow
\not\Rightarrow
C_{\text{formalization}}\downarrow
$$

必然成立。

## 命題七

開放世界 Runtime 需要可修改 schema。

$$
\text{Open World}
\Rightarrow
\text{Revisable Formalization}
$$

。

---

# 120. 工程最小實作

最小 Formalization Runtime：

```text
1. Detect a conceptual claim.
2. Extract candidate entities and states.
3. Define variables and types.
4. Extract hard and soft constraints.
5. Define operators.
6. Define transition rules.
7. Define invariants.
8. Define stop and reopen conditions.
9. Preserve ambiguity.
10. Validate the formalization against examples and counterexamples.
```

---

# 121. 最小資料結構

```yaml
formalization:
  id:
  version:
  concept_source:

  states: []
  variables: []
  types: []

  constraints:
    hard: []
    soft: []

  operators: []

  transitions: []

  invariants: []

  ambiguity: []

  termination:
    stop_conditions: []
    closure_conditions: []
    reopen_conditions: []

  validation:
    examples: []
    counterexamples: []
    holdout_cases: []

  provenance:
    source_claims: []
    parent_version:
```

---

# 122. 一個最小案例

自然語言：

> Deep Research 不應把所有未知都當成缺資料。

Concept：

$$
\text{Unknown Is Not One Thing}
$$

Formal Object：

$$
U=
\{
U_{\text{data}},
U_{\text{category}},
U_{\text{conflict}},
\ldots
\}
$$

Operator Map：

$$
U_{\text{data}}
\rightarrow
\operatorname{Retrieve}
$$

$$
U_{\text{category}}
\rightarrow
\operatorname{OntologyExpand}
$$

Algorithm：

```text
detect unresolved state
→ classify unknown
→ choose operator
→ execute
→ observe
→ reclassify
```

Runtime：

- persist unknown；
- version type；
- record operator；
- preserve failures；
- reopen closure。

這一整條鏈才叫：

$$
\boxed{
\text{From Insight to Executable Epistemology}
}
$$

。

---

# 123. 與 Paper 04 的統一

Paper 04 的理解狀態：

$$
K_3
\rightarrow
K_4
\rightarrow
K_6
\rightarrow
K_7
$$

在本文中可以理解為：

$$
\text{Relation}
\rightarrow
\text{Compression Kernel}
\rightarrow
\text{Formalization}
\rightarrow
\text{Algorithmization}
$$

。

因此：

$$
K_4\neq K_6
$$

的落差就是：

$$
G_F
$$

。

---

# 124. 與 Paper 05 的統一

Paper 05：

$$
C^\ast
$$

是候選壓縮核。

Paper 07：

$$
C^\ast
\rightarrow
F
$$

是外顯化。

所以：

$$
\boxed{
\text{Compression Kernel}
\rightarrow
\text{Formal Object System}
}
$$

是 Insight 走向可執行研究的核心轉換。

---

# 125. 與 Paper 06 的統一

Paper 06：

$$
C_P
\rightarrow
C_T
\rightarrow
C_O
\rightarrow
C_A
\rightarrow
C_R
$$

其中每一層轉換都可被看成：

$$
\text{Epistemic Compilation}
$$

。

因此 institutional translation loss 可以拆成：

$$
\text{formalization loss}
+
\text{algorithmization loss}
+
\text{productization loss}
$$

。

---

# 126. 與 Omphalos 的統一

最新 World-Rooted Omphalos 可以寫成：

$$
W
\rightarrow
\hat W_t
\rightarrow
F_t
\rightarrow
\mathbf U_t
\rightarrow
O_t
\rightarrow
E_{t+1}
\rightarrow
F_{t+1}
$$

。

其中：

$$
F_t
$$

不是固定 ontology，而是：

$$
\boxed{
\text{Revisable Epistemic Formalization}
}
$$

。

---

# 127. 與下一篇的銜接

Paper 07 處理：

$$
\text{Concept}
\rightarrow
\text{Formalization}
\rightarrow
\text{Algorithm}
\rightarrow
\text{Runtime}
$$

。

下一篇 Paper 08 將回到搜尋層，正式整合：

$$
\boxed{
\text{Search as an Epistemic Operator Runtime}
}
$$

把舊 Omphalos / AUSI、DRC、GIPSS 與新版 World-Rooted Omphalos 接回本系列。

核心將不再是：

$$
\text{Search Method}
\rightarrow
\text{Provider}
$$

而是：

$$
\boxed{
W
\rightarrow
\hat W_t
\rightarrow
U_\tau
\rightarrow
O_{\text{epistemic}}
\rightarrow
M_{\text{search}}
\rightarrow
P_{\text{provider}}
\rightarrow
E
\rightarrow
\hat W_{t+1}
}
$$

也就是：

> **搜尋只是認識算子的其中一個執行家族；先判斷世界與未知，再決定是否搜尋、如何搜尋、用哪一種方法與哪一個 Provider。**

---

# References

1. Simon, H. A. *The Sciences of the Artificial*.
2. Newell, A., & Simon, H. A. *Human Problem Solving*.
3. Polanyi, M. *The Tacit Dimension*.
4. Kuhn, T. S. *The Structure of Scientific Revolutions*.
5. Popper, K. R. *The Logic of Scientific Discovery*.
6. EveMissLab. *從資訊檢索到研究編譯：VRCA 理論模型 v0.1*.
7. EveMissLab. *全域欲相位認識論 GIPE v0.1：從語義搜尋到主動科學介入*.
8. EveMissLab. *Omphalos: From Search APIs to an AI-Native Search-Method Runtime v0.1*.
9. EveMissLab. *OWER Paper 00: From Deep Research to Open-World Epistemic Research*.
10. EveMissLab. *OWER Paper 01: The Internet-Access Illusion*.
11. EveMissLab. *OWER Paper 02: Local Attention Convergence and Global Epistemic Distortion*.
12. EveMissLab. *OWER Paper 03: Unknown Is Not One Thing*.
13. EveMissLab. *OWER Paper 04: Understanding-State Calculus*.
14. EveMissLab. *OWER Paper 05: Aha as Compression-Kernel Formation*.
15. EveMissLab. *OWER Paper 06: Institutional Epistemic Compression*.

---

# Appendix A — Formalization Package

```yaml
formalization_package:
  id:
  version:

  semantic_source:
    concepts: []
    claims: []
    compression_kernels: []

  state_model:
    states: []
    variables: []
    types: []

  constraints:
    hard: []
    soft: []

  operators:
    - name:
      preconditions:
      effects:
      outputs:

  transitions: []

  invariants: []

  uncertainty:
    unresolved_ambiguity: []
    open_types: []

  termination:
    stop_conditions: []
    closure_conditions: []
    reopen_conditions: []

  validation:
    examples: []
    counterexamples: []
    holdout_cases: []

  governance:
    owner:
    review_status:
    rollback_version:
```

---

# Appendix B — Epistemic Compilation Pipeline

```text
PHENOMENON
↓
RECOGNITION
↓
CONCEPT
↓
COMPRESSION KERNEL
↓
FORMAL OBJECT
↓
STATE / VARIABLE / CONSTRAINT
↓
OPERATOR
↓
TRANSITION RULE
↓
ALGORITHM
↓
IMPLEMENTATION
↓
RUNTIME
↓
VALIDATION
↓
SCHEMA REVISION
```

---

# Appendix C — 一句話命題

> **真正困難的往往不是把演算法寫成程式，而是先知道什麼應該成為 state、variable、constraint、operator 與 invariant；AI 可以極快生成 code，但如果形式空間錯了，它只會更快把錯的計算做完。**