DCT Laboratory — Volume I, Chapter 2
Enterprise Systems and Transformation
This laboratory demonstrates
Seed 26102 · Companion to Chapter 2 and AXIOM Lab 1.2 (module AXIOM-02) · Mirrored in DCT_V1_Ch02_Lab.xlsx
This laboratory reproduces Worked Example 2.1, Where Does Meridian End?, with the book's declarations, and works the five steps of AXIOM Lab 1.2: draw boundary A, move the dealers inside, change levels, close the loop, map a loop. Every Meridian number below is the book's (Table 2.6, Figures 2.2–2.3, Online Appendix 2.B; for the feedback bench, Meridian's efficiency in the Chapter 1 model, Tables 1.9 and 5.5); the final cell checks them. Money is in $ million.
The declarations (Worked Example 2.1, Step 1)
Industrial Systems sells $2.56 billion, 61 percent of Meridian's $4.2 billion. Of this, $1.54 billion, about 60 percent, is shipped to independent dealers, who resell to end customers at about 20 percent above Meridian's price. The analysis needs six entities (suppliers, Meridian, the dealer network, end customers, capital markets, the regulator) and nine typed flows , each of a type in Definition 2.3's list: capital, goods, services, information, personnel. The book values four of them a year (Table 2.6).
Python Code
import itertools
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({"figure.dpi": 110, "axes.spines.top": False, "axes.spines.right": False})
SEED = 26102
REVENUE, IS_SHARE = 4200.0, 0.61 # Meridian's revenue; Industrial Systems' share (Chapter 1)
SHIP, MARKUP = 1540.0, 0.20 # shipped to independent dealers; the dealers' resale markup
IS_SALES = REVENUE * IS_SHARE
RESALE = SHIP * (1 + MARKUP)
ENTITIES = ["Suppliers", "Meridian", "Dealer network", "End customers", "Capital markets", "Regulator"]
FLOWS = [ # Table 2.6: id, from, to, what flows, type, value a year ($ million; None where the book gives none)
("F1", "Suppliers", "Meridian", "components", "goods", None),
("F2", "Meridian", "Suppliers", "payments", "capital", None),
("F3", "Meridian", "Dealer network", "shipments", "goods", SHIP),
("F4", "Dealer network", "Meridian", "payments", "capital", SHIP),
("F5", "Dealer network", "End customers", "sales", "goods", RESALE),
("F6", "End customers", "Dealer network", "payments", "capital", RESALE),
("F7", "Dealer network", "Meridian", "market intelligence", "information", None),
("F8", "Capital markets", "Meridian", "funding", "capital", None),
("F9", "Regulator", "Meridian", "rules", "information", None),
]
CLASSES = ("interior", "input", "output", "environmental")
def classify(src, dst, B):
# Definition 2.3: a flow's class depends only on whether its two ends lie inside the boundary B
return {(True, True): "interior", (False, True): "input", (True, False): "output",
(False, False): "environmental"}[(src in B, dst in B)]
def classification(B, flows=FLOWS):
return {f[0]: classify(f[1], f[2], B) for f in flows}
def counts(cls):
return {c: sum(v == c for v in cls.values()) for c in CLASSES}
def goods_output(cls):
# the goods that leave the perimeter, valued: what each team reports as "sales"
return sum(v for fid, s, d, what, kind, v in FLOWS if kind == "goods" and cls[fid] == "output" and v is not None)
print(f"Industrial Systems' sales {IS_SALES:,.0f} ({100*IS_SHARE:.0f}% of {REVENUE:,.0f}); "
f"shipped to dealers {SHIP:,.0f} = {100*SHIP/IS_SALES:.1f}% of it")
print(f"dealers' sales to end customers {SHIP:,.0f} x {1+MARKUP:.2f} = {RESALE:,.0f}")
print(f"{len(ENTITIES)} entities, {len(FLOWS)} flows; types used:", sorted({f[4] for f in FLOWS}))Industrial Systems' sales 2,562 (61% of 4,200); shipped to dealers 1,540 = 60.1% of it dealers' sales to end customers 1,540 x 1.20 = 1,848 6 entities, 9 flows; types used: ['capital', 'goods', 'information']
Panel 1 — Draw boundary A (Worked Example 2.1, Step 2; Table 2.6)
AXIOM Lab 1.2, step 1: place only Meridian inside the perimeter and record what each flow becomes. By Definition 2.3 a flow is interior if both ends lie inside, an input if it enters, an output if it leaves, and environmental if neither end is inside. Meridian's goods output to the market is its shipments to dealers, $1,540 million; the dealers' sales to end customers do not touch the boundary at all, and Meridian learns about end demand only through the dealers' market intelligence, an input.
Python Code
A = {"Meridian"}
clsA = classification(A)
print("flow from -> to what flows boundary A")
for fid, s, d, what, kind, v in FLOWS:
val = f", {v:,.0f}" if v else ""
print(f"{fid:4s} {s + ' -> ' + d:36s} {what + val:21s} {clsA[fid]}")
nA = counts(clsA)
print("\ninterior / input / output / environmental:", " / ".join(str(nA[c]) for c in CLASSES))
print(f"goods output under boundary A: {goods_output(clsA):,.0f}")flow from -> to what flows boundary A F1 Suppliers -> Meridian components input F2 Meridian -> Suppliers payments output F3 Meridian -> Dealer network shipments, 1,540 output F4 Dealer network -> Meridian payments, 1,540 input F5 Dealer network -> End customers sales, 1,848 environmental F6 End customers -> Dealer network payments, 1,848 environmental F7 Dealer network -> Meridian market intelligence input F8 Capital markets -> Meridian funding input F9 Regulator -> Meridian rules input interior / input / output / environmental: 0 / 5 / 2 / 2 goods output under boundary A: 1,540
Panel 2 — Move the dealers inside (Worked Example 2.1, Steps 3–5; Theorem 2.2(i)–(ii))
AXIOM Lab 1.2, step 2: drag the dealer network across the line and read the conservation panel. Shipments, dealer payments and market intelligence become interior; the goods output is now the dealers' sales to end customers, , and end-customer payments become an input. The four classes are computed below from their definitions, separately, so the panel can test Theorem 2.2: every flow lands in exactly one class, and the set of flows is the same under both boundaries.
Python Code
B = {"Meridian", "Dealer network"}
clsB = classification(B)
print("flow boundary A boundary B")
for fid in clsA:
mark = " relabeled" if clsA[fid] != clsB[fid] else ""
print(f"{fid:4s} {clsA[fid]:16s} {clsB[fid]:16s}{mark}")
nB = counts(clsB)
print("\ninterior / input / output / environmental: A", " / ".join(str(nA[c]) for c in CLASSES),
" B", " / ".join(str(nB[c]) for c in CLASSES))
def classes_by_definition(Bx, flows=FLOWS):
# the four sets of Definition 2.3, each from its own membership test
return {"interior": {f[0] for f in flows if f[1] in Bx and f[2] in Bx},
"input": {f[0] for f in flows if f[1] not in Bx and f[2] in Bx},
"output": {f[0] for f in flows if f[1] in Bx and f[2] not in Bx},
"environmental": {f[0] for f in flows if f[1] not in Bx and f[2] not in Bx}}
def conservation(Bx, flows=FLOWS):
S = classes_by_definition(Bx, flows)
ids = {f[0] for f in flows}
not_once = sum(sum(f in s for s in S.values()) != 1 for f in ids) # Theorem 2.2(i)
return not_once, set().union(*S.values()) == ids, sum(len(s) for s in S.values()) # (ii)
for name, Bx in (("A", A), ("B", B)):
bad, same, total = conservation(Bx)
print(f"conservation panel, boundary {name}: {total} flows; flows not in exactly one class: {bad}; "
f"the same nine flows: {'yes' if same else 'no'}")
changed = [f for f in clsA if clsA[f] != clsB[f]]
gap = goods_output(clsB) - goods_output(clsA)
print(f"\nrelabeled by the move: {', '.join(changed)} ({len(changed)} flows); no flow created or destroyed")
print(f"goods output: A {goods_output(clsA):,.0f}, B {goods_output(clsB):,.0f}; difference {gap:,.0f} = "
f"{100*gap/goods_output(clsA):.0f}% of shipments, the dealers' gross margin {RESALE - SHIP:,.0f}")
money = {name: {c: sum(v for f, s, d, w, k, v in FLOWS if v and cl[f] == c) for c in CLASSES} for name, cl in (("A", clsA), ("B", clsB))}
for name in ("A", "B"):
print(f"valued flows by class, boundary {name}:", {c: round(x) for c, x in money[name].items()}, "total", round(sum(money[name].values())))
print(f"end-customer demand: sales F5 {clsA['F5']} -> {clsB['F5']}, payments F6 {clsA['F6']} -> {clsB['F6']}: "
"seen directly, if Meridian can get the data")
print("controllability: unchanged; the dealers remain independent businesses")
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.6, 1]})
xs = np.arange(len(CLASSES))
ax1.bar(xs - 0.2, [nA[c] for c in CLASSES], 0.4, color="#616161", label="boundary A: dealers outside")
ax1.bar(xs + 0.2, [nB[c] for c in CLASSES], 0.4, color="#1F4E79", label="boundary B: dealers inside")
for i, c in enumerate(CLASSES):
ax1.text(i - 0.2, nA[c] + 0.1, str(nA[c]), ha="center", fontsize=8)
ax1.text(i + 0.2, nB[c] + 0.1, str(nB[c]), ha="center", fontsize=8)
ax1.set_xticks(xs, CLASSES)
ax1.set(ylabel="flows (count)", ylim=(0, 6.5))
ax1.legend(frameon=False, fontsize=8)
ax2.bar([0, 1], [goods_output(clsA), goods_output(clsB)], 0.6, color=["#616161", "#1F4E79"])
ax2.bar([1], [gap], 0.6, bottom=[goods_output(clsA)], color="#E65100", label=f"dealers' margin {gap:,.0f}")
for i, v in enumerate((goods_output(clsA), goods_output(clsB))):
ax2.text(i, v + 25, f"{v:,.0f}", ha="center", fontsize=8)
ax2.set_xticks([0, 1], ["A", "B"])
ax2.set(ylabel="goods output ($ million a year)", ylim=(0, 2150))
ax2.legend(frameon=False, fontsize=8, loc="upper left")
fig.suptitle("Two boundaries, nine flows: goods output 1,540 or 1,848 (seed 26102)", fontsize=10)
plt.tight_layout(); plt.show()flow boundary A boundary B
F1 input input
F2 output output
F3 output interior relabeled
F4 input interior relabeled
F5 environmental output relabeled
F6 environmental input relabeled
F7 input interior relabeled
F8 input input
F9 input input
interior / input / output / environmental: A 0 / 5 / 2 / 2 B 3 / 4 / 2 / 0
conservation panel, boundary A: 9 flows; flows not in exactly one class: 0; the same nine flows: yes
conservation panel, boundary B: 9 flows; flows not in exactly one class: 0; the same nine flows: yes
relabeled by the move: F3, F4, F5, F6, F7 (5 flows); no flow created or destroyed
goods output: A 1,540, B 1,848; difference 308 = 20% of shipments, the dealers' gross margin 308
valued flows by class, boundary A: {'interior': 0, 'input': 1540, 'output': 1540, 'environmental': 3696} total 6776
valued flows by class, boundary B: {'interior': 3080, 'input': 1848, 'output': 1848, 'environmental': 0} total 6776
end-customer demand: sales F5 environmental -> output, payments F6 environmental -> input: seen directly, if Meridian can get the data
controllability: unchanged; the dealers remain independent businesses

