What does Extra Entries, Extra Layers conclude, in numbers, about “Purchase Entries: a Funnel Network, Elastic Orders and an Audit that Closes Entries One at a Time”?

Answer: Chapter 4 shows on a funnel with three entries that a new entry raises the average time to order from 12.200 to 16.000 minutes and, with a patience scale of 40 minutes, cuts orders by 8.5 %, and gives an audit that closes entries one at a time.

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: 12.200, 16.000

300 buyers an hour: minutes on each route (equilibrium)
route before after
live room -> page12.200 16.000
chat -> order desk12.200 16.999
search -> page16.000 16.000
NEW live -> desk -16.000
average12.200 16.000
demand before after change
1.011.089 6.234 -43.8%
1.511.451 7.183 -37.3%
2.012.000 9.737 -18.9%
2.512.027 14.472 +20.3%
3.012.200 16.000 +31.1%
3.512.616 16.000 +26.8%
4.013.326 16.001 +20.1%
4.514.392 16.004 +11.2%
Show the full program
# Chapter 4. p41: a purchase funnel with three entries (live room,
# private chat, search) gains a fourth: "order from the live room in one
# tap", which hands the buyer straight to the human order desk. Frank-
# Wolfe equilibrium before and after, and the demand window in which the
# new entry slows every buyer. All waits and capacities illustrative.
import heapq
import math

# (from, to, free minutes, capacity in hundreds of buyers an hour)
FUNNEL = [("V", "L", 3.0, 1.5),    # live-room Q&A, host attention
          ("L", "C", 7.0, 9.0),    # live link to the product page
          ("C", "T", 1.0, 9.0),    # self-service payment
          ("V", "P", 9.0, 9.0),    # private-chat article
          ("P", "K", 1.0, 9.0),    # article to the order desk
          ("K", "T", 2.0, 1.2),    # human order desk queue
          ("V", "S", 8.0, 9.0),    # search and catalogue
          ("S", "C", 7.0, 9.0)]    # catalogue to the product page
NEW = ("L", "K", 1.0, 9.0)         # new entry: live room -> order desk
NAMES = ["live Q&A", "live->page", "pay", "chat page", "chat->desk",
         "order desk", "search", "search->page", "NEW live->desk"]


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="V", 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 = [("live room -> page", [0, 1, 2]),
          ("chat -> order desk", [3, 4, 5]),
          ("search -> page", [6, 7, 2]),
          ("NEW live -> desk", [0, 8, 5])]
NET = FUNNEL + [NEW]


def route_times(links, x):
    out = []
    for name, ks in ROUTES:
        if max(ks) < len(links):
            out.append(math.fsum(cost(links[k], x[k]) for k in ks))
        else:
            out.append(None)
    return out


d = 3.0
x0 = frank_wolfe(FUNNEL, d)
x1 = frank_wolfe(NET, d)
r0, r1 = route_times(FUNNEL, x0), route_times(NET, x1)
print("300 buyers an hour: minutes on each route (equilibrium)")
print("  route               before    after")
for (name, _), a, b in zip(ROUTES, r0, r1):
    sa = "%7.3f" % a if a is not None else "      -"
    print("  %-18s  %s  %7.3f" % (name, sa, b))
print("  average             %7.3f  %7.3f"
      % (average(FUNNEL, x0, d), average(NET, x1, d)))
print()
print("demand  before   after   change")
for d in (1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5):
    a = average(FUNNEL, frank_wolfe(FUNNEL, d), d)
    b = average(NET, frank_wolfe(NET, d), d)
    print("  %.1f  %7.3f  %7.3f  %+6.1f%%" % (d, a, b, 100 * (b / a - 1)))

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 4: Purchase Entries: a Funnel Network, Elastic Orders and an Audit that Closes Entries One at a Time. 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