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。图拉普拉斯矩阵 L=D−AL = D – A 的特征值刻画了图的连通方式:最小的非零特征值(代数连通度)越大,图越难被切成两半;生成树的个数由矩阵树定理给出,等于 LL 任一主子式的行列式。

推导

# 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 为最高。

生命之树:节点面积正比于介数中心性;Tiphereth(6)独占全部介数的一半以上(p09)。

这张图的自同构群只有两个元素:恒等映射,以及交换左右两柱的反射(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 步。

参考文献

Brandes, Ulrik. 2001. “A Faster Algorithm for Betweenness Centrality.” Journal of Mathematical Sociology 25 (2): 163–77.
Chandra, Ashok K., Prabhakar Raghavan, Walter L. Ruzzo, Roman Smolensky, and Prasoon Tiwari. 1996. “The Electrical Resistance of a Graph Captures Its Commute and Cover Times.” Computational Complexity 6 (4): 312–40.
Decker, Ronald, Thierry Depaulis, and Michael Dummett. 1996. A Wicked Pack of Cards: The Origins of the Occult Tarot. Duckworth.
Kircher, Athanasius. 1652. Oedipus Aegyptiacus. Vitale Mascardi.
Lovász, László. 1993. “Random Walks on Graphs: A Survey.” In Combinatorics, Paul Erdős Is Eighty, vol. 2. János Bolyai Mathematical Society.

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).