記憶、算法庫與可重用問題求解路徑

Q: 1. 問題：如果每次都重新想，系統真的學會了嗎？

前四篇已經讓系統具備：

Q: 56. 下一步：算法知道了，但在哪裡執行？

到目前為止，系統已經可以知道：

——從世界模型到能力模型的累積式智能架構

Series: Adaptive Epistemic Systems Series
Paper: 5 / 11
Version: v0.1
Language: zh-TW
Status: Complete Draft / Canonical UTF-8 Source

摘要

一個能持續吸收世界知識、更新狀態與重構表示空間的智能系統，若每次面對任務都重新生成方法、重新構造算法或重新探索相同求解路徑，將產生巨大的重複計算成本，也無法形成真正的能力累積。本文提出一個從「世界模型」向「能力模型」擴張的架構：除了保存事實、事件、概念與關係之外，系統也應保存曾經使用過的算法、外部工具、執行契約、成功與失敗紀錄、成本、版本、適用條件與可重用方法鏈。

本文將可調用算法表示為具有輸入域、輸出域、前置條件、後置條件、依賴、成本、可靠度、版本與歷史表現的能力節點，並提出：

Reuse \succ Adapt \succ Create

作為一般性的求解優先順序。系統遇到任務時，應優先檢索是否已存在足夠匹配且仍有效的方法；若現有方法可局部修正，則進行 adapt；只有當現有方法在適配度、可靠度、成本或約束條件上無法達到門檻時，才重新構造新算法。

本文進一步將問題求解歷史表示為可重用方法鏈：

A_3 \rightarrow A_7 \rightarrow A_{12} \rightarrow Verify

並指出能力成長不只來自算法數量，也來自算法組合、執行經驗、失敗模式、契約與調度策略的累積。透過外掛記憶層，主世界圖不需常駐所有細節，只需保留可尋址索引與語義連結；需要時再快速恢復相關算法、資料、執行紀錄與系統模型。

本文亦提出算法新鮮度、能力版本化、方法退化、重新驗證、負遷移、能力債務與重用錯誤等風險，並給出一組可驗證命題，用以測試「能力記憶」是否真的比每次重新生成更高效、更穩定、更可轉移。本文的核心主張是：

\boxed{ \text{intelligence should accumulate reusable capability, not only reusable knowledge} }

。

關鍵詞： 記憶外掛、算法庫、能力模型、方法重用、算法適配、問題求解路徑、執行歷史、工具調度、能力累積、方法鏈

1. 問題：如果每次都重新想，系統真的學會了嗎？

前四篇已經讓系統具備：

\text{world state}

\text{freshness}

\text{canonical symbols}

\text{adaptive representation}

。

但現在出現一個新的問題。

假設任務：

Q_1

被成功解決。

之後出現一個高度相似任務：

Q_2

如果系統仍然從：

\varnothing

開始重新尋找方法，那麼先前成功經驗並沒有真正變成能力。

因此：

\boxed{ \text{past success} \not\Rightarrow \text{future capability} }

除非系統能保存、定位、理解與重新使用那段方法。

這就是世界模型與能力模型之間的分界。

2. 世界知識與能力知識不是同一類資訊

世界模型主要回答：

世界是什麼？

例如：

Fact(A)

Relation(A,B)

Event(E,t)

。

能力模型則回答：

這種問題要怎麼處理？

例如：

Algorithm(A_i)

Tool(T_j)

Workflow(W_k)

ExecutionPattern(P_l)

。

因此整體系統應擴充為：

\mathfrak{S} = ( G_{\mathrm{world}}, G_{\mathrm{capability}} )

。

兩者可以互相連接，但不應混成同一語義。

3. 外掛記憶層

主世界圖不應常駐所有歷史執行內容。

定義外部記憶：

M_{\mathrm{ext}}

保存：

\{ \text{facts}, \text{algorithms}, \text{execution traces}, \text{past solutions}, \text{schemas}, \text{tool contracts}, \text{system models} \}

。

主系統只需保留索引：

\Pi: G \rightarrow M_{\mathrm{ext}}

。

因此：

\boxed{ \text{remember everything} \neq \text{keep everything active} }

。

4. 記憶不是單一資料庫

更合理地說：

M = \{ M_{\mathrm{episodic}}, M_{\mathrm{semantic}}, M_{\mathrm{algorithmic}}, M_{\mathrm{procedural}}, M_{\mathrm{trace}}, M_{\mathrm{external}} \}

