← Archive
lm-003356 · 2026-09

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

zh-Hant · md Raw source ↗ Metadata ↗
下載 MD 檔 ⬇

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

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→s1→s2→⋯→sn→yx \rightarrow s_1 \rightarrow s_2 \rightarrow \cdots \rightarrow s_n \rightarrow y

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

x→Φy,x \xrightarrow{\Phi} y,

甚至在 caller 所見層級中：

1Φ→y.1_{\Phi} \rightarrow y.

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

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

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

更準確的情況是：

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

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

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

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

Clocal,Conline,Coffline,Cexternal,Clifecycle,Cclosed.\boxed{ C_{\mathrm{local}}, \quad C_{\mathrm{online}}, \quad C_{\mathrm{offline}}, \quad C_{\mathrm{external}}, \quad C_{\mathrm{lifecycle}}, \quad C_{\mathrm{closed}}. }

其中：

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

本文進一步區分：

Complexity Reduction≠Complexity Displacement≠Complexity Hiding.\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。

最終本文提出：

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

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

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

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

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

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

假設問題：

q(x)q(x)

原本需要：

T(n)=2nT(n)=2^n

時間求解。

現在建立一個服務：

answer = api.solve(x)

caller 只需要：

  1. 傳送 xx ；
  2. 等待結果；
  3. 接收 yy。

從 caller 的程式碼看：

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

若把 API invocation 本身視為 primitive：

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

但 provider 內部可能仍然執行：

2n.2^n.

因此：

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

更不推出：

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

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

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

Machine instruction：

MUL R1, R2

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

但電晶體層面不是一步。

同樣：

fft(x)

在 library abstraction 中是一個 call。

但其底層可能是：

O(nlog⁡n).O(n\log n).

API：

translate(text)

在 caller 看來也是一步。

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

因此：

Step⁡L\boxed{ \operatorname{Step}_L }

必須相對於 abstraction layer：

L.L.

即：

Step⁡L(Φ)=1\boxed{ \operatorname{Step}_L(\Phi)=1 }

不能推出：

Step⁡L−1(Φ)=1.\operatorname{Step}_{L-1}(\Phi)=1.

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

定義某一局部 actor：

AA

執行任務：

q.q.

令：

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

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

它可包括：

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

其中：

  • TT：時間；
  • SS：空間／記憶；
  • EE：能量；
  • BB：頻寬；
  • LL：latency；
  • I/OI/O：輸入輸出成本。

若 actor 只送一個 request：

ClocalC_{\mathrm{local}}

確實可能極低。

這是真實進步。

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

4. 第二個分離：Online Complexity

對一次 query：

qi,q_i,

定義：

Conline(qi)\boxed{ C_{\mathrm{online}}(q_i) }

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

它包括：

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

形式上：

Conline=Cresolve+Croute+Cexecute+Ccommunicate+Cverify.\boxed{ C_{\mathrm{online}} = C_{\mathrm{resolve}} + C_{\mathrm{route}} + C_{\mathrm{execute}} + C_{\mathrm{communicate}} + C_{\mathrm{verify}}. }

因此：

Clocal≤ConlineC_{\mathrm{local}} \leq C_{\mathrm{online}}

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

5. 第三個分離：Offline Complexity

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

例如 database index。

沒有 index：

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

建立 index：

Cbuild=O(nlog⁡n)C_{\mathrm{build}} = O(n\log n)

後，query 可能：

O(log⁡n)O(\log n)

甚至某些 lookup 模型下近似：

O(1).O(1).

因此：

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

可能來自：

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

定義：

Coffline\boxed{ C_{\mathrm{offline}} }

包含：

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

6. 第四個分離：External Complexity

現在考慮：

AA

呼叫：

B.B.

對 AA：

CAC_A

可能只有：

O(1).O(1).

但：

BB

承擔：

CB.C_B.

若 BB 位於：

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

則：

Cexternal\boxed{ C_{\mathrm{external}} }

必須被明確標示。

因此：

Cvisible≠Cnecessary.\boxed{ C_{\mathrm{visible}} \neq C_{\mathrm{necessary}}. }

7. 第五個分離：Lifecycle Complexity

一個 capability：

FF

不只存在於 execution moment。

它需要：

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

