Extensions: American Options and Exotic Derivatives

Learning Objectives

By the end of this section, you will be able to:

1. Explain the structural gap between European and American options: a single deterministic exercise time vs. an optimal stopping decision at every instant up to maturity.
2. Argue from first principles when early exercise of a put or call is rational, and why Merton's theorem makes early exercise of an American call on a non-dividend-paying stock irrelevant.
3. Set up the free-boundary problem and recognise the variational inequality as the natural calculus statement of optimal exercise.
4. Build the Cox-Ross-Rubinstein binomial tree by hand and price a 3-step American put backwards through it.
5. Implement the binomial pricer in plain Python and then in PyTorch, getting all the Greeks via one .backward() call.
6. Identify the four canonical exotic payoffs (Asian, barrier, lookback, digital) and read them off a simulated GBM path.
7. Use Monte-Carlo + autograd as a universal pricer for payoffs that have no closed-form Black-Scholes solution.

The Big Picture: Where Black-Scholes Stops

Every option we have priced so far has been a vanilla European call or put: a payoff $\max(S_T - K, 0)$ or $\max(K - S_T, 0)$ paid out at one fixed time $T$. For that single object, Black-Scholes is a beautiful endgame: a one-line PDE, a one-line formula, and Greeks in closed form.

Reality is messier. On any trading screen you will see two adjacent prices that the textbook formula cannot reach:

1. American options — exercise allowed at any instant $t \in [0, T]$, not just at maturity. Now pricing is no longer an evaluation — it is an optimal stopping problem.
2. Exotic options — payoffs that depend on the entire path of the underlying, not just on $S_T$: average prices (Asian), barriers (knock-in / knock-out), running extrema (lookback), all-or-nothing payouts (digitals), and combinations of these.

Both extensions break the closed-form magic of Black-Scholes. But the underlying calculus — Itô, risk-neutral expectation, the heat equation in disguise — is unchanged. What changes is the boundary condition: the PDE now lives on a region whose shape we have to solve for, or it lives on a path-functional that only Monte Carlo can integrate.

American Options: The Right to Wait — or Not

A European call says: "pay me $\max(S_T - K, 0)$ at time $T$." Period. You have one chance.

An American call says: "at any moment $\tau \in [0, T]$ you choose, I will pay you $\max(S_\tau - K, 0)$ and the contract is over." You hold an entire continuum of exercise rights and you must pick which one to use.

Mathematically, the price is the supremum over all stopping times $\tau$ (rules that decide when to exercise using only the information available so far):

Here $g$ is the intrinsic-value function ($g(S) = \max(S-K, 0)$ for a call, $g(S) = \max(K-S, 0)$ for a put). The supremum is taken over all admissible stopping times — that single change is the entire structural difference from Black-Scholes.

Intuition: When Does Early Exercise Pay?

Holding an option is holding a right. The question is whether, at this exact moment, the right is worth more in your hands (continuation value) or in your bank account (intrinsic value $g(S_t)$). The optimal rule is

Otherwise $V_t > g(S_t)$ and you hold on. Three forces drive the trade-off:

For an American put with a positive interest rate $r$, exercise can be rational: cash $K$ received today earns risk-free interest you would have to discount away later. Deep enough in the money, $K - S$ already so big and so unlikely to grow much more, it is optimal to take the money.

For an American call on a non-dividend-paying stock, early exercise is never optimal. The reason — Merton, 1973 — is two-line clean: any time you would exercise, you would receive $S - K$; but you could instead short the stock, lock in $S$, and invest $K$ at the risk-free rate. At maturity you cover, pay $K$ only if the call ends in-the-money, and pocket the carry on $K$ as a bonus. So holding strictly dominates exercising.

Practical rule of thumb. American calls on non-dividend stocks = European calls. American puts ≠ European puts — and the "early-exercise premium" $V^{Am} - V^{Eu}$ grows with $r$ and with how deep the put is in the money.

