PaperlayerView exact revision on arXiv

Source-linked AI summary

Option Pricing using Quantum Computers

Nikitas Stamatopoulos, Daniel J. Egger, Yue Sun, Christa Zoufal, Raban Iten, Ning Shen, Stefan Woerner

arXiv:1905.02666v5quant-ph

TL;DR

Pricing complex options accurately is computationally demanding because analytical models rely on restrictive assumptions, while classical Monte Carlo can require extensive resources. The paper develops gate-based quantum option-pricing circuits using amplitude estimation, demonstrates them across option types, and reports error mitigation that reduces hardware-estimation error.

  • Problem

    Analytical option-pricing models rely on simplifying market assumptions, while classical Monte Carlo methods can require extensive computational resources for accurate pricing, especially for complex options.

  • Method

    The paper develops gate-based quantum circuits using amplitude estimation to price vanilla, multi-asset, path-dependent, and portfolio options, including methods for loading relevant distributions.

  • Results

    The implemented circuits price the covered option contracts in simulations and on IBM Q Tokyo, while error mitigation reduces the average option-price error from 62% to 21%.

  • Takeaways & Limitations

    Amplitude estimation offers a theoretical quadratic speed-up over traditional Monte Carlo, although the approach most likely requires a universal fault-tolerant quantum computer.

  • Takeaways & Limitations

    The paper's Fig. 8 option-pricing examples are far beyond the reach of current and near-term quantum hardware.

Abstract

from arXiv · show

We present a methodology to price options and portfolios of options on a gate-based quantum computer using amplitude estimation, an algorithm which provides a quadratic speedup compared to classical Monte Carlo methods. The options that we cover include vanilla options, multi-asset options and path-dependent options such as barrier options. We put an emphasis on the implementation of the quantum circuits required to build the input states and operators needed by amplitude estimation to price the different option types. Additionally, we show simulation results to highlight how the circuits that we implement price the different option contracts. Finally, we examine the performance of option pricing circuits on quantum hardware using the IBM Q Tokyo quantum device. We employ a simple, yet effective, error mitigation scheme that allows us to significantly reduce the errors arising from noisy two-qubit gates.

1 Introduction

Option pricing is computationally demanding for complex contracts because stochastic parameters limit analytical models and make classical Monte Carlo expensive. The paper develops gate-based quantum circuits using amplitude estimation to price diverse option types and evaluates them in simulation and on quantum hardware.

  • Options support market views, arbitrage, and hedging, making their properties fundamental to financial engineering.
  • Stochastic option parameters make fair-value calculation arduous, while analytical models often rely on limiting market-dynamics assumptions.
  • Classical Monte Carlo flexibly handles stochastic parameters but generally requires extensive computational resources for accurate pricing, especially for complex options.
  • Amplitude Estimation offers a theoretical quadratic speed-up over classical Monte Carlo, with convergence rate 1/M for M quantum samples.
  • The paper implements gate-based quantum circuits for vanilla, path-dependent, multi-asset, and portfolio option pricing, then evaluates them through simulations and quantum-hardware experiments.

2 Review of option types and their challenges

Option pricing estimates a discounted expected payoff under uncertainty, with complexity increasing when payoffs depend on asset histories or multiple underlyings. Classical Monte Carlo follows stochastic paths and averages payoffs, while discounting can be performed separately for the options considered.

  • An option’s fair value is the discounted payoff expected at expiration, representing what should be paid for the contract today.
  • Classical numerical pricing models underlying uncertainties as stochastic variables and generate many random price paths from their implied distribution.
  • The payoff is evaluated on each path, and the expected payoff is estimated by averaging across paths.
  • The Monte Carlo estimator converges to the expected payoff as the number of paths approaches infinity.
  • Discounting the expected payoff produces fair value and can be performed classically after payoff calculation for the options considered.
  • Path-independent options depend on an underlying asset at one time, whereas path-dependent options depend on the asset’s evolution and history.

3 Quantum Methodology