因此定義：

Clifecycle(F)=Cdesign+Cconstruct+Cvalidate+Cdeploy+Coperate+Cmaintain+Cmigrate+Cretire.\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：

B.\mathfrak B.

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

B,\mathfrak B,

則定義：

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

任何：

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

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

且被包含於：

B,\mathfrak B,

其成本都不能消失。

9. Complexity Boundary

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

BC\boxed{ \mathfrak B_C }

即：

Complexity Accounting Boundary

例如：

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

或：

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

或：

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

於是：

C(q∣B1)≠C(q∣B2)\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 都需要新建結構？
  • 結果驗證成本多少？

因此：

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

11. 複雜度位移原則

本文正式提出：

Complexity Displacement Principle, CDP

令原計算：

P0\mathcal P_0

具有成本配置：

C0.\mathbf C_0.

經 transformation：

Γ\Gamma

後得到：

P1,\mathcal P_1,

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

Ck(P1)<Ck(P0),C_k(\mathcal P_1) < C_k(\mathcal P_0),

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

CjC_j

使：

Cj(P1)>Cj(P0).C_j(\mathcal P_1) > C_j(\mathcal P_0).

因此：

ΔCk<0⇏ΔCtotal<0.\boxed{ \Delta C_k<0 \not\Rightarrow \Delta C_{\mathrm{total}}<0. }

12. 這不是守恆定律

本文不主張：

Cbefore=Cafter.C_{\mathrm{before}} = C_{\mathrm{after}}.

真正演算法創新可以使：

Cafter<Cbefore.C_{\mathrm{after}} < C_{\mathrm{before}}.

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

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

因此：

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

它只是核算紀律：

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

13. 三種情況必須分開

本文區分：

13.1 Genuine Complexity Reduction

在同一 accounting boundary 下：

Cnew<Cold.\boxed{ C_{\mathrm{new}} < C_{\mathrm{old}}. }

例如更好的 algorithm。

13.2 Complexity Displacement

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

Conline↓,Coffline↑.\boxed{ C_{\mathrm{online}}\downarrow, \qquad C_{\mathrm{offline}}\uparrow. }

13.3 Complexity Hiding

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

Cvisible↓,Cclosed approximately unchanged.\boxed{ C_{\mathrm{visible}}\downarrow, \qquad C_{\mathrm{closed}} \text{ approximately unchanged}. }

這三者不能混同。

14. 從時間到空間

Paper 02 已提出 Computational Spatialization。

現在可正式寫：

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

例如：

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

原本：

x→s1→⋯→y.x \rightarrow s_1 \rightarrow \cdots \rightarrow y.

後來：

XindexX_{\mathrm{index}}

已經保存了某些 search structure。

所以 query：

x→locate⁡(y).x \rightarrow \operatorname{locate}(y).

這是：

Temporal-to-Spatial Complexity Displacement

15. Spatial Complexity

定義：

Cspatial\boxed{ C_{\mathrm{spatial}} }

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

它可以包括：

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

因此：

T↓may requireS↑.\boxed{ T\downarrow \quad\text{may require}\quad S\uparrow. }

這是典型 time–space trade-off。

16. 從搜索到記憶

若每次 query 都重新推理：

Creason.C_{\mathrm{reason}}.

第一次解完後保存：

M(q)=y.M(q)=y.

之後：

Clookup≪Creason.C_{\mathrm{lookup}} \ll C_{\mathrm{reason}}.

因此：

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

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

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

第一次：

x→Ay.x \xrightarrow{A} y.

成本：

CA.C_A.

保存：

(x,y)(x,y)

後，

下一次：

x→cachey.x \xrightarrow{\mathrm{cache}} y.

成本：

Ccache≪CA.C_{\mathrm{cache}}\ll C_A.

但：

CAC_A

已經支付。

所以：

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

18. Historical Complexity

本文定義：

Chistory\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 背後的歷史

今天：

fft(x)

很短。

但它依賴：

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

如果研究的是：

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

那麼：

ChistoryC_{\mathrm{history}}

不能完全忽略。

如果研究的是：

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

那麼它可以忽略。

所以：

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

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

因此區分：

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

與：

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

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

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

如何找到／建造 AA？

所以：

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

21. Training 是複雜度位移

