What does Extra Entries, Extra Layers conclude, in numbers, about “The Opposing Evidence: How Common the Paradox Is, How Much Buyers Know, and How Many New Customers a New Entry Brings”?

Answer: Chapter 6 sets out the opposing evidence: in random networks the share in which a new link hurts is only 0.020 to 0.084, vaguer information among buyers shrinks the harm, and a new entry that brings about 10.0 % new customers comes out ahead.

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: 0.020, 0.084

4000 random Braess-shaped networks per scheme
shortcut fixed waithurtshelpsno changehurt|changedworst
0..500.0200.1080.8720.1551.0572
0..50.0840.3010.6150.2181.0938
ceiling for affine waits: 4/3 = 1.3333
Show the full program
# Chapter 6. p61: how often does a new link hurt? Draw 4000 random
# four-node networks of Braess's shape (s-v, v-t, s-w, w-t, plus the
# candidate v-w) with affine waits a + b x, integer a in 0..50, b in
# 0..10, demand in 1..10 (an illustrative sampling scheme, not the one
# of Steinberg and Zangwill 1983). Equilibria are solved exactly in
# fractions by testing every support of the three routes.
import itertools
import random
from fractions import Fraction as F

PATHS = [(0, 1), (2, 3), (0, 4, 3)]


def solve(eqs):
    # Gauss-Jordan on a square system of Fractions; None if singular
    n = len(eqs)
    m = [row[:] for row in eqs]
    for c in range(n):
        p = next((r for r in range(c, n) if m[r][c] != 0), None)
        if p is None:
            return None
        m[c], m[p] = m[p], m[c]
        for r in range(n):
            if r != c and m[r][c] != 0:
                f = m[r][c] / m[c][c]
                m[r] = [x - f * y for x, y in zip(m[r], m[c])]
    return [m[r][n] / m[r][r] for r in range(n)]


def equilibrium(a, b, d, paths):
    np_ = len(paths)
    for r in range(1, np_ + 1):
        for sup in itertools.combinations(range(np_), r):
            # unknowns: flows on sup, then common cost lam
            eqs = []
            for p in sup:
                row = []
                for q in sup:
                    row.append(F(0) + b_shared(b, paths[p], paths[q]))
                const = F(0)
                for e in paths[p]:
                    const += a[e]
                eqs.append(row + [F(-1), -const])
            eqs.append([F(1)] * r + [F(0), F(d)])
            sol = solve(eqs)
            if sol is None or min(sol[:r]) < 0:
                continue
            f = [F(0)] * np_
            for p, v in zip(sup, sol[:r]):
                f[p] = v
            lam = sol[r]
            ok = True
            for p in range(np_):
                if p not in sup and path_cost(a, b, f, paths, p) < lam:
                    ok = False
            if ok:
                return lam
    return None


def b_shared(b, p, q):
    return sum_ints(b[e] for e in p if e in q)


def sum_ints(it):
    t = 0
    for v in it:
        t += v
    return t


def path_cost(a, b, f, paths, p):
    c = F(0)
    for e in paths[p]:
        x = F(0)
        for q, fq in enumerate(f):
            if e in paths[q]:
                x += fq
        c += a[e] + b[e] * x
    return c


def scheme(rng, top):
    worse = better = same = used = worse_used = 0
    worst = F(1)
    for _ in range(4000):
        a = [rng.randint(0, 50) for _ in range(4)] + [rng.randint(0, top)]
        b = [rng.randint(0, 10) for _ in range(5)]
        d = rng.randint(1, 10)
        c0 = equilibrium(a, b, d, PATHS[:2])
        c1 = equilibrium(a, b, d, PATHS)
        if c1 > c0:
            worse += 1
        elif c1 < c0:
            better += 1
        else:
            same += 1
        if c1 != c0:
            used += 1
            worse_used += c1 > c0
        if c0 > 0 and c1 / c0 > worst:
            worst = c1 / c0
    return worse, better, same, used, worse_used, worst


rng = random.Random(20261113)
print("4000 random Braess-shaped networks per scheme")
print("shortcut fixed wait  hurts   helps   no change  hurt|changed  worst")
for top in (50, 5):
    w, b_, s, u, wu, worst = scheme(rng, top)
    print("   0..%-2d            %.3f   %.3f    %.3f       %.3f    %.4f"
          % (top, w / 4000, b_ / 4000, s / 4000, wu / u, float(worst)))
print("ceiling for affine waits: 4/3 = %.4f" % (4 / 3))

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 6: The Opposing Evidence: How Common the Paradox Is, How Much Buyers Know, and How Many New Customers a New Entry Brings. 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