Case study: the one-period binomial model, and counting defaults

A portfolio of 100 loans

Each loan either defaults this year or does not: a Bernoulli trial with $p = 0.02$ (lesson 5.2.2). Assume for now that the loans default independently of each other. Then the number of defaults $X$ is $\operatorname{Bin}(100, 0.02)$.

Many trials, each with a small chance: the Poisson approximation of lesson 5.2.3 applies, with $\lambda = np = 2$. Both pmfs, to four decimals:

A year with no defaults has probability $0.98^{100} = 0.1326$. One or two defaults are the most likely counts, and the two rows never differ by more than 0.003.

Five or more defaults

Suppose the bank recovers 40% of a defaulted loan, so each default loses $600,000; desks call the 60% the loss given default. Then five or more defaults lose $3,000,000 or more.

By lesson 5.2.1, $P(X \ge 5) = 1 - F(4)$. The binomial gives 0.0508 and the Poisson 0.0527. The Poisson has no upper limit and a slightly longer tail, so here it errs on the cautious side.

How many defaults to plan for

A risk manager asks the question the other way round: what is the smallest count exceeded in at most one year in a hundred? That is the smallest $k$ with $F(k) \ge 0.99$, the 99% quantile of $X$.

Here $F(5) = 0.9845$ falls short and $F(6) = 0.9959$ does not, so the answer is 6 defaults, or $3,600,000 of losses. The Poisson gives 6 as well. Case study 5.3.5 reads quantiles of daily returns the same way, as value at risk.

When defaults are not independent

Real defaults are not independent: in a recession many borrowers struggle at once. Here is a simple model of that. The year is good with probability 0.8, and then each loan defaults with probability 1%; it is bad with probability 0.2, and then 6%.

Within each kind of year the loans default independently, so $X$ is $\operatorname{Bin}(100, 0.01)$ in a good year and $\operatorname{Bin}(100, 0.06)$ in a bad one. The average default probability is $0.8 \times 0.01 + 0.2 \times 0.06 = 0.02$, the same 2% as before.

The law of total probability (lesson 5.1.3) splits on the kind of year:

That is almost three times the independent 0.0508. Quiet years become more likely too: no defaults at all has probability 0.2932, against 0.1326. The 99% quantile moves from 6 defaults to 10.

The strength of the dependence between defaults is measured by their correlation, which module 5.5 defines. A model that assumes independence understates the chance of many defaults together, which is the event that matters most to the bank.

A stock that goes up or down

The same tools price an option. Take the call of case study 2.4.6: stock price $S_0 = 100$, strike $K = 100$, $T = 0.5$ years, a continuous rate $r = 0.03$ and volatility $\sigma = 0.2$.

In the one-period binomial model, the stock has two possible prices at $T$: $S_0 u$ if it goes up, $S_0 d$ if it goes down. A common choice, which case study 5.11.4 also uses, is $u = e^{\sigma\sqrt{T}}$ and $d = \frac{1}{u}$. Here $u = 1.15191$ and $d = 0.868123$, so the stock ends at 115.19 or 86.81.

A bond pays $1 at $T$ and costs $e^{-rT} = 0.985112$ today, by continuous discounting (case study 1.4.6). The call pays $\max(S_T - 100, 0)$ (case study 1.1.5): 15.19 if the stock goes up, nothing if it goes down.

Replicating the call

Case study 3.3.4 priced a payoff by copying it with assets that trade. Here two assets cover two states. With rows down and up and columns the bond and the stock, the payoff matrix is

Hold $b$ bonds and $\Delta$ (delta) shares. Copying the call means $b + 86.81\Delta = 0$ and $b + 115.19\Delta = 15.19$. Subtracting the first equation from the second gives $\Delta = \frac{15.19}{28.38} = 0.5353$, and then $b = -46.4703$: borrow by selling bonds.

The portfolio costs $0.5353 \times 100 - 46.4703 \times 0.985112 = 53.53 - 45.78 = 7.7512$. So the call is worth $7.75. Desks call $\Delta$ the option's delta, the number of shares that hedges it.

The risk-neutral probability

Case study 3.3.4 also found state prices, the price today of $1 paid in one state only, by solving $D^\top\boldsymbol{\psi} = \mathbf{p}$. Here they are $\psi_d = 0.4749$ and $\psi_u = 0.5102$. They add up to 0.985112, the bond's price.

Divided by the bond's price, they become $1 - q = 0.482$ and $q = 0.518$.

Both are positive and they add up to 1, so they form a pmf on the two states (lesson 5.2.1). It is a Bernoulli distribution for an up move (lesson 5.2.2). These are the risk-neutral probabilities.

The formula for $q$ comes from the stock's own price: $q\,S_0 u + (1 - q)\,S_0 d = S_0 e^{rT}$. With the weights $q$ and $1 - q$, the stock grows on average like money in the bond: 101.5113 at $T$.

For the call, $e^{-rT}(0.518 \times 15.19 + 0.482 \times 0) = 7.7512$, as replication found. Lesson 5.3.1 calls such a weighted average an expectation, and later courses write the price as $e^{-rT}\,\mathbb{E}^{\mathbb{Q}}[\text{payoff}]$, with $\mathbb{Q}$ for the risk-neutral probabilities.

Case study 3.3.4's three-state market had risk-neutral probabilities 0.2577, 0.4639 and 0.2784, a pmf on three states. Its exercise has a two-state market: the stock at 80 or 125 from 98.75, and the bond at 0.97. The same rule gives $q = 0.4845$ and a call price of 11.75.

The real chance of an up move does not enter

