Skip to content

Vol. I, Ch. 10

DCT Laboratory — Volume I, Chapter 10

Enterprise Capital Architecture

This laboratory demonstrates

Seed 26110 · Companion to Chapter 10 and AXIOM Lab 1.10 (module AXIOM-10) · Mirrored in DCT_V1_Ch10_Lab.xlsx

This laboratory reproduces Worked Example 10.1, Keep the Engineers or Rebuild Them?, with the book's declarations, and works the five steps of AXIOM Lab 1.10, Meridian's Capital Ledger: build the capital vector, price the rent, test the asymmetry, allocate a budget, audit the ledger. Every Meridian number below is the book's or follows from its declarations (Worked Example 10.1, Table 10.5, Figure 10.3, Online Appendix 10.B.6); the final cell checks the printed ones. Money is in $ million.

The declarations (Worked Example 10.1, Steps 1–2)

The capital vector of Equation 10.1 has ten forms (Table 10.1): financial, human, intellectual, technological, organizational, relational, strategic, governance, innovation and informational capital. Meridian's restructuring sells part of Industrial Systems on the terms of Worked Example 3.1: $112 million net if the shared engineering team goes with the unit, $92 million if Meridian keeps it. The unit takes 10 percent of the technology position, and without the team the workforce-capability index falls from 58 to 53, below the floor of 55 that the digital build and the automation program require. Capability is a capital stock that loses 2.5 percent a quarter to attrition and the aging of skills, C′=0.975 C+IC' = 0.975\,C + I (Equation 10.3); hiring and training add at most 2.5 points a quarter, at about $4 million a point, the price the buyer's discount implies.

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

# Table 10.1: the ten forms of the capital vector (Equation 10.1): form, symbol, content, typical carrier
FORMS = [("Financial", "C_F", "money and funding capacity", "treasury"),
         ("Human", "C_H", "skills embodied in the workforce", "people, functions"),
         ("Intellectual", "C_I", "codified knowledge and IP", "IP estate; data"),
         ("Technological", "C_T", "installed systems and platforms", "operations; IT"),
         ("Organizational", "C_O", "routines and coordination capacity", "the wiring itself"),
         ("Relational", "C_R", "external trust and commitments", "boundary components"),
         ("Strategic", "C_S", "positional advantage and options", "corporate center"),
         ("Governance", "C_G", "decision quality and legitimacy", "board; governance"),
         ("Innovation", "C_N", "pipeline of unrealized options", "R&D; ventures"),
         ("Informational", "C_Info", "decision-relevant data and models", "platforms; functions")]

# Worked Example 10.1 (the sale's terms are Worked Example 3.1's); money in $ million
LIQUIDITY, TECH, TECH_SHARE = 620.0, 41.0, 0.10     # liquidity, technology index, share of it the unit takes
PROCEEDS_LEAVE, DISCOUNT = 112.0, 20.0               # net proceeds if the team goes; the discount to keep it
C_KEEP, POINTS_LOST, FLOOR = 58.0, 5.0, 55.0         # capability with the team, points lost without it, floor
DELTA, CAP = 0.025, 2.5                              # attrition a quarter; most hiring and training a quarter
PROCEEDS_KEEP, C_LEAVE = PROCEEDS_LEAVE - DISCOUNT, C_KEEP - POINTS_LOST
PRICE = DISCOUNT / POINTS_LOST                       # $ million a capability point
CBAR, RENT = CAP / DELTA, DELTA * C_KEEP             # ceiling under the cap; rent on 58 (points a quarter)

def path(c0, invest, n, d=DELTA, target=None):
    # C' = (1 - d) C + I for n quarters (Equation 10.3); invest is a number or one per quarter;
    # with a target, invest only what lands the stock on it, never overshooting
    c, spend = [c0], []
    for k in range(n):
        i = float(invest[k]) if np.ndim(invest) else float(invest)
        if target is not None:
            i = min(i, max(target - (1 - d) * c[-1], 0.0))
        spend.append(i); c.append((1 - d) * c[-1] + i)
    return np.array(c), np.array(spend)

def build_time(c0, c1, cap=CAP, d=DELTA):
    # Theorem 10.3(iii): no spending pattern inside the cap gets from c0 to c1 sooner
    cbar = cap / d
    return log((cbar - c0) / (cbar - c1)) / log(1 / (1 - d))

def first_at(c, level):
    # the first quarter at or above level (None if never)
    hit = np.nonzero(np.asarray(c) >= level - 1e-9)[0]
    return int(hit[0]) if len(hit) else None

print(f"capital vector: {len(FORMS)} forms (Table 10.1)")
print(f"capability decays {DELTA:.1%} a quarter, {1 - (1 - DELTA)**4:.1%} a year; hiring and training at most {CAP} points a quarter")
print(f"price of a point: ${DISCOUNT:.0f} million for {POINTS_LOST:.0f} points = ${PRICE:.1f} million")
capital vector: 10 forms (Table 10.1)
capability decays 2.5% a quarter, 9.6% a year; hiring and training at most 2.5 points a quarter
price of a point: $20 million for 5 points = $4.0 million

Panel 1 — Build the capital vector (Table 10.1; Worked Example 10.1, Step 1)

AXIOM Lab 1.10, step 1. The capital vector carries ten forms. Definitions 10.3–10.9 define the first of them one by one, and Table 10.2 profiles those on the four properties that drive their dynamics; the other three, governance, innovation and informational capital, are treated with the same machinery. Meridian's declared state carries four capital readings (Table 5.2, tagged ECA), each with a carrier, a unit and an error bar. It declares no proxy for organizational capital: Section 4.5 counts organizational cohesion among the latent readings, and Section 10.4 warns that the softer forms have the widest error bars exactly where they matter most. Then read the sale as a conversion (Theorem 10.1): technological, human and relational capital into cash, with the buyer's discount as a market quote for a stock that never appears on the balance sheet, $4 million a point.

Python Code
print(f"Table 10.1: the {len(FORMS)} forms of the capital vector")
print(f"  {'form':15s} {'symbol':7s} {'content':36s} typical carrier")
for name, sym, content, carrier in FORMS:
    print(f"  {name:15s} {sym:7s} {content:36s} {carrier}")

# Table 10.2: the forms of Definitions 10.3-10.9 on the four properties (delta a year)
PROFILE = {"C_F": ("about 0", "immediate", "fully", "fully"),
           "C_H": ("0.10-0.25", "years", "at the margin", "no"),
           "C_I": ("0.05-0.20", "years", "partly", "yes"),
           "C_T": ("0.15-0.30", "quarters to years", "in parts", "partly"),
           "C_O": ("0.03-0.10", "years", "no", "no"),
           "C_R": ("0.05-0.15, plus breach", "years", "no", "no"),
           "C_S": ("tied to the regime", "years", "rarely", "partly")}
print("\nTable 10.2: the four properties, for the forms of Definitions 10.3-10.9 (the other three are not profiled)")
print(f"  {'form':15s} {'delta a year':23s} {'build time':18s} {'tradable':14s} separable")
for name, sym, _, _ in FORMS:
    if sym in PROFILE:
        d, b, t, s = PROFILE[sym]
        print(f"  {name:15s} {d:23s} {b:18s} {t:14s} {s}")

