Skip to content

Vol. I, Ch. 7

DCT Laboratory — Volume I, Chapter 7

Dynamic Enterprise Systems

This laboratory demonstrates

Seed 26107 · Companion to Chapter 7 and AXIOM Lab 1.7 (module AXIOM-07) · Mirrored in DCT_V1_Ch07_Lab.xlsx

This laboratory reproduces Worked Example 7.1, How Hard Should Meridian Steer Its Hiring?, with the book's declarations, and works the five steps of AXIOM Lab 1.7, Steering Meridian Through Time: check the clock, split the path, probe the disclosure, tune the hiring rule, certify with a health index. Every Meridian number below is the book's (Worked Example 7.1, Tables 7.4–7.5, Figures 7.1–7.3, Online Appendix 7.B); the final cell checks them. Gaps are in engineers and readings in index points, as in the book.

The declarations (Worked Example 7.1, Step 1)

The hiring loop. The digital program needs a larger bench of software engineers, and Meridian's bench is 100 engineers short of target. Each quarter, retraining and internal moves close 10 percent of any gap on their own, so 90 percent of the gap carries over, and 60 percent of approved external hires become productive engineers within the quarter. With dkd_k the gap (bench minus target) at the start of quarter kk and uku_k the approvals, dk+1=0.9 dk+0.6 ukd_{k+1} = 0.9\,d_k + 0.6\,u_k. Human resources proposes the rule uk=−γ dku_k = -\gamma\,d_k; the chief operating officer asks how large the gain γ\gamma should be.

The other models the lab loads. The stylized three-reading company of Equation 3.2 (workforce capability, technology platform and operational efficiency, all indices; yearly, with capability investment uu), today at (50,40,60)(50, 40, 60); the covenant model of Online Appendix 7.B.2 (liquidity, leverage, capability and technology, in quarterly deviations from plan); and the start-up's logistic law of Proposition 7.4, x˙=0.9 x(1−x/100)\dot x = 0.9\,x(1 - x/100) from x0=2x_0 = 2 (Online Appendix 7.B.4).

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

# Worked Example 7.1: the hiring gap d (bench minus target, engineers), quarterly
A_H, B_H, D0 = 0.9, 0.6, -100.0            # 90% of a gap carries over; 60% of approvals productive within the quarter
RULES = {"cautious": 0.5, "moderate": 1.0, "deadbeat": 1.5, "aggressive": 2.5, "overcorrecting": 3.5}

def gap_path(gamma, n, delay=False, d0=D0):
    # d_{k+1} = 0.9 d_k + 0.6 u_k under the rule u_k = -gamma d_k; with the delay, approvals act a quarter late
    # (d_{k+1} = 0.9 d_k + 0.6 u_{k-1}, nothing in the pipeline at the start)
    d, u_prev = [d0], 0.0
    for _ in range(n):
        u = -gamma * d[-1]
        d.append(A_H * d[-1] + B_H * (u_prev if delay else u))
        u_prev = u
    return np.array(d)

# Equation 3.2: the stylized three-reading company (capability, technology, efficiency), yearly
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])             # yearly capability investment u builds capability and the platform
X0 = np.array([50.0, 40.0, 60.0])          # today
U_HELD = 8.0                               # the held investment of Figure 7.1

# Online Appendix 7.B.2: four readings of Meridian in quarterly deviations from plan
READINGS = ("liquidity", "leverage", "capability", "technology")
A4 = np.array([[0.95, 0.00, 0.04, 0.00],
               [0.00, 0.90, 0.00, 0.00],
               [0.00, 0.00, 0.90, 0.05],
               [0.00, 0.00, 0.00, 0.92]])

# Proposition 7.4 and Online Appendix 7.B.4: the start-up's logistic law x' = r x (1 - x / kappa)
R_SU, KAPPA, X0_SU = 0.9, 100.0, 2.0

# Section 7.3: capability measured to within 5 points, needed within 15, sensitivity 0.5 a year
ERR0, TOL, L_SENS = 5.0, 15.0, 0.5

print(f"hiring loop: d' = {A_H} d + {B_H} u, starting {-D0:.0f} engineers short; gains tried: "
      + ", ".join(f"{k} {v}" for k, v in RULES.items()))
print(f"three-reading company: today {X0}, held investment {U_HELD:.0f} a year;"
      f" one year at u = 10 gives {A3 @ X0 + B3 * 10} (Section 3.4)")
print(f"covenant model: {len(READINGS)} readings ({', '.join(READINGS)}); the covenant package reports the first two")
hiring loop: d' = 0.9 d + 0.6 u, starting 100 engineers short; gains tried: cautious 0.5, moderate 1.0, deadbeat 1.5, aggressive 2.5, overcorrecting 3.5
three-reading company: today [50. 40. 60.], held investment 8 a year; one year at u = 10 gives [53.  42.  54.5] (Section 3.4)
covenant model: 4 readings (liquidity, leverage, capability, technology); the covenant package reports the first two

Panel 1 — Check the clock (Proposition 7.2; Theorem 7.1(ii); Online Appendix 7.B.1, 7.B.4)

AXIOM Lab 1.7, step 1. Even a perfect model sees only so far: an error ε0\varepsilon_0 in today's state can grow like eLte^{Lt} (Equation 7.3), so a forecast needed within a tolerance τ\tau holds for (1/L)ln⁡(τ/ε0)(1/L)\ln(\tau/\varepsilon_0): 2.2 years for Meridian's capability, and halving the measurement error adds 1.4 years. A linear law has exact continuous and quarterly descriptions (Equation 7.2): if the three-reading company's yearly law is the yearly sample of a continuous law with the investment held level, its quarterly law reproduces every year end exactly, while a simple quarterly step of the continuous law does not. A nonlinear law has no exact translation: the start-up's quarterly step compounds at 22.5 percent while small against about 25 percent for the law, and runs behind, 58.1 at year 5; the gap falls in proportion to the step, 2.1 with a monthly step and 0.5 with a weekly one. A coefficient that is zero or negative, as the deadbeat and overcorrecting hiring rules produce, is the sample of no continuous law (Proposition 7.2(iii)): such rules belong to decisions taken at review dates and held in between.

Python Code
# Theorem 7.1(ii) and Online Appendix 7.B.1: the forecastable horizon (1/L) ln(tolerance / error)
horizon = np.log(TOL / ERR0) / L_SENS
print(f"forecastable horizon (1/{L_SENS}) ln({TOL:.0f}/{ERR0:.0f}) = 2 ln 3 = {horizon:.2f} years;"
      f" halving the error adds {np.log(2) / L_SENS:.2f} years; dynamics twice as fast halve it to {horizon / 2:.2f}")

# Proposition 7.2(i): the yearly law (3.2) as the yearly sample of dx/dt = Ac x + Bc u, investment held within the year
I3 = np.eye(3)
Ac = sl.logm(A3).real                                   # e^Ac = A: the eigenvalues are positive, so Ac exists
Bc = Ac @ np.linalg.solve(A3 - I3, B3)                  # so that the year's input matrix is (int_0^1 e^(Ac s) ds) Bc = B
Aq = sl.expm(Ac / 4)                                    # Equation 7.2 with a quarter: A^(1/4)
Bq = (Aq - I3) @ np.linalg.solve(A3 - I3, B3)           # (int_0^(1/4) e^(Ac s) ds) Bc
yearly, quarterly, stepped = X0.copy(), X0.copy(), X0.copy()
for year in range(10):
    yearly = A3 @ yearly + B3 * U_HELD
    for q in range(4):
        quarterly = Aq @ quarterly + Bq * U_HELD
        stepped = stepped + 0.25 * (Ac @ stepped + Bc * U_HELD)  # a simple quarterly step of the continuous law
q_gap = float(abs(quarterly - yearly).max())
print(f"continuous law: rates {np.round(np.sort(np.linalg.eigvals(Ac).real)[::-1], 4)} a year (ln 0.95, ln 0.80);"
      f" quarterly law: four quarters equal one year to {abs(np.linalg.matrix_power(Aq, 4) - A3).max():.0e}")
print(f"after ten years at {U_HELD:.0f} a year: yearly law {np.round(yearly, 3)}, quarterly law {np.round(quarterly, 3)}"
      f" (largest gap {q_gap:.0e}),\n  simple quarterly steps {np.round(stepped, 3)}")

# Proposition 7.2(iii): a coefficient that is zero or negative is the sample of no continuous law
for name, g in RULES.items():
    c = round(A_H - B_H * g, 12)
    rate = f"= e^({np.log(c):.3f}): a continuous rate of {np.log(c):.3f} a quarter" if c > 0 else "is the sample of no continuous law"
    print(f"  {name:15s} gamma {g:3.1f}: closed-loop coefficient {c:5.2f} {rate}")

