5D Library › 塔罗超几何抽样、雷诺曼网格拓扑与卡巴拉生命树图论 · English
第四章 生命之树的图论:谱、中心性与路径
十个节点与二十二条边
本书采用基歇尔《埃及的俄狄浦斯》中的生命之树 (Kircher 1652),这也是金色黎明会及其后多数西方版本沿用的形状 (Decker et al. 1996)。十个原质(Sephiroth)编号为:1 Kether(王冠)、2 Chokmah(智慧)、3 Binah(理解)、4 Chesed(慈悲)、5 Geburah(力量)、6 Tiphereth(美)、7 Netzach(胜利)、8 Hod(荣耀)、9 Yesod(根基)、10 Malkuth(王国)。22 条路径按基歇尔的次序编为第 11 到第 32 条,各对应一个希伯来字母与一张大阿卡纳(第七章)。
作为一张图,它有 10 个顶点、22 条边,度数之和为 44。图拉普拉斯矩阵 的特征值刻画了图的连通方式:最小的非零特征值(代数连通度)越大,图越难被切成两半;生成树的个数由矩阵树定理给出,等于 任一主子式的行列式。
推导
# Chapter 4. p08: The Tree of Life as a graph - Laplacian and centrality.
# Ten sephiroth: 1 Kether, 2 Chokmah, 3 Binah, 4 Chesed, 5 Geburah,
# 6 Tiphereth, 7 Netzach, 8 Hod, 9 Yesod, 10 Malkuth. The 22 paths of the
# Kircher / Golden Dawn tree, numbered 11-32 in Kircher's order.
# L = D - A. Eigenvalues by the cyclic Jacobi method (pure Python);
# spanning trees by the matrix-tree theorem (exact determinant).
from fractions import Fraction
PATHS = [(1, 2), (1, 3), (1, 6), (2, 3), (2, 6), (2, 4), (3, 6), (3, 5),
(4, 5), (4, 6), (4, 7), (5, 6), (5, 8), (6, 7), (6, 9), (6, 8),
(7, 8), (7, 9), (7, 10), (8, 9), (8, 10), (9, 10)]
NAMES = ["Kether", "Chokmah", "Binah", "Chesed", "Geburah", "Tiphereth",
"Netzach", "Hod", "Yesod", "Malkuth"]
n = 10
def adjacency():
A = [[0] * n for _ in range(n)]
for a, b in PATHS:
A[a - 1][b - 1] = A[b - 1][a - 1] = 1
return A
def jacobi(M, sweeps=60):
M = [row[:] for row in M]
for _ in range(sweeps):
for p in range(n):
for q in range(p + 1, n):
if abs(M[p][q]) < 1e-15:
continue
th = (M[q][q] - M[p][p]) / (2 * M[p][q])
t = (1 if th >= 0 else -1) / (abs(th) + (th * th + 1) ** .5)
c = 1 / (t * t + 1) ** .5
s = t * c
for k in range(n):
mkp, mkq = M[k][p], M[k][q]
M[k][p], M[k][q] = c * mkp - s * mkq, s * mkp + c * mkq
for k in range(n):
mpk, mqk = M[p][k], M[q][k]
M[p][k], M[q][k] = c * mpk - s * mqk, s * mpk + c * mqk
return sorted(M[i][i] for i in range(n))
def det(M):
M = [[Fraction(x) for x in row] for row in M]
d, m = Fraction(1), len(M)
for i in range(m):
piv = next(r for r in range(i, m) if M[r][i] != 0)
if piv != i:
M[i], M[piv] = M[piv], M[i]
d = -d
d *= M[i][i]
for r in range(i + 1, m):
f = M[r][i] / M[i][i]
M[r] = [x - f * y for x, y in zip(M[r], M[i])]
return d
if __name__ == "__main__":
A = adjacency()
deg = [sum(r) for r in A]
L = [[(deg[i] if i == j else 0) - A[i][j] for j in range(n)]
for i in range(n)]
print(" edges {}, degree sum {}".format(len(PATHS), sum(deg)))
lam = jacobi(L)
lam[0] = abs(lam[0]) # the zero eigenvalue, sign of rounding
print(" Laplacian spectrum: " + " ".join("{:.3f}".format(x)
for x in lam[:5]))
print(" " + " ".join("{:.3f}".format(x)
for x in lam[5:]))
print(" algebraic connectivity {:.4f}; largest {:.4f}".format(
lam[1], lam[-1]))
trees = det([row[1:] for row in L[1:]])
print(" spanning trees (matrix-tree theorem): {}".format(trees))
x = [1.0] * n
for _ in range(500):
y = [sum(A[i][j] * x[j] for j in range(n)) for i in range(n)]
s = max(y)
x = [v / s for v in y]
print(" node degree eigenvector centrality (max = 1)")
for i in range(n):
print(" {:2d} {:9s} {:5d} {:.4f}".format(
i + 1, NAMES[i], deg[i], x[i]))
print(" largest adjacency eigenvalue {:.4f}".format(s))
# edges 22, degree sum 44
# Laplacian spectrum: 0.000 1.281 2.891 3.753 4.329
# 4.684 5.445 5.738 6.802 9.077
# algebraic connectivity 1.2805; largest 9.0771
# spanning trees (matrix-tree theorem): 54349
# node degree eigenvector centrality (max = 1)
# 1 Kether 3 0.4420
# 2 Chokmah 4 0.5469
# 3 Binah 4 0.5469
# 4 Chesed 4 0.6015
# 5 Geburah 4 0.6015
# 6 Tiphereth 8 1.0000
# 7 Netzach 5 0.7010
# 8 Hod 5 0.7010
# 9 Yesod 4 0.5961
# 10 Malkuth 3 0.4218
# largest adjacency eigenvalue 4.7369谱与特征向量中心性
拉普拉斯谱从 0 到 9.0771,代数连通度为 1.2805,生成树共 54349 棵。最大的拉普拉斯特征值 9.0771 只略高于下界「最大度加一」,即 9,这正是 Tiphereth 的度 8 留下的痕迹。
特征向量中心性把一个节点的重要性定义为其邻居重要性之和(邻接矩阵的主特征向量)。以最大值归一后,Tiphereth 为 1.0000,其次是 Netzach 与 Hod(0.7010),然后是 Chesed 与 Geburah(0.6015)、Yesod(0.5961)、Chokmah 与 Binah(0.5469),Kether(0.4420)与 Malkuth(0.4218)最低。邻接矩阵的最大特征值为 4.7369。
介数、对称与三柱
推导
# Chapter 4. p09: Who sits on the shortest paths? Betweenness, closeness,
# symmetry and the three pillars.
# Brandes' algorithm for unweighted betweenness (pairs counted once).
# Automorphisms: every relabelling of the ten nodes that keeps the 22
# edges, found by backtracking. Pillars: Mercy 2-4-7, Severity 3-5-8,
# Middle 1-6-9-10.
from fractions import Fraction
PATHS = [(1, 2), (1, 3), (1, 6), (2, 3), (2, 6), (2, 4), (3, 6), (3, 5),
(4, 5), (4, 6), (4, 7), (5, 6), (5, 8), (6, 7), (6, 9), (6, 8),
(7, 8), (7, 9), (7, 10), (8, 9), (8, 10), (9, 10)]
N = range(1, 11)
ADJ = {v: set() for v in N}
for a, b in PATHS:
ADJ[a].add(b)
ADJ[b].add(a)
def bfs(s):
dist, sigma, order = {s: 0}, {s: 1}, [s]
preds = {v: [] for v in N}
for v in order:
for w in sorted(ADJ[v]):
if w not in dist:
dist[w] = dist[v] + 1
sigma[w] = 0
order.append(w)
if dist[w] == dist[v] + 1:
sigma[w] += sigma[v]
preds[w].append(v)
return dist, sigma, order, preds
def betweenness():
bc = {v: Fraction(0) for v in N}
for s in N:
dist, sigma, order, preds = bfs(s)
delta = {v: Fraction(0) for v in N}
for w in reversed(order):
for v in preds[w]:
delta[v] += Fraction(sigma[v], sigma[w]) * (1 + delta[w])
if w != s:
bc[w] += delta[w]
return {v: x / 2 for v, x in bc.items()}
def automorphisms():
found = []
def extend(m):
if len(m) == 10:
found.append(dict(m))
return
v = len(m) + 1
for img in N:
if img in m.values() or len(ADJ[img]) != len(ADJ[v]):
continue
if all((u in ADJ[v]) == (m[u] in ADJ[img]) for u in m):
m[v] = img
extend(m)
del m[v]
extend({})
return found
if __name__ == "__main__":
bc = betweenness()
pairs = 36 # pairs of the other nine nodes
print(" node betweenness share of 36 pairs closeness")
for v in N:
d = bfs(v)[0]
print(" {:4d} {:11.4f} {:17.4f} {:9.4f}".format(
v, float(bc[v]), float(bc[v]) / pairs, 9 / sum(d.values())))
tot = sum(bc.values())
print(" Tiphereth holds {:.4f} of all betweenness".format(
float(bc[6] / tot)))
auts = automorphisms()
print(" automorphisms: {}".format(len(auts)))
for m in auts:
moved = {k: v for k, v in m.items() if k != v}
print(" " + (str(moved) if moved else "identity"))
pill = {"Mercy": (2, 4, 7), "Severity": (3, 5, 8),
"Middle": (1, 6, 9, 10)}
for name, vs in pill.items():
inside = sum(1 for a, b in PATHS if a in vs and b in vs)
print(" pillar {:8s} nodes {} degree sum {:2d} edges inside {}"
.format(name, len(vs), sum(len(ADJ[v]) for v in vs), inside))
# node betweenness share of 36 pairs closeness
# 1 0.0000 0.0000 0.5625
# 2 0.8333 0.0231 0.6000
# 3 0.8333 0.0231 0.6000
# 4 1.4167 0.0394 0.6429
# 5 1.4167 0.0394 0.6429
# 6 13.8333 0.3843 0.9000
# 7 3.2500 0.0903 0.6923
# 8 3.2500 0.0903 0.6923
# 9 1.1667 0.0324 0.6429
# 10 0.0000 0.0000 0.5000
# Tiphereth holds 0.5321 of all betweenness
# automorphisms: 2
# identity
# {2: 3, 3: 2, 4: 5, 5: 4, 7: 8, 8: 7}
# pillar Mercy nodes 3 degree sum 13 edges inside 2
# pillar Severity nodes 3 degree sum 13 edges inside 2
# pillar Middle nodes 4 degree sum 18 edges inside 3介数中心性统计一个节点落在其他节点对之间的最短路径上的份额,程序用布兰德斯算法计算 (Brandes 2001)。Tiphereth 的介数为 13.8333,占其余九个节点之间 36 对的 0.3843,占全图介数总和的 0.5321;Kether 与 Malkuth 的介数为零。紧密度中心性(到其他节点平均距离的倒数)也以 Tiphereth 的 0.9000 为最高。
这张图的自同构群只有两个元素:恒等映射,以及交换左右两柱的反射(2 与 3、4 与 5、7 与 8 互换)。因此慈悲柱(2、4、7)与严厉柱(3、5、8)在结构上完全对称,度数和都是 13,柱内各有 2 条边;中柱(1、6、9、10)度数和为 18,柱内 3 条边。「三柱平衡」在图论上的准确含义就是这一个二阶对称。
证据
Tiphereth 的中心性垄断是图的性质。 它连接了除 Malkuth 以外的全部节点,度为 8,是唯一同时处于左右两柱与上下两半之间的节点,所以在度、特征向量、介数与紧密度四种中心性上都排第一。这一结论只来自 22 条边的排列,与任何象征意义无关。
从 Malkuth 到 Kether
推导
# Chapter 4. p10: Every way up the Tree - simple paths and random walks.
# (1) All simple paths from Malkuth (10) to Kether (1), by depth-first
# search, grouped by number of steps and by whether they use 6.
# (2) A walker at a node picks one of its paths uniformly. Expected
# first-passage times h(v) to Kether solve h(1) = 0,
# h(v) = 1 + mean of h over the neighbours of v (exact fractions).
# (3) Commute time 10 <-> 1 = 2m * R_eff, R_eff the effective resistance
# with every path a unit resistor (m = 22 edges).
from fractions import Fraction
PATHS = [(1, 2), (1, 3), (1, 6), (2, 3), (2, 6), (2, 4), (3, 6), (3, 5),
(4, 5), (4, 6), (4, 7), (5, 6), (5, 8), (6, 7), (6, 9), (6, 8),
(7, 8), (7, 9), (7, 10), (8, 9), (8, 10), (9, 10)]
ADJ = {v: set() for v in range(1, 11)}
for a, b in PATHS:
ADJ[a].add(b)
ADJ[b].add(a)
def simple_paths(s, t):
out = []
def go(v, seen):
if v == t:
out.append(list(seen))
return
for w in sorted(ADJ[v]):
if w not in seen:
seen.append(w)
go(w, seen)
seen.pop()
go(s, [s])
return out
def solve(M, b):
m = len(b)
M = [row[:] + [b[i]] for i, row in enumerate(M)]
for i in range(m):
piv = next(r for r in range(i, m) if M[r][i] != 0)
M[i], M[piv] = M[piv], M[i]
for r in range(m):
if r != i and M[r][i] != 0:
f = M[r][i] / M[i][i]
M[r] = [x - f * y for x, y in zip(M[r], M[i])]
return [M[i][m] / M[i][i] for i in range(m)]
def hitting(target):
vs = [v for v in range(1, 11) if v != target]
idx = {v: i for i, v in enumerate(vs)}
M = [[Fraction(0)] * len(vs) for _ in vs]
b = [Fraction(1)] * len(vs)
for v in vs:
d = len(ADJ[v])
M[idx[v]][idx[v]] = Fraction(1)
for w in ADJ[v]:
if w != target:
M[idx[v]][idx[w]] -= Fraction(1, d)
h = dict(zip(vs, solve(M, b)))
h[target] = Fraction(0)
return h
if __name__ == "__main__":
ps = simple_paths(10, 1)
by_len, via6 = {}, 0
for p in ps:
by_len[len(p) - 1] = by_len.get(len(p) - 1, 0) + 1
via6 += 6 in p
print(" simple paths Malkuth -> Kether: {}".format(len(ps)))
print(" by number of steps: {}".format(dict(sorted(by_len.items()))))
print(" through Tiphereth: {} ({:.4f})".format(via6, via6 / len(ps)))
short = [p for p in ps if len(p) - 1 == min(by_len)]
print(" shortest: {}".format(short))
up, down = hitting(1), hitting(10)
print(" expected steps to reach Kether from Malkuth: {} = {:.4f}"
.format(up[10], float(up[10])))
print(" expected steps to reach Malkuth from Kether: {} = {:.4f}"
.format(down[1], float(down[1])))
comm = up[10] + down[1]
print(" commute time {:.4f}; effective resistance {:.4f}".format(
float(comm), float(comm / 44)))
print(" expected steps to Kether, by starting node:")
print(" " + " ".join("{}:{:.2f}".format(v, float(up[v]))
for v in range(2, 7)))
print(" " + " ".join("{}:{:.2f}".format(v, float(up[v]))
for v in range(7, 11)))
# simple paths Malkuth -> Kether: 573
# by number of steps: {3: 3, 4: 16, 5: 50, 6: 104, 7: 160, 8: 156, 9: 84}
# through Tiphereth: 533 (0.9302)
# shortest: [[10, 7, 6, 1], [10, 8, 6, 1], [10, 9, 6, 1]]
# expected steps to reach Kether from Malkuth: 8225/391 = 21.0358
# expected steps to reach Malkuth from Kether: 8451/391 = 21.6138
# commute time 42.6496; effective resistance 0.9693
# expected steps to Kether, by starting node:
# 2:12.50 3:12.50 4:17.48 5:17.48 6:16.01
# 7:19.94 8:19.94 9:20.23 10:21.04从 Malkuth 到 Kether 共有 573 条简单路径(不重复经过节点),长度从 3 步到 9 步,最常见的是 7 步(160 条)。最短的三条都是 3 步,都经过 Tiphereth;全部简单路径中有 533 条(0.9302)经过它。
随机游走在每个节点等概率地选择一条相连的路径。从 Malkuth 出发首次到达 Kether 的期望步数为 8225/391,约 21.0358;反方向为 21.6138。两者之和是往返时间 42.6496,等于两倍边数乘以把每条边看作单位电阻时两点间的等效电阻 0.9693 (Chandra et al. 1996; Lovász 1993)。从各节点到 Kether 的期望步数中,Chokmah 与 Binah 最近(12.50),Tiphereth 为 16.01,低于与它同层或更低的其他节点。
假说 · 尚未验证
作者的诠释(尚未验证): 以 Tiphereth 为「平衡之所」的传统说法,可以读作对这张图介数结构的直观把握。什么会证明这一读法不当: 若能找到早于基歇尔、边集不同而中心不在第 6 节点的生命树,并且同一传统同样把第 6 节点称为中心,那么这一说法就并非来自图的结构。
小结
生命之树是一张 10 个顶点、22 条边、只有一个左右反射对称的图。Tiphereth 在四种中心性上都居首位,独占介数的 0.5321,从 Malkuth 到 Kether 的简单路径有 0.9302 经过它。往返时间与等效电阻把「上升」与「下降」的不对称量化为 21.0358 与 21.6138 步。
参考文献
Fan, Y. (2026). Tarot Hypergeometric Sampling, Lenormand Grid Topology and Kabbalistic Tree Graphs: Reversal Binomial Mixtures, Grand-Tableau Manhattan Distances and Twenty-Two-Edge Spectral Centrality [塔罗超几何抽样、雷诺曼网格拓扑与卡巴拉生命树图论] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090191 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).