LSMC with Signatures: The Hectic Spectacle of Pricing American Options

Quant Club, IIT Kharagpur 13 min read · Nov 6, 2025

At the end of this blog, you should be able to answer these 4 questions:

1. What am I even talking about, and why should you care?
2. How do we price European Options then, and why won’t it work for American options?
3. So what can we do for American Options?
4. And finally, how are signatures so much better?

So let’s get started.

A Primer On Options

(Feel Free to skip this if you know them.)

Options are one of the most traded derivative types, individually or as part of strategies. Sounds complicated? Well, they are just a financial tool for realizing a very simple idea: “I want to buy/sell stuff tomorrow at today’s price.”

In stock markets, options give you the choice to buy/sell some shares at a pre-fixed price, regardless of what the current share price is. Can you see that the value of this choice is dependent on the current share price (among other variables)? In other words, the price of this value is a derivative of the current share price.

Options are one among a plethora of share derivatives. More broadly, derivatives are instruments based on any securities, which are financial assets with some inherent value — debt or ownership.

To be clear, if you have an option, you have the choice (right) to buy/sell the shares, but not the obligation—you can choose not to use (exercise) the option.

So why is this valuable?

• Risk Mitigation: I want to ensure my current investment. Say I have a lakh worth of Blue shares. I now buy an option to sell the shares at this current price, which I will exercise in case the share price drops.
• Strategic Flexibility: More complicated strategies (Straddle, Covered, etc.) help limit your loss. These, while interesting, are beyond the scope of this blog.

PS: Options exist because people have contradictory views on the market. The seller of an option believes the share price will go up, while the buyer of a contract believes the share price will go down; or vice versa. That is why an option seems like a good idea from both their perspectives.

Some Technicalities

• Premium: This refers to the price that you pay the seller for having the right to buy/sell provided by the option. This is the value we will try to estimate in the rest of the blog.
• Strike Price ($K$): The pre-determined price of the shares to be used when the option is exercised. That is, if you have the strike price as 200, that’s the price that will be paid for the shares when (if) the option is exercised, regardless of the underlying stock price (be it 100 or 300).
• Share Price ($S$): This is the current price of a share.
• Call Option: This gives you the right to buy a specified number of shares at a fixed price. They let you “call” for these shares.
• Put Option: This gives you the right to sell a specified amount of shares at a fixed price. They let you “put” down these shares.
• Exercise: This refers to you using the option, i.e., exercising the right to buy/sell.
• Expiry ($T$): All options are time-limited, and time to expiry refers to how long the option is valid/active.
• In-the-money (ITM): When exercising the option will result in a profit. For a call option: $\text{Strike Price} < \text{Share Price}$. For a put option: $\text{Share Price} < \text{Strike Price}$.
• At-the-money (ATM): No profit or loss, i.e., $\text{Strike Price} = \text{Share Price}$.
• Out-of-the-money (OTM): The case when exercising will lead to a financial loss.
• European Option: These options can only be exercised exactly at the time of expiry, and cannot be used/exercised beforehand.
• American Option: These options can be exercised at any time before or on the expiry date.

Can you now guess why American options are harder to price than European options?

Pricing European Options

(Again, feel free to skip if you know about this)

First, let’s consider the case of European options, as they are far simpler due to only “Time to Expiry” being important.

At the time of expiry, the maximum premium you should pay for a European option is the profit that you would get (i.e., the difference between the strike price and share price, or 0 if you’re out of the money). This is obvious. In other words, you pay the strike price for getting the share price.

Now, let’s say there’s some time to expiration, which will make this far more complex:

1. Probability Distribution: You don’t know how the price will change, whether the stock price will increase or not. So you bring in probabilities, specifically the cumulative normal distribution, to take into consideration the possibility of changes in these prices.
2. Discounting: You will also have to discount the strike price, as this price is something that you’ll pay in the future, and thus that amount of money in the future comes to a lesser amount in the present.
3. Volatility ($\sigma$): Typically, higher volatility would imply higher risk, thus reducing the premium available, but options aren’t typical. Recall that options give you a choice (not an obligation), thus if you have a potential loss due to high volatility, you can just choose not to exercise the option. On the other hand, higher volatility also gives you the chance for higher profits! Thus, higher volatility is a major positive driver for option premiums.
4. Risk-Free Rate ($r$): Certain instruments in the market will give you a guaranteed return on investment for minimal risk (think government bonds), and thus the option should perform better than this risk-free interest rate for it to be worth the risk.