The following plot makes the geometry visible. Slide $r$ up and watch the American-put curve (orange) peel off the European put (blue) and start hugging the intrinsic line (grey) — and watch the red early-exercise frontier $S^*$ march to the right.

The Free-Boundary Problem

In the Black-Scholes derivation (section-04), the option price $V(S, t)$ satisfied the PDE

For an American option, this PDE only holds in the continuation region $\mathcal{C} = \{(S, t) : V(S, t) > g(S)\}$. In the exercise region $\mathcal{E} = \{(S, t) : V(S, t) = g(S)\}$ the price tracks the intrinsic value $g(S)$, which has its own (different) PDE operator. The boundary between the two — the curve $S^*(t)$ — is not given; it is part of the solution. That is exactly what makes this a free-boundary problem.

The combined statement is the variational inequality:

Read this as two simultaneous statements:

• In the continuation region $V > g$, so the second argument is negative, which forces the first argument to be zero: $\mathcal{L}V = 0$. That is BS.
• In the exercise region $V = g$, so the second argument is zero, which is the binding maximum. The PDE is allowed to fail there — and it does, because the holder has already taken the cash.

Closed-form solutions for this problem do not exist in general. So we switch to a discrete approximation that converges to it: the binomial tree.

Binomial Trees: Discrete Calculus to the Rescue

Chop time $[0, T]$ into $N$ equal steps of length $\Delta t = T/N$. At each step, allow the stock to do exactly one of two things:

• go up by a factor $u = e^{\sigma\sqrt{\Delta t}}$, or
• go down by a factor $d = 1/u = e^{-\sigma\sqrt{\Delta t}}$.

The reason for that exact $u, d$ choice — Cox, Ross, Rubinstein 1979 — is that the resulting two-state distribution matches the mean and variance of the continuous-time GBM over the same $\Delta t$. As $\Delta t \to 0$, the binomial price converges to the Black-Scholes price.

To make the binomial market arbitrage-free, the "up" probability under the risk-neutral measure is forced to be

This is the discrete analogue of Girsanov's theorem: it twists the natural up-probability into one under which the stock grows at the risk-free rate.

Given $u, d, p$, the algorithm is now four lines of pseudo-code:

1. Fill the terminal column with intrinsic payoffs $g(S_{N,j})$.
2. For each earlier slice, compute the continuation value $\text{cont} = e^{-r\Delta t}(p\,V_{up} + (1-p)V_{down})$.
3. Compute the intrinsic value $\text{exer} = g(S_{i,j})$.
4. Set the node value to $V_{i,j} = \max(\text{cont}, \text{exer})$.

That last $\max$ is the discrete variational inequality. Everything else is identical to a European tree.

Interactive: The American-Put Binomial Tree

Play with the controls below. Each node shows the stock price $S_{i,j}$, the American option value $V_{i,j}$, and (if toggled on) the European value $E_{i,j}$. Red nodes are the ones where early exercise dominates — the "exercise region" in miniature.

Things to try:

1. Start with the put. Push $r$ from $5\%$ to $15\%$: more red nodes appear on the lower half. Higher rates make "take the strike now and bank it" more attractive.
2. Switch to the call. On a non-dividend stock there will be no red nodes anywhere — Merton's theorem in pixels.
3. Increase $N$. The European and American values get smoothly closer (more accurate) but their difference — the early-exercise premium — converges to a finite limit. That limit is the analytic premium.
4. Move $S_0$ below $K$. The root's European value $E_0$ and American value $V_0$ both rise, but $V_0$ rises faster. Deep ITM puts are where early exercise matters most.

Worked Example (Try It By Hand)

Price an American put with $S_0 = 100$, $K = 100$, $T = 1$ year, $r = 0.10$ (deliberately high so early exercise really bites), $\sigma = 0.30$, on a $3$-step tree ($N = 3$).

Plain Python: Binomial American Pricer