# Online Appendix 7.B.4: the start-up's law and its step-by-step approximations
def logistic(t):
    return KAPPA * X0_SU / (X0_SU + (KAPPA - X0_SU) * np.exp(-R_SU * t))

def euler_logistic(per_year, years):
    dt, x = 1.0 / per_year, [X0_SU]
    for _ in range(int(round(per_year * years))):
        x.append(x[-1] + dt * R_SU * x[-1] * (1 - x[-1] / KAPPA))
    return np.array(x)

t_infl = np.log((KAPPA - X0_SU) / X0_SU) / R_SU
eq, em, ew = euler_logistic(4, 10), euler_logistic(12, 10), euler_logistic(52, 10)
print(f"\nstart-up: doubles every {np.log(2) / R_SU:.2f} years while small; growth peaks at {KAPPA / 2:.0f} after {t_infl:.2f} years")
print(f"while small, a quarter multiplies it by e^0.225 = {np.exp(R_SU / 4):.4f} under the law (Equation 7.2),"
      f" by {1 + R_SU / 4:.3f} under the quarterly step")
print(" year     law   quarterly step   monthly   weekly   exponential plan 2e^(0.9t)")
for yr in (1, 2, 3, 4, 5, 6, 8, 10):
    print(f"{yr:5d} {logistic(yr):7.2f} {eq[4 * yr]:12.2f} {em[12 * yr]:12.2f} {ew[52 * yr]:8.2f} {X0_SU * np.exp(R_SU * yr):14.1f}")
gaps = {"quarterly": logistic(5) - eq[20], "monthly": logistic(5) - em[60], "weekly": logistic(5) - ew[260]}
print("gap to the law at year 5: " + ", ".join(f"{k} {v:.2f}" for k, v in gaps.items()) + ": in proportion to the step")
print(f"the exponential plan at the inflection date: {X0_SU * np.exp(R_SU * t_infl):.0f}; at year 6, "
      f"{X0_SU * np.exp(R_SU * 6) / KAPPA:.1f} times the entire market")

t = np.linspace(0, 10, 401); tq = np.arange(41) / 4
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.plot(t, logistic(t), color="#1F4E79", lw=2, label="the law x(t) = 100 / (1 + 49e^(−0.9t))")
ax.plot(tq, eq, "o", color="#E65100", ms=3, label=f"quarterly steps: {eq[20]:.1f} at year 5")
ax.plot(t, X0_SU * np.exp(R_SU * t), ":", color="#B71C1C", lw=1.6, label="exponential plan 2e^(0.9t)")
ax.axhline(KAPPA, color="#999999", lw=0.8)
ax.text(0.2, KAPPA + 2, "market wall 100", fontsize=8, color="#616161", va="bottom")
ax.plot([t_infl], [KAPPA / 2], "s", color="#616161", ms=5)
ax.annotate(f"inflection: 50 at {t_infl:.1f} years", xy=(t_infl, KAPPA / 2), xytext=(6.3, 44), fontsize=8, color="#616161",
            va="center", arrowprops=dict(arrowstyle="-", color="#616161", lw=0.6))
ax.set(xlabel="years", ylabel="start-up's users (index; market = 100)", xlim=(0, 10), ylim=(0, 125),
       title="Quarterly steps run behind the law; the exponential runs off (seed 26107)")
ax.legend(frameon=False, fontsize=8, loc="lower right"); plt.tight_layout(); plt.show()
forecastable horizon (1/0.5) ln(15/5) = 2 ln 3 = 2.20 years; halving the error adds 1.39 years; dynamics twice as fast halve it to 1.10
continuous law: rates [-0.0513 -0.2231 -0.2231] a year (ln 0.95, ln 0.80); quarterly law: four quarters equal one year to 3e-16
after ten years at 8 a year: yearly law [63.971 52.185 41.078], quarterly law [63.971 52.185 41.078] (largest gap 9e-14),
  simple quarterly steps [64.041 52.242 40.898]
  cautious        gamma 0.5: closed-loop coefficient  0.60 = e^(-0.511): a continuous rate of -0.511 a quarter
  moderate        gamma 1.0: closed-loop coefficient  0.30 = e^(-1.204): a continuous rate of -1.204 a quarter
  deadbeat        gamma 1.5: closed-loop coefficient  0.00 is the sample of no continuous law
  aggressive      gamma 2.5: closed-loop coefficient -0.60 is the sample of no continuous law
  overcorrecting  gamma 3.5: closed-loop coefficient -1.20 is the sample of no continuous law

start-up: doubles every 0.77 years while small; growth peaks at 50 after 4.32 years
while small, a quarter multiplies it by e^0.225 = 1.2523 under the law (Equation 7.2), by 1.225 under the quarterly step
 year     law   quarterly step   monthly   weekly   exponential plan 2e^(0.9t)
    1    4.78         4.41         4.64     4.75            4.9
    2   10.99         9.50        10.43    10.86           12.1
    3   23.29        19.46        21.88    22.96           29.8
    4   42.76        36.25        40.48    42.22           73.2
    5   64.75        58.13        62.61    64.27          180.0
    6   81.88        78.01        80.70    81.62          442.8
    8   96.47        96.25        96.40    96.45         2678.9
   10   99.40        99.49        99.43    99.41        16206.2
gap to the law at year 5: quarterly 6.62, monthly 2.14, weekly 0.49: in proportion to the step
the exponential plan at the inflection date: 98; at year 6, 4.4 times the entire market
Quarterly steps run behind the law; the exponential runs off (seed 26107)

Panel 2 — Split the path (Theorem 7.2(i); Figure 7.1)

AXIOM Lab 1.7, step 2, first part. In a linear company the path is exactly the free response, where momentum alone would carry the company, plus the forced response, what the program adds starting from zero (Equation 7.4). Under a held investment of 8 a year, momentum alone lets the technology index erode from 40 to 27 over ten years, the program adds 25, and the company ends at 52. The program's contribution keeps growing while momentum fades, and the path approaches the steady state of the policy map, 72.

Python Code
def split(u=U_HELD, years=20, x0=X0):
    # Equation 7.4: free response A^k x0 and forced response sum_j A^(k-1-j) B u
    free, forced = [x0.copy()], [np.zeros(3)]
    for _ in range(years):
        free.append(A3 @ free[-1]); forced.append(A3 @ forced[-1] + B3 * u)
    return np.array(free), np.array(forced)

free, forced = split()
path = [X0.copy()]
for _ in range(20):
    path.append(A3 @ path[-1] + B3 * U_HELD)          # the company simply run forward
path = np.array(path)
print("technology platform under a held investment of 8 a year (Figure 7.1)")
print(" year   momentum alone   program effect    path")
for yr in (0, 1, 2, 5, 10, 15, 20):
    print(f"{yr:5d} {free[yr, 1]:14.1f} {forced[yr, 1]:16.1f} {path[yr, 1]:8.1f}")
print(f"the split is exact: largest |path - (free + forced)| over 20 years and three readings = {abs(path - free - forced).max():.1e}")
k10 = np.linalg.matrix_power(A3, 10) @ X0 + sum(np.linalg.matrix_power(A3, 9 - j) @ B3 * U_HELD for j in range(10))
print(f"Equation 7.4 at year 10 (capability, technology, efficiency): {np.round(k10, 2)}")
cross = int(np.argmax(forced[:, 1] > free[:, 1]))
print(f"the program effect overtakes momentum in year {cross}; at year 20 momentum leaves {free[20, 1]:.1f}, the program adds"
      f" {forced[20, 1]:.1f}")

yrs = np.arange(21); ss_tech = (U_HELD * np.linalg.solve(np.eye(3) - A3, B3))[1]
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.plot(yrs, path[:, 1], "o-", color="#1F4E79", lw=2, ms=3, label=f"path = momentum + program: {path[10, 1]:.0f} at year 10")
ax.plot(yrs, free[:, 1], "--", color="#616161", lw=1.5, label=f"momentum alone (free response): {free[10, 1]:.0f} at year 10")
ax.plot(yrs, forced[:, 1], "--", color="#E65100", lw=1.5, label=f"program effect (forced response): {forced[10, 1]:.0f} at year 10")
ax.axhline(ss_tech, color="#999999", lw=0.9, ls=":")
ax.text(20, ss_tech + 1.2, f"steady state under the held investment: {ss_tech:.0f}", ha="right", va="bottom", fontsize=8, color="#616161")
ax.set(xlabel="years", ylabel="technology platform (index)", xlim=(0, 20), ylim=(0, 82), xticks=range(0, 21, 2),
       title="Momentum fades while the program builds (seed 26107)")
