Lesson 7.4: Discrete models: binomial trees and the continuous limit

Learn the binomial tree: backward induction, convergence to Black-Scholes, American options and early exercise, and how the tree solves the pricing equation.

By the end of this lesson you will be able to build a multi-step binomial tree with the Cox–Ross–Rubinstein parameters, price a European option by working backwards through it, see why its price converges to the Black–Scholes price as the steps get finer, price an American option with an early-exercise check at every node, read a hedge ratio from the tree, and explain how the tree is a finite-difference solution of the Black–Scholes equation. You will show that a two-step tree prices the six-month at-the-money call at 6.51 and a 1,000-step tree at 7.1545 against the exact 7.1559, that the tree error falls by about half when the number of steps doubles, that an American put with one year to run is worth 5.80 against 5.17 for the European put, and that a deep in-the-money American put on a share at 60 with a strike of 100 is worth exactly its intrinsic value of 40 because it should be exercised at once. You should have read Lessons 6.1, 7.2 and 7.3. The mathematics is exponentials, a recursion and a limit. This course is education about how markets and research work, not investment advice.

Lesson 7.3 priced an option in one step by replication. Real options last for months, and a share can move many times before they expire. This lesson chains many one-step models together into a binomial tree. The tree is the most useful teaching device in derivatives, because it makes everything concrete: the hedge, the risk-neutral probability, the discounting and the early-exercise decision are all visible node by node. It is also a practical pricing tool, the standard way to value American options. And it forms the bridge between the discrete world of Lesson 7.3 and the continuous world of Lesson 7.2, since, as the number of steps grows, the tree becomes Black–Scholes.

Building the tree

Divide the life of the option, T years, into N steps of length Δt = T ÷ N. At each step the share goes up by a factor u or down by a factor d. The classic choice, due to John Cox, Stephen Ross and Mark Rubinstein in 1979, is

u = e^(σ√Δt), d = 1 ÷ u

so that the up and down moves match the volatility σ of the share, and an up move followed by a down move returns the share to where it started. The tree is therefore recombining: after N steps there are only N + 1 possible prices, S × u^(N−j) × d^j for j = 0 to N, not 2^N. This keeps the tree small enough to compute with large N. The risk-neutral probability of an up move, from Lesson 7.3, is

p = (e^(rΔt) − d) ÷ (u − d)

and the option is valued by backward induction: work out the payoff at each final node, then step back one period at a time, and at each node set the value to the discounted risk-neutral expectation of the two values one step ahead:

V = e^(−rΔt) × [ p × Vup + (1 − p) × Vdown ]

Continue until you reach the starting node. That value is the option price.

Worked example 1: two steps. The share is at 100, the strike is 100, r = 6 per cent, σ = 20 per cent and T = 0.5 years. With two steps, Δt = 0.25. Then

u = e^(0.2 × 0.5) = e^0.1 = 1.1052 and d = 0.9048, p = (e^0.015 − 0.9048) ÷ (1.1052 − 0.9048) = (1.0151 − 0.9048) ÷ 0.2004 = 0.5505.

The terminal share prices are 100 × 1.1052² = 122.14, 100 (up then down) and 100 × 0.9048² = 81.87. The call payoffs are 22.14, 0 and 0. Work back one step:

In the up node (110.52), Vu = e^(−0.015) × [0.5505 × 22.14 + 0.4495 × 0] = 0.9851 × 12.19 = 12.01. In the down node (90.48), both successors pay zero, so Vd = 0. At the start, V₀ = e^(−0.015) × [0.5505 × 12.01 + 0.4495 × 0] = 6.51.

The two-step tree gives 6.51, against the exact Black–Scholes price of 7.16: the tree with so few steps is crude. The hedge ratio at the first step is Δ = (Vu − Vd) ÷ (Su − Sd) = (12.01 − 0) ÷ (110.52 − 90.48) = 0.599, close to the exact delta of 0.611. At each node the tree tells you the delta to hold, and, if you hold it and rebalance at each step, the replication works exactly in the tree world.

Convergence to Black–Scholes