Here is the same algorithm written in straight Python. The whole American/European distinction lives on a single line — the max(cont, exer) deep inside the inner loop.

T = 1.0, N = 500 → dt = 0.002

σ=0.30, dt=0.002 → u ≈ 1.01345

u ≈ 1.01345 → d ≈ 0.98672

r=0.05 → p ≈ 0.5039

disc ≈ 0.99990

j=N=500, S0=100, u≈1.01345 → S_leaf ≈ 854; put payoff = max(0, 100-854) = 0

i=2, j=1, S0=100, u≈1.01345 → S_21 ≈ 100·1.01345·0.98672 ≈ 99.99

p=0.504, V_up=2.0, V_down=5.0, disc=0.9999 → cont = 0.9999·(0.504·2.0 + 0.496·5.0) ≈ 3.488

K=100, S_ij=99.99 → exer = max(100 - 99.99, 0) ≈ 0.01

1import math
2
3def binomial_american(S0, K, T, r, sigma, N, is_call=False):
4    """
5    Cox-Ross-Rubinstein binomial pricer with early-exercise check.
6    Returns the option value at t=0.
7    """
8    dt   = T / N
9    u    = math.exp(sigma * math.sqrt(dt))
10    d    = 1.0 / u
11    p    = (math.exp(r * dt) - d) / (u - d)
12    disc = math.exp(-r * dt)
13
14    # 1. Terminal payoff at the leaves (i = N).
15    values = [
16        max(S0 * u**j * d**(N - j) - K, 0.0) if is_call
17        else max(K - S0 * u**j * d**(N - j), 0.0)
18        for j in range(N + 1)
19    ]
20
21    # 2. Roll backward through the tree.
22    for i in range(N - 1, -1, -1):
23        new_values = []
24        for j in range(i + 1):
25            S_ij = S0 * u**j * d**(i - j)
26            cont = disc * (p * values[j + 1] + (1 - p) * values[j])
27            exer = max(S_ij - K, 0.0) if is_call else max(K - S_ij, 0.0)
28            new_values.append(max(cont, exer))   # ← early-exercise check
29        values = new_values
30
31    return values[0]
32
33# Worked-example inputs (matches the by-hand walkthrough).
34price = binomial_american(S0=100, K=100, T=1.0, r=0.05,
35                          sigma=0.30, N=500, is_call=False)
36print(f"American put price ≈ {price:.4f}")

Running this prints:

American put price ≈ 9.9444

Compare against the European put under the same inputs: roughly $9.35$. The $\approx 0.6$ gap is the early-exercise premium for these parameters — it gets larger as you push $r$ up or move $S_0$ further below $K$.

PyTorch: Autograd Greeks Through the Tree

On the European side, Greeks were available in closed form. On the American side they are not — the kink at the exercise boundary breaks every analytic derivative formula. So we let autograd do the bookkeeping: write the tree in tensors, call .backward(), and read all the Greeks off.grad.

N=200 → j = tensor([0, 1, 2, ..., 200])

Expected ≈ Delta ≈ -0.45, Vega ≈ 35 for the worked example

