# 複雜度位移原則：時間路徑如何轉移為空間、連接、歷史與外部能力

## The Complexity Displacement Principle: How Temporal Computational Paths Move into Space, Connectivity, History, and External Capability

**系列：** Computational Space and Hyperconnected Complexity Series  
**Paper：** 04 / 09  
**作者：** Neo.K  
**協作整理：** Aletheia / GPT-5.6 Sol  
**機構：** EveMissLab／一言諾科技有限公司  
**版本：** v0.1  
**日期：** 2026-08-29  
**文件性質：** 計算複雜度方法論／計算核算理論／超連接計算第二主軸基礎論文  
**前置文件：**  
- Paper 01《計算機不是處理器：可定址狀態轉換空間的重新定義》  
- Paper 02《從 1 到 X：符號、地址、展開與狀態翻轉計算》  
- Paper 03《超連接計算：從無限維奧賽羅到極限 MSSP–RDR》  

**研究狀態：** 理論框架、核算原則與形式化候選；不主張複雜度具有物理守恆律，不主張不同資源皆可轉換成單一標量，不主張本文證明任何經典複雜度類分離或塌縮。

---

## 摘要

前三篇已建立一條從「計算機」到「可定址狀態轉換空間」再到「超連接計算」的理論路徑。

其中最重要的現象是：

$$
x
\rightarrow
s_1
\rightarrow
s_2
\rightarrow
\cdots
\rightarrow
s_n
\rightarrow
y
$$

可以藉由演算法封裝、編譯、索引、預計算、模型訓練、硬體固化、API、外部 provider、Agent capability 或高階狀態翻轉，被轉換為：

$$
x
\xrightarrow{\Phi}
y,
$$

甚至在 caller 所見層級中：

$$
1_{\Phi}
\rightarrow
y.
$$

這會造成一個強烈但危險的直覺：

$$
\boxed{
\text{原本很長的計算現在只剩一步，
所以複雜度消失了。}
}
$$

本文主張，這個推論一般並不成立。

更準確的情況是：

$$
\boxed{
\text{計算複雜度可以下降，
也可以被壓縮、攤銷、外包、預付、空間化或重新分布。}
}
$$

因此，本文提出 **Complexity Displacement Principle，複雜度位移原則**：

> **當某一觀察邊界中的有效計算路徑縮短時，不應立即把消失的路徑成本視為不存在；必須檢查它是否已被轉移到另一個時間階段、空間結構、記憶、連接、provider、硬體、訓練、索引、驗證、維護或歷史形成成本中。**

本文區分六個最低成本邊界：

$$
\boxed{
C_{\mathrm{local}},
\quad
C_{\mathrm{online}},
\quad
C_{\mathrm{offline}},
\quad
C_{\mathrm{external}},
\quad
C_{\mathrm{lifecycle}},
\quad
C_{\mathrm{closed}}.
}
$$

其中：

- $C_{\mathrm{local}}$：當前 caller 直接承擔的成本；
- $C_{\mathrm{online}}$：一次 query / instance 在執行期的完整成本；
- $C_{\mathrm{offline}}$：query 前已支付的 preprocessing、training、indexing、compilation 等成本；
- $C_{\mathrm{external}}$：超出當前觀察者或子系統邊界，由外部 provider 承擔的成本；
- $C_{\mathrm{lifecycle}}$：建立、儲存、執行、驗證、維護、更新與淘汰能力的完整生命週期成本；
- $C_{\mathrm{closed}}$：在指定封閉系統邊界內，所有必要計算責任的總核算。

本文進一步區分：

$$
\boxed{
\text{Complexity Reduction}
\neq
\text{Complexity Displacement}
\neq
\text{Complexity Hiding}.
}
$$

真正的複雜度降低意味在一致 accounting boundary 下，總體所需資源下降；複雜度位移意味成本位置改變；複雜度隱藏則是觀察者因邊界選擇而不再看見成本。

本文亦將 database index、compiled binary、trained model、API、oracle、hardware accelerator、cache、library、Agent tool、MSSP–RDR capability 視為不同形式的 **Complexity-Carrying Structure**。

最終本文提出：

$$
\boxed{
\text{Temporal Complexity}
\leftrightarrow
\text{Spatial Complexity}
\leftrightarrow
\text{Historical Complexity}
\leftrightarrow
\text{Externalized Complexity}
}
$$

並指出，未來任何宣稱「超連接使困難問題變成 $O(1)$ 」的系統，都必須先回答：

$$
\boxed{
O(1)\text{ relative to which boundary?}
}
$$

這為 Paper 05「局部 $O(1)$ 不等於全域 $O(1)$ 」與後續封閉系統 P/NP 建立正式核算基礎。

**關鍵詞：** Complexity Displacement、計算複雜度、外包計算、預計算、攤銷、API、Oracle、超連接計算、封閉系統、Agentic P/NP

---

# 1. 一個最簡單的思想實驗

假設問題：

$$
q(x)
$$

原本需要：

$$
T(n)=2^n
$$

時間求解。

現在建立一個服務：

```text
answer = api.solve(x)
```

caller 只需要：

1. 傳送 $x$ ；
2. 等待結果；
3. 接收 $y$。

從 caller 的程式碼看：

$$
\boxed{
\text{one API call}.
}
$$

若把 API invocation 本身視為 primitive：

$$
C_{\mathrm{caller}}=O(1).
$$

但 provider 內部可能仍然執行：

$$
2^n.
$$

因此：

$$
\boxed{
O(1)_{\mathrm{caller}}
\not\Rightarrow
O(1)_{\mathrm{provider}}.
}
$$

更不推出：

$$
\boxed{
O(1)_{\mathrm{closed}}.
}
$$

這是本文所有討論的最小原型。

---

# 2. 「一步」本來就是相對的

Machine instruction：

```text
MUL R1, R2
```

在 instruction-set abstraction 中可以算一步。

但電晶體層面不是一步。

同樣：

```text
fft(x)
```

在 library abstraction 中是一個 call。

但其底層可能是：

$$
O(n\log n).
$$

API：

```text
translate(text)
```

在 caller 看來也是一步。

但 provider 可能調動數十億參數模型與分散式硬體。

因此：

$$
\boxed{
\operatorname{Step}_L
}
$$

必須相對於 abstraction layer：

$$
L.
$$

即：

$$
\boxed{
\operatorname{Step}_L(\Phi)=1
}
$$

不能推出：

$$
\operatorname{Step}_{L-1}(\Phi)=1.
$$

---

# 3. 第一個基本分離：Local Complexity

定義某一局部 actor：

$$
A
$$

執行任務：

$$
q.
$$

令：

$$
\boxed{
C_{\mathrm{local}}
(q\mid A)
}
$$

表示 actor 自身直接承擔的資源成本。

它可包括：

$$
C_{\mathrm{local}}
=
(
T,
S,
E,
B,
L,
I/O
).
$$

其中：

- $T$：時間；
- $S$：空間／記憶；
- $E$：能量；
- $B$：頻寬；
- $L$：latency；
- $I/O$：輸入輸出成本。

若 actor 只送一個 request：

$$
C_{\mathrm{local}}
$$

確實可能極低。

這是真實進步。

但它不是整個世界的成本。

---

# 4. 第二個分離：Online Complexity

對一次 query：

$$
q_i,
$$

定義：

