---
title: "Chapter 22. American Options"
---
::: {.chapter-objectives}
## Learning Goals
By the end of this chapter, students should be able to:
- distinguish European, Bermudan, and American exercise rights;
- define stopping times with respect to a filtration;
- formulate American option pricing as an optimal stopping problem under the risk-neutral measure;
- construct the Snell envelope in a finite discrete-time model;
- prove the backward-induction recursion for American option prices;
- identify the optimal exercise rule by comparing immediate exercise with continuation value;
- implement American option pricing by binomial trees in Python;
- extract and interpret an early-exercise boundary;
- explain why a non-dividend-paying American call is not exercised early in the Black--Scholes model;
- understand the continuous-time variational inequality and free-boundary viewpoint;
- use AI tools to audit optimal-stopping logic, code, and financial interpretation.
:::
::: {.hero-box}
A European option can be exercised only at maturity. An American option can be exercised at any allowable time before maturity. This extra right converts pricing from a single conditional expectation into an **optimal stopping problem**.
For an American option with payoff process $Z_n$, the value process is the Snell envelope
$$
V_n=egin{cases}
Z_N, & n=N,\\[4pt]
\max\left\{Z_n,\,\frac{1}{1+r}\mathbb E^{\mathbb Q}[V_{n+1}\mid\mathcal F_n]\right\}, & n=N-1,\ldots,0.
\end{cases}
$$
The term $Z_n$ is the value from exercising now. The conditional expectation is the value from continuing. The American option value is the larger of the two.
:::
## 22.1 Why American Options Are Different
A European payoff has the form
$$
X=g(S_T),
$$
and, in a complete risk-neutral model with money-market account $B_t$, its time-$t$ price is
$$
V_t=B_t\mathbb E^{\mathbb Q}\left[\frac{X}{B_T}\mid\mathcal F_t\right].
$$
The maturity $T$ is fixed. The only random object is the terminal payoff.
An American option has a payoff available at multiple times. If the holder exercises at time $t$, the holder receives
$$
Z_t=g(S_t).
$$
For an American put,
$$
Z_t=(K-S_t)^+.
$$
For an American call,
$$
Z_t=(S_t-K)^+.
$$
The holder must choose **when** to stop. The exercise time must be based only on information available at that time. This makes American option pricing a problem about stochastic processes, filtrations, conditional expectation, and optimization.
::: {.definition}
## European, Bermudan, and American exercise rights
Let $0=t_0<t_1<\cdots<t_N=T$ be a set of possible decision dates.
- A **European option** can be exercised only at $T$.
- A **Bermudan option** can be exercised only at a specified finite set of dates.
- An **American option** can be exercised at any time up to maturity. In a discrete-time model, this means any date $t_n$, $0\le n\le N$.
:::
In this chapter we first work in discrete time. This is the cleanest setting for MA Applied Math and MS Statistics students because the entire theory can be written using finite-dimensional conditional expectations and backward induction. Continuous time then appears as a limiting and PDE/free-boundary problem.
## 22.2 Stopping Times
The mathematical object that represents an exercise rule is a stopping time.
::: {.definition}
## Stopping time
Let $(\mathcal F_n)_{n=0}^N$ be a filtration. A random time $\tau$ taking values in $\{0,1,\ldots,N\}$ is a **stopping time** if
$$
\{\tau=n\}\in\mathcal F_n
\qquad \text{for every } n.
$$
Equivalently,
$$
\{\tau\le n\}\in\mathcal F_n
\qquad \text{for every } n.
$$
:::
The stopping-time condition says that the decision to exercise by time $n$ can be made using only information available by time $n$. It rules out strategies that look into the future.
::: {.example}
## A valid exercise rule
For an American put, define
$$
\tau=\inf\{n:S_n\le b_n\},
$$
where $b_n$ is a deterministic boundary. This is a stopping time because the event $\{S_n\le b_n\}$ is known at time $n$.
:::
::: {.example}
## A non-stopping exercise rule
The rule "exercise at the first time before the final maximum of the stock price" is not a stopping time. It requires knowing future prices, so it cannot be implemented by an actual trader.
:::
## 22.3 Risk-Neutral Formulation
Consider a finite discrete-time model with dates $0,1,\ldots,N$. Let the one-period risk-free gross return be
$$
R=1+r>0.
$$
The money-market account is
$$
B_n=R^n.
$$
Assume the market is arbitrage-free and that $\mathbb Q$ is a risk-neutral probability measure. For a payoff process $Z_n$, the value of an American claim at time $0$ is
$$
V_0
=
\sup_{\tau\in\mathcal T_0}
\mathbb E^{\mathbb Q}\left[\frac{Z_\tau}{B_\tau}\right],
$$
where $\mathcal T_0$ is the set of stopping times taking values in $\{0,\ldots,N\}$.
At time $n$, the value is
$$
V_n
=
\operatorname*{ess\,sup}_{\tau\in\mathcal T_n}
\mathbb E^{\mathbb Q}\left[\frac{B_n}{B_\tau}Z_\tau\mid\mathcal F_n\right],
$$
where $\mathcal T_n$ is the set of stopping times with $\tau\ge n$.
In a finite tree model, this essential supremum is just a maximum over all admissible future exercise rules.
::: {.remark}
## American pricing is not just expectation
A common mistake is to write
$$
V_0=\mathbb E^{\mathbb Q}\left[R^{-N}g(S_N)\right]
$$
for an American option. This is the European value. The American value must optimize over stopping times:
$$
V_0=\sup_\tau\mathbb E^{\mathbb Q}\left[R^{-\tau}g(S_\tau)\right].
$$
:::
## 22.4 The Snell Envelope
The Snell envelope is the central mathematical object for American option pricing.
::: {.definition}
## Snell envelope in discrete time
Let $\tilde Z_n=Z_n/B_n$ be the discounted payoff process. The **Snell envelope** $\tilde V_n$ of $\tilde Z_n$ is defined backward by
$$
\tilde V_N=\tilde Z_N,
$$
and
$$
\tilde V_n
=
\max\left\{\tilde Z_n,\mathbb E^{\mathbb Q}[\tilde V_{n+1}\mid\mathcal F_n]\right\},
\qquad n=N-1,\ldots,0.
$$
The undiscounted value is
$$
V_n=B_n\tilde V_n.
$$
:::
Equivalently, if the risk-free rate is constant, then
$$
V_N=Z_N,
$$
and
$$
V_n=
\max\left\{Z_n,\frac{1}{R}\mathbb E^{\mathbb Q}[V_{n+1}\mid\mathcal F_n]\right\}.
$$
The two terms have different meanings:
$$
\text{exercise value}=Z_n,
$$
and
$$
\text{continuation value}=\frac{1}{R}\mathbb E^{\mathbb Q}[V_{n+1}\mid\mathcal F_n].
$$
The optimal rule is to exercise when immediate exercise is at least as valuable as continuation.
$$
\tau^*=\inf\{n:Z_n=V_n\}.
$$
::: {.theorem}
## Snell envelope theorem
Let $\tilde Z=(\tilde Z_n)_{n=0}^N$ be an adapted discounted payoff process with finite expectations. The Snell envelope $\tilde V$ satisfies:
1. $\tilde V_n\ge \tilde Z_n$ for all $n$;
2. $\tilde V$ is a $\mathbb Q$-supermartingale;
3. $\tilde V$ is the smallest $\mathbb Q$-supermartingale that dominates $\tilde Z$;
4. $\tilde V_n=\sup_{\tau\in\mathcal T_n}\mathbb E^{\mathbb Q}[\tilde Z_\tau\mid\mathcal F_n]$.
:::
::: {.proof}
The backward recursion immediately gives $\tilde V_n\ge \tilde Z_n$. It also gives
$$
\tilde V_n
\ge
\mathbb E^{\mathbb Q}[\tilde V_{n+1}\mid\mathcal F_n],
$$
so $\tilde V$ is a supermartingale.
To show minimality, let $Y$ be any supermartingale satisfying $Y_n\ge \tilde Z_n$. Since $Y_N\ge \tilde Z_N=\tilde V_N$, suppose by backward induction that $Y_{n+1}\ge \tilde V_{n+1}$. Then
$$
Y_n
\ge
\mathbb E^{\mathbb Q}[Y_{n+1}\mid\mathcal F_n]
\ge
\mathbb E^{\mathbb Q}[\tilde V_{n+1}\mid\mathcal F_n].
$$
Also $Y_n\ge \tilde Z_n$. Therefore
$$
Y_n\ge
\max\left\{\tilde Z_n,\mathbb E^{\mathbb Q}[\tilde V_{n+1}\mid\mathcal F_n]\right\}
=\tilde V_n.
$$
This proves minimality. The optimal-stopping representation follows from the same backward induction and the stopping rule
$$
\tau^*=\inf\{k\ge n:\tilde V_k=\tilde Z_k\}.
$$
:::
## 22.5 A One-Step American Put
Suppose there is one period, $S_0=100$, $K=100$, $u=1.2$, $d=0.8$, and $R=1.05$. Under the risk-neutral measure,
$$
q=\frac{R-d}{u-d}=\frac{1.05-0.8}{1.2-0.8}=0.625.
$$
The terminal put payoff is
$$
Z_1=(K-S_1)^+.
$$
At the up node, $S_1=120$ and $Z_1=0$. At the down node, $S_1=80$ and $Z_1=20$. The continuation value at time $0$ is
$$
\frac{1}{R}\left(q\cdot 0+(1-q)\cdot 20\right)
=\frac{7.5}{1.05}
\approx 7.1429.
$$
The immediate exercise value is
$$
Z_0=(100-100)^+=0.
$$
Therefore the American put value is
$$
V_0=\max\{0,7.1429\}=7.1429.
$$
In this one-step at-the-money example, early exercise at time $0$ is not optimal.
```{python}
#| label: py-ch22-one-step-put
#| fig-cap: "One-step American put calculation"
S0 = 100
K = 100
u = 1.2
d = 0.8
R = 1.05
q = (R - d) / (u - d)
payoff_up = max(K - u * S0, 0)
payoff_down = max(K - d * S0, 0)
continuation = (q * payoff_up + (1 - q) * payoff_down) / R
exercise = max(K - S0, 0)
american_value = max(exercise, continuation)
print("risk-neutral probability q =", q)
print("continuation value =", continuation)
print("exercise value =", exercise)
print("American put value =", american_value)
```
## 22.6 Binomial Tree Recursion
In the Cox--Ross--Rubinstein binomial model, the stock evolves as
$$
S_{n+1}=\begin{cases}
u S_n, & \text{up},\\
d S_n, & \text{down}.
\end{cases}
$$
For a time step $\Delta t=T/N$, the standard CRR parameters are
$$
u=e^{\sigma\sqrt{\Delta t}},
\qquad
d=e^{-\sigma\sqrt{\Delta t}},
\qquad
R=e^{r\Delta t}.
$$
The risk-neutral probability is
$$
q=\frac{R-d}{u-d}.
$$
At terminal time $N$, set
$$
V_N(j)=g(S_N(j)),
\qquad j=0,1,\ldots,N,
$$
where
$$
S_N(j)=S_0u^j d^{N-j}.
$$
For $n=N-1,\ldots,0$ and $j=0,\ldots,n$,
$$
C_n(j)=\frac{1}{R}\left(qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right),
$$
and
$$
V_n(j)=\max\{g(S_n(j)),C_n(j)\}.
$$
For a European option, the maximum step is removed:
$$
V_n^{\mathrm{Euro}}(j)=C_n(j).
$$
The American premium is
$$
V_0^{\mathrm{Amer}}-V_0^{\mathrm{Euro}}\ge 0.
$$
```{python}
#| label: py-ch22-crr-american-put
#| fig-cap: "American and European put values in a CRR tree"
import math
import numpy as np
def crr_option_price(S0, K, r, sigma, T, N, option="put", american=True):
dt = T / N
u = math.exp(sigma * math.sqrt(dt))
d = 1 / u
R = math.exp(r * dt)
q = (R - d) / (u - d)
if not (0 < q < 1):
raise ValueError("Risk-neutral probability is outside (0,1). Check parameters.")
j = np.arange(N + 1)
stock = S0 * (u ** j) * (d ** (N - j))
if option == "put":
values = np.maximum(K - stock, 0.0)
else:
values = np.maximum(stock - K, 0.0)
for n in range(N - 1, -1, -1):
values = (q * values[1:n+2] + (1 - q) * values[0:n+1]) / R
if american:
j = np.arange(n + 1)
stock = S0 * (u ** j) * (d ** (n - j))
if option == "put":
exercise = np.maximum(K - stock, 0.0)
else:
exercise = np.maximum(stock - K, 0.0)
values = np.maximum(values, exercise)
return float(values[0])
S0, K, r, sigma, T, N = 100, 100, 0.05, 0.25, 1.0, 200
am_put = crr_option_price(S0, K, r, sigma, T, N, option="put", american=True)
eu_put = crr_option_price(S0, K, r, sigma, T, N, option="put", american=False)
print("American put:", am_put)
print("European put:", eu_put)
print("early-exercise premium:", am_put - eu_put)
```
## 22.7 Interactive: American Put Value and Early-Exercise Premium
The next interactive example compares American and European put prices in a CRR tree. The gap between the two curves is the value of the early-exercise right.
::: {.interactive-card}
### American versus European put
Change volatility and the interest rate to see how the early-exercise premium changes.
<div class="mf-control-row">
<label for="ch22-sigma">volatility $\sigma$</label>
<input id="ch22-sigma" type="range" min="0.05" max="0.70" step="0.01" value="0.25">
<span id="ch22-sigma-value" class="mf-badge">0.25</span>
</div>
<div class="mf-control-row">
<label for="ch22-rate">interest rate $r$</label>
<input id="ch22-rate" type="range" min="0.00" max="0.12" step="0.005" value="0.05">
<span id="ch22-rate-value" class="mf-badge">0.050</span>
</div>
<div class="mf-control-row">
<label for="ch22-maturity">maturity $T$</label>
<input id="ch22-maturity" type="range" min="0.25" max="3.00" step="0.25" value="1.00">
<span id="ch22-maturity-value" class="mf-badge">1.00</span>
</div>
<div id="ch22-american-premium-demo" class="plotly-demo"></div>
<script>
(function() {
function payoffPut(K, S) { return Math.max(K - S, 0); }
function crrPrice(S0, K, r, sigma, T, N, american) {
var dt = T / N;
var u = Math.exp(sigma * Math.sqrt(dt));
var d = 1 / u;
var R = Math.exp(r * dt);
var q = (R - d) / (u - d);
if (!(q > 0 && q < 1)) return NaN;
var values = [];
for (var j = 0; j <= N; j++) {
var S = S0 * Math.pow(u, j) * Math.pow(d, N - j);
values.push(payoffPut(K, S));
}
for (var n = N - 1; n >= 0; n--) {
var newValues = [];
for (var k = 0; k <= n; k++) {
var cont = (q * values[k + 1] + (1 - q) * values[k]) / R;
var Snode = S0 * Math.pow(u, k) * Math.pow(d, n - k);
var ex = payoffPut(K, Snode);
newValues.push(american ? Math.max(ex, cont) : cont);
}
values = newValues;
}
return values[0];
}
function draw() {
var sigma = Number(document.getElementById("ch22-sigma").value);
var r = Number(document.getElementById("ch22-rate").value);
var T = Number(document.getElementById("ch22-maturity").value);
document.getElementById("ch22-sigma-value").textContent = sigma.toFixed(2);
document.getElementById("ch22-rate-value").textContent = r.toFixed(3);
document.getElementById("ch22-maturity-value").textContent = T.toFixed(2);
var K = 100;
var N = 80;
var Sgrid = [];
var amer = [];
var euro = [];
var prem = [];
for (var i = 0; i <= 80; i++) {
var S0 = 50 + i * 100 / 80;
var a = crrPrice(S0, K, r, sigma, T, N, true);
var e = crrPrice(S0, K, r, sigma, T, N, false);
Sgrid.push(S0);
amer.push(a);
euro.push(e);
prem.push(a - e);
}
var traces = [
{x: Sgrid, y: amer, mode: "lines", name: "American put"},
{x: Sgrid, y: euro, mode: "lines", name: "European put"},
{x: Sgrid, y: prem, mode: "lines", name: "early-exercise premium"}
];
var layout = {
title: "American put, European put, and early-exercise premium",
xaxis: {title: "initial stock price S0"},
yaxis: {title: "option value"},
legend: {orientation: "h"},
margin: {l: 55, r: 25, t: 55, b: 45}
};
Plotly.newPlot("ch22-american-premium-demo", traces, layout, {responsive: true});
}
if (window.mfPlotlyReady) {
window.mfPlotlyReady(function() {
["ch22-sigma", "ch22-rate", "ch22-maturity"].forEach(function(id) {
document.getElementById(id).addEventListener("input", draw);
});
draw();
});
}
})();
</script>
:::
## 22.8 Exercise Boundary
For an American put, early exercise is usually most attractive when the stock price is sufficiently low. In a binomial tree, the exercise region at time $n$ is
$$
\{j: g(S_n(j))\ge C_n(j)\}.
$$
The continuation region is
$$
\{j: g(S_n(j))< C_n(j)\}.
$$
An approximate exercise boundary can be defined as the largest stock price at which exercise is optimal:
$$
b_n=\max\{S_n(j):g(S_n(j))\ge C_n(j)\}.
$$
For puts, the exercise region often has the approximate form
$$
S_n\le b_n.
$$
The boundary is not a new assumption. It is an output of the optimal-stopping problem.
```{python}
#| label: py-ch22-exercise-boundary
#| fig-cap: "Extracting an American put exercise boundary from a binomial tree"
import math
import numpy as np
def american_put_boundary(S0, K, r, sigma, T, N):
dt = T / N
u = math.exp(sigma * math.sqrt(dt))
d = 1 / u
R = math.exp(r * dt)
q = (R - d) / (u - d)
j = np.arange(N + 1)
stock = S0 * (u ** j) * (d ** (N - j))
values = np.maximum(K - stock, 0.0)
boundary = [(T, np.nan)]
for n in range(N - 1, -1, -1):
continuation = (q * values[1:n+2] + (1 - q) * values[0:n+1]) / R
j = np.arange(n + 1)
stock = S0 * (u ** j) * (d ** (n - j))
exercise = np.maximum(K - stock, 0.0)
exercise_now = exercise >= continuation - 1e-12
positive_payoff = exercise > 0
candidates = stock[exercise_now & positive_payoff]
b = np.max(candidates) if candidates.size else np.nan
boundary.append((n * dt, b))
values = np.maximum(exercise, continuation)
boundary = sorted(boundary)
return boundary, values[0]
boundary, price = american_put_boundary(100, 100, 0.05, 0.25, 1.0, 100)
print("American put price:", price)
print("First five boundary points:")
for row in boundary[:5]:
print(row)
```
## 22.9 Interactive: Snell Envelope on a Small Tree
The following visualization shows a four-step American put tree. Each node compares immediate exercise with continuation value. Red-highlighted nodes are exercise nodes.
::: {.interactive-card}
### Snell envelope and exercise nodes
<div class="mf-control-row">
<label for="ch22-tree-sigma">volatility $\sigma$</label>
<input id="ch22-tree-sigma" type="range" min="0.10" max="0.60" step="0.01" value="0.30">
<span id="ch22-tree-sigma-value" class="mf-badge">0.30</span>
</div>
<div class="mf-control-row">
<label for="ch22-tree-rate">interest rate $r$</label>
<input id="ch22-tree-rate" type="range" min="0.00" max="0.12" step="0.005" value="0.05">
<span id="ch22-tree-rate-value" class="mf-badge">0.050</span>
</div>
<div class="mf-control-row">
<label for="ch22-tree-s0">initial price $S_0$</label>
<input id="ch22-tree-s0" type="range" min="70" max="130" step="1" value="100">
<span id="ch22-tree-s0-value" class="mf-badge">100</span>
</div>
<div id="ch22-snell-tree-demo" class="plotly-demo"></div>
<script>
(function() {
function computeTree(S0, K, r, sigma, T, N) {
var dt = T / N;
var u = Math.exp(sigma * Math.sqrt(dt));
var d = 1 / u;
var R = Math.exp(r * dt);
var q = (R - d) / (u - d);
var stock = [];
var value = [];
var exercise = [];
for (var n = 0; n <= N; n++) {
stock[n] = [];
value[n] = [];
exercise[n] = [];
for (var j = 0; j <= n; j++) {
stock[n][j] = S0 * Math.pow(u, j) * Math.pow(d, n - j);
}
}
for (var jT = 0; jT <= N; jT++) {
value[N][jT] = Math.max(K - stock[N][jT], 0);
exercise[N][jT] = value[N][jT] > 0;
}
for (var n2 = N - 1; n2 >= 0; n2--) {
for (var k = 0; k <= n2; k++) {
var cont = (q * value[n2 + 1][k + 1] + (1 - q) * value[n2 + 1][k]) / R;
var ex = Math.max(K - stock[n2][k], 0);
value[n2][k] = Math.max(ex, cont);
exercise[n2][k] = ex > 0 && ex >= cont - 1e-8;
}
}
return {stock: stock, value: value, exercise: exercise, q: q};
}
function draw() {
var sigma = Number(document.getElementById("ch22-tree-sigma").value);
var r = Number(document.getElementById("ch22-tree-rate").value);
var S0 = Number(document.getElementById("ch22-tree-s0").value);
document.getElementById("ch22-tree-sigma-value").textContent = sigma.toFixed(2);
document.getElementById("ch22-tree-rate-value").textContent = r.toFixed(3);
document.getElementById("ch22-tree-s0-value").textContent = S0.toFixed(0);
var K = 100;
var N = 4;
var T = 1;
var tree = computeTree(S0, K, r, sigma, T, N);
var xC = [], yC = [], textC = [];
var xE = [], yE = [], textE = [];
var lines = [];
for (var n = 0; n <= N; n++) {
for (var j = 0; j <= n; j++) {
var y = 2 * j - n;
var label = "t=" + n + "<br>S=" + tree.stock[n][j].toFixed(2) + "<br>V=" + tree.value[n][j].toFixed(2);
if (tree.exercise[n][j]) {
xE.push(n); yE.push(y); textE.push(label + "<br>exercise");
} else {
xC.push(n); yC.push(y); textC.push(label + "<br>continue");
}
if (n < N) {
lines.push({
x: [n, n + 1, null],
y: [y, 2 * (j + 1) - (n + 1), null],
mode: "lines",
line: {width: 1},
hoverinfo: "skip",
showlegend: false
});
lines.push({
x: [n, n + 1, null],
y: [y, 2 * j - (n + 1), null],
mode: "lines",
line: {width: 1},
hoverinfo: "skip",
showlegend: false
});
}
}
}
var traces = lines.concat([
{x: xC, y: yC, text: textC, mode: "markers", name: "continue", marker: {size: 18}, hovertemplate: "%{text}<extra></extra>"},
{x: xE, y: yE, text: textE, mode: "markers", name: "exercise", marker: {size: 18, symbol: "diamond"}, hovertemplate: "%{text}<extra></extra>"}
]);
var layout = {
title: "Four-step Snell envelope tree for an American put",
xaxis: {title: "time step", dtick: 1},
yaxis: {title: "tree level", showticklabels: false},
legend: {orientation: "h"},
margin: {l: 45, r: 20, t: 55, b: 45}
};
Plotly.newPlot("ch22-snell-tree-demo", traces, layout, {responsive: true});
}
if (window.mfPlotlyReady) {
window.mfPlotlyReady(function() {
["ch22-tree-sigma", "ch22-tree-rate", "ch22-tree-s0"].forEach(function(id) {
document.getElementById(id).addEventListener("input", draw);
});
draw();
});
}
})();
</script>
:::
## 22.10 American Calls Without Dividends
A central result in option theory is that an American call on a non-dividend-paying stock should not be exercised early, under the standard assumptions of the Black--Scholes model.
::: {.theorem}
## No early exercise for a non-dividend-paying American call
Suppose the stock pays no dividends, interest rates are nonnegative, and the holder can trade the stock and bond frictionlessly. Then an American call option has the same value as the corresponding European call option.
:::
::: {.proof}
Let $C^{\mathrm{Euro}}(t,S)$ be the European call value with strike $K$ and maturity $T$. By put-call parity,
$$
C^{\mathrm{Euro}}(t,S)=P^{\mathrm{Euro}}(t,S)+S-Ke^{-r(T-t)}.
$$
Since the European put value is nonnegative,
$$
C^{\mathrm{Euro}}(t,S)\ge S-Ke^{-r(T-t)}.
$$
If $r\ge 0$, then $Ke^{-r(T-t)}\le K$, so
$$
S-Ke^{-r(T-t)}\ge S-K.
$$
Thus
$$
C^{\mathrm{Euro}}(t,S)\ge S-K.
$$
Since the call payoff from immediate exercise is $(S-K)^+$, the continuation value is at least the exercise value. Therefore early exercise is not optimal.
:::
The financial intuition is simple. Exercising the call early requires paying $K$ earlier than necessary. When the stock pays no dividends, holding the option preserves upside exposure while delaying the strike payment.
For dividend-paying stocks, early exercise of a call may become optimal just before an ex-dividend date, because the option holder does not receive the dividend unless the option is exercised and converted into stock ownership.
```{python}
#| label: py-ch22-call-early-exercise-check
#| fig-cap: "American and European calls are nearly equal in a non-dividend CRR model"
for N in [25, 50, 100, 200]:
amer_call = crr_option_price(100, 100, 0.05, 0.25, 1.0, N, option="call", american=True)
euro_call = crr_option_price(100, 100, 0.05, 0.25, 1.0, N, option="call", american=False)
print(N, amer_call, euro_call, amer_call - euro_call)
```
## 22.11 Replication and Hedging in the Continuation Region
At a node where continuation is optimal, an American option behaves locally like a European derivative. In a binomial tree, if the next-step values are $V^u$ and $V^d$, the hedge ratio is
$$
\Delta_n(j)=\frac{V^u-V^d}{S^u-S^d}.
$$
The bond holding is determined by
$$
\beta_n(j)B_n
=
V_n(j)-\Delta_n(j)S_n(j).
$$
At an exercise node, the option value equals the payoff. The holder stops, so the continuation hedge is no longer relevant after exercise.
This is an important conceptual point. American option pricing combines two operations:
1. **dynamic replication** in the continuation region;
2. **optimal stopping** at the exercise boundary.
```{python}
#| label: py-ch22-hedge-ratio-node
#| fig-cap: "One-step hedge ratio at the root of a two-step American put tree"
S0, K, r, sigma, T, N = 100, 100, 0.05, 0.25, 1.0, 2
dt = T / N
u = math.exp(sigma * math.sqrt(dt))
d = 1 / u
R = math.exp(r * dt)
q = (R - d) / (u - d)
# terminal payoffs
S2 = np.array([S0 * d**2, S0 * u * d, S0 * u**2])
V2 = np.maximum(K - S2, 0)
# values at time 1, nodes down and up
S1 = np.array([S0 * d, S0 * u])
cont1 = np.array([
((1 - q) * V2[0] + q * V2[1]) / R,
((1 - q) * V2[1] + q * V2[2]) / R,
])
ex1 = np.maximum(K - S1, 0)
V1 = np.maximum(ex1, cont1)
Delta0 = (V1[1] - V1[0]) / (S0 * u - S0 * d)
V0_cont = ((1 - q) * V1[0] + q * V1[1]) / R
V0 = max(K - S0, V0_cont)
print("V1 down/up:", V1)
print("root continuation value:", V0_cont)
print("American value V0:", V0)
print("root hedge ratio Delta0:", Delta0)
```
## 22.12 Continuous-Time View: Variational Inequality
In continuous time, the American option value is no longer obtained by a finite backward recursion. In the Black--Scholes model, the American put value $V(t,S)$ satisfies a free-boundary problem.
The option value must dominate the exercise payoff:
$$
V(t,S)\ge K-S.
$$
In the continuation region, where $V(t,S)>K-S$, the option satisfies the Black--Scholes PDE:
$$
V_t+\frac12\sigma^2S^2V_{SS}+rSV_S-rV=0.
$$
In the exercise region, where $V(t,S)=K-S$, the holder exercises immediately.
These two conditions can be combined into the variational inequality
$$
\max\left\{
K-S-V,
V_t+\frac12\sigma^2S^2V_{SS}+rSV_S-rV
\right\}=0.
$$
Equivalently, using the payoff $g(S)=(K-S)^+$, the complementarity conditions are
$$
V\ge g,
$$
$$
\mathcal L V-rV\le 0,
$$
and
$$
(V-g)(\mathcal L V-rV)=0,
$$
where
$$
\mathcal L V=V_t+\frac12\sigma^2S^2V_{SS}+rSV_S.
$$
::: {.remark}
## Free boundary
The boundary between exercise and continuation is unknown in advance. It is part of the solution. This is why American options are harder than European options.
:::
## 22.13 Least-Squares Monte Carlo Preview
Binomial trees work well for one-dimensional American options. In high-dimensional problems, such as options depending on several assets, trees become expensive. A common simulation-based approach is the Longstaff--Schwartz least-squares Monte Carlo method.
The idea is to approximate the continuation value by regression. At a decision time $t_n$, the theoretical continuation value is
$$
C_n=\mathbb E^{\mathbb Q}\left[e^{-r\Delta t}V_{n+1}\mid S_n\right].
$$
In least-squares Monte Carlo, we simulate many paths and approximate
$$
C_n\approx a_0+a_1S_n+a_2S_n^2+\cdots,
$$
or, more commonly, by basis functions of moneyness. The exercise decision compares the payoff $g(S_n)$ with the estimated continuation value.
This method introduces statistical learning into American option pricing. The model must learn a conditional expectation from simulated data.
```{python}
#| label: py-ch22-lsm-preview
#| fig-cap: "A small least-squares Monte Carlo preview for an American put"
import numpy as np
import math
rng = np.random.default_rng(7243)
def lsm_american_put(S0=100, K=100, r=0.05, sigma=0.25, T=1.0, steps=40, paths=20000):
dt = T / steps
disc = math.exp(-r * dt)
Z = rng.normal(size=(paths, steps))
S = np.empty((paths, steps + 1))
S[:, 0] = S0
drift = (r - 0.5 * sigma**2) * dt
vol = sigma * math.sqrt(dt)
for n in range(steps):
S[:, n + 1] = S[:, n] * np.exp(drift + vol * Z[:, n])
cashflow = np.maximum(K - S[:, -1], 0.0)
for n in range(steps - 1, 0, -1):
cashflow *= disc
payoff = np.maximum(K - S[:, n], 0.0)
itm = payoff > 0
if np.sum(itm) > 10:
x = S[itm, n] / K
y = cashflow[itm]
A = np.column_stack([np.ones_like(x), x, x**2])
coef, *_ = np.linalg.lstsq(A, y, rcond=None)
continuation = coef[0] + coef[1] * x + coef[2] * x**2
exercise = payoff[itm] > continuation
idx = np.where(itm)[0]
cashflow[idx[exercise]] = payoff[idx[exercise]]
return float(np.mean(cashflow * disc))
print("LSM American put estimate:", lsm_american_put())
print("CRR American put benchmark:", crr_option_price(100, 100, 0.05, 0.25, 1.0, 300, option="put", american=True))
```
## 22.14 Common Mistakes
::: {.callout-warning}
## Mistake 1: treating American value as a terminal expectation
The expression
$$
\mathbb E^{\mathbb Q}\left[e^{-rT}g(S_T)\right]
$$
prices the corresponding European payoff, not the American option.
:::
::: {.callout-warning}
## Mistake 2: using future information in the exercise rule
A valid exercise rule must be a stopping time. It cannot depend on future prices.
:::
::: {.callout-warning}
## Mistake 3: forgetting the maximum in backward induction
The recursion for an American option is not just discounted expectation. It is
$$
V_n=\max\{\text{exercise value},\text{continuation value}\}.
$$
:::
::: {.callout-warning}
## Mistake 4: assuming early exercise is always valuable
The right to exercise early cannot reduce value, but it may have zero value. For a non-dividend-paying call under standard assumptions, the American and European values are equal.
:::
## 22.15 AI-Assisted Learning Components
### AI prompt: explain the Snell envelope
Ask an AI tool:
> Explain the Snell envelope for American option pricing in discrete time. Use the words stopping time, continuation value, exercise value, and supermartingale. Then give a two-step binomial example.
Check whether the answer correctly distinguishes the payoff process $Z_n$ from the value process $V_n$.
### AI prompt: audit an exercise rule
Ask:
> A trader says: "I will exercise my American put at the time when the stock price reaches its lowest value before maturity." Is this a valid stopping time? Explain mathematically.
A correct answer should say no, because knowing the global minimum before maturity requires future information.
### AI prompt: code review
Give an AI tool your binomial American option code and ask:
> Check this code for the following mistakes: missing discount factor, wrong risk-neutral probability, reversing up/down node ordering, using European recursion instead of American recursion, and failing to validate $0<q<1$.
Then verify the comments manually. AI feedback is useful, but the final responsibility for mathematical correctness remains with the modeler.
### AI prompt: compare PDE and tree viewpoints
Ask:
> Compare the binomial tree recursion for an American put with the Black--Scholes variational inequality. Explain how the exercise boundary appears in both approaches.
The answer should connect the discrete maximum operator with the continuous complementarity condition.
## 22.16 Exercises
### Conceptual exercises
1. Explain the difference between a European, Bermudan, and American option.
2. What is a stopping time? Give one valid and one invalid exercise rule.
3. Explain why an American option value is an optimal stopping value rather than a single expectation.
4. Define the exercise value and continuation value at a node of a binomial tree.
5. Why is the Snell envelope a supermartingale after discounting?
6. Explain why the exercise boundary is an output of the pricing problem, not an input.
### Mathematical exercises
7. Prove that the Snell envelope dominates the discounted payoff process.
8. Prove that the Snell envelope is a supermartingale.
9. Prove the one-step American put recursion directly from the definition of optimal stopping.
10. In a one-step binomial model, compute the American call and put values for $S_0=100$, $K=95$, $u=1.1$, $d=0.9$, and $R=1.02$.
11. Show that the American option value is always at least the European option value with the same payoff and maturity.
12. Use put-call parity to explain why a non-dividend-paying American call should not be exercised early.
### Computational exercises
13. Write a Python function that prices an American call or put by a CRR tree.
14. Modify the function to return the early-exercise boundary.
15. Plot American and European put values as a function of $S_0$.
16. Study how the early-exercise premium changes as $r$ increases.
17. Study how the early-exercise premium changes as $\sigma$ increases.
18. Compare binomial American put prices for $N=25,50,100,200,400$.
19. Implement the least-squares Monte Carlo algorithm with three different basis choices.
20. Create unit tests for your American option code using limiting cases such as $T=0$, $\sigma\approx 0$, or very deep in-the-money options.
### AI-assisted exercises
21. Ask an AI tool to derive the American option backward recursion. Identify any missing assumptions.
22. Ask an AI tool whether early exercise is optimal for American calls. Check whether it mentions dividends.
23. Ask an AI tool to explain the variational inequality. Rewrite the explanation in your own mathematical language.
24. Ask an AI tool to generate a binomial American put implementation. Test it against your own implementation and report any differences.
## 22.17 Chapter Summary
American option pricing is the first place in this book where pricing becomes an explicit **control problem**. The holder controls the exercise time, but the exercise time must be a stopping time adapted to the market information.
The main mathematical structure is the Snell envelope. In discrete time, it is computed by backward induction:
$$
V_n=\max\left\{Z_n,\frac{1}{R}\mathbb E^{\mathbb Q}[V_{n+1}\mid\mathcal F_n]\right\}.
$$
This recursion simultaneously gives the price and the optimal exercise rule. In continuous time, the same idea becomes a free-boundary problem or variational inequality.
For students in applied mathematics and statistics, American options are especially valuable because they connect conditional expectation, martingales, dynamic programming, regression, numerical analysis, and stochastic control.