Skip to content

Vol. I, Ch. 4

DCT Laboratory — Volume I, Chapter 4

Enterprise Modeling Principles

This laboratory demonstrates

Seed 26104 · Companion to Chapter 4 and AXIOM Lab 1.4 (module AXIOM-04) · Mirrored in DCT_V1_Ch04_Lab.xlsx

This laboratory reproduces Worked Example 4.1, When the Roll-Up Breaks, with the book's declarations, and works the five steps of AXIOM Lab 1.4, Can We Trust the Model?: walk the chain, test a roll-up, fit and extrapolate, leave the record, set triggers. Every Meridian number below is the book's (Worked Example 4.1, Table 4.5, Figure 4.2, Appendix 4.A, Online Appendix 4.B); the final cell checks them. Headcounts are in engineers; no money enters this chapter's numbers.

The declarations (Worked Example 4.1, the situation)

Meridian's HR dashboard tracks the number of engineers in each unit of Industrial Systems, and the planning model projects each unit's total with one attrition rate. Two units each have 500 engineers. Unit A has 400 legacy-skill and 100 software-skill engineers; Unit B has 100 and 400. Each year 8 percent of legacy engineers leave the legacy pool (5 percent leave the company and 3 percent are retrained into software skills), and 4 percent of software engineers leave. With hℓh_\ell legacy and hsh_s software engineers, the detailed model is x′=Ax\mathbf{x}' = \mathbf{A}\mathbf{x} (Appendix 4.A):

(hℓ′hs′)  =  (0.9200.030.96)(hℓhs),\begin{pmatrix} h_\ell' \\ h_s' \end{pmatrix} \;=\; \begin{pmatrix} 0.92 & 0 \\ 0.03 & 0.96 \end{pmatrix} \begin{pmatrix} h_\ell \\ h_s \end{pmatrix},

and the dashboard's summary is the total H=hℓ+hsH = h_\ell + h_s: the roll-up P=[1  1]\mathbf{P} = [1\ \ 1].

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

# Worked Example 4.1: shares of each pool a year
EXIT_L, RETRAIN, EXIT_S = 0.05, 0.03, 0.04       # legacy engineers who leave the company; legacy retrained; software who leave
A = np.array([[1 - EXIT_L - RETRAIN, 0.0],       # the legacy pool keeps 92 percent
              [RETRAIN, 1 - EXIT_S]])            # the software pool keeps 96 percent and gains the retrained
UNITS = {"Unit A": np.array([400.0, 100.0]),     # (legacy, software) engineers today
         "Unit B": np.array([100.0, 400.0])}
P = np.array([1.0, 1.0])                         # the dashboard's roll-up: the total H
YEARS = 5

def project(x0, years=YEARS):
    # the detailed model x' = A x: one row per year 0..years, columns (legacy, software)
    xs = [np.asarray(x0, float)]
    for _ in range(years):
        xs.append(A @ xs[-1])
    return np.array(xs)

def clean(v, nd=9):
    # round away floating dust, and print -0.0 as 0.0
    return np.round(np.asarray(v, float), nd) + 0.0

print(f"A = [[{A[0, 0]:.2f}, {A[0, 1]:.2f}], [{A[1, 0]:.2f}, {A[1, 1]:.2f}]]")
print(f"legacy pool: {EXIT_L:.0%} leave the company and {RETRAIN:.0%} are retrained, so {1 - A[0, 0]:.0%} leave the pool"
      f" a year; software pool: {EXIT_S:.0%} leave")
for name, x in UNITS.items():
    print(f"{name}: {x[0]:.0f} legacy + {x[1]:.0f} software = {P @ x:.0f} engineers, software share {x[1] / (P @ x):.0%}")
A = [[0.92, 0.00], [0.03, 0.96]]
legacy pool: 5% leave the company and 3% are retrained, so 8% leave the pool a year; software pool: 4% leave
Unit A: 400 legacy + 100 software = 500 engineers, software share 20%
Unit B: 100 legacy + 400 software = 500 engineers, software share 80%

Panel 1 — Walk the chain (Table 4.1; Figure 4.1; Definition 4.1; Table 4.4)

AXIOM Lab 1.4, step 1: follow a question from diagram to running code, and note what each verification checkpoint tests. A company model arrives in a chain of four types, each translating its predecessor into a stricter medium (Table 4.1); an error introduced at one link travels silently through all later links, so every link is verified, not only the last. AXIOM's chain builder walks the working-capital question; the book declares no working-capital numbers, so this panel walks the question Worked Example 4.1 answers, how many engineers will each unit have?, and runs Table 4.4's three verification items on it: the mathematics renders the logic, the code implements the mathematics (a test on a known solution), and the constraints are preserved (internal consistency, Definition 4.5). Verification is internal: it can pass for a model that tracks nothing. Whether the end of the chain tracks the company is validation, the subject of Panel 7 (Figure 4.1: a perfectly verified chain can faithfully implement a wrong idea).

Python Code
TABLE_4_1 = [   # Table 4.1: type, medium, question it settles, typical failure
    ("Conceptual", "diagrams, prose", "what matters and how it connects", "omitted mechanism; wrong boundary"),
    ("Logical", "structured schema", "which readings, links, constraints", "hidden variable; category error"),
    ("Mathematical", "spaces, mappings", "exact form of dynamics and constraints",
     "unearned assumption (linearity, independence)"),
    ("Computational", "code, data", "numbers, paths, optima", "implementation bug; discretization artifact")]
CHAIN = [       # Worked Example 4.1's question, link by link
    ("Conceptual", "two pools of engineers in each unit; engineers leave, and legacy engineers are retrained into software"),
    ("Logical", "a unit's state is (legacy, software); links legacy -> software and both pools -> exit; no pool is negative"),
    ("Mathematical", "x' = A x with A = [[0.92, 0], [0.03, 0.96]] (Appendix 4.A)"),
    ("Computational", "project(x0) above: the recursion, run year by year")]
print(f"Table 4.1: {len(TABLE_4_1)} model types, each translating its predecessor into a stricter medium")
for t, medium, question, failure in TABLE_4_1:
    print(f"  {t:13s} {medium:17s} settles: {question:39s} typical failure: {failure}")
print("\nWorked Example 4.1's question through the chain")
for t, content in CHAIN:
    print(f"  {t:13s} {content}")
print("  the completed chain is Definition 4.1's quadruple M = (X, mu, f-hat, g-hat): X, a unit's pairs of headcounts;"
      "\n  mu, engineers counted by skill pool; f-hat(x) = A x, the modeler's claim; g-hat(x) = the total, the dashboard's reading")

# Table 4.4, verification (1): the mathematics renders the logic
kept = A.sum(axis=0)                             # the share of each pool that stays in the company a year
logic_gap = max(abs((1 - kept[0]) - EXIT_L), abs((1 - kept[1]) - EXIT_S))
print(f"\nverify (1), logic -> mathematics: the company keeps {kept[0]:.2f} of a legacy pool and {kept[1]:.2f} of a software"
      f" pool, so {1 - kept[0]:.0%} and {1 - kept[1]:.0%} leave, as declared (gap {logic_gap:.1e});"
      " the retrained change pools without leaving")

# verification (2): the code implements the mathematics, tested on a known solution
def closed_form(x0, k):
    # h_l(k) = 0.92^k h_l(0);  h_s(k) = 0.96^k h_s(0) + 0.03 h_l(0) (0.96^k - 0.92^k) / (0.96 - 0.92)
    a, c, d = A[0, 0], A[1, 0], A[1, 1]
    return np.array([a ** k * x0[0], d ** k * x0[1] + c * x0[0] * (d ** k - a ** k) / (d - a)])
code_gap = max(float(abs(project(x0)[k] - closed_form(x0, k)).max()) for x0 in UNITS.values() for k in range(YEARS + 1))
print(f"verify (2), mathematics -> code: the recursion against the closed form, years 0-{YEARS}, both units:"
      f" largest gap {code_gap:.1e}")

# verification (3): constraints preserved; the model never leaves its own admissible region (Definition 4.5)
century = [project(x0, 100) for x0 in UNITS.values()]
low = min(float(c.min()) for c in century)
negative = sum(int((c < 0).sum()) for c in century)
rises = sum(int((np.diff(c.sum(axis=1)) > 0).sum()) for c in century)
print(f"verify (3), internal consistency: over 100 years no pool is negative ({negative} cases; the smallest is {low:.2f}),"
      f" and a unit's total rises in {rises} years (the model declares no hiring)")
