DCT Laboratory — Volume I, Chapter 6
Enterprise Transformation Operators
This laboratory demonstrates
Seed 26106 · Companion to Chapter 6 and AXIOM Lab 1.6 (module AXIOM-06) · Mirrored in DCT_V1_Ch06_Lab.xlsx
This laboratory reproduces Worked Example 6.1, Strategy or Trade? Meridian's Automation Playbook, with the book's declarations, and works the five steps of AXIOM Lab 1.6, Sequencing Meridian's Moves: forge the operators, compose programs, test the playbook, explore reachability, stress the execution. Every Meridian number below is the book's (Worked Example 6.1 and Table 6.4, Figures 6.1–6.4, Section 6.5, Online Appendix 6.B); the final cell checks them. Money is in $ million.
The declarations (Worked Example 6.1, Step 1; Figure 6.3)
Meridian today (Table 3.1): liquidity $620 million, technology platform 41, workforce capability 58, operational efficiency 71. The board's floor is $350 million of liquidity (Table 5.4). The lab's repertoire has four moves, each declared with its effect and its domain, the set of states from which it can be taken (Definitions 6.1 and 6.3):
- S, sell part of Industrial Systems as designed, the shared engineering team going with the unit (Worked Example 3.1): $112 million net, the unit takes 10 percent of the technology position, and workforce capability falls by 5 points. It needs the unit unsold.
- S*, the same sale keeping the engineers: $92 million, and capability is kept. It needs the unit unsold.
- D, the digital build: Worked Example 1.1's program, computed with the Chapter 1 model. Over five years it changes liquidity by −$35 million, technology by +34.6 points and efficiency by +2.6, and these changes add to the state it starts from; on the way its cash bottoms around month 21, $138 million below its starting level. It needs workforce capability of at least 55 and must keep the floor intact at that low point, so it needs $488 million first. It is built once.
- A, the automation round: costs $120 million, closes half of the gap between efficiency and the plants' ceiling of 85, and retrains staff, adding a point of workforce capability. It needs liquidity of at least $470 million, so that the floor holds after the round, and workforce capability of at least 55. Every efficiency point gained is worth $10 million a year in lower costs.
Python Code
import math
from collections import namedtuple
from decimal import Decimal, ROUND_HALF_UP
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26106
# Meridian today (Table 3.1) and the board's floor (Table 5.4); money in $ million
State = namedtuple("State", "L T W E sold built") # liquidity, technology, workforce, efficiency, unit sold, platform built
TODAY = State(L=620.0, T=41.0, W=58.0, E=71.0, sold=False, built=False)
FLOOR = 350.0
# The automation round (Worked Example 6.1)
COST, CEIL, CLOSE = 120.0, 85.0, 0.5 # cost; the plants' technical ceiling; share of the gap closed
W_MIN, W_GAIN, VALUE = 55.0, 1.0, 10.0 # capability to staff the lines; retraining; $ a year per point gained
PRE_A = FLOOR + COST # 470: the floor still holds after the round is paid for
# The sale of part of Industrial Systems and the digital build (Worked Example 3.1)
PROCEEDS = {"S": 112.0, "S*": 92.0} # engineers leave with the unit / engineers kept
TECH_SHARE, W_LOST = 0.10, 5.0 # the unit takes 10% of technology; 5 capability points if the team goes
# The digital build is Worked Example 1.1's program: the Chapter 1 model (Eq. 1.B.1, Table 1.B.1's digital row),
# liquidity indexed to today = 100 = $620 million. Its five-year changes add to the state it starts from.
from scipy.optimize import minimize_scalar
def chapter1(key, t):
x0, (target, k, depth, tau) = {"L": (100.0, (112, 0.35, -28, 2.0)), "T": (41.0, (78, 0.55, 0, 1.0)),
"E": (71.0, (77, 0.50, -9, 1.5))}[key]
return target + (x0 - target) * np.exp(-k * t) + depth * (t / tau) * np.exp(1 - t / tau)
LOW = minimize_scalar(lambda t: chapter1("L", t), bounds=(0, 5), method="bounded", options={"xatol": 1e-10})
DIP = 6.2 * (100.0 - LOW.fun) # 138.08: the build's low point below its starting liquidity (month 20.6)
D_L, D_T, D_E = 6.2 * (chapter1("L", 5.0) - 100.0), chapter1("T", 5.0) - 41.0, chapter1("E", 5.0) - 71.0
PRE_D = FLOOR + DIP # 488.08: the floor still holds at the build's low point
TARGET_T, TARGET_E = 70.0, 80.0 # the board's target in Figure 6.3: technology and efficiency
class Operator:
# Definition 6.1: a declared action. Its domain holds the preconditions (Definition 6.3): `needs` lists
# (test, reason) pairs. Its effect is the mapping (Definition 6.2). Outside the domain there is no result.
def __init__(self, code, name, needs, effect, domain):
self.code, self.name, self.needs, self.effect, self.domain = code, name, needs, effect, domain
def why_not(self, x):
for test, reason in self.needs:
if not test(x):
return reason(x)
return None
def __call__(self, x):
return self.effect(x) if self.why_not(x) is None else None
def sale(keep):
return lambda x: x._replace(L=x.L + PROCEEDS["S*" if keep else "S"], T=(1 - TECH_SHARE) * x.T,
W=x.W if keep else x.W - W_LOST, sold=True)
UNSOLD = (lambda x: not x.sold, lambda x: "the unit is already sold")
STAFFED = (lambda x: x.W >= W_MIN, lambda x: f"workforce {x.W:.0f} < {W_MIN:.0f}")
S = Operator("S", "sell, engineers leave", [UNSOLD], sale(False), "the unit unsold")
S_ = Operator("S*", "sell, engineers kept", [UNSOLD], sale(True), "the unit unsold")
UNBUILT = (lambda x: not x.built, lambda x: "the platform is already built")
D = Operator("D", "digital build",
[UNBUILT, STAFFED, (lambda x: x.L - DIP >= FLOOR, lambda x: f"its low point ${x.L - DIP:.0f}m is below the floor")],
lambda x: x._replace(L=x.L + D_L, T=x.T + D_T, E=x.E + D_E, built=True),
f"not built, workforce >= {W_MIN:.0f}, liquidity >= ${PRE_D:.0f}m")
A = Operator("A", "automation round",
[STAFFED, (lambda x: x.L >= PRE_A, lambda x: f"liquidity ${x.L:.0f}m < ${PRE_A:.0f}m")],
lambda x: x._replace(L=x.L - COST, W=x.W + W_GAIN, E=x.E + CLOSE * (CEIL - x.E)),
f"workforce >= {W_MIN:.0f}, liquidity >= ${PRE_A:.0f}m")
REPERTOIRE = [S, S_, D, A]
def show(x):
return f"${x.L:.0f}m, T {x.T:.1f}, W {x.W:.0f}, E {x.E:.1f}"
def meets(x):
return x.T >= TARGET_T - 1e-9 and x.E >= TARGET_E - 1e-9
def half_up(v, nd):
# the book rounds halves up (84.125 -> 84.13); Python's own formatting rounds them to even
return float(Decimal(repr(float(v))).quantize(Decimal(1).scaleb(-nd), rounding=ROUND_HALF_UP))
print("Meridian today:", show(TODAY) + f"; the board's floor ${FLOOR:.0f}m")
print(f"automation round needs ${PRE_A:.0f}m = floor ${FLOOR:.0f}m + cost ${COST:.0f}m;"
f" digital build needs ${PRE_D:.2f}m = floor + its low point ${DIP:.2f}m below the start")
print(f"the build's five-year changes: liquidity {D_L:+.2f}, technology {D_T:+.2f}, efficiency {D_E:+.2f}")Meridian today: $620m, T 41.0, W 58, E 71.0; the board's floor $350m automation round needs $470m = floor $350m + cost $120m; digital build needs $488.08m = floor + its low point $138.08m below the start the build's five-year changes: liquidity -35.37, technology +34.63, efficiency +2.60
Panel 1 — Forge the operators (Definitions 6.1–6.4; Figure 6.1; Proposition 6.1; Theorem 6.1)
AXIOM Lab 1.6, step 1: declare the four moves with their effects and preconditions, the board's floor included, and inspect each operator's domain and range. From today's state all four moves can be taken: the digital build's low point, $482 million, stays $132 million above the floor. Outside its domain an operator has no result ("cannot", not "should not"): two automation rounds leave $380 million, and the build's low point would then fall below the floor, so from there it cannot start. One automation round takes Meridian from $620 million and efficiency 71 to $500 million and efficiency 78 (Figure 6.1). Two more readings of the declarations: a record that pairs one starting state with two outcomes is not one operator (Proposition 6.1), which is why the sale is a family of two, one for each decision about the engineers; and the sale's proceeds rest on a buyer paying the assumed price, an assumption about the environment rather than a commitment (Theorem 6.1(ii)).
Python Code
print(f"{'move':26s} {'domain (preconditions)':37s} from today")
first = {}
for op in REPERTOIRE:
y = op(TODAY)
first[op.code] = y
res = show(y) if y else "no result: " + op.why_not(TODAY)
print(f"{op.code:3s}{op.name:23s} {op.domain:37s} {res}")
n_first = sum(y is not None for y in first.values())
print(f"{n_first} of the 4 moves can be taken today")
one = first["A"]
# Figure 6.1: the automation round on the (liquidity, efficiency) plane, workforce capability 58
print("\nthe round on Figure 6.1's plane, (liquidity $m, efficiency) before -> after:")
for q, e, note in ((620.0, 71.0, "Meridian today"), (860.0, 67.5, ""), (800.0, 81.0, ""), (410.0, 66.5, "")):
x = TODAY._replace(L=q, E=e)
y = A(x)
print(f" ({q:.0f}, {e:4.1f}) -> " + (f"({y.L:.0f}, {y.E:5.2f})" if y else "no result: " + A.why_not(x)
+ ", a feasible state outside the domain") + (f" {note}" if note else ""))
print("range: liquidity at least the floor; efficiency (e + 85)/2, below 85 whenever e is: never the ceiling itself")
# Proposition 6.1: a record of (before, after) pairs is one operator exactly when no start has two outcomes
record = [(TODAY, S(TODAY)), (TODAY, S_(TODAY))]
outcomes = {}
for before, after in record:
outcomes.setdefault(before, set()).add(after)
functional = all(len(v) == 1 for v in outcomes.values())
print(f"\nrecord of 'sell part of Industrial Systems' from today: {len(outcomes[TODAY])} outcomes for one start,"
f" {'functional' if functional else 'not functional'} (Proposition 6.1)")
print(" so the sale is a family of two operators, S and S*, one for each decision about the engineers (Definition 6.1)")
print("the sale's proceeds rest on a buyer paying the assumed price: an assumption, not a commitment (Theorem 6.1(ii))")move domain (preconditions) from today S sell, engineers leave the unit unsold $732m, T 36.9, W 53, E 71.0 S* sell, engineers kept the unit unsold $712m, T 36.9, W 58, E 71.0 D digital build not built, workforce >= 55, liquidity >= $488m $585m, T 75.6, W 58, E 73.6 A automation round workforce >= 55, liquidity >= $470m $500m, T 41.0, W 59, E 78.0 4 of the 4 moves can be taken today the round on Figure 6.1's plane, (liquidity $m, efficiency) before -> after: (620, 71.0) -> (500, 78.00) Meridian today (860, 67.5) -> (740, 76.25) (800, 81.0) -> (680, 83.00) (410, 66.5) -> no result: liquidity $410m < $470m, a feasible state outside the domain range: liquidity at least the floor; efficiency (e + 85)/2, below 85 whenever e is: never the ceiling itself record of 'sell part of Industrial Systems' from today: 2 outcomes for one start, not functional (Proposition 6.1) so the sale is a family of two operators, S and S*, one for each decision about the engineers (Definition 6.1) the sale's proceeds rest on a buyer paying the assumed price: an assumption, not a commitment (Theorem 6.1(ii))
Panel 2 — A policy turns a family into a system (Theorem 6.1(iii); Online Appendix Example 6.B.1)
A bank invests in its digital platform from the liquidity it holds above a regulatory floor of $300 million, and each $1 million invested adds 0.05 points to its technology index. The amount is a decision, so the program is a family with domain . The board's rule, invest half of the liquidity above the floor each year, , selects one operator at every state and leaves a single closed-loop map, : a contraction with toward the floor. From $900 million, liquidity is $600, $450, $375 and $337.5 million, approaching but never reaching $300 million. The investments sum to the initial slack of $600 million, so technology rises from 41 toward 71 (56 after one year, 63.5 after two). A board that wants faster progress must change the rule, not hope for a different path.
Python Code
BANK_Q0, BANK_FLOOR, BANK_T0, GAIN = 900.0, 300.0, 41.0, 0.05
def invest(u):
# one member of the family: T_u(q, t) = (q - u, t + 0.05 u) on the domain q - u >= 300
return lambda q, t: (q - u, t + GAIN * u) if q - u >= BANK_FLOOR - 1e-12 else None
def rule(q):
return 0.5 * (q - BANK_FLOOR) # the board's policy: half of the liquidity above the floor
q, t, bank = BANK_Q0, BANK_T0, [(0, BANK_Q0, 0.0, BANK_T0)]
for year in range(1, 41):
u = rule(q)
q, t = invest(u)(q, t)
bank.append((year, q, u, t))
print("year liquidity invested technology 300 + 600 x 0.5^k")
for yr, q, u, t in bank[:7]:
print(f"{yr:4d} {q:10.2f} {u:9.2f} {t:11.2f} {BANK_FLOOR + (BANK_Q0 - BANK_FLOOR) * 0.5 ** yr:16.2f}")
invested = sum(r[2] for r in bank)
print(f"closed loop q' = (q + 300)/2, a contraction with L = 0.5: after 40 years ${bank[-1][1]:.9f}m, still above $300m")
print(f"investments sum to ${invested:.6f}m, the initial slack of $600m; technology -> {bank[-1][3]:.6f}"
f" (41 + 0.05 x 600 = 71)")year liquidity invested technology 300 + 600 x 0.5^k 0 900.00 0.00 41.00 900.00 1 600.00 300.00 56.00 600.00 2 450.00 150.00 63.50 450.00 3 375.00 75.00 67.25 375.00 4 337.50 37.50 69.12 337.50 5 318.75 18.75 70.06 318.75 6 309.38 9.38 70.53 309.38 closed loop q' = (q + 300)/2, a contraction with L = 0.5: after 40 years $300.000000001m, still above $300m investments sum to $600.000000m, the initial slack of $600m; technology -> 71.000000 (41 + 0.05 x 600 = 71)
Panel 3 — Compose programs (Theorem 6.2(iii); Proposition 6.5; Figure 6.3)
AXIOM Lab 1.6, step 2: chain the moves two at a time. A program runs only if each step's result lies in the next step's domain (Definition 6.5), so every seam is a membership check. Selling as designed is a dead end: with workforce capability down to 53, neither the digital build nor automation can follow. Exactly one two-move program reaches the board's target of a technology index of at least 70 and operational efficiency of at least 80: automate, then build, which ends with $465 million, technology 75.6 and efficiency 80.6, and passes only $12 million above the floor at the build's low point. Building first and automating second ends with the same cash and platform but efficiency 79.3: order decides the result (Theorem 6.2(iii)), and the build followed by the sale as designed runs, while the sale as designed followed by the build does not (Online Appendix 6.B). Section 6.5's case on file: selling with the engineers kept and running two automation rounds leaves $472 million; the build would then end the sequence at $437 million but pass through $334 million, below the floor, so it is not feasible, whatever its end point (Proposition 6.5).
Python Code
pairs = {}
print("today:", show(TODAY))
for f in REPERTOIRE:
y = f(TODAY)
if y is None:
print(f"{f.code}, {f.name}: not possible ({f.why_not(TODAY)})")
pairs.update({(f.code, g.code): None for g in REPERTOIRE})
continue
print(f"{f.code}, {f.name} -> {show(y)}")
for g in REPERTOIRE:
if (g in (S, S_) and y.sold) or (g is D and y.built):
continue # a second sale or a second build is impossible and is not drawn (Figure 6.3)
z = g(y)
pairs[(f.code, g.code)] = z
low = f", low point ${y.L - DIP:.0f}m (${y.L - DIP - FLOOR:.0f}m above the floor)" if g is D and z else ""
mark = " <- meets the target" if z and meets(z) else ""
print(f" {f.code}, then {g.code}: " + (show(z) + low + mark if z else f"not possible ({g.why_not(y)})"))
ran = [p for p, z in pairs.items() if z is not None]
hits = [p for p in ran if meets(pairs[p])]
win = pairs[hits[0]]
print(f"\n{len(ran)} of the {len(pairs)} ordered pairs drawn pass every seam; {len(hits)} reaches the target"
f" (technology >= {TARGET_T:.0f}, efficiency >= {TARGET_E:.0f}): {hits[0][0]} then {hits[0][1]}, {show(win)}")
other = pairs[(hits[0][1], hits[0][0])]
print(f"order decides the result (Theorem 6.2(iii)): {hits[0][1]} then {hits[0][0]} gives {show(other)}, efficiency"
f" {other.E:.1f} < {TARGET_E:.0f}")
print(f"the winning path passes ${first['A'].L - DIP - FLOOR:.0f}m above the floor at the build's low point"
f" (${first['A'].L - DIP:.0f}m)")
print(f"D then S runs; S then D does not ({D.why_not(first['S'])}): the sale as designed takes the engineers the build needs")
# Section 6.5's case on file (Proposition 6.5): sell keeping the engineers, two automation rounds, then the build
pre = A(A(S_(TODAY)))
D_floorless = Operator("D", "digital build, floor ignored", [UNBUILT, STAFFED], D.effect, "workforce >= 55")
end = D_floorless(pre)
mid = pre.L - DIP
print(f"\nS*, A, A leaves {show(pre)}; the build would end the sequence at ${end.L:.0f}m but pass through ${mid:.0f}m,"
f" ${FLOOR - mid:.0f}m below the floor: {D.why_not(pre)}, so the sequence is not feasible, whatever its end point"
" (Proposition 6.5)")today: $620m, T 41.0, W 58, E 71.0
S, sell, engineers leave -> $732m, T 36.9, W 53, E 71.0
S, then D: not possible (workforce 53 < 55)
S, then A: not possible (workforce 53 < 55)
S*, sell, engineers kept -> $712m, T 36.9, W 58, E 71.0
S*, then D: $677m, T 71.5, W 58, E 73.6, low point $574m ($224m above the floor)
S*, then A: $592m, T 36.9, W 59, E 78.0
D, digital build -> $585m, T 75.6, W 58, E 73.6
D, then S: $697m, T 68.1, W 53, E 73.6
D, then S*: $677m, T 68.1, W 58, E 73.6
D, then A: $465m, T 75.6, W 59, E 79.3
A, automation round -> $500m, T 41.0, W 59, E 78.0
A, then S: $612m, T 36.9, W 54, E 78.0
A, then S*: $592m, T 36.9, W 59, E 78.0
A, then D: $465m, T 75.6, W 59, E 80.6, low point $362m ($12m above the floor) <- meets the target
A, then A: $380m, T 41.0, W 60, E 81.5
9 of the 11 ordered pairs drawn pass every seam; 1 reaches the target (technology >= 70, efficiency >= 80): A then D, $465m, T 75.6, W 59, E 80.6
order decides the result (Theorem 6.2(iii)): D then A gives $465m, T 75.6, W 59, E 79.3, efficiency 79.3 < 80
the winning path passes $12m above the floor at the build's low point ($362m)
D then S runs; S then D does not (workforce 53 < 55): the sale as designed takes the engineers the build needs
S*, A, A leaves $472m, T 36.9, W 60, E 81.5; the build would end the sequence at $437m but pass through $334m, $16m below the floor: its low point $334m is below the floor, so the sequence is not feasible, whatever its end point (Proposition 6.5)
Panel 4 — Test the playbook: savings paid out (Worked Example 6.1, Step 2; Equation 6.2; Theorem 6.3)
AXIOM Lab 1.6, step 3, first part. Repeating the round is iterating the operator, and each further round adds a precondition on today's state: (Equation 6.2). If the savings leave Meridian, to fund dividends say, each round simply spends $120 million: liquidity goes from $620 million to $500 million and then to $380 million, and the third round's precondition fails. The -th round requires today's liquidity of at least million, so the nested domains shrink to nothing and the sustainable core is empty (Equation 6.3; Theorem 6.3): on these terms automation is a trade. The workforce precondition is not the problem; each round renews it.
Python Code
def playbook(q0=TODAY.L, e0=TODAY.E, w0=TODAY.W, recycle=1.0, shortfall=0.0, years=40, check=True):
# One automation round at the start of each year (Worked Example 6.1): the precondition is checked before the
# round; its cost and the year's savings ($10m a year per point above today's 71, the share `recycle` kept)
# land by the year's end. Returns rows (year, efficiency, savings, savings less the cost, liquidity at year
# end) and the first round whose precondition fails (None if every round runs).
rows, q, e, w = [(0, e0, 0.0, 0.0, q0)], q0, e0, w0
for k in range(1, years + 1):
if check and not (q >= PRE_A - 1e-9 and w >= W_MIN):
return rows, k
e = e + CLOSE * (CEIL - e) - shortfall
w += W_GAIN
sav = recycle * VALUE * (e - TODAY.E)
q = q - COST + sav
rows.append((k, e, sav, sav - COST, q))
return rows, None
def thresholds(n=10, **kw):
# Equation 6.2 in today's liquidity: round k runs from q0 exactly when q0 - drop_j >= 470 for every j < k, where
# drop_j is how far liquidity has fallen below its start by the end of year j (the same amount from any start)
rows, _ = playbook(check=False, years=n, **kw)
drop = [TODAY.L - r[4] for r in rows]
return [PRE_A + max(drop[:k]) for k in range(1, n + 1)]
paid, stop_paid = playbook(recycle=0.0)
print("savings paid out: liquidity " + " -> ".join(f"${r[4]:.0f}m" for r in paid)
+ f"; round {stop_paid} not available (${paid[-1][4]:.0f}m < ${PRE_A:.0f}m)")
print(f"rounds that run: {len(paid) - 1}; workforce capability after them {TODAY.W + (len(paid) - 1) * W_GAIN:.0f}"
" (each round renews that precondition)")
th_paid = thresholds(recycle=0.0)
print("\nnested domains (Equation 6.2): the liquidity today that lets the playbook run k rounds")
print(" round k " + "".join(f"{k:7d}" for k in range(1, 11)))
print(" paid out " + "".join(f"{v:7.0f}" for v in th_paid))
print(f" = 470 + 120(k - 1): it rises ${th_paid[1] - th_paid[0]:.0f}m a round without bound, so no start supports every"
" round: the sustainable core is empty (Theorem 6.3)")savings paid out: liquidity $620m -> $500m -> $380m; round 3 not available ($380m < $470m) rounds that run: 2; workforce capability after them 60 (each round renews that precondition) nested domains (Equation 6.2): the liquidity today that lets the playbook run k rounds round k 1 2 3 4 5 6 7 8 9 10 paid out 470 590 710 830 950 1070 1190 1310 1430 1550 = 470 + 120(k - 1): it rises $120m a round without bound, so no start supports every round: the sustainable core is empty (Theorem 6.3)
Panel 5 — Test the playbook: savings recycled (Worked Example 6.1, Step 3; Table 6.4; Theorem 6.3)
AXIOM Lab 1.6, step 3, second part. Keep the savings in Meridian's liquidity, so that each year's composite operator is "run a round, then bank the year's savings". The savings grow from $70 million to $122.5 million in year 3, when they first exceed the round's cost; liquidity bottoms at $555 million at the end of year 2 and then rises by up to $20 million a year (Table 6.4). The tightest moment is the start of year 3, so the nested domains stop shrinking: from today's efficiency the playbook runs indefinitely from any starting liquidity of $535 million or more, and Meridian, at $620 million, is inside the sustainable core with $85 million to spare. The lab asks for that threshold; the cell finds it from the nested domains and by bisection, and checks that the core is self-sustaining: one more round from a state in the core lands in the core (Theorem 6.3(ii)).
Python Code
rec, stop_rec = playbook()
row = lambda name, vals: print(f" {name:31s}" + "".join(f"{v:>9s}" for v in vals))
print("Table 6.4: the automation playbook with the savings recycled, as designed ($ million; one round at the start of each year)")
row("Year", [str(r[0]) for r in rec[:7]])
row("Efficiency (index)", [f"{half_up(r[1], 2):.2f}" for r in rec[:7]])
row("Savings this year", ["--"] + [f"{half_up(r[2], 1):.1f}" for r in rec[1:7]])
row("Savings less the round's cost", ["--"] + [f"{half_up(r[3], 1):.1f}" for r in rec[1:7]])
row("Liquidity at year end", [f"{half_up(r[4], 1):.1f}" for r in rec[:7]])
self_year = next(r[0] for r in rec[1:] if r[2] > COST)
low = min(rec[1:], key=lambda r: r[4])
print(f"savings first exceed the round's cost in year {self_year}; liquidity bottoms at ${low[4]:.0f}m at the end of year"
f" {low[0]}; in year 40 it rises ${rec[-1][3]:.2f}m (the limit: savings of ${VALUE * (CEIL - TODAY.E):.0f}m less the"
f" round's ${COST:.0f}m)")
th_rec = thresholds()
print("\nnested domains: the liquidity today that lets the playbook run k rounds")
print(" round k " + "".join(f"{k:7d}" for k in range(1, 11)))
print(" recycled " + "".join(f"{v:7.1f}" for v in th_rec))
core = max(thresholds(n=200))
lo, hi = 300.0, 900.0
for _ in range(60): # bisection on today's liquidity, every round for 200 years
q_mid = (lo + hi) / 2
lo, hi = (lo, q_mid) if playbook(q0=q_mid, years=200)[1] is None else (q_mid, hi)
print(f"the domains settle: the core starts at ${core:.2f}m (bisection over 200 years: ${hi:.2f}m);"
f" Meridian, at ${TODAY.L:.0f}m, is inside with ${TODAY.L - core:.0f}m to spare")
def core_at(e, n=200):
# the core's threshold for a state with efficiency e: from q0 = 0 the playbook's path is minus its drop
rows, _ = playbook(q0=0.0, e0=e, check=False, years=n)
return PRE_A + max(-r[4] for r in rows)
print("\nTheorem 6.3(ii): each year's state lies in the core of the playbook that remains")
print(" year liquidity efficiency core threshold margin")
for r in rec[:7]:
c = core_at(r[1])
print(f" {r[0]:4d} {r[4]:10.2f} {r[1]:11.3f} {c:15.2f} {r[4] - c:7.2f}")
k = np.arange(1, 11)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.plot(k, th_paid, color="#616161", lw=1.8, ls=":", marker="o", ms=4, label="savings paid out: 470 + 120(k - 1), no core")
ax.plot(k, th_rec, color="#1F4E79", lw=2, marker="o", ms=4, label=f"savings recycled: settles at {core:.0f}, the core")
ax.axhline(TODAY.L, color="#E65100", lw=1, ls="--")
ax.text(10.1, TODAY.L + 6, "Meridian today: \\$620m", ha="right", va="bottom", fontsize=8, color="#E65100")
ax.annotate("", xy=(6, core), xytext=(6, TODAY.L), arrowprops=dict(arrowstyle="<->", color="#1F4E79", lw=0.8,
shrinkA=0, shrinkB=0))
ax.text(6.12, (core + TODAY.L) / 2, f"Meridian is \\${TODAY.L - core:.0f}m inside the core", va="center", fontsize=8,
color="#1F4E79")
ax.set_xticks(k)
ax.set(xlim=(0.6, 10.4), ylim=(450, 800), xlabel="round k (one a year)", ylabel="liquidity today that lets k rounds run ($ million)",
title="Recycled savings stop the nested domains from shrinking (seed 26106)")
ax.legend(frameon=False, fontsize=8, loc="upper left"); plt.tight_layout(); plt.show()Table 6.4: the automation playbook with the savings recycled, as designed ($ million; one round at the start of each year)
Year 0 1 2 3 4 5 6
Efficiency (index) 71.00 78.00 81.50 83.25 84.13 84.56 84.78
Savings this year -- 70.0 105.0 122.5 131.3 135.6 137.8
Savings less the round's cost -- -50.0 -15.0 2.5 11.3 15.6 17.8
Liquidity at year end 620.0 570.0 555.0 557.5 568.8 584.4 602.2
savings first exceed the round's cost in year 3; liquidity bottoms at $555m at the end of year 2; in year 40 it rises $20.00m (the limit: savings of $140m less the round's $120m)
nested domains: the liquidity today that lets the playbook run k rounds
round k 1 2 3 4 5 6 7 8 9 10
recycled 470.0 520.0 535.0 535.0 535.0 535.0 535.0 535.0 535.0 535.0
the domains settle: the core starts at $535.00m (bisection over 200 years: $535.00m); Meridian, at $620m, is inside with $85m to spare
Theorem 6.3(ii): each year's state lies in the core of the playbook that remains
year liquidity efficiency core threshold margin
0 620.00 71.000 535.00 85.00
1 570.00 78.000 485.00 85.00
2 555.00 81.500 470.00 85.00
3 557.50 83.250 470.00 87.50
4 568.75 84.125 470.00 98.75
5 584.38 84.562 470.00 114.38
6 602.19 84.781 470.00 132.19