# Meridian's capital readings: Table 5.2 (tagged ECA), carriers from Tables 9.1 and 10.1
READINGS = [("x1 liquidity", "financial", "$620 million", "treasury systems, +/-1%", "treasury (TRS)"),
            ("x2 net leverage", "financial", "3.4x (covenant 4.5x)", "audited accounts, +/-2%", "treasury (TRS)"),
            ("x3 workforce capability", "human", "58 (index)", "skills survey, +/-5", "engineering (ENG)"),
            ("x4 technology platform", "technological", "41 (index)", "architecture audit, +/-4", "operations; IT"),
            ("none declared", "organizational", "latent", "no declared proxy", "the wiring itself")]
print("\nMeridian's capital vector as declared (Table 5.2)")
print(f"  {'reading':24s} {'form':15s} {'today':21s} {'measured by (error)':25s} carrier")
for r in READINGS:
    print(f"  {r[0]:24s} {r[1]:15s} {r[2]:21s} {r[3]:25s} {r[4]}")

TECH_AFTER = TECH * (1 - TECH_SHARE)
AFTER = {"keep the team": (LIQUIDITY + PROCEEDS_KEEP, C_KEEP, TECH_AFTER),
         "let it go": (LIQUIDITY + PROCEEDS_LEAVE, C_LEAVE, TECH_AFTER)}
print("\nThe sale as a conversion (Theorem 10.1): technological, human and relational capital into cash")
print(f"  {'':24s} {'today':>7s} {'keep the team':>15s} {'let it go':>11s}")
for j, label in enumerate(("liquidity ($ million)", "workforce capability", "technology platform")):
    today = (LIQUIDITY, C_KEEP, TECH)[j]
    print(f"  {label:24s} {today:7.1f} {AFTER['keep the team'][j]:15.1f} {AFTER['let it go'][j]:11.1f}")
print(f"the buyer's discount: ${PROCEEDS_LEAVE - PROCEEDS_KEEP:.0f} million for {C_KEEP - C_LEAVE:.0f} capability points"
      f" = ${(PROCEEDS_LEAVE - PROCEEDS_KEEP) / (C_KEEP - C_LEAVE):.1f} million a point")
Table 10.1: the 10 forms of the capital vector
  form            symbol  content                              typical carrier
  Financial       C_F     money and funding capacity           treasury
  Human           C_H     skills embodied in the workforce     people, functions
  Intellectual    C_I     codified knowledge and IP            IP estate; data
  Technological   C_T     installed systems and platforms      operations; IT
  Organizational  C_O     routines and coordination capacity   the wiring itself
  Relational      C_R     external trust and commitments       boundary components
  Strategic       C_S     positional advantage and options     corporate center
  Governance      C_G     decision quality and legitimacy      board; governance
  Innovation      C_N     pipeline of unrealized options       R&D; ventures
  Informational   C_Info  decision-relevant data and models    platforms; functions

Table 10.2: the four properties, for the forms of Definitions 10.3-10.9 (the other three are not profiled)
  form            delta a year            build time         tradable       separable
  Financial       about 0                 immediate          fully          fully
  Human           0.10-0.25               years              at the margin  no
  Intellectual    0.05-0.20               years              partly         yes
  Technological   0.15-0.30               quarters to years  in parts       partly
  Organizational  0.03-0.10               years              no             no
  Relational      0.05-0.15, plus breach  years              no             no
  Strategic       tied to the regime      years              rarely         partly

Meridian's capital vector as declared (Table 5.2)
  reading                  form            today                 measured by (error)       carrier
  x1 liquidity             financial       $620 million          treasury systems, +/-1%   treasury (TRS)
  x2 net leverage          financial       3.4x (covenant 4.5x)  audited accounts, +/-2%   treasury (TRS)
  x3 workforce capability  human           58 (index)            skills survey, +/-5       engineering (ENG)
  x4 technology platform   technological   41 (index)            architecture audit, +/-4  operations; IT
  none declared            organizational  latent                no declared proxy         the wiring itself

The sale as a conversion (Theorem 10.1): technological, human and relational capital into cash
                             today   keep the team   let it go
  liquidity ($ million)      620.0           712.0       732.0
  workforce capability        58.0            58.0        53.0
  technology platform         41.0            36.9        36.9
the buyer's discount: $20 million for 5 capability points = $4.0 million a point

Panel 2 — Price the rent (Theorem 10.3(ii); Figure 10.1; Worked Example 10.1, Step 2)

AXIOM Lab 1.10, step 2, first part: hold each stock at its target with its sustaining flow. Under constant investment II a stock converges to I/δI/\delta, so holding C∗C^{\ast} needs the perpetual flow I=δC∗I = \delta C^{\ast}, and any lower flow guarantees decline: capital is a rental. Figure 10.1's three stocks share the target 100 and decay at 5, 10 and 25 percent a year. From zero they take 44.9, 21.9 and 8.0 years to reach 90 percent of the target at the rent, and 11.7, 5.7 and 2.1 at twice the rent. Meridian's capability rent at 58 is 1.45 points a quarter, about $23 million a year, already in the operating budget.

Python Code
RENTAL = [(0.05, "organizational", "#1F4E79"), (0.10, "human", "#E65100"), (0.25, "technological", "#B71C1C")]

def years_to(share, invest, d, target=100.0):
    # from zero at constant investment, C_k = (I/d)(1 - (1 - d)^k): years to reach share x target
    cinf = invest / d
    return log(cinf / (cinf - share * target)) / log(1 / (1 - d))

print("Figure 10.1: three stocks with the target 100, built from zero, yearly")
print(f"  {'stock':15s} {'delta':>6s} {'rent a year':>12s} {'years to 90%: at the rent':>26s} {'at twice the rent':>18s} {'(1/delta) ln 10':>16s}")
rental = {}
for d, name, _ in RENTAL:
    rental[name] = (years_to(0.9, d * 100, d), years_to(0.9, 2 * d * 100, d))
    print(f"  {name:15s} {d:6.2f} {d * 100:12.0f} {rental[name][0]:26.1f} {rental[name][1]:18.1f} {log(10) / d:16.1f}")

print(f"\nMeridian's capability: {DELTA:.1%} a quarter is {1 - (1 - DELTA)**4:.1%} a year, inside the 6-11% attrition range of Table 4.3")
print(f"rent on 58: {DELTA} x 58 = {RENT:.2f} points a quarter ({4 * RENT:.1f} a year)"
      f" = ${PRICE * RENT:.1f} million a quarter, ${4 * PRICE * RENT:.1f} million a year")
held, held_spend = path(C_KEEP, RENT, 8)
print(f"held with its sustaining flow for eight quarters: capability {held.min():.2f} to {held.max():.2f}, spending {held_spend.sum():.1f} points")

