Skip to content

Vol. I, Ch. 1

DCT Laboratory — Volume I, Chapter 1

Introduction to Dynamic Corporate Transformation

This laboratory demonstrates

Seed 26101 · Companion to Chapter 1 and AXIOM Lab 1.1 (module AXIOM-01) · Mirrored in DCT_V1_Ch01_Lab.xlsx

This laboratory reproduces Worked Example 1.1, Same Score, Different Company, with the book's declarations, and works the five steps of AXIOM Lab 1.1, Meridian at a Crossroads: read the dashboard, play the three options, compare paths rather than endpoints, add uncertainty, and build your own score. Every Meridian number below is the book's (Worked Example 1.1 and Table 1.9, Figure 1.3, Section 1.5 and Tables 1.4–1.5, Online Appendix 1.B); the final cell checks them. Money is in $ million; liquidity is also read as an index, with today = 100 = $620 million.

The declarations (Worked Example 1.1, Step 1; Online Appendix 1.B.4)

Meridian's state today is the one Chapter 3 declares (Table 3.1): liquidity $0.62 billion, read as an index with today = 100, so that a point is $6.2 million; net leverage 3.4 times EBITDA; workforce capability 58; technology platform 41; operational efficiency 71; ROIC 8.3 percent; strategic risk 64 (lower is better); and market share 19 percent. Chapter 1's model moves four of the eight readings — liquidity x1x_1, technology x4x_4, efficiency x5x_5 and strategic risk x7x_7 — and holds the other four at today's values. Each moving reading relaxes toward an option's target xˉi\bar x_i at speed kik_i, with a trough of depth DiD_i at τi\tau_i years for temporary strain and a jump JiJ_i when the sale closes at t=1t = 1 (Equation 1.B.1, with the parameters of Table 1.B.1):

xi(t)=xˉi+(xi(0)−xˉi)e−kit+σiDi tτi e1−t/τi+Ji 1{t≥1}.x_i(t) = \bar x_i + \bigl(x_i(0) - \bar x_i\bigr)e^{-k_i t} + \sigma_i D_i\,\frac{t}{\tau_i}\,e^{1 - t/\tau_i} + J_i\,\mathbf{1}\{t \ge 1\}.

The CFO's scorecard weighs liquidity, technology and efficiency equally and subtracts strategic risk, Score=14 (x1+x4+x5−x7)\text{Score} = \tfrac14\,(x_1 + x_4 + x_5 - x_7). Paths are computed month by month over five years.

Python Code
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.optimize import brentq, minimize_scalar
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26101

# Meridian today (Chapter 3, Table 3.1); liquidity as an index, today = 100 = $620 million
READINGS = ["liquidity", "net leverage", "workforce capability", "technology platform",
            "operational efficiency", "ROIC", "strategic risk", "market share"]
X0 = np.array([100.0, 3.4, 58.0, 41.0, 71.0, 0.083, 64.0, 0.19])
USD_PER_POINT = 620.0 / 100                  # $ million per liquidity point
MOVING = {"x1": 0, "x4": 3, "x5": 4, "x7": 6}  # the four readings the Chapter 1 model moves

# Table 1.B.1: target, speed k, trough (sign x depth), trough time tau (years), jump at the sale
PARAMS = {
    "Digital":       {"x1": (112, 0.35, -28, 2.0, 0), "x4": (78, 0.55, 0, 1.0, 0),
                      "x5": (77, 0.50, -9, 1.5, 0),   "x7": (51, 0.40, 14, 1.2, 0)},
    "Restructuring": {"x1": (104, 0.30, 0, 1.0, 18),  "x4": (38, 0.25, 0, 1.0, 0),
                      "x5": (74, 0.45, 0, 1.0, 0),    "x7": (56, 0.35, 0, 1.0, -8)},
    "Turnaround":    {"x1": (106, 0.45, 0, 1.0, 0),   "x4": (33, 0.20, 0, 1.0, 0),
                      "x5": (79, 0.60, 0, 1.0, 0),    "x7": (67, 0.30, 0, 1.0, 0)},
}
OPTIONS = list(PARAMS)
T_SALE = 1.0
MONTH = np.arange(61)
T = MONTH / 12                                # monthly grid, five years
COLOR = {"Digital": "#5E35B1", "Restructuring": "#2E7D32", "Turnaround": "#E65100"}

def reading(option, key, t):
    target, k, depth, tau, jump = PARAMS[option][key]
    t, x0 = np.asarray(t, float), X0[MOVING[key]]
    return target + (x0 - target) * np.exp(-k * t) + depth * (t / tau) * np.exp(1 - t / tau) + jump * (t >= T_SALE)

def path(option, t=T):
    return {key: reading(option, key, t) for key in MOVING}

CFO = np.array([0.25, 0.25, 0.25, -0.25])     # the CFO's weights on (x1, x4, x5, x7)
def score(p, w=CFO):
    return w[0] * p["x1"] + w[1] * p["x4"] + w[2] * p["x5"] + w[3] * p["x7"]

P = {o: path(o) for o in OPTIONS}
S = {o: score(P[o]) for o in OPTIONS}
NOW = {key: X0[i] for key, i in MOVING.items()}
today = float(score(NOW))
print(f"Meridian today: {len(X0)} readings, {len(MOVING)} of them moving; a liquidity point is ${USD_PER_POINT:.1f} million")
print(f"{len(MONTH)} monthly dates over {T[-1]:.0f} years; today's score {today:.1f}")
Meridian today: 8 readings, 4 of them moving; a liquidity point is $6.2 million
61 monthly dates over 5 years; today's score 37.0