$$
\boxed{
C_{\mathrm{online}}(q_i)
}
$$

為從 query 正式開始，到返回有效答案為止的必要成本。

它包括：

- routing；
- provider selection；
- execution；
- communication；
- result verification。

形式上：

$$
\boxed{
C_{\mathrm{online}}
=
C_{\mathrm{resolve}}
+
C_{\mathrm{route}}
+
C_{\mathrm{execute}}
+
C_{\mathrm{communicate}}
+
C_{\mathrm{verify}}.
}
$$

因此：

$$
C_{\mathrm{local}}
\leq
C_{\mathrm{online}}
$$

通常成立，但不必永遠嚴格。

---

# 5. 第三個分離：Offline Complexity

很多「瞬間完成」其實因為工作早已做完。

例如 database index。

沒有 index：

$$
C_{\mathrm{query}}
=
O(n).
$$

建立 index：

$$
C_{\mathrm{build}}
=
O(n\log n)
$$

後，query 可能：

$$
O(\log n)
$$

甚至某些 lookup 模型下近似：

$$
O(1).
$$

因此：

$$
\boxed{
\text{online speedup}
}
$$

可能來自：

$$
\boxed{
\text{offline cost}.
}
$$

定義：

$$
\boxed{
C_{\mathrm{offline}}
}
$$

包含：

- preprocessing；
- compilation；
- indexing；
- training；
- precomputation；
- cache formation；
- optimization；
- capability construction。

---

# 6. 第四個分離：External Complexity

現在考慮：

$$
A
$$

呼叫：

$$
B.
$$

對 $A$：

$$
C_A
$$

可能只有：

$$
O(1).
$$

但：

$$
B
$$

承擔：

$$
C_B.
$$

若 $B$ 位於：

- cloud；
- database service；
- remote agent；
- external laboratory；
- human expert；
- quantum backend；

則：

$$
\boxed{
C_{\mathrm{external}}
}
$$

必須被明確標示。

因此：

$$
\boxed{
C_{\mathrm{visible}}
\neq
C_{\mathrm{necessary}}.
}
$$

---

# 7. 第五個分離：Lifecycle Complexity

一個 capability：

$$
F
$$

不只存在於 execution moment。

它需要：

1. 設計；
2. 建造；
3. 測試；
4. 部署；
5. 呼叫；
6. 維護；
7. 更新；
8. 驗證；
9. 淘汰。

因此定義：

$$
\boxed{
C_{\mathrm{lifecycle}}(F)
=
C_{\mathrm{design}}
+
C_{\mathrm{construct}}
+
C_{\mathrm{validate}}
+
C_{\mathrm{deploy}}
+
C_{\mathrm{operate}}
+
C_{\mathrm{maintain}}
+
C_{\mathrm{migrate}}
+
C_{\mathrm{retire}}.
}
$$

對長期系統，這個成本可能比單次執行更重要。

---

# 8. 第六個分離：Closed-System Complexity

現在進入本文最重要的邊界。

指定一個 system boundary：

$$
\mathfrak B.
$$

若所有完成任務所必要的 computational responsibility 都必須被納入：

$$
\mathfrak B,
$$

則定義：

$$
\boxed{
C_{\mathrm{closed}}
(q\mid\mathfrak B).
}
$$

任何：

- remote provider；
- precompute；
- lookup table；
- model；
- human；
- external solver

若是任務成立的必要部分，

且被包含於：

$$
\mathfrak B,
$$

其成本都不能消失。

---

# 9. Complexity Boundary

因此每一個複雜度聲明都應附帶：

$$
\boxed{
\mathfrak B_C
}
$$

即：

# Complexity Accounting Boundary

例如：

$$
\mathfrak B_C
=
\text{caller only},
$$

或：

$$
\mathfrak B_C
=
\text{application + database},
$$

或：

$$
\mathfrak B_C
=
\text{whole distributed system}.
$$

於是：

$$
\boxed{
C(q\mid\mathfrak B_1)
\neq
C(q\mid\mathfrak B_2)
}
$$

完全正常。

---

# 10. 「快」本身沒有完整語義

若某系統宣稱：

> 這個問題現在可以在一毫秒內完成。

仍然需要問：

- preprocessing 花多久？
- database 多大？
- model training 花多少？
- external API 做了什麼？
- hardware 用多少 parallel resources？
- 是否每一個 instance 都需要新建結構？
- 結果驗證成本多少？

因此：

$$
\boxed{
\text{Latency}
\neq
\text{Complexity}.
}
$$

---

# 11. 複雜度位移原則

本文正式提出：

# Complexity Displacement Principle, CDP

令原計算：

$$
\mathcal P_0
$$

具有成本配置：

$$
\mathbf C_0.
$$

經 transformation：

$$
\Gamma
$$

後得到：

$$
\mathcal P_1,
$$

若某一資源或某一階段成本下降：

$$
C_k(\mathcal P_1)
<
C_k(\mathcal P_0),
$$

則在宣稱「複雜度降低」前，必須檢查是否存在其他成本項：

$$
C_j
$$

使：

$$
C_j(\mathcal P_1)
>
C_j(\mathcal P_0).
$$

因此：

$$
\boxed{
\Delta C_k<0
\not\Rightarrow
\Delta C_{\mathrm{total}}<0.
}
$$

---

# 12. 這不是守恆定律

本文不主張：

$$
C_{\mathrm{before}}
=
C_{\mathrm{after}}.
$$

真正演算法創新可以使：

$$
C_{\mathrm{after}}
<
C_{\mathrm{before}}.
$$

硬體創新也可以真的降低總能耗。

數學突破也可能真的消除冗餘搜索。

因此：

$$
\boxed{
\text{Complexity Displacement Principle}
\neq
\text{Complexity Conservation Law}.
}
$$

它只是核算紀律：

> 看見一部分成本下降時，不准直接假設所有成本都消失。

---

# 13. 三種情況必須分開

本文區分：

## 13.1 Genuine Complexity Reduction

在同一 accounting boundary 下：

$$
\boxed{
C_{\mathrm{new}}
<
C_{\mathrm{old}}.
}
$$

例如更好的 algorithm。

---

## 13.2 Complexity Displacement

總成本未必大幅改變，但分布位置不同：

$$
\boxed{
C_{\mathrm{online}}\downarrow,
\qquad
C_{\mathrm{offline}}\uparrow.
}
$$

---

## 13.3 Complexity Hiding

成本仍存在，只是不再被 observer 計入：

$$
\boxed{
C_{\mathrm{visible}}\downarrow,
\qquad
C_{\mathrm{closed}}
\text{ approximately unchanged}.
}
$$

這三者不能混同。

---

# 14. 從時間到空間

Paper 02 已提出 Computational Spatialization。

現在可正式寫：

$$
\boxed{
\text{Temporal Work}
\rightarrow
\text{Persistent Spatial Structure}.
}
$$

例如：

$$
\text{search}
\rightarrow
\text{index}.
$$

原本：

$$
x
\rightarrow
s_1
\rightarrow
\cdots
\rightarrow
y.
$$

後來：

$$
X_{\mathrm{index}}
$$

已經保存了某些 search structure。

所以 query：

$$
x
\rightarrow
\operatorname{locate}(y).
$$

這是：

# Temporal-to-Spatial Complexity Displacement

---

# 15. Spatial Complexity

定義：