ax.legend(frameon=False, fontsize=8, loc="upper left"); plt.tight_layout(); plt.show()
technology platform under a held investment of 8 a year (Figure 7.1)
 year   momentum alone   program effect    path
    0           40.0              0.0     40.0
    1           39.0              2.4     41.4
    2           37.9              4.9     42.8
    5           33.9             12.7     46.6
   10           27.2             25.0     52.2
   15           21.4             35.2     56.6
   20           16.7             43.4     60.1
the split is exact: largest |path - (free + forced)| over 20 years and three readings = 2.1e-14
Equation 7.4 at year 10 (capability, technology, efficiency): [63.97 52.19 41.08]
the program effect overtakes momentum in year 11; at year 20 momentum leaves 16.7, the program adds 43.4
Momentum fades while the program builds (seed 26107)

Panel 3 — Move the steady state (Theorem 7.3(ii); Theorem 7.4(i); Online Appendix 7.B.3)

AXIOM Lab 1.7, step 2, second part. One is not an eigenvalue of A\mathbf{A}, so every held investment has exactly one steady state, x∗=(I−A)−1B uˉ\mathbf{x}^{\ast} = (\mathbf{I} - \mathbf{A})^{-1}\mathbf{B}\,\bar u (Equation 7.6): in the near-linear regime, steady states are chosen, not found. Each unit of yearly investment held forever adds 10.5 points of capability, 9 of technology and 7.1 of efficiency, so 8 a year settles the company at (84, 72, 57), far above today on capability and technology and below it on efficiency, which receives no investment of its own. The slowest eigenvalue, 0.95, leaves half of any shock in place after 13.5 years. The readings are indices, so the map applies only while the steady state stays inside them: watch capability as the investment rises.

Python Code
per_unit = np.linalg.solve(np.eye(3) - A3, B3)          # (I - A)^(-1) B: the policy map (7.6) per unit held
eig = np.sort(np.linalg.eigvals(A3).real)[::-1]
half = np.log(0.5) / np.log(eig[0])
print(f"eigenvalues of A: {np.round(eig, 4)}; 1 is not among them, so each held investment has exactly one steady state")
print(f"policy map per unit held: capability {per_unit[0]:.3f}, technology {per_unit[1]:.3f}, efficiency {per_unit[2]:.3f}")
print("held investment   steady state (capability, technology, efficiency)")
for u in (0.0, 4.0, 8.0, 9.0, 10.0):
    print(f"{u:10.1f}          " + ", ".join(f"{v:6.2f}" for v in u * per_unit))
ss8 = U_HELD * per_unit
print(f"at 8 a year the company settles at {np.round(ss8, 2)} against {X0} today")
print(f"slowest eigenvalue {eig[0]:.2f}: half of any shock remains after ln 0.5 / ln 0.95 = {half:.1f} years;"
      f" a tenth after {np.log(0.1) / np.log(eig[0]):.0f} years")
long_run = [X0.copy()]
for _ in range(150):
    long_run.append(A3 @ long_run[-1] + B3 * U_HELD)
dist = np.abs(np.array(long_run) - ss8).max(axis=1)      # the largest reading's distance from the steady state
near = {band: int(np.nonzero(dist > band)[0][-1]) + 1 for band in (10, 1)}
print(f"from today at 8 a year the path is still {dist[10]:.1f} points from its steady state after 10 years and {dist[20]:.1f}"
      f" after 20; it stays within 10 points from year {near[10]}, within 1 point from year {near[1]}")
u_wall = 100 / per_unit[0]
c10, wall_year = X0.copy(), 0
while c10[0] <= 100 and wall_year < 500:
    c10, wall_year = A3 @ c10 + B3 * 10.0, wall_year + 1
print(f"capability's steady state reaches the top of its index, 100, at a held investment of {u_wall:.2f} a year: held at 10,"
      f" the linear law carries capability past 100 in year {wall_year}, where the model no longer describes an index")
eigenvalues of A: [0.95 0.8  0.8 ]; 1 is not among them, so each held investment has exactly one steady state
policy map per unit held: capability 10.500, technology 9.000, efficiency 7.125
held investment   steady state (capability, technology, efficiency)
       0.0            0.00,   0.00,   0.00
       4.0           42.00,  36.00,  28.50
       8.0           84.00,  72.00,  57.00
       9.0           94.50,  81.00,  64.13
      10.0          105.00,  90.00,  71.25
at 8 a year the company settles at [84. 72. 57.] against [50. 40. 60.] today
slowest eigenvalue 0.95: half of any shock remains after ln 0.5 / ln 0.95 = 13.5 years; a tenth after 45 years
from today at 8 a year the path is still 20.0 points from its steady state after 10 years and 12.0 after 20; it stays within 10 points from year 24, within 1 point from year 69
capability's steady state reaches the top of its index, 100, at a held investment of 9.52 a year: held at 10, the linear law carries capability past 100 in year 47, where the model no longer describes an index

Panel 4 — Probe the disclosure (Theorem 7.2(iii); Online Appendix 7.B.2)

AXIOM Lab 1.7, step 3. An outsider who knows the inputs can reconstruct the state from nn periods of reports exactly when the observability matrix (Equation 7.5) has rank nn; directions in its null space stay invisible however long the record. In the covenant model the package reports liquidity and leverage. If technology feeds capability and capability feeds liquidity, the rank is 4, but technology reaches liquidity only after two quarters, with weight 0.002: if every reported number carries an independent error of one unit, the least-squares reconstruction leaves technology uncertain by about ±480 points after four quarters, ±37 after twelve, ±14 after twenty and ±6 after forty. If technology feeds nothing, the rank is 3 and no record of certificates reveals it. Choose the package row by row and watch the rank and the invisible readings.

Python Code
A4_none = A4.copy(); A4_none[2, 3] = 0.0               # case 2: capability no longer responds to technology

def obs_matrix(A, C, N=None):
    # Equation 7.5: C, CA, ..., CA^(N-1) stacked (N = n by default)
    N = A.shape[0] if N is None else N
    return np.vstack([C @ np.linalg.matrix_power(A, k) for k in range(N)])

def package(names):
    return np.array([[1.0 if r == nm else 0.0 for r in READINGS] for nm in names])

def probe(A, names):
    O = obs_matrix(A, package(names))
    rank = int(np.linalg.matrix_rank(O))
    unseen = [r for j, r in enumerate(READINGS) if not O[:, j].any()]
    assert len(unseen) == len(READINGS) - rank        # here the null space is spanned by whole readings
    return rank, unseen

print("liquidity's row of C A^k: weights on (liquidity, leverage, capability, technology)")
for k in range(4):
    print(f"  k = {k}: {np.round(np.linalg.matrix_power(A4, k)[0], 4)}")
w_tech = {k: np.linalg.matrix_power(A4, k)[0, 3] for k in (2, 4, 12)}
print("a 10-point technology deviation moves reported liquidity by "
      + ", ".join(f"{10 * v:.2f} after {k} quarters" for k, v in w_tech.items()))

PACKAGES = [("covenant package: liquidity, leverage", ("liquidity", "leverage")),
            ("leverage only", ("leverage",)),
            ("liquidity only", ("liquidity",)),
            ("covenant package + a capability KPI", ("liquidity", "leverage", "capability")),
            ("covenant package + a technology reading", ("liquidity", "leverage", "technology"))]
print("\nthe disclosure, row by row: the rank of Equation 7.5 and the readings no record reveals")
ranks = {}
for name, rows in PACKAGES:
    print(name)
    for label, A in (("technology feeds capability:", A4), ("technology feeds nothing:", A4_none)):
        r, unseen = probe(A, rows)
        ranks[(name, A is A4)] = r
        print(f"    {label:29s} rank {r}" + (f", invisible: {', '.join(unseen)}" if unseen else ", every reading visible"))

def se(A, names, N):
    # one standard error of the least-squares reconstruction, one unit of error on every reported number
    O = obs_matrix(A, package(names), N)
    return np.sqrt(np.diag(np.linalg.inv(O.T @ O)))

SE = {N: se(A4, ("liquidity", "leverage"), N) for N in (4, 12, 20, 40)}
SE_T = {N: se(A4, ("liquidity", "leverage", "technology"), N) for N in (4, 12, 20, 40)}
print("\nquarters of certificates   uncertainty on technology (one s.e.)   with a technology reading added")
for N in SE:
    print(f"{N:14d} {SE[N][3]:30.1f} {SE_T[N][3]:30.2f}")