Table 4.1: 4 model types, each translating its predecessor into a stricter medium
  Conceptual    diagrams, prose   settles: what matters and how it connects        typical failure: omitted mechanism; wrong boundary
  Logical       structured schema settles: which readings, links, constraints      typical failure: hidden variable; category error
  Mathematical  spaces, mappings  settles: exact form of dynamics and constraints  typical failure: unearned assumption (linearity, independence)
  Computational code, data        settles: numbers, paths, optima                  typical failure: implementation bug; discretization artifact

Worked Example 4.1's question through the chain
  Conceptual    two pools of engineers in each unit; engineers leave, and legacy engineers are retrained into software
  Logical       a unit's state is (legacy, software); links legacy -> software and both pools -> exit; no pool is negative
  Mathematical  x' = A x with A = [[0.92, 0], [0.03, 0.96]] (Appendix 4.A)
  Computational project(x0) above: the recursion, run year by year
  the completed chain is Definition 4.1's quadruple M = (X, mu, f-hat, g-hat): X, a unit's pairs of headcounts;
  mu, engineers counted by skill pool; f-hat(x) = A x, the modeler's claim; g-hat(x) = the total, the dashboard's reading

verify (1), logic -> mathematics: the company keeps 0.95 of a legacy pool and 0.96 of a software pool, so 5% and 4% leave, as declared (gap 4.2e-17); the retrained change pools without leaving
verify (2), mathematics -> code: the recursion against the closed form, years 0-5, both units: largest gap 5.7e-14
verify (3), internal consistency: over 100 years no pool is negative (0 cases; the smallest is 0.02), and a unit's total rises in 0 years (the model declares no hiring)

Panel 2 — Project the detailed model (Worked Example 4.1, Step 1; Table 4.5)

AXIOM Lab 1.4, step 2, first part: the aggregation tester runs the detailed model unit by unit. Unit A next year has 0.92×400=3680.92 \times 400 = 368 legacy engineers and 0.96×100+0.03×400=1080.96 \times 100 + 0.03 \times 400 = 108 software engineers: a total of 476. Unit B has 0.92×100=920.92 \times 100 = 92 and 0.96×400+0.03×100=3870.96 \times 400 + 0.03 \times 100 = 387: a total of 479. Run on for five years, the detailed model gives the first two rows of Table 4.5.

Python Code
paths = {name: project(x0) for name, x0 in UNITS.items()}
totals = {name: p.sum(axis=1) for name, p in paths.items()}
yrs = np.arange(YEARS + 1)
for name, p in paths.items():
    print(f"{name} next year: {p[1, 0]:.0f} legacy + {p[1, 1]:.0f} software = {totals[name][1]:.0f} engineers")

def row(label, values, f="9.1f"):
    print(f"  {label:42s}" + "".join(f"{v:{f}}" for v in clean(values)))
