DCT Laboratory — Volume I, Chapter 16
Synthesis, Future Directions, and Transition to Volume II
Seed 26116 · Companion to Chapter 16 and AXIOM Lab 1.16 (module AXIOM-16) · Mirrored in DCT_V1_Ch16_Lab.xlsx
This laboratory reproduces Worked Example 16.1, Is Meridian Ready to Optimize?, with the book's declarations, and works the five steps of AXIOM Lab 1.16, Certifying Meridian for Volume II: walk the framework and its ledgers, run the readiness chain (R1)–(R4) and watch the certificates issue, inject a drift into the feedback core and read what the gain audit voids, trace Theorem 16.4 to the results it rests on, and export the certified instance in the canonical form that Volume II consumes. The audit re-runs Worked Example 15.1's GEOP on Chapter 8's 100,000 paths, drawn as in the book with random seed 8 (Volume II, Online Appendix 1.B.4), so its odds and costs come out exactly as printed; the lab's seed 26116 is used only for fresh draws, labelled as such, and the certificate's fresh paths use seed 26209, shared with Lab 1.15 and the DCT Simulator's Certify station. Every Meridian number below is the book's (Worked Example 16.1, Tables 16.1 and 16.4, Figure 16.2, Theorems 16.2, 16.4 and 16.5, Online Appendix 16.B.1–16.B.3); the final cell checks them. Money is in $ million.
The declarations (Worked Example 16.1, the situation; Worked Examples 8.1 and 15.1; Tables 5.2 and 15.2)
The question. Meridian's board has approved the digital program with the risk package of Chapter 15, a $170 million standby line and a delay of two months, and is weighing the next step: an optimization platform for the whole transformation, and learning tools to monitor it. Before signing, the chair asks the transformation office for a readiness certificate: run the four gates of Theorem 16.4 on the declaration as it stood after Chapter 8 and as it stands now, and report what failed, what was repaired, at what cost, and what is still weak.
The program and its uncertainty are Worked Example 8.1's. Liquidity follows Chapter 1's digital-program path, read quarterly over the program's three years at $6.2 million an index point: it falls from $620 million to a trough of $482 million in quarter 7 against the board's floor of $350 million. Each quarter brings an execution and market deviation, with surprises of standard deviation $50 million; funding windows close about once a decade ( a year), each closure removing on average $120 million (standard deviation $50 million, gamma distributed) for the rest of the program.
The levers and the commitments are Worked Example 15.1's. The standby line , the CFO's lever, costs in fees over the program; a delay of quarters, the transformation office's, cuts the draw's depth to index points and costs $8 million a quarter. The board's appetite allows at most a 5 percent chance that liquidity falls below the floor in some quarter of the program; the covenant caps net leverage at 4.5× (EBITDA $495.6 million, net debt 3.4× of it); the digital build needs workforce capability of at least 55 (58 today); strategic risk must stay at or below 75.
The register is Chapter 14's. In the feedback core, Industrial Systems and Digital Solutions are each linked, both ways, to shared engineering and to treasury, and each link passes on at most 0.40 of a quarter's deviation; the board's rule is that any deviation must halve within a year. The readings' errors are Table 5.2's: net leverage ±2 percent, workforce capability ±5 points, strategic risk ±6 points.
Python Code
import json
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.optimize import brentq
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26116 # the lab's seed: fresh draws only, labelled as such
CERT_SEED = 26209 # fresh paths for the certificate, shared with Lab 1.15 and the DCT Simulator
BOOK_SEED = 8 # Chapter 8's stream, reused by Worked Examples 15.1 and 16.1 (Volume II, Online Appendix 1.B.4)
# Chapter 1's model of the three options (Online Appendix 1.B.4): the liquidity index L (today 100, $6.2 million a
# point), technology T, efficiency E and strategic risk R relax toward targets; the digital program adds two troughs
# and a hump in strategic risk; the restructuring's sale closes at year 1
def relax(x0, target, k, t):
return target + (x0 - target) * np.exp(-k * t)
def hump(size, tau, t):
# size (t/tau) e^(1 - t/tau): zero today, largest (= size) at t = tau
return size * (t / tau) * np.exp(1 - t / tau)
def option(name, t):
t = np.asarray(t, dtype=float)
if name == "Digital":
return {"L": relax(100, 112, 0.35, t) - hump(28, 2.0, t), "T": relax(41, 78, 0.55, t),
"E": relax(71, 77, 0.50, t) - hump(9, 1.5, t), "R": relax(64, 51, 0.40, t) + hump(14, 1.2, t)}
if name == "Restructuring":
sold = (t >= 1.0).astype(float)
return {"L": relax(100, 104, 0.30, t) + 18 * sold, "T": relax(41, 38, 0.25, t),
"E": relax(71, 74, 0.45, t), "R": relax(64, 56, 0.35, t) - 8 * sold}
return {"L": relax(100, 106, 0.45, t), "T": relax(41, 33, 0.20, t), "E": relax(71, 79, 0.60, t),
"R": relax(64, 67, 0.30, t)}
OPTIONS = ("Digital", "Restructuring", "Turnaround")
# Worked Example 8.1: the digital program, quarterly for three years ($ million)
N, Q = 100_000, 12
LIQ0, FLOOR, POOL = 620.0, 350.0, 270.0 # liquidity today, the board's floor, the cash above it
A_E, SD_W = 0.6, 50.0 # execution and market deviation: E' = 0.6 E + w, sd(w) = 50
LAM, J_MEAN, J_SD = 0.10, 120.0, 50.0 # closures a year; their size: mean and sd (gamma)
# Worked Example 15.1: the levers, their declared prices, and the commitments
FEE, VQ = 0.03, 8.0 # fees: 3% of the line over the program; $8m a quarter of delay
DEPTH0, DEPTH_PER_Q = 28.0, 4.0 # the draw's depth (index points); a quarter of delay cuts 4
APPETITE = 0.05 # at most a 5% chance of a breach in some quarter
EBITDA = 0.118 * 4200.0 # $495.6m
NET_DEBT, COVENANT = 3.4 * EBITDA, 4.5 # $1,685m; net leverage at most 4.5x
CAPABILITY, CAP_FLOOR, RISK_CEIL = 58.0, 55.0, 75.0
BAND_LEV, BAND_CAP, BAND_RISK = 0.02, 5.0, 6.0 # Table 5.2: leverage +/-2%, capability +/-5, strategic risk +/-6
TQ = np.arange(1, Q + 1) / 4 # quarters 1..12, in years
BASE = 6.2 * relax(100, 112, 0.35, TQ) # Chapter 1's liquidity without the program's draw
SHAPE = 6.2 * hump(1.0, 2.0, TQ) # $ million per point of the draw's depth
def plan(depth=DEPTH0):
t = np.arange(Q + 1) / 4
return 6.2 * (relax(100, 112, 0.35, t) - hump(depth, 2.0, t))
def depth(phi):
return DEPTH0 - DEPTH_PER_Q * phi
def draw(phi=0.0):
# the program's deepest cash draw under a delay of phi quarters
return LIQ0 - plan(depth(phi)).min()
class Stream:
# n three-year paths of both channels, drawn in the order of the book's engines: each quarter the n
# surprises, then the n closure counts, then the sizes of that quarter's closures in path order
def __init__(self, seed, n=N, a=A_E, sd=SD_W, lam=LAM, mean=J_MEAN, sdj=J_SD, base=BASE, shape=SHAPE,
floor=FLOOR, depth0=DEPTH0, per_q=DEPTH_PER_Q):
rng = np.random.default_rng(seed)
self.n, self.events, W = n, [], np.empty((n, Q))
for k in range(Q):
W[:, k] = sd * rng.standard_normal(n)
cnt = rng.poisson(lam / 4, n)
self.events.append((np.repeat(np.arange(n), cnt), rng.gamma((mean / sdj) ** 2, sdj ** 2 / mean, cnt.sum())))
self.E, e = np.empty((n, Q)), np.zeros(n)
for k in range(Q):
e = a * e + W[:, k]
self.E[:, k] = e
self.base, self.shape, self.floor, self.depth0, self.per_q, self._crit = base, shape, floor, depth0, per_q, {}
def lost(self, line):
# liquidity lost to closures the line does not cover, cumulated by quarter
J, j = np.empty((self.n, Q)), np.zeros(self.n)
for k, (who, size) in enumerate(self.events):
j = j + np.bincount(who, np.maximum(size - line, 0.0), minlength=self.n)
J[:, k] = j
return J
def paths(self, line=0.0, phi=0.0):
# liquidity in quarters 1..12 under the package (line, delay)
return self.base - (self.depth0 - self.per_q * phi) * self.shape + self.E - self.lost(line)
def crit(self, line):
# each path's critical depth, sorted: the path stays above the floor exactly when the depth is at most it
key = round(float(line), 6)
if key not in self._crit:
self._crit[key] = np.sort(((self.base + self.E - self.lost(line) - self.floor) / self.shape).min(axis=1))
return self._crit[key]
def odds(self, line, phi):
return float(np.mean(self.crit(line) < self.depth0 - self.per_q * phi))
def delay_for(self, line, p):
# the least delay that meets an appetite p with this line (nan if no delay can)
d = min(self.depth0, self.crit(line)[int(np.floor(p * self.n + 1e-9))])
return np.nan if d < 0 else (self.depth0 - d) / self.per_q
def cost(line, phi):
return FEE * line + VQ * phi
LINES = np.arange(0.0, 400.01, 5.0) # lines in $5m steps, as in the book's engine
def cheapest(S, p, fee=FEE, vq=VQ, lines=LINES):
# the least-cost package meeting appetite p: (line, delay, cost)
best = None
for l in lines:
ph = S.delay_for(l, p)
if np.isnan(ph):
continue
c = fee * l + vq * ph
if best is None or c < best[2]:
best = (float(l), float(ph), float(c))
return best
# Chapter 14's coupling register on the feedback core: column j holds the shares of a quarter's deviation unit j passes on
CORE = ("IND", "DIG", "ENG", "TRS") # Industrial Systems, Digital Solutions, shared engineering, treasury
CEIL, RULE = 0.40, 0.5 ** 0.25 # each link's ceiling; the board's rule: any deviation halves within a year
def register(e=CEIL, t=CEIL, h=0.0, dig_eng=None):
# engineering links e, treasury links t, the phase-two Digital-Industrial Systems link h; every link two-way
M = np.zeros((4, 4))
for a, b, w in ((0, 2, e), (1, 2, e if dig_eng is None else dig_eng), (0, 3, t), (1, 3, t), (0, 1, h)):
M[a, b] = M[b, a] = w
return M
def rho(M):
return float(max(abs(np.linalg.eigvals(M))))
def half_life(r):
return np.log(2) / np.log(1 / r) if r < 1 else np.inf
def multiplier(r):
return 1 / (1 - r) if r < 1 else np.inf
def echo(M, quarters=12, size=10.0):
# the core's total deviation, quarter by quarter, after a one-off shock of `size` at Digital Solutions
x, out = np.zeros(4), []
x[CORE.index("DIG")] = size
for _ in range(quarters + 1):
out.append(x.sum())
x = M @ x
return np.array(out)
B = Stream(BOOK_SEED) # the book's 100,000 paths (seed 8)
M = register()
pl = plan()
print("plan by quarter ($ million):", np.round(pl).astype(int))
print(f"trough ${pl.min():.0f} million in quarter {pl.argmin()}: deepest draw ${draw(0):.1f} million against the"
f" ${POOL:.0f} million above the floor")
print(f"closures on the book's paths (seed {BOOK_SEED}): {sum(len(s) for _, s in B.events):,}, the largest"
f" ${max(s.max() for _, s in B.events):.0f} million")
print(f"EBITDA ${EBITDA:.1f} million, net debt ${NET_DEBT:,.1f} million ({NET_DEBT / EBITDA:.1f}x)")
print(f"register: eight entries of {CEIL:.2f}; spectral radius {rho(M):.3f}; the board's rule {RULE:.4f}")plan by quarter ($ million): [620 574 540 516 499 488 483 482 484 488 494 502 510] trough $482 million in quarter 7: deepest draw $138.0 million against the $270 million above the floor closures on the book's paths (seed 8): 30,030, the largest $486 million EBITDA $495.6 million, net debt $1,685.0 million (3.4x) register: eight entries of 0.40; spectral radius 0.800; the board's rule 0.8409
Panel 1 — Walk the framework: five limitations, removed (AXIOM Lab 1.16, step 1; Section 16.1; Table 16.1: $138 and $187 million on $270 million, 24.6 percent, 1.6 weight points, 3.1 quarters, $10.4 and $180 million)
AXIOM Lab 1.16, step 1, the framework visualizer and architecture explorer. Chapter 1 named five limitations of the frameworks that companies use to think about transformation; Table 16.1 records how the volume removed each, with Meridian's evidence, and what remains true. The cell recomputes the evidence from the declarations. Fragmentation: two sign-offs each pass against the $270 million of cash above the floor, the program's deepest draw of $138 million and the treasury's buffer of $187 million, yet they promise the same cash. Snapshots: the average path never breaches the floor, while 24.6 percent of paths do. One-number summaries: moving 1.6 points of weight from technology to liquidity ties digital and restructuring, and the scorecard's scale flips the ranking. No state: a shock in the feedback core halves in 3.1 quarters; one more link would make it grow. No well-posed problem: the GEOP meets the board's 5 percent appetite for $10.4 million and prices a breach at about $180 million.
Python Code
P90 = stats.gamma.ppf(0.9, (J_MEAN / J_SD) ** 2, scale=J_SD ** 2 / J_MEAN) # Chapter 12's 90th-percentile closure
DRAW0 = draw(0.0)
P0 = B.odds(0.0, 0.0)
MEAN_PATH = plan() - LAM / 4 * np.arange(Q + 1) * J_MEAN # the average path: the plan less the expected drain
TROUGH_SIM = float(B.paths(0, 0).mean(axis=0).min())
Y5 = np.array([[option(o, 5.0)[k] for k in "LTER"] for o in OPTIONS]) # Chapter 11: the four readings at year 5
TODAY = np.array([100.0, 41.0, 71.0, 64.0])
SIGN = np.array([1.0, 1.0, 1.0, -1.0]) # strategic risk: lower is better
def best_to_worst(v):
# each reading rescaled so that the best option scores 100 and the worst 0; equal weights
s = v * SIGN
return (100 * (s - s.min(axis=0)) / (s.max(axis=0) - s.min(axis=0))).mean(axis=1)
def pct_on_today(v):
# each reading as a percentage improvement on today; equal weights
return (100 * (v - TODAY) / TODAY * SIGN).mean(axis=1)
CFO = (Y5 * SIGN).mean(axis=1) # the CFO's scorecard, (L + T + E - R)/4
GAP = (Y5[0] - Y5[1]) * SIGN
TIE = GAP.mean() / (GAP[1] - GAP[0]) # weight moved from technology to liquidity that ties the two leaders
BTW, PCT = best_to_worst(Y5), pct_on_today(Y5)
R_CORE, R_PH2 = rho(M), rho(register(h=CEIL))
L5, PH5, C5 = cheapest(B, APPETITE)
C45, C55 = cheapest(B, 0.045)[2], cheapest(B, 0.055)[2]
LAMBDA = C45 - C55 # the appetite's multiplier, $ million per percentage point
print("L1 Fragmentation (Chapter 13): each sign-off passes alone, the two together do not")
print(f" deepest draw {DRAW0:.1f} <= {POOL:.0f}; buffer for a 90th-percentile closure {P90:.1f} <= {POOL:.0f};"
f" together {DRAW0 + P90:.1f} > {POOL:.0f}")
print("L2 Snapshots (Chapter 8): the flaw of averages")
print(f" the average path's lowest point ${MEAN_PATH.min():.0f} million (on the paths ${TROUGH_SIM:.0f} million), above"
f" the floor; {100 * P0:.1f}% of paths breach it (seed {BOOK_SEED})")
print("L3 One-number summaries (Chapter 11): the CFO's scorecard at year 5:",
", ".join(f"{o} {s:.1f}" for o, s in zip(OPTIONS, CFO)))
print(f" moving {100 * TIE:.1f} points of weight from technology to liquidity ties digital and restructuring;"
f" the scale flips the ranking: best-to-worst puts {OPTIONS[int(BTW.argmax())]} first,"
f" percentage improvement {OPTIONS[int(PCT.argmax())]}")
print("L4 No state (Chapter 14): the register's feedback core")
print(f" spectral radius {R_CORE:.2f}: a shock halves in {half_life(R_CORE):.1f} quarters;"
f" one more link at 0.40: {R_PH2:.2f} > 1, a shock grows")
print("L5 No well-posed problem (Chapter 15): the GEOP")
print(f" the 5% appetite met for ${C5:.1f} million (line {L5:.0f}, delay {PH5:.3f}); its multiplier, ${LAMBDA:.2f} million"
f" a point, prices a breach at about ${round(100 * LAMBDA, -1):.0f} million (100 x {LAMBDA:.3f})")
print("\nWhat remains true: couplings are only as good as their ceilings; the flaw of averages; a measure targeted hard"
" stops measuring; every reading has an error band; feasible this quarter is not viable for the horizon")L1 Fragmentation (Chapter 13): each sign-off passes alone, the two together do not deepest draw 138.0 <= 270; buffer for a 90th-percentile closure 186.9 <= 270; together 324.9 > 270 L2 Snapshots (Chapter 8): the flaw of averages the average path's lowest point $460 million (on the paths $460 million), above the floor; 24.6% of paths breach it (seed 8) L3 One-number summaries (Chapter 11): the CFO's scorecard at year 5: Digital 47.1, Restructuring 46.1, Turnaround 38.4 moving 1.6 points of weight from technology to liquidity ties digital and restructuring; the scale flips the ranking: best-to-worst puts Restructuring first, percentage improvement Digital L4 No state (Chapter 14): the register's feedback core spectral radius 0.80: a shock halves in 3.1 quarters; one more link at 0.40: 1.02 > 1, a shock grows L5 No well-posed problem (Chapter 15): the GEOP the 5% appetite met for $10.4 million (line 170, delay 0.668); its multiplier, $1.81 million a point, prices a breach at about $180 million (100 x 1.807) What remains true: couplings are only as good as their ceilings; the flaw of averages; a measure targeted hard stops measuring; every reading has an error band; feasible this quarter is not viable for the horizon
Panel 2 — Consistent, and complete only relative to the declaration (Theorems 16.1–16.2; Worked Example 4.1: 12 engineers apart, 391 for both)
Two assurances rest on Definition 16.1. Consistency (Theorem 16.1): the framework's requirements cannot contradict one another, because one declared company meets all of them at once; the panels that follow run that company, Meridian with the repairs of Chapters 13–15, through every gate. Relative completeness (Theorem 16.2): a question the declaration does not determine cannot be answered by any analysis of the declaration, human or machine. Chapter 4's sharpest instance is Worked Example 4.1: two engineering units with the same declared headcount of 500 but different skill mixes end five years later 12 engineers apart, while a model that declares only totals predicts 391 for both. Whatever a procedure does with the totals, it gives both units the same answer, so it is wrong for at least one of them, by at least half the gap. Declaring the skill mix determines the answer.
Python Code
AW = np.array([[0.92, 0.00], # legacy engineers: 5% leave and 3% retrain each year
[0.03, 0.96]]) # software engineers: 4% leave; the retrained legacy engineers join
UNITS = {"Unit A (legacy-heavy)": np.array([400.0, 100.0]), "Unit B (software-heavy)": np.array([100.0, 400.0])}
HEAD = {}
for name, x in UNITS.items():
tot, y = [x.sum()], x.copy()
for _ in range(5):
y = AW @ y
tot.append(y.sum())
HEAD[name] = np.array(tot)
print(f"{name:24s} declared total {x.sum():.0f}: years 0-5 {np.round(tot, 1)}")
RATE = (AW @ UNITS["Unit A (legacy-heavy)"]).sum() / 500.0 # a totals model, calibrated on unit A's first year
TOTALS5 = 500 * RATE ** 5
HA, HB = HEAD["Unit A (legacy-heavy)"][-1], HEAD["Unit B (software-heavy)"][-1]
print(f"\na model that declares only totals: x{RATE:.3f} a year -> {TOTALS5:.1f} engineers in year 5, for both units")
print(f"the units reach {HA:.1f} and {HB:.1f}: {HB - HA:.1f} engineers apart; the totals model errs by"
f" {TOTALS5 - HA:+.1f} and {TOTALS5 - HB:+.1f}")
print(f"any answer P computed from the declared total alone has |P - {HA:.1f}| + |P - {HB:.1f}| >= {HB - HA:.1f}:"
f" it is off by at least {(HB - HA) / 2:.2f} for one unit (Theorem 16.2(ii))")
print("declaring the skill mix (legacy, software) determines the answer: the model is then the declaration itself")Unit A (legacy-heavy) declared total 500: years 0-5 [500. 476. 453.3 431.8 411.4 392.1] Unit B (software-heavy) declared total 500: years 0-5 [500. 479. 458.9 439.7 421.3 403.8] a model that declares only totals: x0.952 a year -> 391.0 engineers in year 5, for both units the units reach 392.1 and 403.8: 11.7 engineers apart; the totals model errs by -1.1 and -12.8 any answer P computed from the declared total alone has |P - 392.1| + |P - 403.8| >= 11.7: it is off by at least 5.86 for one unit (Theorem 16.2(ii)) declaring the skill mix (legacy, software) determines the answer: the model is then the declaration itself
Panel 3 — Declaration completeness, gate (R1) (Worked Example 16.1, Step 1; AXIOM Lab 1.16, steps 1–2: $19.0 against $14.7 million; 52.3 to 41.4 and 24.0 to 10.6)
AXIOM Lab 1.16, step 1, continued (open the coupling register and the inventory of commitments), and step 2, the GEOP formulation assistant, which starts the readiness chain. The inventory is long: eight state readings, each with the office that measures it and an error band (Table 5.2); seven components and fourteen typed arrows (Chapter 9), whose feedback core the cell finds from the arrows themselves; five standing commitments; the environment's laws (Chapter 8); the coupling register, with four two-way links in the core at a ceiling of 0.40 (Chapter 14); and the six elements of the GEOP, each with an owner (Worked Example 15.1). Two items were missing when the volume first needed them, and both gaps cost something. The levers had no declared prices until Chapter 15, so Chapter 8 chose its package on safety alone: a $100 million line with two quarters of phasing costs $19.0 million, where $14.7 million buys the same 3.0 percent odds. The CFO's scorecard was declared without its scale, which decides the ranking of the options: on a best-to-worst scale restructuring leads digital 52.3 to 41.4; on percentage improvement digital leads 24.0 to 10.6. The first gap is closed. The second is the board's to close before any optimizer ranks the three options: with an undeclared normalization the same scorecard ranks them in opposite orders (Proposition 16.1(i)).
Python Code
READINGS = [("liquidity", "treasury systems", "+/-1%"), ("net leverage", "audited accounts", "+/-2%"),
("workforce capability", "skills survey", "+/-5 points"), ("technology platform", "architecture audit", "+/-4 points"),
("operational efficiency", "cost benchmarking", "+/-3 points"), ("ROIC", "audited accounts", "+/-0.4 pp"),
("strategic risk", "risk committee", "+/-6 points"), ("market share", "industry data", "+/-0.8 pp")]
ARROWS = [("MKT", "IND", "demand"), ("MKT", "DIG", "demand"), ("MKT", "MAT", "demand"), ("IND", "TRS", "cash"),
("DIG", "TRS", "cash"), ("MAT", "TRS", "cash"), ("TRS", "IND", "funding"), ("TRS", "DIG", "funding"),
("ENG", "IND", "capability"), ("IND", "ENG", "capability"), ("ENG", "DIG", "capability"),
("DIG", "ENG", "capability"), ("GOV", "TRS", "policy"), ("GOV", "DIG", "policy")] # Chapter 9
COMMITMENTS = [("covenant: net leverage at most 4.5x", "CFO"), ("liquidity floor: $350 million", "board"),
("strategic-risk ceiling: 75", "CRO, board"), ("plant capacity in Industrial Systems", "COO"),
("capability at least 55 for the digital build", "HR, CTO")] # Table 15.2
GEOP_ELEMENTS = [("horizon", "the program's 12 quarters"),
("decisions", "the standby line (CFO); the delay in quarters (transformation office)"),
("policy class", "a package committed today (open loop)"),
("environment", f"Chapter 8's laws: {N:,} paths, seed {BOOK_SEED}"),
("objective", "the levers' cost, 0.03 line + 8 delay: fees priced by the CFO, delay by the"
" transformation office"),
("commitments", "the appetite (board); the covenant (CFO); the capability floor (HR, CTO)")]
print("The declaration inventory")
print(f" {len(READINGS)} state readings (Table 5.2), each with the office that measures it and its error:")
for r, o, e in READINGS:
print(f" {r:24s} {o:20s} {e}")
COMPONENTS = sorted({a for a, b, _ in ARROWS} | {b for a, b, _ in ARROWS})
idx = {c: i for i, c in enumerate(COMPONENTS)}
R = np.eye(len(COMPONENTS), dtype=bool)
for a, b, _ in ARROWS:
R[idx[a], idx[b]] = True
for _ in range(len(COMPONENTS)): # who can reach whom: the transitive closure
R = R | ((R.astype(int) @ R.astype(int)) > 0)
CORE_FOUND = [c for c in COMPONENTS if sum(R[idx[c], idx[d]] and R[idx[d], idx[c]] for d in COMPONENTS) > 1]
TWO_WAY = sorted({tuple(sorted((a, b))) for a, b, _ in ARROWS if (b, a) in {(x, y) for x, y, _ in ARROWS}})
print(f" {len(COMPONENTS)} components, {len(ARROWS)} typed arrows; the feedback core, where every member reaches every"
f" other: {CORE_FOUND}; its two-way links: {TWO_WAY}")
print(f" {len(COMMITMENTS)} standing commitments:", "; ".join(f"{c} ({o})" for c, o in COMMITMENTS))
print(f" the coupling register: {len(TWO_WAY)} two-way links at a ceiling of {CEIL:.2f} (risk office)")
print(f" the GEOP's {len(GEOP_ELEMENTS)} elements:")
for k, v in GEOP_ELEMENTS:
print(f" {k:13s} {v}")
P_PKG, C_PKG = B.odds(100, 2), cost(100, 2)
F_PKG = cheapest(B, P_PKG)
print(f"\ngap 1, the levers' prices: Chapter 8's package (a $100 million line, two quarters of phasing) costs"
f" {FEE} x 100 + {VQ:.0f} x 2 = ${C_PKG:.1f} million at the declared prices; odds {100 * P_PKG:.2f}% (seed {BOOK_SEED})")
print(f" the cheapest package at those odds: line {F_PKG[0]:.0f}, delay {F_PKG[1]:.2f} quarters, ${F_PKG[2]:.2f} million:"
f" choosing on safety alone cost ${C_PKG - F_PKG[2]:.2f} million")
print("gap 2, the scorecard's scale, at equal weights on the four readings:")
for name, s in (("best-to-worst", BTW), ("percentage improvement on today", PCT)):
print(f" {name:32s}", ", ".join(f"{OPTIONS[i]} {s[i]:.1f}" for i in np.argsort(-s)))
print("\n(R1) after Chapter 8: fails, two items undeclared; now: the prices are declared (Chapter 15), and the scale is"
" the board's to declare before any optimizer ranks the three options")The declaration inventory
8 state readings (Table 5.2), each with the office that measures it and its error:
liquidity treasury systems +/-1%
net leverage audited accounts +/-2%
workforce capability skills survey +/-5 points
technology platform architecture audit +/-4 points
operational efficiency cost benchmarking +/-3 points
ROIC audited accounts +/-0.4 pp
strategic risk risk committee +/-6 points
market share industry data +/-0.8 pp
7 components, 14 typed arrows; the feedback core, where every member reaches every other: ['DIG', 'ENG', 'IND', 'TRS']; its two-way links: [('DIG', 'ENG'), ('DIG', 'TRS'), ('ENG', 'IND'), ('IND', 'TRS')]
5 standing commitments: covenant: net leverage at most 4.5x (CFO); liquidity floor: $350 million (board); strategic-risk ceiling: 75 (CRO, board); plant capacity in Industrial Systems (COO); capability at least 55 for the digital build (HR, CTO)
the coupling register: 4 two-way links at a ceiling of 0.40 (risk office)
the GEOP's 6 elements:
horizon the program's 12 quarters
decisions the standby line (CFO); the delay in quarters (transformation office)
policy class a package committed today (open loop)
environment Chapter 8's laws: 100,000 paths, seed 8
objective the levers' cost, 0.03 line + 8 delay: fees priced by the CFO, delay by the transformation office
commitments the appetite (board); the covenant (CFO); the capability floor (HR, CTO)
gap 1, the levers' prices: Chapter 8's package (a $100 million line, two quarters of phasing) costs 0.03 x 100 + 8 x 2 = $19.0 million at the declared prices; odds 3.00% (seed 8)
the cheapest package at those odds: line 180, delay 1.16 quarters, $14.67 million: choosing on safety alone cost $4.33 million
gap 2, the scorecard's scale, at equal weights on the four readings:
best-to-worst Restructuring 52.3, Digital 41.4, Turnaround 35.3
percentage improvement on today Digital 24.0, Restructuring 10.6, Turnaround 0.0
(R1) after Chapter 8: fails, two items undeclared; now: the prices are declared (Chapter 15), and the scale is the board's to declare before any optimizer ranks the three options
Panel 4 — Unified consistency, gate (R2) (Worked Example 16.1, Step 2: 138 + 187 = 325 on 270; 122 + 17 = 139, $131 million unclaimed)
AXIOM Lab 1.16, step 2, continued: reproduce the failure of the joint check, then apply the Chapter 15 package and watch the certificate issue. As first declared, the books did not close. The program's deepest draw of $138 million and the treasury's buffer of $187 million for a 90th-percentile closure of the funding window each passed its own sign-off against the $270 million of cash above the floor, but together they claim $325 million, $55 million more than there is (Worked Example 13.1). The artifact is a minimal set of three commitments with three owners, the program's draw (transformation office), the buffer (treasury) and the floor (board), any two of which can hold. The Chapter 15 package repairs it: the line covers all but $17 million of such a closure, and the delay cuts the deepest draw to $122 million, so the two claims total $139 million and leave $131 million unclaimed.
Python Code
print(f"as first declared: draw {DRAW0:.1f} + buffer {P90:.1f} = {DRAW0 + P90:.1f} against {POOL:.0f}:"
f" short by {DRAW0 + P90 - POOL:.1f}")
SET = {"the program's draw (transformation office)": DRAW0, "the buffer (treasury)": P90, "the floor (board)": None}
print("the minimal set: drop any one commitment, and the other two can hold")
for drop in SET:
held = sum(v for k, v in SET.items() if k != drop and v is not None)
floor = 0.0 if drop == "the floor (board)" else FLOOR
print(f" without {drop:45s} liquidity left after the claims {LIQ0 - held:6.1f} >= {floor:3.0f}:"
f" {'holds' if LIQ0 - held >= floor else 'fails'}")
print(f" all three: {LIQ0 - DRAW0 - P90:.1f} >= {FLOOR:.0f}: fails")
D_NOW, B_NOW = draw(PH5), max(P90 - L5, 0.0)
print(f"\nChapter 15's package: line {L5:.0f}, delay {PH5:.3f} quarters ({3 * PH5:.1f} months)")
print(f" the line covers all but {B_NOW:.1f} of a 90th-percentile closure; the delay cuts the deepest draw to {D_NOW:.1f}")
print(f" draw {D_NOW:.1f} + buffer {B_NOW:.1f} = {D_NOW + B_NOW:.1f}: {POOL - D_NOW - B_NOW:.1f} of the {POOL:.0f} unclaimed"
" -> the consistency certificate issues")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for i, (d, b, lab) in enumerate(((DRAW0, P90, "after Chapter 8"), (D_NOW, B_NOW, "now: Chapter 15's package"))):
ax.barh(i, d, color="#5E35B1", height=0.5, label="the program's deepest draw" if i == 0 else None)
ax.barh(i, b, left=d, color="#2E7D32", height=0.5, label="the buffer for a 90th-percentile closure" if i == 0 else None)
ax.text(d + b + 4, i, f"{d:.0f} + {b:.0f} = {d + b:.0f}", va="center", fontsize=9)
ax.axvline(POOL, color="#B71C1C", lw=1.4, ls="--")
ax.text(POOL - 4, -0.42, "cash above the floor: 270", color="#B71C1C", fontsize=8.5, va="center", ha="right")
ax.set(yticks=[0, 1], yticklabels=["after Chapter 8", "now"], xlim=(0, 380), ylim=(-0.6, 1.75),
xlabel="claims on the cash above the floor (\\$ million)",
title="The same cash promised twice, and the repair (seed 26116)")
ax.invert_yaxis(); ax.legend(frameon=False, fontsize=8, loc="lower right"); plt.tight_layout(); plt.show()as first declared: draw 138.0 + buffer 186.9 = 324.9 against 270: short by 54.9 the minimal set: drop any one commitment, and the other two can hold without the program's draw (transformation office) liquidity left after the claims 433.1 >= 350: holds without the buffer (treasury) liquidity left after the claims 482.0 >= 350: holds without the floor (board) liquidity left after the claims 295.1 >= 0: holds all three: 295.1 >= 350: fails Chapter 15's package: line 170, delay 0.668 quarters (2.0 months) the line covers all but 16.9 of a 90th-percentile closure; the delay cuts the deepest draw to 121.6 draw 121.6 + buffer 16.9 = 138.5: 131.5 of the 270 unclaimed -> the consistency certificate issues

