DCT Laboratory — Volume I, Chapter 4
Enterprise Modeling Principles
This laboratory demonstrates
Seed 26104 · Companion to Chapter 4 and AXIOM Lab 1.4 (module AXIOM-04) · Mirrored in DCT_V1_Ch04_Lab.xlsx
This laboratory reproduces Worked Example 4.1, When the Roll-Up Breaks, with the book's declarations, and works the five steps of AXIOM Lab 1.4, Can We Trust the Model?: walk the chain, test a roll-up, fit and extrapolate, leave the record, set triggers. Every Meridian number below is the book's (Worked Example 4.1, Table 4.5, Figure 4.2, Appendix 4.A, Online Appendix 4.B); the final cell checks them. Headcounts are in engineers; no money enters this chapter's numbers.
The declarations (Worked Example 4.1, the situation)
Meridian's HR dashboard tracks the number of engineers in each unit of Industrial Systems, and the planning model projects each unit's total with one attrition rate. Two units each have 500 engineers. Unit A has 400 legacy-skill and 100 software-skill engineers; Unit B has 100 and 400. Each year 8 percent of legacy engineers leave the legacy pool (5 percent leave the company and 3 percent are retrained into software skills), and 4 percent of software engineers leave. With legacy and software engineers, the detailed model is (Appendix 4.A):
and the dashboard's summary is the total : the roll-up .
Python Code
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26104
# Worked Example 4.1: shares of each pool a year
EXIT_L, RETRAIN, EXIT_S = 0.05, 0.03, 0.04 # legacy engineers who leave the company; legacy retrained; software who leave
A = np.array([[1 - EXIT_L - RETRAIN, 0.0], # the legacy pool keeps 92 percent
[RETRAIN, 1 - EXIT_S]]) # the software pool keeps 96 percent and gains the retrained
UNITS = {"Unit A": np.array([400.0, 100.0]), # (legacy, software) engineers today
"Unit B": np.array([100.0, 400.0])}
P = np.array([1.0, 1.0]) # the dashboard's roll-up: the total H
YEARS = 5
def project(x0, years=YEARS):
# the detailed model x' = A x: one row per year 0..years, columns (legacy, software)
xs = [np.asarray(x0, float)]
for _ in range(years):
xs.append(A @ xs[-1])
return np.array(xs)
def clean(v, nd=9):
# round away floating dust, and print -0.0 as 0.0
return np.round(np.asarray(v, float), nd) + 0.0
print(f"A = [[{A[0, 0]:.2f}, {A[0, 1]:.2f}], [{A[1, 0]:.2f}, {A[1, 1]:.2f}]]")
print(f"legacy pool: {EXIT_L:.0%} leave the company and {RETRAIN:.0%} are retrained, so {1 - A[0, 0]:.0%} leave the pool"
f" a year; software pool: {EXIT_S:.0%} leave")
for name, x in UNITS.items():
print(f"{name}: {x[0]:.0f} legacy + {x[1]:.0f} software = {P @ x:.0f} engineers, software share {x[1] / (P @ x):.0%}")A = [[0.92, 0.00], [0.03, 0.96]] legacy pool: 5% leave the company and 3% are retrained, so 8% leave the pool a year; software pool: 4% leave Unit A: 400 legacy + 100 software = 500 engineers, software share 20% Unit B: 100 legacy + 400 software = 500 engineers, software share 80%
Panel 1 — Walk the chain (Table 4.1; Figure 4.1; Definition 4.1; Table 4.4)
AXIOM Lab 1.4, step 1: follow a question from diagram to running code, and note what each verification checkpoint tests. A company model arrives in a chain of four types, each translating its predecessor into a stricter medium (Table 4.1); an error introduced at one link travels silently through all later links, so every link is verified, not only the last. AXIOM's chain builder walks the working-capital question; the book declares no working-capital numbers, so this panel walks the question Worked Example 4.1 answers, how many engineers will each unit have?, and runs Table 4.4's three verification items on it: the mathematics renders the logic, the code implements the mathematics (a test on a known solution), and the constraints are preserved (internal consistency, Definition 4.5). Verification is internal: it can pass for a model that tracks nothing. Whether the end of the chain tracks the company is validation, the subject of Panel 7 (Figure 4.1: a perfectly verified chain can faithfully implement a wrong idea).
Python Code
TABLE_4_1 = [ # Table 4.1: type, medium, question it settles, typical failure
("Conceptual", "diagrams, prose", "what matters and how it connects", "omitted mechanism; wrong boundary"),
("Logical", "structured schema", "which readings, links, constraints", "hidden variable; category error"),
("Mathematical", "spaces, mappings", "exact form of dynamics and constraints",
"unearned assumption (linearity, independence)"),
("Computational", "code, data", "numbers, paths, optima", "implementation bug; discretization artifact")]
CHAIN = [ # Worked Example 4.1's question, link by link
("Conceptual", "two pools of engineers in each unit; engineers leave, and legacy engineers are retrained into software"),
("Logical", "a unit's state is (legacy, software); links legacy -> software and both pools -> exit; no pool is negative"),
("Mathematical", "x' = A x with A = [[0.92, 0], [0.03, 0.96]] (Appendix 4.A)"),
("Computational", "project(x0) above: the recursion, run year by year")]
print(f"Table 4.1: {len(TABLE_4_1)} model types, each translating its predecessor into a stricter medium")
for t, medium, question, failure in TABLE_4_1:
print(f" {t:13s} {medium:17s} settles: {question:39s} typical failure: {failure}")
print("\nWorked Example 4.1's question through the chain")
for t, content in CHAIN:
print(f" {t:13s} {content}")
print(" the completed chain is Definition 4.1's quadruple M = (X, mu, f-hat, g-hat): X, a unit's pairs of headcounts;"
"\n mu, engineers counted by skill pool; f-hat(x) = A x, the modeler's claim; g-hat(x) = the total, the dashboard's reading")
# Table 4.4, verification (1): the mathematics renders the logic
kept = A.sum(axis=0) # the share of each pool that stays in the company a year
logic_gap = max(abs((1 - kept[0]) - EXIT_L), abs((1 - kept[1]) - EXIT_S))
print(f"\nverify (1), logic -> mathematics: the company keeps {kept[0]:.2f} of a legacy pool and {kept[1]:.2f} of a software"
f" pool, so {1 - kept[0]:.0%} and {1 - kept[1]:.0%} leave, as declared (gap {logic_gap:.1e});"
" the retrained change pools without leaving")
# verification (2): the code implements the mathematics, tested on a known solution
def closed_form(x0, k):
# h_l(k) = 0.92^k h_l(0); h_s(k) = 0.96^k h_s(0) + 0.03 h_l(0) (0.96^k - 0.92^k) / (0.96 - 0.92)
a, c, d = A[0, 0], A[1, 0], A[1, 1]
return np.array([a ** k * x0[0], d ** k * x0[1] + c * x0[0] * (d ** k - a ** k) / (d - a)])
code_gap = max(float(abs(project(x0)[k] - closed_form(x0, k)).max()) for x0 in UNITS.values() for k in range(YEARS + 1))
print(f"verify (2), mathematics -> code: the recursion against the closed form, years 0-{YEARS}, both units:"
f" largest gap {code_gap:.1e}")
# verification (3): constraints preserved; the model never leaves its own admissible region (Definition 4.5)
century = [project(x0, 100) for x0 in UNITS.values()]
low = min(float(c.min()) for c in century)
negative = sum(int((c < 0).sum()) for c in century)
rises = sum(int((np.diff(c.sum(axis=1)) > 0).sum()) for c in century)
print(f"verify (3), internal consistency: over 100 years no pool is negative ({negative} cases; the smallest is {low:.2f}),"
f" and a unit's total rises in {rises} years (the model declares no hiring)")Table 4.1: 4 model types, each translating its predecessor into a stricter medium Conceptual diagrams, prose settles: what matters and how it connects typical failure: omitted mechanism; wrong boundary Logical structured schema settles: which readings, links, constraints typical failure: hidden variable; category error Mathematical spaces, mappings settles: exact form of dynamics and constraints typical failure: unearned assumption (linearity, independence) Computational code, data settles: numbers, paths, optima typical failure: implementation bug; discretization artifact Worked Example 4.1's question through the chain Conceptual two pools of engineers in each unit; engineers leave, and legacy engineers are retrained into software Logical a unit's state is (legacy, software); links legacy -> software and both pools -> exit; no pool is negative Mathematical x' = A x with A = [[0.92, 0], [0.03, 0.96]] (Appendix 4.A) Computational project(x0) above: the recursion, run year by year the completed chain is Definition 4.1's quadruple M = (X, mu, f-hat, g-hat): X, a unit's pairs of headcounts; mu, engineers counted by skill pool; f-hat(x) = A x, the modeler's claim; g-hat(x) = the total, the dashboard's reading verify (1), logic -> mathematics: the company keeps 0.95 of a legacy pool and 0.96 of a software pool, so 5% and 4% leave, as declared (gap 4.2e-17); the retrained change pools without leaving verify (2), mathematics -> code: the recursion against the closed form, years 0-5, both units: largest gap 5.7e-14 verify (3), internal consistency: over 100 years no pool is negative (0 cases; the smallest is 0.02), and a unit's total rises in 0 years (the model declares no hiring)
Panel 2 — Project the detailed model (Worked Example 4.1, Step 1; Table 4.5)
AXIOM Lab 1.4, step 2, first part: the aggregation tester runs the detailed model unit by unit. Unit A next year has legacy engineers and software engineers: a total of 476. Unit B has and : a total of 479. Run on for five years, the detailed model gives the first two rows of Table 4.5.
Python Code
paths = {name: project(x0) for name, x0 in UNITS.items()}
totals = {name: p.sum(axis=1) for name, p in paths.items()}
yrs = np.arange(YEARS + 1)
for name, p in paths.items():
print(f"{name} next year: {p[1, 0]:.0f} legacy + {p[1, 1]:.0f} software = {totals[name][1]:.0f} engineers")
def row(label, values, f="9.1f"):
print(f" {label:42s}" + "".join(f"{v:{f}}" for v in clean(values)))
print("\nTable 4.5" + " " * 35 + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
for name in UNITS:
row(f"{name}, detailed model", totals[name])Unit A next year: 368 legacy + 108 software = 476 engineers Unit B next year: 92 legacy + 387 software = 479 engineers Table 4.5 year 0 year 1 year 2 year 3 year 4 year 5 Unit A, detailed model 500.0 476.0 453.3 431.8 411.4 392.1 Unit B, detailed model 500.0 479.0 458.9 439.7 421.3 403.8
Panel 3 — Apply the roll-up test (Worked Example 4.1, Step 2; Theorem 4.2; Appendix 4.A; Figure 4.2)
AXIOM Lab 1.4, step 2: roll the engineers up to a single total and test it. By Theorem 4.2 a summary supports its own forecasting model exactly when the detailed dynamics never split what the summary lumps together. Units A and B have the same total today, 500, and different totals next year, 476 and 479: the dynamics split the fiber of 500 (Figure 4.2), so the total alone is not a state, and no model that forecasts from the total alone can be right for both units. For linear dynamics the test is a calculation (Appendix 4.A): with , is spanned by , and lies outside it.
The tester below applies the same calculation to other one-number summaries the dashboard could carry, and tries each on 10,000 random pairs of configurations that share the summary (drawn with the lab's seed, 26104). Only summaries along directions the dynamics do not split pass: the legacy count, and a weighted count of three legacy to four software engineers. That is the book's practical rule: summarize along directions the dynamics do not split, or carry the mix up into the summary (Step 5). Table 4.2 lists skill mix by unit among the readings of level .
Python Code
img = A @ np.array([1.0, -1.0])
print(f"Appendix 4.A: ker P is spanned by (1, -1); A (1, -1) = ({img[0]:.2f}, {img[1]:.2f}), whose total is"
f" {P @ img:+.2f}: outside ker P, so the condition fails")
print(f"Step 2: the same total today ({UNITS['Unit A'] @ P:.0f} and {UNITS['Unit B'] @ P:.0f}), different totals next year"
f" ({totals['Unit A'][1]:.0f} and {totals['Unit B'][1]:.0f}): the dynamics split the fiber of 500\n")
SUMMARIES = {"total (the dashboard)": np.array([1.0, 1.0]), "software engineers": np.array([0.0, 1.0]),
"legacy engineers": np.array([1.0, 0.0]), "3 legacy + 4 software": np.array([3.0, 4.0])}
def roll_up_test(p):
# Theorem 4.2, linear case: the one-row roll-up p supports a model exactly when A maps ker p into ker p
v = np.array([p[1], -p[0]]) # spans ker p
return float(p @ (A @ v))
def fiber_pairs(p, n=10_000, seed=SEED):
# pairs of configurations (up to 1,000 engineers in each pool) with the same summary today;
# returns the pairs kept, how equal the summaries are today, and the largest gap between them next year
rng = np.random.default_rng(seed)
v = np.array([p[1], -p[0]]) / abs(np.array([p[1], -p[0]])).max()
x1 = rng.uniform(0, 1000, size=(n, 2))
x2 = x1 + rng.uniform(-500, 500, size=(n, 1)) * v
ok = (x2 >= 0).all(axis=1)
x1, x2 = x1[ok], x2[ok]
return int(ok.sum()), float(abs(x1 @ p - x2 @ p).max()), float(abs((x1 @ A.T) @ p - (x2 @ A.T) @ p).max())
print(f"{'summary':24s} {'p A v (0 passes)':>17s} {'pairs':>7s} {'largest gap next year':>22s} verdict")
tester, today_max = {}, 0.0
for name, p in SUMMARIES.items():
test = roll_up_test(p)
n, today, gap = fiber_pairs(p)
today_max = max(today_max, today)
j = int(np.argmax(abs(p)))
rate = float((p @ A)[j] / p[j]) if abs(test) < 1e-12 else None
tester[name] = (test, gap, rate)
verdict = f"a state: next year = {rate:.2f} x this year" if rate is not None else "not a state: the dynamics split it"
print(f"{name:24s} {test:17.4f} {n:7d} {gap:22.2e} {verdict}")
print(f"(pairs drawn with the lab's seed {SEED}; the two summaries of each pair agree today to {today_max:.0e})")Appendix 4.A: ker P is spanned by (1, -1); A (1, -1) = (0.92, -0.93), whose total is -0.01: outside ker P, so the condition fails Step 2: the same total today (500 and 500), different totals next year (476 and 479): the dynamics split the fiber of 500 summary p A v (0 passes) pairs largest gap next year verdict total (the dashboard) -0.0100 7505 5.00e+00 not a state: the dynamics split it software engineers 0.0300 8740 1.50e+01 not a state: the dynamics split it legacy engineers 0.0000 8765 0.00e+00 a state: next year = 0.92 x this year 3 legacy + 4 software 0.0000 7797 1.82e-12 a state: next year = 0.96 x this year (pairs drawn with the lab's seed 26104; the two summaries of each pair agree today to 9e-13)
Panel 4 — Watch the error grow (Worked Example 4.1, Step 3; Table 4.5; Online Appendix 4.B)
Suppose the planning model is calibrated on Unit A's first year: total next year total today 0.952. Applied to Unit B, it under-forecasts by 3 engineers in year one and by about 13 by year five (Table 4.5). The error grows because the mix keeps shifting; for the same reason the model also errs a little for Unit A itself after its first year (the last row below, which the book does not print). Online Appendix 4.B bounds such an approximate aggregation: if the summary model misses by at most in one step and is Lipschitz with constant , the gap after periods is at most , roughly in proportion to the number of periods when is near one. Here , and Unit B's one-step miss is largest in year one: 3 engineers.
Python Code
r = totals["Unit A"][1] / totals["Unit A"][0] # calibrated on Unit A's first year: 476 / 500
coarse = totals["Unit A"][0] * r ** yrs # the total-only model from 500
errB, errA = coarse - totals["Unit B"], coarse - totals["Unit A"]
print(f"Step 3: calibrated on Unit A's first year, total next year = total today x {r:.3f}\n")
print("Table 4.5" + " " * 35 + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
row("Unit A, detailed model", totals["Unit A"])
row("Unit B, detailed model", totals["Unit B"])
row("Total-only model (x 0.952 a year)", coarse)
row("Error for Unit B", errB)
row("Error for Unit A (not printed in the book)", errA)
miss = np.abs(r * totals["Unit B"][:-1] - totals["Unit B"][1:]) # one-step misses along Unit B's path
delta, L = float(miss.max()), float(r)
bound = np.array([delta * (L ** k - 1) / (L - 1) for k in yrs])
fails = int((np.abs(errB) > bound + 1e-9).sum())
print(f"\nOnline Appendix 4.B: one-step misses for Unit B, years 1-5: {', '.join(f'{m:.2f}' for m in miss)};"
f" delta = {delta:.2f}, L = {L:.3f}")
row("bound delta (L^k - 1) / (L - 1)", bound, "9.2f")
row("Unit B's error, in absolute value", np.abs(errB), "9.2f")
print(f" the bound holds in every year (it fails in {fails}); with L = 1 it would be k delta, {YEARS * delta:.1f} by year five")
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.35, 1]})
ax1.plot(yrs, totals["Unit A"], "-o", color="#1F4E79", ms=4, lw=2, label="Unit A, detailed model")
ax1.plot(yrs, totals["Unit B"], "-o", color="#E65100", ms=4, lw=2, label="Unit B, detailed model")
ax1.plot(yrs, coarse, "--", color="#616161", lw=1.4, label="total-only model, x 0.952 a year")
ax1.annotate(f"{totals['Unit B'][-1]:.1f}", (YEARS, totals["Unit B"][-1]), textcoords="offset points", xytext=(5, 0),
fontsize=8, color="#E65100", va="center")
ax1.annotate(f"{totals['Unit A'][-1]:.1f}", (YEARS, totals["Unit A"][-1]), textcoords="offset points", xytext=(5, 4),
fontsize=8, color="#1F4E79", va="center")
ax1.annotate(f"{coarse[-1]:.1f}", (YEARS, coarse[-1]), textcoords="offset points", xytext=(5, -7), fontsize=8,
color="#616161", va="center")
ax1.set(xlabel="years", ylabel="engineers in the unit", xticks=yrs, xlim=(-0.2, 5.9), ylim=(380, 506))
ax1.legend(frameon=False, fontsize=8, loc="lower left")
ax2.bar(yrs[1:] - 0.19, -errB[1:], 0.38, color="#E65100", label="Unit B")
ax2.bar(yrs[1:] + 0.19, -errA[1:], 0.38, color="#1F4E79", label="Unit A")
ax2.plot(yrs, bound, ":", color="#B71C1C", lw=1.6, label="Online Appendix 4.B bound")
ax2.set(xlabel="years", ylabel="under-forecast (engineers)", xticks=yrs)
ax2.legend(frameon=False, fontsize=8, loc="upper left")
fig.suptitle("One total, two futures: the total-only model misses Unit B by 12.8 (seed 26104)", fontsize=10)
plt.tight_layout(); plt.show()Step 3: calibrated on Unit A's first year, total next year = total today x 0.952 Table 4.5 year 0 year 1 year 2 year 3 year 4 year 5 Unit A, detailed model 500.0 476.0 453.3 431.8 411.4 392.1 Unit B, detailed model 500.0 479.0 458.9 439.7 421.3 403.8 Total-only model (x 0.952 a year) 500.0 476.0 453.2 431.4 410.7 391.0 Error for Unit B 0.0 -3.0 -5.8 -8.3 -10.7 -12.8 Error for Unit A (not printed in the book) 0.0 0.0 -0.1 -0.4 -0.7 -1.1 Online Appendix 4.B: one-step misses for Unit B, years 1-5: 3.00, 2.91, 2.82, 2.74, 2.65; delta = 3.00, L = 0.952 bound delta (L^k - 1) / (L - 1) 0.00 3.00 5.86 8.57 11.16 13.63 Unit B's error, in absolute value 0.00 3.00 5.77 8.32 10.66 12.80 the bound holds in every year (it fails in 0); with L = 1 it would be k delta, 15.0 by year five

Panel 5 — See what the total hides, and repair the summary (Worked Example 4.1, Steps 4–5; Theorems 4.1–4.2)
AXIOM Lab 1.4, step 2, second part: add the skill mix to the summary and test again. By year five the totals are close, 392 and 404, but the companies they describe are not: compare their software engineers below. The digital program needs software engineers, so a headcount dashboard would misstate exactly the capacity the board most needs to see. That is the representation bound (Theorem 4.1) in Meridian's numbers: today the two units are the same dashboard state, 500, and differ by 300 software engineers, so a question about software capacity cannot be answered from the dashboard by any analysis. The remedy is a richer representation, not cleverer analysis.
The repair (Step 5). Carry the software share alongside the total . The detailed dynamics then roll up exactly: next year's total is , which gives for Unit A and for Unit B, matching Step 1. The share follows a rule of its own that the declarations imply, , so the enlarged summary satisfies the condition of Theorem 4.2 and agrees with the detailed model at every horizon. Rolled up once more, to the two units together, it stays consistent (Proposition 4.3).
Python Code
soft = {name: paths[name][:, 1] for name in UNITS}
share = {name: soft[name] / totals[name] for name in UNITS}
print(f"Step 4, year {YEARS}: totals {totals['Unit A'][-1]:.1f} and {totals['Unit B'][-1]:.1f};"
f" software engineers {soft['Unit A'][-1]:.1f} and {soft['Unit B'][-1]:.1f}"
f" (software shares {share['Unit A'][-1]:.1%} and {share['Unit B'][-1]:.1%})")
print(f"Theorem 4.1: today both units are the dashboard state {UNITS['Unit A'] @ P:.0f}; their software engineers are"
f" {UNITS['Unit A'][1]:.0f} and {UNITS['Unit B'][1]:.0f}\n")
def mix_model(H, s):
# Step 5: the total carried with the software share; both rules follow from x' = A x
H1 = H * (1 - EXIT_L + (EXIT_L - EXIT_S) * s) # H (0.95 + 0.01 s)
return H1, H * (RETRAIN + (1 - EXIT_S - RETRAIN) * s) / H1 # s' = (0.03 + 0.93 s) / (0.95 + 0.01 s)
print(f"Step 5: the repaired summary's coefficients are 1 - {EXIT_L} = {1 - EXIT_L:.2f} and {EXIT_L} - {EXIT_S} ="
f" {EXIT_L - EXIT_S:.2f}")
for name, x in UNITS.items():
H, s = x @ P, x[1] / (x @ P)
print(f" {name}: {H:.0f} x (0.95 + 0.01 x {s:.1f}) = {mix_model(H, s)[0]:.0f}, matching Step 1's {totals[name][1]:.0f}")
Hs_units_gap = 0.0
for name, x in UNITS.items(): # the (H, s) model run forward five years, against Table 4.5
H, s = x @ P, x[1] / (x @ P)
for k in range(1, YEARS + 1):
H, s = mix_model(H, s)
Hs_units_gap = max(Hs_units_gap, abs(H - totals[name][k]), abs(s - share[name][k]))
X = np.random.default_rng(SEED).uniform(0, 1000, size=(10_000, 2)) # random configurations, the lab's seed
H, s = X.sum(axis=1), X[:, 1] / X.sum(axis=1)
Hs_gap = 0.0
for k in range(YEARS): # test again: summary model forward against the detailed model rolled up
H, s = mix_model(H, s)
X = X @ A.T
Hs_gap = max(Hs_gap, float(abs(H - X.sum(axis=1)).max()), float(abs(s - X[:, 1] / X.sum(axis=1)).max()))
print(f"\nthe (H, s) model run forward five years against the detailed model rolled up: Units A and B, largest gap"
f" {Hs_units_gap:.1e}; 10,000 random configurations (seed {SEED}), {Hs_gap:.1e}")
both = UNITS["Unit A"] + UNITS["Unit B"] # Proposition 4.3: roll the two units up once more
Hd1, sd1 = mix_model(both.sum(), both[1] / both.sum())
print(f"Proposition 4.3: the two units together, {both.sum():.0f} engineers with software share {both[1] / both.sum():.0%}:"
f" the (H, s) model gives {Hd1:.0f} next year = {totals['Unit A'][1]:.0f} + {totals['Unit B'][1]:.0f};"
f" the total-only model gives {r * both.sum():.0f}")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for name, col, dy_t, dy_s in (("Unit A", "#1F4E79", -5, 0), ("Unit B", "#E65100", 5, -4)):
ax.plot(yrs, totals[name], "-o", color=col, lw=2, ms=4, label=f"{name}: all engineers")
ax.plot(yrs, soft[name], "--s", color=col, lw=1.6, ms=3.5, label=f"{name}: software engineers")
ax.annotate(f"{totals[name][-1]:.1f}", (YEARS, totals[name][-1]), textcoords="offset points", xytext=(6, dy_t),
fontsize=8, color=col, va="center")
ax.annotate(f"{soft[name][-1]:.1f}", (YEARS, soft[name][-1]), textcoords="offset points", xytext=(6, dy_s),
fontsize=8, color=col, va="center")
ax.set(xlabel="years", ylabel="engineers", xticks=yrs, xlim=(-0.2, 5.9), ylim=(0, 560),
title="Close totals, different companies: software engineers by unit (seed 26104)")
ax.legend(frameon=False, fontsize=8, ncol=2, loc="center left", bbox_to_anchor=(0.0, 0.42))
plt.tight_layout(); plt.show()Step 4, year 5: totals 392.1 and 403.8; software engineers 128.4 and 337.9 (software shares 32.8% and 83.7%) Theorem 4.1: today both units are the dashboard state 500; their software engineers are 100 and 400 Step 5: the repaired summary's coefficients are 1 - 0.05 = 0.95 and 0.05 - 0.04 = 0.01 Unit A: 500 x (0.95 + 0.01 x 0.2) = 476, matching Step 1's 476 Unit B: 500 x (0.95 + 0.01 x 0.8) = 479, matching Step 1's 479 the (H, s) model run forward five years against the detailed model rolled up: Units A and B, largest gap 1.1e-13; 10,000 random configurations (seed 26104), 6.8e-13 Proposition 4.3: the two units together, 1000 engineers with software share 50%: the (H, s) model gives 955 next year = 476 + 479; the total-only model gives 952

Panel 6 — Fit and extrapolate (Section 4.5)
AXIOM Lab 1.4, step 3: on the model bench, fit a simple and a rich model to the same adoption history and slide the rich model's complexity up; compare the fit on the history with the error on the later quarters. The book prints no numbers for this step. The bench history below is the lab's own: the share of target users of a new digital service, quarter by quarter, following an S-shaped curve (ceiling 60 percent, midpoint quarter 12, speed 0.35 a quarter) observed with a measurement error of standard deviation 1.5 points, drawn with the lab's seed 26104. These are bench settings to vary, not Meridian facts. The simple model is a straight line; the rich model is a polynomial whose degree is the complexity slider. Both are fitted to quarters 1–16 and judged on quarters 17–24. Each added degree fits the history better, as it must; the forecast does not follow. A fitted curve's only content is its record, and it says nothing reliable off it.
Python Code
Q = np.arange(1, 25) # quarters 1-24
HIST, LATER = Q <= 16, Q > 16
CEIL, SPEED, MID, NOISE_SD = 60.0, 0.35, 12.0, 1.5 # bench settings, not Meridian facts
curve = CEIL / (1 + np.exp(-SPEED * (Q - MID)))
noise = np.random.default_rng(SEED).normal(0.0, NOISE_SD, Q.size) # the lab's seed 26104
adopt = curve + noise
z = (Q - 8.5) / 7.5 # quarters 1-16 mapped onto [-1, 1], for a well-conditioned fit
def fit(deg):
c = np.linalg.lstsq(np.vander(z[HIST], deg + 1), adopt[HIST], rcond=None)[0]
pred = np.vander(z, deg + 1) @ c
rmse = lambda m: float(np.sqrt(np.mean((pred[m] - adopt[m]) ** 2)))
return c, rmse(HIST), rmse(LATER), pred
DEGREES = range(1, 9)
bench = {d: fit(d) for d in DEGREES}
print("adoption history (percent of target users), quarters 1-16:", ", ".join(f"{v:.1f}" for v in adopt[HIST]))
print("later quarters 17-24: ", ", ".join(f"{v:.1f}" for v in adopt[LATER]))
print(f"\n{'model':22s} {'parameters':>10s} {'error on history':>17s} {'error on later quarters':>24s} {'quarter 24':>11s}")
for d in DEGREES:
c, rh, rl, pred = bench[d]
label = "simple: a straight line" if d == 1 else f"rich: degree {d}"
print(f"{label:22s} {d + 1:10d} {rh:17.2f} {rl:24.2f} {pred[-1]:11.1f}")
print("(root-mean-square errors in percentage points)")
better_fit_worse = [d for d in DEGREES if d > 1 and bench[d][1] < bench[1][1] and bench[d][2] > bench[1][2]]
print(f"every rich model, degrees {better_fit_worse[0]}-{better_fit_worse[-1]}, fits the history better than the line"
f" and forecasts the later quarters worse: {len(better_fit_worse)} of {len(DEGREES) - 1}")
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.4, 1]})
ax1.axvspan(16.5, 24.5, color="#F2F2F2", lw=0)
qq = np.linspace(1, 24, 400)
for d, col, ls in ((1, "#1F4E79", "-"), (3, "#E65100", "--"), (6, "#B71C1C", ":")):
ax1.plot(qq, np.vander((qq - 8.5) / 7.5, d + 1) @ bench[d][0], ls, color=col, lw=1.6,
label="straight line" if d == 1 else f"degree {d}")
ax1.plot(Q[HIST], adopt[HIST], "o", color="#616161", ms=3.5, label="history, quarters 1-16")
ax1.plot(Q[LATER], adopt[LATER], "o", mfc="white", color="#616161", ms=3.5, label="later quarters")
ax1.text(20.5, 3, "later\nquarters", ha="center", fontsize=8, color="#616161")
ax1.set(xlabel="quarter", ylabel="adoption (percent of target users)", xlim=(0.5, 24.5), ylim=(-5, 100))
ax1.legend(frameon=False, fontsize=7.5, loc="upper left")
ax2.semilogy(list(DEGREES), [bench[d][1] for d in DEGREES], "-o", color="#1F4E79", ms=4, label="error on the history")
ax2.semilogy(list(DEGREES), [bench[d][2] for d in DEGREES], "-o", color="#E65100", ms=4, label="error on later quarters")
ax2.set(xlabel="degree (complexity)", ylabel="RMS error (percentage points)", xticks=list(DEGREES), ylim=(0.8, 8000))
ax2.legend(frameon=False, fontsize=8, loc="upper left")
fig.suptitle("The better fit on history is the worse forecast (seed 26104)", fontsize=10)
plt.tight_layout(); plt.show()adoption history (percent of target users), quarters 1-16: 3.2, 1.2, 3.9, 4.5, 2.9, 7.8, 12.7, 12.6, 13.6, 19.1, 25.3, 26.7, 35.1, 40.2, 46.3, 47.0 later quarters 17-24: 52.2, 53.2, 56.6, 56.2, 58.4, 58.3, 59.9, 61.2 model parameters error on history error on later quarters quarter 24 simple: a straight line 2 4.35 4.66 68.9 rich: degree 2 3 1.81 31.78 114.7 rich: degree 3 4 1.71 18.44 90.5 rich: degree 4 5 1.62 24.77 6.6 rich: degree 5 6 1.40 248.61 -468.5 rich: degree 6 7 1.36 575.08 -1198.7 rich: degree 7 8 1.36 810.76 -1748.6 rich: degree 8 9 1.36 539.66 1454.0 (root-mean-square errors in percentage points) every rich model, degrees 2-8, fits the history better than the line and forecasts the later quarters worse: 7 of 7