Panel 3 — Repeat with other entities: which moves change nothing (Theorem 2.2(iii); Corollary 2.B.2)
AXIOM Lab 1.2, step 2, second part. Theorem 2.2(iii): two boundaries classify the flows identically exactly when they agree on every entity that takes part in some flow. In Meridian's map all six entities take part in a flow, so every one of the boundaries gives a different classification and every move relabels something. A boundary debate is idle only for entities outside the flows being analyzed (Online Appendix Corollary 2.B.2): for the goods question alone, capital markets and the regulator can sit on either side of the line.
Python Code
ALL = [frozenset(e for e, bit in zip(ENTITIES, bits) if bit) for bits in itertools.product((0, 1), repeat=len(ENTITIES))]
def theorem_iii_breaches(flows):
# pairs of boundaries whose classifications agree but which differ on an entity that takes part in a flow, or vice versa
EF = {f[1] for f in flows} | {f[2] for f in flows}
sig = [tuple(classify(f[1], f[2], Bx) for f in flows) for Bx in ALL]
return sum((sig[i] == sig[j]) != ((ALL[i] & EF) == (ALL[j] & EF)) for i in range(len(ALL)) for j in range(len(ALL))), len(set(sig)), EF
worst = max(conservation(Bx)[0] for Bx in ALL)
totals = sorted({conservation(Bx)[2] for Bx in ALL})
breaches, n_distinct, EF = theorem_iii_breaches(FLOWS)
print(f"{len(ALL)} boundaries: flows counted per boundary {totals}; flows not in exactly one class, worst case: {worst}")
print(f"distinct classifications: {n_distinct}; pairs that break Theorem 2.2(iii): {breaches}")
print("\nmove one entity, starting from boundary A flows relabeled")
moves = {}
for e in ENTITIES:
Bx = A ^ {e}
rel = [f for f, c in classification(Bx).items() if c != clsA[f]]
moves[e] = len(rel)
verb = "outside" if e in A else "inside"
print(f" {e + ' ' + verb:28s} {len(rel)}: {', '.join(rel)}")
print("moves that change nothing:", [e for e in ENTITIES if moves[e] == 0] or "none: every entity takes part in some flow")
distinct = {}
for kind in ("goods", "capital", "information"):
sub = [f for f in FLOWS if f[4] == kind]
b, n, EFk = theorem_iii_breaches(sub)
distinct[kind] = n
free = [e for e in ENTITIES if e not in EFk]
print(f"{kind:11s} flows {', '.join(f[0] for f in sub):14s}: {n:2d} distinct classifications; breaches {b}; free to move: {free}")
rows = []
for Bx in ALL:
if "Meridian" in Bx:
n = counts(classification(Bx))
rows.append((len(Bx), -n["interior"], Bx == A, Bx == B, [n[c] for c in CLASSES]))
rows.sort(key=lambda r: (r[0], r[1]))
fig, ax = plt.subplots(figsize=(7.6, 3.6))
bottom = np.zeros(len(rows))
for j, (c, col) in enumerate(zip(CLASSES, ("#1F4E79", "#E65100", "#B71C1C", "#999999"))):
v = np.array([r[4][j] for r in rows])
ax.bar(np.arange(len(rows)), v, 0.8, bottom=bottom, color=col, label=c)
bottom += v
for i, r in enumerate(rows):
if r[2] or r[3]:
ax.text(i, 9.15, "A" if r[2] else "B", ha="center", fontsize=8, fontweight="bold")
ax.set(xlabel="the 32 boundaries that keep Meridian inside, by number of entities inside", ylabel="flows (count)",
ylim=(0, 10), title="Every boundary classifies the same nine flows (seed 26102)")
ax.legend(frameon=False, fontsize=8, ncol=4, loc="upper center", bbox_to_anchor=(0.5, -0.2))
plt.tight_layout(); plt.show()64 boundaries: flows counted per boundary [9]; flows not in exactly one class, worst case: 0 distinct classifications: 64; pairs that break Theorem 2.2(iii): 0 move one entity, starting from boundary A flows relabeled Suppliers inside 2: F1, F2 Meridian outside 7: F1, F2, F3, F4, F7, F8, F9 Dealer network inside 5: F3, F4, F5, F6, F7 End customers inside 2: F5, F6 Capital markets inside 1: F8 Regulator inside 1: F9 moves that change nothing: none: every entity takes part in some flow goods flows F1, F3, F5 : 16 distinct classifications; breaches 0; free to move: ['Capital markets', 'Regulator'] capital flows F2, F4, F6, F8: 32 distinct classifications; breaches 0; free to move: ['Regulator'] information flows F7, F9 : 8 distinct classifications; breaches 0; free to move: ['Suppliers', 'End customers', 'Capital markets']