print("\nTable 4.5" + " " * 35 + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
for name in UNITS:
    row(f"{name}, detailed model", totals[name])
Unit A next year: 368 legacy + 108 software = 476 engineers
Unit B next year: 92 legacy + 387 software = 479 engineers

Table 4.5                                      year 0   year 1   year 2   year 3   year 4   year 5
  Unit A, detailed model                        500.0    476.0    453.3    431.8    411.4    392.1
  Unit B, detailed model                        500.0    479.0    458.9    439.7    421.3    403.8

Panel 3 — Apply the roll-up test (Worked Example 4.1, Step 2; Theorem 4.2; Appendix 4.A; Figure 4.2)

AXIOM Lab 1.4, step 2: roll the engineers up to a single total and test it. By Theorem 4.2 a summary supports its own forecasting model exactly when the detailed dynamics never split what the summary lumps together. Units A and B have the same total today, 500, and different totals next year, 476 and 479: the dynamics split the fiber of 500 (Figure 4.2), so the total alone is not a state, and no model that forecasts from the total alone can be right for both units. For linear dynamics the test is a calculation (Appendix 4.A): with P=[1  1]\mathbf{P} = [1\ \ 1], ker⁡P\ker\mathbf{P} is spanned by (1,−1)(1, -1), and A(1,−1)=(0.92,−0.93)\mathbf{A}(1, -1) = (0.92, -0.93) lies outside it.

The tester below applies the same calculation to other one-number summaries the dashboard could carry, and tries each on 10,000 random pairs of configurations that share the summary (drawn with the lab's seed, 26104). Only summaries along directions the dynamics do not split pass: the legacy count, and a weighted count of three legacy to four software engineers. That is the book's practical rule: summarize along directions the dynamics do not split, or carry the mix up into the summary (Step 5). Table 4.2 lists skill mix by unit among the readings of level L1L_1.

Python Code
img = A @ np.array([1.0, -1.0])
print(f"Appendix 4.A: ker P is spanned by (1, -1); A (1, -1) = ({img[0]:.2f}, {img[1]:.2f}), whose total is"
      f" {P @ img:+.2f}: outside ker P, so the condition fails")
print(f"Step 2: the same total today ({UNITS['Unit A'] @ P:.0f} and {UNITS['Unit B'] @ P:.0f}), different totals next year"
      f" ({totals['Unit A'][1]:.0f} and {totals['Unit B'][1]:.0f}): the dynamics split the fiber of 500\n")

SUMMARIES = {"total (the dashboard)": np.array([1.0, 1.0]), "software engineers": np.array([0.0, 1.0]),
             "legacy engineers": np.array([1.0, 0.0]), "3 legacy + 4 software": np.array([3.0, 4.0])}

def roll_up_test(p):
    # Theorem 4.2, linear case: the one-row roll-up p supports a model exactly when A maps ker p into ker p
    v = np.array([p[1], -p[0]])                  # spans ker p
    return float(p @ (A @ v))

def fiber_pairs(p, n=10_000, seed=SEED):
    # pairs of configurations (up to 1,000 engineers in each pool) with the same summary today;
    # returns the pairs kept, how equal the summaries are today, and the largest gap between them next year
    rng = np.random.default_rng(seed)
    v = np.array([p[1], -p[0]]) / abs(np.array([p[1], -p[0]])).max()
    x1 = rng.uniform(0, 1000, size=(n, 2))
    x2 = x1 + rng.uniform(-500, 500, size=(n, 1)) * v
    ok = (x2 >= 0).all(axis=1)
    x1, x2 = x1[ok], x2[ok]
    return int(ok.sum()), float(abs(x1 @ p - x2 @ p).max()), float(abs((x1 @ A.T) @ p - (x2 @ A.T) @ p).max())

print(f"{'summary':24s} {'p A v (0 passes)':>17s} {'pairs':>7s} {'largest gap next year':>22s}   verdict")
tester, today_max = {}, 0.0
for name, p in SUMMARIES.items():
    test = roll_up_test(p)
    n, today, gap = fiber_pairs(p)
    today_max = max(today_max, today)
    j = int(np.argmax(abs(p)))
    rate = float((p @ A)[j] / p[j]) if abs(test) < 1e-12 else None
    tester[name] = (test, gap, rate)
    verdict = f"a state: next year = {rate:.2f} x this year" if rate is not None else "not a state: the dynamics split it"
    print(f"{name:24s} {test:17.4f} {n:7d} {gap:22.2e}   {verdict}")
print(f"(pairs drawn with the lab's seed {SEED}; the two summaries of each pair agree today to {today_max:.0e})")
Appendix 4.A: ker P is spanned by (1, -1); A (1, -1) = (0.92, -0.93), whose total is -0.01: outside ker P, so the condition fails
Step 2: the same total today (500 and 500), different totals next year (476 and 479): the dynamics split the fiber of 500

summary                   p A v (0 passes)   pairs  largest gap next year   verdict
total (the dashboard)              -0.0100    7505               5.00e+00   not a state: the dynamics split it
software engineers                  0.0300    8740               1.50e+01   not a state: the dynamics split it
legacy engineers                    0.0000    8765               0.00e+00   a state: next year = 0.92 x this year
3 legacy + 4 software               0.0000    7797               1.82e-12   a state: next year = 0.96 x this year
(pairs drawn with the lab's seed 26104; the two summaries of each pair agree today to 9e-13)

Panel 4 — Watch the error grow (Worked Example 4.1, Step 3; Table 4.5; Online Appendix 4.B)

Suppose the planning model is calibrated on Unit A's first year: total next year == total today ×\times 0.952. Applied to Unit B, it under-forecasts by 3 engineers in year one and by about 13 by year five (Table 4.5). The error grows because the mix keeps shifting; for the same reason the model also errs a little for Unit A itself after its first year (the last row below, which the book does not print). Online Appendix 4.B bounds such an approximate aggregation: if the summary model misses by at most δ\delta in one step and is Lipschitz with constant LL, the gap after kk periods is at most δ (Lk−1)/(L−1)\delta\,(L^k - 1)/(L - 1), roughly in proportion to the number of periods when LL is near one. Here L=0.952L = 0.952, and Unit B's one-step miss is largest in year one: 3 engineers.

Python Code
r = totals["Unit A"][1] / totals["Unit A"][0]               # calibrated on Unit A's first year: 476 / 500
coarse = totals["Unit A"][0] * r ** yrs                     # the total-only model from 500
errB, errA = coarse - totals["Unit B"], coarse - totals["Unit A"]
print(f"Step 3: calibrated on Unit A's first year, total next year = total today x {r:.3f}\n")
print("Table 4.5" + " " * 35 + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
row("Unit A, detailed model", totals["Unit A"])
row("Unit B, detailed model", totals["Unit B"])
row("Total-only model (x 0.952 a year)", coarse)
row("Error for Unit B", errB)
row("Error for Unit A (not printed in the book)", errA)

miss = np.abs(r * totals["Unit B"][:-1] - totals["Unit B"][1:])   # one-step misses along Unit B's path
delta, L = float(miss.max()), float(r)
bound = np.array([delta * (L ** k - 1) / (L - 1) for k in yrs])
fails = int((np.abs(errB) > bound + 1e-9).sum())
print(f"\nOnline Appendix 4.B: one-step misses for Unit B, years 1-5: {', '.join(f'{m:.2f}' for m in miss)};"
      f" delta = {delta:.2f}, L = {L:.3f}")
row("bound delta (L^k - 1) / (L - 1)", bound, "9.2f")
row("Unit B's error, in absolute value", np.abs(errB), "9.2f")
print(f"  the bound holds in every year (it fails in {fails}); with L = 1 it would be k delta, {YEARS * delta:.1f} by year five")

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.35, 1]})
ax1.plot(yrs, totals["Unit A"], "-o", color="#1F4E79", ms=4, lw=2, label="Unit A, detailed model")
ax1.plot(yrs, totals["Unit B"], "-o", color="#E65100", ms=4, lw=2, label="Unit B, detailed model")
ax1.plot(yrs, coarse, "--", color="#616161", lw=1.4, label="total-only model, x 0.952 a year")
ax1.annotate(f"{totals['Unit B'][-1]:.1f}", (YEARS, totals["Unit B"][-1]), textcoords="offset points", xytext=(5, 0),
             fontsize=8, color="#E65100", va="center")
ax1.annotate(f"{totals['Unit A'][-1]:.1f}", (YEARS, totals["Unit A"][-1]), textcoords="offset points", xytext=(5, 4),
             fontsize=8, color="#1F4E79", va="center")
ax1.annotate(f"{coarse[-1]:.1f}", (YEARS, coarse[-1]), textcoords="offset points", xytext=(5, -7), fontsize=8,
             color="#616161", va="center")
ax1.set(xlabel="years", ylabel="engineers in the unit", xticks=yrs, xlim=(-0.2, 5.9), ylim=(380, 506))
ax1.legend(frameon=False, fontsize=8, loc="lower left")
ax2.bar(yrs[1:] - 0.19, -errB[1:], 0.38, color="#E65100", label="Unit B")
ax2.bar(yrs[1:] + 0.19, -errA[1:], 0.38, color="#1F4E79", label="Unit A")
ax2.plot(yrs, bound, ":", color="#B71C1C", lw=1.6, label="Online Appendix 4.B bound")
ax2.set(xlabel="years", ylabel="under-forecast (engineers)", xticks=yrs)
ax2.legend(frameon=False, fontsize=8, loc="upper left")
fig.suptitle("One total, two futures: the total-only model misses Unit B by 12.8 (seed 26104)", fontsize=10)
plt.tight_layout(); plt.show()
Step 3: calibrated on Unit A's first year, total next year = total today x 0.952

Table 4.5                                      year 0   year 1   year 2   year 3   year 4   year 5
  Unit A, detailed model                        500.0    476.0    453.3    431.8    411.4    392.1
  Unit B, detailed model                        500.0    479.0    458.9    439.7    421.3    403.8
  Total-only model (x 0.952 a year)             500.0    476.0    453.2    431.4    410.7    391.0
  Error for Unit B                                0.0     -3.0     -5.8     -8.3    -10.7    -12.8
  Error for Unit A (not printed in the book)      0.0      0.0     -0.1     -0.4     -0.7     -1.1

Online Appendix 4.B: one-step misses for Unit B, years 1-5: 3.00, 2.91, 2.82, 2.74, 2.65; delta = 3.00, L = 0.952
  bound delta (L^k - 1) / (L - 1)                0.00     3.00     5.86     8.57    11.16    13.63
  Unit B's error, in absolute value              0.00     3.00     5.77     8.32    10.66    12.80
  the bound holds in every year (it fails in 0); with L = 1 it would be k delta, 15.0 by year five
One total, two futures: the total-only model misses Unit B by 12.8 (seed 26104)

Panel 5 — See what the total hides, and repair the summary (Worked Example 4.1, Steps 4–5; Theorems 4.1–4.2)

AXIOM Lab 1.4, step 2, second part: add the skill mix to the summary and test again. By year five the totals are close, 392 and 404, but the companies they describe are not: compare their software engineers below. The digital program needs software engineers, so a headcount dashboard would misstate exactly the capacity the board most needs to see. That is the representation bound (Theorem 4.1) in Meridian's numbers: today the two units are the same dashboard state, 500, and differ by 300 software engineers, so a question about software capacity cannot be answered from the dashboard by any analysis. The remedy is a richer representation, not cleverer analysis.

The repair (Step 5). Carry the software share ss alongside the total HH. The detailed dynamics then roll up exactly: next year's total is H (0.95+0.01 s)H\,(0.95 + 0.01\,s), which gives 500×(0.95+0.01×0.2)=476500 \times (0.95 + 0.01 \times 0.2) = 476 for Unit A and 500×(0.95+0.01×0.8)=479500 \times (0.95 + 0.01 \times 0.8) = 479 for Unit B, matching Step 1. The share follows a rule of its own that the declarations imply, s′=(0.03+0.93 s)/(0.95+0.01 s)s' = (0.03 + 0.93\,s)/(0.95 + 0.01\,s), so the enlarged summary satisfies the condition of Theorem 4.2 and agrees with the detailed model at every horizon. Rolled up once more, to the two units together, it stays consistent (Proposition 4.3).

Python Code
soft = {name: paths[name][:, 1] for name in UNITS}
share = {name: soft[name] / totals[name] for name in UNITS}
print(f"Step 4, year {YEARS}: totals {totals['Unit A'][-1]:.1f} and {totals['Unit B'][-1]:.1f};"
      f" software engineers {soft['Unit A'][-1]:.1f} and {soft['Unit B'][-1]:.1f}"
      f" (software shares {share['Unit A'][-1]:.1%} and {share['Unit B'][-1]:.1%})")
print(f"Theorem 4.1: today both units are the dashboard state {UNITS['Unit A'] @ P:.0f}; their software engineers are"
      f" {UNITS['Unit A'][1]:.0f} and {UNITS['Unit B'][1]:.0f}\n")

def mix_model(H, s):
    # Step 5: the total carried with the software share; both rules follow from x' = A x
    H1 = H * (1 - EXIT_L + (EXIT_L - EXIT_S) * s)                    # H (0.95 + 0.01 s)
    return H1, H * (RETRAIN + (1 - EXIT_S - RETRAIN) * s) / H1      # s' = (0.03 + 0.93 s) / (0.95 + 0.01 s)

print(f"Step 5: the repaired summary's coefficients are 1 - {EXIT_L} = {1 - EXIT_L:.2f} and {EXIT_L} - {EXIT_S} ="
      f" {EXIT_L - EXIT_S:.2f}")
for name, x in UNITS.items():
    H, s = x @ P, x[1] / (x @ P)
    print(f"  {name}: {H:.0f} x (0.95 + 0.01 x {s:.1f}) = {mix_model(H, s)[0]:.0f}, matching Step 1's {totals[name][1]:.0f}")

Hs_units_gap = 0.0
for name, x in UNITS.items():                    # the (H, s) model run forward five years, against Table 4.5
    H, s = x @ P, x[1] / (x @ P)
    for k in range(1, YEARS + 1):
        H, s = mix_model(H, s)
        Hs_units_gap = max(Hs_units_gap, abs(H - totals[name][k]), abs(s - share[name][k]))
X = np.random.default_rng(SEED).uniform(0, 1000, size=(10_000, 2))   # random configurations, the lab's seed
H, s = X.sum(axis=1), X[:, 1] / X.sum(axis=1)
Hs_gap = 0.0
for k in range(YEARS):                           # test again: summary model forward against the detailed model rolled up
    H, s = mix_model(H, s)
    X = X @ A.T
    Hs_gap = max(Hs_gap, float(abs(H - X.sum(axis=1)).max()), float(abs(s - X[:, 1] / X.sum(axis=1)).max()))
print(f"\nthe (H, s) model run forward five years against the detailed model rolled up: Units A and B, largest gap"
      f" {Hs_units_gap:.1e}; 10,000 random configurations (seed {SEED}), {Hs_gap:.1e}")

both = UNITS["Unit A"] + UNITS["Unit B"]          # Proposition 4.3: roll the two units up once more
Hd1, sd1 = mix_model(both.sum(), both[1] / both.sum())
print(f"Proposition 4.3: the two units together, {both.sum():.0f} engineers with software share {both[1] / both.sum():.0%}:"
      f" the (H, s) model gives {Hd1:.0f} next year = {totals['Unit A'][1]:.0f} + {totals['Unit B'][1]:.0f};"
      f" the total-only model gives {r * both.sum():.0f}")

fig, ax = plt.subplots(figsize=(7.6, 3.6))
for name, col, dy_t, dy_s in (("Unit A", "#1F4E79", -5, 0), ("Unit B", "#E65100", 5, -4)):
    ax.plot(yrs, totals[name], "-o", color=col, lw=2, ms=4, label=f"{name}: all engineers")
    ax.plot(yrs, soft[name], "--s", color=col, lw=1.6, ms=3.5, label=f"{name}: software engineers")
    ax.annotate(f"{totals[name][-1]:.1f}", (YEARS, totals[name][-1]), textcoords="offset points", xytext=(6, dy_t),
                fontsize=8, color=col, va="center")
    ax.annotate(f"{soft[name][-1]:.1f}", (YEARS, soft[name][-1]), textcoords="offset points", xytext=(6, dy_s),
                fontsize=8, color=col, va="center")
ax.set(xlabel="years", ylabel="engineers", xticks=yrs, xlim=(-0.2, 5.9), ylim=(0, 560),
       title="Close totals, different companies: software engineers by unit (seed 26104)")
ax.legend(frameon=False, fontsize=8, ncol=2, loc="center left", bbox_to_anchor=(0.0, 0.42))
plt.tight_layout(); plt.show()
Step 4, year 5: totals 392.1 and 403.8; software engineers 128.4 and 337.9 (software shares 32.8% and 83.7%)
Theorem 4.1: today both units are the dashboard state 500; their software engineers are 100 and 400

Step 5: the repaired summary's coefficients are 1 - 0.05 = 0.95 and 0.05 - 0.04 = 0.01
  Unit A: 500 x (0.95 + 0.01 x 0.2) = 476, matching Step 1's 476
  Unit B: 500 x (0.95 + 0.01 x 0.8) = 479, matching Step 1's 479

the (H, s) model run forward five years against the detailed model rolled up: Units A and B, largest gap 1.1e-13; 10,000 random configurations (seed 26104), 6.8e-13
Proposition 4.3: the two units together, 1000 engineers with software share 50%: the (H, s) model gives 955 next year = 476 + 479; the total-only model gives 952
Close totals, different companies: software engineers by unit (seed 26104)

Panel 6 — Fit and extrapolate (Section 4.5)

AXIOM Lab 1.4, step 3: on the model bench, fit a simple and a rich model to the same adoption history and slide the rich model's complexity up; compare the fit on the history with the error on the later quarters. The book prints no numbers for this step. The bench history below is the lab's own: the share of target users of a new digital service, quarter by quarter, following an S-shaped curve (ceiling 60 percent, midpoint quarter 12, speed 0.35 a quarter) observed with a measurement error of standard deviation 1.5 points, drawn with the lab's seed 26104. These are bench settings to vary, not Meridian facts. The simple model is a straight line; the rich model is a polynomial whose degree is the complexity slider. Both are fitted to quarters 1–16 and judged on quarters 17–24. Each added degree fits the history better, as it must; the forecast does not follow. A fitted curve's only content is its record, and it says nothing reliable off it.

Python Code
Q = np.arange(1, 25)                              # quarters 1-24
HIST, LATER = Q <= 16, Q > 16
CEIL, SPEED, MID, NOISE_SD = 60.0, 0.35, 12.0, 1.5        # bench settings, not Meridian facts
curve = CEIL / (1 + np.exp(-SPEED * (Q - MID)))
noise = np.random.default_rng(SEED).normal(0.0, NOISE_SD, Q.size)   # the lab's seed 26104
adopt = curve + noise
z = (Q - 8.5) / 7.5                               # quarters 1-16 mapped onto [-1, 1], for a well-conditioned fit

def fit(deg):
    c = np.linalg.lstsq(np.vander(z[HIST], deg + 1), adopt[HIST], rcond=None)[0]
    pred = np.vander(z, deg + 1) @ c
    rmse = lambda m: float(np.sqrt(np.mean((pred[m] - adopt[m]) ** 2)))
    return c, rmse(HIST), rmse(LATER), pred

DEGREES = range(1, 9)
bench = {d: fit(d) for d in DEGREES}
print("adoption history (percent of target users), quarters 1-16:", ", ".join(f"{v:.1f}" for v in adopt[HIST]))
print("later quarters 17-24:                                    ", ", ".join(f"{v:.1f}" for v in adopt[LATER]))
print(f"\n{'model':22s} {'parameters':>10s} {'error on history':>17s} {'error on later quarters':>24s} {'quarter 24':>11s}")
for d in DEGREES:
    c, rh, rl, pred = bench[d]
    label = "simple: a straight line" if d == 1 else f"rich: degree {d}"
    print(f"{label:22s} {d + 1:10d} {rh:17.2f} {rl:24.2f} {pred[-1]:11.1f}")
print("(root-mean-square errors in percentage points)")
better_fit_worse = [d for d in DEGREES if d > 1 and bench[d][1] < bench[1][1] and bench[d][2] > bench[1][2]]
print(f"every rich model, degrees {better_fit_worse[0]}-{better_fit_worse[-1]}, fits the history better than the line"
      f" and forecasts the later quarters worse: {len(better_fit_worse)} of {len(DEGREES) - 1}")

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(7.6, 3.6), gridspec_kw={"width_ratios": [1.4, 1]})
ax1.axvspan(16.5, 24.5, color="#F2F2F2", lw=0)
qq = np.linspace(1, 24, 400)
for d, col, ls in ((1, "#1F4E79", "-"), (3, "#E65100", "--"), (6, "#B71C1C", ":")):
    ax1.plot(qq, np.vander((qq - 8.5) / 7.5, d + 1) @ bench[d][0], ls, color=col, lw=1.6,
             label="straight line" if d == 1 else f"degree {d}")