The methodology prices options by loading stochastic asset distributions, encoding payoff functions, and using Amplitude Estimation to calculate expected payoffs. It also addresses distribution-loading constraints and uses qGANs and maximum-likelihood amplitude estimation to support practical implementations.

  • Amplitude Estimation: Amplitude Estimation calculates option-payoff expectations from a quantum state representing the relevant probability distribution and a payoff operator.The framework requires representing P, constructing f(X), and estimating E_P[f(X)].
  • Amplitude Estimation: The algorithm offers a quadratic speed-up over classical Monte Carlo, with estimation error scaling as O(1/(M√N)) in the maximum-likelihood approach.Here M is the total number of Q applications and N is the number of shots per experiment.
  • Distribution loading: Option pricing circuits load possible asset prices as computational-basis states whose amplitudes encode their corresponding probabilities.For BSM-modeled options, log-concave distributions such as the log-normal distribution can be loaded without prohibitive complexity.
  • Distribution loading: Arbitrary probability distributions are inefficient to load directly because doing so requires exponentially many gates.qGANs can instead learn distributions from samples and load them using a polynomial number of gates, with variational forms tailored for short-depth circuits.
  • Computing the payoff: The payoff functions considered are piecewise linear and are implemented through controlled Y-rotations acting on an ancilla qubit.Each input qubit controls a rotation for the linear term, while the constant term uses an uncontrolled rotation.
  • Computing the payoff: A first-order payoff approximation achieves O(M^-2/3) convergence, while higher-order quantum arithmetic restores O(M^-1) convergence at the cost of additional gates.The scaling parameter c is chosen to minimize estimation error, and the payoff is rescaled to lie within the required range.

4 Option pricing on a quantum computer

The paper builds quantum circuits for pricing vanilla, multi-asset, and path-dependent options through probability loading, payoff construction, and amplitude estimation. Vanilla pricing uses strike comparison and controlled rotations, while simulations compare estimates with analytical values and Monte Carlo.

  • Framework: The pricing framework emphasizes implementing quantum circuits that prepare the states required by amplitude estimation for multiple option classes.The covered classes include vanilla options, portfolios of vanilla options, path-dependent options, and multi-asset options.
  • Vanilla options: Vanilla option pricing loads a truncated, discretized maturity distribution into an n-qubit register, with basis states representing asset values and amplitudes encoding probabilities.The distribution-loading operator PX creates the encoded state, illustrated for a Black-Scholes-Merton log-normal distribution.
  • Vanilla options: A strike comparator sets an ancilla qubit to 1 when the encoded asset value satisfies i ≥ K, using carry computation with CNOT, Toffoli, and logical-OR operations.The comparator uses the two’s complement of K and uncomputes auxiliary information after the comparison in the example circuit.
  • Vanilla options: A comparator-controlled multi-controlled Y-rotation encodes the call payoff only for values above the strike, producing an ancilla probability measurable by amplitude estimation.Choosing g0 and g(i) appropriately recovers the expected payoff up to a scaling factor and constant; discounting is applied afterward to obtain fair value.
  • Results: Amplitude-estimation results for a European call converge toward the analytical Black-Scholes-Merton value as the number of evaluation qubits increases.The simulated experiment uses sampling-qubit counts m ∈ {3, 5, 7, 9}, corresponding to M ∈ {8, 32, 128, 512} quantum samples.
  • Basket options: For a three-asset basket option, amplitude estimation provides a quadratic speed-up over classical Monte Carlo under equal-sample comparisons.The comparison uses repeated simulations at an approximately 81% confidence interval; typical business cases may require tens of thousands to millions of paths.

5 Quantum hardware results

The paper evaluates shortened amplitude-estimation option-pricing circuits on IBM Q Tokyo, using three qubits and error mitigation to address hardware noise. The circuits remain resource-intensive, but mitigation substantially improves the agreement of estimated prices with classical simulations.

  • Hardware motivation: Standard amplitude estimation is unsuitable for near-term hardware because it requires additional accuracy-control qubits and multi-controlled gates.The paper therefore evaluates amplitude estimation without quantum phase estimation, which produces shorter circuits.
  • Experimental setup: The hardware experiment uses three qubits: two encode uncertainty and one encodes the payoff for a European call option.The input is a two-qubit log-normal distribution with parameters S0 = 2, σ = 40%, r = 5%, and T = 40/365.
  • Measurement procedure: The experiments run circuits on IBM Q Tokyo using repeated 8192-shot measurements and maximum likelihood estimation of the expected payoff.All three qubits are measured so readout-error mitigation can be applied.
  • Circuit construction: The payoff operator loads a two-qubit log-normal distribution and applies a uniformly controlled Y-rotation without ancilla qubits.The resulting A circuit requires five CNOT gates and eight single-qubit Y-rotations.
  • Error mitigation: Readout-error mitigation reduces the measured error on P1 for A |0⟩3 from ∼6% to ∼4%.The method calibrates an 8 × 8 readout matrix by preparing and measuring all eight computational basis states.
  • Error mitigation: 62% to 21%: second-order Richardson extrapolation reduces the average option-price error after amplifying CNOT noise with 18, 54, and 90 CNOT-gate circuits.The mitigated results recover the same behavior as the option price obtained from classical simulations.

