Tensor Logic：邏輯規則和 einsum 是同一種運算嗎

邏輯程式設計裡有一條教科書式的規則：x 是 y 的姐妹，y 是 z 的父母，那麼 x 是 z 的姑姑或姨媽。用 Datalog 寫出來是這樣：

Aunt(x, z) :- Sister(x, y), Parent(y, z).

而用 numpy 寫，是這樣一行：

Aunt = np.einsum("xy,yz->xz", Sister, Parent) > 0

華盛頓大學的 Pedro Domingos 在 2025 年 10 月的論文《Tensor Logic: The Language of AI》裡說，這兩行不只是“結果碰巧一樣”，它們本來就是同一種運算；而且神經網路、邏輯推理、核方法、機率圖模型，全都可以只用這一種語句寫出來¹。他據此提出一門新語言，名字就叫張量邏輯（tensor logic），並且說它能在嵌入空間裡做“可靠、透明、不會幻覺”的推理。

這話聽上去很大。邏輯規則和矩陣乘法真的是一回事嗎？如果是，為什麼符號 AI 和神經網路各走各路走了幾十年？只剩一種語句的語言長什麼樣，能不能真把規則學出來、真不幻覺？我們就從上面這一行 einsum 開始，邊跑程式碼邊往下看。

一、規則與 einsum 的對應

先認識兩邊

Datalog 是最簡單的邏輯程式語言，可以看成去掉函式符號的 Prolog。一個 Datalog 程式由兩樣東西組成：事實，比如 Parent(舅舅, 表妹)，說的是“舅舅是表妹的父母”；規則，比如上面那條 Aunt，箭頭（:-）左邊叫頭，右邊叫體，體裡的逗號是“並且”。規則的意思是：只要能找到一組取值，讓體裡的每一項都是已知事實，頭就成立。

einsum（愛因斯坦求和）是一種寫張量運算的記號。張量就是多維陣列：向量有一個下標，矩陣有兩個。"xy,yz->xz" 的意思是：第一個矩陣的下標叫 x、y，第二個叫 y、z，結果保留 x、z；在箭頭右邊沒出現的下標 y，要被求和掉。所以它就是矩陣乘法 $C_{xz} = \sum_y A_{xy} B_{yz}$。

現象：兩邊算出同樣的五條

我們拿一個七口之家試一下：外婆有三個孩子，媽媽、小姨和舅舅；媽媽有“我”，舅舅有表妹和表弟。把 Sister 和 Parent 各寫成一個 7×7 的 0/1 矩陣，第 x 行第 y 列是 1 就表示這條事實成立，再跑上面那行 einsum：

einsum[妈妈,表妹] = 1  经由 y = ['舅舅']  -> Aunt = 1
einsum[妈妈,表弟] = 1  经由 y = ['舅舅']  -> Aunt = 1
einsum[小姨,我]   = 1  经由 y = ['妈妈']  -> Aunt = 1
einsum[小姨,表妹] = 1  经由 y = ['舅舅']  -> Aunt = 1
einsum[小姨,表弟] = 1  经由 y = ['舅舅']  -> Aunt = 1

五條結果，和按 Datalog 規則一條條推出來的完全一樣²。

原因：關係就是布林張量

為什麼會一樣？把規則拆開看，每一部分都能在 einsum 裡找到對應。

關係就是布林張量。 一個二元關係 Parent(y, z) 等價於一個 0/1 矩陣，三元關係就是一個三維的 0/1 陣列。論文把這句話反過來說：關係是稀疏布林張量的一種緊湊寫法，只列出值為 1 的那些格子。

體裡的逗號是乘法，共享的變數是共享的下標。 兩個 0/1 數相乘，只有都為 1 時才是 1，正好是“並且”。Sister(x, y) 和 Parent(y, z) 用的是同一個 y，對應到 einsum 裡就是兩邊用同一個下標 y。資料庫裡把這叫連線（join）：把兩張表裡 y 相同的行拼起來。

只在體裡出現的變數被求和。 頭裡只有 x 和 z，y 沒出現，einsum 就把 y 求和掉。資料庫裡這叫投影（projection）：把不需要的列扔掉。邏輯上，它對應的是“存在某個 y”。

最後套一個階躍函式。 求和得到的是“有幾個 y 能連起來”，可能大於 1；比如表妹若同時是媽媽和舅舅的孩子，小姨就能經由兩條路成為她的姨媽，這一格會數出 2²。邏輯只關心真假，所以論文在外面套了一個階躍函式 $H(x)$：大於 0 就是 1，否則是 0。寫成公式就是：

