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 the gap (bench minus target) at the start of quarter and the approvals, . Human resources proposes the rule ; the chief operating officer asks how large the gain 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 ), today at ; 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, from (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 in today's state can grow like (Equation 7.3), so a forecast needed within a tolerance holds for : 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

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

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 , so every held investment has exactly one steady state, (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 periods of reports exactly when the observability matrix (Equation 7.5) has rank ; 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 : the whole design question is the coefficient . By Table 7.4, with and , the rule is stable for gains below 3.17; the deadbeat gain 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: . The closed loop now has two eigenvalues, the roots of , of modulus when they are complex, and the safe range shrinks from to 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 , the slowest without the delay, is now the fastest: within 10 engineers by quarter 4. The gain with the smallest modulus, 0.45 at 0.34, is slower from Meridian's starting gap: within 5 engineers by quarter 7, against quarter 4 for .
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

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, , runs a scalar feedback loop of its own, : it converges steadily on the deadbeat gain for , with damped swings up to , and with growing swings beyond. At , 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 , which solves the Lyapunov equation , the index falls by 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

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.


