Skip to content

Vol. I, Ch. 3

DCT Laboratory — Volume I, Chapter 3

Mathematical Foundations

This laboratory demonstrates

Seed 26103 · Companion to Chapter 3 and AXIOM Lab 1.3 (module AXIOM-03) · Mirrored in DCT_V1_Ch03_Lab.xlsx

This laboratory reproduces Worked Example 3.1, Does the Order of Initiatives Matter?, with the book's declarations, and works the five steps of AXIOM Lab 1.3, Measuring Meridian: read the vector, declare the scaling, compare distance measures, sequence the initiatives, watch a company run down. Every Meridian number below is the book's or follows from its declarations (Tables 3.1 and 3.4, Figure 3.3, Section 3.4, Appendix 3.A, Online Appendix 3.B, and the later sections that reuse Chapter 3's scaling and three-reading company: 5.8, 6.5–6.6, 7.4–7.6); the final cell checks the printed ones. The book declares no peer companies for the lab, so the two used here are drawn with the lab's seed and labelled as such. Money is in $ million; Table 3.1 declares liquidity in $ billion.

The declarations (Table 3.1; Worked Example 3.1, The situation; Section 3.4)

Meridian's state is the eight readings of Table 3.1, each with its unit: the canonical starting state for both volumes. The readings mix three families of unit (currency, ratios and bounded indices), so whenever the book computes a distance for Meridian it first applies the declared scaling W ⁣M=diag⁡(1/0.62, 1/3.4, 1/100, 1/100, 1/100, 1/0.083, 1/100, 1/0.19)\mathbf{W}_{\!M} = \operatorname{diag}(1/0.62,\ 1/3.4,\ 1/100,\ 1/100,\ 1/100,\ 1/0.083,\ 1/100,\ 1/0.19): unbounded readings are divided by today's value and bounded indices by their range.

Worked Example 3.1 follows three readings: liquidity ($620 million), the technology platform (index 41) and workforce capability (index 58). The sale of part of Industrial Systems brings in $112 million net, but the divested unit takes 10 percent of the technology position, and workforce capability falls by 5 points unless the contract keeps the shared engineering team, at a cost of $20 million in lower proceeds. The digital program is Worked Example 1.1's platform build (Table 1.9), computed here with the Chapter 1 model: over five years cash first falls, to $138 million below its starting level around month 21, and ends $35 million down, while the platform rises by 34.6 points. Its effects are changes to whatever state it starts from, and it can be carried out only if workforce capability is at least 55, which is its domain.

Section 3.4's three-reading company (Equation 3.2) has workforce capability, technology platform and operational efficiency, all indices, and an annual capability investment uku_k.

The two peer companies of the lab's first question are not declared in the book. This notebook draws them with the lab's seed 26103: each reading departs from Meridian's by a normal draw whose standard deviation is a tenth of the reading's declared scale ($62 million of liquidity, 0.34 turns of leverage, 10 index points, 0.83 percentage points of ROIC, 1.9 percentage points of market share), rounded as Table 3.1 rounds.

Python Code
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26103

# Table 3.1: Meridian's state today, declared with units; W_M divides each reading by its declared scale
READINGS = [  # symbol, reading, unit, today, family of unit, declared scale
    ("x1", "liquidity", "US$ billion", 0.62, "currency", 0.62),
    ("x2", "net leverage", "net debt / EBITDA", 3.4, "ratio", 3.4),
    ("x3", "workforce capability", "index, 0-100", 58, "index", 100),
    ("x4", "technology platform", "index, 0-100", 41, "index", 100),
    ("x5", "operational efficiency", "index, 0-100", 71, "index", 100),
    ("x6", "return on invested capital", "ratio", 0.083, "ratio", 0.083),
    ("x7", "strategic risk (lower is better)", "index, 0-100", 64, "index", 100),
    ("x8", "market share", "ratio", 0.19, "ratio", 0.19),
]
NAMES = [r[1] for r in READINGS]
FAMILY = np.array([r[4] for r in READINGS])
X0 = np.array([r[3] for r in READINGS], float)
SCALE = np.array([r[5] for r in READINGS], float)    # unbounded readings: today's value; bounded indices: their range
WM = 1 / SCALE                                         # the diagonal of the declared scaling W_M

# Worked Example 3.1 (money in $ million): (liquidity, technology platform, workforce capability)
TODAY = (620.0, 41.0, 58.0)
SALE, TECH_SHARE, W_LOSS, KEEP_COST = 112.0, 0.10, 5.0, 20.0   # net proceeds; the unit's share of technology;
                                                               # points lost unless the team is kept; cost of keeping it
W_MIN = 55.0                                                  # the digital program's domain: workforce >= 55

# The digital program is Worked Example 1.1's platform build: the Chapter 1 model (Eq. 1.B.1, Table 1.B.1's digital
# row), liquidity indexed to today = 100 = $620 million. Its five-year changes add to the state it starts from.
from scipy.optimize import minimize_scalar
def chapter1(key, t):
    x0, (target, k, depth, tau) = {"L": (100.0, (112, 0.35, -28, 2.0)), "T": (41.0, (78, 0.55, 0, 1.0))}[key]
    return target + (x0 - target) * np.exp(-k * t) + depth * (t / tau) * np.exp(1 - t / tau)
LOW = minimize_scalar(lambda t: chapter1("L", t), bounds=(0, 5), method="bounded", options={"xatol": 1e-10})
BUILD_DIP = 6.2 * (100.0 - LOW.fun)                            # its low point below the start: $138.08 million
BUILD_LOW_MONTH = 12 * LOW.x                                   # month 20.6, "around month 21"
BUILD_L = 6.2 * (chapter1("L", 5.0) - 100.0)                   # -$35.37 million by Year 5
BUILD_T = chapter1("T", 5.0) - 41.0                            # +34.63 platform points

def restructure(x, keep=False):
    # the sale of part of Industrial Systems; keep=True: the contract keeps the shared engineering team
    if x is None:
        return None
    L, T, W = x
    return (L + SALE - (KEEP_COST if keep else 0.0), (1 - TECH_SHARE) * T, W if keep else W - W_LOSS)

def digital(x):
    # the platform build for Digital Solutions: an operator with a domain, workforce capability >= 55
    if x is None or x[2] < W_MIN:
        return None                                            # outside the domain: the step cannot start
    L, T, W = x
    return (L + BUILD_L, T + BUILD_T, W)

# Section 3.4, Equation 3.2: capability, technology, efficiency (indices); annual capability investment u
A3 = np.array([[0.90, 0.05, 0.00],
               [0.10, 0.85, 0.00],
               [0.05, 0.10, 0.80]])
B3 = np.array([0.6, 0.3, 0.0])
Y0, U0 = np.array([50.0, 40.0, 60.0]), 10.0

# The lab's two peer companies: not declared in the book, drawn here with the lab's seed
DIGITS = [2, 1, 0, 0, 0, 3, 0, 2]                        # Table 3.1's rounding of each reading
rng = np.random.default_rng(SEED)
def draw_peers(n):
    raw = X0 + rng.normal(0.0, 0.10, (n, len(X0))) * SCALE
    return np.column_stack([np.round(raw[:, i], d) for i, d in enumerate(DIGITS)])
PEER_A, PEER_B = draw_peers(2)

count = {f: int((FAMILY == f).sum()) for f in ("currency", "ratio", "index")}
print(f"Meridian's state: {len(X0)} readings, {count['currency']} in currency, {count['ratio']} ratios, {count['index']} bounded indices")
print("the declared scaling W_M divides them by:", ", ".join(f"{s:g}" for s in SCALE))
print(f"Worked Example 3.1 today: liquidity ${TODAY[0]:.0f} million, technology {TODAY[1]:.0f}, workforce {TODAY[2]:.0f};"
      f" the digital program's domain: workforce >= {W_MIN:.0f}")
print(f"three-reading company: x0 = ({', '.join(f'{v:.0f}' for v in Y0)}), u0 = {U0:.0f}")
print(f"two peer companies drawn with the lab's seed {SEED} (the book declares none)")
Meridian's state: 8 readings, 1 in currency, 3 ratios, 4 bounded indices
the declared scaling W_M divides them by: 0.62, 3.4, 100, 100, 100, 0.083, 100, 0.19
Worked Example 3.1 today: liquidity $620 million, technology 41, workforce 58; the digital program's domain: workforce >= 55
three-reading company: x0 = (50, 40, 60), u0 = 10
two peer companies drawn with the lab's seed 26103 (the book declares none)

Panel 1 — Read the vector (Table 3.1; Proposition 3.2)

AXIOM Lab 1.3, step 1. Read Meridian's eight readings and their units, then switch the liquidity unit from billions to millions and watch the raw distances to the two peer companies. A raw distance is the straight-line distance between the readings as recorded. Proposition 3.2: changing units loses no information, but a comparison of raw readings across attributes, or a total without declared weights, can be reversed by a legitimate change of units, and so says nothing about the company. LOS Guidance 3.1 gives the example: "strategic risk, at 64, exceeds leverage, at 3.4" means nothing, because rescaling either reading reverses it.

Python Code
print("Table 3.1: Meridian's state today, declared with units")
print(f"  {'':3s} {'reading':33s} {'unit':18s} {'today':>6s}   family of unit")
for sym, name, unit, today, fam, _ in READINGS:
    print(f"  {sym:3s} {name:33s} {unit:18s} {today:6g}   {fam}")
span = X0.max() / X0.min()
print(f"the raw readings run from {X0.min():g} ({NAMES[X0.argmin()]}) to {X0.max():g} ({NAMES[X0.argmax()]}):"
      f" a factor of {span:.0f}, {np.log10(span):.2f} orders of magnitude")

risk, lev = X0[6], X0[1]
print(f"\nProposition 3.2: strategic risk {risk:g} > net leverage {lev:g}? {risk > lev}."
      f"  With leverage in percent ({100 * lev:g}): {risk > 100 * lev}")
MM = np.ones(8); MM[0] = 1000.0                        # liquidity recorded in $ million instead of $ billion
print(f"an undeclared total of the raw readings: {X0.sum():.3f} with liquidity in $ billion, {(X0 * MM).sum():.3f} in $ million")

def raw_distance(x, y, unit=np.ones(8)):
    return float(np.linalg.norm((np.asarray(y) - np.asarray(x)) * unit))

def shares(x, y, unit=np.ones(8)):
    # each reading's share of the squared distance from x to y
    d2 = ((np.asarray(y) - np.asarray(x)) * unit) ** 2
    return d2 / d2.sum()

print(f"\n  {'reading':33s} {'Meridian':>9s} {'Peer A':>8s} {'Peer B':>8s}   (peers drawn with seed {SEED})")
for i, name in enumerate(NAMES):
    print(f"  {name:33s} {X0[i]:9g} {PEER_A[i]:8g} {PEER_B[i]:8g}")
UNITS = {"liquidity in $ billion": np.ones(8), "liquidity in $ million": MM}
raw, closer = {}, {}
for label, unit in UNITS.items():
    raw[label] = (raw_distance(X0, PEER_A, unit), raw_distance(X0, PEER_B, unit))
    closer[label] = "A" if raw[label][0] < raw[label][1] else "B"
    sA = shares(X0, PEER_A, unit)
    print(f"raw distance, {label}: Peer A {raw[label][0]:8.3f}, Peer B {raw[label][1]:8.3f} -> closer: Peer {closer[label]};"
          f" Peer A's squared distance is {100 * sA[FAMILY == 'index'].sum():.0f}% indices, {100 * sA[0]:.0f}% liquidity")
same = closer["liquidity in $ billion"] == closer["liquidity in $ million"]
print("does the closer peer change? " + ("no, but for two different reasons: in billions the indices decide, in millions"
      " liquidity does, and Peer A happens to be closer on both" if same else "yes"))

PCT = np.ones(8); PCT[1] = 100.0                         # net leverage recorded in percent
dA, dB = raw_distance(X0, PEER_A, PCT), raw_distance(X0, PEER_B, PCT)
print(f"any reading on which Peer B is closer can reverse it: with leverage in percent, Peer A {dA:.3f}, Peer B {dB:.3f}"
      f" -> closer: Peer {'A' if dA < dB else 'B'}")

N = 10_000                                               # 10,000 more pairs, drawn the same way, the same stream
pairs = draw_peers(2 * N).reshape(N, 2, 8)
d_bn = np.linalg.norm(pairs - X0, axis=2)
d_mm = np.linalg.norm((pairs - X0) * MM, axis=2)
flip = float(np.mean(d_bn.argmin(1) != d_mm.argmin(1)))
print(f"over {N:,} more pairs drawn the same way (seed {SEED}), switching liquidity to millions changes the closer peer"
      f" for {100 * flip:.1f}%")
Table 3.1: Meridian's state today, declared with units
      reading                           unit                today   family of unit
  x1  liquidity                         US$ billion          0.62   currency
  x2  net leverage                      net debt / EBITDA     3.4   ratio
  x3  workforce capability              index, 0-100           58   index
  x4  technology platform               index, 0-100           41   index
  x5  operational efficiency            index, 0-100           71   index
  x6  return on invested capital        ratio               0.083   ratio
  x7  strategic risk (lower is better)  index, 0-100           64   index
  x8  market share                      ratio                0.19   ratio
the raw readings run from 0.083 (return on invested capital) to 71 (operational efficiency): a factor of 855, 2.93 orders of magnitude

Proposition 3.2: strategic risk 64 > net leverage 3.4? True.  With leverage in percent (340): False
an undeclared total of the raw readings: 238.293 with liquidity in $ billion, 857.673 in $ million

  reading                            Meridian   Peer A   Peer B   (peers drawn with seed 26103)
  liquidity                              0.62     0.65     0.47
  net leverage                            3.4      3.9      3.3
  workforce capability                     58       59       54
  technology platform                      41       37       47
  operational efficiency                   71       74       58
  return on invested capital            0.083    0.072    0.085
  strategic risk (lower is better)         64       68       79
  market share                           0.19      0.2     0.17
raw distance, liquidity in $ billion: Peer A    6.500, Peer B   21.119 -> closer: Peer A; Peer A's squared distance is 99% indices, 0% liquidity
raw distance, liquidity in $ million: Peer A   30.696, Peer B  151.479 -> closer: Peer A; Peer A's squared distance is 4% indices, 96% liquidity
does the closer peer change? no, but for two different reasons: in billions the indices decide, in millions liquidity does, and Peer A happens to be closer on both
any reading on which Peer B is closer can reverse it: with leverage in percent, Peer A 50.418, Peer B 23.367 -> closer: Peer B
over 10,000 more pairs drawn the same way (seed 26103), switching liquidity to millions changes the closer peer for 43.3%

Panel 2 — Declare the scaling (Figure 3.3; Proposition 3.3)

AXIOM Lab 1.3, step 2. Switch on the declared scaling and compare again. After W ⁣M\mathbf{W}_{\!M} every reading is unit-free and of order one (Figure 3.3): Meridian's scaled state is (1.00, 1.00, 0.58, 0.41, 0.71, 1.00, 0.64, 1.00). Proposition 3.3: a weighted distance gives the same answer after a change of units only if its weights change in the opposite direction. The declared rule does this by itself, because it divides by today's value in whatever unit the reading is recorded: with liquidity in millions, today's value is 620 and the weight 1/620. This is the comparison to defend to the board. It does not move when someone changes a unit, no reading dominates because of its unit, and what it does depend on, the weights, is declared.

Python Code
SX0 = X0 * WM
print("Figure 3.3, right: Meridian's scaled readings W_M x0 =", ", ".join(f"{v:.2f}" for v in SX0))
print(f"readings at 1.00 after scaling: {int(np.isclose(SX0, 1.0).sum())} (today's value is their declared scale)")

def declared_weights(today):
    # W_M's rule, in whatever units the readings are recorded: unbounded readings / today's value, indices / range
    return 1 / np.where(FAMILY == "index", 100.0, today)

scaled = {}
for label, unit in UNITS.items():
    w = declared_weights(X0 * unit)
    scaled[label] = tuple(float(np.linalg.norm(w * (P - X0) * unit)) for P in (PEER_A, PEER_B))
    print(f"scaled distance, {label}: weight on liquidity 1/{1 / w[0]:g}; Peer A {scaled[label][0]:.4f},"
          f" Peer B {scaled[label][1]:.4f}")
gap_units = max(abs(a - b) for a, b in zip(*scaled.values()))
print(f"gap between the two units: {gap_units:.1e} (Proposition 3.3: the weight moved the opposite way)")
wrong = float(np.linalg.norm(WM * (PEER_A - X0) * MM))
print(f"liquidity in millions with its weight left at 1/0.62: Peer A at {wrong:.3f} instead of {scaled['liquidity in $ billion'][0]:.4f}")

sc = {"A": shares(SX0, PEER_A * WM), "B": shares(SX0, PEER_B * WM)}
print(f"\n  share of the squared scaled distance {'Peer A':>8s} {'Peer B':>8s}")
for i, name in enumerate(NAMES):
    print(f"  {name:36s} {100 * sc['A'][i]:7.1f}% {100 * sc['B'][i]:7.1f}%")
dS = scaled["liquidity in $ billion"]
print(f"declared scaling: Peer A {dS[0]:.3f}, Peer B {dS[1]:.3f} -> closer: Peer {'A' if dS[0] < dS[1] else 'B'};"
      f" no reading carries more than {100 * max(sc['A'].max(), sc['B'].max()):.0f}% of either distance")

FAMS = [("index", "the four indices", "#1F4E79"), ("ratio", "the three ratios", "#999999"),
        ("currency", "liquidity (currency)", "#E65100")]
bars = []
for peer, P in (("Peer A", PEER_A), ("Peer B", PEER_B)):
    bars += [(f"{peer}: raw, liquidity in $ billion", shares(X0, P), raw_distance(X0, P), "{:.2f}"),
             (f"{peer}: raw, liquidity in $ million", shares(X0, P, MM), raw_distance(X0, P, MM), "{:.1f}"),
             (f"{peer}: declared scaling", shares(SX0, P * WM), float(np.linalg.norm((P - X0) * WM)), "{:.3f}")]
ys = [5.5, 4.5, 3.5, 2.0, 1.0, 0.0]
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for y, (label, s, d, f) in zip(ys, bars):
    left = 0.0
    for fam, flabel, col in FAMS:
        v = 100 * s[FAMILY == fam].sum()
        ax.barh(y, v, left=left, color=col, height=0.72, label=flabel if y == ys[0] else None)
        left += v
    ax.text(101.5, y, "distance " + f.format(d), va="center", ha="left", fontsize=8, color="#333333")
ax.set_yticks(ys)
ax.set_yticklabels([b[0] for b in bars], fontsize=8)
ax.set(xlim=(0, 122), ylim=(-0.6, 7.0), xlabel="share of the squared distance (%)",
       title="Units decide which readings drive a raw distance (seed 26103)")
ax.set_xticks([0, 25, 50, 75, 100])
ax.legend(frameon=False, fontsize=8, ncol=3, loc="upper center", bbox_to_anchor=(0.42, 1.02), handlelength=1.2,
          columnspacing=1.6)
plt.tight_layout(); plt.show()
Figure 3.3, right: Meridian's scaled readings W_M x0 = 1.00, 1.00, 0.58, 0.41, 0.71, 1.00, 0.64, 1.00
readings at 1.00 after scaling: 4 (today's value is their declared scale)
scaled distance, liquidity in $ billion: weight on liquidity 1/0.62; Peer A 0.2202, Peer B 0.3401
scaled distance, liquidity in $ million: weight on liquidity 1/620; Peer A 0.2202, Peer B 0.3401
gap between the two units: 0.0e+00 (Proposition 3.3: the weight moved the opposite way)
liquidity in millions with its weight left at 1/0.62: Peer A at 48.388 instead of 0.2202

  share of the squared scaled distance   Peer A   Peer B
  liquidity                                4.8%    50.6%
  net leverage                            44.6%     0.7%
  workforce capability                     0.2%     1.4%
  technology platform                      3.3%     3.1%
  operational efficiency                   1.9%    14.6%
  return on invested capital              36.2%     0.5%
  strategic risk (lower is better)         3.3%    19.5%
  market share                             5.7%     9.6%
declared scaling: Peer A 0.220, Peer B 0.340 -> closer: Peer A; no reading carries more than 51% of either distance
Units decide which readings drive a raw distance (seed 26103)

Panel 3 — Compare distance measures (Definition 3.5; Theorem 3.1; Online Appendix Remark 3.B.1; Section 5.8)

AXIOM Lab 1.3, step 3: the norm gallery. The effort view ∥⋅∥1\lVert\cdot\rVert_1 totals the moves, the bottleneck view ∥⋅∥∞\lVert\cdot\rVert_\infty reports the largest single move, and the Euclidean norm ∥⋅∥2\lVert\cdot\rVert_2 sits between them (Definition 3.5). The changes of state measured here, all in the declared scaling, are Meridian's moves to each option's Year-5 state in the Chapter 1 model (Table 1.9; only liquidity, technology, efficiency and strategic risk move) and to each peer. Section 5.8 measures the Year-5 moves with Chapter 3's scaling: 0.11 for the turnaround, 0.26 for restructuring, 0.36 for digital. The constants that link the views (Online Appendix 3.B, Remark 3.B.1) are ∥x∥∞≤∥x∥1≤n ∥x∥∞,∥x∥2≤∥x∥1≤n ∥x∥2,\lVert\mathbf{x}\rVert_\infty \le \lVert\mathbf{x}\rVert_1 \le n\,\lVert\mathbf{x}\rVert_\infty, \qquad \lVert\mathbf{x}\rVert_2 \le \lVert\mathbf{x}\rVert_1 \le \sqrt{n}\,\lVert\mathbf{x}\rVert_2 , so for Meridian's eight readings the effort and bottleneck views of one change can differ by a factor of up to eight. Theorem 3.1 promises agreement on qualitative questions (which sequences converge, which sets are open, which mappings are continuous, which states are stable), not on the numbers; and a ranking of two distances is a comparison of numbers.

Python Code
NORMS = (("effort", 1), ("Euclidean", 2), ("bottleneck", np.inf))
def views(dx):
    return {nm: float(np.linalg.norm(np.asarray(dx, float), o)) for nm, o in NORMS}

# Table 1.9: the four moving readings in Year 5 (liquidity indexed to today = 100 = $0.62 billion)
TODAY4 = (100.0, 41.0, 71.0, 64.0)
YEAR5 = {"turnaround": (105.4, 35.9, 78.6, 66.3), "restructuring": (121.1, 38.9, 73.7, 49.4),
         "digital": (94.3, 75.6, 73.6, 55.2)}
def year5_state(v):
    x = X0.copy()
    x[0], x[3], x[4], x[6] = X0[0] * v[0] / TODAY4[0], v[1], v[2], v[3]
    return x

moves = {f"{k}, Year 5": (year5_state(v) - X0) * WM for k, v in YEAR5.items()}
moves.update({"Peer A": (PEER_A - X0) * WM, "Peer B": (PEER_B - X0) * WM})
V = {name: views(dx) for name, dx in moves.items()}
print(f"  {'scaled change of state':22s} {'effort':>7s} {'Euclidean':>10s} {'bottleneck':>11s}   effort/bottleneck"
      f"  Euclidean/bottleneck  effort/Euclidean")
for name, v in V.items():
    print(f"  {name:22s} {v['effort']:7.3f} {v['Euclidean']:10.3f} {v['bottleneck']:11.3f}   {v['effort'] / v['bottleneck']:17.2f}"
          f"  {v['Euclidean'] / v['bottleneck']:20.2f}  {v['effort'] / v['Euclidean']:16.2f}")

n = len(X0)
e1, ones = np.eye(n)[0], np.ones(n)
print(f"\nconstants for n = {n} readings: effort/bottleneck in [1, {n}]; Euclidean/bottleneck and effort/Euclidean in [1, {np.sqrt(n):.2f}]")
print(f"attained: one reading moving (e1) gives {views(e1)['effort'] / views(e1)['bottleneck']:.0f};"
      f" all eight moving equally give {views(ones)['effort'] / views(ones)['bottleneck']:.0f}"
      f" and {views(ones)['effort'] / views(ones)['Euclidean']:.2f}")
for nm, _ in NORMS:
    ranking = sorted(YEAR5, key=lambda k: V[f"{k}, Year 5"][nm])
    print(f"the {nm} view ranks the Year-5 moves {' < '.join(ranking)}; closer peer: Peer {'A' if V['Peer A'][nm] < V['Peer B'][nm] else 'B'}")

dmv = (pairs - X0) * WM                                   # the 10,000 pairs of Panel 1, in the declared scaling
eff, bot = np.abs(dmv).sum(2), np.abs(dmv).max(2)
disagree = float(np.mean(eff.argmin(1) != bot.argmin(1)))
ratio = eff / bot
print(f"over the {N:,} pairs: effort/bottleneck from {ratio.min():.2f} to {ratio.max():.2f} (median {np.median(ratio):.2f});"
      f" the effort and bottleneck views name different closer peers for {100 * disagree:.1f}% of pairs")

fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.scatter(bot.ravel(), eff.ravel(), s=3, color="#999999", alpha=0.12, lw=0, label=f"{2 * N:,} more peers drawn with seed {SEED}")
xs = np.array([0.0, 0.6])
ax.plot(xs, xs, color="#616161", lw=1.1, ls="--", label="effort = bottleneck: one reading moves")
ax.plot(xs, n * xs, color="#616161", lw=1.1, ls=":", label=f"effort = {n} x bottleneck: all {n} readings move equally")
box = dict(boxstyle="square,pad=0.15", fc="white", ec="none", alpha=0.85)
for i, k in enumerate(YEAR5):
    v = V[f"{k}, Year 5"]
    ax.plot(v["bottleneck"], v["effort"], "o", color="#E65100", ms=6, zorder=4,
            label="Year-5 moves of the three options (Table 1.9)" if i == 0 else None)
    ax.annotate(k, (v["bottleneck"], v["effort"]), xytext=(v["bottleneck"] + 0.008, v["effort"] - 0.085), fontsize=8,
                color="#E65100", bbox=box, zorder=5)
for i, name in enumerate(("Peer A", "Peer B")):
    v = V[name]
    ax.plot(v["bottleneck"], v["effort"], "s", color="#1F4E79", ms=6, zorder=4, label="the lab's two peers" if i == 0 else None)
    ax.annotate(name, (v["bottleneck"], v["effort"]), xytext=(v["bottleneck"] + 0.01, v["effort"] + 0.03), fontsize=8,
                color="#1F4E79", bbox=box, zorder=5)
ax.set(xlim=(0, 0.5), ylim=(0, 1.6), xlabel="bottleneck view: largest scaled move", ylabel="effort view: sum of scaled moves",
       title="Effort and bottleneck views stay within a factor of eight (seed 26103)")
leg = ax.legend(frameon=False, fontsize=8, loc="upper right")
for h in leg.legend_handles:
    if hasattr(h, "set_sizes"):                         # the cloud's legend marker: larger and darker
        h.set_alpha(0.6); h.set_sizes([18])
plt.tight_layout(); plt.show()
  scaled change of state  effort  Euclidean  bottleneck   effort/bottleneck  Euclidean/bottleneck  effort/Euclidean
  turnaround, Year 5       0.204      0.109       0.076                2.68                  1.43              1.88
  restructuring, Year 5    0.405      0.259       0.211                1.92                  1.23              1.56
  digital, Year 5          0.517      0.362       0.346                1.49                  1.05              1.43
  Peer A                   0.501      0.220       0.147                3.40                  1.50              2.27
  Peer B                   0.781      0.340       0.242                3.23                  1.41              2.30

constants for n = 8 readings: effort/bottleneck in [1, 8]; Euclidean/bottleneck and effort/Euclidean in [1, 2.83]
attained: one reading moving (e1) gives 1; all eight moving equally give 8 and 2.83
the effort view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A
the Euclidean view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A
the bottleneck view ranks the Year-5 moves turnaround < restructuring < digital; closer peer: Peer A
over the 10,000 pairs: effort/bottleneck from 1.35 to 6.74 (median 3.64); the effort and bottleneck views name different closer peers for 24.8% of pairs
Effort and bottleneck views stay within a factor of eight (seed 26103)

Panel 4 — Appraise each initiative, then chain them (Worked Example 3.1, Steps 1–2; Proposition 3.1)

Worked Example 3.1, Steps 1–2, and the first half of AXIOM Lab 1.3, step 4. Appraise each initiative alone from today's state and add the appraisals, as a "bag of initiatives" would; then run restructure-then-digital step by step. Proposition 3.1: running T1T_1 and then T2T_2 can start exactly from the states where T1T_1 is possible and delivers the company into the domain of T2T_2. In Appendix 3.A's notation the chained domain is the preimage T1−1(dom⁡T2)T_1^{-1}(\operatorname{dom} T_2) (Equation 3.4), which is empty unless what T1T_1 can produce overlaps what T2T_2 requires.

Python Code
def fmt(x):
    return "infeasible" if x is None else f"liquidity ${x[0]:.0f} million, technology {x[1]:.2f}, workforce {x[2]:.0f}"

def change(a, b):
    return tuple(q - p for p, q in zip(a, b))

def signed(v, d=0):
    return "unchanged" if round(v, d) == 0 else f"{v:+.{d}f}"

sale, build = restructure(TODAY), digital(TODAY)
d_sale, d_build = change(TODAY, sale), change(TODAY, build)
bag = tuple(t + a + b for t, a, b in zip(TODAY, d_sale, d_build))
print("today:                 ", fmt(TODAY))
print(f"Step 1, the sale alone:  liquidity {signed(d_sale[0])}, technology {signed(d_sale[1], 1)}, workforce {signed(d_sale[2])}")
print(f"Step 1, digital alone:   liquidity {signed(d_build[0])}, technology {signed(d_build[1], 1)}, workforce {signed(d_build[2])}")
print("bag of initiatives:     ", fmt(bag))

r_then_d = digital(sale)
print(f"\nStep 2, after the sale: {fmt(sale)}; workforce {sale[2]:.0f} < {W_MIN:.0f}, outside the digital program's domain")
print("restructure, then digital:", fmt(r_then_d))

# Proposition 3.1 and Equation 3.4: from which workforce levels can each two-step program start?
levels = np.arange(45.0, 71.0)
start = {"sale as designed, then digital": [w for w in levels if digital(restructure((620.0, 41.0, w))) is not None],
         "sale with the engineers kept, then digital": [w for w in levels if digital(restructure((620.0, 41.0, w), keep=True)) is not None],
         "digital alone": [w for w in levels if digital((620.0, 41.0, w)) is not None]}
for name, ok in start.items():
    print(f"chained domain, {name}: workforce >= {min(ok):.0f}")
chain_min = min(start["sale as designed, then digital"])
print(f"the sale as designed lands 5 points lower, so the program needs {chain_min:.0f} = {W_MIN:.0f} + {W_LOSS:.0f} at the start;"
      f" Meridian, at {TODAY[2]:.0f}, is {chain_min - TODAY[2]:.0f} points short")
today:                  liquidity $620 million, technology 41.00, workforce 58
Step 1, the sale alone:  liquidity +112, technology -4.1, workforce -5
Step 1, digital alone:   liquidity -35, technology +34.6, workforce unchanged
bag of initiatives:      liquidity $697 million, technology 71.53, workforce 53

Step 2, after the sale: liquidity $732 million, technology 36.90, workforce 53; workforce 53 < 55, outside the digital program's domain
restructure, then digital: infeasible
chained domain, sale as designed, then digital: workforce >= 60
chained domain, sale with the engineers kept, then digital: workforce >= 55
chained domain, digital alone: workforce >= 55
the sale as designed lands 5 points lower, so the program needs 60 = 55 + 5 at the start; Meridian, at 58, is 2 points short

Panel 5 — Sequence the initiatives (Worked Example 3.1, Steps 3–5; Table 3.4; Theorem 3.2(iii); Online Appendix 3.B)

Worked Example 3.1, Steps 3–5, and AXIOM Lab 1.3, step 4: apply the two initiatives in both orders, record the end states (Table 3.4) and the size of the difference between them, which needs a declared norm and scaling. Theorem 3.2(iii): the same two transformations in different orders generally produce different companies. Table 3.4's two feasible orders also differ in their deal terms (the engineers go in one and stay in the other), so the panel separates the terms from the order, and then splits the order's effect as Online Appendix 3.B does for affine transformations Tix=Aix+biT_i\mathbf{x} = \mathbf{A}_i\mathbf{x} + \mathbf{b}_i: (T2∘T1)x−(T1∘T2)x=(A2A1−A1A2) x+(A2−I) b1−(A1−I) b2.(T_2 \circ T_1)\mathbf{x} - (T_1 \circ T_2)\mathbf{x} = (\mathbf{A}_2\mathbf{A}_1 - \mathbf{A}_1\mathbf{A}_2)\,\mathbf{x} + (\mathbf{A}_2 - \mathbf{I})\,\mathbf{b}_1 - (\mathbf{A}_1 - \mathbf{I})\,\mathbf{b}_2 . The first term is the commutator, how each transformation changes what the other acts on; the second, how each rescales the other's fixed shift. For Meridian the digital program is a pure shift, so the commutator vanishes and the constant term is the one interaction Step 5 names: the sale takes 10 percent of the points the build adds.

Python Code
after_build = digital(TODAY)                                   # Step 3: the digital program runs first
d_then_r = restructure(after_build)
sale_kept = restructure(TODAY, keep=True)                      # Step 4: the deal keeps the engineers
kept_then_d = digital(sale_kept)
d_then_kept = restructure(after_build, keep=True)              # the same deal terms in both orders (not in Table 3.4)
print(f"Step 3: digital first, its low ${TODAY[0] - BUILD_DIP:.0f} million around month {BUILD_LOW_MONTH:.0f}: {fmt(after_build)}")
print(f"        then the sale: {fmt(d_then_r)}")
print(f"Step 4: the sale with the engineers kept: {fmt(sale_kept)}")
print(f"        then the digital program, its low ${sale_kept[0] - BUILD_DIP:.0f} million: {fmt(kept_then_d)}")

TABLE34 = [("Today", TODAY), ("Bag of initiatives (each appraised alone, then added)", bag),
           ("Restructure, then digital (as designed)", r_then_d), ("Digital, then restructure", d_then_r),
           ("Restructure (engineers kept), then digital", kept_then_d)]
print(f"\nTable 3.4 {'':45s} {'liquidity':>10s} {'technology':>11s} {'workforce':>10s}")
for name, x in TABLE34:
    print(f"  {name:53s} " + (f"{'infeasible':^33s}" if x is None else f"{x[0]:10.0f} {x[1]:11.1f} {x[2]:10.0f}"))

gap = change(kept_then_d, d_then_r)                            # digital-first minus restructure-first
print(f"\nStep 5: digital-first ends with ${gap[0]:.0f} million more cash; restructure-first with a stronger platform"
      f" ({kept_then_d[1]:.1f} against {d_then_r[1]:.2f}, {-gap[1]:.2f} points) and workforce ({kept_then_d[2]:.0f} against {d_then_r[2]:.0f})")
terms = change(d_then_kept, d_then_r)                          # same order (digital first), different deal terms
order = change(kept_then_d, d_then_kept)                       # same deal terms (engineers kept), different order
print(f"digital, then the sale with the engineers kept: {fmt(d_then_kept)}")
print(f"the gap ({gap[0]:.0f}, {gap[1]:.2f}, {gap[2]:.0f}) = deal terms ({terms[0]:.0f}, {terms[1]:.2f}, {terms[2]:.0f})"
      f" + order ({order[0]:.0f}, {order[1]:.2f}, {order[2]:.0f})")

# Online Appendix 3.B on Meridian: the sale (engineers kept) and the build as affine maps of (L, T, W)
A_R, b_R = np.diag([1.0, 1 - TECH_SHARE, 1.0]), np.array([SALE - KEEP_COST, 0.0, 0.0])
A_D, b_D = np.eye(3), np.array([BUILD_L, BUILD_T, 0.0])     # the build: a pure shift
x0 = np.array(TODAY)
commutator = (A_D @ A_R - A_R @ A_D) @ x0
constant = (A_D - np.eye(3)) @ b_R - (A_R - np.eye(3)) @ b_D
direct = np.array(kept_then_d) - np.array(d_then_kept)
v3 = lambda v: "(" + ", ".join(f"{q:.2f}" for q in v) + ")"
print(f"\nOnline Appendix 3.B: (D o R)x0 - (R o D)x0 = commutator {v3(commutator)} + constant {v3(constant)} = {v3(commutator + constant)};"
      f" directly {v3(direct)}")
print(f"  commutator: {v3(commutator)}, zero, since the build's effect does not depend on the state it starts from")
print(f"  constant: built first, the platform's {BUILD_T:.2f} new points lose 10% to the sale ({TECH_SHARE * BUILD_T:.2f}):"
      " 'the sale takes a share of a platform that grows if the digital program runs first'")
print(f"  the bag misses it: it pairs digital-first's cash (${bag[0]:.0f} million) with restructure-first's platform"
      f" ({bag[1]:.1f}) and the sale-as-designed workforce ({bag[2]:.0f}), a company no sequence produces")

# Appendix 3.A's two-reading example (proof of Theorem 3.2(iii)) and its split (Online Appendix 3.B)
T_R = lambda x: np.array([x[0] + 3, 0.9 * x[1]])
T_D = lambda x: np.array([0.5 * x[0], x[1] + 0.8 * x[0]])
z0 = np.array([2.0, 40.0])
dr2, rd2 = T_D(T_R(z0)), T_R(T_D(z0))
Ar2, br2, Ad2 = np.diag([1.0, 0.9]), np.array([3.0, 0.0]), np.array([[0.5, 0.0], [0.8, 1.0]])
c2, k2 = (Ad2 @ Ar2 - Ar2 @ Ad2) @ z0, (Ad2 - np.eye(2)) @ br2
print(f"\nAppendix 3.A: T_D(T_R x0) = ({dr2[0]:.1f}, {dr2[1]:.1f}), T_R(T_D x0) = ({rd2[0]:.1f}, {rd2[1]:.2f});"
      f" difference ({dr2[0] - rd2[0]:.1f}, {dr2[1] - rd2[1]:.2f}) = commutator ({c2[0]:.1f}, {c2[1]:.2f}) + constant ({k2[0]:.1f}, {k2[1]:.1f})")

# the size of the difference (lab step 4): W_M's rule on these three readings, liquidity in $ million
w3 = 1 / np.array([TODAY[0], 100.0, 100.0])
size = {}
for label, dx in (("Table 3.4's two feasible orders", gap), ("the same deal terms in both orders", order)):
    size[label] = views(w3 * np.array(dx))
    s = size[label]
    print(f"size of the difference, {label}: effort {s['effort']:.3f}, Euclidean {s['Euclidean']:.3f}, bottleneck {s['bottleneck']:.3f}")

steps = [0, 1, 2]
paths = [("digital, then restructure", (TODAY, after_build, d_then_r), "#E65100", "-"),
         ("restructure (engineers kept), then digital", (TODAY, sale_kept, kept_then_d), "#1F4E79", "-"),
         ("restructure as designed: digital cannot start", (TODAY, sale), "#B71C1C", "--")]
fig, axes = plt.subplots(1, 3, figsize=(7.6, 3.6))
for j, (ax, ylab, lims) in enumerate(zip(axes, ("liquidity ($ million)", "technology platform (index)",
                                                 "workforce capability (index)"), ((560, 760), (34, 79), (50, 60)))):
    for name, path, col, ls in paths:
        ax.plot(steps[:len(path)], [x[j] for x in path], color=col, ls=ls, lw=1.8, marker="o", ms=4, label=name)
        if len(path) == 2:                                   # the second step is outside its domain: blocked
            ax.plot([1, 1.5], [path[1][j]] * 2, color=col, ls=":", lw=1.4)
            ax.plot(1.5, path[1][j], "x", color=col, ms=8, mew=2)
    ax.plot(2, bag[j], "o", mfc="white", mec="#616161", mew=1.5, ms=7, label="bag of initiatives: no real sequence")
    ax.set_xticks(steps)
    ax.set_xticklabels(["today", "step 1", "step 2"], fontsize=8)
    ax.set_ylim(*lims)
    ax.set_xlim(-0.25, 2.25)
    ax.set_title(ylab, fontsize=9)
    ax.tick_params(axis="y", labelsize=8)
axes[2].axhline(W_MIN, color="#616161", lw=0.9, ls=":")
axes[2].text(2.2, 50.3, "dotted: the digital\nprogram's domain (55)", ha="right", va="bottom", fontsize=7.5, color="#616161")
handles, labels = axes[0].get_legend_handles_labels()
fig.legend(handles, labels, loc="lower center", ncol=2, frameon=False, fontsize=8, bbox_to_anchor=(0.5, 0.0))
fig.suptitle("Two feasible orders, two companies (seed 26103)", fontsize=11)
plt.tight_layout(rect=(0, 0.13, 1, 1)); plt.show()
Step 3: digital first, its low $482 million around month 21: liquidity $585 million, technology 75.63, workforce 58
        then the sale: liquidity $697 million, technology 68.07, workforce 53
Step 4: the sale with the engineers kept: liquidity $712 million, technology 36.90, workforce 58
        then the digital program, its low $574 million: liquidity $677 million, technology 71.53, workforce 58

Table 3.4                                                liquidity  technology  workforce
  Today                                                        620        41.0         58
  Bag of initiatives (each appraised alone, then added)        697        71.5         53
  Restructure, then digital (as designed)                          infeasible            
  Digital, then restructure                                    697        68.1         53
  Restructure (engineers kept), then digital                   677        71.5         58

Step 5: digital-first ends with $20 million more cash; restructure-first with a stronger platform (71.5 against 68.07, 3.46 points) and workforce (58 against 53)
digital, then the sale with the engineers kept: liquidity $677 million, technology 68.07, workforce 58
the gap (20, -3.46, -5) = deal terms (20, 0.00, -5) + order (0, -3.46, 0)

Online Appendix 3.B: (D o R)x0 - (R o D)x0 = commutator (0.00, 0.00, 0.00) + constant (0.00, 3.46, 0.00) = (0.00, 3.46, 0.00); directly (0.00, 3.46, 0.00)
  commutator: (0.00, 0.00, 0.00), zero, since the build's effect does not depend on the state it starts from
  constant: built first, the platform's 34.63 new points lose 10% to the sale (3.46): 'the sale takes a share of a platform that grows if the digital program runs first'
  the bag misses it: it pairs digital-first's cash ($697 million) with restructure-first's platform (71.5) and the sale-as-designed workforce (53), a company no sequence produces

Appendix 3.A: T_D(T_R x0) = (2.5, 40.0), T_R(T_D x0) = (4.0, 37.44); difference (-1.5, 2.56) = commutator (0.0, 0.16) + constant (-1.5, 2.4)
size of the difference, Table 3.4's two feasible orders: effort 0.117, Euclidean 0.069, bottleneck 0.050
size of the difference, the same deal terms in both orders: effort 0.035, Euclidean 0.035, bottleneck 0.035
Two feasible orders, two companies (seed 26103)

Panel 6 — Recommend (Worked Example 3.1, Step 6; Theorem 3.2(i)–(ii))

Worked Example 3.1, Step 6: the order is a decision variable, and so are the deal terms that decide whether the second step is possible. Because the sale cannot be undone (Theorem 3.2(i)), the board should fix the order and the retention clause before signing. Theorem 3.2(ii): sensitivities multiply along a program, so five mild steps (factor 1.2 each) can amplify an error in the starting state by up to 1.25≈2.51.2^5 \approx 2.5, while replacing two of them with consolidating steps (factor 0.7) brings the bound to 1.23×0.72≈0.851.2^3 \times 0.7^2 \approx 0.85. The discussion question asks what would have to be true about the value of cash against platform strength for a recommendation to change; the arithmetic below locates the break-even. Chapter 6 later adds the board's liquidity floor (Table 5.4): both orders stay above it, since the build's low point, $138 million below its start, leaves $482 million when the build runs first.

Python Code
print(f"Theorem 3.2(ii): five steps at factor 1.2 amplify by at most {1.2 ** 5:.3f} (about 2.5);"
      f" three at 1.2 and two at 0.7 by at most {1.2 ** 3 * 0.7 ** 2:.3f} (about 0.85)")

cash, tech, work = gap[0], -gap[1], -gap[2]
price_w = KEEP_COST / W_LOSS
breakeven = (cash - price_w * work) / tech
print(f"\nFor discussion: digital-first keeps ${cash:.0f} million more cash; restructure-first ends with {tech:.2f} more"
      f" platform points and {work:.0f} more workforce points")
print(f"the retention clause prices those {work:.0f} workforce points at ${KEEP_COST:.0f} million, ${price_w:.0f} million a point"
      " (the quote Chapter 10 reads from the same deal)")
print(f"at that price restructure-first is worth more exactly when the board values a platform point above"
      f" ({cash:.0f} - {KEEP_COST:.0f}) / {tech:.2f} = ${breakeven:.1f} million: digital-first's extra cash is the clause itself")

FLOOR = 350.0       # Table 5.4: the board's floor, liquidity >= $0.35 billion (declared in Chapter 5)
lowest = {}
for name, start in (("digital, then restructure", TODAY), ("restructure (engineers kept), then digital", sale_kept)):
    lowest[name] = start[0] - BUILD_DIP                        # the build's low point comes around month 21
    print(f"{name}: lowest liquidity on the way ${lowest[name]:.0f} million, {lowest[name] - FLOOR:+.0f} against the floor")
print("Sections 6.5-6.6: on the floor both orders run; the build needs liquidity of at least"
      f" ${FLOOR + BUILD_DIP:.0f} million when it starts, so that its low point respects the floor")
Theorem 3.2(ii): five steps at factor 1.2 amplify by at most 2.488 (about 2.5); three at 1.2 and two at 0.7 by at most 0.847 (about 0.85)

For discussion: digital-first keeps $20 million more cash; restructure-first ends with 3.46 more platform points and 5 more workforce points
the retention clause prices those 5 workforce points at $20 million, $4 million a point (the quote Chapter 10 reads from the same deal)
at that price restructure-first is worth more exactly when the board values a platform point above (20 - 20) / 3.46 = $0.0 million: digital-first's extra cash is the clause itself
digital, then restructure: lowest liquidity on the way $482 million, +132 against the floor
restructure (engineers kept), then digital: lowest liquidity on the way $574 million, +224 against the floor
Sections 6.5-6.6: on the floor both orders run; the build needs liquidity of at least $488 million when it starts, so that its low point respects the floor

Panel 7 — Watch a company run down (Section 3.4, Equation 3.2; Table 3.2; Sections 7.4–7.6)

AXIOM Lab 1.3, step 5. Run Section 3.4's three-reading company (Equation 3.2) with no investment, then with investment, and read the eigenvalue display. Entry aija_{ij} of A\mathbf{A} is the response of reading ii to reading jj: the zeros say that efficiency feeds neither capability nor technology, the entry 0.10 says that capability builds the platform, and diagonal entries below one say that every reading decays without reinforcement. From x0=(50,40,60)\mathbf{x}_0 = (50, 40, 60) with u0=10u_0 = 10, one year later x1=(53.0,42.0,54.5)\mathbf{x}_1 = (53.0, 42.0, 54.5). The eigenvalues are 0.95, 0.80 and 0.80, all below one, so without investment the company decays steadily toward zero: open systems run down without throughput (Table 2.2). Chapter 7 holds the investment at 8 a year: each unit held forever adds 10.5 points of capability, 9 of technology and 7.1 of efficiency, so the company settles at (84, 72, 57) (Section 7.5); over ten years momentum alone lets technology erode from 40 to 27 while the program adds 25 (Section 7.4); and the slowest eigenvalue, 0.95, leaves half of any shock after about 13.5 years (Section 7.6). The spectral radius ρ(A)\rho(\mathbf{A}) of Table 3.2 does not depend on the norm; each norm's one-year sensitivity factor does, and a run of years multiplies them (Theorem 3.2(ii)).

Python Code
x1 = A3 @ Y0 + B3 * U0
eig = np.sort(np.linalg.eigvals(A3).real)[::-1]
rho = float(np.abs(np.linalg.eigvals(A3)).max())
print(f"one year from x0 = (50, 40, 60) with u0 = 10: x1 = ({x1[0]:.1f}, {x1[1]:.1f}, {x1[2]:.1f})")
print(f"eigenvalues {', '.join(f'{v:.2f}' for v in eig)}; spectral radius {rho:.2f} < 1: without investment every reading decays")

def run(y0, u, years):
    y = [np.asarray(y0, float)]
    for _ in range(years):
        y.append(A3 @ y[-1] + B3 * u)
    return np.array(y)

U_HELD, YEARS = 8.0, 30                                   # Chapter 7's held investment of 8 a year
free, held = run(Y0, 0.0, YEARS), run(Y0, U_HELD, YEARS)
per_unit = np.linalg.solve(np.eye(3) - A3, B3)
steady = U_HELD * per_unit
v3 = lambda v, d=1: "(" + ", ".join(f"{q:.{d}f}" for q in v) + ")"
print(f"no investment: year 10 {v3(free[10])}, year 30 {v3(free[30])}: the three readings end up falling together,"
      " 5 percent a year (every row of A sums to 0.95, so (1, 1, 1) is the slowest mode)")
print(f"each unit of investment held forever adds {v3(per_unit, 3)}; a held 8 settles the company at {v3(steady, 0)}")
print(f"technology at year 10: momentum alone {free[10, 1]:.1f}, the program adds {held[10, 1] - free[10, 1]:.1f},"
      f" in all {held[10, 1]:.1f}")
half = np.log(0.5) / np.log(rho)
print(f"half-life of the slowest mode: ln 0.5 / ln {rho:.2f} = {half:.1f} years")

# the one-year map's sensitivity factor in three norms; a k-year run's factor is at most its k-th power
Lf = {"bottleneck": float(np.abs(A3).sum(1).max()), "Euclidean": float(np.linalg.norm(A3, 2)),
      "effort": float(np.abs(A3).sum(0).max())}
print("\none-year sensitivity factor: " + ", ".join(f"{k} {v:.3f}" for k, v in Lf.items()))
K = 40
eff_k = np.array([np.abs(np.linalg.matrix_power(A3, k)).sum(0).max() for k in range(K + 1)])
bot_k = np.array([np.abs(np.linalg.matrix_power(A3, k)).sum(1).max() for k in range(K + 1)])
k_peak = int(eff_k.argmax())
k_below = int(np.argmax((eff_k < 1) & (np.arange(K + 1) > k_peak)))
print(f"bottleneck view: a k-year run's factor is exactly 0.95^k (largest gap to 0.95^k over 40 years:"
      f" {np.abs(bot_k - 0.95 ** np.arange(K + 1)).max():.0e}); the largest single deviation never grows")
print(f"effort view: a capability shortfall spreads to technology and efficiency, so the total first grows: the k-year factor"
      f" rises to {eff_k[k_peak]:.3f} at year {k_peak} and falls below one only from year {k_below}")
print("the conclusion is the same in every norm (Theorem 3.1): every deviation dies out, at the rate the spectral radius sets")

t = np.arange(YEARS + 1)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for j, (name, col) in enumerate((("capability", "#1F4E79"), ("technology", "#E65100"), ("efficiency", "#B71C1C"))):
    ax.plot(t, held[:, j], color=col, lw=2, label=name)
    ax.plot(t, free[:, j], color=col, lw=1.4, ls="--")
    ax.axhline(steady[j], color=col, lw=0.7, ls=":")
    ax.text(YEARS + 0.3, steady[j], f"{steady[j]:.0f}", va="center", ha="left", fontsize=8, color=col)
ax.plot([], [], color="#616161", lw=2, label="investment held at 8 a year")
ax.plot([], [], color="#616161", lw=1.4, ls="--", label="no investment")
ax.plot([], [], color="#616161", lw=0.7, ls=":", label="steady state under the held 8")
ax.text(YEARS, 1.5, "eigenvalues 0.95, 0.80, 0.80", ha="right", va="bottom", fontsize=8, color="#616161")
ax.set(xlim=(0, YEARS), ylim=(0, 104), xlabel="years", ylabel="index (0-100)",
       title="Without investment the company runs down; a held 8 sets its level (seed 26103)")
h, lab = ax.get_legend_handles_labels()
rows = [0, 3, 1, 4, 2, 5]                                 # colours on the first row, line styles on the second
ax.legend([h[i] for i in rows], [lab[i] for i in rows], frameon=False, fontsize=8, ncol=3, loc="upper center",
          bbox_to_anchor=(0.5, 1.02), columnspacing=1.4)
plt.tight_layout(); plt.show()
one year from x0 = (50, 40, 60) with u0 = 10: x1 = (53.0, 42.0, 54.5)
eigenvalues 0.95, 0.80, 0.80; spectral radius 0.95 < 1: without investment every reading decays
no investment: year 10 (28.3, 27.2, 28.7), year 30 (10.0, 10.0, 10.0): the three readings end up falling together, 5 percent a year (every row of A sums to 0.95, so (1, 1, 1) is the slowest mode)
each unit of investment held forever adds (10.500, 9.000, 7.125); a held 8 settles the company at (84, 72, 57)
technology at year 10: momentum alone 27.2, the program adds 25.0, in all 52.2
half-life of the slowest mode: ln 0.5 / ln 0.95 = 13.5 years

one-year sensitivity factor: bottleneck 0.950, Euclidean 0.971, effort 1.050
bottleneck view: a k-year run's factor is exactly 0.95^k (largest gap to 0.95^k over 40 years: 7e-16); the largest single deviation never grows
effort view: a capability shortfall spreads to technology and efficiency, so the total first grows: the k-year factor rises to 1.117 at year 5 and falls below one only from year 11
the conclusion is the same in every norm (Theorem 3.1): every deviation dies out, at the rate the spectral radius sets
Without investment the company runs down; a held 8 sets its level (seed 26103)

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

Each checkpoint is a number printed in Chapter 3 (Tables 3.1 and 3.4, Figure 3.3, Worked Example 3.1, Sections 3.4–3.5, Appendix 3.A), in Online Appendix 3.B, or in the later sections that reuse Chapter 3's scaling and three-reading company (Sections 5.8, 6.6 and 7.4–7.6). The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.

Python Code
y5 = {k: V[f"{k}, Year 5"]["Euclidean"] for k in YEAR5}
checks = [
    ("readings in Meridian's state, Table 3.1 (workbook)", len(X0), 8, 0),
    ("scaled workforce capability, Figure 3.3 (workbook)", SX0[2], 0.58, 0.005),
    ("scaled technology platform, Figure 3.3 (workbook)", SX0[3], 0.41, 0.005),
    ("scaled operational efficiency, Figure 3.3 (workbook)", SX0[4], 0.71, 0.005),
    ("scaled strategic risk, Figure 3.3 (workbook)", SX0[6], 0.64, 0.005),
    ("readings at 1.00 after scaling, Figure 3.3 (workbook)", int(np.isclose(SX0, 1.0).sum()), 4, 0),
    ("sale alone: liquidity change, Step 1 (workbook)", d_sale[0], 112, 0.5),
    ("sale alone: technology change, Step 1 (workbook)", d_sale[1], -4.1, 0.05),
    ("sale alone: workforce change, Step 1 (workbook)", d_sale[2], -5, 0),
    ("digital alone: liquidity change by Year 5, Step 1 (workbook)", d_build[0], -35, 0.5),
    ("digital alone: technology change, Step 1 (workbook)", d_build[1], 34.6, 0.05),
    ("the build's low point below its start, the situation (workbook)", BUILD_DIP, 138, 0.5),
    ("bag of initiatives: liquidity, Table 3.4 (workbook)", bag[0], 697, 0.5),
    ("bag of initiatives: technology, Table 3.4 (workbook)", bag[1], 71.5, 0.05),
    ("bag of initiatives: workforce, Table 3.4 (workbook)", bag[2], 53, 0),
    ("after the sale: liquidity, Step 2 (workbook)", sale[0], 732, 0.5),
    ("after the sale: technology, Step 2 (workbook)", sale[1], 36.9, 0.05),
    ("restructure, then digital is feasible, Table 3.4 (workbook)", int(r_then_d is not None), 0, 0),
    ("digital first: liquidity after the build, Step 3 (workbook)", after_build[0], 585, 0.5),
    ("digital first: technology after the build, Step 3 (workbook)", after_build[1], 75.6, 0.05),
    ("digital, then restructure: liquidity, Table 3.4 (workbook)", d_then_r[0], 697, 0.5),
    ("digital, then restructure: technology, Table 3.4 (workbook)", d_then_r[1], 68.1, 0.05),
    ("digital, then restructure: workforce, Table 3.4 (workbook)", d_then_r[2], 53, 0),
    ("sale with the engineers kept: liquidity, Step 4 (workbook)", sale_kept[0], 712, 0.5),
    ("restructure (kept), then digital: liquidity, Table 3.4 (workbook)", kept_then_d[0], 677, 0.5),
    ("restructure (kept), then digital: technology, Table 3.4 (workbook)", kept_then_d[1], 71.5, 0.05),
    ("restructure (kept), then digital: workforce, Table 3.4 (workbook)", kept_then_d[2], 58, 0),
    ("digital-first's extra cash, Step 5 (workbook)", gap[0], 20, 0.5),
    ("three-reading company: capability after a year, Section 3.4 (workbook)", x1[0], 53.0, 0.05),
    ("three-reading company: technology after a year, Section 3.4 (workbook)", x1[1], 42.0, 0.05),
    ("three-reading company: efficiency after a year, Section 3.4 (workbook)", x1[2], 54.5, 0.05),
    ("largest eigenvalue, Section 3.4 (workbook)", eig[0], 0.95, 0.005),
    ("second eigenvalue, Section 3.4 (workbook)", eig[1], 0.80, 0.005),
    ("third eigenvalue, Section 3.4 (workbook)", eig[2], 0.80, 0.005),
    ("five steps at factor 1.2, Section 3.5 (workbook)", 1.2 ** 5, 2.5, 0.05),
    ("three steps at 1.2 and two at 0.7, Section 3.5 (workbook)", 1.2 ** 3 * 0.7 ** 2, 0.85, 0.005),
    ("T_D(T_R x0), first reading, Appendix 3.A (workbook)", dr2[0], 2.5, 0.05),
    ("T_D(T_R x0), second reading, Appendix 3.A (workbook)", dr2[1], 40.0, 0.05),
    ("T_R(T_D x0), first reading, Appendix 3.A (workbook)", rd2[0], 4.0, 0.05),
    ("T_R(T_D x0), second reading, Appendix 3.A (workbook)", rd2[1], 37.44, 0.005),
    ("difference of the orders, first reading, OA 3.B (workbook)", dr2[0] - rd2[0], -1.5, 0.05),
    ("difference of the orders, second reading, OA 3.B (workbook)", dr2[1] - rd2[1], 2.56, 0.005),
    ("largest effort/bottleneck ratio, eight readings, Remark 3.B.1 (workbook)", views(ones)["effort"] / views(ones)["bottleneck"], 8, 1e-9),
    ("scaled distance to the turnaround's Year 5, Section 5.8 (workbook)", y5["turnaround"], 0.11, 0.005),
    ("scaled distance to restructuring's Year 5, Section 5.8 (workbook)", y5["restructuring"], 0.26, 0.005),
    ("scaled distance to digital's Year 5, Section 5.8 (workbook)", y5["digital"], 0.36, 0.005),
    ("digital first: lowest liquidity on the way, Worked Example 8.1 (workbook)", lowest["digital, then restructure"], 482, 0.5),
    ("technology at year 10, momentum alone, Section 7.4 (workbook)", free[10, 1], 27, 0.5),
    ("technology at year 10, the program's addition, Section 7.4 (workbook)", held[10, 1] - free[10, 1], 25, 0.5),
    ("technology at year 10, in all, Section 7.4 (workbook)", held[10, 1], 52, 0.5),
    ("efficiency per unit of investment held, Section 7.5 (workbook)", per_unit[2], 7.1, 0.05),
    ("steady state under a held 8: capability, Section 7.5 (workbook)", steady[0], 84, 0.5),
    ("steady state under a held 8: technology, Section 7.5 (workbook)", steady[1], 72, 0.5),
    ("steady state under a held 8: efficiency, Section 7.5 (workbook)", steady[2], 57, 0.5),
    ("half-life of the slowest mode, years, Section 7.6 (workbook)", half, 13.5, 0.05),
]
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")
readings in Meridian's state, Table 3.1 (workbook)                            8.0000   book    8.0000   PASS
scaled workforce capability, Figure 3.3 (workbook)                            0.5800   book    0.5800   PASS
scaled technology platform, Figure 3.3 (workbook)                             0.4100   book    0.4100   PASS
scaled operational efficiency, Figure 3.3 (workbook)                          0.7100   book    0.7100   PASS
scaled strategic risk, Figure 3.3 (workbook)                                  0.6400   book    0.6400   PASS
readings at 1.00 after scaling, Figure 3.3 (workbook)                         4.0000   book    4.0000   PASS
sale alone: liquidity change, Step 1 (workbook)                             112.0000   book  112.0000   PASS
sale alone: technology change, Step 1 (workbook)                             -4.1000   book   -4.1000   PASS
sale alone: workforce change, Step 1 (workbook)                              -5.0000   book   -5.0000   PASS
digital alone: liquidity change by Year 5, Step 1 (workbook)                -35.3673   book  -35.0000   PASS
digital alone: technology change, Step 1 (workbook)                          34.6347   book   34.6000   PASS
the build's low point below its start, the situation (workbook)             138.0821   book  138.0000   PASS
bag of initiatives: liquidity, Table 3.4 (workbook)                         696.6327   book  697.0000   PASS
bag of initiatives: technology, Table 3.4 (workbook)                         71.5347   book   71.5000   PASS
bag of initiatives: workforce, Table 3.4 (workbook)                          53.0000   book   53.0000   PASS
after the sale: liquidity, Step 2 (workbook)                                732.0000   book  732.0000   PASS
after the sale: technology, Step 2 (workbook)                                36.9000   book   36.9000   PASS
restructure, then digital is feasible, Table 3.4 (workbook)                   0.0000   book    0.0000   PASS
digital first: liquidity after the build, Step 3 (workbook)                 584.6327   book  585.0000   PASS
digital first: technology after the build, Step 3 (workbook)                 75.6347   book   75.6000   PASS
digital, then restructure: liquidity, Table 3.4 (workbook)                  696.6327   book  697.0000   PASS
digital, then restructure: technology, Table 3.4 (workbook)                  68.0712   book   68.1000   PASS
digital, then restructure: workforce, Table 3.4 (workbook)                   53.0000   book   53.0000   PASS
sale with the engineers kept: liquidity, Step 4 (workbook)                  712.0000   book  712.0000   PASS
restructure (kept), then digital: liquidity, Table 3.4 (workbook)           676.6327   book  677.0000   PASS
restructure (kept), then digital: technology, Table 3.4 (workbook)           71.5347   book   71.5000   PASS
restructure (kept), then digital: workforce, Table 3.4 (workbook)            58.0000   book   58.0000   PASS
digital-first's extra cash, Step 5 (workbook)                                20.0000   book   20.0000   PASS
three-reading company: capability after a year, Section 3.4 (workbook)       53.0000   book   53.0000   PASS
three-reading company: technology after a year, Section 3.4 (workbook)       42.0000   book   42.0000   PASS
three-reading company: efficiency after a year, Section 3.4 (workbook)       54.5000   book   54.5000   PASS
largest eigenvalue, Section 3.4 (workbook)                                    0.9500   book    0.9500   PASS
second eigenvalue, Section 3.4 (workbook)                                     0.8000   book    0.8000   PASS
third eigenvalue, Section 3.4 (workbook)                                      0.8000   book    0.8000   PASS
five steps at factor 1.2, Section 3.5 (workbook)                              2.4883   book    2.5000   PASS
three steps at 1.2 and two at 0.7, Section 3.5 (workbook)                     0.8467   book    0.8500   PASS
T_D(T_R x0), first reading, Appendix 3.A (workbook)                           2.5000   book    2.5000   PASS
T_D(T_R x0), second reading, Appendix 3.A (workbook)                         40.0000   book   40.0000   PASS
T_R(T_D x0), first reading, Appendix 3.A (workbook)                           4.0000   book    4.0000   PASS
T_R(T_D x0), second reading, Appendix 3.A (workbook)                         37.4400   book   37.4400   PASS
difference of the orders, first reading, OA 3.B (workbook)                   -1.5000   book   -1.5000   PASS
difference of the orders, second reading, OA 3.B (workbook)                   2.5600   book    2.5600   PASS
largest effort/bottleneck ratio, eight readings, Remark 3.B.1 (workbook)      8.0000   book    8.0000   PASS
scaled distance to the turnaround's Year 5, Section 5.8 (workbook)            0.1087   book    0.1100   PASS
scaled distance to restructuring's Year 5, Section 5.8 (workbook)             0.2589   book    0.2600   PASS
scaled distance to digital's Year 5, Section 5.8 (workbook)                   0.3625   book    0.3600   PASS
digital first: lowest liquidity on the way, Worked Example 8.1 (workbook)   481.9179   book  482.0000   PASS
technology at year 10, momentum alone, Section 7.4 (workbook)                27.2252   book   27.0000   PASS
technology at year 10, the program's addition, Section 7.4 (workbook)        24.9600   book   25.0000   PASS
technology at year 10, in all, Section 7.4 (workbook)                        52.1853   book   52.0000   PASS
efficiency per unit of investment held, Section 7.5 (workbook)                7.1250   book    7.1000   PASS
steady state under a held 8: capability, Section 7.5 (workbook)              84.0000   book   84.0000   PASS
steady state under a held 8: technology, Section 7.5 (workbook)              72.0000   book   72.0000   PASS
steady state under a held 8: efficiency, Section 7.5 (workbook)              57.0000   book   57.0000   PASS
half-life of the slowest mode, years, Section 7.6 (workbook)                 13.5134   book   13.5000   PASS

55 of 55 checkpoints PASS

Next. Chapter 4 asks what a company model can and cannot answer: no analysis extracts what a model's readings leave out, and validation certifies a model only where history has been. The declarations made here, units, scaling, the norm and the spacing of ratings, become part of its modeling contract. AXIOM-03 runs the same models interactively (Lab 1.3); 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