8Forward-Rate and Market Models

For twenty years before 1997, traders priced caps with Black’s formula applied to each forward rate as if it were a stock, knowing that the formula came from no consistent model of the curve: the lognormal forward of one caplet and the lognormal forward of the next could not both be lognormal under the same measure, and short-rate models priced caps with other formulas. In 1997 three papers, by Brace, Gatarek and Musiela, by Jamshidian, and by Miltersen, Sandmann and Sondermann, showed that the traders’ formula was exactly right in a model in which every forward rate is lognormal under the measure of its own payment date, and that one such model could hold all forwards at once. The market model, as it came to be called, calibrates to caplets by construction, needs Monte Carlo for almost everything else, and makes visible a parameter the short-rate models hid: the correlation between forward rates. This chapter derives the general framework it belongs to, builds and simulates it, and shows two correlations that fit the same caplets and price the same swaption 22% apart.

8.1 The Heath–Jarrow–Morton framework and its drift

8.2 The market model

The instantaneous forward is not traded. The market model takes the forwards that are: $F_k(t)$ for the accrual periods $[T_k,T_{k+1}]$ of a tenor structure.

Each caplet is then priced exactly by Black’s formula with volatility $\sqrt{\frac1{T_k}\int_0^{T_k}\sigma_k(t)^2dt}$, which is what makes the model calibrate to caps by construction. A common volatility form is Rebonato’s

a hump in the time to reset scaled by a constant per forward (Figure 8.1); the $\phi_k$ are solved so that every caplet reprices.

8.3 Drifts under the spot and terminal measures

To simulate all forwards together they must share one measure, and under any single measure all but one of them acquire a drift.

Simulation steps $\ln F_k$ with the drift evaluated at the start of the step (Euler) and again at the predicted end, averaging the two (predictor–corrector): the drift depends on the forwards themselves, and the correction keeps the simulated caplets on their Black prices at coarse steps.

def spot_drift(fv: np.ndarray, sig: np.ndarray, rho: np.ndarray, nxt: int, delta: float) -> np.ndarray:
    """Drift of each ln F_k under the spot measure (Ito term excluded):
    sigma_k sum_{j=nxt}^{k} delta rho_kj sigma_j F_j / (1 + delta F_j)."""
    x = delta * sig * fv / (1 + delta * fv)                        # paths x n
    mu = np.zeros_like(fv)
    for k in range(nxt, fv.shape[1]):
        mu[:, k] = sig[k] * (x[:, nxt:k + 1] @ rho[k, nxt:k + 1])
    return mu


def simulate(m: LMM, horizon: int, paths: int, sub: int = 4, seed: int = 7):
    """Forwards on the reset grid under the spot measure: returns (F at each reset date 0..horizon,
    numeraire B_d at each reset date). F[t][p, k] is F_k at T_t on path p."""
    rng = np.random.default_rng(seed)
    n, dt, rho = m.n, 1.0 / sub, m.corr()
    chol = np.linalg.cholesky(rho)
    logf = np.tile(np.log(m.f0), (paths, 1))
    out, numer = [np.exp(logf).copy()], [np.ones(paths)]
    bd = np.ones(paths)
    for step in range(horizon * sub):
        t = step * dt
        nxt = int(math.floor(t + 1e-12)) + 1                      # first forward still alive after t
        z = rng.standard_normal((paths, n)) @ chol.T
        sig = np.array([m.vol(k, t) for k in range(n)])
        mu0 = spot_drift(np.exp(logf), sig, rho, nxt, m.delta)          # predictor
        pred = logf + (mu0 - 0.5 * sig**2) * dt + sig * math.sqrt(dt) * z
        mu1 = spot_drift(np.exp(pred), sig, rho, nxt, m.delta)          # corrector
        alive = np.arange(n) >= nxt
        logf = np.where(alive, logf + (0.5 * (mu0 + mu1) - 0.5 * sig**2) * dt + sig * math.sqrt(dt) * z, logf)

8.4 Calibrating to caps and swaptions: Rebonato’s formula

A swap rate is a weighted average of forwards, $S_{a,b}=\sum_{i=a}^{b-1}w_iF_i$ with $w_i = \delta_iP(t,T_{i+1})/A_{a,b}(t)$, so its volatility follows from theirs and their correlations.

def rebonato_vol(m: LMM, a: int, b: int) -> float:
    """Black volatility of the swaption expiring at T_a on the swap [T_a, T_b], by Rebonato's formula."""
    s, _, w = m.swap(a, b)
    rho = m.corr()
    tot = 0.0
    for i in range(a, b):
        for j in range(a, b):
            tot += w[i - a] * w[j - a] * m.f0[i] * m.f0[j] * rho[i, j] * m.integrated_cov(i, j, float(a))
    return math.sqrt(tot / (s * s * a))

8.5 Correlation and factor reduction

Caplets do not depend on correlation; swaptions do, since a swap rate averages several forwards and averaging decorrelated rates reduces volatility. A market model calibrated to caplets alone therefore leaves its swaption prices to an assumption.

8.6 Tutorial: a market model on the euro curve

8.7 Build: a market-model engine

8.8 Exercises

8.9 Problem: The Correlation You Cannot See

8.10 Interview questions