关于「枢纽卷、孤立卷与知识共同体的治理规则」,《四百卷自持回路总纲》给出的定量结论是什么?

结论:合成书库用掉 1,250 个关键词,与真实的 1,241(第一章程序 p12)很接近。边数 90 对 87,孤立比例 0.651 对 0.699,最大连通块 19 卷对 14 卷。差得较远的是两项:传递性 0.396 低于真实的 0.639,战区模块度 0.397 高于真实的 0.285。

数据口径:书库是群岛,不是全息网;合成模型显示,半数新卷各做一次桥接引用,就能让大部分新卷接入同一巨连通块。 示意基准下 g 为 0.018,临界规模 55.6,再投入率可行带 0.294 到 0.529;相图里同时满足增长与个人报酬条件的格子只占 0.231。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: 0.285, 0.396, 0.397, 0.639, 0.651, 0.699

synthetic library332 volumes, 1,250 keywords
synthetic real (p21)
edges90 87
isolated share0.651 0.699
transitivity0.396 0.639
largest component19 14
modularity, zones0.397 0.285
label-propagation communities (non-isolated) 40
modularity, label propagation 0.875
查看完整验算程序
# Chapter 3. p31: a synthetic keyword network calibrated on the library
# 332 volumes in 11 subject zones of the real sizes; each volume draws
# 4 distinct keywords. A keyword is new with probability p_new = 0.933
# (the measured share); otherwise an old one is reused in proportion
# to past use, from the volume's own zone with probability 0.35. Two
# volumes are linked when they share a keyword. Communities by label
# propagation (fixed seed, ties to the smallest label); modularity as
# in Newman (2006). Illustrative model, not the real graph.
import collections
import math
import random

ZONES = [47, 46, 46, 38, 35, 31, 29, 22, 18, 12, 8]
rng = random.Random(40831)


def build(p_new, own=0.35):
    zone = [z for z, n in enumerate(ZONES) for _ in range(n)]
    rng.shuffle(zone)
    gl, zl = [], collections.defaultdict(list)
    nkw, vols = 0, []
    for v, z in enumerate(zone):
        mine = []
        for _ in range(4):
            k = None
            if gl and rng.random() >= p_new:
                pool = zl[z] if zl[z] and rng.random() < own else gl
                for _ in range(5):
                    c = pool[rng.randrange(len(pool))]
                    if c not in mine:
                        k = c
                        break
            if k is None:
                k, nkw = nkw, nkw + 1
            mine.append(k)
            gl.append(k)
            zl[z].append(k)
        vols.append(mine)
    holders = collections.defaultdict(list)
    for v, ks in enumerate(vols):
        for k in ks:
            holders[k].append(v)
    adj = [set() for _ in vols]
    for k in sorted(holders):
        hs = holders[k]
        for i in range(len(hs)):
            for j in range(i + 1, len(hs)):
                adj[hs[i]].add(hs[j])
                adj[hs[j]].add(hs[i])
    return zone, adj, nkw


def modularity(adj, lab):
    m2 = math.fsum(len(a) for a in adj)
    if m2 == 0:
        return 0.0
    inside, tot = collections.Counter(), collections.Counter()
    for v, a in enumerate(adj):
        tot[lab[v]] += len(a)
        inside[lab[v]] += len([u for u in a if lab[u] == lab[v]])
    return math.fsum(inside[c] / m2 - (tot[c] / m2) ** 2
                     for c in sorted(tot))


def lpa(adj):
    lab = list(range(len(adj)))
    order = list(range(len(adj)))
    for _ in range(50):
        rng.shuffle(order)
        moved = 0
        for v in order:
            if not adj[v]:
                continue
            cnt = collections.Counter(lab[u] for u in adj[v])
            best = max(cnt.values())
            new = min(c for c, n in cnt.items() if n == best)
            if new != lab[v]:
                lab[v], moved = new, moved + 1
        if moved == 0:
            break
    return lab


def stats(adj):
    n = len(adj)
    m = int(math.fsum(len(a) for a in adj)) // 2
    iso = len([a for a in adj if not a])
    tri = trip = 0
    for v, a in enumerate(adj):
        d = len(a)
        trip += d * (d - 1) // 2
        nb = sorted(a)
        for i in range(len(nb)):
            for j in range(i + 1, len(nb)):
                if nb[j] in adj[nb[i]]:
                    tri += 1
    seen, big = set(), 0
    for s in range(n):
        if s in seen:
            continue
        st, size = [s], 0
        seen.add(s)
        while st:
            x = st.pop()
            size += 1
            for y in adj[x]:
                if y not in seen:
                    seen.add(y)
                    st.append(y)
        big = max(big, size)
    c = tri / trip if trip else 0.0
    return m, iso, c, big


def main():
    zone, adj, nkw = build(0.933)
    m, iso, c, big = stats(adj)
    lab = lpa(adj)
    ncom = len({lab[v] for v in range(len(adj)) if adj[v]})
    print("synthetic library: 332 volumes, {:,} keywords".format(nkw))
    print("                    synthetic   real (p21)")
    print("edges               {:>9}   87".format(m))
    print("isolated share      {:>9.3f}   0.699".format(iso / 332))
    print("transitivity        {:>9.3f}   0.639".format(c))
    print("largest component   {:>9}   14".format(big))
    print("modularity, zones   {:>9.3f}   0.285".format(
        modularity(adj, zone)))
    print("label-propagation communities (non-isolated) {}".format(ncom))
    print("modularity, label propagation {:.3f}".format(
        modularity(adj, lab)))


main()

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《四百卷全息知识共同体、现金流与算力自持闭环及无限创作自由态母典》第 3 章「枢纽卷、孤立卷与知识共同体的治理规则」(版本 1.0.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 5DL-B-408 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026408,
  author    = {Fan, Yafu},
  title     = {The Four-Hundred-Volume Holographic Knowledge Commonwealth: Self-Sustaining Cashflow-Compute Loops and Unbounded Creative Sovereignty},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

本书其他章节结论