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 60mK2 80mK3 50mD1 20m
pull list: R1 15mA1 45m
policyplannedmean valuep10 valuedays all done
pipeline21079.7462.000.760
H1 value, fine36042.8540.000.220
H2 list, medium36035.658.400.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