# Model dictionary — notation shared by text, code and tables

Code: `src/agi_ge/`. Every symbol below appears with the same name in the code (`params.py`, `production.py`,
`transition.py`, `households.py`) and in the LaTeX macros of `paper/`. Time is discrete and annual; t = 0 is 2026.
All quantities are real, in units of the 2026 final good unless stated.

## 1. Tasks and skills (Restrepo block, `tasks.py`)

| Symbol | Code | Meaning | Units |
|---|---|---|---|
| i ∈ B = {1,…,n_B} | `tasks.bottleneck` | bottleneck task classes (default n_B = 4) | — |
| a ∈ A | `tasks.accessory` | accessory task classes entering output linearly (default 2) | — |
| s ∈ {L, H} | `skills` | permanent skill of workers; Ω(L) = {1,2,a_L}, Ω(H) = {3,4,a_H} (a partition) | — |
| H_s | `H[s]` | inelastic labor supply of skill s (efficiency units) | workers |
| L_i | `L[i]` | labor employed in task i | workers |
| Q_i | `Q[i]` | compute services used in task i | compute units |
| α_{i,t} | `alpha[i,t]` | compute needed to replicate one worker in task i; ∞ = not automatable yet | compute / worker |
| X_i = L_i + Q_i/α_{i,t} | `X[i]` | task output (eq. 1 of Restrepo) | worker-equivalents |
| X_B = (Σ_i ν_i X_i^{ρ_B})^{1/ρ_B} | `XB` | bottleneck composite, σ_B = 1/(1−ρ_B) < 1 | — |
| CEU(s) = max_{i∈Ω(s)} α_i | `ceu[s]` | compute-equivalent units of skill s (Restrepo p. 7) | compute / worker |
| w_s | `w[s]` | wage of skill s | goods / worker |
| A_t | `A` | price of one unit of compute services | goods / compute unit |

A compute unit is normalized so that the terminal α of task 1 equals one: one unit of installed compute
capacity replaces one task-1 worker once AGI is reached (α_1^∞ = 1).

## 2. Final goods, scarce complements, energy (`production.py`)

| Symbol | Code | Meaning |
|---|---|---|
| K^N_t | `KN` | structures and machinery (reproducible, price 1, δ_N) |
| T | `T` | production land (fixed) |
| E^Y_t | `EY` | energy used in final production |
| V = (ν_N K_N^{ρ_N} + (1−ν_N) X_B^{ρ_N})^{1/ρ_N} | `V` | task–structures nest, σ_N = 1/(1−ρ_N) |
| G = (ν_T T^{ρ_T} + ν_E E_Y^{ρ_T} + ν_V V^{ρ_T})^{1/ρ_T} | `G` | top nest with scarce physical inputs, σ_T = 1/(1−ρ_T) |
| Y_t = Z_t (G + Σ_a γ_a X_a) | `Y` | gross output of final goods; Z_t = Z_0 (1+g_Z)^t non-AI technical progress |
| R^N_t, R^T_t, P^E_t | `RN`,`RT`,`PE` | rental of structures, land rent, energy price = Z × marginal products |
| K^Q_t | `KQ` | installed compute capacity (capital), productive at t, bought at t−1 at price p^Q_{t−1} |
| p^Q_t = p^Q_0 max{e^{−g_p t}, p̄^Q/p^Q_0} | `pQ` | price of one unit of capacity (Moore-type decline, optional floor) |
| ε_t = ε_0 max{e^{−g_ε t}, ε̄/ε_0} | `eps` | energy per unit of compute service (Koomey-type decline, optional floor) |
| u_t ∈ (0,1] | `util` | utilization of compute capacity (below one only if A_t < ε_t P^E_t) |
| Q_t = u_t K^Q_t | `Qtot` | compute services supplied |
| E_t = Z^E (K^E_t)^{1−η} (R^E)^{η} | `E` | energy output; K^E energy capital (price 1, δ_E), R^E fixed resource with share η |
| E_t = ε_t Q_t + E^Y_t | — | energy market clearing |
| R^E_t = (1−η) P^E E/K^E ; rent_R = η P^E E | `RE`,`rentR` | energy-capital rental and resource rent |
| K^H_t, T^H | `KH`,`TH` | housing structures (price 1, δ_H) and residential land |
| H^S = (K^H)^{1−ν_H} (T^H)^{ν_H} | `HS` | housing services |
| R^H_t | `RH` | rent per unit of housing services; θ_H = expenditure share on housing |
| GDP_t = Y_t + R^H_t H^S_t | `GDP` | value added (energy and compute services are intermediate) |