。

其中：

M_{\mathrm{episodic}}

保存具體過去事件；

M_{\mathrm{semantic}}

保存抽象知識；

M_{\mathrm{algorithmic}}

保存算法；

M_{\mathrm{procedural}}

保存方法鏈；

M_{\mathrm{trace}}

保存執行過程；

M_{\mathrm{external}}

保存可重新調用的外部資料與系統描述。

5. 算法作為一等能力節點

算法不應只是檔案名稱或程式碼字串。

定義：

A_i = ( id_i, f_i, I_i, O_i, Pre_i, Post_i, Dep_i, Cost_i, Reliability_i, Version_i, Freshness_i )

其中：

f_i

是算法本體；

I_i

是輸入域；

O_i

是輸出域；

Pre_i

是前置條件；

Post_i

是後置條件；

Dep_i

是依賴；

Cost_i

是成本；

Reliability_i

是可靠度；

Version_i

是版本；

Freshness_i

是有效性狀態。

因此算法本身也是：

v_{A_i}\in V_{\mathrm{capability}}

。

6. 不是知道算法存在，而是知道它何時可用

真正的能力不是：

Exists(A_i)=True

而是：

CanUse(A_i,Q)=True

。

因此需要估計：

Match(A_i,Q)

。

一個簡化適配度可寫成：

Match(A_i,Q) = w_1M_{\mathrm{input}} + w_2M_{\mathrm{output}} + w_3M_{\mathrm{constraint}} + w_4M_{\mathrm{domain}} + w_5M_{\mathrm{cost}}

。

若：

Match(A_i,Q)\ge\theta

才值得使用。

7. Reuse、Adapt、Create

本文提出三階決策：

Reuse

直接調用既有方法；

Adapt

修改既有方法；

Create

重新構造。

一般優先順序為：

\boxed{ Reuse \succ Adapt \succ Create }

。

原因不是 reuse 永遠比較好，而是若既有方法已被驗證，重用通常能降低：

C_{\mathrm{design}}

C_{\mathrm{verification}}

C_{\mathrm{debug}}

與：

C_{\mathrm{latency}}

。

8. 最小決策規則

可寫成：

D(Q) = \begin{cases} Reuse(A_i), & Match(A_i,Q)\ge\theta_1\\ Adapt(A_i), & \theta_2\le Match(A_i,Q)<\theta_1\\ Create(A_{\mathrm{new}}), & Match(A_i,Q)<\theta_2 \end{cases}

。

但這只是起始模型。

實際上還要考慮：

Reliability(A_i)

Cost(A_i)

Freshness(A_i)

Risk(A_i,Q)

。

9. 已存在不代表值得用

即使：

A_i

存在，也可能：

Cost(A_i)\gg Budget

或：

Reliability(A_i)<\theta_r

或：

Latency(A_i)>\theta_l

或：

Freshness(A_i)<\theta_f

。

因此真正的建立新算法條件不是：

\mathcal{A}_Q=\varnothing

而是：

\boxed{ \max_i U(A_i\mid Q) < \theta_U }

。

其中：

U(A_i\mid Q)

是綜合效用。

10. 算法效用函數

可定義：

U(A_i\mid Q) = \alpha P_{\mathrm{success}} - \beta C_{\mathrm{compute}} - \gamma C_{\mathrm{money}} - \delta C_{\mathrm{latency}} - \epsilon Risk + \zeta Reusability

。

因此「最強算法」不一定是最值得使用的算法。

最佳方法是：

A^\ast = \arg\max_{A_i} U(A_i\mid Q)

。

11. 執行歷史是能力的一部分

每個算法應保存：

H(A_i) = \{ (Q_j, Result_j, Cost_j, Success_j, Error_j, Context_j) \}_{j=1}^{n}

。

這使系統可以估計：

P( Success \mid A_i,Q,C )

。

因此方法選擇不再只依賴人工標註，而能利用過去真實執行經驗。

12. 成功紀錄與失敗紀錄同樣重要

若只保存成功：

M_{\mathrm{success}}

而刪除失敗：

M_{\mathrm{failure}}

系統會重複踩相同錯誤。

因此需要：

FailureMode(A_i)

以及：

Counterexample(A_i)

。

失敗可以成為負能力知識：

在什麼條件下不要用這個方法。

13. 算法選擇也可以持續更新

