Skip to content

Vol. I, Ch. 13

DCT Laboratory — Volume I, Chapter 13

Unified Enterprise Transformation Architecture

This laboratory demonstrates

Seed 26113 · Companion to Chapter 13 and AXIOM Lab 1.13 (module AXIOM-13) · Mirrored in DCT_V1_Ch13_Lab.xlsx

This laboratory reproduces Worked Example 13.1, Is the Same Cash Promised Twice?, with the book's declarations, and works the five steps of AXIOM Lab 1.13, One Company, Five Ledgers: assemble, wire the couplings, follow the wavefront, audit the cycle, decide in one place. The breach odds the worked example cites are Worked Example 8.1's 100,000 paths, drawn as in the book with random seed 8 (Volume II, Online Appendix 1.B.4), so they come out exactly as printed; the lab's seed 26113 is used only for fresh draws, labelled as such. Every Meridian number below is the book's or follows from its declarations (Worked Example 13.1, Tables 13.1 and 13.6, Figures 13.1–13.3, Online Appendix 13.B.1–13.B.4); the final cell checks the printed ones. Money is in $ million.

The declarations (Worked Example 13.1, Step 1; Table 13.1)

The skeleton (Chapter 9, Worked Example 9.1). Seven components: the divisions Industrial Systems (IND), Digital Solutions (DIG) and Advanced Materials (MAT), shared engineering (ENG), treasury (TRS), the market (MKT) and governance (GOV). Fourteen typed arrows wire them: demand from the market to each division, cash from the divisions to treasury, funding from treasury to Industrial Systems and Digital, capability both ways between engineering and those two divisions, and policy from governance to treasury and Digital. The constraints (Table 9.3): the covenant (net leverage at most 4.5 times) and the $350 million liquidity floor at treasury, plant capacity at Industrial Systems, the strategic-risk ceiling of 75 across the three divisions, and workforce capability of at least 55 for the digital build across engineering and Digital.

The layers on it (Table 13.1). Capital: the ten forms of Table 10.1; treasury carries liquidity and net leverage, engineering the workforce-capability index (Table 9.1). Performance: the ten dimensions of Table 11.2 with the supports of Table 11.4, and the CFO's scorecard (L+T+E−R)/4(L + T + E - R)/4 on Chapter 1's readings, 37.0 today. Risk: the loss channels of Table 12.2 with their supports, the walls, and the risk office's closure buffer. Transformation: the digital build, which writes to Digital and engineering (Online Appendix 13.B.3). An indicator read by two layers carries its one Table 5.2 contract: liquidity from treasury systems (±1 percent), strategic risk from the risk committee (±6 points).

The digital program (Chapters 1 and 8). Liquidity today is $620 million, $6.2 million an index point. Chapter 1's digital path (Online Appendix 1.B.4) relaxes toward 112 at 35 percent a year, less a trough of depth 28 reached after two years (the phased build: depth 20); Chapter 8's plan reads it quarterly over the program's three years. The board's floor is $350 million, and its appetite tolerates at most a 5 percent chance of breaching the floor during the program.

The uncertainty (Chapters 8 and 12). Each quarter brings an execution surprise with a standard deviation of $50 million, 60 percent of which carries into the next quarter. A funding window closes about once a decade (0.10 a year) and removes a gamma-distributed amount, mean $120 million and standard deviation $50 million, that is not recovered within the program. The standby line covers $100 million of any closure.

Python Code
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26113          # the lab's seed: fresh draws only, labelled as such
BOOK_SEED = 8         # the book's stream for Worked Example 8.1's paths (Volume II, Online Appendix 1.B.4)

# The skeleton: Meridian's state architecture (Chapter 9, Worked Example 9.1; Tables 9.1 and 9.3)
COMPONENTS = ["MKT", "GOV", "MAT", "IND", "DIG", "ENG", "TRS"]
NAMES = {"MKT": "the market", "GOV": "governance", "MAT": "Advanced Materials", "IND": "Industrial Systems",
         "DIG": "Digital", "ENG": "engineering", "TRS": "treasury"}
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")]
CONSTRAINTS = {"covenant: net leverage at most 4.5x": ["TRS"], "liquidity floor of $350 million": ["TRS"],
               "plant capacity": ["IND"], "strategic-risk ceiling of 75": ["IND", "DIG", "MAT"],
               "capability of at least 55 for the digital build": ["ENG", "DIG"]}
# Table 5.2: one measurement contract per indicator
CONTRACTS = {"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", "strategic risk": "risk committee, +/-6 points"}
FORMS = ["financial", "human", "intellectual", "technological", "organizational", "relational",
         "strategic", "governance", "innovation", "informational"]                      # Table 10.1
DIMENSIONS = ["financial", "operational", "strategic", "human", "technological", "innovation",
              "governance", "environmental", "resilience", "sustainability"]            # Table 11.2

CAPABILITY, CAPABILITY_FLOOR = 58.0, 55.0            # workforce capability today (Table 3.1); the build's floor

def reach(sources):
    # earliest quarter at which a change at the sources can reach each component (None: never)
    dist, frontier, k = {s: 0 for s in sources}, list(sources), 0
    while frontier:
        k, nxt = k + 1, []
        for u in frontier:
            for a, b, _ in ARROWS:
                if a == u and b not in dist:
                    dist[b] = k
                    nxt.append(b)
        frontier = nxt
    return {c: dist.get(c) for c in COMPONENTS}

# The digital program (Chapter 1's model, Online Appendix 1.B.4; Chapter 8's plan), $ million
LIQ0, FLOOR, PER_POINT, APPETITE = 620.0, 350.0, 6.2, 0.05
POOL = LIQ0 - FLOOR                                          # cash above the floor

def relax(x0, target, k, t):
    return target + (x0 - target) * np.exp(-k * t)

def trough(depth, tau, t):
    return depth * (t / tau) * np.exp(1 - t / tau)

def digital(t, depth=28.0):
    # the four moving readings: liquidity index, technology platform, efficiency, strategic risk (t in years)
    return {"L": relax(100.0, 112.0, 0.35, t) - trough(depth, 2.0, t), "T": relax(41.0, 78.0, 0.55, t),
            "E": relax(71.0, 77.0, 0.50, t) - trough(9.0, 1.5, t), "R": relax(64.0, 51.0, 0.40, t) + trough(14.0, 1.2, t)}

def score(r):
    return (r["L"] + r["T"] + r["E"] - r["R"]) / 4             # the CFO's scorecard (Worked Example 1.1; Chapter 11)

def plan(depth=28.0):
    return PER_POINT * digital(np.arange(13) / 4, depth)["L"]   # Chapter 8's plan, quarters 0-12

# The uncertainty (Chapter 8, Worked Example 8.1; Chapter 12's closures) and the levers
A_E, SD_W = 0.6, 50.0                                      # execution deviation: share carried, surprise sd
LAM, J_MEAN, J_SD = 0.10, 120.0, 50.0                      # closures a year; size mean and sd
SHAPE, SCALE = (J_MEAN / J_SD) ** 2, J_SD ** 2 / J_MEAN    # gamma sizes with that mean and sd
LINE, DEPTH, DEPTH_PHASED = 100.0, 28.0, 20.0              # the standby line per closure; the draw's depth

def simulate(line=0.0, depth=DEPTH, n=100_000, seed=BOOK_SEED):
    # Liquidity paths [n, 13] in the book engine's order (we_8.py): each quarter the n surprises, the n closure
    # counts, then the sizes of that quarter's closures in path order; seed 8 gives the book's paths exactly.
    rng = np.random.default_rng(seed)
    pl, E, J = plan(depth), np.zeros(n), np.zeros(n)
    L = np.empty((n, 13)); L[:, 0] = pl[0]
    for k in range(12):
        w = SD_W * rng.standard_normal(n)
        cnt = rng.poisson(LAM / 4, n)
        sizes = rng.gamma(SHAPE, SCALE, cnt.sum())
        lost = np.bincount(np.repeat(np.arange(n), cnt), np.maximum(sizes - line, 0.0), minlength=n)
        E, J = A_E * E + w, J - lost
        L[:, k + 1] = pl[k + 1] + E + J
    return L

print(f"skeleton: {len(COMPONENTS)} components, {len(ARROWS)} arrows, {len(CONSTRAINTS)} constraints")
print(f"liquidity today ${LIQ0:.0f} million, floor ${FLOOR:.0f} million: ${POOL:.0f} million above it")
print(f"closure sizes: gamma, shape {SHAPE:.2f} and scale {SCALE:.2f} (mean {SHAPE * SCALE:.0f}, sd {np.sqrt(SHAPE) * SCALE:.0f})")
print(f"the CFO's scorecard today: ({100:.0f} + {41:.0f} + {71:.0f} - {64:.0f})/4 = {score(digital(0.0)):.1f}")
skeleton: 7 components, 14 arrows, 5 constraints
liquidity today $620 million, floor $350 million: $270 million above it
closure sizes: gamma, shape 5.76 and scale 20.83 (mean 120, sd 50)
the CFO's scorecard today: (100 + 41 + 71 - 64)/4 = 37.0

Panel 1 — Assemble (Theorems 13.1 and 13.2(i); Definition 13.4; Table 13.1: seven components, a feedback core of four, ten forms, ten dimensions)

