Halley-Based Implied Volatility Solver

• Halley-Method-Based IV Solver is a root-finding framework that leverages cubic convergence via third-order Householder iterations to accurately recover implied volatility from Black-Scholes models.
• It integrates safety mechanisms such as fallback logic, bracket enforcement, and convergence diagnostics to ensure robust and monotonic updates under diverse conditions.
• Vectorized, batched implementations in libraries like fast-vollib deliver millions of volatility inversions per second across CPU and GPU, optimizing performance in large-scale computing.

A Halley-method-based IV (Implied Volatility) solver is a root-finding framework that leverages the third-order Householder (Halley) iteration for rapidly and accurately inverting the Black-Scholes-Merton (and related) option price models to recover implied volatility. Recent highly vectorized implementations, such as those in the fast-vollib library, combine Halley’s cubic convergence with batched, memory-efficient backends across NumPy, PyTorch, JAX, and CUDA, providing robust, high-throughput solutions suitable for CPU and GPU workloads (Saqur, 29 Apr 2026). This approach is particularly distinguished by elementwise fallback logic (Halley–Newton–bisection), bracket enforcement, and convergence diagnostics, enabling monotonic and vectorized resolution of millions of volatility-inversion tasks per second.

1. Volatility Inversion as a Root-Finding Problem

Implied volatility inversion is formally a scalar root-finding problem. Under the Black-Scholes-Merton framework, the price of a European call at time $0$ is

$$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$

where

$$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$

and $\Phi$ is the standard Normal CDF. The implied volatility $\sigma^*$ is the positive solution to $f(\sigma) := C(\sigma) - C_{\rm mkt} = 0$ for any admissible market price $C_{\rm mkt}$. $C(\sigma)$ increases strictly in $\sigma$, so the root is unique and well-posed for all practical input data (Saqur, 29 Apr 2026).

2. Halley Iteration: Derivation and Cubic Convergence

Classical Halley’s method is a third-order scalar root solver that refines Newton’s method by using second derivative information. For $f\in C^2$, the generic Halley step is given by

$$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$0

In the context of implied volatility, the derivatives are:

• $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$1 vega $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$2
• $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$3 vega $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$4

where $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$5 is the standard normal density. The error recurrence is $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$6—that is, the number of correct digits triples per iteration in the local regime (Martin, 2023, Petković et al., 2017).

3. Production-Grade Batched and Vectorized Algorithm

The fast-vollib implementation realizes Halley’s method in a vectorized, batched form. All primary quantities (option prices, derivatives, deltas, intermediate steps) are handled as arrays. A typical high-level pseudocode is:

$\sigma^*$1 Convergence is declared when $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$7 or $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$8. Fallback to bracketed Newton steps ensures monotonic and bounded updates even in wings or ill-conditioned settings (Saqur, 29 Apr 2026). All arithmetic is backend-fused (NumPy, PyTorch, JAX), enabling kernel fusion and single-pass, memory-efficient batched execution.

4. Convergence Safeguards and Performance Characteristics

Practical implementation incorporates multiple fallback and safety mechanisms:

• Bracket enforcement: Each $$C(\sigma) = S e^{-qT} \Phi(d_1(\sigma)) - K e^{-rT} \Phi(d_2(\sigma)),$$9 is clamped to $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$0 at every iteration.
• Singular denominator protection: Revert to the Newton update wherever $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$1 or update leaves bracket.
• Termination by either price residual or absolute difference in $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$2.

Performance metrics, as reported for fast-vollib (Saqur, 29 Apr 2026):

• Halley converges in $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$3–$$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$4 iterations, compared to $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$5–$$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$6 for Newton, and $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$7 for “LBR” (Jäckel's algorithm).
• On 16-core CPUs (NumPy): Halley yields $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$8M IV/s/core.
• PyTorch-CPU with torch.compile: $$d_1(\sigma) = \frac{\ln(S/K) + (r-q + 0.5 \sigma^2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T},$$9 speedup over plain NumPy.
• GPU: Halley (torch.jit): $\Phi$0M IV/s; JAX, $\Phi$1M IV/s; Triton-fused LBR: up to $\Phi$2M IV/s (A100 GPU, $\Phi$3 batch size).

Performance is modulated by hardware, batch size, precision mode, and just-in-time (JIT) kernel amortization.

5. CUDA Fused-Kernel and Triton Backend

The separate Triton kernel (not Halley-based, but provided for benchmarking) implements Jäckel's "Let's Be Rational" algorithm: four-branch rational initial guess and two Householder(3) updates in a single kernel pass. Design highlights:

• Intermediate arrays (e.g., $\Phi$4) reside fully in registers, not global memory.
• Control flow is lowered to masked selection; all elements in a warp follow the same execution path, reducing divergence.
• Each implied volatility is assigned to a single thread; block sizes are tuned to the GPU’s warp size.
• Write-back to DRAM occurs only after full convergence, minimizing bandwidth usage.

Such fused implementations are necessary to saturate multi-million-IV/s performance on modern CUDA hardware. The Halley scheme itself can be adapted for such high-performance kernels by ensuring all reductions and branching occur locally (Saqur, 29 Apr 2026).

6. Example Usage: Python API for Fast-Vollib

The fast-vollib public API allows batch calls across all supported backends:

• NumPy example:

$\sigma^*$2

• PyTorch/JAX examples: Analogous calls with native tensors; hardware-aware kernel fusing is triggered via torch.compile or jax.jit.

These interfaces return arrays of implied volatilities for massive option chains in single calls, adjusting for vectorization and architecture.

7. Related Advances: Halley Variants and Generalizations

Halley’s framework is extensible to broader classes of nonlinear equations:

• Generalized equations: The Josephy–Halley method extends cubic convergence to inclusions of the form $\Phi$5, using predictor–corrector linearizations. This yields $\Phi$6-cubic convergence under metric regularity and mild smoothness, with majorant-based semilocal guarantees (Roubal et al., 24 Apr 2025).
• Parameter families: Third-order convergence can be achieved for families of rational updates parameterized by $\Phi$7 (Petković et al., 2017); Halley is the case $\Phi$8.
• Robustified Halley: Variants avoid singularities and sign errors when $\Phi$9 is large or near $\sigma^*$0, using exponential or rational Padé corrections (Martin, 2023). These are not explicitly used in fast-vollib but are applicable when extending to more general, potentially ill-conditioned, root-finding contexts.

The vectorized Halley-method-based IV solver represents a state-of-the-art, cubic convergence, production-grade root-finding solution tailored to large-scale, modern computational finance workloads (Saqur, 29 Apr 2026).