print("technology is visible in principle and invisible in practice for years; a reading of it settles the question at once")
liquidity's row of C A^k: weights on (liquidity, leverage, capability, technology)
  k = 0: [1. 0. 0. 0.]
  k = 1: [0.95 0.   0.04 0.  ]
  k = 2: [0.9025 0.     0.074  0.002 ]
  k = 3: [0.8574 0.     0.1027 0.0055]
a 10-point technology deviation moves reported liquidity by 0.02 after 2 quarters, 0.10 after 4 quarters, 0.60 after 12 quarters

the disclosure, row by row: the rank of Equation 7.5 and the readings no record reveals
covenant package: liquidity, leverage
    technology feeds capability:  rank 4, every reading visible
    technology feeds nothing:     rank 3, invisible: technology
leverage only
    technology feeds capability:  rank 1, invisible: liquidity, capability, technology
    technology feeds nothing:     rank 1, invisible: liquidity, capability, technology
liquidity only
    technology feeds capability:  rank 3, invisible: leverage
    technology feeds nothing:     rank 2, invisible: leverage, technology
covenant package + a capability KPI
    technology feeds capability:  rank 4, every reading visible
    technology feeds nothing:     rank 3, invisible: technology
covenant package + a technology reading
    technology feeds capability:  rank 4, every reading visible
    technology feeds nothing:     rank 4, every reading visible

quarters of certificates   uncertainty on technology (one s.e.)   with a technology reading added
             4                          483.2                           0.56
            12                           37.0                           0.42
            20                           14.3                           0.40
            40                            5.8                           0.39
technology is visible in principle and invisible in practice for years; a reading of it settles the question at once

Panel 5 — Write the loop and read the chart (Worked Example 7.1, Steps 1–2; Theorem 7.5(ii); Tables 7.4–7.5)

AXIOM Lab 1.7, step 4, first part. The rule gives the closed loop dk+1=(0.9−0.6γ) dkd_{k+1} = (0.9 - 0.6\gamma)\,d_k: the whole design question is the coefficient 0.9−0.6γ0.9 - 0.6\gamma. By Table 7.4, with a=0.9a = 0.9 and b=0.6b = 0.6, the rule is stable for gains below 1.9/0.6≈1.9/0.6 \approx 3.17; the deadbeat gain 0.9/0.6=0.9/0.6 = 1.5 closes the gap in a single quarter; gains between 1.5 and 3.17 overshoot and swing back with shrinking swings; and gains above 3.17 overcorrect. A gain of 3.5 turns a shortfall of 100 into a surplus of 120, then a shortfall of 144: a hiring spree, a freeze, a bigger spree.

Python Code
lo, dead, hi = (A_H - 1) / B_H, A_H / B_H, (A_H + 1) / B_H

def regime(c):
    # Table 7.4, by the closed-loop coefficient a - b gamma
    if c >= 1: return "divergence persists: undercorrection"
    if c > 0: return "steady convergence: calibrated steering"
    if c == 0: return "one step: deadbeat"
    if c > -1: return "damped swings: aggressive but stable"
    return "growing swings: overcorrection"

print(f"stable gains {lo:.2f} < gamma < {hi:.2f}; deadbeat gamma = {dead:.2f}")
print(f"{'rule':16s} gain  coefficient  regime (Table 7.4)")
for name, g in RULES.items():
    c = round(A_H - B_H * g, 12)
    print(f"{name:16s} {g:4.1f} {c:10.2f}   {regime(c)}")
nodelay = {g: gap_path(g, 12) for g in RULES.values()}
print("\nTable 7.5, hires take effect within the quarter (engineers, bench minus target)")
print(f"{'quarter':28s}" + "".join(f"{k:8d}" for k in range(9)))
for name in ("cautious", "deadbeat", "overcorrecting"):
    g = RULES[name]
    print(f"{name + ', gamma = ' + str(g):28s}" + "".join(f"{v + 0.0:8.1f}" for v in np.round(nodelay[g][:9], 1)))
oc = nodelay[3.5]
print(f"gain 3.5: a shortfall of {-oc[0]:.0f} becomes a surplus of {oc[1]:.0f}, then a shortfall of {-oc[2]:.0f}, a surplus of {oc[3]:.1f}")
stable gains -0.17 < gamma < 3.17; deadbeat gamma = 1.50
rule             gain  coefficient  regime (Table 7.4)
cautious          0.5       0.60   steady convergence: calibrated steering
moderate          1.0       0.30   steady convergence: calibrated steering
deadbeat          1.5       0.00   one step: deadbeat
aggressive        2.5      -0.60   damped swings: aggressive but stable
overcorrecting    3.5      -1.20   growing swings: overcorrection

Table 7.5, hires take effect within the quarter (engineers, bench minus target)
quarter                            0       1       2       3       4       5       6       7       8
cautious, gamma = 0.5         -100.0   -60.0   -36.0   -21.6   -13.0    -7.8    -4.7    -2.8    -1.7
deadbeat, gamma = 1.5         -100.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0     0.0
overcorrecting, gamma = 3.5   -100.0   120.0  -144.0   172.8  -207.4   248.8  -298.6   358.3  -430.0
gain 3.5: a shortfall of 100 becomes a surplus of 120, then a shortfall of 144, a surplus of 172.8

Panel 6 — Allow for the delay; re-test the deadbeat rule (Worked Example 7.1, Steps 3–4; Online Appendix 7.B.5–7.B.7; Table 7.5; Figure 7.3)

AXIOM Lab 1.7, step 4, second part. In practice approvals take a quarter to become engineers: dk+1=0.9 dk+0.6 uk−1d_{k+1} = 0.9\,d_k + 0.6\,u_{k-1}. The closed loop now has two eigenvalues, the roots of z2−0.9z+0.6γ=0z^2 - 0.9z + 0.6\gamma = 0, of modulus 0.6γ\sqrt{0.6\gamma} when they are complex, and the safe range shrinks from γ<3.17\gamma < 3.17 to γ<\gamma < 1.67. The deadbeat rule is barely stable, modulus 0.95: the bench overshoots to 89 engineers too many in quarter 3, swings to 79 too few in quarter 6, repeats the cycle about every 5.8 quarters, and is still more than 10 engineers off target a decade later. The cautious rule γ=0.5\gamma = 0.5, the slowest without the delay, is now the fastest: within 10 engineers by quarter 4. The gain with the smallest modulus, 0.45 at γ≈\gamma \approx 0.34, is slower from Meridian's starting gap: within 5 engineers by quarter 7, against quarter 4 for γ=0.5\gamma = 0.5.

Python Code
def delay_roots(g):
    # the roots of z^2 - 0.9 z + 0.6 gamma = 0, in closed form (a double root when the discriminant vanishes)
    disc = A_H ** 2 - 4 * B_H * g
    s = np.sqrt(complex(0.0 if abs(disc) < 1e-12 else disc))
    return np.array([(A_H + s) / 2, (A_H - s) / 2])

def settles(path, band):
    # the first quarter from which the gap stays within the band for good
    out = np.nonzero(np.abs(path) > band + 1e-12)[0]
    return int(out[-1]) + 1 if len(out) else 0

g_merge = A_H ** 2 / (4 * B_H)                         # the two roots merge: the smallest modulus, a / 2
print(f"with the delay the loop is stable for gamma < 1/0.6 = {1 / B_H:.2f}, against {hi:.2f} without: "
      f"the safe range shrinks to {(1 / B_H) / hi:.0%} of itself")
print(f"{'rule':24s} roots of z^2 - 0.9z + 0.6 gamma   modulus   cycle (quarters)   halving   within 10   within 5")
delayed = {}
for name, g in (("cautious", 0.5), ("moderate", 1.0), ("deadbeat rule", 1.5), ("beyond the limit", 1.8), ("merged roots", g_merge)):
    z = delay_roots(g); mod = float(abs(z).max())
    p = gap_path(g, 80, delay=True); delayed[g] = p
    cyc = f"{2 * np.pi / abs(np.angle(z[0])):10.1f}" if abs(z[0].imag) > 1e-6 else "      none"
    hv = f"{np.log(2) / np.log(1 / mod):7.1f}" if mod < 1 else "  grows"
    w10, w5 = (f"{settles(p, 10):5d}", f"{settles(p, 5):5d}") if mod < 1 else ("never", "never")
    zs = f"{z[0].real:.3f} ± {abs(z[0].imag):.3f}i" if abs(z[0].imag) > 1e-6 else f"{z[0].real:.3f} (double)"
    print(f"{name + ', ' + format(g, '.4g'):24s} {zs:34s} {mod:7.3f} {cyc:16s} {hv:9s} {w10:>9s} {w5:>9s}")
