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 -> build | 8.623 10.957 |
| build -> sign-off | 8.623 10.957 |
| review -> layer -> sign-off - | 10.957 |
| average | 8.623 10.957 (+27.1%) |
| load on the two single-person steps (tens of requests a week) | |
| owner review | 1.200 -> 1.772 |
| sign-off | 0.800 -> 1.692 |
| best possible routing with the layer | 8.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
- Chapter 1 · Two Principles: Wardrop Equilibrium, and How a "One-Tap" Entry Makes Every Buyer Wait Four Minutes Longer
- Chapter 2 · The Main Argument: the Demand Window of Braess's Paradox and the Limits of the Four-Thirds Ceiling
- Chapter 3 · Frank and Wolfe in the Standard Library: Equilibrium, Optimum and the Relative Gap
- Chapter 4 · Purchase Entries: a Funnel Network, Elastic Orders and an Audit that Closes Entries One at a Time
- Chapter 6 · The Opposing Evidence: How Common the Paradox Is, How Much Buyers Know, and How Many New Customers a New Entry Brings
- Chapter 7 · Classical Sources East and West: "The Great Road Is Very Smooth, yet People Love the Byways" and Pigou's Two Roads
- Chapter 8 · Closing the Loop: Whole-Block Switchback Tests for Entries, an Audit of Organisational Layers, and a Pre-Registered Protocol