Systemic Risk and Contagion

Picture the night Lehman Brothers filed for bankruptcy in 2008. Lehman was, on its own balance sheet, a single firm — a large one, sure, but one node out of thousands. A tabular risk model staring at Lehman’s own financials might have flagged it as wobbly. What no per-firm model on Earth could see was the web: the money market funds that held Lehman paper, the banks that had lent to those funds, the funds that “broke the buck” and triggered a run, the frozen short-term funding markets that then starved healthy firms of cash. Lehman didn’t fail alone. It pulled.

That pull is systemic risk, and it is the single best argument for treating finance as a graph rather than a spreadsheet. A row in a table describes one bank in isolation. An edge in a network describes who owes whom — and contagion lives entirely in the edges. This lesson is the marquee application of everything you’ve built: node-level prediction (lesson 2), inductive message passing (lesson 3), and the blunt observation that the most dangerous risk in finance is the kind a table literally cannot represent.

What systemic risk is — and why a table can’t see it

Analogy. Systemic risk is the difference between asking “is this domino heavy?” and asking “where does this domino stand in the line?” A heavy domino lying alone topples and nothing happens. A light domino positioned so that twelve others lean on it can flatten the whole row. Or think of a power grid: a single substation’s own specs tell you almost nothing about whether its failure browns out three states. The danger is in the wiring, not the box.

Definition. Systemic risk is the risk that the failure or distress of one node in a financial network propagates through the network’s connections, damaging other nodes that were individually healthy. It is a property of the system, not of any single firm. Formally, if each bank $i$ has some health $H_i$, systemic risk asks how a shock to one $H_j$ flows along the edges to change every other $H_i$ — a question about the topology of connections, not about any one node’s column of features.

A per-firm tabular model scores each bank from a feature vector of its own attributes: capital ratio, leverage, asset quality, profitability. It produces a probability of that bank failing on its own terms. By construction it is blind to “who is connected to whom,” because the connection information was never in the table. You can stack a hundred features per firm and still never encode the one fact that matters for contagion: bank A’s fate is wired to bank B’s.

Worked example. Banks A and B both report a capital buffer of $50m, leverage of 10x, and pristine asset quality. A tabular model scores both at, say, a 2 percent one-year default probability — identical, because their rows are identical. But suppose bank A has lent $80m to a shaky hub that the network already knows is fragile, while bank B’s $80m is spread across ten rock-solid counterparties. If the hub defaults with a loss given default of 70 percent, bank A absorbs $0.70 \times 80 = 56$ (in $m) in losses — more than its $50m buffer, so A fails. Bank B loses nothing comparable. Same table row, opposite fate. The model that scored them as twins was structurally wrong, and no amount of feature engineering on A’s own columns fixes it.

When to use it

Reach for a systemic-risk lens whenever the failures you care about are correlated through connections rather than independent: interbank lending, supply chains, payment systems, reinsurance webs, or any portfolio where counterparties overlap. If failures are genuinely independent — a diversified book of unrelated consumer loans, say — a per-firm model may be enough. The moment one entity’s collapse can cause another’s, you need the graph.

The interbank lending network

Analogy. Think of the banking system as a plumbing diagram. Each bank is a tank of water (capital). Pipes connect the tanks, and each pipe carries water one way — from lender to borrower’s obligation. When a tank cracks (a bank defaults), the lenders upstream lose the water they were owed. A big pipe into a small tank is a recipe for flooding the floor.

Definitions. The interbank network is a directed, weighted graph:

• Nodes are banks (or any financial firms).
• A directed edge from $X$ to $Y$ means $X$ lent to $Y$ — so $X$ holds an exposure to $Y$. The edge weight $w_{X \to Y}$ is the size of that exposure (the amount $X$ stands to lose if $Y$ goes bad).
• Exposure is the amount a lender has at risk to a given counterparty.
• A bank’s capital buffer $C_i$ is the equity cushion it can burn before it becomes insolvent — losses up to $C_i$ are survivable; losses beyond $C_i$ mean failure.
• Loss given default (LGD) is the fraction of an exposure that is actually lost when the borrower defaults. If $Y$ owes $100 and you recover $40 in bankruptcy, the LGD is 60 percent. The realized loss to the lender is $\text{LGD} \times \text{exposure}$.

Play with a live one below. Pick a bank to default, set the loss-given-default slider, and watch the loss ripple outward round by round. Notice that the same trigger bank can cause a tiny ripple or a system-wide collapse depending only on the LGD and on who sits downstream — the topology is doing the work.

Worked example. Bank $Y$ defaults owing $100 (in units) to lender $X$. The recovery is poor, so $\text{LGD} = 60\%$. The loss flowing up the edge to $X$ is

