DCT Laboratory — Volume I, Chapter 5
Enterprise State Representation
This laboratory demonstrates
Seed 26105 · Companion to Chapter 5 and AXIOM Lab 1.5 (module AXIOM-05) · Mirrored in DCT_V1_Ch05_Lab.xlsx
This laboratory reproduces Worked Example 5.1, Where Does the Turnaround Settle?, with the book's declarations, and works the five steps of AXIOM Lab 1.5, Meridian's Room to Maneuver: declare the state, build the walls, sample a path, find the steady state, compare profiles. Every Meridian number below is the book's (Worked Example 5.1 and Table 5.5, Tables 5.2 and 5.4, Sections 5.4–5.8, Figures 5.1–5.5, Online Appendix 5.B); the final cell checks them. Money is in $ million; liquidity is also read as an index, with today = 100 = $620 million, the $0.62 billion of Table 5.2.
The declarations (Tables 5.2 and 5.4; Worked Example 5.1, The situation)
Meridian's declared state has eight readings (Table 5.2): liquidity ($0.62 billion; here an index with today = 100, so 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), each with a unit, a type, a measurement source and its error. The walls with numbers are Table 5.4's: the loan covenant , the board's liquidity floor of $350 million ($0.35 billion), the risk ceiling , liquidity of at least zero, and the definitional bounds (indices between 0 and 100, shares between 0 and 1). The paths are Chapter 1's model (Online Appendix 1.B.4). It moves four 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 restructuring's sale closes at year 1 (Equation 1.B.1):
The turnaround of Worked Example 5.1 is this model's third option: targets 106, 33, 79 and 67.
Python Code
import numpy as np
import matplotlib.pyplot as plt
from math import pi, lgamma, exp, log, log10
from scipy.integrate import solve_ivp
from scipy.linalg import expm
from scipy.optimize import minimize_scalar, brentq
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26105
# Table 5.2: Meridian's declared state, today's values (Chapter 3, Table 3.1) in each reading's declared unit
STATE = [ # symbol, reading, today, unit, type, measured by, error in the reading's unit, error as printed, tag
("x1", "liquidity", 0.62, "US$ billion", "stock", "treasury systems", 0.0062, "+/-1%", "ECA"),
("x2", "net leverage", 3.4, "ND/EBITDA", "ratio", "audited accounts", 0.068, "+/-2%", "ECA"),
("x3", "workforce capability", 58.0, "0-100", "index", "skills survey", 5.0, "+/-5", "ECA"),
("x4", "technology platform", 41.0, "0-100", "index", "architecture audit", 4.0, "+/-4", "ECA"),
("x5", "operational efficiency", 71.0, "0-100", "index", "cost benchmarking", 3.0, "+/-3", "EPA"),
("x6", "ROIC", 0.083, "ratio", "ratio", "audited accounts", 0.004, "+/-0.4 pp", "EPA"),
("x7", "strategic risk", 64.0, "0-100", "index", "risk committee", 6.0, "+/-6", "ERRA"),
("x8", "market share", 0.19, "ratio", "ratio", "industry data", 0.008, "+/-0.8 pp", "EPA"),
]
USD_PT = 620.0 / 100 # liquidity as an index, today = 100 = $620 million: $6.2 million a point
X0 = np.array([s[2] for s in STATE]); X0[0] = 100.0
COVENANT, FLOOR_USD, RISK_CEILING = 4.5, 350.0, 75.0 # Table 5.4: covenant, board floor ($ million), risk ceiling
FLOOR_PT = FLOOR_USD / USD_PT
# Chapter 1's model (Online Appendix 1.B.4, Table 1.B.1): target, speed a year, trough (sign x depth), trough time, jump
MOVING = {"x1": 0, "x4": 3, "x5": 4, "x7": 6}
MODEL = {
"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(MODEL)
COLOR = {"Digital": "#5E35B1", "Restructuring": "#2E7D32", "Turnaround": "#E65100"}
def reading(option, key, t):
# Equation 1.B.1: relaxation toward the target, a trough for temporary strain, a jump when the sale closes (t = 1)
target, k, depth, tau, jump = MODEL[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 >= 1.0)
def state_at(option, t):
# all eight readings at the times t; the four the model does not move stay at today's values
t = np.atleast_1d(np.asarray(t, float))
x = np.tile(X0, (len(t), 1))
for key, i in MOVING.items():
x[:, i] = reading(option, key, t)
return x
def score(x1, x4, x5, x7):
# Chapter 1's scorecard: liquidity, technology and efficiency weighed equally, strategic risk subtracted
return 0.25 * (x1 + x4 + x5 - x7)
MONTHS = np.arange(61); T_M = MONTHS / 12 # five years, month by month
Y5 = {o: state_at(o, 5.0)[0] for o in OPTIONS} # the Year-5 states (Table 1.9)
print(f"Meridian's declared state: {len(STATE)} readings (Table 5.2); Chapter 1's model moves {len(MOVING)} of them")
print(f"liquidity today: ${STATE[0][2]:.2f} billion = index 100; a point is ${USD_PT:.1f} million")
print(f"walls with numbers (Table 5.4): covenant x2 <= {COVENANT}; board floor ${FLOOR_USD:.0f} million (index {FLOOR_PT:.2f}); "
f"risk ceiling x7 <= {RISK_CEILING:.0f}; liquidity >= 0; indices in [0, 100]; shares in [0, 1]")
print("Year 5 (liquidity, technology, efficiency, strategic risk): "
+ "; ".join(f"{o.lower()} " + ", ".join(f"{Y5[o][i]:.1f}" for i in MOVING.values()) for o in OPTIONS))Meridian's declared state: 8 readings (Table 5.2); Chapter 1's model moves 4 of them liquidity today: $0.62 billion = index 100; a point is $6.2 million walls with numbers (Table 5.4): covenant x2 <= 4.5; board floor $350 million (index 56.45); risk ceiling x7 <= 75; liquidity >= 0; indices in [0, 100]; shares in [0, 1] Year 5 (liquidity, technology, efficiency, strategic risk): digital 94.3, 75.6, 73.6, 55.2; restructuring 121.1, 38.9, 73.7, 49.4; turnaround 105.4, 35.9, 78.6, 66.3
Panel 1 — Declare the state (Tables 5.1–5.2; Definitions 5.2–5.3; Theorem 5.1)
AXIOM Lab 1.5, step 1. In the state constructor, review Meridian's declaration: eight readings, each with its unit, its type (Table 5.1: one stock, three ratios, four indices), its measurement source and error, and its tag for the architecture of Part III it belongs to — capital (ECA), performance (EPA), or risk, resilience and robustness (ERRA). One vector carries cash, ratios and survey indices; the declaration, not the notation, does the carrying (Definition 5.3). On Chapter 3's scale (indices divided by 100, the other readings by today's value) the widest error bars belong to strategic risk and workforce capability.
Then switch the attrition rate from parameter to state variable and rerun the digital program. Table 5.1 lists the attrition rate as a parameter, held fixed over the horizon; its declared range is 6 to 11 percent a year (Table 4.3). Theorem 5.1's membership test says what the switch changes: a reading earns its place by carrying information the future needs. Chapter 1's model holds workforce capability at 58 and never reads the attrition rate, so two Meridians that differ only in it have the same future: the rerun is identical, and the new coordinate does not move over the five years. At this horizon the attrition rate is a parameter; it becomes a state variable in a model whose future depends on it, such as a ten-year plan in which capability moves (the lab's discussion question 3).
Python Code
SCALE = np.array([X0[0], X0[1], 100, 100, 100, X0[5], 100, X0[7]], float) # Chapter 3's scale (liquidity in index points)
ERR = np.array([s[6] for s in STATE]); ERR[0] = 0.01 * X0[0] # liquidity's +/-1%, in index points
print("Table 5.2 -- Meridian's declared state")
print(f" {'reading':24s}{'today':>7s} {'unit':13s}{'type':7s}{'measured by (error)':31s}{'tag':6s}scaled error")
for s, sc, e in zip(STATE, SCALE, ERR):
print(f"{s[0]:5s}{s[1]:24s}{s[2]:7.3g} {s[3]:13s}{s[4]:7s}{s[5] + ' (' + s[7] + ')':31s}{s[8]:6s}{e / sc:.3f}")
count = {t: [s[0] for s in STATE if s[4] == t] for t in ("stock", "ratio", "index")}
tags = {t: [s[0] for s in STATE if s[8] == t] for t in ("ECA", "EPA", "ERRA")}
print(f"types (Table 5.1): {len(count['stock'])} stock {count['stock']}, {len(count['ratio'])} ratios {count['ratio']}, "
f"{len(count['index'])} indices {count['index']}")
print("tags (Part III): " + "; ".join(f"{t} {v}" for t, v in tags.items()))
w1, w2 = np.argsort(-ERR / SCALE)[:2]
print(f"widest error bars on Chapter 3's scale: {STATE[w1][1]} ({ERR[w1] / SCALE[w1]:.3f}) and {STATE[w2][1]} ({ERR[w2] / SCALE[w2]:.3f})")
# The switch: promote the attrition rate (a parameter, Table 5.1) to a ninth state variable and rerun the digital program
def run_digital(attrition=None):
x = state_at("Digital", T_M)
if attrition is None:
return x
return np.hstack([x, np.full((len(T_M), 1), attrition)]) # Chapter 1's model gives the new coordinate no law
base, lo, hi = run_digital(), run_digital(0.06), run_digital(0.11) # either end of the declared range (Table 4.3)
print(f"\nthe switch: the state's dimension goes from {base.shape[1]} to {lo.shape[1]}")
print(f" rerun from attrition 6% and 11% a year: the eight readings differ by at most {np.abs(lo[:, :8] - hi[:, :8]).max():.1f}, "
f"and from the run before the switch by {np.abs(lo[:, :8] - base).max():.1f}")
print(f" the new coordinate moves by {np.ptp(lo[:, 8]):.1f} in five years: held fixed over the horizon, it is a parameter here")Table 5.2 -- Meridian's declared state
reading today unit type measured by (error) tag scaled error
x1 liquidity 0.62 US$ billion stock treasury systems (+/-1%) ECA 0.010
x2 net leverage 3.4 ND/EBITDA ratio audited accounts (+/-2%) ECA 0.020
x3 workforce capability 58 0-100 index skills survey (+/-5) ECA 0.050
x4 technology platform 41 0-100 index architecture audit (+/-4) ECA 0.040
x5 operational efficiency 71 0-100 index cost benchmarking (+/-3) EPA 0.030
x6 ROIC 0.083 ratio ratio audited accounts (+/-0.4 pp) EPA 0.048
x7 strategic risk 64 0-100 index risk committee (+/-6) ERRA 0.060
x8 market share 0.19 ratio ratio industry data (+/-0.8 pp) EPA 0.042
types (Table 5.1): 1 stock ['x1'], 3 ratios ['x2', 'x6', 'x8'], 4 indices ['x3', 'x4', 'x5', 'x7']
tags (Part III): ECA ['x1', 'x2', 'x3', 'x4']; EPA ['x5', 'x6', 'x8']; ERRA ['x7']
widest error bars on Chapter 3's scale: strategic risk (0.060) and workforce capability (0.050)
the switch: the state's dimension goes from 8 to 9
rerun from attrition 6% and 11% a year: the eight readings differ by at most 0.0, and from the run before the switch by 0.0
the new coordinate moves by 0.0 in five years: held fixed over the horizon, it is a parameter here
Panel 2 — Build the walls (Table 5.4; Definitions 5.8–5.9; Proposition 5.5; Figure 5.4)
AXIOM Lab 1.5, step 2. In the constraint sculptor, add Table 5.4's constraints one at a time — the definitional bounds, liquidity of at least zero, the loan covenant, the board's floor, the risk ceiling — and watch the region shrink: each wall can only remove states (Proposition 5.5(i)). Then probe. Today's state, 3.4 times leverage and $620 million ($0.62 billion) of liquidity, touches no wall: the binding set is empty, with 1.1 turns of covenant headroom and $270 million ($0.27 billion) above the floor. At the digital program's low point, around month 21 of Chapter 1's model, liquidity is $482 million ($0.48 billion) and the slack above the floor shrinks to $132 million ($0.13 billion): a board that raised its floor above that would make the program, as modeled, infeasible. The probe below reads every wall with numbers, today, at the low point, and at its tightest along each option's five-year path.
Python Code
WALLS = [ # Table 5.4's walls with numbers: name, type, slack (room left; zero = binding, negative = breached), unit
("liquidity at least zero", "physical", lambda x: USD_PT * x[:, 0], "$ million"),
("board floor, $350 million", "policy", lambda x: USD_PT * x[:, 0] - FLOOR_USD, "$ million"),
("covenant, leverage <= 4.5", "contractual", lambda x: COVENANT - x[:, 1], "turns"),
("risk ceiling, risk <= 75", "policy", lambda x: RISK_CEILING - x[:, 6], "points"),
("indices between 0 and 100", "definitional", lambda x: np.minimum(x[:, [2, 3, 4, 6]], 100 - x[:, [2, 3, 4, 6]]).min(1), "points"),
("shares between 0 and 1", "definitional", lambda x: np.minimum(x[:, 7], 1 - x[:, 7]), "share"),
]
def probe(x):
x = np.atleast_2d(x)
return np.array([f(x) for _, _, f, _ in WALLS]) # walls x states
slack_today = probe(X0)[:, 0]
binding_today = [WALLS[j][0] for j in range(len(WALLS)) if abs(slack_today[j]) < 1e-9]
low = minimize_scalar(lambda t: float(reading("Digital", "x1", t)), bounds=(1.0, 3.0), method="bounded",
options={"xatol": 1e-10})
T_LOW, LOW_PT = float(low.x), float(low.fun)
LOW_USD = USD_PT * LOW_PT
slack_low = probe(state_at("Digital", T_LOW))[:, 0]
binding_low = [WALLS[j][0] for j in range(len(WALLS)) if abs(slack_low[j]) < 1e-9]
peak = minimize_scalar(lambda t: -float(reading("Digital", "x7", t)), bounds=(0.2, 2.0), method="bounded",
options={"xatol": 1e-10})
T_PEAK, RISK_PEAK = float(peak.x), float(-peak.fun)
SL = {o: probe(state_at(o, T_M)) for o in OPTIONS} # every wall, month by month, five years
M_LOW, M_PEAK = int(MONTHS[SL["Digital"][1].argmin()]), int(MONTHS[SL["Digital"][3].argmin()])
def tightest(o, j):
v = SL[o][j]
return "held" if np.ptp(v) < 1e-12 else f"{v.min():.2f} (m{MONTHS[v.argmin()]})"
print(f"{'wall (Table 5.4)':28s}{'type':14s}{'today':>8s}{'digital low':>13s} tightest along each five-year path (month)")
print(f"{'':50s}{'(month ' + format(12 * T_LOW, '.1f') + ')':>13s} {'digital':16s}{'restructuring':16s}turnaround")
for j, (name, kind, _, unit) in enumerate(WALLS):
print(f"{name:28s}{kind:14s}{slack_today[j]:8.2f}{slack_low[j]:13.2f} " + "".join(f"{tightest(o, j):16s}" for o in OPTIONS))
print(f"binding set today: {binding_today or 'empty'}; at the digital low point: {binding_low or 'empty'}")
print(f"today: {slack_today[2]:.1f} turns of covenant headroom; ${slack_today[1]:.0f} million (${slack_today[1] / 1000:.2f} billion) "
f"above the floor")
print(f"digital low point: index {LOW_PT:.2f} at {T_LOW:.3f} years (month {12 * T_LOW:.1f}; month {M_LOW} on the monthly grid) "
f"= ${LOW_USD:.1f} million (${LOW_USD / 1000:.2f} billion), ${LOW_USD - FLOOR_USD:.1f} million above the floor")
print(f"the highest floor the digital program can meet is its low point, ${LOW_USD:.1f} million; above it the program is infeasible")
print(f"digital strategic risk peaks at {RISK_PEAK:.2f} at month {12 * T_PEAK:.1f} (month {M_PEAK} on the monthly grid), "
f"{RISK_CEILING - RISK_PEAK:.2f} points under the ceiling")
print("\nwalls added one at a time in Figure 5.4's projection (leverage, liquidity): are today and the low point inside?")
ADDED = [("definitional and physical: liquidity >= 0", lambda lev, usd: usd >= 0),
("+ the covenant: leverage <= 4.5", lambda lev, usd: lev <= COVENANT),
("+ the board floor: liquidity >= $350 million", lambda lev, usd: usd >= FLOOR_USD)]
for i in range(len(ADDED)):
inside = lambda usd: all(w(X0[1], usd) for _, w in ADDED[:i + 1])
print(f" {ADDED[i][0]:46s} today {'inside' if inside(620.0) else 'outside'}; low point {'inside' if inside(LOW_USD) else 'outside'}")
print("\nthe walls the digital path comes closest to, in common units (Chapter 3's scale; the reading's error)")
for name, j, t_at, sc, err in (("board floor", 1, T_LOW, 620.0, 6.2), ("covenant", 2, T_LOW, X0[1], 0.068),
("risk ceiling", 3, T_PEAK, 100.0, 6.0)):
s = float(probe(state_at("Digital", t_at))[j, 0])
print(f" {name:13s} slack {s:7.2f} at month {12 * t_at:4.1f}: {s / sc:.3f} on Chapter 3's scale, {s / err:5.2f} reading errors")
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6))
ax.add_patch(plt.Rectangle((0, FLOOR_USD), COVENANT, 1250 - FLOOR_USD, color="#EEF3F9", lw=0, zorder=0))
ax.axvline(COVENANT, color="#B71C1C", lw=1.1); ax.axhline(FLOOR_USD, color="#E65100", lw=1.1)
ax.axhline(0, color="#999999", lw=0.8)
ax.text(COVENANT + 0.08, 1180, "covenant\n4.5x", fontsize=7, color="#B71C1C", va="top")
ax.text(0.1, FLOOR_USD - 30, "board floor $350m", fontsize=7, color="#E65100", va="top")
ax.text(0.1, 30, "liquidity >= 0", fontsize=7, color="#616161", va="bottom")
ax.plot(X0[1], 620, "o", color="#1F4E79", ms=6, zorder=5)
ax.annotate("today: 3.4x, $620m", (X0[1], 620), xytext=(-7, 5), textcoords="offset points", ha="right", fontsize=7, color="#1F4E79")
ax.plot(X0[1], LOW_USD, "v", color="#5E35B1", ms=6, zorder=5)
ax.annotate(f"digital low point,\nmonth 21: ${LOW_USD:.0f}m", (X0[1], LOW_USD), xytext=(-7, -2), textcoords="offset points",
ha="right", va="top", fontsize=7, color="#5E35B1")
ax.annotate("", xy=(X0[1] + 0.22, FLOOR_USD), xytext=(X0[1] + 0.22, LOW_USD),
arrowprops=dict(arrowstyle="<->", color="#616161", lw=0.7, shrinkA=0, shrinkB=0))
ax.text(X0[1] + 0.3, (FLOOR_USD + LOW_USD) / 2, f"${LOW_USD - FLOOR_USD:.0f}m", fontsize=7, color="#616161", va="center")
ax.set(xlim=(0, 6), ylim=(-50, 1250), xlabel="net leverage (net debt / EBITDA)", ylabel="liquidity ($ million)")
ax.set_title("Figure 5.4's projection", fontsize=9)
bx.add_patch(plt.Rectangle((40, FLOOR_USD), RISK_CEILING - 40, 850 - FLOOR_USD, color="#EEF3F9", lw=0, zorder=0))
bx.axvline(RISK_CEILING, color="#B71C1C", lw=1.1); bx.axhline(FLOOR_USD, color="#E65100", lw=1.1)
tt = np.linspace(0, 5, 601)
for o in OPTIONS:
s = state_at(o, tt)
pre, post = tt < 1.0, tt >= 1.0 # draw the restructuring's sale as a jump, not a path
bx.plot(s[pre, 6], USD_PT * s[pre, 0], color=COLOR[o], lw=1.6, label=o.lower())
bx.plot(s[post, 6], USD_PT * s[post, 0], color=COLOR[o], lw=1.6)
bx.plot(s[-1, 6], USD_PT * s[-1, 0], "s", color=COLOR[o], ms=3.5)
bx.plot(X0[6], 620, "o", color="#1F4E79", ms=6, zorder=5)
pk = state_at("Digital", T_PEAK)[0]
bx.plot(pk[6], USD_PT * pk[0], "o", color="#5E35B1", ms=4, zorder=5)
bx.annotate(f"risk peak, month 11: {RISK_PEAK:.1f},\n{RISK_CEILING - RISK_PEAK:.1f} under the ceiling", (pk[6], USD_PT * pk[0]),
xytext=(74.2, 410), textcoords="data", ha="right", va="top", fontsize=7, color="#5E35B1",
arrowprops=dict(arrowstyle="-", color="#5E35B1", lw=0.6))
lw_ = state_at("Digital", T_LOW)[0]
bx.plot(lw_[6], LOW_USD, "v", color="#5E35B1", ms=5, zorder=5)
bx.text(RISK_CEILING + 0.4, 840, "risk\nceiling 75", fontsize=7, color="#B71C1C", va="top")
bx.set(xlim=(40, 80), ylim=(300, 850), xlabel="strategic risk (index, 0-100)", ylabel="liquidity ($ million)")
bx.set_title("A projection Figure 5.4 does not show", fontsize=9)
bx.legend(frameon=False, fontsize=7, loc="lower left")
for z in (ax, bx):
z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8)
fig.suptitle("No wall binds today; the digital path nears the floor and the risk ceiling (seed 26105)", fontsize=10)
plt.tight_layout(); plt.show()wall (Table 5.4) type today digital low tightest along each five-year path (month)
(month 20.6) digital restructuring turnaround
liquidity at least zero physical 620.00 481.92 481.95 (m21) 620.00 (m0) 620.00 (m0)
board floor, $350 million policy 270.00 131.92 131.95 (m21) 270.00 (m0) 270.00 (m0)
covenant, leverage <= 4.5 contractual 1.10 1.10 held held held
risk ceiling, risk <= 75 policy 11.00 4.42 1.45 (m11) 11.00 (m0) 8.67 (m60)
indices between 0 and 100 definitional 29.00 29.42 24.37 (m60) 26.32 (m60) 21.40 (m60)
shares between 0 and 1 definitional 0.19 0.19 held held held
binding set today: empty; at the digital low point: empty
today: 1.1 turns of covenant headroom; $270 million ($0.27 billion) above the floor
digital low point: index 77.73 at 1.715 years (month 20.6; month 21 on the monthly grid) = $481.9 million ($0.48 billion), $131.9 million above the floor
the highest floor the digital program can meet is its low point, $481.9 million; above it the program is infeasible
digital strategic risk peaks at 73.55 at month 10.9 (month 11 on the monthly grid), 1.45 points under the ceiling
walls added one at a time in Figure 5.4's projection (leverage, liquidity): are today and the low point inside?
definitional and physical: liquidity >= 0 today inside; low point inside
+ the covenant: leverage <= 4.5 today inside; low point inside
+ the board floor: liquidity >= $350 million today inside; low point inside
the walls the digital path comes closest to, in common units (Chapter 3's scale; the reading's error)
board floor slack 131.92 at month 20.6: 0.213 on Chapter 3's scale, 21.28 reading errors
covenant slack 1.10 at month 20.6: 0.324 on Chapter 3's scale, 16.18 reading errors
risk ceiling slack 1.45 at month 10.9: 0.014 on Chapter 3's scale, 0.24 reading errors