6 Conclusion

The paper presents gate-based quantum circuits for pricing vanilla, portfolio, multi-asset, and path-dependent options, and demonstrates amplitude-estimation pricing with reduced-gate methods and error mitigation. It concludes that larger, deeper, fault-tolerant quantum hardware is still needed for typical industry portfolios.

  • Conclusion: The methodology prices options and option portfolios on gate-based quantum computers, including exotic contracts with barriers and averages.The implemented results are available in the finance module in Qiskit.
  • Conclusion: Amplitude estimation offers a quadratic speed-up over traditional Monte Carlo simulations, although it will most likely require a universal fault-tolerant quantum computer.The paper uses an approach that retains the speed-up while requiring fewer gates to measure an option price.
  • Conclusion: The simple error-mitigation scheme greatly reduces errors from noisy quantum hardware.The hardware experiments use error mitigation to improve calculated option prices.
  • Conclusion: Larger quantum hardware with more qubits and deeper-circuit capability is needed to price typical financial-industry portfolios.This is identified as a requirement beyond currently available quantum computers.

A.1 Weighted sum of single qubits

The weighted sum operator adds binary state qubits into a sum register using classically specified binary weights. Its circuit is assembled from elementary Boolean gates while reusing available sum qubits to limit ancilla requirements.

  • A.1 Weighted sum of single qubits: The weighted sum operator S computes a weighted arithmetic sum of n state qubits and stores it in an m-qubit register initialized to zero.The weights are non-negative integers defined classically.
  • A.1 Weighted sum of single qubits: A binary matrix Ω specifies which state qubits are added to each sum-register bit according to the binary representation of their weights.An additional register can temporarily store carries during addition.
  • A.1 Weighted sum of single qubits: The construction uses X, CNOT, and Toffoli gates to compute carries, add bits, and reset carries column by column.These gates are sufficient to construct the Boolean functions needed by the weighted sum circuit.
  • A.1 Weighted sum of single qubits: At most max(k −2, 0) carry qubits are needed for an addition, with k determined by the maximum possible sum length.When k = 1, the operation reduces to copying the state qubit without producing carries.
  • A.1 Weighted sum of single qubits: Unused more-significant sum qubits can serve as carry qubits during column-wise processing.This reuse further reduces the number of additional ancilla qubits.
  • A.1 Weighted sum of single qubits: The total number of ancilla qubits required for S grows at most logarithmically with the number of state qubits n.The construction derives an upper bound by accounting for non-trivial carry operations.

A.2 Sum of multi-qubit integers

The weighted sum operator also combines several multi-qubit binary integers into one sum register. Binary weights assign each input bit its positional value, so applying the operator produces the arithmetic total.

  • A.2 Sum of multi-qubit integers: The operator prepares an input register containing d multi-qubit integers, with each integer represented in binary using its own qubit block.The least significant bit is listed first for each integer.
  • A.2 Sum of multi-qubit integers: Applying S with these weights to the input state stores the sum of all d integers in the m-qubit register |s⟩m.The same weighted-sum construction is used for the multi-integer case.
  • A.2 Sum of multi-qubit integers: A circuit example adds two 3-digit binary numbers from a 6-qubit input register and stores the result in a 4-qubit sum register.It uses weights ω = (1, 2, 4, 1, 2, 4).

A.3 Weighted sum of multi-qubit integers

The weighted sum operator adds integers represented on quantum registers with configurable weights. Non-integer weights can be converted to integer weights through common rescaling and corrected during postprocessing.

  • Weighted sums assign a weight wi to each integer a(i) before addition.
  • Figure 18 computes the sum of binary numbers |a⟩3 and |b⟩3 into |s⟩4 using weights ω = (1, 2, 4, 1, 2, 4).
  • Non-integer weights can be rescaled to integers and divided out during postprocessing.Weights 0.2 and 0.8 become w1 = 1 and w2 = 4, with the sum divided by 5 afterward.

B Optimized Circuit for QA |0⟩3

The optimized QA |0⟩3 circuit combines amplitude-amplification reflections with gate cancellations and classical postprocessing. These transformations reduce its CNOT count to 18.

  • QA |0⟩3 uses Q = −AS0A†Sψ0, with S0 and Sψ0 implementing reflections on the relevant states.Sψ0 can be implemented up to a global phase with a single-qubit Z-gate, while S0 is synthesized as a diagonal unitary.
  • The optimization drops the final CNOT through classical postprocessing and cancels neighboring CNOTs around a commuting X-rotation.
  • 18 CNOT gates remain in the optimized QA |0⟩3 circuit.
Loading 1905.02666v5…