這就是論文的核心觀察：一條 Datalog 規則，等於在布林張量上做一次 einsum，再逐元素過一個階躍函式。體裡有幾項就是幾個張量相乘，關係有幾元就是幾維；對應關係對任意多項、任意元數都成立。

遞迴規則：反覆做到不動點

再看一條遞迴的規則，祖先：父母是祖先，祖先的孩子的祖先也是祖先。

Ancestor(x, y) :- Parent(x, y).
Ancestor(x, z) :- Ancestor(x, y), Parent(y, z).

Datalog 的標準演算法叫前向鏈：把所有規則拿到已知事實上反覆用，推出新事實，加進去，再用，直到一輪下來什麼新東西都推不出為止。這個“推不出新東西”的狀態叫不動點。換成矩陣，就是反覆算 $A \leftarrow H(A + A P)$，直到 $A$ 不再變化。在那個七口之家上，第一輪新增了外婆是“我”、表妹、表弟的祖先這三條，第二輪什麼也沒新增，停下²。

到這裡，“規則就是 einsum”是站得住的。而 einsum 本來就是神經網路裡最常用的運算：全連線層、卷積、注意力，幾乎都能寫成 einsum³。那麼，能不能乾脆只保留這一種語句，用它把兩邊都寫出來？

二、只有一種語句的語言

張量方程

論文的回答是能，並且把這當成整門語言的定義。張量邏輯程式就是一組張量方程，每條方程長這樣：

Aunt[x, z] = H(Sister[x, y] Parent[y, z])

左邊是要算的張量，右邊是幾個張量的連線，加一個可選的逐元素非線性函式（階躍、sigmoid、ReLU 都行）。規則只有這麼幾條：右邊有、左邊沒有的下標被求和；沒算出來的元素預設是 0；左邊相同的幾條方程結果相加（這正好對應 Datalog 裡同名的幾條規則取“或”）。用圓括號寫的張量表示布林張量，所以任何 Datalog 程式原樣就是合法的張量邏輯程式¹。

論文說這就是全部定義：沒有關鍵字，沒有別的語句。為了方便，可以加一些語法糖，比如下標裡寫 t+1、用 max= 代替預設的求和、softmax，但它們不增加表達能力。

現象：神經網路和圖模型都寫得進去

有了這一種語句，論文第 4 節把幾類 AI 方法挨個寫了一遍。挑幾條放在一起看：

這張表裡，左邊那一列來自完全不同的幾個學派，右邊的寫法卻是同一個模子。

推理和學習也只有一套

推理有兩種方式，都是從 Datalog 搬過來的。前向鏈把方程當成一段順序程式碼，挨個執行，能算的元素都算出來，重複到不動點或滿足停止條件；後向鏈把每條方程當成函式，從要問的那個張量出發，遞迴地去調右邊那些張量的方程，只算用得到的元素。

學習靠求導。因為只有一種語句，求導規則也只有一條：不看非線性，方程左邊對右邊某個張量的導數，就是右邊其餘張量的乘積。比如 $Y_{ij} = M_{ik} X_{kj}$，$\partial Y_{ij}/\partial M_{ik} = X_{kj}$。所以一個張量邏輯程式的梯度，本身也是一個張量邏輯程式。第六節學規則時，我們會用數值差分核對這一點。

第一次嘗試的疑問：這不就是 einsum 嗎

讀到這裡，很自然會有一個疑問：PyTorch 和 numpy 裡早就有 einsum，上面那張表的每一行都能直接用它寫出來，張量邏輯多了什麼？

論文的回答是，Python 的張量庫只管求導和 GPU，不管推理和知識；邏輯語言只管推理，不管學習和擴充套件。張量邏輯想做的是讓同一個程式裡，布林的事實和規則、實數的權重和嵌入可以混在一起寫、一起推理、一起求導。

可是反過來想，既然 einsum 在每個深度學習框架裡都有，為什麼沒人拿它來跑 Datalog？用矩陣跑規則，代價在哪裡？

三、稀疏關係的代價

現象：結果一樣，速度差了上千倍

我們生成一個隨機家譜：N 個人，每人平均有一個更早出生的父母，然後用兩種辦法算出全部祖先關係。一種是 Datalog 引擎常用的半樸素求值：存一個事實集合，每一輪只拿上一輪新推出的事實去連線；另一種是上面的稠密矩陣寫法，每一輪做一次 N×N 的矩陣乘法。

