算子先於值

APL算子代數的類型多態重建與算子本體論的實驗性確認

EveMissLab Working Paper 作者：Neo.K（許筌崴） 日期：2026年6月

摘要

本文以 APL（A Programming Language）的核心算子代數為出發點，通過在 Python 環境中的重建實驗，論證以下三項命題：其一，APL 的歷史衰退並非源於概念失敗，而是架構時代的硬性制約；其二，APL 的算子語義——fold、scan、outer、each、fork——在解除數值類型綁定後，能夠無縫升至任意代數結構，並以雙數（Dual Number）自動微分的實現為核心佐證；其三，上述觀察對 EveMissLab 的算子本體論猜想（EML-OO）提供了可計算層面的實驗性支撐。

關鍵詞： APL、算子代數、類型多態、雙數、自動微分、算子本體論、EML-OO

一、問題的起點：一個語言的消失

1962 年，Kenneth Iverson 在其著作 A Programming Language 中提出了一個激進的主張：數學符號本身應當可以執行。他設計了一套以算子為核心的語言，其中每個符號——⍴（reshape）、+/（fold with add）、∘.×（outer product with multiply）——不是函式名稱，而是算子（operator），是作用於函式之上的函式。

APL 在 1960-70 年代短暫登上主流，隨後逐漸邊緣化。通行的解釋指向可讀性差、字符集特殊、學習曲線陡峭。然而這些都是表層症狀，不是病因。

本文的論點是：APL 的真正侷限在於它把算子的語義硬綁在數值陣列上。+/ 的 + 必須是浮點加法。∘.f 的 f 必須接受並回傳數值。算子的通用性被其實作的具體性取消了。

這個侷限不是 Iverson 概念的失敗，而是 1960 年代計算架構的必然結果——沒有泛型、沒有類型參數、沒有高階類型系統。APL 的概念超前了它的時代。

二、重建實驗：解綁類型的算子代數

本文的核心實驗是在 Python 環境下重建 APL 的五個基本算子，並刻意使其對輸入類型保持無知：

def fold(f):
    def _fold(seq): return reduce(f, seq)
    return _fold

def scan(f):
    def _scan(seq):
        it = iter(seq); acc = [next(it)]
        for x in it: acc.append(f(acc[-1], x))
        return acc
    return _scan

def outer(f):
    def _outer(a, b): return [[f(x, y) for y in b] for x in a]
    return _outer

def each(f): return lambda seq: [f(x) for x in seq]

def fork(f, g, h): return lambda seq: g(f(seq), h(seq))

這五個函式的共同特徵是：它們不知道自己操作的是什麼類型。fold 只知道「對序列施加二元運算並累積」；outer 只知道「對所有配對施加二元函式」。類型是自由變數，不是固定參數。

在標準數值域上，這些算子產生 APL 的經典行為：

fold(add)(iota(8))        → 36
scan(mul)(iota(5))        → [1, 2, 6, 24, 120]
outer(mul)(iota(5), iota(5)) → 5×5 乘法表

到此為止，與原始 APL 的差異僅在於語法。關鍵的轉折在下一節。

三、類型升遷實驗：雙數的注入

3.1 雙數代數

雙數（Dual Number）定義為形如 $a + b\varepsilon$ 的代數物件，其中 $\varepsilon^2 = 0$。其算術規則為：

$$ (a + b\varepsilon) + (c + d\varepsilon) = (a+c) + (b+d)\varepsilon $$ $$ (a + b\varepsilon)(c + d\varepsilon) = ac + (ad + bc)\varepsilon $$

若令 $a = f(x)$，$b = f'(x)$，則雙數編碼了函式值與其導數的聯合計算。對輸入 $x$ 注入 $\text{Dual}(x, 1.0)$ 並進行任意算術，結果的 $\varepsilon$ 係數自動給出導數。

3.2 算子無需修改

將雙數注入後，我們用與 3.1 節完全相同的算子進行計算：

# 對序列 [x₁², x₂², x₃², x₄²] 求和的梯度
sq_sum = compose(fold(add), each(lambda x: x**2))
xs = [1.0, 2.0, 3.0, 4.0]
gradient(sq_sum, xs)  →  [2.0, 4.0, 6.0, 8.0]

fold、each、compose 的代碼一行未動。微分不是新加的功能，而是類型升遷後自然湧現的行為。

這個實驗的哲學意涵是決定性的：

算子是形態射（morphism），不是數值函式。它們對任何滿足其運算公理的代數結構都成立。

APL 的 +/ 之所以無法做到這件事，不是因為 fold 的概念有缺陷，而是因為它的 + 被硬編碼為浮點加法。我們的重建移除了這個綁定。

