What does Spectral Gaps and Bottleneck Cuts conclude, in numbers, about “The Empirical Loop: a Quarterly Checkup of the Workflow Graph, Link Advice and a Plan for Refutation”?

Answer: Chapter 8 gives a quarterly loop of drawing, checking, adding and reviewing, in which three rounds of advice raise the algebraic connectivity of an illustrative workflow from 0.1824 to 1.0000; the distilled "Bottleneck Cut-Set Checker"; and a pre-registered test with 74 team-quarters per arm together with conditions for overturning the book. Marked boxes separate published evidence, runnable Python calculations (18 programs), classical sources and the author's hypotheses.

Scope of the numbers: The parameters are illustrative; all calculations are generated by the book's programs; the book is not individual business advice, and any change to a production system or a real supply chain must be reviewed and released by hand by the person in charge. Marked boxes separate published evidence, runnable Python calculations (18 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.1824, 1.0000, 18

round links lambda2 rel.gap sweep bridges cuts verdict
017 0.1824 0.0644 0.200 2 3 RED
advice: add res_a - docs
118 0.4352 0.1451 0.400 1 1 RED
advice: add router - security
219 0.6166 0.1947 0.667 0 0 GREEN
advice: add retriever - reviewer
320 1.0000 0.3000 0.833 0 0 GREEN
Show the full program
# Chapter 8. p81: the quarterly checkup and link advice on the
# twelve-agent workflow of p42, run for three rounds of advice.
# Model: per round report lambda2, the relative gap lambda2 / mean
# degree, the Fiedler sweep ratio (best |boundary| / smaller side along
# the Fiedler order), bridges and cut vertices. Verdict thresholds are
# the book's illustrative defaults: RED if any cut vertex, AMBER if the
# relative gap is below 0.10, GREEN otherwise. Advice: among all absent
# links, prefer fewer cut vertices, then the larger lambda2.
import math


def laplacian(n, edges):
    lap = [[0.0] * n for _ in range(n)]
    for i, j in edges:
        lap[i][j] -= 1.0
        lap[j][i] -= 1.0
        lap[i][i] += 1.0
        lap[j][j] += 1.0
    return lap


def jacobi(mat, tol=1e-22):
    n = len(mat)
    a = [row[:] for row in mat]
    v = [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
    sweeps = 0
    while True:
        off = math.fsum(a[i][j] ** 2 for i in range(n)
                        for j in range(i + 1, n))
        if off < tol or sweeps > 60:
            break
        sweeps += 1
        for p in range(n - 1):
            for q in range(p + 1, n):
                if abs(a[p][q]) < 1e-300:
                    continue
                th = (a[q][q] - a[p][p]) / (2.0 * a[p][q])
                t = math.copysign(1.0, th) / (abs(th) + math.hypot(th, 1.0))
                c = 1.0 / math.sqrt(t * t + 1.0)
                s = t * c
                for k in range(n):
                    akp, akq = a[k][p], a[k][q]
                    a[k][p] = c * akp - s * akq
                    a[k][q] = s * akp + c * akq
                for k in range(n):
                    apk, aqk = a[p][k], a[q][k]
                    a[p][k] = c * apk - s * aqk
                    a[q][k] = s * apk + c * aqk
                for k in range(n):
                    vkp, vkq = v[k][p], v[k][q]
                    v[k][p] = c * vkp - s * vkq
                    v[k][q] = s * vkp + c * vkq
    order = sorted(range(n), key=lambda i: a[i][i])
    vals = [a[i][i] for i in order]
    vecs = [[v[k][i] for k in range(n)] for i in order]
    return vals, vecs, sweeps


NAMES = ["router", "planner", "res_a", "res_b", "retriever", "coder_a",
         "coder_b", "tester", "reviewer", "security", "docs", "release"]
EDGES = [(0, 1), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4), (1, 5), (5, 6),
         (5, 7), (6, 7), (7, 8), (6, 8), (8, 9), (7, 9), (8, 11),
         (8, 10), (10, 11)]


def splits(n, edges, drop_v=None, drop_e=None):
    adj = {v: [] for v in range(n) if v != drop_v}
    for e in edges:
        if e == drop_e or drop_v in e:
            continue
        adj[e[0]].append(e[1])
        adj[e[1]].append(e[0])
    start = min(adj)
    seen, stack = {start}, [start]
    while stack:
        u = stack.pop()
        for w in adj[u]:
            if w not in seen:
                seen.add(w)
                stack.append(w)
    return len(seen) < len(adj)


def checkup(n, edges):
    vals, vecs, _ = jacobi(laplacian(n, edges))
    lam, f = vals[1], vecs[1]
    rel = lam / (2.0 * len(edges) / n)
    order = sorted(range(n), key=lambda i: (round(f[i], 12), i))
    side, best = set(), None
    for k in range(1, n):
        side.add(order[k - 1])
        cut = len([e for e in edges if (e[0] in side) != (e[1] in side)])
        r = cut / min(k, n - k)
        best = r if best is None or r < best else best
    bridges = [e for e in edges if splits(n, edges, drop_e=e)]
    cuts = [v for v in range(n) if splits(n, edges, drop_v=v)]
    verdict = "RED" if cuts else ("AMBER" if rel < 0.10 else "GREEN")
    return lam, rel, best, bridges, cuts, verdict


def advise(n, edges):
    have, best = set(edges), None
    for i in range(n):
        for j in range(i + 1, n):
            if (i, j) in have:
                continue
            lam, _, _, _, cuts, _ = checkup(n, edges + [(i, j)])
            key = (len(cuts), -round(lam, 9), i, j)
            if best is None or key < best:
                best = key
    return best[2], best[3]


n = len(NAMES)
es = list(EDGES)
print("round  links lambda2  rel.gap  sweep  bridges cuts  verdict")
for rnd in range(4):
    lam, rel, sw, br, cv, verdict = checkup(n, es)
    print("%5d  %5d  %6.4f   %6.4f  %5.3f  %7d %4d  %s"
          % (rnd, len(es), lam, rel, sw, len(br), len(cv), verdict))
    if rnd < 3:
        i, j = advise(n, es)
        print("       advice: add %s - %s" % (NAMES[i], NAMES[j]))
        es.append((i, j))

Single source and citation

Fan, Y. (2026). Graph-Laplacian Spectral Gaps and Cheeger Constants: Single-Point Bottleneck Cuts in Multi-Agent Workflows and Cross-Border Supply Chains (Version 1.0.0), Chapter 8: The Empirical Loop: a Quarterly Checkup of the Workflow Graph, Link Advice and a Plan for Refutation. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-243 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026243,
  author    = {Fan, Yafu},
  title     = {Graph-Laplacian Spectral Gaps and Cheeger Constants: Single-Point Bottleneck Cuts in Multi-Agent Workflows and Cross-Border Supply Chains},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book