dp = delayed[1.5]
zd = delay_roots(1.5)
peak_q = int(dp.argmax()); trough_q = peak_q + int(dp[peak_q:peak_q + 6].argmin())     # the swing after the overshoot
print(f"deadbeat rule: modulus sqrt(0.9) = {abs(zd[0]):.3f}, cos(theta) = 0.9 / (2 sqrt(0.9)) = {zd[0].real / abs(zd[0]):.2f}")
print(f"  overshoots to {dp[peak_q]:.1f} in quarter {peak_q}, swings back to {dp[trough_q]:.1f} in quarter {trough_q};"
      f" largest gap in quarters 40-45, a decade on: {abs(dp[40:46]).max():.1f} (quarter {40 + int(abs(dp[40:46]).argmax())})")
print(f"merged roots at gamma = 0.81/2.4 = {g_merge:.4f}: modulus {abs(delay_roots(g_merge)).max():.2f}, the smallest attainable")

print("\nTable 7.5, hires take effect one quarter late (engineers, bench minus target)")
print(f"{'quarter':28s}" + "".join(f"{k:8d}" for k in range(9)))
for name, g in (("cautious, gamma = 0.5", 0.5), ("deadbeat rule, gamma = 1.5", 1.5)):
    print(f"{name:28s}" + "".join(f"{v + 0.0:8.1f}" for v in np.round(delayed[g][:9], 1)))

q = np.arange(13)
STYLE = {0.5: ("#1F4E79", "-"), 1.0: ("#999999", "--"), 1.5: ("#E65100", "-"), 2.5: ("#616161", "--"), 3.5: ("#B71C1C", ":")}
fig, (axl, axr) = plt.subplots(1, 2, figsize=(7.6, 3.6), sharex=True)
for name in ("cautious", "deadbeat", "aggressive", "overcorrecting"):
    g = RULES[name]; col, ls = STYLE[g]; n = 4 if g == 3.5 else 12
    axl.plot(np.arange(n + 1), nodelay[g][:n + 1], ls, color=col, marker="o", ms=2.5, lw=1.5, label=f"{name}, γ = {g}")
axl.annotate("and growing", xy=(4.6, -232), xytext=(4.25, -207), fontsize=7, color="#B71C1C", va="center",
             arrowprops=dict(arrowstyle="-|>", color="#B71C1C", lw=0.8, mutation_scale=6))
axl.set(title="hires within the quarter", ylim=(-240, 240))
for name, g in (("cautious", 0.5), ("moderate", 1.0), ("deadbeat rule", 1.5)):
    col, ls = STYLE[g]
    axr.plot(q, delayed[g][:13], ls, color=col, marker="o", ms=2.5, lw=1.5, label=f"{name}, γ = {g}")
axr.set(title="hires a quarter late", ylim=(-140, 120))
for ax, where in ((axl, "upper right"), (axr, "lower right")):
    ax.axhline(0, color="#999999", lw=0.7); ax.set_xlabel("quarters"); ax.set_xticks(range(0, 13, 2))
    ax.legend(frameon=False, fontsize=7, loc=where); ax.title.set_fontsize(9)
axl.set_ylabel("gap to target (engineers)")
fig.suptitle("The deadbeat rule cycles for years once hires arrive late (seed 26107)", fontsize=11)
plt.tight_layout(); plt.show()
with the delay the loop is stable for gamma < 1/0.6 = 1.67, against 3.17 without: the safe range shrinks to 53% of itself
rule                     roots of z^2 - 0.9z + 0.6 gamma   modulus   cycle (quarters)   halving   within 10   within 5
cautious, 0.5            0.450 ± 0.312i                       0.548       10.4           1.2           4         4
moderate, 1              0.450 ± 0.630i                       0.775        6.6           2.7           9        12
deadbeat rule, 1.5       0.450 ± 0.835i                       0.949        5.8          13.2          45        57
beyond the limit, 1.8    0.450 ± 0.937i                       1.039        5.6         grows       never     never
merged roots, 0.3375     0.450 (double)                       0.450       none           0.9           6         7
deadbeat rule: modulus sqrt(0.9) = 0.949, cos(theta) = 0.9 / (2 sqrt(0.9)) = 0.47
  overshoots to 89.1 in quarter 3, swings back to -78.7 in quarter 6; largest gap in quarters 40-45, a decade on: 12.4 (quarter 41)
merged roots at gamma = 0.81/2.4 = 0.3375: modulus 0.45, the smallest attainable

Table 7.5, hires take effect one quarter late (engineers, bench minus target)
quarter                            0       1       2       3       4       5       6       7       8
cautious, gamma = 0.5         -100.0   -90.0   -51.0   -18.9    -1.7     4.1     4.2     2.6     1.0
deadbeat rule, gamma = 1.5    -100.0   -90.0     9.0    89.1    72.1   -15.3   -78.7   -57.0    19.5
The deadbeat rule cycles for years once hires arrive late (seed 26107)

Panel 7 — Sweep the gain bench, then tune the tuner (Theorem 7.5(i); Figure 7.2; Online Appendix 7.B.8)

AXIOM Lab 1.7, step 4, the sweep: run the gain through every regime of Table 7.4, without the delay and with it, and read off the eigenvalues that Figure 7.2 places against the unit circle. Then the second loop. A committee that retunes the gain at each review in proportion to the evidence, γj+1=γj+η (dj+1/dj)\gamma_{j+1} = \gamma_j + \eta\,(d_{j+1}/d_j), runs a scalar feedback loop of its own, γj+1−1.5=(1−0.6η)(γj−1.5)\gamma_{j+1} - 1.5 = (1 - 0.6\eta)(\gamma_j - 1.5): it converges steadily on the deadbeat gain for η<1.67\eta < 1.67, with damped swings up to η=3.33\eta = 3.33, and with growing swings beyond. At η=3.5\eta = 3.5, starting from the cautious gain, it sets 2.6, 0.29, 2.83, 0.04, 3.11 and then −0.27, outside the inner loop's stable range.

Python Code
def delay_regime(g):
    z = delay_roots(g); mod = float(abs(z).max()); cplx = abs(z[0].imag) > 1e-6
    if abs(mod - 1) < 1e-9: return mod, "on the circle: cycles that neither die out nor grow"
    if mod > 1: return mod, "cycles that grow" if cplx else "diverges"
    return mod, "damped cycles" if cplx else "settles without cycling"

print(f"{'gain':>7s} {'coefficient':>12s}  {'no delay (Table 7.4)':40s} {'modulus':>8s}  with the delay")
SWEEP = (-0.25, 0.0, 0.25, g_merge, 0.5, 0.75, 1.0, 1.25, 1.5, 1 / B_H, 1.8, 2.0, 2.5, 3.0, hi, 3.5)
sweep = []
for g in SWEEP:
    c = round(A_H - B_H * g, 12); mod, reg = delay_regime(g)
    sweep.append((g, c, regime(c), mod, reg))
    print(f"{g:7.3f} {c:12.3f}  {regime(c):40s} {mod:8.3f}  {reg}")

print("\nFigure 7.2's points (eigenvalues; the unit circle separates shocks that die out from shocks that grow)")
print(f"  three-reading company: {', '.join(f'{v:.2f}' for v in eig)}")
for g in (0.5, 1.5, 2.5, 3.5):
    print(f"  no delay, gamma {g}: {A_H - B_H * g + 0.0:.1f}")
for g in (0.5, 1.5, 1.8):
    z = delay_roots(g)
    print(f"  delay, gamma {g}: {z[0].real:.2f} ± {abs(z[0].imag):.3f}i, modulus {abs(z[0]):.3f} ({'inside' if abs(z[0]) < 1 else 'outside'})")

# Online Appendix 7.B.8: the committee that retunes its rule
ETA = 3.5
tuned = [0.5]
for j in range(6):
    tuned.append(tuned[-1] + ETA * (A_H - B_H * tuned[-1]))     # carry-over ratio d_{j+1}/d_j = 0.9 - 0.6 gamma_j
leaves = next(j for j, g in enumerate(tuned) if not lo < g < hi)
print(f"\nouter loop: gamma - 1.5 multiplies by 1 - 0.6 eta = {1 - B_H * ETA:.2f} at each review; steady for eta < {1 / B_H:.2f},"
      f" damped swings for eta < {2 / B_H:.2f}")