原因：矩陣要為不存在的事實付錢

原因就在最後一列。4000 個人的祖先關係有 4.5 萬條，可 4000×4000 的矩陣有 1600 萬個格子，99.7% 是 0。集合求值只碰真實存在的事實，事實多一倍，時間大約多一倍；矩陣乘法每輪要做 $N^3$ 次乘加，人數翻倍，每輪就慢 8 倍，加上輪數也在增加，總時間漲了約 9 倍。

換到 GPU 上，常數會小很多，但階數不變。更麻煩的是維數：一個三元關係是 $N^3$ 個格子，論文自己也說，用元組列表代替稠密張量，省下的空間隨元數指數增長。所以用稠密 einsum 跑規則，在“幾個人的家譜”上很優雅，在真實的知識庫上走不通。

論文給的兩條路

論文第 6 節承認了這一點，給了兩條路¹。

第一條是分工：稠密的部分交給 GPU，稀疏的部分當成關係交給資料庫查詢引擎，用上資料庫幾十年的查詢最佳化。這條路靠得住，但它其實就是今天大家在做的事：向量算在框架裡，關係存在資料庫裡，中間寫膠水程式碼。張量邏輯在這裡的作用，是把兩邊寫成同一種記號。

第二條是論文更看好的：把稀疏張量分解成稠密的小張量，全部放到 GPU 上算。論文說這比直接操作稀疏張量“指數級更高效”，而且隨機的分解就夠用，代價是有一點出錯的機率。這條路通向論文第 5 節，也是論文自己說最有意思的部分：在嵌入空間裡推理。把關係壓進嵌入以後，推出來的東西還對嗎？

四、在嵌入空間裡推理

先從一個集合開始

嵌入就是給每個物件分配一個 D 維向量。論文先考慮最簡單的情況：每個物件一個隨機的單位向量。D 足夠大時，兩個隨機單位向量幾乎正交，點積在 0 附近，標準差約 $1/\sqrt{D}$；一個向量和自己的點積是 1。

想存一個集合，比如“哪些人喜歡貓”，就把集合裡每個人的向量加起來，得到一個向量 $S$。問某人 A 在不在集合裡，算 $S \cdot e_A$：A 在裡面，結果約等於 1；不在，約等於 0。噪聲來自集合裡另外 N 個向量和 $e_A$ 的點積，標準差約 $\sqrt{N/D}$。取 ½ 當閾值，就能判斷在不在，出錯的機率隨 D 增大而減小。論文把它比作 Bloom filter：一種用固定大小的位陣列判斷“是否在集合裡”的資料結構，可能誤報，不會漏報⁴。

我們用 5000 個物件試了一下，集合外得分的標準差和 $\sqrt{N/D}$ 吻合得很好：D=1024、N=50 時實測 0.211，理論 0.221；這時錯判率 0.92%。集合放到 200 個，錯判率漲到 12%²。

再存一個關係

同樣的辦法可以存關係。一條事實 Parent(Bob, Carl) 用兩個向量的外積 $e_{Bob} \otimes e_{Carl}$ 表示，得到一個 D×D 的矩陣；把所有事實的外積加起來，就是整個關係的嵌入：

這是 Smolensky 在 1990 年提出的張量積表示⁵。查詢 Parent(A, B) 時，用 $e_A$ 和 $e_B$ 從兩邊各點一次：$D_{AB} = e_A^\top\, \text{EmbR}\, e_B$。展開後，每條事實貢獻 $(e_x \cdot e_A)(e_y \cdot e_B)$，只有 $x=A$、$y=B$ 那條貢獻約 1，其餘都是接近 0 的噪聲。

現象：誤判率很低，假事實卻很多

我們在 2000 個物件上掃了一遍維度 D 和事實數 |R|，閾值取 ½：

看百分比，D=256 存 1000 條事實只誤判 0.028%，好像很準了。可換成條數就是另一回事：多出來約 1122 條假事實，比 1000 條真事實還多。邏輯推理裡，一條假事實接著往下推，可能帶出一串假結論。

問題出在分母上。這個誤差和 Bloom filter 一樣，單次查詢出錯的機率小，但“把整個關係取回來”要查 $N^2$ 次。實驗裡要讓假事實降到個位數，D² 大約要比事實數大兩個數量級（D=128 存 100 條，誤判約 5 條）。而 D×D 的稠密矩陣本身並不比元組列表省地方：存 1000 條事實，列表是 2000 個整數，D=256 的 EmbR 是 6.5 萬個實數。嵌入真正省下的是相對 $N^2$ 的稠密矩陣，以及“全部在 GPU 上做稠密運算”這件事。

