DCT Laboratory — Volume I, Chapter 3
Mathematical Foundations
This laboratory demonstrates
Seed 26103 · Companion to Chapter 3 and AXIOM Lab 1.3 (module AXIOM-03) · Mirrored in DCT_V1_Ch03_Lab.xlsx
This laboratory reproduces Worked Example 3.1, Does the Order of Initiatives Matter?, with the book's declarations, and works the five steps of AXIOM Lab 1.3, Measuring Meridian: read the vector, declare the scaling, compare distance measures, sequence the initiatives, watch a company run down. Every Meridian number below is the book's or follows from its declarations (Tables 3.1 and 3.4, Figure 3.3, Section 3.4, Appendix 3.A, Online Appendix 3.B, and the later sections that reuse Chapter 3's scaling and three-reading company: 5.8, 6.5–6.6, 7.4–7.6); the final cell checks the printed ones. The book declares no peer companies for the lab, so the two used here are drawn with the lab's seed and labelled as such. Money is in $ million; Table 3.1 declares liquidity in $ billion.
The declarations (Table 3.1; Worked Example 3.1, The situation; Section 3.4)
Meridian's state is the eight readings of Table 3.1, each with its unit: the canonical starting state for both volumes. The readings mix three families of unit (currency, ratios and bounded indices), so whenever the book computes a distance for Meridian it first applies the declared scaling : unbounded readings are divided by today's value and bounded indices by their range.
Worked Example 3.1 follows three readings: liquidity ($620 million), the technology platform (index 41) and workforce capability (index 58). The sale of part of Industrial Systems brings in $112 million net, but the divested unit takes 10 percent of the technology position, and workforce capability falls by 5 points unless the contract keeps the shared engineering team, at a cost of $20 million in lower proceeds. The digital program is Worked Example 1.1's platform build (Table 1.9), computed here with the Chapter 1 model: over five years cash first falls, to $138 million below its starting level around month 21, and ends $35 million down, while the platform rises by 34.6 points. Its effects are changes to whatever state it starts from, and it can be carried out only if workforce capability is at least 55, which is its domain.
Section 3.4's three-reading company (Equation 3.2) has workforce capability, technology platform and operational efficiency, all indices, and an annual capability investment .
The two peer companies of the lab's first question are not declared in the book. This notebook draws them with the lab's seed 26103: each reading departs from Meridian's by a normal draw whose standard deviation is a tenth of the reading's declared scale ($62 million of liquidity, 0.34 turns of leverage, 10 index points, 0.83 percentage points of ROIC, 1.9 percentage points of market share), rounded as Table 3.1 rounds.
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 = 26103
# Table 3.1: Meridian's state today, declared with units; W_M divides each reading by its declared scale
READINGS = [ # symbol, reading, unit, today, family of unit, declared scale
("x1", "liquidity", "US$ billion", 0.62, "currency", 0.62),
("x2", "net leverage", "net debt / EBITDA", 3.4, "ratio", 3.4),
("x3", "workforce capability", "index, 0-100", 58, "index", 100),
("x4", "technology platform", "index, 0-100", 41, "index", 100),
("x5", "operational efficiency", "index, 0-100", 71, "index", 100),
("x6", "return on invested capital", "ratio", 0.083, "ratio", 0.083),
("x7", "strategic risk (lower is better)", "index, 0-100", 64, "index", 100),
("x8", "market share", "ratio", 0.19, "ratio", 0.19),
]
NAMES = [r[1] for r in READINGS]
FAMILY = np.array([r[4] for r in READINGS])
X0 = np.array([r[3] for r in READINGS], float)
SCALE = np.array([r[5] for r in READINGS], float) # unbounded readings: today's value; bounded indices: their range
WM = 1 / SCALE # the diagonal of the declared scaling W_M
# Worked Example 3.1 (money in $ million): (liquidity, technology platform, workforce capability)
TODAY = (620.0, 41.0, 58.0)
SALE, TECH_SHARE, W_LOSS, KEEP_COST = 112.0, 0.10, 5.0, 20.0 # net proceeds; the unit's share of technology;
# points lost unless the team is kept; cost of keeping it
W_MIN = 55.0 # the digital program's domain: workforce >= 55
# The digital program is Worked Example 1.1's platform build: the Chapter 1 model (Eq. 1.B.1, Table 1.B.1's digital
# row), liquidity indexed to today = 100 = $620 million. Its five-year changes add to the state it starts from.
from scipy.optimize import minimize_scalar
def chapter1(key, t):
x0, (target, k, depth, tau) = {"L": (100.0, (112, 0.35, -28, 2.0)), "T": (41.0, (78, 0.55, 0, 1.0))}[key]
return target + (x0 - target) * np.exp(-k * t) + depth * (t / tau) * np.exp(1 - t / tau)
LOW = minimize_scalar(lambda t: chapter1("L", t), bounds=(0, 5), method="bounded", options={"xatol": 1e-10})
BUILD_DIP = 6.2 * (100.0 - LOW.fun) # its low point below the start: $138.08 million
BUILD_LOW_MONTH = 12 * LOW.x # month 20.6, "around month 21"
BUILD_L = 6.2 * (chapter1("L", 5.0) - 100.0) # -$35.37 million by Year 5
BUILD_T = chapter1("T", 5.0) - 41.0 # +34.63 platform points
def restructure(x, keep=False):
# the sale of part of Industrial Systems; keep=True: the contract keeps the shared engineering team
if x is None:
return None
L, T, W = x
return (L + SALE - (KEEP_COST if keep else 0.0), (1 - TECH_SHARE) * T, W if keep else W - W_LOSS)
def digital(x):
# the platform build for Digital Solutions: an operator with a domain, workforce capability >= 55
if x is None or x[2] < W_MIN:
return None # outside the domain: the step cannot start
L, T, W = x
return (L + BUILD_L, T + BUILD_T, W)
# Section 3.4, Equation 3.2: capability, technology, efficiency (indices); annual capability investment u
A3 = np.array([[0.90, 0.05, 0.00],
[0.10, 0.85, 0.00],
[0.05, 0.10, 0.80]])
B3 = np.array([0.6, 0.3, 0.0])
Y0, U0 = np.array([50.0, 40.0, 60.0]), 10.0
# The lab's two peer companies: not declared in the book, drawn here with the lab's seed
DIGITS = [2, 1, 0, 0, 0, 3, 0, 2] # Table 3.1's rounding of each reading
rng = np.random.default_rng(SEED)
def draw_peers(n):
raw = X0 + rng.normal(0.0, 0.10, (n, len(X0))) * SCALE
return np.column_stack([np.round(raw[:, i], d) for i, d in enumerate(DIGITS)])
PEER_A, PEER_B = draw_peers(2)
count = {f: int((FAMILY == f).sum()) for f in ("currency", "ratio", "index")}
print(f"Meridian's state: {len(X0)} readings, {count['currency']} in currency, {count['ratio']} ratios, {count['index']} bounded indices")
print("the declared scaling W_M divides them by:", ", ".join(f"{s:g}" for s in SCALE))
print(f"Worked Example 3.1 today: liquidity ${TODAY[0]:.0f} million, technology {TODAY[1]:.0f}, workforce {TODAY[2]:.0f};"
f" the digital program's domain: workforce >= {W_MIN:.0f}")
print(f"three-reading company: x0 = ({', '.join(f'{v:.0f}' for v in Y0)}), u0 = {U0:.0f}")
print(f"two peer companies drawn with the lab's seed {SEED} (the book declares none)")Meridian's state: 8 readings, 1 in currency, 3 ratios, 4 bounded indices the declared scaling W_M divides them by: 0.62, 3.4, 100, 100, 100, 0.083, 100, 0.19 Worked Example 3.1 today: liquidity $620 million, technology 41, workforce 58; the digital program's domain: workforce >= 55 three-reading company: x0 = (50, 40, 60), u0 = 10 two peer companies drawn with the lab's seed 26103 (the book declares none)
Panel 1 — Read the vector (Table 3.1; Proposition 3.2)
AXIOM Lab 1.3, step 1. Read Meridian's eight readings and their units, then switch the liquidity unit from billions to millions and watch the raw distances to the two peer companies. A raw distance is the straight-line distance between the readings as recorded. Proposition 3.2: changing units loses no information, but a comparison of raw readings across attributes, or a total without declared weights, can be reversed by a legitimate change of units, and so says nothing about the company. LOS Guidance 3.1 gives the example: "strategic risk, at 64, exceeds leverage, at 3.4" means nothing, because rescaling either reading reverses it.
Python Code
print("Table 3.1: Meridian's state today, declared with units")
print(f" {'':3s} {'reading':33s} {'unit':18s} {'today':>6s} family of unit")
for sym, name, unit, today, fam, _ in READINGS:
print(f" {sym:3s} {name:33s} {unit:18s} {today:6g} {fam}")
span = X0.max() / X0.min()
print(f"the raw readings run from {X0.min():g} ({NAMES[X0.argmin()]}) to {X0.max():g} ({NAMES[X0.argmax()]}):"
f" a factor of {span:.0f}, {np.log10(span):.2f} orders of magnitude")
risk, lev = X0[6], X0[1]
print(f"\nProposition 3.2: strategic risk {risk:g} > net leverage {lev:g}? {risk > lev}."
f" With leverage in percent ({100 * lev:g}): {risk > 100 * lev}")
MM = np.ones(8); MM[0] = 1000.0 # liquidity recorded in $ million instead of $ billion
print(f"an undeclared total of the raw readings: {X0.sum():.3f} with liquidity in $ billion, {(X0 * MM).sum():.3f} in $ million")
def raw_distance(x, y, unit=np.ones(8)):
return float(np.linalg.norm((np.asarray(y) - np.asarray(x)) * unit))
def shares(x, y, unit=np.ones(8)):
# each reading's share of the squared distance from x to y
d2 = ((np.asarray(y) - np.asarray(x)) * unit) ** 2
return d2 / d2.sum()
print(f"\n {'reading':33s} {'Meridian':>9s} {'Peer A':>8s} {'Peer B':>8s} (peers drawn with seed {SEED})")
for i, name in enumerate(NAMES):
print(f" {name:33s} {X0[i]:9g} {PEER_A[i]:8g} {PEER_B[i]:8g}")
UNITS = {"liquidity in $ billion": np.ones(8), "liquidity in $ million": MM}
raw, closer = {}, {}
for label, unit in UNITS.items():
raw[label] = (raw_distance(X0, PEER_A, unit), raw_distance(X0, PEER_B, unit))
closer[label] = "A" if raw[label][0] < raw[label][1] else "B"
sA = shares(X0, PEER_A, unit)
print(f"raw distance, {label}: Peer A {raw[label][0]:8.3f}, Peer B {raw[label][1]:8.3f} -> closer: Peer {closer[label]};"
f" Peer A's squared distance is {100 * sA[FAMILY == 'index'].sum():.0f}% indices, {100 * sA[0]:.0f}% liquidity")
same = closer["liquidity in $ billion"] == closer["liquidity in $ million"]
print("does the closer peer change? " + ("no, but for two different reasons: in billions the indices decide, in millions"
" liquidity does, and Peer A happens to be closer on both" if same else "yes"))
PCT = np.ones(8); PCT[1] = 100.0 # net leverage recorded in percent
dA, dB = raw_distance(X0, PEER_A, PCT), raw_distance(X0, PEER_B, PCT)
print(f"any reading on which Peer B is closer can reverse it: with leverage in percent, Peer A {dA:.3f}, Peer B {dB:.3f}"
f" -> closer: Peer {'A' if dA < dB else 'B'}")
N = 10_000 # 10,000 more pairs, drawn the same way, the same stream
pairs = draw_peers(2 * N).reshape(N, 2, 8)
d_bn = np.linalg.norm(pairs - X0, axis=2)
d_mm = np.linalg.norm((pairs - X0) * MM, axis=2)
flip = float(np.mean(d_bn.argmin(1) != d_mm.argmin(1)))
print(f"over {N:,} more pairs drawn the same way (seed {SEED}), switching liquidity to millions changes the closer peer"
f" for {100 * flip:.1f}%")Table 3.1: Meridian's state today, declared with units
reading unit today family of unit
x1 liquidity US$ billion 0.62 currency
x2 net leverage net debt / EBITDA 3.4 ratio
x3 workforce capability index, 0-100 58 index
x4 technology platform index, 0-100 41 index
x5 operational efficiency index, 0-100 71 index
x6 return on invested capital ratio 0.083 ratio
x7 strategic risk (lower is better) index, 0-100 64 index
x8 market share ratio 0.19 ratio
the raw readings run from 0.083 (return on invested capital) to 71 (operational efficiency): a factor of 855, 2.93 orders of magnitude
Proposition 3.2: strategic risk 64 > net leverage 3.4? True. With leverage in percent (340): False
an undeclared total of the raw readings: 238.293 with liquidity in $ billion, 857.673 in $ million
reading Meridian Peer A Peer B (peers drawn with seed 26103)
liquidity 0.62 0.65 0.47
net leverage 3.4 3.9 3.3
workforce capability 58 59 54
technology platform 41 37 47
operational efficiency 71 74 58
return on invested capital 0.083 0.072 0.085
strategic risk (lower is better) 64 68 79
market share 0.19 0.2 0.17
raw distance, liquidity in $ billion: Peer A 6.500, Peer B 21.119 -> closer: Peer A; Peer A's squared distance is 99% indices, 0% liquidity
raw distance, liquidity in $ million: Peer A 30.696, Peer B 151.479 -> closer: Peer A; Peer A's squared distance is 4% indices, 96% liquidity
does the closer peer change? no, but for two different reasons: in billions the indices decide, in millions liquidity does, and Peer A happens to be closer on both
any reading on which Peer B is closer can reverse it: with leverage in percent, Peer A 50.418, Peer B 23.367 -> closer: Peer B
over 10,000 more pairs drawn the same way (seed 26103), switching liquidity to millions changes the closer peer for 43.3%
Panel 2 — Declare the scaling (Figure 3.3; Proposition 3.3)
AXIOM Lab 1.3, step 2. Switch on the declared scaling and compare again. After every reading is unit-free and of order one (Figure 3.3): Meridian's scaled state is (1.00, 1.00, 0.58, 0.41, 0.71, 1.00, 0.64, 1.00). Proposition 3.3: a weighted distance gives the same answer after a change of units only if its weights change in the opposite direction. The declared rule does this by itself, because it divides by today's value in whatever unit the reading is recorded: with liquidity in millions, today's value is 620 and the weight 1/620. This is the comparison to defend to the board. It does not move when someone changes a unit, no reading dominates because of its unit, and what it does depend on, the weights, is declared.
Python Code
SX0 = X0 * WM
print("Figure 3.3, right: Meridian's scaled readings W_M x0 =", ", ".join(f"{v:.2f}" for v in SX0))
print(f"readings at 1.00 after scaling: {int(np.isclose(SX0, 1.0).sum())} (today's value is their declared scale)")
def declared_weights(today):
# W_M's rule, in whatever units the readings are recorded: unbounded readings / today's value, indices / range
return 1 / np.where(FAMILY == "index", 100.0, today)
scaled = {}
for label, unit in UNITS.items():
w = declared_weights(X0 * unit)
scaled[label] = tuple(float(np.linalg.norm(w * (P - X0) * unit)) for P in (PEER_A, PEER_B))
print(f"scaled distance, {label}: weight on liquidity 1/{1 / w[0]:g}; Peer A {scaled[label][0]:.4f},"
f" Peer B {scaled[label][1]:.4f}")
gap_units = max(abs(a - b) for a, b in zip(*scaled.values()))
print(f"gap between the two units: {gap_units:.1e} (Proposition 3.3: the weight moved the opposite way)")
wrong = float(np.linalg.norm(WM * (PEER_A - X0) * MM))
print(f"liquidity in millions with its weight left at 1/0.62: Peer A at {wrong:.3f} instead of {scaled['liquidity in $ billion'][0]:.4f}")
sc = {"A": shares(SX0, PEER_A * WM), "B": shares(SX0, PEER_B * WM)}
print(f"\n share of the squared scaled distance {'Peer A':>8s} {'Peer B':>8s}")
for i, name in enumerate(NAMES):
print(f" {name:36s} {100 * sc['A'][i]:7.1f}% {100 * sc['B'][i]:7.1f}%")
dS = scaled["liquidity in $ billion"]
print(f"declared scaling: Peer A {dS[0]:.3f}, Peer B {dS[1]:.3f} -> closer: Peer {'A' if dS[0] < dS[1] else 'B'};"
f" no reading carries more than {100 * max(sc['A'].max(), sc['B'].max()):.0f}% of either distance")
FAMS = [("index", "the four indices", "#1F4E79"), ("ratio", "the three ratios", "#999999"),
("currency", "liquidity (currency)", "#E65100")]
bars = []
for peer, P in (("Peer A", PEER_A), ("Peer B", PEER_B)):
bars += [(f"{peer}: raw, liquidity in $ billion", shares(X0, P), raw_distance(X0, P), "{:.2f}"),
(f"{peer}: raw, liquidity in $ million", shares(X0, P, MM), raw_distance(X0, P, MM), "{:.1f}"),
(f"{peer}: declared scaling", shares(SX0, P * WM), float(np.linalg.norm((P - X0) * WM)), "{:.3f}")]
ys = [5.5, 4.5, 3.5, 2.0, 1.0, 0.0]
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for y, (label, s, d, f) in zip(ys, bars):
left = 0.0
for fam, flabel, col in FAMS:
v = 100 * s[FAMILY == fam].sum()
ax.barh(y, v, left=left, color=col, height=0.72, label=flabel if y == ys[0] else None)
left += v
ax.text(101.5, y, "distance " + f.format(d), va="center", ha="left", fontsize=8, color="#333333")
ax.set_yticks(ys)
ax.set_yticklabels([b[0] for b in bars], fontsize=8)
ax.set(xlim=(0, 122), ylim=(-0.6, 7.0), xlabel="share of the squared distance (%)",
title="Units decide which readings drive a raw distance (seed 26103)")
ax.set_xticks([0, 25, 50, 75, 100])
ax.legend(frameon=False, fontsize=8, ncol=3, loc="upper center", bbox_to_anchor=(0.42, 1.02), handlelength=1.2,
columnspacing=1.6)
plt.tight_layout(); plt.show()Figure 3.3, right: Meridian's scaled readings W_M x0 = 1.00, 1.00, 0.58, 0.41, 0.71, 1.00, 0.64, 1.00 readings at 1.00 after scaling: 4 (today's value is their declared scale) scaled distance, liquidity in $ billion: weight on liquidity 1/0.62; Peer A 0.2202, Peer B 0.3401 scaled distance, liquidity in $ million: weight on liquidity 1/620; Peer A 0.2202, Peer B 0.3401 gap between the two units: 0.0e+00 (Proposition 3.3: the weight moved the opposite way) liquidity in millions with its weight left at 1/0.62: Peer A at 48.388 instead of 0.2202 share of the squared scaled distance Peer A Peer B liquidity 4.8% 50.6% net leverage 44.6% 0.7% workforce capability 0.2% 1.4% technology platform 3.3% 3.1% operational efficiency 1.9% 14.6% return on invested capital 36.2% 0.5% strategic risk (lower is better) 3.3% 19.5% market share 5.7% 9.6% declared scaling: Peer A 0.220, Peer B 0.340 -> closer: Peer A; no reading carries more than 51% of either distance