若算法歷史改變，則：

P_t(A_i\mid Q)

也應更新。

例如：

P_{t+1} ( Success\mid A_i,Q ) \neq P_t ( Success\mid A_i,Q )

。

這可以使用 Bayesian、頻率統計、分數更新或其他方式。

重要的不是一定用哪一種，而是：

\boxed{ \text{method choice should learn from method outcomes} }

。

14. 算法新鮮度

世界知識會過時，算法也會過時。

例如：

Dependency(A_i)

可能更新；

Interface(A_i)

可能變更；

Version(A_i)

可能失效；

SecurityAssumption(A_i)

可能不再成立。

因此需要：

Freshness(A_i)

與：

LastVerified(A_i)

。

算法不是因為「以前成功過」就永久可信。

15. 能力張力

可類比世界節點，定義算法更新張力：

T_{A_i}

。

例如：

T_{A_i} = \alpha Age_i + \beta DependencyChange_i + \gamma FailureRate_i + \delta InterfaceChange_i + \epsilon Risk_i

。

若：

T_{A_i}>\theta_i

則：

Revalidate(A_i)

。

16. 算法契約

每個算法應有：

Contract(A_i) = ( Pre_i, Post_i, Invariant_i, Failure_i )

。

這讓調度器能在執行前判斷：

Pre_i(Q)=True?

執行後判斷：

Post_i(Result)=True?

。

若：

Post_i=False

則結果不能直接進 canonical state。

17. 執行後驗證

流程：

Q \rightarrow A_i \rightarrow Result \rightarrow Verify

。

若：

Verify(Result)=True

則：

Commit(Result)

。

若：

Verify(Result)=False

則可以：

Fallback(A_j)

或：

Adapt(A_i)

或：

Create(A_{\mathrm{new}})

。

18. 方法鏈：真正可重用的不是單一算法

許多問題不是：

Q \rightarrow A_i

一次完成。

而是：

Q \rightarrow A_1 \rightarrow A_2 \rightarrow A_3 \rightarrow Verify

。

因此要保存：

W_k = ( A_1,A_2,\ldots,A_n )

作為 workflow。

19. 方法鏈可以有條件分支

例如：

A_1 \rightarrow \begin{cases} A_2, & r_1>\theta\\ A_3, & r_1\le\theta \end{cases}

。

因此方法鏈更一般是：

G_{\mathrm{workflow}}

而不只是線性序列。

20. 方法鏈也是圖節點

定義：

v_{W_k}\in V_{\mathrm{capability}}

並建立：

TaskType \rightarrow Workflow \rightarrow Algorithm

。

這樣系統不只知道有哪些算法，也知道：

某類問題通常應按什麼順序使用哪些能力。

21. 從 Know-What 到 Know-How

可將系統能力分成：

\boxed{ Know\text{-}What }

知道世界事實；

\boxed{ Know\text{-}How }

知道方法；

\boxed{ Know\text{-}When }

知道何時使用；

\boxed{ Know\text{-}Where }

知道在哪個系統或容器執行；

\boxed{ Know\text{-}When\text{-}To\text{-}Build }

知道何時現有能力不夠。

Paper 05 主要建立前四者中的方法與調度部分。

22. 記憶檢索不是全文搜尋

若記憶庫龐大，系統需要：

Retrieve(M,Q)

而不是：

Scan(M)

。

檢索條件可以包含：

SemanticMatch

TaskType

InputSchema

OutputSchema

HistoricalSuccess

Cost

。

因此：

\boxed{ \text{memory usefulness} \propto \text{retrievability} }

。

23. 能力索引

定義能力索引：

Index(A_i) = ( Domain, InputType, OutputType, Constraint, CostBand, ReliabilityBand )

。

查詢：

Q

先被映射到能力需求：

Req(Q)

再：

Req(Q) \rightarrow Retrieve(\mathcal{A})

。

這比直接用自然語言搜尋算法名稱更穩定。

24. 方法重用也可能造成負遷移

相似問題不代表同一方法適用。

若：

Similarity(Q_1,Q_2)\uparrow

但關鍵約束不同：

Constraint(Q_1)\neq Constraint(Q_2)

直接 reuse 可能失敗。

因此：

\boxed{ \text{similarity} \neq \text{applicability} }

。

25. 負遷移檢測

可比較：

ExpectedGain(Reuse)

與：

ExpectedLoss(Mismatch)

。

只有：

