Binomial Trees for Option Pricing

Binomial trees decompose option pricing into a sequence of discrete up-or-down decisions—like climbing a decision ladder where each rung offers exactly two possible outcomes. While Black-Scholes gives you a single number, a binomial tree shows you how that number was built, node by node, decision by decision. This transparency is why trees remain the go-to method for pricing American options, extracting Greeks without calculus, and building intuition that carries into every other pricing model you'll encounter.

TL;DR: Binomial trees break option pricing into simple up/down steps, price backward through the tree using risk-neutral probabilities, and naturally handle early exercise—all while converging to Black-Scholes as you add steps.

One-Step Intuition (Why This Framework Works)

Before building a multi-step tree, understand the core insight with a single step.

A stock trades at $100. Over one period, it can go up to $110 or down to $90. You want to price a call with a $100 strike. The payoffs are simple: $10 if the stock goes up, $0 if it goes down.

The point is: you don't need to know the real probability of an up move. Instead, you find the unique probability—called the risk-neutral probability—that makes the expected return on the stock equal to the risk-free rate. This isn't a forecast. It's a pricing tool. Under this probability, the discounted expected payoff of any derivative equals its fair price today.

Why does this work? Because you can perfectly replicate the option's payoff by holding a specific mix of stock and borrowing. Since the replicating portfolio and the option have identical payoffs in every state, they must have the same price today (otherwise you'd have a risk-free arbitrage). The risk-neutral probability is just a shortcut that gives you the same answer without explicitly constructing the hedge.

Why this matters: every node in a multi-step tree uses this same one-step logic. Master the single step, and the rest is repetition.

Framework: Building the Multi-Step Tree

Inputs and Setup