Panel 3 — Compare distance measures (Definition 3.5; Theorem 3.1; Online Appendix Remark 3.B.1; Section 5.8)
AXIOM Lab 1.3, step 3: the norm gallery. The effort view totals the moves, the bottleneck view reports the largest single move, and the Euclidean norm sits between them (Definition 3.5). The changes of state measured here, all in the declared scaling, are Meridian's moves to each option's Year-5 state in the Chapter 1 model (Table 1.9; only liquidity, technology, efficiency and strategic risk move) and to each peer. Section 5.8 measures the Year-5 moves with Chapter 3's scaling: 0.11 for the turnaround, 0.26 for restructuring, 0.36 for digital. The constants that link the views (Online Appendix 3.B, Remark 3.B.1) are so for Meridian's eight readings the effort and bottleneck views of one change can differ by a factor of up to eight. Theorem 3.1 promises agreement on qualitative questions (which sequences converge, which sets are open, which mappings are continuous, which states are stable), not on the numbers; and a ranking of two distances is a comparison of numbers.
Python Code
NORMS = (("effort", 1), ("Euclidean", 2), ("bottleneck", np.inf))
def views(dx):
return {nm: float(np.linalg.norm(np.asarray(dx, float), o)) for nm, o in NORMS}
# Table 1.9: the four moving readings in Year 5 (liquidity indexed to today = 100 = $0.62 billion)
TODAY4 = (100.0, 41.0, 71.0, 64.0)
YEAR5 = {"turnaround": (105.4, 35.9, 78.6, 66.3), "restructuring": (121.1, 38.9, 73.7, 49.4),
"digital": (94.3, 75.6, 73.6, 55.2)}
def year5_state(v):
x = X0.copy()
x[0], x[3], x[4], x[6] = X0[0] * v[0] / TODAY4[0], v[1], v[2], v[3]
return x
moves = {f"{k}, Year 5": (year5_state(v) - X0) * WM for k, v in YEAR5.items()}
moves.update({"Peer A": (PEER_A - X0) * WM, "Peer B": (PEER_B - X0) * WM})
V = {name: views(dx) for name, dx in moves.items()}
print(f" {'scaled change of state':22s} {'effort':>7s} {'Euclidean':>10s} {'bottleneck':>11s} effort/bottleneck"
f" Euclidean/bottleneck effort/Euclidean")
for name, v in V.items():
print(f" {name:22s} {v['effort']:7.3f} {v['Euclidean']:10.3f} {v['bottleneck']:11.3f} {v['effort'] / v['bottleneck']:17.2f}"
f" {v['Euclidean'] / v['bottleneck']:20.2f} {v['effort'] / v['Euclidean']:16.2f}")
n = len(X0)
e1, ones = np.eye(n)[0], np.ones(n)
print(f"\nconstants for n = {n} readings: effort/bottleneck in [1, {n}]; Euclidean/bottleneck and effort/Euclidean in [1, {np.sqrt(n):.2f}]")
print(f"attained: one reading moving (e1) gives {views(e1)['effort'] / views(e1)['bottleneck']:.0f};"
f" all eight moving equally give {views(ones)['effort'] / views(ones)['bottleneck']:.0f}"
f" and {views(ones)['effort'] / views(ones)['Euclidean']:.2f}")
for nm, _ in NORMS:
ranking = sorted(YEAR5, key=lambda k: V[f"{k}, Year 5"][nm])
print(f"the {nm} view ranks the Year-5 moves {' < '.join(ranking)}; closer peer: Peer {'A' if V['Peer A'][nm] < V['Peer B'][nm] else 'B'}")
dmv = (pairs - X0) * WM # the 10,000 pairs of Panel 1, in the declared scaling
eff, bot = np.abs(dmv).sum(2), np.abs(dmv).max(2)
disagree = float(np.mean(eff.argmin(1) != bot.argmin(1)))
ratio = eff / bot
print(f"over the {N:,} pairs: effort/bottleneck from {ratio.min():.2f} to {ratio.max():.2f} (median {np.median(ratio):.2f});"
f" the effort and bottleneck views name different closer peers for {100 * disagree:.1f}% of pairs")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.scatter(bot.ravel(), eff.ravel(), s=3, color="#999999", alpha=0.12, lw=0, label=f"{2 * N:,} more peers drawn with seed {SEED}")
xs = np.array([0.0, 0.6])
ax.plot(xs, xs, color="#616161", lw=1.1, ls="--", label="effort = bottleneck: one reading moves")
ax.plot(xs, n * xs, color="#616161", lw=1.1, ls=":", label=f"effort = {n} x bottleneck: all {n} readings move equally")
box = dict(boxstyle="square,pad=0.15", fc="white", ec="none", alpha=0.85)
for i, k in enumerate(YEAR5):
v = V[f"{k}, Year 5"]
ax.plot(v["bottleneck"], v["effort"], "o", color="#E65100", ms=6, zorder=4,
label="Year-5 moves of the three options (Table 1.9)" if i == 0 else None)
ax.annotate(k, (v["bottleneck"], v["effort"]), xytext=(v["bottleneck"] + 0.008, v["effort"] - 0.085), fontsize=8,
color="#E65100", bbox=box, zorder=5)
for i, name in enumerate(("Peer A", "Peer B")):
v = V[name]
ax.plot(v["bottleneck"], v["effort"], "s", color="#1F4E79", ms=6, zorder=4, label="the lab's two peers" if i == 0 else None)
ax.annotate(name, (v["bottleneck"], v["effort"]), xytext=(v["bottleneck"] + 0.01, v["effort"] + 0.03), fontsize=8,
color="#1F4E79", bbox=box, zorder=5)
ax.set(xlim=(0, 0.5), ylim=(0, 1.6), xlabel="bottleneck view: largest scaled move", ylabel="effort view: sum of scaled moves",
title="Effort and bottleneck views stay within a factor of eight (seed 26103)")
leg = ax.legend(frameon=False, fontsize=8, loc="upper right")
for h in leg.legend_handles:
if hasattr(h, "set_sizes"): # the cloud's legend marker: larger and darker
h.set_alpha(0.6); h.set_sizes([18])
plt.tight_layout(); plt.show()scaled change of state effort Euclidean bottleneck effort/bottleneck Euclidean/bottleneck effort/Euclidean turnaround, Year 5 0.204 0.109 0.076 2.68 1.43 1.88 restructuring, Year 5 0.405 0.259 0.211 1.92 1.23 1.56 digital, Year 5 0.517 0.362 0.346 1.49 1.05 1.43 Peer A 0.501 0.220 0.147 3.40 1.50 2.27 Peer B 0.781 0.340 0.242 3.23 1.41 2.30 constants for n = 8 readings: effort/bottleneck in [1, 8]; Euclidean/bottleneck and effort/Euclidean in [1, 2.83] attained: one reading moving (e1) gives 1; all eight moving equally give 8 and 2.83 the effort view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A the Euclidean view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A the bottleneck view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A over the 10,000 pairs: effort/bottleneck from 1.35 to 6.74 (median 3.64); the effort and bottleneck views name different closer peers for 24.8% of pairs