Panel 6 — Explore reachability (Theorem 6.4; Online Appendix Remark 6.B.3)
AXIOM Lab 1.6, step 4: grow the reachable sets of the four-move repertoire one step at a time by breadth-first search, , against the board's target. Attainability is a membership question (Theorem 6.4(i)): the target is first met at depth two, by the one path of Panel 3. The counts by depth are computed from the book's declarations: the sets stop growing after four moves, so the repertoire reaches finitely many states and no program from today has more than four moves. Then tighten or loosen the target, and its cushion over the floor. Theorem 6.4(iii) explains why complete goals need tolerances: efficiency after recycled rounds is (the first row of Table 6.4), so the ceiling of 85 is approached but never reached. Within a tolerance it is reached after rounds, and halving the tolerance costs one more round (Remark 6.B.3).
Python Code
def key(x):
return (round(x.L, 6), round(x.T, 6), x.W, round(x.E, 6), x.sold, x.built)
def reach(x0=TODAY, repertoire=REPERTOIRE, kmax=12):
# Theorem 6.4(i): breadth-first search; each state keeps the first, shortest, word that reaches it
seen, frontier, sizes = {key(x0): (x0, (), 0)}, [(x0, ())], [1]
for k in range(1, kmax + 1):
nxt = []
for x, word in frontier:
for op in repertoire:
y = op(x)
if y is not None and key(y) not in seen:
seen[key(y)] = (y, word + (op.code,), k)
nxt.append((y, word + (op.code,)))
sizes.append(len(seen))
frontier = nxt
if not nxt:
break
return seen, sizes
def programs(x0=TODAY, repertoire=REPERTOIRE, kmax=12):
# every word that runs from x0, counted by length (depth first)
count, stack = {}, [(x0, 0)]
while stack:
x, k = stack.pop()
for op in repertoire:
y = op(x)
if y is not None and k < kmax:
count[k + 1] = count.get(k + 1, 0) + 1
stack.append((y, k + 1))
return count
seen, sizes = reach()
nprog = programs()
closed = next(k for k in range(1, len(sizes)) if sizes[k] == sizes[k - 1]) - 1
print("depth k " + "".join(f"{k:5d}" for k in range(len(sizes))))
print("states in R_k " + "".join(f"{s:5d}" for s in sizes))
print("programs of length k " + "".join(f"{nprog.get(k, 1 if k == 0 else 0):5d}" for k in range(len(sizes))))
print(f"R_k stops growing after depth {closed}: {sizes[-1]} reachable states; the longest program has {max(nprog)} moves")
for x, word, d in sorted(seen.values(), key=lambda v: (v[2], -v[0].L)):
tag = " meets the target" if meets(x) else ""
print(f" depth {d}: {' '.join(word) or 'today':9s} {show(x)}{tag}")
def first_hit(tau, eps, cushion=0.0):
# the shallowest reachable state with technology >= tau, efficiency >= eps and liquidity >= floor + cushion
ok = [(d, word, x) for x, word, d in seen.values()
if x.T >= tau - 1e-9 and x.E >= eps - 1e-9 and x.L >= FLOOR + cushion - 1e-9]
return min(ok, key=lambda h: (h[0], -h[2].L)) if ok else None
levels = sorted({round(x.T, 1) for x, w, d in seen.values()})
print(f"\ntechnology levels the repertoire can reach: {levels}")
for tau, eps, cushion in ((50.0, 0.0, 0.0), (70.0, 0.0, 0.0), (70.0, 78.0, 0.0), (70.0, 80.0, 0.0), (70.0, 81.0, 0.0),
(70.0, 80.0, 115.0), (70.0, 80.0, 120.0)):
h = first_hit(tau, eps, cushion)
res = f"depth {h[0]}, {' '.join(h[1]) or 'today'}: {show(h[2])}" if h else "not reachable"
print(f" technology >= {tau:4.1f}, efficiency >= {eps:4.1f}, liquidity >= ${FLOOR + cushion:.0f}m: {res}")
target = first_hit(TARGET_T, TARGET_E)
# Theorem 6.4(iii): a complete goal. Efficiency after k recycled rounds is 85 - 14 x 0.5^k: never 85 itself
gap0, L_eff = CEIL - TODAY.E, 1 - CLOSE
assert all(abs(r[1] - (CEIL - gap0 * L_eff ** r[0])) < 1e-9 for r in rec)
print(f"\nefficiency after k rounds: 85 - {gap0:.0f} x 0.5^k; within a tolerance eps of 85 after ceil(log2({gap0:.0f}/eps)) rounds"
" (Remark 6.B.3)")
tol_rounds = {}
for eps in (2.0, 1.0, 0.5, 0.25, 0.1):
n = math.ceil(math.log(gap0 / eps) / math.log(1 / L_eff))
tol_rounds[eps] = n
print(f" eps = {eps:4.2f}: {n} rounds (efficiency {CEIL - gap0 * L_eff ** n:.4f}; one fewer leaves"
f" {CEIL - gap0 * L_eff ** (n - 1):.4f})")
print(f"halving the tolerance costs log 2 / log(1/L) = {math.log(2) / math.log(1 / L_eff):.0f} more round at L = 0.5")
print("Theorem 6.4(iii)'s own example, T x = x/2 from 1: the target {0} is never reached; [0, eps] after ceil(log2(1/eps)) steps:",
", ".join(f"eps {e}: {math.ceil(math.log2(1 / e))}" for e in (0.1, 0.01, 0.001)))
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.axvspan(180, FLOOR, color="#F6E3E3", lw=0)
ax.axvline(FLOOR, color="#B71C1C", lw=0.9, ls="--")
ax.text(186, -0.42, "below the floor:\nno result", ha="left", va="top", fontsize=7.5, color="#B71C1C", linespacing=1.0)
depth_of = {key(x): d for x, w, d in seen.values()}
for x, word, d in seen.values(): # every move that runs, from layer d to layer d + 1
for op in REPERTOIRE:
y = op(x)
if y is not None:
ax.annotate("", xy=(y.L, depth_of[key(y)]), xytext=(x.L, d),
arrowprops=dict(arrowstyle="-|>", color={"D": "#E65100", "A": "#1F4E79"}.get(op.code, "#999999"),
lw=0.8, mutation_scale=7, shrinkA=5, shrinkB=5))
elif op is D and not x.built and x.W >= W_MIN: # the build would breach the floor at its low point: no result
ax.plot(x.L - DIP, d + 0.5, "x", color="#B71C1C", ms=5, mew=1.3)
tone = lambda x: "#E65100" if meets(x) else ("#5E35B1" if x.built else "#616161")
for x, word, d in seen.values():
hit = meets(x)
ax.plot(x.L, d, "*" if hit else "o", color=tone(x), ms=14 if hit else (8 if d == 0 else 5), zorder=5)
if d == 0:
ax.text(x.L + 12, d, "today: \\$620m, T 41, E 71", ha="left", va="center", fontsize=7.5, color=tone(x))
elif hit and d == target[0]: # label the shallowest program that meets the target
ax.annotate(f"{' '.join(word)}: \\${x.L:.0f}m, T {x.T:.1f}, E {x.E:.1f}", xy=(x.L, d), xytext=(x.L - 190, d - 0.45),
ha="center", va="bottom", fontsize=7.5, color=tone(x), fontweight="bold",
arrowprops=dict(arrowstyle="-", color=tone(x), lw=0.6, shrinkB=7))
ax.plot([], [], "o", color="#616161", ms=5, label="platform not built")
ax.plot([], [], "o", color="#5E35B1", ms=5, label="platform built")
ax.plot([], [], "*", color="#E65100", ms=9, label="meets the target")
ax.plot([], [], "x", color="#B71C1C", ms=5, label="build's low below the floor")
ax.plot([], [], color="#999999", lw=1, label="sale, S or S*")
ax.plot([], [], color="#E65100", lw=1, label="digital build, D")
ax.plot([], [], color="#1F4E79", lw=1, label="automation round, A")
ax.set_yticks(range(closed + 1))
ax.set(xlim=(180, 800), ylim=(closed + 0.75, -0.6), xlabel="liquidity ($ million)", ylabel="moves from today",
title="Within two moves, only automate-then-build meets the target")
ax.legend(frameon=False, fontsize=7, loc="lower right", ncol=2, columnspacing=1.2, handlelength=1.6)
plt.tight_layout(); plt.show()depth k 0 1 2 3 4 5
states in R_k 1 5 13 21 28 28
programs of length k 1 4 9 12 11 0
R_k stops growing after depth 4: 28 reachable states; the longest program has 4 moves
depth 0: today $620m, T 41.0, W 58, E 71.0
depth 1: S $732m, T 36.9, W 53, E 71.0
depth 1: S* $712m, T 36.9, W 58, E 71.0
depth 1: D $585m, T 75.6, W 58, E 73.6
depth 1: A $500m, T 41.0, W 59, E 78.0
depth 2: D S $697m, T 68.1, W 53, E 73.6
depth 2: S* D $677m, T 71.5, W 58, E 73.6
depth 2: D S* $677m, T 68.1, W 58, E 73.6
depth 2: A S $612m, T 36.9, W 54, E 78.0
depth 2: S* A $592m, T 36.9, W 59, E 78.0
depth 2: D A $465m, T 75.6, W 59, E 79.3
depth 2: A D $465m, T 75.6, W 59, E 80.6 meets the target
depth 2: A A $380m, T 41.0, W 60, E 81.5
depth 3: D A S $577m, T 68.1, W 54, E 79.3
depth 3: A D S $577m, T 68.1, W 54, E 80.6
depth 3: S* D A $557m, T 71.5, W 59, E 79.3
depth 3: S* A D $557m, T 71.5, W 59, E 80.6 meets the target
depth 3: D S* A $557m, T 68.1, W 59, E 79.3
depth 3: A D S* $557m, T 68.1, W 59, E 80.6
depth 3: A A S $492m, T 36.9, W 55, E 81.5
depth 3: S* A A $472m, T 36.9, W 60, E 81.5
depth 4: A A S D $457m, T 71.5, W 55, E 84.1 meets the target
depth 4: S* D A A $437m, T 71.5, W 60, E 82.1 meets the target
depth 4: S* A D A $437m, T 71.5, W 60, E 82.8 meets the target
depth 4: D S* A A $437m, T 68.1, W 60, E 82.1
depth 4: A D S* A $437m, T 68.1, W 60, E 82.8
depth 4: A A S A $372m, T 36.9, W 56, E 83.2
depth 4: S* A A A $352m, T 36.9, W 61, E 83.2
technology levels the repertoire can reach: [36.9, 41.0, np.float64(68.1), np.float64(71.5), np.float64(75.6)]
technology >= 50.0, efficiency >= 0.0, liquidity >= $350m: depth 1, D: $585m, T 75.6, W 58, E 73.6
technology >= 70.0, efficiency >= 0.0, liquidity >= $350m: depth 1, D: $585m, T 75.6, W 58, E 73.6
technology >= 70.0, efficiency >= 78.0, liquidity >= $350m: depth 2, D A: $465m, T 75.6, W 59, E 79.3
technology >= 70.0, efficiency >= 80.0, liquidity >= $350m: depth 2, A D: $465m, T 75.6, W 59, E 80.6
technology >= 70.0, efficiency >= 81.0, liquidity >= $350m: depth 4, A A S D: $457m, T 71.5, W 55, E 84.1
technology >= 70.0, efficiency >= 80.0, liquidity >= $465m: depth 3, S* A D: $557m, T 71.5, W 59, E 80.6
technology >= 70.0, efficiency >= 80.0, liquidity >= $470m: depth 3, S* A D: $557m, T 71.5, W 59, E 80.6
efficiency after k rounds: 85 - 14 x 0.5^k; within a tolerance eps of 85 after ceil(log2(14/eps)) rounds (Remark 6.B.3)
eps = 2.00: 3 rounds (efficiency 83.2500; one fewer leaves 81.5000)
eps = 1.00: 4 rounds (efficiency 84.1250; one fewer leaves 83.2500)
eps = 0.50: 5 rounds (efficiency 84.5625; one fewer leaves 84.1250)
eps = 0.25: 6 rounds (efficiency 84.7812; one fewer leaves 84.5625)
eps = 0.10: 8 rounds (efficiency 84.9453; one fewer leaves 84.8906)
halving the tolerance costs log 2 / log(1/L) = 1 more round at L = 0.5
Theorem 6.4(iii)'s own example, T x = x/2 from 1: the target {0} is never reached; [0, eps] after ceil(log2(1/eps)) steps: eps 0.1: 4, eps 0.01: 7, eps 0.001: 10

