The Binomial Model Part 2: Trees, Greeks, and the Continuous Limit

In Part 1 we covered the intuition behind the binomial model: delta hedging, risk-neutral pricing, and why probabilities do not matter for option values. Now we get to the practical side. How do you actually build a binomial tree, compute option prices, estimate Greeks, handle American options, and connect everything back to Black-Scholes?

Building the Binomial Tree

In Part 1 we had just one time step. In practice, you split the time until expiry into many steps. At each step the stock either goes up by factor u or down by factor v. Starting from price S:

• After 1 step: uS or vS (2 possible values)
• After 2 steps: u squared times S, uvS, or v squared times S (3 possible values)
• After 3 steps: 4 possible values
• After N steps: N+1 possible values

This branching structure is the binomial tree. Because we multiply by u and v (rather than add), the tree naturally bends upward, reflecting the geometric (lognormal) nature of stock prices.

An interesting property: the middle nodes can be reached by many different paths, while the extreme top and bottom can each be reached by only one path (all ups or all downs). This means interior prices are more probable. The distribution of final prices is roughly bell-shaped, which is an approximation to the lognormal distribution.

Valuing Back Down the Tree

Here is the algorithm. It works backward from expiry to today:

1. Build the stock price tree forward to expiry (N time steps, giving N+1 final prices).
2. At expiry, calculate the option payoff at each node. For a call: max(S minus K, 0).
3. Step back one time period. At each node, the option value equals the discounted risk-neutral expected value of the two nodes ahead of it.
4. Repeat step 3 until you reach today.

The formula at each node:

V = exp(-r dt) times [p’ times V_up + (1 minus p’) times V_down]

where p’ is the risk-neutral probability from Part 1. The value at the root of the tree is today’s option price.

Programming the Binomial Method

Wilmott provides actual code (in VBA, but the logic translates to any language). The key insight for implementation:

You only need the final asset prices. Build the stock array forward to get all values at expiry, then calculate payoffs, then work backward through the option values. You do not need to store the entire tree in memory for a European option. Two one-dimensional arrays are enough: one for stock prices at the current level, one for option values.

Here is the structure in pseudocode:

set up parameters: dt, u, v, p', discount factor
build stock prices at expiry: S[j] for j = 0 to N
calculate payoffs: V[j] = max(S[j] - K, 0)
for n = N down to 1:
    for j = 0 to n-1:
        V[j] = discount * (p' * V[j+1] + (1-p') * V[j])
return V[0]

One thing Wilmott points out: if you plot the option price against the number of time steps, you get an oscillation. Odd steps give values that are too high, even steps give values that are too low. Both converge to the true value, but slowly. This is one of the reasons Wilmott considers the binomial method “prehistoric” compared to finite-difference methods.

The Greeks from the Tree

The Greeks measure how the option price changes with respect to various inputs. Some can be estimated directly from the tree, others require running the tree twice.

Delta is the sensitivity to the stock price. From the tree, after one time step you have two option values (V+ and V-) and two stock prices (uS and vS). Delta is simply:

Delta = (V+ minus V-) / (uS minus vS)

As the time step shrinks toward zero, this approaches the Black-Scholes delta, which is the partial derivative of V with respect to S.

Gamma measures how much delta changes. You need to go two time steps into the tree, calculate delta at the up-node and delta at the down-node, then divide the difference by the distance between the two stock prices. This uses option values from three nodes two steps ahead.

Theta measures sensitivity to time. Interpolate between V+ and V- to estimate what the option would be worth if the stock price had not changed, then compare that with today’s value.

Vega and rho are sensitivities to parameters (volatility and interest rate). These cannot be read off a single tree. You must run the entire binomial calculation twice with slightly different parameter values and take the difference. For vega: run the tree with volatility sigma + epsilon and sigma minus epsilon, then vega is approximately (V+ minus V-) / (2 times epsilon).

Early Exercise: American Options