Panel 4 — Appraise each initiative, then chain them (Worked Example 3.1, Steps 1–2; Proposition 3.1)
Worked Example 3.1, Steps 1–2, and the first half of AXIOM Lab 1.3, step 4. Appraise each initiative alone from today's state and add the appraisals, as a "bag of initiatives" would; then run restructure-then-digital step by step. Proposition 3.1: running and then can start exactly from the states where is possible and delivers the company into the domain of . In Appendix 3.A's notation the chained domain is the preimage (Equation 3.4), which is empty unless what can produce overlaps what requires.
Python Code
def fmt(x):
return "infeasible" if x is None else f"liquidity ${x[0]:.0f} million, technology {x[1]:.2f}, workforce {x[2]:.0f}"
def change(a, b):
return tuple(q - p for p, q in zip(a, b))
def signed(v, d=0):
return "unchanged" if round(v, d) == 0 else f"{v:+.{d}f}"
sale, build = restructure(TODAY), digital(TODAY)
d_sale, d_build = change(TODAY, sale), change(TODAY, build)
bag = tuple(t + a + b for t, a, b in zip(TODAY, d_sale, d_build))
print("today: ", fmt(TODAY))
print(f"Step 1, the sale alone: liquidity {signed(d_sale[0])}, technology {signed(d_sale[1], 1)}, workforce {signed(d_sale[2])}")
print(f"Step 1, digital alone: liquidity {signed(d_build[0])}, technology {signed(d_build[1], 1)}, workforce {signed(d_build[2])}")
print("bag of initiatives: ", fmt(bag))
r_then_d = digital(sale)
print(f"\nStep 2, after the sale: {fmt(sale)}; workforce {sale[2]:.0f} < {W_MIN:.0f}, outside the digital program's domain")
print("restructure, then digital:", fmt(r_then_d))
# Proposition 3.1 and Equation 3.4: from which workforce levels can each two-step program start?
levels = np.arange(45.0, 71.0)
start = {"sale as designed, then digital": [w for w in levels if digital(restructure((620.0, 41.0, w))) is not None],
"sale with the engineers kept, then digital": [w for w in levels if digital(restructure((620.0, 41.0, w), keep=True)) is not None],
"digital alone": [w for w in levels if digital((620.0, 41.0, w)) is not None]}
for name, ok in start.items():
print(f"chained domain, {name}: workforce >= {min(ok):.0f}")
chain_min = min(start["sale as designed, then digital"])
print(f"the sale as designed lands 5 points lower, so the program needs {chain_min:.0f} = {W_MIN:.0f} + {W_LOSS:.0f} at the start;"
f" Meridian, at {TODAY[2]:.0f}, is {chain_min - TODAY[2]:.0f} points short")today: liquidity $620 million, technology 41.00, workforce 58 Step 1, the sale alone: liquidity +112, technology -4.1, workforce -5 Step 1, digital alone: liquidity -35, technology +34.6, workforce unchanged bag of initiatives: liquidity $697 million, technology 71.53, workforce 53 Step 2, after the sale: liquidity $732 million, technology 36.90, workforce 53; workforce 53 < 55, outside the digital program's domain restructure, then digital: infeasible chained domain, sale as designed, then digital: workforce >= 60 chained domain, sale with the engineers kept, then digital: workforce >= 55 chained domain, digital alone: workforce >= 55 the sale as designed lands 5 points lower, so the program needs 60 = 55 + 5 at the start; Meridian, at 58, is 2 points short
Panel 5 — Sequence the initiatives (Worked Example 3.1, Steps 3–5; Table 3.4; Theorem 3.2(iii); Online Appendix 3.B)
Worked Example 3.1, Steps 3–5, and AXIOM Lab 1.3, step 4: apply the two initiatives in both orders, record the end states (Table 3.4) and the size of the difference between them, which needs a declared norm and scaling. Theorem 3.2(iii): the same two transformations in different orders generally produce different companies. Table 3.4's two feasible orders also differ in their deal terms (the engineers go in one and stay in the other), so the panel separates the terms from the order, and then splits the order's effect as Online Appendix 3.B does for affine transformations : The first term is the commutator, how each transformation changes what the other acts on; the second, how each rescales the other's fixed shift. For Meridian the digital program is a pure shift, so the commutator vanishes and the constant term is the one interaction Step 5 names: the sale takes 10 percent of the points the build adds.
Python Code
after_build = digital(TODAY) # Step 3: the digital program runs first
d_then_r = restructure(after_build)
sale_kept = restructure(TODAY, keep=True) # Step 4: the deal keeps the engineers
kept_then_d = digital(sale_kept)
d_then_kept = restructure(after_build, keep=True) # the same deal terms in both orders (not in Table 3.4)
print(f"Step 3: digital first, its low ${TODAY[0] - BUILD_DIP:.0f} million around month {BUILD_LOW_MONTH:.0f}: {fmt(after_build)}")
print(f" then the sale: {fmt(d_then_r)}")
print(f"Step 4: the sale with the engineers kept: {fmt(sale_kept)}")
print(f" then the digital program, its low ${sale_kept[0] - BUILD_DIP:.0f} million: {fmt(kept_then_d)}")
TABLE34 = [("Today", TODAY), ("Bag of initiatives (each appraised alone, then added)", bag),
("Restructure, then digital (as designed)", r_then_d), ("Digital, then restructure", d_then_r),
("Restructure (engineers kept), then digital", kept_then_d)]
print(f"\nTable 3.4 {'':45s} {'liquidity':>10s} {'technology':>11s} {'workforce':>10s}")
for name, x in TABLE34:
print(f" {name:53s} " + (f"{'infeasible':^33s}" if x is None else f"{x[0]:10.0f} {x[1]:11.1f} {x[2]:10.0f}"))
gap = change(kept_then_d, d_then_r) # digital-first minus restructure-first
print(f"\nStep 5: digital-first ends with ${gap[0]:.0f} million more cash; restructure-first with a stronger platform"
f" ({kept_then_d[1]:.1f} against {d_then_r[1]:.2f}, {-gap[1]:.2f} points) and workforce ({kept_then_d[2]:.0f} against {d_then_r[2]:.0f})")
terms = change(d_then_kept, d_then_r) # same order (digital first), different deal terms
order = change(kept_then_d, d_then_kept) # same deal terms (engineers kept), different order
print(f"digital, then the sale with the engineers kept: {fmt(d_then_kept)}")
print(f"the gap ({gap[0]:.0f}, {gap[1]:.2f}, {gap[2]:.0f}) = deal terms ({terms[0]:.0f}, {terms[1]:.2f}, {terms[2]:.0f})"
f" + order ({order[0]:.0f}, {order[1]:.2f}, {order[2]:.0f})")
# Online Appendix 3.B on Meridian: the sale (engineers kept) and the build as affine maps of (L, T, W)
A_R, b_R = np.diag([1.0, 1 - TECH_SHARE, 1.0]), np.array([SALE - KEEP_COST, 0.0, 0.0])
A_D, b_D = np.eye(3), np.array([BUILD_L, BUILD_T, 0.0]) # the build: a pure shift
x0 = np.array(TODAY)
commutator = (A_D @ A_R - A_R @ A_D) @ x0
constant = (A_D - np.eye(3)) @ b_R - (A_R - np.eye(3)) @ b_D
direct = np.array(kept_then_d) - np.array(d_then_kept)
v3 = lambda v: "(" + ", ".join(f"{q:.2f}" for q in v) + ")"
print(f"\nOnline Appendix 3.B: (D o R)x0 - (R o D)x0 = commutator {v3(commutator)} + constant {v3(constant)} = {v3(commutator + constant)};"
f" directly {v3(direct)}")
print(f" commutator: {v3(commutator)}, zero, since the build's effect does not depend on the state it starts from")
print(f" constant: built first, the platform's {BUILD_T:.2f} new points lose 10% to the sale ({TECH_SHARE * BUILD_T:.2f}):"
" 'the sale takes a share of a platform that grows if the digital program runs first'")
print(f" the bag misses it: it pairs digital-first's cash (${bag[0]:.0f} million) with restructure-first's platform"
f" ({bag[1]:.1f}) and the sale-as-designed workforce ({bag[2]:.0f}), a company no sequence produces")
# Appendix 3.A's two-reading example (proof of Theorem 3.2(iii)) and its split (Online Appendix 3.B)
T_R = lambda x: np.array([x[0] + 3, 0.9 * x[1]])
T_D = lambda x: np.array([0.5 * x[0], x[1] + 0.8 * x[0]])
z0 = np.array([2.0, 40.0])
dr2, rd2 = T_D(T_R(z0)), T_R(T_D(z0))
Ar2, br2, Ad2 = np.diag([1.0, 0.9]), np.array([3.0, 0.0]), np.array([[0.5, 0.0], [0.8, 1.0]])
c2, k2 = (Ad2 @ Ar2 - Ar2 @ Ad2) @ z0, (Ad2 - np.eye(2)) @ br2
print(f"\nAppendix 3.A: T_D(T_R x0) = ({dr2[0]:.1f}, {dr2[1]:.1f}), T_R(T_D x0) = ({rd2[0]:.1f}, {rd2[1]:.2f});"
f" difference ({dr2[0] - rd2[0]:.1f}, {dr2[1] - rd2[1]:.2f}) = commutator ({c2[0]:.1f}, {c2[1]:.2f}) + constant ({k2[0]:.1f}, {k2[1]:.1f})")
# the size of the difference (lab step 4): W_M's rule on these three readings, liquidity in $ million
w3 = 1 / np.array([TODAY[0], 100.0, 100.0])
size = {}
for label, dx in (("Table 3.4's two feasible orders", gap), ("the same deal terms in both orders", order)):
size[label] = views(w3 * np.array(dx))
s = size[label]
print(f"size of the difference, {label}: effort {s['effort']:.3f}, Euclidean {s['Euclidean']:.3f}, bottleneck {s['bottleneck']:.3f}")
steps = [0, 1, 2]
paths = [("digital, then restructure", (TODAY, after_build, d_then_r), "#E65100", "-"),
("restructure (engineers kept), then digital", (TODAY, sale_kept, kept_then_d), "#1F4E79", "-"),
("restructure as designed: digital cannot start", (TODAY, sale), "#B71C1C", "--")]
fig, axes = plt.subplots(1, 3, figsize=(7.6, 3.6))
for j, (ax, ylab, lims) in enumerate(zip(axes, ("liquidity ($ million)", "technology platform (index)",
"workforce capability (index)"), ((560, 760), (34, 79), (50, 60)))):
for name, path, col, ls in paths:
ax.plot(steps[:len(path)], [x[j] for x in path], color=col, ls=ls, lw=1.8, marker="o", ms=4, label=name)
if len(path) == 2: # the second step is outside its domain: blocked
ax.plot([1, 1.5], [path[1][j]] * 2, color=col, ls=":", lw=1.4)
ax.plot(1.5, path[1][j], "x", color=col, ms=8, mew=2)
ax.plot(2, bag[j], "o", mfc="white", mec="#616161", mew=1.5, ms=7, label="bag of initiatives: no real sequence")
ax.set_xticks(steps)
ax.set_xticklabels(["today", "step 1", "step 2"], fontsize=8)
ax.set_ylim(*lims)
ax.set_xlim(-0.25, 2.25)
ax.set_title(ylab, fontsize=9)
ax.tick_params(axis="y", labelsize=8)
axes[2].axhline(W_MIN, color="#616161", lw=0.9, ls=":")
axes[2].text(2.2, 50.3, "dotted: the digital\nprogram's domain (55)", ha="right", va="bottom", fontsize=7.5, color="#616161")
handles, labels = axes[0].get_legend_handles_labels()
fig.legend(handles, labels, loc="lower center", ncol=2, frameon=False, fontsize=8, bbox_to_anchor=(0.5, 0.0))
fig.suptitle("Two feasible orders, two companies (seed 26103)", fontsize=11)
plt.tight_layout(rect=(0, 0.13, 1, 1)); plt.show()Step 3: digital first, its low $482 million around month 21: liquidity $585 million, technology 75.63, workforce 58
then the sale: liquidity $697 million, technology 68.07, workforce 53
Step 4: the sale with the engineers kept: liquidity $712 million, technology 36.90, workforce 58
then the digital program, its low $574 million: liquidity $677 million, technology 71.53, workforce 58
Table 3.4 liquidity technology workforce
Today 620 41.0 58
Bag of initiatives (each appraised alone, then added) 697 71.5 53
Restructure, then digital (as designed) infeasible
Digital, then restructure 697 68.1 53
Restructure (engineers kept), then digital 677 71.5 58
Step 5: digital-first ends with $20 million more cash; restructure-first with a stronger platform (71.5 against 68.07, 3.46 points) and workforce (58 against 53)
digital, then the sale with the engineers kept: liquidity $677 million, technology 68.07, workforce 58
the gap (20, -3.46, -5) = deal terms (20, 0.00, -5) + order (0, -3.46, 0)
Online Appendix 3.B: (D o R)x0 - (R o D)x0 = commutator (0.00, 0.00, 0.00) + constant (0.00, 3.46, 0.00) = (0.00, 3.46, 0.00); directly (0.00, 3.46, 0.00)
commutator: (0.00, 0.00, 0.00), zero, since the build's effect does not depend on the state it starts from
constant: built first, the platform's 34.63 new points lose 10% to the sale (3.46): 'the sale takes a share of a platform that grows if the digital program runs first'
the bag misses it: it pairs digital-first's cash ($697 million) with restructure-first's platform (71.5) and the sale-as-designed workforce (53), a company no sequence produces
Appendix 3.A: T_D(T_R x0) = (2.5, 40.0), T_R(T_D x0) = (4.0, 37.44); difference (-1.5, 2.56) = commutator (0.0, 0.16) + constant (-1.5, 2.4)
size of the difference, Table 3.4's two feasible orders: effort 0.117, Euclidean 0.069, bottleneck 0.050
size of the difference, the same deal terms in both orders: effort 0.035, Euclidean 0.035, bottleneck 0.035

