What does Bottleneck Triage and Value-per-Hour Scheduling conclude, in numbers, about “Field Tools and Checker Specifications: the Daily Scheduling Ledger, the Scheduler and a Pre-registered Test”?
Answer: Chapter 8 gives field tools and checker specifications: the daily scheduling ledger, the distilled Bottleneck Focus and Value-per-Hour Scheduler, red, yellow and green checks, daily, weekly and monthly rhythms, and a pre-registered paired-week test with refutation conditions; in the illustrative simulation the five-step pipeline averages 79.74 points a day against 42.85 for the habit of doing the most valuable task first and filling the cap. Marked boxes separate published evidence, runnable Python calculations (20 programs), classical sources and the author's hypotheses.
Scope of the numbers: Smith proved in 1956 that when one person faces a list, the order that minimises the weighted cost of delay sorts tasks by value divided by duration, not by value; on seven illustrative tasks the importance order pays 0.311 more than the exhaustive optimum. Frustum culling and levels of detail from computer graphics show that a fixed frame budget should not be spent on doing everything finely: doing all eight illustrative tasks finely finishes only three and reaches 0.783 of the best plan.
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: 20, 42.85, 79.74
| bottleneck: engage; planning budget 210 of 360 focus minutes | ||||
| plan: K1 60m | K2 80m | K3 50m | D1 20m | |
| pull list: R1 15m | A1 45m | |||
| policy | planned | mean value | p10 value | days all done |
| pipeline | 210 | 79.74 | 62.00 | 0.760 |
| H1 value, fine | 360 | 42.85 | 40.00 | 0.220 |
| H2 list, medium | 360 | 35.65 | 8.40 | 0.091 |
Show the full program
# Chapter 8. p81: the daily pipeline against two common habits.
# Pipeline: bottleneck (min stage capacity, p31) -> frustum classes
# (p41) -> WSPT order (p11) -> level-of-detail DP inside a planning
# budget = cap / (1 + buffer) (p51, p62) -> run the day.
# Habit H1: most valuable first, everything fine, plan the full cap.
# Habit H2: list order, everything medium, plan the full cap.
# A day: actual minutes = planned * 1.2 * exp(N(0, 0.6^2)); the focus
# cap of 360 minutes is a hard stop (unfinished work earns nothing).
# Value counts fully for IN tasks, 0.3 for DEFER, 0 for CULL. If the
# pipeline's plan ends early, it pulls the unplanned non-culled tasks
# at coarse level in w/p order (the buffer is not idle time).
# 4,000 simulated days, same draws for every policy. Illustrative.
import math
import random
import statistics
CAPS = {"acquire": 20.0, "engage": 15.0, "deliver": 18.0,
"collect": 40.0, "repeat": 24.0}
# id, stage fed (None = no path to cash), value V at fine, medium min
TASKS = [("A1", "acquire", 35.0, 90), ("X1", None, 25.0, 60),
("K3", "engage", 22.0, 50), ("D1", "deliver", 18.0, 40),
("K1", "engage", 40.0, 60), ("R1", "repeat", 12.0, 30),
("X2", None, 10.0, 30), ("K2", "engage", 30.0, 40)]
CAP, BUF = 360, 0.676
CREDIT = {"IN": 1.0, "DEFER": 0.3, "CULL": 0.0}
def levels(v, m, cash):
lo = 0.2 if cash else 0.45
return [(m // 2, lo * v), (m, 0.8 * v), (2 * m, v)]
def classify(stage, neck):
if stage is None:
return "CULL"
return "IN" if stage == neck else "DEFER"
def lod_plan(items, budget):
cap = budget // 10
best = [0.0] * (cap + 1)
keep = []
for _, _, opts, cr in items:
nxt, ch = best[:], [0] * (cap + 1)
for b in range(cap + 1):
for lv, (m, v) in enumerate(opts, start=1):
u = m // 10
if u <= b and best[b - u] + v * cr > nxt[b]:
nxt[b], ch[b] = best[b - u] + v * cr, lv
keep.append(ch)
best = nxt
out, b = [], cap
for i in range(len(items) - 1, -1, -1):
lv = keep[i][b]
if lv:
m, v = items[i][2][lv - 1]
out.append((items[i][0], m, v * items[i][3]))
b -= m // 10
return out[::-1]
def protocol():
neck = min(CAPS, key=lambda s: CAPS[s])
items = []
for tid, st, v, m in TASKS:
c = classify(st, neck)
if c != "CULL":
items.append((tid, c, levels(v, m, c == "IN"), CREDIT[c]))
items.sort(key=lambda it: -it[2][1][1] / it[2][1][0])
plan = lod_plan(items, int(CAP / (1 + BUF)) // 10 * 10)
done = {p[0] for p in plan}
tail = [(t, o[0][0], o[0][1] * cr) for t, _, o, cr in items
if t not in done]
tail.sort(key=lambda p: -p[2] / p[1])
return sorted(plan, key=lambda p: -p[2] / p[1]), tail, neck
def habit(order_key, lv):
neck = min(CAPS, key=lambda s: CAPS[s])
rows = []
for tid, st, v, m in sorted(TASKS, key=order_key):
c = classify(st, neck)
mm, vv = levels(v, m, c == "IN")[lv]
rows.append((tid, mm, vv * CREDIT[c]))
plan, used = [], 0
for r in rows:
if used + r[1] <= CAP:
plan.append(r)
used += r[1]
return plan
def run(plan, tail=(), days=4000):
rng = random.Random(37681)
vals, full = [], 0
for _ in range(days):
t, got, k = 0.0, [], 0
for _, m, v in plan:
t += m * 1.2 * math.exp(rng.gauss(0.0, 0.6))
if t <= CAP:
got.append(v)
k += 1
for _, m, v in tail:
if t >= CAP:
break
t += m * 1.2 * math.exp(rng.gauss(0.0, 0.6))
if t <= CAP:
got.append(v)
vals.append(math.fsum(got))
if k == len(plan):
full += 1
q = statistics.quantiles(vals, n=10)
return statistics.fmean(vals), q[0], full / days
plan, tail, neck = protocol()
print("bottleneck: %s; planning budget %d of %d focus minutes" % (
neck, int(CAP / (1 + BUF)) // 10 * 10, CAP))
print("plan: " + " ".join("%s %dm" % (t, m) for t, m, _ in plan))
print("pull list: " + " ".join("%s %dm" % (t, m) for t, m, _ in tail))
print("policy planned mean value p10 value days all done")
for name, pl, tl in (("pipeline", plan, tail),
("H1 value, fine", habit(lambda r: -r[2], 2), ()),
("H2 list, medium", habit(lambda r: 0, 1), ())):
mins = 0
for _, m, _ in pl:
mins += m
mean, p10, full = run(pl, tl)
print("%-15s %7d %10.2f %9.2f %13.3f" % (name, mins, mean, p10, full))Single source and citation
Fan, Y. (2026). Stage-Bottleneck Triage, Weighted Shortest-Processing-Time Scheduling and Level-of-Detail Execution Velocity (Version 1.0.0), Chapter 8: Field Tools and Checker Specifications: the Daily Scheduling Ledger, the Scheduler and a Pre-registered Test. 5D Library. DOI pending
DOI pending · monograph page goes live after publication · 5DL-B-376 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026376,
author = {Fan, Yafu},
title = {Stage-Bottleneck Triage, Weighted Shortest-Processing-Time Scheduling and Level-of-Detail Execution Velocity},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
note = {DOI pending}
}Other chapter answers in this book
- Chapter 1 · Why "Most Important First" Is Wrong: Value per Hour and the Adjacent Interchange
- Chapter 2 · Streams of Arriving Work: the c-mu Rule, the Generalised c-mu Rule and the Gittins Index
- Chapter 3 · The Single Bottleneck of a Phase: a Five-Stage Funnel, Little's Law and the Moving Constraint
- Chapter 4 · Frustum Culling: Tasks with No Causal Path to Cash
- Chapter 5 · Levels of Detail: a Multiple-Choice Knapsack inside a Fixed Focus Budget
- Chapter 6 · No Stalls: Log-Normal Tails, Pooled Buffers and a Focus Budget That Includes Rest
- Chapter 7 · The Classical Sources: Sunzi on Emptiness and Fullness, Mencius on Declining, Seneca's Second Letter and the Law of the Minimum