$$
\boxed{
C_{\mathrm{spatial}}
}
$$

表示為了縮短未來 temporal path 而 materialize 的結構成本。

它可以包括：

- memory；
- index；
- lookup table；
- circuit；
- graph；
- routing table；
- cached result；
- embedding store；
- compiled executable。

因此：

$$
\boxed{
T\downarrow
\quad\text{may require}\quad
S\uparrow.
}
$$

這是典型 time–space trade-off。

---

# 16. 從搜索到記憶

若每次 query 都重新推理：

$$
C_{\mathrm{reason}}.
$$

第一次解完後保存：

$$
M(q)=y.
$$

之後：

$$
C_{\mathrm{lookup}}
\ll
C_{\mathrm{reason}}.
$$

因此：

$$
\boxed{
\text{Reasoning Complexity}
\rightarrow
\text{Memory Complexity}.
}
$$

這是任何具 persistent memory 的 Agent 都會遇到的現象。

---

# 17. Cache 是最純粹的複雜度位移

第一次：

$$
x
\xrightarrow{A}
y.
$$

成本：

$$
C_A.
$$

保存：

$$
(x,y)
$$

後，

下一次：

$$
x
\xrightarrow{\mathrm{cache}}
y.
$$

成本：

$$
C_{\mathrm{cache}}\ll C_A.
$$

但：

$$
C_A
$$

已經支付。

所以：

$$
\boxed{
\text{cached speed}
=
\text{historically prepaid computation}.
}
$$

---

# 18. Historical Complexity

本文定義：

$$
\boxed{
C_{\mathrm{history}}
}
$$

表示當前能力依賴、但已在過去支付的必要形成成本。

例如：

- algorithm discovery；
- mathematical proof；
- training；
- corpus construction；
- compiler engineering；
- hardware design；
- database creation。

這不是標準 complexity class 的替代物。

它是：

# capability formation accounting

---

# 19. 一個 FFT call 背後的歷史

今天：

```text
fft(x)
```

很短。

但它依賴：

$$
\boxed{
\text{mathematical discovery}
+
\text{algorithm design}
+
\text{implementation}
+
\text{optimization}.
}
$$

如果研究的是：

> 一個文明如何獲得 FFT 能力？

那麼：

$$
C_{\mathrm{history}}
$$

不能完全忽略。

如果研究的是：

> 已有 FFT library 時，一個 instance 的 asymptotic runtime？

那麼它可以忽略。

所以：

$$
\boxed{
\text{correct accounting depends on the research question}.
}
$$

---

# 20. 演算法複雜度與能力形成複雜度

因此區分：

$$
\boxed{
C_{\mathrm{execute}}(A,x)
}
$$

與：

$$
\boxed{
C_{\mathrm{form}}(A).
}
$$

經典 complexity theory 通常主要研究前者。

Agentic Computation 則不可避免碰到後者：

> 如何找到／建造 $A$？

所以：

$$
\boxed{
\text{Algorithmic Existence}
\neq
\text{Algorithmic Acquisition}.
}
$$

---

# 21. Training 是複雜度位移

模型：

$$
M_\theta
$$

訓練成本：

$$
C_{\mathrm{train}}.
$$

推理成本：

$$
C_{\mathrm{infer}}.
$$

常有：

$$
C_{\mathrm{train}}
\gg
C_{\mathrm{infer}}.
$$

因此：

$$
\boxed{
\text{Training}
}
$$

本質上把大量歷史 computation 壓入：

$$
\theta.
$$

所以：

$$
\boxed{
\theta
=
\text{a complexity-carrying state}.
}
$$

不是說參數「等於複雜度」。

而是其形成依賴歷史計算。

---

# 22. Model as Spatialized History

因此可以寫：

$$
\boxed{
X_{\mathrm{data}}
+
X_{\mathrm{optimization}}
\rightarrow
\theta
}
$$

再：

$$
\theta
+
x
\rightarrow
y.
$$

這是一個：

$$
\boxed{
\text{History}
\rightarrow
\text{State}
\rightarrow
\text{Cheap Reuse}
}
$$

結構。

---

# 23. 編譯也是一樣

Source：

$$
P
$$

經：

$$
C_{\mathrm{compile}}
$$

轉為 binary：

$$
B.
$$

之後每次執行：

$$
C_{\mathrm{run}}.
$$

因此：

$$
\boxed{
\text{Compilation}
=
\text{offline transformation for repeated online savings}.
}
$$

這是複雜度位移，不是幻覺。

---

# 24. Hardware Accelerator 是把演算法空間化到物理

假設 CPU 執行：

$$
A
$$

需要大量 primitive operations。

如果某硬體：

$$
H_A
$$

直接實現：

$$
A,
$$

則：

$$
\boxed{
\text{software path}
\rightarrow
\text{physical structure}.
}
$$

也就是：

# Algorithm-to-Hardware Spatialization

此時：

$$
C_{\mathrm{runtime}}\downarrow
$$

可能是真的。

但新增：

$$
C_{\mathrm{fabrication}},
C_{\mathrm{area}},
C_{\mathrm{energy}},
C_{\mathrm{design}}.
$$

---

# 25. FPGA、ASIC 與極致狀態通道

對固定算法：

$$
A,
$$

ASIC 可以讓：

$$
A
$$

高度固化。

從 high-level 看：

$$
1_A\rightarrow X_A
$$

非常短。

但：

$$
\boxed{
\text{short control path}
}
$$

依賴：

$$
\boxed{
\text{pre-existing physical geometry}.
}
$$

這正是 Paper 01 所說「狀態位置改變」。

---

# 26. 外包到另一台電腦

如果：

$$
A
$$

太昂貴，

caller 把它傳給 GPU server。

Local：

$$
C_{\mathrm{local}}\downarrow.
$$

Global：

$$
C_{\mathrm{global}}
$$

可能幾乎不變，

甚至增加 network overhead。

所以：

$$
\boxed{
\text{offloading}
\neq
\text{elimination}.
}
$$

---

# 27. 外包到人類也是同樣問題

Agent 遇到困難：

$$
q.
$$

直接：

$$
\text{AskHuman}(q).
$$

對 agent：

$$
C_{\mathrm{agent}}
$$

很低。

但：

$$
C_{\mathrm{human}}
$$

存在。

因此：

$$
\boxed{
\text{human-in-the-loop}
}
$$

也屬於 external complexity。

---

# 28. 外包到另一個 Agent

多 Agent：

$$
A_1
\rightarrow
A_2
\rightarrow
A_3.
$$

若只計：

$$
A_1,
$$

看起來很輕。

但真正：

$$
\boxed{
C_{\mathrm{federation}}
=
\sum_i C_{A_i}
+
C_{\mathrm{communication}}
+
C_{\mathrm{coordination}}.
}
$$

這對未來 Agentic P/NP 特別重要。

---

# 29. Oracle：理論上的極端外包

令 oracle：

$$
O_L(x)
$$

直接回答：

$$
x\in L?
$$

若 oracle call 計作一步，

則：

$$
\boxed{
C^{O_L}_{\mathrm{query}}=O(1).
}
$$

但這是：

$$
\boxed{
\text{oracle-relative complexity}.
}
$$

不能直接推出 ordinary machine complexity。

因此 oracle 是 Complexity Boundary 的經典極端案例。

---