Panel 7 — Stress the execution: the playbook (Worked Example 6.1, Step 4; Theorem 6.5(iii); Figure 6.2)
Suppose every round delivers one efficiency point less than designed. The efficiency step is a contraction with (each round halves the remaining gap), so by Theorem 6.5(iii) its steady state moves by at most points: efficiency settles at 83 instead of 85. Savings then top out at $120 million, exactly the cost of a round, and liquidity sinks toward $500 million but never below the $470 million precondition: the playbook survives, with only $30 million of headroom. With a two-point shortfall, savings top out at $100 million, liquidity falls below $470 million before the fifth round, and the playbook ends: a trade again. Whether automation is a strategy or a trade is set by two choices the board controls: what happens to the savings, and how closely execution tracks the design.
Python Code
cases = {"savings paid out": dict(recycle=0.0), "recycled, as designed": dict(),
"recycled, 1-point shortfall": dict(shortfall=1.0), "recycled, 2-point shortfall": dict(shortfall=2.0)}
runs = {name: playbook(**kw) for name, kw in cases.items()}
steady = {}
for s in (1.0, 2.0):
e_star = CEIL - s / (1 - L_eff) # the fixed point of e' = e + 0.5 (85 - e) - s
steady[s] = (e_star, VALUE * (e_star - TODAY.E))
print(f"{s:.0f}-point shortfall a round: efficiency settles at {e_star:.0f}, moved {CEIL - e_star:.0f} = s/(1 - L)"
f" (Theorem 6.5(iii)); savings top out at ${steady[s][1]:.0f}m against the round's ${COST:.0f}m")
r1, stop1 = runs["recycled, 1-point shortfall"]
long1, _ = playbook(shortfall=1.0, years=200)
print(f"1 point: liquidity " + " -> ".join(f"{r[4]:.2f}" for r in r1[1:7]) + f" ... -> ${long1[-1][4]:.2f}m:"
f" never below ${PRE_A:.0f}m, ${long1[-1][4] - PRE_A:.0f}m of headroom; every round runs: {stop1 is None}")
r2, stop2 = runs["recycled, 2-point shortfall"]
print(f"2 points: liquidity " + " -> ".join(f"{r[4]:.2f}" for r in r2[1:]) + f": round {stop2} not available; a trade again")
th1, th2 = thresholds(n=200, shortfall=1.0), thresholds(n=10, shortfall=2.0)
print(f"nested domains: with 1 point the core starts at ${max(th1):.2f}m (Meridian ${TODAY.L - max(th1):.0f}m inside);"
f" with 2 points round k needs " + ", ".join(f"{v:.2f}" for v in th2[:6]) + " ...: rising without bound, no core")
# the liquidity account keeps every shortfall: each year's savings fall 10 x the efficiency gap short of the design
design, _ = playbook(check=False, years=10)
short1, _ = playbook(shortfall=1.0, check=False, years=10)
gaps = [a[4] - b[4] for a, b in zip(design, short1)]
print("gap between designed and executed liquidity, 1 point, years 1-10: " + ", ".join(f"{g:.1f}" for g in gaps[1:]))
print(f" growing by close to $20m a year: efficiency forgives the error (L = 0.5), the liquidity account keeps it")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
style = {"savings paid out": ("#616161", ":"), "recycled, as designed": ("#1F4E79", "-"),
"recycled, 1-point shortfall": ("#E65100", "--"), "recycled, 2-point shortfall": ("#B71C1C", "-.")}
for name, (rows, stop) in runs.items():
yrs = [r[0] for r in rows if r[0] <= 10]
liq = [r[4] for r in rows if r[0] <= 10]
col, ls = style[name]
ax.plot(yrs, liq, color=col, ls=ls, lw=1.8, marker="o", ms=3.5,
label=name + (f": stops before round {stop}" if stop else ": runs indefinitely"))
if stop:
ax.plot(yrs[-1], liq[-1], "X", color=col, ms=9, zorder=6)
ax.axhline(PRE_A, color="#1F4E79", lw=0.9)
ax.text(10.2, PRE_A + 4, "precondition for a round: \\$470m", ha="right", va="bottom", fontsize=8, color="#1F4E79")
ax.axhline(FLOOR, color="#B71C1C", lw=0.9, ls="--")
ax.text(10.2, FLOOR + 4, "board floor: \\$350m", ha="right", va="bottom", fontsize=8, color="#B71C1C")
ax.set_xticks(range(11))
ax.set(xlim=(-0.3, 10.4), ylim=(330, 700), xlabel="year (one automation round at the start of each year)",
ylabel="liquidity at year end ($ million)", title="Recycled savings make automation a strategy (seed 26106)")
ax.legend(frameon=False, fontsize=7.5, loc="upper left", ncol=2); plt.tight_layout(); plt.show()1-point shortfall a round: efficiency settles at 83, moved 2 = s/(1 - L) (Theorem 6.5(iii)); savings top out at $120m against the round's $120m 2-point shortfall a round: efficiency settles at 81, moved 4 = s/(1 - L) (Theorem 6.5(iii)); savings top out at $100m against the round's $120m 1 point: liquidity 560.00 -> 530.00 -> 515.00 -> 507.50 -> 503.75 -> 501.88 ... -> $500.00m: never below $470m, $30m of headroom; every round runs: True 2 points: liquidity 550.00 -> 505.00 -> 472.50 -> 446.25: round 5 not available; a trade again nested domains: with 1 point the core starts at $590.00m (Meridian $30m inside); with 2 points round k needs 470.00, 540.00, 585.00, 617.50, 643.75, 666.88 ...: rising without bound, no core gap between designed and executed liquidity, 1 point, years 1-10: 10.0, 25.0, 42.5, 61.2, 80.6, 100.3, 120.2, 140.1, 160.0, 180.0 growing by close to $20m a year: efficiency forgives the error (L = 0.5), the liquidity account keeps it