The rule for the board (Worked Example 2.1, Step 6). The $308 million gap is a boundary difference, not a performance difference: the two teams agree on the facts. Options must be compared under one declared boundary, and every result reported as conditional on it. Boundary B suits the digital option's question (what do end customers buy, and could Meridian serve them directly?); boundary A suits the turnaround's (what does Meridian's own operation earn?). Drawing the dealers inside changes the labels, not control: they remain independent.
Panel 4 — Change levels (Definition 2.4; Figure 2.3)
AXIOM Lab 1.2, step 3: zoom from group to division to unit. Meridian is a system of systems: the group, its three divisions and their units (Figure 2.3). By Definition 2.4 a subsystem's environment is its parent's environment plus its sibling subsystems, so the environment changes with the level. The same boundary machinery then classifies the coupling Figure 2.3 draws between the divisions — Digital Solutions' demands for engineers and capital reach Industrial Systems through it.
Python Code
HIERARCHY = {"Meridian Group": ["Industrial Systems", "Digital Solutions", "Advanced Materials"],
"Industrial Systems": ["Plants", "Service"], "Digital Solutions": ["Platform", "Apps"],
"Advanced Materials": ["Polymers", "Composites"]}
PARENT = {c: p for p, cs in HIERARCHY.items() for c in cs}
DIVISIONS = HIERARCHY["Meridian Group"]
UNITS = [u for d in DIVISIONS for u in HIERARCHY[d]]
def environment(s):
# Definition 2.4: the parent's environment plus the sibling subsystems
if s not in PARENT:
return ["the external environment"]
p = PARENT[s]
return environment(p) + [x for x in HIERARCHY[p] if x != s]
print(f"Meridian: {len(DIVISIONS)} divisions, {len(UNITS)} units (Figure 2.3)\n")
print("level system inside environment")
for level, s in (("group", "Meridian Group"), ("division", "Digital Solutions"), ("unit", "Platform")):
inside = f"{len(DIVISIONS)} divisions, {len(UNITS)} units" if s == "Meridian Group" else ", ".join(HIERARCHY.get(s, ["-"]))
env = environment(s)
print(f"{level:9s} {s:19s} {inside:22s} {env[0]}" + "".join(f" + {x}" for x in env[1:]))
siblings_DS = [x for x in environment("Digital Solutions") if x in DIVISIONS]
print(f"Digital Solutions' environment holds {len(siblings_DS)} sibling divisions and their {2 * len(siblings_DS)} units")
SHORT = {"Industrial Systems": "IS", "Digital Solutions": "DS", "Advanced Materials": "AM"}
COUPLING = [("C1", "Industrial Systems", "Digital Solutions"), ("C2", "Digital Solutions", "Industrial Systems"),
("C3", "Digital Solutions", "Advanced Materials"), ("C4", "Advanced Materials", "Digital Solutions")]
print("\nthe coupling Figure 2.3 draws, both ways: " + "".join(f"{c[0] + ' ' + SHORT[c[1]] + '->' + SHORT[c[2]]:15s}" for c in COUPLING))
levels = {}
for name, Bx in (("the group", set(DIVISIONS)), ("Industrial Systems", {"Industrial Systems"}),
("Digital Solutions", {"Digital Solutions"}), ("Advanced Materials", {"Advanced Materials"})):
cl = {c[0]: classify(c[1], c[2], Bx) for c in COUPLING}
levels[name] = cl
print(f"boundary around {name:20s} " + "".join(f"{cl[c[0]]:15s}" for c in COUPLING))
print("interior at the group level; at the division level it crosses the boundary of each division it joins,"
"\nand is environmental for the third")Meridian: 3 divisions, 6 units (Figure 2.3) level system inside environment group Meridian Group 3 divisions, 6 units the external environment division Digital Solutions Platform, Apps the external environment + Industrial Systems + Advanced Materials unit Platform - the external environment + Industrial Systems + Advanced Materials + Apps Digital Solutions' environment holds 2 sibling divisions and their 4 units the coupling Figure 2.3 draws, both ways: C1 IS->DS C2 DS->IS C3 DS->AM C4 AM->DS boundary around the group interior interior interior interior boundary around Industrial Systems output input environmental environmental boundary around Digital Solutions input output output input boundary around Advanced Materials environmental environmental input output interior at the group level; at the division level it crosses the boundary of each division it joins, and is environmental for the third
Panel 5 — Close the loop: feedback (Definition 2.5; Proposition 2.2; Tables 1.9 and 5.5)
AXIOM Lab 1.2, step 4: the feedback bench runs an efficiency example. Here it is Meridian's: operational efficiency is 71 today (Table 3.1), and the operational turnaround of Chapter 1's model takes it toward a target of 79 at a speed of 0.60 a year (Online Appendix Table 1.B.1). Read as a rule, that program is state feedback (Definition 2.5): each year it acts on the gap, , with , so and the gap shrinks by the factor 0.549 a year (Worked Example 5.1). Switch the feedback off and the gap stays where it is; vary the gain and the loop speeds up, then overshoots. By Proposition 2.2 the company with its rule is again a system: one path for every environment.
Python Code
X0_EFF, TARGET, SPEED = 71.0, 79.0, 0.60 # efficiency today; the turnaround's target and speed (Chapter 1 model)
K_T = 1 - np.exp(-SPEED) # share of the gap the program closes each year
def run(gain, years=20, x0=X0_EFF, w=None):
x = [x0]
for k in range(years):
u = gain * (TARGET - x[-1]) # state feedback: the decision is set by the rule from the state
x.append(x[-1] + u + (0.0 if w is None else w[k]))
return np.array(x)
path = run(K_T)
print(f"gain of the turnaround's rule K = {K_T:.4f}; the gap is multiplied by {1 - K_T:.4f} a year")
print("year " + "".join(f"{k:8d}" for k in (0, 1, 3, 5, 11)))
print("feedback on " + "".join(f"{path[k]:8.2f}" for k in (0, 1, 3, 5, 11)), " (Table 5.5: 71.0, 74.6, 77.7, 78.6, 79.0)")
print("feedback off " + "".join(f"{run(0.0)[k]:8.2f}" for k in (0, 1, 3, 5, 11)), " (no rule: the gap of 8 points stays)")
gains = [0.0, 0.25, K_T, 1.0, 1.6, 2.2]
for g in gains:
p = run(g)
years_in = next((k for k in range(len(p)) if np.all(np.abs(p[k:] - TARGET) <= 0.5)), None)
shape = "never" if years_in is None else f"from year {years_in}"
print(f"gain {g:5.3f}: years 1-4 {np.round(p[1:5], 2)}; within half a point of 79 {shape}")
def closed_loop(x, w, K=K_T):
# Proposition 2.2: substitute the rule into the transition, f~(x, w) = f(x, phi(x), w): one map of state and input
return (1 - K) * x + K * TARGET + w
rng = np.random.default_rng(SEED)
W = rng.normal(0.0, 1.0, size=(1000, 20)) # 1,000 environment paths (any paths would do)
gap22 = 0.0
for w in W:
p_map = [X0_EFF]
for wk in w:
p_map.append(closed_loop(p_map[-1], wk))
gap22 = max(gap22, float(np.abs(run(K_T, w=w) - np.array(p_map)).max()))
print(f"Proposition 2.2: rule-then-transition against the closed-loop map on 1,000 environment paths (seed {SEED}): "
f"largest difference {gap22:.1e}")
fig, ax = plt.subplots(figsize=(7.6, 3.6))
yrs = np.arange(21)
for g, col, ls, lab in ((0.0, "#999999", "-", "feedback off"), (0.25, "#616161", "--", "gain 0.25"),
(K_T, "#1F4E79", "-", "the turnaround's rule, gain 0.451"), (1.0, "#E65100", "--", "gain 1.0"),
(1.6, "#B71C1C", ":", "gain 1.6: overshoots")):
ax.plot(yrs, run(g), ls, color=col, lw=2 if g == K_T else 1.4, label=lab)
ax.plot([1, 3, 5, 11], [74.6, 77.7, 78.6, 79.0], "o", color="#1F4E79", ms=5, label="Table 5.5")
ax.set_xticks(range(0, 21, 2))
ax.set(xlabel="years", ylabel="operational efficiency (index, 0-100)", ylim=(70, 85),
title="Feedback holds efficiency at the target; the gain sets the pace (seed 26102)")
ax.legend(frameon=False, fontsize=8, ncol=2); plt.tight_layout(); plt.show()gain of the turnaround's rule K = 0.4512; the gap is multiplied by 0.5488 a year year 0 1 3 5 11 feedback on 71.00 74.61 77.68 78.60 78.99 (Table 5.5: 71.0, 74.6, 77.7, 78.6, 79.0) feedback off 71.00 71.00 71.00 71.00 71.00 (no rule: the gap of 8 points stays) gain 0.000: years 1-4 [71. 71. 71. 71.]; within half a point of 79 never gain 0.250: years 1-4 [73. 74.5 75.62 76.47]; within half a point of 79 from year 10 gain 0.451: years 1-4 [74.61 76.59 77.68 78.27]; within half a point of 79 from year 5 gain 1.000: years 1-4 [79. 79. 79. 79.]; within half a point of 79 from year 1 gain 1.600: years 1-4 [83.8 76.12 80.73 77.96]; within half a point of 79 from year 6 gain 2.200: years 1-4 [88.6 67.48 92.82 62.41]; within half a point of 79 never Proposition 2.2: rule-then-transition against the closed-loop map on 1,000 environment paths (seed 26102): largest difference 2.8e-14

Output feedback needs a reporting lag (Online Appendix Remark 2.B.1). Proposition 2.2 uses the fact that outputs depend on the state alone. If a reported figure responds instantly to the decision, , output feedback must solve : with there is no solution, with there are two, and . A reporting lag, , removes the problem: every rule then gives one path.
Python Code
from numpy.polynomial import polynomial as Pn
def loop_solutions(phi_coeffs):
# real solutions of u = phi(u) for a polynomial phi (coefficients from the constant term up)
c = np.array(phi_coeffs, float); c = np.pad(c, (0, max(0, 2 - len(c)))); c[1] -= 1.0
c = np.trim_zeros(c, "b")
if len(c) <= 1:
return [] # a nonzero constant: no solution
r = Pn.polyroots(c)
return sorted(float(x.real) for x in r if abs(x.imag) < 1e-12)
sol_plus = loop_solutions([1.0, 1.0]) # phi(y) = y + 1
sol_square = loop_solutions([0.0, 0.0, 1.0]) # phi(y) = y^2
print("phi(y) = y + 1: solutions of u = phi(u):", sol_plus or "none")
print("phi(y) = y^2: solutions of u = phi(u):", sol_square)
u = [0.0]
for k in range(5):
u.append(u[-1] + 1.0) # with a one-period lag: u_k = phi(y_{k-1}), y = u
print("with a one-period reporting lag, phi(y) = y + 1 gives one path:", u)phi(y) = y + 1: solutions of u = phi(u): none phi(y) = y^2: solutions of u = phi(u): [0.0, 1.0] with a one-period reporting lag, phi(y) = y + 1 gives one path: [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
Panel 6 — Close the loop: adaptation, and a shift in the environment (Definition 2.6)
AXIOM Lab 1.2, step 4, second part. After year 5, when the turnaround has delivered 78.6 (Table 1.9), switch on an adaptation law of the form of Online Appendix 2.B — the rule's gain is revised upward when the squared gap is large and downward when it is small, — and let the environment start taking efficiency away each year. The book prints no numbers for this step: the shift, the speed and the tolerance below are bench settings to vary, not Meridian facts. The fixed rule settles a predictable points short of 79; the adaptive rule holds closer, but how it gets there, and whether it does, depends on the shift and on how fast it adapts.
Python Code
SHIFT_YEAR, ETA, C_TOL = 5, 0.05, 1.0 # bench settings: when the environment shifts; adaptation speed; tolerated squared gap
def bench(shift, adapt=True, eta=ETA, c=C_TOL, years=20, theta0=K_T, x0=X0_EFF):
# the fixed rule until SHIFT_YEAR; then the environment takes `shift` points a year and, if adapt, the law is on
x, th = [x0], [theta0]
for k in range(years):
w = -shift if k >= SHIFT_YEAR else 0.0
gap = x[-1] - TARGET
x.append(x[-1] + th[-1] * (TARGET - x[-1]) + w)
th.append(th[-1] + (eta * (gap ** 2 - c) if adapt and k >= SHIFT_YEAR else 0.0))
if not 0.0 <= x[-1] <= 100.0: # the index leaves its range: the loop has lost control
break
return np.array(x), np.array(th)
print("shift a year fixed rule settles at (79 - s/K) adaptive rule: year 20, gain")
res = {}
for s, eta in ((1.0, ETA), (2.0, ETA), (3.0, ETA), (2.0, 2 * ETA)):
xf, _ = bench(s, adapt=False, years=40)
xa, th = bench(s, eta=eta)
res[(s, eta)] = (xf, xa, th)
tail = (f"{xa[20]:6.2f}, gain {th[20]:4.2f}" if len(xa) > 20 else f"leaves the 0-100 range in year {len(xa) - 1}")
note = "" if eta == ETA else f" (adapting twice as fast, eta {eta:.2f})"
print(f" {s:4.1f} {xf[-1]:6.2f} (short {s / K_T:4.2f}) {tail}{note}")
xf1, xa1, th1 = res[(1.0, ETA)]
print("\na model that freezes the rule at 0.451 (and knows the shift) forecasts the adaptive company with errors of")
print(" " + ", ".join(f"year {k}: {xa1[k] - bench(1.0, adapt=False)[0][k]:+.2f}" for k in (6, 7, 8, 10, 15, 20)))
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.5, 1]})
yrs = np.arange(21)
off = np.concatenate([path[:SHIFT_YEAR + 1], path[SHIFT_YEAR] - np.arange(1, 16) * 1.0])
ax1.plot(yrs, off, color="#999999", lw=1.2, label="feedback off from year 5 (shift 1)")
for s, ls in ((1.0, "-"), (2.0, "--")):
xf, xa, th = res[(s, ETA)]
ax1.plot(yrs, xf[:21], ls, color="#1F4E79", lw=1.8, label=f"fixed rule, shift {s:.0f} a year")
ax1.plot(yrs, xa[:21], ls, color="#E65100", lw=1.8, label=f"adaptive rule, shift {s:.0f} a year")
ax2.plot(yrs, th[:21], ls, color="#E65100", lw=1.8)
ax2.axhline(K_T, color="#1F4E79", lw=1.8)
ax1.axhline(TARGET, color="#999999", lw=0.6); ax1.axvline(SHIFT_YEAR, color="#999999", lw=0.6, ls=":")
for ax in (ax1, ax2):
ax.set_xticks(range(0, 21, 5))
ax1.set(xlabel="years", ylabel="operational efficiency (index)", ylim=(70, 80))
ax2.set(xlabel="years", ylabel="gain (share of the gap a year)")
fig.legend(*ax1.get_legend_handles_labels(), loc="lower center", ncol=3, frameon=False, fontsize=7)
fig.suptitle("After the shift: the adaptive rule holds closer to 79, its gain swings (seed 26102)", fontsize=10)
plt.tight_layout(rect=(0, 0.12, 1, 1)); plt.show()shift a year fixed rule settles at (79 - s/K) adaptive rule: year 20, gain
1.0 76.78 (short 2.22) 77.97, gain 0.98
2.0 74.57 (short 4.43) 77.91, gain 1.83
3.0 72.35 (short 6.65) leaves the 0-100 range in year 13
2.0 74.57 (short 4.43) leaves the 0-100 range in year 15 (adapting twice as fast, eta 0.10)
a model that freezes the rule at 0.451 (and knows the shift) forecasts the adaptive company with errors of
year 6: +0.00, year 7: -0.05, year 8: -0.06, year 10: +0.50, year 15: +1.16, year 20: +1.19