# 30. API 是工程世界中的準 Oracle

API 與 formal oracle 不完全相同。

API 有：

- latency；
- failure；
- billing；
- provider；
- version；
- implementation；
- finite hardware。

但從 caller abstraction 看：

$$
\boxed{
\text{API}
\approx
\text{operational oracle-like interface}.
}
$$

所以本文稱：

# Operational Externalization

---

# 31. 極致 MSSP–RDR 的本質

Paper 03 已提出：

$$
\text{Intent}
\rightarrow
\text{Resolve}
\rightarrow
\text{Select / Construct}
\rightarrow
\text{Execute}.
$$

如果每個 capability：

$$
A_i
$$

都有 address：

$$
1_i,
$$

caller 可以：

$$
1_i\rightarrow A_i.
$$

這會大幅降低：

$$
C_{\mathrm{local-route}}.
$$

但：

$$
A_i
$$

真正成本仍在。

所以：

$$
\boxed{
\text{MSSP--RDR can collapse coordination distance
without necessarily collapsing execution complexity}.
}
$$

---

# 32. Coordination Complexity

這引出一個獨立成本：

$$
\boxed{
C_{\mathrm{coord}}
}
$$

大型系統的問題可能不是 solver 本身慢，

而是：

- 找不到 solver；
- 不知道誰能做；
- interface 不一致；
- resource 不知道在哪；
- permission 不清楚；
- version 不一致。

MSSP–RDR 可以真正降低：

$$
C_{\mathrm{coord}}.
$$

這是一種真正的複雜度降低。

---

# 33. 不是所有位移都代表沒進步

這點很重要。

假設原來：

$$
C_{\mathrm{total}}
=
C_{\mathrm{solve}}
+
C_{\mathrm{coord}}.
$$

建立 MSSP–RDR 後：

$$
C'_{\mathrm{coord}}
\ll
C_{\mathrm{coord}}.
$$

即使：

$$
C'_{\mathrm{solve}}
=
C_{\mathrm{solve}},
$$

仍有：

$$
C'_{\mathrm{total}}
<
C_{\mathrm{total}}.
$$

所以超連接本身可以產生真實效率增益。

---

# 34. 真正要反對的是錯誤歸因

不應說：

> 「因為 API 呼叫是 $O(1)$，所以問題本身已變成 $O(1)$。」

但可以說：

> 「因為 capability 已被 addressable 化，caller 的 routing / invocation complexity 接近常數。」

兩者差別巨大。

因此：

$$
\boxed{
\text{Precise Complexity Attribution}
}
$$

是本文的核心紀律。

---

# 35. Complexity Vector

本文不建議立刻把所有成本壓成單一 scalar。

定義：

$$
\boxed{
\mathbf C
=
(
T,
S,
E,
B,
L,
H,
P,
V,
M
)
}
$$

其中：

- $T$：time；
- $S$：space；
- $E$：energy；
- $B$：bandwidth / hardware；
- $L$：latency；
- $H$：historical/preprocessing cost；
- $P$：provider / external dependency；
- $V$：verification；
- $M$：maintenance。

不同方案可能：

$$
T_1<T_2,
$$

但：

$$
S_1>S_2.
$$

所以不存在天然總序。

---

# 36. Pareto Complexity

對兩方案：

$$
A,B,
$$

若：

$$
\mathbf C_A
\preceq
\mathbf C_B
$$

且至少一維嚴格較小，

則：

$$
A
$$

Pareto-dominates：

$$
B.
$$

否則可能只是不同 trade-off。

因此：

$$
\boxed{
\text{better computation}
}
$$

不總能壓成單一「更快」。

---

# 37. Complexity Displacement Matrix

本文提出第一版位移矩陣：

$$
\boxed{
D_{ij}
}
$$

表示複雜度從成本類型 $i$ 移向 $j$ 的程度。

例如：

$$
D_{\mathrm{time}\rightarrow\mathrm{space}}
$$

表示 time–space displacement。

$$
D_{\mathrm{online}\rightarrow\mathrm{offline}}
$$

表示 preprocessing。

$$
D_{\mathrm{local}\rightarrow\mathrm{external}}
$$

表示 outsourcing。

$$
D_{\mathrm{execution}\rightarrow\mathrm{history}}
$$

表示 capability formation。

---

# 38. 常見位移類型

本文整理至少八種：

### 1. Time → Space

$$
\text{search}
\rightarrow
\text{index}.
$$

### 2. Online → Offline

$$
\text{runtime work}
\rightarrow
\text{precomputation}.
$$

### 3. Local → External

$$
\text{local solve}
\rightarrow
\text{API/provider}.
$$

### 4. Execution → Hardware

$$
\text{software steps}
\rightarrow
\text{physical circuit}.
$$

### 5. Search → Memory

$$
\text{recompute}
\rightarrow
\text{cache}.
$$

### 6. Discovery → Reuse

$$
\text{algorithm invention}
\rightarrow
\text{library call}.
$$

### 7. Human → Agent

$$
\text{manual reasoning}
\rightarrow
\text{automated capability}.
$$

### 8. Primitive Path → Macro Transition

$$
e_1,\ldots,e_n
\rightarrow
e_\Phi.
$$

---

# 39. 複雜度可以多次搬家

例如：

$$
\text{human research}
\rightarrow
\text{algorithm}
\rightarrow
\text{source code}
\rightarrow
\text{compiler}
\rightarrow
\text{binary}
\rightarrow
\text{hardware cache}
\rightarrow
\text{API}.
$$

每一步都可能重新配置成本。

因此：

$$
\boxed{
\text{complexity displacement is compositional}.
}
$$

---

# 40. Complexity Lineage

定義：

$$
\boxed{
\mathcal L_C(F)
}
$$

為 capability $F$ 的 complexity lineage。

例如：

$$
\mathcal L_C(F)
=
(
\text{discovery},
\text{formalization},
\text{training},
\text{build},
\text{deployment},
\text{inference}
).
$$

這對 AI-native systems 很重要。

因為當下的一個 tool call 可能承載多年歷史。

---

# 41. 一個符號可以承載多少歷史？

Paper 02 的：

$$
1\rightarrow X
$$

現在可以再補：

$$
\boxed{
1_i
\rightarrow
(
X_i,
\mathcal L_C(X_i)
).
}
$$

也就是 address 不只指向能力。

它也可以指向其：

- provenance；
- construction；
- cost；
- version；
- verification。

未來 MSSP capability manifest 可以直接承載這些資訊。

---

# 42. Complexity-Carrying Structure

本文定義：

> 若一個持久結構 $S$ 的存在使未來某類 query 的必要 online computation 系統性降低，且 $S$ 本身需要非零形成／維護成本，則稱 $S$ 為 Complexity-Carrying Structure。

形式上：

若：

$$
C_{\mathrm{online}}(q\mid S)
<
C_{\mathrm{online}}(q\mid \varnothing),
$$

且：

$$
C_{\mathrm{form}}(S)>0,
$$

則：

$$
\boxed{
S
\in
\mathfrak S_C.
}
$$

---

# 43. Complexity-Carrying Structures 的例子

包括：

- lookup table；
- database index；
- compiled binary；
- trained model；
- cache；
- proof library；
- hardware accelerator；
- routing table；
- ontology；
- capability registry；
- precomputed embedding；
- theorem database。

所以：

