💰 quantitative finance

Synthetic American Option Pricing via Jump-HMM-Driven Heston Implied Volatility

This paper introduces an open-source Julia framework that breaks the circular dependency in synthetic option pricing by generating realistic American option prices and implied volatility surfaces through a structural pipeline combining Jump Hidden Markov Models, regime-dependent Heston dynamics, and neural-surrogate-calibrated binomial lattices.

Original authors: Julia Sun, Zheyu Jin, Jiawei Zhang, Jeffrey D. Varner

Published 2026-05-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Julia Sun, Zheyu Jin, Jiawei Zhang, Jeffrey D. Varner

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot how to play a complex game of financial chess. To do this, you need to generate millions of "what-if" scenarios: What if the stock market crashes? What if a tech company has a great earnings report? What if oil prices spike?

To play the game, the robot needs to know the price of "insurance policies" on these stocks (called options). But here is the catch: The price of this insurance depends on something called Implied Volatility (IV). The problem is, in the real world, we only know what IV is after we see the actual prices of these insurance policies. It's a circular trap: You need the price to know the volatility, but you need the volatility to calculate the price. This makes it very hard to create realistic "fake" data to train robots or test strategies.

This paper presents a clever way to break that circle. The authors built a machine that doesn't just guess prices; it builds the prices from the ground up, starting with how stocks actually move.

Here is how their machine works, explained through a few simple analogies:

1. The Engine: The "Mood Ring" Stock Simulator

First, the team built a simulator for stock prices using something called a Jump Hidden Markov Model. Think of this as a mood ring for the entire stock market.

The Mood: The market isn't just "up" or "down." It has different "regimes" or moods. Sometimes it's calm, sometimes it's jittery, and sometimes it's in a panic.
The Jumps: Real stocks don't just move smoothly; they sometimes "jump" (suddenly crash or spike). This simulator is designed to create those sudden jumps and the "clustering" of volatility (where a bad day is often followed by another bad day).
The Connection: It also knows that when one stock panics, its neighbors often panic too (like a ripple effect).

2. The Translator: The "Shape-Shifting" Volatility

Once the simulator creates a path for a stock price, the team needs to translate that into an "Implied Volatility" number. In the past, people had to manually guess what this number should look like.

The Innovation: The authors created a modified Heston model. Imagine a thermostat that controls the heat (volatility) of the market. Usually, a thermostat has a fixed target temperature.
The Smart Thermostat: Their thermostat is smart. It changes its target temperature based on:
- The Mood: Is the market in a panic state? (Turn up the heat).
- Time: How close is the option to expiring?
- The Strike Price: Is the option betting on a huge move or a small one?
- Earnings: Is a company about to release its financial report?
The Result: Because the thermostat is so smart, the "smile" and "skew" (the complex shapes of option prices) appear automatically. You don't need to force them; they emerge naturally from the stock's behavior.

3. The Brain: The "Neural Surrogate"

To make the thermostat even smarter, they used Neural Networks (a type of AI).

The Problem: A simple formula couldn't capture the unique quirks of every single company. A tech company like NVIDIA behaves differently than a bank like JPMorgan.
The Solution: They trained a "Neural Surrogate." Think of this as a specialized translator that learns the specific "personality" of different groups of companies (sectors).
- It learned that Tech stocks have a certain "smile" shape.
- It learned that Healthcare stocks have bumps around FDA approval dates.
- It learned that Energy stocks react to oil supply shocks.
The Hierarchy: They started with one translator for everyone, then realized it was better to have one translator per industry (Sector), and finally, for the biggest companies, a translator just for that specific company. This made the predictions much more accurate.

4. The Calculator: The "Lattice"

Once they have the stock path and the volatility, they need to calculate the final price of the American option (which can be exercised early). They used a Binomial Lattice.

The Metaphor: Imagine a tree where every branch represents a possible future price. The computer walks backward from the end of the tree to the beginning, checking at every branch: "Is it better to cash out now or wait?" This gives the precise price for the option.

The Big Test: Did it Work?

The authors tested their machine in two ways:

The "Earnings" Test: They tried to predict option prices around earnings reports. They found that the machine struggled only when a company announced a surprise earnings result that wasn't on the calendar. If the event was scheduled (like a known earnings date), the machine could predict the price jump perfectly. If the surprise was a total shock, the machine couldn't see it coming (which is realistic!).
The "Forward Simulation" Test: They took a real stock (Goldman Sachs) and ran 1,000 simulated futures.
- They sold "short" options (betting the price wouldn't move too much).
- The Result: The machine showed that while most of the time the bet wins (you keep the premium), the losses are "fat-tailed." This means when you lose, you lose a lot more than you expected, especially on the "Call" side (betting the price goes up). This happened because the machine correctly learned that when stocks crash, volatility spikes, making the insurance much more expensive.

The Conclusion

The paper claims they have built a synthetic data generator. It creates realistic option prices and volatility without needing to look at real market prices first. It breaks the circular dependency by letting the volatility emerge naturally from the simulated stock movements.

They released this as an open-source tool (in the Julia programming language) so others can use it to generate training data for machine learning models, test risk strategies, or simulate market crashes without needing real-world data that might be biased or incomplete.

In short: They built a video game engine for the stock market that generates its own realistic physics (volatility) so you can train your AI to play the game without needing to watch the real world first.

Technical Summary: Synthetic American Option Pricing via Jump-HMM-Driven Heston Implied Volatility

1. Problem Statement

The generation of realistic synthetic option data for machine learning and risk analysis is hindered by a circular dependency: pricing American options typically requires implied volatility (IV) as an input, yet IV is itself an empirical quantity derived from observed option prices. Existing approaches fail to break this cycle:

Parametric models (e.g., SABR, SVI) fit IV surfaces to market quotes but cannot generate new IV dynamics for unobserved conditions.
Local volatility models produce static surfaces consistent with a single cross-section but lack stochastic fluctuations.
Stochastic volatility models (e.g., Heston) generate realistic variance paths but require observed IV or option prices for calibration, reintroducing the circularity.

Consequently, there is a gap in the literature regarding frameworks that generate self-consistent IV surfaces as an emergent output of a structural equity return model without relying on observed option data during simulation.

2. Methodology

The authors propose a three-stage pipeline where IV is an output of a structural model rather than an input. The framework couples a Jump Hidden Markov Model (JumpHMM), a modified Heston stochastic variance process, and a binomial lattice pricer.

Stage 1: Price Path Generation (JumpHMM)
A Jump Hidden Markov Model generates multi-asset price paths that preserve three stylized facts of financial returns: heavy tails, negligible linear autocorrelation, and persistent volatility clustering.

Mechanism: Continuous excess growth rates are discretized into $N$ states via quantile bins of a fitted Laplace distribution.
Dynamics: A hidden state $S_t$ governs the location and scale of a Student-t distribution for returns. Poisson-distributed jumps force the chain into tail states, creating sustained extreme-volatility regimes.
Dependence: Cross-asset dependence is imposed via a Student-t copula, ensuring realistic joint tail events.

Stage 2: Implied Volatility Generation (Modified Heston)
The price paths are converted into IV paths using a modified Heston stochastic variance process.

State-Dependent Mean Reversion: The long-run variance target $\theta$ is not constant but a function of the JumpHMM regime state, days to expiration (DTE), moneyness, and an aggregate market-mood indicator.
Equilibrium Initialization: A central design choice is initializing the variance process at its mean-reversion target ( $v_0 = \theta$ ) for each strike-expiration pair. This ensures the smile, skew, and term structure emerge automatically without external calibration data.
Market Mood: An endogenous market mood signal ( $M_t$ ) is defined as the fraction of tickers in tail states. When multiple assets occupy tail states, $M_t$ rises, elevating $\theta$ and IV across all contracts, creating correlated IV spikes during stress.
Shape Function ( $\psi$ ): The contract-specific adjustment to $\theta$ $θ$ is modeled via a shape function $\psi$ $ψ$ . The authors employ a hierarchy of representations:
1. Parametric Baseline: A five-parameter log-polynomial form.
2. Global Neural Surrogate: A single neural network shared across all tickers.
3. Sector-Specific Neural Surrogate: Separate networks for different sectors (e.g., Technology, Healthcare) to capture sector-specific skew and curvature.
4. Per-Ticker Extension: For data-rich names, the framework supports per-ticker networks.
Event Awareness: The shape function incorporates scheduled event features: signed days to earnings ( $e$ ) and minimum days to earnings for same-sector peers ( $e_{peer}$ ).

Stage 3: American Option Pricing (Binomial Lattice)
The resulting IV surface is used to price American options via a recombining binomial lattice.

Pricing: A Cox-Ross-Rubinstein (CRR) tree is used for the main calibration pipeline.
Greeks Calculation: For forward simulations requiring smooth finite-difference Greeks, a Leisen-Reimer (LR) tree is utilized. The LR construction pins the strike to a node, eliminating the "staircase aliasing" observed in CRR trees when spot or volatility bumps move the strike across node boundaries.

3. Key Contributions

Breaking Circularity: The framework generates self-consistent IV surfaces as an emergent property of equity return dynamics, eliminating the need for observed option data as a calibration target during simulation.
Endogenous Market Mood: The model introduces an endogenous market mood signal derived from the JumpHMM state distribution, allowing for correlated IV spikes during stress events without external data (e.g., VIX).
Hierarchical Shape Calibration: The paper demonstrates a progression from parametric to neural representations, showing that sector-specific neural surrogates significantly outperform global parametric forms in capturing cross-sectional smile geometry.
Event-Driven Generalization: The study isolates scheduled corporate earnings as the dominant source of temporal generalization error and demonstrates that calendar-derived features (earnings distance and peer coupling) can recover a portion of this signal.

4. Results

Calibration Performance (31-Ticker Ladder)

Parametric vs. Neural: Replacing the global parametric shape function with a global neural surrogate reduced the Root Mean Square Error (RMSE) from 12.48% to 11.47% IV.
Sector Specificity: Moving to sector-specific neural networks further reduced RMSE to 10.24% (a 17.9% cumulative improvement over the parametric baseline).
Per-Ticker Gains: On a pooled corpus of 234,549 observations, per-ticker neural networks reduced RMSE to 9.73%, with the largest gains observed in sectors with high within-sector heterogeneity (e.g., Technology, Healthcare).

Temporal Generalization

Earnings Impact: A temporal holdout test revealed a generalization gap of +4.99% IV. When observations within ±3 days of earnings were excluded, the gap vanished (−0.06%), confirming that scheduled earnings events were the sole source of the error.
Feature Recovery: Adding earnings-distance and peer-coupling features to the shape network recovered approximately one-fifth of the generalization gap (reducing test RMSE from 13.03% to 11.98%).
Limitation: The calendar-based indicator captured pre-event IV expansion and sympathy moves but failed to predict post-event IV crushes driven by earnings surprises (e.g., the +2192% EPS surprise for INTC).

Forward Simulation Scenarios

Setup: The framework was applied to simulate 1,000 paths for Goldman Sachs (GS) and Eli Lilly (LLY) options over a 31-day horizon.
Pricing Accuracy: For GS, the model's initial fair value was within the market bid-ask spread. For LLY, the model marked slightly below market due to a specific IV regime mismatch on the capture day, validating the model's sensitivity to IV levels.
Risk Dynamics: The simulations reproduced realistic short-premium asymmetry. Short calls exhibited fatter left-tail losses than short puts despite receiving smaller premiums, driven by the negative skew encoded in the per-ticker shape function and leverage coupling.
Greeks: The Leisen-Reimer lattice provided smooth finite-difference Greeks (Delta, Gamma, Vega) essential for risk analysis, avoiding the oscillations typical of standard CRR trees.

5. Significance and Claims

The paper claims to provide a robust, open-source framework (implemented in Julia) for generating synthetic American option data that is structurally consistent with equity return dynamics.

Structural Consistency: By initializing variance at its mean-reversion target, the model ensures the IV surface is fully determined by the structural parameters, avoiding the "chicken-and-egg" problem of fitting IV to prices.
Scalability: The hierarchical calibration approach (parametric $\to$ global NN $\to$ sector NN $\to$ per-ticker NN) allows the model to adapt to varying data volumes and sector characteristics.
Application: The framework is designed to serve as a synthetic data generator for downstream applications, including training machine learning models for option pricing, learning delta-hedging policies via reinforcement learning, and conducting scenario-based risk analysis that requires consistent option prices across strikes and expirations.
Modesty: The authors acknowledge that while the framework captures scheduled event risks, it does not yet model unscheduled IV spikes driven by earnings surprises or other idiosyncratic shocks. Future work is suggested to incorporate per-ticker tail sensitivity mechanisms to address these residual signals.