Now make the tree finer. We priced the same six-month at-the-money call with N steps. The exact Black–Scholes price is 7.1559. Steps N · Tree price · Error against Black–Scholes1 · 8.4327 · +1.2768 2 · 6.5104 · −0.6455 3 · 7.5945 · +0.4386 5 · 7.4182 · +0.2623 10 · 7.0160 · −0.1399 25 · 7.2078 · +0.0519 50 · 7.1276 · −0.0283 100 · 7.1417 · −0.0142 250 · 7.1502 · −0.0057 500 · 7.1531 · −0.0028 1,000 · 7.1545 · −0.0014 Two patterns stand out. First, the error shrinks roughly in proportion to 1 ÷ N: when N doubles from 500 to 1,000, the error halves, from −0.0028 to −0.0014. Second, for small N the price oscillates around the true value, above for odd N and below for even N in this example. At N = 49, 50, 51 and 52 the tree gives 7.1823, 7.1276, 7.1813 and 7.1287: the odd and even trees disagree by about 0.05. The oscillation comes from where the strike falls relative to the final nodes: with an odd number of steps the nodes straddle the strike differently from an even number. It can be tamed by averaging the prices from N and N + 1 steps, by Richardson extrapolation, or by choosing the tree so that the strike sits on a node, as in the Leisen–Reimer tree.

Why the tree converges

Look at the log of the share price after N steps. Each step adds +σ√Δt or −σ√Δt to the logarithm, with probabilities p and 1 − p. The log of the final price is therefore a sum of N independent two-valued steps, so by the central limit theorem (the same random-walk argument as Lesson 7.1) its distribution tends to a normal. The parameters were chosen so that the mean and the variance match those of geometric Brownian motion, as Lesson 7.2 gives them:

mean of the log return → (r − σ²/2) T variance of the log return → σ² T

Check it with N = 50, σ = 20 per cent, r = 6 per cent, T = 0.5: the tree's mean log return and its variance should be close to (0.06 − 0.02) × 0.5 = 0.0200 and 0.04 × 0.5 = 0.0200. A tree with a few steps matches approximately, and the match improves as Δt shrinks. A normally distributed log price is a lognormal price, and the expectation of the call payoff under it, discounted, is the Black–Scholes formula. The price of the tree converges because the tree's distribution converges.

Test the match yourself, and see how the error depends on the number of steps.

American options and early exercise

A European option can be exercised only at expiry, and an American option at any time. The tree handles the American case with one extra line. At each node, before stepping back, compare two values: the continuation value, the discounted expectation of the next step's values, and the intrinsic value, what you would get by exercising now. The option is worth the larger:

V = max( e^(−rΔt) × [ p Vup + (1 − p) Vdown ], intrinsic value )

If the intrinsic value is bigger at some node, exercising there is optimal, and the early-exercise boundary falls out of the tree.

Worked example 2. An at-the-money put on a share at 100, strike 100, with one year to expiry, 6 per cent interest and 20 per cent volatility. A 500-step tree gives:

European put: 5.16 (Black–Scholes 5.17), American put: 5.80.

The right to exercise early is worth about 0.63, 12 per cent of the European value. It pays for a put because exercising early lets you receive the strike now and earn interest on it. The premium grows with volatility in rupees: Volatility · European put · American put · Early-exercise premium10% · 1.64 · 2.23 · 0.60 20% · 5.17 · 5.80 · 0.63 30% · 8.89 · 9.53 · 0.63 40% · 12.65 · 13.29 · 0.64 For a deep in-the-money put the early-exercise decision is clear-cut. A put on a share at 60 with a strike of 100, a year to run and the same rates and volatility, has a European value of 34.24 but an American value of 40.00, exactly its intrinsic value: the tree says to exercise at once, since waiting only loses interest on the 40, and the loss of time value is small when the put is so deep in the money that it will almost surely be exercised.

By contrast, an American call on a share that pays no dividends is never exercised early, as Lesson 6.1 said, so its price equals the European price. The tree agrees: 7.1531 against the exact 7.1559, with the small gap due to the tree's error. With dividends, early exercise of a call becomes possible just before the share goes ex-dividend.