Panel 1 — Read the dashboard (Worked Example 1.1, Step 1)

AXIOM Lab 1.1, step 1: what each of the eight readings measures and where its data come from. Chapter 5 declares each reading's source and error band (Table 5.2). On Chapter 3's declared scale — unbounded readings divided by today's value, indices by their range of 100 — the widest bands belong to strategic risk and workforce capability: the two readings whose margins Chapter 16 finds thinner than their reading error (Table 1.5). The four moving readings give today's score, 14(100+41+71−64)=37.0\tfrac14(100 + 41 + 71 - 64) = 37.0.

Python Code
UNIT = ["index, today = 100", "net debt / EBITDA", "index, 0-100", "index, 0-100",
        "index, 0-100", "ratio", "index, 0-100", "ratio"]
SOURCE = ["treasury systems (+/-1%)", "audited accounts (+/-2%)", "skills survey (+/-5)", "architecture audit (+/-4)",
          "cost benchmarking (+/-3)", "audited accounts (+/-0.4 pp)", "risk committee (+/-6)", "industry data (+/-0.8 pp)"]
ERROR = np.array([0.01 * X0[0], 0.02 * X0[1], 5, 4, 3, 0.004, 6, 0.008])   # Table 5.2, in each reading's unit
SCALE = np.array([X0[0], X0[1], 100, 100, 100, X0[5], 100, X0[7]])        # Chapter 3's declared scale
rel = ERROR / SCALE
moving = [i in MOVING.values() for i in range(8)]
print(f"     {'reading':24s}{'today':>7s}  {'unit':20s}{'Chapter 1 model':17s}{'measured by (error)':30s}scaled error")
for i in range(8):
    print(f"x{i + 1}   {READINGS[i]:24s}{X0[i]:7.3g}  {UNIT[i]:20s}{('moves' if moving[i] else 'held at today'):17s}{SOURCE[i]:30s}{rel[i]:.3f}")
two = np.argsort(-rel)[:2]
print(f"widest declared error bands: {READINGS[two[0]]} ({rel[two[0]]:.3f}) and {READINGS[two[1]]} ({rel[two[1]]:.3f})")
print(f"today's score = (100 + 41 + 71 - 64)/4 = {today:.1f}")
     reading                   today  unit                Chapter 1 model  measured by (error)           scaled error
x1   liquidity                   100  index, today = 100  moves            treasury systems (+/-1%)      0.010
x2   net leverage                3.4  net debt / EBITDA   held at today    audited accounts (+/-2%)      0.020
x3   workforce capability         58  index, 0-100        held at today    skills survey (+/-5)          0.050
x4   technology platform          41  index, 0-100        moves            architecture audit (+/-4)     0.040
x5   operational efficiency       71  index, 0-100        moves            cost benchmarking (+/-3)      0.030
x6   ROIC                      0.083  ratio               held at today    audited accounts (+/-0.4 pp)  0.048
x7   strategic risk               64  index, 0-100        moves            risk committee (+/-6)         0.060
x8   market share               0.19  ratio               held at today    industry data (+/-0.8 pp)     0.042
widest declared error bands: strategic risk (0.060) and workforce capability (0.050)
today's score = (100 + 41 + 71 - 64)/4 = 37.0

Panel 2 — Play the three options (Worked Example 1.1, Step 2; Table 1.9)

AXIOM Lab 1.1, step 2: run each option over five years, pause around month 21 and at the sale date in Year 1, and record the four moving readings at Year 5. The Year-5 readings are Table 1.9's. Digital scores 47.1 and restructuring 46.1, a one-point gap well inside any forecast error; the turnaround, at 38.4, is clearly behind.

Python Code
Y5 = {o: np.array([P[o][key][-1] for key in MOVING]) for o in OPTIONS}
NAMES = ["liquidity (index)", "technology platform", "operational efficiency", "strategic risk"]
print("Table 1.9 -- Meridian today and in Year 5")
print(f"{'reading':24s}{'today':>8s}" + "".join(f"{o:>15s}" for o in OPTIONS))
for j, name in enumerate(NAMES):
    print(f"{name:24s}{X0[list(MOVING.values())[j]]:8.1f}" + "".join(f"{Y5[o][j]:15.1f}" for o in OPTIONS))
print(f"{'score':24s}{today:8.1f}" + "".join(f"{S[o][-1]:15.1f}" for o in OPTIONS))
print(f"digital leads restructuring by {S['Digital'][-1] - S['Restructuring'][-1]:.2f} points; "
      f"the turnaround trails by {S['Digital'][-1] - S['Turnaround'][-1]:.1f}")
print("\npauses: the four readings and the score")
for m, label in ((11, "month 11, before the sale"), (12, "month 12, the sale closes"), (21, "month 21")):
    for o in OPTIONS:
        print(f"  {label:27s}{o:15s}" + "".join(f"{P[o][key][m]:8.1f}" for key in MOVING) + f"   score {S[o][m]:5.1f}")

fig, axes = plt.subplots(2, 2, figsize=(7.6, 3.6), sharex=True)
for ax, key, name in zip(axes.flat, MOVING, NAMES):
    for o in OPTIONS:
        ax.plot(T, P[o][key], color=COLOR[o], lw=1.6, label=o)
    ax.axhline(NOW[key], color="#999999", lw=0.6, ls=":")
    ax.set_ylabel(name.replace(" (index)", "") + " (index)", fontsize=7.5)
    ax.tick_params(labelsize=7)