fig, ax = plt.subplots(figsize=(7.6, 3.6))
T = 30
for d, name, col in RENTAL:
    at_rent, _ = path(0.0, d * 100, T, d)
    fast, _ = path(0.0, 2 * d * 100, T, d, target=100.0)
    ax.plot(np.arange(T + 1), at_rent, color=col, lw=2, label=f"{name}, δ = {d:.0%}: rent {d * 100:.0f} a year")
    ax.plot(np.arange(T + 1), fast, color=col, lw=1.2, ls="--")
ax.axhline(90, color="#999999", lw=0.8, ls=":")
ax.text(T, 88, "90% of target", ha="right", va="top", fontsize=8, color="#616161")
ax.plot([], [], color="#616161", lw=1.2, ls="--", label="dashed: twice the rent until the target")
ax.set(xlabel="years from zero", ylabel="stock (target = 100)", xlim=(0, T), ylim=(0, 108),
       title="At the rent, slow stocks take decades to build (seed 26110)")
ax.legend(frameon=False, fontsize=8, loc="lower right"); plt.tight_layout(); plt.show()
Figure 10.1: three stocks with the target 100, built from zero, yearly
  stock            delta  rent a year  years to 90%: at the rent  at twice the rent  (1/delta) ln 10
  organizational    0.05            5                       44.9               11.7             46.1
  human             0.10           10                       21.9                5.7             23.0
  technological     0.25           25                        8.0                2.1              9.2

Meridian's capability: 2.5% a quarter is 9.6% a year, inside the 6-11% attrition range of Table 4.3
rent on 58: 0.025 x 58 = 1.45 points a quarter (5.8 a year) = $5.8 million a quarter, $23.2 million a year
held with its sustaining flow for eight quarters: capability 58.00 to 58.00, spending 11.6 points
At the rent, slow stocks take decades to build (seed 26110)

Panel 3 — Run the rebuild clock (Theorem 10.3(iii); Figure 10.3; Worked Example 10.1, Steps 3–4)

With the cap at 2.5 points a quarter the ceiling is Cˉ=2.5/0.025=100\bar C = 2.5/0.025 = 100, and no spending pattern reaches a target sooner than full throttle: from 53, at least ln⁡(47/45)/ln⁡(1/0.975)=1.7\ln(47/45)/\ln(1/0.975) = 1.7 quarters to clear 55 and ln⁡(47/42)/ln⁡(1/0.975)=4.4\ln(47/42)/\ln(1/0.975) = 4.4 to regain 58, two quarters and five in practice. At the old maintenance budget capability creeps back toward 58 and clears 55 only after 21 quarters, more than five years. Step 4: while capability is below 55 the digital build and the automation program are off the menu (Propositions 10.3 and 10.4); the sale removes them on the day it closes.

Python Code
full, spend_full = path(C_LEAVE, CAP, 24, target=C_KEEP)      # rebuild at the cap, landing on 58
maint, _ = path(C_LEAVE, RENT, 120)                            # the old maintenance budget
t55, t58 = build_time(C_LEAVE, FLOOR), build_time(C_LEAVE, C_KEEP)
k55, k58 = first_at(full, FLOOR), first_at(full, C_KEEP)
k55m, k57m = first_at(maint, FLOOR), first_at(maint, 57.0)
print(f"ceiling under the cap: {CAP} / {DELTA} = {CBAR:.0f}")
print(f"full throttle from 53: at least {t55:.2f} quarters to clear 55 and {t58:.2f} to regain 58")
fmt = lambda xs, nd=2: ", ".join(f"{v:.{nd}f}" for v in np.round(xs, nd))
print(f"capability at the cap, quarters 0-{k58}: {fmt(full[:k58 + 1])} -> clears 55 at quarter {k55}, regains 58 at quarter {k58}")
print(f"investment at the cap: {fmt(spend_full[:k58])} points a quarter")
print(f"old maintenance budget ({RENT:.2f} a quarter): capability = 58 - 5 x 0.975^k;"
      f" clears 55 at quarter {k55m} ({k55m / 4:.2f} years), {maint[24]:.2f} after six years, 57 only at quarter {k57m}")
print(f"Step 4: the digital build and the automation program are off the menu for {k55} quarters at the cap, {k55m} at the old budget")

q = np.arange(25)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.axvspan(0, k55, color="#F6E3E3", lw=0)
ax.axhline(FLOOR, color="#B71C1C", lw=0.9, ls="--")
ax.text(6.3, FLOOR + 0.08, "floor 55: digital build and automation", ha="left", va="bottom", fontsize=8, color="#B71C1C")
ax.plot(q, np.full(len(q), C_KEEP), color="#1F4E79", lw=3, alpha=0.5, label=f"keep the team: proceeds \\${PROCEEDS_KEEP:.0f} million")
ax.step(q, full[:25], where="post", color="#E65100", lw=2, label=f"let it go, rebuild at the cap: \\${PROCEEDS_LEAVE:.0f} million; {k55} quarters below 55")
ax.step(q, maint[:25], where="post", color="#616161", lw=1.6, ls=":", label=f"let it go, old maintenance budget: {k55m} quarters below 55")
ax.set(xlabel="quarters after closing", ylabel="workforce capability (index)", xlim=(0, 24), ylim=(52.3, 60.6),
       title="Rebuilding at the cap clears the floor in two quarters (seed 26110)")
ax.legend(frameon=False, fontsize=8, loc="upper right"); plt.tight_layout(); plt.show()
ceiling under the cap: 2.5 / 0.025 = 100
full throttle from 53: at least 1.72 quarters to clear 55 and 4.44 to regain 58
capability at the cap, quarters 0-5: 53.00, 54.18, 55.32, 56.44, 57.53, 58.00 -> clears 55 at quarter 2, regains 58 at quarter 5
investment at the cap: 2.50, 2.50, 2.50, 2.50, 1.91 points a quarter
old maintenance budget (1.45 a quarter): capability = 58 - 5 x 0.975^k; clears 55 at quarter 21 (5.25 years), 55.28 after six years, 57 only at quarter 64
Step 4: the digital build and the automation program are off the menu for 2 quarters at the cap, 21 at the old budget
Rebuilding at the cap clears the floor in two quarters (seed 26110)

Panel 4 — Cut the rent for four quarters (Proposition 10.4; Section 11.8)

AXIOM Lab 1.10, step 2, second part: cut investment for four quarters and watch the decline, and the recovery at the old budget and at the cap; this is the proposal the transformation office must answer. The book prints its first consequence in Chapter 11 (Section 11.8): skipping the rent adds about $23 million a year to reported EBITDA, while capability falls below the floor of 55 within three quarters. The rest follows from the declarations of Worked Example 10.1.

Python Code
CUT = 4
cut, _ = path(C_KEEP, 0.0, CUT)
below = int(np.argmax(cut < FLOOR))
print(f"capability with no investment, quarters 0-{CUT}: {fmt(cut)} -> below 55 from quarter {below}")
print(f"the cut saves {CUT * RENT:.2f} points = ${PRICE * CUT * RENT:.1f} million, the year's rent")
c4 = cut[-1]
old, _ = path(c4, RENT, 400)
fast, fast_spend = path(c4, CAP, 40, target=C_KEEP)
r55, r58 = first_at(fast, FLOOR), first_at(fast, C_KEEP)
print(f"recovery from {c4:.2f} at the old budget: clears 55 after {first_at(old, FLOOR)} quarters and creeps toward 58"
      f" without regaining it ({old[40]:.2f} after ten years)")
