American Options and Longstaff-Schwartz

Finance

The Black-Scholes formula and the Monte Carlo techniques for vanilla EUROPEAN options assume exercise happens only at expiry. AMERICAN options can be exercised at any time up to expiry, which adds a non-trivial OPTIMAL STOPPING problem on top of the pricing: at every moment, decide whether to exercise now or continue holding. The early-exercise premium can be substantial — 15-20% of the European price for typical in-the-money puts — and capturing it correctly is the central challenge of practical equity derivatives pricing.

The classical approach for American options is the BINOMIAL TREE (Cox-Ross-Rubinstein 1979): discretize time and price into a lattice, work backward computing the value at each node as max(intrinsic, discounted expected continuation). Clean, simple, exact in the continuous limit. But trees scale poorly to multi-asset problems or path-dependent payoffs; their state-space blows up. The modern alternative is LONGSTAFF-SCHWARTZ MONTE CARLO (LSM, 2001) — simulate paths forward, then regress backward to estimate continuation values. LSM scales to high dimensions and handles arbitrary path-dependent features. It is the standard tool for American-style and Bermudan options in production code.

The optimal stopping problem

Consider an American put with strike $K$ on a stock $S_{t}$ . At any time $t \in [0, T]$ , exercising pays $(K - S_{t})^{+}$ immediately. The optimal exercise rule: at time $t$ , exercise if and only if the IMMEDIATE PAYOFF EXCEEDS the CONTINUATION VALUE,

V_{t} = max ((K - S_{t})^{+}, E_{t} [e^{- r Δ t} V_{t + Δ t}]) .

The challenge: the continuation value $E_{t} [\dots]$ depends on the optimal policy at all FUTURE times. The recursion runs BACKWARD in time from $t = T$ (where $V_{T} = (K - S_{T})^{+}$ ) to $t = 0$ . For a binomial tree, this is straightforward — each node has finitely many children. For Monte Carlo with general path-dependence, computing the conditional expectation along each simulated path is the hard part.

The Longstaff-Schwartz idea

Approximate $E_{t} [e^{- r Δ t} V_{t + Δ t} ∣ S_{t}]$ by a REGRESSION of the realized discounted future cash-flows against basis functions of $S_{t}$ . Specifically, at each backward time step:

Identify the paths that are IN-THE-MONEY at $t$ (where exercise might be optimal — out-of-the-money paths automatically continue).
For each such path, compute the DISCOUNTED FUTURE CASH-FLOW under the current exercise policy (which was determined in previous backward steps).
REGRESS those cash-flows on a polynomial basis of $S_{t}$ (typically ${1, S, S^{2}}$ or Laguerre polynomials).
The fitted value at each path is the ESTIMATED continuation value at that path.
Set the exercise decision: exercise if $(K - S_{t})^{+} > \hat{V}_{cont}$ , otherwise continue.

Once all backward steps are done, each path has a sequence of cash-flows (zeros, plus one positive payoff at the time of exercise — or at expiry if never exercised). Discount and average across paths for the LSM price estimate.

Why does this work? The key insight: the conditional expectation $E_{t} [Y ∣ S_{t}]$ is the function of $S_{t}$ that minimizes $E [(Y - g (S_{t}))^{2}]$ . Empirically, this is exactly what least-squares regression of $Y$ on a basis of $S_{t}$ computes. As the number of basis functions and paths grows, the regression-estimated continuation value converges to the true conditional expectation, and the LSM price converges to the true American price.

Convergence properties

LSM has two error sources:

Regression error: the polynomial basis must be rich enough to represent the true continuation value. In practice 3-5 polynomial basis functions suffice for most single-asset American problems; for multi-asset or path-dependent problems, more basis functions or tensor products are needed.
Monte Carlo error: $O (1/ n_{paths})$ . With 50,000-200,000 paths, standard errors of 0.5-1 cent on a $5 option are typical.

BIAS: LSM as stated above produces a SLIGHT UNDER-estimate of the American price (the policy estimated from regression isn't quite optimal, so it's sub-optimal exercise; sub-optimal exercise gives a lower payoff). The bias can be addressed by various techniques (separate samples for the policy and the valuation, the "dual" formulation of Rogers-Haugh-Kogan that gives upper bounds), but for production pricing the modest under-bias is typically acceptable.

Code

# Longstaff-Schwartz Monte Carlo for an American put option.
#   1. Simulate stock paths under risk-neutral measure (GBM).
#   2. Step backward in time: at each step, regress the discounted
#      future cash-flow on a polynomial basis of the current stock price,
#      to estimate the CONTINUATION VALUE.
#   3. Exercise where intrinsic value > continuation value;
#      otherwise hold.
#   4. Discount the resulting cash-flows to time zero, average over paths.

import numpy as np
from scipy.stats import norm

def lsm_american_put(S0, K, T, r, sigma, N=50, n_paths=50000, seed=0):
    rng = np.random.default_rng(seed)
    dt = T / N

    # Simulate paths
    Z = rng.standard_normal((n_paths, N))
    S = np.zeros((n_paths, N + 1))
    S[:, 0] = S0
    for t in range(1, N + 1):
        S[:, t] = S[:, t-1] * np.exp((r - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*Z[:, t-1])

    payoff = np.maximum(K - S, 0)
    cf = np.zeros_like(payoff)
    cf[:, -1] = payoff[:, -1]                  # exercise at expiry if ITM
    discount = np.exp(-r * dt)

    for t in range(N - 1, 0, -1):
        itm = payoff[:, t] > 0                 # regress only on ITM paths
        if not np.any(itm):
            continue
        x = S[itm, t]
        # Discount each future cash flow back to this time step
        future_cf = np.sum(cf[itm, t+1:] *
                          np.cumprod(np.full(N - t, discount)), axis=1)
        # Polynomial basis: 1, S, S²
        A = np.column_stack([np.ones_like(x), x, x**2])
        coef, *_ = np.linalg.lstsq(A, future_cf, rcond=None)
        continuation = A @ coef
        # Exercise where intrinsic > continuation
        exercise = payoff[itm, t] > continuation
        idx = np.where(itm)[0][exercise]
        cf[idx, t]      = payoff[idx, t]
        cf[idx, t+1:]   = 0                    # cancel future cash flows

    # Discount all cash flows back to time 0
    times = np.arange(1, N + 1) * dt
    return np.mean((cf[:, 1:] * np.exp(-r * times)).sum(axis=1))

def bs_put(S, K, T, r, sigma):
    """European put for comparison."""
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    return K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)

