What does Bottlenecks, Cannibalization and Advisory Pricing conclude, in numbers, about “Finding the Bottleneck in the Logs, a Contract Ledger and a Pre-Registered Switchback Experiment”?

Answer: Chapter 8 finds the bottleneck from event logs (named correctly with probability 0.976 after 30 days), and gives a contract ledger and a pre-registered switchback experiment. Marked boxes separate published evidence, runnable Python calculations (16 programs), classical sources and the author's hypotheses.

Scope of the numbers: Team capacities, demand parameters, margins, noise and contract parameters are illustrative or synthetic; all data are generated by its programs; the book is not investment, legal or tax advice. Marked boxes separate published evidence, runnable Python calculations (16 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.976, 30

   team         true load  logged load (30 days)
   content          0.714        0.778
   acquisition      0.625        0.678
   conversion       0.833        0.858
   fulfilment       0.579        0.553
    1 logged days: bottleneck named correctly 0.526
    3 logged days: bottleneck named correctly 0.716
    7 logged days: bottleneck named correctly 0.827
   14 logged days: bottleneck named correctly 0.904
   30 logged days: bottleneck named correctly 0.976
Show the full program
# Chapter 8. p14: Finding the bottleneck from event logs. The network of
# p01 is simulated job by job for 32 days (2 days warm-up) at 20 jobs a
# day; each day's log gives every team's busy fraction (busy server time
# / (servers x 1 day)). How often does a sample of k logged days name the
# right team? Bootstrap over days, seed 83, 2,000 resamples per k.
import heapq
import importlib.util
import random

def load(name):
    spec = importlib.util.spec_from_file_location(name, name + ".py")
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    return m

p01 = load("p01_jackson_open")
C, MU = p01.BASE["c"], p01.BASE["mu"]
DAYS, WARM = 32, 2

def simulate(rng, lam=20.0):
    busy = [[0.0] * DAYS for _ in range(4)]
    free = list(C)
    queue = [[] for _ in range(4)]
    ev = [(rng.expovariate(lam), 0, -1)]      # (time, kind, station)
    seq = 0

    def add_busy(i, t0, t1):
        while t0 < t1 and int(t0) < DAYS:
            d = int(t0)
            step = min(t1, d + 1) - t0
            busy[i][d] += step
            t0 += step

    def start(i, t):
        nonlocal seq
        free[i] -= 1
        s = rng.expovariate(MU[i])
        add_busy(i, t, t + s)
        seq += 1
        heapq.heappush(ev, (t + s, seq, i))

    def arrive(i, t):
        if free[i] > 0:
            start(i, t)
        else:
            queue[i].append(t)

    while ev:
        t, kind, i = heapq.heappop(ev)
        if t >= DAYS:
            break
        if i < 0:
            arrive(0, t)
            heapq.heappush(ev, (t + rng.expovariate(lam), 0, -1))
            continue
        free[i] += 1
        if queue[i]:
            queue[i].pop(0)
            start(i, t)
        u, acc = rng.random(), 0.0
        for j in range(4):
            acc += p01.ROUTE[i][j]
            if u < acc:
                arrive(j, t)
                break
    return [[busy[i][d] / C[i] for d in range(WARM, DAYS)]
            for i in range(4)]

if __name__ == "__main__":
    rng = random.Random(83)
    load_ = simulate(rng)
    n = len(load_[0])
    true = p01.network(20.0, C, MU)[0]
    print("   team         true load  logged load ({} days)".format(n))
    for i, name in enumerate(p01.NAMES):
        print("   {:<12} {:9.3f}  {:11.3f}".format(
            name, true[i], sum(load_[i]) / n))
    for k in (1, 3, 7, 14, 30):
        hit = 0
        for _ in range(2000):
            days = [rng.randrange(n) for _ in range(k)]
            est = [sum(load_[i][d] for d in days) for i in range(4)]
            hit += max(range(4), key=lambda i: est[i]) == 2
        print("   {:2d} logged days: bottleneck named correctly {:.3f}"
              .format(k, hit / 2000))

Single source and citation

Fan, Y. (2026). Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds (Version 1.0.0), Chapter 8: Finding the Bottleneck in the Logs, a Contract Ledger and a Pre-Registered Switchback Experiment. 5D Library. https://doi.org/10.5281/zenodo.24090217

DOI: 10.5281/zenodo.24090217 · Read the monograph · 5DL-B-083 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026083,
  author    = {Fan, Yafu},
  title     = {Enterprise Bottleneck Diagnostics, SKU Cannibalization Audits and Automation Return Bounds},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  doi       = {10.5281/zenodo.24090217},
  url       = {https://doi.org/10.5281/zenodo.24090217}
}

Other chapter answers in this book