Neither replication nor $q$ used the probability that the stock actually goes up. Suppose it is 0.6. Discounting the average payoff with that weight gives $e^{-rT} \times 0.6 \times 15.19 = 8.9789$, which is not the price.

If the call traded at $8.98, you could sell it and buy the replicating portfolio for 7.7512, keeping 1.2288 today. At $T$ the portfolio pays exactly what the call sold owes, in both states. The view on the stock's direction is already in its price $S_0$; the option adds nothing to it.

The put, and put–call parity

The put with strike 100 pays nothing if the stock goes up and $100 - 86.81 = 13.19$ if it goes down. Its price is $e^{-rT} \times 0.482 \times 13.19 = 6.2624$. Its replicating portfolio is short 0.4647 shares and long 53.53 bonds.

Put–call parity from case study 3.3.4 holds: $C - P = 7.7512 - 6.2624 = 1.4888$, and $S_0 - Ke^{-rT} = 100 - 98.5112 = 1.4888$.

One step is not enough

Case study 2.4.6 priced the same call by Black–Scholes at 6.3710. The one-step price, 7.7512, is 1.3801 too high: two final prices are a crude picture of a stock over six months.

The cure is more steps. Split the half year into $n$ steps, each up or down with probability $q$: the number of up moves is then $\operatorname{Bin}(n, q)$ (lesson 5.2.2). Case study 5.11.4 builds that tree and shows the price closing in on 6.3710 as $n$ grows.

import math

U = math.exp(0.2 * math.sqrt(0.5))  # the call of case study 2.4.6: sigma = 0.2, T = 0.5
D = 1 / U


def call(S):
    return max(S - 100, 0)


def put(S):
    return max(100 - S, 0)


def test_q():
    """With u = e^(0.2√0.5), d = 1/u, r = 3% and T = 0.5, q is about 0.5180"""
    expect_close(risk_neutral_q(U, D, 0.03, 0.5), 0.5179585268029778, what="risk_neutral_q", rel=1e-9)


def test_call():
    """The one-step call costs 7.7512: 0.5353 shares and −46.4703 bonds"""
    price, shares, bonds = one_step(100, U, D, 0.03, 0.5, call)
    expect_close(price, 7.751159552620581, what="price of the call", rel=1e-9)
    expect_close(shares, 0.5352965311073328, what="shares", rel=1e-9)
    expect_close(bonds, -46.47034688926673, what="bonds", rel=1e-9)


def test_put_and_parity():
    """The put costs 6.2624, short 0.4647 shares, and C − P = S₀ − Ke^(−rT)"""
    p, shares, bonds = one_step(100, U, D, 0.03, 0.5, put)
    expect_close(p, 6.26235351292685, what="price of the put", rel=1e-9)
    expect_close(shares, -0.4647034688926673, what="shares in the put's portfolio", rel=1e-9)
    c = one_step(100, U, D, 0.03, 0.5, call)[0]
    expect_close(c - p, 100 - 100 * math.exp(-0.015), what="C - P", rel=1e-9)


def test_stock_and_bond():
    """The stock's own payoff costs S₀ (1 share, 0 bonds); a payoff of 1 costs e^(−rT) (1 bond)"""
    price, shares, bonds = one_step(100, U, D, 0.03, 0.5, lambda S: S)
    expect_close((price, shares, bonds), (100.0, 1.0, 0.0), what="(price, shares, bonds) of the stock", abs_tol=1e-9)
    price, shares, bonds = one_step(100, U, D, 0.03, 0.5, lambda S: 1.0)
    expect_close((price, shares, bonds), (math.exp(-0.015), 0.0, 1.0), what="(price, shares, bonds) of the bond", abs_tol=1e-9)


def test_case_study_334():
    """Case study 3.3.4's two-state market (stock 80 or 125 from 98.75, bond 0.97): the call costs 11.75"""
    price, shares, bonds = one_step(98.75, 125 / 98.75, 80 / 98.75, -math.log(0.97), 1.0, call)
    expect_close(price, 11.75, what="price of the call", rel=1e-9)
    expect_close(shares, 25 / 45, what="shares", rel=1e-9)
    expect_close(bonds, -80 * 25 / 45, what="bonds", rel=1e-9)


def test_digital():
    """A payoff of 1 when the stock ends above 100 costs e^(−rT)·q = 0.5102"""
    price, _, _ = one_step(100, U, D, 0.03, 0.5, lambda S: 1.0 if S > 100 else 0.0)
    expect_close(price, 0.5102471289728264, what="price of the digital payoff", rel=1e-9)


def test_bond_beats_stock():
    """u = 1.01 and d = 0.99 with e^(rT) = 1.0151: the bond beats the stock in both states, so ValueError"""
    try:
        risk_neutral_q(1.01, 0.99, 0.03, 0.5)
    except ValueError:
        return
    raise AssertionError("expected ValueError: q would be 1.2557, not a probability")


def test_stock_beats_bond():
    """u = 1.2 and d = 1.05 with e^(rT) = 1.0151: the stock beats the bond in both states, so ValueError"""
    try:
        one_step(100, 1.2, 1.05, 0.03, 0.5, call)
    except ValueError:
        return
    raise AssertionError("expected ValueError: q would be negative")


def test_bad_moves():
    """d at or above u, or d at or below 0, raises ValueError"""
    for u, d in ((1.1, 1.1), (0.9, 1.1), (1.2, 0.0), (1.2, -0.5)):
        try:
            risk_neutral_q(u, d, 0.03, 0.5)
        except ValueError:
            continue
        raise AssertionError(f"expected ValueError for u = {u}, d = {d}")