Panel 6 — Recommend (Worked Example 3.1, Step 6; Theorem 3.2(i)–(ii))
Worked Example 3.1, Step 6: the order is a decision variable, and so are the deal terms that decide whether the second step is possible. Because the sale cannot be undone (Theorem 3.2(i)), the board should fix the order and the retention clause before signing. Theorem 3.2(ii): sensitivities multiply along a program, so five mild steps (factor 1.2 each) can amplify an error in the starting state by up to , while replacing two of them with consolidating steps (factor 0.7) brings the bound to . The discussion question asks what would have to be true about the value of cash against platform strength for a recommendation to change; the arithmetic below locates the break-even. Chapter 6 later adds the board's liquidity floor (Table 5.4): both orders stay above it, since the build's low point, $138 million below its start, leaves $482 million when the build runs first.
Python Code
print(f"Theorem 3.2(ii): five steps at factor 1.2 amplify by at most {1.2 ** 5:.3f} (about 2.5);"
f" three at 1.2 and two at 0.7 by at most {1.2 ** 3 * 0.7 ** 2:.3f} (about 0.85)")
cash, tech, work = gap[0], -gap[1], -gap[2]
price_w = KEEP_COST / W_LOSS
breakeven = (cash - price_w * work) / tech
print(f"\nFor discussion: digital-first keeps ${cash:.0f} million more cash; restructure-first ends with {tech:.2f} more"
f" platform points and {work:.0f} more workforce points")
print(f"the retention clause prices those {work:.0f} workforce points at ${KEEP_COST:.0f} million, ${price_w:.0f} million a point"
" (the quote Chapter 10 reads from the same deal)")
print(f"at that price restructure-first is worth more exactly when the board values a platform point above"
f" ({cash:.0f} - {KEEP_COST:.0f}) / {tech:.2f} = ${breakeven:.1f} million: digital-first's extra cash is the clause itself")
FLOOR = 350.0 # Table 5.4: the board's floor, liquidity >= $0.35 billion (declared in Chapter 5)
lowest = {}
for name, start in (("digital, then restructure", TODAY), ("restructure (engineers kept), then digital", sale_kept)):
lowest[name] = start[0] - BUILD_DIP # the build's low point comes around month 21
print(f"{name}: lowest liquidity on the way ${lowest[name]:.0f} million, {lowest[name] - FLOOR:+.0f} against the floor")
print("Sections 6.5-6.6: on the floor both orders run; the build needs liquidity of at least"
f" ${FLOOR + BUILD_DIP:.0f} million when it starts, so that its low point respects the floor")Theorem 3.2(ii): five steps at factor 1.2 amplify by at most 2.488 (about 2.5); three at 1.2 and two at 0.7 by at most 0.847 (about 0.85) For discussion: digital-first keeps $20 million more cash; restructure-first ends with 3.46 more platform points and 5 more workforce points the retention clause prices those 5 workforce points at $20 million, $4 million a point (the quote Chapter 10 reads from the same deal) at that price restructure-first is worth more exactly when the board values a platform point above (20 - 20) / 3.46 = $0.0 million: digital-first's extra cash is the clause itself digital, then restructure: lowest liquidity on the way $482 million, +132 against the floor restructure (engineers kept), then digital: lowest liquidity on the way $574 million, +224 against the floor Sections 6.5-6.6: on the floor both orders run; the build needs liquidity of at least $488 million when it starts, so that its low point respects the floor
Panel 7 — Watch a company run down (Section 3.4, Equation 3.2; Table 3.2; Sections 7.4–7.6)
AXIOM Lab 1.3, step 5. Run Section 3.4's three-reading company (Equation 3.2) with no investment, then with investment, and read the eigenvalue display. Entry of is the response of reading to reading : the zeros say that efficiency feeds neither capability nor technology, the entry 0.10 says that capability builds the platform, and diagonal entries below one say that every reading decays without reinforcement. From with , one year later . The eigenvalues are 0.95, 0.80 and 0.80, all below one, so without investment the company decays steadily toward zero: open systems run down without throughput (Table 2.2). Chapter 7 holds the investment at 8 a year: each unit held forever adds 10.5 points of capability, 9 of technology and 7.1 of efficiency, so the company settles at (84, 72, 57) (Section 7.5); over ten years momentum alone lets technology erode from 40 to 27 while the program adds 25 (Section 7.4); and the slowest eigenvalue, 0.95, leaves half of any shock after about 13.5 years (Section 7.6). The spectral radius of Table 3.2 does not depend on the norm; each norm's one-year sensitivity factor does, and a run of years multiplies them (Theorem 3.2(ii)).
Python Code
x1 = A3 @ Y0 + B3 * U0
eig = np.sort(np.linalg.eigvals(A3).real)[::-1]
rho = float(np.abs(np.linalg.eigvals(A3)).max())
print(f"one year from x0 = (50, 40, 60) with u0 = 10: x1 = ({x1[0]:.1f}, {x1[1]:.1f}, {x1[2]:.1f})")
print(f"eigenvalues {', '.join(f'{v:.2f}' for v in eig)}; spectral radius {rho:.2f} < 1: without investment every reading decays")
def run(y0, u, years):
y = [np.asarray(y0, float)]
for _ in range(years):
y.append(A3 @ y[-1] + B3 * u)
return np.array(y)
U_HELD, YEARS = 8.0, 30 # Chapter 7's held investment of 8 a year
free, held = run(Y0, 0.0, YEARS), run(Y0, U_HELD, YEARS)
per_unit = np.linalg.solve(np.eye(3) - A3, B3)
steady = U_HELD * per_unit
v3 = lambda v, d=1: "(" + ", ".join(f"{q:.{d}f}" for q in v) + ")"
print(f"no investment: year 10 {v3(free[10])}, year 30 {v3(free[30])}: the three readings end up falling together,"
" 5 percent a year (every row of A sums to 0.95, so (1, 1, 1) is the slowest mode)")
print(f"each unit of investment held forever adds {v3(per_unit, 3)}; a held 8 settles the company at {v3(steady, 0)}")
print(f"technology at year 10: momentum alone {free[10, 1]:.1f}, the program adds {held[10, 1] - free[10, 1]:.1f},"
f" in all {held[10, 1]:.1f}")
half = np.log(0.5) / np.log(rho)
print(f"half-life of the slowest mode: ln 0.5 / ln {rho:.2f} = {half:.1f} years")
# the one-year map's sensitivity factor in three norms; a k-year run's factor is at most its k-th power
Lf = {"bottleneck": float(np.abs(A3).sum(1).max()), "Euclidean": float(np.linalg.norm(A3, 2)),
"effort": float(np.abs(A3).sum(0).max())}
print("\none-year sensitivity factor: " + ", ".join(f"{k} {v:.3f}" for k, v in Lf.items()))
K = 40
eff_k = np.array([np.abs(np.linalg.matrix_power(A3, k)).sum(0).max() for k in range(K + 1)])
bot_k = np.array([np.abs(np.linalg.matrix_power(A3, k)).sum(1).max() for k in range(K + 1)])
k_peak = int(eff_k.argmax())
k_below = int(np.argmax((eff_k < 1) & (np.arange(K + 1) > k_peak)))
print(f"bottleneck view: a k-year run's factor is exactly 0.95^k (largest gap to 0.95^k over 40 years:"
f" {np.abs(bot_k - 0.95 ** np.arange(K + 1)).max():.0e}); the largest single deviation never grows")
print(f"effort view: a capability shortfall spreads to technology and efficiency, so the total first grows: the k-year factor"
f" rises to {eff_k[k_peak]:.3f} at year {k_peak} and falls below one only from year {k_below}")
print("the conclusion is the same in every norm (Theorem 3.1): every deviation dies out, at the rate the spectral radius sets")
t = np.arange(YEARS + 1)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for j, (name, col) in enumerate((("capability", "#1F4E79"), ("technology", "#E65100"), ("efficiency", "#B71C1C"))):
ax.plot(t, held[:, j], color=col, lw=2, label=name)
ax.plot(t, free[:, j], color=col, lw=1.4, ls="--")
ax.axhline(steady[j], color=col, lw=0.7, ls=":")
ax.text(YEARS + 0.3, steady[j], f"{steady[j]:.0f}", va="center", ha="left", fontsize=8, color=col)
ax.plot([], [], color="#616161", lw=2, label="investment held at 8 a year")
ax.plot([], [], color="#616161", lw=1.4, ls="--", label="no investment")
ax.plot([], [], color="#616161", lw=0.7, ls=":", label="steady state under the held 8")
ax.text(YEARS, 1.5, "eigenvalues 0.95, 0.80, 0.80", ha="right", va="bottom", fontsize=8, color="#616161")
ax.set(xlim=(0, YEARS), ylim=(0, 104), xlabel="years", ylabel="index (0-100)",
title="Without investment the company runs down; a held 8 sets its level (seed 26103)")
h, lab = ax.get_legend_handles_labels()
rows = [0, 3, 1, 4, 2, 5] # colours on the first row, line styles on the second
ax.legend([h[i] for i in rows], [lab[i] for i in rows], frameon=False, fontsize=8, ncol=3, loc="upper center",
bbox_to_anchor=(0.5, 1.02), columnspacing=1.4)
plt.tight_layout(); plt.show()one year from x0 = (50, 40, 60) with u0 = 10: x1 = (53.0, 42.0, 54.5) eigenvalues 0.95, 0.80, 0.80; spectral radius 0.95 < 1: without investment every reading decays no investment: year 10 (28.3, 27.2, 28.7), year 30 (10.0, 10.0, 10.0): the three readings end up falling together, 5 percent a year (every row of A sums to 0.95, so (1, 1, 1) is the slowest mode) each unit of investment held forever adds (10.500, 9.000, 7.125); a held 8 settles the company at (84, 72, 57) technology at year 10: momentum alone 27.2, the program adds 25.0, in all 52.2 half-life of the slowest mode: ln 0.5 / ln 0.95 = 13.5 years one-year sensitivity factor: bottleneck 0.950, Euclidean 0.971, effort 1.050 bottleneck view: a k-year run's factor is exactly 0.95^k (largest gap to 0.95^k over 40 years: 7e-16); the largest single deviation never grows effort view: a capability shortfall spreads to technology and efficiency, so the total first grows: the k-year factor rises to 1.117 at year 5 and falls below one only from year 11 the conclusion is the same in every norm (Theorem 3.1): every deviation dies out, at the rate the spectral radius sets