模型：

MθM_\theta

訓練成本：

Ctrain.C_{\mathrm{train}}.

推理成本：

Cinfer.C_{\mathrm{infer}}.

常有：

Ctrain≫Cinfer.C_{\mathrm{train}} \gg C_{\mathrm{infer}}.

因此：

Training\boxed{ \text{Training} }

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

θ.\theta.

所以：

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

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

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

22. Model as Spatialized History

因此可以寫：

Xdata+Xoptimization→θ\boxed{ X_{\mathrm{data}} + X_{\mathrm{optimization}} \rightarrow \theta }

再：

θ+x→y.\theta + x \rightarrow y.

這是一個：

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

結構。

23. 編譯也是一樣

Source：

PP

經：

CcompileC_{\mathrm{compile}}

轉為 binary：

B.B.

之後每次執行：

Crun.C_{\mathrm{run}}.

因此：

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

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

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

假設 CPU 執行：

AA

需要大量 primitive operations。

如果某硬體：

HAH_A

直接實現：

A,A,

則：

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

也就是：

Algorithm-to-Hardware Spatialization

此時：

Cruntime↓C_{\mathrm{runtime}}\downarrow

可能是真的。

但新增：

Cfabrication,Carea,Cenergy,Cdesign.C_{\mathrm{fabrication}}, C_{\mathrm{area}}, C_{\mathrm{energy}}, C_{\mathrm{design}}.

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

對固定算法：

A,A,

ASIC 可以讓：

AA

高度固化。

從 high-level 看：

1A→XA1_A\rightarrow X_A

非常短。

但：

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

依賴：

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

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

26. 外包到另一台電腦

如果：

AA

太昂貴，

caller 把它傳給 GPU server。

Local：

Clocal↓.C_{\mathrm{local}}\downarrow.

Global：

CglobalC_{\mathrm{global}}

可能幾乎不變，

甚至增加 network overhead。

所以：

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

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

Agent 遇到困難：

q.q.

直接：

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

對 agent：

CagentC_{\mathrm{agent}}

很低。

但：

ChumanC_{\mathrm{human}}

存在。

因此：

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

也屬於 external complexity。

28. 外包到另一個 Agent

多 Agent：

A1→A2→A3.A_1 \rightarrow A_2 \rightarrow A_3.

若只計：

A1,A_1,

看起來很輕。

但真正：

Cfederation=∑iCAi+Ccommunication+Ccoordination.\boxed{ C_{\mathrm{federation}} = \sum_i C_{A_i} + C_{\mathrm{communication}} + C_{\mathrm{coordination}}. }

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

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

令 oracle：

OL(x)O_L(x)

直接回答：

x∈L?x\in L?

若 oracle call 計作一步，

則：

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

但這是：

oracle-relative complexity.\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 看：

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

所以本文稱：

Operational Externalization

31. 極致 MSSP–RDR 的本質

Paper 03 已提出：

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

如果每個 capability：

AiA_i

都有 address：

1i,1_i,

caller 可以：

1i→Ai.1_i\rightarrow A_i.

這會大幅降低：

Clocal−route.C_{\mathrm{local-route}}.

但：

AiA_i

真正成本仍在。

所以：

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

32. Coordination Complexity

這引出一個獨立成本：

Ccoord\boxed{ C_{\mathrm{coord}} }

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

而是：

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

MSSP–RDR 可以真正降低：

Ccoord.C_{\mathrm{coord}}.

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

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

這點很重要。

假設原來：

Ctotal=Csolve+Ccoord.C_{\mathrm{total}} = C_{\mathrm{solve}} + C_{\mathrm{coord}}.

建立 MSSP–RDR 後：

Ccoord′≪Ccoord.C'_{\mathrm{coord}} \ll C_{\mathrm{coord}}.

即使：

Csolve′=Csolve,C'_{\mathrm{solve}} = C_{\mathrm{solve}},

仍有：

Ctotal′<Ctotal.C'_{\mathrm{total}} < C_{\mathrm{total}}.

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

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

不應說：

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

但可以說：

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

兩者差別巨大。

因此：

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

是本文的核心紀律。

35. Complexity Vector

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

定義：

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

