Building a Binomial Option Pricer and Checking Black–Scholes Convergence

Build a recombining Cox–Ross–Rubinstein tree for the stock, evaluate the European payoff at every terminal node, and roll those payoffs back using discounted risk-neutral expectations. Compare the resulting price at several step counts with Black–Scholes using the same spot, strike, maturity, rate and volatility.

Roll the payoff backwards through a recombining grid

For step length

h=\tau/n

, set

u=e^{\sigma\sqrt h}

d=1/u

R=e^{rh}

, and

p=(R-d)/(u-d)

. The identity

pu+(1-p)d=R

makes the discounted stock a martingale under these probabilities. With

j

up moves after

i

steps, the stock is

S_{i,j}=S_0u^jd^{i-j}

. A European call has

V_{n,j}=(S_{n,j}-K)^+

. Its backward recursion is

V_{i,j}=R^{-1}\left[(1-p)V_{i+1,j}+pV_{i+1,j+1}\right].

A single vector is enough for the option values because each backward step only needs the next vector. The straightforward method costs $O(n^2)$ time and $O(n)$ memory. If $p$ is outside $(0,1)$ , inspect the input assumptions and step size before rolling back.

At an interior node you already know both successor option values because you work from maturity backwards. Multiply each by its risk-neutral weight, add them and discount that single-period expectation. The index

j

identifies the number of up moves so the down successor uses the same

j

and the up successor uses

j+1

. The node arrangement is why one rolling array is enough. If you update that array in place, go from low

j

to high

j

so both entries on the right-hand side still belong to the next time level.

Take $S_0=K=100$ , $\tau=1$ , $r=5\%$ , and $\sigma=20\%$ . With one step, $u\approx1.2214$ and $d\approx0.8187$ . The call pays about $22.14$ in the up state and zero in the down state, giving a price near $12.16$ . With two steps the price is about $9.54$ , on the other side of the Black–Scholes value of $10.45$ . At 100 steps the price is about $10.43$ . Watching just the first two rows might suggest deterioration, but the run at many step counts tells a different story.

A pricer and its convergence check

import numpy as np
from scipy.stats import norm

def crr_call(spot, strike, maturity, rate, vol, steps):
    h = maturity / steps
    u = np.exp(vol * np.sqrt(h))
    d = 1 / u
    gross = np.exp(rate * h)
    p = (gross - d) / (u - d)
    if not 0 < p < 1:
        raise ValueError("Tree needs down < gross return < up.")
    ups = np.arange(steps + 1)
    values = np.maximum(spot * u**ups * d**(steps - ups) - strike, 0)
    for _ in range(steps):
        values = ((1 - p) * values[:-1] + p * values[1:]) / gross
    return values[0]

benchmark = 100 * (norm.cdf(0.35) - np.exp(-0.05) * norm.cdf(0.15))
for steps in (1, 2, 10, 25, 100, 400):
    price = crr_call(100, 100, 1, 0.05, 0.20, steps)
    print(steps, round(price, 5), round(price - benchmark, 5))

Compare the continuous-model reference in the options pricer before diagnosing a discrepancy in the tree.

Building a Binomial Option Pricer and Checking Black–Scholes Convergence

Roll the payoff backwards through a recombining grid

A pricer and its convergence check

Watch a binomial tree approach the Black–Scholes price

References and next steps

Roll the payoff backwards through a recombining grid

Why the first refinements can cross the benchmark

A pricer and its convergence check

Watch a binomial tree approach the Black–Scholes price

References and next steps