print(f"recovery at the cap: clears 55 after {r55} quarters, regains 58 after {r58} (Theorem 10.3(iii): at least {build_time(c4, C_KEEP):.2f})")
rebuy, hold = fast_spend[:r58].sum(), RENT * r58
print(f"over those {r58} quarters the cap invests {rebuy:.2f} points (${PRICE * rebuy:.1f} million) against {hold:.2f}"
      f" (${PRICE * hold:.1f} million) at the rent: ${PRICE * (rebuy - hold):.1f} million more")
print(f"capability is below 55 for {CUT - below + 1 + r55 - 1} quarters (quarters {below}-{CUT + r55 - 1}): the digital build waits a year")
capability with no investment, quarters 0-4: 58.00, 56.55, 55.14, 53.76, 52.41 -> below 55 from quarter 3
the cut saves 5.80 points = $23.2 million, the year's rent
recovery from 52.41 at the old budget: clears 55 after 25 quarters and creeps toward 58 without regaining it (55.97 after ten years)
recovery at the cap: clears 55 after 3 quarters, regains 58 after 5 (Theorem 10.3(iii): at least 4.93)
over those 5 quarters the cap invests 12.43 points ($49.7 million) against 7.25 ($29.0 million) at the rent: $20.7 million more
capability is below 55 for 4 quarters (quarters 3-6): the digital build waits a year

Panel 5 — Test the asymmetry (Proposition 10.4; Online Appendix 10.B.2)

AXIOM Lab 1.10, step 3: destroy 30 percent of human capital in one quarter and count the quarters needed to recover, here from the declarations of Worked Example 10.1. Burning capital is fast; rebuilding it is limited by δ\delta (Proposition 10.4). Online Appendix 10.B.2 prices a write-off ww from a floor cc: climbing back takes at least k(w)=ln⁡((Cˉ−c+w)/(Cˉ−c))/ln⁡(1/(1−δ))k(w) = \ln\bigl((\bar C - c + w)/(\bar C - c)\bigr)/\ln\bigl(1/(1-\delta)\bigr) periods, about w/(δ(Cˉ−c))w/(\delta(\bar C - c)) for small write-offs. For Meridian's 2 points below the floor that is 1.72 quarters exactly and 1.78 by the approximation.

Python Code
SHOCK = 0.30
c0 = (1 - SHOCK) * C_KEEP
s_cap, s_spend = path(c0, CAP, 40, target=C_KEEP)
s_old, _ = path(c0, RENT, 400)
k55s, k58s = first_at(s_cap, FLOOR), first_at(s_cap, C_KEEP)
print(f"destroy {SHOCK:.0%} of capability in one quarter: 58 -> {c0:.1f}, a write-off of {C_KEEP - c0:.1f} points")
print(f"at the cap: clears 55 after {k55s} quarters, regains 58 after {k58s} (Theorem 10.3(iii): at least {build_time(c0, C_KEEP):.2f}),"
      f" investing {s_spend[:k58s].sum():.1f} points (${PRICE * s_spend[:k58s].sum():.0f} million)")
print(f"at the old budget: clears 55 only after {first_at(s_old, FLOOR)} quarters and never regains 58")

def repurchase(w, c, d=DELTA, cbar=CBAR):
    # Online Appendix 10.B.2: the fewest periods back to c after a write-off w, and its approximation
    return log((cbar - c + w) / (cbar - c)) / log(1 / (1 - d)), w / (d * (cbar - c))

for w, c, label in ((2.0, FLOOR, "2 points below the floor of 55"), (C_KEEP - c0, C_KEEP, "the 30% write-off from 58")):
    ex, ap = repurchase(w, c)
    print(f"repurchase period, {label}: {ex:.2f} quarters exactly, {ap:.2f} by w/(delta(Cbar - c))")

q = np.arange(41)
cut_cap = np.concatenate([cut, fast[1:]])[:41]
cut_old = np.concatenate([cut, old[1:]])[:41]
fig, ax = plt.subplots(figsize=(7.6, 3.6))
ax.axhline(FLOOR, color="#B71C1C", lw=0.9, ls="--")
ax.axhline(C_KEEP, color="#999999", lw=0.8)
ax.step(q, s_cap[:41], where="post", color="#E65100", lw=2, label=f"destroy 30% in a quarter, rebuild at the cap: back in {k58s}")
ax.step(q, s_old[:41], where="post", color="#E65100", lw=1.4, ls=":", label="destroy 30%, old budget: never back")
ax.step(q, cut_cap, where="post", color="#1F4E79", lw=2, label=f"cut for four quarters, then the cap: back after {r58} more")
ax.step(q, cut_old, where="post", color="#1F4E79", lw=1.4, ls=":", label="cut for four quarters, then the old budget")
ax.text(15.5, FLOOR + 0.2, "floor 55", ha="left", va="bottom", fontsize=8, color="#B71C1C")
ax.set_yticks([40, 45, 50, 55, 58])
ax.set(xlabel="quarters", ylabel="workforce capability (index)", xlim=(0, 40), ylim=(39, 60),
       title="One quarter to destroy, fourteen to rebuild (seed 26110)")
ax.legend(frameon=False, fontsize=8, loc="lower right"); plt.tight_layout(); plt.show()
destroy 30% of capability in one quarter: 58 -> 40.6, a write-off of 17.4 points
at the cap: clears 55 after 11 quarters, regains 58 after 14 (Theorem 10.3(iii): at least 13.69), investing 34.7 points ($139 million)
at the old budget: clears 55 only after 70 quarters and never regains 58
repurchase period, 2 points below the floor of 55: 1.72 quarters exactly, 1.78 by w/(delta(Cbar - c))
repurchase period, the 30% write-off from 58: 13.69 quarters exactly, 16.57 by w/(delta(Cbar - c))
One quarter to destroy, fourteen to rebuild (seed 26110)

Panel 6 — Compare the cash (Table 10.5; Online Appendix 10.B.6)

Worked Example 10.1, Step 5. Over the five-quarter rebuild window, full-throttle rebuilding invests 11.9 points ($47.6 million) against the 7.25 points ($29.0 million) needed to hold 58 with the team in place: $18.6 million more. Net of the extra $20 million of proceeds, rebuilding comes out $1.4 million ahead (Table 10.5): in cash, the two options are a wash. Online Appendix 10.B.6 shows the comparison is robust to the cap and the attrition rate, and prices a $30 million ask.