print(f"eta = {ETA}, from 0.5: " + ", ".join(f"{g:.2f}" for g in tuned[1:]) + f"; review {leaves} leaves ({lo:.2f}, {hi:.2f})")
   gain  coefficient  no delay (Table 7.4)                      modulus  with the delay
 -0.250        1.050  divergence persists: undercorrection        1.044  diverges
  0.000        0.900  steady convergence: calibrated steering     0.900  settles without cycling
  0.250        0.750  steady convergence: calibrated steering     0.679  settles without cycling
  0.338        0.698  steady convergence: calibrated steering     0.450  settles without cycling
  0.500        0.600  steady convergence: calibrated steering     0.548  damped cycles
  0.750        0.450  steady convergence: calibrated steering     0.671  damped cycles
  1.000        0.300  steady convergence: calibrated steering     0.775  damped cycles
  1.250        0.150  steady convergence: calibrated steering     0.866  damped cycles
  1.500        0.000  one step: deadbeat                          0.949  damped cycles
  1.667       -0.100  damped swings: aggressive but stable        1.000  on the circle: cycles that neither die out nor grow
  1.800       -0.180  damped swings: aggressive but stable        1.039  cycles that grow
  2.000       -0.300  damped swings: aggressive but stable        1.095  cycles that grow
  2.500       -0.600  damped swings: aggressive but stable        1.225  cycles that grow
  3.000       -0.900  damped swings: aggressive but stable        1.342  cycles that grow
  3.167       -1.000  growing swings: overcorrection              1.378  cycles that grow
  3.500       -1.200  growing swings: overcorrection              1.449  cycles that grow

Figure 7.2's points (eigenvalues; the unit circle separates shocks that die out from shocks that grow)
  three-reading company: 0.95, 0.80, 0.80
  no delay, gamma 0.5: 0.6
  no delay, gamma 1.5: 0.0
  no delay, gamma 2.5: -0.6
  no delay, gamma 3.5: -1.2
  delay, gamma 0.5: 0.45 ± 0.312i, modulus 0.548 (inside)
  delay, gamma 1.5: 0.45 ± 0.835i, modulus 0.949 (inside)
  delay, gamma 1.8: 0.45 ± 0.937i, modulus 1.039 (outside)

outer loop: gamma - 1.5 multiplies by 1 - 0.6 eta = -1.10 at each review; steady for eta < 1.67, damped swings for eta < 3.33
eta = 3.5, from 0.5: 2.60, 0.29, 2.83, 0.04, 3.11, -0.27; review 6 leaves (-0.17, 3.17)

Panel 8 — Certify with a health index (Theorem 7.4(iii); Remark 7.1)

AXIOM Lab 1.7, step 5. A health index that is zero at the target, positive elsewhere, and falls every period under the company's own dynamics certifies stability, with no eigenvalues needed. For a stable linear loop one always exists: with P=∑k≥0(A⊤)kQAk\mathbf{P} = \sum_{k \ge 0}(\mathbf{A}^{\top})^k\mathbf{Q}\mathbf{A}^k, which solves the Lyapunov equation A⊤PA−P=−Q\mathbf{A}^{\top}\mathbf{P}\mathbf{A} - \mathbf{P} = -\mathbf{Q}, the index V(x)=x⊤PxV(\mathbf{x}) = \mathbf{x}^{\top}\mathbf{P}\mathbf{x} falls by x⊤Qx\mathbf{x}^{\top}\mathbf{Q}\mathbf{x} every period (Remark 7.1). A scorecard of one's own choosing need not. Under the deadbeat rule with the delay the state is this quarter's gap and last quarter's, and the plain sum of their squares rises in many quarters although the loop is stable. The paths below are the book's and 1,000 starting positions drawn with the lab's seed 26107 (new draws: the book prints no numbers for this step).

Python Code
def lyapunov(A, Q):
    # Remark 7.1: P = sum_k (A^T)^k Q A^k, summed until the terms vanish
    P, T = np.zeros_like(Q), Q.copy()
    for _ in range(5000):
        P = P + T; T = A.T @ T @ A
        if abs(T).max() < 1e-17 * abs(P).max():
            return P
    raise ValueError("the series does not converge: the loop is not stable")

def rises(index, path):
    v = np.array([index(x) for x in path]); return int((np.diff(v) > 1e-12).sum()), v

P3 = lyapunov(A3, np.eye(3))
print("three-reading company, Q = I: P =\n", np.round(P3, 4))
print(f"  Lyapunov equation residual {abs(A3.T @ P3 @ A3 - P3 + np.eye(3)).max():.1e}; eigenvalues of P {np.round(np.linalg.eigvalsh(P3), 3)}")
dev = path - ss8                                         # deviations from the steady state at 8 a year, today onward
r3_sum, r3_V = rises(lambda e: e @ e, dev)[0], rises(lambda e: e @ P3 @ e, dev)[0]
print(f"  along today's path at 8 a year: the sum of squared deviations rises in {r3_sum} of 20 years, V in {r3_V};"
      f" here even the plain sum works (the largest stretch of A is {np.linalg.norm(A3, 2):.2f} < 1)")

M15 = np.array([[A_H, -B_H * 1.5], [1.0, 0.0]])           # (d_k, d_{k-1}) under the deadbeat rule with the delay
PM = lyapunov(M15, np.eye(2))
print("\ndeadbeat rule with the delay, state (gap now, gap a quarter ago), Q = I: P =\n", np.round(PM, 4))
print(f"  residual {abs(M15.T @ PM @ M15 - PM + np.eye(2)).max():.1e}; eigenvalues of P {np.round(np.linalg.eigvalsh(PM), 3)}:"
      f" positive, so V is a health index; the largest stretch of the loop is {np.linalg.norm(M15, 2):.2f}")
X = [np.array([D0, 0.0])]                                # the book's start: 100 short, nothing in the pipeline
for _ in range(40):
    X.append(M15 @ X[-1])
X = np.array(X)
n_score, score = rises(lambda x: x @ x, X)
n_V, V = rises(lambda x: x @ PM @ x, X)
print(f"  the book's path, quarters 1-40: the scorecard d_k^2 + d_(k-1)^2 rises in {n_score} quarters, V in {n_V}")
print(f"  first quarters, scorecard: {np.round(score[:5]).astype(int)}; V: {np.round(V[:5]).astype(int)}")

rng = np.random.default_rng(SEED)
starts = rng.uniform(-150, 150, size=(1000, 2))          # gap now and a quarter ago, engineers (lab's seed)
up_s = up_V = steps = 0
for x in starts:
    for _ in range(40):
        y = M15 @ x
        up_s += int(y @ y > x @ x); up_V += int(y @ PM @ y > x @ PM @ x); steps += 1; x = y
print(f"  1,000 simulated starts x 40 quarters (seed {SEED}): the scorecard rises in {up_s:,} of {steps:,} quarters"
      f" ({up_s / steps:.0%}), V in {up_V}")

M18 = np.array([[A_H, -B_H * 1.8], [1.0, 0.0]])
P18 = sl.solve_discrete_lyapunov(M18.T, np.eye(2))
print(f"\ngamma = 1.8, beyond the limit: the Lyapunov equation still has a solution, but its eigenvalues"
      f" {np.round(np.linalg.eigvalsh(P18), 2)} are negative: no quadratic health index exists, as Theorem 7.4 requires")

kk = np.arange(41)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.semilogy(kk, score, "o-", color="#B71C1C", lw=1.2, ms=3, label=f"scorecard d_k² + d_(k−1)²: rises in {n_score} of 40 quarters")
ax.semilogy(kk, V, "-", color="#1F4E79", lw=2, label="Lyapunov index xᵀPx: falls every quarter")
ax.set(xlabel="quarters", ylabel="index (engineers squared)", xlim=(0, 40),
       title="The Lyapunov index falls every quarter; the scorecard does not (seed 26107)")
ax.legend(frameon=False, fontsize=8, loc="upper right"); plt.tight_layout(); plt.show()
three-reading company, Q = I: P =
 [[10.2973  4.6069  0.6173]
 [ 4.6069  5.7025  0.7716]
 [ 0.6173  0.7716  2.7778]]
  Lyapunov equation residual 1.8e-15; eigenvalues of P [ 2.434  3.113 13.231]
  along today's path at 8 a year: the sum of squared deviations rises in 0 of 20 years, V in 0; here even the plain sum works (the largest stretch of A is 0.97 < 1)