AXIOM Lab 1.13, step 1. Attach the four layers to Meridian's skeleton in two different orders and read the compatibility checks at each attachment: (C1) every carrier, support, write set and buffer is a component; (C2) an indicator read by two layers carries one measurement contract; (C3) every risk buffer is named to a declared capital stock, its funding identity; (C4) the layers' constraints have a joint solution, which for Meridian is the joint check of the claims on treasury cash (Table 13.3); (C5) operator domains are recomputed against it, the digital build's among them. Integration adjoins a declaration and changes nothing already attached (Definition 13.3), so the unified object is the skeleton with the set of declarations: both orders give the same one (Theorem 13.2(i)), and restricting it to one layer returns that layer unchanged (Theorem 13.1(iii)). The order changes only when (C4) fails, never whether: it fails at the attachment that puts the program's draw and the closure buffer on the same treasury cash, whichever comes second. No layer can be dropped (Theorem 13.1(iv)): two risk layers that differ only in their measure answer the same question differently.

Python Code
DRAW = LIQ0 - plan().min()                                     # the program's deepest draw (quarter 7)
BUFFER = stats.gamma.ppf(0.90, SHAPE, scale=SCALE)             # the 90th-percentile closure (Chapter 12)
LAYERS = {
    "transformation": {"refs": {"digital build: write set": ["DIG", "ENG"], "program draw D": ["DIG"]},
                       "claims": {"program draw D": DRAW}},
    "capital": {"refs": {"liquidity": ["TRS"], "net leverage": ["TRS"], "workforce capability": ["ENG"],
                         "cash above the floor A": ["TRS"]},
                "reads": {k: CONTRACTS[k] for k in ("liquidity", "net leverage", "workforce capability")},
                "stocks": {"cash above the floor A": POOL}, "forms": FORMS},
    "performance": {"refs": {"P_F": ["TRS"], "P_O": ["IND", "MAT"], "P_S": ["IND", "DIG", "MAT"], "P_T": ["DIG"],
                             "P_I": ["DIG", "ENG"], "P_R": ["TRS"]},                       # Table 11.4
                    "reads": {k: CONTRACTS[k] for k in ("liquidity", "technology platform", "operational efficiency",
                                                        "strategic risk")},             # the CFO's scorecard
                    "dimensions": DIMENSIONS},
    "risk": {"refs": {"R_F": ["TRS"], "R_O": ["IND", "MAT"], "R_S": ["MKT", "GOV"], "R_T": ["DIG", "ENG"],
                      "R_G": ["GOV"], "R_L": ["GOV", "TRS"], "R_E": ["IND", "MAT"],          # Table 12.2
                      "strategic-risk ceiling": ["IND", "DIG", "MAT"], "closure buffer B": ["TRS"]},
             "reads": {k: CONTRACTS[k] for k in ("liquidity", "strategic risk")},
             "buffers": {"closure buffer B": ("cash above the floor A", BUFFER)}},
}

def compatibility(U):
    # (C1)-(C5) on the layers attached so far (Definition 13.4)
    L = U["layers"].values()
    c1 = all(c in U["components"] for d in L for refs in d["refs"].values() for c in refs)
    contracts = {}
    for d in L:
        for ind, con in d.get("reads", {}).items():
            contracts.setdefault(ind, set()).add(con)
    c2 = all(len(v) == 1 for v in contracts.values())
    stocks = {s for d in L for s in d.get("stocks", {})}
    buffers = [b for d in L for b in d.get("buffers", {}).values()]
    c3 = all(fund in stocks for fund, _ in buffers)
    claims = sum(v for d in L for v in d.get("claims", {}).values()) + sum(b for fund, b in buffers if fund in stocks)
    c4 = claims <= POOL                # Table 13.3: for Meridian, (C4) is the joint check of the claims on treasury cash
    has_build = any("digital build: write set" in d["refs"] for d in L)
    c5 = (c4 and CAPABILITY >= CAPABILITY_FLOOR) if has_build else None    # the build's domain against the joint region
    return {"C1": c1, "C2": c2, "C3": c3, "C4": c4, "C5": c5, "claims": claims}

def assemble(order):
    U = {"components": tuple(COMPONENTS), "arrows": tuple(ARROWS), "layers": {}}
    print("attach in the order " + ", ".join(order) + ":")
    for name in order:
        U["layers"][name] = LAYERS[name]                       # integration adjoins a declaration (Definition 13.3)
        c = compatibility(U)
        flags = "  ".join(f"{k} {'pass' if c[k] else 'FAIL'}" for k in ("C1", "C2", "C3", "C4"))
        c5 = "no operator attached yet" if c["C5"] is None else f"the build's domain {'nonempty' if c['C5'] else 'empty'}"
        print(f"  + {name:15s} {flags}   claims on treasury cash {c['claims']:6.1f} of {POOL:.0f}   C5: {c5}")
    return U, c

U1, last1 = assemble(["transformation", "capital", "performance", "risk"])
U2, last2 = assemble(["capital", "risk", "performance", "transformation"])
print("the two orders give the same unified architecture:", U1 == U2, "  and the same checks:", last1 == last2)
print("each layer returned unchanged on restriction:", all(U1["layers"][k] is LAYERS[k] for k in LAYERS))
print(f"(C4) fails by {last1['claims'] - POOL:.1f}: the joint check of Worked Example 13.1 (Panel 5)")

shared = {}
for name, d in LAYERS.items():
    for ind, con in d.get("reads", {}).items():
        shared.setdefault(ind, []).append(name)
for ind, who in shared.items():
    if len(who) > 1:
        print(f"(C2) {ind} is read by {', '.join(who)}: one contract, {CONTRACTS[ind]}")

R = np.array([[1 if (a, b) in {(x, y) for x, y, _ in ARROWS} else 0 for b in COMPONENTS] for a in COMPONENTS])
closure = np.linalg.matrix_power(R + np.eye(7, dtype=int), 6) > 0             # who reaches whom
core = [c for i, c in enumerate(COMPONENTS) if any(closure[i, j] and closure[j, i] for j in range(7) if j != i)]
RENT = 0.025 * 58 * 4.0 * 4                                                     # Chapter 10: delta x 58 at $4m a point
print("\nTable 13.1, Meridian's instance:")
print(f"  state           {len(COMPONENTS)} components; a feedback core of {len(core)}: {', '.join(core)}")
print(f"  transformation  the digital build writes to Digital and engineering; deepest draw ${DRAW:.1f} million")
print(f"  capital         {len(FORMS)} forms; a capability rent of 0.025 x 58 = 1.45 points a quarter at $4 million: ${RENT:.1f} million a year")
print(f"  performance     {len(DIMENSIONS)} dimensions; the CFO's scorecard reads liquidity, technology, efficiency and strategic risk")
print(f"  risk            ${POOL:.0f} million of armor above the floor; the closure buffer, ${BUFFER:.1f} million, is treasury cash")

def var_es(values, probs, alpha=0.95):
    # value at risk and expected shortfall of a discrete loss law (Chapter 12)
    o = np.argsort(values); v, p = np.asarray(values, float)[o], np.asarray(probs, float)[o]
    q = v[np.searchsorted(np.cumsum(p), alpha - 1e-15)]
    return q, (p[v > q] @ v[v > q] + q * (p[v <= q].sum() - alpha)) / (1 - alpha)
one, pair = var_es([0, 100], [0.96, 0.04]), var_es([0, 100, 200], [0.96 ** 2, 2 * 0.04 * 0.96, 0.04 ** 2])
print("\nnon-redundancy (Theorem 13.1(iv)): two loans that each lose 100 with probability 0.04, consolidated")
print(f"  risk layer declaring VaR at 95%: {one[0]:.0f} + {one[0]:.0f} apart, {pair[0]:.0f} together -> consolidating raises measured risk")
print(f"  risk layer declaring ES at 95%:  {one[1]:.0f} + {one[1]:.0f} apart, {pair[1]:.1f} together -> it lowers it")
attach in the order transformation, capital, performance, risk:
  + transformation  C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash  138.0 of 270   C5: the build's domain nonempty
  + capital         C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash  138.0 of 270   C5: the build's domain nonempty
  + performance     C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash  138.0 of 270   C5: the build's domain nonempty
  + risk            C1 pass  C2 pass  C3 pass  C4 FAIL   claims on treasury cash  324.9 of 270   C5: the build's domain empty
attach in the order capital, risk, performance, transformation:
  + capital         C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash    0.0 of 270   C5: no operator attached yet
  + risk            C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash  186.9 of 270   C5: no operator attached yet
  + performance     C1 pass  C2 pass  C3 pass  C4 pass   claims on treasury cash  186.9 of 270   C5: no operator attached yet
  + transformation  C1 pass  C2 pass  C3 pass  C4 FAIL   claims on treasury cash  324.9 of 270   C5: the build's domain empty
the two orders give the same unified architecture: True   and the same checks: True
each layer returned unchanged on restriction: True
(C4) fails by 54.9: the joint check of Worked Example 13.1 (Panel 5)
(C2) liquidity is read by capital, performance, risk: one contract, treasury systems, +/-1%
(C2) strategic risk is read by performance, risk: one contract, risk committee, +/-6 points