其中：

  • TT：time；
  • SS：space；
  • EE：energy；
  • BB：bandwidth / hardware；
  • LL：latency；
  • HH：historical/preprocessing cost；
  • PP：provider / external dependency；
  • VV：verification；
  • MM：maintenance。

不同方案可能：

T1<T2,T_1<T_2,

但：

S1>S2.S_1>S_2.

所以不存在天然總序。

36. Pareto Complexity

對兩方案：

A,B,A,B,

若：

CA⪯CB\mathbf C_A \preceq \mathbf C_B

且至少一維嚴格較小，

則：

AA

Pareto-dominates：

B.B.

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

因此：

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

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

37. Complexity Displacement Matrix

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

Dij\boxed{ D_{ij} }

表示複雜度從成本類型 ii 移向 jj 的程度。

例如：

Dtime→spaceD_{\mathrm{time}\rightarrow\mathrm{space}}

表示 time–space displacement。

Donline→offlineD_{\mathrm{online}\rightarrow\mathrm{offline}}

表示 preprocessing。

Dlocal→externalD_{\mathrm{local}\rightarrow\mathrm{external}}

表示 outsourcing。

Dexecution→historyD_{\mathrm{execution}\rightarrow\mathrm{history}}

表示 capability formation。

38. 常見位移類型

本文整理至少八種：

1. Time → Space

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

2. Online → Offline

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

3. Local → External

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

4. Execution → Hardware

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

5. Search → Memory

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

6. Discovery → Reuse

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

7. Human → Agent

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

8. Primitive Path → Macro Transition

e1,…,en→eΦ.e_1,\ldots,e_n \rightarrow e_\Phi.

39. 複雜度可以多次搬家

例如：

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

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

因此：

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

40. Complexity Lineage

定義：

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

為 capability FF 的 complexity lineage。

例如：

LC(F)=(discovery,formalization,training,build,deployment,inference).\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→X1\rightarrow X

現在可以再補：

1i→(Xi,LC(Xi)).\boxed{ 1_i \rightarrow ( X_i, \mathcal L_C(X_i) ). }

也就是 address 不只指向能力。

它也可以指向其：

  • provenance；
  • construction；
  • cost；
  • version；
  • verification。

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

42. Complexity-Carrying Structure

本文定義：

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

形式上：

若：

Conline(q∣S)<Conline(q∣∅),C_{\mathrm{online}}(q\mid S) < C_{\mathrm{online}}(q\mid \varnothing),

且：

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

則：

S∈SC.\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。

所以：

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

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

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

如果不知道：

k,k,

要搜尋：

2n2^n

狀態。

如果知道一個 theorem：

T,T,

直接把空間縮到：

n3.n^3.

則：

TT

也是 Complexity-Carrying Structure。

所以：

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

45. 這與 Agentic P/NP 的關係

經典：

∃A\exists A

問 algorithm 是否存在。

Agentic 問：

Σt→A\boxed{ \Sigma_t \rightarrow A }

要花多少成本？

如果：

AA

已在 registry：

Cdiscover≈0.C_{\mathrm{discover}}\approx0.

如果不存在：

CdiscoverC_{\mathrm{discover}}

可能極高。

因此：

Cagent=Cacquire+Cexecute.\boxed{ C_{\mathrm{agent}} = C_{\mathrm{acquire}} + C_{\mathrm{execute}}. }

46. Solver Generation Complexity

定義：

Cgen(A∣q,Σt)\boxed{ C_{\mathrm{gen}}(A\mid q,\Sigma_t) }

表示 agent 在狀態：

Σt\Sigma_t

下為任務 qq 生成 solver AA 的成本。

則總成本：

Cagent=Cgen+Cexecute+Cverify.\boxed{ C_{\mathrm{agent}} = C_{\mathrm{gen}} + C_{\mathrm{execute}} + C_{\mathrm{verify}}. }

這將在 Paper 08 正式展開。

47. 如果 solver 已經存在

如果：

A∈At,A\in\mathcal A_t,

則：

Cgen≈0.C_{\mathrm{gen}}\approx0.

這就是歷史累積造成的：

Historical Acceleration

即：

At+1⊃At\boxed{ \mathcal A_{t+1} \supset \mathcal A_t }

可使未來：

ConlineC_{\mathrm{online}}

下降。

