PaperlayerView exact revision on arXiv

Source-linked AI summary

A Threshold for Quantum Advantage in Derivative Pricing

Shouvanik Chakrabarti, Rajiv Krishnakumar, Guglielmo Mazzola, Nikitas Stamatopoulos, Stefan Woerner, William J. Zeng

arXiv:2012.03819v3quant-phcs.ETq-fin.CP

TL;DR

The paper asks what resources are required for useful quantum advantage in derivative pricing, focusing on realistic path-dependent benchmarks. It provides end-to-end estimates and introduces re-parameterization to avoid limitations in known loading methods, finding substantial but currently out-of-reach requirements and a roughly one-second performance threshold.

  • Problem

    Quantum derivative-pricing research lacked complete resource estimates for useful, computationally expensive path-dependent derivatives, including the cost of loading underlying asset paths.

  • Method

    The paper combines fault-tolerant quantum pricing with return-space optimizations and a re-parameterization method using pre-trained variational circuits to load stochastic processes.

  • Results

    The benchmark autocallable and TARF use cases require substantial quantum resources, with the target threshold requiring execution at approximately one second and 10MHz T-gate operation for the stated autocallable target.

  • Takeaways & Limitations

    The resource estimates provide a target performance threshold and a roadmap for improving quantum algorithms, implementations, and hardware architectures.

  • Takeaways & Limitations

    The resource analysis uses IQAE with oracle depth O(1/ε), while the trade-off between shorter-depth programs and reduced quantum advantage is left for future work.

Abstract

from arXiv · show

We give an upper bound on the resources required for valuable quantum advantage in pricing derivatives. To do so, we give the first complete resource estimates for useful quantum derivative pricing, using autocallable and Target Accrual Redemption Forward (TARF) derivatives as benchmark use cases. We uncover blocking challenges in known approaches and introduce a new method for quantum derivative pricing - the re-parameterization method - that avoids them. This method combines pre-trained variational circuits with fault-tolerant quantum computing to dramatically reduce resource requirements. We find that the benchmark use cases we examine require 8k logical qubits and a T-depth of 54 million. We estimate that quantum advantage would require executing this program at the order of a second. While the resource requirements given here are out of reach of current systems, we hope they will provide a roadmap for further improvements in algorithms, implementations, and planned hardware architectures.

1 Introduction

Derivatives derive their value from underlying assets and specify payoffs over a contract’s lifetime. Because pricing often relies on resource-intensive Monte Carlo methods, this work estimates the conditions for quantum advantage and introduces new stochastic-process loading methods.

  • Derivatives are financial assets whose values derive from one or more underlying assets and whose payoffs quantify the holder’s potential gain.Underlying assets include stocks, currencies, and commodities; contracts are typically issued between an issuer and holder until expiration.
  • Derivative pricing determines today’s contract value under uncertainty about future underlying values and the resulting payoff.
  • Monte Carlo methods commonly used for derivative pricing consume significant computational resources for financial institutions.
  • This work provides the first detailed resource estimates for the conditions required to obtain quantum advantage in derivative pricing.
  • The paper introduces new methods for loading stochastic processes into quantum computers as part of its derivative-pricing approach.

2 Derivative Pricing and Summarized Results