Greeks and the tree

The tree gives the hedge ratio at each node, as in worked example 1. The delta at the root is (Vu − Vd) ÷ (Su − Sd), and the same formula at any node gives the delta to hold there. Gamma is the change in delta between nodes two steps ahead, and theta can be read from the difference between the value at the centre node two steps ahead and at the root. Because the tree is only an approximation, the Greeks it gives are less precise than its price: with few steps, a gamma computed from the tree is noisy. For accuracy, practitioners compute the Greeks by re-running the tree with small shifts in the inputs, or use more steps, or use a finite-difference method (Lesson 8.2).

The tree as a finite-difference solution of the Black–Scholes equation

There is a deeper way to see the convergence, which ties the whole module together. Write the backward step as

V(S, t) = e^(−rΔt) × [ p V(uS, t + Δt) + (1 − p) V(dS, t + Δt) ]

Expand the right side in a Taylor series in Δt, using u = e^(σ√Δt), d = 1/u and the formula for p. The up and down values are V(uS) and V(dS), and u S ≈ S(1 + σ√Δt + ½σ²Δt), and similarly for d. Collecting terms in Δt, with the first-order terms in √Δt cancelling because the up and down moves are symmetric, what remains is

Vt + ½ σ² S² VSS + r S VS − r V = 0

the Black–Scholes partial differential equation of Lesson 7.2. So the binomial recursion is an explicit finite-difference scheme for the Black–Scholes equation, and its convergence is the convergence of a numerical method for the equation. This is the link between the three themes of the module: the random walk of Lesson 7.1 gives the tree, no-arbitrage and the risk-neutral probability of Lesson 7.3 give the recursion, and Itô's lemma of Lesson 7.2 gives the limit.

Strengths and limits of trees

Strengths. Trees are intuitive and easy to code. They handle American and Bermudan options naturally, they allow dividends and other discrete features to be put in, and they give the hedge ratio at every node.

Limits.

Path dependence. For options whose payoff depends on the path, such as Asian options on an average, a recombining tree does not carry enough information, and the number of states explodes. Monte Carlo (Lesson 8.1) or specialised methods are used instead. Many risk factors. A tree with two variables, such as a share and its volatility, grows as the square of the number of nodes, and with three or more it is impractical. Accuracy. The error falls only as 1 ÷ N, and the odd–even oscillation needs a fix. Models. A basic tree has constant volatility, so it cannot price the smile of Lesson 6.3. Implied trees and local-volatility trees exist, and other models (trinomial trees, interest-rate lattices such as Black–Derman–Toy) extend the idea.

The code below builds the tree, reproduces the convergence table, prices the American put and checks the moments.

python import numpy as np from math import exp, log, sqrt from scipy.stats import norm

def bs(S, K, r, sigma, T, kind="call"): d1 = (log(S / K) + (r + 0.5 sigma 2) T) / (sigma sqrt(T)) d2 = d1 - sigma sqrt(T) if kind == "call": return S norm.cdf(d1) - K exp(-r T) norm.cdf(d2) return K exp(-r T) norm.cdf(-d2) - S norm.cdf(-d1)

def crr(S, K, r, sigma, T, N, kind="call", american=False): dt = T / N u = exp(sigma sqrt(dt)) d = 1 / u p = (exp(r dt) - d) / (u - d) disc = exp(-r dt) j = np.arange(N + 1) ST = S u (N - j) d j # the N + 1 final prices V = np.maximum(ST - K, 0) if kind == "call" else np.maximum(K - ST, 0) for i in range(N - 1, -1, -1): # work back one step at a time V = disc (p V[:-1] + (1 - p) V[1:]) if american: jj = np.arange(i + 1) Si = S u (i - jj) d jj intrinsic = np.maximum(Si - K, 0) if kind == "call" else np.maximum(K - Si, 0) V = np.maximum(V, intrinsic) # exercise now if that is worth more return V[0]

