Skip to content

Vol. I, Ch. 16

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, Ek+1=0.6Ek+wkE_{k+1} = 0.6E_k + w_k with surprises of standard deviation $50 million; funding windows close about once a decade (λ=0.10\lambda = 0.10 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 ℓ\ell, the CFO's lever, costs 0.03ℓ0.03\ell in fees over the program; a delay of ϕ\phi quarters, the transformation office's, cuts the draw's depth to 28−4ϕ28 - 4\phi 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
The same cash promised twice, and the repair (seed 26116)

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, Aij=MijuijA_{ij} = M_{ij}u_{ij} with uiju_{ij} uniform on [−1,1][-1, 1]. Every spectral radius among them lies below 0.80, and for every one the total echo of a $10 million shock at Digital Solutions, ∣1⊤Aks∣|\mathbf{1}^{\top} \mathbf{A}^{k}\mathbf{s}|, is at most the register's, 10×0.8k10 \times 0.8^{k}: $8 million, $6.4 million, …, $50 million in all. The bound is attained by A=M\mathbf{A} = \mathbf{M}: 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
A drift past its ceiling voids the register's certificate (seed 26116)

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
Two passes are thinner than the errors in their readings (seed 26116)

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 120−(50+40+30+20)=−20120 - (50 + 40 + 30 + 20) = -20.

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
No citation points to a later chapter; the longest chain has 15 steps (seed 26116)

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.

Dynamic Corporate Transformation — Volume I: Foundations and Mathematical Framework; Volume II: Enterprise Optimization & Applications
Jump to any chapter

Volume I: Foundations and Mathematical Framework

  1. Ch. 1Introduction to Dynamic Corporate Transformation
  2. Ch. 2Enterprise Systems and Transformation
  3. Ch. 3Mathematical Foundations
  4. Ch. 4Enterprise Modeling Principles
  5. Ch. 5Enterprise State Representation
  6. Ch. 6Enterprise Transformation Operators
  7. Ch. 7Dynamic Enterprise Systems
  8. Ch. 8Stochastic Enterprise Dynamics
  9. Ch. 9Enterprise State Architecture
  10. Ch. 10Enterprise Capital Architecture
  11. Ch. 11Enterprise Performance Architecture
  12. Ch. 12Enterprise Risk, Resilience, and Robustness Architecture
  13. Ch. 13Unified Enterprise Transformation Architecture
  14. Ch. 14Mathematical Analysis of the Unified Enterprise Transformation Architecture
  15. Ch. 15Mathematical Formulation of Enterprise Optimization
  16. Ch. 16Synthesis, Future Directions, and Transition to Volume II

Volume II: Enterprise Optimization & Applications

  1. Ch. 1Introduction to Enterprise Optimization
  2. Ch. 2The General Enterprise Optimization Problem Revisited
  3. Ch. 3Convex Enterprise Optimization
  4. Ch. 4Nonlinear and Mixed-Integer Enterprise Optimization
  5. Ch. 5Dynamic Enterprise Optimization
  6. Ch. 6Optimal Control of Enterprise Systems
  7. Ch. 7Dynamic Programming for Enterprise Systems
  8. Ch. 8Hamilton–Jacobi–Bellman Enterprise Framework
  9. Ch. 9Stochastic Enterprise Optimization
  10. Ch. 10Neuro-Fuzzy Robust Enterprise Optimization
  11. Ch. 11Distributionally Robust Enterprise Optimization
  12. Ch. 12Multi-Objective Enterprise Optimization
  13. Ch. 13Machine Learning for Enterprise Transformation
  14. Ch. 14Artificial Intelligence for Enterprise Optimization
  15. Ch. 15Enterprise Digital Twins and Autonomous Enterprise Transformation
  16. Ch. 16Enterprise Applications and Integrated Transformation Case Studies

Dynamic Corporate Transformation

Springer Nature · Management for Professionals · Forthcoming 2027

  • Volume I — Foundations and Mathematical Framework
  • Volume II — Enterprise Optimization & Applications
Buy Volume I: Dynamic Corporate Transformation: Foundations and Mathematical FrameworkBuy Volume II: Dynamic Corporate Transformation: Enterprise Optimization & Applications
Jump to any chapter

Volume I: Foundations and Mathematical Framework

  1. Ch. 1Introduction to Dynamic Corporate Transformation
  2. Ch. 2Enterprise Systems and Transformation
  3. Ch. 3Mathematical Foundations
  4. Ch. 4Enterprise Modeling Principles
  5. Ch. 5Enterprise State Representation
  6. Ch. 6Enterprise Transformation Operators
  7. Ch. 7Dynamic Enterprise Systems
  8. Ch. 8Stochastic Enterprise Dynamics
  9. Ch. 9Enterprise State Architecture
  10. Ch. 10Enterprise Capital Architecture
  11. Ch. 11Enterprise Performance Architecture
  12. Ch. 12Enterprise Risk, Resilience, and Robustness Architecture
  13. Ch. 13Unified Enterprise Transformation Architecture
  14. Ch. 14Mathematical Analysis of the Unified Enterprise Transformation Architecture
  15. Ch. 15Mathematical Formulation of Enterprise Optimization
  16. Ch. 16Synthesis, Future Directions, and Transition to Volume II

Volume II: Enterprise Optimization & Applications

  1. Ch. 1Introduction to Enterprise Optimization
  2. Ch. 2The General Enterprise Optimization Problem Revisited
  3. Ch. 3Convex Enterprise Optimization
  4. Ch. 4Nonlinear and Mixed-Integer Enterprise Optimization
  5. Ch. 5Dynamic Enterprise Optimization
  6. Ch. 6Optimal Control of Enterprise Systems
  7. Ch. 7Dynamic Programming for Enterprise Systems
  8. Ch. 8Hamilton–Jacobi–Bellman Enterprise Framework
  9. Ch. 9Stochastic Enterprise Optimization
  10. Ch. 10Neuro-Fuzzy Robust Enterprise Optimization
  11. Ch. 11Distributionally Robust Enterprise Optimization
  12. Ch. 12Multi-Objective Enterprise Optimization
  13. Ch. 13Machine Learning for Enterprise Transformation
  14. Ch. 14Artificial Intelligence for Enterprise Optimization
  15. Ch. 15Enterprise Digital Twins and Autonomous Enterprise Transformation
  16. Ch. 16Enterprise Applications and Integrated Transformation Case Studies