This is where the binomial model really shines compared to closed-form solutions. There is no simple formula for American options, but the binomial tree handles them easily.

The modification is small but important. At each node, as you work backward through the tree, you compare two values:

1. The “continuation value” (the discounted risk-neutral expected value from continuing to hold)
2. The “exercise value” (the immediate payoff from exercising now)

The option value at that node is whichever is larger:

V = max(continuation value, payoff(S))

If the payoff is higher, it means the option should be exercised at that point. This is what creates the early exercise boundary for American puts.

The code changes are minimal. You need to keep track of stock prices at every node (not just at expiry), and you add one max() comparison in the backward loop. But now the algorithm correctly handles the possibility of early exercise at any point in time.

The Continuous-Time Limit

Here is where the math gets satisfying. As the time step dt approaches zero, the binomial model becomes Black-Scholes.

Take the binomial pricing equation and expand everything in Taylor series for small dt. The terms u and v both approach 1 (tiny moves up and down). The risk-neutral probability p’ approaches 1/2. After grinding through the algebra, the binomial equation becomes:

dV/dt + (1/2) sigma squared S squared d2V/dS2 + rS dV/dS minus rV = 0

That is the Black-Scholes equation. The drift rate mu has disappeared, exactly as expected. The binomial delta also converges to the Black-Scholes delta (partial derivative of V with respect to S).

So the binomial model is not just an approximation. In the limit of infinitely many time steps, it IS Black-Scholes. This is why both approaches give the same option prices.

The Trinomial Problem

Wilmott makes a sharp observation about why the binomial model is special. What if instead of two possible moves, we allowed three? An up, a middle, and a down.

With three possible outcomes, you would need to make the hedged portfolio have the same value in all three states. That is two equations (state 1 = state 2, state 2 = state 3) with one unknown (delta). You cannot solve it. Perfect hedging is impossible.

This is actually true in the real world too. Perfect delta hedging only works in the two special mathematical worlds: the continuous-time Black-Scholes world, and the discrete-time binomial world. In reality, with its infinitely many possible outcomes at each moment, delta hedging is imperfect. Wilmott finds it “fascinating” that the two most popular models are the only ones where hedging works perfectly. He thinks this says more about modelers than about actual financial markets.

Alternative Parameterizations

There is more than one way to choose u, v, and p for the binomial tree. The version in Part 1 used p = 1/2 and adjusted u and v to match drift and volatility. Another popular choice (from Cox, Ross, and Rubinstein, the original creators) sets:

• u times v = 1 (so an up followed by a down returns to the starting price)
• u = exp(sigma times sqrt(dt))
• v = 1/u

This gives a “recombining” tree that is symmetric around the starting price, making it visually clean and computationally efficient. The probability p is then adjusted to match the drift.

Both parameterizations converge to the same answer as the number of steps increases. The choice is mostly about convenience and numerical behavior.

What to Remember

Wilmott says you should study this chapter for the ideas, then “relegate the binomial method to the back of your mind.” For actual numerical work, finite-difference methods (covered later in the book) are more flexible and more accurate.

But the intuition from this chapter is permanent. The backward induction algorithm, the irrelevance of real-world probabilities, the connection between discrete hedging and continuous-time PDEs, and the simplicity of handling American exercise through a max() comparison. These ideas come up over and over again in quantitative finance.

Key Takeaways

1. The binomial tree extends the one-step model to many time steps, creating a lattice of possible stock prices.
2. Option values are computed by working backward from expiry, using discounted risk-neutral expectations at each node.
3. Delta, gamma, and theta can be estimated from the tree. Vega and rho need two separate tree calculations.
4. American options just add a max() at each node: compare continuation value with immediate exercise value.
5. As the time step goes to zero, the binomial equation becomes the Black-Scholes PDE.
6. Perfect hedging only works in binomial and Black-Scholes worlds. Real markets are messier.

Previous post: The Binomial Model Part 1: Building Intuition for Option Pricing

Next post: Is the Normal Distribution Good Enough for Finance?