Skip to content

Vol. I, Ch. 6

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 uu is a decision, so the program is a family Tu(q,t)=(q−u, t+0.05u)T_u(q, t) = (q - u,\ t + 0.05u) with domain q−u≥300q - u \ge 300. The board's rule, invest half of the liquidity above the floor each year, u(q)=12(q−300)u(q) = \tfrac12(q - 300), selects one operator at every state and leaves a single closed-loop map, q′=12(q+300)q' = \tfrac12(q + 300): a contraction with L=1/2L = 1/2 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: dom⁡Tk+1={x∈dom⁡Tk:Tkx∈dom⁡T}\operatorname{dom}T^{k+1} = \{x \in \operatorname{dom}T^{k} : T^{k}x \in \operatorname{dom}T\} (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 kk-th round requires today's liquidity of at least 470+120(k−1)470 + 120(k - 1) 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
Recycled savings stop the nested domains from shrinking (seed 26106)

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, Rk+1=Rk∪⋃iTi(Rk∩dom⁡Ti)R_{k+1} = R_k \cup \bigcup_i T_i(R_k \cap \operatorname{dom}T_i), 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 kk recycled rounds is 85−14⋅0.5k85 - 14 \cdot 0.5^{k} (the first row of Table 6.4), so the ceiling of 85 is approached but never reached. Within a tolerance ε\varepsilon it is reached after ⌈log⁡2(14/ε)⌉\lceil \log_2(14/\varepsilon) \rceil 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
Within two moves, only automate-then-build meets the target

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 L=0.5L = 0.5 (each round halves the remaining gap), so by Theorem 6.5(iii) its steady state moves by at most 1/(1−0.5)=21/(1 - 0.5) = 2 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
Recycled savings make automation a strategy (seed 26106)

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 ε\varepsilon and the sensitivity factor LL, and compare the observed drift with the bound of Equation 6.4, ε(1+L+⋯+Lk−1)\varepsilon(1 + L + \cdots + L^{k-1}), never more than ε/(1−L)\varepsilon/(1 - L) under contraction. With a 1 percent shortfall each quarter, a consolidating program (L=0.8L = 0.8) never drifts more than 5 percent, a neutral one drifts in proportion to time, 12 percent in three years, and an amplifying one (L=1.2L = 1.2) drifts about 40 percent in three years. The bound is attained by Tx=Lx+cTx = Lx + c executed as Lx+c−εLx + c - \varepsilon (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
Amplifying programs compound execution error (seed 26106)

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.