💰 quantitative finance

PIVOT: Bridging Black-Scholes Implied-Volatility and Price Objectives via Differentiable Jäckel Operator

The paper introduces PIVOT, a differentiable layer that bridges Black-Scholes price and implied volatility spaces by preserving the efficient "Let's Be Rational" solver in the forward pass while using implicit differentiation with explicit gating to safely handle low-vega singularities, thereby significantly improving option-learning objectives and price prediction accuracy across major indices.

Original authors: Raeid Saqur, Yannick Limmer, Anastasis Kratsios, Blanka Horvath, Hans Buehler

Published 2026-06-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Raeid Saqur, Yannick Limmer, Anastasis Kratsios, Blanka Horvath, Hans Buehler

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

The Big Picture: Two Different Languages

Imagine the world of stock options as a bustling marketplace. In this market, there are two ways to talk about the value of an option:

The Price Language: This is what you see on the ticker tape (e.g., "This option costs $5.00"). This is the raw, real-world data.
The Volatility Language: This is a mathematical translation called "Implied Volatility" (IV). It's like a "temperature" reading that tells you how much the market expects the stock to shake up and down.

The Problem:
Modern AI models that try to predict these options are like translators who are great at speaking both languages, but they struggle to switch between them instantly.

When the AI wants to learn, it often needs to speak in Volatility (because the patterns are clearer there).
But the real market data is in Price.
To switch from Price to Volatility, you need a special calculator (a "solver"). The best calculator in the world is called Jäckel's LBR. It's incredibly accurate, but it's built like a complex, old-school machine with many switches and levers.

The Bottleneck:
If you try to teach an AI using this old machine, the AI gets stuck. When the AI tries to learn from its mistakes (a process called "backpropagation"), it tries to trace its steps backward through the machine. But because the machine has so many switches and "if-then" logic, the AI gets confused and can't figure out how to fix its errors. It's like trying to drive a car backward through a maze of one-way streets; you can't get a clear path.

The Solution: PIVOT

The authors created a new tool called PIVOT (Price–Implied-Volatility Objective Translator). Think of PIVOT as a smart bridge that connects the Price side and the Volatility side without breaking the AI's learning process.

Here is how PIVOT works, broken down into three simple parts:

1. The Forward Pass: The Trusted Translator

When the AI needs to convert a Price into a Volatility number, PIVOT uses the original, trusted Jäckel calculator. It doesn't try to replace the calculator with a new, "learned" version. It just runs the trusted machine exactly as it was designed.

Analogy: Imagine you need to translate a book. You use the world's best human translator (Jäckel) to do the job. You trust their result completely.

2. The Backward Pass: The Magic Shortcut

This is the real innovation. When the AI needs to learn from its mistakes, it usually has to trace back through the translator's brain. But PIVOT says, "No need to do that!"
Instead, PIVOT uses a mathematical shortcut (called the Implicit Function Theorem). It knows that if you know the Price and the Volatility, there is a direct, smooth mathematical relationship between them.

Analogy: Instead of asking the translator, "How did you decide to use this specific word?" (which is hard to explain), PIVOT just looks at the relationship between the two languages and says, "If the price went up by $0.01, the volatility must have changed by exactly this amount." It skips the messy internal logic of the translator and gives the AI a clean, direct instruction on how to adjust.

3. The Safety Gate: Handling the "Danger Zones"

There is a tricky part of the market called the Low-Vega Regime. This happens when an option is very cheap or very far from its strike price. In these zones, a tiny change in price can cause a massive, wild swing in volatility. Mathematically, this is like a cliff edge where the slope becomes infinite.

The Problem: If an AI tries to learn from these cliff edges, it gets "NaN" (Not a Number) errors, which crash the whole system. It's like trying to drive a car off a cliff and expecting it to land safely.
The PIVOT Fix: PIVOT installs a Safety Gate.
- If the data is safe (well-conditioned), the gate opens, and the AI learns normally.
- If the data is near the cliff (low-vega), the gate gently closes or turns the signal down. It tells the AI, "Don't try to learn from this specific number right now; it's too dangerous."
- Crucially, the AI doesn't crash. It just ignores the dangerous part and keeps learning from the safe parts.

Why This Matters (The Results)

The paper tested this on real-world data (like the S&P 500 options).