Python Code
def compare(cap=CAP, d=DELTA, ask=DISCOUNT):
    # rebuild at the cap from 53 against holding 58 with the team, over the rebuild window
    reb, spend = path(C_LEAVE, cap, 200, d, target=C_KEEP)
    q55, q58 = first_at(reb, FLOOR), first_at(reb, C_KEEP)
    inv_rebuild, inv_keep = spend[:q58].sum(), d * C_KEEP * q58
    net_keep, net_rebuild = PROCEEDS_LEAVE - ask - PRICE * inv_keep, PROCEEDS_LEAVE - PRICE * inv_rebuild
    return dict(q55=q55, q58=q58, rebuild=inv_rebuild, keep=inv_keep, extra=PRICE * (inv_rebuild - inv_keep),
                net_keep=net_keep, net_rebuild=net_rebuild)

base = compare()
TABLE105 = [("Proceeds at closing ($ million)", PROCEEDS_KEEP, PROCEEDS_LEAVE, "0f"),
            ("Capability at closing", C_KEEP, C_LEAVE, "0f"),
            ("Quarters below the floor of 55", 0, base["q55"], "0f"),
            ("Quarters below 58", 0, base["q58"], "0f"),
            ("Capability investment, five quarters (points)", base["keep"], base["rebuild"], "2f"),
            ("Capability investment, five quarters ($ million)", PRICE * base["keep"], PRICE * base["rebuild"], "1f"),
            ("Proceeds net of that investment ($ million)", base["net_keep"], base["net_rebuild"], "1f")]
print(f"Table 10.5   {'':38s} {'keep the team':>14s} {'let it go, rebuild':>19s}")
for label, keep, leave, f in TABLE105:
    print(f"  {label:49s} {keep:14{'.' + f}} {leave:19{'.' + f}}")
print(f"rebuilding invests {base['rebuild'] - base['keep']:.2f} points (${base['extra']:.1f} million) more,"
      f" and comes out ${base['net_rebuild'] - base['net_keep']:.1f} million ahead net of the extra proceeds")

CASES = [("as declared", CAP, DELTA), ("cap 2.0 points a quarter", 2.0, DELTA),
         ("attrition 6% a year", CAP, 1 - 0.94 ** 0.25), ("attrition 11% a year", CAP, 1 - 0.89 ** 0.25)]
print(f"\nOnline Appendix 10.B.6   {'delta a quarter':>16s} {'clears 55':>10s} {'regains 58':>11s} {'extra cost':>11s}")
sens = {}
for label, cap, d in CASES:
    sens[label] = compare(cap, d)
    r = sens[label]
    print(f"  {label:25s} {d:14.4f} {r['q55']:10d} {r['q58']:11d} {r['extra']:11.1f}")
ask30 = compare(ask=30.0)
print(f"a $30 million ask: keeping nets ${ask30['net_keep']:.1f} million against ${ask30['net_rebuild']:.1f} million for rebuilding,"
      f" ${ask30['net_rebuild'] - ask30['net_keep']:.1f} million more in cash: the price the board would put on two quarters of digital-program time")
Table 10.5                                           keep the team  let it go, rebuild
  Proceeds at closing ($ million)                               92                 112
  Capability at closing                                         58                  53
  Quarters below the floor of 55                                 0                   2
  Quarters below 58                                              0                   5
  Capability investment, five quarters (points)               7.25               11.91
  Capability investment, five quarters ($ million)            29.0                47.6
  Proceeds net of that investment ($ million)                 63.0                64.4
rebuilding invests 4.66 points ($18.6 million) more, and comes out $1.4 million ahead net of the extra proceeds

Online Appendix 10.B.6    delta a quarter  clears 55  regains 58  extra cost
  as declared                       0.0250          2           5        18.6
  cap 2.0 points a quarter          0.0250          4           9        17.8
  attrition 6% a year               0.0153          2           4        19.4
  attrition 11% a year              0.0287          3           6        18.2
a $30 million ask: keeping nets $53.0 million against $64.4 million for rebuilding, $11.4 million more in cash: the price the board would put on two quarters of digital-program time

Panel 7 — Allocate a budget (Theorems 10.2(i) and 10.4; Figure 10.2)

AXIOM Lab 1.10, step 4. Section 10.7's technology company needs technology, people and routines in fixed proportions, F=min⁡(CT/1.0, CH/0.5, CO/0.75)F = \min(C_T/1.0,\ C_H/0.5,\ C_O/0.75), with stocks 80, 45 and 60. The ratios are 80, 90 and 80: technology and routines tie as the bottleneck and human capital has 12.5 percent slack. Funding the bottleneck raises capacity by 0.57 a point until all three tie at 90 after 17.5 points, and by 0.44 after; these slopes are the budget's shadow value λ\lambda (Theorem 10.4). An equal split earns 0.33 a point, and the "talent war" buys nothing: capacity after 30 points is 95.6, 90.0 and 80.0. Capacity here reads no financial capital, so a finance-heavy split adds nothing until the money is converted into one of the three forms.

Python Code
STOCKS = np.array([80.0, 45.0, 60.0])        # technology, human, organizational (Figure 10.2)
REQ = np.array([1.0, 0.5, 0.75])             # requirements r_i: F = min_i C_i / r_i
NAMES = ("technology", "human", "organizational")

def capacity(c, r=REQ):
    return float(np.min(np.asarray(c) / r))

def need(level, c=STOCKS, r=REQ):
    # Theorem 10.4(ii): a_i(l) = max(r_i l - C_i, 0), the funding that lifts every form to level l
    return np.maximum(r * level - c, 0.0)

def fund_bottleneck(B, c=STOCKS, r=REQ):
    # the level l_B with sum_i a_i(l_B) = B, walking the kinks where another form joins the tie
    kinks = np.unique(c / r)
    level = kinks[0]
    for nxt in list(kinks[1:]) + [np.inf]:
        tied = r[c / r <= level + 1e-9].sum()
        spent = need(level, c, r).sum()
        if spent + (nxt - level) * tied >= B - 1e-12:
            level += (B - spent) / tied
            break
        level = nxt
    return level, need(level, c, r)

POLICIES = {"fund the bottleneck": lambda B: fund_bottleneck(B)[0],
            "equal split": lambda B: capacity(STOCKS + B / 3),
            "all to human capital": lambda B: capacity(STOCKS + np.array([0.0, B, 0.0]))}
ratios = STOCKS / REQ
print("ratios C/r:", ", ".join(f"{n} {v:.0f}" for n, v in zip(NAMES, ratios)),
      f"-> capacity {capacity(STOCKS):.0f}; human capital's slack {ratios[1] / ratios.min() - 1:.1%}")
tie = need(ratios.max()).sum()
lam = [1 / REQ[ratios <= ratios.min() + 1e-9].sum(), 1 / REQ.sum()]
print(f"fund the bottleneck: lambda = 1/(1.0 + 0.75) = {lam[0]:.3f} a point until all three tie at {ratios.max():.0f}"
      f" after {tie:.1f} points, then 1/(1.0 + 0.5 + 0.75) = {lam[1]:.3f}")
print(f"{'budget':>8s}" + "".join(f"{p:>24s}" for p in POLICIES))
for B in (0.0, 10.0, 17.5, 30.0):
    print(f"{B:8.1f}" + "".join(f"{f(B):24.2f}" for f in POLICIES.values()))