Panel 7 — The adaptive company is an ordinary system (Proposition 2.3; Theorem 2.1; Online Appendix 2.B)
AXIOM Lab 1.2, step 4, continued: why the adaptive rule can still be analyzed. Count the rule as part of the state, , and the two-loop company is one map , to which Theorem 2.1 applies. Online Appendix 2.B writes this out for the scalar company , , , whose map is . Theorem 2.1(ii) says two histories that reach the same state have the same future; the Online Appendix adds what a fixed-rule model misses: the same with different rules has different futures. Its , and are symbolic; the runs below use bench values (, , ).
Python Code
A_OWN = 0.9 # bench value of the deviation's own persistence a
def oa_two_loops(x0, th0, w, eta, c, a=A_OWN): # the Online Appendix's company, as written: rule, decision, two laws
x, th = [x0], [th0]
for wk in w:
u = -th[-1] * x[-1]
x_next = a * x[-1] + u + wk
th.append(th[-1] + eta * (x[-1] ** 2 - c)); x.append(x_next)
return np.array(x), np.array(th)
def oa_F(z, wk, eta, c, a=A_OWN): # the same company as one map of the augmented state
x, th = z
return np.array([(a - th) * x + wk, th + eta * (x ** 2 - c)])
rng = np.random.default_rng(SEED)
gap_F = 0.0
for _ in range(1000): # 1,000 random histories: starts, rules, environments
x0, th0 = rng.uniform(-2, 2), rng.uniform(0.1, 0.6)
w = rng.normal(0.0, 0.5, 12)
xs, ths = oa_two_loops(x0, th0, w, eta=0.05, c=1.0)
z = np.array([x0, th0]); zs = [z]
for wk in w:
z = oa_F(z, wk, 0.05, 1.0); zs.append(z)
gap_F = max(gap_F, float(np.abs(np.array(zs) - np.column_stack([xs, ths])).max()))
print(f"Proposition 2.3: the map F reproduces the two-loop company on 1,000 histories (seed {SEED}); largest difference {gap_F:.1e}")
def efficiency_F(z, wk, adapt=True, eta=ETA, c=C_TOL): # the bench's efficiency company as one map of (x, theta)
x, th = z
return np.array([x + th * (TARGET - x) + wk, th + (eta * ((x - TARGET) ** 2 - c) if adapt else 0.0)])
def future(z5, shift, adapt, years=15):
z, out = np.array(z5, float), [z5[0]]
for k in range(years):
z = efficiency_F(z, -shift, adapt); out.append(z[0])
return np.array(out)
x5 = path[SHIFT_YEAR] # 78.60, reached from 71 by the turnaround
h2 = run(K_T, years=4, x0=75.0) # a second history: another start ...
w4 = x5 - (h2[-1] + K_T * (TARGET - h2[-1])) # ... and another environment, reaching the same efficiency in year 5
x5_second = h2[-1] + K_T * (TARGET - h2[-1]) + w4
fixed_1, fixed_2 = future((x5, K_T), 1.0, False), future((x5_second, K_T), 1.0, False)
same_state_gap = float(np.abs(fixed_1 - fixed_2).max())
print(f"fixed rule: two histories (from 71, and from 75 with another environment) reach {x5:.4f} and {x5_second:.4f} "
f"in year 5;\n facing the same shift, their futures differ by at most {same_state_gap:.1e}")
adapt_1, adapt_2 = future((x5, K_T), 1.0, True), future((x5, 2 * K_T), 1.0, True)
rule_gap = float(np.abs(adapt_1 - adapt_2).max())
print(f"adaptive rule: the same efficiency {x5:.2f} in year 5 with rules {K_T:.3f} and {2 * K_T:.3f}; their futures differ by up to "
f"{rule_gap:.2f} points:\n efficiency alone is no longer a sufficient statistic; (efficiency, rule) is")Proposition 2.3: the map F reproduces the two-loop company on 1,000 histories (seed 26102); largest difference 8.9e-16 fixed rule: two histories (from 71, and from 75 with another environment) reach 78.6017 and 78.6017 in year 5; facing the same shift, their futures differ by at most 0.0e+00 adaptive rule: the same efficiency 78.60 in year 5 with rules 0.451 and 0.902; their futures differ by up to 0.82 points: efficiency alone is no longer a sufficient statistic; (efficiency, rule) is
Panel 8 — Map a loop (Tables 2.4 and 2.5)
AXIOM Lab 1.2, step 5. Industrial Systems' migration loop, in the book's words: customer migration cuts volume, which raises unit cost, which speeds migration (Table 2.5). Label each link by whether it moves its target the same way (+) or the opposite way (−); a loop's polarity is the product of its links' signs, and a push that comes back around the loop with the same sign marks a reinforcing loop. The turnaround's efficiency program of Panel 5 is the balancing kind (Table 2.4: it opposes deviation from a target).
Python Code
LOOPS = {
"Industrial Systems' migration loop": [("customer migration", "volume", -1, "migration cuts volume"),
("volume", "unit cost", -1, "less volume raises unit cost"),
("unit cost", "customer migration", +1, "higher unit cost speeds migration")],
"the turnaround's efficiency program": [("efficiency gap", "program effort", +1, "a wider gap draws more effort"),
("program effort", "efficiency", +1, "effort raises efficiency"),
("efficiency", "efficiency gap", -1, "higher efficiency narrows the gap")],
}
polarity = {}
for name, links in LOOPS.items():
sign = int(np.prod([l[2] for l in links]))
polarity[name] = sign
print(f"{name}: " + "; ".join(f"{a} -> {b} ({'+' if s > 0 else '-'})" for a, b, s, _ in links))
print(f" opposite links {sum(l[2] < 0 for l in links)}, polarity {'+' if sign > 0 else '-'}: "
f"{'reinforcing' if sign > 0 else 'balancing'}; a push of +1 comes back as {sign:+d}")Industrial Systems' migration loop: customer migration -> volume (-); volume -> unit cost (-); unit cost -> customer migration (+) opposite links 2, polarity +: reinforcing; a push of +1 comes back as +1 the turnaround's efficiency program: efficiency gap -> program effort (+); program effort -> efficiency (+); efficiency -> efficiency gap (-) opposite links 1, polarity -: balancing; a push of +1 comes back as -1
Validation — the book's numbers, and agreement with DCT_V1_Ch02_Lab.xlsx
Each checkpoint is a number printed in Chapter 2 (Worked Example 2.1, Table 2.6, Figure 2.3), in Online
Appendix 2.B, or, for the feedback bench, in Tables 1.9 and 5.5 and Worked Example 5.1. Theorem checks compare
with what the printed theorem asserts. The workbook recomputes the ones marked workbook with Excel formulas and
shows PASS against the same engine values on its Checks sheet.
Python Code
TABLE_2_6 = {"F1": ("input", "input"), "F2": ("output", "output"), "F3": ("output", "interior"),
"F4": ("input", "interior"), "F5": ("environmental", "output"), "F6": ("environmental", "input"),
"F7": ("input", "interior"), "F8": ("input", "input"), "F9": ("input", "input")}
matchA = sum(clsA[f] == TABLE_2_6[f][0] for f in TABLE_2_6)
matchB = sum(clsB[f] == TABLE_2_6[f][1] for f in TABLE_2_6)
checks = [
("Industrial Systems' sales, $2.56bn (workbook)", IS_SALES, 2560, 5),
("share shipped to dealers, about 60% (workbook)", 100 * SHIP / IS_SALES, 60, 0.5),
("dealers' sales to end customers (workbook)", RESALE, 1848, 0.5),
("goods output, boundary A (workbook)", goods_output(clsA), 1540, 0.5),
("goods output, boundary B (workbook)", goods_output(clsB), 1848, 0.5),
("the gap: dealers' gross margin (workbook)", gap, 308, 0.5),
("the gap as a share of shipments, % (workbook)", 100 * gap / goods_output(clsA), 20, 0.05),
("entities in the map", len(ENTITIES), 6, 0),
("flows in the map", len(FLOWS), 9, 0),
("boundary A: interior flows (workbook)", nA["interior"], 0, 0),
("boundary A: inputs (workbook)", nA["input"], 5, 0),
("boundary A: outputs (workbook)", nA["output"], 2, 0),
("boundary A: environmental flows (workbook)", nA["environmental"], 2, 0),
("boundary B: interior flows (workbook)", nB["interior"], 3, 0),
("boundary B: inputs (workbook)", nB["input"], 4, 0),
("boundary B: outputs (workbook)", nB["output"], 2, 0),
("boundary B: environmental flows (workbook)", nB["environmental"], 0, 0),
("Table 2.6 rows reproduced, boundary A (workbook)", matchA, 9, 0),
("Table 2.6 rows reproduced, boundary B (workbook)", matchB, 9, 0),
("flows relabeled by the move, Table 2.6 (workbook)", len(changed), 5, 0),
("Theorem 2.2(i): flows not in exactly one class (workbook)", worst, 0, 0),
("Theorem 2.2(ii): flows under every boundary (workbook)", min(totals), 9, 0),
("Theorem 2.2(iii): breaching pairs of boundaries", breaches, 0, 0),
("Figure 2.3: Meridian's divisions (workbook)", len(DIVISIONS), 3, 0),
("Figure 2.3: units (workbook)", len(UNITS), 6, 0),
("Definition 2.4: Digital Solutions' sibling divisions (workbook)", len(siblings_DS), 2, 0),
("turnaround efficiency, year 1, Table 5.5 (workbook)", path[1], 74.6, 0.05),
("turnaround efficiency, year 3, Table 5.5 (workbook)", path[3], 77.7, 0.05),
("turnaround efficiency, year 5, Tables 1.9, 5.5 (workbook)", path[5], 78.6, 0.05),
("turnaround efficiency, year 11, Table 5.5 (workbook)", path[11], 79.0, 0.05),
("gap factor a year, Worked Example 5.1 (workbook)", 1 - K_T, 0.549, 5e-4),
("Proposition 2.2: closed-loop map vs rule and transition (workbook)", gap22, 0, 1e-9),
("Remark 2.B.1: solutions of u = u + 1 (workbook)", len(sol_plus), 0, 0),
("Remark 2.B.1: solutions of u = u^2 (workbook)", len(sol_square), 2, 0),
("Remark 2.B.1: the larger solution (workbook)", max(sol_square), 1, 1e-12),
("Proposition 2.3: augmented map vs two loops (workbook)", gap_F, 0, 1e-9),
("Theorem 2.1(ii): same state, futures differ by", same_state_gap, 0, 1e-9),
("migration loop: polarity +1, reinforcing (workbook)", polarity["Industrial Systems' migration loop"], 1, 0),
("efficiency program: polarity -1, balancing (workbook)", polarity["the turnaround's efficiency program"], -1, 0),
]
ok = 0
for name, got, want, tol in checks:
status = "PASS" if abs(got - want) <= tol else "FAIL"; ok += status == "PASS"
print(f"{name:64s} {got:10.4f} book {want:9.4f} {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")Industrial Systems' sales, $2.56bn (workbook) 2562.0000 book 2560.0000 PASS share shipped to dealers, about 60% (workbook) 60.1093 book 60.0000 PASS dealers' sales to end customers (workbook) 1848.0000 book 1848.0000 PASS goods output, boundary A (workbook) 1540.0000 book 1540.0000 PASS goods output, boundary B (workbook) 1848.0000 book 1848.0000 PASS the gap: dealers' gross margin (workbook) 308.0000 book 308.0000 PASS the gap as a share of shipments, % (workbook) 20.0000 book 20.0000 PASS entities in the map 6.0000 book 6.0000 PASS flows in the map 9.0000 book 9.0000 PASS boundary A: interior flows (workbook) 0.0000 book 0.0000 PASS boundary A: inputs (workbook) 5.0000 book 5.0000 PASS boundary A: outputs (workbook) 2.0000 book 2.0000 PASS boundary A: environmental flows (workbook) 2.0000 book 2.0000 PASS boundary B: interior flows (workbook) 3.0000 book 3.0000 PASS boundary B: inputs (workbook) 4.0000 book 4.0000 PASS boundary B: outputs (workbook) 2.0000 book 2.0000 PASS boundary B: environmental flows (workbook) 0.0000 book 0.0000 PASS Table 2.6 rows reproduced, boundary A (workbook) 9.0000 book 9.0000 PASS Table 2.6 rows reproduced, boundary B (workbook) 9.0000 book 9.0000 PASS flows relabeled by the move, Table 2.6 (workbook) 5.0000 book 5.0000 PASS Theorem 2.2(i): flows not in exactly one class (workbook) 0.0000 book 0.0000 PASS Theorem 2.2(ii): flows under every boundary (workbook) 9.0000 book 9.0000 PASS Theorem 2.2(iii): breaching pairs of boundaries 0.0000 book 0.0000 PASS Figure 2.3: Meridian's divisions (workbook) 3.0000 book 3.0000 PASS Figure 2.3: units (workbook) 6.0000 book 6.0000 PASS Definition 2.4: Digital Solutions' sibling divisions (workbook) 2.0000 book 2.0000 PASS turnaround efficiency, year 1, Table 5.5 (workbook) 74.6095 book 74.6000 PASS turnaround efficiency, year 3, Table 5.5 (workbook) 77.6776 book 77.7000 PASS turnaround efficiency, year 5, Tables 1.9, 5.5 (workbook) 78.6017 book 78.6000 PASS turnaround efficiency, year 11, Table 5.5 (workbook) 78.9891 book 79.0000 PASS gap factor a year, Worked Example 5.1 (workbook) 0.5488 book 0.5490 PASS Proposition 2.2: closed-loop map vs rule and transition (workbook) 0.0000 book 0.0000 PASS Remark 2.B.1: solutions of u = u + 1 (workbook) 0.0000 book 0.0000 PASS Remark 2.B.1: solutions of u = u^2 (workbook) 2.0000 book 2.0000 PASS Remark 2.B.1: the larger solution (workbook) 1.0000 book 1.0000 PASS Proposition 2.3: augmented map vs two loops (workbook) 0.0000 book 0.0000 PASS Theorem 2.1(ii): same state, futures differ by 0.0000 book 0.0000 PASS migration loop: polarity +1, reinforcing (workbook) 1.0000 book 1.0000 PASS efficiency program: polarity -1, balancing (workbook) -1.0000 book -1.0000 PASS 39 of 39 checkpoints PASS
Next. Chapter 3 gives the state its numbers: readings with units, distances on a declared scale, and transformations as operators that work only from certain states. AXIOM-02 runs the same world interactively (Lab 1.2); this notebook and the workbook are its reproducible record.