Table 13.1, Meridian's instance:
  state           7 components; a feedback core of 4: IND, DIG, ENG, TRS
  transformation  the digital build writes to Digital and engineering; deepest draw $138.0 million
  capital         10 forms; a capability rent of 0.025 x 58 = 1.45 points a quarter at $4 million: $23.2 million a year
  performance     10 dimensions; the CFO's scorecard reads liquidity, technology, efficiency and strategic risk
  risk            $270 million of armor above the floor; the closure buffer, $186.9 million, is treasury cash

non-redundancy (Theorem 13.1(iv)): two loans that each lose 100 with probability 0.04, consolidated
  risk layer declaring VaR at 95%: 0 + 0 apart, 100 together -> consolidating raises measured risk
  risk layer declaring ES at 95%:  80 + 80 apart, 103.2 together -> it lowers it

Panel 2 — Wire the couplings (Theorem 13.3(ii); Figure 13.2; Online Appendix 13.B.1: 2, 4, 10, unbounded)

AXIOM Lab 1.13, step 2. Losses propagate on the layered graph with the gains of the interaction matrix M\mathbf{M}, rows receiving: ℓk+1=Mℓk\boldsymbol{\ell}_{k+1} = \mathbf{M}\boldsymbol{\ell}_k, and the total impact of a unit loss, summed over layers and periods, is finite exactly when ρ(M)<1\rho(\mathbf{M}) < 1. Figure 13.2's three layers each keep half of a quarter's loss (a=0.5a = 0.5): alone, each books a unit shock 1/(1−a)=21/(1 - a) = 2 times over and passes its own stress test. Let a share cc cross from capital to performance, performance to risk, and risk to capital. Every column of M\mathbf{M} then sums to a+ca + c, so ρ(M)=a+c\rho(\mathbf{M}) = a + c and the total impact is 1/(1−a−c)1/(1 - a - c): 4 at c=0.25c = 0.25, 10 at c=0.40c = 0.40, and from c=0.5c = 0.5 on no finite bill, while each layer alone still reports 2. The spectral report splits ρ(M)\rho(\mathbf{M}) by block, giving each block its eigenvalue-sensitivity weight uℓ⊤Mℓℓ′vℓ′/u⊤v\mathbf{u}_\ell^{\top}\mathbf{M}_{\ell\ell'}\mathbf{v}_{\ell'}/\mathbf{u}^{\top}\mathbf{v} (u\mathbf{u}, v\mathbf{v} the left and right Perron vectors): the diagonal blocks carry exactly aa, the layers' own radius, and the cross-layer blocks carry cc, the whole difference (Theorem 13.3(ii)). To build a case in which every layer is stable and the whole is not, take Online Appendix 13.B.1's construction: layers as stable as one likes (a=0.05a = 0.05) and c=1c = 1.

Python Code
LAYERS3 = ["capital", "performance", "risk"]

def cycle_matrix(c, a=0.5):
    # capital -> performance -> risk -> capital; rows receive, columns send (Online Appendix 13.B.1)
    return np.array([[a, 0.0, c], [c, a, 0.0], [0.0, c, a]])

def rho(M):
    return float(max(abs(np.linalg.eigvals(M))))

def total_impact(M, seed=0):
    # sum over layers and periods of a unit loss seeded in one layer, exact transmission: 1'(I - M)^-1 e
    if rho(M) >= 1 - 1e-12:
        return np.inf                                  # no finite bill
    return float(np.linalg.solve(np.eye(len(M)) - M, np.eye(len(M))[:, seed]).sum())

def spectral_report(M, label):
    w, V = np.linalg.eig(M); v = np.abs(V[:, np.argmax(w.real)].real)
    w2, U = np.linalg.eig(M.T); u = np.abs(U[:, np.argmax(w2.real)].real)
    r = rho(M); share = np.outer(u, v) * M / (u @ v)          # share[i, j] * r: block (i, j)'s part of rho(M)
    diag, cross = float(np.trace(share)), float(share.sum() - np.trace(share))
    radii = ", ".join(f"{M[i, i]:.2f}" for i in range(len(M)))
    bill = total_impact(M)
    print(f"{label:34s} layer radii {radii}   rho(M) {r:.2f} = diagonal blocks {diag:.2f} + cross-layer blocks {cross:.2f}"
          f"   total impact {'%.1f' % bill if np.isfinite(bill) else 'unbounded'}")
    return r, diag, cross

print("each layer alone: radius 0.5, total impact 1/(1 - 0.5) =", 1 / (1 - 0.5))
GRID = (0.0, 0.25, 0.40, 0.45, 0.50)
REPORT = {c: spectral_report(cycle_matrix(c), f"Figure 13.2, c = {c:.2f}") for c in GRID}
BILL = {c: total_impact(cycle_matrix(c)) for c in GRID}
spectral_report(cycle_matrix(1.0, a=0.05), "every layer at 0.05, c = 1")
print("column sums at c = 0.25:", cycle_matrix(0.25).sum(axis=0), "-> rho(M) = a + c exactly (Online Appendix 13.B.1)")

Q = 40
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.15, 1]})
for c, col, ls in ((0.0, "#616161", ":"), (0.25, "#1F4E79", "-"), (0.40, "#E65100", "-"), (0.50, "#B71C1C", "--")):
    M, loss, cum = cycle_matrix(c), np.array([1.0, 0.0, 0.0]), [1.0]
    for _ in range(Q):
        loss = M @ loss; cum.append(cum[-1] + loss.sum())
    lab = "each layer alone: 2" if c == 0 else (f"c = {c:.2f}: " + ("no finite bill" if c >= 0.5 else f"{BILL[c]:.0f}"))
    ax.plot(range(Q + 1), cum, color=col, lw=1.8, ls=ls, label=lab)
ax.set(xlabel="quarters after a unit loss", ylabel="cumulative bill, all layers (× the shock)", xlim=(0, Q), ylim=(0, 22),
       title="The bill quarter by quarter")
ax.legend(frameon=False, fontsize=7, loc="upper left")
cs = np.linspace(0, 0.4985, 400)
bx.axvspan(0.5, 0.62, color="#F6E3E3", lw=0)
bx.plot(cs, [1 / (1 - 0.5 - c) for c in cs], color="#B71C1C", lw=1.8)
bx.axhline(2, color="#616161", lw=0.9, ls="--")
bx.text(0.02, 2.4, "each layer alone: 2", fontsize=7, color="#616161")
for c in (0.25, 0.40):
    bx.plot([c], [BILL[c]], "o", color="#B71C1C", ms=4)
    bx.text(c - 0.015, BILL[c] + 0.3, f"{BILL[c]:.0f}×", fontsize=7, color="#B71C1C", ha="right")
bx.text(0.56, 8, "no finite\nbill", fontsize=7, color="#B71C1C", ha="center")
bx.set(xlabel="cross-layer share, c", ylabel="total impact of a unit shock", xlim=(0, 0.62), ylim=(0, 12),
       title="Coupled, the bill is 1/(1 − a − c)")
for z in (ax, bx):
    z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8); z.title.set_size(9)
fig.suptitle("Every layer passes its own test, the whole fails (seed 26113)", fontsize=10)
plt.tight_layout(); plt.show()
each layer alone: radius 0.5, total impact 1/(1 - 0.5) = 2.0
Figure 13.2, c = 0.00              layer radii 0.50, 0.50, 0.50   rho(M) 0.50 = diagonal blocks 0.50 + cross-layer blocks 0.00   total impact 2.0
Figure 13.2, c = 0.25              layer radii 0.50, 0.50, 0.50   rho(M) 0.75 = diagonal blocks 0.50 + cross-layer blocks 0.25   total impact 4.0
Figure 13.2, c = 0.40              layer radii 0.50, 0.50, 0.50   rho(M) 0.90 = diagonal blocks 0.50 + cross-layer blocks 0.40   total impact 10.0
Figure 13.2, c = 0.45              layer radii 0.50, 0.50, 0.50   rho(M) 0.95 = diagonal blocks 0.50 + cross-layer blocks 0.45   total impact 20.0
Figure 13.2, c = 0.50              layer radii 0.50, 0.50, 0.50   rho(M) 1.00 = diagonal blocks 0.50 + cross-layer blocks 0.50   total impact unbounded
every layer at 0.05, c = 1         layer radii 0.05, 0.05, 0.05   rho(M) 1.05 = diagonal blocks 0.05 + cross-layer blocks 1.00   total impact unbounded
column sums at c = 0.25: [0.75 0.75 0.75] -> rho(M) = a + c exactly (Online Appendix 13.B.1)
Every layer passes its own test, the whole fails (seed 26113)

Panel 3 — Follow the wavefront (Proposition 13.2; Theorem 13.4(iii); Online Appendix 13.B.3: treasury and Industrial Systems after one quarter; Materials, the market and governance never)