The paper formulates derivative pricing as an expected discounted payoff over stochastic asset paths and targets computationally expensive path-dependent contracts. It estimates end-to-end quantum resources, comparing known loading approaches with return-space calculations and the re-parameterization method.

  • Derivative prices are expected discounted payoffs under a stochastic process, while path-dependent contracts are generally harder to price than path-independent contracts.Classical Monte Carlo is commonly used for path-dependent derivatives, whereas some path-independent derivatives have analytic solutions.
  • The study estimates end-to-end quantum resources for autocallable options and TARFs, which are computationally expensive, path-dependent derivatives relevant in practice.The loading of asset-path distributions, left open in previous work, is explicitly analyzed here.
  • The authors introduce return-space calculations and the re-parameterization method alongside an extended Riemann Sum method to reduce resource requirements.Resource requirements are evaluated using T-count, T-depth, and logical-qubit measures in the fault-tolerant setting.
  • Summarized Results: Table 1 evaluates methods for target error 2 × 10^-3 on a basket autocallable and a one-underlying TARF, reporting resource requirements across methods.The caption states that Grover-Rudolph methods are impractical and that Riemann methods require normalization assumptions to avoid exponentially growing errors.
  • The underlying assets are modeled with geometric Brownian motion, whose transition probabilities are multivariate log-normal in price space.The process uses parameters including the risk-free rate, volatility, time step, and covariance matrix.
  • Price Space vs. Return Space: In return space, log-returns are normally distributed and the path distribution consists of dT independent Gaussians rather than price-conditioned transitions.This representation can make distribution loading easier, although converting back to prices may require quantum arithmetic.

3 Core Approach

The quantum derivative-pricing approach loads path distributions, computes normalized payoffs in superposition, and uses amplitude estimation to recover expected payoffs. Its accuracy and practicality depend on resource-intensive state preparation, circuit depth, normalization, and truncation, discretization, and estimation errors.

  • Quantum pricing algorithm: The algorithm loads a path distribution, computes all path payoffs in quantum parallel, encodes the expected payoff in an amplitude, and estimates that amplitude.Amplitude estimation requires O(1/ϵ) queries for target accuracy ϵ > 0.
  • Quantum pricing algorithm: IQAE provides the resource estimates used here, but its oracle depth scales as O(1/ϵ), making circuit execution a dominant resource requirement.Shorter-depth alternatives trade reduced depth for more total oracle calls and are left for future analysis.
  • Path distribution loading: Path loading is essential for path-dependent derivatives because analytic loading of final prices mainly applies to derivatives that are easy to price classically.The paper focuses on autocallables and TARFs, which require a superposition over asset paths.
  • Path distribution loading: The re-parameterization and related price-space-to-return-space optimizations reduce resources, while general distribution loading remains exponentially hard and qGAN training overhead is difficult to anticipate.Loading normal distributions can be easier because their stochastic evolution is independent of the previous asset price.
  • Error analysis: The error budget includes truncation, discretization, and amplitude-estimation errors, with discretization error reducible by increasing the number of qubits.Finite quantum memory restricts the integration domain, omitting probability mass and creating truncation error.

4 Methods for Advantage in Quantum Derivative Pricing

The paper compares Riemann summation with re-parameterization for loading stochastic processes in quantum derivative pricing. Riemann summation suffers from normalization-driven error growth, while re-parameterization uses pre-trained Gaussian circuits and affine transformations to reduce practical resource requirements.

  • Riemann Summation: Riemann summation normalizes transition probabilities and uses amplitude estimation to price derivatives over discretized asset paths.The method prepares a superposition of paths, loads initial prices, applies transition operators, encodes payoff-related values into an ancilla, and estimates its amplitude.
  • Riemann Summation: If Pmax > 1, normalization error increases exponentially with T, rendering the Riemann summation approach impractical.For sufficiently small discretization windows, truncation error can also reach ϵtrunc ≥ 0.17 and increase with the number of assets and timesteps.
  • Riemann Summation: The Riemann summation method introduces additional errors from scaling, arithmetic, density computation, and payoff evaluation.The total error analysis includes transition-operator density error, payoff error, and rescaling errors in the input variables.
  • Resource estimates: The reported benchmark estimates include 1.5 × 10^8 T-depth for one autocallable setup and 1.6 × 10^8 T-depth with 17k qubits for a TARF setup.The autocallable estimate uses N_oracle ≤ 6k, while the TARF estimate targets ϵtotal/fδ ≤ 2 × 10−3.
  • Re-parameterization: Re-parameterization loads independent standard normal states in parallel, then applies affine transformations to obtain the required means and standard deviations.Return paths are constructed using the transformation R_t = µ_t + L^T R̄_t based on a Cholesky factor L of the covariance matrix.
  • Re-parameterization: Variational Ry-CNOT circuits are trained to prepare Gaussian states, with numerical error decreasing exponentially with circuit depth and gate count.The approach combines energy-based optimization with subsequent direct L∞ re-optimization against the target distribution.