# Standard benchmark from Longstaff & Schwartz 2001 Table 1
# American put, S0=36, K=40, T=1, r=6%, sigma=20%, target ≈ 4.478
print(f"American put (S0=36, K=40, T=1.0, r=6%, sigma=20%):")
price_am = lsm_american_put(S0=36, K=40, T=1.0, r=0.06, sigma=0.20,
                            N=50, n_paths=50000, seed=0)
print(f"  LSM price (50k paths):  {price_am:.4f}")
print(f"  Benchmark (LS 2001):    4.478")

price_eu = bs_put(36, 40, 1.0, 0.06, 0.20)
print(f"  European put:           {price_eu:.4f}")
print(f"  Early-exercise premium: {price_am - price_eu:.4f}  "
      f"({100*(price_am - price_eu)/price_eu:.1f}% of EU price)")

# Verify across different moneyness
print(f"\nLSM across moneyness (T=1, r=6%, sigma=20%):")
print(f"  {'S0':>4s}  {'European':>10s}  {'American':>10s}  {'premium':>10s}")
for S0 in [36, 38, 40, 42, 44]:
    pa = lsm_american_put(S0=S0, K=40, T=1.0, r=0.06, sigma=0.20,
                          N=50, n_paths=20000, seed=0)
    pe = bs_put(S0, 40, 1.0, 0.06, 0.20)
    print(f"  {S0:>4d}  {pe:>10.4f}  {pa:>10.4f}  {pa - pe:>10.4f}")

Output:

American put (S0=36, K=40, T=1.0, r=6%, sigma=20%):
  LSM price (50k paths):  4.4726
  Benchmark (LS 2001):    4.478
  European put:           3.8443
  Early-exercise premium: 0.6283  (16.3% of EU price)

LSM across moneyness (T=1, r=6%, sigma=20%):
    S0    European    American     premium
    36      3.8443      4.4654      0.6211
    38      2.8519      3.2487      0.3968
    40      2.0664      2.3164      0.2500
    42      1.4646      1.6122      0.1476
    44      1.0181      1.1024      0.0843

Three things to read off. (1) The benchmark case ( $S_{0} = 36$ , $K = 40$ , deeply ITM put) gives LSM price 4.473 against the published binomial-tree benchmark of 4.478 — within 0.005, well below standard Monte Carlo error at 50k paths. (2) The early-exercise premium is 0.63 — about 16% of the European price. For deep-ITM puts on dividend-free stocks, early exercise is often optimal because exercise lets you collect the strike $K$ NOW and earn interest $rK$ per year on it, while delay loses that interest. (3) The premium shrinks rapidly with moneyness: at $S_{0} = 44$ (OTM put), the early-exercise premium is only 0.08 (8% of European). For OTM puts, the put's value comes almost entirely from the option's potential to go ITM, which exercise destroys; rational exercise never happens. The early-exercise PREMIUM is a moneyness-dependent property.

When NOT to use LSM

Single-asset American with simple payoff: just use a binomial or trinomial tree. Faster, easier to debug, easier to compute Greeks.
European options: closed-form (Black-Scholes) or simpler Monte Carlo without the early-exercise machinery.
Very high-dimensional state space: LSM's regression scales poorly in dimension. For exotic basket options or convertibles with many factors, more advanced techniques are needed (deep learning for stopping policies, finite-difference PDE solvers).

Generalizations and modern variants

Bermudan options: exercise allowed only at discrete dates (typical for OTC structured products). LSM applies directly; the early-exercise decision is checked only at the allowed dates.
Path-dependent payoffs: include path-dependent quantities (running maximum for lookback options, average for Asian options) as regressors alongside the spot. LSM handles them naturally.
Stochastic interest rates / dividends: include the relevant state variables as regressors.
Deep LSM (Becker-Cheridito-Jentzen 2019): replace polynomial regression with a neural network. Better for high-dimensional or non-smooth continuation surfaces; standard tool in modern derivative pricing libraries.
Stochastic mesh methods: alternative MC framework using importance-sampled cross-paths. Less common but gives upper bounds for free.

What practical pricing systems do

A bank's exotic-derivatives pricing system typically has both engines:

FINITE-DIFFERENCE PDE solver for 1-3D problems with high accuracy requirements (American options on a single underlying, Bermudan swaptions in short-rate models).
LSM Monte Carlo for higher-dimensional problems (basket Asians, convertibles with credit and rates, structured products).

Greeks are computed by FINITE DIFFERENCES on the Monte Carlo (bumping the input and re-running) or by PATHWISE / LIKELIHOOD RATIO methods that compute derivatives along the simulated paths themselves. The Greeks are the operationally important output; getting them efficient and stable is a substantial engineering exercise.

Monte Carlo option pricing — the simulation machinery; LSM extends it with the regression-based stopping rule.
Black-Scholes model — the European reference; American premium is American minus European.
Greeks and delta hedging — for American options, Greeks come from finite-difference bumps on the LSM engine.
Heston model — stochastic vol extension; LSM still applies.