AXIOM Lab 1.13, step 3. Seed the digital program at its write set, Digital and engineering, and a demand shock at the market, in the same quarter. A readout moves no sooner than the distance from the seed to its support, and never if its support cannot be reached (Proposition 13.2; Theorem 13.4(iii)), so each readout's ledger clock is that distance. Treasury is one arrow from Digital and Industrial Systems one arrow from engineering: liquidity, the covenant and Industrial Systems' operations can respond to the program after one quarter. Advanced Materials receives arrows only from the market, and the market and governance receive none: no readout supported only there can ever respond to the program, so crediting Materials' results to it is refuted by the wiring. The demand shock reaches the three divisions after one quarter and engineering and treasury after two (Worked Example 9.1). The readouts and their supports are the book's: capital (Table 9.1), performance (Table 11.4), risk (Tables 9.3 and 12.2).

Python Code
WRITE = ["DIG", "ENG"]                                     # the digital program's write set
PROGRAM, SHOCK = reach(WRITE), reach(["MKT"])
fmt = lambda d: "never" if d is None else str(d)
print("first quarter in which a change can reach each component")
print(f"  {'component':26s} {'digital program':>16s} {'demand shock':>13s}")
for c in COMPONENTS:
    print(f"  {NAMES[c] + ' (' + c + ')':26s} {fmt(PROGRAM[c]):>16s} {fmt(SHOCK[c]):>13s}")
for name, dist in (("digital program", PROGRAM), ("demand shock", SHOCK)):
    waves = {}
    for c, d in dist.items():
        waves.setdefault(d, []).append(c)
    print(f"the {name}'s wavefront: " + "; ".join(f"quarter {d}: {', '.join(waves[d])}" for d in sorted(k for k in waves if k is not None))
          + (f"; never: {', '.join(waves[None])}" if None in waves else ""))

READOUTS = [("capital", "liquidity (financial capital)", ["TRS"]), ("capital", "net leverage (financial capital)", ["TRS"]),
            ("capital", "workforce capability (human capital)", ["ENG"]),
            ("performance", "P_F financial", ["TRS"]), ("performance", "P_O operational", ["IND", "MAT"]),
            ("performance", "P_S strategic", ["IND", "DIG", "MAT"]), ("performance", "P_T technological", ["DIG"]),
            ("performance", "P_I innovation", ["DIG", "ENG"]), ("performance", "P_R resilience", ["TRS"]),
            ("risk", "R_F financial: floor, covenant", ["TRS"]), ("risk", "R_O operational", ["IND", "MAT"]),
            ("risk", "R_S strategic", ["MKT", "GOV"]), ("risk", "R_T technological", ["DIG", "ENG"]),
            ("risk", "R_G governance", ["GOV"]), ("risk", "R_L legal and regulatory", ["GOV", "TRS"]),
            ("risk", "R_E environmental", ["IND", "MAT"]), ("risk", "strategic-risk ceiling", ["IND", "DIG", "MAT"])]

def clock(support, dist):
    hit = [dist[c] for c in support if dist[c] is not None]
    return min(hit) if hit else None

print("\nthe ledger clocks: first quarter in which each readout can respond")
print(f"  {'ledger':12s} {'readout':36s} {'support':14s} {'program':>8s} {'shock':>6s}")
CLOCKS = []
for ledger, name, support in READOUTS:
    p, s = clock(support, PROGRAM), clock(support, SHOCK)
    CLOCKS.append((ledger, name, support, p, s))
    print(f"  {ledger:12s} {name:36s} {'+'.join(support):14s} {fmt(p):>8s} {fmt(s):>6s}")
never = [c for c in COMPONENTS if PROGRAM[c] is None]
print(f"\nthe program never reaches {', '.join(NAMES[c] for c in never)}: {len(never)} of {len(COMPONENTS)} components;")
print(f"Industrial Systems is {reach(['DIG'])['IND']} quarters from Digital alone (Table 11.4's floor for P_T -> P_O), "
      f"{PROGRAM['IND']} from the program, which also writes to engineering")
for seed, j in (("the digital program", 3), ("the demand shock", 4)):
    first = {lg: min(r[j] for r in CLOCKS if r[0] == lg and r[j] is not None) for lg in ("capital", "performance", "risk")}
    print(f"first quarter in which each ledger can respond to {seed}: " + ", ".join(f"{lg} {q}" for lg, q in first.items()))
print("every ledger with a readout on the write set responds at once (Proposition 13.2); each readout on its own clock")
first quarter in which a change can reach each component
  component                   digital program  demand shock
  the market (MKT)                      never             0
  governance (GOV)                      never         never
  Advanced Materials (MAT)              never             1
  Industrial Systems (IND)                  1             1
  Digital (DIG)                             0             1
  engineering (ENG)                         0             2
  treasury (TRS)                            1             2
the digital program's wavefront: quarter 0: DIG, ENG; quarter 1: IND, TRS; never: MKT, GOV, MAT
the demand shock's wavefront: quarter 0: MKT; quarter 1: MAT, IND, DIG; quarter 2: ENG, TRS; never: GOV

the ledger clocks: first quarter in which each readout can respond
  ledger       readout                              support         program  shock
  capital      liquidity (financial capital)        TRS                   1      2
  capital      net leverage (financial capital)     TRS                   1      2
  capital      workforce capability (human capital) ENG                   0      2
  performance  P_F financial                        TRS                   1      2
  performance  P_O operational                      IND+MAT               1      1
  performance  P_S strategic                        IND+DIG+MAT           0      1
  performance  P_T technological                    DIG                   0      1
  performance  P_I innovation                       DIG+ENG               0      1
  performance  P_R resilience                       TRS                   1      2
  risk         R_F financial: floor, covenant       TRS                   1      2
  risk         R_O operational                      IND+MAT               1      1
  risk         R_S strategic                        MKT+GOV           never      0
  risk         R_T technological                    DIG+ENG               0      1
  risk         R_G governance                       GOV               never  never
  risk         R_L legal and regulatory             GOV+TRS               1      2
  risk         R_E environmental                    IND+MAT               1      1
  risk         strategic-risk ceiling               IND+DIG+MAT           0      1

