從動態圖到可執行符號系統
——自然語言作為世界狀態的 Rendering，而非 Canonical State
Series: Adaptive Epistemic Systems SeriesPaper: 3 / 11Version: v0.1Language: zh-TWStatus: Complete Draft / Canonical UTF-8 Source
摘要
若一個自適應世界狀態系統只能保存節點、關係、可信度、新鮮度與更新張力，卻無法將其轉換成可操作、可計算、可交換與可表達的形式，那麼它仍然只是一個動態狀態庫，而不是完整的可執行智能架構。本文在前兩篇所提出的非對稱時空張力與動態新鮮度模型之上，引入一個可執行符號層，將世界狀態、命題、規則、事件、算法、外部系統與輸出表達統一映射為具有明確語義與操作規則的 canonical symbolic state。
本文核心主張是：自然語言不應被直接等同於系統內部的 canonical state。文字可以作為輸入，也可以作為輸出，但在內部應經過解析、正規化、語義綁定與來源標記，轉換為可比較、可驗證、可更新的符號結構。反之，最終文字輸出則應由內部符號狀態經 rendering 生成，而不是讓文字本身承擔所有推理、記憶與狀態一致性責任。
本文提出四層結構：世界狀態層、canonical 符號層、可執行操作層與 rendering 層；並進一步定義符號型別、命題結構、規則、操作契約、輸入正規化、輸出投影、自我生成內容的來源隔離與 round-trip consistency。本文同時分析自然語言作為內部主狀態所造成的歧義、同義異構、上下文依賴與自我污染問題，並提出將自然語言視為介面而非本體的架構原則。
在此框架下，文字、表格、程式碼、圖結構、數值、指令與外部動作都只是同一 canonical state 的不同輸出投影。由此，系統不再被限定為「文字生成器」，而成為一個可從多種輸入映射到統一內部狀態，再經計算與驗證後映射到多種輸出介面的自適應符號計算系統。
關鍵詞： canonical state、符號系統、自然語言 rendering、可執行語義、狀態正規化、輸入解析、輸出投影、來源隔離、round-trip consistency、自適應智能系統
1. 問題：世界狀態如何變成可計算的東西？
前兩篇建立了：
G t \mathcal{G}_t G t 作為動態世界狀態圖，並為節點配置：
S i , F i , T i , I i , C i S_i,
F_i,
T_i,
I_i,
C_i S i , F i , T i , I i , C i 等屬性。
但若系統只知道：
v i v_i v i 存在，卻不知道如何把：
v i v_i v i 轉換成可執行命題、條件、規則、查詢或輸出，那麼它仍缺少一個關鍵中介。
因此需要：
World State → Symbolic State → Executable Operation \boxed{
\text{World State}
\rightarrow
\text{Symbolic State}
\rightarrow
\text{Executable Operation}
} World State → Symbolic State → Executable Operation 。
令：
Z t Z_t Z t 表示時間 t t t
則完整系統不再只有：
G t \mathcal{G}_t G t 而是：
S t = ( G t , Z t ) \mathfrak{S}_t
=
\left(
\mathcal{G}_t,
Z_t
\right) S t = ( G t , Z t ) 。
其中：
G t \mathcal{G}_t G t 描述「世界目前如何被系統表示」；
Z t Z_t Z t 描述「這些狀態如何被正式編碼、引用、計算與交換」。
2. 為什麼自然語言不能直接當 canonical state？
自然語言非常適合人類溝通，但不適合單獨承擔內部 canonical state。
原因至少有四個。
2.1 同義異構
不同句子可能表達近似相同內容：
T 1 ≠ T 2 T_1\neq T_2 T 1 = T 2 但：
M e a n i n g ( T 1 ) ≈ M e a n i n g ( T 2 ) Meaning(T_1)\approx Meaning(T_2) M e anin g ( T 1 ) ≈ M e anin g ( T 2 ) 。
例如：
A 導致 B。
與：
B 是由 A 所造成。
文字不同，但核心關係接近：
C A U S E ( A , B ) CAUSE(A,B) C A U S E ( A , B ) 。
若內部直接保存文字，系統可能建立兩筆重複知識。
2.2 同形異義
相同文字在不同上下文可能代表不同內容：
T 1 = T 2 T_1=T_2 T 1 = T 2 但：
M e a n i n g ( T 1 ∣ C 1 ) ≠ M e a n i n g ( T 2 ∣ C 2 ) Meaning(T_1\mid C_1)
\neq
Meaning(T_2\mid C_2) M e anin g ( T 1 ∣ C 1 ) = M e anin g ( T 2 ∣ C 2 ) 。
因此字串相等不能被當成語義相等。
2.3 省略與隱含
自然語言大量依賴省略：
他昨天改了。
系統必須知道：
W h o ( 他 ) Who(\text{他}) W h o ( 他 ) W h a t ( 改了 ) What(\text{改了}) W ha t ( 改了 ) W h e n ( 昨天 ) When(\text{昨天}) W h e n ( 昨天 ) 才能形成可驗證狀態。
文字本身不足以提供完整 canonical semantics。
2.4 修辭與非字面語義
自然語言可能包含：
metaphor , irony , hyperbole , fiction , quotation \text{metaphor},
\text{irony},
\text{hyperbole},
\text{fiction},
\text{quotation} metaphor , irony , hyperbole , fiction , quotation 。
若所有文字都被直接寫入世界狀態，系統會把：
世界末日了。
與：
W O R L D _ E N D = T r u e WORLD\_END=True W O R L D _ E N D = T r u e 混為一談。
因此：
text ≠ canonical world state \boxed{
\text{text}
\neq
\text{canonical world state}
} text = canonical world state 。
3. 四層架構
本文提出四層：
W → Z → E → R \boxed{
W
\rightarrow
Z
\rightarrow
E
\rightarrow
R
} W → Z → E → R 其中：
W W W 為 world-state layer；
Z Z Z 為 canonical symbolic layer；
E E E 為 executable operation layer；
R R R 為 rendering layer。
完整形式可寫成：
S = ( W , Z , E , R ) \mathfrak{S}
=
(
W,
Z,
E,
R
) S = ( W , Z , E , R ) 。
3.1 世界狀態層
保存：
G t = ( V t , E t , W t , X t , B t , S t , T t , Λ t , I t ) \mathcal{G}_t
=
(
V_t,
E_t,
W_t,
X_t,
B_t,
S_t,
T_t,
\Lambda_t,
I_t
) G t = ( V t , E t , W t , X t , B t , S t , T t , Λ t , I t ) 。
3.2 Canonical 符號層
保存可比較、可引用、可驗證的正式語義：
Z t = { z 1 , z 2 , … , z n } Z_t
=
\{
z_1,
z_2,
\ldots,
z_n
\} Z t = { z 1 , z 2 , … , z n } 。
3.3 可執行操作層
提供：
O = { o p 1 , o p 2 , … , o p m } \mathcal{O}
=
\{
op_1,
op_2,
\ldots,
op_m
\} O = { o p 1 , o p 2 , … , o p m } 使符號狀態可以被變換。
3.4 Rendering 層
將 canonical state 投影成：
text , table , code , graph , number , command , action \text{text},
\text{table},
\text{code},
\text{graph},
\text{number},
\text{command},
\text{action} text , table , code , graph , number , command , action 。
4. Canonical Symbolic State 的最小形式
一個 canonical symbol 可以寫成：
z i = ( i d i , t y p e i , v a l u e i , a r g s i , c o n t e x t i , s o u r c e i , c o n f i d e n c e i , t i m e i , s t a t u s i ) z_i
=
(
id_i,
type_i,
value_i,
args_i,
context_i,
source_i,
confidence_i,
time_i,
status_i
) z i = ( i d i , t y p e i , v a l u e i , a r g s i , co n t e x t i , so u r c e i , co n f i d e n c e i , t im e i , s t a t u s i ) 其中：
i d i id_i i d i 是穩定識別碼；
t y p e i type_i t y p e i 是型別；
v a l u e i value_i v a l u e i 是核心值；
a r g s i args_i a r g s i 是參數；
c o n t e x t i context_i co n t e x t i 是上下文；
s o u r c e i source_i so u r c e i 是來源；
c o n f i d e n c e i confidence_i co n f i d e n c e i 是可信度；
t i m e i time_i t im e i 是時間狀態；
s t a t u s i status_i s t a t u s i 表示 active、deprecated、hypothesis、verified 等狀態。
這樣同一個概念即使有不同自然語言表述，也可以指向同一個：
i d i id_i i d i 。
5. 符號型別
為避免所有節點都只是無型別字串，可以至少定義：
Σ = { Σ e n t i t y , Σ r e l a t i o n , Σ e v e n t , Σ p r e d i c a t e , Σ r u l e , Σ q u a n t i t y , Σ h y p o t h e s i s , Σ a l g o r i t h m , Σ s y s t e m } \Sigma
=
\{
\Sigma_{\mathrm{entity}},
\Sigma_{\mathrm{relation}},
\Sigma_{\mathrm{event}},
\Sigma_{\mathrm{predicate}},
\Sigma_{\mathrm{rule}},
\Sigma_{\mathrm{quantity}},
\Sigma_{\mathrm{hypothesis}},
\Sigma_{\mathrm{algorithm}},
\Sigma_{\mathrm{system}}
\} Σ = { Σ entity , Σ relation , Σ event , Σ predicate , Σ rule , Σ quantity , Σ hypothesis , Σ algorithm , Σ system } 。
例如：
P e r s o n ( N e o ) Person(Neo) P er so n ( N eo ) 可以是一個 entity；
C A U S E ( A , B ) CAUSE(A,B) C A U S E ( A , B ) 是一個 relation；
E v e n t ( C h a n g e L a w , t ) Event(ChangeLaw,t) E v e n t ( C han g e L a w , t ) 是一個 event；
I F ( A ) → B IF(A)\rightarrow B I F ( A ) → B 是一個 rule；
P r i c e ( X , t ) = 100 Price(X,t)=100 P r i ce ( X , t ) = 100 是一個 quantity。
不同型別允許不同更新與驗證規則。
6. 命題層
一個命題可表示為：
p = P r e d i c a t e ( a 1 , … , a n ) p
=
Predicate(a_1,\ldots,a_n) p = P r e d i c a t e ( a 1 , … , a n ) 。
例如：
C E O ( C o m p a n y X , P e r s o n Y , t ) CEO(CompanyX,PersonY,t) C E O ( C o m p an y X , P er so nY , t ) 。
這類命題可以附加：
C o n f i d e n c e ( p ) Confidence(p) C o n f i d e n ce ( p ) F r e s h n e s s ( p ) Freshness(p) F r es hn ess ( p ) S o u r c e ( p ) Source(p) S o u r ce ( p ) V a l i d T i m e ( p ) ValidTime(p) V a l i d T im e ( p ) 。
因此，系統不只保存：
PersonY 是 CompanyX 的 CEO。
而是保存：
p = C E O ( C o m p a n y X , P e r s o n Y , t ) p
=
CEO(CompanyX,PersonY,t) p = C E O ( C o m p an y X , P er so nY , t ) 以及與其有效性相關的狀態。
7. 事件層
世界變化通常由事件驅動。
定義：
e = E v e n t ( t y p e , p a r t i c i p a n t s , t i m e , l o c a t i o n , e f f e c t s ) e
=
Event(
type,
participants,
time,
location,
effects
) e = E v e n t ( t y p e , p a r t i c i p an t s , t im e , l oc a t i o n , e f f ec t s ) 。
例如：
e 1 = E v e n t ( A p p o i n t m e n t , C o m p a n y X , P e r s o n Y , t 1 ) e_1
=
Event(
Appointment,
CompanyX,
PersonY,
t_1
) e 1 = E v e n t ( A pp o in t m e n t , C o m p an y X , P er so nY , t 1 ) 。
事件經過規則可以產生狀態更新：
e 1 ⇒ C E O ( C o m p a n y X , P e r s o n Y , t ≥ t 1 ) e_1
\Rightarrow
CEO(CompanyX,PersonY,t\ge t_1) e 1 ⇒ C E O ( C o m p an y X , P er so nY , t ≥ t 1 ) 。
因此：
event \text{event} event 與：
state \text{state} state 必須區分。
事件是變化發生；
狀態是變化後世界如何被表示。
8. 規則層
可執行符號系統需要規則。
定義：
r i : P r e i → P o s t i r_i:
Pre_i
\rightarrow
Post_i r i : P r e i → P os t i 。
例如：
I F A p p o i n t m e n t ( c , p , t ) ∧ V a l i d A p p o i n t m e n t ( c , p ) IF\;
Appointment(c,p,t)
\land
ValidAppointment(c,p) I F A pp o in t m e n t ( c , p , t ) ∧ V a l i d A pp o in t m e n t ( c , p ) 則：
C E O ( c , p , t + ) CEO(c,p,t^+) C E O ( c , p , t + ) 。
規則還可以加入：
I n v a r i a n t i Invariant_i I n v a r ian t i 與：
F a i l u r e i Failure_i F ai l u r e i 。
因此完整規則可寫成：
r i = ( P r e i , T r a n s f o r m i , P o s t i , I n v a r i a n t i , F a i l u r e i ) r_i
=
(
Pre_i,
Transform_i,
Post_i,
Invariant_i,
Failure_i
) r i = ( P r e i , T r an s f or m i , P os t i , I n v a r ian t i , F ai l u r e i ) 。
這使規則不只是文字敘述，而是正式可執行結構。
9. 輸入不是直接寫入世界
定義輸入：
I t I_t I t 。
無論輸入來自：
I t e x t , I n u m b e r , I i m a g e , I s e n s o r , I s y s t e m I_{\mathrm{text}},
I_{\mathrm{number}},
I_{\mathrm{image}},
I_{\mathrm{sensor}},
I_{\mathrm{system}} I text , I number , I image , I sensor , I system 都不應直接寫入 canonical world state。
而應先經過：
P a r s e Parse P a r se N o r m a l i z e Normalize N or ma l i z e R e s o l v e Resolve R eso l v e V a l i d a t e Validate V a l i d a t e 。
即：
I t → P t → N t → R t → V t → Z t I_t
\rightarrow
P_t
\rightarrow
N_t
\rightarrow
R_t
\rightarrow
V_t
\rightarrow
Z_t I t → P t → N t → R t → V t → Z t 。
其中：
P t P_t P t 是 parsing；
N t N_t N t 是 normalization；
R t R_t R t 是 reference resolution；
V t V_t V t 是 validation。
10. 自然語言輸入的正規化
假設輸入：
A 昨天可能造成了 B。
系統不應直接保存原句作為事實。
而應轉換為：
H y p o t h e s i s ( C A U S E ( A , B ) , t i m e = t − 1 d , c o n f i d e n c e = c ) Hypothesis(
CAUSE(A,B),
time=t-1d,
confidence=c
) H y p o t h es i s ( C A U S E ( A , B ) , t im e = t − 1 d , co n f i d e n ce = c ) 其中：
0 < c < 1 0<c<1 0 < c < 1 。
如果「昨天」依賴使用者當下時間，則必須解析成絕對時間：
t a b s o l u t e t_{\mathrm{absolute}} t absolute 。
因此：
surface text → resolved symbolic proposition \text{surface text}
\rightarrow
\text{resolved symbolic proposition} surface text → resolved symbolic proposition 是必要步驟。
11. Canonical State 與表面文字分離
令：
ρ t e x t \rho_{\mathrm{text}} ρ text 表示文字 rendering 函數。
則：
T e x t = ρ t e x t ( Z q ) Text
=
\rho_{\mathrm{text}}
\left(
Z_q
\right) T e x t = ρ text ( Z q ) 其中：
Z q ⊆ Z Z_q
\subseteq Z Z q ⊆ Z 是與查詢相關的 canonical symbolic substate。
因此：
text generation = state projection \boxed{
\text{text generation}
=
\text{state projection}
} text generation = state projection 而不是：
text generation = the entire reasoning process \boxed{
\text{text generation}
=
\text{the entire reasoning process}
} text generation = the entire reasoning process 。
這是本文最重要的架構分離之一。
12. 多重輸出投影
同一個 canonical state 可以有不同 rendering。
令：
ρ k \rho_k ρ k 表示第 k k k
則：
O k = ρ k ( Z q ) O_k
=
\rho_k(Z_q) O k = ρ k ( Z q ) 。
例如：
ρ t e x t \rho_{\mathrm{text}} ρ text 輸出文字；
ρ t a b l e \rho_{\mathrm{table}} ρ table 輸出表格；
ρ g r a p h \rho_{\mathrm{graph}} ρ graph 輸出圖；
ρ c o d e \rho_{\mathrm{code}} ρ code 輸出程式；
ρ c o m m a n d \rho_{\mathrm{command}} ρ command 輸出命令；
ρ a c t i o n \rho_{\mathrm{action}} ρ action 輸出外部動作。
因此：
Z → { O 1 , O 2 , … , O n } \boxed{
Z
\rightarrow
\{O_1,O_2,\ldots,O_n\}
} Z → { O 1 , O 2 , … , O n } 。
文字只是其中之一。
13. Output-Time Validation
輸出前不應只問：
我能不能生成一句話？
而應問：
這句話引用的 canonical state 是否仍符合當前任務的新鮮度與可信度要求？
令：
D e p s ( O ) Deps(O) D e p s ( O ) 表示輸出 O O O
輸出前檢查：
∀ v i ∈ D e p s ( O ) , F i ( t ∣ q ) ≥ θ i F \forall v_i\in Deps(O),
\quad
F_i(t\mid q)\ge\theta_i^F ∀ v i ∈ D e p s ( O ) , F i ( t ∣ q ) ≥ θ i F 以及：
C i ≥ θ i C C_i\ge\theta_i^C C i ≥ θ i C 。
若某節點不滿足：
F i < θ i F F_i<\theta_i^F F i < θ i F 則先觸發：
R e v a l i d a t e ( v i ) Revalidate(v_i) R e v a l i d a t e ( v i ) 。
因此：
Q → R e l e v a n t S u b g r a p h → F r e s h n e s s C h e c k → S e l e c t i v e U p d a t e → R e n d e r Q
\rightarrow
RelevantSubgraph
\rightarrow
FreshnessCheck
\rightarrow
SelectiveUpdate
\rightarrow
Render Q → R e l e v an tS u b g r a p h → F r es hn ess C h ec k → S e l ec t i v e U p d a t e → R e n d er 。
14. 查詢本身是一種局部喚醒
使用者問題：
Q t Q_t Q t 不只是要求文字輸出，也是一個動態喚醒事件。
定義：
R e l ( v i , Q t ) Rel(v_i,Q_t) R e l ( v i , Q t ) 表示節點與查詢的相關性。
則：
T i ′ ( t ) = T i ( t ) + α R e l ( v i , Q t ) T_i'(t)
=
T_i(t)
+
\alpha Rel(v_i,Q_t) T i ′ ( t ) = T i ( t ) + α R e l ( v i , Q t ) 。
因此查詢可以提高某些節點的更新張力。
這使系統不需要預先將整個世界更新至「完美最新」，而可以：
update on demand where the query makes freshness valuable \boxed{
\text{update on demand where the query makes freshness valuable}
} update on demand where the query makes freshness valuable 。
15. 可執行操作與符號狀態
操作函數：
o p k op_k o p k 接受 canonical symbolic state：
o p k : Z i n → Z o u t op_k:
Z_{\mathrm{in}}
\rightarrow
Z_{\mathrm{out}} o p k : Z in → Z out 。
例如：
C o m p a r e ( a , b ) Compare(a,b) C o m p a r e ( a , b ) I n f e r ( p 1 , p 2 ) Infer(p_1,p_2) I n f er ( p 1 , p 2 ) U p d a t e ( v i ) Update(v_i) U p d a t e ( v i ) M e r g e ( v i , v j ) Merge(v_i,v_j) M er g e ( v i , v j ) V e r i f y ( p ) Verify(p) V er i f y ( p ) 。
因此可執行層不需要依賴自然語言。
自然語言只是可能的：
I n p u t A d a p t e r InputAdapter I n p u t A d a pt er 或：
O u t p u t A d a p t e r OutputAdapter O u tp u t A d a pt er 。
16. 操作契約
每個操作應有明確契約：
C o n t r a c t ( o p i ) = ( P r e i , P o s t i , I n v a r i a n t i , F a i l u r e i ) Contract(op_i)
=
(
Pre_i,
Post_i,
Invariant_i,
Failure_i
) C o n t r a c t ( o p i ) = ( P r e i , P os t i , I n v a r ian t i , F ai l u r e i ) 。
例如：
P r e i Pre_i P r e i 規定輸入型別；
P o s t i Post_i P os t i 規定正常輸出；
I n v a r i a n t i Invariant_i I n v a r ian t i 規定執行期間不可破壞的狀態；
F a i l u r e i Failure_i F ai l u r e i 規定失敗形式。
這使系統可以在調用操作後驗證：
V e r i f y ( P o s t i ) Verify(Post_i) V er i f y ( P os t i ) 而不是只接受任意輸出。
17. 自我生成文字不能自動成為證據
如果系統輸出的文字可以再次被讀入，會形成：
O t → I t + 1 O_t
\rightarrow
I_{t+1} O t → I t + 1 。
若沒有來源隔離，系統可能產生：
I generated X ⇒ X is evidence ⇒ I believe X more \text{I generated X}
\Rightarrow
\text{X is evidence}
\Rightarrow
\text{I believe X more} I generated X ⇒ X is evidence ⇒ I believe X more 的自我強化。
因此每個符號應標記：
s r c ( z ) ∈ { e x t e r n a l , o b s e r v e d , c o m p u t e d , i n f e r r e d , s e l f _ g e n e r a t e d , q u o t e d } src(z)
\in
\{
external,
observed,
computed,
inferred,
self\_generated,
quoted
\} sr c ( z ) ∈ { e x t er na l , o b ser v e d , co m p u t e d , in f er r e d , se l f _ g e n er a t e d , q u o t e d } 。
不同來源具有不同證據權重。
一般應避免：
s e l f _ g e n e r a t e d ≡ e x t e r n a l self\_generated
\equiv
external se l f _ g e n er a t e d ≡ e x t er na l 。
18. 自我引用與來源污染
若：
z 1 z_1 z 1 由系統自身生成，
再被當作新證據產生：
z 2 z_2 z 2 則需要追蹤：
P r o v ( z 2 ) ⊇ P r o v ( z 1 ) Prov(z_2)
\supseteq
Prov(z_1) P r o v ( z 2 ) ⊇ P r o v ( z 1 ) 。
這使系統可以辨認：
z 2 z_2 z 2 是否只是：
z 1 z_1 z 1 的再表述，而非獨立證據。
因此：
provenance must survive transformation \boxed{
\text{provenance must survive transformation}
} provenance must survive transformation 。
否則系統可能將一個來源經過十次改寫後誤認為十份獨立證據。
19. Round-Trip Consistency
若文字是 rendering，則可以檢驗：
Z → ρ t e x t T → π t e x t Z ^ Z
\xrightarrow{\rho_{\mathrm{text}}}
T
\xrightarrow{\pi_{\mathrm{text}}}
\widehat{Z} Z ρ text T π text Z 其中：
π t e x t \pi_{\mathrm{text}} π text 為文字解析器。
理想上：
Z ^ ≈ Z \widehat{Z}\approx Z Z ≈ Z 。
這不要求逐字相同，而要求語義保持。
定義：
D Z ( Z , Z ^ ) D_Z(Z,\widehat{Z}) D Z ( Z , Z ) 為 canonical state distance。
則：
D Z ( Z , Z ^ ) < ϵ D_Z(Z,\widehat{Z})<\epsilon D Z ( Z , Z ) < ϵ 表示 round-trip consistency 可接受。
這可以用來測試輸出 rendering 是否在語義上破壞內部狀態。
20. Lossy Rendering 是允許的
自然語言通常是壓縮表達。
因此不要求：
ρ t e x t \rho_{\mathrm{text}} ρ text 保留所有內部資訊。
例如內部可能保存：
C o n f i d e n c e = 0.731 Confidence=0.731 C o n f i d e n ce = 0.731 F r e s h n e s s = 0.842 Freshness=0.842 F r es hn ess = 0.842 S o u r c e C o u n t = 17 SourceCount=17 S o u r ce C o u n t = 17 但文字只說：
目前證據中度支持此命題。
因此 rendering 可以是：
Z → T Z
\rightarrow
T Z → T 的有損投影。
但若使用者要求完整輸出，系統可以切換：
ρ d e t a i l e d \rho_{\mathrm{detailed}} ρ detailed 。
關鍵不是所有 rendering 都無損，而是：
the canonical state is not lost merely because one rendering is compressed \boxed{
\text{the canonical state is not lost merely because one rendering is compressed}
} the canonical state is not lost merely because one rendering is compressed 。
21. 語言表達與世界承諾分離
輸出一句：
A 很可能導致 B。
不應自動等同：
C A U S E ( A , B ) = T r u e CAUSE(A,B)=True C A U S E ( A , B ) = T r u e 。
更合理的是：
O u t p u t C o m m i t m e n t = ( P r o p o s i t i o n , M o d a l i t y , C o n f i d e n c e , S c o p e ) OutputCommitment
=
(
Proposition,
Modality,
Confidence,
Scope
) O u tp u tC o mmi t m e n t = ( P r o p os i t i o n , M o d a l i t y , C o n f i d e n ce , S co p e ) 。
例如：
( C A U S E ( A , B ) , P o s s i b l e , 0.67 , C o n t e x t = C ) (
CAUSE(A,B),
Possible,
0.67,
Context=C
) ( C A U S E ( A , B ) , P oss ib l e , 0.67 , C o n t e x t = C ) 。
這使「文字語氣」與「系統實際信念」可以被正式對齊。
22. 模態與認識論標記
canonical symbolic layer 應支持：
T r u e True T r u e F a l s e False F a l se U n k n o w n Unknown U nk n o w n P o s s i b l e Possible P oss ib l e P r o b a b l e Probable P r o bab l e H y p o t h e s i s Hypothesis H y p o t h es i s C o u n t e r f a c t u a l Counterfactual C o u n t er f a c t u a l F i c t i o n a l Fictional F i c t i o na l Q u o t e d Quoted Q u o t e d 等模態。
因此：
假設 A 發生，B 可能發生。
不應被寫成：
A = T r u e A=True A = T r u e 或：
B = T r u e B=True B = T r u e 。
而應表示為：
C o u n t e r f a c t u a l ( A ⇒ P o s s i b l e ( B ) ) Counterfactual(
A
\Rightarrow
Possible(B)
) C o u n t er f a c t u a l ( A ⇒ P oss ib l e ( B )) 。
23. 文字生成只是 Renderer，推理則可以完全不同
系統內部推理可以由：
graph traversal \text{graph traversal} graph traversal logic \text{logic} logic probability \text{probability} probability optimization \text{optimization} optimization algorithm execution \text{algorithm execution} algorithm execution 完成。
文字 rendering 只需要：
ρ t e x t : Z q → T \rho_{\mathrm{text}}:
Z_q
\rightarrow
T ρ text : Z q → T 。
因此即使替換文字生成模組：
ρ t e x t ( 1 ) → ρ t e x t ( 2 ) \rho_{\mathrm{text}}^{(1)}
\rightarrow
\rho_{\mathrm{text}}^{(2)} ρ text ( 1 ) → ρ text ( 2 ) 只要：
Z q Z_q Z q 保持不變，系統的 canonical world state 仍然保持。
這是一個非常重要的架構測試。
24. 語言模組可替換性測試
令：
L 1 , L 2 , L 3 L_1,
L_2,
L_3 L 1 , L 2 , L 3 為不同語言模組。
若：
Z t ( L 1 ) ≈ Z t ( L 2 ) ≈ Z t ( L 3 ) Z_t^{(L_1)}
\approx
Z_t^{(L_2)}
\approx
Z_t^{(L_3)} Z t ( L 1 ) ≈ Z t ( L 2 ) ≈ Z t ( L 3 ) 且最終差異主要存在於：
ρ t e x t \rho_{\mathrm{text}} ρ text 則代表語言模組不是 canonical state 的唯一持有者。
反之，若替換語言模組後：
Z t Z_t Z t 本身大量崩解或無法維持，則表示系統的高階狀態仍依賴語言模組。
這一測試將在後續智能架構比較中非常重要。
25. 從「生成答案」到「編譯答案」
當 canonical state 與 rendering 分離後，輸出過程可以被重新理解為：
compile a representation from verified state \boxed{
\text{compile a representation from verified state}
} compile a representation from verified state 。
也就是：
Q → Z q → V a l i d a t e → P l a n R e p r e s e n t a t i o n → R e n d e r Q
\rightarrow
Z_q
\rightarrow
Validate
\rightarrow
PlanRepresentation
\rightarrow
Render Q → Z q → V a l i d a t e → P l an R e p r ese n t a t i o n → R e n d er 。
此時答案不是完全從空白生成，而是從已解析、已驗證的內部狀態編譯成使用者要求的表達形式。
26. 多語言不再代表多個世界模型
若 canonical state 與語言分離，則：
ρ z h \rho_{\mathrm{zh}} ρ zh ρ e n \rho_{\mathrm{en}} ρ en ρ j a \rho_{\mathrm{ja}} ρ ja 可以對同一：
Z q Z_q Z q 進行不同 rendering。
因此：
Z q → { T e x t z h , T e x t e n , T e x t j a } Z_q
\rightarrow
\{
Text_{\mathrm{zh}},
Text_{\mathrm{en}},
Text_{\mathrm{ja}}
\} Z q → { T e x t zh , T e x t en , T e x t ja } 。
這意味著多語言能力理論上不必維護多套完全獨立世界狀態。
27. 符號層與圖層的雙向映射
定義：
ϕ : G → Z \phi:
\mathcal{G}
\rightarrow
Z ϕ : G → Z 將世界圖映射成 canonical symbol；
以及：
ψ : Z → G \psi:
Z
\rightarrow
\mathcal{G} ψ : Z → G 將符號更新重新寫回世界圖。
理想上：
ψ ( ϕ ( G ) ) ≈ G \psi(\phi(\mathcal{G}))
\approx
\mathcal{G} ψ ( ϕ ( G )) ≈ G 。
這提供另一個 consistency test：
D G ( G , ψ ( ϕ ( G ) ) ) < ϵ D_G
\left(
\mathcal{G},
\psi(\phi(\mathcal{G}))
\right)
<
\epsilon D G ( G , ψ ( ϕ ( G )) ) < ϵ 。
28. 狀態變更必須先驗證再提交
新的符號狀態：
Z ′ Z' Z ′ 不應自動覆寫：
Z Z Z 。
而應經過：
C a n d i d a t e → V a l i d a t e → C o m m i t Candidate
\rightarrow
Validate
\rightarrow
Commit C an d i d a t e → V a l i d a t e → C o mmi t 。
即：
Z t → o p Z t + 1 c a n d i d a t e Z_t
\xrightarrow{op}
Z_{t+1}^{\mathrm{candidate}} Z t o p Z t + 1 candidate 若：
V a l i d a t e ( Z t + 1 c a n d i d a t e ) = T r u e Validate
\left(
Z_{t+1}^{\mathrm{candidate}}
\right)
=True V a l i d a t e ( Z t + 1 candidate ) = T r u e 才：
C o m m i t ( Z t + 1 c a n d i d a t e ) Commit
\left(
Z_{t+1}^{\mathrm{candidate}}
\right) C o mmi t ( Z t + 1 candidate ) 。
否則：
R o l l b a c k Rollback R o l l ba c k 或保持 hypothesis 狀態。
這使符號層具有 transactional semantics。
29. Canonical State 的不變量
至少可以要求：
29.1 識別一致性
i d i = i d i id_i=id_i i d i = i d i 不能因 rendering 改變而改變。
29.2 型別一致性
若：
t y p e ( z i ) = Q u a n t i t y type(z_i)=Quantity t y p e ( z i ) = Q u an t i t y 則不能突然在無轉換規則下成為：
P e r s o n Person P er so n 。
29.3 來源可追溯
P r o v ( z i ) ≠ ∅ Prov(z_i)\neq\varnothing P r o v ( z i ) = ∅ 對外部事實節點應盡可能成立。
29.4 時間語義明確
V a l i d T i m e ( z i ) ValidTime(z_i) V a l i d T im e ( z i ) 與：
O b s e r v e d T i m e ( z i ) ObservedTime(z_i) O b ser v e d T im e ( z i ) 應區分。
29.5 Rendering 不改寫真值
ρ k \rho_k ρ k 只能投影，不應自行改變 canonical commitment。
30. 可驗證命題
命題一：Canonical State 可降低同義重複
若語言表達先經正規化：
D u p l i c a t e R a t e c a n o n i c a l < D u p l i c a t e R a t e r a w − t e x t DuplicateRate_{\mathrm{canonical}}
<
DuplicateRate_{\mathrm{raw-text}} D u pl i c a t e R a t e canonical < D u pl i c a t e R a t e raw − text 應在多樣化表述輸入中成立。
命題二：來源隔離可降低自我強化污染
若自生成內容與外部證據具有不同 provenance：
F a l s e C o n f i d e n c e i s o l a t e d < F a l s e C o n f i d e n c e u n t r a c k e d FalseConfidence_{\mathrm{isolated}}
<
FalseConfidence_{\mathrm{untracked}} F a l se C o n f i d e n c e isolated < F a l se C o n f i d e n c e untracked 應在自我引用測試中成立。
命題三：Output-Time Validation 可降低過時回答
若輸出前進行相關節點新鮮度檢查：
S t a l e A n s w e r R a t e v a l i d a t e d < S t a l e A n s w e r R a t e d i r e c t StaleAnswerRate_{\mathrm{validated}}
<
StaleAnswerRate_{\mathrm{direct}} S t a l e A n s w er R a t e validated < S t a l e A n s w er R a t e direct 。
命題四：Renderer 可替換性
若系統狀態真正獨立於語言 renderer，則替換：
ρ t e x t \rho_{\mathrm{text}} ρ text 不應造成：
D Z ( Z t , Z t ′ ) ≫ 0 D_Z(Z_t,Z_t')\gg0 D Z ( Z t , Z t ′ ) ≫ 0 。
命題五：Round-Trip 可作為語義保持測試
不同 rendering / parsing 配對之：
D Z ( Z , Z ^ ) D_Z(Z,\widehat{Z}) D Z ( Z , Z ) 應可被量化，並用於比較語言接口品質。
31. 最小實驗
建立 canonical symbolic set：
Z ∗ Z^\ast Z ∗ 其中包含：
事實；
假設；
時間條件；
因果關係；
不確定性；
引用；
反事實。
生成多組不同自然語言 rendering：
T 1 , … , T n T_1,\ldots,T_n T 1 , … , T n 再解析回：
Z ^ 1 , … , Z ^ n \widehat{Z}_1,\ldots,\widehat{Z}_n Z 1 , … , Z n 。
測量：
D Z ( Z ∗ , Z ^ i ) D_Z
\left(
Z^\ast,
\widehat{Z}_i
\right) D Z ( Z ∗ , Z i ) 。
同時比較：
raw text memory \text{raw text memory} raw text memory 與：
canonical symbolic memory \text{canonical symbolic memory} canonical symbolic memory 在長期重複輸入、同義改寫、語境切換與自我引用下的狀態一致性。
32. 與傳統文字中心系統的核心差異
文字中心系統可抽象為：
C o n t e x t → T e x t Context
\rightarrow
Text C o n t e x t → T e x t 。
本文系統則是：
I n p u t → P a r s e → C a n o n i c a l S t a t e → C o m p u t e → V a l i d a t e → R e n d e r → O u t p u t Input
\rightarrow
Parse
\rightarrow
CanonicalState
\rightarrow
Compute
\rightarrow
Validate
\rightarrow
Render
\rightarrow
Output I n p u t → P a r se → C an o ni c a l S t a t e → C o m p u t e → V a l i d a t e → R e n d er → O u tp u t 。
因此：
language is an interface to intelligence, not necessarily the state substrate of intelligence \boxed{
\text{language is an interface to intelligence, not necessarily the state substrate of intelligence}
} language is an interface to intelligence, not necessarily the state substrate of intelligence 。
這不否認語言本身可以承載大量推理，而只是拒絕將：
surface linguistic sequence \text{surface linguistic sequence} surface linguistic sequence 直接等同於：
entire internal epistemic state \text{entire internal epistemic state} entire internal epistemic state 。
33. 從單一輸出系統到多介面世界模型
若：
Z Z Z 是 canonical state，
則同一內部狀態可以支援：
Z → T e x t Z
\rightarrow
Text Z → T e x t Z → C o d e Z
\rightarrow
Code Z → C o d e Z → G r a p h Z
\rightarrow
Graph Z → G r a p h Z → C o m m a n d Z
\rightarrow
Command Z → C o mman d Z → A c t i o n Z
\rightarrow
Action Z → A c t i o n 。
因此能力提升不只來自「更會寫文字」，也來自：
more precise state representation \text{more precise state representation} more precise state representation 與：
more reliable state-to-interface compilation \text{more reliable state-to-interface compilation} more reliable state-to-interface compilation 。
34. 最小完整循環
將前三篇統合後，一次完整循環可以寫成：
I t → P a r s e → R e s o l v e → Z t → G t → T t → A c t i v a t e → U ∗ → Z t + 1 c a n d i d a t e → V a l i d a t e → C o m m i t → ρ k → O t I_t
\rightarrow
Parse
\rightarrow
Resolve
\rightarrow
Z_t
\rightarrow
\mathcal{G}_t
\rightarrow
T_t
\rightarrow
Activate
\rightarrow
U^\ast
\rightarrow
Z_{t+1}^{\mathrm{candidate}}
\rightarrow
Validate
\rightarrow
Commit
\rightarrow
\rho_k
\rightarrow
O_t I t → P a r se → R eso l v e → Z t → G t → T t → A c t i v a t e → U ∗ → Z t + 1 candidate → V a l i d a t e → C o mmi t → ρ k → O t 。
其中：
T t T_t T t 控制哪些世界區域需要被重新喚醒；
U ∗ U^\ast U ∗ 選擇適用的更新操作；
V a l i d a t e Validate V a l i d a t e 阻止未驗證狀態直接污染 canonical source；
ρ k \rho_k ρ k 只負責輸出表達。
35. 結論
當世界狀態系統需要真正支援輸入、計算、更新與輸出時，單純的動態圖仍不足夠。
系統需要一個：
canonical executable symbolic layer \boxed{
\text{canonical executable symbolic layer}
} canonical executable symbolic layer 。
自然語言可以是極強大的輸入與輸出介面，但不應自動成為：
the canonical source of world state \boxed{
\text{the canonical source of world state}
} the canonical source of world state 。
因此本文提出：
World State → Canonical Symbolic State → Executable Operations → Rendering \text{World State}
\rightarrow
\text{Canonical Symbolic State}
\rightarrow
\text{Executable Operations}
\rightarrow
\text{Rendering} World State → Canonical Symbolic State → Executable Operations → Rendering 的四層結構。
其中：
T e x t = R e n d e r i n g ( Z ) \boxed{
Text
=
Rendering(Z)
} T e x t = R e n d er in g ( Z ) 而不是：
Z = T e x t \boxed{
Z
=
Text
} Z = T e x t 。
這一分離帶來幾個重要效果：
same meaning ⇒ same canonical identity \text{same meaning}
\Rightarrow
\text{same canonical identity} same meaning ⇒ same canonical identity different language ⇒ different rendering, same state \text{different language}
\Rightarrow
\text{different rendering, same state} different language ⇒ different rendering, same state self-generated text ⇏ external evidence \text{self-generated text}
\not\Rightarrow
\text{external evidence} self-generated text ⇒ external evidence stale dependency ⇒ revalidate before output \text{stale dependency}
\Rightarrow
\text{revalidate before output} stale dependency ⇒ revalidate before output 以及：
renderer replacement ⇏ world-state replacement \text{renderer replacement}
\not\Rightarrow
\text{world-state replacement} renderer replacement ⇒ world-state replacement 。
因此，文字輸出不再是整個系統智能的唯一中心，而只是世界狀態的一種可交換表示。
這使後續研究能進一步處理更大的問題：當世界狀態與符號層可以持續擴張時，系統能力是否能藉由增加有效節點、關係、抽象與世界事實而擴張？而這種擴張究竟會形成真正新的智能結構，還是最終再次收斂到現有 AI 的工程形態？
附錄 A：核心映射
輸入解析：
π k : I k → Z \pi_k:
I_k
\rightarrow
Z π k : I k → Z 世界圖映射：
ϕ : G → Z \phi:
\mathcal{G}
\rightarrow
Z ϕ : G → Z 狀態回寫：
ψ : Z → G \psi:
Z
\rightarrow
\mathcal{G} ψ : Z → G 輸出 rendering：
ρ k : Z → O k \rho_k:
Z
\rightarrow
O_k ρ k : Z → O k 完整介面：
I k → π k Z → o p Z ′ → ρ j O j I_k
\xrightarrow{\pi_k}
Z
\xrightarrow{op}
Z'
\xrightarrow{\rho_j}
O_j I k π k Z o p Z ′ ρ j O j 。
附錄 B：最小 Canonical Symbol Schema
z i = ( i d i , t y p e i , v a l u e i , a r g s i , c o n t e x t i , s o u r c e i , c o n f i d e n c e i , f r e s h n e s s i , v a l i d T i m e i , o b s e r v e d T i m e i , s t a t u s i ) z_i
=
(
id_i,
type_i,
value_i,
args_i,
context_i,
source_i,
confidence_i,
freshness_i,
validTime_i,
observedTime_i,
status_i
) z i = ( i d i , t y p e i , v a l u e i , a r g s i , co n t e x t i , so u r c e i , co n f i d e n c e i , f r es hn es s i , v a l i d T im e i , o b ser v e d T im e i , s t a t u s i ) 。
建議最小 invariant：
i d i ≠ ∅ id_i\neq\varnothing i d i = ∅ t y p e i ≠ ∅ type_i\neq\varnothing t y p e i = ∅ s o u r c e i ≠ ∅ source_i\neq\varnothing so u r c e i = ∅ 對外部事實節點成立；
並且任何 canonical commit 都必須經過：
C a n d i d a t e → V a l i d a t e → C o m m i t Candidate
\rightarrow
Validate
\rightarrow
Commit C an d i d a t e → V a l i d a t e → C o mmi t 而非：
I n p u t → D i r e c t W r i t e Input
\rightarrow
DirectWrite I n p u t → D i r ec t W r i t e 。
附錄 C：最小輸出驗證流程
對查詢 Q Q Q
Q → Z Q Q
\rightarrow
Z_Q Q → Z Q 取得相關 canonical state。
對所有：
z i ∈ Z Q z_i\in Z_Q z i ∈ Z Q 檢查：
F r e s h n e s s i ≥ θ i F ( Q ) Freshness_i\ge\theta_i^F(Q) F r es hn es s i ≥ θ i F ( Q ) C o n f i d e n c e i ≥ θ i C ( Q ) Confidence_i\ge\theta_i^C(Q) C o n f i d e n c e i ≥ θ i C ( Q ) 若不成立：
R e v a l i d a t e ( z i ) Revalidate(z_i) R e v a l i d a t e ( z i ) 。
最後：
O u t p u t = ρ k ( Z Q v a l i d a t e d ) Output
=
\rho_k
\left(
Z_Q^{\mathrm{validated}}
\right) O u tp u t = ρ k ( Z Q validated ) 。
這使輸出不只是生成，而是：
validated state compilation \boxed{
\text{validated state compilation}
} validated state compilation 。