In Figure 5.4's projection — leverage and liquidity — the floor is the wall the digital program approaches most closely (Section 5.7). The probe reads every wall of Table 5.4, and one that the projection cannot show comes closer still: strategic risk peaks at 73.6 in month 11, 1.4 points under the ceiling of 75 and inside the risk committee's reading error — the margin Chapter 1 reports (Table 1.5) and Worked Example 16.1 flags as thinner than its reading. A projection is exact for what it shows and silent about the rest (Section 5.8); the note to the CFO should name both walls. The restructuring and the turnaround never come closer to the floor than today: their liquidity only rises.
Panel 3 — A wall that is not convex, and walls that keep their boundary (Theorem 5.2(iii); Figure 5.1; Theorem 5.5)
AXIOM Lab 1.5, step 2, continued. Not every wall is convex. Two platforms share a capacity budget of 100 units: configuration A runs the legacy platform at 80 and the new one at 10; configuration B shuts legacy down and runs the new platform at 90 (Figure 5.1). Under the budget alone, a convex wall, every blend of A and B is feasible (Theorem 5.2(iii)). Add a minimum efficient scale — run legacy at 60 or more, or not at all — and both pure configurations remain viable while the 50/50 blend, legacy 40 and new 50, does not: (Appendix 5.A). Then Theorem 5.5: walls written with weak inequalities keep the states where companies actually operate. Written strictly, the covenant admits leverage of for every but not its limit, so the most levered feasible state does not exist.
Python Code
A_CFG, B_CFG = np.array([80.0, 10.0]), np.array([0.0, 90.0]) # (legacy, new) volumes, Figure 5.1
BUDGET, MIN_SCALE = 100.0, 60.0
def admissible(c, scale=False):
c = np.atleast_2d(c)
ok = (c >= 0).all(1) & (c.sum(1) <= BUDGET + 1e-12) # the capacity budget: a convex wall
if scale:
ok &= np.minimum(c[:, 0], MIN_SCALE - c[:, 0]) <= 1e-12 # minimum scale: legacy 0 or at least 60
return ok
w = np.round(np.linspace(0, 1, 21), 2) # weight on A, in steps of 0.05
blend = w[:, None] * A_CFG + (1 - w[:, None]) * B_CFG
MID = 0.5 * (A_CFG + B_CFG)
G_MID = float(min(MID[0], MIN_SCALE - MID[0]))
ok_b, ok_s = admissible(blend), admissible(blend, scale=True)
print(f"A = (legacy {A_CFG[0]:.0f}, new {A_CFG[1]:.0f}), B = (legacy {B_CFG[0]:.0f}, new {B_CFG[1]:.0f}); budget {BUDGET:.0f}; "
f"minimum scale {MIN_SCALE:.0f}")
print(f"the 50/50 blend: legacy {MID[0]:.0f}, new {MID[1]:.0f}; budget slack {BUDGET - MID.sum():.0f}; "
f"minimum-scale g = min({MID[0]:.0f}, {MIN_SCALE - MID[0]:.0f}) = {G_MID:.0f} > 0: infeasible")
print(f"blends feasible on a grid of 21 weights: {ok_b.sum()} under the budget alone, {ok_s.sum()} with the minimum scale "
f"(weight 0 on A, or at least {w[ok_s & (w > 0)].min():.2f}: legacy 80w must be 0 or at least 60)")
k = np.arange(1, 7)
lev = COVENANT - 1.0 / k
print(f"\nTheorem 5.5: leverage 4.5 - 1/k for k = 1..6: {np.round(lev, 3)} -> 4.5")
print(f" weak covenant, x2 <= 4.5: every term feasible ({bool(np.all(lev <= COVENANT))}), the limit feasible ({COVENANT <= COVENANT})")
print(f" strict covenant, x2 < 4.5: every term feasible ({bool(np.all(lev < COVENANT))}), the limit feasible ({COVENANT < COVENANT})")
print(" under the strict form no feasible state is most levered; under the weak form it is 4.5, the covenant binding")A = (legacy 80, new 10), B = (legacy 0, new 90); budget 100; minimum scale 60 the 50/50 blend: legacy 40, new 50; budget slack 10; minimum-scale g = min(40, 20) = 20 > 0: infeasible blends feasible on a grid of 21 weights: 21 under the budget alone, 7 with the minimum scale (weight 0 on A, or at least 0.75: legacy 80w must be 0 or at least 60) Theorem 5.5: leverage 4.5 - 1/k for k = 1..6: [3.5 4. 4.167 4.25 4.3 4.333] -> 4.5 weak covenant, x2 <= 4.5: every term feasible (True), the limit feasible (True) strict covenant, x2 < 4.5: every term feasible (True), the limit feasible (False) under the strict form no feasible state is most levered; under the weak form it is 4.5, the covenant binding
Panel 4 — Sample a path (Definition 5.6; Propositions 5.3–5.4; Theorem 5.3; Figure 5.2)
AXIOM Lab 1.5, step 3. In the trajectory sampler, run the digital program in continuous time. Chapter 1's liquidity path solves a linear differential equation in three numbers: liquidity itself and two that carry the program's progress through its trough (the trough term is the response of a two-stage lag). Take quarterly readings, which are all a management report ever shows, and join the two phases, the platform build (years 0–2) and the scale-up (years 2–5): they join because the scale-up starts exactly where the build ends, at a liquidity index of 78 (Proposition 5.3(ii)). Then check sampling: a half-yearly reading is two quarterly steps, (Proposition 5.3(iii)), and the quarterly step can be undone (Proposition 5.4). The path exists and is unique because the right-hand side is Lipschitz (Theorem 5.3); Online Appendix 5.B.1–5.B.2 shows the two ways a model can lose that guarantee.
Python Code
def flow_system(option="Digital", key="x1"):
# Equation 1.B.1 as a system in s = (x, z1, z2): z2 is the trough term D (t/tau) e^(1 - t/tau), z1 = (D e/tau) e^(-t/tau)
# drives it, and x - z2 relaxes toward the target: ds/dt = M (s - s*), with s* = (target, 0, 0)
target, k, depth, tau, _ = MODEL[option][key]
M = np.array([[-k, 1.0, k - 1.0 / tau], [0.0, -1.0 / tau, 0.0], [0.0, 1.0, -1.0 / tau]])
return M, np.array([X0[MOVING[key]], depth * np.e / tau, 0.0]), np.array([float(target), 0.0, 0.0])
M, S0, S_STAR = flow_system()
def flow(s, dt):
# the flow map: the evolution over a spacing dt, exact for this linear system
return S_STAR + expm(M * dt) @ (np.asarray(s, float) - S_STAR)
ode = solve_ivp(lambda t, s: M @ (s - S_STAR), (0.0, 5.0), S0, dense_output=True, rtol=1e-12, atol=1e-12)
tt = np.linspace(0, 5, 501)
ERR_ODE = float(np.abs(ode.sol(tt)[0] - reading("Digital", "x1", tt)).max())
Q = [S0]
for _ in range(20):
Q.append(flow(Q[-1], 0.25)) # twenty quarterly steps
Q = np.array(Q)
H = [S0]
for _ in range(10):
H.append(flow(H[-1], 0.5)) # ten half-yearly steps
H = np.array(H)
ERR_Q = float(np.abs(Q[:, 0] - reading("Digital", "x1", np.arange(21) / 4)).max())
ERR_H = float(np.abs(H - Q[::2]).max())
BUILD = Q[:9] # phase 1, the platform build: quarters 0-8
SCALE_UP = [BUILD[-1]] # phase 2, the scale-up, starts where the build ends
for _ in range(12):
SCALE_UP.append(flow(SCALE_UP[-1], 0.25))
JOINED = np.vstack([BUILD, np.array(SCALE_UP)[1:]])
ERR_JOIN = float(np.abs(JOINED - Q).max())
back = Q[-1]
for _ in range(20):
back = flow(back, -0.25) # the quarterly step, undone
ERR_BACK = float(np.abs(back - S0).max())
JOIN = float(Q[8, 0])
print(f"continuous time: the system, solved numerically, reproduces Chapter 1's path to {ERR_ODE:.1e}")
print("quarterly readings (index): " + ", ".join(f"{v:.1f}" for v in Q[:, 0]))
print(f" twenty quarterly steps reproduce the closed form at every quarter to {ERR_Q:.1e}")
print(f"half-yearly readings against two quarterly steps: largest difference {ERR_H:.1e} (Proposition 5.3(iii))")
print(f"the phases join at year 2 at a liquidity index of {JOIN:.2f}; build + scale-up equals the whole path to {ERR_JOIN:.1e}")
print(f"twenty quarterly steps backward from year 5 return to today's {back[0]:.6f} (Proposition 5.4)")
print(f"the low point: index {LOW_PT:.2f} at {T_LOW:.2f} years (about month {12 * T_LOW:.0f}) = ${LOW_USD:.0f} million")
# a reading is not the state: liquidity shows the junction's value twice, once falling and once rising
T_TWIN = float(brentq(lambda t: float(reading("Digital", "x1", t)) - JOIN, 0.5, T_LOW))
s_twin = ode.sol(T_TWIN)
rate = lambda s: float((M @ (s - S_STAR))[0])
print(f"the reading {JOIN:.2f} appears at {T_TWIN:.2f} years ({rate(s_twin):+.1f} a year) and at 2.00 years ({rate(Q[8]):+.1f} a year): "
f"the trough's memory (z1, z2) = ({s_twin[1]:.1f}, {s_twin[2]:.1f}) against ({Q[8, 1]:.1f}, {Q[8, 2]:.1f}) tells them apart")
# validity horizons: Theorem 5.3's guarantee is local (Online Appendix 5.B.1-5.B.2)
blow = solve_ivp(lambda t, x: x ** 2, (0.0, 2.0), [1.0], rtol=1e-10, atol=1e-12, events=lambda t, x: x[0] - 1e6)
print(f"\nx' = x^2 from x(0) = 1 is 1/(1 - t): the solver passes one million at t = {blow.t_events[0][0]:.6f}; "
f"the model says nothing beyond t = 1")
print("x' = sqrt|x| from x(0) = 0: x = 0 solves it, and so does x = (t - c)^2/4 after any c >= 0, since its slope (t - c)/2 "
"equals sqrt(x); at t = 3, c = 0, 1, 2 give " + ", ".join(f"{0.25 * (3 - c) ** 2:.2f}" for c in (0, 1, 2)))
fig, ax = plt.subplots(figsize=(7.6, 3.6))
xx = reading("Digital", "x1", tt)
ax.plot(tt[tt <= 2], xx[tt <= 2], color="#5E35B1", lw=2, label="phase 1: platform build, years 0-2")
ax.plot(tt[tt >= 2], xx[tt >= 2], color="#1F4E79", lw=2, label="phase 2: scale-up, years 2-5")
ax.plot(np.arange(21) / 4, Q[:, 0], "o", color="#212121", ms=3.2, label="quarterly readings")
ax.plot(np.arange(11) / 2, H[:, 0], "s", mfc="none", mec="#E65100", ms=8, mew=1.1, label="half-yearly = two quarterly steps")
ax.plot(2.0, JOIN, "s", color="#E65100", ms=6, zorder=5)
ax.annotate(f"the phases join at year 2: {JOIN:.1f}", (2.0, JOIN), xytext=(1.0, 86.5), textcoords="data", fontsize=8,
color="#E65100", arrowprops=dict(arrowstyle="-", color="#E65100", lw=0.6))
ax.annotate(f"low point {LOW_PT:.1f}, month {12 * T_LOW:.0f}: ${LOW_USD:.0f} million", (T_LOW, LOW_PT), xytext=(-30, -18),
textcoords="offset points", fontsize=8, color="#5E35B1")
ax.set(xlabel="years", ylabel="liquidity (index, today = 100)", xlim=(0, 5), ylim=(73, 104),
title="Quarterly readings of one path; the phases join at year 2 (seed 26105)")
ax.legend(frameon=False, fontsize=7.5, loc="upper center", ncol=2); plt.tight_layout(); plt.show()continuous time: the system, solved numerically, reproduces Chapter 1's path to 7.5e-12 quarterly readings (index): 100.0, 92.6, 87.1, 83.2, 80.5, 78.8, 77.9, 77.7, 78.0, 78.7, 79.7, 81.0, 82.3, 83.8, 85.3, 86.9, 88.4, 90.0, 91.5, 92.9, 94.3 twenty quarterly steps reproduce the closed form at every quarter to 2.8e-14 half-yearly readings against two quarterly steps: largest difference 2.1e-14 (Proposition 5.3(iii)) the phases join at year 2 at a liquidity index of 78.04; build + scale-up equals the whole path to 0.0e+00 twenty quarterly steps backward from year 5 return to today's 100.000000 (Proposition 5.4) the low point: index 77.73 at 1.71 years (about month 21) = $482 million the reading 78.04 appears at 1.45 years (-2.5 a year) and at 2.00 years (+2.1 a year): the trough's memory (z1, z2) = (-18.4, -26.7) against (-14.0, -28.0) tells them apart x' = x^2 from x(0) = 1 is 1/(1 - t): the solver passes one million at t = 0.999999; the model says nothing beyond t = 1 x' = sqrt|x| from x(0) = 0: x = 0 solves it, and so does x = (t - c)^2/4 after any c >= 0, since its slope (t - c)/2 equals sqrt(x); at t = 3, c = 0, 1, 2 give 2.25, 1.00, 0.25