the program never reaches the market, governance, Advanced Materials: 3 of 7 components;
Industrial Systems is 2 quarters from Digital alone (Table 11.4's floor for P_T -> P_O), 1 from the program, which also writes to engineering
first quarter in which each ledger can respond to the digital program: capital 0, performance 0, risk 0
first quarter in which each ledger can respond to the demand shock: capital 2, performance 1, risk 0
every ledger with a readout on the write set responds at once (Proposition 13.2); each readout on its own clock

Panel 4 — Read the sign-offs (Worked Example 13.1, Step 1; Online Appendix 13.B.4: $138 million at quarter 7, $187 million, $132 and $83 million to spare)

AXIOM Lab 1.13, step 4, first part: load the funding, buffer and schedule sign-offs. Liquidity today is $620 million and the board's floor $350 million, so $270 million lies above the floor. On Chapter 8's plan the program's deepest draw is $138 million, at quarter 7: funded, with $132 million to spare. The risk office sizes its buffer against a closed funding window at the 90th-percentile closure of Chapter 12, $187 million: funded, with $83 million to spare. The schedule sign-off accepts the unphased plan because the buffer is held; it involves no constraint between the draw and the buffer alone. Each check is correct.

Python Code
PLAN, PHASED = plan(DEPTH), plan(DEPTH_PHASED)
K7 = int(PLAN.argmin())
MEDIAN = stats.gamma.ppf(0.50, SHAPE, scale=SCALE)
print("quarter      " + "".join(f"{k:6d}" for k in range(13)))
print("plan         " + "".join(f"{v:6.0f}" for v in PLAN))
print("phased build " + "".join(f"{v:6.0f}" for v in PHASED))
print(f"\nthe program's deepest draw: {LIQ0:.0f} - {PLAN.min():.1f} = {DRAW:.1f} at quarter {K7}")
print(f"closures (gamma, mean 120, sd 50): median {MEDIAN:.1f}, 90th percentile {BUFFER:.1f}")
print(f"funding sign-off   (CFO and transformation office): draw   {DRAW:6.1f} <= {POOL:.0f}: {DRAW <= POOL}, {POOL - DRAW:.1f} to spare")
print(f"buffer sign-off    (CFO and CRO):                   buffer {BUFFER:6.1f} <= {POOL:.0f}: {BUFFER <= POOL}, {POOL - BUFFER:.1f} to spare")
print(f"schedule sign-off  (transformation office and CRO): the unphased plan, because the buffer is held: no constraint between the two alone")
quarter           0     1     2     3     4     5     6     7     8     9    10    11    12
plan            620   574   540   516   499   488   483   482   484   488   494   502   510
phased build    620   589   566   550   540   534   531   531   533   537   543   549   556

the program's deepest draw: 620 - 482.0 = 138.0 at quarter 7
closures (gamma, mean 120, sd 50): median 113.1, 90th percentile 186.9
funding sign-off   (CFO and transformation office): draw    138.0 <= 270: True, 132.0 to spare
buffer sign-off    (CFO and CRO):                   buffer  186.9 <= 270: True, 83.1 to spare
schedule sign-off  (transformation office and CRO): the unphased plan, because the buffer is held: no constraint between the two alone

Panel 5 — Walk the cycle as one constraint (Worked Example 13.1, Steps 2–3; Theorem 13.5(ii)–(iii), (v); Online Appendix 13.B.2; Figure 13.3: $325 million on $270 million)

AXIOM Lab 1.13, step 4, second part. Both claims rest on one asset, treasury's cash above the floor. The draw DD is a transformation node at Digital that flows through the cash arrow to treasury; the buffer BB is a risk node at treasury, a claim on that cash by its funding identity (C3); the cash AA is a capital node at treasury. The constraint that matters, D+B≤AD + B \le A, holds all three in its scope, so its constraint graph is a triangle — a cycle — and by Theorem 13.5(iii) no bilateral sign-off can certify it: each pair is satisfiable while the three together are not (Theorem 13.5(ii)). The joint check: 138+187=325138 + 187 = 325 against $270 million, infeasible by $55 million. On the plan, liquidity runs inside the buffer line 350+187=537350 + 187 = 537 from quarter 3 to the end of the program, 55 deep at quarter 7; the phased build only in quarters 5–8, by at most 6. When a tripwire fires, the error lies among the ancestors of its scope (Theorem 13.5(v)): every component reaches treasury, so an invariant failing on treasury's books clears none of them, while one failing on Materials' books clears all but the market and Materials.

Python Code
NODES = {"D": ("transformation", "DIG", DRAW), "B": ("risk", "TRS", BUFFER), "A": ("capital", "TRS", POOL)}
SCOPE = ["D", "B", "A"]                                         # the one constraint D + B <= A
EDGES = {(SCOPE[i], SCOPE[j]) for i in range(3) for j in range(i + 1, 3)}
print(f"constraint graph: nodes {SCOPE}, edges {sorted(EDGES)}; independent cycles {len(EDGES) - len(SCOPE) + 1}: a triangle")
D, B, A = DRAW, BUFFER, POOL
print("bilateral sign-offs, each a projection of D + B <= A:")
print(f"  funding  (D, A): {D:.1f} <= {A:.0f}   {'pass' if D <= A else 'fail'}")
print(f"  buffer   (B, A): {B:.1f} <= {A:.0f}   {'pass' if B <= A else 'fail'}")
print(f"  schedule (D, B): no constraint on the pair alone   pass")
JOINT = A - (D + B)
print(f"joint check: {D:.1f} + {B:.1f} = {D + B:.1f} against {A:.0f}: {'feasible' if JOINT >= 0 else 'infeasible'} by {abs(JOINT):.1f}")

BUFFER_LINE = FLOOR + BUFFER
inside = [k for k in range(13) if PLAN[k] < BUFFER_LINE]
inside_ph = [k for k in range(13) if PHASED[k] < BUFFER_LINE]
print(f"\nbuffer line: {FLOOR:.0f} + {BUFFER:.1f} = {BUFFER_LINE:.1f}")
print(f"the plan runs inside it in quarters {inside[0]}-{inside[-1]} ({len(inside)} quarters), deepest "
      f"{BUFFER_LINE - PLAN.min():.1f} at quarter {K7}")
print(f"the phased build runs inside it in quarters {inside_ph[0]}-{inside_ph[-1]}, by at most {BUFFER_LINE - PHASED.min():.1f}")

ancestors = lambda v: [c for c in COMPONENTS if reach([c])[v] is not None]
for v, books in (("TRS", "treasury's books"), ("MAT", "Materials' books")):
    anc = ancestors(v)
    cleared = [c for c in COMPONENTS if c not in anc]
    print(f"a tripwire on {books}: suspects {', '.join(anc)}; cleared: {', '.join(cleared) if cleared else 'none'}")

ROWS = [("As signed off", DRAW, BUFFER), ("Buffer at the median closure", DRAW, MEDIAN),
        ("Phased build", LIQ0 - PHASED.min(), BUFFER), ("Standby line", DRAW, max(BUFFER - LINE, 0.0)),
        ("Both levers", LIQ0 - PHASED.min(), max(BUFFER - LINE, 0.0))]
fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.1, 1]})
q = np.arange(13)
ax.fill_between(q, PLAN, BUFFER_LINE, where=PLAN < BUFFER_LINE, interpolate=True, color="#F3D9D9", lw=0)
ax.axhline(FLOOR, color="#616161", lw=0.9)
ax.axhline(BUFFER_LINE, color="#B71C1C", lw=0.9, ls="--")
ax.plot(q, PLAN, color="#1F4E79", lw=1.8, marker="o", ms=3, label="plan")
ax.plot(q, PHASED, color="#2E7D32", lw=1.4, ls="--", label="phased build")
ax.text(12.2, FLOOR + 5, "floor 350", fontsize=7, color="#616161", ha="right", va="bottom")
ax.text(11.6, BUFFER_LINE - 4, f"buffer line {BUFFER_LINE:.0f}", fontsize=7, color="#B71C1C", ha="right", va="top")
ax.text(7, 445, f"cash promised twice:\n{BUFFER_LINE - PLAN.min():.0f} deep at quarter {K7}", fontsize=7, color="#B71C1C", ha="center")
ax.set(xlabel="quarter of the program", ylabel="liquidity ($ million)", xlim=(0, 12.4), ylim=(300, 640), xticks=range(0, 13, 2),
       title="One pool, two claims")
ax.legend(frameon=False, fontsize=7, loc="upper right", bbox_to_anchor=(1.0, 0.93))
y = np.arange(len(ROWS))[::-1]
for yy, (name, d, b) in zip(y, ROWS):
    bx.barh(yy, d, height=0.56, color="#5E35B1", lw=0)
    bx.barh(yy, b, left=d, height=0.56, color="#B71C1C", alpha=0.85, lw=0)
    spare = POOL - d - b
    bx.text(max(d + b, POOL) + 6, yy, f"{spare:+.0f}", fontsize=7.5, va="center", fontweight="bold",
            color="#B71C1C" if spare < 0 else "#2E7D32")
bx.axvline(POOL, color="#2E7D32", lw=1.1)
bx.text(POOL - 4, len(ROWS) - 0.45, "pool 270", fontsize=7, color="#2E7D32", ha="right")
bx.text(8, -0.8, "draw", fontsize=7, color="#5E35B1", fontweight="bold", va="center")
bx.text(70, -0.8, "cash buffer", fontsize=7, color="#B71C1C", fontweight="bold", va="center")
bx.set_yticks(y); bx.set_yticklabels(["As signed off", "Median buffer", "Phased build", "Standby line", "Both levers"])
bx.set(xlabel="claims on the cash above the floor ($ million)", xlim=(0, 380), ylim=(-1.1, len(ROWS) - 0.2), title="The joint check")
for z in (ax, bx):
    z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8); z.title.set_size(9)
fig.suptitle("The same cash is promised twice: 325 of claims on 270 (seed 26113)", fontsize=10)
plt.tight_layout(); plt.show()
constraint graph: nodes ['D', 'B', 'A'], edges [('B', 'A'), ('D', 'A'), ('D', 'B')]; independent cycles 1: a triangle
bilateral sign-offs, each a projection of D + B <= A:
  funding  (D, A): 138.0 <= 270   pass
  buffer   (B, A): 186.9 <= 270   pass
  schedule (D, B): no constraint on the pair alone   pass
joint check: 138.0 + 186.9 = 324.9 against 270: infeasible by 54.9

buffer line: 350 + 186.9 = 536.9
the plan runs inside it in quarters 3-12 (10 quarters), deepest 54.9 at quarter 7
the phased build runs inside it in quarters 5-8, by at most 5.9
a tripwire on treasury's books: suspects MKT, GOV, MAT, IND, DIG, ENG, TRS; cleared: none
a tripwire on Materials' books: suspects MKT, MAT; cleared: GOV, IND, DIG, ENG, TRS
The same cash is promised twice: 325 of claims on 270 (seed 26113)

Panel 6 — Repair it three ways (Worked Example 13.1, Step 4; Table 13.6; Online Appendix 13.B.4: +19, −6, +45, +94)

AXIOM Lab 1.13, step 4, last part. Each repair lives in its own ledger. Relaxing the buffer to the median closure, $113 million, a risk-ledger repair, passes with $19 million to spare, but only by lowering the bar: half of all closures would exceed it, and since the declaration does not change the cash, the breach odds stay at 24.6 percent. Phasing the build, a transformation repair, cuts the draw to $89 million but alone still fails, by $6 million. The standby line of Chapter 8, a capital repair, covers $100 million of any closure, cuts the cash buffer to $87 million and passes with $45 million to spare. Both levers pass with $94 million. One million fresh closures drawn with the lab's seed confirm the two quantiles the buffers rest on.

Python Code
print(f"Table 13.6 ($ million)        {'draw':>6s} {'cash buffer':>12s} {'total claims':>13s} {'spare cash':>11s}")
for name, d, b in ROWS:
    print(f"  {name:28s} {d:6.1f} {b:12.1f} {d + b:13.1f} {POOL - d - b:+11.1f}   {'passes' if d + b <= POOL else 'fails'}")
TABLE = {name: (d, b, d + b, POOL - d - b) for name, d, b in ROWS}
print(f"the phased build's deepest draw: {LIQ0:.0f} - {PHASED.min():.1f} = {LIQ0 - PHASED.min():.1f} (quarter {int(PHASED.argmin())})")
print(f"the standby line covers {LINE:.0f} of a closure: cash buffer {BUFFER:.1f} - {LINE:.0f} = {BUFFER - LINE:.1f}; "
      f"cash and line together still cover the 90th percentile")