Panel 8 — Stress the execution: drift and its bound (Theorem 6.5(i)–(ii); Figure 6.4; Online Appendix Remark 6.B.2)
AXIOM Lab 1.6, step 5: set the shortfall per step and the sensitivity factor , and compare the observed drift with the bound of Equation 6.4, , never more than under contraction. With a 1 percent shortfall each quarter, a consolidating program () never drifts more than 5 percent, a neutral one drifts in proportion to time, 12 percent in three years, and an amplifying one () drifts about 40 percent in three years. The bound is attained by executed as (Remark 6.B.2), so Figure 6.4's curves are the worst case itself. The lab's new draws (seed 26106) let each quarter's shortfall vary between zero and 1 percent: every observed path stays inside the bound. Hence the doctrine: match execution tolerance to the program's sensitivity factor.
Python Code
EPS, K = 1.0, 12 # 1 percent of plan a quarter, for three years
LS = (0.8, 1.0, 1.2)
def drift(L, k, eps=EPS):
# Equation 6.4: eps (1 + L + ... + L^(k-1))
return eps * k if L == 1 or k == 0 else eps * (L ** k - 1) / (L - 1)
quarters = np.arange(K + 1)
print("quarter " + "".join(f"{k:6d}" for k in quarters))
for L in LS:
print(f"L = {L:.1f} " + "".join(f"{drift(L, k):6.2f}" for k in quarters))
print(f"under contraction the drift never exceeds eps/(1 - L) = {EPS / (1 - 0.8):.0f} percent at L = 0.8")
# Remark 6.B.2: the bound is attained by T x = L x + c executed as T' x = L x + c - eps (design held at 100)
attained = {}
for L in LS:
x = xe = 100.0
for _ in range(K):
x, xe = L * x + 100 * (1 - L), L * xe + 100 * (1 - L) - EPS
attained[L] = x - xe
print(f"L = {L}: the executed path ends {x - xe:.4f} below the design; the bound is {drift(L, K):.4f}")
print("Theorem 6.5(i): an error of 1 in the starting state after 12 quarters is " + ", ".join(f"{L ** K:.3f} at L = {L}" for L in LS))
print(f"to hold the drift of a consolidating program, an amplifying one needs execution {drift(1.2, K) / drift(0.8, K):.1f} times as precise")
# the lab's new draws (seed 26106): each quarter's shortfall uniform between 0 and eps
rng = np.random.default_rng(SEED)
N = 2000
draws = rng.uniform(0.0, EPS, size=(len(LS), N, K))
paths = {}
for i, L in enumerate(LS):
d = np.zeros((N, K + 1))
for k in range(K):
d[:, k + 1] = L * d[:, k] + draws[i, :, k]
paths[L] = d
inside = bool((d <= np.array([drift(L, k) for k in quarters]) + 1e-12).all())
print(f"seed {SEED}, L = {L}: at quarter 12 mean {d[:, -1].mean():5.2f}, largest {d[:, -1].max():5.2f} of {N} paths;"
f" bound {drift(L, K):5.2f}; every path inside: {inside}")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for L, col, name in ((1.2, "#B71C1C", "amplifying, L = 1.2"), (1.0, "#616161", "neutral, L = 1.0"),
(0.8, "#1F4E79", "consolidating, L = 0.8")):
for j in range(40):
ax.plot(quarters, paths[L][j], color=col, lw=0.5, alpha=0.25)
ax.plot(quarters, [drift(L, k) for k in quarters], color=col, lw=2, marker="o", ms=3.5, label=f"{name}: worst case")
ax.text(12.25, drift(L, K), f"{drift(L, K):.1f}%", va="center", fontsize=8, color=col)
ax.axhline(EPS / (1 - 0.8), color="#1F4E79", lw=0.8, ls="--")
ax.text(0.25, 5.5, "5% bound at L = 0.8", fontsize=8, color="#1F4E79")
ax.plot([], [], color="#999999", lw=0.8, label="shortfalls drawn between 0 and 1% a quarter")
ax.set_xticks(range(0, 13, 2))
ax.set(xlim=(0, 13.4), ylim=(0, 42), xlabel="quarters of execution", ylabel="gap from the designed path (% of plan)",
title="Amplifying programs compound execution error (seed 26106)")
ax.legend(frameon=False, fontsize=8, loc="upper left"); plt.tight_layout(); plt.show()quarter 0 1 2 3 4 5 6 7 8 9 10 11 12 L = 0.8 0.00 1.00 1.80 2.44 2.95 3.36 3.69 3.95 4.16 4.33 4.46 4.57 4.66 L = 1.0 0.00 1.00 2.00 3.00 4.00 5.00 6.00 7.00 8.00 9.00 10.00 11.00 12.00 L = 1.2 0.00 1.00 2.20 3.64 5.37 7.44 9.93 12.92 16.50 20.80 25.96 32.15 39.58 under contraction the drift never exceeds eps/(1 - L) = 5 percent at L = 0.8 L = 0.8: the executed path ends 4.6564 below the design; the bound is 4.6564 L = 1.0: the executed path ends 12.0000 below the design; the bound is 12.0000 L = 1.2: the executed path ends 39.5805 below the design; the bound is 39.5805 Theorem 6.5(i): an error of 1 in the starting state after 12 quarters is 0.069 at L = 0.8, 1.000 at L = 1.0, 8.916 at L = 1.2 to hold the drift of a consolidating program, an amplifying one needs execution 8.5 times as precise seed 26106, L = 0.8: at quarter 12 mean 2.33, largest 3.64 of 2000 paths; bound 4.66; every path inside: True seed 26106, L = 1.0: at quarter 12 mean 5.98, largest 9.23 of 2000 paths; bound 12.00; every path inside: True seed 26106, L = 1.2: at quarter 12 mean 19.71, largest 30.71 of 2000 paths; bound 39.58; every path inside: True