規則在嵌入空間裡連著用

規則也能搬進嵌入空間。Ancestor(x, z) :- Ancestor(x, y), Parent(y, z) 裡，共享變數 y 在嵌入空間裡變成共享的下標，兩個關係嵌入直接做矩陣乘法：$\text{EmbAnc}' = \text{EmbAnc} \cdot \text{EmbP}$。展開後，中間多出來的是 $e_y \cdot e_{y'}$ 這一項，y 和 y′ 相同時約為 1，不同時約為 0，所以近似成立。

每多連一次，就多一層近似。我們用 1000 個物件、611 條父子事實（含一條 12 代的長鏈），D=512，算“恰好 k 代”的祖先關係，看錯判怎麼隨跳數變化。論文還建議了一個降噪辦法：每推一步就把結果取出來、按 ½ 閾值化、再重新嵌入。兩種做法都試了：

直接連乘時，第 1 跳完全正確，到第 6 跳漏掉了 22% 的真事實，還多出 6 萬多條假的。每步閾值化在第 3、4 跳確實把誤判壓了下來，但到第 6 跳反而更糟：早期混進去的少量假事實被當成真事實重新嵌入，下一跳從它們出發又推出一批，越滾越多。

所以論文說的“出錯機率隨嵌入維度下降”是對的，但要讀全：維度要跟著事實數、物件數和推理深度一起漲，降噪也只能延緩誤差累積，擋不住它。隨機嵌入下的“可靠”，是一個有代價的機率保證。

不過隨機嵌入只是第一步，它和查表沒有本質區別。論文真正想要的是學出來的嵌入：相似的物件向量相近，可以互相“借”結論。這時候，論文說的“不會幻覺”還成立嗎？

五、溫度與“不會幻覺”

論文的主張

嵌入是學出來的時候，$\text{Sim} = \text{Emb}\,\text{Emb}^\top$ 不再接近單位陣，而是一個衡量物件兩兩相似度的 Gram 矩陣。查詢 Parent(Rob, Carl) 時，即使庫裡只有 Parent(Bob, Carl)，只要 Rob 和 Bob 的向量相近，也會得到一個不小的分數。論文把這叫類比推理：相似的物件按相似程度分享推論。

接著論文在每條方程外面套一個帶溫度 T 的 sigmoid：$\sigma(x, T) = 1/(1+e^{-x/T})$。T 越大，曲線越平緩；T 趨於 0，曲線變成階躍。論文的說法是：T 設為 0，等於把 Gram 矩陣變成單位陣，推理就成了純演繹；“這和 LLM 不同，LLM 即使在 T=0 時也會幻覺”。T 調高，推理就越來越偏類比；每條規則還可以有自己的 T，數學定理用 0，積累弱證據的規則用高溫¹。

現象：T 趨於 0，相似的物件照樣“借”到結論

我們用一個最小的例子檢查。D=256，庫裡只存一條事實 Parent(Bob, Carl)。另造三個物件：Rob 和 Bob 餘弦相似度 0.8（像學出來的近義物件），Bobby 是 0.4，Alice 和 Zed 是無關的隨機向量。原始得分分別是：Bob 1.0、Rob 0.8、Bobby 0.4，無關的在 ±0.02 附近。再把得分過 sigmoid，看 T 變小時會怎樣：

先看論文原式。閾值在 0，T 趨於 0 時得分只要大於 0 就判真，而無關物件的得分是圍著 0 抖動的噪聲，於是一半無關物件都被判成了 Carl 的父母。這顯然不是論文字意，應該理解成方程裡還有一個偏置，把閾值放在 ½，就像第四節的 Bloom filter 那樣。

閾值挪到 ½ 以後，T 趨於 0 確實把弱相似（Bobby）和噪聲都清掉了，但 Rob 仍然是 1。原因很簡單：Rob 的原始得分是 0.8，已經越過了閾值，曲線再陡也只會把它推向 1，不會推向 0。

原因：演繹和類比的衝突在嵌入裡，不在溫度裡