S, K, r, sigma, T = 100, 100, 0.06, 0.20, 0.5 exact = bs(S, K, r, sigma, T) print("Black-Scholes call", round(exact, 4)) for N in (1, 2, 3, 5, 10, 25, 50, 100, 250, 500, 1000): price = crr(S, K, r, sigma, T, N) print(f" N = {N:>4}: tree {price:.4f} | error {price - exact:+.4f}") print("odd and even trees:", [round(crr(S, K, r, sigma, T, N), 4) for N in (49, 50, 51, 52)])

the two-step tree by hand N = 2 dt = T / N u = exp(sigma sqrt(dt)); d = 1 / u; p = (exp(r dt) - d) / (u - d) Vuu, Vud, Vdd = max(S u u - K, 0), max(S - K, 0), max(S d d - K, 0) Vu = exp(-r dt) (p Vuu + (1 - p) Vud) Vd = exp(-r dt) (p Vud + (1 - p) Vdd) print("two-step: u", round(u, 4), "d", round(d, 4), "p", round(p, 4), "| final prices", round(S u u, 2), S, round(S d d, 2)) print(" Vu", round(Vu, 3), "Vd", round(Vd, 3), "price", round(exp(-r dt) (p Vu + (1 - p) Vd), 4), "| first-step delta", round((Vu - Vd) / (S u - S d), 4))

American against European puts Sp, Kp, rp, Tp = 100, 100, 0.06, 1.0 print("American put premium by volatility:") for sg in (0.10, 0.20, 0.30, 0.40): eu, am = bs(Sp, Kp, rp, sg, Tp, "put"), crr(Sp, Kp, rp, sg, Tp, 500, "put", american=True) print(f" volatility {sg:.0%}: European {eu:.3f} | American {am:.3f} | premium {am - eu:.3f}") print("deep in-the-money put (share 60, strike 100): European", round(bs(60, 100, rp, 0.2, Tp, "put"), 3), "| American", round(crr(60, 100, rp, 0.2, Tp, 500, "put", american=True), 3)) print("American call on a share with no dividends:", round(crr(S, K, r, sigma, T, 500, "call", american=True), 4), "| European", round(exact, 4))

moment matching with 50 and 1,000 steps for N in (50, 1000): dt = T / N u = exp(sigma sqrt(dt)); p = (exp(r dt) - 1 / u) / (u - 1 / u) mean = N (p log(u) + (1 - p) log(1 / u)) var = N p (1 - p) (2 log(u)) 2 print(f"N = {N:>4}: tree mean {mean:.5f} vs {(r - sigma 2 / 2) T:.5f} | tree variance {var:.5f} vs {sigma 2 T:.5f}")

Common mistakes

Using too few steps. A tree with 5 or 10 steps is a teaching tool. For prices use hundreds of steps and check convergence. Using the real-world probability in the tree. The probability is the risk-neutral p, and the real-world drift does not enter. Forgetting that the odd–even oscillation exists. Average two consecutive trees, or extrapolate, before quoting a price. Letting the probability leave the range from 0 to 1. If p is above 1 or below 0, the step is too large for the interest rate and volatility, which signals an arbitrage in the tree. Applying the American check to a European option. It would overstate the price. Exercising an American call early on a share with no dividends. It is never optimal. Using the tree's Greeks without checking. With few steps they are noisy, and a bump-and-reprice or finite-difference check is better. Using a recombining tree for a path-dependent payoff. The state is not enough. Ignoring discrete dividends. They break recombination unless handled carefully.

Key takeaways