Start with concrete numbers (these follow Hull's standard examples, adjusted for clarity):

• S = Spot price = $100
• K = Strike price = $100
• σ = Volatility = 30% annualized
• r = Risk-free rate = 5% continuously compounded
• T = Time to expiration = 0.25 years (3 months)
• n = Number of steps = 3

Each step spans Δt = T/n = 0.25/3 = 0.0833 years (roughly one month).

Deriving u, d, and p

The up and down factors translate annualized volatility into per-step price moves:

The calculation:

• u = e^(σ√Δt) = e^(0.30 × √0.0833) = e^(0.0866) = 1.0905
• d = 1/u = 0.9170
• p = (e^(rΔt) − d) / (u − d) = (1.0042 − 0.9170) / (1.0905 − 0.9170) = 0.503

Interpretation: The risk-neutral probability p ≈ 0.503 means up and down moves are approximately equally likely under the pricing measure. This doesn't mean the stock is a coin flip in reality—it means we've calibrated our artificial probability so that discounting at the risk-free rate produces arbitrage-free prices.

A few things worth noting about these parameters. The relationship d = 1/u is what makes the tree recombine: an up-then-down move lands at the same price as a down-then-up move ($100 × u × d = $100). Without recombination, a 3-step tree would have 8 terminal nodes instead of 4, and a 50-step tree would be computationally unmanageable. Recombination is the reason binomial trees scale (the number of nodes grows as n², not 2ⁿ).

Building the Stock Price Lattice

Starting from $100, multiply by u for an up move and d for a down move:

Notice the recombination at work: the middle node at Step 2 is exactly $100 (= $100 × u × d), and Step 3 has only 4 nodes instead of the 8 you'd get without recombination.

The key insight: every price in this tree is determined entirely by the starting price and the number of up moves. The node after j up moves and (n − j) down moves has price S × uʲ × d^(n−j). No path dependence, no memory of how you got there. This is what makes backward induction possible.

Backward Induction (Pricing the Option)

Terminal Payoffs

For a European call (payoff = max(S − K, 0)) at Step 3:

Working Backward Through the Tree

At each earlier node, the option value is the discounted risk-neutral expected value of the two child nodes. The discount factor per step is e^(−rΔt) = e^(−0.05 × 0.0833) = 0.9958.

At Step 2:

• Node uu ($118.91): 0.9958 × [0.503 × $29.66 + 0.497 × $9.05] = $19.33
• Node ud ($100.00): 0.9958 × [0.503 × $9.05 + 0.497 × $0] = $4.53
• Node dd ($84.10): 0.9958 × [0.503 × $0 + 0.497 × $0] = $0.00

At Step 1:

• Node u ($109.05): 0.9958 × [0.503 × $19.33 + 0.497 × $4.53] = $11.92
• Node d ($91.70): 0.9958 × [0.503 × $4.53 + 0.497 × $0] = $2.27

At Step 0 (today):

• Root ($100): 0.9958 × [0.503 × $11.92 + 0.497 × $2.27] = $7.10

The 3-step binomial call price is $7.10.

The point is: backward induction is just the one-step pricing logic applied repeatedly. Each node is a miniature one-period problem. You already understand the entire algorithm from the one-step case—the multi-step tree just chains those calculations together.

Early Exercise and American Options (Where Trees Really Shine)

European options can only be exercised at expiration. American options can be exercised at any node. This is where binomial trees earn their keep, because backward induction naturally accommodates the early exercise decision.

At each node during backward induction, you compare two values:

1. Continuation value: the discounted expected value from the child nodes (what you calculated above)
2. Immediate exercise value: the intrinsic value if you exercise right now

You take whichever is larger.

American Put Example

Consider an American put (payoff = max(K − S, 0)) with the same parameters. At Node d, Step 1 (stock = $91.70):

• Continuation value: $2.27 (from backward induction)
• Immediate exercise value: max($100 − $91.70, 0) = $8.30

Since $8.30 > $2.27, you exercise immediately at this node. The tree uses $8.30 (not $2.27) and propagates that value backward.

Why this matters: this early exercise check is impossible in the standard Black-Scholes formula (which prices only European options). It's also what makes the American put worth more than its European counterpart—you're paying for the right to act on favorable exercise opportunities before expiration. Monte Carlo simulation can handle American options too, but it requires sophisticated regression techniques (like Longstaff-Schwartz). The binomial tree handles it with a simple max() comparison at each node.

What this means in practice: the tree doesn't just price the option—it tells you the optimal exercise boundary. Every node where immediate exercise wins marks a point where the rational holder should exercise. Plot those nodes across steps and you've mapped the early exercise frontier.

Extracting Delta and Gamma (Greeks Without Calculus)

One of the most practical features of the binomial tree: you can extract Greeks directly from the node values without any differentiation.

Delta from Adjacent Nodes

Delta measures how much the option value changes per dollar change in the stock. At Step 0, use the two Step 1 nodes:

Delta = (V_u − V_d) / (S_u − S_d) = ($11.92 − $2.27) / ($109.05 − $91.70) = $9.65 / $17.35 = 0.556

Interpretation: the option gains approximately $0.556 for each $1.00 increase in the underlying at current levels. To delta-hedge this call, you'd hold 0.556 shares of stock against each call sold.

Gamma from Three Nodes at Step 2

Gamma measures how delta itself changes. You need delta at two different stock price levels:

• Delta_up = (V_uu − V_ud) / (S_uu − S_ud) = ($19.33 − $4.53) / ($118.91 − $100.00) = 0.783
• Delta_down = (V_ud − V_dd) / (S_ud − S_dd) = ($4.53 − $0.00) / ($100.00 − $84.10) = 0.285

Gamma = (Delta_up − Delta_down) / ((S_uu − S_dd) / 2) = (0.783 − 0.285) / (($118.91 − $84.10) / 2) = 0.498 / 17.41 = 0.0286

The point is: these are finite-difference approximations (the same idea behind numerical derivatives), but you didn't need to know that. The tree hands you the numbers directly. For theta, you'd compare the option value at the root with the center node at Step 2 (both at stock price $100) and divide by the time difference.

Convergence to Black-Scholes (The Sanity Check)

How accurate is a 3-step tree? Compare with Black-Scholes and higher-step trees using the same inputs:

The binomial model converges to Black-Scholes as the number of steps increases. This isn't coincidence—Black-Scholes is the continuous-time limit of the binomial model as Δt → 0. Cox, Ross, and Rubinstein (1979) proved this explicitly when they introduced the model.

The practical takeaway: a 3-step tree gives you intuition and rough accuracy. 50+ steps give you pricing-grade accuracy (within a penny of Black-Scholes for European options). For American options where Black-Scholes doesn't apply, 200-500 steps is standard practice.

One subtlety: binomial prices oscillate slightly around the true value as you add steps (even steps tend to converge from one side, odd from the other). Practitioners sometimes average adjacent step counts or use Richardson extrapolation to accelerate convergence.

When Trees Beat PDE or Monte Carlo (And When They Don't)

Binomial trees excel when:

• Early exercise matters: backward induction handles American options with a simple comparison at each node—no regression, no approximation
• Discrete dividends need modeling: you can drop the stock price at specific nodes to reflect ex-dividend dates (something continuous models handle awkwardly)
• Transparency is required: every node value is traceable, making trees ideal for audit, explanation, or teaching
• Greeks are needed quickly: finite differences from node values, no adjoint methods or bumping required
• Single-asset options dominate your book: a 500-step tree on one underlying computes in milliseconds

Trees become impractical when:

• Path-dependent payoffs (Asian options, lookbacks) require tracking the full price history, breaking recombination and causing exponential node growth
• Multiple underlying assets create a curse of dimensionality—a 100-step tree on 3 assets has 100³ = 1,000,000 nodes (still manageable), but 5 assets yields 10 billion nodes (not manageable)
• Extreme precision on European options is needed—just use Black-Scholes directly

What the data confirms: trees are the right tool for single-asset options with early exercise features. For everything else, consider Monte Carlo (path-dependent or high-dimensional problems) or finite-difference PDE methods (when you need a full surface of prices across strikes and maturities simultaneously).

Practical Checklist (Building Your First Tree)

Essential Steps

• Define your inputs clearly: spot, strike, vol, rate, time, and number of steps—all must be consistent (annualized vol with time in years)
• Calculate u, d, and p first: verify that 0 < d < e^(rΔt) < u (this ensures p is between 0 and 1)
• Build forward, price backward: construct the stock lattice from left to right, then compute option values from right to left
• Check recombination: verify that S × u × d = S at the center node (rounding errors can accumulate)

For American Options

• Compare continuation vs. exercise at every interior node—not just the final step
• Track where early exercise wins: these nodes map the optimal exercise boundary
• Expect American values ≥ European values for puts (and for calls on dividend-paying stocks)

Validation

• Compare your tree price to Black-Scholes for European options—they should converge within a few cents at 50+ steps
• Increase step count and verify convergence: if your price changes significantly from 100 to 200 steps, you need more steps
• Cross-check delta against the hedge ratio implied by a one-step replicating portfolio

For the continuous-time limit of binomial pricing, see Black-Scholes Model Inputs and Outputs. To compare tree methods with other American option approaches, review American Option Pricing Approaches.