ExpectedGain(Reuse) > ExpectedLoss(Mismatch)

才執行 reuse。

這使系統避免「因為以前成功過，所以什麼都用同一招」。

26. Adapt 的形式

Adapt 可以包括：

ParameterChange

WrapperAddition

ConstraintInjection

AlgorithmComposition

InputTransformation

OutputTransformation

。

因此：

A_i \xrightarrow{Adapt} A_i'

不一定表示完全新算法。

27. Adapt 需要保留 lineage

若：

A_2=Adapt(A_1)

則應保存：

Parent(A_2)=A_1

。

更長期：

A_1 \rightarrow A_2 \rightarrow A_3

形成算法演化鏈。

這使系統可以知道：

哪個版本從哪裡來，又為什麼修改。

28. Create 不代表無中生有

真正的新算法往往仍然使用既有 primitives。

可寫成：

A_{\mathrm{new}} = Compose \left( A_i, A_j, r_k, op_l \right)

。

因此 create 也可能只是新組合：

\text{new capability} = \text{new composition of old capabilities}

。

29. 能力閉包

若：

\mathcal{A} = \{ A_1,\ldots,A_n \}

則可組合能力空間：

Closure(\mathcal{A})

可能遠大於：

|\mathcal{A}|

。

因此能力不只由算法數量決定，而由：

\boxed{ \text{compositional reachability} }

決定。

30. 方法鏈的壓縮

若大量任務反覆使用：

A_3 \rightarrow A_7 \rightarrow A_{12} \rightarrow Verify

可以建立：

W^\ast

作為高階 macro。

則：

W^\ast(Q)

直接調用整段流程。

這是一種：

\text{procedural abstraction}

。

31. 方法鏈也需要拆分

若：

W^\ast

在新環境下部分失效，不能只整體丟棄。

可拆成：

W^\ast = W_a \circ W_b \circ W_c

找到失敗段：

W_b

再：

Adapt(W_b)

。

這能降低重新設計成本。

32. 能力記憶的壓縮與蒸餾

執行 trace 可能非常大。

因此不需永久保存所有細節。

可從：

Trace_1,\ldots,Trace_n

抽取：

Pattern

FailureMode

CostProfile

SuccessCondition

。

這形成：

\boxed{ \text{experience compression} }

。

33. 但不能只保存摘要

若摘要錯誤，可能污染後續所有調度。

因此：

Summary

應保留對原 trace 的：

Provenance

。

需要時：

Summary \rightarrow RawTrace

可追溯。

34. 能力債務

如果某算法長期未重新驗證：

Freshness(A_i)\downarrow

但仍被反覆依賴，則形成能力債務：

D_{A_i}^{\mathrm{cap}}

。

可定義：

D_{A_i}^{\mathrm{cap}} = Usage(A_i) \cdot Risk(A_i) \cdot Staleness(A_i)

。

若：

D_{A_i}^{\mathrm{cap}}\uparrow

應優先重新驗證。

35. 能力節點也能被淘汰

若：

Usage(A_i)\rightarrow0

Reliability(A_i)\downarrow

Replacement(A_i)=True

則可：

Deprecate(A_i)

甚至：

Archive(A_i)

。

因此能力庫不是 append-only。

36. 能力競爭

同一任務可能有：

A_1,A_2,\ldots,A_n

多個可用方法。

系統可以持續比較：

Performance(A_i)

Cost(A_i)

Reliability(A_i)

。

因此算法之間可以形成：

\boxed{ \text{capability competition} }

。

37. 能力替換不是刪除歷史

若：

A_2

全面優於：

A_1

仍不一定應完全刪除：

A_1

。

因為在某些特殊約束下：

A_1

仍可能更好。

所以應建立：

Dominates(A_2,A_1\mid C)

而非：

A_2>A_1

的全域判定。

38. 問題分解

複雜任務：

Q

可以拆成：

Q \rightarrow \{ q_1,q_2,\ldots,q_m \}

。

每個：

q_i

可以選不同：

A_i

。

因此：

Solve(Q) = Compose \left( Solve(q_1),\ldots,Solve(q_m) \right)

。

這是後續異質計算容器調度的直接前置結構。

39. 調度器

定義：

Scheduler

負責：

Task \rightarrow CapabilitySelection

。

完整流程：

Q \rightarrow Understand \rightarrow Decompose \rightarrow Retrieve \rightarrow Evaluate \rightarrow Select \rightarrow Execute \rightarrow Verify \rightarrow Learn