rng = np.random.default_rng(SEED)                       # fresh draws, the lab's seed
sizes = rng.gamma(SHAPE, SCALE, 1_000_000)
print(f"\none million fresh closures (seed {SEED}): median {np.median(sizes):.1f} (exact {MEDIAN:.1f}), "
      f"90th percentile {np.percentile(sizes, 90):.1f} (exact {BUFFER:.1f})")
print(f"  share exceeding the median buffer {100 * (sizes > MEDIAN).mean():.1f}%: half of all closures; exceeding the "
      f"90th-percentile cover {100 * (sizes > BUFFER).mean():.1f}%")
Table 13.6 ($ million)          draw  cash buffer  total claims  spare cash
  As signed off                 138.0        186.9         324.9       -54.9   fails
  Buffer at the median closure  138.0        113.1         251.2       +18.8   passes
  Phased build                   89.0        186.9         275.9        -5.9   fails
  Standby line                  138.0         86.9         224.9       +45.1   passes
  Both levers                    89.0         86.9         175.9       +94.1   passes
the phased build's deepest draw: 620 - 531.0 = 89.0 (quarter 6)
the standby line covers 100 of a closure: cash buffer 186.9 - 100 = 86.9; cash and line together still cover the 90th percentile

one million fresh closures (seed 26113): median 113.1 (exact 113.1), 90th percentile 186.7 (exact 186.9)
  share exceeding the median buffer 50.0%: half of all closures; exceeding the 90th-percentile cover 10.0%

Panel 7 — Run the program on one clock (Proposition 13.2; Theorem 13.4; Figure 13.1: months 11, 21 and 29)

AXIOM Lab 1.13, step 5, first part: run the program through all ledgers on one clock. Chapter 1's model, month by month, read in three ledgers: capital (liquidity against the $350 million floor), performance (the CFO's scorecard against today's 37.0) and risk (strategic risk against its ceiling of 75, which the risk committee measures to ±6 points). The scorecard and strategic risk are at their worst in month 11 (32.1, and 73.55, a ceiling 1.4 points away), liquidity in month 21 ($482 million), and the scorecard regains today's level only in month 29 (37.19). A review at month 11 in any one ledger reaches a verdict that is correct in its ledger and unsafe for the program: performance sees a failing program, liquidity a falling but ample cushion, risk a ceiling 1.4 points away, inside the instrument's error.

Python Code
MONTHS = np.arange(61)
LED = digital(MONTHS / 12)
LIQ_M, SCORE_M, RISK_M = PER_POINT * LED["L"], score(LED), LED["R"]
TODAY = SCORE_M[0]
i_liq, i_sc, i_rk = int(LIQ_M.argmin()), int(SCORE_M.argmin()), int(RISK_M.argmax())
i_back = next(m for m in range(i_sc, 61) if SCORE_M[m] >= TODAY)
print(f"capital:     liquidity low ${LIQ_M[i_liq]:.1f} million in month {i_liq}")
print(f"performance: the scorecard falls from {TODAY:.1f} to {SCORE_M[i_sc]:.2f} in month {i_sc} and regains today's level "
      f"in month {i_back} ({SCORE_M[i_back]:.2f}; {SCORE_M[i_back - 1]:.2f} in month {i_back - 1})")
print(f"risk:        strategic risk peaks at {RISK_M[i_rk]:.2f} in month {i_rk}, {75 - RISK_M[i_rk]:.1f} under the ceiling of 75 "
      f"(measured +/-6)")
m = 11
print(f"\nthe three reviews at month {m}, each in its own ledger:")
print(f"  performance: scorecard {SCORE_M[m]:.1f} against today's {TODAY:.1f} -> a failing program")
print(f"  capital:     liquidity ${LIQ_M[m]:.0f} million, falling ({LIQ_M[m] - LIQ_M[m - 1]:+.1f} a month), "
      f"${LIQ_M[m] - FLOOR:.0f} million above the floor -> an ample cushion")
print(f"  risk:        strategic risk {RISK_M[m]:.1f}, the ceiling {75 - RISK_M[m]:.1f} points away -> inside the +/-6 error")

fig, axes = plt.subplots(1, 3, figsize=(7.6, 3.6))
specs = [(LIQ_M, "Capital", "#2E7D32", "liquidity ($ million)", FLOOR, "floor 350", (300, 660), i_liq, "low"),
         (SCORE_M, "Performance", "#E65100", "CFO's scorecard", TODAY, "today 37.0", (28, 50), i_sc, "low"),
         (RISK_M, "Risk", "#B71C1C", "strategic risk (index)", 75.0, "ceiling 75", (42, 86), i_rk, "peak")]
for ax, (y, name, col, ylab, ref, reflab, ylim, i, word) in zip(axes, specs):
    if name == "Risk":
        ax.fill_between(MONTHS, y - 6, y + 6, color="#F3D9D9", lw=0)
    ax.axhline(ref, color="#616161" if name != "Risk" else "#B71C1C", lw=0.9, ls="--" if name == "Performance" else "-")
    ax.plot(MONTHS, y, color=col, lw=1.8)
    ax.plot([i], [y[i]], "o", color=col, ms=4)
    val = f"{y[i]:.0f}" if name == "Capital" else f"{y[i]:.1f}"
    ax.annotate(f"{word} {val},\nmonth {i}", (i, y[i]), xytext=(i + 4, y[i] + (-0.12 if word == "low" else 0.10) * (ylim[1] - ylim[0])),
                fontsize=7, color=col, va="center")
    ax.text(59, ref + 0.012 * (ylim[1] - ylim[0]), reflab, fontsize=7, color="#616161" if name != "Risk" else "#B71C1C",
            ha="right", va="bottom")
    if name == "Risk":
        ax.text(59, 44, "band: error ±6", fontsize=7, color="#616161", ha="right", va="bottom")
    for mm in (11, 21):
        ax.axvline(mm, color="#9E9E9E", lw=0.5, ls=":")
    ax.set(xlim=(0, 60), ylim=ylim, xticks=range(0, 61, 12), xlabel="month")
    ax.set_ylabel(ylab, fontsize=8); ax.set_title(name, fontsize=9, color=col, loc="left")
    ax.tick_params(labelsize=7); ax.xaxis.label.set_size(8)
axes[1].plot([i_back], [SCORE_M[i_back]], "o", color="#E65100", mfc="white", ms=4)
axes[1].annotate(f"today again,\nmonth {i_back}", (i_back, SCORE_M[i_back]), xytext=(i_back + 4, SCORE_M[i_back] - 3),
                 fontsize=7, color="#E65100", va="center")
fig.suptitle("One program, three ledgers, three clocks (seed 26113)", fontsize=10)
plt.tight_layout(); plt.show()
capital:     liquidity low $482.0 million in month 21
performance: the scorecard falls from 37.0 to 32.11 in month 11 and regains today's level in month 29 (37.19; 36.80 in month 28)
risk:        strategic risk peaks at 73.55 in month 11, 1.4 under the ceiling of 75 (measured +/-6)

the three reviews at month 11, each in its own ledger:
  performance: scorecard 32.1 against today's 37.0 -> a failing program
  capital:     liquidity $504 million, falling (-5.5 a month), $154 million above the floor -> an ample cushion
  risk:        strategic risk 73.6, the ceiling 1.4 points away -> inside the +/-6 error
One program, three ledgers, three clocks (seed 26113)

Panel 8 — Decide in one place (Worked Example 13.1, Step 5; Proposition 13.5; Theorem 13.4(iv); Worked Example 12.1: 24.6, 13.1, 12.4 and 3.0 percent)

AXIOM Lab 1.13, step 5, second part: compare the separated verdicts with the unified one. Deciding alone, each office guards its own ledger: the CRO will not shrink the buffer, the transformation office will not delay its technology gains, and the CFO will not pay for a line it does not use. Each repair taken alone is a separated choice, and the unified object reads every repair in every ledger: the joint check, and the risk ledger of Worked Example 12.1, the breach odds over Chapter 8's 100,000 paths (seed 8, the book's stream) against the 5 percent appetite. The joint check rules out the plan as signed off and the phased build alone; the risk ledger rules out the smaller buffer and the line alone, at 24.6 and 12.4 percent; only both levers pass every ledger, at 3.0 percent. A separated procedure is the unified problem with the other ledgers' repairs ruled out, so it never does better, and here strictly worse: its extra constraints exclude the only integrated answer (Proposition 13.5(ii)). The flaw of averages runs through every ledger at once (Theorem 13.4(iv)): the plan's low point is $482 million, while its simulated paths bottom out at $384 million on average. A fresh stream drawn with the lab's seed returns the same verdicts.

Python Code
CONFIGS = {"As signed off": {}, "Buffer at the median closure": {}, "Phased build": {"depth": DEPTH_PHASED},
           "Standby line": {"line": LINE}, "Both levers": {"line": LINE, "depth": DEPTH_PHASED}}
LEDGER = {"As signed off": "-", "Buffer at the median closure": "risk", "Phased build": "transformation",
          "Standby line": "capital", "Both levers": "transformation + capital"}     # Step 4: where each repair lives