48. Amortized Complexity

如果 capability：

FF

建立成本：

Cbuild,C_{\mathrm{build}},

未來被使用：

NN

次，

每次：

Crun,C_{\mathrm{run}},

則：

Ctotal(N)=Cbuild+∑i=1NCrun,i+Cmaintain.\boxed{ C_{\mathrm{total}}^{(N)} = C_{\mathrm{build}} + \sum_{i=1}^{N}C_{\mathrm{run},i} + C_{\mathrm{maintain}}. }

平均：

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

若：

N→∞,N\rightarrow\infty,

offline build cost 可被攤薄。

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

若：

CbuildC_{\mathrm{build}}

雖大，

但：

CrunC_{\mathrm{run}}

極小，

且使用次數足夠多，

則：

C‾N\overline C_N

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

因此：

displacement\boxed{ \text{displacement} }

不是貶義詞。

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

50. 但 worst-case 仍不能消失

即使：

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

對：

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

任務，

仍需追蹤：

Cworst.C_{\mathrm{worst}}.

因此：

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

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

假設：

DN={x1,…,xM}D_N = \{x_1,\ldots,x_M\}

是固定有限 domain。

若預先建立：

T[xi]=yi,T[x_i]=y_i,

則 query：

T[xi]T[x_i]

可近似常數查找。

所以：

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

可以成立。

但：

CofflineC_{\mathrm{offline}}

可能：

Ω(M).\Omega(M).

如果：

M=2n,M=2^n,

則：

CofflineC_{\mathrm{offline}}

可能 exponential。

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

在有限封閉世界：

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

因此 query：

O(1)O(1)

並不奇怪。

真正問題不是：

查表能不能快？

而是：

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

以及：

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

53. Nonuniformity

如果對每個 input size：

nn

都外部提供一個巨大 state：

Sn,S_n,

且 runtime 只需 lookup，

則：

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

可能來自：

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

因此：

∀n∃Sn\forall n\exists S_n

不等於：

∃G∀n.\exists G\forall n.

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

54. Complexity Displacement 與 Quantifier

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

∀x∃Sx\forall x\exists S_x

與：

∃S∀x\exists S\forall x

的差異。

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

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

所以：

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

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

系統可以快速產生答案：

y.y.

但若 verification：

V(x,y)V(x,y)

非常昂貴，

總體：

CclosedC_{\mathrm{closed}}

仍高。

因此：

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

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

56. Completion Complexity

定義：

Ccomplete=Csolve+Cverify+Ccommit.\boxed{ C_{\mathrm{complete}} = C_{\mathrm{solve}} + C_{\mathrm{verify}} + C_{\mathrm{commit}}. }

如果需要：

  • evidence；
  • proof；
  • provenance；
  • rollback；
  • consistency；

還需加入相應成本。

所以：

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

57. Complexity Debt

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

  • validation；
  • consistency；
  • migration；
  • documentation；

則當下：

Conline↓.C_{\mathrm{online}}\downarrow.

但未來可能形成：

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

這可以稱：

Complexity Debt

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

58. Hidden Complexity Debt

例如：

quick hack

當下成本低。

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

於是：

Cmaintain(t)↑.C_{\mathrm{maintain}}(t) \uparrow.

因此：

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

可以是：

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

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

如果系統不斷新增：

  • API；
  • bridge；
  • adapter；
  • tool；
  • capability；

但缺乏治理，

則：

∣E∣↑|E|\uparrow

同時：

Croute,Cverify,Cmaintain↑.C_{\mathrm{route}}, C_{\mathrm{verify}}, C_{\mathrm{maintain}} \uparrow.

所以：

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

存在負收益區域。

60. Hyperconnection Saturation

定義候選：

若新增 edge：

ee

造成：

Δdeff<0\Delta d_{\mathrm{eff}}<0

但：

ΔCmaintain+ΔCroute>∣ΔCsolve∣,\Delta C_{\mathrm{maintain}} + \Delta C_{\mathrm{route}} > |\Delta C_{\mathrm{solve}}|,

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

這可以形成：

Hyperconnection Saturation

61. 不是越連越好

因此：

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

更合理是：

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

即只建立：

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

的通道。

62. Complexity Placement

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

計算應該放在哪裡？