5 Payoffs

The payoff subroutines encode autocallable and TARF payoffs into accumulator amplitudes, using logical comparisons, arithmetic, controlled rotations, and amplitude estimation. For the benchmark autocallable, payoff implementation requires 1.6k qubits and T-depth 3.2k, while the TARF payoff circuit requires 9k qubits and T-depth 6k.

  • Payoff framework: The payoff stage applies payoff functions to superpositions of asset paths and stores the normalized expected discounted payoff in an accumulator amplitude for amplitude estimation.This stage also analyzes the additional errors introduced by payoff implementation.
  • Autocallables: Autocallables combine m time-ordered binary options with a knock-in put, while any non-zero binary payoff knocks out later options and the put.The binary options use strikes, payment dates, and fixed payoffs; the put has its own strike, barrier, and notional value.
  • Autocallables: The autocallable circuit computes strike and put indicator qubits, applies controlled rotations for binary payoffs, and calculates the normalized put payoff before rotating the accumulator.The put condition is formed with AND and OR operations, while the put payoff uses quantum arithmetic to compute an arcsine rotation angle.
  • Autocallables: 1.6k qubits and T-depth 3.2k are required for the benchmark autocallable payoff circuit at additive payoff error ϵf = 10^-4.The estimate assumes computations can be parallelized wherever possible and is included in the end-to-end resource summary.
  • TARFs: TARF payoff implementation computes partial conditional payoffs, corrects them for the accrual cap, discounts and sums them, then normalizes the result before applying an accumulator rotation.The procedure is described for a single underlying in price space, with forward and strike parameters, a knock-out price, an accrual coefficient, and a cap.
  • TARFs: 9k qubits and T-depth 6k are required for the TARF payoff circuit at ϵf = 10^-4, assuming computations can be parallelized.The resource estimate is smaller in T-depth than the corresponding autocallable payoff implementation because discounted payoffs are added with errors accumulating in quadrature.

6 Discussion

The paper presents the re-parameterization method and resource estimates for quantum pricing of path-dependent derivatives, while identifying the performance threshold and current hardware gap for quantum advantage.

  • 6 Discussion: The re-parameterization method loads stochastic processes and overcomes limitations of existing approaches, with analysis limited to geometric Brownian motion.The authors state that extensions to stochastic or local volatility models are straightforward through multiple independent processes and conditional or non-stationary re-parameterization.
  • 6 Discussion: A 1-second autocallable target requires a 10MHz logical T-gate rate at a code distance supporting 10^10 logical operations.Reducing the algorithm’s T-depth would linearly reduce this execution-rate requirement.
  • 6 Discussion: Amplitude-estimation speedups can be lost to constant-factor error-correction overheads, so complexity scaling alone does not determine quantum advantage.The paper emphasizes resource estimates beyond asymptotic scaling when evaluating practical thresholds.
  • 6 Discussion: Current logical clock-rate estimates around 10kHz are orders of magnitude slower than the requirement for the target quantum pricing program.The authors identify algorithm, circuit, error-correction, and hardware improvements as avenues for reducing the gap.
  • 6 Discussion: The resource-estimation approach can also analyze quantum-advantage thresholds in other financially relevant applications.The paper frames these thresholds as useful targets for industry and research.

A.4 Auto-callable Options