Panel 5 — The analytical panel, gate (R3) (Worked Example 16.1, Step 3; AXIOM Lab 1.16, step 3, second part: 0.80, 3.1 quarters, 5; 1.02; 0.08, 0.16 and 0.30)
The panel A1–A5 of Table 14.1 must hold with the gain audit current, decision sets must be compact, and the objective and commitments continuous. The register's ceilings certify the feedback core: a spectral radius of 0.80, a half-life of 3.1 quarters inside the board's four-quarter rule, and a worst-case multiplier of 5 (Theorem 16.5(ii)); a $10 million shock at Digital Solutions echoes through the core by at most $8 million the next quarter, $6.4 million the quarter after, and $50 million in all, shock included. The gate passes for the program as approved. The program's second phase would fail it: the shared installed base creates a link between Digital Solutions and Industrial Systems that the register does not carry, so its ceiling is zero and the gain audit would flag it at once. Declare the link at the 0.40 ceiling, as AXIOM Lab 1.16's step 3 asks, and read the stability certificate fail: the spectral radius reaches 1.02, past the board's rule and past the point where any stability or sensitivity certificate holds. The work order is to declare the link before phase two and buy it down: run it below 0.08 (at most 0.0798), ring-fence the treasury links below 0.16 (at most 0.159), or trim all four existing links to 0.30.
Python Code
print("the register M (column j: the shares of a quarter's deviation that unit j passes on)")
print(" " + "".join(f"{c:>7s}" for c in CORE))
for i, c in enumerate(CORE):
print(f" {c:4s} " + "".join(f"{v:7.2f}" for v in M[i]))
EC = echo(M, quarters=80)
print(f"spectral radius {R_CORE:.3f} <= the board's rule 2^(-1/4) = {RULE:.4f}: half-life {half_life(R_CORE):.2f} quarters"
f" (the rule allows 4), multiplier {multiplier(R_CORE):.2f}")
print(f"a $10 million shock at Digital echoes {EC[1]:.1f}, {EC[2]:.1f}, {EC[3]:.2f}, {EC[4]:.2f}, ... : {EC.sum():.1f} in all,"
" shock included")
print("the panel's other rows: decision sets compact (line 0 to 400, delay 0 to 7 quarters); commitments closed (<=) and"
" continuous; gain audit current -> (R3) passes for the program as approved")
M2 = register(h=CEIL)
print(f"\nphase two, the Digital-Industrial Systems link not in the register: its ceiling is 0, so any measured gain on it"
" fails the gain audit")
print(f"declared at {CEIL:.2f}: Industrial Systems and Digital pass on {M2[:, 0].sum():.2f} each; spectral radius"
f" {R_PH2:.4f} > {RULE:.4f}, and >= 1: no stability or sensitivity certificate holds")
print(" echo of a $10 million shock at Digital:", np.round(echo(M2), 1))
H_MAX = (RULE ** 2 - 2 * (CEIL ** 2 + CEIL ** 2)) / RULE # Chapter 14's closed form at the rule
T_MAX = np.sqrt((RULE ** 2 - CEIL * RULE) / 2 - CEIL ** 2)
TRIM = np.sqrt((RULE ** 2 - CEIL * RULE) / 4)
REPAIRS = [("run the new link at no more than", H_MAX, register(h=H_MAX)),
("ring-fence the treasury links at", T_MAX, register(t=T_MAX, h=CEIL)),
("trim all four existing links to", TRIM, register(e=TRIM, t=TRIM, h=CEIL))]
print("the work order, at the board's rule:")
for name, g, Mx in REPAIRS:
print(f" {name:34s} {g:.3f}: spectral radius {rho(Mx):.4f}, half-life {half_life(rho(Mx)):.2f} quarters")the register M (column j: the shares of a quarter's deviation that unit j passes on)
IND DIG ENG TRS
IND 0.00 0.00 0.40 0.40
DIG 0.00 0.00 0.40 0.40
ENG 0.40 0.40 0.00 0.00
TRS 0.40 0.40 0.00 0.00
spectral radius 0.800 <= the board's rule 2^(-1/4) = 0.8409: half-life 3.11 quarters (the rule allows 4), multiplier 5.00
a $10 million shock at Digital echoes 8.0, 6.4, 5.12, 4.10, ... : 50.0 in all, shock included
the panel's other rows: decision sets compact (line 0 to 400, delay 0 to 7 quarters); commitments closed (<=) and continuous; gain audit current -> (R3) passes for the program as approved
phase two, the Digital-Industrial Systems link not in the register: its ceiling is 0, so any measured gain on it fails the gain audit
declared at 0.40: Industrial Systems and Digital pass on 1.20 each; spectral radius 1.0246 > 0.8409, and >= 1: no stability or sensitivity certificate holds
echo of a $10 million shock at Digital: [10. 12. 11.2 12.2 12. 12.6 12.7 13.2 13.4 13.8 14.1 14.5 14.8]
the work order, at the board's rule:
run the new link at no more than 0.080: spectral radius 0.8409, half-life 4.00 quarters
ring-fence the treasury links at 0.159: spectral radius 0.8409, half-life 4.00 quarters
trim all four existing links to 0.304: spectral radius 0.8409, half-life 4.00 quarters
Panel 6 — The digital twin: inject a drift and read what the gain audit voids (AXIOM Lab 1.16, step 3; Theorem 16.5(ii); Online Appendix 16.B.2: $8 million, $6.4 million, $50 million in all)
AXIOM Lab 1.16, step 3, the digital-twin demonstration. A twin is a live, executable instance of the declaration (Definition 16.4): its register is bound to the gain audit, which compares each measured gain with its ceiling. First, what the register certifies (Theorem 16.5(ii); Online Appendix 16.B.2): draw 10,000 models that keep every sign and size within the ceilings, with uniform on . Every spectral radius among them lies below 0.80, and for every one the total echo of a $10 million shock at Digital Solutions, , is at most the register's, : $8 million, $6.4 million, …, $50 million in all. The bound is attained by : the register is the worst case among the models it certifies, not a typical one. The book's draws use the engine's seed 16; fresh draws with the lab's seed 26116 lead to the same conclusion.
Then the drift. The book prints no numbers for this part, so the scenario is this notebook's declaration, not the book's (seed 26116). Over the program's twelve quarters the risk office measures the four links each quarter with an error of ±0.02 (two standard deviations); the Digital–engineering link, near 0.36 at first, starts to drift up 0.02 a quarter in quarter 4 as shared engineers are pulled into Digital's work. As Table 16.4 grades the commitments, the audit grades each reading against its error: within 0.02 of the ceiling is a thin pass, and more than 0.02 above it is a flag. Attribute the flag, list the certificates it voids, and re-certify on the measured gain.
Python Code
def models_within(seed, n=10_000, quarters=8):
# n models with |A| <= M entrywise, drawn as in the book's engine; their spectral radii and echoes
rng = np.random.default_rng(seed)
bound = echo(M, quarters)
rmax, over_r, over_e, env = 0.0, 0, 0, np.zeros(quarters + 1)
for _ in range(n):
A = M * rng.uniform(-1.0, 1.0, size=M.shape)
r, x, e = rho(A), np.zeros(4), []
x[CORE.index("DIG")] = 10.0
for _k in range(quarters + 1):
e.append(abs(x.sum()))
x = A @ x
e = np.array(e)
rmax, env = max(rmax, r), np.maximum(env, e)
over_r += r > R_CORE + 1e-12
over_e += bool((e > bound + 1e-9).any())
return rmax, over_r, over_e, env, bound
RM16, OR16, OE16, ENV16, BOUND = models_within(16)
RMF, ORF, OEF, ENVF, _ = models_within(SEED)
print("the register's echo bound, 10 x 0.8^k:", np.round(BOUND, 2), f"... {echo(M, 80).sum():.0f} in all")
for lab, rm, o_r, o_e, env in ((f"seed 16, as in the book's engine", RM16, OR16, OE16, ENV16),
(f"seed {SEED}, fresh draws", RMF, ORF, OEF, ENVF)):
print(f"10,000 models within the ceilings ({lab}): largest spectral radius {rm:.3f} < {R_CORE:.2f};"
f" models above the register's radius {o_r}, echoes above its bound {o_e}")
print(" largest echo among them, quarter by quarter:", np.round(env, 2))
# The twin (this notebook's declaration; seed 26116): the gain audit's quarterly readings of the four links
rng = np.random.default_rng(SEED)
LINKS = ("IND-ENG", "DIG-ENG", "IND-TRS", "DIG-TRS")
QQ = np.arange(Q + 1)
TRUE = np.full((Q + 1, 4), 0.36)
TRUE[:, 1] = 0.36 + 0.02 * np.maximum(QQ - 3, 0) # the Digital-engineering link drifts from quarter 4
ERR = 0.02 # the audit's reading error: two standard deviations
READ = TRUE + rng.normal(0.0, ERR / 2, size=TRUE.shape)
THIN = READ > CEIL - ERR # within the error of the ceiling, or above it
FLAG = READ > CEIL + ERR # above the ceiling by more than the error
print("\nquarter " + "".join(f"{l:>9s}" for l in LINKS) + " the gain audit")
for k in QQ:
if FLAG[k].any():
verdict = "FLAG: " + ", ".join(LINKS[j] for j in np.nonzero(FLAG[k])[0])
elif THIN[k].any():
verdict = "thin pass: " + ", ".join(LINKS[j] for j in np.nonzero(THIN[k])[0])
else:
verdict = "passes"
print(f" {k:3d} " + "".join(f"{v:9.3f}" for v in READ[k]) + f" {verdict}")
K_THIN, K_FLAG = int(np.argmax(THIN.any(axis=1))), int(np.argmax(FLAG.any(axis=1)))
J_FLAG = int(np.argmax(FLAG[K_FLAG]))
G_FLAG = float(READ[K_FLAG, J_FLAG])
print(f"\nfirst thin pass in quarter {K_THIN}; first flag in quarter {K_FLAG}: {LINKS[J_FLAG]} read at {G_FLAG:.3f}"
f" > {CEIL:.2f} + {ERR:.2f}")
print("attribution: the Digital-engineering link, both ways (Digital Solutions and shared engineering), in the risk"
" office's register")
print("certificates it voids, all of which Theorem 16.5(ii) grants only within the ceilings:")
for c in (f"spectral radius at most {R_CORE:.2f}", f"half-life at most {half_life(R_CORE):.1f} quarters, inside the board's"
" four-quarter rule", f"multiplier at most {multiplier(R_CORE):.0f}",
"echo of a $10 million shock at most $8m, $6.4m, ..., $50m in all",
"the sensitivity certificates of Chapter 14", "gate (R3), and with it the readiness certificate"):
print(" -", c)
MF = register(dig_eng=G_FLAG)
RF = rho(MF)
print(f"re-certified on the reading {G_FLAG:.3f} (the other links at their ceilings): spectral radius {RF:.4f},"
f" half-life {half_life(RF):.2f} quarters, multiplier {multiplier(RF):.2f}, echo {echo(MF, 80).sum():.1f} in all")
G_RULE = brentq(lambda g: rho(register(dig_eng=g)) - RULE, CEIL, 1.0)
K_RULE = int(np.argmax(TRUE[:, 1] > G_RULE))
print(f"the board's rule tolerates the Digital-engineering link up to {G_RULE:.3f} with the others at 0.40; the drift"
f" passes it in quarter {K_RULE}: re-declaring the ceiling is no longer enough, the link must be bought down")
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6))
cols = ("#1F4E79", "#B71C1C", "#2E7D32", "#E65100")
ax.axhspan(CEIL - ERR, CEIL + ERR, color="#EFE4D0", lw=0)
ax.axhline(CEIL, color="#616161", lw=1.0, ls="--")
for j in range(4):
ax.plot(QQ, READ[:, j], "o-", color=cols[j], lw=1.3, ms=3, label=LINKS[j])
ax.plot([K_FLAG], [G_FLAG], "X", color="#B71C1C", ms=10, zorder=5)
ax.text(K_FLAG - 0.3, G_FLAG + 0.012, f"flag, q{K_FLAG}", color="#B71C1C", fontsize=8, ha="right")
ax.text(12.3, CEIL + ERR + 0.004, "ceiling 0.40 ± 0.02", color="#8A6A33", fontsize=7.5, ha="right", va="bottom")
ax.set(xlabel="quarter", ylabel="measured gain (share passed on)", title="The gain audit", ylim=(0.30, 0.58))
ax.legend(frameon=False, fontsize=7, loc="upper left", ncol=2)
kk = np.arange(9)
bx.fill_between(kk, 0, ENVF, color="#DCE6F2", lw=0, label="10,000 models within the ceilings")
bx.plot(kk, BOUND, "o-", color="#1F4E79", lw=1.6, ms=3, label=r"the register: $10 \times 0.8^k$")
bx.plot(kk, echo(MF, 8), "s--", color="#B71C1C", lw=1.2, ms=3, label=f"re-certified at {G_FLAG:.2f}")
bx.plot(kk, echo(M2, 8), "^:", color="#5E35B1", lw=1.2, ms=3, label="phase-two link at 0.40")
bx.set(xlabel="quarters after a \\$10 million shock", ylabel="total echo in the core (\\$ million)", title="The echo",
ylim=(0, 15))
bx.legend(frameon=False, fontsize=7, loc="center right", bbox_to_anchor=(1.0, 0.56))
for z in (ax, bx):
z.tick_params(labelsize=8); z.xaxis.label.set_size(8.5); z.yaxis.label.set_size(8.5); z.title.set_size(9)
fig.suptitle("A drift past its ceiling voids the register's certificate (seed 26116)", fontsize=10)
plt.tight_layout(); plt.show()the register's echo bound, 10 x 0.8^k: [10. 8. 6.4 5.12 4.1 3.28 2.62 2.1 1.68] ... 50 in all
10,000 models within the ceilings (seed 16, as in the book's engine): largest spectral radius 0.635 < 0.80; models above the register's radius 0, echoes above its bound 0
largest echo among them, quarter by quarter: [10. 7.91 4.95 2.28 1.76 0.76 0.71 0.26 0.29]
10,000 models within the ceilings (seed 26116, fresh draws): largest spectral radius 0.650 < 0.80; models above the register's radius 0, echoes above its bound 0
largest echo among them, quarter by quarter: [10. 7.99 5.3 2.66 1.74 1.12 0.73 0.47 0.3 ]
quarter IND-ENG DIG-ENG IND-TRS DIG-TRS the gain audit
0 0.368 0.346 0.375 0.359 passes
1 0.346 0.375 0.367 0.365 passes
2 0.368 0.358 0.353 0.365 passes
3 0.360 0.365 0.350 0.372 passes
4 0.372 0.397 0.360 0.357 thin pass: DIG-ENG
5 0.342 0.393 0.362 0.348 thin pass: DIG-ENG
6 0.385 0.427 0.373 0.344 FLAG: DIG-ENG
7 0.382 0.431 0.383 0.361 FLAG: DIG-ENG
8 0.362 0.481 0.364 0.348 FLAG: DIG-ENG
9 0.361 0.491 0.344 0.368 FLAG: DIG-ENG
10 0.361 0.484 0.375 0.363 FLAG: DIG-ENG
11 0.343 0.513 0.361 0.365 FLAG: DIG-ENG
12 0.362 0.536 0.351 0.360 FLAG: DIG-ENG
first thin pass in quarter 4; first flag in quarter 6: DIG-ENG read at 0.427 > 0.40 + 0.02
attribution: the Digital-engineering link, both ways (Digital Solutions and shared engineering), in the risk office's register
certificates it voids, all of which Theorem 16.5(ii) grants only within the ceilings:
- spectral radius at most 0.80
- half-life at most 3.1 quarters, inside the board's four-quarter rule
- multiplier at most 5
- echo of a $10 million shock at most $8m, $6.4m, ..., $50m in all
- the sensitivity certificates of Chapter 14
- gate (R3), and with it the readiness certificate
re-certified on the reading 0.427 (the other links at their ceilings): spectral radius 0.8136, half-life 3.36 quarters, multiplier 5.36, echo 54.4 in all
the board's rule tolerates the Digital-engineering link up to 0.478 with the others at 0.40; the drift passes it in quarter 9: re-declaring the ceiling is no longer enough, the link must be bought down

Panel 7 — Feasibility with horizon honesty, gate (R4) (Worked Example 16.1, Step 4; Table 16.4: 24.6 and 5.0 percent; 3.74×, 0.76 below the limit; 3 points against ±5; 73.6 in month 11, 1.4 points against ±6)
As first declared, the plan had no levers among its decisions, and the floor was breached on 24.6 percent of paths against the board's 5 percent appetite: no policy in the declared class kept the commitment, so the gate failed. Its artifact is the number of periods for which the declaration can be honored (Theorem 16.4(vi)). With the levers declared and the package chosen, every commitment holds over the 12 quarters, but not with equal conviction, so each margin is compared with the error band of the reading behind it. The covenant passes with ten times its band: with the line fully drawn, leverage reaches only 3.74×, 0.76 below the limit, against a reading error of about 0.075. The appetite binds, as a binding commitment must, at 5.0 percent with a simulation error of 0.07 points: its certificate is statistical, and its price, $1.8 million a point, says what more safety would cost. Two passes are thinner than their readings: the capability floor holds by 3 points against a survey error of ±5, and strategic risk peaks at 73.6 in month 11, 1.4 points under its ceiling, against a band of ±6. Fresh paths drawn with the certificate seed 26209 show what a statistical certificate means: the package was fitted to the book's paths, where it binds at exactly 5.0 percent, while on new paths its odds move by about a standard error (4.91 percent), and re-solved there its cost moves too.
Python Code
L0 = B.paths(0, 0) < FLOOR
CUM0 = np.array([L0[:, :k].any(axis=1).mean() for k in range(1, Q + 1)])
K_HONORED = int((CUM0 <= APPETITE + 1e-12).sum())
print(f"as first declared (no levers among the decisions): odds {100 * P0:.2f}% > {100 * APPETITE:.0f}%"
f" (seed {BOOK_SEED}) -> (R4) fails")
print(" odds of a breach by quarter K (%):", np.round(100 * CUM0, 2))
print(f" artifact: the declaration honors the appetite through quarter {K_HONORED} of {Q}, and no further")
P5 = B.odds(L5, PH5)
SE5 = np.sqrt(P5 * (1 - P5) / N)
LEV = (NET_DEBT + L5) / EBITDA
LEV_BAND = BAND_LEV * LEV
tt = np.arange(0.0, 5.0 + 1e-9, 1 / 120) # five years, every tenth of a month
RISK = option("Digital", tt)["R"]
PEAK, PEAK_MONTH = float(RISK.max()), float(12 * tt[RISK.argmax()])
GRADES = []
for name, margin, err, src in ((f"leverage <= {COVENANT}x", COVENANT - LEV, LEV_BAND, "audited accounts, +/-2%"),
("breach odds <= 5%", 100 * (APPETITE - P5), 100 * SE5, "simulation (seed 8), points"),
(f"capability >= {CAP_FLOOR:.0f}", CAPABILITY - CAP_FLOOR, BAND_CAP, "skills survey"),
(f"strategic risk <= {RISK_CEIL:.0f}", RISK_CEIL - PEAK, BAND_RISK, "risk committee")):
grade = ("statistical: binds" if abs(margin) < 1e-9 else "strong" if margin >= err else "weaker than the reading")
GRADES.append((name, margin, err, grade))
print(f"\nwith the package (line {L5:.0f}, delay {PH5:.3f}): odds {100 * P5:.2f}%, standard error {100 * SE5:.3f} points;"
f" price ${LAMBDA:.2f} million a point")
print(f"leverage with the line fully drawn ({NET_DEBT:,.0f} + {L5:.0f}) / {EBITDA:.1f} = {LEV:.3f}x: margin {COVENANT - LEV:.3f},"
f" {(COVENANT - LEV) / LEV_BAND:.1f} times its band of {LEV_BAND:.3f}")
print(f"capability {CAPABILITY:.0f} against the floor of {CAP_FLOOR:.0f}: margin {CAPABILITY - CAP_FLOOR:.0f} against +/-{BAND_CAP:.0f}")
print(f"strategic risk peaks at {PEAK:.2f} in month {PEAK_MONTH:.1f}: margin {RISK_CEIL - PEAK:.2f} against +/-{BAND_RISK:.0f}")
print("\ncommitment margin error of the reading grade")
for name, margin, err, grade in GRADES:
print(f" {name:20s} {margin:8.3f} +/-{err:<8.3f} {grade}")
F = Stream(CERT_SEED) # fresh paths: the certificate seed 26209
P5_FRESH = F.odds(L5, PH5)
LF, PHF, CF = cheapest(F, APPETITE)
print(f"\nfresh paths (seed {CERT_SEED}): the same package breaches {100 * P5_FRESH:.2f}% (no levers: {100 * F.odds(0, 0):.2f}%);"
f" it was fitted to the book's paths, where it binds at exactly {100 * P5:.2f}%")
print(f" re-solved on the fresh paths: line {LF:.0f}, delay {PHF:.3f} quarters, ${CF:.2f} million ({CF - C5:+.2f}):"
" a statistical certificate carries its paths, its seed and its error")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
names = ["leverage ≤ 4.5×", "breach odds ≤ 5%", "capability ≥ 55", "strategic risk ≤ 75"][::-1]
ratio = [g[1] / g[2] for g in GRADES][::-1]
colors = {"strong": "#2E7D32", "statistical: binds": "#1F4E79", "weaker than the reading": "#B71C1C"}
ax.barh(range(4), ratio, color=[colors[g[3]] for g in GRADES][::-1], height=0.55)
ax.axvline(1.0, color="#616161", lw=1.0, ls="--")
ax.text(1.12, 3.6, "margin = error", fontsize=8, color="#616161", va="center", ha="left")
ax.plot([0.06], [2], "D", color="#1F4E79", ms=6, clip_on=False)
TXT = [f"{COVENANT - LEV:.3f} against ±{LEV_BAND:.3f}: strong",
f"binds at {100 * P5:.2f}%, error ±{100 * SE5:.3f} points (simulation, seed 8)",
f"{CAPABILITY - CAP_FLOOR:.0f} points against ±{BAND_CAP:.0f}: weaker than the reading",
f"{RISK_CEIL - PEAK:.2f} points against ±{BAND_RISK:.0f}: weaker than the reading"][::-1]
for i, (r_, t_) in enumerate(zip(ratio, TXT)):
ax.text(max(r_, 1.0) + 0.2, i, t_, va="center", fontsize=8)
ax.set(yticks=range(4), yticklabels=names, xlim=(0, 16), ylim=(-0.5, 3.8),
xlabel="margin to the commitment, in errors of its reading",
title="Two passes are thinner than the errors in their readings (seed 26116)")
ax.tick_params(axis="y", labelsize=8.5); plt.tight_layout(); plt.show()as first declared (no levers among the decisions): odds 24.62% > 5% (seed 8) -> (R4) fails odds of a breach by quarter K (%): [ 0.22 1.03 2.68 5.11 8.09 11.3 14.29 16.93 19.36 21.39 23.17 24.62] artifact: the declaration honors the appetite through quarter 3 of 12, and no further with the package (line 170, delay 0.668): odds 5.00%, standard error 0.069 points; price $1.81 million a point leverage with the line fully drawn (1,685 + 170) / 495.6 = 3.743x: margin 0.757, 10.1 times its band of 0.075 capability 58 against the floor of 55: margin 3 against +/-5 strategic risk peaks at 73.55 in month 10.9: margin 1.45 against +/-6 commitment margin error of the reading grade leverage <= 4.5x 0.757 +/-0.075 strong breach odds <= 5% 0.000 +/-0.069 statistical: binds capability >= 55 3.000 +/-5.000 weaker than the reading strategic risk <= 75 1.447 +/-6.000 weaker than the reading fresh paths (seed 26209): the same package breaches 4.91% (no levers: 24.31%); it was fitted to the book's paths, where it binds at exactly 5.00% re-solved on the fresh paths: line 165, delay 0.666 quarters, $10.28 million (-0.16): a statistical certificate carries its paths, its seed and its error

Panel 8 — Issue the certificate (Worked Example 16.1, Step 5; Table 16.4; Theorem 16.4(iii)–(v); Appendix 16.A: −20)
Meridian is GEOP-ready for the program as approved: (R1)–(R4) pass, with the four artifacts on file. The certificate carries its grades and two work orders: the human-resources and engineering offices should tighten the capability survey or protect five points of margin, and the risk office should narrow the band of the risk reading, or the plan should buy margin at the month-11 peak. Phase two must return to (R3) before it is optimized, which is the lifecycle at work: adapt, re-declare, re-certify. The gates come in an order, and Appendix 16.A shows with three small declarations that no gate implies the next and none can be dropped: a cash floor of 350 beside a payout policy that keeps cash at or below 300 fails (R2), and with it (R3) and (R4); a limit written as a strict inequality passes (R1), (R2) and (R4) and fails (R3), with feasible plans but no best one; and Chapter 14's runway passes (R1)–(R3) and fails (R4), since cash four quarters on is at most .
Python Code
R2_OK = D_NOW + B_NOW <= POOL # the joint check passes with the package
GATES = [("(R1) declaration", "lever prices and the scorecard's scale undeclared",
"prices declared; the scale is the board's to declare", "CFO, transformation office, board", True),
("(R2) consistency", f"draw {DRAW0:.0f} + buffer {P90:.0f} = {DRAW0 + P90:.0f} on {POOL:.0f} of cash",
f"{D_NOW:.0f} + {B_NOW:.0f} = {D_NOW + B_NOW:.0f}; {POOL - D_NOW - B_NOW:.0f} unclaimed",
"transformation office, treasury, board", R2_OK),
("(R3) panel", f"fails with (R2), though the core alone is certified ({R_CORE:.2f})",
f"passes; a phase-two link at 0.40 would fail ({R_PH2:.2f})", "risk office, Digital, Industrial Systems",
R2_OK and R_CORE <= RULE),
("(R4) horizon", f"breach odds {100 * P0:.1f}% against 5%", f"{100 * P5:.1f}% with the ${C5:.1f} million package",
"board, CFO, transformation office", R2_OK and P5 <= APPETITE + 1e-12)]
print("Table 16.4, top: the four gates, after Chapter 8 and now ($ million)")
for g, before, now, owners, ok in GATES:
print(f" {g:18s} after Chapter 8: {before}")
print(f" {'':18s} now: {now} -> {'passes' if ok else 'FAILS'}; owners: {owners}")
print(" after Chapter 8, (R1), (R2) and (R4) failed, and by Theorem 16.4(iii) the failure at (R2) is a failure at (R3)"
" as well: the register's certificate alone does not pass the gate")
print("\nTable 16.4, bottom: how strong each pass of (R4) is")
for name, margin, err, grade in GRADES:
print(f" {name:20s} margin {margin:7.3f} error of the reading +/-{err:.3f} {grade}")
READY = all(ok for *_, ok in GATES)
print(f"\nGEOP-ready for the program as approved: {READY} ({sum(ok for *_, ok in GATES)} of 4 gates pass)")
print("work orders: HR and engineering, tighten the capability survey or protect five points of margin; the risk office,"
" narrow the risk reading's band, or buy margin at the month-11 peak; phase two returns to (R3) first")
print("\nAppendix 16.A: no gate implies the next, and none can be dropped")
print(" (R2) fails: a cash floor x >= 350 beside a payout policy x <= 300: no cash level keeps both; the region is empty,"
" so A1 fails, (R3) fails, and no trajectory stays in it, so (R4) fails")
us = 1 - 1 / np.array([10.0, 100.0, 1000.0, 1e6])
print(" (R3) fails, (R4) holds: a limit x < 1 written strictly, decisions u in [0, 1], value x_1 = u; the plans u ="
f" {', '.join(f'{u:g}' for u in us)}, ... keep it, and their values approach 1, which no feasible plan attains")
s, r, cash = 120.0, 50.0, [120.0]
for _ in range(4):
s, r = s - r, max(r - 10.0, 0.0)
cash.append(s)
HONORED = int(np.argmax(np.array(cash) < 0)) - 1
print(f" (R4) fails, (R1)-(R3) pass: Chapter 14's runway, cash 120 above the floor, a burn of 50 cut by at most 10 a"
f" quarter: cash {', '.join(f'{c:.0f}' for c in cash)}: s_4 = 120 - (50 + 40 + 30 + 20) = {cash[-1]:.0f} < 0;"
f" the artifact: the commitments can be kept for {HONORED} quarters")Table 16.4, top: the four gates, after Chapter 8 and now ($ million)
(R1) declaration after Chapter 8: lever prices and the scorecard's scale undeclared
now: prices declared; the scale is the board's to declare -> passes; owners: CFO, transformation office, board
(R2) consistency after Chapter 8: draw 138 + buffer 187 = 325 on 270 of cash
now: 122 + 17 = 139; 131 unclaimed -> passes; owners: transformation office, treasury, board
(R3) panel after Chapter 8: fails with (R2), though the core alone is certified (0.80)
now: passes; a phase-two link at 0.40 would fail (1.02) -> passes; owners: risk office, Digital, Industrial Systems
(R4) horizon after Chapter 8: breach odds 24.6% against 5%
now: 5.0% with the $10.4 million package -> passes; owners: board, CFO, transformation office
after Chapter 8, (R1), (R2) and (R4) failed, and by Theorem 16.4(iii) the failure at (R2) is a failure at (R3) as well: the register's certificate alone does not pass the gate
Table 16.4, bottom: how strong each pass of (R4) is
leverage <= 4.5x margin 0.757 error of the reading +/-0.075 strong
breach odds <= 5% margin 0.000 error of the reading +/-0.069 statistical: binds
capability >= 55 margin 3.000 error of the reading +/-5.000 weaker than the reading
strategic risk <= 75 margin 1.447 error of the reading +/-6.000 weaker than the reading
GEOP-ready for the program as approved: True (4 of 4 gates pass)
work orders: HR and engineering, tighten the capability survey or protect five points of margin; the risk office, narrow the risk reading's band, or buy margin at the month-11 peak; phase two returns to (R3) first
Appendix 16.A: no gate implies the next, and none can be dropped
(R2) fails: a cash floor x >= 350 beside a payout policy x <= 300: no cash level keeps both; the region is empty, so A1 fails, (R3) fails, and no trajectory stays in it, so (R4) fails
(R3) fails, (R4) holds: a limit x < 1 written strictly, decisions u in [0, 1], value x_1 = u; the plans u = 0.9, 0.99, 0.999, 0.999999, ... keep it, and their values approach 1, which no feasible plan attains
(R4) fails, (R1)-(R3) pass: Chapter 14's runway, cash 120 above the floor, a burn of 50 cut by at most 10 a quarter: cash 120, 70, 30, 0, -20: s_4 = 120 - (50 + 40 + 30 + 20) = -20 < 0; the artifact: the commitments can be kept for 3 quarters
Panel 9 — The dependency navigator: trace Theorem 16.4 to its foundations (AXIOM Lab 1.16, step 4; Theorem 16.5(i); Figure 16.2; Online Appendix 16.B.1: 211 results, 302 citations, 15 steps)
AXIOM Lab 1.16, step 4. Clause (i) of Theorem 16.5 is a property of the text, and the book checked it mechanically: a script read every chapter and the Online Appendix and recorded an arc from each numbered result to every result cited in its statement or proof. The next cell carries that graph as data, exactly as the script reads it from the book's source, with the nine pointers to illustrations that the citing proofs do not use set aside. Among the 211 numbered results and their 302 citations, 138 stay within a chapter and 164 point to earlier chapters (Figure 16.2); none points to a later chapter, and there is no loop. Sixty-two results cite no other result of the volume: they rest on definitions and on classical results cited to their sources. The longest chains have 15 citations; there are eight of them, starting at Theorem 16.1 or Example 16.B.2 and ending at Theorem 3.3 or Proposition 5.1. Trace Theorem 16.4 to the results it rests on, and find where its longest chain ends.
Python Code
# Volume I's citation graph (Online Appendix 16.B.1) as the book's script reads it from the source: each numbered
# result, then ':' and the results it cites. T theorem, P proposition, L lemma, C corollary; numbers N.B.k are the
# Online Appendix's, where E is an example, R a remark and S a result.
GRAPH = '''
P1.1 P1.2 S1.B.1 S1.B.2
P2.1 T2.1 P2.2:T2.1 T2.2 P2.3:T2.1 R2.B.1:P2.2 C2.B.2:T2.2
P3.1 T3.1 P3.2 T3.2:P3.1 P3.3 T3.3 R3.B.1
P4.1:T4.1 T4.1:T3.3 P4.2 T4.2 P4.3:P3.1 T4.3:T2.1 P4.B.1
P5.1 T5.1:T2.1 P5.2:T3.3,P5.1 T5.2:T3.3,P5.2 P5.3:P3.1 T5.3:T2.1,T5.4 P5.4:P5.3,T5.3 T5.4 P5.5 T5.5 E5.B.1:T5.3
E5.B.2 R5.B.3 E5.B.4:T5.4 R5.B.5:E5.B.4 E5.B.6:T5.4 E5.B.7:T5.4
P6.1 T6.1:P2.2 P6.2:P3.1 T6.2:P3.1,T3.2,P6.2,P6.3,P6.4 P6.3 T6.3:T5.5,P6.2 P6.4:P3.1 T6.4 P6.5:P6.2 T6.5:T5.4
E6.B.1:T5.4,T6.1 R6.B.2 R6.B.3:T6.4
P7.1:T7.1 T7.1:T2.1,P5.3,T5.3,T5.4,E5.B.1 P7.2:T7.1,T7.2 T7.2:T7.1 P7.3:P7.1,T7.1 T7.3:P5.3,T7.1,P7.3,P7.4
P7.4:T5.3,P7.2 T7.4 P7.5:P2.2 T7.5:T7.4,P7.5 E7.B.1 E7.B.2:T7.2 E7.B.3 E7.B.4:P7.2 L7.B.5
P7.B.6:T7.4,T7.5,L7.B.5 E7.B.7:T7.5 R7.B.8:P2.3,E7.B.7
L8.1 P8.1:T4.3 T8.1:T2.1,P2.2,T5.2,T5.3,L8.1 P8.2:T8.1 T8.2:T8.1 P8.3 T8.3:T7.4 P8.4:T8.1 T8.4:T8.5 P8.5:T6.2
T8.5 E8.B.1:T8.3 E8.B.2:T8.2 E8.B.3:T8.3 R8.B.4 E8.B.5 E8.B.6:T8.5 E8.B.7:T8.5
P9.1:T9.1 T9.1:T2.1 P9.2:T9.1 T9.2 P9.3 T9.3:T9.2 P9.4:P9.3 T9.4 P9.5:T4.2,T9.1 T9.5:T4.1 P9.6 E9.B.1:T9.2
P9.B.2:T9.2 P9.B.3 P9.B.4 E9.B.5:T9.4,P9.B.4 P9.B.6:T9.4 E9.B.7
P10.1 T10.1:T10.5 P10.2 T10.2:T9.1,T9.2 P10.3:T6.4 T10.3:T7.2 P10.4:P10.3,T10.3 T10.4 P10.5:T10.5
T10.5:T4.2,T9.4 P10.B.1 P10.B.2:T10.3 E10.B.3:T10.4 E10.B.4:T10.4 P10.B.5:T10.5 E10.B.6
P11.1:T9.5 T11.1:T7.1,T8.1,P8.2,P11.1 P11.2:T11.4 T11.2 P11.3:T8.2,T8.5,T11.1 T11.3:T9.2 T11.4:P11.B.4
T11.5:T4.2,T9.4 P11.B.1:T11.3 E11.B.2 E11.B.3:T11.2 P11.B.4 E11.B.5:T11.5 E11.B.6
P12.1:T9.5,P10.1,P11.1 T12.1:P8.2 P12.2 T12.2 T12.3:T7.3,T7.4,T8.3,T11.2 T12.4:T8.4,T12.2 T12.5:T7.4,T9.2
P12.B.1:T12.1 E12.B.2:T12.2 P12.B.3:T12.5 E12.B.4:T12.5 E12.B.5:T12.4 E12.B.6
P13.1:P9.1 T13.1:T6.1,T6.4,T8.2,T9.1,T9.2,T11.2,T12.1 P13.2:T9.2,T13.1 T13.2:T4.2,T9.1,T9.3,T13.5
P13.3:T12.5,T13.3 T13.3:T12.5 P13.4:T12.5,P13.3 T13.4:T7.1,T8.1,T8.2,T8.5,T10.1,T13.1,P13.2,T13.5 P13.5
T13.5:T4.2,T9.4,P9.5,T13.1,T13.3 P13.B.1 E13.B.2:T13.5 E13.B.3:P13.2,T13.4 E13.B.4
P14.1:T5.5,T6.2,T13.1,T13.5,T14.5,E14.B.2 T14.1:T5.3,T5.4,P6.2,T8.1,T8.2,T13.1,T14.5,E14.B.2 P14.2 T14.2
P14.3:T9.2,T13.3,T14.4 T14.3:T3.1,T7.4,T11.1 P14.4:T13.3 T14.4:T12.5,T13.3,T14.3 P14.5 T14.5:T5.5,T6.3,T13.5
T14.6:T3.1,T6.2,T13.2,T14.1,T14.2,P14.3,T14.3,T14.4 T14.7:T8.3,T12.3,T13.4,T13.5,T14.5 T14.8:T5.4,T8.3,T8.5
P14.B.1 E14.B.2:T14.5 E14.B.3:E12.B.4,P14.B.1
P15.1:P13.5 T15.1:P7.2,T10.1,T12.1 P15.2:T8.1,T8.2 T15.2:T14.5,T15.3 P15.3:T15.3 T15.3:T14.4
P15.4:T13.5,T14.5,T15.2 T15.4:T5.4,T14.5,T15.2,T15.3,E15.B.2 P15.5:T10.4,T14.4,T15.3 T15.5:T11.4,T15.2,T15.3
P15.6:T6.2 T15.6:T13.3,T14.3 P15.7:E15.B.4 T15.7:T13.5,T15.1,T15.2,T15.3,T15.4,P15.5,T15.5,T15.6,P15.7
P15.8:E15.B.4 P15.9:P14.B.1 E15.B.1:T14.4,P15.5 E15.B.2:E14.B.2 E15.B.3:T15.3,T15.6,P15.9 E15.B.4:T15.3,T15.5
P16.1:T4.3,T15.4 T16.1:T13.1,T13.5,P14.1,T14.6,T15.1,T15.2,T15.7,T16.4,E16.B.3 T16.2:T4.1,T13.1,T15.1
T16.3:T14.1,T14.2,T15.1,T15.5,T15.7 T16.4:T14.5,T14.6,T15.2,T15.7 T16.5:T13.1,T13.2,T15.7,E16.B.1 E16.B.1
E16.B.2:T16.5 E16.B.3:E14.B.3,E15.B.4
'''
# the nine pointers to illustrations that the citing proof does not use, set aside (Online Appendix 16.B.1)
POINTERS = "T5.4>T5.3 T7.1>P7.1 T7.1>P7.4 P7.2>E7.B.4 T9.2>E9.B.1 T14.5>E14.B.2 P15.5>E15.B.1 P15.9>E15.B.3 T15.2>E15.B.4"
KIND = {"T": "Theorem", "P": "Proposition", "L": "Lemma", "C": "Corollary", "E": "Example", "R": "Remark", "S": "Result"}Python Code
CITES = {}
for tok in GRAPH.split():
name, _, cited = tok.partition(":")
CITES[name] = cited.split(",") if cited else []
NODES = list(CITES)
EDGES = [(a, b) for a in NODES for b in CITES[a]]
chap = lambda n: int(n[1:].split(".")[0])
label = lambda n: f"{KIND[n[0]]} {n[1:]}"
key = lambda n: tuple(int(p) if p.isdigit() else 0 for p in n[1:].split(".")) # the script's order, for ties
book = lambda n: (chap(n), ".B." in n, int(n.split(".")[-1]), n[0]) # book order: N.k, then N.B.k
MAT = np.zeros((16, 16), dtype=int) # Figure 16.2: citing chapter (row) by cited chapter (column)
for a, b in EDGES:
MAT[chap(a) - 1, chap(b) - 1] += 1
print(f"{len(NODES)} numbered results, {len(EDGES)} citations among them, {len(POINTERS.split())} pointers set aside")
print(f"within a chapter {np.trace(MAT)}, to earlier chapters {np.tril(MAT, -1).sum()}, to later chapters"
f" {np.triu(MAT, 1).sum()}")
print("results per chapter:", [sum(chap(n) == c for n in NODES) for c in range(1, 17)])
print("Figure 16.2 (rows cite, columns are cited; chapters 1-16):")
for i in range(16):
print(f" {i + 1:2d} " + " ".join(f"{v:2d}" if v else " ." for v in MAT[i]))
def topological(cites):
# Kahn's algorithm: place a result once everything it cites is placed; a loop leaves results unplaced
left, order, placed = {n: set(c) for n, c in cites.items()}, [], set()
ready = sorted([n for n in left if not left[n]], key=book)
while ready:
n = ready.pop(0)
order.append(n); placed.add(n)
for m in sorted(left, key=book):
if m not in placed and m not in ready and left[m] and n in left[m]:
left[m].discard(n)
if not left[m]:
ready.append(m)
ready.sort(key=book)
return order, [n for n in cites if n not in placed]
ORDER, STUCK = topological(CITES)
print(f"\nKahn's algorithm places all {len(ORDER)} results: no loop ({len(STUCK)} left over)")
RAW = {n: list(c) for n, c in CITES.items()}
for p in POINTERS.split():
a, b = p.split(">"); RAW[a].append(b)
ix = {n: i for i, n in enumerate(NODES)}
REACH = np.eye(len(NODES), dtype=bool)
for a in NODES:
for b in RAW[a]:
REACH[ix[a], ix[b]] = True
for _ in range(9): # 2^9 > 211: the transitive closure by repeated squaring
REACH = REACH | ((REACH.astype(np.int32) @ REACH.astype(np.int32)) > 0)
LOOPS = {frozenset(NODES[j] for j in np.nonzero(REACH[i] & REACH[:, i])[0]) for i in range(len(NODES))}
LOOPS = sorted([sorted(c, key=book) for c in LOOPS if len(c) > 1], key=lambda c: book(c[0]))
print(f"with the nine pointers put back, the graph has {len(LOOPS)} loops:",
"; ".join(", ".join(label(n) for n in c) for c in LOOPS))
BEST, NEXT, COUNT = {}, {}, {} # longest chain of citations below each result
for v in ORDER: # cited results come first
if not CITES[v]:
BEST[v], NEXT[v], COUNT[v] = 0, None, 1
continue
top = max(BEST[w] for w in CITES[v])
on = sorted([w for w in CITES[v] if BEST[w] == top], key=key)
BEST[v], NEXT[v], COUNT[v] = top + 1, on[0], sum(COUNT[w] for w in on)
SINKS = [n for n in NODES if not CITES[n]]
LONGEST = max(BEST.values())
STARTS = sorted([n for n in NODES if BEST[n] == LONGEST], key=book)
N_CHAINS = sum(COUNT[n] for n in STARTS)
ENDS = set()
def walk(u):
if BEST[u] == 0:
ENDS.add(u); return
for w in CITES[u]:
if BEST[w] == BEST[u] - 1:
walk(w)
for s0 in STARTS:
walk(s0)
CHAIN = [STARTS[0]]
while NEXT[CHAIN[-1]]:
CHAIN.append(NEXT[CHAIN[-1]])
print(f"{len(SINKS)} results cite no other result; the longest chains have {LONGEST} citations: {N_CHAINS} of them,"
f" starting at {' or '.join(label(n) for n in STARTS)} and ending at {' or '.join(label(n) for n in sorted(ENDS, key=book))}")
print("one of them:", " -> ".join(label(n) for n in CHAIN))
T164 = "T16.4"
BELOW, stack = set(), [T164]
while stack:
for w in CITES[stack.pop()]:
if w not in BELOW:
BELOW.add(w); stack.append(w)
print(f"\nTheorem 16.4 cites {', '.join(label(w) for w in CITES[T164])}")
print(f"it rests on {len(BELOW)} results, by chapter:", {c: sum(chap(n) == c for n in BELOW) for c in range(1, 17)
if any(chap(n) == c for n in BELOW)})
c4, u = [T164], T164
while NEXT[u]:
u = NEXT[u]; c4.append(u)
print(f"its longest chain has {BEST[T164]} citations and ends at {label(c4[-1])}:", " -> ".join(label(n) for n in c4))
fig, ax = plt.subplots(figsize=(7.6, 3.6))
pos = {}
for c in range(1, 17):
members = sorted([n for n in NODES if chap(n) == c], key=book)
for i, n in enumerate(members):
pos[n] = (c + (i - (len(members) - 1) / 2) * 0.6 / max(len(members), 1), BEST[n])
xs, ys = zip(*pos.values())
ax.scatter(xs, ys, s=10, color="#9DB3CF", zorder=2, label="a numbered result")
cx, cy = zip(*[pos[n] for n in CHAIN])
ax.plot(cx, cy, "o-", color="#B71C1C", lw=1.4, ms=4, zorder=3, label="a longest chain: Theorem 16.1 to Theorem 3.3")
gx, gy = zip(*[pos[n] for n in c4])
ax.plot(gx[:1], gy[:1], "D", color="#5E35B1", ms=7, zorder=4, label="Theorem 16.4")
ax.set(xticks=range(1, 17), xlim=(0.4, 16.6), ylim=(-0.8, 16.5), xlabel="chapter",
ylabel="longest chain of citations below",
title="No citation points to a later chapter; the longest chain has 15 steps (seed 26116)")
ax.legend(frameon=False, fontsize=8, loc="upper left"); plt.tight_layout(); plt.show()211 numbered results, 302 citations among them, 9 pointers set aside
within a chapter 138, to earlier chapters 164, to later chapters 0
results per chapter: [4, 7, 7, 7, 17, 13, 18, 18, 18, 16, 14, 13, 14, 16, 20, 9]
Figure 16.2 (rows cite, columns are cited; chapters 1-16):
1 . . . . . . . . . . . . . . . .
2 . 4 . . . . . . . . . . . . . .
3 . . 1 . . . . . . . . . . . . .
4 . 1 2 1 . . . . . . . . . . . .
5 . 2 3 . 10 . . . . . . . . . . .
6 . 1 4 . 3 7 . . . . . . . . . .
7 . 3 . . 6 . 19 . . . . . . . . .
8 . 2 . 1 2 1 1 10 . . . . . . . .
9 . 1 . 2 . . . . 10 . . . . . . .
10 . . . 1 . 1 1 . 3 8 . . . . . .
11 . . . 1 . . 1 4 3 . 7 . . . . .
12 . . . . . . 3 3 2 1 2 6 . . . .
13 . . . 2 . 2 1 4 8 1 1 4 12 . . .
14 . . 2 . 5 4 1 5 1 . 1 3 10 14 . .
15 . . . . 1 1 1 2 . 2 1 1 4 9 25 .
16 . . . 2 . . . . . . . . 5 7 12 4
Kahn's algorithm places all 211 results: no loop (0 left over)
with the nine pointers put back, the graph has 7 loops: Theorem 5.3, Theorem 5.4; Proposition 7.1, Theorem 7.1, Proposition 7.2, Theorem 7.2, Proposition 7.4, Example 7.B.4; Theorem 9.2, Example 9.B.1; Theorem 14.5, Example 14.B.2; Theorem 15.2, Theorem 15.5, Example 15.B.4; Proposition 15.5, Example 15.B.1; Proposition 15.9, Example 15.B.3
62 results cite no other result; the longest chains have 15 citations: 8 of them, starting at Theorem 16.1 or Example 16.B.2 and ending at Theorem 3.3 or Proposition 5.1
one of them: Theorem 16.1 -> Theorem 16.4 -> Theorem 15.7 -> Proposition 15.7 -> Example 15.B.4 -> Theorem 15.5 -> Theorem 15.2 -> Theorem 14.5 -> Theorem 13.5 -> Theorem 13.1 -> Theorem 12.1 -> Proposition 8.2 -> Theorem 8.1 -> Theorem 5.2 -> Proposition 5.2 -> Theorem 3.3
Theorem 16.4 cites Theorem 14.5, Theorem 14.6, Theorem 15.2, Theorem 15.7
it rests on 70 results, by chapter: {2: 2, 3: 4, 4: 2, 5: 8, 6: 7, 7: 4, 8: 4, 9: 6, 10: 3, 11: 5, 12: 2, 13: 4, 14: 8, 15: 11}
its longest chain has 14 citations and ends at Theorem 3.3: Theorem 16.4 -> Theorem 15.7 -> Proposition 15.7 -> Example 15.B.4 -> Theorem 15.5 -> Theorem 15.2 -> Theorem 14.5 -> Theorem 13.5 -> Theorem 13.1 -> Theorem 12.1 -> Proposition 8.2 -> Theorem 8.1 -> Theorem 5.2 -> Proposition 5.2 -> Theorem 3.3

Panel 10 — Export the certified instance for Volume II (AXIOM Lab 1.16, step 5; Table 16.3)
AXIOM Lab 1.16, step 5, the Volume II transition environment. Volume I delivers the unified system and its certificates, the GEOP and its audits, multipliers with their meaning, and the honesty clauses and the readiness gates; Volume II consumes them unchanged (Table 16.3). The cell writes Meridian's certified instance in the canonical form that Volume II's method modules consume, decisions, objective, dynamics and commitments, each with its owner, together with the certificate, its grades, the work orders and the conditions under which it lapses, as one JSON document. A consumer that reads only the document, regenerates the environment from its declaration and solves the problem finds the book's package again: the export is complete.
Python Code
INSTANCE = {
"instance": "Meridian Group: the digital program's risk levers (Worked Examples 15.1 and 16.1)",
"canonical_form": "max over u in D of J(x, u) subject to x = f(u), g_i(x, u) <= 0",
"decisions": [{"name": "line", "unit": "$ million", "domain": [0, 400], "step": 5, "owner": "CFO"},
{"name": "delay", "unit": "quarters", "domain": [0, 7], "owner": "transformation office"}],
"objective": {"sense": "min", "expression": "fee * line + value_of_delay * delay", "fee": FEE,
"value_of_delay": VQ, "owners": ["CFO", "transformation office"]},
"dynamics": {"usd_per_point": 6.2, "index_today": 100.0, "index_target": 112.0, "relaxation": 0.35,
"years_to_deepest": 2.0, "depth": DEPTH0, "depth_cut_per_quarter_of_delay": DEPTH_PER_Q,
"quarters": Q},
"environment": {"deviation_persistence": A_E, "deviation_sd": SD_W, "closures_a_year": LAM,
"closure_mean": J_MEAN, "closure_sd": J_SD, "closure_law": "gamma", "paths": N, "seed": BOOK_SEED},
"policy_class": "a package committed today (open loop)",
"commitments": [
{"name": "appetite", "g": "P(liquidity < floor in some quarter) - 0.05 <= 0", "floor": FLOOR, "level": APPETITE,
"owner": "board", "form": "chance constraint"},
{"name": "covenant", "g": "(net_debt + line) / ebitda - 4.5 <= 0", "net_debt": NET_DEBT, "ebitda": EBITDA,
"owner": "CFO"},
{"name": "capability floor", "g": "55 - capability <= 0", "owner": "HR, CTO"},
{"name": "strategic-risk ceiling", "g": "peak strategic risk - 75 <= 0", "owner": "CRO, board"},
{"name": "register", "g": "|A_ij| - M_ij <= 0, every core link at most 0.40", "owner": "risk office"}],
"certificate": {
"gates": {g.split()[0]: ("pass" if ok else "fail") for g, *_, ok in GATES},
"grades": {name: grade for name, margin, err, grade in GRADES},
"work_orders": ["HR and engineering: tighten the capability survey or protect five points of margin",
"risk office: narrow the risk reading's band, or buy margin at the month-11 peak",
"phase two: declare the Digital-Industrial Systems link and return to (R3) before optimizing"],
"lapses_if": [f"(R3) the gain audit reads a core link above its ceiling of {CEIL:.2f} by more than its error",
"(R3) the phase-two Digital-Industrial Systems link appears before it is declared and bought down",
f"(R4) a reading crosses its commitment: capability below {CAP_FLOOR:.0f}, strategic risk above"
f" {RISK_CEIL:.0f}, net leverage above {COVENANT}x",
"(R1)-(R2) a declared price, law, owner or commitment changes: re-declare, then re-run the gates"
" in order"]},
"solution": {"line": L5, "delay": PH5, "cost": C5, "odds": P5, "seed": BOOK_SEED}}
DOC = json.dumps(INSTANCE, indent=1)
print(f"the certified instance: {len(DOC):,} characters of JSON; sections: {', '.join(INSTANCE)}")
for d in INSTANCE["decisions"]:
print(f" decision {d['name']:7s} {d['domain'][0]} to {d['domain'][1]} {d['unit']:9s} ({d['owner']})")
print(f" objective minimize {INSTANCE['objective']['expression']} with fee {FEE}, value of delay {VQ}")
for c in INSTANCE["commitments"]:
print(f" commitment {c['g']:58s} ({c['owner']})")
print(" certificate", ", ".join(f"{g} {v}" for g, v in INSTANCE["certificate"]["gates"].items()), "| grades:",
"; ".join(f"{k} {v}" for k, v in INSTANCE["certificate"]["grades"].items()))
for w in INSTANCE["certificate"]["work_orders"]:
print(" work order ", w)
for w in INSTANCE["certificate"]["lapses_if"]:
print(" lapses if ", w)
def consume(doc):
# what a Volume II method module does: read the document only, rebuild the environment, solve
d = json.loads(doc)
dyn, env, obj = d["dynamics"], d["environment"], d["objective"]
t = np.arange(1, dyn["quarters"] + 1) / 4
base = dyn["usd_per_point"] * relax(dyn["index_today"], dyn["index_target"], dyn["relaxation"], t)
shape = dyn["usd_per_point"] * hump(1.0, dyn["years_to_deepest"], t)
appetite = next(c for c in d["commitments"] if c["name"] == "appetite")
S = Stream(env["seed"], n=env["paths"], a=env["deviation_persistence"], sd=env["deviation_sd"],
lam=env["closures_a_year"], mean=env["closure_mean"], sdj=env["closure_sd"], base=base, shape=shape,
floor=appetite["floor"], depth0=dyn["depth"], per_q=dyn["depth_cut_per_quarter_of_delay"])
lo, hi = d["decisions"][0]["domain"]
lines = np.arange(lo, hi + 1e-9, d["decisions"][0]["step"])
return cheapest(S, appetite["level"], fee=obj["fee"], vq=obj["value_of_delay"], lines=lines), S
(RL, RPH, RC), S2 = consume(DOC)
print(f"\nre-solved from the document alone: line {RL:.0f}, delay {RPH:.3f} quarters, cost ${RC:.2f} million,"
f" odds {100 * S2.odds(RL, RPH):.2f}%; identical to the certified package: {(RL, RPH, RC) == (L5, PH5, C5)}")the certified instance: 2,988 characters of JSON; sections: instance, canonical_form, decisions, objective, dynamics, environment, policy_class, commitments, certificate, solution decision line 0 to 400 $ million (CFO) decision delay 0 to 7 quarters (transformation office) objective minimize fee * line + value_of_delay * delay with fee 0.03, value of delay 8.0 commitment P(liquidity < floor in some quarter) - 0.05 <= 0 (board) commitment (net_debt + line) / ebitda - 4.5 <= 0 (CFO) commitment 55 - capability <= 0 (HR, CTO) commitment peak strategic risk - 75 <= 0 (CRO, board) commitment |A_ij| - M_ij <= 0, every core link at most 0.40 (risk office) certificate (R1) pass, (R2) pass, (R3) pass, (R4) pass | grades: leverage <= 4.5x strong; breach odds <= 5% statistical: binds; capability >= 55 weaker than the reading; strategic risk <= 75 weaker than the reading work order HR and engineering: tighten the capability survey or protect five points of margin work order risk office: narrow the risk reading's band, or buy margin at the month-11 peak work order phase two: declare the Digital-Industrial Systems link and return to (R3) before optimizing lapses if (R3) the gain audit reads a core link above its ceiling of 0.40 by more than its error lapses if (R3) the phase-two Digital-Industrial Systems link appears before it is declared and bought down lapses if (R4) a reading crosses its commitment: capability below 55, strategic risk above 75, net leverage above 4.5x lapses if (R1)-(R2) a declared price, law, owner or commitment changes: re-declare, then re-run the gates in order re-solved from the document alone: line 170, delay 0.668 quarters, cost $10.44 million, odds 5.00%; identical to the certified package: True
Validation — the book's numbers, and agreement with DCT_V1_Ch16_Lab.xlsx
Each checkpoint is a number printed in Chapter 16 (Worked Example 16.1, Tables 16.1 and 16.4, Sections 16.2 and 16.5,
Appendix 16.A) or in Online Appendix 16.B (Examples 16.B.1–16.B.3, the proof of Theorem 16.2), with the counts the
inventory of Step 1 states. Simulated checkpoints use the book's paths (seed 8) or, for Example 16.B.2, the engine's
seed 16. The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine
values on its Checks sheet.
Python Code
LIM = lambda name: next(g for g in GRADES if g[0].startswith(name))
checks = [
("Table 16.1, L1: deepest draw (workbook)", DRAW0, 138.0, 0.05),
("Table 16.1, L1: buffer for a 90th-percentile closure (workbook)", P90, 186.9, 0.05),
("Table 16.1, L2: breach odds, no levers, % (seed 8)", 100 * P0, 24.62, 0.005),
("Table 16.1, L2: the average path's trough (workbook)", MEAN_PATH.min(), 460, 0.5),
("Table 16.1, L3: weight points that tie the leaders (workbook)", 100 * TIE, 1.6, 0.05),
("Table 16.1, L4: half-life in the core, quarters (workbook)", half_life(R_CORE), 3.11, 0.005),
("Table 16.1, L5: least cost at 5% (workbook)", C5, 10.4, 0.05),
("Table 16.1, L5: implied cost of a breach (workbook)", 100 * LAMBDA, 180, 1.0),
("Theorem 16.2: unit A in year 5 (workbook)", HA, 392, 0.5),
("Theorem 16.2: unit B in year 5 (workbook)", HB, 404, 0.5),
("Theorem 16.2: engineers apart (workbook)", HB - HA, 12, 0.5),
("Theorem 16.2: the totals model for both (workbook)", TOTALS5, 391, 0.5),
("R1: state readings declared", len(READINGS), 8, 0),
("R1: components (workbook)", len(COMPONENTS), 7, 0),
("R1: typed arrows (workbook)", len(ARROWS), 14, 0),
("R1: two-way links in the feedback core (workbook)", len(TWO_WAY), 4, 0),
("R1: standing commitments (workbook)", len(COMMITMENTS), 5, 0),
("R1: elements of the GEOP (workbook)", len(GEOP_ELEMENTS), 6, 0),
("R1: Chapter 8 package, cost (workbook)", C_PKG, 19.0, 0.005),
("R1: Chapter 8 package, odds, % (seed 8)", 100 * P_PKG, 3.0, 0.05),
("R1: cheapest at the package's odds (workbook)", F_PKG[2], 14.67, 0.005),
("R1: cost of choosing without prices (workbook)", C_PKG - F_PKG[2], 4.33, 0.005),
("R1: best-to-worst, restructuring (workbook)", BTW[1], 52.3, 0.05),
("R1: best-to-worst, digital (workbook)", BTW[0], 41.4, 0.05),
("R1: best-to-worst, turnaround (workbook)", BTW[2], 35.3, 0.05),
("R1: percentage improvement, digital (workbook)", PCT[0], 24.0, 0.05),
("R1: percentage improvement, restructuring (workbook)", PCT[1], 10.6, 0.05),
("R1: percentage improvement, turnaround (workbook)", PCT[2], 0.0, 0.05),
("R2: draw + buffer as declared (workbook)", DRAW0 + P90, 324.9, 0.05),
("R2: short by (workbook)", DRAW0 + P90 - POOL, 54.9, 0.05),
("R2: the package's line (workbook)", L5, 170, 0),
("R2: the package's delay, quarters (workbook)", PH5, 0.668, 5e-4),
("R2: deepest draw with the delay (workbook)", D_NOW, 121.6, 0.05),
("R2: buffer the line leaves (workbook)", B_NOW, 16.9, 0.05),
("R2: draw + buffer now (workbook)", D_NOW + B_NOW, 138.5, 0.05),
("R2: unclaimed (workbook)", POOL - D_NOW - B_NOW, 131.5, 0.05),
("R3: spectral radius of the core (workbook)", R_CORE, 0.800, 5e-4),
("R3: the board's rule 2^(-1/4) (workbook)", RULE, 0.841, 5e-4),
("R3: multiplier (workbook)", multiplier(R_CORE), 5.00, 0.005),
("R3: echo of $10m, next quarter (workbook)", EC[1], 8.0, 1e-9),
("R3: echo of $10m, the quarter after (workbook)", EC[2], 6.4, 1e-9),
("R3: echo of $10m, in all (workbook)", EC.sum(), 50, 0.01),
("R3: phase-two link at 0.40, spectral radius (workbook)", R_PH2, 1.025, 5e-4),
("R3: repair, new link at most (workbook)", H_MAX, 0.080, 5e-4),
("R3: repair, treasury links at most (workbook)", T_MAX, 0.159, 5e-4),
("R3: repair, all four links at (workbook)", TRIM, 0.304, 5e-4),
("16.B.2: models above the register's radius (seed 16)", OR16, 0, 0),
("16.B.2: echoes above the register's bound (seed 16)", OE16, 0, 0),
("16.B.2: the register's echo, quarter 3 (workbook)", BOUND[3], 5.12, 1e-9),
("R4: breach odds with the package, % (seed 8)", 100 * P5, 5.00, 0.005),
("R4: standard error, points (workbook)", 100 * SE5, 0.069, 5e-4),
("R4: leverage with the line fully drawn (workbook)", LEV, 3.743, 5e-4),
("R4: covenant margin (workbook)", COVENANT - LEV, 0.757, 5e-4),
("R4: covenant band, 2% of the reading (workbook)", LEV_BAND, 0.075, 5e-4),
("R4: capability margin (workbook)", CAPABILITY - CAP_FLOOR, 3, 0),
("R4: strategic risk, peak (workbook)", PEAK, 73.55, 0.005),
("R4: strategic risk, month of the peak (workbook)", PEAK_MONTH, 10.9, 0.05),
("R4: strategic risk, margin (workbook)", RISK_CEIL - PEAK, 1.45, 0.005),
("R4: price of the appetite, $m a point (workbook)", LAMBDA, 1.8, 0.05),
("Certificate: gates passing now (workbook)", sum(ok1 for *_, ok1 in GATES), 4, 0),
("Certificate: thin passes, weaker than the reading (workbook)",
sum(g[3] == "weaker than the reading" for g in GRADES), 2, 0),
("Appendix 16.A: the runway's cash in quarter 4 (workbook)", cash[-1], -20, 0),
("16.B.1: numbered results (workbook)", len(NODES), 211, 0),
("16.B.1: citations (workbook)", len(EDGES), 302, 0),
("16.B.1: pointers set aside", len(POINTERS.split()), 9, 0),
("16.B.1: citations within a chapter (workbook)", np.trace(MAT), 138, 0),
("16.B.1: citations to earlier chapters (workbook)", np.tril(MAT, -1).sum(), 164, 0),
("16.B.1: citations to later chapters (workbook)", np.triu(MAT, 1).sum(), 0, 0),
("16.B.1: results on a loop (workbook)", len(STUCK), 0, 0),
("16.B.1: results citing none (workbook)", len(SINKS), 62, 0),
("16.B.1: longest chain, citations (workbook)", LONGEST, 15, 0),
("16.B.1: chains of that length (workbook)", N_CHAINS, 8, 0),
("Export: re-solved least cost (workbook)", RC, 10.44, 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-9 else "FAIL"; ok += status == "PASS"
print(f"{name:{width}s} {got:12.4f} book {want:10.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")Table 16.1, L1: deepest draw (workbook) 138.0496 book 138.0000 PASS Table 16.1, L1: buffer for a 90th-percentile closure (workbook) 186.8670 book 186.9000 PASS Table 16.1, L2: breach odds, no levers, % (seed 8) 24.6220 book 24.6200 PASS Table 16.1, L2: the average path's trough (workbook) 459.8541 book 460.0000 PASS Table 16.1, L3: weight points that tie the leaders (workbook) 1.5924 book 1.6000 PASS Table 16.1, L4: half-life in the core, quarters (workbook) 3.1063 book 3.1100 PASS Table 16.1, L5: least cost at 5% (workbook) 10.4406 book 10.4000 PASS Table 16.1, L5: implied cost of a breach (workbook) 180.7015 book 180.0000 PASS Theorem 16.2: unit A in year 5 (workbook) 392.0572 book 392.0000 PASS Theorem 16.2: unit B in year 5 (workbook) 403.7791 book 404.0000 PASS Theorem 16.2: engineers apart (workbook) 11.7218 book 12.0000 PASS Theorem 16.2: the totals model for both (workbook) 390.9802 book 391.0000 PASS R1: state readings declared 8.0000 book 8.0000 PASS R1: components (workbook) 7.0000 book 7.0000 PASS R1: typed arrows (workbook) 14.0000 book 14.0000 PASS R1: two-way links in the feedback core (workbook) 4.0000 book 4.0000 PASS R1: standing commitments (workbook) 5.0000 book 5.0000 PASS R1: elements of the GEOP (workbook) 6.0000 book 6.0000 PASS R1: Chapter 8 package, cost (workbook) 19.0000 book 19.0000 PASS R1: Chapter 8 package, odds, % (seed 8) 3.0030 book 3.0000 PASS R1: cheapest at the package's odds (workbook) 14.6681 book 14.6700 PASS R1: cost of choosing without prices (workbook) 4.3319 book 4.3300 PASS R1: best-to-worst, restructuring (workbook) 52.2640 book 52.3000 PASS R1: best-to-worst, digital (workbook) 41.3999 book 41.4000 PASS R1: best-to-worst, turnaround (workbook) 35.3238 book 35.3000 PASS R1: percentage improvement, digital (workbook) 24.0381 book 24.0000 PASS R1: percentage improvement, restructuring (workbook) 10.6237 book 10.6000 PASS R1: percentage improvement, turnaround (workbook) 0.0246 book 0.0000 PASS R2: draw + buffer as declared (workbook) 324.9166 book 324.9000 PASS R2: short by (workbook) 54.9166 book 54.9000 PASS R2: the package's line (workbook) 170.0000 book 170.0000 PASS R2: the package's delay, quarters (workbook) 0.6676 book 0.6680 PASS R2: deepest draw with the delay (workbook) 121.6344 book 121.6000 PASS R2: buffer the line leaves (workbook) 16.8670 book 16.9000 PASS R2: draw + buffer now (workbook) 138.5013 book 138.5000 PASS R2: unclaimed (workbook) 131.4987 book 131.5000 PASS R3: spectral radius of the core (workbook) 0.8000 book 0.8000 PASS R3: the board's rule 2^(-1/4) (workbook) 0.8409 book 0.8410 PASS R3: multiplier (workbook) 5.0000 book 5.0000 PASS R3: echo of $10m, next quarter (workbook) 8.0000 book 8.0000 PASS R3: echo of $10m, the quarter after (workbook) 6.4000 book 6.4000 PASS R3: echo of $10m, in all (workbook) 50.0000 book 50.0000 PASS R3: phase-two link at 0.40, spectral radius (workbook) 1.0246 book 1.0250 PASS R3: repair, new link at most (workbook) 0.0798 book 0.0800 PASS R3: repair, treasury links at most (workbook) 0.1593 book 0.1590 PASS R3: repair, all four links at (workbook) 0.3044 book 0.3040 PASS 16.B.2: models above the register's radius (seed 16) 0.0000 book 0.0000 PASS 16.B.2: echoes above the register's bound (seed 16) 0.0000 book 0.0000 PASS 16.B.2: the register's echo, quarter 3 (workbook) 5.1200 book 5.1200 PASS R4: breach odds with the package, % (seed 8) 5.0000 book 5.0000 PASS R4: standard error, points (workbook) 0.0689 book 0.0690 PASS R4: leverage with the line fully drawn (workbook) 3.7430 book 3.7430 PASS R4: covenant margin (workbook) 0.7570 book 0.7570 PASS R4: covenant band, 2% of the reading (workbook) 0.0749 book 0.0750 PASS R4: capability margin (workbook) 3.0000 book 3.0000 PASS R4: strategic risk, peak (workbook) 73.5525 book 73.5500 PASS R4: strategic risk, month of the peak (workbook) 10.9000 book 10.9000 PASS R4: strategic risk, margin (workbook) 1.4475 book 1.4500 PASS R4: price of the appetite, $m a point (workbook) 1.8070 book 1.8000 PASS Certificate: gates passing now (workbook) 4.0000 book 4.0000 PASS Certificate: thin passes, weaker than the reading (workbook) 2.0000 book 2.0000 PASS Appendix 16.A: the runway's cash in quarter 4 (workbook) -20.0000 book -20.0000 PASS 16.B.1: numbered results (workbook) 211.0000 book 211.0000 PASS 16.B.1: citations (workbook) 302.0000 book 302.0000 PASS 16.B.1: pointers set aside 9.0000 book 9.0000 PASS 16.B.1: citations within a chapter (workbook) 138.0000 book 138.0000 PASS 16.B.1: citations to earlier chapters (workbook) 164.0000 book 164.0000 PASS 16.B.1: citations to later chapters (workbook) 0.0000 book 0.0000 PASS 16.B.1: results on a loop (workbook) 0.0000 book 0.0000 PASS 16.B.1: results citing none (workbook) 62.0000 book 62.0000 PASS 16.B.1: longest chain, citations (workbook) 15.0000 book 15.0000 PASS 16.B.1: chains of that length (workbook) 8.0000 book 8.0000 PASS Export: re-solved least cost (workbook) 10.4406 book 10.4400 PASS 73 of 73 checkpoints PASS
Next. Volume II opens with this instance. Its Chapter 1 writes every well-posed transformation decision in one canonical form, decisions, an objective, commitments and the company's dynamics, and its Worked Example 1.1, Can Meridian Sign Volume I's Answer?, asks whether the cheapest way to meet the board's appetite survives when credit lines come in tranches and delays in whole quarters. AXIOM-16 runs the readiness chain interactively (Lab 1.16); this notebook and the workbook are its reproducible record.