level30, alloc30 = fund_bottleneck(30.0)
print("the bottleneck allocation of 30 points:", ", ".join(f"{n} {v:.2f}" for n, v in zip(NAMES, alloc30)), f"-> capacity {level30:.2f}")
eq_rate = (POLICIES["equal split"](30.0) - capacity(STOCKS)) / 30.0
print(f"equal split: {eq_rate:.3f} a point; all to human capital: {POLICIES['all to human capital'](30.0) - capacity(STOCKS):.1f} in all")

# Online Appendix 10.B.3: F = min(C1/1, C2/2), stocks (10, 30), budget 20
l3, a3 = fund_bottleneck(20.0, np.array([10.0, 30.0]), np.array([1.0, 2.0]))
print(f"Online Appendix 10.B.3: capacity {l3:.0f}, allocation ({fmt(a3, 1)}), kink after"
      f" {need(15.0, np.array([10.0, 30.0]), np.array([1.0, 2.0])).sum():.0f} units")
# Online Appendix 10.B.4: complements F = C1^a C2^b; the optimal final stocks are in the ratio a : b
for a, b in ((0.3, 0.3), (0.4, 0.2)):
    tgt = np.array([a, b]) / (a + b) * (40 + 20 + 20)
    print(f"Online Appendix 10.B.4, alpha {a}, beta {b}: final stocks ({fmt(tgt, 1)}), funding ({fmt(tgt - [40, 20], 1)})")

Bs = np.linspace(0, 30, 301)
fig, ax = plt.subplots(figsize=(7.6, 3.6))
for (name, f), col, ls in zip(POLICIES.items(), ("#1F4E79", "#E65100", "#B71C1C"), ("-", "--", ":")):
    ax.plot(Bs, [f(B) for B in Bs], color=col, lw=2, ls=ls, label=f"{name}: {f(30.0):.1f} after 30")
ax.plot([tie], [ratios.max()], "o", color="#1F4E79", ms=5)
ax.annotate("all three tie at 90:\nthe bottleneck rotates", xy=(tie, ratios.max()), xytext=(19.5, 84.5), fontsize=8,
            color="#1F4E79", arrowprops=dict(arrowstyle="-", color="#1F4E79", lw=0.6))
ax.set_yticks([80, 85, 90, 95])
ax.set(xlabel="budget spent (index points)", ylabel="delivery capacity (index)", xlim=(0, 30), ylim=(78, 97.5),
       title="Funding the bottleneck buys the most capacity (seed 26110)")
ax.legend(frameon=False, fontsize=8, loc="upper left"); plt.tight_layout(); plt.show()
ratios C/r: technology 80, human 90, organizational 80 -> capacity 80; human capital's slack 12.5%
fund the bottleneck: lambda = 1/(1.0 + 0.75) = 0.571 a point until all three tie at 90 after 17.5 points, then 1/(1.0 + 0.5 + 0.75) = 0.444
  budget     fund the bottleneck             equal split    all to human capital
     0.0                   80.00                   80.00                   80.00
    10.0                   85.71                   83.33                   80.00
    17.5                   90.00                   85.83                   80.00
    30.0                   95.56                   90.00                   80.00
the bottleneck allocation of 30 points: technology 15.56, human 2.78, organizational 11.67 -> capacity 95.56
equal split: 0.333 a point; all to human capital: 0.0 in all
Online Appendix 10.B.3: capacity 20, allocation (10.0, 10.0), kink after 5 units
Online Appendix 10.B.4, alpha 0.3, beta 0.3: final stocks (40.0, 40.0), funding (0.0, 20.0)
Online Appendix 10.B.4, alpha 0.4, beta 0.2: final stocks (53.3, 26.7), funding (13.3, 6.7)
Funding the bottleneck buys the most capacity (seed 26110)

Panel 8 — Audit the ledger (Theorems 10.1 and 10.5(iii); Online Appendix 10.B.5)

AXIOM Lab 1.10, step 5. Every stock obeys the balance of Equation 10.2: investment, use, decay, and conversion in and out. Conversion leaks (Theorem 10.1(ii)): cash turned into a platform at 80 percent and the platform into capability at 70 percent delivers 56 percent (Online Appendix 10.B.1). The plug πi,k=ΔCi,k−[declared channels]\pi_{i,k} = \Delta C_{i,k} - [\text{declared channels}] is zero exactly when the declared channels are complete and correctly measured; one undeclared channel with flow uu shows up as π=s u\pi = s\,u, so its sign and timing locate it (Theorem 10.5(iii)). Two of Meridian's records, built from the book's numbers and each missing one conversion: the sale booked without the engineering team, and the proposed training cut booked as if the rent were paid.

Python Code
print(f"conversion chain: 0.80 x 0.70 = {0.80 * 0.70:.2f} of the budget arrives as capability; {1 - 0.80 * 0.70:.0%} leaks")

def audit(stocks, invest_declared, d=DELTA):
    # Theorem 10.5(iii): pi_k = C_{k+1} - C_k - [I_k - d C_k], the change the declared channels do not explain
    stocks = np.asarray(stocks, float)
    return np.diff(stocks) - (np.asarray(invest_declared, float) - d * stocks[:-1])

def report(name, ends, stocks, declared, cash_plug):
    # one row per quarter, labelled by the quarter it ends; capability in points, cash in $ million
    pi = audit(stocks, declared)
    print(name)
    print(f"  {'quarter':>7s} {'start':>8s} {'declared I':>11s} {'decay':>7s} {'end':>8s} {'plug':>7s} {'cash plug':>10s}")
    for k in range(len(pi)):
        print(f"  {ends[k]:7d} {stocks[k]:8.3f} {declared[k]:11.3f} {DELTA * stocks[k]:7.3f} {stocks[k + 1]:8.3f}"
              f" {round(pi[k], 9) + 0.0:7.2f} {cash_plug[k]:10.1f}")
    hit = np.nonzero(np.abs(pi) > 1e-9)[0]
    print(f"  nonzero plugs in quarters {[int(ends[k]) for k in hit]}: sign {'-' if pi[hit].sum() < 0 else '+'},"
          f" {abs(pi[hit].sum()):.2f} points in all; cash plug {sum(cash_plug):+.1f}")
    return pi

# Record A: the sale closes in quarter 0 and the team leaves with the unit; the ledger declares hiring,
# training and attrition, but not the team's transfer, and the treasury books the unit at the $92 million
# price it would fetch without the team
true_A = [RENT, RENT] + list(spend_full[:k58])
out_A = [0.0, POINTS_LOST] + [0.0] * k58
rec_A = [C_KEEP]
for i, u in zip(true_A, out_A):
    rec_A.append((1 - DELTA) * rec_A[-1] + i - u)
cash_A = [0.0, PROCEEDS_LEAVE - PROCEEDS_KEEP] + [0.0] * k58
pi_A = report("Record A: the sale, booked without the engineering team (quarter 0 ends with the closing)",
              np.arange(-1, k58 + 1), rec_A, true_A, cash_A)
print(f"  -> one outflow of {-pi_A.min():.0f} points on capability and ${max(cash_A):.0f} million into cash in the closing quarter:"
      f" a conversion at ${max(cash_A) / -pi_A.min():.0f} million a point, the team sold with the unit\n")