Panel 7 — Leave the record (Definition 4.6; Theorem 4.3; Figure 4.3; Table 4.4)
AXIOM Lab 1.4, step 4: fit two models to the same record, confirm that they fit equally well, then run both beyond it. Take as the record Unit A's first year, the year the planning model was calibrated on. Its excited domain (Definition 4.6) is the one state it visits, 400 legacy and 100 software engineers. The total-only model and the detailed model fit it equally well, both predicting 476.0, and they make identical predictions for every unit with that mix, one software engineer in five, whatever its size: no statistic computed from the record can tell them apart (Theorem 4.3). Off the record they separate in proportion to the distance from the record's mix. Unit B, four software engineers in five, lies outside it: there the two models disagree by 3 engineers in a year and 12.8 by year five. A longer record, Unit A's five years, carries the mix to one in three and begins to separate the two models; it still says nothing about Unit B.
Section 4.5 runs the same audit on the digital-program model, validated on seven years of history, by Table 4.4's domain items: the excited domain described, the intended use compared with it, and the conclusions beyond it annotated with the assumptions that carry them.
Python Code
def one_year(model, H, s):
# each model's forecast of next year's total from a unit's total H and software share s
return r * H if model == "total-only" else H * (1 - EXIT_L + (EXIT_L - EXIT_S) * s)
MODELS = ("total-only", "detailed")
H0, s0, obs1 = totals["Unit A"][0], share["Unit A"][0], totals["Unit A"][1] # the record: Unit A's first year
print(f"the record: Unit A, {H0:.0f} engineers with software share {s0:.0%}; next year {obs1:.1f}")
disc = {}
for m in MODELS:
pred = one_year(m, H0, s0)
disc[m] = abs(pred - obs1)
print(f" {m:10s} model predicts {pred:.1f}: discrepancy {disc[m]:.1e}, squared error {(pred - obs1) ** 2:.1e}")
same_mix = max(abs(one_year("total-only", H, s0) - one_year("detailed", H, s0)) for H in (100.0, 250.0, 1000.0, 5000.0))
print(f" on the record's mix the two models agree for a unit of any size: largest gap {same_mix:.1e}")
grid = np.round(np.arange(0.0, 1.0001, 0.1), 1)
print("\nbeyond the record: next year's total for a unit of 500, by software share")
print(f" {'software share':16s}" + "".join(f"{s:7.1f}" for s in grid))
for m in MODELS:
print(f" {m + ' model':16s}" + "".join(f"{one_year(m, 500.0, s):7.1f}" for s in grid))
gapB = one_year("detailed", 500.0, 0.8) - one_year("total-only", 500.0, 0.8)
print(f" at Unit B's mix the two models part by {gapB:.1f} engineers in a year: {one_year('total-only', 500.0, 0.8):.0f}"
f" against {one_year('detailed', 500.0, 0.8):.0f} (Step 2)")
recA = float(abs(errA).max())
print(f"\nUnit A's five-year record (software share {share['Unit A'][0]:.0%} to {share['Unit A'][-1]:.0%}): the total-only"
f" model misses by at most {recA:.2f}, the detailed model not at all")
print(f"Unit B lies outside that record: the total-only model misses it by {abs(errB[-1]):.1f} by year five")
AUDIT = [ # Section 4.5: the digital-program model, validated on seven years of history
("the program's leverage and liquidity", "within the ranges history visited", "validation evidence applies"),
("capability spending above 40% of capital spending", "no year in the record", "carried by assumptions"),
("two platforms run side by side", "no period in the record", "carried by assumptions"),
("a talent market like the hiring plan assumes", "none in the record", "carried by assumptions")]
print("\nSection 4.5's domain audit of the digital-program model (seven years of history; Table 4.4, domain items)")
for what, record, verdict in AUDIT:
print(f" {what:51s} {record:35s} {verdict}")
print(" the assumptions that carry it: an attrition mechanism credentialed elsewhere, an adoption mechanism declared"
" as an assumption rather than fitted")
ss = np.linspace(0, 1, 201)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.axvspan(share["Unit A"][0], share["Unit A"][-1], color="#EEF3F9", lw=0)
ax.text((share["Unit A"][0] + share["Unit A"][-1]) / 2, 480.15, "Unit A's\nfive-year\nrecord", ha="center", va="top",
fontsize=8, color="#1F4E79")
ax.plot(ss, [one_year("total-only", 500.0, s) for s in ss], "--", color="#616161", lw=1.6,
label="total-only model: 500 x 0.952 at every mix")
ax.plot(ss, [one_year("detailed", 500.0, s) for s in ss], color="#1F4E79", lw=2, label="detailed model: 500 (0.95 + 0.01 s)")
ax.plot([s0], [obs1], "o", color="#1F4E79", ms=6, zorder=3)
ax.annotate("the record: Unit A's first year,\nboth models 476.0", (s0, obs1), textcoords="offset points", xytext=(-38, -34),
fontsize=8, color="#1F4E79")
ax.plot([0.8, 0.8], [one_year("total-only", 500.0, 0.8), one_year("detailed", 500.0, 0.8)], color="#E65100", lw=2.5,
zorder=3)
ax.annotate(f"Unit B: 476 against 479,\n{gapB:.1f} apart", (0.8, 477.5), textcoords="offset points", xytext=(8, -6),
fontsize=8, color="#E65100")
ax.set(xlabel="software share of the unit's engineers", ylabel="engineers next year (unit of 500)", xlim=(0, 1),
ylim=(474.6, 480.4), title="Equal on the record, apart beyond it (seed 26104)")
ax.legend(frameon=False, fontsize=8, loc="upper left", bbox_to_anchor=(0.36, 1.0))
plt.tight_layout(); plt.show()the record: Unit A, 500 engineers with software share 20%; next year 476.0 total-only model predicts 476.0: discrepancy 0.0e+00, squared error 0.0e+00 detailed model predicts 476.0: discrepancy 0.0e+00, squared error 0.0e+00 on the record's mix the two models agree for a unit of any size: largest gap 0.0e+00 beyond the record: next year's total for a unit of 500, by software share software share 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 total-only model 476.0 476.0 476.0 476.0 476.0 476.0 476.0 476.0 476.0 476.0 476.0 detailed model 475.0 475.5 476.0 476.5 477.0 477.5 478.0 478.5 479.0 479.5 480.0 at Unit B's mix the two models part by 3.0 engineers in a year: 476 against 479 (Step 2) Unit A's five-year record (software share 20% to 33%): the total-only model misses by at most 1.08, the detailed model not at all Unit B lies outside that record: the total-only model misses it by 12.8 by year five Section 4.5's domain audit of the digital-program model (seven years of history; Table 4.4, domain items) the program's leverage and liquidity within the ranges history visited validation evidence applies capability spending above 40% of capital spending no year in the record carried by assumptions two platforms run side by side no period in the record carried by assumptions a talent market like the hiring plan assumes none in the record carried by assumptions the assumptions that carry it: an attrition mechanism credentialed elsewhere, an adoption mechanism declared as an assumption rather than fitted