Finding out how you combine all of these factors is what won the authors of the Black-Scholes-Merton Model their Nobel Prize.

The Black-Scholes Formula

For a European Call Option:

$C(S, T) = S_t N(d_1) - K e^{-rT} N(d_2)$

Where:

$d_1 = \frac{\ln(S_t/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}$

$d_2 = d_1 - \sigma\sqrt{T}$

• $S$ = Share Price
• $K$ = Strike Price
• $\sigma$ = Volatility of the share (standard deviation of its log-returns)
• $T$ = Time to expiration
• $r$ = Risk-free interest rate
• $N()$ = Cumulative Distribution Function (CDF) of a standard Normal distribution

This looks complicated, but it’s just a quantification of our ideas. The $N(\cdot)$ terms ensure the premium is weighted by probabilities over time. It is highly accurate, easily calculated by computers, and has been the effective industry standard for decades.

Why is there no clean formula for American Options?

Because American options can be exercised at any time, and not only at Expiry. This allows people to exercise the options when they feel they have had enough profits from the option (i.e., the value they might get from continuing to hold is expected to be less than the immediate payout).

If you’re trying to use an analytical model here, you would have to find a joint probability density function of the asset path and the exact, unknown stopping time when it will be exercised, and then compute the expectation over a near-infinite number of discrete path points. This is effectively mathematically intractable.

Current Methods for Pricing American Options

Since an exact analytical standard doesn't exist, we rely on numeric approximations:

1. Binomial and Trinomial Trees

Think of this as taking a step back from the continuous world of the Black–Scholes model and turning time into small discrete steps. At each step, the stock price can go up or down (and in a trinomial model, also stay the same).

By building this tree step by step, you can evaluate the option’s value backward from the end—starting at expiry, where you know exactly what the payoff is, and moving back to the present. At each node, you check whether it’s better to exercise the option now or hold it longer. This is known as the early exercise condition.

2. Finite Difference Methods (FDM)

If the binomial tree is like playing chess on a grid, the finite difference method is like turning that grid into a continuous field and solving the underlying Partial Differential Equation (PDE) directly. You discretize both time and stock price, then iteratively solve the PDE backward in time—again checking the early exercise condition at every step.

3. Least Squares Monte Carlo (LSMC)

Monte Carlo is a brute-force simulation approach. Standard Monte Carlo works great for European options because you only need to know the terminal value at expiry. For American options, though, you need to decide when to exercise along the way.

That’s where Least Squares Monte Carlo (LSMC) comes in (the method made famous by Longstaff and Schwartz). It uses regression to approximate the continuation value of the option at each point—i.e., what you’d expect to get if you held the option instead of exercising it now.

By comparing this continuation value with the immediate exercise value, you can determine the optimal exercise strategy across thousands of paths. However, the regression is often done on a simple polynomial basis consisting only of the stock price $S_t$ at that specific point in time. In practice, this completely misses the complex, path-dependent history leading up to that point.

And that’s where Signatures come into play.

Enter Signatures!

In simple terms, a signature is a mathematical way of summarizing an entire path—for example, how a stock price evolved over time—into a sequence of numbers that capture all of its structurally important features.

Formally derived from rough path theory, a signature represents the infinite series of iterated integrals of a path:

• Level 1: Tells you the overall net change of the variables.
• Level 2: Captures corporate interactions and path shapes (like the correlation/lead-lag effects between price and time).
• Higher Levels: Capture increasingly complex path-dependent behavior and memory.

$\mathcal{S}(X)_{s,t} = \left( 1, \int_s^t dX_u, \int_s^t \int_s^u dX_v \otimes dX_u, \dots \right)$

The beauty of signatures is that they can effectively represent any continuous path while generating a fixed vector length, unlike raw time-series data which expands in dimension with every new timestamp. Instead of manually guessing polynomial basis functions for our LSMC regression, we can drop in a few levels of signature terms as rich, automatically generated features.

Code Implementation: LSMC with Signatures

Below is an implementation of the Longstaff-Schwartz algorithm enhanced with path signatures using Python's iisignature library.

Parameters & Setup

• S0: Current stock price
• K: Strike price
• r: Risk-free interest rate
• sigma: Volatility of the stock
• T: Time to maturity (years)
• N: Number of discrete time steps
• M: Number of simulated Monte Carlo paths

First, we divide the Maturity time into N small time intervals, dt, we simulate M possible paths:

Each small interval behaves as a European option, and at the end of the time interval, the stock price can go up or down, and we calculate the option value (specifically its profit — intrinsic value) for that time interval. One of the most common methods of doing this is by using Geometric Brownian Motion (useful for constant volatility) to calculate the option value Generate Geometric Brownian Motion Paths, based on given time-steps, initial price, and volatility. This information is found by statistically analyzing the underlying share of the option, and is available in most trading terminals themselves.

def simulate_gbm_paths(S0, mu, sigma, T, N, M):
 dt = T / N
 paths = np.zeros((M, N + 1))
 paths[:, 0] = S0
 for i in range(1, N + 1):
 z = np.random.randn(M)
 paths[:, i] = paths[:, i - 1] * np.exp((mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * z)
 return paths
paths = simulate_gbm_paths(S0, r, sigma, T, N, M)
def payoff(S):# Amount earned if we exercise the put option immediately
return np.maximum(K - S, 0)

Now, we get into actually using signatures. The code takes an array of all paths up to a time t, generates signatures for all the paths, and returns them.

A few things to note:

Depth-2 iterated integrals basically are double integrals over time and stock price, capturing the trends in how the stock price changes and interacts with its past movements. Each depth 2 iterated integral is summarized with signature vectors(numerical representation of the path) used as features in regression. Higher depth can be tried, but the complexity exponentially increases.

depth = 2
sig_dim = iisignature.siglength(2, depth) # A function that tells us the size of signatures generated (2 here refers to 2 variables - price & time).
def get_signatures_up_to(paths, t):
 M = paths.shape[0]
 time_grid = np.linspace(0, t * dt, t + 1)
 X = np.zeros((M, sig_dim))
 for i in range(M):
 path_2d = np.column_stack([time_grid, paths[i, :t + 1]])
 X[i] = iisignature.sig(path_2d, depth) # Calculates the signatures
 return X

We now find all in-the-money paths and linearly regress them to find the continuation values for all the paths. Then see if early exercise is a good option or not, and finally, average over all paths to find the premium. Or in-depth:

We start at the time of maturity, where the option’s value equals its payoff, because no future decisions remain. We then move backward in time, one step at a time, asking at each step: Should we exercise the option now or hold it? For each path, we compute the immediate exercise value (payoff if exercised) and the continuation value (expected discounted value if held). The optimal decision is to take the maximum of these two values. Once we update the value for the current step, we discount it and treat it as the future value for the previous step. Repeating this process backwards allows us to account for early exercise at every step. Using signatures or other path features in the regression allows us to incorporate the entire history of the path, not just the current stock price, improving the accuracy of the continuation value estimate.

cashflows = payoff(paths[:, -1])
exercise_times = np.full(M, N) # to track when each path exercised

for t in range(N - 1, 0, -1):
 # In-the-money paths are calculated since we want to make a profit 
 itm = payoff(paths[:, t]) > 0
 if np.sum(itm) == 0:
 continue
 X = get_signatures_up_to(paths[itm], t)
 Y = cashflows[itm] * discount # discounted future value for the previous step
 # Regress continuation value
 model = LinearRegression().fit(X, Y)
 continuation_values = model.predict(X)
 # Exercise decision
 exercise_values = payoff(paths[itm, t])
 exercise = exercise_values > continuation_values
 # Update cashflows
 exercised_indices = np.where(itm)[0][exercise]
 cashflows[exercised_indices] = exercise_values[exercise]
 exercise_times[exercised_indices] = t
 cashflows *= discount # discount for next step

And we finally output the premium!

price_estimate = np.mean(cashflows)
print(f"Estimated American put price: {price_estimate:.4f}")
Estimated American put price: 6.0607

The image below is a set of sample paths generated by GBM, where red dots represent early exercises.

Press enter or click to view image in full size Where do we go from here? Linear signature models are powerful but capture only the straight line relationships of the signature features. But in reality, the financial markets are not that simple to work with, and that is where Deep Signature Learning comes into the picture. So what do we do?

What we do to understand non-linear relationships in typical Machine learning : use a deep neural network on top of the signature! This allows the model to capture complex, non-linear patterns within the data, adding depth, making it even more powerful.

To explore this further, you can refer to this research paper and its GitHub repository.

Pricing American options under rough volatility using deep-signatures and signature-kernels:https://www.wias-berlin.de/preprint/3172/wias_preprints_3172.pdf

Repository: https://github.com/lucapelizzari/Optimal_Stopping_with_signatures)