不是只問：

Which algorithm?\text{Which algorithm?}

而是：

Where should the complexity live?\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。

本文再加入：

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

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

還可以配置：

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

64. Complexity Placement Policy

定義：

PlaceC:(q,Ct,B,H)→PC\boxed{ \mathsf{Place}_C : ( q, \mathfrak C_t, B, H ) \rightarrow \mathcal P_C }

其中：

PC\mathcal P_C

是 complexity placement plan。

例如：

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

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

65. 動態複雜度配置

若 workload 改變：

DQ(t),\mathcal D_Q(t),

最優 placement 也可能改變。

例如：

低頻 query：

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

高頻 query：

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

因此：

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

66. Complexity Migration

當 capability 從 cloud 移到 local accelerator：

Cexternal→Clocal.C_{\mathrm{external}} \rightarrow C_{\mathrm{local}}.

當 local DB 搬到 cloud：

Clocal→Cexternal.C_{\mathrm{local}} \rightarrow C_{\mathrm{external}}.

因此：

Complexity Migration

可以被直接觀測。

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

定義：

ΛC(t)\boxed{ \Lambda_C(t) }

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

例如：

ΛC=(Clocal,Coffline,Cmemory,Cprovider,Chistory,Cverify).\Lambda_C = ( C_{\mathrm{local}}, C_{\mathrm{offline}}, C_{\mathrm{memory}}, C_{\mathrm{provider}}, C_{\mathrm{history}}, C_{\mathrm{verify}} ).

計算架構演化可以寫成：

ΛC(t)→ΛC(t+1).\boxed{ \Lambda_C(t) \rightarrow \Lambda_C(t+1). }

68. Complexities Do Not Simply Vanish under Abstraction

如果 abstraction：

α\alpha

把：

x0→⋯→xnx_0\rightarrow\cdots\rightarrow x_n

視為：

x0→Φxn,x_0\xrightarrow{\Phi}x_n,

則：

α\boxed{ \alpha }

改變的是觀察粒度。

不能單靠：

∣πα∣=1|\pi_\alpha|=1

推出底層 work 為 1。

因此：

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

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

反過來也不能過度保守。

新的 representation：

R′R'

可能真的讓問題更容易。

例如：