ax1.plot(Q[HIST], adopt[HIST], "o", color="#616161", ms=3.5, label="history, quarters 1-16")
ax1.plot(Q[LATER], adopt[LATER], "o", mfc="white", color="#616161", ms=3.5, label="later quarters")
ax1.text(20.5, 3, "later\nquarters", ha="center", fontsize=8, color="#616161")
ax1.set(xlabel="quarter", ylabel="adoption (percent of target users)", xlim=(0.5, 24.5), ylim=(-5, 100))
ax1.legend(frameon=False, fontsize=7.5, loc="upper left")
ax2.semilogy(list(DEGREES), [bench[d][1] for d in DEGREES], "-o", color="#1F4E79", ms=4, label="error on the history")
ax2.semilogy(list(DEGREES), [bench[d][2] for d in DEGREES], "-o", color="#E65100", ms=4, label="error on later quarters")
ax2.set(xlabel="degree (complexity)", ylabel="RMS error (percentage points)", xticks=list(DEGREES), ylim=(0.8, 8000))
ax2.legend(frameon=False, fontsize=8, loc="upper left")
fig.suptitle("The better fit on history is the worse forecast (seed 26104)", fontsize=10)
plt.tight_layout(); plt.show()
adoption history (percent of target users), quarters 1-16: 3.2, 1.2, 3.9, 4.5, 2.9, 7.8, 12.7, 12.6, 13.6, 19.1, 25.3, 26.7, 35.1, 40.2, 46.3, 47.0
later quarters 17-24:                                     52.2, 53.2, 56.6, 56.2, 58.4, 58.3, 59.9, 61.2