def odds(L):
    lows = L[:, 1:].min(axis=1)
    p = float((lows < FLOOR).mean())
    return p, np.sqrt(p * (1 - p) / len(lows)), lows

BOOK, FRESH, _runs = {}, {}, {}
for name, kw in CONFIGS.items():                         # a buffer declaration does not change the cash: same paths
    key = tuple(sorted(kw.items()))
    if key not in _runs:
        _runs[key] = (odds(simulate(**kw)), odds(simulate(seed=SEED, **kw)))   # the book's paths (seed 8); a fresh stream
    BOOK[name], FRESH[name] = _runs[key]
LOWS = BOOK["As signed off"][2]
print(f"{'declaration':30s} {'ledger of the repair':24s} {'joint check':>12s} {'breach (seed 8)':>16s} {'risk ledger':>12s} {'every ledger':>13s}")
VERDICT = {}
for name in CONFIGS:
    spare, (p, se, _) = TABLE[name][3], BOOK[name]
    joint_ok, risk_ok = spare >= 0, p <= APPETITE
    VERDICT[name] = joint_ok and risk_ok
    print(f"{name:30s} {LEDGER[name]:24s} {spare:+7.1f} {'pass' if joint_ok else 'fail':>4s} {100 * p:9.1f}% ± {100 * se:.2f}"
          f" {'pass' if risk_ok else 'fail':>9s} {'yes' if VERDICT[name] else 'no':>13s}")
separated = ["Buffer at the median closure", "Phased build", "Standby line"]
print(f"\nseparated choices (one ledger's repair each): {len(separated)}; passing every ledger: {sum(VERDICT[s] for s in separated)}")
print(f"unified choices (the repairs and their combination): passing every ledger: {sum(VERDICT.values())}, "
      f"{', '.join(n for n in CONFIGS if VERDICT[n])}")
print(f"\nthe flaw of averages (Theorem 13.4(iv)): planned low ${PLAN.min():.1f} million; average of the simulated lows "
      f"${LOWS.mean():.1f} million (seed 8), {PLAN.min() - LOWS.mean():.0f} below the plan")
print("\nfresh stream (seed 26113), 100,000 paths each: the same verdicts")
for name in CONFIGS:
    (pb, sb, _), (pf, sf, _) = BOOK[name], FRESH[name]
    print(f"  {name:30s} {100 * pf:5.1f}% ± {100 * sf:.2f}  ({(pf - pb) / sb:+.1f} standard errors from the book's {100 * pb:.1f}%)"
          f"  risk ledger {'pass' if pf <= APPETITE else 'fail'}")

fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.add_patch(plt.Rectangle((0, 0), 130, 100 * APPETITE, color="#E3F0E4", lw=0, zorder=0))
ax.axvline(0, color="#616161", lw=0.9); ax.axhline(100 * APPETITE, color="#616161", lw=0.9, ls="--")
ax.text(127, 5.4, "appetite 5%", fontsize=7, color="#616161", ha="right")
ax.text(3, 0.7, "passes every ledger", fontsize=7, color="#2E7D32", ha="left")
ax.text(-3, 29, "← joint check fails", fontsize=7, color="#616161", ha="right")
ax.text(3, 29, "joint check passes →", fontsize=7, color="#616161", ha="left")
place = {"As signed off": (0, 1.6, "center"), "Buffer at the median closure": (0, 1.6, "center"),
         "Phased build": (-5, 0, "right"), "Standby line": (9, 0, "left"), "Both levers": (9, 0, "left")}
for name, col in zip(CONFIGS, ("#B71C1C", "#B71C1C", "#5E35B1", "#2E7D32", "#1F4E79")):
    x, (pb, sb, _), (pf, sf, _) = TABLE[name][3], BOOK[name], FRESH[name]
    ax.plot([x], [100 * pb], "o", color=col, ms=6, zorder=3)
    ax.errorbar([x + 3.5], [100 * pf], yerr=[200 * sf], fmt="o", mfc="white", color=col, ms=5, capsize=2, lw=1, zorder=3)
    dx, dy, ha = place[name]
    ax.text(x + dx, 100 * pb + dy, name.replace("Buffer at the median closure", "Median buffer"), fontsize=7, color=col,
            ha=ha, va="center" if dy == 0 else "bottom")
ax.plot([], [], "o", color="#616161", ms=6, label="the book's stream (seed 8)")
ax.errorbar([], [], yerr=[], fmt="o", mfc="white", color="#616161", ms=5, capsize=2, lw=1, label="fresh stream (seed 26113), ± 2 s.e.")
ax.set(xlabel="spare cash in the joint check ($ million)", ylabel="breach probability (%)", xlim=(-80, 130), ylim=(0, 31),
       title="Only both levers pass every ledger (seed 26113)")
ax.legend(frameon=False, fontsize=7, loc="center right", bbox_to_anchor=(1.0, 0.62))
plt.tight_layout(); plt.show()
declaration                    ledger of the repair      joint check  breach (seed 8)  risk ledger  every ledger
As signed off                  -                          -54.9 fail      24.6% ± 0.14      fail            no
Buffer at the median closure   risk                       +18.8 pass      24.6% ± 0.14      fail            no
Phased build                   transformation              -5.9 fail      13.1% ± 0.11      fail            no
Standby line                   capital                    +45.1 pass      12.4% ± 0.10      fail            no
Both levers                    transformation + capital   +94.1 pass       3.0% ± 0.05      pass           yes