for ax in axes[1]:
    ax.set_xlabel("years from today", fontsize=8)
axes[0, 1].legend(frameon=False, fontsize=7, loc="upper left")
fig.suptitle("Four readings move, along three different paths (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()
Table 1.9 -- Meridian today and in Year 5
reading                    today        Digital  Restructuring     Turnaround
liquidity (index)          100.0           94.3          121.1          105.4
technology platform         41.0           75.6           38.9           35.9
operational efficiency      71.0           73.6           73.7           78.6
strategic risk              64.0           55.2           49.4           66.3
score                       37.0           47.1           46.1           38.4
digital leads restructuring by 1.01 points; the turnaround trails by 8.7

pauses: the four readings and the score
  month 11, before the sale  Digital            81.2    55.7    65.1    73.6   score  32.1
  month 11, before the sale  Restructuring     101.0    40.4    72.0    61.8   score  37.9
  month 11, before the sale  Turnaround        102.0    39.7    74.4    64.7   score  37.8
  month 12, the sale closes  Digital            80.5    56.7    65.0    73.5   score  32.2
  month 12, the sale closes  Restructuring     119.0    40.3    72.1    53.6   score  44.5
  month 12, the sale closes  Turnaround        102.2    39.5    74.6    64.8   score  37.9
  month 21                   Digital            77.7    63.9    65.6    70.4   score  34.2
  month 21                   Restructuring     119.6    39.9    72.6    52.3   score  45.0
  month 21                   Turnaround        103.3    38.6    76.2    65.2   score  38.2
Four readings move, along three different paths (seed 26101)

Panel 3 — Compare paths, not just endpoints (Worked Example 1.1, Step 5; Figure 1.3; Proposition 1.1)

AXIOM Lab 1.1, step 3: the state-space view, technology against liquidity. The digital path reaches its lowest liquidity, 77.7, around month 21 — 22 percent below today, about $138 million — before recovering, while the restructuring jumps by 18 points, about $112 million, when the sale closes in Year 1. A before-and-after slide shows neither. Nor does it show the strategic-risk peak on the digital path at month 11, 1.4 points under the ceiling of 75 that Chapter 5 declares (Table 1.5), or the scorecard's own path: the digital score stays below today's 37.0 until month 29, so annual reviews rank digital last for two years (Section 1.5.4).

Python Code
d1 = P["Digital"]["x1"]
i_low = int(np.argmin(d1))
low = minimize_scalar(lambda t: float(reading("Digital", "x1", t)), bounds=(0.5, 3.0), method="bounded",
                      options={"xatol": 1e-10})
drop = 100 - low.fun
print(f"digital liquidity, monthly: lowest {d1[i_low]:.2f} in month {MONTH[i_low]}; "
      f"continuous: {low.fun:.2f} at {low.x:.2f} years ({12 * low.x:.1f} months)")
print(f"  {drop:.1f} points ({drop:.0f} percent) below today, about ${drop * USD_PER_POINT:.0f} million")
jump = PARAMS["Restructuring"]["x1"][4]
r1 = P["Restructuring"]["x1"]
print(f"restructuring: liquidity jumps {jump} points when the sale closes, about ${jump * USD_PER_POINT:.0f} million "
      f"(month 11 -> 12: {r1[11]:.1f} -> {r1[12]:.1f})")
CEILING = 75.0                                # strategic-risk ceiling (Chapter 5, Table 5.4)
peak = minimize_scalar(lambda t: -float(reading("Digital", "x7", t)), bounds=(0.2, 2.0), method="bounded",
                       options={"xatol": 1e-10})
risk_gap = CEILING + peak.fun
print(f"digital strategic risk peaks at {-peak.fun:.2f} at {12 * peak.x:.1f} months: "
      f"{risk_gap:.1f} points under the ceiling of {CEILING:.0f}, inside the risk committee's +/-6")
sd = S["Digital"]
i_min = int(np.argmin(sd))
back = int(next(m for m in MONTH[1:] if sd[m] >= today and sd[m - 1] < today))
print(f"\ndigital score: low {sd[i_min]:.1f} in month {i_min}; below today's {today:.1f} in months "
      f"{MONTH[sd < today].min()}-{MONTH[sd < today].max()}; back to {sd[back]:.2f} in month {back}")
print("annual reviews: score (rank among the three)")
last_years = []
for y in range(1, 6):
    m = 12 * y
    vals = {o: S[o][m] for o in OPTIONS}
    order = sorted(OPTIONS, key=lambda o: -vals[o])
    if order[-1] == "Digital":
        last_years.append(y)
    print(f"  Year {y}: " + ",  ".join(f"{o.lower()} {vals[o]:.2f} ({order.index(o) + 1})" for o in OPTIONS))
print(f"digital ranks last at the reviews of years {last_years}: {len(last_years)} years")

fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.15, 1]})
j = int(np.argmax(T >= T_SALE))
for o in OPTIONS:
    x, y = P[o]["x4"], P[o]["x1"]
    if o == "Restructuring":
        ax.plot(x[:j], y[:j], color=COLOR[o], lw=1.6, label=o)
        ax.plot(x[j - 1:j + 1], y[j - 1:j + 1], color=COLOR[o], lw=1.1, ls="--")
        ax.plot(x[j:], y[j:], color=COLOR[o], lw=1.6)
    else:
        ax.plot(x, y, color=COLOR[o], lw=1.6, label=o)
    ax.plot(x[-1], y[-1], "s", ms=4, color=COLOR[o])