Validation — the book's numbers, and agreement with DCT_V1_Ch06_Lab.xlsx
Each checkpoint is a number printed in Chapter 6 (Figures 6.1–6.4, Sections 6.2 and 6.5–6.7, Worked Example 6.1 and
Table 6.4), in Worked Example 3.1, which Section 6.5 cites, or in Online Appendix 6.B. Values the book prints rounded
are checked to half a unit of their last digit (the book rounds halves up). The workbook recomputes the ones marked
workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.
Python Code
T64 = {r[0]: r for r in rec}
checks = [
("precondition for a round, liquidity (workbook)", PRE_A, 470, 0),
("precondition for the build, liquidity (workbook)", PRE_D, 488, 0.5),
("moves possible from today (workbook)", n_first, 4, 0),
("one round from today: liquidity (workbook)", one.L, 500, 0),
("one round from today: efficiency (workbook)", one.E, 78, 0),
("sell, engineers leave: liquidity (workbook)", first["S"].L, 732, 0),
("sell, engineers leave: technology (workbook)", first["S"].T, 36.9, 1e-9),
("sell, engineers leave: workforce (workbook)", first["S"].W, 53, 0),
("sell, engineers kept: liquidity (workbook)", first["S*"].L, 712, 0),
("two-move programs reaching the target (workbook)", len(hits), 1, 0),
("A then D: liquidity (workbook)", win.L, 465, 0.5),
("A then D: efficiency (workbook)", win.E, 80.6, 0.05),
("A then D: headroom at the low point (workbook)", first["A"].L - DIP - FLOOR, 12, 0.5),
("D then A: efficiency (workbook)", other.E, 79.3, 0.05),
("A then S: liquidity (workbook)", pairs[("A", "S")].L, 612, 0),
("A then S: workforce (workbook)", pairs[("A", "S")].W, 54, 0),
("A then S*: liquidity (workbook)", pairs[("A", "S*")].L, 592, 0),
("A then A: liquidity (workbook)", pairs[("A", "A")].L, 380, 0),
("S*, A, A, D: end liquidity, floor ignored (workbook)", end.L, 437, 0.5),
("S*, A, A, D: low point (workbook)", mid, 334, 0.5),
("paid out: liquidity after round 2 (workbook)", paid[2][4], 380, 0),
("paid out: rounds that run (workbook)", len(paid) - 1, 2, 0),
("paid out: extra liquidity each round needs (workbook)", th_paid[1] - th_paid[0], 120, 0),
] + [
(f"Table 6.4: efficiency, year {y} (workbook)", T64[y][1], v, 0.005)
for y, v in zip(range(1, 7), (78.00, 81.50, 83.25, 84.13, 84.56, 84.78))
] + [
(f"Table 6.4: savings, year {y} (workbook)", T64[y][2], v, 0.05)
for y, v in zip(range(1, 7), (70.0, 105.0, 122.5, 131.3, 135.6, 137.8))
] + [
(f"Table 6.4: savings less cost, year {y} (workbook)", T64[y][3], v, 0.05)
for y, v in zip(range(1, 7), (-50.0, -15.0, 2.5, 11.3, 15.6, 17.8))
] + [
(f"Table 6.4: liquidity, year {y} (workbook)", T64[y][4], v, 0.05)
for y, v in zip(range(1, 7), (570.0, 555.0, 557.5, 568.8, 584.4, 602.2))
] + [
("recycled: first year savings exceed the cost (workbook)", self_year, 3, 0),
("recycled: lowest liquidity (workbook)", low[4], 555, 0),
("recycled: long-run yearly rise of liquidity (workbook)", rec[-1][3], 20, 1e-6),
("core threshold at today's efficiency (workbook)", core, 535, 1e-9),
("core threshold by bisection", hi, 535, 1e-6),
("Meridian's margin inside the core (workbook)", TODAY.L - core, 85, 1e-9),
("1-point shortfall: steady efficiency (workbook)", steady[1.0][0], 83, 0),
("steady-state shift bound 1/(1 - 0.5) (workbook)", 1.0 / (1 - L_eff), 2, 0),
("1-point shortfall: savings top out (workbook)", steady[1.0][1], 120, 1e-9),
("1-point shortfall: liquidity tends to (workbook)", long1[-1][4], 500, 1e-6),
("1-point shortfall: headroom (workbook)", long1[-1][4] - PRE_A, 30, 1e-6),
("2-point shortfall: savings top out (workbook)", steady[2.0][1], 100, 1e-9),
("2-point shortfall: round that fails (workbook)", stop2, 5, 0),
("drift bound at L = 0.8, percent (workbook)", EPS / (1 - 0.8), 5, 1e-9),
("drift after 12 quarters, L = 0.8 (workbook)", drift(0.8, K), 4.7, 0.05),
("drift after 12 quarters, L = 1.0 (workbook)", drift(1.0, K), 12, 1e-9),
("drift after 12 quarters, L = 1.2 (workbook)", drift(1.2, K), 40, 0.5),
("bound less the worst case, L = 1.2 (workbook)", drift(1.2, K) - attained[1.2], 0, 1e-9),
("bank: liquidity after one year (workbook)", bank[1][1], 600, 1e-9),
("bank: liquidity after two years (workbook)", bank[2][1], 450, 1e-9),
("bank: liquidity after three years (workbook)", bank[3][1], 375, 1e-9),
("bank: liquidity after four years (workbook)", bank[4][1], 337.5, 1e-9),
("bank: technology after one year (workbook)", bank[1][3], 56, 1e-9),
("bank: technology after two years (workbook)", bank[2][3], 63.5, 1e-9),
("bank: total invested, the initial slack (workbook)", invested, 600, 1e-6),
("bank: technology in the limit (workbook)", bank[-1][3], 71, 1e-6),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
status = "PASS" if abs(got - want) <= tol + 1e-9 else "FAIL"
ok += status == "PASS"
print(f"{name:{width}s} {got:10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")precondition for a round, liquidity (workbook) 470.0000 book 470.0000 PASS precondition for the build, liquidity (workbook) 488.0821 book 488.0000 PASS moves possible from today (workbook) 4.0000 book 4.0000 PASS one round from today: liquidity (workbook) 500.0000 book 500.0000 PASS one round from today: efficiency (workbook) 78.0000 book 78.0000 PASS sell, engineers leave: liquidity (workbook) 732.0000 book 732.0000 PASS sell, engineers leave: technology (workbook) 36.9000 book 36.9000 PASS sell, engineers leave: workforce (workbook) 53.0000 book 53.0000 PASS sell, engineers kept: liquidity (workbook) 712.0000 book 712.0000 PASS two-move programs reaching the target (workbook) 1.0000 book 1.0000 PASS A then D: liquidity (workbook) 464.6327 book 465.0000 PASS A then D: efficiency (workbook) 80.5983 book 80.6000 PASS A then D: headroom at the low point (workbook) 11.9179 book 12.0000 PASS D then A: efficiency (workbook) 79.2992 book 79.3000 PASS A then S: liquidity (workbook) 612.0000 book 612.0000 PASS A then S: workforce (workbook) 54.0000 book 54.0000 PASS A then S*: liquidity (workbook) 592.0000 book 592.0000 PASS A then A: liquidity (workbook) 380.0000 book 380.0000 PASS S*, A, A, D: end liquidity, floor ignored (workbook) 436.6327 book 437.0000 PASS S*, A, A, D: low point (workbook) 333.9179 book 334.0000 PASS paid out: liquidity after round 2 (workbook) 380.0000 book 380.0000 PASS paid out: rounds that run (workbook) 2.0000 book 2.0000 PASS paid out: extra liquidity each round needs (workbook) 120.0000 book 120.0000 PASS Table 6.4: efficiency, year 1 (workbook) 78.0000 book 78.0000 PASS Table 6.4: efficiency, year 2 (workbook) 81.5000 book 81.5000 PASS Table 6.4: efficiency, year 3 (workbook) 83.2500 book 83.2500 PASS Table 6.4: efficiency, year 4 (workbook) 84.1250 book 84.1300 PASS Table 6.4: efficiency, year 5 (workbook) 84.5625 book 84.5600 PASS Table 6.4: efficiency, year 6 (workbook) 84.7812 book 84.7800 PASS Table 6.4: savings, year 1 (workbook) 70.0000 book 70.0000 PASS Table 6.4: savings, year 2 (workbook) 105.0000 book 105.0000 PASS Table 6.4: savings, year 3 (workbook) 122.5000 book 122.5000 PASS Table 6.4: savings, year 4 (workbook) 131.2500 book 131.3000 PASS Table 6.4: savings, year 5 (workbook) 135.6250 book 135.6000 PASS Table 6.4: savings, year 6 (workbook) 137.8125 book 137.8000 PASS Table 6.4: savings less cost, year 1 (workbook) -50.0000 book -50.0000 PASS Table 6.4: savings less cost, year 2 (workbook) -15.0000 book -15.0000 PASS Table 6.4: savings less cost, year 3 (workbook) 2.5000 book 2.5000 PASS Table 6.4: savings less cost, year 4 (workbook) 11.2500 book 11.3000 PASS Table 6.4: savings less cost, year 5 (workbook) 15.6250 book 15.6000 PASS Table 6.4: savings less cost, year 6 (workbook) 17.8125 book 17.8000 PASS Table 6.4: liquidity, year 1 (workbook) 570.0000 book 570.0000 PASS Table 6.4: liquidity, year 2 (workbook) 555.0000 book 555.0000 PASS Table 6.4: liquidity, year 3 (workbook) 557.5000 book 557.5000 PASS Table 6.4: liquidity, year 4 (workbook) 568.7500 book 568.8000 PASS Table 6.4: liquidity, year 5 (workbook) 584.3750 book 584.4000 PASS Table 6.4: liquidity, year 6 (workbook) 602.1875 book 602.2000 PASS recycled: first year savings exceed the cost (workbook) 3.0000 book 3.0000 PASS recycled: lowest liquidity (workbook) 555.0000 book 555.0000 PASS recycled: long-run yearly rise of liquidity (workbook) 20.0000 book 20.0000 PASS core threshold at today's efficiency (workbook) 535.0000 book 535.0000 PASS core threshold by bisection 535.0000 book 535.0000 PASS Meridian's margin inside the core (workbook) 85.0000 book 85.0000 PASS 1-point shortfall: steady efficiency (workbook) 83.0000 book 83.0000 PASS steady-state shift bound 1/(1 - 0.5) (workbook) 2.0000 book 2.0000 PASS 1-point shortfall: savings top out (workbook) 120.0000 book 120.0000 PASS 1-point shortfall: liquidity tends to (workbook) 500.0000 book 500.0000 PASS 1-point shortfall: headroom (workbook) 30.0000 book 30.0000 PASS 2-point shortfall: savings top out (workbook) 100.0000 book 100.0000 PASS 2-point shortfall: round that fails (workbook) 5.0000 book 5.0000 PASS drift bound at L = 0.8, percent (workbook) 5.0000 book 5.0000 PASS drift after 12 quarters, L = 0.8 (workbook) 4.6564 book 4.7000 PASS drift after 12 quarters, L = 1.0 (workbook) 12.0000 book 12.0000 PASS drift after 12 quarters, L = 1.2 (workbook) 39.5805 book 40.0000 PASS bound less the worst case, L = 1.2 (workbook) -0.0000 book 0.0000 PASS bank: liquidity after one year (workbook) 600.0000 book 600.0000 PASS bank: liquidity after two years (workbook) 450.0000 book 450.0000 PASS bank: liquidity after three years (workbook) 375.0000 book 375.0000 PASS bank: liquidity after four years (workbook) 337.5000 book 337.5000 PASS bank: technology after one year (workbook) 56.0000 book 56.0000 PASS bank: technology after two years (workbook) 63.5000 book 63.5000 PASS bank: total invested, the initial slack (workbook) 600.0000 book 600.0000 PASS bank: technology in the limit (workbook) 71.0000 book 71.0000 PASS 73 of 73 checkpoints PASS
Next. Chapter 7 assembles the machine: the company as a process that unfolds in time under its inherited momentum, management's decisions and a changing environment, with steady states, stability tests and management itself as a feedback rule. Theorem 6.1(iii) is the bridge: a policy turns a family of operators into a closed-loop system. AXIOM-06 runs the same model interactively (Lab 1.6); this notebook and the workbook are its reproducible record.