Autocallables combine contingent payments, knock-out rules, and often a knock-in put, making their payoffs strongly path dependent and computationally expensive to price.

  • A.4 Auto-callable Options: An autocallable consists of binary options at multiple payment dates, with later options voided after an earlier non-zero payout.The binary-option payoffs depend on cumulative underlying returns at their respective payment dates.
  • A.4 Auto-callable Options: A bundled short knock-in put can reduce the holder’s price while mitigating risk for the issuer.Its payoff is also contingent on the underlying asset’s return path.
  • A.4 Auto-callable Options: Autocallables can take five to ten seconds to price classically using Monte Carlo with at least 40,000 paths.Their contingent payoffs and knock-in put make them computationally expensive in practice.
  • A.4 Auto-callable Options: A TARF is a multi-payment forward derivative with upper and lower strikes, an asymmetric downside factor, and knock-out conditions based on a threshold and accrual cap.The payoff is positive above the upper strike, zero between strikes, and negative below the lower strike.

B Insufficiency of Grover-Rudolph Loading

The section explains why Grover-Rudolph loading does not provide a practical route to quantum-accelerated Monte Carlo when its required integrals are themselves classically expensive.

  • B Insufficiency of Grover-Rudolph Loading: Grover-Rudolph iteratively refines a probability distribution by adding qubits and controlled rotations over subdivided regions.After n = log2 N iterations, the distribution is discretized over N points.
  • B Insufficiency of Grover-Rudolph Loading: The method requires computing conditional probabilities for region halves and implementing those computations in superposition.The controlled rotation extends the distribution state by one qubit at each iteration.
  • B Insufficiency of Grover-Rudolph Loading: Its efficiency depends on performing the required probability integrals efficiently in superposition.The original argument assumes that classically efficient probabilistic integration transfers to quantum integration.
  • B Insufficiency of Grover-Rudolph Loading: Using Grover-Rudolph for quantum-accelerated Monte Carlo is insufficient when the loading integrals are evaluated by the same classical Monte Carlo procedure that quantum pricing aims to accelerate.This creates a bottleneck in the state-preparation step rather than resolving the integration cost.
  • B Insufficiency of Grover-Rudolph Loading: A normal-distribution approximation becomes accurate for m ≥7, but earlier terms still require classical computation before loading.The construction remains iterative, so the approximation does not remove the initial classical work.

C Fixed-point Quantum Arithmetic Resources

The resource analysis estimates fault-tolerant quantum arithmetic in a Clifford + T decomposition, using T-depth as the dominant sequential cost measure.

  • C Fixed-point Quantum Arithmetic Resources: Quantum arithmetic supports path loading through both the Riemann summation and re-parameterization methods, as well as payoff calculation.The Riemann-sum method requires the arithmetic operations appearing in its defining equations.
  • C Fixed-point Quantum Arithmetic Resources: The analysis estimates T-depth after decomposing circuits into the fault-tolerant Clifford + T gate set.T-depth measures sequential layers, while the assumptions allow parallelization wherever possible.
  • C Fixed-point Quantum Arithmetic Resources: Toffoli gates are assumed to have T-depth one using ancilla qubits.This assumption is part of the fault-tolerant resource-estimation model.

C.1 Resource Estimation

This section defines the fixed-point quantum arithmetic primitives and resource models used to estimate qubit counts, Toffoli counts, and T-depths for derivative-pricing subroutines.

  • Arithmetic representation: Fixed-point representations control arithmetic precision and the resources required for reversible quantum-register operations.The register parameters n and p determine both calculation error and arithmetic cost, and remain fixed throughout the analysis.
  • Addition and multiplication: Controlled addition uses an additional n-qubit ancilla register and two sets of parallel controlled swaps.Each controlled swap consists of three Toffoli gates in series.
  • Addition and multiplication: Parallel multiplication with factor z adds n·(z−1) qubits while enabling z-way parallel controlled additions and reducing sequential depth.The subsequent accumulation of partial results introduces z−1 additional additions.
  • Nonlinear functions: Square-root computation has T-depth Tsq(n) = 5n + 3 and requires 2n + 1 qubits.The algorithm extends a classical square-root procedure to fixed-point quantum registers.
  • Nonlinear functions: Piecewise polynomial evaluation uses polynomial degree k and M subintervals, with T-depth Tpp(n,z) = k(Tmul(n,z) + Tadd) + M(2⌊log2(n − 1)⌋ + 5).The same framework estimates exponential and arcsine resources, while qpp(n,k,M) gives the corresponding qubit count.
  • Nonlinear functions: Arcsine evaluation combines square root, polynomial evaluation, and conditional logic, giving Tarcsq(n,p,z) = Tsq(n) + Tpp(n,z) + 8n + 6.Its qubit requirement is qarcsq(n,k,M) = qpp(n,k,M) + 2n + 1.