deadbeat rule with the delay, state (gap now, gap a quarter ago), Q = I: P =
 [[13.5714 -5.7857]
 [-5.7857 11.9929]]
  residual 5.3e-15; eigenvalues of P [ 6.943 18.621]: positive, so V is a health index; the largest stretch of the loop is 1.50
  the book's path, quarters 1-40: the scorecard d_k^2 + d_(k-1)^2 rises in 18 quarters, V in 0
  first quarters, scorecard: [10000 18100  8181  8020 13136]; V: [135714 125714 107614  99433  91413]
  1,000 simulated starts x 40 quarters (seed 26107): the scorecard rises in 18,451 of 40,000 quarters (46%), V in 0

gamma = 1.8, beyond the limit: the Lyapunov equation still has a solution, but its eigenvalues [-22.47  -8.57] are negative: no quadratic health index exists, as Theorem 7.4 requires
The Lyapunov index falls every quarter; the scorecard does not (seed 26107)

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

Each checkpoint is a number printed in Chapter 7 (Worked Example 7.1, Tables 7.4–7.5, Figures 7.1–7.3, Sections 7.3–7.6), in Online Appendix 7.B, or in Section 3.4 for the three-reading company of Equation 3.2; a claim stated in words ("more than 10 engineers off target a decade later") is checked as true or false. The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.

Python Code
d35, c05, l05, l15 = nodelay[3.5], nodelay[0.5], delayed[0.5], delayed[1.5]
TABLE_7_5 = {                                            # as printed in the book, quarters 0-8
    "cautious": (c05, [-100, -60, -36, -22, -13, -8, -5, -3, -2]),
    "deadbeat": (nodelay[1.5], [-100, 0, 0, 0, 0, 0, 0, 0, 0]),
    "overcorrecting": (d35, [-100, 120, -144, 173, -207, 249, -299, 358, -430]),
    "cautious with the delay": (l05, [-100, -90, -51, -19, -2, 4, 4, 3, 1]),
    "deadbeat rule with the delay": (l15, [-100, -90, 9, 89, 72, -15, -79, -57, 19]),
}
def row_gap(name, upto=9):
    got, printed = TABLE_7_5[name]
    return float(np.abs(np.round(got[:upto]) - np.array(printed[:upto])).max())