ax.plot(NOW["x4"], NOW["x1"], "o", ms=5, color="#1F4E79", zorder=5)
ax.annotate("today", (NOW["x4"], NOW["x1"]), xytext=(-26, -12), textcoords="offset points", fontsize=7, color="#1F4E79")
ax.plot(P["Digital"]["x4"][i_low], d1[i_low], "o", ms=3.5, color=COLOR["Digital"])
ax.annotate(f"low point, month {MONTH[i_low]}", (P["Digital"]["x4"][i_low], d1[i_low]), xytext=(-20, 10),
            textcoords="offset points", fontsize=7, color=COLOR["Digital"])
ax.annotate("sale closes", (P["Restructuring"]["x4"][j], (r1[j - 1] + r1[j]) / 2), xytext=(8, 0),
            textcoords="offset points", fontsize=7, color=COLOR["Restructuring"])
ax.set(xlabel="technology platform (index, 0-100)", ylabel="liquidity (index, today = 100)")
ax.legend(frameon=False, fontsize=7, loc="upper right")
for o in OPTIONS:
    bx.plot(MONTH, S[o], color=COLOR[o], lw=1.6)
bx.axhline(today, color="#616161", lw=0.8, ls=":")
bx.plot(12 * np.arange(1, 6), sd[12 * np.arange(1, 6)], "o", ms=3, color=COLOR["Digital"])
bx.annotate(f"back to today's {today:.0f} in month {back}", (back, sd[back]), xytext=(4, -16),
            textcoords="offset points", fontsize=7, color=COLOR["Digital"])
bx.set(xlabel="months from today (dots: annual reviews)", ylabel="CFO's score (points)")
for a in (ax, bx):
    a.tick_params(labelsize=7); a.xaxis.label.set_size(8); a.yaxis.label.set_size(8)