1import torch
2
3def binomial_american_torch(S0, K, T, r, sigma, N, is_call=False):
4    """Differentiable binomial American pricer. Inputs are tensors."""
5    dt   = T / N
6    u    = torch.exp(sigma * torch.sqrt(dt))
7    d    = 1.0 / u
8    p    = (torch.exp(r * dt) - d) / (u - d)
9    disc = torch.exp(-r * dt)
10
11    # j-indices for the terminal slice [0, 1, ..., N]
12    j = torch.arange(N + 1, dtype=S0.dtype, device=S0.device)
13    S_term = S0 * u**j * d**(N - j)
14    if is_call:
15        values = torch.clamp(S_term - K, min=0.0)
16    else:
17        values = torch.clamp(K - S_term, min=0.0)
18
19    # Roll backward; everything stays a tensor so autograd sees it.
20    for i in range(N - 1, -1, -1):
21        j_i = torch.arange(i + 1, dtype=S0.dtype, device=S0.device)
22        S_i = S0 * u**j_i * d**(i - j_i)
23        cont = disc * (p * values[1 : i + 2] + (1 - p) * values[0 : i + 1])
24        if is_call:
25            exer = torch.clamp(S_i - K, min=0.0)
26        else:
27            exer = torch.clamp(K - S_i, min=0.0)
28        values = torch.maximum(cont, exer)
29
30    return values[0]
31
32# Inputs as leaves with grad — we want d price / d each of these.
33S0    = torch.tensor(100.0, requires_grad=True)
34K     = torch.tensor(100.0)
35T     = torch.tensor(1.0)
36r     = torch.tensor(0.05)
37sigma = torch.tensor(0.30, requires_grad=True)
38
39price = binomial_american_torch(S0, K, T, r, sigma, N=200, is_call=False)
40price.backward()
41
42print("Price :", price.item())
43print("Delta :", S0.grad.item())    # ∂P/∂S
44print("Vega  :", sigma.grad.item()) # ∂P/∂σ

Expected output (for the worked-example inputs, N = 200):

Price : 9.9407
Delta : -0.4524
Vega  : 35.41

The Exotic Zoo: Payoffs That Remember the Path

A European call cares only about $S_T$ — the terminal value. Most real-world exotics care about the entire path $\{S_t\}_{0 \le t \le T}$. That single change forces Monte Carlo (or path-aware PDE methods) on us, because the BS PDE is path-independent by construction.

Notice the common thread: every payoff is a functional of the path — a number you can only compute after you have observed (or simulated) the whole trajectory. That rules out the "just look at $S_T$" Black-Scholes shortcut.

Interactive: Watch a Path Pay a Payoff

Pick a payoff type, generate a Monte-Carlo path, and watch how each exotic reads the trajectory differently. The pink line is the running arithmetic average (used by Asians); the green line is the running maximum (used by lookbacks); the red dot is the first time the path touches the barrier (used by knock-in / knock-out).

One path tells you very little about the price — but it tells you everything about the structure of the payoff. Generate a new seed a few times and notice:

1. The Asian payoff is almost always smaller than the vanilla payoff on the same path — averaging clips the tails.
2. The up-and-out call evaporates the instant the path pokes above $B$. Push the barrier down to a level near the spot and watch how often the option dies.
3. The lookback's payoff is driven entirely by the highest point the path ever reached. Cranking $\sigma$ up rewards the lookback non-linearly: every jagged spike adds option value.
4. The digital pays either $1$ or $0$ — a binary outcome that depends only on the very last sample.

Monte Carlo + Autograd: The Modern Toolkit

For any payoff $\Phi$ that is a functional of the path, the risk-neutral price is

The Monte-Carlo recipe is three lines:

1. Simulate $n$ independent paths $S^{(1)}, \ldots, S^{(n)}$ under the risk-neutral measure.
2. Evaluate the payoff on each path: $\Phi(S^{(k)})$.
3. Discount and average: $\hat{V}_0 = e^{-rT} \cdot \tfrac{1}{n} \sum_k \Phi(S^{(k)})$.

The standard error decays as $\sigma_\Phi / \sqrt{n}$ — slow, but independent of dimension, which is the entire reason Monte Carlo wins at high dimensions where finite-difference PDE solvers choke.

The classical Greeks question — how do you differentiate $\hat{V}_0$ with respect to the parameters when randomness is baked into the estimator? — used to require three competing techniques:

• Bump-and-reprice: re-run with $\sigma + \varepsilon$, subtract, divide. Easy to code, but each Greek doubles the cost and finite-difference error swamps Monte-Carlo noise.
• Pathwise (IPA): differentiate the path generator and the payoff symbolically. Exact, low-variance — but you write a new estimator per Greek.
• Likelihood-ratio (score): keep the path fixed and differentiate the density. Works for non-smooth payoffs but tends to be noisier.