Panel 5 — Write the annual step; check for a contraction (Worked Example 5.1, Steps 1–2; Theorem 5.4(i))
AXIOM Lab 1.5, step 4, in the equilibrium bench. Run indefinitely, the turnaround closes a fixed share of each reading's gap to its target every year: about 36 percent for liquidity, 18 for technology, 45 for efficiency and 26 for strategic risk, toward 106, 33, 79 and 67. Next year's gap is this year's times a factor, 0.638, 0.819, 0.549 and 0.741 (Step 1), and from today's (100, 41, 71, 64) year 1 is (102.2, 39.5, 74.6, 64.8). The annual step is Chapter 1's continuous model sampled once a year, its flow map (Proposition 5.4). For any two starting states the gaps between them are multiplied by the same factors, so the largest gap shrinks by at least , set by technology, the slowest reading (Step 2): the map is a contraction, and Theorem 5.4(i) gives exactly one steady state, the targets, reached from any starting point.
Python Code
KEYS = list(MOVING)
NAMES4 = ["liquidity (index)", "technology", "efficiency", "strategic risk"]
TARGET = np.array([MODEL["Turnaround"][k][0] for k in KEYS], float) # 106, 33, 79, 67
SPEED = np.array([MODEL["Turnaround"][k][1] for k in KEYS]) # a year
FACTOR = np.exp(-SPEED) # next year's gap / this year's
x0 = X0[list(MOVING.values())]
def step(x):
# Worked Example 5.1, Step 1: the annual step, reading by reading, x_{k+1} = x* + a (x_k - x*)
return TARGET + FACTOR * (np.asarray(x, float) - TARGET)
x1 = step(x0)
print("gap closed each year: " + ", ".join(f"{n} {100 * (1 - a):.1f}%" for n, a in zip(NAMES4, FACTOR)))
print("factors a: " + ", ".join(f"{a:.3f}" for a in FACTOR) + "; targets: " + ", ".join(f"{v:.0f}" for v in TARGET))
print("today: " + ", ".join(f"{v:.1f}" for v in x0) + " -> year 1: " + ", ".join(f"{v:.1f}" for v in x1))
annual = [x0]
for _ in range(5):
annual.append(step(annual[-1]))
cont = np.array([[reading("Turnaround", k, t) for k in KEYS] for t in range(6)])
print(f"the annual step is Chapter 1's continuous model sampled once a year: agreement over five years to {np.abs(np.array(annual) - cont).max():.1e}")
L = float(FACTOR.max()); SLOWEST = NAMES4[int(FACTOR.argmax())]
rng = np.random.default_rng(SEED) # the lab's seed: random pairs of states
BOX_LO, BOX_HI = np.array([0.0, 0, 0, 0]), np.array([200.0, 100, 100, 100]) # a bench box: liquidity 0-200, indices 0-100
P1, P2 = rng.uniform(BOX_LO, BOX_HI, (100_000, 4)), rng.uniform(BOX_LO, BOX_HI, (100_000, 4))
RATIO = np.abs(step(P1) - step(P2)).max(1) / np.abs(P1 - P2).max(1)
print(f"\ncontraction constant L = {L:.4f}, set by {SLOWEST}, the slowest reading")
print(f"100,000 random pairs of states (lab seed {SEED}): the largest gap between two companies shrinks a year by a factor "
f"of at most {RATIO.max():.4f} <= L")
FIXED = float(np.abs(step(TARGET) - TARGET).max())
sol = np.linalg.solve(np.eye(4) - np.diag(FACTOR), (1 - FACTOR) * TARGET)
print(f"the steady state: the map leaves the targets where they are (moved by {FIXED:.1f}); solving x = f(x) gives "
f"({', '.join(f'{v:.2f}' for v in sol)}): exactly one, as Theorem 5.4(i) promises")gap closed each year: liquidity (index) 36.2%, technology 18.1%, efficiency 45.1%, strategic risk 25.9% factors a: 0.638, 0.819, 0.549, 0.741; targets: 106, 33, 79, 67 today: 100.0, 41.0, 71.0, 64.0 -> year 1: 102.2, 39.5, 74.6, 64.8 the annual step is Chapter 1's continuous model sampled once a year: agreement over five years to 1.4e-14 contraction constant L = 0.8187, set by technology, the slowest reading 100,000 random pairs of states (lab seed 26105): the largest gap between two companies shrinks a year by a factor of at most 0.8187 <= L the steady state: the map leaves the targets where they are (moved by 0.0); solving x = f(x) gives (106.00, 33.00, 79.00, 67.00): exactly one, as Theorem 5.4(i) promises
Panel 6 — Budget the convergence on day one; compare with the actual path (Worked Example 5.1, Steps 3–4; Equation 5.1; Table 5.5)
AXIOM Lab 1.5, step 4, with the day-one bound overlaid. The largest first-year move is 3.61 points (efficiency, from 71.0 to 74.6). By Equation 5.1 the largest remaining gap after years is at most , which falls below one point by year 15 (Step 3): a guarantee available on day one, from one year of data. The actual path (Table 5.5) gets there by year 11: the largest gap falls from 8.0 today to 2.9 in year 5 and 0.9 in year 11, comfortably inside the bound (Step 4), which is conservative because it assumes the worst case at every step. Then run the map from two other starting states — here the Year-5 states of the digital program and of the restructuring (Figure 5.5) — and from a thousand more drawn with the lab's seed: every one converges to the same steady state, inside its own day-one bound. From the digital Year-5 state the bound is attained: technology makes the largest first move and is also the slowest reading, so the worst case the bound assumes is the case that occurs.
Python Code
STEP1 = float(np.abs(x1 - x0).max()); J1 = int(np.abs(x1 - x0).argmax())
C_BOUND = STEP1 / (1 - L)
YEARS = np.arange(41)
PATH = np.array([TARGET + FACTOR ** k * (x0 - TARGET) for k in YEARS])
GAP = np.abs(PATH - TARGET).max(1)
BOUND = C_BOUND * L ** YEARS
K_BOUND, K_ACT = int(np.argmax(BOUND < 1)), int(np.argmax(GAP < 1))
SCORE = score(*PATH.T); SCORE_SS = float(score(*TARGET))
print(f"Step 3: the largest first-year move is {STEP1:.2f} points ({NAMES4[J1]}, {x0[J1]:.1f} -> {x1[J1]:.1f})")
print(f" Equation 5.1: largest gap after k years <= {STEP1:.2f} x {L:.3f}^k / (1 - {L:.3f}) = {C_BOUND:.1f} x {L:.3f}^k, "
f"below one point by year {K_BOUND}")
print(f"Step 4: the actual largest gap is below one point by year {K_ACT}; inside the bound every year: {bool(np.all(GAP <= BOUND))}")
COLS = [0, 1, 3, 5, 11]
print("\nTable 5.5 -- Meridian under the turnaround, by year")
print(f"{'year':29s}" + "".join(f"{k:>8d}" for k in COLS) + f"{'steady state':>14s}")
for i, n in enumerate(["Liquidity (index)", "Technology", "Efficiency", "Strategic risk"]):
print(f"{n:29s}" + "".join(f"{PATH[k, i]:8.1f}" for k in COLS) + f"{TARGET[i]:14.0f}")
print(f"{'Largest gap to steady state':29s}" + "".join(f"{GAP[k]:8.1f}" for k in COLS) + f"{0:14.0f}")
print(f"{'Day-one bound':29s}" + "".join(f"{BOUND[k]:8.1f}" for k in COLS) + f"{0:14.0f}")
print(f"{'Scorecard':29s}" + "".join(f"{SCORE[k]:8.1f}" for k in COLS) + f"{SCORE_SS:14.1f}")
STARTS = {"today": x0, "digital, Year 5": Y5["Digital"][list(MOVING.values())],
"restructuring, Year 5": Y5["Restructuring"][list(MOVING.values())]}
RUNS = {}
print("\nthe same map from three starting states (liquidity, technology, efficiency, strategic risk)")
for name, s in STARTS.items():
g = np.array([np.abs(FACTOR ** k * (s - TARGET)).max() for k in YEARS])
first = float(np.abs(step(s) - s).max())
b = first / (1 - L) * L ** YEARS
RUNS[name] = {"gap": g, "bound": b, "kb": int(np.argmax(b < 1)), "ka": int(np.argmax(g < 1)), "c": first / (1 - L)}
print(f" {name:22s} ({', '.join(f'{v:.1f}' for v in s)}): bound {first / (1 - L):5.1f} x {L:.3f}^k; below one point: "
f"bound by year {RUNS[name]['kb']}, actual by year {RUNS[name]['ka']}; inside the bound: {bool(np.all(g <= b + 1e-9))}")
rng = np.random.default_rng(SEED)
MANY = rng.uniform(BOX_LO, BOX_HI, (1000, 4)) # a thousand starts, the lab's seed
first = np.abs(step(MANY) - MANY).max(1)
GK = np.array([np.abs(FACTOR ** k * (MANY - TARGET)).max(1) for k in YEARS])
BK = np.array([first / (1 - L) * L ** k for k in YEARS])
END = np.abs(np.array([FACTOR ** 200 * (m - TARGET) for m in MANY])).max()
print(f"1,000 random starting states (lab seed {SEED}): after 200 years all within {END:.0e} of the same steady state; "
f"the largest gap never exceeds its day-one bound (largest ratio {float((GK / BK).max()):.3f})")Step 3: the largest first-year move is 3.61 points (efficiency, 71.0 -> 74.6) Equation 5.1: largest gap after k years <= 3.61 x 0.819^k / (1 - 0.819) = 19.9 x 0.819^k, below one point by year 15 Step 4: the actual largest gap is below one point by year 11; inside the bound every year: True Table 5.5 -- Meridian under the turnaround, by year year 0 1 3 5 11 steady state Liquidity (index) 100.0 102.2 104.4 105.4 106.0 106 Technology 41.0 39.5 37.4 35.9 33.9 33 Efficiency 71.0 74.6 77.7 78.6 79.0 79 Strategic risk 64.0 64.8 65.8 66.3 66.9 67 Largest gap to steady state 8.0 6.5 4.4 2.9 0.9 0 Day-one bound 19.9 16.3 10.9 7.3 2.2 0 Scorecard 37.0 37.9 38.4 38.4 38.0 37.8 the same map from three starting states (liquidity, technology, efficiency, strategic risk) today (100.0, 41.0, 71.0, 64.0): bound 19.9 x 0.819^k; below one point: bound by year 15, actual by year 11; inside the bound: True digital, Year 5 (94.3, 75.6, 73.6, 55.2): bound 42.6 x 0.819^k; below one point: bound by year 19, actual by year 19; inside the bound: True restructuring, Year 5 (121.1, 38.9, 73.7, 49.4): bound 30.2 x 0.819^k; below one point: bound by year 18, actual by year 10; inside the bound: True 1,000 random starting states (lab seed 26105): after 200 years all within 3e-16 of the same steady state; the largest gap never exceeds its day-one bound (largest ratio 1.000)
Panel 7 — Read the destination (Worked Example 5.1, Step 5; Table 5.5)
The steady state has stronger liquidity and efficiency than today but a weaker technology platform (33 against 41) and higher strategic risk (67 against 64). Chapter 1's scorecard, , tells the story over time: it rises from 37.0 to about 38.4 by year 3, holds there through year 5, and then slides toward 37.8 as the eroding platform outweighs the early efficiency gains. The turnaround is stable: it settles, reliably and on a computable schedule, in about a decade. But stability is not success: the digital program reaches a technology index of 75.6 by year 5 (Table 1.9).
Python Code
print("Step 5 -- the scorecard by year, (liquidity + technology + efficiency - strategic risk)/4")
print(" year " + "".join(f"{k:7d}" for k in range(16)) + " steady state")
print(" score " + "".join(f"{SCORE[k]:7.2f}" for k in range(16)) + f" {SCORE_SS:.2f}")
K_PEAK = int(SCORE[:16].argmax())
print(f"it rises from {SCORE[0]:.1f} to {SCORE[3]:.2f} in year 3, peaks at {SCORE[K_PEAK]:.2f} in year {K_PEAK}, is {SCORE[5]:.2f} "
f"in year 5 and {SCORE[11]:.2f} in year 11, and slides toward {SCORE_SS:.2f}")
print("\nthe destination against today, reading by reading, and its effect on the score")
for i, n in enumerate(NAMES4):
w_i = -0.25 if i == 3 else 0.25
print(f" {n:18s} today {x0[i]:6.1f} steady state {TARGET[i]:6.1f} change {TARGET[i] - x0[i]:+5.1f} "
f"score {w_i * (TARGET[i] - x0[i]):+5.2f}")
print(f" {'scorecard':18s} today {SCORE[0]:6.2f} steady state {SCORE_SS:6.2f}")
print(f"\nthe digital program's technology index in Year 5: {Y5['Digital'][3]:.1f} (Table 1.9); the turnaround settles at "
f"{TARGET[1]:.0f}, below today's {x0[1]:.0f}")
print(f"within one point of the steady state by year {K_ACT}, guaranteed by year {K_BOUND}: it settles in about a decade")Step 5 -- the scorecard by year, (liquidity + technology + efficiency - strategic risk)/4 year 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 steady state score 37.00 37.89 38.29 38.43 38.45 38.40 38.32 38.24 38.16 38.10 38.04 37.99 37.94 37.91 37.88 37.86 37.75 it rises from 37.0 to 38.43 in year 3, peaks at 38.45 in year 4, is 38.40 in year 5 and 37.99 in year 11, and slides toward 37.75 the destination against today, reading by reading, and its effect on the score liquidity (index) today 100.0 steady state 106.0 change +6.0 score +1.50 technology today 41.0 steady state 33.0 change -8.0 score -2.00 efficiency today 71.0 steady state 79.0 change +8.0 score +2.00 strategic risk today 64.0 steady state 67.0 change +3.0 score -0.75 scorecard today 37.00 steady state 37.75 the digital program's technology index in Year 5: 75.6 (Table 1.9); the turnaround settles at 33, below today's 41 within one point of the steady state by year 11, guaranteed by year 15: it settles in about a decade
Panel 8 — Two more equilibrium worlds: growth and coexistence (Figure 5.3; Table 5.3; Online Appendix 5.B.4–5.B.7)
AXIOM Lab 1.5, step 4, second part: run the start-up map and watch it leave zero for the market wall. The start-up of Figure 5.3 (right) follows with a quarterly step , and , from (Online Appendix 5.B.7). Its equilibria are 0 and 100. Near zero the user base grows by a factor of 1.225 a quarter, 22.5 percent, so zero is unstable; the slope at the wall is 0.775, so the wall attracts. The map is not a contraction on ; on it is, with slope at most 0.955, and the path passes 60 in year 5.25 (58.1 at year 5, 99.5 at year 10): there the expanding regime hands over to a contracting one. Two Online Appendix examples complete the picture of Table 5.3: three equilibria with an unstable middle, the strategist's "stuck in the middle" (5.B.6), and a coupled contraction whose row-sum rule still delivers a convergence budget, with the a posteriori bound for monitoring (5.B.4–5.B.5).
Python Code
R_G, KAPPA, DT, U0 = 0.9, 100.0, 0.25, 2.0 # Online Appendix 5.B.7 (the course notebook's start-up)
grow = lambda x: x + DT * R_G * x * (1 - x / KAPPA)
dgrow = lambda x: 1 + DT * R_G * (1 - 2 * np.asarray(x, float) / KAPPA)
U = [U0]
for _ in range(48):
U.append(grow(U[-1])) # 48 quarters: twelve years
U = np.array(U); TQ = np.arange(49) * DT
Q60 = int(np.argmax(U > 60))
XS = np.linspace(60, 100, 40001)
print(f"start-up: equilibria 0 and {KAPPA:.0f}; f'(0) = {dgrow(0):.3f} ({100 * (dgrow(0) - 1):.1f} percent a quarter when small), "
f"f'({KAPPA:.0f}) = {dgrow(KAPPA):.3f}")
print(f" user base {U[20]:.1f} at year 5 and {U[40]:.1f} at year 10; it first passes 60 in year {TQ[Q60]:.2f}")
print(f" on [60, 100]: f(60) = {grow(60.0):.1f}, f maps it into [{grow(XS).min():.1f}, {grow(XS).max():.1f}], slope at most "
f"{np.abs(dgrow(XS)).max():.3f}: a contraction there, though not on [0, 100]")
f_mid = lambda x: 3 * x ** 2 - 2 * x ** 3 # Online Appendix 5.B.6: stuck in the middle
ROOTS = np.sort(np.roots([-2.0, 3.0, -1.0, 0.0]).real) # f(x) - x = -x (2x - 1)(x - 1)
print(f"\nstuck in the middle, f(x) = 3x^2 - 2x^3: equilibria {', '.join(f'{r:g}' for r in ROOTS)}; slopes "
+ ", ".join(f"{6 * r * (1 - r):g}" for r in ROOTS))
for s0 in (0.49, 0.51):
x = s0
for _ in range(10):
x = f_mid(x)
print(f" from {s0}: {x:.4f} after ten years -- history decides which pure position")
A2, B2 = np.array([[0.55, 0.20], [0.10, 0.60]]), np.array([28.0, 24.0]) # Online Appendix 5.B.4: a service operation
X_STAR2 = np.linalg.solve(np.eye(2) - A2, B2)
XH = [np.array([70.0, 60.0])]
for _ in range(30):
XH.append(A2 @ XH[-1] + B2)
XH = np.array(XH)
L2 = float(np.abs(A2).sum(1).max()); STEP2 = float(np.abs(XH[1] - XH[0]).max()); C2 = STEP2 / (1 - L2)
D2 = np.abs(XH - X_STAR2).max(1)
KB2, KA2 = int(np.argmax(C2 * L2 ** np.arange(31) <= 1)), int(np.argmax(D2 <= 1))
POST5 = L2 / (1 - L2) * float(np.abs(XH[5] - XH[4]).max())
print(f"\nservice operation: row sums {', '.join(f'{v:.2f}' for v in np.abs(A2).sum(1))} -> L = {L2:.2f}; "
f"x* = ({X_STAR2[0]:.0f}, {X_STAR2[1]:.0f}); x1 = ({XH[1, 0]:.1f}, {XH[1, 1]:.0f}); first step {STEP2:.1f}")
print(f" bound {C2:.0f} x {L2:.2f}^k: below one point from k = {KB2}; actual within one point by k = {KA2}")
print(f" at k = 5: actual {D2[5]:.1f}, a priori {C2 * L2 ** 5:.1f}, a posteriori {POST5:.1f} (Remark 5.B.5); "
f"eigenvalues of A {', '.join(f'{v:.2f}' for v in np.sort(np.linalg.eigvals(A2).real))}")
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6))
yy = np.arange(16)
for (name, run), col in zip(RUNS.items(), ("#1F4E79", "#5E35B1", "#2E7D32")):
tag = " (bound attained)" if np.allclose(run["gap"], run["bound"]) else ""
ax.semilogy(yy, run["gap"][:16], "o-", color=col, ms=2.8, lw=1.3, label=f"from {name}{tag}")
ax.semilogy(yy, run["bound"][:16], "--", color=col, lw=0.9)
ax.axhline(1.0, color="#999999", lw=0.7)
ax.text(0.2, 1.08, "within 1 point", fontsize=7, color="#616161", va="bottom")
ax.plot([], [], "--", color="#616161", lw=0.9, label="dashed: day-one bounds")
ax.set(xlabel="years", ylabel="largest gap to the steady state (log)", ylim=(0.2, 120), title="Turnaround: one steady state")
ax.legend(frameon=False, fontsize=6.5, loc="upper right")
bx.plot(TQ, U, color="#E65100", lw=1.8)
bx.axhline(0, color="#999999", lw=0.8, ls="--"); bx.axhline(KAPPA, color="#2E7D32", lw=0.8, ls="--")
bx.axhspan(60, KAPPA, color="#EEF3F9", lw=0, zorder=0)
bx.text(11.8, 4, "unstable equilibrium at zero", fontsize=7, color="#616161", ha="right", va="bottom")
bx.text(11.8, 101.5, "stable equilibrium: the market wall", fontsize=7, color="#2E7D32", ha="right", va="bottom")
bx.text(0.3, 62, "contraction above 60", fontsize=7, color="#1F4E79", va="bottom")
bx.set(xlim=(0, 12), ylim=(-5, 112), xlabel="years", ylabel="user base (index)", title="Start-up: growth to the wall")
for z in (ax, bx):
z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8); z.title.set_size(9)
fig.suptitle("A contraction settles; growth runs to the market wall (seed 26105)", fontsize=10)
plt.tight_layout(); plt.show()start-up: equilibria 0 and 100; f'(0) = 1.225 (22.5 percent a quarter when small), f'(100) = 0.775 user base 58.1 at year 5 and 99.5 at year 10; it first passes 60 in year 5.25 on [60, 100]: f(60) = 65.4, f maps it into [65.4, 100.0], slope at most 0.955: a contraction there, though not on [0, 100] stuck in the middle, f(x) = 3x^2 - 2x^3: equilibria 0, 0.5, 1; slopes 0, 1.5, 0 from 0.49: 0.0754 after ten years -- history decides which pure position from 0.51: 0.9246 after ten years -- history decides which pure position service operation: row sums 0.75, 0.70 -> L = 0.75; x* = (100, 85); x1 = (78.5, 67); first step 8.5 bound 34 x 0.75^k: below one point from k = 13; actual within one point by k = 11 at k = 5: actual 5.7, a priori 8.1, a posteriori 6.7 (Remark 5.B.5); eigenvalues of A 0.43, 0.72