Income identity (tested in `tests/test_accounting.py`):
GDP = Σ_s w_s H_s + R^N K^N + R^T T + (A − εP^E) u K^Q + R^E K^E + rent_R + R^H H^S (housing split into
(1−ν_H) R^H H^S to structures and ν_H R^H H^S to residential land). Profits are zero under perfect competition;
with the AI-monopoly scenario the markup wedge (μ−1)·cost is a separate profit line.

## 3. Capital accumulation and asset prices (`transition.py`)

For each capital type k ∈ {N, Q, E, H} with purchase price p^k_t (p^N = p^E = p^H = 1), depreciation δ_k and
adjustment-cost parameter φ_k, x^k_t = I^k_t/K^k_t:
K^k_{t+1} = (1−δ_k) K^k_t + I^k_t;  adjustment cost p^k_t (φ_k/2)(x^k_t − δ_k)^2 K^k_t;
q^k_t = p^k_t [1 + φ_k (x^k_t − δ_k)] (Tobin's marginal q = average q, Hayashi);
Euler: q^k_t (1 + r_{t+1}) = R^k_{t+1} + p^k_{t+1}[φ_k(x^k_{t+1}−δ_k)x^k_{t+1} − (φ_k/2)(x^k_{t+1}−δ_k)^2] + (1−δ_k) q^k_{t+1},
with R^Q_t ≡ u_t(A_t − ε_t P^E_t) the net rental of compute capacity.
Land: P^T_t (1+r_{t+1}) = R^T_{t+1} + P^T_{t+1}; same for residential land.
Equity value of sector k (ex-dividend) V^k_t = q^k_t K^k_{t+1}; net payout D^k_t = R^k_t K^k_t − p^k_t I^k_t − adj. cost
(negative = net issuance); price–payout ratio V^k_t / D^k_t; market-to-replacement-cost = q^k_t / p^k_t.
Aggregate wealth W_t = Σ_k V^k_t + P^T_t T + P^{TH}_t T^H (= household net worth; there is no government debt in the baseline).

## 4. Households

Two-class (`transition.py`): capitalists (mass μ_K, no labor income, own all claims) with
u = (c^{1−θ_H} h^{θ_H})^{1−γ}/(1−γ), Euler (x_{t+1}/x_t)^γ (P_{t+1}/P_t)^{1−γ} = β(1+r_{t+1}) where x = expenditure and
P_t ∝ (R^H_t)^{θ_H} the ideal price index; workers of skill s consume w_s H_s + transfers − taxes (hand-to-mouth).
Heterogeneous agents (`households.py`): households (skill s, discount type β_j, productivity e_t Markov) choose
assets a_{t+1} ≥ 0 earning r_{t+1}; income w_s e_t + transfers; one composite asset = claim on the aggregate fund.

## 5. Government (policy scenarios)

τ_T land-value tax, τ_K tax on capital income, τ_Q tax on compute rental income; citizen capital fund holding a
share θ_F of all equity and paying its net payout equally to all households; balanced budget each period.

## 6. Scenario primitives

A scenario is a tuple of paths {α_{i,t}}, {p^Q_t}, {ε_t}, {Z_t}, policy parameters and preference/technology
constants; see `scenarios.py` and `results/scenarios/*.json`.