C(q∣R′)<C(q∣R).C(q\mid R') < C(q\mid R).

這時不是單純 hiding。

而是：

Representation-Induced Complexity Reduction

所以本文不否定 representation power。

只是要求：

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

70. Task Identity Firewall

如果：

qq

被改成：

q′,q',

且：

q′≢q,q'\not\equiv q,

即使：

C(q′)≪C(q),C(q')\ll C(q),

也不能說：

qq

變簡單了。

因此任何 complexity displacement 都應附帶：

Iq\boxed{ \mathfrak I_q }

Task Identity Contract。

只有：

q′≡Iqqq'\equiv_{\mathfrak I_q}q

時，才能比較。

71. Bypass 與真正改善

如果：

qq

要求 exact solution，

而：

q′q'

只要求 approximation，

則：

C(q′)<C(q)C(q')<C(q)

不代表 exact problem 改善。

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

則 bypass 可以合法。

因此：

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

72. 第一個主命題：Boundary Relativity

Complexity Boundary Relativity Proposition

對同一任務：

q,q,

存在 boundaries：

B1⊂B2\mathfrak B_1\subset\mathfrak B_2

使：

C(q∣B1)<C(q∣B2).\boxed{ C(q\mid\mathfrak B_1) < C(q\mid\mathfrak B_2). }

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

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

若：

Ci′ ⁣<Ci,C_i'\!<C_i,

則一般不能推出：

∑jCj′<∑jCj.\boxed{ \sum_jC'_j < \sum_jC_j. }

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

74. 第三個主命題：Spatialization Principle

若 persistent structure：

SS

使：

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

則至少部分 online complexity 已被：

  • 消除；
  • 或轉移至 SS 的形成／維護。

若：

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

則存在 displacement component。

75. 第四個主命題：Externalization Principle

若 subsystem：

AA

將必要工作交給：

B,B,

則：

CA↓C_A\downarrow

不推出：

CA∪B↓.C_{A\cup B}\downarrow.

因此：

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

與：

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

必須分離。

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

若：

Ht+1⊃HtH_{t+1}\supset H_t

且新增 reusable structures 使：

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

則可稱：

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

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

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

若能力：

FF

對任務：

qq

必要，

則在把 FF 納入 closed boundary 後：

CF\boxed{ C_F }

不得因 interface abstraction 而被忽略。

這是本文最核心的 audit rule。

78. Complexity Accounting Ledger

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

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。

還可以記：

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

RDR 在 dispatch 時可比較：

F1,F2,…,FnF_1,F_2,\ldots,F_n

的：

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

於是：

routing\boxed{ \text{routing} }

開始具有真正 complexity awareness。

80. Complexity-Aware RDR

未來：

RDR(q)RDR(q)

不只問：

哪個 provider 可以跑？

而是：

arg⁡min⁡FiJ(C(Fi),q,B,Risk).\boxed{ \arg\min_{F_i} \mathcal J ( \mathbf C(F_i), q, B, \mathrm{Risk} ). }

其中：

J\mathcal J

是 task-relative objective。

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

例如：

1 Joule1\text{ Joule}

與：

1 GB1\text{ GB}

沒有天然 universal exchange rate。

所以：

J\mathcal J

是政策／任務相對。

本文不主張存在：

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

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

先前提出：

Θ\boldsymbol\Theta

描述 system state-transition capacity。

現在可看到：

Θ↑\boldsymbol\Theta\uparrow

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

TT

搬進：

  • memory；
  • parallelism；
  • hardware；
  • provider；
  • history。

所以：

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

部分來自：

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

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

假設同一 algorithm：

AA

可以在 486 上跑。

理論可計算性上：

AA

可能存在。

但現代系統擁有：

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

因此現代系統的：

ΛC\Lambda_C

完全不同。

很多以前需要：

local sequential compute\text{local sequential compute}

的工作，

現在可轉為：

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

所以：

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

也是：

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

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

若現代文明先算出：

yy

再把：

yy

交給 486，

486 可以：

O(1)O(1)

輸出。

但：

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

不能推出：

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

因為：

Cmodern−civilizationC_{\mathrm{modern-civilization}}

被外包了。

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

若：

π⋆(x)\pi^\star(x)

已知，

執行成本可能很低。

但：

Cdiscover(π⋆)C_{\mathrm{discover}}(\pi^\star)

可能高。

因此：

Cexecute(π⋆)≠Cfind(π⋆).\boxed{ C_{\mathrm{execute}}(\pi^\star) \neq C_{\mathrm{find}}(\pi^\star). }

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

86. 複雜度位移與 solver state

如果 solver：

Σ⋆\Sigma^\star

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

則：

x→Σ⋆yx \xrightarrow{\Sigma^\star} y

可以很短。

但需要問：

Σ0→Σ⋆\boxed{ \Sigma_0 \rightarrow \Sigma^\star }

成本多少？

因此：

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

87. Solver-State Complexity

定義：

Cstate(Σ⋆)\boxed{ C_{\mathrm{state}} ( \Sigma^\star ) }

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

它可以包含：

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

於是：

Csolve(x∣Σ⋆)\boxed{ C_{\mathrm{solve}} ( x\mid\Sigma^\star ) }

與：

Cstate(Σ⋆)\boxed{ C_{\mathrm{state}} ( \Sigma^\star ) }

必須分開。

88. Instance-Time Complexity 與 Solver-State Complexity

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

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

一個 civilization 可能花：

10610^6

年建立：

Σ⋆,\Sigma^\star,

之後每個 instance 一秒完成。

這對 civilization engineering 很有價值。

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

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

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

也可以是：

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

因此：

Externalization\boxed{ \text{Externalization} }

應廣義理解為：

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

90. Complexity Location

定義一個成本定位函數：

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

複雜度位移就是：

ℓC(t)→ℓC(t+1).\boxed{ \ell_C^{(t)} \rightarrow \ell_C^{(t+1)}. }

91. 路徑被壓成結構

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

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

中文：

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

92. 結構狀態可以被複製

一個 algorithm：

AA

一旦被寫成 code，

可以：

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

這意味：

CdiscoverC_{\mathrm{discover}}

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

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

93. Complexity Replication Asymmetry

建立一個 capability：

Cbuild≫1,C_{\mathrm{build}}\gg1,

但複製：

Ccopy≪Cbuild.C_{\mathrm{copy}}\ll C_{\mathrm{build}}.

因此：

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

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

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

每一代新增：

Anew,A_{new},

之後：

AnewA_{new}

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

所以：

At⊆At+1.\mathcal A_t \subseteq \mathcal A_{t+1}.

如果維護良好，

歷史形成：

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

95. 但 capability 也會失效

因此不是單調：

At⊆At+1\mathcal A_t\subseteq\mathcal A_{t+1}

永遠成立。

可能：

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

所以：

At+1=(At+Anew)−Ainvalid.\boxed{ \mathcal A_{t+1} = ( \mathcal A_t + A_{\mathrm{new}} ) - A_{\mathrm{invalid}}. }

96. Maintenance Is Computation

維持 address：

1i→Xi1_i\rightarrow X_i

長期有效，

需要：

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

所以：

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

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

97. Complexity Displacement Failure

如果：

Conline↓C_{\mathrm{online}}\downarrow

但：

Cmaintain↑↑C_{\mathrm{maintain}}\uparrow\uparrow

到超過收益，

則 displacement 不值得。

這是可測工程問題。

98. Net Complexity Benefit

對 workload：

QNQ_N

定義：

ΔCnet=Cbaseline(N)−Cnew(N).\boxed{ \Delta C_{\mathrm{net}} = C_{\mathrm{baseline}}^{(N)} - C_{\mathrm{new}}^{(N)}. }

若：

ΔCnet>0,\Delta C_{\mathrm{net}}>0,

新架構有淨收益。

若：

ΔCnet<0,\Delta C_{\mathrm{net}}<0,

則只是看起來更漂亮。

99. 多資源版本

因資源不可全部相加，

可改用：

ΔC=Cbaseline−Cnew.\boxed{ \Delta\mathbf C = \mathbf C_{\mathrm{baseline}} - \mathbf C_{\mathrm{new}}. }

再用 task policy：

Uq(ΔC)U_q(\Delta\mathbf C)

判斷是否有實際改善。

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

再強調一次：

好的 algorithm 可以真的讓：

T(n):2n→n3.T(n) : 2^n \rightarrow n^3.

這不是單純 displacement。

因此 CDP 不是：

困難永遠不會消失。

而是：

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

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

前三篇研究：

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

本文開始研究：

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

所以整個系列正式從：

Computational Space

進入：

Complexity Displacement

102. 下一篇的核心

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

O(1)local≠O(1)global.\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. 結論

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

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

本文的答案是：

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

一個符號：

1i1_i

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

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

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

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

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

這些都是真實進步。

但是：

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

所以本文提出：

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

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

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

因此：

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

完整計算至少需要區分：

Clocal,Conline,Coffline,Cexternal,Clifecycle,Cclosed.\boxed{ C_{\mathrm{local}}, C_{\mathrm{online}}, C_{\mathrm{offline}}, C_{\mathrm{external}}, C_{\mathrm{lifecycle}}, C_{\mathrm{closed}}. }

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

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

還應知道：

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

因此未來計算排程會從：

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

進一步變成：

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

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

本篇核心公式總結

Clocal≠Cclosed\boxed{ C_{\mathrm{local}} \neq C_{\mathrm{closed}} } Conline≠Coffline\boxed{ C_{\mathrm{online}} \neq C_{\mathrm{offline}} } Cvisible≠Cnecessary\boxed{ C_{\mathrm{visible}} \neq C_{\mathrm{necessary}} } ΔCi<0⇏ΔCtotal<0\boxed{ \Delta C_i<0 \not\Rightarrow \Delta C_{\mathrm{total}}<0 } Path Compression≠Cost Annihilation\boxed{ \text{Path Compression} \neq \text{Cost Annihilation} } Temporal Complexity→Spatial / Historical / Externalized Complexity\boxed{ \text{Temporal Complexity} \rightarrow \text{Spatial / Historical / Externalized Complexity} }

以及：

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

下一篇

Paper 05 / 09

局部 O(1)O(1) 不等於全域 O(1)O(1)

API、Oracle、預計算、Advice 與外包計算的複雜度邊界

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