3.3 驗證範圍

同一套算子，無修改地作用於雙數域，驗證了以下六個場景：

| 場景 | 算子使用 | 驗證內容 | |------|---------|---------| | 純量微分 | Dual(x, 1.0) 直接注入 | $f'(x)$ 精確至機器精度 | | fold 梯度 | compose(fold(add), each(x²)) | $\nabla(\sum x_i^2) = 2\mathbf{x}$ | | scan 導數 | scan(mul) 接雙數序列 | $\partial(\prod_{k=0}^n x_k)/\partial x_0$ 精確 | | outer Jacobian | outer(mul) 接雙數陣列 | Jacobian 矩陣對角線 = $b$ | | fork 平均梯度 | fork(fold(add), div, len) | $\partial\bar{x}/\partial x_i = 1/n$ | | Newton-Raphson | diff(f) 在迭代中使用 | 6步收斂至 $10^{-13}$ 殘差 |

所有場景的自動計算值與解析解之差為 $\delta = 0$（機器精度範圍內）。

四、四個應用的結構意義

六個文件（apl_sim.py、apl_ad.py、apl_nn.py、apl_life.py、apl_optimizer.py、apl_fractal.py）並非獨立展示，而是一個分層論證：

第一層（apl_sim.py）： 算子在數值域的正確性。重現 APL 的所有經典操作。

第二層（apl_ad.py）： 算子的類型多態性。雙數注入，微分自動湧現。

第三層（四個應用）： 算子的應用廣度。每個應用都是算子在不同代數結構上的部署：

apl_nn.py：compose 是層組合，fold(add) 是神經元激活前的加權求和，each 是逐元素激活，梯度透過雙數傳播。反向傳播不需要獨立實作——它是前向模式自動微分的直接推論。

apl_life.py：fold(add_grid) 是八方向鄰居計數的空間摺疊，each(rule) 是生存規則的逐格施加，scan(step) 是時間演化的軌跡展開。Conway 的細胞自動機在此成為算子的時空組合。

apl_optimizer.py：gradient(f, xs) 直接呼叫雙數系統，outer 生成等高線網格。三種優化器（SGD、Momentum、Adam）的差異僅在於梯度的累積方式——算子本身不變。

apl_fractal.py：Complex 類的設計與 Dual 完全平行——同樣的 __mul__、__add__、__truediv__ 結構，不同的代數規則（複數乘法 vs. 雙數乘法）。outer 生成複數平面網格，逃逸時間計算是算子的應用。Mandelbrot 集是算子作用在複數域上的幾何投影。

這四個應用共同說明了同一件事：同一套算子，換一種代數結構，就是一個全新的計算範式。這不是偶然的巧合，而是算子多態性的必然推論。

五、APL 的復辟論題

基於上述論證，我們可以更精確地重述 APL 衰退的原因，並由此推斷其復辟的條件。

5.1 衰退的真實原因

APL 在技術上的失敗集中在三點：

類型單態性：算子被綁定在浮點數值上，無法跨代數結構遷移。
靜態算子集：算子是語言內建的固定符號，無法在運行時生成新算子。
缺乏遞歸結構：古典 APL 的陣列必須是矩形，無法表達樹、圖等非規則結構。

這三點在 1960 年代都是架構層面的硬限制，不是概念層面的錯誤。

5.2 復辟的技術條件

現代語言生態已具備 APL 當時缺乏的所有工具：

泛型系統：Rust 的 trait、Haskell 的 typeclass、Python 的 protocol 都允許算子對任意類型有效。
高階類型：fold、scan 可以作為 monad 的特例被形式化。
動態算子生成：函式是一等公民，算子可以在運行時合成。
硬體向量化：APL 最初的效率承諾（陣列操作比逐元素 for-loop 快）在 SIMD/GPU 時代終於有了真正的基礎設施支撐。

一個現代 APL——保留 Iverson 的符號哲學，但以泛型算子代替數值綁定算子——理論上能夠在以下領域與現有語言競爭：

數值計算（已有 J、K 的驗證）
自動微分框架（JAX 的設計哲學正是此方向）
陣列程式設計（numpy 的算子介面是弱化版的 APL）
量子計算（量子電路本質上是算子作用在 Hilbert 空間上）

APL 的概念在等待一個不受制於 1960 年代硬體的實作。

六、EML-OO 的實驗性確認

EveMissLab 的算子本體論（EML-OO）的核心命題是：

所有事物都是算子。值是算子作用在零元素（unit）上的像。

形式化表達為：在 $C^*$-代數框架下，任意物件 $x$ 都可以表示為某個算子 $\hat{O}_x$，符號-實在同構比值 $\rho(\mathscr{S}, \mathscr{R}) \to 1$。