所以“T=0 讓 Gram 矩陣變成單位陣”需要一個前提：任意兩個不同物件的相似度都低於閾值。這在隨機嵌入下成立（這就是第四節），而學出來的嵌入恰恰是要讓相似的物件靠近，餘弦 0.8 很平常。下面這段是我的推斷，論文沒有討論：想要同一套嵌入既能類比又能在需要時嚴格演繹，可能得給演繹用的規則單獨一套近乎正交的嵌入，或者在讀出時把“是不是同一個物件”和“像不像”分開判斷，光調 T 做不到。

再說和 LLM 的比較。張量邏輯的推理過程裡，每一步推出的張量都能取出來看，這一點確實比 LLM 的推理過程透明。但“T=0 不會幻覺”成立的那個區間，正好是隨機嵌入、不做類比的區間，而在那個區間裡，它仍然有第四節看到的、隨維度和推理深度變化的誤判。把它說成“免疫幻覺”，是把一個機率保證說成了絕對保證。

前面討論的都是事實和嵌入怎麼存、怎麼推。張量邏輯另一半的賣點是學習：規則本身能不能也學出來？

六、規則的學習

歸納邏輯程式設計與一條帶權重的方程

從資料裡學出邏輯規則，有一個專門的領域，叫歸納邏輯程式設計（ILP）。它難在搜尋：可能的規則組合是天文數字。論文的思路是，把“候選規則”寫成一條帶權重的張量方程，讓梯度下降來挑。論文原話是，一條方程可以表示連線結構相同的所有規則。

我們照這個思路，在家庭資料上學“姑姨”關係。候選方程是：

Aunt[x, z] = sig(W[r, s] Rel[r, x, y] Rel[s, y, z] + b)

Rel 把四種基本關係（Parent、Sister、Brother、Spouse）疊成一個三維張量，r、s 取遍這四種。所以這一條方程同時代表了 16 條形如 Aunt(x, z) :- r(x, y), s(y, z) 的候選規則，W[r, s] 就是每條候選規則的權重。

現象：權重自己挑出了正確的規則

隨機生成 40 個家庭（452 人，195 條真的姑姨關係）訓練，20 個新家庭（232 人，84 條）測試。訓練完的權重是這樣的：

16 個權重裡，只有 W[Sister, Parent] 長到了 20.6，其餘都在 0 附近。閾值化以後，留下的正是 Aunt(x, z) :- Sister(x, y), Parent(y, z)，拿到沒見過的新家庭上 84 條全中，沒有誤判。學出來的不是一個黑盒，而是一條能讀、能拿去推理任何家庭的規則。

順便核對第二節說的求導規則。損失對 W[r, s] 的梯度寫出來也是一個 einsum：$\partial L/\partial W_{rs} = \sum G_{xz}\,\text{Rel}_{rxy}\,\text{Rel}_{syz}$，其中 $G$ 是損失對 sigmoid 輸入的導數。和數值差分比，W[Sister, Parent] 這一格是 −2.742338e-05 對 −2.742324e-05，前五位一致²。

不足：權重能學，結構要先寫對

真實的“姑姨”還包括姻親：舅舅的妻子是舅媽，叔叔的妻子是嬸嬸。這類關係是三段連線，Spouse(x, w), Brother(w, y), Parent(y, z)。我們把舅媽也加進訓練目標（訓練集裡 134 條），候選方程仍然只有兩段，再訓一次：模型還是隻學出了 Sister∘Parent，新家庭上 80 條舅媽全部漏掉。

這不是訓練不夠，而是兩段連線的方程里根本沒有三段的規則，權重怎麼調都補不上。論文那句“一條方程表示連線結構相同的所有規則”，反過來讀就是：連線結構得由人先寫好。ILP 最難的那部分，正是在不同的結構之間搜尋。論文提到可以用張量分解來“發明”新的中間謂詞（比如自動發現“兄弟姐妹”這個概念），這是一個有意思的方向，但論文沒有給出實驗，我們也沒有驗證。

到這裡，論文的幾個主張都摸了一遍。最後還剩一個問題：這些想法裡，哪些是新的？

七、這篇論文的位置

這個觀察並不新

“規則就是矩陣乘法加閾值”這個觀察，在 2013 到 2017 年之間就有好幾個人寫過，論文幾乎都沒有引用：

具體來說，Smolensky 1990 年就用外積疊加表示符號結構⁵；RESCAL 用每個關係一個矩陣打分⁶；Grefenstette 2013 年把邏輯演算寫成張量運算⁷；Cohen 2016 年的 TensorLog 把 Datalog 編譯成可微的矩陣運算⁸；Sato 同年用矩陣乘法加閾值求值 Datalog⁹；神經定理證明器用嵌入相似度做軟匹配¹⁰。