Panel 9 — Compare profiles (Section 5.8; Definition 5.10; Figure 5.5; Online Appendix 5.B)
AXIOM Lab 1.5, step 5. In the profile theater, display today's state and the three Year-5 states in parallel coordinates, the readings scaled as in Chapter 3 (indices divided by 100, the other readings by today's value), with the distance readout alongside. The digital line departs from today's mainly on technology, restructuring's on liquidity and strategic risk, the turnaround's hardly at all. Profile proximity is not state proximity: measured with Chapter 3's scaling, the turnaround's Year-5 state lies 0.11 from today, restructuring's 0.26 and digital's 0.36, more than three times as far as the turnaround. And high dimension crowds volume toward the boundary: a ball inscribed in a cube fills 79 percent of it in two dimensions but 1.6 percent in eight, Meridian's dimension, and more than half of an eight-dimensional ball lies within 10 percent of its surface.
Python Code
LABELS = ["liquidity", "net leverage", "workforce", "technology", "efficiency", "ROIC", "strategic risk", "market share"]
SC = {"today": X0 / SCALE, **{o: Y5[o] / SCALE for o in OPTIONS}} # Chapter 3's scaling
DIST = {o: float(np.linalg.norm(SC[o] - SC["today"])) for o in OPTIONS}
DMAX = {o: float(np.abs(SC[o] - SC["today"]).max()) for o in OPTIONS}
print(f"{'scaled reading':16s}" + "".join(f"{h:>21s}" for h in ["today"] + [o.lower() + ", Year 5" for o in OPTIONS]))
for i, lab in enumerate(LABELS):
print(f"{lab:16s}" + "".join(f"{SC[k][i]:21.3f}" for k in ["today"] + OPTIONS))
print()
for o in OPTIONS:
d = SC[o] - SC["today"]
top = [j for j in np.argsort(-np.abs(d))[:2] if abs(d[j]) > 0.03]
print(f"{o.lower():14s} distance from today {DIST[o]:.3f} (its largest single move {DMAX[o]:.3f}); departs mainly on "
+ " and ".join(f"{LABELS[j]} ({d[j]:+.3f})" for j in top))
RATIO_DT = DIST["Digital"] / DIST["Turnaround"]
print(f"the digital program moves Meridian {RATIO_DT:.2f} times as far as the turnaround; the four readings Chapter 1's "
f"model holds lie on today's line")
def ball_cube(n):
# the volume of the unit ball over that of the cube [-1, 1]^n
return exp((n / 2) * log(pi) - n * log(2) - lgamma(n / 2 + 1))
print("\n n ball / cube share of the ball within 0.1 of its surface")
for n in (2, 3, 8, 32):
print(f"{n:4d} {ball_cube(n):11.4g} {1 - 0.9 ** n:.3f}")
rng = np.random.default_rng(SEED)
PTS = rng.uniform(-1.0, 1.0, (1_000_000, 8)) # a million points in the eight-dimensional cube, the lab's seed
RAD = np.linalg.norm(PTS, axis=1); IN = RAD <= 1
print(f"a million points in the 8-cube (lab seed {SEED}): {IN.mean():.4f} fall in the ball (exact {ball_cube(8):.4f}); "
f"of those, {(RAD[IN] > 0.9).mean():.3f} lie within 0.1 of its surface (exact {1 - 0.9 ** 8:.3f})")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
xs = np.arange(8)
for x in xs:
ax.axvline(x, color="#E0E0E0", lw=0.8, zorder=0)
ax.plot(xs, SC["today"], "o-", color="#1F4E79", lw=2, ms=4, label="today")
for o in OPTIONS:
ax.plot(xs, SC[o], "o--", color=COLOR[o], lw=1.3, ms=3.5, label=f"{o.lower()}, Year 5: distance {DIST[o]:.2f}")
ax.set_xticks(xs); ax.set_xticklabels([l.replace(" ", "\n") for l in LABELS], fontsize=8)
ax.set(ylabel="scaled reading (Chapter 3)", ylim=(0.25, 1.3), title="Profiles show every reading; the distance ranks the states (seed 26105)")
ax.legend(frameon=False, fontsize=7.5, loc="upper center", ncol=2); plt.tight_layout(); plt.show()scaled reading today digital, Year 5restructuring, Year 5 turnaround, Year 5 liquidity 1.000 0.943 1.211 1.054 net leverage 1.000 1.000 1.000 1.000 workforce 0.580 0.580 0.580 0.580 technology 0.410 0.756 0.389 0.359 efficiency 0.710 0.736 0.737 0.786 ROIC 1.000 1.000 1.000 1.000 strategic risk 0.640 0.552 0.494 0.663 market share 1.000 1.000 1.000 1.000 digital distance from today 0.363 (its largest single move 0.346); departs mainly on technology (+0.346) and strategic risk (-0.088) restructuring distance from today 0.259 (its largest single move 0.211); departs mainly on liquidity (+0.211) and strategic risk (-0.146) turnaround distance from today 0.108 (its largest single move 0.076); departs mainly on efficiency (+0.076) and liquidity (+0.054) the digital program moves Meridian 3.35 times as far as the turnaround; the four readings Chapter 1's model holds lie on today's line n ball / cube share of the ball within 0.1 of its surface 2 0.7854 0.190 3 0.5236 0.271 8 0.01585 0.570 32 1.002e-15 0.966 a million points in the 8-cube (lab seed 26105): 0.0159 fall in the ball (exact 0.0159); of those, 0.568 lie within 0.1 of its surface (exact 0.570)