C.2 Error Analysis

The error analysis tracks approximation and fixed-point errors through addition, multiplication, nonlinear functions, and synthesized rotations, while noting one deferred rotation optimization.

  • Arithmetic error: Fixed-point addition introduces error bounded by ϵA = 1/2^(n−p), while multiplication propagates operand errors and adds its own arithmetic error.For bounded factors, multiplication error is ϵmul = b·(ϵX + ϵY) + ϵXϵY + ϵM(n,p).
  • Rotation error: A Repeat-Until-Success rotation synthesis could reduce T-depth to approximately 1.15 log2(1/ϵ), but its failure probability complicates the analysis and it is left for future work.The baseline arbitrary single-qubit synthesis uses approximately 3 log2(1/ϵ) T-depth.
  • Function approximation: Exponential and arcsine approximation errors depend on polynomial degree and the number of subintervals, with resource tables covering errors from 10^-5 to 10^-9.These approximation choices are incorporated into the overall error estimate.
  • Function approximation: Square-root error combines the algorithmic approximation error ϵsq with the input-register error through the bound ϵsq + √ξ.The bound applies when the input register contains positive additive error ξ.
  • Rotation error: Sine evaluation accounts for both input-angle arithmetic error and the gate-decomposition error ϵsin.The analysis uses the monotonic slope of sine on 0 ≤ θ ≤ π/2 to bound propagated error.

D.1 Riemann Summation Path Loading Resource Estimates

The Riemann-summation method loads asset-path distributions and computes derivative prices through parallel arithmetic, exponential and arcsine evaluation, and payoff-amplitude rotations.

  • Path-loading pipeline: The path-loading calculation evaluates the pricing expression in log-return space and encodes its value into an ancilla amplitude.Resource estimates use the arithmetic primitives introduced earlier.
  • Path-loading pipeline: Parallel computation across d assets and T timesteps requires registers for returns, sums, squared terms, cross-products, exponentials, and arcsine evaluation.Reusable registers reduce some additional qubit requirements, while parallel multiplication can add (z−1)·T·d extra qubits.
  • Resource contributions: Exponentials contribute Texp T-depth and qexp·d·T qubits when calculated across all assets and timesteps in parallel.The approximation parameters determine qexp and Texp through the target accuracy.
  • Resource contributions: The ancilla rotation requires T-depth 3n log2(n/ϵ) to precision ϵ and uses n ancilla qubits under the controlled-Ry decomposition.The rotation encodes the computed payoff or probability amplitude.
  • Total resources: The total T-depth and qubit count combine arithmetic, exponential, arcsine, rotation, and register-storage costs, with Texp and Tarcsin depending on target accuracy.The estimates assume parallelization wherever possible across assets and timesteps.

D.2 Importance Sampling for Normalization in Riemann Summation

