DCT Laboratory — Volume I, Chapter 1
Introduction to Dynamic Corporate Transformation
This laboratory demonstrates
Seed 26101 · Companion to Chapter 1 and AXIOM Lab 1.1 (module AXIOM-01) · Mirrored in DCT_V1_Ch01_Lab.xlsx
This laboratory reproduces Worked Example 1.1, Same Score, Different Company, with the book's declarations, and works the five steps of AXIOM Lab 1.1, Meridian at a Crossroads: read the dashboard, play the three options, compare paths rather than endpoints, add uncertainty, and build your own score. Every Meridian number below is the book's (Worked Example 1.1 and Table 1.9, Figure 1.3, Section 1.5 and Tables 1.4–1.5, Online Appendix 1.B); the final cell checks them. Money is in $ million; liquidity is also read as an index, with today = 100 = $620 million.
The declarations (Worked Example 1.1, Step 1; Online Appendix 1.B.4)
Meridian's state today is the one Chapter 3 declares (Table 3.1): liquidity $0.62 billion, read as an index with today = 100, so that a point is $6.2 million; net leverage 3.4 times EBITDA; workforce capability 58; technology platform 41; operational efficiency 71; ROIC 8.3 percent; strategic risk 64 (lower is better); and market share 19 percent. Chapter 1's model moves four of the eight readings — liquidity , technology , efficiency and strategic risk — and holds the other four at today's values. Each moving reading relaxes toward an option's target at speed , with a trough of depth at years for temporary strain and a jump when the sale closes at (Equation 1.B.1, with the parameters of Table 1.B.1):
The CFO's scorecard weighs liquidity, technology and efficiency equally and subtracts strategic risk, . Paths are computed month by month over five years.
Python Code
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.optimize import brentq, minimize_scalar
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26101
# Meridian today (Chapter 3, Table 3.1); liquidity as an index, today = 100 = $620 million
READINGS = ["liquidity", "net leverage", "workforce capability", "technology platform",
"operational efficiency", "ROIC", "strategic risk", "market share"]
X0 = np.array([100.0, 3.4, 58.0, 41.0, 71.0, 0.083, 64.0, 0.19])
USD_PER_POINT = 620.0 / 100 # $ million per liquidity point
MOVING = {"x1": 0, "x4": 3, "x5": 4, "x7": 6} # the four readings the Chapter 1 model moves
# Table 1.B.1: target, speed k, trough (sign x depth), trough time tau (years), jump at the sale
PARAMS = {
"Digital": {"x1": (112, 0.35, -28, 2.0, 0), "x4": (78, 0.55, 0, 1.0, 0),
"x5": (77, 0.50, -9, 1.5, 0), "x7": (51, 0.40, 14, 1.2, 0)},
"Restructuring": {"x1": (104, 0.30, 0, 1.0, 18), "x4": (38, 0.25, 0, 1.0, 0),
"x5": (74, 0.45, 0, 1.0, 0), "x7": (56, 0.35, 0, 1.0, -8)},
"Turnaround": {"x1": (106, 0.45, 0, 1.0, 0), "x4": (33, 0.20, 0, 1.0, 0),
"x5": (79, 0.60, 0, 1.0, 0), "x7": (67, 0.30, 0, 1.0, 0)},
}
OPTIONS = list(PARAMS)
T_SALE = 1.0
MONTH = np.arange(61)
T = MONTH / 12 # monthly grid, five years
COLOR = {"Digital": "#5E35B1", "Restructuring": "#2E7D32", "Turnaround": "#E65100"}
def reading(option, key, t):
target, k, depth, tau, jump = PARAMS[option][key]
t, x0 = np.asarray(t, float), X0[MOVING[key]]
return target + (x0 - target) * np.exp(-k * t) + depth * (t / tau) * np.exp(1 - t / tau) + jump * (t >= T_SALE)
def path(option, t=T):
return {key: reading(option, key, t) for key in MOVING}
CFO = np.array([0.25, 0.25, 0.25, -0.25]) # the CFO's weights on (x1, x4, x5, x7)
def score(p, w=CFO):
return w[0] * p["x1"] + w[1] * p["x4"] + w[2] * p["x5"] + w[3] * p["x7"]
P = {o: path(o) for o in OPTIONS}
S = {o: score(P[o]) for o in OPTIONS}
NOW = {key: X0[i] for key, i in MOVING.items()}
today = float(score(NOW))
print(f"Meridian today: {len(X0)} readings, {len(MOVING)} of them moving; a liquidity point is ${USD_PER_POINT:.1f} million")
print(f"{len(MONTH)} monthly dates over {T[-1]:.0f} years; today's score {today:.1f}")Meridian today: 8 readings, 4 of them moving; a liquidity point is $6.2 million 61 monthly dates over 5 years; today's score 37.0
Panel 1 — Read the dashboard (Worked Example 1.1, Step 1)
AXIOM Lab 1.1, step 1: what each of the eight readings measures and where its data come from. Chapter 5 declares each reading's source and error band (Table 5.2). On Chapter 3's declared scale — unbounded readings divided by today's value, indices by their range of 100 — the widest bands belong to strategic risk and workforce capability: the two readings whose margins Chapter 16 finds thinner than their reading error (Table 1.5). The four moving readings give today's score, .
Python Code
UNIT = ["index, today = 100", "net debt / EBITDA", "index, 0-100", "index, 0-100",
"index, 0-100", "ratio", "index, 0-100", "ratio"]
SOURCE = ["treasury systems (+/-1%)", "audited accounts (+/-2%)", "skills survey (+/-5)", "architecture audit (+/-4)",
"cost benchmarking (+/-3)", "audited accounts (+/-0.4 pp)", "risk committee (+/-6)", "industry data (+/-0.8 pp)"]
ERROR = np.array([0.01 * X0[0], 0.02 * X0[1], 5, 4, 3, 0.004, 6, 0.008]) # Table 5.2, in each reading's unit
SCALE = np.array([X0[0], X0[1], 100, 100, 100, X0[5], 100, X0[7]]) # Chapter 3's declared scale
rel = ERROR / SCALE
moving = [i in MOVING.values() for i in range(8)]
print(f" {'reading':24s}{'today':>7s} {'unit':20s}{'Chapter 1 model':17s}{'measured by (error)':30s}scaled error")
for i in range(8):
print(f"x{i + 1} {READINGS[i]:24s}{X0[i]:7.3g} {UNIT[i]:20s}{('moves' if moving[i] else 'held at today'):17s}{SOURCE[i]:30s}{rel[i]:.3f}")
two = np.argsort(-rel)[:2]
print(f"widest declared error bands: {READINGS[two[0]]} ({rel[two[0]]:.3f}) and {READINGS[two[1]]} ({rel[two[1]]:.3f})")
print(f"today's score = (100 + 41 + 71 - 64)/4 = {today:.1f}")reading today unit Chapter 1 model measured by (error) scaled error x1 liquidity 100 index, today = 100 moves treasury systems (+/-1%) 0.010 x2 net leverage 3.4 net debt / EBITDA held at today audited accounts (+/-2%) 0.020 x3 workforce capability 58 index, 0-100 held at today skills survey (+/-5) 0.050 x4 technology platform 41 index, 0-100 moves architecture audit (+/-4) 0.040 x5 operational efficiency 71 index, 0-100 moves cost benchmarking (+/-3) 0.030 x6 ROIC 0.083 ratio held at today audited accounts (+/-0.4 pp) 0.048 x7 strategic risk 64 index, 0-100 moves risk committee (+/-6) 0.060 x8 market share 0.19 ratio held at today industry data (+/-0.8 pp) 0.042 widest declared error bands: strategic risk (0.060) and workforce capability (0.050) today's score = (100 + 41 + 71 - 64)/4 = 37.0
Panel 2 — Play the three options (Worked Example 1.1, Step 2; Table 1.9)
AXIOM Lab 1.1, step 2: run each option over five years, pause around month 21 and at the sale date in Year 1, and record the four moving readings at Year 5. The Year-5 readings are Table 1.9's. Digital scores 47.1 and restructuring 46.1, a one-point gap well inside any forecast error; the turnaround, at 38.4, is clearly behind.
Python Code
Y5 = {o: np.array([P[o][key][-1] for key in MOVING]) for o in OPTIONS}
NAMES = ["liquidity (index)", "technology platform", "operational efficiency", "strategic risk"]
print("Table 1.9 -- Meridian today and in Year 5")
print(f"{'reading':24s}{'today':>8s}" + "".join(f"{o:>15s}" for o in OPTIONS))
for j, name in enumerate(NAMES):
print(f"{name:24s}{X0[list(MOVING.values())[j]]:8.1f}" + "".join(f"{Y5[o][j]:15.1f}" for o in OPTIONS))
print(f"{'score':24s}{today:8.1f}" + "".join(f"{S[o][-1]:15.1f}" for o in OPTIONS))
print(f"digital leads restructuring by {S['Digital'][-1] - S['Restructuring'][-1]:.2f} points; "
f"the turnaround trails by {S['Digital'][-1] - S['Turnaround'][-1]:.1f}")
print("\npauses: the four readings and the score")
for m, label in ((11, "month 11, before the sale"), (12, "month 12, the sale closes"), (21, "month 21")):
for o in OPTIONS:
print(f" {label:27s}{o:15s}" + "".join(f"{P[o][key][m]:8.1f}" for key in MOVING) + f" score {S[o][m]:5.1f}")
fig, axes = plt.subplots(2, 2, figsize=(7.6, 3.6), sharex=True)
for ax, key, name in zip(axes.flat, MOVING, NAMES):
for o in OPTIONS:
ax.plot(T, P[o][key], color=COLOR[o], lw=1.6, label=o)
ax.axhline(NOW[key], color="#999999", lw=0.6, ls=":")
ax.set_ylabel(name.replace(" (index)", "") + " (index)", fontsize=7.5)
ax.tick_params(labelsize=7)
for ax in axes[1]:
ax.set_xlabel("years from today", fontsize=8)
axes[0, 1].legend(frameon=False, fontsize=7, loc="upper left")
fig.suptitle("Four readings move, along three different paths (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()Table 1.9 -- Meridian today and in Year 5 reading today Digital Restructuring Turnaround liquidity (index) 100.0 94.3 121.1 105.4 technology platform 41.0 75.6 38.9 35.9 operational efficiency 71.0 73.6 73.7 78.6 strategic risk 64.0 55.2 49.4 66.3 score 37.0 47.1 46.1 38.4 digital leads restructuring by 1.01 points; the turnaround trails by 8.7 pauses: the four readings and the score month 11, before the sale Digital 81.2 55.7 65.1 73.6 score 32.1 month 11, before the sale Restructuring 101.0 40.4 72.0 61.8 score 37.9 month 11, before the sale Turnaround 102.0 39.7 74.4 64.7 score 37.8 month 12, the sale closes Digital 80.5 56.7 65.0 73.5 score 32.2 month 12, the sale closes Restructuring 119.0 40.3 72.1 53.6 score 44.5 month 12, the sale closes Turnaround 102.2 39.5 74.6 64.8 score 37.9 month 21 Digital 77.7 63.9 65.6 70.4 score 34.2 month 21 Restructuring 119.6 39.9 72.6 52.3 score 45.0 month 21 Turnaround 103.3 38.6 76.2 65.2 score 38.2

Panel 3 — Compare paths, not just endpoints (Worked Example 1.1, Step 5; Figure 1.3; Proposition 1.1)
AXIOM Lab 1.1, step 3: the state-space view, technology against liquidity. The digital path reaches its lowest liquidity, 77.7, around month 21 — 22 percent below today, about $138 million — before recovering, while the restructuring jumps by 18 points, about $112 million, when the sale closes in Year 1. A before-and-after slide shows neither. Nor does it show the strategic-risk peak on the digital path at month 11, 1.4 points under the ceiling of 75 that Chapter 5 declares (Table 1.5), or the scorecard's own path: the digital score stays below today's 37.0 until month 29, so annual reviews rank digital last for two years (Section 1.5.4).
Python Code
d1 = P["Digital"]["x1"]
i_low = int(np.argmin(d1))
low = minimize_scalar(lambda t: float(reading("Digital", "x1", t)), bounds=(0.5, 3.0), method="bounded",
options={"xatol": 1e-10})
drop = 100 - low.fun
print(f"digital liquidity, monthly: lowest {d1[i_low]:.2f} in month {MONTH[i_low]}; "
f"continuous: {low.fun:.2f} at {low.x:.2f} years ({12 * low.x:.1f} months)")
print(f" {drop:.1f} points ({drop:.0f} percent) below today, about ${drop * USD_PER_POINT:.0f} million")
jump = PARAMS["Restructuring"]["x1"][4]
r1 = P["Restructuring"]["x1"]
print(f"restructuring: liquidity jumps {jump} points when the sale closes, about ${jump * USD_PER_POINT:.0f} million "
f"(month 11 -> 12: {r1[11]:.1f} -> {r1[12]:.1f})")
CEILING = 75.0 # strategic-risk ceiling (Chapter 5, Table 5.4)
peak = minimize_scalar(lambda t: -float(reading("Digital", "x7", t)), bounds=(0.2, 2.0), method="bounded",
options={"xatol": 1e-10})
risk_gap = CEILING + peak.fun
print(f"digital strategic risk peaks at {-peak.fun:.2f} at {12 * peak.x:.1f} months: "
f"{risk_gap:.1f} points under the ceiling of {CEILING:.0f}, inside the risk committee's +/-6")
sd = S["Digital"]
i_min = int(np.argmin(sd))
back = int(next(m for m in MONTH[1:] if sd[m] >= today and sd[m - 1] < today))
print(f"\ndigital score: low {sd[i_min]:.1f} in month {i_min}; below today's {today:.1f} in months "
f"{MONTH[sd < today].min()}-{MONTH[sd < today].max()}; back to {sd[back]:.2f} in month {back}")
print("annual reviews: score (rank among the three)")
last_years = []
for y in range(1, 6):
m = 12 * y
vals = {o: S[o][m] for o in OPTIONS}
order = sorted(OPTIONS, key=lambda o: -vals[o])
if order[-1] == "Digital":
last_years.append(y)
print(f" Year {y}: " + ", ".join(f"{o.lower()} {vals[o]:.2f} ({order.index(o) + 1})" for o in OPTIONS))
print(f"digital ranks last at the reviews of years {last_years}: {len(last_years)} years")
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.15, 1]})
j = int(np.argmax(T >= T_SALE))
for o in OPTIONS:
x, y = P[o]["x4"], P[o]["x1"]
if o == "Restructuring":
ax.plot(x[:j], y[:j], color=COLOR[o], lw=1.6, label=o)
ax.plot(x[j - 1:j + 1], y[j - 1:j + 1], color=COLOR[o], lw=1.1, ls="--")
ax.plot(x[j:], y[j:], color=COLOR[o], lw=1.6)
else:
ax.plot(x, y, color=COLOR[o], lw=1.6, label=o)
ax.plot(x[-1], y[-1], "s", ms=4, color=COLOR[o])
ax.plot(NOW["x4"], NOW["x1"], "o", ms=5, color="#1F4E79", zorder=5)
ax.annotate("today", (NOW["x4"], NOW["x1"]), xytext=(-26, -12), textcoords="offset points", fontsize=7, color="#1F4E79")
ax.plot(P["Digital"]["x4"][i_low], d1[i_low], "o", ms=3.5, color=COLOR["Digital"])
ax.annotate(f"low point, month {MONTH[i_low]}", (P["Digital"]["x4"][i_low], d1[i_low]), xytext=(-20, 10),
textcoords="offset points", fontsize=7, color=COLOR["Digital"])
ax.annotate("sale closes", (P["Restructuring"]["x4"][j], (r1[j - 1] + r1[j]) / 2), xytext=(8, 0),
textcoords="offset points", fontsize=7, color=COLOR["Restructuring"])
ax.set(xlabel="technology platform (index, 0-100)", ylabel="liquidity (index, today = 100)")
ax.legend(frameon=False, fontsize=7, loc="upper right")
for o in OPTIONS:
bx.plot(MONTH, S[o], color=COLOR[o], lw=1.6)
bx.axhline(today, color="#616161", lw=0.8, ls=":")
bx.plot(12 * np.arange(1, 6), sd[12 * np.arange(1, 6)], "o", ms=3, color=COLOR["Digital"])
bx.annotate(f"back to today's {today:.0f} in month {back}", (back, sd[back]), xytext=(4, -16),
textcoords="offset points", fontsize=7, color=COLOR["Digital"])
bx.set(xlabel="months from today (dots: annual reviews)", ylabel="CFO's score (points)")
for a in (ax, bx):
a.tick_params(labelsize=7); a.xaxis.label.set_size(8); a.yaxis.label.set_size(8)
fig.suptitle("Same start, different paths; the score has a path too (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()digital liquidity, monthly: lowest 77.73 in month 21; continuous: 77.73 at 1.71 years (20.6 months) 22.3 points (22 percent) below today, about $138 million restructuring: liquidity jumps 18 points when the sale closes, about $112 million (month 11 -> 12: 101.0 -> 119.0) digital strategic risk peaks at 73.55 at 10.9 months: 1.4 points under the ceiling of 75, inside the risk committee's +/-6 digital score: low 32.1 in month 11; below today's 37.0 in months 1-28; back to 37.19 in month 29 annual reviews: score (rank among the three) Year 1: digital 32.15 (3), restructuring 44.46 (1), turnaround 37.89 (2) Year 2: digital 35.27 (3), restructuring 45.11 (1), turnaround 38.29 (2) Year 3: digital 39.88 (2), restructuring 45.55 (1), turnaround 38.43 (3) Year 4: digital 43.96 (2), restructuring 45.86 (1), turnaround 38.45 (3) Year 5: digital 47.08 (1), restructuring 46.07 (2), turnaround 38.40 (3) digital ranks last at the reviews of years [1, 2]: 2 years

Panel 4 — Add uncertainty (Section 1.5.3: 24.6 and 3.0 percent; Volume I, Worked Example 8.1)
AXIOM Lab 1.1, step 4: the uncertainty fan for the digital option's liquidity. Chapter 1 draws one path per option; the fan uses the uncertainty the book declares for this program in Chapter 8 (Worked Example 8.1, cited in Section 1.5.3). The plan is this chapter's digital path read quarterly in $ million (index × 6.2) over the program's three years: it dips from $620 million to a trough of $482 million in quarter 7, $132 million above the board's floor of $350 million. Each quarter brings an execution and market surprise with a standard deviation of $50 million, 60 percent of which carries into the next quarter; funding windows close about once a decade (0.10 a year), each removing on average $120 million (standard deviation $50 million) for the rest of the program. Two levers: a standby line that replaces up to $100 million of any closure, and a phased build whose trough depth is 20 instead of 28. The book draws this model's 100,000 paths with random seed 8 (Volume II, Online Appendix 1.B.4: "Volume I's Chapter 8 model, random seed 8"), so the draws below use seed 8 and reproduce the printed odds exactly; the lab's seed 26101 is used only for one fresh stream at the end, labelled as such.
Python Code
FLOOR, A_E, SD_W = 350.0, 0.6, 50.0 # $ million; carry-over; surprise sd a quarter
LAM, J_MEAN, J_SD = 0.10, 120.0, 50.0 # closures a year; size mean and sd ($ million)
QUARTERS, N_PATHS = 12, 100_000
SHAPE, SCALE_G = (J_MEAN / J_SD) ** 2, J_SD ** 2 / J_MEAN # gamma sizes
BOOK_SEED = 8 # the book's stream for this model (Volume II, Online Appendix 1.B.4)
def plan(depth=28.0):
t = np.arange(QUARTERS + 1) / 4
x1 = 112 + (X0[0] - 112) * np.exp(-0.35 * t) - depth * (t / 2.0) * np.exp(1 - t / 2.0)
return USD_PER_POINT * x1
def simulate(line=0.0, depth=28.0, n=N_PATHS, seed=BOOK_SEED):
# Worked Example 8.1's two channels, quarter by quarter; returns liquidity paths [n, 13]
rng = np.random.default_rng(seed)
pl, E, J = plan(depth), np.zeros(n), np.zeros(n)
L = np.empty((n, QUARTERS + 1)); L[:, 0] = pl[0]
for k in range(QUARTERS):
w = rng.normal(0.0, SD_W, n)
cnt = rng.poisson(LAM / 4, n)
sizes = np.zeros(n)
for i in np.nonzero(cnt)[0]:
sizes[i] = np.maximum(rng.gamma(SHAPE, SCALE_G, cnt[i]) - line, 0.0).sum()
E = A_E * E + w
J = J - sizes
L[:, k + 1] = pl[k + 1] + E + J
return L
pl = plan()
k_low = int(np.argmin(pl))
print("plan by quarter ($ million):", np.round(pl, 0).astype(int))
print(f"trough ${pl[k_low]:.0f} million in quarter {k_low} (month {3 * k_low}); ${pl[k_low] - FLOOR:.0f} million above the floor; "
f"the program draws ${pl[0] - pl[k_low]:.0f} million")
print(f"surprises: long-run sd {SD_W / np.sqrt(1 - A_E ** 2):.1f}, so the trough's headroom is "
f"{(pl[k_low] - FLOOR) / (SD_W / np.sqrt(1 - A_E ** 2)):.1f} sd; closures: "
f"P(at least one in three years) = {1 - np.exp(-3 * LAM):.3f}")
RUNS = {"plan as drawn": {}, "standby line ($100m)": {"line": 100.0}, "phased build": {"depth": 20.0},
"line and phased build": {"line": 100.0, "depth": 20.0}}
res = {}
for name, kw in RUNS.items():
L = simulate(**kw)
lows = L[:, 1:].min(axis=1)
p = float((lows < FLOOR).mean())
q5 = np.percentile(lows, 5)
res[name] = {"L": L, "p": p, "se": np.sqrt(p * (1 - p) / N_PATHS), "es": float(lows[lows <= q5].mean()),
"trough": float(plan(kw.get("depth", 28.0)).min())}
L0 = res["plan as drawn"]["L"]
q10, q90 = np.percentile(L0[:, k_low], [10, 90])
print(f"\nfan at quarter {k_low} (month {3 * k_low}): 80 percent of paths between ${q10:.0f} and ${q90:.0f} million, "
f"a band ${q90 - q10:.0f} million wide; mean path's low ${L0.mean(axis=0).min():.0f} million")
print(f"the book's draws (seed {BOOK_SEED}):")
print(f"{'':24s}{'plan trough':>12s}{'breach odds':>13s}{'s.e.':>7s} worst 5% of troughs: average, below the floor")
for name, r in res.items():
print(f"{name:24s}{r['trough']:12.0f}{100 * r['p']:12.2f}%{100 * r['se']:7.2f}{r['es']:14.1f}{FLOOR - r['es']:14.1f}")
buffer = stats.gamma.ppf(0.9, SHAPE, scale=SCALE_G)
draw = pl[0] - pl[k_low]
print(f"\na bad closure (90th percentile) is ${buffer:.0f} million; the program's draw is ${draw:.0f} million; "
f"together ${draw + buffer:.0f} million against ${pl[0] - FLOOR:.0f} million above the floor")
fresh = simulate(seed=SEED) # a fresh stream with the lab's seed: not the book's draws
p_fresh = float((fresh[:, 1:].min(axis=1) < FLOOR).mean())
print(f"fresh stream, lab seed {SEED} (not the book's draws): plan as drawn {100 * p_fresh:.2f}%, "
f"{(p_fresh - res['plan as drawn']['p']) / res['plan as drawn']['se']:+.1f} standard errors from the book's")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
qs = np.arange(QUARTERS + 1)
for i in range(30):
ax.plot(qs, L0[i], color="#999999", lw=0.5, alpha=0.6)
lo, hi = np.percentile(L0, [10, 90], axis=0)
ax.fill_between(qs, lo, hi, color="#5E35B1", alpha=0.15, lw=0, label="80 percent of paths")
ax.plot(qs, L0.mean(axis=0), color="#1F4E79", lw=1.2, ls="--", label="mean path")
ax.plot(qs, pl, color="#5E35B1", lw=2, label="plan (Chapter 1's digital path)")
ax.axhline(FLOOR, color="#B71C1C", lw=1, ls=":", label="board floor $350m")
ax.set(xlabel="quarters from today (quarter 7 = month 21)", ylabel="liquidity ($ million)")
ax.set_title("Digital liquidity: one path in four breaches the floor (seed 8, the book's stream)", fontsize=10)
ax.tick_params(labelsize=7); ax.xaxis.label.set_size(8); ax.yaxis.label.set_size(8)
ax.legend(frameon=False, fontsize=7, loc="upper center", bbox_to_anchor=(0.5, -0.2), ncol=4)
plt.tight_layout(); plt.show()plan by quarter ($ million): [620 574 540 516 499 488 483 482 484 488 494 502 510]
trough $482 million in quarter 7 (month 21); $132 million above the floor; the program draws $138 million
surprises: long-run sd 62.5, so the trough's headroom is 2.1 sd; closures: P(at least one in three years) = 0.259
fan at quarter 7 (month 21): 80 percent of paths between $357 and $556 million, a band $199 million wide; mean path's low $460 million
the book's draws (seed 8):
plan trough breach odds s.e. worst 5% of troughs: average, below the floor
plan as drawn 482 24.62% 0.14 166.3 183.7
standby line ($100m) 482 12.37% 0.10 285.6 64.4
phased build 531 13.07% 0.11 213.4 136.6
line and phased build 531 3.00% 0.05 332.5 17.5
a bad closure (90th percentile) is $187 million; the program's draw is $138 million; together $325 million against $270 million above the floor
fresh stream, lab seed 26101 (not the book's draws): plan as drawn 24.52%, -0.7 standard errors from the book's

Around month 21 the band that holds 80 percent of the outcomes is about $200 million wide, against $132 million of headroom, so the program should not be financed from its cash cushion alone: the draw and a bad closure together claim more than the $270 million above the floor (Section 1.5.4), and only the standby line and the phased build together bring the odds within the board's 5 percent appetite (Section 1.5.3; Table 1.5). With the book's stream the odds are exactly the printed 24.6 percent, and 3.0 percent with both levers, whose worst 5 percent of troughs average $18 million below the floor (Section 1.5.4). A fresh stream drawn with the lab's seed differs from them only by sampling error.
Panel 5 — Build your own score (Worked Example 1.1, Steps 3, 4 and 6; Proposition 1.2; Online Appendix 1.B.1–1.B.2)
AXIOM Lab 1.1, step 5. With the CFO's weights, $25 million more from the sale — 4.05 liquidity points — lifts the restructuring to the digital option's 47.1 (Step 3), yet the two Year-5 companies are very different (Step 4): digital Meridian has the modern platform, restructured Meridian the cash and the lower risk, and each has different moves open to it next (Step 6). A weighted score gives the same reading to every pair of states whose difference has , a hyperplane of dimension (Result 1.B.2), and moving 1.6 points of weight from technology to liquidity ties the two options as they stand (Table 1.4). Try your own weights below: every weighting ties some clearly different Meridians, and so does any score that moves smoothly with the readings (Proposition 1.2; Result 1.B.1).
Python Code
d5, r5 = Y5["Digital"], Y5["Restructuring"]
gap = float(CFO @ d5 - CFO @ r5)
delta = gap / CFO[0]
matched = r5 + np.array([delta, 0, 0, 0])
print(f"CFO's weights: digital {CFO @ d5:.3f}, restructuring {CFO @ r5:.3f}; {delta:.2f} more liquidity points "
f"(${delta * USD_PER_POINT:.0f} million) tie them")
print(" digital, Year 5 ", np.round(d5, 1), f"score {CFO @ d5:.2f}")
print(" restructuring + $25m ", np.round(matched, 1), f"score {CFO @ matched:.2f}")
print(f" same score; the platform differs by {d5[1] - matched[1]:.1f} points, cash by {matched[0] - d5[0]:.1f}, "
f"strategic risk by {d5[3] - matched[3]:.1f}")
print(f" the tie set is a hyperplane of dimension {4 - np.linalg.matrix_rank(CFO[None, :])} in the four moving readings "
f"({8 - np.linalg.matrix_rank(np.r_[CFO, 0, 0, 0, 0][None, :])} in all eight)")
diff = (d5 - r5) * np.sign(CFO) # digital's advantage reading by reading (risk reversed)
rate = {name: 0.01 * (diff[1] - diff[j]) for j, name in ((0, "liquidity"), (2, "efficiency"), (3, "strategic risk"))}
tie = {name: gap / r for name, r in rate.items()}
print("\nweight points moved from technology that tie digital and restructuring: "
+ ", ".join(f"to {n} {v:.1f}" for n, v in tie.items()))
WEIGHTS = {"CFO": CFO, "liquidity first": np.array([0.40, 0.20, 0.20, -0.20]),
"technology first": np.array([0.20, 0.40, 0.20, -0.20]), "risk first": np.array([0.20, 0.20, 0.20, -0.40])}
print("\nyour weightings: Year-5 scores, and a tie between two clearly different Meridians")
print(f" {'weights on (x1, x4, x5, x7)':40s}" + "".join(f"{o:>15s}" for o in OPTIONS) + " runner-up ties with")
for name, w in WEIGHTS.items():
sc = {o: float(w @ Y5[o]) for o in OPTIONS}
lead, second = sorted(OPTIONS, key=lambda o: -sc[o])[:2]
dl = (sc[lead] - sc[second]) / w[0]
twin = Y5[second] + np.array([dl, 0, 0, 0])
label = name + " (" + ", ".join(f"{v:g}" for v in w) + ")"
print(f" {label:40s}" + "".join(f"{sc[o]:15.2f}" for o in OPTIONS)
+ f" {dl:+.2f} liquidity points: {w @ twin:.2f}")
# A smooth nonlinear score ties too: Proposition 1.2's proof, run on two routes from one state to another
def smooth(x): # geometric mean of the three goods, less half the risk
return np.cbrt(x[..., 0] * x[..., 1] * x[..., 2]) - 0.5 * x[..., 3]
a, b = d5, r5
c = 0.5 * (smooth(a) + smooth(b))
u = (b - a) / np.linalg.norm(b - a)
e = np.array([0.0, 0.0, 1.0, 0.0]); e -= (e @ u) * u; e /= np.linalg.norm(e)
segment = lambda s: a + s * (b - a)
arc = lambda s: a + s * (b - a) + 12.0 * np.sin(np.pi * s) * e
s1 = brentq(lambda s: smooth(segment(s)) - c, 0, 1)
s2 = brentq(lambda s: smooth(arc(s)) - c, 0, 1)
p1, p2 = segment(s1), arc(s2)
print(f"\nsmooth score: digital {smooth(a):.2f}, restructuring {smooth(b):.2f}; a reading of {c:.2f} is taken on both routes:")
print(" on the straight route", np.round(p1, 2), f"score {smooth(p1):.2f}")
print(" on the bulging route ", np.round(p2, 2), f"score {smooth(p2):.2f}")
print(f" two different states ({np.linalg.norm(p1 - p2):.1f} index points apart), one score")
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6))
mv = np.linspace(0, 4, 81)
for (name, r), ls in zip(rate.items(), ("-", "--", ":")):
ax.plot(mv, gap - mv * r, color="#1F4E79", lw=1.6, ls=ls, label=f"to {name}: tie at {tie[name]:.1f}")
ax.axhline(0, color="#616161", lw=0.8)
ax.set(xlabel="weight points moved from technology", ylabel="digital's lead in score (points)")
ax.legend(frameon=False, fontsize=7)
ss = np.linspace(0, 1, 201)
bx.plot(ss, [smooth(segment(s)) for s in ss], color="#5E35B1", lw=1.6, label="straight route")
bx.plot(ss, [smooth(arc(s)) for s in ss], color="#E65100", lw=1.6, ls="--", label="bulging route")
bx.axhline(c, color="#616161", lw=0.8, ls=":")
bx.plot([s1, s2], [c, c], "o", ms=4, color="#B71C1C")
bx.set(xlabel="from digital (0) to restructuring (1)", ylabel="smooth score (points)")
bx.legend(frameon=False, fontsize=7)
for z in (ax, bx):
z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8)
fig.suptitle("Weights decide, and every smooth score ties (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()CFO's weights: digital 47.078, restructuring 46.065; 4.05 more liquidity points ($25 million) tie them digital, Year 5 [94.3 75.6 73.6 55.2] score 47.08 restructuring + $25m [125.2 38.9 73.7 49.4] score 47.08 same score; the platform differs by 36.8 points, cash by 30.9, strategic risk by 5.8 the tie set is a hyperplane of dimension 3 in the four moving readings (7 in all eight) weight points moved from technology that tie digital and restructuring: to liquidity 1.6, to efficiency 2.7, to strategic risk 2.4 your weightings: Year-5 scores, and a tie between two clearly different Meridians weights on (x1, x4, x5, x7) Digital Restructuring Turnaround runner-up ties with CFO (0.25, 0.25, 0.25, -0.25) 47.08 46.07 38.40 +4.05 liquidity points: 47.08 liquidity first (0.4, 0.2, 0.2, -0.2) 56.52 61.07 51.79 +11.38 liquidity points: 61.07 technology first (0.2, 0.4, 0.2, -0.2) 52.79 44.62 37.90 +40.83 liquidity points: 52.79 risk first (0.2, 0.2, 0.2, -0.4) 26.62 26.97 17.45 +1.78 liquidity points: 26.97 smooth score: digital 53.06, restructuring 45.56; a reading of 49.31 is taken on both routes: on the straight route [112.32 50.91 73.66 51.3 ] score 49.31 on the bulging route [116.98 44.52 79.24 50.29] score 49.31 two different states (9.7 index points apart), one score

Validation — the book's numbers, and agreement with DCT_V1_Ch01_Lab.xlsx
Each checkpoint is a number printed in Chapter 1 (Worked Example 1.1 and Table 1.9, Figure 1.3, Sections
1.5.3–1.5.4, Tables 1.4–1.5) or in Online Appendix 1.B. The workbook recomputes the ones marked
workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.
The three simulated figures are drawn, as in the book, with seed 8.
Python Code
D, R, U = Y5["Digital"], Y5["Restructuring"], Y5["Turnaround"]
both = res["line and phased build"]
checks = [
("today's score (workbook)", today, 37.0, 0.05),
("Table 1.9: digital liquidity (workbook)", D[0], 94.3, 0.05),
("Table 1.9: digital technology (workbook)", D[1], 75.6, 0.05),
("Table 1.9: digital efficiency (workbook)", D[2], 73.6, 0.05),
("Table 1.9: digital strategic risk (workbook)", D[3], 55.2, 0.05),
("Table 1.9: restructuring liquidity (workbook)", R[0], 121.1, 0.05),
("Table 1.9: restructuring technology (workbook)", R[1], 38.9, 0.05),
("Table 1.9: restructuring efficiency (workbook)", R[2], 73.7, 0.05),
("Table 1.9: restructuring strategic risk (workbook)", R[3], 49.4, 0.05),
("Table 1.9: turnaround liquidity (workbook)", U[0], 105.4, 0.05),
("Table 1.9: turnaround technology (workbook)", U[1], 35.9, 0.05),
("Table 1.9: turnaround efficiency (workbook)", U[2], 78.6, 0.05),
("Table 1.9: turnaround strategic risk (workbook)", U[3], 66.3, 0.05),
("Year-5 score, digital (workbook)", S["Digital"][-1], 47.078, 5e-4),
("Year-5 score, restructuring (workbook)", S["Restructuring"][-1], 46.065, 5e-4),
("Year-5 score, turnaround (workbook)", S["Turnaround"][-1], 38.4, 0.05),
("digital liquidity low point (workbook)", low.fun, 77.73, 5e-3),
("month of the low point (workbook)", MONTH[i_low], 21, 0),
("time of the low point, years (workbook)", low.x, 1.71, 5e-3),
("low point below today, points (workbook)", drop, 22.3, 0.05),
("low point below today, $ million (workbook)", drop * USD_PER_POINT, 138, 0.5),
("sale-date jump, $ million (workbook)", jump * USD_PER_POINT, 112, 0.5),
("liquidity points that tie the scores (workbook)", delta, 4.05, 5e-3),
("the tying sale proceeds, $ million (workbook)", delta * USD_PER_POINT, 25, 0.5),
("score-matched restructured liquidity (workbook)", matched[0], 125.2, 0.05),
("weight points to liquidity that tie (workbook)", tie["liquidity"], 1.6, 0.05),
("digital score back to today's, month (workbook)", back, 29, 0),
("annual reviews with digital last (workbook)", len(last_years), 2, 0),
("risk ceiling margin at the peak (workbook)", risk_gap, 1.4, 0.05),
("digital plan trough, $ million (workbook)", pl[k_low], 482, 0.5),
("trough above the floor, $ million (workbook)", pl[k_low] - FLOOR, 132, 0.5),
("buffer for a bad closure, $ million (workbook)", buffer, 187, 0.5),
("draw plus buffer, $ million (workbook)", draw + buffer, 325, 0.5),
("breach odds, plan as drawn (%, seed 8)", 100 * res["plan as drawn"]["p"], 24.6, 0.05),
("breach odds, both levers (%, seed 8)", 100 * both["p"], 3.0, 0.05),
("worst 5% of troughs below the floor, both levers", FLOOR - both["es"], 18, 0.5),
]
ok = 0
for name, got, want, tol in checks:
status = "PASS" if abs(got - want) <= tol else "FAIL"; ok += status == "PASS"
print(f"{name:52s} {got:10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")today's score (workbook) 37.0000 book 37.0000 PASS Table 1.9: digital liquidity (workbook) 94.2956 book 94.3000 PASS Table 1.9: digital technology (workbook) 75.6347 book 75.6000 PASS Table 1.9: digital efficiency (workbook) 73.5983 book 73.6000 PASS Table 1.9: digital strategic risk (workbook) 55.2177 book 55.2000 PASS Table 1.9: restructuring liquidity (workbook) 121.1075 book 121.1000 PASS Table 1.9: restructuring technology (workbook) 38.8595 book 38.9000 PASS Table 1.9: restructuring efficiency (workbook) 73.6838 book 73.7000 PASS Table 1.9: restructuring strategic risk (workbook) 49.3902 book 49.4000 PASS Table 1.9: turnaround liquidity (workbook) 105.3676 book 105.4000 PASS Table 1.9: turnaround technology (workbook) 35.9430 book 35.9000 PASS Table 1.9: turnaround efficiency (workbook) 78.6017 book 78.6000 PASS Table 1.9: turnaround strategic risk (workbook) 66.3306 book 66.3000 PASS Year-5 score, digital (workbook) 47.0777 book 47.0780 PASS Year-5 score, restructuring (workbook) 46.0652 book 46.0650 PASS Year-5 score, turnaround (workbook) 38.3954 book 38.4000 PASS digital liquidity low point (workbook) 77.7287 book 77.7300 PASS month of the low point (workbook) 21.0000 book 21.0000 PASS time of the low point, years (workbook) 1.7145 book 1.7100 PASS low point below today, points (workbook) 22.2713 book 22.3000 PASS low point below today, $ million (workbook) 138.0821 book 138.0000 PASS sale-date jump, $ million (workbook) 111.6000 book 112.0000 PASS liquidity points that tie the scores (workbook) 4.0502 book 4.0500 PASS the tying sale proceeds, $ million (workbook) 25.1115 book 25.0000 PASS score-matched restructured liquidity (workbook) 125.1577 book 125.2000 PASS weight points to liquidity that tie (workbook) 1.5924 book 1.6000 PASS digital score back to today's, month (workbook) 29.0000 book 29.0000 PASS annual reviews with digital last (workbook) 2.0000 book 2.0000 PASS risk ceiling margin at the peak (workbook) 1.4475 book 1.4000 PASS digital plan trough, $ million (workbook) 481.9504 book 482.0000 PASS trough above the floor, $ million (workbook) 131.9504 book 132.0000 PASS buffer for a bad closure, $ million (workbook) 186.8670 book 187.0000 PASS draw plus buffer, $ million (workbook) 324.9166 book 325.0000 PASS breach odds, plan as drawn (%, seed 8) 24.6220 book 24.6000 PASS breach odds, both levers (%, seed 8) 3.0030 book 3.0000 PASS worst 5% of troughs below the floor, both levers 17.5321 book 18.0000 PASS 36 of 36 checkpoints PASS
Next. Chapter 2 asks what exactly is being transformed: the company as an open system, whose boundary is itself a declaration. Chapters 5–8 then let all eight readings move and interact. AXIOM-01 runs the same model interactively (Lab 1.1); this notebook and the workbook are its reproducible record.