model                  parameters  error on history  error on later quarters  quarter 24
simple: a straight line          2              4.35                     4.66        68.9
rich: degree 2                  3              1.81                    31.78       114.7
rich: degree 3                  4              1.71                    18.44        90.5
rich: degree 4                  5              1.62                    24.77         6.6
rich: degree 5                  6              1.40                   248.61      -468.5
rich: degree 6                  7              1.36                   575.08     -1198.7
rich: degree 7                  8              1.36                   810.76     -1748.6
rich: degree 8                  9              1.36                   539.66      1454.0
(root-mean-square errors in percentage points)
every rich model, degrees 2-8, fits the history better than the line and forecasts the later quarters worse: 7 of 7
The better fit on history is the worse forecast (seed 26104)

Panel 7 — Leave the record (Definition 4.6; Theorem 4.3; Figure 4.3; Table 4.4)

AXIOM Lab 1.4, step 4: fit two models to the same record, confirm that they fit equally well, then run both beyond it. Take as the record Unit A's first year, the year the planning model was calibrated on. Its excited domain (Definition 4.6) is the one state it visits, 400 legacy and 100 software engineers. The total-only model and the detailed model fit it equally well, both predicting 476.0, and they make identical predictions for every unit with that mix, one software engineer in five, whatever its size: no statistic computed from the record can tell them apart (Theorem 4.3). Off the record they separate in proportion to the distance from the record's mix. Unit B, four software engineers in five, lies outside it: there the two models disagree by 3 engineers in a year and 12.8 by year five. A longer record, Unit A's five years, carries the mix to one in three and begins to separate the two models; it still says nothing about Unit B.

Section 4.5 runs the same audit on the digital-program model, validated on seven years of history, by Table 4.4's domain items: the excited domain described, the intended use compared with it, and the conclusions beyond it annotated with the assumptions that carry them.

Python Code
def one_year(model, H, s):
    # each model's forecast of next year's total from a unit's total H and software share s
    return r * H if model == "total-only" else H * (1 - EXIT_L + (EXIT_L - EXIT_S) * s)
MODELS = ("total-only", "detailed")
H0, s0, obs1 = totals["Unit A"][0], share["Unit A"][0], totals["Unit A"][1]      # the record: Unit A's first year
print(f"the record: Unit A, {H0:.0f} engineers with software share {s0:.0%}; next year {obs1:.1f}")
disc = {}
for m in MODELS:
    pred = one_year(m, H0, s0)
    disc[m] = abs(pred - obs1)
    print(f"  {m:10s} model predicts {pred:.1f}: discrepancy {disc[m]:.1e}, squared error {(pred - obs1) ** 2:.1e}")
same_mix = max(abs(one_year("total-only", H, s0) - one_year("detailed", H, s0)) for H in (100.0, 250.0, 1000.0, 5000.0))
print(f"  on the record's mix the two models agree for a unit of any size: largest gap {same_mix:.1e}")

grid = np.round(np.arange(0.0, 1.0001, 0.1), 1)
print("\nbeyond the record: next year's total for a unit of 500, by software share")
print(f"  {'software share':16s}" + "".join(f"{s:7.1f}" for s in grid))
for m in MODELS:
    print(f"  {m + ' model':16s}" + "".join(f"{one_year(m, 500.0, s):7.1f}" for s in grid))
gapB = one_year("detailed", 500.0, 0.8) - one_year("total-only", 500.0, 0.8)
print(f"  at Unit B's mix the two models part by {gapB:.1f} engineers in a year: {one_year('total-only', 500.0, 0.8):.0f}"
      f" against {one_year('detailed', 500.0, 0.8):.0f} (Step 2)")
recA = float(abs(errA).max())
print(f"\nUnit A's five-year record (software share {share['Unit A'][0]:.0%} to {share['Unit A'][-1]:.0%}): the total-only"
      f" model misses by at most {recA:.2f}, the detailed model not at all")
print(f"Unit B lies outside that record: the total-only model misses it by {abs(errB[-1]):.1f} by year five")

AUDIT = [   # Section 4.5: the digital-program model, validated on seven years of history
    ("the program's leverage and liquidity", "within the ranges history visited", "validation evidence applies"),
    ("capability spending above 40% of capital spending", "no year in the record", "carried by assumptions"),
    ("two platforms run side by side", "no period in the record", "carried by assumptions"),
    ("a talent market like the hiring plan assumes", "none in the record", "carried by assumptions")]
print("\nSection 4.5's domain audit of the digital-program model (seven years of history; Table 4.4, domain items)")
for what, record, verdict in AUDIT:
    print(f"  {what:51s} {record:35s} {verdict}")
print("  the assumptions that carry it: an attrition mechanism credentialed elsewhere, an adoption mechanism declared"
      " as an assumption rather than fitted")

ss = np.linspace(0, 1, 201)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.axvspan(share["Unit A"][0], share["Unit A"][-1], color="#EEF3F9", lw=0)
ax.text((share["Unit A"][0] + share["Unit A"][-1]) / 2, 480.15, "Unit A's\nfive-year\nrecord", ha="center", va="top",
        fontsize=8, color="#1F4E79")
ax.plot(ss, [one_year("total-only", 500.0, s) for s in ss], "--", color="#616161", lw=1.6,
        label="total-only model: 500 x 0.952 at every mix")
ax.plot(ss, [one_year("detailed", 500.0, s) for s in ss], color="#1F4E79", lw=2, label="detailed model: 500 (0.95 + 0.01 s)")
ax.plot([s0], [obs1], "o", color="#1F4E79", ms=6, zorder=3)
ax.annotate("the record: Unit A's first year,\nboth models 476.0", (s0, obs1), textcoords="offset points", xytext=(-38, -34),
            fontsize=8, color="#1F4E79")
ax.plot([0.8, 0.8], [one_year("total-only", 500.0, 0.8), one_year("detailed", 500.0, 0.8)], color="#E65100", lw=2.5,
        zorder=3)
ax.annotate(f"Unit B: 476 against 479,\n{gapB:.1f} apart", (0.8, 477.5), textcoords="offset points", xytext=(8, -6),
            fontsize=8, color="#E65100")
ax.set(xlabel="software share of the unit's engineers", ylabel="engineers next year (unit of 500)", xlim=(0, 1),
       ylim=(474.6, 480.4), title="Equal on the record, apart beyond it (seed 26104)")
ax.legend(frameon=False, fontsize=8, loc="upper left", bbox_to_anchor=(0.36, 1.0))
plt.tight_layout(); plt.show()
the record: Unit A, 500 engineers with software share 20%; next year 476.0
  total-only model predicts 476.0: discrepancy 0.0e+00, squared error 0.0e+00
  detailed   model predicts 476.0: discrepancy 0.0e+00, squared error 0.0e+00
  on the record's mix the two models agree for a unit of any size: largest gap 0.0e+00

beyond the record: next year's total for a unit of 500, by software share
  software share      0.0    0.1    0.2    0.3    0.4    0.5    0.6    0.7    0.8    0.9    1.0
  total-only model  476.0  476.0  476.0  476.0  476.0  476.0  476.0  476.0  476.0  476.0  476.0
  detailed model    475.0  475.5  476.0  476.5  477.0  477.5  478.0  478.5  479.0  479.5  480.0
  at Unit B's mix the two models part by 3.0 engineers in a year: 476 against 479 (Step 2)

Unit A's five-year record (software share 20% to 33%): the total-only model misses by at most 1.08, the detailed model not at all
Unit B lies outside that record: the total-only model misses it by 12.8 by year five

Section 4.5's domain audit of the digital-program model (seven years of history; Table 4.4, domain items)
  the program's leverage and liquidity                within the ranges history visited   validation evidence applies
  capability spending above 40% of capital spending   no year in the record               carried by assumptions
  two platforms run side by side                      no period in the record             carried by assumptions
  a talent market like the hiring plan assumes        none in the record                  carried by assumptions
  the assumptions that carry it: an attrition mechanism credentialed elsewhere, an adoption mechanism declared as an assumption rather than fitted
Equal on the record, apart beyond it (seed 26104)