Autograd automates the pathwise method. You write the price; PyTorch records the graph; .backward() delivers every Greek of every input flagged requires_grad=True. No bumps, no symbolic derivations.

Plain Python: Monte Carlo Asian Call

Here is the simplest possible Monte-Carlo Asian pricer. No NumPy, no vectorisation — just a double loop, so the algorithm is visible. Production code would replace the inner loop with a vectorised tensor pipeline (next code block).

S=100, drift≈0.00018, diff≈0.0189, z=0.42 → S ≈ 100·exp(0.0082) ≈ 100.82

1import math, random
2
3def mc_asian_call(S0, K, T, r, sigma, n_steps=252, n_paths=100_000, seed=0):
4    """Arithmetic-average Asian call by plain Monte Carlo."""
5    random.seed(seed)
6    dt   = T / n_steps
7    drift = (r - 0.5 * sigma * sigma) * dt
8    diff  = sigma * math.sqrt(dt)
9    disc  = math.exp(-r * T)
10
11    payoff_sum = 0.0
12    for _ in range(n_paths):
13        S        = S0
14        avg_sum  = 0.0   # we accumulate S_t and divide once at the end
15        for _ in range(n_steps):
16            z   = random.gauss(0.0, 1.0)
17            S   = S * math.exp(drift + diff * z)
18            avg_sum += S
19        avg = avg_sum / n_steps
20        payoff_sum += max(avg - K, 0.0)
21
22    return disc * payoff_sum / n_paths
23
24price = mc_asian_call(S0=100, K=100, T=1.0, r=0.05,
25                      sigma=0.30, n_paths=200_000, seed=42)
26print(f"Asian call ≈ {price:.4f}")

Sample output:

Asian call ≈ 7.1486

For the same inputs, the European call (BS) is $\approx 14.23$. The Asian is roughly $50\%$ of the European premium — exactly the kind of vol-suppression we predicted.

PyTorch: Pathwise Greeks via Autograd

Now we rewrite the same algorithm in torch with two extra wins: (1) the inner loop disappears — every path is computed in parallel as a slab of tensor math; (2) the Greeks of the Monte-Carlo estimator come out of one backward pass.

n_paths=50_000, n_steps=64 → Z is a tensor of 3,200,000 numbers, allocated in milliseconds

1import torch
2
3def mc_asian_call_torch(S0, K, T, r, sigma, n_steps=64, n_paths=20_000, seed=0):
4    """Vectorised differentiable Monte-Carlo Asian call."""
5    g = torch.Generator(device=S0.device).manual_seed(seed)
6    dt    = T / n_steps
7    drift = (r - 0.5 * sigma * sigma) * dt
8    diff  = sigma * torch.sqrt(dt)
9    disc  = torch.exp(-r * T)
10
11    # Pre-sample all the Gaussians in one shot.
12    Z = torch.randn((n_paths, n_steps),
13                    device=S0.device, dtype=S0.dtype, generator=g)
14
15    # Log-returns per step: shape (n_paths, n_steps).
16    log_steps = drift + diff * Z
17
18    # Build the running sum of S_t along the path via cumulative log-prices.
19    log_S = log_steps.cumsum(dim=1) + torch.log(S0)
20    S     = torch.exp(log_S)          # (n_paths, n_steps)
21    avg   = S.mean(dim=1)             # one average per path
22
23    payoff = torch.clamp(avg - K, min=0.0)
24    return disc * payoff.mean()
25
26S0    = torch.tensor(100.0, requires_grad=True)
27K     = torch.tensor(100.0)
28T     = torch.tensor(1.0)
29r     = torch.tensor(0.05)
30sigma = torch.tensor(0.30, requires_grad=True)
31
32price = mc_asian_call_torch(S0, K, T, r, sigma, n_paths=50_000)
33price.backward()
34
35print("Asian price :", price.item())
36print("Delta       :", S0.grad.item())     # pathwise Δ
37print("Vega        :", sigma.grad.item())  # pathwise ν