Speed: PIVOT is incredibly fast. It can process billions of options per second on a modern computer chip.
Accuracy: By using this bridge, the AI models learned better. They made fewer mistakes in predicting prices (up to 43% fewer errors) and volatility (up to 21% fewer errors) compared to models that didn't use this bridge.
Stability: When they tried to remove the "Safety Gate," the models collapsed and produced nonsense results. This proved that the gate isn't just a tweak; it's a necessary safety feature to keep the math honest.

Summary

PIVOT is a new software layer that lets AI models speak both "Price" and "Volatility" fluently. It uses a trusted calculator to translate forward, a mathematical shortcut to learn backward, and a safety gate to prevent the AI from falling off mathematical cliffs. The result is faster, more accurate, and more stable AI models for understanding financial markets.

Technical Summary: PIVOT – Bridging Black-Scholes Implied-Volatility and Price Objectives via Differentiable Jäckel Operator

1. Problem Statement

Modern machine learning systems for option pricing operate in two distinct coordinate spaces: price space, where market quotes exist and no-arbitrage constraints are naturally enforced, and implied volatility (IV) space, where volatility surfaces are smoothed, regularized, and evaluated. A critical bottleneck exists at the interface between these spaces. While the "Let's Be Rational" (LBR) solver by Jäckel provides a highly efficient, machine-precision method for inverting Black-Scholes prices to IV, existing implementations are scalar, CPU-bound, and lack differentiability.

This creates a mismatch for neural network training:

Non-differentiability: Standard solvers (e.g., py_vollib) do not support automatic differentiation (autograd), preventing gradients from flowing through the IV inversion step.
Singularity: The inverse map from price to IV is singular in the low-vega regime (where $\partial P / \partial \sigma \to 0$ ), causing the derivative $\partial \sigma / \partial P = 1/V$ to diverge. Existing workflows often handle this by manually filtering out low-vega rows, discarding valuable data that could be supervised via price-space losses.
Scalability: Training on millions of contracts requires batched, GPU-accelerated operations, which scalar CPU solvers cannot provide.

The paper argues that the solution is not to replace the trusted numerical solver with a learned approximation, but to create a differentiable bridge that preserves the exact LBR forward pass while supplying analytically correct gradients for the backward pass.

2. Methodology

The proposed system, PIVOT (Price–Implied-Volatility Objective Translator), decomposes the IV inversion task into a forward pass and a backward pass, treating the solver as an opaque primitive within an autograd-native framework.

2.1 Forward Pass: Vectorized Jäckel Solver

The forward pass delegates the inversion to a vectorized implementation of Jäckel's LBR algorithm.

Normalization: Market parameters $(S, K, \tau, r, q)$ are converted to dimensionless coordinates: log-forward-moneyness $k = \log(K/F)$ and total volatility $\sigma_\tau = \sigma\sqrt{\tau}$ .
Solver: The algorithm solves $b(k, \sigma_\tau) = \beta$ (where $b$ is the normalized Black function and $\beta$ is the normalized price) using rational seeds and Householder iterations to achieve machine precision.
Vectorization: The solver is implemented as a batched GPU primitive (using NumPy, PyTorch, JAX, and Triton fused kernels), handling heterogeneous option chains simultaneously.
Validity Masking: Invalid inputs (e.g., prices below intrinsic value, arbitrage violations, $\tau \le 0$ ) are explicitly masked to NaN rather than silently failing.

2.2 Backward Pass: Implicit Differentiation

Instead of backpropagating through the solver's branch logic, rational approximations, or Householder iterations, PIVOT applies the Implicit Function Theorem.

The Identity: Since the forward pass solves $P(\xi, \sigma) = P^*$ , the derivative of the inverse map is given by:
$\frac{\partial \sigma_{imp}}{\partial P^*} = \frac{1}{V}, \quad \frac{\partial \sigma_{imp}}{\partial \xi} = -\frac{\partial P / \partial \xi}{V}$
where $V = \partial P / \partial \sigma$ is the Vega.
Implementation: The backward pass treats the recovered $\sigma_{imp}$ as the exact local inverse of the smooth Black-Scholes/Black-76 price map. It computes the gradient by evaluating the smooth price function and its derivatives at $\sigma_{imp}$ , bypassing the solver's internal branches entirely. This ensures the gradient cost is independent of the number of solver iterations.

