OWER Paper 07 v0.1｜形式化落差
形式化落差
The Formalization Gap: From Problem Recognition to Formal Objects, Operators, Algorithms, and Runtime
Series: Open-World Epistemic ResearchPaper: 07Version: v0.1Date: 2026-09-20Language: zh-TWStatus: Formal Draft / Canonical Markdown SourceAuthors: Neo.K × GPT-5.6 SolInstitution: EveMissLab / 一言諾科技有限公司
摘要
現代 AI、科學研究與軟體工程中，一個常見但容易被忽略的錯誤，是把「我已經能精確描述問題」誤認成「我已經有了解法」，或進一步誤認成「我已經知道怎麼寫成演算法」。
本文提出 Formalization Gap ，用來描述從現象辨識、概念形成、形式化、演算法化、實作到 Runtime 化之間的非平凡轉換距離。本文將一條完整轉換鏈寫成：
Phenomenon → Recognition → Concept → Formal Object → Operator → Algorithm → Implementation → 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}
} Phenomenon → Recognition → Concept → Formal Object → Operator → Algorithm → Implementation → Runtime 其中每一層都需要新的表示能力與約束，而不是前一層的自然延伸。
例如：
「Deep Research 會在錯的局部空間中越研究越深。」
這是一個高品質概念敘述。
但要變成可執行系統，至少還需要：
D t D_t D t 表示當前研究域，
∂ D t \partial D_t ∂ D t 表示未閉合邊界，
U τ U_\tau U τ 表示不同未知型別，
O τ O_\tau O τ 表示認識算子，
再定義：
ExpandBoundary \operatorname{ExpandBoundary} ExpandBoundary ReTypeUnknown \operatorname{ReTypeUnknown} ReTypeUnknown ChallengeKernel \operatorname{ChallengeKernel} ChallengeKernel 等 operator，最後才能形成 algorithm 與 runtime。
因此：
Precise Description ≠ Formalization \boxed{
\text{Precise Description}
\neq
\text{Formalization}
} Precise Description = Formalization Formalization ≠ Algorithm \boxed{
\text{Formalization}
\neq
\text{Algorithm}
} Formalization = Algorithm Algorithm ≠ Runtime \boxed{
\text{Algorithm}
\neq
\text{Runtime}
} Algorithm = Runtime 本文進一步分析為何 AI 時代容易產生新的形式化錯覺。大型模型可以在收到自然語言描述後快速產生 code prototype，使「概念到程式」看起來只需要幾分鐘。但真正被壓縮掉的工作，不是 coding 本身，而是：
What computation should exist?
也就是：應該有哪些 state、哪些 variables、哪些 constraints、哪些 operators、哪些 invariants、哪些 transition rules，以及什麼條件算完成。
如果這些物件沒有被正確定義，AI 仍然可以快速寫出大量程式，但只是在錯誤計算空間中高效率執行。
本文因此提出：
Better Code Generation × Wrong Formal Space = Faster Wrong System \boxed{
\text{Better Code Generation}
\times
\text{Wrong Formal Space}
=
\text{Faster Wrong System}
} Better Code Generation × Wrong Formal Space = Faster Wrong System 並將形式化視為 AI 原生研究架構中的核心認識轉換，而不是單純數學記號化。
關鍵詞： Formalization Gap、Problem Formalization、Algorithmization、Runtime、Formal Object、Operator、Constraint、State Space、AI-Native Research、Epistemic Runtime
1. 問題：為什麼「說清楚」仍然不等於「做得出來」？
研究者經常有一種經驗：
問題已經說得非常清楚，但還是不知道怎麼做。
這並不矛盾。
因為：
Description \text{Description} Description 與：
Computation \text{Computation} Computation 並不是同一層。
一句：
系統應該主動懷疑自己的分類。
是一個概念要求。
但程式不能直接執行：
doubt_your_categories()
除非先定義：
什麼是 category；
如何表示 category；
什麼叫「分類不完整」；
哪些 evidence 觸發懷疑；
懷疑後做什麼；
如何停止；
如何驗證新分類是否更好。
所以：
Semantic Precision ≠ Operational Precision \boxed{
\text{Semantic Precision}
\neq
\text{Operational Precision}
} Semantic Precision = Operational Precision 。
2. 從現象到 Runtime 的八層鏈
本文採用：
P 0 → P 1 → P 2 → P 3 → P 4 → P 5 → P 6 → P 7 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 → P 1 → P 2 → P 3 → P 4 → P 5 → P 6 → P 7 其中：
P 0 = Phenomenon P_0=\text{Phenomenon} P 0 = Phenomenon P 1 = Recognition P_1=\text{Recognition} P 1 = Recognition P 2 = Concept P_2=\text{Concept} P 2 = Concept P 3 = Formal Object P_3=\text{Formal Object} P 3 = Formal Object P 4 = Operator P_4=\text{Operator} P 4 = Operator P 5 = Algorithm P_5=\text{Algorithm} P 5 = Algorithm P 6 = Implementation P_6=\text{Implementation} P 6 = Implementation P 7 = Runtime P_7=\text{Runtime} P 7 = Runtime 。
每一層都回答不同問題。
3. Phenomenon
現象層只需要：
有事情發生了。
例如：
Deep Research 有時候搜尋很多資料後，反而對錯誤結論更有信心。
這還不是理論。
只是：
O 0 = Observed Pattern O_0
=
\text{Observed Pattern} O 0 = Observed Pattern 。
4. Recognition
Recognition 是：
這不是偶然 bug，而是一個值得研究的結構問題。
也就是：
O 0 → P 1 O_0
\rightarrow
P_1 O 0 → P 1 。
Recognition 的價值在於把：
noise \text{noise} noise 提升成：
problem candidate \text{problem candidate} problem candidate 。
5. Concept
Concept 層開始形成：
這可能叫做局部注意力收斂。
或者：
未知不是單一狀態。
這些概念可以高度有解釋力。
但仍是：
P 2 P_2 P 2 而不是：
P 3 P_3 P 3 。
6. Formal Object
Formalization 的第一步，是把自然語言概念轉成可區分物件。
例如：
未知有很多種。
形式化為：
U = { U data , U category , U structure , U conflict , … } U
=
\{
U_{\text{data}},
U_{\text{category}},
U_{\text{structure}},
U_{\text{conflict}},
\ldots
\} U = { U data , U category , U structure , U conflict , … } 。
這一步很重要。
因為只有變成：
U τ U_\tau U τ 之後，系統才能：
比較；
儲存；
轉型；
排程；
綁定 operator。
7. 形式化不是加數學符號
一個常見誤解是：
把自然語言寫成公式，就叫形式化。
不是。
形式化真正要求：
Ambiguous Semantic Object → Explicit Computational Object \boxed{
\text{Ambiguous Semantic Object}
\rightarrow
\text{Explicit Computational Object}
} Ambiguous Semantic Object → Explicit Computational Object 。
例如：
「世界邊界」
如果只是寫：
B B B 但不知道：
B B B 如何建立；
如何更新；
如何測量；
如何與 query planner 互動；
那只是：
symbolic relabeling \text{symbolic relabeling} symbolic relabeling 而不是完整形式化。
8. Formal Object 的最低條件
本文提出一個 formal object：
X X X 至少應具有：
X = ( identity , type , state , relations , update rules ) X
=
(
\text{identity},
\text{type},
\text{state},
\text{relations},
\text{update rules}
) X = ( identity , type , state , relations , update rules ) 。
若沒有 update rules，它可能只是資料結構。
若沒有 relations，它可能只是 isolated variable。
9. State Space
任何可執行研究系統都需要：
S S S state space。
例如：
S t = ( K t , U t , C t , E t , B t ) S_t
=
(
\mathbf K_t,
\mathbf U_t,
\mathcal C_t,
E_t,
B_t
) S t = ( K t , U t , C t , E t , B t ) 。
如果系統沒有顯式 state，就只能依賴模型當前 context 的臨時表示。
10. State 與自然語言 context 不同
Context：
C t C_t C t 通常只是目前送進模型的 token。
State：
S t S_t S t 則是：
系統認為世界現在處於什麼狀態。
因此：
Context ≠ State \boxed{
\text{Context}
\neq
\text{State}
} Context = State 。
11. Variable
形式化還需要把變動因素顯式化。
例如：
u category u_{\text{category}} u category 表示分類未知程度。
b frontier b_{\text{frontier}} b frontier 表示未閉合邊界壓力。
q source q_{\text{source}} q source 表示來源品質。
沒有 variable，系統很難 measure 或 route。
12. Constraint
只有 variable 不夠。
還需要：
C = { c 1 , c 2 , … , c n } C
=
\{c_1,c_2,\ldots,c_n\} C = { c 1 , c 2 , … , c n } 。
例如：
u counter > 0.8 ⇒ Closure = 0 u_{\text{counter}}>0.8
\Rightarrow
\operatorname{Closure}=0 u counter > 0.8 ⇒ Closure = 0 。
或者：
SourceRoots < 2 ⇒ EvidenceIndependence = low \operatorname{SourceRoots}<2
\Rightarrow
\operatorname{EvidenceIndependence}=\text{low} SourceRoots < 2 ⇒ EvidenceIndependence = low 。
Constraint 讓系統不只生成可能，而能排除不允許狀態。
13. Constraint 的價值
假設候選空間：
Ω = { x 1 , x 2 , … , x n } \Omega
=
\{x_1,x_2,\ldots,x_n\} Ω = { x 1 , x 2 , … , x n } 加入約束：
C C C 之後：
Ω ′ = { x ∈ Ω : x ⊨ C } \Omega'
=
\{x\in\Omega:x\models C\} Ω ′ = { x ∈ Ω : x ⊨ C } 。
如果：
∣ Ω ′ ∣ ≪ ∣ Ω ∣ |\Omega'|\ll|\Omega| ∣ Ω ′ ∣ ≪ ∣Ω∣ 則：
Constraint = Search-Space Reduction \boxed{
\text{Constraint}
=
\text{Search-Space Reduction}
} Constraint = Search-Space Reduction 。
14. Operator
有 state、variable、constraint 之後，才有 operator。
Operator：
O : S t → S t + 1 O:
S_t
\rightarrow
S_{t+1} O : S t → S t + 1 。
例如：
Retrieve \operatorname{Retrieve} Retrieve Reclassify \operatorname{Reclassify} Reclassify ExpandBoundary \operatorname{ExpandBoundary} ExpandBoundary ChallengeKernel \operatorname{ChallengeKernel} ChallengeKernel ReopenClosure \operatorname{ReopenClosure} ReopenClosure 。
15. Operator 不等於 Tool
Tool：
Browser。
Operator：
搜尋反證。
同一 operator 可使用不同 tool。
O counter → { Web , Paper DB , Experiment , Simulation } O_{\text{counter}}
\rightarrow
\{
\text{Web},
\text{Paper DB},
\text{Experiment},
\text{Simulation}
\} O counter → { Web , Paper DB , Experiment , Simulation } 。
同一 tool 也可支援不同 operator。
因此：
Operator ≠ Tool \boxed{
\text{Operator}
\neq
\text{Tool}
} Operator = Tool 。
16. Operator 不等於 Method
Method 可以是一個高階程序：
M = O 1 ▹ O 2 ▹ O 3 M
=
O_1
\triangleright
O_2
\triangleright
O_3 M = O 1 ▹ O 2 ▹ O 3 。
因此至少在本文架構中：
Operator ⊂ Method \text{Operator}
\subset
\text{Method} Operator ⊂ Method 。
17. Transition Rule
如果 operator 改變 state，就需要：
T : ( S t , O t , E t ) → S t + 1 T:
(S_t,O_t,E_t)
\rightarrow
S_{t+1} T : ( S t , O t , E t ) → S t + 1 。
這是 transition rule。
沒有 transition rule，operator 只是一個 action。
18. Invariant
研究 Runtime 還需要 invariant。
例如：
Retrieved ≠ Verified \boxed{
\text{Retrieved}
\neq
\text{Verified}
} Retrieved = Verified 是一個 invariant。
又如：
Closure ⇒ Reopen Conditions Exist \boxed{
\text{Closure}
\Rightarrow
\text{Reopen Conditions Exist}
} Closure ⇒ Reopen Conditions Exist 。
Invariant 保證系統不因局部更新破壞核心認識規則。
19. Formalization Package
因此完整形式化至少可以表示為：
F = ( S , V , C , O , T , I ) F
=
(
S,
V,
C,
O,
T,
I
) F = ( S , V , C , O , T , I ) 其中：
S S S V V V C C C O O O T T T I I I
這比一條公式完整得多。
20. Formalization Gap
定義：
G F = dist ( P 2 , F ) G_F
=
\operatorname{dist}
(
P_2,
F
) G F = dist ( P 2 , F ) 其中：
P 2 P_2 P 2 F F F
如果：
G F ≫ 0 G_F\gg0 G F ≫ 0 表示：
想法很清楚，但離可計算仍很遠。
21. Formalization-Speed Projection
對某些研究者：
C P 2 → F C_{P_2\rightarrow F} C P 2 → F 很低。
也就是：
從概念到形式物件的轉換很快。
這容易產生：
Formalization-Speed Projection \boxed{
\text{Formalization-Speed Projection}
} Formalization-Speed Projection ：
既然我很快能寫出來，別人應該早就寫過。
但：
C P 2 → F A ≠ C P 2 → F B C_{P_2\rightarrow F}^{A}
\neq
C_{P_2\rightarrow F}^{B} C P 2 → F A = C P 2 → F B 。
22. 概念簡單不代表形式化簡單
例如：
AI 應該知道自己不知道什麼。
概念非常簡單。
但真正形式化：
U τ U_\tau U τ 還需要：
unknown types；
classification policy；
transition rules；
operator mapping；
closure relation；
persistence；
validation。
因此：
Conceptual Simplicity ≠ Formal Simplicity \boxed{
\text{Conceptual Simplicity}
\neq
\text{Formal Simplicity}
} Conceptual Simplicity = Formal Simplicity 。
23. 形式化優雅不代表演算法容易
即使：
U τ U_\tau U τ 定義很乾淨，要可靠判斷：
τ \tau τ 仍可能很難。
所以：
Formal Elegance ≠ Algorithmic Ease \boxed{
\text{Formal Elegance}
\neq
\text{Algorithmic Ease}
} Formal Elegance = Algorithmic Ease 。
24. Algorithmization
Algorithmization 需要：
A = ( input , state , procedure , termination , output ) A
=
(
\text{input},
\text{state},
\text{procedure},
\text{termination},
\text{output}
) A = ( input , state , procedure , termination , output ) 。
形式物件只說：
世界應該怎麼被表示。
Algorithm 則說：
系統下一步應該怎麼做。
25. Algorithm 的最小結構
可寫：
A : ( S t , X t ) → ( O t , S t + 1 ) A:
(S_t,X_t)
\rightarrow
(O_t,S_{t+1}) A : ( S t , X t ) → ( O t , S t + 1 ) 。
其中：
S t S_t S t X t X_t X t O t O_t O t S t + 1 S_{t+1} S t + 1
26. Algorithm 需要終止條件
若：
A A A 沒有 stop condition，
研究會：
expand forever \text{expand forever} expand forever 。
因此：
Stop ( S t ) \operatorname{Stop}(S_t) Stop ( S t ) 是 algorithm 的一部分。
27. Stop Condition 不等於 Closure
Stop = 1 \operatorname{Stop}=1 Stop = 1 可能只是：
budget exhausted；
deadline；
user asked；
marginal gain low。
Closure：
C E = 1 C_E=1 C E = 1 則是認識條件。
因此：
Stop ≠ Closure \boxed{
\text{Stop}
\neq
\text{Closure}
} Stop = Closure 。
28. Algorithm 需要 failure handling
例如：
O t = Retrieve O_t=\operatorname{Retrieve} O t = Retrieve 失敗後：
F t F_t F t 應進：
S t + 1 S_{t+1} S t + 1 而不是被忽略。
因此：
Failure ⊂ State Update \boxed{
\text{Failure}
\subset
\text{State Update}
} Failure ⊂ State Update 。
29. Algorithm 需要 uncertainty handling
如果：
P ( τ i ) ≈ P ( τ j ) P(\tau_i)\approx P(\tau_j) P ( τ i ) ≈ P ( τ j ) 未知型別不確定，
算法不應強行：
arg max \arg\max arg max 後刪掉其他候選。
可保留：
{ τ i , τ j } \{\tau_i,\tau_j\} { τ i , τ j } 。
30. Algorithm 需要 branch management
開放世界研究很容易出現：
b d b^d b d 組合爆炸。
因此要：
Prune \operatorname{Prune} Prune Budget \operatorname{Budget} Budget Prioritize \operatorname{Prioritize} Prioritize 。
這些都屬於 algorithmization。
31. Implementation
Algorithm：
A A A 進入程式後：
I I I 還需要：
data structure；
API；
database；
scheduler；
persistence；
concurrency；
errors；
logging；
authentication；
tests。
因此：
A ≠ I \boxed{
A
\neq
I
} A = I 。
32. Implementation Gap
定義：
G I = dist ( A , I ) G_I
=
\operatorname{dist}(A,I) G I = dist ( A , I ) 。
一個 algorithm 可以理論上很好，但：
G I G_I G I 仍極大。
33. Runtime
Runtime 比 implementation 再多一層。
Runtime 是：
Implementation + Persistent State + Environment + Policies + Execution Control \boxed{
\text{Implementation}
+
\text{Persistent State}
+
\text{Environment}
+
\text{Policies}
+
\text{Execution Control}
} Implementation + Persistent State + Environment + Policies + Execution Control 。
所以：
R ≠ I R
\neq
I R = I 。
34. Why Runtime Matters
同一 implementation：
I I I 在不同：
E 1 , E 2 E_1,E_2 E 1 , E 2 environment 下，可能行為不同。
因此：
Behavior = f ( I , E , P , S ) \operatorname{Behavior}
=
f(I,E,P,S) Behavior = f ( I , E , P , S ) 其中：
E E E P P P S S S
35. Runtime 是認識行為真正發生的地方
理論與算法只是 potential。
真正：
observe → update → act \text{observe}
\rightarrow
\text{update}
\rightarrow
\text{act} observe → update → act 發生在 runtime。
所以 Epistemic Runtime 指的是：
認識狀態持續存在並驅動行動的執行層。
36. Runtime State
可定義：
R t = ( W t , K t , U t , C t , E t , H t , P t ) R_t
=
(
W_t,
K_t,
U_t,
C_t,
E_t,
H_t,
P_t
) R t = ( W t , K t , U t , C t , E t , H t , P t ) 其中：
W t W_t W t K t K_t K t U t U_t U t C t C_t C t E t E_t E t H t H_t H t P t P_t P t
37. Prompt 不是 Runtime
一個 prompt：
請主動找反證。
只是 instruction。
如果系統沒有：
counterevidence state；
action tracking；
completion requirement；
verifier；
那它不保證：
CounterSearch \operatorname{CounterSearch} CounterSearch 每次真的執行。
因此：
Prompt ≠ Runtime Constraint \boxed{
\text{Prompt}
\neq
\text{Runtime Constraint}
} Prompt = Runtime Constraint 。
38. Prompt Engineering 與 Algorithm Engineering
Prompt：
P P P 通常是軟約束。
Algorithm：
A A A 可建立硬流程。
Runtime：
R R R 則可持續 enforce。
因此：
P → A → R P
\rightarrow
A
\rightarrow
R P → A → R 是一條逐步外顯化約束的路徑。
39. AI 時代的 Coding Illusion
現代模型可以：
Natural Language → Code \text{Natural Language}
\rightarrow
\text{Code} Natural Language → Code 非常快。
這會產生：
Coding Illusion \boxed{
\text{Coding Illusion}
} Coding Illusion ：
好像只要能說清楚，就已經快做完。
但真正被 AI 代勞的是 syntax generation 與部分 implementation detail。
最難的往往仍是：
What computation should exist? \boxed{
\text{What computation should exist?}
} What computation should exist? 。
40. What Computation Should Exist?
這個問題包括：
什麼 state 必須存在？
哪些 variable 必須被追蹤？
哪些 unknown 必須分型？
哪些 constraint 是硬條件？
哪些 operator 必須存在？
哪些 invariant 不能被破壞？
哪些 transition 是合法的？
何時停止？
何時重新打開？
這些不是 code generator 自動保證的。
41. AI 會放大好的 Formalization，也會放大壞的 Formalization
若：
F good F_{\text{good}} F good 則：
AI Coding → Fast Prototype \text{AI Coding}
\rightarrow
\text{Fast Prototype} AI Coding → Fast Prototype 非常有價值。
但若：
F bad F_{\text{bad}} F bad 則：
AI Coding → Fast Wrong Prototype \boxed{
\text{AI Coding}
\rightarrow
\text{Fast Wrong Prototype}
} AI Coding → Fast Wrong Prototype 。
所以 AI 時代反而提高 formalization 的槓桿。
42. Better Intelligence × Wrong State Representation
若模型更強：
I model ↑ I_{\text{model}}\uparrow I model ↑ 但 state representation 錯：
S ≠ S ∗ S\neq S^\ast S = S ∗ 則：
I model ↑ ⇒ Better Optimization of the Wrong Space \boxed{
I_{\text{model}}\uparrow
\Rightarrow
\text{Better Optimization of the Wrong Space}
} I model ↑⇒ Better Optimization of the Wrong Space 可能成立。
43. Formalization 決定什麼可以被穩定最佳化
如果：
U category U_{\text{category}} U category 根本不存在 state 中，
系統就很難穩定最佳化：
Δ U category \Delta U_{\text{category}} Δ U category 。
因此：
What Is Not Represented Cannot Be Reliably Optimized \boxed{
\text{What Is Not Represented Cannot Be Reliably Optimized}
} What Is Not Represented Cannot Be Reliably Optimized 。
44. 表示先於最佳化
可以寫成：
Representation ≺ Optimization \boxed{
\text{Representation}
\prec
\text{Optimization}
} Representation ≺ Optimization 。
不是時間上必然先後，而是邏輯依賴：
先有可計算對象，才有穩定最佳化對象。
45. 形式化是壓縮核的外顯化
Paper 05 的壓縮核：
C C C 如果只存在於直覺，
它是：
C tacit C_{\text{tacit}} C tacit 。
Formalization：
C tacit → C explicit C_{\text{tacit}}
\rightarrow
C_{\text{explicit}} C tacit → C explicit 。
因此：
Formalization = Externalization of Generative Structure \boxed{
\text{Formalization}
=
\text{Externalization of Generative Structure}
} Formalization = Externalization of Generative Structure 至少在部分情況下成立。
46. Formalization Loss
C tacit → C explicit C_{\text{tacit}}
\rightarrow
C_{\text{explicit}} C tacit → C explicit 也可能丟失：
L F L_F L F 。
例如：
模糊邊界；
類比；
implicit assumptions；
可能難完整轉成 formal object。
因此形式化不是永遠無損。
47. Formalization Overreach
另一種錯誤是：
因為寫成公式，所以以為問題已經被理解。
可寫：
Symbolic Precision ⇏ Ontological Accuracy \boxed{
\text{Symbolic Precision}
\not\Rightarrow
\text{Ontological Accuracy}
} Symbolic Precision ⇒ Ontological Accuracy 。
形式化可以非常精確地描述錯誤模型。
48. Wrong Ontology, Perfect Mathematics
如果 ontology：
O O O 錯，
即使數學：
M ( O ) M(O) M ( O ) 完全正確，
仍可能：
M ( O ) ≠ W M(O)
\neq
W M ( O ) = W 。
因此：
Formal Correctness ≠ World Correctness \boxed{
\text{Formal Correctness}
\neq
\text{World Correctness}
} Formal Correctness = World Correctness 。
49. World Root 與 Formalization
World Root 的作用之一，是保留：
W ≠ F ( W ) W
\neq
F(W) W = F ( W ) 。
Formalization：
F ( W ) F(W) F ( W ) 只是對世界的一種可操作表示，不是世界本身。
50. Formalization 與 World Model 的差異
一個 world model：
M W M_W M W 可以很強。
但 Formalization Runtime 問：
目前有哪些可操作認識物件？
例如：
U τ U_\tau U τ C i C_i C i B t B_t B t E i E_i E i 。
所以：
World Model \text{World Model} World Model 與：
Epistemic Formalization \text{Epistemic Formalization} Epistemic Formalization 不是同一件事。
51. 形式化層級
可以有：
L0 — Linguistic
自然語言概念。
L1 — Typed Concepts
明確類型。
L2 — Variables and Relations
變量與關係。
L3 — Constraints
限制與不變量。
L4 — Operators
可操作轉換。
L5 — Algorithms
程序。
L6 — Runtime Semantics
長期執行語義。
因此：
F 0 → F 1 → ⋯ → F 6 F_0
\rightarrow
F_1
\rightarrow
\cdots
\rightarrow
F_6 F 0 → F 1 → ⋯ → F 6 。
52. 不是所有問題都需要做到 L6
若任務只是理論分析，可能：
F 3 F_3 F 3 已足夠。
若要做自主研究 Agent，則至少需要：
F 5 / F 6 F_5/F_6 F 5 / F 6 。
因此 formalization depth 應 task-relative。
53. Formalization Depth
定義：
D F D_F D F 表示形式化深度。
可以是：
D F ∈ { 0 , … , 6 } D_F\in\{0,\ldots,6\} D F ∈ { 0 , … , 6 } 。
產品評估時，不應只問：
有沒有形式化？
而應問：
到哪一層？
54. Precision 不等於 Depth
一篇論文可以在：
F 2 F_2 F 2 非常精準，
但沒有：
F 4 F_4 F 4 operator。
另一篇可能符號較少，
但已給完整：
F 5 F_5 F 5 algorithm。
因此：
Notation Density ≠ Formalization Depth \boxed{
\text{Notation Density}
\neq
\text{Formalization Depth}
} Notation Density = Formalization Depth 。
55. Formalization Coverage
同一問題有多個子域：
D 1 , … , D n D_1,\ldots,D_n D 1 , … , D n 。
可能只有：
D 1 , D 2 D_1,D_2 D 1 , D 2 被形式化。
所以還需要：
C F = formalized critical domains required domains C_F
=
\frac{
\text{formalized critical domains}
}{
\text{required domains}
} C F = required domains formalized critical domains 。
56. 深度與覆蓋率要分開
D F ≠ C F D_F
\neq
C_F D F = C F 。
可能：
D F ≫ 0 D_F\gg0 D F ≫ 0 但：
C F ≪ 1 C_F\ll1 C F ≪ 1 。
這與 Paper 02 的：
Local Depth ≠ Global Coverage \text{Local Depth}
\neq
\text{Global Coverage} Local Depth = Global Coverage 同構。
57. Formalization Gap Matrix
可建立：
M F = [ d 11 ⋯ d 1 m ⋮ ⋱ ⋮ d n 1 ⋯ d n m ] M_F
=
\begin{bmatrix}
d_{11} & \cdots & d_{1m}\\
\vdots & \ddots & \vdots\\
d_{n1} & \cdots & d_{nm}
\end{bmatrix} M F = d 11 ⋮ d n 1 ⋯ ⋱ ⋯ d 1 m ⋮ d nm 其中：
row：problem domains；
column：formalization layers。
這比單一「成熟度」更能描述系統。
58. 形式化與驗證
形式化後要驗證：
V F V_F V F 。
例如 Unknown Type classifier 需測：
Accuracy ( τ ) \operatorname{Accuracy}(\tau) Accuracy ( τ ) 。
Closure rule 需測：
FalseClosureRate \operatorname{FalseClosureRate} FalseClosureRate 。
因此：
Formalized ≠ Validated \boxed{
\text{Formalized}
\neq
\text{Validated}
} Formalized = Validated 。
59. Formalization 與反例
好的 formalization 應讓反例更容易指定。
例如：
u counter > 0.8 ⇒ Closure = 0 u_{\text{counter}}>0.8
\Rightarrow
\operatorname{Closure}=0 u counter > 0.8 ⇒ Closure = 0 就可以測是否存在反例。
形式化使反證更可操作。
60. Formalization as Falsifiability Amplifier
可以說：
Formalization → Sharper Falsification Surface \boxed{
\text{Formalization}
\rightarrow
\text{Sharper Falsification Surface}
} Formalization → Sharper Falsification Surface 。
模糊概念很難被精確推翻。
61. Formalization 與 Modularity
如果：
F = ( S , V , C , O , T , I ) F
=
(S,V,C,O,T,I) F = ( S , V , C , O , T , I ) 各自模組化，
可以替換：
O i O_i O i 而不重寫全部。
這是 architecture stability。
62. Formal Objects as First-Class Objects
真正 AI-native Runtime 應讓：
U τ U_\tau U τ C i C_i C i E i E_i E i B i B_i B i 成為 first-class objects。
意味：
可讀；
可寫；
可傳遞；
可版本化；
可查詢；
可驗證。
63. Natural Language 仍然重要
本文不主張全部都要形式語言。
自然語言仍擅長：
提出新概念；
描述邊界；
表達例外；
跨領域類比；
高層壓縮。
因此：
Natural Language + Formal Objects \boxed{
\text{Natural Language}
+
\text{Formal Objects}
} Natural Language + Formal Objects 比單一形式更適合研究。
64. 雙表示層
可建立：
L N L_N L N 自然語言層，
與：
L F L_F L F 形式化層。
兩者：
L N ↔ L F L_N
\leftrightarrow
L_F L N ↔ L F 持續互譯。
65. 語言層負責生成，形式層負責約束
概念上：
L N → candidate expansion L_N
\rightarrow
\text{candidate expansion} L N → candidate expansion L F → constraint and verification L_F
\rightarrow
\text{constraint and verification} L F → constraint and verification 。
兩者不是敵對，而是互補。
66. AI 的特殊優勢
大型模型很適合：
L N → L F L_N\rightarrow L_F L N → L F candidate generation。
例如：
幫我把「未知不是一種」轉成 state schema。
AI 可以很快產生候選 formalization。
67. AI 的特殊風險
AI 也很容易：
plausible language → plausible formalization \text{plausible language}
\rightarrow
\text{plausible formalization} plausible language → plausible formalization 但：
plausible ≠ correct \text{plausible}
\neq
\text{correct} plausible = correct 。
所以：
L N → L F L_N\rightarrow L_F L N → L F 必須有 validation。
68. Formalization Compiler
可以把：
FormalizationCompiler : L N → F \boxed{
\operatorname{FormalizationCompiler}
:
L_N
\rightarrow
F
} FormalizationCompiler : L N → F 視為未來 Research Runtime 的核心模組。
它不是自動把句子變公式，而是：
identify entities；
identify states；
identify variables；
identify constraints；
identify operators；
identify invariants；
identify transition rules；
identify unresolved ambiguity。
69. Ambiguity Ledger
任何 formalization compiler 都應保存：
A F A_F A F 未解歧義。
例如：
ambiguity:
phrase: "global coverage"
candidates:
- source coverage
- category coverage
- world-surface coverage
unresolved: true
。
這比假裝已經形式化更安全。
70. Partial Formalization
形式化不必一次完成。
可以：
F t → F t + 1 F_t
\rightarrow
F_{t+1} F t → F t + 1 逐步改善。
所以：
Formalization = Iterative Epistemic Compilation \boxed{
\text{Formalization}
=
\text{Iterative Epistemic Compilation}
} Formalization = Iterative Epistemic Compilation 。
71. Epistemic Compilation
本文將：
Concept → Formal Object → Operator → Algorithm \text{Concept}
\rightarrow
\text{Formal Object}
\rightarrow
\text{Operator}
\rightarrow
\text{Algorithm} Concept → Formal Object → Operator → Algorithm 整體稱為：
Epistemic Compilation \boxed{
\text{Epistemic Compilation}
} Epistemic Compilation 。
因為它把可理解思想轉成可執行認識程序。
72. Compilation Error
若：
C C C 被錯誤編譯成：
F ′ F' F ′ 則：
F ′ ≠ C F'\neq C F ′ = C 。
這就是：
Epistemic Compilation Error \text{Epistemic Compilation Error} Epistemic Compilation Error 。
例如原理：
保留未知類別。
被編譯成：
增加 confidence threshold。
這可能根本不是同一件事。
73. Semantic Preservation
因此要求：
Sem ( C ) ≈ Sem ( F ) \operatorname{Sem}(C)
\approx
\operatorname{Sem}(F) Sem ( C ) ≈ Sem ( F ) 。
可定義：
F S = SemanticFidelity ( C , F ) F_S
=
\operatorname{SemanticFidelity}(C,F) F S = SemanticFidelity ( C , F ) 。
74. Operator Preservation
再要求：
Behavior ( F ) \operatorname{Behavior}(F) Behavior ( F ) 符合：
Intent ( C ) \operatorname{Intent}(C) Intent ( C ) 。
即：
F O = OperationalFidelity F_O
=
\operatorname{OperationalFidelity} F O = OperationalFidelity 。
75. Algorithmic Preservation
形式化：
F F F 轉算法：
A A A 再檢查：
Sem ( F ) ≈ Behavior ( A ) \operatorname{Sem}(F)
\approx
\operatorname{Behavior}(A) Sem ( F ) ≈ Behavior ( A ) 。
這是一個 compiler correctness 問題。
76. Runtime Preservation
算法：
A A A 進 runtime：
R R R 還要檢查：
Behavior ( R ) ≈ Spec ( A ) \operatorname{Behavior}(R)
\approx
\operatorname{Spec}(A) Behavior ( R ) ≈ Spec ( A ) 。
因為環境與 policy 可能改變結果。
77. End-to-End Fidelity
完整可以概念化為：
F end = F S ⋅ F O ⋅ F A ⋅ F R F_{\text{end}}
=
F_S
\cdot
F_O
\cdot
F_A
\cdot
F_R F end = F S ⋅ F O ⋅ F A ⋅ F R 。
任一層很低，最終產品就可能偏離原始理解。
78. 這接回 Institutional Epistemic Compression
Paper 06 的 translation loss：
L i L_i L i 在 Paper 07 中可以具體理解為：
Compilation Loss \text{Compilation Loss} Compilation Loss 。
因此：
Institutional Translation ≈ Multi-Layer Epistemic Compilation \boxed{
\text{Institutional Translation}
\approx
\text{Multi-Layer Epistemic Compilation}
} Institutional Translation ≈ Multi-Layer Epistemic Compilation 。
79. 個人「我懂了」為什麼能很快到 Algorithm Sketch？
Paper 05 的：
C ∗ C^\ast C ∗ 壓縮核一旦形成，
如果研究者已有：
operator vocabulary；
constraint habits；
graph thinking；
runtime concepts；
則：
C ∗ → F C^\ast
\rightarrow
F C ∗ → F 成本很低。
因此：
Aha → Algorithm Sketch \text{Aha}
\rightarrow
\text{Algorithm Sketch} Aha → Algorithm Sketch 可以非常快。
80. 但這不代表別人同樣快
別人可能缺：
O formal \mathcal O_{\text{formal}} O formal 即形式化 operator library。
所以：
C ∗ C^\ast C ∗ 雖然理解，仍不會立即變成：
F F F 。
81. Formalization Operator Library
可建立：
L F \mathcal L_F L F 包含：
classify；
type；
parameterize；
constrain；
factor；
decompose；
graph；
bind；
verify；
close；
reopen。
這些是：
Meta-Formalization Operators \boxed{
\text{Meta-Formalization Operators}
} Meta-Formalization Operators 。
82. 形式化能力可以被工具化
如果：
L F \mathcal L_F L F 被保存，
同一 AI 在未改 weights 情況下也能更快形式化。
因此 Formalization Skill 可以是 non-parametric capability。
83. Research Skill 與 Formalization Skill
Research Option：
Ω R \Omega_R Ω R 告訴：
怎麼研究。
Formalization Option：
Ω F \Omega_F Ω F 告訴：
怎麼把研究想法變成可操作形式。
兩者可組合。
84. Formalization Trajectory Compression
昂貴過程：
C → F 1 → F 2 → F 3 C
\rightarrow
F_1
\rightarrow
F_2
\rightarrow
F_3 C → F 1 → F 2 → F 3 可以抽成：
Ω F \Omega_F Ω F 。
因此：
Formalization Experience → Reusable Formalization Skill \boxed{
\text{Formalization Experience}
\rightarrow
\text{Reusable Formalization Skill}
} Formalization Experience → Reusable Formalization Skill 。
85. Formalization Debt
如果系統大量靠：
prompt；
convention；
hidden assumptions；
運作，但沒有顯式 formal object，
就會累積：
D F D_F D F Formalization Debt。
未來修改成本：
C change ↑ C_{\text{change}}\uparrow C change ↑ 。
86. Hidden Assumption Debt
若：
A hidden A_{\text{hidden}} A hidden 不外顯，
容易導致：
environment change → silent failure \text{environment change}
\rightarrow
\text{silent failure} environment change → silent failure 。
因此 assumptions 也應 first-class。
87. Constraint Debt
如果約束只存在於開發者腦中：
C implicit C_{\text{implicit}} C implicit 就無法被 Agent 自己檢查。
這是：
Constraint Debt \text{Constraint Debt} Constraint Debt 。
88. Runtime Without Formalization
很多現代 Agent 可以：
LLM + tools + prompt \text{LLM}
+
\text{tools}
+
\text{prompt} LLM + tools + prompt 直接跑。
這很有用。
但如果缺：
F F F 則：
state 不穩定；
failure 不可分類；
invariants 不明；
closure 不可檢查。
因此：
Working Agent ≠ Formalized Agent \boxed{
\text{Working Agent}
\neq
\text{Formalized Agent}
} Working Agent = Formalized Agent 。
89. Formalization Without Runtime
反過來，一套理論也可能非常完整：
F ≫ 0 F\gg0 F ≫ 0 但：
R = 0 R=0 R = 0 。
這仍然有學術價值，但不能說已是一個可運作系統。
90. Research Runtime 的正式角色
在 OWER 中：
R E R_E R E 應把：
F F F 持續實例化。
即：
R E : F × W t → S t + 1 R_E:
F\times W_t
\rightarrow
S_{t+1} R E : F × W t → S t + 1 。
91. World-Rooted Formalization
如果最新 Omphalos 以：
W W W 為 root，
則 formalization 不是：
Task → F \text{Task}
\rightarrow
F Task → F 而是：
W → W ^ t → F t → O t \boxed{
W
\rightarrow
\hat W_t
\rightarrow
F_t
\rightarrow
O_t
} W → W ^ t → F t → O t 。
這避免 formal objects 脫離世界。
92. Formalization 只是世界認識的一個投影
F t = Π F ( W ^ t ) F_t
=
\Pi_F(\hat W_t) F t = Π F ( W ^ t ) 。
所以：
F t ≠ W F_t
\neq
W F t = W 。
這與後續 World Model 番外相容。
93. Formalization Reopen
若新證據：
E n e w E_{new} E n e w 使原形式化不夠，
應：
F t → F t + 1 F_t
\rightarrow
F_{t+1} F t → F t + 1 。
因此 formalization 本身也必須可 reopen。
94. Static Formalization 問題
如果：
F F F 被視為永遠正確，
runtime 只會在舊 ontology 中運行。
所以：
Open-World Runtime ⇒ Revisable Formalization \boxed{
\text{Open-World Runtime}
\Rightarrow
\text{Revisable Formalization}
} Open-World Runtime ⇒ Revisable Formalization 。
95. Meta-Formalization
系統甚至要能問：
我的 state schema 本身是不是錯了？
這就是：
Meta-Formalization \boxed{
\text{Meta-Formalization}
} Meta-Formalization 。
96. Schema Rewriting
例如原本：
S t = ( K , U , E ) S_t
=
(K,U,E) S t = ( K , U , E ) 後來發現還需要：
C C C compression kernels。
則：
S t → S t ′ = ( K , U , E , C ) S_t
\rightarrow
S_t'
=
(K,U,E,C) S t → S t ′ = ( K , U , E , C ) 。
這就是 runtime schema evolution。
97. Schema Evolution 是 Open-World 的必要條件
封閉系統可以固定 schema。
開放世界：
W t W_t W t 可能出現新類別。
所以：
Open World ⇒ Potentially Open Schema \boxed{
\text{Open World}
\Rightarrow
\text{Potentially Open Schema}
} Open World ⇒ Potentially Open Schema 。
98. Schema Explosion 風險
如果遇到每個新東西都加新 field：
∣ S ∣ → ∞ |S|\rightarrow\infty ∣ S ∣ → ∞ 。
因此需要：
Generalize \operatorname{Generalize} Generalize Merge \operatorname{Merge} Merge Refactor \operatorname{Refactor} Refactor 。
99. Formalization Refactoring
與程式一樣，
formalization 也需要：
F t → F t + 1 F_t
\rightarrow
F_{t+1} F t → F t + 1 重構。
目標：
fewer redundant types；
clearer invariants；
better operator reuse；
lower coupling。
100. Formalization Minimality
理想希望：
∣ F ∣ |F| ∣ F ∣ 不要過大。
但 minimal 不能犧牲 coverage。
所以：
Minimal Formalization ≠ Under-Specified Formalization \boxed{
\text{Minimal Formalization}
\neq
\text{Under-Specified Formalization}
} Minimal Formalization = Under-Specified Formalization 。
101. 最小充分形式集
可定義：
F ∗ = arg min F ∣ F ∣ F^\ast
=
\arg\min_F |F| F ∗ = arg F min ∣ F ∣ subject to：
Coverage ( F ) ≥ θ \operatorname{Coverage}(F)\geq\theta Coverage ( F ) ≥ θ Operationality ( F ) ≥ θ O \operatorname{Operationality}(F)\geq\theta_O Operationality ( F ) ≥ θ O Validation ( F ) ≥ θ V \operatorname{Validation}(F)\geq\theta_V Validation ( F ) ≥ θ V 。
這是一種：
Minimal Sufficient Formalization \boxed{
\text{Minimal Sufficient Formalization}
} Minimal Sufficient Formalization 問題。
102. 與 Constraint-Based Thinking 的關係
當問題被形式化成：
Ω \Omega Ω 加：
C C C 後，
很多 reasoning 可變成：
Ω → Ω ′ \Omega
\rightarrow
\Omega' Ω → Ω ′ 。
這也是為什麼精細分類、約束與變量消除能大幅降低搜尋空間。
103. 變量消除
如果：
x 3 = f ( x 1 , x 2 ) x_3=f(x_1,x_2) x 3 = f ( x 1 , x 2 ) 則：
x 3 x_3 x 3 可不再獨立搜尋。
同理研究中：
H 3 = g ( H 1 , H 2 ) H_3
=
g(H_1,H_2) H 3 = g ( H 1 , H 2 ) 可能降低 hypothesis degrees of freedom。
104. Formalization as Degree-of-Freedom Reduction
可將形式化部分理解成：
Reduce Unnecessary Degrees of Freedom \boxed{
\text{Reduce Unnecessary Degrees of Freedom}
} Reduce Unnecessary Degrees of Freedom 。
這不是過度限制，而是把已知依賴編譯進 system。
105. Constraint Propagation
若：
c 1 , c 2 , c 3 c_1,c_2,c_3 c 1 , c 2 , c 3 互相關聯，
則新證據：
E E E 可：
E → Δ c 1 → Δ c 2 → Δ c 3 E
\rightarrow
\Delta c_1
\rightarrow
\Delta c_2
\rightarrow
\Delta c_3 E → Δ c 1 → Δ c 2 → Δ c 3 。
這就是 constraint propagation。
106. Research Agent 中的 Constraint Propagation
例如：
source date = 2025 \text{source date}=2025 source date = 2025 而任務要求：
t = 2026 t=2026 t = 2026 則：
current claim support \text{current claim support} current claim support 應下降。
這可以自動傳導，而不是等模型每次重新想到。
107. Formalization 將「想到」變成「必須處理」
這是核心差異。
Prompt：
記得注意時間。
Formalization：
TemporalMismatch > 0 ⇒ FreshnessCheck = 1 \operatorname{TemporalMismatch}>0
\Rightarrow
\operatorname{FreshnessCheck}=1 TemporalMismatch > 0 ⇒ FreshnessCheck = 1 。
前者是：
may remember \text{may remember} may remember 後者是：
must process \text{must process} must process 。
108. 從人格要求到算法要求
很多 Agent prompt 說：
be critical；
be skeptical；
consider alternatives；
verify sources。
這些像人格要求。
Formalization 把它變成：
counterevidence queue \text{counterevidence queue} counterevidence queue alternative hypothesis set \text{alternative hypothesis set} alternative hypothesis set source-root graph \text{source-root graph} source-root graph 。
這是：
Behavioral Instruction → Computational Obligation \boxed{
\text{Behavioral Instruction}
\rightarrow
\text{Computational Obligation}
} Behavioral Instruction → Computational Obligation 。
109. 這是 AI 原生研究的重要轉折
當「批判思考」仍是 prompt，
它只是：
soft behavior \text{soft behavior} soft behavior 。
當它變成：
O challenge O_{\text{challenge}} O challenge 與：
I counter I_{\text{counter}} I counter 它才變成：
runtime property \text{runtime property} runtime property 。
110. Formalization 與自由度
過強 formalization 也可能限制創造性。
所以需要：
ϵ free \epsilon_{\text{free}} ϵ free free exploration。
即：
formal constraints + open exploratory channel \text{formal constraints}
+
\text{open exploratory channel} formal constraints + open exploratory channel 。
111. Formalization 不應關閉未知世界
如果：
F F F 限制：
W W W 只能符合既有 type，
那麼：
U world U_{\text{world}} U world 永遠無法被發現。
所以：
Formalization Must Preserve Open-Set Capacity \boxed{
\text{Formalization Must Preserve Open-Set Capacity}
} Formalization Must Preserve Open-Set Capacity 。
112. Open-Type Slot
可以在 schema 中保留：
U novel U_{\text{novel}} U novel 或：
untyped object \text{untyped object} untyped object 。
這讓系統可以：
new observation → new type candidate \text{new observation}
\rightarrow
\text{new type candidate} new observation → new type candidate 。
113. Formalization 與 Meta-Unknown
Paper 03 的：
U meta U_{\text{meta}} U meta 要求 formalization 本身承認：
schema 可能不完整。
因此：
F F F 應有：
SchemaUnknown \operatorname{SchemaUnknown} SchemaUnknown 。
114. 自我修改形式化
更高階系統可：
F t → MetaOp F t + 1 F_t
\xrightarrow{\operatorname{MetaOp}}
F_{t+1} F t MetaOp F t + 1 。
即不只更新資料，也更新認識語言本身。
115. 但 MetaOp 需要治理
如果 Agent 可任意改：
F F F 可能破壞 invariant。
因此：
MetaOp \operatorname{MetaOp} MetaOp 需要：
validation；
versioning；
rollback；
audit。
116. Formalization Governance
可定義：
G F = ( proposal , test , review , promote , rollback ) G_F
=
(
\text{proposal},
\text{test},
\text{review},
\text{promote},
\text{rollback}
) G F = ( proposal , test , review , promote , 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。
比較：
language-only reasoning；
code-generation baseline；
formalization-aware agent；
runtime-aware agent。
評估：
Semantic Fidelity \text{Semantic Fidelity} Semantic Fidelity Operational Fidelity \text{Operational Fidelity} Operational Fidelity Invariant Preservation \text{Invariant Preservation} Invariant Preservation State Drift \text{State Drift} State Drift False Closure Rate \text{False Closure Rate} False Closure Rate Schema Adaptation \text{Schema Adaptation} Schema Adaptation 。
119. 主要命題
命題一
Precise Description ≠ Formalization \boxed{
\text{Precise Description}
\neq
\text{Formalization}
} Precise Description = Formalization 。
命題二
Formalization ≠ Algorithmization \boxed{
\text{Formalization}
\neq
\text{Algorithmization}
} Formalization = Algorithmization 。
命題三
Algorithm ≠ Runtime \boxed{
\text{Algorithm}
\neq
\text{Runtime}
} Algorithm = Runtime 。
命題四
Formalization 至少需要：
F = ( S , V , C , O , T , I ) F
=
(S,V,C,O,T,I) F = ( S , V , C , O , T , I ) 的部分結構，而不只是符號替換。
命題五
若重要認識狀態沒有被表示，系統無法穩定最佳化它。
Not Represented ⇒ Not Reliably Optimized \text{Not Represented}
\Rightarrow
\text{Not Reliably Optimized} Not Represented ⇒ Not Reliably Optimized 。
命題六
AI code generation 降低 implementation cost，但不自動降低 conceptual-formalization cost。
C code ↓ ⇏ C formalization ↓ C_{\text{code}}\downarrow
\not\Rightarrow
C_{\text{formalization}}\downarrow C code ↓ ⇒ C formalization ↓ 必然成立。
命題七
開放世界 Runtime 需要可修改 schema。
Open World ⇒ Revisable Formalization \text{Open World}
\Rightarrow
\text{Revisable Formalization} Open World ⇒ Revisable Formalization 。
120. 工程最小實作
最小 Formalization Runtime：
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. 最小資料結構
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：
Unknown Is Not One Thing \text{Unknown Is Not One Thing} Unknown Is Not One Thing Formal Object：
U = { U data , U category , U conflict , … } U=
\{
U_{\text{data}},
U_{\text{category}},
U_{\text{conflict}},
\ldots
\} U = { U data , U category , U conflict , … } Operator Map：
U data → Retrieve U_{\text{data}}
\rightarrow
\operatorname{Retrieve} U data → Retrieve U category → OntologyExpand U_{\text{category}}
\rightarrow
\operatorname{OntologyExpand} U category → OntologyExpand Algorithm：
detect unresolved state
→ classify unknown
→ choose operator
→ execute
→ observe
→ reclassify
Runtime：
persist unknown；
version type；
record operator；
preserve failures；
reopen closure。
這一整條鏈才叫：
From Insight to Executable Epistemology \boxed{
\text{From Insight to Executable Epistemology}
} From Insight to Executable Epistemology 。
123. 與 Paper 04 的統一
Paper 04 的理解狀態：
K 3 → K 4 → K 6 → K 7 K_3
\rightarrow
K_4
\rightarrow
K_6
\rightarrow
K_7 K 3 → K 4 → K 6 → K 7 在本文中可以理解為：
Relation → Compression Kernel → Formalization → Algorithmization \text{Relation}
\rightarrow
\text{Compression Kernel}
\rightarrow
\text{Formalization}
\rightarrow
\text{Algorithmization} Relation → Compression Kernel → Formalization → Algorithmization 。
因此：
K 4 ≠ K 6 K_4\neq K_6 K 4 = K 6 的落差就是：
G F G_F G F 。
124. 與 Paper 05 的統一
Paper 05：
C ∗ C^\ast C ∗ 是候選壓縮核。
Paper 07：
C ∗ → F C^\ast
\rightarrow
F C ∗ → F 是外顯化。
所以：
Compression Kernel → Formal Object System \boxed{
\text{Compression Kernel}
\rightarrow
\text{Formal Object System}
} Compression Kernel → Formal Object System 是 Insight 走向可執行研究的核心轉換。
125. 與 Paper 06 的統一
Paper 06：
C P → C T → C O → C A → C R C_P
\rightarrow
C_T
\rightarrow
C_O
\rightarrow
C_A
\rightarrow
C_R C P → C T → C O → C A → C R 其中每一層轉換都可被看成：
Epistemic Compilation \text{Epistemic Compilation} Epistemic Compilation 。
因此 institutional translation loss 可以拆成：
formalization loss + algorithmization loss + productization loss \text{formalization loss}
+
\text{algorithmization loss}
+
\text{productization loss} formalization loss + algorithmization loss + productization loss 。
126. 與 Omphalos 的統一
最新 World-Rooted Omphalos 可以寫成：
W → W ^ t → F t → U t → O t → E t + 1 → F t + 1 W
\rightarrow
\hat W_t
\rightarrow
F_t
\rightarrow
\mathbf U_t
\rightarrow
O_t
\rightarrow
E_{t+1}
\rightarrow
F_{t+1} W → W ^ t → F t → U t → O t → E t + 1 → F t + 1 。
其中：
F t F_t F t 不是固定 ontology，而是：
Revisable Epistemic Formalization \boxed{
\text{Revisable Epistemic Formalization}
} Revisable Epistemic Formalization 。
127. 與下一篇的銜接
Paper 07 處理：
Concept → Formalization → Algorithm → Runtime \text{Concept}
\rightarrow
\text{Formalization}
\rightarrow
\text{Algorithm}
\rightarrow
\text{Runtime} Concept → Formalization → Algorithm → Runtime 。
下一篇 Paper 08 將回到搜尋層，正式整合：
Search as an Epistemic Operator Runtime \boxed{
\text{Search as an Epistemic Operator Runtime}
} Search as an Epistemic Operator Runtime 把舊 Omphalos / AUSI、DRC、GIPSS 與新版 World-Rooted Omphalos 接回本系列。
核心將不再是：
Search Method → Provider \text{Search Method}
\rightarrow
\text{Provider} Search Method → Provider 而是：
W → W ^ t → U τ → O epistemic → M search → P provider → E → W ^ t + 1 \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}
} W → W ^ t → U τ → O epistemic → M search → P provider → E → W ^ t + 1 也就是：
搜尋只是認識算子的其中一個執行家族；先判斷世界與未知，再決定是否搜尋、如何搜尋、用哪一種方法與哪一個 Provider。
References
Simon, H. A. The Sciences of the Artificial .
Newell, A., & Simon, H. A. Human Problem Solving .
Polanyi, M. The Tacit Dimension .
Kuhn, T. S. The Structure of Scientific Revolutions .
Popper, K. R. The Logic of Scientific Discovery .
EveMissLab. 從資訊檢索到研究編譯：VRCA 理論模型 v0.1 .
EveMissLab. 全域欲相位認識論 GIPE v0.1：從語義搜尋到主動科學介入 .
EveMissLab. Omphalos: From Search APIs to an AI-Native Search-Method Runtime v0.1 .
EveMissLab. OWER Paper 00: From Deep Research to Open-World Epistemic Research .
EveMissLab. OWER Paper 01: The Internet-Access Illusion .
EveMissLab. OWER Paper 02: Local Attention Convergence and Global Epistemic Distortion .
EveMissLab. OWER Paper 03: Unknown Is Not One Thing .
EveMissLab. OWER Paper 04: Understanding-State Calculus .
EveMissLab. OWER Paper 05: Aha as Compression-Kernel Formation .
EveMissLab. OWER Paper 06: Institutional Epistemic Compression .
Appendix A — Formalization Package
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
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，但如果形式空間錯了，它只會更快把錯的計算做完。