$$
\boxed{
\text{memory is not just passive storage}.
}
$$

它可以承載已支付的計算。

---

# 44. 知識本身可以承載複雜度

如果不知道：

$$
k,
$$

要搜尋：

$$
2^n
$$

狀態。

如果知道一個 theorem：

$$
T,
$$

直接把空間縮到：

$$
n^3.
$$

則：

$$
T
$$

也是 Complexity-Carrying Structure。

所以：

$$
\boxed{
\text{knowledge can alter effective computational geometry}.
}
$$

---

# 45. 這與 Agentic P/NP 的關係

經典：

$$
\exists A
$$

問 algorithm 是否存在。

Agentic 問：

$$
\boxed{
\Sigma_t
\rightarrow
A
}
$$

要花多少成本？

如果：

$$
A
$$

已在 registry：

$$
C_{\mathrm{discover}}\approx0.
$$

如果不存在：

$$
C_{\mathrm{discover}}
$$

可能極高。

因此：

$$
\boxed{
C_{\mathrm{agent}}
=
C_{\mathrm{acquire}}
+
C_{\mathrm{execute}}.
}
$$

---

# 46. Solver Generation Complexity

定義：

$$
\boxed{
C_{\mathrm{gen}}(A\mid q,\Sigma_t)
}
$$

表示 agent 在狀態：

$$
\Sigma_t
$$

下為任務 $q$ 生成 solver $A$ 的成本。

則總成本：

$$
\boxed{
C_{\mathrm{agent}}
=
C_{\mathrm{gen}}
+
C_{\mathrm{execute}}
+
C_{\mathrm{verify}}.
}
$$

這將在 Paper 08 正式展開。

---

# 47. 如果 solver 已經存在

如果：

$$
A\in\mathcal A_t,
$$

則：

$$
C_{\mathrm{gen}}\approx0.
$$

這就是歷史累積造成的：

# Historical Acceleration

即：

$$
\boxed{
\mathcal A_{t+1}
\supset
\mathcal A_t
}
$$

可使未來：

$$
C_{\mathrm{online}}
$$

下降。

---

# 48. Amortized Complexity

如果 capability：

$$
F
$$

建立成本：

$$
C_{\mathrm{build}},
$$

未來被使用：

$$
N
$$

次，

每次：

$$
C_{\mathrm{run}},
$$

則：

$$
\boxed{
C_{\mathrm{total}}^{(N)}
=
C_{\mathrm{build}}
+
\sum_{i=1}^{N}C_{\mathrm{run},i}
+
C_{\mathrm{maintain}}.
}
$$

平均：

$$
\boxed{
\overline C_N
=
\frac{
C_{\mathrm{total}}^{(N)}
}{N}.
}
$$

若：

$$
N\rightarrow\infty,
$$

offline build cost 可被攤薄。

---

# 49. 所以位移可以帶來真實長期改善

若：

$$
C_{\mathrm{build}}
$$

雖大，

但：

$$
C_{\mathrm{run}}
$$

極小，

且使用次數足夠多，

則：

$$
\overline C_N
$$

確實可能遠低於每次重新求解。

因此：

$$
\boxed{
\text{displacement}
}
$$

不是貶義詞。

它可能是工程進步的主要形式。

---

# 50. 但 worst-case 仍不能消失

即使：

$$
\mathbb E[C]\ll C_{\mathrm{worst}},
$$

對：

- safety-critical；
- security-critical；
- proof-critical；

任務，

仍需追蹤：

$$
C_{\mathrm{worst}}.
$$

因此：

$$
\boxed{
\text{amortized tractability}
\neq
\text{worst-case tractability}.
}
$$

---

# 51. 封閉有限世界的極端情況

假設：

$$
D_N
=
\{x_1,\ldots,x_M\}
$$

是固定有限 domain。

若預先建立：

$$
T[x_i]=y_i,
$$

則 query：

$$
T[x_i]
$$

可近似常數查找。

所以：

$$
\boxed{
C_{\mathrm{online}}=O(1)
}
$$

可以成立。

但：

$$
C_{\mathrm{offline}}
$$

可能：

$$
\Omega(M).
$$

如果：

$$
M=2^n,
$$

則：

$$
C_{\mathrm{offline}}
$$

可能 exponential。

---

# 52. 這就是 P/NP 思維實驗的第一個核心

在有限封閉世界：

$$
\boxed{
\text{任何有限函數都可理論上被完全表格化}.
}
$$

因此 query：

$$
O(1)
$$

並不奇怪。

真正問題不是：

> 查表能不能快？

而是：

$$
\boxed{
\text{這個 table 如何被 uniform 地建立？}
}
$$

以及：

$$
\boxed{
\text{其 size 如何隨 }n\text{ 成長？}
}
$$

---

# 53. Nonuniformity

如果對每個 input size：

$$
n
$$

都外部提供一個巨大 state：

$$
S_n,
$$

且 runtime 只需 lookup，

則：

$$
\boxed{
\text{cheap online solve}
}
$$

可能來自：

$$
\boxed{
\text{nonuniform advice}.
}
$$

因此：

$$
\forall n\exists S_n
$$

不等於：

$$
\exists G\forall n.
$$

這會在 P/NP 篇正式處理。

---

# 54. Complexity Displacement 與 Quantifier

其實位移問題最終會碰到：

$$
\forall x\exists S_x
$$

與：

$$
\exists S\forall x
$$

的差異。

如果每一個 instance 都可以被個別預算，

不代表存在一個統一 tractable solver。

所以：

$$
\boxed{
\text{instance-wise spatialization}
\neq
\text{uniform complexity collapse}.
}
$$

---

# 55. Verification 也可能成為外包成本

系統可以快速產生答案：

$$
y.
$$

但若 verification：

$$
V(x,y)
$$

非常昂貴，

總體：

$$
C_{\mathrm{closed}}
$$

仍高。

因此：

$$
\boxed{
\text{Solve Cost}
\neq
\text{Completion Cost}.
}
$$

這與 UCPNP / GLC 的思想直接一致。

---

# 56. Completion Complexity

定義：

$$
\boxed{
C_{\mathrm{complete}}
=
C_{\mathrm{solve}}
+
C_{\mathrm{verify}}
+
C_{\mathrm{commit}}.
}
$$

如果需要：

- evidence；
- proof；
- provenance；
- rollback；
- consistency；

還需加入相應成本。

所以：

$$
\boxed{
\text{answer found}
\neq
\text{task completed}.
}
$$

---

# 57. Complexity Debt

如果某系統為了快速返回結果而省略：

- validation；
- consistency；
- migration；
- documentation；

則當下：

$$
C_{\mathrm{online}}\downarrow.
$$

但未來可能形成：

$$
\boxed{
C_{\mathrm{debt}}>0.
}
$$

這可以稱：

# Complexity Debt

它與 software technical debt 類似，但更一般。

---

# 58. Hidden Complexity Debt

例如：

```text
quick hack
```

當下成本低。

未來每次修改都必須繞過它。

於是：

$$
C_{\mathrm{maintain}}(t)
\uparrow.
$$

因此：

$$
\boxed{
\text{short-term complexity reduction}
}
$$

可以是：

$$
\boxed{
\text{long-term displacement into maintenance}.
}
$$

---

# 59. 超連接系統尤其容易產生 Complexity Debt

如果系統不斷新增：

