American Options (Longstaff-Schwartz)

A European option is simple: you buy the right to sell a stock at a fixed price on one specific date in the future. If the stock is above that price on expiry day, you exercise; otherwise you don't.

An American option is harder. You have the same right, but you can exercise it any day between now and expiry. Every morning you must ask: is it better to exercise today and pocket the payoff, or hold on in case tomorrow's price is even better?

That question — exercise now or wait — cannot be answered by looking at today's price alone. You need to estimate the continuation value: how much the option is worth if you keep holding it. And that value depends on all the random paths the stock might take in the future.

This is exactly what the Longstaff-Schwartz algorithm (LSM, 2001), invented by Francis Longstaff and Eduardo Schwartz, is designed to do. It simulates thousands of random price paths, then uses least-squares regression — the same tool you use to fit a line through scattered data — to estimate the continuation value at each point along each path. The result is a decision rule: exercise if the immediate payoff exceeds the estimated continuation value, hold otherwise.

The algorithm is a solved method, not an open problem. LSM is the industry standard for American option pricing and is used daily in quantitative finance.

Below is a simplified LSM simulation. The stock starts at $100, the strike price is $100 (a put option: you profit when the stock falls below the strike). There are 5 time steps and a small number of paths.

<!-- {{c_html_comment}} -->
<div class="controls">
  <label>{{lbl_paths}} <input id="nPaths" type="range" min="4" max="12" value="8" step="1"> <span id="nPathsVal">8</span></label>
  <label>{{lbl_strike}} lt;input id="strike" type="range" min="90" max="110" value="100" step="1"> <span id="strikeVal">100</span></label>
</div>
<canvas id="chart" width="560" height="220"></canvas>
<div id="status" class="status"></div>
<div class="btns">
  <button id="runBtn" type="button">{{btn_run}}</button>
  <button id="resetBtn" type="button" class="ghost">{{btn_reset}}</button>
</div>
<div id="legend" class="legend">
  <span class="dot exercised"></span>{{leg_exercised}}
  <span class="dot held"></span>{{leg_held}}
  <span class="dot strike-line"></span>{{leg_strike}}
</div>

/* {{c_css_comment}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: .5rem; }
.controls { display: flex; gap: 1.2rem; flex-wrap: wrap; margin-bottom: .5rem; font-size: .85rem; }
label { display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 100px; }
canvas { display: block; width: 100%; max-width: 560px; border: 1px solid #cdd9e3; border-radius: 8px; margin-bottom: .4rem; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.4em; margin-bottom: .3rem; }
.status.ok { color: #0a7d33; }
.status.info { color: #1d3557; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-bottom: .4rem; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.legend { display: flex; align-items: center; gap: .9rem; font-size: .8rem; flex-wrap: wrap; }
.dot { display: inline-block; width: 14px; height: 4px; border-radius: 2px; margin-right: 3px; vertical-align: middle; }
.dot.exercised { background: #e63946; }
.dot.held { background: #457b9d; }
.dot.strike-line { background: #999; border-top: 2px dashed #999; height: 0; width: 18px; }

// Code not found

At each time step the algorithm regresses the immediate payoff (if positive) against the simulated stock price to estimate the continuation value. A path exercises at the first step where the immediate payoff exceeds the estimated continuation value. Notice how different paths exercise at different times — or not at all. This is the key insight of LSM: early exercise is path-dependent, and regression approximates the value of waiting.

LSM looks deceptively simple but hides several layers of computational thinking.

The backwards induction structure. At expiry, the payoff is known exactly. LSM works backwards in time: at each step $t$ it uses the paths that are in the money (immediate payoff $> 0$) to regress payoff against the current stock price $S_t$, estimating the continuation value $\hat{C}(S_t)$. A path exercises at step $t$ if the immediate payoff exceeds $\hat{C}(S_t)$.

Regression and basis functions. The continuation value is approximated by a linear combination of basis functions — typically low-degree polynomials like $1, S_t, S_t^2$. The coefficients are fitted by ordinary least squares at each time step. More basis functions give a better fit but increase cost.

Cost. With $N$ simulated paths, $T$ time steps, and $B$ basis functions, the dominant cost is $O(N \cdot T \cdot B^2)$ — roughly, fitting a small regression at each of $T$ steps across $N$ paths. In practice $N$ is tens of thousands and $T$ is dozens to hundreds.

Bias and variance. The regression introduces a small downward bias (the estimated continuation value is a lower bound on the true one). Increasing $N$ reduces variance; increasing $B$ reduces bias but risks overfitting. The method converges to the true price as $N \to \infty$ with appropriate basis functions.

Why not dynamic programming? A grid-based approach works for one underlying asset but suffers the curse of dimensionality: the state space explodes exponentially when the payoff depends on multiple assets (e.g., basket options). Monte Carlo scales to hundreds of dimensions; grid methods do not. This is the key advantage of Monte Carlo over deterministic methods for high-dimensional option pricing.

"Hold or exercise now?" is one of the most universal decision problems in finance and beyond:

• American equity options: millions of contracts traded daily on exchanges like the CBOE are American-style — LSM or its variants price them and manage their risk.
• Bermudan options: exercise is allowed on a discrete set of dates (e.g., once a month). LSM handles these naturally since it already works on a discrete time grid.
• Mortgage prepayment: homeowners can repay their mortgage early when interest rates drop. Modelling this as an optimal stopping problem uses exactly the same regression trick.
• Real options analysis: a company deciding whether to delay, expand or abandon a capital project faces an American-style option on real assets. LSM is used in corporate finance and energy project valuation.
• Executive stock options: employees can exercise vesting shares during a window — the optimal exercise policy is computed with variants of LSM.

The deeper pattern is optimal stopping: given a stochastic process, when should you stop to maximize expected reward? LSM turns this into a sequence of regressions, making it tractable wherever Monte Carlo simulation is feasible.

The Longstaff-Schwartz algorithm is a beautiful meeting point of simulation, linear algebra, and financial economics. The insight — that the optimal exercise boundary can be learned by regressing future cash flows against today's state — turned an apparently intractable high-dimensional problem into a handful of ordinary least-squares fits.

Every morning, quant desks around the world run variants of LSM to price American options, stress-test portfolios, and hedge risk. The next time you hear that someone "exercised their option early," there is a good chance a backward-induction regression decided exactly when that moment should be.