Panel 8 — Set triggers, and write the contract (Section 4.6; Figure 4.4; Tables 4.3–4.4)
AXIOM Lab 1.4, step 5: replay five years of use with drift, and set the triggers that should send the model back for revalidation. The lifecycle of Figure 4.4 runs specify, build, verify, validate, deploy, monitor, revise or retire; Table 4.4's monitoring item asks for drift indicators and revalidation triggers. Replay the planning model's five-year plan for both units against what happens, with two drift indicators: the plan's error, and how far the unit's software share has moved from the mix the model was calibrated on, 20 percent. The book declares no tolerances; the tolerances below are settings to vary. The mix indicator fires before the error does, and fires for Unit B before any plan is made, because Unit B lies outside the record. A third trigger is an event, not a measurement: revalidation follows transformation, because a company that completes a transformation has left the domain its models were validated on.
The lab's deliverable is a one-page modeling contract for the digital-program model. The last lines assemble its four parts (Section 4.1) from the book's declarations: the readings and units (Table 3.1), the assumption classes with Meridian's instances (Table 4.3), the validated domain (Section 4.5) and the lifecycle plan (Section 4.6).
Python Code
LIFECYCLE = ["specify", "build", "verify", "validate", "deploy", "monitor", "revise or retire"] # Figure 4.4
print("Figure 4.4: " + " -> ".join(LIFECYCLE) + f" ({len(LIFECYCLE)} stages)\n")
s_cal = share["Unit A"][0]
indic = {name: {"error": np.abs(clean(coarse - totals[name])), "mix": 100 * np.abs(share[name] - s_cal)} for name in UNITS}
print(f"{'replay: the five-year plan against what happens':56s}" + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
for name in UNITS:
print(f" {name + ': plan error (engineers)':54s}" + "".join(f"{v:9.2f}" for v in indic[name]["error"]))
print(f" {name + ': software share, points from 20%':54s}" + "".join(f"{v:9.2f}" for v in indic[name]["mix"]))
def first_year(series, tol):
hit = np.nonzero(np.asarray(series) > tol + 1e-12)[0]
return int(hit[0]) if len(hit) else None
ERR_TOLS, MIX_TOLS = (1.0, 2.5, 5.0, 10.0), (2.5, 5.0, 10.0) # settings to vary: the book declares none
fired = {}
print("\nthe year each trigger first fires (- : not within five years; 0 : before the first forecast)")
print(f" {'trigger':52s} {'Unit A':>7s} {'Unit B':>7s}")
for kind, tols in (("error", ERR_TOLS), ("mix", MIX_TOLS)):
for tol in tols:
ys = [first_year(indic[name][kind], tol) for name in UNITS]
fired[(kind, tol)] = ys
label = (f"plan error above {tol:g} engineer{'' if tol == 1 else 's'}" if kind == "error"
else f"software share more than {tol:g} points from 20%")
print(f" {label:52s} " + " ".join(f"{('-' if y is None else y):>7}" for y in ys))
print(f" {'a transformation event: the program starts or ends':52s} {'at once':>15s}")
TABLE_4_3 = [ # Table 4.3: class, content, Meridian instance
("Structural", "which mechanisms exist; coupling; functional forms", "modernization affects efficiency with a one-period lag"),
("Parametric", "values and ranges of named parameters", "talent attrition between 6 and 11 percent a year"),
("Domain", "the region where the model is asserted", "leverage at most 4.5x; no acquisitions"),
("Measurement", "proxies, error sizes, and delays for each reading",
"capability index: survey proxy, +/-5 points, twice a year"),
("Horizon", "periods over which conclusions are claimed", "12 quarters")]
READINGS = [("liquidity", "US$ billion"), ("net leverage", "net debt / EBITDA"), ("workforce capability", "index, 0-100"),
("technology platform", "index, 0-100"), ("operational efficiency", "index, 0-100"),
("return on invested capital", "ratio"), ("strategic risk (lower is better)", "index, 0-100"),
("market share", "ratio")] # Table 3.1
CONTRACT = [
("(i) readings, units, measurement", [f"{n} ({u})" for n, u in READINGS] + [
"observed directly: liquidity, leverage, market share; index proxies with material error: capability,"
" efficiency, strategic risk; organizational cohesion is latent (Section 4.5)"]),
("(ii) assumptions (Table 4.3)", [f"{c.lower()}: {m}" for c, _, m in TABLE_4_3]),
("(iii) validated domain", ["seven years of history; leverage and liquidity within the ranges it visited",
"beyond it: capability spending above 40% of capital spending, two platforms side by side,"
" the hiring plan's talent market"]),
("(iv) lifecycle plan (Section 4.6)", [" -> ".join(LIFECYCLE),
"triggers: drift indicators beyond their declared tolerances; the program's"
" start and completion (revalidation follows transformation)",
"retire the model at the edge of its domain: retirement is a success mode"])]
print(f"\nthe modeling contract for the digital-program model: {len(CONTRACT)} parts, {len(READINGS)} readings,"
f" {len(TABLE_4_3)} assumption classes")
for part, lines in CONTRACT:
print(f" {part}")
for ln in lines:
print(f" {ln}")Figure 4.4: specify -> build -> verify -> validate -> deploy -> monitor -> revise or retire (7 stages)
replay: the five-year plan against what happens year 0 year 1 year 2 year 3 year 4 year 5
Unit A: plan error (engineers) 0.00 0.00 0.13 0.36 0.68 1.08
Unit A: software share, points from 20% 0.00 2.69 5.31 7.86 10.34 12.76
Unit B: plan error (engineers) 0.00 3.00 5.77 8.32 10.66 12.80
Unit B: software share, points from 20% 60.00 60.79 61.56 62.29 63.00 63.68
the year each trigger first fires (- : not within five years; 0 : before the first forecast)
trigger Unit A Unit B
plan error above 1 engineer 5 1
plan error above 2.5 engineers - 1
plan error above 5 engineers - 2
plan error above 10 engineers - 4
software share more than 2.5 points from 20% 1 0
software share more than 5 points from 20% 2 0
software share more than 10 points from 20% 4 0
a transformation event: the program starts or ends at once
the modeling contract for the digital-program model: 4 parts, 8 readings, 5 assumption classes
(i) readings, units, measurement
liquidity (US$ billion)
net leverage (net debt / EBITDA)
workforce capability (index, 0-100)
technology platform (index, 0-100)
operational efficiency (index, 0-100)
return on invested capital (ratio)
strategic risk (lower is better) (index, 0-100)
market share (ratio)
observed directly: liquidity, leverage, market share; index proxies with material error: capability, efficiency, strategic risk; organizational cohesion is latent (Section 4.5)
(ii) assumptions (Table 4.3)
structural: modernization affects efficiency with a one-period lag
parametric: talent attrition between 6 and 11 percent a year
domain: leverage at most 4.5x; no acquisitions
measurement: capability index: survey proxy, +/-5 points, twice a year
horizon: 12 quarters
(iii) validated domain
seven years of history; leverage and liquidity within the ranges it visited
beyond it: capability spending above 40% of capital spending, two platforms side by side, the hiring plan's talent market
(iv) lifecycle plan (Section 4.6)
specify -> build -> verify -> validate -> deploy -> monitor -> revise or retire
triggers: drift indicators beyond their declared tolerances; the program's start and completion (revalidation follows transformation)
retire the model at the edge of its domain: retirement is a success mode
Validation — the book's numbers, and agreement with DCT_V1_Ch04_Lab.xlsx
Each checkpoint is a number printed in Chapter 4 (Worked Example 4.1, Steps 1–5, Table 4.5, Tables 4.1–4.4, Figure 4.4,
Appendix 4.A) or in Online Appendix 4.B; the theorem checks compare with what the printed result asserts. The workbook
recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks
sheet.
Python Code
LADDER = [("L3", "group"), ("L2", "divisions"), ("L1", "business units, plants"), ("L0", "transactions, individuals")]
CHECKLIST = ["Verification", "Validation", "Domain", "Monitoring"] # Table 4.4
checks = [
("Step 1: Unit A legacy engineers next year (workbook)", paths["Unit A"][1, 0], 368, 1e-9),
("Step 1: Unit A software engineers next year (workbook)", paths["Unit A"][1, 1], 108, 1e-9),
("Step 1: Unit A total next year (workbook)", totals["Unit A"][1], 476, 1e-9),
("Step 1: Unit B legacy engineers next year (workbook)", paths["Unit B"][1, 0], 92, 1e-9),
("Step 1: Unit B software engineers next year (workbook)", paths["Unit B"][1, 1], 387, 1e-9),
("Step 1: Unit B total next year (workbook)", totals["Unit B"][1], 479, 1e-9),
("Step 2: Unit A total today (workbook)", totals["Unit A"][0], 500, 0),
("Step 2: Unit B total today (workbook)", totals["Unit B"][0], 500, 0),
("Table 4.5: Unit A, year 2 (workbook)", totals["Unit A"][2], 453.3, 0.05),
("Table 4.5: Unit A, year 3 (workbook)", totals["Unit A"][3], 431.8, 0.05),
("Table 4.5: Unit A, year 4 (workbook)", totals["Unit A"][4], 411.4, 0.05),
("Table 4.5: Unit A, year 5 (workbook)", totals["Unit A"][5], 392.1, 0.05),
("Table 4.5: Unit B, year 2 (workbook)", totals["Unit B"][2], 458.9, 0.05),
("Table 4.5: Unit B, year 3 (workbook)", totals["Unit B"][3], 439.7, 0.05),
("Table 4.5: Unit B, year 4 (workbook)", totals["Unit B"][4], 421.3, 0.05),
("Table 4.5: Unit B, year 5 (workbook)", totals["Unit B"][5], 403.8, 0.05),
("Step 3: the total-only model's rate (workbook)", r, 0.952, 1e-12),
("Table 4.5: total-only model, year 2 (workbook)", coarse[2], 453.2, 0.05),
("Table 4.5: total-only model, year 3 (workbook)", coarse[3], 431.4, 0.05),
("Table 4.5: total-only model, year 4 (workbook)", coarse[4], 410.7, 0.05),
("Table 4.5: total-only model, year 5 (workbook)", coarse[5], 391.0, 0.05),
("Table 4.5: error for Unit B, year 1 (workbook)", errB[1], -3.0, 0.05),
("Table 4.5: error for Unit B, year 2 (workbook)", errB[2], -5.8, 0.05),
("Table 4.5: error for Unit B, year 3 (workbook)", errB[3], -8.3, 0.05),
("Table 4.5: error for Unit B, year 4 (workbook)", errB[4], -10.7, 0.05),
("Table 4.5: error for Unit B, year 5 (workbook)", errB[5], -12.8, 0.05),
("Step 4: Unit A total in year five, 392 (workbook)", totals["Unit A"][5], 392, 0.5),
("Step 4: Unit B total in year five, 404 (workbook)", totals["Unit B"][5], 404, 0.5),
("Step 4: Unit B software engineers in year five, about 338 (workbook)", soft["Unit B"][5], 338, 0.5),
("Step 5: base rate of the repaired summary, 0.95 (workbook)", 1 - EXIT_L, 0.95, 1e-12),
("Step 5: mix coefficient of the repaired summary, 0.01 (workbook)", EXIT_L - EXIT_S, 0.01, 1e-12),
("Step 5: repaired summary, Unit A next year (workbook)", mix_model(500.0, 0.2)[0], 476, 1e-9),
("Step 5: repaired summary, Unit B next year (workbook)", mix_model(500.0, 0.8)[0], 479, 1e-9),
("Theorem 4.2: (H, s) model against Table 4.5, largest gap (workbook)", Hs_units_gap, 0, 1e-9),
("Theorem 4.2: (H, s) model, random configurations, largest gap", Hs_gap, 0, 1e-9),
("Proposition 4.3: the two units together next year, 476 + 479 (workbook)", Hd1, 955, 1e-9),
("Appendix 4.A: A(1, -1), first entry (workbook)", img[0], 0.92, 1e-12),
("Appendix 4.A: A(1, -1), second entry (workbook)", img[1], -0.93, 1e-12),
("Appendix 4.A: the total of A(1, -1), not 0 (workbook)", P @ img, -0.01, 1e-12),
("Online Appendix 4.B: Unit B's error in year one, 3 (workbook)", -errB[1], 3, 0.05),
("Online Appendix 4.B: Unit B's error by year five, about 13 (workbook)", -errB[5], 13, 0.5),
("Online Appendix 4.B: years in which the bound fails (workbook)", fails, 0, 0),
("Theorem 4.3: discrepancy on the record, total-only model (workbook)", disc["total-only"], 0, 1e-9),
("Theorem 4.3: discrepancy on the record, detailed model (workbook)", disc["detailed"], 0, 1e-9),
("Theorem 4.3: the two models at Unit B's mix, 479 - 476 (workbook)", gapB, 3, 1e-9),
("Table 4.4 verification: the code against the closed form (workbook)", code_gap, 0, 1e-9),
("Definition 4.5: negative pools in 100 years, none (workbook)", negative, 0, 0),
("Table 4.1: model types in the chain (workbook)", len(TABLE_4_1), 4, 0),
("Table 4.2: levels of the Meridian abstraction ladder (workbook)", len(LADDER), 4, 0),
("Table 4.2: readings at level L3, those of Table 3.1 (workbook)", len(READINGS), 8, 0),
("Table 4.3: declared assumption classes (workbook)", len(TABLE_4_3), 5, 0),
("Table 4.4: stages of the validation checklist (workbook)", len(CHECKLIST), 4, 0),
("Figure 4.4: stages of the model lifecycle (workbook)", len(LIFECYCLE), 7, 0),
("Section 4.1: parts of the modeling contract (workbook)", len(CONTRACT), 4, 0),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
status = "PASS" if abs(got - want) <= tol + 1e-12 else "FAIL"; ok += status == "PASS"
print(f"{name:{width}s} {float(got):10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")Step 1: Unit A legacy engineers next year (workbook) 368.0000 book 368.0000 PASS Step 1: Unit A software engineers next year (workbook) 108.0000 book 108.0000 PASS Step 1: Unit A total next year (workbook) 476.0000 book 476.0000 PASS Step 1: Unit B legacy engineers next year (workbook) 92.0000 book 92.0000 PASS Step 1: Unit B software engineers next year (workbook) 387.0000 book 387.0000 PASS Step 1: Unit B total next year (workbook) 479.0000 book 479.0000 PASS Step 2: Unit A total today (workbook) 500.0000 book 500.0000 PASS Step 2: Unit B total today (workbook) 500.0000 book 500.0000 PASS Table 4.5: Unit A, year 2 (workbook) 453.2800 book 453.3000 PASS Table 4.5: Unit A, year 3 (workbook) 431.7632 book 431.8000 PASS Table 4.5: Unit A, year 4 (workbook) 411.3779 book 411.4000 PASS Table 4.5: Unit A, year 5 (workbook) 392.0572 book 392.1000 PASS Table 4.5: Unit B, year 2 (workbook) 458.9200 book 458.9000 PASS Table 4.5: Unit B, year 3 (workbook) 439.7168 book 439.7000 PASS Table 4.5: Unit B, year 4 (workbook) 421.3494 book 421.3000 PASS Table 4.5: Unit B, year 5 (workbook) 403.7791 book 403.8000 PASS Step 3: the total-only model's rate (workbook) 0.9520 book 0.9520 PASS Table 4.5: total-only model, year 2 (workbook) 453.1520 book 453.2000 PASS Table 4.5: total-only model, year 3 (workbook) 431.4007 book 431.4000 PASS Table 4.5: total-only model, year 4 (workbook) 410.6935 book 410.7000 PASS Table 4.5: total-only model, year 5 (workbook) 390.9802 book 391.0000 PASS Table 4.5: error for Unit B, year 1 (workbook) -3.0000 book -3.0000 PASS Table 4.5: error for Unit B, year 2 (workbook) -5.7680 book -5.8000 PASS Table 4.5: error for Unit B, year 3 (workbook) -8.3161 book -8.3000 PASS Table 4.5: error for Unit B, year 4 (workbook) -10.6560 book -10.7000 PASS Table 4.5: error for Unit B, year 5 (workbook) -12.7989 book -12.8000 PASS Step 4: Unit A total in year five, 392 (workbook) 392.0572 book 392.0000 PASS Step 4: Unit B total in year five, 404 (workbook) 403.7791 book 404.0000 PASS Step 4: Unit B software engineers in year five, about 338 (workbook) 337.8709 book 338.0000 PASS Step 5: base rate of the repaired summary, 0.95 (workbook) 0.9500 book 0.9500 PASS Step 5: mix coefficient of the repaired summary, 0.01 (workbook) 0.0100 book 0.0100 PASS Step 5: repaired summary, Unit A next year (workbook) 476.0000 book 476.0000 PASS Step 5: repaired summary, Unit B next year (workbook) 479.0000 book 479.0000 PASS Theorem 4.2: (H, s) model against Table 4.5, largest gap (workbook) 0.0000 book 0.0000 PASS Theorem 4.2: (H, s) model, random configurations, largest gap 0.0000 book 0.0000 PASS Proposition 4.3: the two units together next year, 476 + 479 (workbook) 955.0000 book 955.0000 PASS Appendix 4.A: A(1, -1), first entry (workbook) 0.9200 book 0.9200 PASS Appendix 4.A: A(1, -1), second entry (workbook) -0.9300 book -0.9300 PASS Appendix 4.A: the total of A(1, -1), not 0 (workbook) -0.0100 book -0.0100 PASS Online Appendix 4.B: Unit B's error in year one, 3 (workbook) 3.0000 book 3.0000 PASS Online Appendix 4.B: Unit B's error by year five, about 13 (workbook) 12.7989 book 13.0000 PASS Online Appendix 4.B: years in which the bound fails (workbook) 0.0000 book 0.0000 PASS Theorem 4.3: discrepancy on the record, total-only model (workbook) 0.0000 book 0.0000 PASS Theorem 4.3: discrepancy on the record, detailed model (workbook) 0.0000 book 0.0000 PASS Theorem 4.3: the two models at Unit B's mix, 479 - 476 (workbook) 3.0000 book 3.0000 PASS Table 4.4 verification: the code against the closed form (workbook) 0.0000 book 0.0000 PASS Definition 4.5: negative pools in 100 years, none (workbook) 0.0000 book 0.0000 PASS Table 4.1: model types in the chain (workbook) 4.0000 book 4.0000 PASS Table 4.2: levels of the Meridian abstraction ladder (workbook) 4.0000 book 4.0000 PASS Table 4.2: readings at level L3, those of Table 3.1 (workbook) 8.0000 book 8.0000 PASS Table 4.3: declared assumption classes (workbook) 5.0000 book 5.0000 PASS Table 4.4: stages of the validation checklist (workbook) 4.0000 book 4.0000 PASS Figure 4.4: stages of the model lifecycle (workbook) 7.0000 book 7.0000 PASS Section 4.1: parts of the modeling contract (workbook) 4.0000 book 4.0000 PASS 54 of 54 checkpoints PASS
Next. Chapter 5 asks which state is the right one: the minimal state, the memory the future requires (Theorem 5.1). Worked Example 4.1 is a first instance of its test. The total merges two units whose futures differ, so it is not a state of the engineering workforce; the total with the software share is. AXIOM-04 runs the same bench interactively (Lab 1.4); this notebook and the workbook are its reproducible record.