- API；
- bridge；
- adapter；
- tool；
- capability；

但缺乏治理，

則：

$$
|E|\uparrow
$$

同時：

$$
C_{\mathrm{route}},
C_{\mathrm{verify}},
C_{\mathrm{maintain}}
\uparrow.
$$

所以：

$$
\boxed{
\text{connectivity growth}
}
$$

存在負收益區域。

---

# 60. Hyperconnection Saturation

定義候選：

若新增 edge：

$$
e
$$

造成：

$$
\Delta d_{\mathrm{eff}}<0
$$

但：

$$
\Delta C_{\mathrm{maintain}}
+
\Delta C_{\mathrm{route}}
>
|\Delta C_{\mathrm{solve}}|,
$$

則該 edge 對指定 workload 未產生淨收益。

這可以形成：

# Hyperconnection Saturation

---

# 61. 不是越連越好

因此：

$$
\boxed{
\text{Maximum Connectivity}
\neq
\text{Optimal Computation}.
}
$$

更合理是：

$$
\boxed{
\text{Optimal Addressable Connectivity}.
}
$$

即只建立：

- 高價值；
- 可驗證；
- 可維護；
- 常用；
- 可組合

的通道。

---

# 62. Complexity Placement

本文因此提出一個新問題：

> **計算應該放在哪裡？**

不是只問：

$$
\text{Which algorithm?}
$$

而是：

$$
\boxed{
\text{Where should the complexity live?}
}
$$

可以放在：

- runtime；
- memory；
- hardware；
- network；
- training；
- provider；
- human；
- history。

---

# 63. 這是 GCM 的自然接口

Global Computation Methodology 本來就問：

- where to compute；
- how to compute；
- at what resolution；
- under which transition law。

本文再加入：

$$
\boxed{
\text{where to place complexity}.
}
$$

因此未來 scheduler 不只配置算力。

還可以配置：

$$
\boxed{
\text{complexity location}.
}
$$

---

# 64. Complexity Placement Policy

定義：

$$
\boxed{
\mathsf{Place}_C
:
(
q,
\mathfrak C_t,
B,
H
)
\rightarrow
\mathcal P_C
}
$$

其中：

$$
\mathcal P_C
$$

是 complexity placement plan。

例如：

```text
precompute locally
cache in NAS
dispatch inference to GPU
verify locally
archive proof externally
```

這就是實際工程中的複雜度配置。

---

# 65. 動態複雜度配置

若 workload 改變：

$$
\mathcal D_Q(t),
$$

最優 placement 也可能改變。

例如：

低頻 query：

$$
\text{compute on demand}.
$$

高頻 query：

$$
\text{precompute/cache}.
$$

因此：

$$
\boxed{
\mathsf{Place}_C(t)
\neq
\mathsf{Place}_C(t+1).
}
$$

---

# 66. Complexity Migration

當 capability 從 cloud 移到 local accelerator：

$$
C_{\mathrm{external}}
\rightarrow
C_{\mathrm{local}}.
$$

當 local DB 搬到 cloud：

$$
C_{\mathrm{local}}
\rightarrow
C_{\mathrm{external}}.
$$

因此：

# Complexity Migration

可以被直接觀測。

---

# 67. 複雜度位置本身是一個狀態

定義：

$$
\boxed{
\Lambda_C(t)
}
$$

表示複雜度在系統各層的分布。

例如：

$$
\Lambda_C
=
(
C_{\mathrm{local}},
C_{\mathrm{offline}},
C_{\mathrm{memory}},
C_{\mathrm{provider}},
C_{\mathrm{history}},
C_{\mathrm{verify}}
).
$$

計算架構演化可以寫成：

$$
\boxed{
\Lambda_C(t)
\rightarrow
\Lambda_C(t+1).
}
$$

---

# 68. Complexities Do Not Simply Vanish under Abstraction

如果 abstraction：

$$
\alpha
$$

把：

$$
x_0\rightarrow\cdots\rightarrow x_n
$$

視為：

$$
x_0\xrightarrow{\Phi}x_n,
$$

則：

$$
\boxed{
\alpha
}
$$

改變的是觀察粒度。

不能單靠：

$$
|\pi_\alpha|=1
$$

推出底層 work 為 1。

因此：

$$
\boxed{
\text{abstraction collapse}
\neq
\text{resource collapse}.
}
$$

---

# 69. 但 abstraction 可以真實改變算法

反過來也不能過度保守。

新的 representation：

$$
R'
$$

可能真的讓問題更容易。

例如：

