Binomial Option Pricing

A stock option gives its holder the right — but not the obligation — to buy or sell a stock at a fixed strike price on (or before) expiry. How much is that right worth today?

The insight behind the binomial model, introduced by Cox, Ross and Rubinstein in 1979, is disarmingly simple: divide time to expiry into $n$ equal steps. In each step the stock price either multiplies by an up factor $u$ or a down factor $d$. At expiry every node carries a known payoff. Work backwards through the tree, discounting each node's value, and you get the fair price at the root.

The model is recombining: an up move followed by a down move lands on the same node as a down move followed by an up move ($u \cdot d = 1$), so the tree has $n + 1$ terminal nodes instead of $2^{n}$. That makes the whole calculation run in $O(n^{2})$ time — fast enough to be practical long before continuous calculus is tractable.

As $n \to \infty$ and the step size $\Delta t = T/n \to 0$, the discrete tree converges to the famous Black-Scholes formula — the continuous limit of the same risk-neutral argument.

Adjust the sliders to build a binomial lattice. Each node shows the stock price; the highlighted bottom row shows the option payoff at expiry. The model folds those payoffs back to give the fair price today (top-left node). Increase the number of steps and watch the price converge toward the Black-Scholes value.

<!-- {{c_html_intro}} -->
<div class="controls">
  <label>{{lbl_steps}} <span id="stepsVal">8</span>
    <input type="range" id="steps" min="2" max="20" value="8">
  </label>
  <label>{{lbl_vol}} <span id="volVal">20</span>%
    <input type="range" id="vol" min="5" max="80" value="20">
  </label>
  <label>{{lbl_strike}} lt;span id="strikeVal">100</span>
    <input type="range" id="strike" min="80" max="120" value="100">
  </label>
</div>
<div class="results">
  <div class="result-box">
    <div class="result-label">{{lbl_binomial}}</div>
    <div class="result-value" id="binomialPrice">—</div>
  </div>
  <div class="result-box">
    <div class="result-label">{{lbl_bs}}</div>
    <div class="result-value" id="bsPrice">—</div>
  </div>
  <div class="result-box">
    <div class="result-label">{{lbl_diff}}</div>
    <div class="result-value" id="diffVal">—</div>
  </div>
</div>
<canvas id="chart" width="480" height="200"></canvas>
<div class="hint-bar" id="hintBar">{{hint_default}}</div>

/* {{c_css_intro}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: .5rem; background: transparent; }
.controls { display: flex; flex-direction: column; gap: .5rem; margin-bottom: .8rem; }
label { font-size: .85rem; color: #444; display: flex; align-items: center; gap: .5rem; }
input[type=range] { flex: 1; cursor: pointer; }
.results { display: flex; gap: .6rem; margin-bottom: .8rem; }
.result-box { flex: 1; background: #e8eef3; border-radius: 8px; padding: .5rem .7rem; text-align: center; }
.result-label { font-size: .72rem; color: #666; margin-bottom: .2rem; }
.result-value { font: 700 1.1rem ui-monospace, monospace; color: #1d3557; }
canvas { display: block; width: 100%; max-width: 480px; background: #f7f9fb; border-radius: 8px; border: 1px solid #dde3ea; }
.hint-bar { font-size: .8rem; color: #555; margin-top: .5rem; min-height: 1.2em; }

// Code not found

Notice how even 4–5 steps give a good approximation, and by 20 steps the binomial price is within a fraction of a cent of the Black-Scholes closed form. The tree trades continuous mathematics for a simple loop — and the two answers agree in the limit.

Why does the binomial model matter computationally, not just financially?

• Naive enumeration of all price paths gives $2^{n}$ leaves — hopeless beyond a handful of steps.
• Recombination collapses the tree: up then down equals down then up, leaving only $n + 1$ terminal nodes at step $n$. Total work is $O(n^{2})$, and it fits in $O(n)$ space with a rolling array.
• American options — which can be exercised early — have no clean closed form under Black-Scholes. The binomial tree handles them naturally: at each interior node, compare the continuation value with the immediate exercise payoff and take the max.
• Convergence rate: the error versus Black-Scholes is $O(1/n)$ for European calls, so doubling the steps halves the error. Practitioners use $n \approx 100$–$1000$ depending on the required precision.
• Exotic path dependence (barrier options, lookback options) requires tracking extra state per node but the lattice structure remains; dynamic programming on the tree generalises naturally.

The binomial model is also a gateway to understanding risk-neutral pricing: the up/down probabilities $p$ and $1-p$ are chosen so every asset grows at the risk-free rate, not the subjective expected return. The actual probability the stock goes up never appears — only the no-arbitrage constraint matters.

The binomial lattice is one of the most versatile tools in quantitative finance:

• Equity options: the original use case — calls and puts on individual stocks, handling both European and American exercise styles.
• Interest-rate trees: models such as Ho-Lee and Black-Derman-Toy build a binomial tree of short rates to price bonds, caps, floors and swaptions.
• Real options: capital-budgeting decisions (expand, defer, abandon a project) are modelled as options on uncertain future cash flows; the lattice prices the managerial flexibility explicitly.
• Credit derivatives: simplified lattice models price convertible bonds and credit default options where early exercise and credit events interact.
• Algorithm education: because the backward induction is a pure dynamic programming computation on a DAG, the binomial tree is one of the clearest real-world examples of that paradigm.

Wherever continuous-time stochastic calculus is too heavy — or produces no closed form — the lattice provides a transparent, tuneable approximation.

The binomial model is a masterclass in discretising a hard continuous problem. Replace Brownian motion with coin flips, fold payoffs backwards through a recombining tree, and — almost magically — the answer converges to the same number that the Black-Scholes partial differential equation gives in the limit $n \to \infty$.

Its computational footprint is modest: $O(n^{2})$ work, $O(n)$ space. Its conceptual payoff is enormous: risk-neutral pricing, no-arbitrage arguments, and the link between discrete dynamic programming and continuous stochastic calculus all live inside one simple lattice.