checks = [
    ("Section 3.4: capability a year after u = 10 (workbook)", (A3 @ X0 + B3 * 10)[0], 53.0, 0.05),
    ("Section 3.4: efficiency a year after u = 10 (workbook)", (A3 @ X0 + B3 * 10)[2], 54.5, 0.05),
    ("forecastable horizon, years (workbook)", horizon, 2.2, 0.05),
    ("halving the error adds, years (workbook)", np.log(2) / L_SENS, 1.4, 0.05),
    ("Proposition 7.2(i): quarterly law, gap at year ends (workbook)", q_gap, 0.0, 1e-9),
    ("exact quarterly growth while small, percent (workbook)", 100 * (np.exp(R_SU / 4) - 1), 25, 0.5),
    ("start-up doubling time, years (workbook)", np.log(2) / R_SU, 0.77, 0.005),
    ("start-up inflection date, years (workbook)", t_infl, 4.3, 0.05),
    ("start-up at year 5 (Online Appendix 7.B.4)", logistic(5), 64.8, 0.05),
    ("start-up at year 6 (workbook)", logistic(6), 81.9, 0.05),
    ("start-up at year 10 (workbook)", logistic(10), 99.4, 0.05),
    ("quarterly step at year 5 (workbook)", eq[20], 58.1, 0.05),
    ("monthly step: gap at year 5 (workbook)", gaps["monthly"], 2.1, 0.05),
    ("weekly step: gap at year 5 (workbook)", gaps["weekly"], 0.5, 0.05),
    ("exponential plan at the inflection date (workbook)", X0_SU * np.exp(R_SU * t_infl), 98, 0.5),
    ("exponential plan at year 5 (workbook)", X0_SU * np.exp(R_SU * 5), 180, 0.5),
    ("exponential plan at year 6 (workbook)", X0_SU * np.exp(R_SU * 6), 443, 0.5),
    ("Figure 7.1: technology, momentum at year 10 (workbook)", free[10, 1], 27, 0.5),
    ("Figure 7.1: technology, program at year 10 (workbook)", forced[10, 1], 25, 0.5),
    ("Figure 7.1: technology, path at year 10 (workbook)", path[10, 1], 52, 0.5),
    ("Figure 7.1: steady state of technology (workbook)", ss_tech, 72, 0.5),
    ("policy map: capability per unit (workbook)", per_unit[0], 10.5, 1e-9),
    ("policy map: technology per unit (workbook)", per_unit[1], 9, 1e-9),
    ("policy map: efficiency per unit (workbook)", per_unit[2], 7.125, 1e-9),
    ("steady state at 8: capability (workbook)", ss8[0], 84, 0.5),
    ("steady state at 8: technology (workbook)", ss8[1], 72, 0.5),
    ("steady state at 8: efficiency (workbook)", ss8[2], 57, 0.5),
    ("slowest eigenvalue (workbook)", eig[0], 0.95, 1e-9),
    ("other eigenvalues (workbook)", eig[1], 0.80, 1e-6),
    ("half-life of a shock, years (workbook)", half, 13.5, 0.05),
    ("covenant package: rank, technology feeds capability (workbook)", ranks[(PACKAGES[0][0], True)], 4, 0),
    ("covenant package: rank, technology feeds nothing (workbook)", ranks[(PACKAGES[0][0], False)], 3, 0),
    ("technology's weight in liquidity after 2 quarters (workbook)", w_tech[2], 0.002, 5e-4),
    ("10-point technology deviation, liquidity after 4 quarters (workbook)", 10 * w_tech[4], 0.10, 0.005),
    ("10-point technology deviation, liquidity after 12 quarters (workbook)", 10 * w_tech[12], 0.6, 0.05),
    ("uncertainty on technology, 4 quarters (workbook)", SE[4][3], 480, 5),
    ("uncertainty on technology, 12 quarters (workbook)", SE[12][3], 37, 0.5),
    ("uncertainty on technology, 20 quarters (workbook)", SE[20][3], 14, 0.5),
    ("uncertainty on technology, 40 quarters (workbook)", SE[40][3], 6, 0.5),
    ("no delay: upper stability limit (workbook)", hi, 3.17, 0.005),
    ("no delay: lower stability limit (workbook)", lo, -0.17, 0.005),
    ("deadbeat gain (workbook)", dead, 1.5, 1e-9),
    ("Table 7.5: cautious row, in whole engineers", row_gap("cautious"), 0, 0),
    ("Table 7.5: deadbeat row, in whole engineers", row_gap("deadbeat"), 0, 0),
    ("Table 7.5: overcorrecting row, in whole engineers", row_gap("overcorrecting"), 0, 0),
    ("Table 7.5: cautious row with the delay, in whole engineers", row_gap("cautious with the delay"), 0, 0),
    ("Table 7.5: deadbeat rule with the delay, in whole engineers", row_gap("deadbeat rule with the delay"), 0, 0),
    ("Table 7.5: cautious, quarter 3 (workbook)", c05[3], -22, 0.5),
    ("Table 7.5: overcorrecting, quarter 8 (workbook)", d35[8], -430, 0.5),
    ("Table 7.5: delay, cautious, quarter 2 (workbook)", l05[2], -51, 0.5),
    ("Table 7.5: delay, deadbeat rule, quarter 4 (workbook)", l15[4], 72, 0.5),
    ("Figure 7.2: aggressive coefficient (workbook)", A_H - B_H * 2.5, -0.6, 1e-9),
    ("Figure 7.2: overcorrecting coefficient (workbook)", A_H - B_H * 3.5, -1.2, 1e-9),
    ("delay: stability limit (workbook)", 1 / B_H, 1.67, 0.005),
    ("delay: deadbeat rule's modulus (workbook)", abs(zd[0]), 0.95, 0.005),
    ("delay: deadbeat rule's cos(theta) (workbook)", zd[0].real / abs(zd[0]), 0.47, 0.005),
    ("delay: deadbeat rule's cycle, quarters (workbook)", 2 * np.pi / abs(np.angle(zd[0])), 5.8, 0.05),
    ("delay: deadbeat rule's swings halve, quarters (workbook)", np.log(2) / np.log(1 / abs(zd[0])), 13, 0.5),
    ("delay: deadbeat rule's overshoot (workbook)", dp[peak_q], 89, 0.5),
    ("delay: quarter of the overshoot (workbook)", peak_q, 3, 0),
    ("delay: deadbeat rule's swing back (workbook)", dp[trough_q], -79, 0.5),
    ("delay: quarter of the swing back (workbook)", trough_q, 6, 0),
    ("delay: more than 10 off a decade later (workbook)", float(abs(dp[40:46]).max() > 10), 1, 0),
    ("delay: cautious rule's modulus (workbook)", abs(delay_roots(0.5)[0]), 0.55, 0.005),
    ("delay: cautious within 10 by quarter (workbook)", settles(l05, 10), 4, 0),
    ("delay: cautious within 5 by quarter (workbook)", settles(l05, 5), 4, 0),
    ("delay: gain with merged roots (workbook)", g_merge, 0.34, 0.005),
    ("delay: smallest modulus (workbook)", abs(delay_roots(g_merge)).max(), 0.45, 0.005),
    ("delay: merged-roots gain within 5 by quarter (workbook)", settles(delayed[g_merge], 5), 7, 0),
    ("Figure 7.2: delay, gamma 1.8 outside the circle (workbook)", float(abs(delay_roots(1.8)).max() > 1), 1, 0),
    ("retuning: gain after one review (workbook)", tuned[1], 2.6, 0.005),
    ("retuning: gain after five reviews (workbook)", tuned[5], 3.11, 0.005),
    ("retuning: gain after six reviews (workbook)", tuned[6], -0.27, 0.005),
    ("retuning: steady below eta (workbook)", 1 / B_H, 1.67, 0.005),
    ("retuning: growing swings above eta (workbook)", 2 / B_H, 3.33, 0.005),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
    status = "PASS" if abs(got - want) <= tol + 1e-12 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")
Section 3.4: capability a year after u = 10 (workbook)                   53.0000   book   53.0000   PASS
Section 3.4: efficiency a year after u = 10 (workbook)                   54.5000   book   54.5000   PASS
forecastable horizon, years (workbook)                                    2.1972   book    2.2000   PASS
halving the error adds, years (workbook)                                  1.3863   book    1.4000   PASS
Proposition 7.2(i): quarterly law, gap at year ends (workbook)            0.0000   book    0.0000   PASS
exact quarterly growth while small, percent (workbook)                   25.2323   book   25.0000   PASS
start-up doubling time, years (workbook)                                  0.7702   book    0.7700   PASS
start-up inflection date, years (workbook)                                4.3242   book    4.3000   PASS
start-up at year 5 (Online Appendix 7.B.4)                               64.7525   book   64.8000   PASS
start-up at year 6 (workbook)                                            81.8791   book   81.9000   PASS
start-up at year 10 (workbook)                                           99.3989   book   99.4000   PASS
quarterly step at year 5 (workbook)                                      58.1286   book   58.1000   PASS
monthly step: gap at year 5 (workbook)                                    2.1426   book    2.1000   PASS
weekly step: gap at year 5 (workbook)                                     0.4872   book    0.5000   PASS
exponential plan at the inflection date (workbook)                       98.0000   book   98.0000   PASS
exponential plan at year 5 (workbook)                                   180.0343   book  180.0000   PASS
exponential plan at year 6 (workbook)                                   442.8128   book  443.0000   PASS
Figure 7.1: technology, momentum at year 10 (workbook)                   27.2252   book   27.0000   PASS
Figure 7.1: technology, program at year 10 (workbook)                    24.9600   book   25.0000   PASS
Figure 7.1: technology, path at year 10 (workbook)                       52.1853   book   52.0000   PASS
Figure 7.1: steady state of technology (workbook)                        72.0000   book   72.0000   PASS
policy map: capability per unit (workbook)                               10.5000   book   10.5000   PASS
policy map: technology per unit (workbook)                                9.0000   book    9.0000   PASS
policy map: efficiency per unit (workbook)                                7.1250   book    7.1250   PASS
steady state at 8: capability (workbook)                                 84.0000   book   84.0000   PASS
steady state at 8: technology (workbook)                                 72.0000   book   72.0000   PASS
steady state at 8: efficiency (workbook)                                 57.0000   book   57.0000   PASS
slowest eigenvalue (workbook)                                             0.9500   book    0.9500   PASS
other eigenvalues (workbook)                                              0.8000   book    0.8000   PASS
half-life of a shock, years (workbook)                                   13.5134   book   13.5000   PASS
covenant package: rank, technology feeds capability (workbook)            4.0000   book    4.0000   PASS
covenant package: rank, technology feeds nothing (workbook)               3.0000   book    3.0000   PASS
technology's weight in liquidity after 2 quarters (workbook)              0.0020   book    0.0020   PASS
10-point technology deviation, liquidity after 4 quarters (workbook)      0.1023   book    0.1000   PASS
10-point technology deviation, liquidity after 12 quarters (workbook)     0.5978   book    0.6000   PASS
uncertainty on technology, 4 quarters (workbook)                        483.1660   book  480.0000   PASS
uncertainty on technology, 12 quarters (workbook)                        36.9872   book   37.0000   PASS
uncertainty on technology, 20 quarters (workbook)                        14.2774   book   14.0000   PASS
uncertainty on technology, 40 quarters (workbook)                         5.7790   book    6.0000   PASS
no delay: upper stability limit (workbook)                                3.1667   book    3.1700   PASS
no delay: lower stability limit (workbook)                               -0.1667   book   -0.1700   PASS
deadbeat gain (workbook)                                                  1.5000   book    1.5000   PASS
Table 7.5: cautious row, in whole engineers                               0.0000   book    0.0000   PASS
Table 7.5: deadbeat row, in whole engineers                               0.0000   book    0.0000   PASS
Table 7.5: overcorrecting row, in whole engineers                         0.0000   book    0.0000   PASS
Table 7.5: cautious row with the delay, in whole engineers                0.0000   book    0.0000   PASS
Table 7.5: deadbeat rule with the delay, in whole engineers               0.0000   book    0.0000   PASS
Table 7.5: cautious, quarter 3 (workbook)                               -21.6000   book  -22.0000   PASS
Table 7.5: overcorrecting, quarter 8 (workbook)                        -429.9817   book -430.0000   PASS
Table 7.5: delay, cautious, quarter 2 (workbook)                        -51.0000   book  -51.0000   PASS
Table 7.5: delay, deadbeat rule, quarter 4 (workbook)                    72.0900   book   72.0000   PASS
Figure 7.2: aggressive coefficient (workbook)                            -0.6000   book   -0.6000   PASS
Figure 7.2: overcorrecting coefficient (workbook)                        -1.2000   book   -1.2000   PASS
delay: stability limit (workbook)                                         1.6667   book    1.6700   PASS
delay: deadbeat rule's modulus (workbook)                                 0.9487   book    0.9500   PASS
delay: deadbeat rule's cos(theta) (workbook)                              0.4743   book    0.4700   PASS
delay: deadbeat rule's cycle, quarters (workbook)                         5.8362   book    5.8000   PASS
delay: deadbeat rule's swings halve, quarters (workbook)                 13.1576   book   13.0000   PASS
delay: deadbeat rule's overshoot (workbook)                              89.1000   book   89.0000   PASS
delay: quarter of the overshoot (workbook)                                3.0000   book    3.0000   PASS
delay: deadbeat rule's swing back (workbook)                            -78.6591   book  -79.0000   PASS
delay: quarter of the swing back (workbook)                               6.0000   book    6.0000   PASS
delay: more than 10 off a decade later (workbook)                         1.0000   book    1.0000   PASS
delay: cautious rule's modulus (workbook)                                 0.5477   book    0.5500   PASS
delay: cautious within 10 by quarter (workbook)                           4.0000   book    4.0000   PASS
delay: cautious within 5 by quarter (workbook)                            4.0000   book    4.0000   PASS
delay: gain with merged roots (workbook)                                  0.3375   book    0.3400   PASS
delay: smallest modulus (workbook)                                        0.4500   book    0.4500   PASS
delay: merged-roots gain within 5 by quarter (workbook)                   7.0000   book    7.0000   PASS
Figure 7.2: delay, gamma 1.8 outside the circle (workbook)                1.0000   book    1.0000   PASS
retuning: gain after one review (workbook)                                2.6000   book    2.6000   PASS
retuning: gain after five reviews (workbook)                              3.1105   book    3.1100   PASS
retuning: gain after six reviews (workbook)                              -0.2716   book   -0.2700   PASS
retuning: steady below eta (workbook)                                     1.6667   book    1.6700   PASS
retuning: growing swings above eta (workbook)                             3.3333   book    3.3300   PASS

75 of 75 checkpoints PASS

Next. Chapter 8 gives the environment inputs probabilities: the forecast becomes a distribution, the fan chart, and a plan that looks comfortable on the chart meets the odds of breaching the board's liquidity floor. AXIOM-07 runs this chapter's model interactively (Lab 1.7); 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