2.3 Low-Vega Gating Mechanism

To address the singularity where $V \to 0$ (causing $1/V \to \infty$ ), PIVOT introduces a conditioning-aware gating mechanism:

Well-Conditioned Set ( $G_\tau$ ): For rows where $|V| > \tau$ , the exact $1/V$ gradient is applied.
Singular Tail: For rows where $|V| \le \tau$ , the system does not silently regularize. Instead, it applies a smooth gate $w_\tau(V) = V^2 / (V^2 + \tau^2)$ to the IV-space loss term or returns NaN if the loss explicitly requests an ill-conditioned gradient.
Price-Space Fallback: Rows in the singular tail remain in the batch and contribute to the training objective via price-space losses (which are well-conditioned), while their singular IV-space channel is attenuated. This allows the model to learn from low-vega data without corrupting the optimizer with infinite gradients.

3. Key Contributions

The paper makes three specific contributions:

(C1) Jäckel as a Batched GPU Primitive: A vectorized, GPU-resident implementation of the LBR solver that operates on heterogeneous option chains, replacing scalar CPU wrappers with a high-throughput backend.
(C2) Autograd-Native Implicit Backward: An operator that provides exact inverse-function derivatives via implicit differentiation, decoupling gradient computation from the solver's internal complexity and avoiding backpropagation through branch logic.
(C3) Conditioning-Aware Gating: A mechanism that explicitly handles the low-vega singularity, allowing low-vega rows to contribute via price-space residuals while suppressing their unstable IV-space gradients, eliminating the need for manual pre-filtering.

4. Empirical Results

Experiments were conducted on a single NVIDIA H100 GPU using synthetic data and real-world OptionMetrics data (SPX, RUT, VIX, NDX).

4.1 Performance and Accuracy

Throughput: The fused Triton kernel achieves 1.79 billion IV inversions per second with a maximum relative error of $9.3 \times 10^{-14}$ against the reference C solver.
Label Generation: The system generates 48.9 million synthetic IV labels/s and 16.6 million real SPX labels/s.
Self-Consistency: Round-trip residuals (Price $\to$ IV $\to$ Price) show a 99th percentile error $\le 1.8 \times 10^{-7}$ in price units.

4.2 Impact on Surface Learning (HyperIV Reproduction)

The authors integrated PIVOT into a HyperIV-style volatility surface smoother.

Pareto Dominance: PIVOT-augmented objectives (combining price-MSE and gated IV-roundtrip losses) Pareto-dominate the vanilla baseline.
SPX Results: The best gated configuration reduced held-out Price MAE by 38.8% and IV MAE by 21.3% simultaneously.
Cross-Asset: Similar directional improvements were observed on RUT (40.1% Price MAE reduction), VIX (24.2%), and NDX (16.7%).
Necessity of Gating: An "ungated" diagnostic control (omitting the low-vega gate) collapsed to a degenerate near-zero surface, with Price MAE increasing by up to 2949% (NDX) and thousands of NaN-gradient steps, confirming the gate is a correctness requirement, not a tuning knob.

5. Significance and Claims

The paper positions PIVOT not as a new trading strategy or a replacement for numerical solvers, but as a methodological interface for machine learning pipelines.

Bridging Coordinates: It enables end-to-end differentiable training that simultaneously optimizes for price consistency (where markets quote) and volatility smoothness (where surfaces are reported), a capability previously hindered by the non-differentiable nature of IV inversion.
Correctness Contract: The work claims that the low-vega singularity is a fundamental property of the price-to-IV map that must be handled explicitly. The gating mechanism is presented as a "correctness contract" that prevents numerical poisoning of the optimizer, allowing models to utilize the full dataset without manual pre-filtering.
Reproducibility and Governance: By making the price-IV boundary explicit (invalid rows return NaN, low-vega rows are gated), the framework supports clearer reporting of data validity and conditioning in volatility surface learning.

The authors explicitly state that they do not claim to generate arbitrage-free surfaces (a property inherited from the baseline HyperIV model) nor do they claim to solve the low-vega singularity by changing the objective; rather, they provide the exact differentiable bridge that allows existing objectives to be composed correctly in the presence of these singularities.