。

這個循環使每次任務都有可能增強後續能力。

40. Learn 的內容

執行後：

Learn

不只更新世界知識。

也更新：

Reliability(A_i)

Cost(A_i)

FailureMode(A_i)

Workflow(W_i)

Match(A_i,Q)

。

因此：

\boxed{ \text{task execution} \rightarrow \text{capability update} }

。

41. 世界模型與能力模型的交叉連結

世界節點：

v_{\mathrm{domain}}

可以連到：

v_{A_i}

表示：

ApplicableTo(A_i,Domain)

。

算法節點又能連到：

v_{\mathrm{system}}

表示：

Requires(A_i,System)

。

因此：

Problem \rightarrow Domain \rightarrow Algorithm \rightarrow System

形成完整能力路徑。

42. 能力模型本身也有非對稱時空張力

某些算法多年不變：

T_{A_i}\approx0

。

某些算法高度依賴外部介面：

T_{A_j}\gg0

。

所以 Paper 01 與 Paper 02 的非對稱更新理論，同樣適用於能力圖。

這使世界模型與能力模型共享：

Freshness

Tension

Provenance

Validation

。

43. 方法重用的核心工程預測

若能力記憶有效，則對重複或相似任務：

C_{\mathrm{reuse}} < C_{\mathrm{recreate}}

。

同時：

Reliability_{\mathrm{reuse}} \ge Reliability_{\mathrm{recreate}}

應至少在大量已驗證任務上成立。

44. 對適配能力的預測

若：

Q_2

與：

Q_1

高度相似但有局部差異，則：

Cost(Adapt) < Cost(Create)

且輸出品質保持近似。

若不成立，adapt 層的存在價值就需要重新檢驗。

45. 對方法鏈記憶的預測

對多步任務：

WorkflowReuse

應降低：

PlanningCost

ToolSelectionError

與：

ExecutionVariance

。

如果只保存單一算法、不保存方法鏈，則這些收益可能不完整。

46. 對失敗記憶的預測

若系統保存失敗模式：

FailureMemory=True

則：

RepeatedFailureRate

應低於：

FailureMemory=False

的系統。

47. 對能力新鮮度的預測

若算法依賴會變動，加入：

Freshness(A_i)

與：

Revalidate(A_i)

應降低：

StaleCapabilityFailureRate

。

48. 實驗設計草案

建立三種系統：

S_1 = \text{generate-every-time}

S_2 = \text{algorithm-memory only}

S_3 = \text{algorithm + workflow + trace + freshness}

。

提供：

Q_1,\ldots,Q_n

包含：

重複任務；
輕微變形任務；
高度相似但關鍵約束不同的任務；
工具版本更新；
已知失敗模式；
多步工作流。

測量：

PlanningCost

ExecutionCost

SuccessRate

RepeatedFailureRate

Latency

AdaptationCost

StaleMethodFailure

。

49. 失敗模式：能力庫變成垃圾場

如果系統不斷保存：

A_1,A_2,\ldots

卻不去：

Deduplicate

Version

Validate

Deprecate

能力庫會和世界知識庫一樣退化。

因此 Paper 04 的：

Add, Delete, Merge, Split, Abstract

也適用於能力節點。

50. 失敗模式：錯誤方法被過度重用

若某方法：

A_i

過去成功率高，系統可能產生：

ReuseBias(A_i)\uparrow

。

這會使新的、更好方法難以被採用。

因此需要保留：

ExplorationRate>0

。

即使有成熟方法，也要允許有限探索。

51. 失敗模式：方法鏈僵化

成功 workflow：

W^\ast

若被永久固化，環境改變後可能失效。

因此：

Freshness(W^\ast)

與：

Revalidate(W^\ast)

同樣必要。

52. 失敗模式：過度創造

若 Create 閾值太低：

\theta_U\downarrow

系統會一直生成新算法。

結果：

|\mathcal{A}|\uparrow

但：

ReuseRate\downarrow

。

這違反能力累積初衷。

53. 失敗模式：過度重用

反之若：

\theta_U\uparrow

系統可能硬把舊算法套用到不適合的新問題。

因此：

\boxed{ \text{reuse and innovation require dynamic balance} }

。

54. 能力成長函數

可將能力累積寫成：