# Record B: training is cut for four quarters, but the ledger still books the rent as invested
true_B = [0.0] * CUT + [RENT] * CUT
declared_B = [RENT] * (2 * CUT)
rec_B, _ = path(C_KEEP, true_B, 2 * CUT)
cash_B = [PRICE * (dcl - tru) for dcl, tru in zip(declared_B, true_B)]
pi_B = report("Record B: the training cut, booked as if the rent were paid", np.arange(1, 2 * CUT + 1), rec_B, declared_B, cash_B)
print(f"  -> {-pi_B[0]:.2f} points a quarter out of capability and ${cash_B[0]:.1f} million a quarter into cash for exactly the four quarters"
      f" of the cut: the rent turned back into cash, ${sum(cash_B):.1f} million of reported earnings borrowed from the stock")
conversion chain: 0.80 x 0.70 = 0.56 of the budget arrives as capability; 44% leaks
Record A: the sale, booked without the engineering team (quarter 0 ends with the closing)
  quarter    start  declared I   decay      end    plug  cash plug
       -1   58.000       1.450   1.450   58.000    0.00        0.0
        0   58.000       1.450   1.450   53.000   -5.00       20.0
        1   53.000       2.500   1.325   54.175    0.00        0.0
        2   54.175       2.500   1.354   55.321    0.00        0.0
        3   55.321       2.500   1.383   56.438    0.00        0.0
        4   56.438       2.500   1.411   57.527    0.00        0.0
        5   57.527       1.911   1.438   58.000    0.00        0.0
  nonzero plugs in quarters [0]: sign -, 5.00 points in all; cash plug +20.0
  -> one outflow of 5 points on capability and $20 million into cash in the closing quarter: a conversion at $4 million a point, the team sold with the unit

Record B: the training cut, booked as if the rent were paid
  quarter    start  declared I   decay      end    plug  cash plug
        1   58.000       1.450   1.450   56.550   -1.45        5.8
        2   56.550       1.450   1.414   55.136   -1.45        5.8
        3   55.136       1.450   1.378   53.758   -1.45        5.8
        4   53.758       1.450   1.344   52.414   -1.45        5.8
        5   52.414       1.450   1.310   52.554    0.00        0.0
        6   52.554       1.450   1.314   52.690    0.00        0.0
        7   52.690       1.450   1.317   52.822    0.00        0.0
        8   52.822       1.450   1.321   52.952    0.00        0.0
  nonzero plugs in quarters [1, 2, 3, 4]: sign -, 5.80 points in all; cash plug +23.2
  -> 1.45 points a quarter out of capability and $5.8 million a quarter into cash for exactly the four quarters of the cut: the rent turned back into cash, $23.2 million of reported earnings borrowed from the stock

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

Each checkpoint is a number printed in Chapter 10 (Worked Example 10.1, Tables 10.1 and 10.5, Figures 10.1–10.3, Section 10.7), in Online Appendix 10.B, or in Chapter 11's reading of the rent (Section 11.8). The workbook recomputes the ones marked workbook with Excel formulas and shows PASS against the same engine values on its Checks sheet.

Python Code
checks = [
    ("forms in the capital vector (workbook)", len(FORMS), 10, 0),
    ("price of a capability point (workbook)", PRICE, 4.0, 0.05),
    ("liquidity after the sale, team goes (workbook)", AFTER["let it go"][0], 732, 0.5),
    ("liquidity after the sale, team kept (workbook)", AFTER["keep the team"][0], 712, 0.5),
    ("technology after the sale (workbook)", TECH_AFTER, 36.9, 0.05),
    ("depreciation a year, percent (workbook)", 100 * (1 - (1 - DELTA) ** 4), 9.6, 0.05),
    ("rent on 58, points a quarter (workbook)", RENT, 1.45, 0.005),
    ("rent on 58, $ million a year (workbook)", 4 * PRICE * RENT, 23, 0.5),
    ("years to 90%, delta 5%, at the rent (workbook)", rental["organizational"][0], 44.9, 0.05),
    ("years to 90%, delta 10%, at the rent (workbook)", rental["human"][0], 21.9, 0.05),
    ("years to 90%, delta 25%, at the rent (workbook)", rental["technological"][0], 8.0, 0.05),
    ("years to 90%, delta 5%, twice the rent (workbook)", rental["organizational"][1], 11.7, 0.05),
    ("years to 90%, delta 10%, twice the rent (workbook)", rental["human"][1], 5.7, 0.05),
    ("years to 90%, delta 25%, twice the rent (workbook)", rental["technological"][1], 2.1, 0.05),
    ("ceiling under the cap (workbook)", CBAR, 100, 0),
    ("time to clear 55 at the cap, quarters (workbook)", t55, 1.72, 0.005),
    ("time to regain 58 at the cap, quarters (workbook)", t58, 4.4, 0.05),
    ("capability after one quarter at the cap (workbook)", full[1], 54.18, 0.005),
    ("capability after four quarters at the cap (workbook)", full[4], 57.53, 0.005),
    ("quarters below 55, rebuild at the cap (workbook)", base["q55"], 2, 0),
    ("quarters below 58, rebuild at the cap (workbook)", base["q58"], 5, 0),
    ("old budget: quarters below 55 (workbook)", k55m, 21, 0),
    ("old budget: capability after six years (workbook)", maint[24], 55.3, 0.05),
    ("old budget: quarters to reach 57 (workbook)", k57m, 64, 0),
    ("rebuild investment, points (workbook)", base["rebuild"], 11.91, 0.005),
    ("rebuild investment, $ million (workbook)", PRICE * base["rebuild"], 47.6, 0.05),
    ("keep investment, $ million (workbook)", PRICE * base["keep"], 29.0, 0.05),
    ("extra cost of rebuilding, $ million (workbook)", base["extra"], 18.6, 0.05),
    ("net proceeds, keep the team (workbook)", base["net_keep"], 63.0, 0.05),
    ("net proceeds, rebuild (workbook)", base["net_rebuild"], 64.4, 0.05),
    ("cap 2.0: quarter capability clears 55 (workbook)", sens["cap 2.0 points a quarter"]["q55"], 4, 0),
    ("cap 2.0: quarter capability regains 58 (workbook)", sens["cap 2.0 points a quarter"]["q58"], 9, 0),
    ("cap 2.0: extra cost, $ million (workbook)", sens["cap 2.0 points a quarter"]["extra"], 17.8, 0.05),
    ("attrition 6%: quarter capability clears 55 (workbook)", sens["attrition 6% a year"]["q55"], 2, 0),
    ("attrition 6%: quarter capability regains 58 (workbook)", sens["attrition 6% a year"]["q58"], 4, 0),
    ("attrition 6%: extra cost, $ million (workbook)", sens["attrition 6% a year"]["extra"], 19.4, 0.05),
    ("attrition 11%: quarter capability clears 55 (workbook)", sens["attrition 11% a year"]["q55"], 3, 0),
    ("attrition 11%: quarter capability regains 58 (workbook)", sens["attrition 11% a year"]["q58"], 6, 0),
    ("attrition 11%: extra cost, $ million (workbook)", sens["attrition 11% a year"]["extra"], 18.2, 0.05),
    ("$30m ask: keeping costs more, $ million (workbook)", ask30["net_rebuild"] - ask30["net_keep"], 11, 0.5),
    ("skipped rent: quarter below 55 (workbook)", below, 3, 0),
    ("repurchase of 2 points, exact (workbook)", repurchase(2.0, FLOOR)[0], 1.72, 0.005),
    ("repurchase of 2 points, approximation (workbook)", repurchase(2.0, FLOOR)[1], 1.78, 0.005),
    ("bottleneck: capacity after 30 (workbook)", POLICIES["fund the bottleneck"](30.0), 95.6, 0.05),
    ("equal split: capacity after 30 (workbook)", POLICIES["equal split"](30.0), 90.0, 0.05),
    ("all to human capital: capacity after 30 (workbook)", POLICIES["all to human capital"](30.0), 80.0, 0.05),
    ("shadow value before the tie (workbook)", lam[0], 0.57, 0.005),
    ("shadow value after the tie (workbook)", lam[1], 0.44, 0.005),
    ("budget at which all three tie (workbook)", tie, 17.5, 0),
    ("equal split: capacity a point (workbook)", eq_rate, 0.33, 0.005),
    ("OA 10.B.3: capacity with a budget of 20 (workbook)", l3, 20, 1e-9),
    ("OA 10.B.4: funding of form 1 (workbook)", (0.4 / 0.6) * 80 - 40, 13.3, 0.05),
    ("conversion chain, share delivered (workbook)", 0.80 * 0.70, 0.56, 1e-9),
]
ok, width = 0, max(len(name) for name, *_ in checks)
for name, got, want, tol in checks:
    status = "PASS" if abs(got - want) <= tol + 1e-9 else "FAIL"; ok += status == "PASS"
    print(f"{name:{width}s} {got:10.4f}   book {want:9.4f}   {status}")
