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 outcomes. Black-Scholes hands you a single number; a tree shows you how that number was built, node by node. That transparency is the reason trees remain the workhorse for American options, intuition-building, and Greeks-without-calculus, decades after Cox, Ross, and Rubinstein introduced them.¹

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. As steps increase, prices converge to Black-Scholes — but from above for a European call with this paper’s parameters, not from below. Worth knowing before you build a sanity-check table.

One-Step Intuition (Why the Framework Works)

A stock trades at $100. Over one period it goes to $110 (up) or $90 (down). You want to price a call struck at $100. Payoffs: $10 if up, $0 if down.

You don’t need the real probability of an up move. You find the unique probability — the risk-neutral probability — under which the discounted expected stock price equals today’s price.² Discount the expected option payoff at the risk-free rate using that probability and you get the arbitrage-free price.

Why does it work? Because the option’s payoff can be replicated by holding a specific mix of stock and cash. The replicating portfolio and the option must have the same price today, or there’s a free lunch. The risk-neutral probability is just the algebraic shortcut that returns the same number without writing out the hedge.

Master the one-step problem and the rest is repetition: every node in a multi-step tree solves the same equation.

Building the Multi-Step Tree

Inputs

Following Hull’s convention,³ price a 3-month European call:

• S (spot) = $100
• K (strike) = $100
• σ (vol) = 30% annualized
• r (risk-free rate, continuously compounded) = 5%
• T = 0.25 years
• n (steps) = 3

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

Deriving u, d, and p (Cox-Ross-Rubinstein parameterization)

• 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.00418 − 0.9170) / (1.0905 − 0.9170) = 0.5024

Two structural points worth pinning down:

1. d = 1/u is what makes the tree recombine: an up-then-down path lands at the same price as down-then-up. Without recombination, an n-step tree has 2ⁿ terminal nodes; with it, only n+1. That’s the difference between a 3-step toy and a 1,000-step pricing engine.
2. p ≈ 0.503 doesn’t mean the stock is a coin flip in reality. It’s the artificial probability under which discounting at the risk-free rate yields arbitrage-free prices.²

Stock-price lattice

The middle node at Step 2 is $100, since u·d = 1. Every price in the lattice is determined by the starting price and the count of up moves — no path memory. That’s what makes backward induction work.

Backward Induction (Pricing the European Call)

Terminal payoffs (Step 3)

Discount one step at a time

Per-step discount factor: e^(−rΔt) = e^(−0.00417) = 0.9958.

Step 2:

• uu ($118.91): 0.9958 × [0.5024 × $29.66 + 0.4976 × $9.05] = $19.32
• ud ($100.00): 0.9958 × [0.5024 × $9.05 + 0.4976 × $0] = $4.53
• dd ($84.10): 0.9958 × [0 + 0] = $0.00

Step 1:

• u ($109.05): 0.9958 × [0.5024 × $19.32 + 0.4976 × $4.53] = $11.91
• d ($91.70): 0.9958 × [0.5024 × $4.53 + 0.4976 × $0] = $2.27

Step 0 (today):

• Root: 0.9958 × [0.5024 × $11.91 + 0.4976 × $2.27] = $7.08

The 3-step CRR European call price is $7.08.

Backward induction is just one-step pricing applied at every node. Once you understand the single-step replication argument, the rest is bookkeeping.

Convergence to Black-Scholes (and the Direction Matters)

Black-Scholes is the continuous-time limit of the binomial model as Δt → 0.⁴ But for a given set of parameters the tree price approaches the limit from a specific side, and CRR prices oscillate slightly even after convergence is well under way.

Using the same inputs (S=K=$100, σ=30%, r=5%, T=0.25):

Note three things readers often get wrong:

1. Black-Scholes is $6.58, not “around $7.” With these parameters, d₁ = 0.1583, d₂ = 0.0083, N(d₁) = 0.5629, N(d₂) = 0.5033, so C = 100·(0.5629) − 100·e^(−0.0125)·(0.5033) = $6.583. Round to $6.58.⁵
2. The 3-step tree overshoots. $7.08 is higher than the limit. CRR convergence isn’t monotone — early-step prices oscillate around the limit, and the bias depends on whether the strike sits at, between, or far from a node. Run the numbers if you don’t believe it.
3. 50+ steps is “pricing-grade” only after you’ve checked the oscillation pattern. Practitioners often average n and n+1, or apply Richardson extrapolation, to damp the wobble.⁶