The importance-sampling construction approximates a target distribution with an efficiently loadable distribution and corrects the resulting multiplicative discrepancy using quantum arithmetic.

  • Core construction: The method replaces a difficult target distribution with an efficiently loadable distribution h and adjusts the multiplicative error during quantum evaluation.This is closely related to classical importance sampling and targets the exponential scaling overhead of direct normalization.
  • Core construction: For a univariate density, h must satisfy f(x)/(h(x)N) ∈ [0,1] so the corrected amplitude construction remains valid.The construction combines a state-preparation operator H with a correction operator Fh.
  • Multivariate distributions: For multivariate densities, the method distinguishes separable, non-separable, and stochastic-process cases and seeks corresponding efficiently loadable factors.The stochastic-process case uses conditional components h_t that can be loaded efficiently.
  • Multivariate distributions: If the conditional factors satisfy the required boundedness condition, stochastic-process loading avoids the exponential scaling overhead P^(T+1).When P ≤ 1, choosing h_t(x_t) = 1 recovers the original approach without importance sampling.
  • Limitations: A suitable h is not guaranteed to exist, but even partial satisfaction can lower the normalization overhead.The practical benefit therefore depends on finding efficiently loadable distributions meeting the required bounds.

E Re-parameterization Path Loading Resource Estimates

The re-parameterization method loads independent Gaussian log-returns, then computes cumulative returns and asset prices with quantum arithmetic. Its resource formulas account for Gaussian preparation, register sizes, additions, exponentials, and correlated-asset interactions.

  • Path representation: Independent Gaussian states represent the dT log-returns, replacing sequential price-distribution loading with normal-distribution loading.The method prepares each Gaussian and subsequently performs the affine transformation needed to recover prices from log-returns.
  • Asset-price computation: Correlated assets require d² contributions per timestep when every asset is pairwise correlated, although additions can be parallelized in d rounds.The circuit computes distinct source-target operations in parallel and repeats them across rounds and timesteps.
  • Register sizing: n + ⌈log2 T⌉ qubits hold cumulative sums over T timesteps, with an additional ⌈log2 d⌉ qubits for sums over d assets.These register extensions accommodate the largest values of the timestep and asset sums.
  • Resource estimates: The re-parameterization path-loading cost is summarized by TRP(n, d, T, L, ϵ) = 3n log2(n/ϵ)(L + 1) + 10T + d¯n² + Texp(¯n, ϵ).Here ¯n = n + ⌈log2 T⌉ + ⌈log2 d⌉.
  • Resource estimates: The corresponding qubit requirement is qRP(n, d, T) = (n + ¯n + qexp(¯n, ϵ))dT.The estimate includes Gaussian, cumulative-sum, and exponential-computation registers.

F Method for Gaussian Loader Training

The Gaussian loader uses a variational Ry-CNOT circuit trained with an energy-based cost function and refined with the L∞ distribution error. Numerical studies report exponential convergence with circuit depth, while digitized parameters can approach continuous solutions at sufficiently fine resolution.

  • Training strategy: The variational approach trains a parameterized state toward the target by optimizing a suitable cost function, whose choice is crucial.The paper uses the target-state energy of an associated quantum harmonic oscillator as the principal training objective.
  • Limitations: Shallow variational circuits can avoid costly quantum arithmetic, but optimization may encounter local minima and limited trial-state representational power.These are identified as persistent sources of error in numerical variational approaches.
  • Ansatz: The Ry-CNOT ansatz uses L rotation-and-entangler blocks, linear CNOT connectivity, and n × (L + 1) variational parameters.The initial n-qubit state is |0⟩⊗n, followed by single-qubit rotations and entangling layers.
  • Optimization refinement: Direct L∞ optimization consistently fails to provide accurate results, so pre-optimized energy-based circuits are used as starting points for L∞ refinement.The energy landscape is smoother than the more corrugated L∞ landscape, while their attraction basins overlap.
  • Numerical results: The convergence to the exact ground state is exponential in circuit depth and therefore in the number of gate operations.The study repeats optimization eight times for each n and L to account for suboptimal minima.
  • Parameter digitization: Digitization error decreases as O(1/Mdigit), with solutions comparable to or better than continuous optimization at Mdigit ∼ 10^5.This corresponds to an angular grid spacing of approximately 0.0001 rad.
Loading 2012.03819v3…