A Cox–Ross–Rubinstein tree uses u = e^(σ√Δt), d = 1 ÷ u and p = (e^(rΔt) − d) ÷ (u − d). It recombines, with N + 1 final prices after N steps, and the option is priced by backward induction: V = e^(−rΔt)[pVup + (1 − p)Vdown]. A two-step tree prices the six-month at-the-money call at 6.51, with u = 1.1052, d = 0.9048, p = 0.5505 and a first-step delta of 0.599. A 1,000-step tree gives 7.1545 against 7.1559. The tree price converges to Black–Scholes with an error falling about as 1 ÷ N (−0.0028 at 500 steps and −0.0014 at 1,000), with an odd–even oscillation (7.1823, 7.1276, 7.1813, 7.1287 for 49 to 52 steps) that can be removed by averaging or extrapolation. Convergence holds because the log of the final price is a sum of independent steps, so by the central limit theorem it becomes normal, and the tree's mean and variance match (r − σ²/2)T and σ²T. An American option takes the larger of the continuation value and the intrinsic value at every node. The one-year at-the-money put is worth 5.80 American against 5.17 European, and a put on a share at 60 with a strike of 100 is worth 40.00, exercised at once. An American call on a share with no dividends is never exercised early, so it is worth the European price. The binomial recursion is an explicit finite-difference scheme for the Black–Scholes equation, which joins the random walk, risk-neutral pricing and Itô's lemma. Trees are intuitive and good for American options, but they struggle with path dependence, several risk factors and the smile.

Check yourself

1. In a tree with Δt = 0.01 and σ = 30 per cent, what are u and d? u = e^(0.3 × 0.1) = e^0.03 = 1.0305, and d = 1 ÷ 1.0305 = 0.9704. 2. After 10 steps of a recombining tree, how many different final prices are there, and how many paths? There are 11 final prices. There are 2¹⁰ = 1,024 paths, which are grouped into the 11 nodes. 3. A tree has u = 1.05, d = 0.95 and one-period interest of 2 per cent (R = 1.02). What is p? p = (1.02 − 0.95) ÷ (1.05 − 0.95) = 0.07 ÷ 0.10 = 0.70. 4. At a node an American put has a continuation value of 3.80 and the share is at 90 with a strike of 100. What is the node value? Intrinsic value = 100 − 90 = 10, which exceeds 3.80, so the node value is 10 and the option is exercised. 5. Why does an American call on a share with no dividends have the same price as the European call? Exercising early gives up the time value and the interest on the strike, so it is never better than selling the option, and the right to exercise early has no value.

Try this

Set aside forty-five minutes. You need Python and the code in this lesson.

1. Run the code. Check the convergence table, the two-step example and the American put values. 2. Plot the tree price against N from 1 to 200 and the error against 1 ÷ N. Is the error proportional to 1 ÷ N, apart from the oscillation? 3. Average the prices from N and N + 1 steps for N between 20 and 200. How much does the oscillation shrink? 4. Price an American put with a dividend yield of 3 per cent, by lowering the risk-neutral drift to r − q in the tree. How does the early-exercise premium change? 5. Compute the delta from the first step of the tree for the call and compare with the exact delta of 0.611 for N = 10, 100 and 1,000. 6. Use the moment-matching simulator to find the number of steps at which the variance error falls below 1 per cent for a volatility of 20 per cent and one year. 7. Write a short note: when you would use a tree rather than the Black–Scholes formula, what you would check before relying on its price and what the tree cannot do.

A good result is a convergence plot with an error that falls as 1 ÷ N, an American put priced with its early-exercise premium and a clear statement of what you checked. This completes the module on the theory of stochastic calculus and pricing. The next module builds on it with the numerical methods and models that the formula does not cover: Monte Carlo, finite differences, interest-rate models and stochastic volatility.

John Cox, Stephen Ross and Mark Rubinstein's 1979 paper "Option Pricing: A Simplified Approach" in the Journal of Financial Economics introduced the binomial tree. Steven Shreve's Stochastic Calculus for Finance I: The Binomial Asset Pricing Model develops it rigorously, and John Hull's Options, Futures and Other Derivatives shows trees for American options, dividends and interest rates. Marc Leisen and Matthias Reimer's 1996 paper "Binomial Models for Option Valuation: Examining and Improving Convergence" in Applied Mathematical Finance addresses the oscillation, and Mark Rubinstein's work on implied trees extends the method to the smile. Espen Haug's The Complete Guide to Option Pricing Formulas collects the analytical alternatives.

Tags: Quant Trader Binomial tree American options Cox-Ross-Rubinstein Backward induction