Validation — the book's numbers, and agreement with DCT_V1_Ch03_Lab.xlsx
Each checkpoint is a number printed in Chapter 3 (Tables 3.1 and 3.4, Figure 3.3, Worked Example 3.1,
Sections 3.4–3.5, Appendix 3.A), in Online Appendix 3.B, or in the later sections that reuse Chapter 3's
scaling and three-reading company (Sections 5.8, 6.6 and 7.4–7.6). The workbook recomputes the ones marked
workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.
Python Code
y5 = {k: V[f"{k}, Year 5"]["Euclidean"] for k in YEAR5}
checks = [
("readings in Meridian's state, Table 3.1 (workbook)", len(X0), 8, 0),
("scaled workforce capability, Figure 3.3 (workbook)", SX0[2], 0.58, 0.005),
("scaled technology platform, Figure 3.3 (workbook)", SX0[3], 0.41, 0.005),
("scaled operational efficiency, Figure 3.3 (workbook)", SX0[4], 0.71, 0.005),
("scaled strategic risk, Figure 3.3 (workbook)", SX0[6], 0.64, 0.005),
("readings at 1.00 after scaling, Figure 3.3 (workbook)", int(np.isclose(SX0, 1.0).sum()), 4, 0),
("sale alone: liquidity change, Step 1 (workbook)", d_sale[0], 112, 0.5),
("sale alone: technology change, Step 1 (workbook)", d_sale[1], -4.1, 0.05),
("sale alone: workforce change, Step 1 (workbook)", d_sale[2], -5, 0),
("digital alone: liquidity change by Year 5, Step 1 (workbook)", d_build[0], -35, 0.5),
("digital alone: technology change, Step 1 (workbook)", d_build[1], 34.6, 0.05),
("the build's low point below its start, the situation (workbook)", BUILD_DIP, 138, 0.5),
("bag of initiatives: liquidity, Table 3.4 (workbook)", bag[0], 697, 0.5),
("bag of initiatives: technology, Table 3.4 (workbook)", bag[1], 71.5, 0.05),
("bag of initiatives: workforce, Table 3.4 (workbook)", bag[2], 53, 0),
("after the sale: liquidity, Step 2 (workbook)", sale[0], 732, 0.5),
("after the sale: technology, Step 2 (workbook)", sale[1], 36.9, 0.05),
("restructure, then digital is feasible, Table 3.4 (workbook)", int(r_then_d is not None), 0, 0),
("digital first: liquidity after the build, Step 3 (workbook)", after_build[0], 585, 0.5),
("digital first: technology after the build, Step 3 (workbook)", after_build[1], 75.6, 0.05),
("digital, then restructure: liquidity, Table 3.4 (workbook)", d_then_r[0], 697, 0.5),
("digital, then restructure: technology, Table 3.4 (workbook)", d_then_r[1], 68.1, 0.05),
("digital, then restructure: workforce, Table 3.4 (workbook)", d_then_r[2], 53, 0),
("sale with the engineers kept: liquidity, Step 4 (workbook)", sale_kept[0], 712, 0.5),
("restructure (kept), then digital: liquidity, Table 3.4 (workbook)", kept_then_d[0], 677, 0.5),
("restructure (kept), then digital: technology, Table 3.4 (workbook)", kept_then_d[1], 71.5, 0.05),
("restructure (kept), then digital: workforce, Table 3.4 (workbook)", kept_then_d[2], 58, 0),
("digital-first's extra cash, Step 5 (workbook)", gap[0], 20, 0.5),
("three-reading company: capability after a year, Section 3.4 (workbook)", x1[0], 53.0, 0.05),
("three-reading company: technology after a year, Section 3.4 (workbook)", x1[1], 42.0, 0.05),
("three-reading company: efficiency after a year, Section 3.4 (workbook)", x1[2], 54.5, 0.05),
("largest eigenvalue, Section 3.4 (workbook)", eig[0], 0.95, 0.005),
("second eigenvalue, Section 3.4 (workbook)", eig[1], 0.80, 0.005),
("third eigenvalue, Section 3.4 (workbook)", eig[2], 0.80, 0.005),
("five steps at factor 1.2, Section 3.5 (workbook)", 1.2 ** 5, 2.5, 0.05),
("three steps at 1.2 and two at 0.7, Section 3.5 (workbook)", 1.2 ** 3 * 0.7 ** 2, 0.85, 0.005),
("T_D(T_R x0), first reading, Appendix 3.A (workbook)", dr2[0], 2.5, 0.05),
("T_D(T_R x0), second reading, Appendix 3.A (workbook)", dr2[1], 40.0, 0.05),
("T_R(T_D x0), first reading, Appendix 3.A (workbook)", rd2[0], 4.0, 0.05),
("T_R(T_D x0), second reading, Appendix 3.A (workbook)", rd2[1], 37.44, 0.005),
("difference of the orders, first reading, OA 3.B (workbook)", dr2[0] - rd2[0], -1.5, 0.05),
("difference of the orders, second reading, OA 3.B (workbook)", dr2[1] - rd2[1], 2.56, 0.005),
("largest effort/bottleneck ratio, eight readings, Remark 3.B.1 (workbook)", views(ones)["effort"] / views(ones)["bottleneck"], 8, 1e-9),
("scaled distance to the turnaround's Year 5, Section 5.8 (workbook)", y5["turnaround"], 0.11, 0.005),
("scaled distance to restructuring's Year 5, Section 5.8 (workbook)", y5["restructuring"], 0.26, 0.005),
("scaled distance to digital's Year 5, Section 5.8 (workbook)", y5["digital"], 0.36, 0.005),
("digital first: lowest liquidity on the way, Worked Example 8.1 (workbook)", lowest["digital, then restructure"], 482, 0.5),
("technology at year 10, momentum alone, Section 7.4 (workbook)", free[10, 1], 27, 0.5),
("technology at year 10, the program's addition, Section 7.4 (workbook)", held[10, 1] - free[10, 1], 25, 0.5),
("technology at year 10, in all, Section 7.4 (workbook)", held[10, 1], 52, 0.5),
("efficiency per unit of investment held, Section 7.5 (workbook)", per_unit[2], 7.1, 0.05),
("steady state under a held 8: capability, Section 7.5 (workbook)", steady[0], 84, 0.5),
("steady state under a held 8: technology, Section 7.5 (workbook)", steady[1], 72, 0.5),
("steady state under a held 8: efficiency, Section 7.5 (workbook)", steady[2], 57, 0.5),
("half-life of the slowest mode, years, Section 7.6 (workbook)", half, 13.5, 0.05),
]
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-9 else "FAIL"; ok += status == "PASS"
print(f"{name:{width}s} {got:10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")readings in Meridian's state, Table 3.1 (workbook) 8.0000 book 8.0000 PASS scaled workforce capability, Figure 3.3 (workbook) 0.5800 book 0.5800 PASS scaled technology platform, Figure 3.3 (workbook) 0.4100 book 0.4100 PASS scaled operational efficiency, Figure 3.3 (workbook) 0.7100 book 0.7100 PASS scaled strategic risk, Figure 3.3 (workbook) 0.6400 book 0.6400 PASS readings at 1.00 after scaling, Figure 3.3 (workbook) 4.0000 book 4.0000 PASS sale alone: liquidity change, Step 1 (workbook) 112.0000 book 112.0000 PASS sale alone: technology change, Step 1 (workbook) -4.1000 book -4.1000 PASS sale alone: workforce change, Step 1 (workbook) -5.0000 book -5.0000 PASS digital alone: liquidity change by Year 5, Step 1 (workbook) -35.3673 book -35.0000 PASS digital alone: technology change, Step 1 (workbook) 34.6347 book 34.6000 PASS the build's low point below its start, the situation (workbook) 138.0821 book 138.0000 PASS bag of initiatives: liquidity, Table 3.4 (workbook) 696.6327 book 697.0000 PASS bag of initiatives: technology, Table 3.4 (workbook) 71.5347 book 71.5000 PASS bag of initiatives: workforce, Table 3.4 (workbook) 53.0000 book 53.0000 PASS after the sale: liquidity, Step 2 (workbook) 732.0000 book 732.0000 PASS after the sale: technology, Step 2 (workbook) 36.9000 book 36.9000 PASS restructure, then digital is feasible, Table 3.4 (workbook) 0.0000 book 0.0000 PASS digital first: liquidity after the build, Step 3 (workbook) 584.6327 book 585.0000 PASS digital first: technology after the build, Step 3 (workbook) 75.6347 book 75.6000 PASS digital, then restructure: liquidity, Table 3.4 (workbook) 696.6327 book 697.0000 PASS digital, then restructure: technology, Table 3.4 (workbook) 68.0712 book 68.1000 PASS digital, then restructure: workforce, Table 3.4 (workbook) 53.0000 book 53.0000 PASS sale with the engineers kept: liquidity, Step 4 (workbook) 712.0000 book 712.0000 PASS restructure (kept), then digital: liquidity, Table 3.4 (workbook) 676.6327 book 677.0000 PASS restructure (kept), then digital: technology, Table 3.4 (workbook) 71.5347 book 71.5000 PASS restructure (kept), then digital: workforce, Table 3.4 (workbook) 58.0000 book 58.0000 PASS digital-first's extra cash, Step 5 (workbook) 20.0000 book 20.0000 PASS three-reading company: capability after a year, Section 3.4 (workbook) 53.0000 book 53.0000 PASS three-reading company: technology after a year, Section 3.4 (workbook) 42.0000 book 42.0000 PASS three-reading company: efficiency after a year, Section 3.4 (workbook) 54.5000 book 54.5000 PASS largest eigenvalue, Section 3.4 (workbook) 0.9500 book 0.9500 PASS second eigenvalue, Section 3.4 (workbook) 0.8000 book 0.8000 PASS third eigenvalue, Section 3.4 (workbook) 0.8000 book 0.8000 PASS five steps at factor 1.2, Section 3.5 (workbook) 2.4883 book 2.5000 PASS three steps at 1.2 and two at 0.7, Section 3.5 (workbook) 0.8467 book 0.8500 PASS T_D(T_R x0), first reading, Appendix 3.A (workbook) 2.5000 book 2.5000 PASS T_D(T_R x0), second reading, Appendix 3.A (workbook) 40.0000 book 40.0000 PASS T_R(T_D x0), first reading, Appendix 3.A (workbook) 4.0000 book 4.0000 PASS T_R(T_D x0), second reading, Appendix 3.A (workbook) 37.4400 book 37.4400 PASS difference of the orders, first reading, OA 3.B (workbook) -1.5000 book -1.5000 PASS difference of the orders, second reading, OA 3.B (workbook) 2.5600 book 2.5600 PASS largest effort/bottleneck ratio, eight readings, Remark 3.B.1 (workbook) 8.0000 book 8.0000 PASS scaled distance to the turnaround's Year 5, Section 5.8 (workbook) 0.1087 book 0.1100 PASS scaled distance to restructuring's Year 5, Section 5.8 (workbook) 0.2589 book 0.2600 PASS scaled distance to digital's Year 5, Section 5.8 (workbook) 0.3625 book 0.3600 PASS digital first: lowest liquidity on the way, Worked Example 8.1 (workbook) 481.9179 book 482.0000 PASS technology at year 10, momentum alone, Section 7.4 (workbook) 27.2252 book 27.0000 PASS technology at year 10, the program's addition, Section 7.4 (workbook) 24.9600 book 25.0000 PASS technology at year 10, in all, Section 7.4 (workbook) 52.1853 book 52.0000 PASS efficiency per unit of investment held, Section 7.5 (workbook) 7.1250 book 7.1000 PASS steady state under a held 8: capability, Section 7.5 (workbook) 84.0000 book 84.0000 PASS steady state under a held 8: technology, Section 7.5 (workbook) 72.0000 book 72.0000 PASS steady state under a held 8: efficiency, Section 7.5 (workbook) 57.0000 book 57.0000 PASS half-life of the slowest mode, years, Section 7.6 (workbook) 13.5134 book 13.5000 PASS 55 of 55 checkpoints PASS
Next. Chapter 4 asks what a company model can and cannot answer: no analysis extracts what a model's readings leave out, and validation certifies a model only where history has been. The declarations made here, units, scaling, the norm and the spacing of ratings, become part of its modeling contract. AXIOM-03 runs the same models interactively (Lab 1.3); this notebook and the workbook are its reproducible record.