Panel 8 — Set triggers, and write the contract (Section 4.6; Figure 4.4; Tables 4.3–4.4)

AXIOM Lab 1.4, step 5: replay five years of use with drift, and set the triggers that should send the model back for revalidation. The lifecycle of Figure 4.4 runs specify, build, verify, validate, deploy, monitor, revise or retire; Table 4.4's monitoring item asks for drift indicators and revalidation triggers. Replay the planning model's five-year plan for both units against what happens, with two drift indicators: the plan's error, and how far the unit's software share has moved from the mix the model was calibrated on, 20 percent. The book declares no tolerances; the tolerances below are settings to vary. The mix indicator fires before the error does, and fires for Unit B before any plan is made, because Unit B lies outside the record. A third trigger is an event, not a measurement: revalidation follows transformation, because a company that completes a transformation has left the domain its models were validated on.

The lab's deliverable is a one-page modeling contract for the digital-program model. The last lines assemble its four parts (Section 4.1) from the book's declarations: the readings and units (Table 3.1), the assumption classes with Meridian's instances (Table 4.3), the validated domain (Section 4.5) and the lifecycle plan (Section 4.6).

Python Code
LIFECYCLE = ["specify", "build", "verify", "validate", "deploy", "monitor", "revise or retire"]    # Figure 4.4
print("Figure 4.4: " + " -> ".join(LIFECYCLE) + f" ({len(LIFECYCLE)} stages)\n")
s_cal = share["Unit A"][0]
indic = {name: {"error": np.abs(clean(coarse - totals[name])), "mix": 100 * np.abs(share[name] - s_cal)} for name in UNITS}
print(f"{'replay: the five-year plan against what happens':56s}" + "".join(f"{'year ' + str(k):>9s}" for k in yrs))
for name in UNITS:
    print(f"  {name + ': plan error (engineers)':54s}" + "".join(f"{v:9.2f}" for v in indic[name]["error"]))
    print(f"  {name + ': software share, points from 20%':54s}" + "".join(f"{v:9.2f}" for v in indic[name]["mix"]))

def first_year(series, tol):
    hit = np.nonzero(np.asarray(series) > tol + 1e-12)[0]
    return int(hit[0]) if len(hit) else None

ERR_TOLS, MIX_TOLS = (1.0, 2.5, 5.0, 10.0), (2.5, 5.0, 10.0)        # settings to vary: the book declares none
fired = {}
print("\nthe year each trigger first fires (- : not within five years; 0 : before the first forecast)")
print(f"  {'trigger':52s} {'Unit A':>7s} {'Unit B':>7s}")
for kind, tols in (("error", ERR_TOLS), ("mix", MIX_TOLS)):
    for tol in tols:
        ys = [first_year(indic[name][kind], tol) for name in UNITS]
        fired[(kind, tol)] = ys
        label = (f"plan error above {tol:g} engineer{'' if tol == 1 else 's'}" if kind == "error"
                 else f"software share more than {tol:g} points from 20%")
        print(f"  {label:52s} " + " ".join(f"{('-' if y is None else y):>7}" for y in ys))
print(f"  {'a transformation event: the program starts or ends':52s} {'at once':>15s}")

TABLE_4_3 = [   # Table 4.3: class, content, Meridian instance
    ("Structural", "which mechanisms exist; coupling; functional forms", "modernization affects efficiency with a one-period lag"),
    ("Parametric", "values and ranges of named parameters", "talent attrition between 6 and 11 percent a year"),
    ("Domain", "the region where the model is asserted", "leverage at most 4.5x; no acquisitions"),
    ("Measurement", "proxies, error sizes, and delays for each reading",
     "capability index: survey proxy, +/-5 points, twice a year"),
    ("Horizon", "periods over which conclusions are claimed", "12 quarters")]
READINGS = [("liquidity", "US$ billion"), ("net leverage", "net debt / EBITDA"), ("workforce capability", "index, 0-100"),
            ("technology platform", "index, 0-100"), ("operational efficiency", "index, 0-100"),
            ("return on invested capital", "ratio"), ("strategic risk (lower is better)", "index, 0-100"),
            ("market share", "ratio")]    # Table 3.1
CONTRACT = [
    ("(i) readings, units, measurement", [f"{n} ({u})" for n, u in READINGS] + [
        "observed directly: liquidity, leverage, market share; index proxies with material error: capability,"
        " efficiency, strategic risk; organizational cohesion is latent (Section 4.5)"]),
    ("(ii) assumptions (Table 4.3)", [f"{c.lower()}: {m}" for c, _, m in TABLE_4_3]),
    ("(iii) validated domain", ["seven years of history; leverage and liquidity within the ranges it visited",
                                "beyond it: capability spending above 40% of capital spending, two platforms side by side,"
                                " the hiring plan's talent market"]),
    ("(iv) lifecycle plan (Section 4.6)", [" -> ".join(LIFECYCLE),
                                           "triggers: drift indicators beyond their declared tolerances; the program's"
                                           " start and completion (revalidation follows transformation)",
                                           "retire the model at the edge of its domain: retirement is a success mode"])]
print(f"\nthe modeling contract for the digital-program model: {len(CONTRACT)} parts, {len(READINGS)} readings,"
      f" {len(TABLE_4_3)} assumption classes")
for part, lines in CONTRACT:
    print(f"  {part}")
    for ln in lines:
        print(f"      {ln}")
Figure 4.4: specify -> build -> verify -> validate -> deploy -> monitor -> revise or retire (7 stages)

replay: the five-year plan against what happens            year 0   year 1   year 2   year 3   year 4   year 5
  Unit A: plan error (engineers)                             0.00     0.00     0.13     0.36     0.68     1.08
  Unit A: software share, points from 20%                    0.00     2.69     5.31     7.86    10.34    12.76
  Unit B: plan error (engineers)                             0.00     3.00     5.77     8.32    10.66    12.80
  Unit B: software share, points from 20%                   60.00    60.79    61.56    62.29    63.00    63.68

the year each trigger first fires (- : not within five years; 0 : before the first forecast)
  trigger                                               Unit A  Unit B
  plan error above 1 engineer                                5       1
  plan error above 2.5 engineers                             -       1
  plan error above 5 engineers                               -       2
  plan error above 10 engineers                              -       4
  software share more than 2.5 points from 20%               1       0
  software share more than 5 points from 20%                 2       0
  software share more than 10 points from 20%                4       0
  a transformation event: the program starts or ends           at once

the modeling contract for the digital-program model: 4 parts, 8 readings, 5 assumption classes
  (i) readings, units, measurement
      liquidity (US$ billion)
      net leverage (net debt / EBITDA)
      workforce capability (index, 0-100)
      technology platform (index, 0-100)
      operational efficiency (index, 0-100)
      return on invested capital (ratio)
      strategic risk (lower is better) (index, 0-100)
      market share (ratio)
      observed directly: liquidity, leverage, market share; index proxies with material error: capability, efficiency, strategic risk; organizational cohesion is latent (Section 4.5)
  (ii) assumptions (Table 4.3)
      structural: modernization affects efficiency with a one-period lag
      parametric: talent attrition between 6 and 11 percent a year
      domain: leverage at most 4.5x; no acquisitions
      measurement: capability index: survey proxy, +/-5 points, twice a year
      horizon: 12 quarters
  (iii) validated domain
      seven years of history; leverage and liquidity within the ranges it visited
      beyond it: capability spending above 40% of capital spending, two platforms side by side, the hiring plan's talent market
  (iv) lifecycle plan (Section 4.6)
      specify -> build -> verify -> validate -> deploy -> monitor -> revise or retire
      triggers: drift indicators beyond their declared tolerances; the program's start and completion (revalidation follows transformation)
      retire the model at the edge of its domain: retirement is a success mode

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