separated choices (one ledger's repair each): 3; passing every ledger: 0
unified choices (the repairs and their combination): passing every ledger: 1, Both levers

the flaw of averages (Theorem 13.4(iv)): planned low $482.0 million; average of the simulated lows $383.8 million (seed 8), 98 below the plan

fresh stream (seed 26113), 100,000 paths each: the same verdicts
  As signed off                   24.5% ± 0.14  (-0.6 standard errors from the book's 24.6%)  risk ledger fail
  Buffer at the median closure    24.5% ± 0.14  (-0.6 standard errors from the book's 24.6%)  risk ledger fail
  Phased build                    13.1% ± 0.11  (+0.6 standard errors from the book's 13.1%)  risk ledger fail
  Standby line                    12.3% ± 0.10  (-0.6 standard errors from the book's 12.4%)  risk ledger fail
  Both levers                      3.0% ± 0.05  (+0.4 standard errors from the book's 3.0%)  risk ledger pass
Only both levers pass every ledger (seed 26113)

Validation — the book's numbers, and agreement with DCT_V1_Ch13_Lab.xlsx

Each checkpoint is a number printed in Chapter 13 (Worked Example 13.1, Tables 13.1 and 13.6, Figures 13.1–13.3, Sections 13.5 and 13.6) or in Online Appendix 13.B.1–13.B.4. The breach odds and the average low are the book's simulated paths (seed 8). The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.

Python Code
T = TABLE
checks = [
    ("components in the skeleton (workbook)", len(COMPONENTS), 7, 0),
    ("feedback core: components (workbook)", len(core), 4, 0),
    ("forms of capital (workbook)", len(FORMS), 10, 0),
    ("performance dimensions (workbook)", len(DIMENSIONS), 10, 0),
    ("capability rent, $ million a year (workbook)", RENT, 23, 0.5),
    ("cash above the floor today (workbook)", POOL, 270, 0),
    ("each layer alone: total impact (workbook)", 1 / (1 - 0.5), 2, 1e-9),
    ("total impact, no coupling (workbook)", BILL[0.0], 2, 1e-9),
    ("total impact at c = 0.25 (workbook)", BILL[0.25], 4, 1e-9),
    ("total impact at c = 0.40 (workbook)", BILL[0.40], 10, 1e-9),
    ("rho(M) at c = 0.25, a + c (workbook)", REPORT[0.25][0], 0.75, 1e-9),
    ("rho(M) at c = 0.5: no finite bill (workbook)", REPORT[0.50][0], 1.0, 1e-9),
    ("program: quarters to treasury (workbook)", PROGRAM["TRS"], 1, 0),
    ("program: quarters to Industrial Systems (workbook)", PROGRAM["IND"], 1, 0),
    ("program: components never reached (workbook)", len(never), 3, 0),
    ("demand shock: quarters to the divisions (workbook)", max(SHOCK[c] for c in ("IND", "DIG", "MAT")), 1, 0),
    ("demand shock: quarters to engineering (workbook)", SHOCK["ENG"], 2, 0),
    ("demand shock: quarters to treasury (workbook)", SHOCK["TRS"], 2, 0),
    ("plan liquidity, quarter 1 (workbook)", PLAN[1], 574, 0.5),
    ("plan liquidity, quarter 12 (workbook)", PLAN[12], 510, 0.5),
    ("phased liquidity, quarter 1 (workbook)", PHASED[1], 589, 0.5),
    ("phased liquidity, quarter 12 (workbook)", PHASED[12], 556, 0.5),
    ("deepest draw (workbook)", DRAW, 138, 0.5),
    ("quarter of the deepest draw (workbook)", K7, 7, 0),
    ("funding check: spare (workbook)", POOL - DRAW, 132, 0.5),
    ("closure: 90th percentile (workbook)", BUFFER, 187, 0.5),
    ("buffer check: spare (workbook)", POOL - BUFFER, 83, 0.5),
    ("closure: median (workbook)", MEDIAN, 113, 0.5),
    ("joint check: total claims (workbook)", T["As signed off"][2], 325, 0.5),
    ("joint check: spare (workbook)", T["As signed off"][3], -55, 0.5),
    ("buffer line (workbook)", BUFFER_LINE, 537, 0.5),
    ("plan inside the buffer line: first quarter (workbook)", inside[0], 3, 0),
    ("plan inside the buffer line: last quarter (workbook)", inside[-1], 12, 0),
    ("plan inside the buffer line: deepest (workbook)", BUFFER_LINE - PLAN.min(), 55, 0.5),
    ("phased inside the buffer line: first quarter (workbook)", inside_ph[0], 5, 0),
    ("phased inside the buffer line: last quarter (workbook)", inside_ph[-1], 8, 0),
    ("phased inside the buffer line: deepest (workbook)", BUFFER_LINE - PHASED.min(), 6, 0.5),
    ("median buffer: total claims (workbook)", T["Buffer at the median closure"][2], 251, 0.5),
    ("median buffer: spare (workbook)", T["Buffer at the median closure"][3], 19, 0.5),
    ("phased build: draw (workbook)", T["Phased build"][0], 89, 0.5),
    ("phased build: total claims (workbook)", T["Phased build"][2], 276, 0.5),
    ("phased build: spare (workbook)", T["Phased build"][3], -6, 0.5),
    ("standby line: cash buffer (workbook)", T["Standby line"][1], 87, 0.5),
    ("standby line: total claims (workbook)", T["Standby line"][2], 225, 0.5),
    ("standby line: spare (workbook)", T["Standby line"][3], 45, 0.5),
    ("both levers: total claims (workbook)", T["Both levers"][2], 176, 0.5),
    ("both levers: spare (workbook)", T["Both levers"][3], 94, 0.5),
    ("scorecard today (workbook)", TODAY, 37.0, 0.05),
    ("liquidity low, $ million (workbook)", LIQ_M[i_liq], 482, 0.5),
    ("month of the liquidity low (workbook)", i_liq, 21, 0),
    ("scorecard low (workbook)", SCORE_M[i_sc], 32.1, 0.05),
    ("month of the scorecard low (workbook)", i_sc, 11, 0),
    ("month the scorecard regains 37.0 (workbook)", i_back, 29, 0),
    ("scorecard in that month (workbook)", SCORE_M[i_back], 37.19, 0.005),
    ("strategic-risk peak (workbook)", RISK_M[i_rk], 73.55, 0.005),
    ("month of the risk peak (workbook)", i_rk, 11, 0),
    ("ceiling's distance at the peak (workbook)", 75 - RISK_M[i_rk], 1.4, 0.05),
    ("breach odds, plan as signed off, % (seed 8)", 100 * BOOK["As signed off"][0], 24.6, 0.05),
    ("breach odds, phased build, % (seed 8)", 100 * BOOK["Phased build"][0], 13.1, 0.05),
    ("breach odds, standby line, % (seed 8)", 100 * BOOK["Standby line"][0], 12.4, 0.05),
    ("breach odds, both levers, % (seed 8)", 100 * BOOK["Both levers"][0], 3.0, 0.05),
    ("planned low point, $ million (workbook)", PLAN.min(), 482, 0.5),
    ("average simulated low, $ million (seed 8)", LOWS.mean(), 384, 0.5),
    ("repairs that pass every ledger (workbook)", sum(VERDICT.values()), 1, 0),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
    status = "PASS" if abs(got - want) <= tol + 1e-9 else "FAIL"; ok += status == "PASS"
    print(f"{name:{width}s} {got:10.4f}   book {want:9.4f}   {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")
components in the skeleton (workbook)                       7.0000   book    7.0000   PASS
feedback core: components (workbook)                        4.0000   book    4.0000   PASS
forms of capital (workbook)                                10.0000   book   10.0000   PASS
performance dimensions (workbook)                          10.0000   book   10.0000   PASS
capability rent, $ million a year (workbook)               23.2000   book   23.0000   PASS
cash above the floor today (workbook)                     270.0000   book  270.0000   PASS
each layer alone: total impact (workbook)                   2.0000   book    2.0000   PASS
total impact, no coupling (workbook)                        2.0000   book    2.0000   PASS
total impact at c = 0.25 (workbook)                         4.0000   book    4.0000   PASS
total impact at c = 0.40 (workbook)                        10.0000   book   10.0000   PASS
rho(M) at c = 0.25, a + c (workbook)                        0.7500   book    0.7500   PASS
rho(M) at c = 0.5: no finite bill (workbook)                1.0000   book    1.0000   PASS
program: quarters to treasury (workbook)                    1.0000   book    1.0000   PASS
program: quarters to Industrial Systems (workbook)          1.0000   book    1.0000   PASS
program: components never reached (workbook)                3.0000   book    3.0000   PASS
demand shock: quarters to the divisions (workbook)          1.0000   book    1.0000   PASS
demand shock: quarters to engineering (workbook)            2.0000   book    2.0000   PASS
demand shock: quarters to treasury (workbook)               2.0000   book    2.0000   PASS
plan liquidity, quarter 1 (workbook)                      574.1777   book  574.0000   PASS
plan liquidity, quarter 12 (workbook)                     510.4240   book  510.0000   PASS
phased liquidity, quarter 1 (workbook)                    589.0507   book  589.0000   PASS
phased liquidity, quarter 12 (workbook)                   555.5499   book  556.0000   PASS
deepest draw (workbook)                                   138.0496   book  138.0000   PASS
quarter of the deepest draw (workbook)                      7.0000   book    7.0000   PASS
funding check: spare (workbook)                           131.9504   book  132.0000   PASS
closure: 90th percentile (workbook)                       186.8670   book  187.0000   PASS
buffer check: spare (workbook)                             83.1330   book   83.0000   PASS
closure: median (workbook)                                113.1316   book  113.0000   PASS
joint check: total claims (workbook)                      324.9166   book  325.0000   PASS
joint check: spare (workbook)                             -54.9166   book  -55.0000   PASS
buffer line (workbook)                                    536.8670   book  537.0000   PASS
plan inside the buffer line: first quarter (workbook)       3.0000   book    3.0000   PASS
plan inside the buffer line: last quarter (workbook)       12.0000   book   12.0000   PASS
plan inside the buffer line: deepest (workbook)            54.9166   book   55.0000   PASS
phased inside the buffer line: first quarter (workbook)     5.0000   book    5.0000   PASS
phased inside the buffer line: last quarter (workbook)      8.0000   book    8.0000   PASS
phased inside the buffer line: deepest (workbook)           5.8931   book    6.0000   PASS
median buffer: total claims (workbook)                    251.1812   book  251.0000   PASS
median buffer: spare (workbook)                            18.8188   book   19.0000   PASS
phased build: draw (workbook)                              89.0261   book   89.0000   PASS
phased build: total claims (workbook)                     275.8931   book  276.0000   PASS
phased build: spare (workbook)                             -5.8931   book   -6.0000   PASS
standby line: cash buffer (workbook)                       86.8670   book   87.0000   PASS
standby line: total claims (workbook)                     224.9166   book  225.0000   PASS
standby line: spare (workbook)                             45.0834   book   45.0000   PASS
both levers: total claims (workbook)                      175.8931   book  176.0000   PASS
both levers: spare (workbook)                              94.1069   book   94.0000   PASS
scorecard today (workbook)                                 37.0000   book   37.0000   PASS
liquidity low, $ million (workbook)                       481.9504   book  482.0000   PASS
month of the liquidity low (workbook)                      21.0000   book   21.0000   PASS
scorecard low (workbook)                                   32.1065   book   32.1000   PASS
month of the scorecard low (workbook)                      11.0000   book   11.0000   PASS
month the scorecard regains 37.0 (workbook)                29.0000   book   29.0000   PASS
scorecard in that month (workbook)                         37.1874   book   37.1900   PASS
strategic-risk peak (workbook)                             73.5521   book   73.5500   PASS
month of the risk peak (workbook)                          11.0000   book   11.0000   PASS
ceiling's distance at the peak (workbook)                   1.4479   book    1.4000   PASS
breach odds, plan as signed off, % (seed 8)                24.6220   book   24.6000   PASS
breach odds, phased build, % (seed 8)                      13.0680   book   13.1000   PASS
breach odds, standby line, % (seed 8)                      12.3740   book   12.4000   PASS
breach odds, both levers, % (seed 8)                        3.0030   book    3.0000   PASS
planned low point, $ million (workbook)                   481.9504   book  482.0000   PASS
average simulated low, $ million (seed 8)                 383.8315   book  384.0000   PASS
repairs that pass every ledger (workbook)                   1.0000   book    1.0000   PASS

64 of 64 checkpoints PASS

Next. Chapter 14 asks what the assembled system does: well-posedness, equilibria, stability (opening with the interaction matrix's spectral reading), sensitivity, and viability, whether the unified feasible region can be maintained along a transformation path. AXIOM-13 runs the same model interactively (Lab 1.13); 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