The Binomial Lattice Model for Option Valuation

Imagine you want to know the fair price of an option today, but the future is uncertain. Listing every possible path the stock price might take would be impossible. What if we simplify by breaking time into many small steps, and at each step the stock can only go up or down? That’s the idea behind the binomial lattice model: we build a tree of possible prices and work backwards to find the option’s value. It’s a powerful, intuitive way to price both European and American options.

The Big Picture#

The binomial lattice model takes the complex, continuous world and turns it into a simple, step‑by‑step tree. At each small time step, the stock price can only go up (multiply by ) or down (multiply by ). By choosing and in a certain way and using a clever probability trick, we can create a “risk‑neutral” world. In that world, we can discount all future payoffs at the risk‑free rate, as if investors didn’t mind risk. Then we just start at the end of the tree, where the option payoff is known, and work backwards to get today’s price. For American options, we also check at each step whether it’s better to exercise early. By the end of this chapter, you’ll be able to build a binomial tree, price European and American options, and see why the method gets close to the famous Black–Scholes price when you use many steps.

Building a Recombining Binomial Tree#

We want to model a stock price over a time . Instead of a continuous timeline, we split into equal pieces, each of length . At each piece, the stock can only go up or down. Starting from , after one step we have:

• Up:
• Down:

where and . After two steps, we could go up then down, or down then up. Because multiplication is commutative (), both paths land at the same price: . This is called a recombining tree. A recombining tree is much more efficient than a non‑recombining one because the number of distinct nodes after steps is only , not .

Recombining tree: A binomial tree where an up move followed by a down move reaches the same node as a down move followed by an up move. The number of nodes grows linearly with the number of steps.

How do we choose and ? They should reflect the stock’s volatility (the standard deviation of annual returns) and the time step . A standard choice (the Cox–Ross–Rubinstein, or CRR, parameterization) is:

This makes the tree symmetric in log‑prices: and . The up and down factors are reciprocals, which ensures the tree recombines nicely and the log‑returns have variance (in the real world, before we adjust for risk‑neutral pricing).

Example: Suppose , (20% per year), year, and steps, so . Then:

After one step: , . After two steps, the three possible prices are:

• Two ups:
• One up, one down (in either order): (since )
• Two downs:

Notice the middle node is exactly —a handy feature of the CRR choice. The tree recombines perfectly.

We can represent the entire stock price tree as a grid. For step (with ), and for up moves, the stock price at node is:

This formula will be our building block for option pricing.

📝 Section Recap: We chop time into small steps and let the stock multiply by (up) or (down) at each step. Choosing and creates a recombining tree that captures volatility and is easy to work with.

Risk‑Neutral Probabilities and the Risk‑Free Rate#

The tree shows where the stock price might go, but to value an option we need to handle risk. Usually, investors demand extra return for taking risk. But there’s a clever trick: we can pretend the world is risk‑neutral by adjusting the probabilities of up and down moves. In this risk‑neutral world, the expected return on the stock is just the risk‑free rate , and we can discount all future payoffs at . Amazingly, the price we get is the correct no‑arbitrage price in the real world.

Why does this work? A fundamental principle in finance says that if there’s no arbitrage, we can construct a risk‑neutral probability measure. In our simple binomial model, that means we can find a single probability of an up move (and for down) such that the expected stock price after one step, when discounted at the risk‑free rate, equals today’s price.

Over one time step of length , 1e^{r \Delta t}p$ to grow at the same rate:

Cancel :

Solve for :

This is the risk‑neutral probability of an up move. It depends only on , , , and —not on the stock’s actual expected return. For to be between and we need ; with CRR parameters and reasonable numbers this holds for small .

Risk‑neutral probability: The probability that makes the stock’s expected return equal to the risk‑free rate. Using this probability, we can discount future option payoffs at to get today’s price.

Once we have , the value of an option one step before payoff is the discounted risk‑neutral expected value:

where and are the option values in the up and down states. This is the heart of the backward induction algorithm.

Example continued: Using (5% per year), , we compute:

Then:

So . In the risk‑neutral world, the stock has a chance of going up each step—even if real‑world investors see a different chance. That’s fine; the pricing formula doesn’t need real‑world probabilities.

📝 Section Recap: We find a unique probability that makes the expected stock return equal to the risk‑free rate. Using , we can discount expected option payoffs at to get today’s fair price.

Backward Induction for European Options#

Now we can price a European option, which can only be exercised at expiration. We start at the final time step , where the payoff is known for every possible stock price . For a call option with strike , the payoff is ; for a put, . We then work backwards through the tree, applying the one‑step valuation formula over and over.

We call this process backward induction.

Algorithm (European option):

1. Build the stock price tree for to , using .
2. At , set the option value at each node :
   .
3. For down to :
   For each to :
   .
4. The option price today is .

Why does this work? At each node, the value is the discounted risk‑neutral expected value of the two next‑step possibilities. By repeating this, we make sure the whole tree is free of arbitrage.

Example: Let’s price a European call with , , , , , . We already have , , , and .

Terminal stock prices: , , . Call payoffs: , , .

Now step back to :

• Node (1,1): stock 115.19, .
• Node (1,0): stock 86.81, .

Step back to :

• .

So the call price is about . With more steps, this will converge to the Black–Scholes price (around for these parameters). Even with only two steps we are in the right neighbourhood.

This backward induction is a form of dynamic programming: we solve a small problem at each node using solutions we already have from later nodes.

📝 Section Recap: To price a European option, we start with the known payoffs at expiration and work backwards, at each node computing the discounted expected value using risk‑neutral probabilities. The value at the root is today’s fair price.

American Options and Early Exercise#

American options can be exercised at any time up to expiration. This extra freedom adds value, especially for puts and for calls on dividend‑paying stocks. The tree handles this beautifully: at each node we simply compare the value from continuing (the discounted expected future value) with the value from exercising immediately. If exercising gives a higher payoff, we take it; otherwise, we continue. This is a straightforward dynamic programming check.

Algorithm (American option):

1. Build the stock price tree.
2. At , .
3. For down to :
   For each to :
   • Compute the continuation value: .
   • Compute the immediate exercise value: .
   • Set .
4. The option price is .

The only difference from the European case is the step. That captures early exercise perfectly.

Example: American put. Puts are often exercised early, especially when deep in‑the‑money and interest rates are positive. Let’s price an American put with the same parameters: , , , , , .

Terminal payoffs: (put payoff 0), (payoff 0), (payoff ).

Step back to :

• Node (1,1): stock 115.19, continuation . Exercise . So .
• Node (1,0): stock 86.81, continuation . Exercise . Since , it is optimal to exercise early. So .

Step back to :

• Continuation .
• Exercise .
• .

The American put price is . If we had priced a European put on the same tree (by ignoring the early exercise check at node (1,0) and keeping the continuation value ), the European put price would be about . The early exercise premium is .

This algorithm works for any number of steps, and as grows, the American option price converges to the true value from the continuous‑time model.

📝 Section Recap: For American options, we add a simple check at each node: is it better to exercise now or wait? The value is the maximum of the immediate payoff and the discounted expected future value. This dynamic programming approach naturally captures early exercise.

Summary#

We began by turning the uncertain future into a tree of up and down moves. By picking and to match volatility and using risk‑neutral probabilities, option pricing becomes a simple backward calculation. The same tree works for European options (just discount expected payoffs) and American options (check for early exercise at each step). The binomial model is not just a learning tool—it’s a practical method that gives accurate prices as you use more steps, and it can handle dividends, multiple assets, and more.