Validation — the book's numbers, and agreement with DCT_V1_Ch05_Lab.xlsx
Each checkpoint is a number printed in Chapter 5 (Worked Example 5.1 and Table 5.5, Sections 5.4–5.8, Figures
5.1–5.5, Appendix 5.A) or in Online Appendix 5.B, except three that the book prints elsewhere for the same Chapter 1
model: the digital program's strategic-risk peak, 73.6 in month 11, 1.4 points under the ceiling (Table 1.5; Worked
Example 16.1). Money in $ million: the chapter's $0.27, $0.48 and $0.13 billion are checked as 270, 480 and 130 to
the nearest $5 million. The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against
the same engine values on its Checks sheet.
Python Code
checks = [
("readings in the declared state (workbook)", len(STATE), 8, 0),
("indices among the readings (workbook)", len(count["index"]), 4, 0),
("covenant headroom today, turns (workbook)", slack_today[2], 1.1, 0.05),
("slack above the floor today, $ million (workbook)", slack_today[1], 270, 5),
("walls binding today (workbook)", len(binding_today), 0, 0),
("digital liquidity low point, $ million (workbook)", LOW_USD, 480, 5),
("month of the digital low point (workbook)", M_LOW, 21, 0),
("floor slack at the low point, $ million (workbook)", LOW_USD - FLOOR_USD, 130, 5),
("digital strategic-risk peak (workbook)", RISK_PEAK, 73.6, 0.05),
("risk-ceiling margin at the peak (workbook)", RISK_CEILING - RISK_PEAK, 1.4, 0.05),
("month of the strategic-risk peak (workbook)", M_PEAK, 11, 0),
("minimum-scale g at the 50/50 blend (workbook)", G_MID, 20, 0),
("phases join at year 2, liquidity index (workbook)", JOIN, 78, 0.5),
("half-yearly reading less two quarterly steps (workbook)", ERR_H, 0, 1e-9),
("factor a year: liquidity (workbook)", FACTOR[0], 0.638, 5e-4),
("factor a year: technology (workbook)", FACTOR[1], 0.819, 5e-4),
("factor a year: efficiency (workbook)", FACTOR[2], 0.549, 5e-4),
("factor a year: strategic risk (workbook)", FACTOR[3], 0.741, 5e-4),
("gap closed a year: liquidity, % (workbook)", 100 * (1 - FACTOR[0]), 36, 0.5),
("gap closed a year: technology, % (workbook)", 100 * (1 - FACTOR[1]), 18, 0.5),
("gap closed a year: efficiency, % (workbook)", 100 * (1 - FACTOR[2]), 45, 0.5),
("gap closed a year: strategic risk, % (workbook)", 100 * (1 - FACTOR[3]), 26, 0.5),
("year 1: liquidity (workbook)", x1[0], 102.2, 0.05),
("year 1: technology (workbook)", x1[1], 39.5, 0.05),
("year 1: efficiency (workbook)", x1[2], 74.6, 0.05),
("year 1: strategic risk (workbook)", x1[3], 64.8, 0.05),
("contraction constant L (workbook)", L, 0.819, 5e-4),
("largest first-year move (workbook)", STEP1, 3.61, 5e-3),
("day-one bound coefficient (workbook)", C_BOUND, 19.9, 0.05),
("first year the bound is below one point (workbook)", K_BOUND, 15, 0),
("first year the gap is below one point (workbook)", K_ACT, 11, 0),
]
for k, vals in ((3, (104.4, 37.4, 77.7, 65.8)), (5, (105.4, 35.9, 78.6, 66.3)), (11, (106.0, 33.9, 79.0, 66.9))):
for i, n in enumerate(("liquidity", "technology", "efficiency", "strategic risk")):
checks.append((f"Table 5.5, year {k}: {n} (workbook)", PATH[k, i], vals[i], 0.05))
for k, g, b, s in zip(COLS, (8.0, 6.5, 4.4, 2.9, 0.9), (19.9, 16.3, 10.9, 7.3, 2.2), (37.0, 37.9, 38.4, 38.4, 38.0)):
checks += [(f"Table 5.5, year {k}: largest gap (workbook)", GAP[k], g, 0.05),
(f"Table 5.5, year {k}: day-one bound (workbook)", BOUND[k], b, 0.05),
(f"Table 5.5, year {k}: scorecard (workbook)", SCORE[k], s, 0.05)]
checks += [
("Table 5.5, steady state: scorecard (workbook)", SCORE_SS, 37.8, 0.05),
("digital technology in Year 5 (workbook)", Y5["Digital"][3], 75.6, 0.05),
("start-up growth factor near zero (workbook)", dgrow(0), 1.225, 5e-4),
("start-up slope at the market wall (workbook)", dgrow(KAPPA), 0.775, 5e-4),
("start-up user base, year 5 (workbook)", U[20], 58.1, 0.05),
("start-up user base, year 10 (workbook)", U[40], 99.5, 0.05),
("start-up first passes 60, year (workbook)", TQ[Q60], 5.25, 0),
("start-up f(60) (workbook)", grow(60.0), 65.4, 0.05),
("start-up slope at 60 (workbook)", dgrow(60.0), 0.955, 5e-4),
("stuck in the middle: equilibria", len(ROOTS), 3, 0),
("stuck in the middle: slope at 1/2 (workbook)", 6 * 0.5 * (1 - 0.5), 1.5, 0),
("service: L by the row-sum rule (workbook)", L2, 0.75, 1e-9),
("service: steady occupancy (workbook)", X_STAR2[0], 100, 1e-9),
("service: steady staffing (workbook)", X_STAR2[1], 85, 1e-9),
("service: first step (workbook)", STEP2, 8.5, 1e-9),
("service: bound coefficient (workbook)", C2, 34, 1e-9),
("service: bound below one from k (workbook)", KB2, 13, 0),
("service: actual within one by k (workbook)", KA2, 11, 0),
("service, k = 5: actual distance (workbook)", D2[5], 5.7, 0.05),
("service, k = 5: a priori bound (workbook)", C2 * L2 ** 5, 8.1, 0.05),
("service, k = 5: a posteriori bound (workbook)", POST5, 6.7, 0.05),
("distance to the turnaround's Year 5 (workbook)", DIST["Turnaround"], 0.11, 0.005),
("distance to the restructuring's Year 5 (workbook)", DIST["Restructuring"], 0.26, 0.005),
("distance to the digital Year 5 (workbook)", DIST["Digital"], 0.36, 0.005),
("digital more than three times as far (workbook)", float(RATIO_DT > 3), 1, 0),
("ball/cube volume, n = 2 (workbook)", ball_cube(2), 0.785, 5e-4),
("ball/cube volume, n = 3 (workbook)", ball_cube(3), 0.524, 5e-4),
("ball/cube volume, n = 8 (workbook)", ball_cube(8), 0.0159, 5e-5),
("ball/cube volume, n = 32, log10 (workbook)", log10(ball_cube(32)), -15, 0.5),
("share near the surface, n = 2 (workbook)", 1 - 0.9 ** 2, 0.19, 0.005),
("share near the surface, n = 3 (workbook)", 1 - 0.9 ** 3, 0.27, 0.005),
("share near the surface, n = 8 (workbook)", 1 - 0.9 ** 8, 0.57, 0.005),
("share near the surface, n = 32 (workbook)", 1 - 0.9 ** 32, 0.97, 0.005),
]
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} {got:10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")readings in the declared state (workbook) 8.0000 book 8.0000 PASS indices among the readings (workbook) 4.0000 book 4.0000 PASS covenant headroom today, turns (workbook) 1.1000 book 1.1000 PASS slack above the floor today, $ million (workbook) 270.0000 book 270.0000 PASS walls binding today (workbook) 0.0000 book 0.0000 PASS digital liquidity low point, $ million (workbook) 481.9179 book 480.0000 PASS month of the digital low point (workbook) 21.0000 book 21.0000 PASS floor slack at the low point, $ million (workbook) 131.9179 book 130.0000 PASS digital strategic-risk peak (workbook) 73.5525 book 73.6000 PASS risk-ceiling margin at the peak (workbook) 1.4475 book 1.4000 PASS month of the strategic-risk peak (workbook) 11.0000 book 11.0000 PASS minimum-scale g at the 50/50 blend (workbook) 20.0000 book 20.0000 PASS phases join at year 2, liquidity index (workbook) 78.0410 book 78.0000 PASS half-yearly reading less two quarterly steps (workbook) 0.0000 book 0.0000 PASS factor a year: liquidity (workbook) 0.6376 book 0.6380 PASS factor a year: technology (workbook) 0.8187 book 0.8190 PASS factor a year: efficiency (workbook) 0.5488 book 0.5490 PASS factor a year: strategic risk (workbook) 0.7408 book 0.7410 PASS gap closed a year: liquidity, % (workbook) 36.2372 book 36.0000 PASS gap closed a year: technology, % (workbook) 18.1269 book 18.0000 PASS gap closed a year: efficiency, % (workbook) 45.1188 book 45.0000 PASS gap closed a year: strategic risk, % (workbook) 25.9182 book 26.0000 PASS year 1: liquidity (workbook) 102.1742 book 102.2000 PASS year 1: technology (workbook) 39.5498 book 39.5000 PASS year 1: efficiency (workbook) 74.6095 book 74.6000 PASS year 1: strategic risk (workbook) 64.7775 book 64.8000 PASS contraction constant L (workbook) 0.8187 book 0.8190 PASS largest first-year move (workbook) 3.6095 book 3.6100 PASS day-one bound coefficient (workbook) 19.9124 book 19.9000 PASS first year the bound is below one point (workbook) 15.0000 book 15.0000 PASS first year the gap is below one point (workbook) 11.0000 book 11.0000 PASS Table 5.5, year 3: liquidity (workbook) 104.4446 book 104.4000 PASS Table 5.5, year 3: technology (workbook) 37.3905 book 37.4000 PASS Table 5.5, year 3: efficiency (workbook) 77.6776 book 77.7000 PASS Table 5.5, year 3: strategic risk (workbook) 65.7803 book 65.8000 PASS Table 5.5, year 5: liquidity (workbook) 105.3676 book 105.4000 PASS Table 5.5, year 5: technology (workbook) 35.9430 book 35.9000 PASS Table 5.5, year 5: efficiency (workbook) 78.6017 book 78.6000 PASS Table 5.5, year 5: strategic risk (workbook) 66.3306 book 66.3000 PASS Table 5.5, year 11: liquidity (workbook) 105.9575 book 106.0000 PASS Table 5.5, year 11: technology (workbook) 33.8864 book 33.9000 PASS Table 5.5, year 11: efficiency (workbook) 78.9891 book 79.0000 PASS Table 5.5, year 11: strategic risk (workbook) 66.8894 book 66.9000 PASS Table 5.5, year 0: largest gap (workbook) 8.0000 book 8.0000 PASS Table 5.5, year 0: day-one bound (workbook) 19.9124 book 19.9000 PASS Table 5.5, year 0: scorecard (workbook) 37.0000 book 37.0000 PASS Table 5.5, year 1: largest gap (workbook) 6.5498 book 6.5000 PASS Table 5.5, year 1: day-one bound (workbook) 16.3029 book 16.3000 PASS Table 5.5, year 1: scorecard (workbook) 37.8890 book 37.9000 PASS Table 5.5, year 3: largest gap (workbook) 4.3905 book 4.4000 PASS Table 5.5, year 3: day-one bound (workbook) 10.9282 book 10.9000 PASS Table 5.5, year 3: scorecard (workbook) 38.4331 book 38.4000 PASS Table 5.5, year 5: largest gap (workbook) 2.9430 book 2.9000 PASS Table 5.5, year 5: day-one bound (workbook) 7.3254 book 7.3000 PASS Table 5.5, year 5: scorecard (workbook) 38.3954 book 38.4000 PASS Table 5.5, year 11: largest gap (workbook) 0.8864 book 0.9000 PASS Table 5.5, year 11: day-one bound (workbook) 2.2064 book 2.2000 PASS Table 5.5, year 11: scorecard (workbook) 37.9859 book 38.0000 PASS Table 5.5, steady state: scorecard (workbook) 37.7500 book 37.8000 PASS digital technology in Year 5 (workbook) 75.6347 book 75.6000 PASS start-up growth factor near zero (workbook) 1.2250 book 1.2250 PASS start-up slope at the market wall (workbook) 0.7750 book 0.7750 PASS start-up user base, year 5 (workbook) 58.1286 book 58.1000 PASS start-up user base, year 10 (workbook) 99.4909 book 99.5000 PASS start-up first passes 60, year (workbook) 5.2500 book 5.2500 PASS start-up f(60) (workbook) 65.4000 book 65.4000 PASS start-up slope at 60 (workbook) 0.9550 book 0.9550 PASS stuck in the middle: equilibria 3.0000 book 3.0000 PASS stuck in the middle: slope at 1/2 (workbook) 1.5000 book 1.5000 PASS service: L by the row-sum rule (workbook) 0.7500 book 0.7500 PASS service: steady occupancy (workbook) 100.0000 book 100.0000 PASS service: steady staffing (workbook) 85.0000 book 85.0000 PASS service: first step (workbook) 8.5000 book 8.5000 PASS service: bound coefficient (workbook) 34.0000 book 34.0000 PASS service: bound below one from k (workbook) 13.0000 book 13.0000 PASS service: actual within one by k (workbook) 11.0000 book 11.0000 PASS service, k = 5: actual distance (workbook) 5.7132 book 5.7000 PASS service, k = 5: a priori bound (workbook) 8.0684 book 8.1000 PASS service, k = 5: a posteriori bound (workbook) 6.7197 book 6.7000 PASS distance to the turnaround's Year 5 (workbook) 0.1084 book 0.1100 PASS distance to the restructuring's Year 5 (workbook) 0.2590 book 0.2600 PASS distance to the digital Year 5 (workbook) 0.3628 book 0.3600 PASS digital more than three times as far (workbook) 1.0000 book 1.0000 PASS ball/cube volume, n = 2 (workbook) 0.7854 book 0.7850 PASS ball/cube volume, n = 3 (workbook) 0.5236 book 0.5240 PASS ball/cube volume, n = 8 (workbook) 0.0159 book 0.0159 PASS ball/cube volume, n = 32, log10 (workbook) -14.9992 book -15.0000 PASS share near the surface, n = 2 (workbook) 0.1900 book 0.1900 PASS share near the surface, n = 3 (workbook) 0.2710 book 0.2700 PASS share near the surface, n = 8 (workbook) 0.5695 book 0.5700 PASS share near the surface, n = 32 (workbook) 0.9657 book 0.9700 PASS 91 of 91 checkpoints PASS
Next. Chapter 6 gives the state its verb. A transformation operator is a declared action whose preconditions are its domain in this chapter's state space, so the walls built here become preconditions: an automation round costs $120 million, and it can be taken only with at least $470 million of liquidity, so that the board's $350 million floor still holds after it. AXIOM-05 runs the same model interactively (Lab 1.5); this notebook and the workbook are its reproducible record.