$\text{loss}_{X} = \text{LGD} \times \text{exposure} = 0.60 \times 100 = 60.$

Now check $X$‘s buffer. If $X$ holds a capital buffer $C_X = 50$, then its loss of $60$ exceeds its cushion of $50$ by $10$:

$\text{loss}_X = 60 > C_X = 50 \implies X \text{ becomes insolvent}.$

So $X$ — a bank that did nothing wrong, made one ordinary loan — also fails, in the next round. Had the LGD instead been 40 percent, $X$‘s loss would have been $0.40 \times 100 = 40 < 50$, and $X$ survives, bruised but standing. One slider, two completely different systems. That is the whole game.

When to use it

Model the interbank graph explicitly whenever you have, or can estimate, the bilateral exposures between firms — regulators with reporting data, a clearinghouse, or a fund-of-funds that knows its underlying counterparties. When exact exposures are hidden (the usual case for outside observers), the network is reconstructed statistically from aggregate balance-sheet items, and the reconstruction’s assumptions matter enormously for the cascade you’ll compute.

The default cascade

Analogy. A default cascade is dominoes, but with a twist: each domino only falls if enough weight lands on it. Round 0, you flick the first tile. Round 1, every tile it leans on takes the hit — but only the ones that can’t bear the load actually topple. Round 2, those new fallen tiles deliver their own pushes, and so on, until a round passes where nothing new falls. The line goes quiet, and you count the wreckage.

Definition. A default cascade is the round-by-round propagation of failures through the exposure graph:

• Round 0. A set of seed banks default (the initial shock).
• Each subsequent round $t$. For every still-solvent bank $i$, add up the losses it has taken from all counterparties that defaulted in rounds $0 \ldots t-1$. Bank $i$ fails this round if those cumulative losses exceed its capital buffer:

$\sum_{j \,\in\, \text{defaulted}} \text{LGD} \times w_{i \to j} \;>\; C_i.$

• Stop when a full round produces no new defaults. The set of failed banks is the cascade’s footprint; the summed losses are its severity.

Worked example — a chain A → B → C. Read the arrows as exposures: $A$ lent to $B$, and $B$ lent to $C$. Suppose:

with capital buffers $C_C$ irrelevant (C is the seed), $C_B = 50$, and $C_A = 40$.

• Round 0. $C$ defaults (the seed shock).
• Round 1. $B$ had lent $120 to $C$. Its loss is $0.50 \times 120 = 60$. Compare to $B$‘s buffer: $60 > 50$, so $B$ fails. Meanwhile $A$ has so far lost nothing (its borrower $B$ has not yet defaulted, only become insolvent this round), so $A$ holds.
• Round 2. Now that $B$ has defaulted, $A$‘s loss on its $90 loan to $B$ is $0.50 \times 90 = 45$. Compare to $A$‘s buffer: $45 > 40$, so $A$ fails too.
• Round 3. No solvent banks remain with new losses. The cascade stops. One seed default ($C$) flattened the entire chain — three banks down from one shock, two hops deep.

Notice the cascade reached $A$ even though $A$ never lent a cent to the original defaulter $C$. $A$ was two hops away and still died. That is contagion: damage travels along paths, not just to immediate neighbours.

When to use it

Run an explicit cascade simulation when you need a mechanistic, auditable answer to “what happens if bank $j$ fails?” — stress testing, regulatory what-ifs, setting capital surcharges for systemically important banks. The cascade is transparent and causal: you can point at every domino. Its cost is that it needs the full exposure matrix and a choice of LGD, and it counts each path discretely (a bank is either failed or not), which is exactly the rigidity that motivates the next, smoother measure.

DebtRank — systemic impact without double-counting

Analogy. The default cascade is a binary game of dominoes — a tile is up or down. DebtRank is more like measuring how far a rumor spreads through a town when one person gets nervous: not everyone panics fully, people pass along a fraction of their worry, and crucially, you don’t let the rumor bounce back and forth between the same two gossips forever inflating the count. You let each person spread their unease once, then tally how much of the town is rattled.

Definition. DebtRank is a recursive measure of the fraction of the system’s total economic value that would be affected if a node (or set of nodes) becomes distressed — not necessarily fully defaulted. Each node $i$ carries a distress level $h_i \in [0, 1]$ ($0$ = healthy, $1$ = fully defaulted) and an economic value weight $v_i$ (its share of total system value, with $\sum_i v_i = 1$). Distress propagates along edges with a relative-loss weighting: if borrower $j$‘s distress rises by $\Delta h_j$, its lender $i$ absorbs impact proportional to the exposure $w_{i \to j}$ relative to $i$‘s own capital. The key discipline: each node is allowed to transmit its distress onward only once (it moves to an “inactive” state after passing it along), so feedback loops do not let impact circulate forever.