fig.suptitle("Same start, different paths; the score has a path too (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()
digital liquidity, monthly: lowest 77.73 in month 21; continuous: 77.73 at 1.71 years (20.6 months)
  22.3 points (22 percent) below today, about $138 million
restructuring: liquidity jumps 18 points when the sale closes, about $112 million (month 11 -> 12: 101.0 -> 119.0)
digital strategic risk peaks at 73.55 at 10.9 months: 1.4 points under the ceiling of 75, inside the risk committee's +/-6

digital score: low 32.1 in month 11; below today's 37.0 in months 1-28; back to 37.19 in month 29
annual reviews: score (rank among the three)
  Year 1: digital 32.15 (3),  restructuring 44.46 (1),  turnaround 37.89 (2)
  Year 2: digital 35.27 (3),  restructuring 45.11 (1),  turnaround 38.29 (2)
  Year 3: digital 39.88 (2),  restructuring 45.55 (1),  turnaround 38.43 (3)
  Year 4: digital 43.96 (2),  restructuring 45.86 (1),  turnaround 38.45 (3)
  Year 5: digital 47.08 (1),  restructuring 46.07 (2),  turnaround 38.40 (3)
digital ranks last at the reviews of years [1, 2]: 2 years
Same start, different paths; the score has a path too (seed 26101)

Panel 4 — Add uncertainty (Section 1.5.3: 24.6 and 3.0 percent; Volume I, Worked Example 8.1)

AXIOM Lab 1.1, step 4: the uncertainty fan for the digital option's liquidity. Chapter 1 draws one path per option; the fan uses the uncertainty the book declares for this program in Chapter 8 (Worked Example 8.1, cited in Section 1.5.3). The plan is this chapter's digital path read quarterly in $ million (index × 6.2) over the program's three years: it dips from $620 million to a trough of $482 million in quarter 7, $132 million above the board's floor of $350 million. Each quarter brings an execution and market surprise with a standard deviation of $50 million, 60 percent of which carries into the next quarter; funding windows close about once a decade (0.10 a year), each removing on average $120 million (standard deviation $50 million) for the rest of the program. Two levers: a standby line that replaces up to $100 million of any closure, and a phased build whose trough depth is 20 instead of 28. The book draws this model's 100,000 paths with random seed 8 (Volume II, Online Appendix 1.B.4: "Volume I's Chapter 8 model, random seed 8"), so the draws below use seed 8 and reproduce the printed odds exactly; the lab's seed 26101 is used only for one fresh stream at the end, labelled as such.

Python Code
FLOOR, A_E, SD_W = 350.0, 0.6, 50.0             # $ million; carry-over; surprise sd a quarter
LAM, J_MEAN, J_SD = 0.10, 120.0, 50.0           # closures a year; size mean and sd ($ million)
QUARTERS, N_PATHS = 12, 100_000
SHAPE, SCALE_G = (J_MEAN / J_SD) ** 2, J_SD ** 2 / J_MEAN    # gamma sizes
BOOK_SEED = 8                                   # the book's stream for this model (Volume II, Online Appendix 1.B.4)

def plan(depth=28.0):
    t = np.arange(QUARTERS + 1) / 4
    x1 = 112 + (X0[0] - 112) * np.exp(-0.35 * t) - depth * (t / 2.0) * np.exp(1 - t / 2.0)
    return USD_PER_POINT * x1

def simulate(line=0.0, depth=28.0, n=N_PATHS, seed=BOOK_SEED):
    # Worked Example 8.1's two channels, quarter by quarter; returns liquidity paths [n, 13]
    rng = np.random.default_rng(seed)
    pl, E, J = plan(depth), np.zeros(n), np.zeros(n)
    L = np.empty((n, QUARTERS + 1)); L[:, 0] = pl[0]
    for k in range(QUARTERS):
        w = rng.normal(0.0, SD_W, n)
        cnt = rng.poisson(LAM / 4, n)
        sizes = np.zeros(n)
        for i in np.nonzero(cnt)[0]:
            sizes[i] = np.maximum(rng.gamma(SHAPE, SCALE_G, cnt[i]) - line, 0.0).sum()
        E = A_E * E + w
        J = J - sizes
        L[:, k + 1] = pl[k + 1] + E + J
    return L

pl = plan()
k_low = int(np.argmin(pl))
print("plan by quarter ($ million):", np.round(pl, 0).astype(int))
print(f"trough ${pl[k_low]:.0f} million in quarter {k_low} (month {3 * k_low}); ${pl[k_low] - FLOOR:.0f} million above the floor; "
      f"the program draws ${pl[0] - pl[k_low]:.0f} million")
print(f"surprises: long-run sd {SD_W / np.sqrt(1 - A_E ** 2):.1f}, so the trough's headroom is "
      f"{(pl[k_low] - FLOOR) / (SD_W / np.sqrt(1 - A_E ** 2)):.1f} sd; closures: "
      f"P(at least one in three years) = {1 - np.exp(-3 * LAM):.3f}")

RUNS = {"plan as drawn": {}, "standby line ($100m)": {"line": 100.0}, "phased build": {"depth": 20.0},
        "line and phased build": {"line": 100.0, "depth": 20.0}}
res = {}
for name, kw in RUNS.items():
    L = simulate(**kw)
    lows = L[:, 1:].min(axis=1)
    p = float((lows < FLOOR).mean())
    q5 = np.percentile(lows, 5)
    res[name] = {"L": L, "p": p, "se": np.sqrt(p * (1 - p) / N_PATHS), "es": float(lows[lows <= q5].mean()),
                 "trough": float(plan(kw.get("depth", 28.0)).min())}
L0 = res["plan as drawn"]["L"]
q10, q90 = np.percentile(L0[:, k_low], [10, 90])
print(f"\nfan at quarter {k_low} (month {3 * k_low}): 80 percent of paths between ${q10:.0f} and ${q90:.0f} million, "
      f"a band ${q90 - q10:.0f} million wide; mean path's low ${L0.mean(axis=0).min():.0f} million")
print(f"the book's draws (seed {BOOK_SEED}):")
print(f"{'':24s}{'plan trough':>12s}{'breach odds':>13s}{'s.e.':>7s}   worst 5% of troughs: average, below the floor")
for name, r in res.items():
    print(f"{name:24s}{r['trough']:12.0f}{100 * r['p']:12.2f}%{100 * r['se']:7.2f}{r['es']:14.1f}{FLOOR - r['es']:14.1f}")
buffer = stats.gamma.ppf(0.9, SHAPE, scale=SCALE_G)
draw = pl[0] - pl[k_low]
print(f"\na bad closure (90th percentile) is ${buffer:.0f} million; the program's draw is ${draw:.0f} million; "
      f"together ${draw + buffer:.0f} million against ${pl[0] - FLOOR:.0f} million above the floor")
fresh = simulate(seed=SEED)                     # a fresh stream with the lab's seed: not the book's draws
p_fresh = float((fresh[:, 1:].min(axis=1) < FLOOR).mean())
print(f"fresh stream, lab seed {SEED} (not the book's draws): plan as drawn {100 * p_fresh:.2f}%, "
      f"{(p_fresh - res['plan as drawn']['p']) / res['plan as drawn']['se']:+.1f} standard errors from the book's")

fig, ax = plt.subplots(figsize=(7.6, 3.6))
qs = np.arange(QUARTERS + 1)
for i in range(30):
    ax.plot(qs, L0[i], color="#999999", lw=0.5, alpha=0.6)
lo, hi = np.percentile(L0, [10, 90], axis=0)
ax.fill_between(qs, lo, hi, color="#5E35B1", alpha=0.15, lw=0, label="80 percent of paths")
ax.plot(qs, L0.mean(axis=0), color="#1F4E79", lw=1.2, ls="--", label="mean path")
ax.plot(qs, pl, color="#5E35B1", lw=2, label="plan (Chapter 1's digital path)")
ax.axhline(FLOOR, color="#B71C1C", lw=1, ls=":", label="board floor $350m")
ax.set(xlabel="quarters from today (quarter 7 = month 21)", ylabel="liquidity ($ million)")
ax.set_title("Digital liquidity: one path in four breaches the floor (seed 8, the book's stream)", fontsize=10)
ax.tick_params(labelsize=7); ax.xaxis.label.set_size(8); ax.yaxis.label.set_size(8)
ax.legend(frameon=False, fontsize=7, loc="upper center", bbox_to_anchor=(0.5, -0.2), ncol=4)
plt.tight_layout(); plt.show()
plan by quarter ($ million): [620 574 540 516 499 488 483 482 484 488 494 502 510]
trough $482 million in quarter 7 (month 21); $132 million above the floor; the program draws $138 million
surprises: long-run sd 62.5, so the trough's headroom is 2.1 sd; closures: P(at least one in three years) = 0.259

fan at quarter 7 (month 21): 80 percent of paths between $357 and $556 million, a band $199 million wide; mean path's low $460 million
the book's draws (seed 8):
                         plan trough  breach odds   s.e.   worst 5% of troughs: average, below the floor
plan as drawn                    482       24.62%   0.14         166.3         183.7
standby line ($100m)             482       12.37%   0.10         285.6          64.4
phased build                     531       13.07%   0.11         213.4         136.6
line and phased build            531        3.00%   0.05         332.5          17.5

a bad closure (90th percentile) is $187 million; the program's draw is $138 million; together $325 million against $270 million above the floor
fresh stream, lab seed 26101 (not the book's draws): plan as drawn 24.52%, -0.7 standard errors from the book's
Digital liquidity: one path in four breaches the floor (seed 8, the book's stream)

Around month 21 the band that holds 80 percent of the outcomes is about $200 million wide, against $132 million of headroom, so the program should not be financed from its cash cushion alone: the draw and a bad closure together claim more than the $270 million above the floor (Section 1.5.4), and only the standby line and the phased build together bring the odds within the board's 5 percent appetite (Section 1.5.3; Table 1.5). With the book's stream the odds are exactly the printed 24.6 percent, and 3.0 percent with both levers, whose worst 5 percent of troughs average $18 million below the floor (Section 1.5.4). A fresh stream drawn with the lab's seed differs from them only by sampling error.

Panel 5 — Build your own score (Worked Example 1.1, Steps 3, 4 and 6; Proposition 1.2; Online Appendix 1.B.1–1.B.2)

AXIOM Lab 1.1, step 5. With the CFO's weights, $25 million more from the sale — 4.05 liquidity points — lifts the restructuring to the digital option's 47.1 (Step 3), yet the two Year-5 companies are very different (Step 4): digital Meridian has the modern platform, restructured Meridian the cash and the lower risk, and each has different moves open to it next (Step 6). A weighted score gives the same reading to every pair of states whose difference d\mathbf{d} has w⊤d=0\mathbf{w}^\top\mathbf{d} = 0, a hyperplane of dimension n−1n - 1 (Result 1.B.2), and moving 1.6 points of weight from technology to liquidity ties the two options as they stand (Table 1.4). Try your own weights below: every weighting ties some clearly different Meridians, and so does any score that moves smoothly with the readings (Proposition 1.2; Result 1.B.1).

Python Code
d5, r5 = Y5["Digital"], Y5["Restructuring"]
gap = float(CFO @ d5 - CFO @ r5)
delta = gap / CFO[0]
matched = r5 + np.array([delta, 0, 0, 0])
print(f"CFO's weights: digital {CFO @ d5:.3f}, restructuring {CFO @ r5:.3f}; {delta:.2f} more liquidity points "
      f"(${delta * USD_PER_POINT:.0f} million) tie them")
print("  digital, Year 5         ", np.round(d5, 1), f"score {CFO @ d5:.2f}")
print("  restructuring + $25m    ", np.round(matched, 1), f"score {CFO @ matched:.2f}")
print(f"  same score; the platform differs by {d5[1] - matched[1]:.1f} points, cash by {matched[0] - d5[0]:.1f}, "
      f"strategic risk by {d5[3] - matched[3]:.1f}")
print(f"  the tie set is a hyperplane of dimension {4 - np.linalg.matrix_rank(CFO[None, :])} in the four moving readings "
      f"({8 - np.linalg.matrix_rank(np.r_[CFO, 0, 0, 0, 0][None, :])} in all eight)")

diff = (d5 - r5) * np.sign(CFO)                 # digital's advantage reading by reading (risk reversed)
rate = {name: 0.01 * (diff[1] - diff[j]) for j, name in ((0, "liquidity"), (2, "efficiency"), (3, "strategic risk"))}
tie = {name: gap / r for name, r in rate.items()}
print("\nweight points moved from technology that tie digital and restructuring: "
      + ", ".join(f"to {n} {v:.1f}" for n, v in tie.items()))

WEIGHTS = {"CFO": CFO, "liquidity first": np.array([0.40, 0.20, 0.20, -0.20]),
           "technology first": np.array([0.20, 0.40, 0.20, -0.20]), "risk first": np.array([0.20, 0.20, 0.20, -0.40])}
print("\nyour weightings: Year-5 scores, and a tie between two clearly different Meridians")
print(f"  {'weights on (x1, x4, x5, x7)':40s}" + "".join(f"{o:>15s}" for o in OPTIONS) + "   runner-up ties with")
for name, w in WEIGHTS.items():
    sc = {o: float(w @ Y5[o]) for o in OPTIONS}
    lead, second = sorted(OPTIONS, key=lambda o: -sc[o])[:2]
    dl = (sc[lead] - sc[second]) / w[0]
    twin = Y5[second] + np.array([dl, 0, 0, 0])
    label = name + " (" + ", ".join(f"{v:g}" for v in w) + ")"
    print(f"  {label:40s}" + "".join(f"{sc[o]:15.2f}" for o in OPTIONS)
          + f"   {dl:+.2f} liquidity points: {w @ twin:.2f}")

# A smooth nonlinear score ties too: Proposition 1.2's proof, run on two routes from one state to another
def smooth(x):                                   # geometric mean of the three goods, less half the risk
    return np.cbrt(x[..., 0] * x[..., 1] * x[..., 2]) - 0.5 * x[..., 3]
a, b = d5, r5
c = 0.5 * (smooth(a) + smooth(b))
u = (b - a) / np.linalg.norm(b - a)
e = np.array([0.0, 0.0, 1.0, 0.0]); e -= (e @ u) * u; e /= np.linalg.norm(e)
segment = lambda s: a + s * (b - a)
arc = lambda s: a + s * (b - a) + 12.0 * np.sin(np.pi * s) * e
s1 = brentq(lambda s: smooth(segment(s)) - c, 0, 1)
s2 = brentq(lambda s: smooth(arc(s)) - c, 0, 1)
p1, p2 = segment(s1), arc(s2)
print(f"\nsmooth score: digital {smooth(a):.2f}, restructuring {smooth(b):.2f}; a reading of {c:.2f} is taken on both routes:")
print("  on the straight route", np.round(p1, 2), f"score {smooth(p1):.2f}")
print("  on the bulging route ", np.round(p2, 2), f"score {smooth(p2):.2f}")
print(f"  two different states ({np.linalg.norm(p1 - p2):.1f} index points apart), one score")

fig, (ax, bx) = plt.subplots(1, 2, figsize=(7.6, 3.6))
mv = np.linspace(0, 4, 81)
for (name, r), ls in zip(rate.items(), ("-", "--", ":")):
    ax.plot(mv, gap - mv * r, color="#1F4E79", lw=1.6, ls=ls, label=f"to {name}: tie at {tie[name]:.1f}")
ax.axhline(0, color="#616161", lw=0.8)
ax.set(xlabel="weight points moved from technology", ylabel="digital's lead in score (points)")
ax.legend(frameon=False, fontsize=7)
ss = np.linspace(0, 1, 201)
bx.plot(ss, [smooth(segment(s)) for s in ss], color="#5E35B1", lw=1.6, label="straight route")
bx.plot(ss, [smooth(arc(s)) for s in ss], color="#E65100", lw=1.6, ls="--", label="bulging route")
bx.axhline(c, color="#616161", lw=0.8, ls=":")
bx.plot([s1, s2], [c, c], "o", ms=4, color="#B71C1C")
bx.set(xlabel="from digital (0) to restructuring (1)", ylabel="smooth score (points)")
bx.legend(frameon=False, fontsize=7)
for z in (ax, bx):
    z.tick_params(labelsize=7); z.xaxis.label.set_size(8); z.yaxis.label.set_size(8)
fig.suptitle("Weights decide, and every smooth score ties (seed 26101)", fontsize=10)
plt.tight_layout(); plt.show()
CFO's weights: digital 47.078, restructuring 46.065; 4.05 more liquidity points ($25 million) tie them
  digital, Year 5          [94.3 75.6 73.6 55.2] score 47.08
  restructuring + $25m     [125.2  38.9  73.7  49.4] score 47.08
  same score; the platform differs by 36.8 points, cash by 30.9, strategic risk by 5.8
  the tie set is a hyperplane of dimension 3 in the four moving readings (7 in all eight)

weight points moved from technology that tie digital and restructuring: to liquidity 1.6, to efficiency 2.7, to strategic risk 2.4

your weightings: Year-5 scores, and a tie between two clearly different Meridians
  weights on (x1, x4, x5, x7)                     Digital  Restructuring     Turnaround   runner-up ties with
  CFO (0.25, 0.25, 0.25, -0.25)                     47.08          46.07          38.40   +4.05 liquidity points: 47.08
  liquidity first (0.4, 0.2, 0.2, -0.2)             56.52          61.07          51.79   +11.38 liquidity points: 61.07
  technology first (0.2, 0.4, 0.2, -0.2)            52.79          44.62          37.90   +40.83 liquidity points: 52.79
  risk first (0.2, 0.2, 0.2, -0.4)                  26.62          26.97          17.45   +1.78 liquidity points: 26.97

smooth score: digital 53.06, restructuring 45.56; a reading of 49.31 is taken on both routes:
  on the straight route [112.32  50.91  73.66  51.3 ] score 49.31
  on the bulging route  [116.98  44.52  79.24  50.29] score 49.31
  two different states (9.7 index points apart), one score
Weights decide, and every smooth score ties (seed 26101)

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

Each checkpoint is a number printed in Chapter 1 (Worked Example 1.1 and Table 1.9, Figure 1.3, Sections 1.5.3–1.5.4, Tables 1.4–1.5) or in Online Appendix 1.B. The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet. The three simulated figures are drawn, as in the book, with seed 8.

Python Code
D, R, U = Y5["Digital"], Y5["Restructuring"], Y5["Turnaround"]
both = res["line and phased build"]
checks = [
    ("today's score (workbook)", today, 37.0, 0.05),
    ("Table 1.9: digital liquidity (workbook)", D[0], 94.3, 0.05),
    ("Table 1.9: digital technology (workbook)", D[1], 75.6, 0.05),
    ("Table 1.9: digital efficiency (workbook)", D[2], 73.6, 0.05),
    ("Table 1.9: digital strategic risk (workbook)", D[3], 55.2, 0.05),
    ("Table 1.9: restructuring liquidity (workbook)", R[0], 121.1, 0.05),
    ("Table 1.9: restructuring technology (workbook)", R[1], 38.9, 0.05),
    ("Table 1.9: restructuring efficiency (workbook)", R[2], 73.7, 0.05),
    ("Table 1.9: restructuring strategic risk (workbook)", R[3], 49.4, 0.05),
    ("Table 1.9: turnaround liquidity (workbook)", U[0], 105.4, 0.05),
    ("Table 1.9: turnaround technology (workbook)", U[1], 35.9, 0.05),
    ("Table 1.9: turnaround efficiency (workbook)", U[2], 78.6, 0.05),
    ("Table 1.9: turnaround strategic risk (workbook)", U[3], 66.3, 0.05),
    ("Year-5 score, digital (workbook)", S["Digital"][-1], 47.078, 5e-4),
    ("Year-5 score, restructuring (workbook)", S["Restructuring"][-1], 46.065, 5e-4),
    ("Year-5 score, turnaround (workbook)", S["Turnaround"][-1], 38.4, 0.05),
    ("digital liquidity low point (workbook)", low.fun, 77.73, 5e-3),
    ("month of the low point (workbook)", MONTH[i_low], 21, 0),
    ("time of the low point, years (workbook)", low.x, 1.71, 5e-3),
    ("low point below today, points (workbook)", drop, 22.3, 0.05),
    ("low point below today, $ million (workbook)", drop * USD_PER_POINT, 138, 0.5),
    ("sale-date jump, $ million (workbook)", jump * USD_PER_POINT, 112, 0.5),
    ("liquidity points that tie the scores (workbook)", delta, 4.05, 5e-3),
    ("the tying sale proceeds, $ million (workbook)", delta * USD_PER_POINT, 25, 0.5),
    ("score-matched restructured liquidity (workbook)", matched[0], 125.2, 0.05),
    ("weight points to liquidity that tie (workbook)", tie["liquidity"], 1.6, 0.05),
    ("digital score back to today's, month (workbook)", back, 29, 0),
    ("annual reviews with digital last (workbook)", len(last_years), 2, 0),
    ("risk ceiling margin at the peak (workbook)", risk_gap, 1.4, 0.05),
    ("digital plan trough, $ million (workbook)", pl[k_low], 482, 0.5),
    ("trough above the floor, $ million (workbook)", pl[k_low] - FLOOR, 132, 0.5),
    ("buffer for a bad closure, $ million (workbook)", buffer, 187, 0.5),
    ("draw plus buffer, $ million (workbook)", draw + buffer, 325, 0.5),
    ("breach odds, plan as drawn (%, seed 8)", 100 * res["plan as drawn"]["p"], 24.6, 0.05),
    ("breach odds, both levers (%, seed 8)", 100 * both["p"], 3.0, 0.05),
    ("worst 5% of troughs below the floor, both levers", FLOOR - both["es"], 18, 0.5),
]
ok = 0
for name, got, want, tol in checks:
    status = "PASS" if abs(got - want) <= tol else "FAIL"; ok += status == "PASS"
    print(f"{name:52s} {got:10.4f}   book {want:9.4f}   {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")
today's score (workbook)                                37.0000   book   37.0000   PASS
Table 1.9: digital liquidity (workbook)                 94.2956   book   94.3000   PASS
Table 1.9: digital technology (workbook)                75.6347   book   75.6000   PASS
Table 1.9: digital efficiency (workbook)                73.5983   book   73.6000   PASS
Table 1.9: digital strategic risk (workbook)            55.2177   book   55.2000   PASS
Table 1.9: restructuring liquidity (workbook)          121.1075   book  121.1000   PASS
Table 1.9: restructuring technology (workbook)          38.8595   book   38.9000   PASS
Table 1.9: restructuring efficiency (workbook)          73.6838   book   73.7000   PASS
Table 1.9: restructuring strategic risk (workbook)      49.3902   book   49.4000   PASS
Table 1.9: turnaround liquidity (workbook)             105.3676   book  105.4000   PASS
Table 1.9: turnaround technology (workbook)             35.9430   book   35.9000   PASS
Table 1.9: turnaround efficiency (workbook)             78.6017   book   78.6000   PASS
Table 1.9: turnaround strategic risk (workbook)         66.3306   book   66.3000   PASS
Year-5 score, digital (workbook)                        47.0777   book   47.0780   PASS
Year-5 score, restructuring (workbook)                  46.0652   book   46.0650   PASS
Year-5 score, turnaround (workbook)                     38.3954   book   38.4000   PASS
digital liquidity low point (workbook)                  77.7287   book   77.7300   PASS
month of the low point (workbook)                       21.0000   book   21.0000   PASS
time of the low point, years (workbook)                  1.7145   book    1.7100   PASS
low point below today, points (workbook)                22.2713   book   22.3000   PASS
low point below today, $ million (workbook)            138.0821   book  138.0000   PASS
sale-date jump, $ million (workbook)                   111.6000   book  112.0000   PASS
liquidity points that tie the scores (workbook)          4.0502   book    4.0500   PASS
the tying sale proceeds, $ million (workbook)           25.1115   book   25.0000   PASS
score-matched restructured liquidity (workbook)        125.1577   book  125.2000   PASS
weight points to liquidity that tie (workbook)           1.5924   book    1.6000   PASS
digital score back to today's, month (workbook)         29.0000   book   29.0000   PASS
annual reviews with digital last (workbook)              2.0000   book    2.0000   PASS
risk ceiling margin at the peak (workbook)               1.4475   book    1.4000   PASS
digital plan trough, $ million (workbook)              481.9504   book  482.0000   PASS
trough above the floor, $ million (workbook)           131.9504   book  132.0000   PASS
buffer for a bad closure, $ million (workbook)         186.8670   book  187.0000   PASS
draw plus buffer, $ million (workbook)                 324.9166   book  325.0000   PASS
breach odds, plan as drawn (%, seed 8)                  24.6220   book   24.6000   PASS
breach odds, both levers (%, seed 8)                     3.0030   book    3.0000   PASS
worst 5% of troughs below the floor, both levers        17.5321   book   18.0000   PASS

36 of 36 checkpoints PASS

Next. Chapter 2 asks what exactly is being transformed: the company as an open system, whose boundary is itself a declaration. Chapters 5–8 then let all eight readings move and interact. AXIOM-01 runs the same model interactively (Lab 1.1); 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