Expected output (50,000 paths):

Asian price : 7.1432
Delta       : 0.5174
Vega        : 26.30

Application: Why Trading Desks Care

Every name on this page corresponds to a multi-billion-dollar market:

1. American puts on equity indices. SPX index options are European, but single-stock options listed on US exchanges are American. Every model that prices single-stock options under the BS framework must solve the free-boundary problem above. The early-exercise premium is small but it is real money on a portfolio of millions of contracts.
2. Asian options on commodities. Crude oil, jet fuel, gold, agricultural products — every commodity desk uses arithmetic Asians because they suppress squeeze risk on the settlement date. An airline hedging fuel costs over a month would rather pay on the month-average than on one observation that a producer can corner.
3. Barrier options in FX. EUR/USD knock-outs, double-no-touch, autocallables — barriers are the bread and butter of structured-product desks. The continuous-monitoring assumption baked into the closed-form Reiner-Rubinstein formulas is, in practice, replaced by a discretely-monitored Monte-Carlo simulation.
4. Lookbacks and cliquets in structured products. The retail "principal-protected note" market is full of payoffs of the form "participate in the best $5$ of the last $12$ months," which is a basket of forward-start cliquets — and every one of them is priced by the autograd Monte-Carlo above.
5. Real-options analysis. Outside finance: a mining company deciding when to open a pit, a pharma company deciding when to start a trial, an oil major deciding when to drill — all are American-style optimal-stopping problems on a state variable like commodity price or trial success probability. The same binomial backward induction prices them.

In every case the pattern is the same: describe the payoff as code, simulate or backward-induct, differentiate with autograd, hedge against the Greeks. The elegant closed form of Black-Scholes was the special case where every step had a clean answer; the modern desk is the general case where every step is a tensor operation.

Summary

What we built in this section:

1. American options: pricing is an optimal stopping problem. The natural calculus statement is the variational inequality $\max(\mathcal{L}V, g - V) = 0$ on a free boundary.
2. Binomial tree (Cox-Ross-Rubinstein): the discrete pricer that converges to that PDE/inequality. European-to-American is one extra max(cont, exer) per node — that is the discrete variational inequality made literal.
3. Autograd Greeks: writing the tree (or Monte-Carlo) in PyTorch and calling .backward() gives you Delta, Vega, Theta, Rho, Gamma exactly — no bumping, no symbolic derivation.
4. Exotic options: Asian, barrier, lookback, digital — payoffs that read the entire path, not just $S_T$. Black-Scholes does not reach them in closed form. Monte-Carlo does, and autograd hands you the pathwise Greeks for free.
5. Practical synthesis: in modern code, every option — vanilla, American, exotic, basket, autocallable — is the same six-line skeleton: pick a path generator, evaluate a payoff, mean over paths, discount, call .backward(). The calculus we developed across the chapter is now a tensor program.

That is where the journey through Black-Scholes ends — not at a single formula, but at a programmable framework that absorbs every special case under one autograd-aware skeleton. The next chapter leaves finance behind and turns to a different masterpiece of 19th- century calculus: Maxwell's equations.

Next steps

• Try implementing the Longstaff-Schwartz least-squares Monte Carlo algorithm — it prices American options without a tree, by regressing the continuation value onto path basis functions.
• Add antithetic variates and a geometric-Asian control variate to the torch Monte-Carlo. You will typically see a 5–10× reduction in standard error for the same number of paths.
• Reproduce the Reiner-Rubinstein closed-form for a continuously monitored knock-out call, then compare it against a discretely monitored Monte-Carlo at increasing monitoring frequencies. The gap is real money.
• Calibrate a local-volatility surface to a real options chain by using the autograd binomial pricer as the loss function — every quoted strike contributes one term, and .backward() handles the gradient flow.