A sanity-check table that says “3-step ≈ 50-step ≈ Black-Scholes” should never appear in a textbook. Convergence has both a magnitude and a direction, and getting either wrong means the model has a silent bug.

Early Exercise (Where Trees Earn Their Keep)

European options exercise only at expiry. American options exercise any time. Backward induction handles the difference with a one-line edit at every interior node:

Option value at node = max(continuation value, immediate-exercise value)

For an American put with the same inputs (S = K = $100), at Node d, Step 1 (stock = $91.70):

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

Take $8.30. Propagate it backward. The tree just told you the optimal exercise boundary at this node.

Black-Scholes can’t do this — it has no node-level decision. Monte Carlo can, but only with regression machinery (Longstaff-Schwartz).⁷ Trees handle it with a max(). That’s why they remain the default for American puts and most callable/convertible structures.

For our parameters, the American put values out at $5.44 at 1,000 steps versus the European-put Black-Scholes value of $5.34 — a roughly 10-cent early-exercise premium that exists because rates are positive and strikes can be in the money before expiry.⁸

Greeks Without Calculus (Finite Differences from the Lattice)

You can read off Delta, Gamma, and Theta directly from the tree.

Delta from Step 1

Delta = (V_u − V_d) / (S_u − S_d) Delta = ($11.91 − $2.27) / ($109.05 − $91.70) = 0.556

The call gains roughly $0.56 per $1 increase in the stock. To delta-hedge a sold call, hold 0.556 shares per contract.

Gamma from Step 2

Compute Delta at two underlying levels, then the slope:

• Delta_up = (V_uu − V_ud) / (S_uu − S_ud) = ($19.32 − $4.53) / ($118.91 − $100) = 0.782
• Delta_down = (V_ud − V_dd) / (S_ud − S_dd) = ($4.53 − $0) / ($100 − $84.10) = 0.285
• Gamma = (Delta_up − Delta_down) / ((S_uu − S_dd)/2) = (0.782 − 0.285) / 17.41 = 0.0286

These are finite-difference approximations, which is the same idea behind every numerical Greek. The tree just hands you the inputs.

When Trees Beat PDE or Monte Carlo (and When They Don’t)

Trees win when:

• Early exercise is in scope. A max() at every node, no regression.
• Discrete dividends sit on specific dates. Drop the lattice on the ex-date instead of squeezing them into a continuous yield.
• Auditability matters. Every node value traces back to a one-step expectation.
• Greeks need to be cheap. Read them straight off the lattice.

Trees lose when:

• Payoffs are path-dependent. Asians and lookbacks need history, which breaks recombination — node count goes from O(n²) to O(2ⁿ).
• Multiple underlying assets. A 100-step 5-asset tree has 100⁵ = 10¹⁰ nodes; you’re now living in PDE or Monte Carlo land.
• Pure European pricing on a vanilla. Just call Black-Scholes — it’s exact, free, and won’t oscillate.

Building Your First Tree (Practical Checklist)

Inputs are consistent. Vol annualized, time in years, rate continuously compounded.

Verify 0 < d < e^(rΔt) < u before pricing. If this inequality breaks, p is outside [0, 1] and the tree is mis-parameterized.

Build forward, price backward. Construct the stock lattice left-to-right; compute option values right-to-left.

For American options: apply the max(continuation, exercise) test at every interior node, not just the final one.

Validate convergence. Increase steps and confirm the price stabilizes. If it’s still moving by more than a cent between n=200 and n=500, you need more steps — or you’ve got a parameterization bug.

Cross-check with Black-Scholes for European options. They should agree to within a few cents at 50+ steps. If your 50-step tree is half a dollar off Black-Scholes, the bug is in your code, not in the model.

For the continuous-time analog, see the companion piece on Black-Scholes Model Inputs and Outputs. For other approaches to American options — including Longstaff-Schwartz Monte Carlo and finite-difference PDE solvers — see American Option Pricing Approaches.