新的是什麼，缺的是什麼

論文新的地方，是把這個對應關係推到了極致：張量方程是整門語言唯一的語句，並且把神經網路、核方法、機率圖模型、邏輯程式都寫成這一種形式；再加上第五節“學出來的嵌入 + 溫度”這個統一演繹與類比的設想。作為一種看問題的視角，這很有啟發：GNN 的聚合就是“鄰居關係”和特徵的連線，貝葉斯網路的邊緣化就是投影，讀完再看這些模型，確實會覺得它們是一家人。

缺的東西也很明顯。論文 17 頁，沒有圖，沒有一個實驗；專案網站上只有論文、幻燈片和訪談，截至本文寫作時沒有官方實現¹¹。語言層面也有不少空白，比如 Datalog 裡很重要的否定（“x 沒有孩子”）怎麼寫、遞迴和否定混在一起時怎麼分層，論文都沒講。

目前能看到的實驗來自第三方。2026 年 1 月 Shah 和 Zadrozny 按論文實現了一版：在 1972 人的聖經家譜上，用矩陣乘法加階躍 74 輪算出 33945 條祖先關係；在知識圖譜資料集 FB15k-237 上，按論文的關係矩陣寫法做連結預測，MRR 0.3068，去掉直連邊後的組合推理 MRR 0.3346¹²¹³。前者驗證的正是第一節的對應關係，後者是一個合格但不算突出的知識圖譜嵌入結果。“嵌入空間裡可靠推理”“治好 LLM 的幻覺”這些更大的主張，還沒有實驗支撐。

小結

1. 邏輯規則和 einsum 是同一種運算嗎？ 在布林張量上是。關係是 0/1 張量，體裡的“並且”是相乘，共享變數是共享下標，只在體裡出現的變數被求和，最後用階躍函式把路徑計數壓回真假。遞迴規則就是反覆做到不動點。
2. 只有一種語句的語言長什麼樣？ 一組張量方程。感知機、卷積、注意力、核機器、貝葉斯網路和 Datalog 都能寫進去，推理是前向鏈和後向鏈，梯度也是張量方程。
3. 直接用稠密矩陣跑規則行不行？ 結果對，但稀疏關係裡 99% 以上是 0。4000 人的家譜，集合求值 28 ms，稠密矩陣 24 s。論文的出路是交給資料庫，或者壓進嵌入。
4. 壓進嵌入以後推理還對嗎？ 近似對。誤差隨維度下降，但要和事實數、物件數、推理深度一起看：D=256 存 1000 條事實，多出約 1122 條假事實；連乘 6 跳，漏判 22%。每步閾值化只能延緩累積。
5. 溫度調到 0 就不會幻覺嗎？ 不能這麼說。溫度只管曲線陡不陡；相似度 0.8 的物件在任何溫度下都會“借”到結論。純演繹要求不同物件的相似度都低於閾值，這和學出來的嵌入的目的相沖突。
6. 規則能學出來嗎？ 在給定的連線結構裡能：16 條候選規則同時訓練，權重集中到了正確的 Sister∘Parent，新家庭全中。結構之外的規則（三段的舅媽）學不出來。
7. 哪些是新的？ 對應關係本身 2016 年前後就有人寫過；新的是把它當作唯一的語言構造、統一幾大正規化，以及嵌入空間推理的設想。論文沒有實驗和實現，更大的主張還有待驗證。

本文所有實驗都是幾十行 numpy，可以在調研筆記目錄裡找到²。想自己體會一下，最短的版本就是這幾行：

import numpy as np
rng = np.random.default_rng(0)
N, D = 2000, 256
E = rng.standard_normal((N, D)); E /= np.linalg.norm(E, axis=1, keepdims=True)

R = np.zeros((N, N)); R[rng.integers(0, N, 1000), rng.integers(0, N, 1000)] = 1
EmbR = E.T @ R @ E            # EmbR[i,j] = R(x,y) Emb[x,i] Emb[y,j]
Score = E @ EmbR @ E.T        # D[x,y]   = EmbR[i,j] Emb[x,i] Emb[y,j]

print("真事实", int(R.sum()), "判真", int((Score > 0.5).sum()),
      "其中假的", int(((Score > 0.5) & (R == 0)).sum()))
# 真事实 1000 判真 2171 其中假的 1171

參考資料