print(f"\n{ok} of {len(checks)} checkpoints PASS")
forms in the capital vector (workbook)                     10.0000   book   10.0000   PASS
price of a capability point (workbook)                      4.0000   book    4.0000   PASS
liquidity after the sale, team goes (workbook)            732.0000   book  732.0000   PASS
liquidity after the sale, team kept (workbook)            712.0000   book  712.0000   PASS
technology after the sale (workbook)                       36.9000   book   36.9000   PASS
depreciation a year, percent (workbook)                     9.6312   book    9.6000   PASS
rent on 58, points a quarter (workbook)                     1.4500   book    1.4500   PASS
rent on 58, $ million a year (workbook)                    23.2000   book   23.0000   PASS
years to 90%, delta 5%, at the rent (workbook)             44.8906   book   44.9000   PASS
years to 90%, delta 10%, at the rent (workbook)            21.8543   book   21.9000   PASS
years to 90%, delta 25%, at the rent (workbook)             8.0039   book    8.0000   PASS
years to 90%, delta 5%, twice the rent (workbook)          11.6553   book   11.7000   PASS
years to 90%, delta 10%, twice the rent (workbook)          5.6742   book    5.7000   PASS
years to 90%, delta 25%, twice the rent (workbook)          2.0781   book    2.1000   PASS
ceiling under the cap (workbook)                          100.0000   book  100.0000   PASS
time to clear 55 at the cap, quarters (workbook)            1.7176   book    1.7200   PASS
time to regain 58 at the cap, quarters (workbook)           4.4426   book    4.4000   PASS
capability after one quarter at the cap (workbook)         54.1750   book   54.1800   PASS
capability after four quarters at the cap (workbook)       57.5267   book   57.5300   PASS
quarters below 55, rebuild at the cap (workbook)            2.0000   book    2.0000   PASS
quarters below 58, rebuild at the cap (workbook)            5.0000   book    5.0000   PASS
old budget: quarters below 55 (workbook)                   21.0000   book   21.0000   PASS
old budget: capability after six years (workbook)          55.2768   book   55.3000   PASS
old budget: quarters to reach 57 (workbook)                64.0000   book   64.0000   PASS
rebuild investment, points (workbook)                      11.9115   book   11.9100   PASS
rebuild investment, $ million (workbook)                   47.6460   book   47.6000   PASS
keep investment, $ million (workbook)                      29.0000   book   29.0000   PASS
extra cost of rebuilding, $ million (workbook)             18.6460   book   18.6000   PASS
net proceeds, keep the team (workbook)                     63.0000   book   63.0000   PASS
net proceeds, rebuild (workbook)                           64.3540   book   64.4000   PASS
cap 2.0: quarter capability clears 55 (workbook)            4.0000   book    4.0000   PASS
cap 2.0: quarter capability regains 58 (workbook)           9.0000   book    9.0000   PASS
cap 2.0: extra cost, $ million (workbook)                  17.7934   book   17.8000   PASS
attrition 6%: quarter capability clears 55 (workbook)       2.0000   book    2.0000   PASS
attrition 6%: quarter capability regains 58 (workbook)      4.0000   book    4.0000   PASS
attrition 6%: extra cost, $ million (workbook)             19.3870   book   19.4000   PASS
attrition 11%: quarter capability clears 55 (workbook)      3.0000   book    3.0000   PASS
attrition 11%: quarter capability regains 58 (workbook)     6.0000   book    6.0000   PASS
attrition 11%: extra cost, $ million (workbook)            18.1765   book   18.2000   PASS
$30m ask: keeping costs more, $ million (workbook)         11.3540   book   11.0000   PASS
skipped rent: quarter below 55 (workbook)                   3.0000   book    3.0000   PASS
repurchase of 2 points, exact (workbook)                    1.7176   book    1.7200   PASS
repurchase of 2 points, approximation (workbook)            1.7778   book    1.7800   PASS
bottleneck: capacity after 30 (workbook)                   95.5556   book   95.6000   PASS
equal split: capacity after 30 (workbook)                  90.0000   book   90.0000   PASS
all to human capital: capacity after 30 (workbook)         80.0000   book   80.0000   PASS
shadow value before the tie (workbook)                      0.5714   book    0.5700   PASS
shadow value after the tie (workbook)                       0.4444   book    0.4400   PASS
budget at which all three tie (workbook)                   17.5000   book   17.5000   PASS
equal split: capacity a point (workbook)                    0.3333   book    0.3300   PASS
OA 10.B.3: capacity with a budget of 20 (workbook)         20.0000   book   20.0000   PASS
OA 10.B.4: funding of form 1 (workbook)                    13.3333   book   13.3000   PASS
conversion chain, share delivered (workbook)                0.5600   book    0.5600   PASS

53 of 53 checkpoints PASS

Next. Chapter 11 attaches performance to these stocks: the rate and efficiency at which a company converts capital into declared outcomes, with the rent δC∗\delta C^{\ast} as a required line in any honest performance statement. AXIOM-10 runs the same model interactively (Lab 1.10); 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