18Real-Time Risk

Each of two desks was inside its limit all afternoon. Together they were short almost twice the firm’s appetite in the same index, and nobody saw it until the end-of-day batch, because nothing added the desks up while they traded. Each desk’s system answered the question it was asked — am I inside my limit? — and the question nobody’s system was asked is the one that mattered. This chapter builds the aggregator that asks it on every fill and every market move: exposures added up the risk hierarchy incrementally, sensitivities cached and refreshed when the market moves, limits checked in the loop, and a what-if answer before a trade is sent.

18.1 What real-time means for risk

The end-of-day risk engine of Book 6 (chapter 29) revalues every position under hundreds of scenarios once a night; the pre-trade gate of Book 13 (chapter 22) checks one order in microseconds against limits it holds in memory. Real-time risk sits between them: seconds, not nanoseconds or hours, and the whole firm, not one order. Its numbers are coarser than the nightly engine’s (sensitivities, not full revaluation) and its scope wider than the gate’s (every desk at once). The timeliness of risk data is one of the principles of BCBS 239 (Book 6, chapter 29): a figure available the next morning describes a risk that has already been taken.

18.2 Aggregation along the hierarchy

A desk’s limit and the firm’s are not a partition: the firm’s appetite is usually less than the sum of its desks’ limits, because desks are not expected to use their limits at the same time and in the same direction. That is exactly what they sometimes do. The chapter’s hierarchy has one firm, two desks and a book each; the firm’s appetite and each desk’s limit are $50 million of index delta, which firm.riskctl’s rule allows (a desk’s limit never above the firm’s).

18.3 Incremental updates

The chapter’s aggregator (firm.rtrisk) keeps, for each trade, the delta-dollars it currently contributes. A fill adds the new contribution minus the old to the trade’s book and every ancestor. A market tick carries each cached delta forward with its gamma, $(\Delta + \Gamma\,\mathrm{d}S)\,q\,S$, and applies the differences; when the spot has moved more than 0.5% since the cache was filled, every instrument is repriced by Book 5’s library (firm.pricing, bump and reprice) and the differences are applied again. The aggregates are never rebuilt; the tests check that they always equal a rebuild.

class SensitivityCache:
    """Greeks per instrument, computed at one snapshot, valid while the spot stays near it."""

    def __init__(self, md: FP.MarketData, underlying: str, threshold: float = 0.005):
        self.md, self.und, self.threshold = md, underlying, threshold
        self.asof_spot = md.spots[underlying]
        self.cache: dict = {}
        self.refreshes = 0

    def greeks(self, inst) -> dict:
        if inst.id not in self.cache:
            if isinstance(inst, Future):
                self.cache[inst.id] = {"delta": 1.0, "gamma": 0.0, "vega": 0.0}
            else:
                g = FP.greeks(inst, self.md, which=("delta", "gamma", "vega"))
                s = self.asof_spot
                gamma = g["gamma"] * 100.0 / (s * s)          # per unit of spot, squared
                self.cache[inst.id] = {"delta": g["delta"], "gamma": gamma, "vega": g["vega"]}
        return self.cache[inst.id]

    def stale(self, spot: float) -> bool:
        return abs(spot / self.asof_spot - 1.0) > self.threshold

    def refresh(self, md: FP.MarketData) -> None:
        self.md, self.asof_spot, self.cache = md, md.spots[self.und], {}
        self.refreshes += 1

    def _dd(self, inst, qty: float) -> float:
        """Delta-dollars of a trade now, from the cache: (delta + gamma dS) qty S."""
        g = self.cache.greeks(inst)
        ds = self.spot - self.cache.asof_spot
        return (g["delta"] + g["gamma"] * ds) * qty * self.spot

    def _add(self, book, amount: float) -> None:
        for node in self.h.ancestors(book):
            self.expo[node] = self.expo.get(node, 0.0) + amount
        self.updates += 1

    def _check(self, t: float) -> None:
        for node, lim in self.limits.items():
            e = self.expo.get(node, 0.0)
            if abs(e) > lim and not any(a[1] == node for a in self.alerts):
                self.alerts.append((t, node, e, lim))

    def on_fill(self, t: float, book, key, inst, qty: float) -> None:
        old = self.trades.get(key)
        qty_total = qty + (old[2] if old else 0.0)
        self.trades[key] = (book, inst, qty_total)
        new = self._dd(inst, qty_total)
        self._add(book, new - self.contrib.get(key, 0.0))
        self.contrib[key] = new
        self._check(t)

    def on_tick(self, t: float, md: FP.MarketData) -> None:
        self.spot = md.spots[self.cache.und]
        if self.cache.stale(self.spot):
            self.cache.refresh(md)
            self.cache_t = t
        for key, (book, inst, qty) in self.trades.items():
            new = self._dd(inst, qty)
            self._add(book, new - self.contrib[key])
            self.contrib[key] = new
        self._check(t)

A snapshot that does not say how old its sensitivities are cannot be trusted; one that does can be used with judgement. At the close of the chapter’s afternoon the cache was last refreshed 65 minutes earlier (3 890 seconds): the spot had not moved 0.5% since, so the carried deltas were within the threshold’s accuracy.

18.4 Sensitivities, full revaluation and the gap

Carrying exposures with cached sensitivities is fast and approximate; full revaluation is exact and slow. The gap is measured by pricing desk A’s options at the close both ways for moves from $-10\%$ to $+10\%$ (Figure 18.2): the delta-gamma P&L from sensitivities computed at the close against the change of the options’ full values.

Inside the range a real-time system meets in a day, the approximation is excellent: the error is exactly zero at $\pm 1\%$, because the library computed delta and gamma from bumps of $\pm 1\%$ and the quadratic passes through them, and stays under 1% of the full revaluation from $-6.75\%$ to $+3.5\%$. Beyond, it fails fast — 3.1% at $+5\%$, 23.6% at $+10\%$ — which is why the cache is refreshed on moves far smaller than those, and why stress numbers come from full revaluation (Book 6, chapter 29), not from sensitivities.

18.5 Limits in the loop

    def what_if(self, book, inst, qty: float) -> tuple[dict, list]:
        d = self._dd(inst, qty)
        after = {n: self.expo.get(n, 0.0) + d for n in self.h.ancestors(book)}
        breached = [n for n, e in after.items() if n in self.limits and abs(e) > self.limits[n]]
        return after, breached

A what-if check is the real-time system’s contribution to pre-trade control: the gate of Book 13 checks an order against limits in microseconds, the what-if tells it whether the firm-level limit has room. At the close of the chapter’s afternoon, desk B asking to sell 400 more futures would be told that its desk stays at $-\$45.2$ million, inside its limit, and the firm goes to $-\$92.8$ million, far outside.

18.6 Two desks, one index

The chapter’s afternoon runs from 13:00 to 17:30 on an index starting at 5 000, with seeded moves (20% annual volatility and a drift of $-1.5\%$ over the afternoon; it closes at 4 908.5). Desk A buys index puts — six listed lines, three strikes and two expiries, 1 000 units at a time — and desk B sells index futures, 400 at a time, each at random moments, about every five minutes. Before each trade the desk checks its own exposure and trades only if it stays under 90% of its limit. Executions go through the position service of chapter 17; the firm’s aggregator adds everything up.

18.7 Tutorial: two desks and an aggregator

18.8 Build: the real-time aggregator

18.9 Exercises

18.10 Problem: Two Desks, One Index

18.11 Interview questions