Each checkpoint is a number printed in Chapter 4 (Worked Example 4.1, Steps 1–5, Table 4.5, Tables 4.1–4.4, Figure 4.4, Appendix 4.A) or in Online Appendix 4.B; the theorem checks compare with what the printed result 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
LADDER = [("L3", "group"), ("L2", "divisions"), ("L1", "business units, plants"), ("L0", "transactions, individuals")]
CHECKLIST = ["Verification", "Validation", "Domain", "Monitoring"]                      # Table 4.4
checks = [
    ("Step 1: Unit A legacy engineers next year (workbook)", paths["Unit A"][1, 0], 368, 1e-9),
    ("Step 1: Unit A software engineers next year (workbook)", paths["Unit A"][1, 1], 108, 1e-9),
    ("Step 1: Unit A total next year (workbook)", totals["Unit A"][1], 476, 1e-9),
    ("Step 1: Unit B legacy engineers next year (workbook)", paths["Unit B"][1, 0], 92, 1e-9),
    ("Step 1: Unit B software engineers next year (workbook)", paths["Unit B"][1, 1], 387, 1e-9),
    ("Step 1: Unit B total next year (workbook)", totals["Unit B"][1], 479, 1e-9),
    ("Step 2: Unit A total today (workbook)", totals["Unit A"][0], 500, 0),
    ("Step 2: Unit B total today (workbook)", totals["Unit B"][0], 500, 0),
    ("Table 4.5: Unit A, year 2 (workbook)", totals["Unit A"][2], 453.3, 0.05),
    ("Table 4.5: Unit A, year 3 (workbook)", totals["Unit A"][3], 431.8, 0.05),
    ("Table 4.5: Unit A, year 4 (workbook)", totals["Unit A"][4], 411.4, 0.05),
    ("Table 4.5: Unit A, year 5 (workbook)", totals["Unit A"][5], 392.1, 0.05),
    ("Table 4.5: Unit B, year 2 (workbook)", totals["Unit B"][2], 458.9, 0.05),
    ("Table 4.5: Unit B, year 3 (workbook)", totals["Unit B"][3], 439.7, 0.05),
    ("Table 4.5: Unit B, year 4 (workbook)", totals["Unit B"][4], 421.3, 0.05),
    ("Table 4.5: Unit B, year 5 (workbook)", totals["Unit B"][5], 403.8, 0.05),
    ("Step 3: the total-only model's rate (workbook)", r, 0.952, 1e-12),
    ("Table 4.5: total-only model, year 2 (workbook)", coarse[2], 453.2, 0.05),
    ("Table 4.5: total-only model, year 3 (workbook)", coarse[3], 431.4, 0.05),
    ("Table 4.5: total-only model, year 4 (workbook)", coarse[4], 410.7, 0.05),
    ("Table 4.5: total-only model, year 5 (workbook)", coarse[5], 391.0, 0.05),
    ("Table 4.5: error for Unit B, year 1 (workbook)", errB[1], -3.0, 0.05),
    ("Table 4.5: error for Unit B, year 2 (workbook)", errB[2], -5.8, 0.05),
    ("Table 4.5: error for Unit B, year 3 (workbook)", errB[3], -8.3, 0.05),
    ("Table 4.5: error for Unit B, year 4 (workbook)", errB[4], -10.7, 0.05),
    ("Table 4.5: error for Unit B, year 5 (workbook)", errB[5], -12.8, 0.05),
    ("Step 4: Unit A total in year five, 392 (workbook)", totals["Unit A"][5], 392, 0.5),
    ("Step 4: Unit B total in year five, 404 (workbook)", totals["Unit B"][5], 404, 0.5),
    ("Step 4: Unit B software engineers in year five, about 338 (workbook)", soft["Unit B"][5], 338, 0.5),
    ("Step 5: base rate of the repaired summary, 0.95 (workbook)", 1 - EXIT_L, 0.95, 1e-12),
    ("Step 5: mix coefficient of the repaired summary, 0.01 (workbook)", EXIT_L - EXIT_S, 0.01, 1e-12),
    ("Step 5: repaired summary, Unit A next year (workbook)", mix_model(500.0, 0.2)[0], 476, 1e-9),
    ("Step 5: repaired summary, Unit B next year (workbook)", mix_model(500.0, 0.8)[0], 479, 1e-9),
    ("Theorem 4.2: (H, s) model against Table 4.5, largest gap (workbook)", Hs_units_gap, 0, 1e-9),
    ("Theorem 4.2: (H, s) model, random configurations, largest gap", Hs_gap, 0, 1e-9),
    ("Proposition 4.3: the two units together next year, 476 + 479 (workbook)", Hd1, 955, 1e-9),
    ("Appendix 4.A: A(1, -1), first entry (workbook)", img[0], 0.92, 1e-12),
    ("Appendix 4.A: A(1, -1), second entry (workbook)", img[1], -0.93, 1e-12),
    ("Appendix 4.A: the total of A(1, -1), not 0 (workbook)", P @ img, -0.01, 1e-12),
    ("Online Appendix 4.B: Unit B's error in year one, 3 (workbook)", -errB[1], 3, 0.05),
    ("Online Appendix 4.B: Unit B's error by year five, about 13 (workbook)", -errB[5], 13, 0.5),
    ("Online Appendix 4.B: years in which the bound fails (workbook)", fails, 0, 0),
    ("Theorem 4.3: discrepancy on the record, total-only model (workbook)", disc["total-only"], 0, 1e-9),
    ("Theorem 4.3: discrepancy on the record, detailed model (workbook)", disc["detailed"], 0, 1e-9),
    ("Theorem 4.3: the two models at Unit B's mix, 479 - 476 (workbook)", gapB, 3, 1e-9),
    ("Table 4.4 verification: the code against the closed form (workbook)", code_gap, 0, 1e-9),
    ("Definition 4.5: negative pools in 100 years, none (workbook)", negative, 0, 0),
    ("Table 4.1: model types in the chain (workbook)", len(TABLE_4_1), 4, 0),
    ("Table 4.2: levels of the Meridian abstraction ladder (workbook)", len(LADDER), 4, 0),
    ("Table 4.2: readings at level L3, those of Table 3.1 (workbook)", len(READINGS), 8, 0),
    ("Table 4.3: declared assumption classes (workbook)", len(TABLE_4_3), 5, 0),
    ("Table 4.4: stages of the validation checklist (workbook)", len(CHECKLIST), 4, 0),
    ("Figure 4.4: stages of the model lifecycle (workbook)", len(LIFECYCLE), 7, 0),
    ("Section 4.1: parts of the modeling contract (workbook)", len(CONTRACT), 4, 0),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
    status = "PASS" if abs(got - want) <= tol + 1e-12 else "FAIL"; ok += status == "PASS"
    print(f"{name:{width}s} {float(got):10.4f}   book {want:9.4f}   {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")
Step 1: Unit A legacy engineers next year (workbook)                      368.0000   book  368.0000   PASS
Step 1: Unit A software engineers next year (workbook)                    108.0000   book  108.0000   PASS
Step 1: Unit A total next year (workbook)                                 476.0000   book  476.0000   PASS
Step 1: Unit B legacy engineers next year (workbook)                       92.0000   book   92.0000   PASS
Step 1: Unit B software engineers next year (workbook)                    387.0000   book  387.0000   PASS
Step 1: Unit B total next year (workbook)                                 479.0000   book  479.0000   PASS
Step 2: Unit A total today (workbook)                                     500.0000   book  500.0000   PASS
Step 2: Unit B total today (workbook)                                     500.0000   book  500.0000   PASS
Table 4.5: Unit A, year 2 (workbook)                                      453.2800   book  453.3000   PASS
Table 4.5: Unit A, year 3 (workbook)                                      431.7632   book  431.8000   PASS
Table 4.5: Unit A, year 4 (workbook)                                      411.3779   book  411.4000   PASS
Table 4.5: Unit A, year 5 (workbook)                                      392.0572   book  392.1000   PASS
Table 4.5: Unit B, year 2 (workbook)                                      458.9200   book  458.9000   PASS
Table 4.5: Unit B, year 3 (workbook)                                      439.7168   book  439.7000   PASS
Table 4.5: Unit B, year 4 (workbook)                                      421.3494   book  421.3000   PASS
Table 4.5: Unit B, year 5 (workbook)                                      403.7791   book  403.8000   PASS
Step 3: the total-only model's rate (workbook)                              0.9520   book    0.9520   PASS
Table 4.5: total-only model, year 2 (workbook)                            453.1520   book  453.2000   PASS
Table 4.5: total-only model, year 3 (workbook)                            431.4007   book  431.4000   PASS
Table 4.5: total-only model, year 4 (workbook)                            410.6935   book  410.7000   PASS
Table 4.5: total-only model, year 5 (workbook)                            390.9802   book  391.0000   PASS
Table 4.5: error for Unit B, year 1 (workbook)                             -3.0000   book   -3.0000   PASS
Table 4.5: error for Unit B, year 2 (workbook)                             -5.7680   book   -5.8000   PASS
Table 4.5: error for Unit B, year 3 (workbook)                             -8.3161   book   -8.3000   PASS
Table 4.5: error for Unit B, year 4 (workbook)                            -10.6560   book  -10.7000   PASS
Table 4.5: error for Unit B, year 5 (workbook)                            -12.7989   book  -12.8000   PASS
Step 4: Unit A total in year five, 392 (workbook)                         392.0572   book  392.0000   PASS
Step 4: Unit B total in year five, 404 (workbook)                         403.7791   book  404.0000   PASS
Step 4: Unit B software engineers in year five, about 338 (workbook)      337.8709   book  338.0000   PASS
Step 5: base rate of the repaired summary, 0.95 (workbook)                  0.9500   book    0.9500   PASS
Step 5: mix coefficient of the repaired summary, 0.01 (workbook)            0.0100   book    0.0100   PASS
Step 5: repaired summary, Unit A next year (workbook)                     476.0000   book  476.0000   PASS
Step 5: repaired summary, Unit B next year (workbook)                     479.0000   book  479.0000   PASS
Theorem 4.2: (H, s) model against Table 4.5, largest gap (workbook)         0.0000   book    0.0000   PASS
Theorem 4.2: (H, s) model, random configurations, largest gap               0.0000   book    0.0000   PASS
Proposition 4.3: the two units together next year, 476 + 479 (workbook)   955.0000   book  955.0000   PASS
Appendix 4.A: A(1, -1), first entry (workbook)                              0.9200   book    0.9200   PASS
Appendix 4.A: A(1, -1), second entry (workbook)                            -0.9300   book   -0.9300   PASS
Appendix 4.A: the total of A(1, -1), not 0 (workbook)                      -0.0100   book   -0.0100   PASS
Online Appendix 4.B: Unit B's error in year one, 3 (workbook)               3.0000   book    3.0000   PASS
Online Appendix 4.B: Unit B's error by year five, about 13 (workbook)      12.7989   book   13.0000   PASS
Online Appendix 4.B: years in which the bound fails (workbook)              0.0000   book    0.0000   PASS
Theorem 4.3: discrepancy on the record, total-only model (workbook)         0.0000   book    0.0000   PASS
Theorem 4.3: discrepancy on the record, detailed model (workbook)           0.0000   book    0.0000   PASS
Theorem 4.3: the two models at Unit B's mix, 479 - 476 (workbook)           3.0000   book    3.0000   PASS
Table 4.4 verification: the code against the closed form (workbook)         0.0000   book    0.0000   PASS
Definition 4.5: negative pools in 100 years, none (workbook)                0.0000   book    0.0000   PASS
Table 4.1: model types in the chain (workbook)                              4.0000   book    4.0000   PASS
Table 4.2: levels of the Meridian abstraction ladder (workbook)             4.0000   book    4.0000   PASS
Table 4.2: readings at level L3, those of Table 3.1 (workbook)              8.0000   book    8.0000   PASS
Table 4.3: declared assumption classes (workbook)                           5.0000   book    5.0000   PASS
Table 4.4: stages of the validation checklist (workbook)                    4.0000   book    4.0000   PASS
Figure 4.4: stages of the model lifecycle (workbook)                        7.0000   book    7.0000   PASS
Section 4.1: parts of the modeling contract (workbook)                      4.0000   book    4.0000   PASS

54 of 54 checkpoints PASS

Next. Chapter 5 asks which state is the right one: the minimal state, the memory the future requires (Theorem 5.1). Worked Example 4.1 is a first instance of its test. The total merges two units whose futures differ, so it is not a state of the engineering workforce; the total with the software share is. AXIOM-04 runs the same bench interactively (Lab 1.4); this notebook and the workbook are its reproducible record.

Dynamic Corporate Transformation — Volume I: Foundations and Mathematical Framework; Volume II: Enterprise Optimization & Applications
Jump to any chapter

Volume I: Foundations and Mathematical Framework

  1. Ch. 1Introduction to Dynamic Corporate Transformation
  2. Ch. 2Enterprise Systems and Transformation
  3. Ch. 3Mathematical Foundations
  4. Ch. 4Enterprise Modeling Principles
  5. Ch. 5Enterprise State Representation
  6. Ch. 6Enterprise Transformation Operators
  7. Ch. 7Dynamic Enterprise Systems
  8. Ch. 8Stochastic Enterprise Dynamics
  9. Ch. 9Enterprise State Architecture
  10. Ch. 10Enterprise Capital Architecture
  11. Ch. 11Enterprise Performance Architecture
  12. Ch. 12Enterprise Risk, Resilience, and Robustness Architecture
  13. Ch. 13Unified Enterprise Transformation Architecture
  14. Ch. 14Mathematical Analysis of the Unified Enterprise Transformation Architecture
  15. Ch. 15Mathematical Formulation of Enterprise Optimization
  16. Ch. 16Synthesis, Future Directions, and Transition to Volume II

Volume II: Enterprise Optimization & Applications

  1. Ch. 1Introduction to Enterprise Optimization
  2. Ch. 2The General Enterprise Optimization Problem Revisited
  3. Ch. 3Convex Enterprise Optimization
  4. Ch. 4Nonlinear and Mixed-Integer Enterprise Optimization
  5. Ch. 5Dynamic Enterprise Optimization
  6. Ch. 6Optimal Control of Enterprise Systems
  7. Ch. 7Dynamic Programming for Enterprise Systems
  8. Ch. 8Hamilton–Jacobi–Bellman Enterprise Framework
  9. Ch. 9Stochastic Enterprise Optimization
  10. Ch. 10Neuro-Fuzzy Robust Enterprise Optimization
  11. Ch. 11Distributionally Robust Enterprise Optimization
  12. Ch. 12Multi-Objective Enterprise Optimization
  13. Ch. 13Machine Learning for Enterprise Transformation
  14. Ch. 14Artificial Intelligence for Enterprise Optimization
  15. Ch. 15Enterprise Digital Twins and Autonomous Enterprise Transformation
  16. Ch. 16Enterprise Applications and Integrated Transformation Case Studies

Dynamic Corporate Transformation

Springer Nature · Management for Professionals · Forthcoming 2027

  • Volume I — Foundations and Mathematical Framework
  • Volume II — Enterprise Optimization & Applications
Buy Volume I: Dynamic Corporate Transformation: Foundations and Mathematical FrameworkBuy Volume II: Dynamic Corporate Transformation: Enterprise Optimization & Applications
Jump to any chapter

Volume I: Foundations and Mathematical Framework

  1. Ch. 1Introduction to Dynamic Corporate Transformation
  2. Ch. 2Enterprise Systems and Transformation
  3. Ch. 3Mathematical Foundations
  4. Ch. 4Enterprise Modeling Principles
  5. Ch. 5Enterprise State Representation
  6. Ch. 6Enterprise Transformation Operators
  7. Ch. 7Dynamic Enterprise Systems
  8. Ch. 8Stochastic Enterprise Dynamics
  9. Ch. 9Enterprise State Architecture
  10. Ch. 10Enterprise Capital Architecture
  11. Ch. 11Enterprise Performance Architecture
  12. Ch. 12Enterprise Risk, Resilience, and Robustness Architecture
  13. Ch. 13Unified Enterprise Transformation Architecture
  14. Ch. 14Mathematical Analysis of the Unified Enterprise Transformation Architecture
  15. Ch. 15Mathematical Formulation of Enterprise Optimization
  16. Ch. 16Synthesis, Future Directions, and Transition to Volume II

Volume II: Enterprise Optimization & Applications

  1. Ch. 1Introduction to Enterprise Optimization
  2. Ch. 2The General Enterprise Optimization Problem Revisited
  3. Ch. 3Convex Enterprise Optimization
  4. Ch. 4Nonlinear and Mixed-Integer Enterprise Optimization
  5. Ch. 5Dynamic Enterprise Optimization
  6. Ch. 6Optimal Control of Enterprise Systems
  7. Ch. 7Dynamic Programming for Enterprise Systems
  8. Ch. 8Hamilton–Jacobi–Bellman Enterprise Framework
  9. Ch. 9Stochastic Enterprise Optimization
  10. Ch. 10Neuro-Fuzzy Robust Enterprise Optimization
  11. Ch. 11Distributionally Robust Enterprise Optimization
  12. Ch. 12Multi-Objective Enterprise Optimization
  13. Ch. 13Machine Learning for Enterprise Transformation
  14. Ch. 14Artificial Intelligence for Enterprise Optimization
  15. Ch. 15Enterprise Digital Twins and Autonomous Enterprise Transformation
  16. Ch. 16Enterprise Applications and Integrated Transformation Case Studies