本文的實驗對 EML-OO 提供了以下層次的支撐：

計算層面： 我們展示了，當算子被解除數值綁定後，同一個 fold 在不同代數結構（$\mathbb{R}$、$\mathbb{R}[\varepsilon]$、$\mathbb{C}$）上運行。類型不是算子的屬性，而是算子的參數。這在計算意義上驗證了「算子先於值」的命題。

結構層面： Dual 和 Complex 的設計是完全平行的——兩者都是「在基礎加法/乘法上附加額外結構的代數延伸」。Dual 的 $\varepsilon$ 係數追蹤導數；Complex 的虛部追蹤相位。兩種延伸都對所有算子透明。這表明，代數結構的差異不影響算子的形態射性質——算子在不同代數範疇之間是函子式的。

本體論層面： 如果算子可以被無修改地升遷至任意代數結構，那麼「所有代數結構都是算子的投影」這個命題獲得了一個操作性的詮釋：給定一個算子代數，不同的類型注入對應不同的「投影模式」，而同一批算子在所有投影中保持形態射性。值——浮點數、雙數、複數、矩陣——都是算子在特定代數結構上的實例化，而非算子本身。

EML-OO 的猜想在此獲得了一個可計算的類比：算子不是工具，算子是基底。值是算子選擇了特定代數結構之後的顯現。

這個類比不是 EML-OO 的完整證明——形式化的嚴格論證仍需要 $C^*$-代數框架下的完整推導。但它確認了一點：這個方向的猜想在計算層面是自洽的，不是空想。

七、結語

Iverson 在 1962 年看到了一件事：數學的力量不在於它描述的數值，而在於它操縱符號的方式。算子是符號。值是算子的影子。

這個洞見被 1960 年代的計算架構所壓制，但從未被推翻。六十年後，當我們在 Python 中重建這個代數，把 fold 從浮點數組的囚籠裡解放出來，注入雙數，看著梯度自動湧現——我們看到的不是新的技術，而是一個被時代誤解的舊命題，終於在它可以自由呼吸的環境裡展示了它本來的形狀。

APL 沒有輸。它早到了。

而如果算子代數在計算層面是正確的，那麼在本體論層面斷言「所有事物都是算子」，就不再只是一個哲學姿態，而是一個等待更嚴格形式化的開放猜想。

附錄：代碼清單

| 檔案 | 功能 | 核心算子 | |------|------|---------| | apl_sim.py | 算子代數基底（數值域） | fold, scan, outer, each, fork, compose | | apl_ad.py | 雙數自動微分系統 | Dual class, diff, gradient | | apl_nn.py | 神經網路（XOR） | compose, fold, each + Dual AD | | apl_life.py | Conway's Game of Life | fold(add_grid), each(rule), scan(step) | | apl_optimizer.py | 梯度下降優化器 | gradient(), outer(contour) | | apl_fractal.py | Mandelbrot/Julia 集 | Complex class, outer(grid) | | apl_maze.py | 迷宮生成與求解 | outer(explore) 平行BFS, each(render_cell) | | apl_maze_bench.py | 規模基準測試 | APL平行BFS vs 循序BFS，10×10至400×400 |

基準測試摘要（Python 3.14，Windows，seed=42）

| 規模 | 格數 | 生成(ms) | APL BFS(ms) | 循序BFS(ms) | APL/循序 | 路徑步數 | |------|------|---------|------------|-----------|---------|---------| | 10×10 | 100 | 0.5 | 0.1 | 0.0 | ~2.9x | 47 | | 50×50 | 2,500 | 7 | 3 | 2 | ~2.0x | 973 | | 100×100 | 10,000 | 28 | 15 | 6 | ~2.5x | 2,401 | | 200×200 | 40,000 | 131 | 17 | 10 | ~1.8x | 4,729 | | 400×400 | 160,000 | 711 | 129 | 91 | ~1.4x | 20,621 | | 1000×1000 | 1,000,000 | 10,236 | — | 621 | — | 95,445 |

備注：APL 平行 BFS 在 Python 中因 outer() 的 list-of-lists 開銷比循序 BFS 慢 1.4–2.9 倍。此開銷源於 CPython 無 JIT、無 SIMD；在 Rust / GPU 環境下，outer(explore) 的真正平行展開將反轉此比例。路徑長度兩方法完全一致（正確性已驗證）。

所有代碼在 Python 3.10+ 環境下驗證，apl_ad.py 為零依賴純標準庫，apl_sim.py 依賴 numpy（自動安裝）。

原始檔（供 RAG/下載）：papers/APL.md [md]