What does Extra Entries, Extra Layers conclude, in numbers, about “Coordination Layers: the More Efficient a Pure Relay, the Slower Every Request”?

Answer: Chapter 5 shows that a relay-only coordination layer lengthens the cycle of requests from 8.623 to 10.957 days and gets worse the more efficient it becomes, while a layer with its own handling capacity is the best design.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (21 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: 10.957, 8.623

20 requests a week: days on each route at equilibrium
route before after
review -> build8.623 10.957
build -> sign-off8.623 10.957
review -> layer -> sign-off -10.957
average8.623 10.957 (+27.1%)
load on the two single-person steps (tens of requests a week)
owner review1.200 -> 1.772
sign-off0.800 -> 1.692
best possible routing with the layer8.437 days
Show the full program
# Chapter 5. p51: a coordination layer between the owner's review and
# the quality sign-off. Each request picks the route that is quickest
# for itself (Wardrop). Before: review -> build, or build -> sign-off.
# After: a shared layer lets a reviewed request go straight to sign-off,
# so it now queues at both single-person steps. Frank-Wolfe, BPR waits,
# 20 requests a week (demand 2.0 in tens). All values illustrative.
import heapq
import math

# (from, to, free days, capacity in tens of requests a week)
ORG = [("R", "A", 2.0, 1.0),     # owner review, one person
       ("A", "T", 6.0, 9.0),     # build and self-check, team A
       ("R", "E", 6.0, 9.0),     # build first, team E
       ("E", "B", 0.5, 9.0),     # hand to quality lead
       ("B", "T", 2.0, 1.0)]     # quality sign-off, one person
LAYER = [("A", "H", 0.5, 9.0),   # owner posts to the shared layer
         ("H", "B", 1.0, 2.0)]   # layer routes to quality sign-off


def cost(link, x):
    # BPR wait: free time * (1 + 0.15 (load / capacity)^4)
    return link[2] * (1.0 + 0.15 * (x / link[3]) ** 4)


def mcost(link, x):
    # marginal social cost: wait + load * d(wait)/d(load)
    return link[2] * (1.0 + 0.75 * (x / link[3]) ** 4)


def shortest(links, times, s, t):
    adj = {}
    for k, link in enumerate(links):
        adj.setdefault(link[0], []).append((link[1], k))
    dist, back, heap = {s: 0.0}, {}, [(0.0, s)]
    while heap:
        du, u = heapq.heappop(heap)
        if du > dist.get(u, math.inf):
            continue
        for v, k in adj.get(u, []):
            nd = du + times[k]
            if nd < dist.get(v, math.inf) - 1e-12:
                dist[v], back[v] = nd, k
                heapq.heappush(heap, (nd, v))
    path, node = [], t
    while node != s:
        k = back[node]
        path.append(k)
        node = links[k][0]
    return dist[t], path


def frank_wolfe(links, d, iters=300, f=cost, s="R", t="T"):
    def aon(x):
        times = [f(lk, xe) for lk, xe in zip(links, x)]
        c, path = shortest(links, times, s, t)
        y = [0.0] * len(links)
        for k in path:
            y[k] = d
        return y
    x = aon([0.0] * len(links))
    for _ in range(iters):
        y = aon(x)

        def slope(a):
            return math.fsum((ye - xe) * f(lk, xe + a * (ye - xe))
                             for lk, xe, ye in zip(links, x, y))
        if slope(1.0) <= 0:
            a = 1.0
        else:
            lo, hi = 0.0, 1.0
            for _ in range(60):
                mid = (lo + hi) / 2
                if slope(mid) > 0:
                    hi = mid
                else:
                    lo = mid
            a = (lo + hi) / 2
        x = [xe + a * (ye - xe) for xe, ye in zip(x, y)]
    return x


def average(links, x, d):
    return math.fsum(xe * cost(lk, xe) for lk, xe in zip(links, x)) / d


ROUTES = [("review -> build", [0, 1]),
          ("build -> sign-off", [2, 3, 4]),
          ("review -> layer -> sign-off", [0, 5, 6, 4])]
NET = ORG + LAYER
d = 2.0
x0 = frank_wolfe(ORG, d)
x1 = frank_wolfe(NET, d)
print("20 requests a week: days on each route at equilibrium")
print("  route                         before    after")
for name, ks in ROUTES:
    b = math.fsum(cost(NET[k], x1[k]) for k in ks)
    if max(ks) < len(ORG):
        a = "%7.3f" % math.fsum(cost(ORG[k], x0[k]) for k in ks)
    else:
        a = "      -"
    print("  %-28s  %s  %7.3f" % (name, a, b))
a0, a1 = average(ORG, x0, d), average(NET, x1, d)
print("  average                       %7.3f  %7.3f  (%+.1f%%)"
      % (a0, a1, 100 * (a1 / a0 - 1)))
print()
print("load on the two single-person steps (tens of requests a week)")
print("  owner review   %.3f -> %.3f" % (x0[0], x1[0]))
print("  sign-off       %.3f -> %.3f" % (x0[4], x1[4]))
s1 = average(NET, frank_wolfe(NET, d, f=mcost), d)
print("best possible routing with the layer: %.3f days" % s1)

Single source and citation

Fan, Y. (2026). Braess's Paradox and Wardrop Equilibrium: When One More Purchase Entry or One More Coordination Layer Slows Everyone Down (Version 1.0.0), Chapter 5: Coordination Layers: the More Efficient a Pure Relay, the Slower Every Request. 5D Library. DOI pending

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

BibTeX
@book{fan2026246,
  author    = {Fan, Yafu},
  title     = {Braess's Paradox and Wardrop Equilibrium: When One More Purchase Entry or One More Coordination Layer Slows Everyone Down},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book