\mathcal{C}_{t+1} = \mathcal{C}_t + \Delta\mathcal{A} + \Delta\mathcal{W} + \Delta H_{\mathrm{execution}} + \Delta M_{\mathrm{failure}} + \Delta M_{\mathrm{selection}}

。

其中：

\Delta\mathcal{A}

是新算法；

\Delta\mathcal{W}

是新方法鏈；

\Delta H_{\mathrm{execution}}

是執行經驗；

\Delta M_{\mathrm{failure}}

是失敗知識；

\Delta M_{\mathrm{selection}}

是調度經驗。

55. 從知識累積到能力累積

Paper 04 的世界擴張是：

\text{more effective world structure}

。

Paper 05 則新增：

\text{more effective capability structure}

。

因此：

\boxed{ \text{Intelligence Growth} = \text{World Model Growth} + \text{Capability Model Growth} }

。

56. 下一步：算法知道了，但在哪裡執行？

到目前為止，系統已經可以知道：

A_i

該不該用。

但仍有下一個問題：

同一算法應該在哪一種計算載體執行？

若系統只能假設單一傳統計算機，那麼能力模型仍被某個底層架構綁定。

因此下一篇將引入：

\Gamma_i

作為抽象計算容器，並讓算法選擇升級為：

(A^\ast,\Gamma^\ast) = \arg\max_{A_i,\Gamma_j} U(A_i,\Gamma_j\mid Q)

。

57. 結論

一個真正能累積能力的智能系統，不應每次面對任務都重新發明方法。

世界知識告訴系統：

\boxed{ \text{what is the case} }

能力知識則告訴系統：

\boxed{ \text{what can be done} }

以及：

\boxed{ \text{how it was done before} }

。

因此本文提出：

M + \mathcal{A} + \mathcal{W} + H

作為能力累積核心。

其中：

M

是記憶；

\mathcal{A}

是算法庫；

\mathcal{W}

是方法鏈；

H

是執行歷史。

系統的正常優先順序為：

\boxed{ Reuse \succ Adapt \succ Create }

但此順序受適配度、可靠度、新鮮度、風險與成本動態調整。

因此：

\text{previous execution}

不再只是歷史。

它可以被壓縮、索引、驗證並轉換成：

\boxed{ \text{future executable capability} }

。

真正的能力成長，不只是能夠「想出更多方法」，而是能夠：

\boxed{ \text{知道哪些方法已經存在、何時值得重用、何時應修改，以及何時真的必須重新創造} }

。

這一步使自適應世界狀態系統正式跨越：

\text{knowledge system}

走向：

\text{cumulative problem-solving system}

。

附錄 A：最小算法節點

A_i = ( id_i, f_i, I_i, O_i, Pre_i, Post_i, Dep_i, Cost_i, Reliability_i, Version_i, Freshness_i, History_i )

。

附錄 B：最小算法選擇函數

U(A_i\mid Q) = \alpha Match(A_i,Q) + \beta Reliability(A_i) + \gamma Freshness(A_i) - \delta Cost(A_i) - \epsilon Risk(A_i,Q)

並選擇：

A^\ast = \arg\max_i U(A_i\mid Q)

。

若：

U(A^\ast\mid Q)<\theta_{\mathrm{reuse}}

則進入 Adapt 或 Create。

附錄 C：最小方法鏈

W_k = ( A_1, A_2, \ldots, A_n, Verify )

。

其執行可表示為：

Q \xrightarrow{A_1} Z_1 \xrightarrow{A_2} Z_2 \rightarrow \cdots \xrightarrow{A_n} Z_n \xrightarrow{Verify} Result

。

若其中一步失敗：

A_j \rightarrow Failure

則可根據 workflow contract：

Fallback

Retry

Adapt

或：

Abort

。

附錄 D：完整能力循環

Q \rightarrow Understand \rightarrow Decompose \rightarrow Retrieve(M) \rightarrow Search(\mathcal{A},\mathcal{W}) \rightarrow Evaluate \rightarrow \begin{cases} Reuse\\ Adapt\\ Create \end{cases} \rightarrow Execute \rightarrow Verify \rightarrow Commit \rightarrow Learn

其中：

Learn

反向更新：

M, \mathcal{A}, \mathcal{W}, Reliability, Freshness, FailureMode

。

這使：

\boxed{ \text{every task can become reusable capability} }

。

記憶、算法庫與可重用問題求解路徑 — ——從世界模型到能力模型的累積式智能架構