The DebtRank of an initial shock is then the economic-value-weighted increase in distress across the whole system, minus the seed’s own initial distress:

$\text{DebtRank} \;=\; \sum_{i} v_i \, h_i(\infty) \;-\; \sum_{i} v_i \, h_i(0).$

Read it as: “of all the economic value in the system, what additional fraction ends up distressed because this node wobbled?” A DebtRank near $1$ means this node can rattle essentially the whole system; near $0$ means it is systemically peripheral.

Worked example — a stylised 3-node network. Let nodes be $\{1, 2, 3\}$ with equal economic value weights $v_1 = v_2 = v_3 = 1/3$. Let the impact passed from a distressed borrower to its lender be governed by relative exposures (already normalised by the lender’s capital):

Shock node $1$ to full distress: $h_1 = 1$, others start at $h_2 = h_3 = 0$.

• Step 1. Node $1$ (distressed) passes impact to node $2$: $h_2 \leftarrow \min(1,\; 0 + 0.8 \times 1) = 0.8$. Node $1$ now goes inactive (it has spread its distress once and will not transmit again).
• Step 2. Node $2$ (now distressed at $0.8$) passes impact to node $3$: $h_3 \leftarrow \min(1,\; 0 + 0.5 \times 0.8) = 0.4$. Node $2$ goes inactive.
• Step 3. Node $3$ has no outgoing edge to pass along; it goes inactive. No node can transmit further — and critically, node $1$ being inactive means node $3$‘s distress cannot loop back into $1$ and re-inflate the total. The walk terminates.

Final distress: $h_1 = 1,\ h_2 = 0.8,\ h_3 = 0.4$. The DebtRank (impact beyond the seed’s own value) is the value-weighted distress of everyone else:

$\text{DebtRank} = \tfrac{1}{3}(0.8) + \tfrac{1}{3}(0.4) = \tfrac{1}{3}(1.2) = 0.40.$

So distressing node $1$ puts an additional 40 percent of the system’s economic value into distress — even though only node $1$ ever truly “defaulted.” A naive sum over walks that let distress bounce $1 \to 2 \to 3 \to \ldots \to 1 \to 2 \ldots$ would have inflated this past any sensible bound; DebtRank’s walk-once rule keeps it honest.

When to use it

Use DebtRank when you want a smooth, single number ranking nodes by systemic importance — who to capitalise more, who to watch, who to never let fail. Unlike the binary cascade, it captures partial distress and the contribution of weak (not yet failed) links, and it avoids the double-counting that plagues naive path-summing. Pair it with the cascade: the cascade tells you the discrete worst case, DebtRank gives you a continuous ranking for triage.

Feedback loops and amplification

Analogy. Imagine two people standing on opposite ends of the same waterbed. They’ve never touched, never spoken — but when one flops down, the other gets launched. The mattress is the shared asset, and mark-to-market is the bounce. Now add a feedback twist: the launched person, scrambling, also flops, which bounces the first one again. That back-and-forth is a fire-sale spiral, and it is why systemic losses are nonlinear.

Definitions.

• Mark-to-market accounting forces a bank to value assets at current market prices. If the price falls, the bank books a loss immediately, even without selling.
• A fire sale happens when a distressed bank dumps assets to raise cash; the selling pressure pushes the price down.
• Common-asset overlap is an indirect edge: two banks holding the same asset are linked even with no loan between them, because one’s fire sale marks down the other’s book. The “edge weight” is the size of their overlapping positions.
• A fire-sale spiral is the feedback loop: distress → fire sale → price drop → mark-to-market losses at other holders → their distress → more fire sales → further price drops. Each lap feeds the next.

This feedback is why the system is nonlinear. A linear per-firm regression implicitly assumes losses add up independently: shock bank A, get loss A; shock bank B, get loss B; total loss = A + B. But with feedback, shocking A and B together produces losses larger than A + B, because A’s fire sale worsens B’s position, which worsens A’s, and so on. The linear model has no term for “your loss depends on the loss you caused in someone else,” so it systematically underestimates tail losses — precisely the losses you most need to size correctly.

Worked / illustrative example — an amplification multiplier. Suppose a shock would cause $100m of direct losses if the system were static. But each $1 of forced selling depresses the common asset’s price enough to create an additional $0.40 of mark-to-market losses across all holders, which triggers further selling, and so on. The total loss is a geometric series:

$\text{total loss} = 100 \times \left(1 + 0.4 + 0.4^2 + 0.4^3 + \cdots\right) = 100 \times \frac{1}{1 - 0.4}.$

Compute the multiplier: $\frac{1}{1 - 0.4} = \frac{1}{0.6} \approx 1.67$. So the total loss is

$100 \times 1.67 \approx 167,$

a 67 percent amplification over the $100m of direct damage. A linear model that booked only the first-round $100m would have understated the true loss by $67m. And the multiplier explodes as the per-lap feedback approaches $1$: at a feedback of $0.8$ the multiplier is $\frac{1}{1-0.8} = 5\times$. Tail risk lives in that denominator.

When to use it

Model feedback and indirect (common-asset) edges whenever leverage is high, assets are illiquid, and mark-to-market or margin rules can force selling — i.e., whenever a price drop can mechanically compel more selling. In those regimes the multiplier dominates the tail and ignoring it is malpractice. In genuinely liquid, low-leverage, hold-to-maturity settings the feedback is weak and a first-round (linear) estimate may suffice — but verify that assumption rather than assuming it.

Where the GNN comes in

Analogy. DebtRank and the cascade are like a recipe a human chef wrote out by hand: “to find a node’s distress, take its neighbours’ distress, weight by exposures, repeat.” A GNN is a chef who tastes thousands of finished dishes (simulated cascades) and learns to predict the outcome directly — same underlying logic of “the dish depends on its ingredients’ interactions,” but learned from examples rather than hand-coded, and fast enough to taste a new menu instantly.

The reframing — this is a node-level prediction task. Recall from lesson 2 that GNNs do node-level regression or classification. Systemic risk slots in perfectly:

• Each node (bank) gets a fragility / systemic-importance score as its label.
• The label can come from simulation (run thousands of cascades with random shocks and record each bank’s expected cascade loss or its DebtRank) or from history (realised losses in past stress episodes).
• The features are the per-firm columns the tabular model used — capital, leverage, asset quality — but now the message passing adds the topology the table lacked.

The mechanism is the point. A GNN layer updates each bank’s hidden state $h_i$ from its neighbours’ states:

$h_i^{(\ell+1)} = \sigma\!\left( W \, h_i^{(\ell)} \;+\; \sum_{j \in \mathcal{N}(i)} \frac{w_{i \to j}}{\,\text{(normaliser)}\,}\, h_j^{(\ell)} \right).$

Read it next to the DebtRank update $h_i \leftarrow \sum_j (\text{relative loss}) \, h_j$. They are the same shape: a node’s new state is a weighted combination of its neighbours’ states, stacked over rounds/layers. The cascade hand-codes the weights and the threshold; the GNN learns them from data. Stack $L$ layers and a node “feels” everything within $L$ hops — exactly the multi-round reach of a cascade. And because lesson 3 gave you inductive GraphSAGE, the trained GNN can score a new bank that wasn’t in the training graph, by aggregating its neighbours — no retraining required.

Worked intuition. Train on simulated labels: for each of the 3,000 banks, run 10,000 random shock scenarios, record the bank’s average cascade loss, and use that as its target. The GNN learns a function from (own features + neighbourhood structure) to expected systemic loss. At inference it produces that score in milliseconds per bank, versus the minutes-to-hours a fresh 10,000-scenario simulation would take — a fast, differentiable surrogate for the simulator. Differentiable matters: you can now ask “which exposure, if trimmed, most reduces system fragility?” by reading gradients, something a discrete simulation can’t hand you directly.

Here is the comparison the whole lesson has been building toward:

When to use it

Bring in a GNN when (1) you have a usable graph (estimated exposures and/or common-asset overlaps), (2) you can generate labels from simulation or history, and (3) you need either speed (a real-time fragility score across thousands of banks) or features (topology signals to feed a downstream model). Stick with the bare structural cascade when you need a one-off, fully-auditable answer and have time to simulate. And never deploy the GNN’s score without checking it against the simulator it learned from.

Recap

You came in knowing that a per-firm model scores each bank from its own row. You leave knowing why that is structurally fatal for the most important risk in finance: contagion lives in the edges, and a table has no edges. You traced a default cascade round by round, watched a bank two hops from the shock die anyway, and saw that depth is about loss-versus-buffer along paths, not raw degree. You met DebtRank — a smooth, walk-once measure of systemic impact (not probability) — and the fire-sale feedback loops whose amplification multiplier makes the system nonlinear and humbles every linear model in the tail. And you saw the punchline: a GNN’s message passing is the neighbour-depends-on-neighbour recursion that DebtRank hand-codes, so it can learn a fast, topology-aware fragility score — a surrogate for the simulator, validated against it, not a replacement.