$$
C(q\mid R')
<
C(q\mid R).
$$

這時不是單純 hiding。

而是：

# Representation-Induced Complexity Reduction

所以本文不否定 representation power。

只是要求：

$$
\boxed{
\text{prove where the gain comes from}.
}
$$

---

# 70. Task Identity Firewall

如果：

$$
q
$$

被改成：

$$
q',
$$

且：

$$
q'\not\equiv q,
$$

即使：

$$
C(q')\ll C(q),
$$

也不能說：

$$
q
$$

變簡單了。

因此任何 complexity displacement 都應附帶：

$$
\boxed{
\mathfrak I_q
}
$$

Task Identity Contract。

只有：

$$
q'\equiv_{\mathfrak I_q}q
$$

時，才能比較。

---

# 71. Bypass 與真正改善

如果：

$$
q
$$

要求 exact solution，

而：

$$
q'
$$

只要求 approximation，

則：

$$
C(q')<C(q)
$$

不代表 exact problem 改善。

但若 task 原本就只要求 functional terminal state，

則 bypass 可以合法。

因此：

$$
\boxed{
\text{complexity reduction is contract-relative}.
}
$$

---

# 72. 第一個主命題：Boundary Relativity

## Complexity Boundary Relativity Proposition

對同一任務：

$$
q,
$$

存在 boundaries：

$$
\mathfrak B_1\subset\mathfrak B_2
$$

使：

$$
\boxed{
C(q\mid\mathfrak B_1)
<
C(q\mid\mathfrak B_2).
}
$$

因此任何 complexity claim 若未聲明 accounting boundary，可能不完整。

---

# 73. 第二個主命題：Displacement Non-Implication

若：

$$
C_i'\!<C_i,
$$

則一般不能推出：

$$
\boxed{
\sum_jC'_j
<
\sum_jC_j.
}
$$

尤其當資源不可直接標量相加時，更應使用 vector / Pareto accounting。

---

# 74. 第三個主命題：Spatialization Principle

若 persistent structure：

$$
S
$$

使：

$$
C_{\mathrm{online}}(q\mid S)
<
C_{\mathrm{online}}(q),
$$

則至少部分 online complexity 已被：

- 消除；
- 或轉移至 $S$ 的形成／維護。

若：

$$
C_{\mathrm{form}}(S)>0,
$$

則存在 displacement component。

---

# 75. 第四個主命題：Externalization Principle

若 subsystem：

$$
A
$$

將必要工作交給：

$$
B,
$$

則：

$$
C_A\downarrow
$$

不推出：

$$
C_{A\cup B}\downarrow.
$$

因此：

$$
\boxed{
\text{outsourcing efficiency}
}
$$

與：

$$
\boxed{
\text{global complexity reduction}
}
$$

必須分離。

---

# 76. 第五個主命題：Historical Acceleration Principle

若：

$$
H_{t+1}\supset H_t
$$

且新增 reusable structures 使：

$$
C_{\mathrm{online}}
(
q\mid H_{t+1}
)
<
C_{\mathrm{online}}
(
q\mid H_t
),
$$

則可稱：

$$
\boxed{
\text{Historical Acceleration}.
}
$$

其成本不必在每次 query 重新支付。

---

# 77. 第六個主命題：Closed-System Accountability

若能力：

$$
F
$$

對任務：

$$
q
$$

必要，

則在把 $F$ 納入 closed boundary 後：

$$
\boxed{
C_F
}
$$

不得因 interface abstraction 而被忽略。

這是本文最核心的 audit rule。

---

# 78. Complexity Accounting Ledger

未來工程應為每一 capability 建立：

```text
Capability
├─ build_cost
├─ training_cost
├─ precompute_cost
├─ storage_cost
├─ invocation_cost
├─ provider_cost
├─ communication_cost
├─ verification_cost
├─ maintenance_cost
├─ migration_cost
└─ amortization_profile
```

即：

# Complexity Accounting Ledger, CAL

---

# 79. CAL 與 MSSP–RDR

MSSP capability entry 不只描述：

- What；
- type；
- provider。

還可以記：

$$
\boxed{
\mathbf C(F).
}
$$

RDR 在 dispatch 時可比較：

$$
F_1,F_2,\ldots,F_n
$$

的：

- latency；
- energy；
- external dependency；
- verification；
- historical amortization。

於是：

$$
\boxed{
\text{routing}
}
$$

開始具有真正 complexity awareness。

---

# 80. Complexity-Aware RDR

未來：

$$
RDR(q)
$$

不只問：

> 哪個 provider 可以跑？

而是：

$$
\boxed{
\arg\min_{F_i}
\mathcal J
(
\mathbf C(F_i),
q,
B,
\mathrm{Risk}
).
}
$$

其中：

$$
\mathcal J
$$

是 task-relative objective。

---

# 81. 不能預設所有資源可換算

例如：

$$
1\text{ Joule}
$$

與：

$$
1\text{ GB}
$$

沒有天然 universal exchange rate。

所以：

$$
\mathcal J
$$

是政策／任務相對。

本文不主張存在：

$$
\boxed{
C_{\mathrm{ultimate scalar}}.
}
$$

---

# 82. 複雜度位移與狀態張力

先前提出：

$$
\boldsymbol\Theta
$$

描述 system state-transition capacity。

現在可看到：

$$
\boldsymbol\Theta\uparrow
$$

往往代表系統能把更多原本 online temporal work：

$$
T
$$

搬進：

- memory；
- parallelism；
- hardware；
- provider；
- history。

所以：

$$
\boxed{
\text{higher state-transition capacity}
}
$$

部分來自：

$$
\boxed{
\text{better complexity placement}.
}
$$

---

# 83. 486 與現代計算機思想實驗

假設同一 algorithm：

$$
A
$$

可以在 486 上跑。

理論可計算性上：

$$
A
$$

可能存在。

但現代系統擁有：

- larger memory；
- GPU；
- network；
- compiler；
- libraries；
- cache；
- APIs；
- pre-trained models。

因此現代系統的：

$$
\Lambda_C
$$

完全不同。

很多以前需要：

$$
\text{local sequential compute}
$$

的工作，

現在可轉為：

$$
\text{parallel}
+
\text{cached}
+
\text{external}
+
\text{precomputed}.
$$

所以：

$$
\boxed{
\text{hardware evolution}
}
$$

也是：

$$
\boxed{
\text{complexity-placement evolution}.
}
$$

---

# 84. 給 486 最佳答案不等於 486 具有現代能力

若現代文明先算出：

$$
y
$$

再把：

$$
y
$$

交給 486，

486 可以：

$$
O(1)
$$

輸出。

但：

$$
\boxed{
C_{\mathrm{486,local}}\approx O(1)
}
$$

不能推出：

$$
\boxed{
C_{\mathrm{486,closed}}\approx O(1).
}
$$

因為：

$$
C_{\mathrm{modern-civilization}}
$$

被外包了。

---

# 85. 知道最短路不等於自己找得到最短路

若：

$$
\pi^\star(x)
$$

已知，

執行成本可能很低。

但：

$$
C_{\mathrm{discover}}(\pi^\star)
$$

可能高。

因此：

$$
\boxed{
C_{\mathrm{execute}}(\pi^\star)
\neq
C_{\mathrm{find}}(\pi^\star).
}
$$

這是 Agentic P/NP 的重要前提。

---

# 86. 複雜度位移與 solver state

如果 solver：

$$
\Sigma^\star
$$

已經包含大量訓練、推理與算法結構，

則：

$$
x
\xrightarrow{\Sigma^\star}
y
$$

可以很短。

但需要問：

$$
\boxed{
\Sigma_0
\rightarrow
\Sigma^\star
}
$$

成本多少？

因此：

$$
\boxed{
\text{path complexity can be absorbed into solver-state formation}.
}
$$

---

# 87. Solver-State Complexity

定義：

$$
\boxed{
C_{\mathrm{state}}
(
\Sigma^\star
)
}
$$

表示建立一個足以支持指定能力的 solver state 所需成本。

它可以包含：

- training；
- memory；
- algorithms；
- tools；
- hardware；
- knowledge；
- connections。

於是：

$$
\boxed{
C_{\mathrm{solve}}
(
x\mid\Sigma^\star
)
}
$$

與：

$$
\boxed{
C_{\mathrm{state}}
(
\Sigma^\star
)
}
$$

必須分開。

---

# 88. Instance-Time Complexity 與 Solver-State Complexity

這是本文另一個重要分離：

$$
\boxed{
\text{Instance-Time Complexity}
\neq
\text{Solver-State Complexity}.
}
$$

一個 civilization 可能花：

$$
10^6
$$

年建立：

$$
\Sigma^\star,
$$

之後每個 instance 一秒完成。

這對 civilization engineering 很有價值。

但不能把前者從理論上直接抹掉。

---

# 89. 這正是「計算被外包到外部」的更一般形式

外部不一定是另一台機器。

也可以是：

- 過去；
- 記憶；
- 硬體；
- architecture；
- algorithm registry；
- civilization knowledge。

因此：

$$
\boxed{
\text{Externalization}
}
$$

應廣義理解為：

> 把當下 query 不再直接承擔的必要計算責任放入另一個狀態位置。

---

# 90. Complexity Location

定義一個成本定位函數：

$$
\boxed{
\ell_C(c)
\in
\{
\text{online},
\text{offline},
\text{memory},
\text{hardware},
\text{history},
\text{external},
\text{verification}
\}.
}
$$

複雜度位移就是：

$$
\boxed{
\ell_C^{(t)}
\rightarrow
\ell_C^{(t+1)}.
}
$$

---

# 91. 路徑被壓成結構

本文現在可以把 Paper 02 的核心句正式升級為：

$$
\boxed{
\text{When a computational path is compressed into a reusable structure,
part of its temporal burden becomes structural state.}
}
$$

中文：

> **當計算路徑被壓縮為可重用結構時，其部分時間負擔會轉化為結構狀態。**

---

# 92. 結構狀態可以被複製

一個 algorithm：

$$
A
$$

一旦被寫成 code，

可以：

$$
\mathrm{Copy}(A).
$$

這意味：

$$
C_{\mathrm{discover}}
$$

不必由每個使用者重新支付。

這是文明級效率最重要的來源之一。

---

# 93. Complexity Replication Asymmetry

建立一個 capability：

$$
C_{\mathrm{build}}\gg1,
$$

但複製：

$$
C_{\mathrm{copy}}\ll C_{\mathrm{build}}.
$$

因此：

$$
\boxed{
\text{Knowledge / software has asymmetric formation and replication cost}.
}
$$

這使文明可以持續積累可重用計算。

---

# 94. 這就是為什麼超連接文明會越來越強

每一代新增：

$$
A_{new},
$$

之後：

$$
A_{new}
$$

可被所有未來系統直接 reuse。

所以：

$$
\mathcal A_t
\subseteq
\mathcal A_{t+1}.
$$

如果維護良好，

歷史形成：

$$
\boxed{
\text{a growing bank of prepaid computation}.
}
$$

---

# 95. 但 capability 也會失效

因此不是單調：

$$
\mathcal A_t\subseteq\mathcal A_{t+1}
$$

永遠成立。

可能：

- provider removed；
- dependency incompatible；
- proof invalidated；
- security revoked；
- hardware obsolete。

所以：

$$
\boxed{
\mathcal A_{t+1}
=
(
\mathcal A_t
+
A_{\mathrm{new}}
)
-
A_{\mathrm{invalid}}.
}
$$

---

# 96. Maintenance Is Computation

維持 address：

$$
1_i\rightarrow X_i
$$

長期有效，

需要：

- version migration；
- compatibility；
- tests；
- security；
- data refresh。

所以：

$$
\boxed{
\text{connection maintenance itself consumes computation}.
}
$$

這是超連接系統不能忽略的成本。

---

# 97. Complexity Displacement Failure

如果：

$$
C_{\mathrm{online}}\downarrow
$$

但：

$$
C_{\mathrm{maintain}}\uparrow\uparrow
$$

到超過收益，

則 displacement 不值得。

這是可測工程問題。

---

# 98. Net Complexity Benefit

對 workload：

$$
Q_N
$$

定義：

$$
\boxed{
\Delta C_{\mathrm{net}}
=
C_{\mathrm{baseline}}^{(N)}
-
C_{\mathrm{new}}^{(N)}.
}
$$

若：

$$
\Delta C_{\mathrm{net}}>0,
$$

新架構有淨收益。

若：

$$
\Delta C_{\mathrm{net}}<0,
$$

則只是看起來更漂亮。

---

# 99. 多資源版本

因資源不可全部相加，

可改用：

$$
\boxed{
\Delta\mathbf C
=
\mathbf C_{\mathrm{baseline}}
-
\mathbf C_{\mathrm{new}}.
}
$$

再用 task policy：

$$
U_q(\Delta\mathbf C)
$$

判斷是否有實際改善。

---

# 100. 本文不宣稱「複雜度一定守恆」

再強調一次：

好的 algorithm 可以真的讓：

$$
T(n)
:
2^n
\rightarrow
n^3.
$$

這不是單純 displacement。

因此 CDP 不是：

> 困難永遠不會消失。

而是：

> 在你宣稱困難消失前，把帳算完整。

---

# 101. 第一部分與第二部分的轉折

前三篇研究：

$$
\boxed{
\text{How to shorten effective transition distance?}
}
$$

本文開始研究：

$$
\boxed{
\text{What happens to the cost when distance is shortened?}
}
$$

所以整個系列正式從：

# Computational Space

進入：

# Complexity Displacement

---

# 102. 下一篇的核心

Paper 05 將把本文最重要的一個特例單獨抽出：

$$
\boxed{
O(1)_{\mathrm{local}}
\neq
O(1)_{\mathrm{global}}.
}
$$

並正式比較：

- API；
- oracle；
- lookup；
- precomputation；
- advice；
- trained model；
- external agent；
- remote hardware。

最終建立：

# Local Constant-Time Illusion

與：

# Global Complexity Accounting

之間的邊界。

---

# 103. 結論

超連接計算最容易製造一個錯覺：

$$
\boxed{
\text{如果所有能力都能用一個符號呼叫，
是不是所有計算都已經變成 }O(1)?
}
$$

本文的答案是：

$$
\boxed{
\text{不一定。}
}
$$

一個符號：

$$
1_i
$$

可以真的把 caller 的操作縮成一步。

一個 API 可以真的把本地實作成本降到近乎零。

一個 index 可以真的把 query 從 linear search 降成 logarithmic 或 constant-like lookup。

一個 trained model 可以真的把昂貴的歷史學習壓縮成快速 inference。

一個 ASIC 可以真的把大量 software operations 固化成高速物理轉換。

這些都是真實進步。

但是：

$$
\boxed{
\text{caller 看不到的成本，
不因此停止存在。}
}
$$

所以本文提出：

$$
\boxed{
\textbf{Complexity Displacement Principle}
}
$$

作為超連接計算的第一條核算紀律：

> **當一段計算路徑縮短時，先檢查原有複雜度是否被真正降低，還是被搬到了空間、記憶、硬體、預處理、歷史、provider、驗證或維護。**

因此：

$$
\boxed{
\text{Complexity Reduction}
\neq
\text{Complexity Displacement}
\neq
\text{Complexity Hiding}.
}
$$

完整計算至少需要區分：

$$
\boxed{
C_{\mathrm{local}},
C_{\mathrm{online}},
C_{\mathrm{offline}},
C_{\mathrm{external}},
C_{\mathrm{lifecycle}},
C_{\mathrm{closed}}.
}
$$

而一個真正成熟的 Hyperconnected Runtime，最終不應只知道：

> 「哪個能力可以被叫到？」

還應知道：

> 「呼叫這個能力，究竟把成本放到了哪裡？」

因此未來計算排程會從：

$$
\boxed{
\text{Where to Compute?}
}
$$

進一步變成：

$$
\boxed{
\text{Where Should the Complexity Live?}
}
$$

這也是 GCM、MSSP–RDR、PCMT 與 Agentic P/NP 開始真正合流的地方。

---

## 本篇核心公式總結

$$
\boxed{
C_{\mathrm{local}}
\neq
C_{\mathrm{closed}}
}
$$

$$
\boxed{
C_{\mathrm{online}}
\neq
C_{\mathrm{offline}}
}
$$

$$
\boxed{
C_{\mathrm{visible}}
\neq
C_{\mathrm{necessary}}
}
$$

$$
\boxed{
\Delta C_i<0
\not\Rightarrow
\Delta C_{\mathrm{total}}<0
}
$$

$$
\boxed{
\text{Path Compression}
\neq
\text{Cost Annihilation}
}
$$

$$
\boxed{
\text{Temporal Complexity}
\rightarrow
\text{Spatial / Historical / Externalized Complexity}
}
$$

以及：

$$
\boxed{
\text{Complexity Reduction}
\neq
\text{Complexity Displacement}
\neq
\text{Complexity Hiding}.
}
$$

---

## 下一篇

**Paper 05 / 09**

# 局部 $O(1)$ 不等於全域 $O(1)$  
## API、Oracle、預計算、Advice 與外包計算的複雜度邊界

**Local $O(1)$ Is Not Global $O(1)$: Complexity Boundaries of APIs, Oracles, Precomputation, Advice, and Outsourced Computation**