Goldman Sachs: Quantum Amplitude Estimation for Option Pricing

The Problem

Pricing financial derivatives like options requires computing expectations over many possible future price paths. The standard tool is Monte Carlo simulation: generate many random scenarios, compute the payoff in each, and average. Classical Monte Carlo converges at rate O(1/sqrt(N)) in the number of samples. Cutting the error in half requires four times as many samples.

For a European option, millions of samples may suffice. For exotic options with path-dependent payoffs (arithmetic Asian options, barrier options), accurate pricing requires more samples still. In practice, banks run these simulations continuously across large portfolios.

Quantum Amplitude Estimation (QAE) changes the convergence rate to O(1/N), a quadratic speedup. Goldman Sachs was among the first institutions to publish concrete, end-to-end resource estimates asking: how good does quantum hardware need to be before QAE beats classical Monte Carlo in wall-clock time?

How Quantum Amplitude Estimation Works

QAE encodes the probability distribution over future prices into a quantum state. The option payoff is encoded as a rotation angle. A procedure based on Quantum Phase Estimation (QPE) then extracts the expectation value of that payoff with quadratic sample efficiency.

The core circuit applies a Grover-like operator repeatedly. The number of applications (oracle queries) determines precision: to achieve error epsilon, QAE needs O(1/epsilon) queries versus O(1/epsilon^2) for classical Monte Carlo.

from qiskit_finance.circuit.library import LogNormalDistribution
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
import numpy as np

# Option parameters (Black-Scholes model)
S0 = 100.0     # spot price
K  = 105.0     # strike price
r  = 0.05      # risk-free rate
sigma = 0.20   # volatility
T  = 1.0       # time to maturity (years)

# Discretize the log-normal price distribution onto num_qubits qubits
num_qubits = 3
mu = (r - 0.5 * sigma**2) * T + np.log(S0)
variance = sigma**2 * T

# Price range for discretization
low  = np.exp(mu - 3 * np.sqrt(variance))
high = np.exp(mu + 3 * np.sqrt(variance))

# Quantum circuit encoding the log-normal distribution
uncertainty_model = LogNormalDistribution(
    num_qubits=num_qubits,
    mu=mu,
    sigma=np.sqrt(variance),
    bounds=(low, high),
)

# Encode the European call payoff: max(S - K, 0), normalized to [0, 1]
# for amplitude encoding
breakpoints = [low, K]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = high - K

payoff_func = LinearAmplitudeFunction(
    num_state_qubits=num_qubits,
    slope=slopes,
    offset=offsets,
    domain=(low, high),
    image=(f_min, f_max),
    breakpoints=breakpoints,
)

# Compose distribution and payoff into full state preparation circuit
num_sum_qubits = payoff_func.num_ancillas
from qiskit import QuantumCircuit
full_circuit = QuantumCircuit(num_qubits + num_sum_qubits + 1)
full_circuit.compose(uncertainty_model, range(num_qubits), inplace=True)
full_circuit.compose(payoff_func, range(num_qubits + num_sum_qubits + 1), inplace=True)

# Define the estimation problem: amplitude in the objective qubit encodes E[payoff]
problem = EstimationProblem(
    state_preparation=full_circuit,
    objective_qubits=[num_qubits + num_sum_qubits],
)

# Run Iterative QAE (avoids QPE overhead, uses fewer qubits)
sampler = Sampler()
iae = IterativeAmplitudeEstimation(
    epsilon_target=0.01,   # target estimation error
    alpha=0.05,            # confidence level
    sampler=sampler,
)
result = iae.estimate(problem)

# Rescale from normalized amplitude back to option price
estimated_price = result.estimation * (f_max - f_min) + f_min
print(f"Estimated European call price: ${estimated_price:.4f}")
print(f"Circuit evaluations used: {result.num_oracle_queries}")

Arithmetic Asian Options

European options depend only on the final stock price. Asian options depend on the average price over the life of the contract, making them path-dependent and harder to price analytically.

Goldman Sachs extended the QAE framework to arithmetic Asian options. The quantum circuit must encode a discretized price path (multiple time steps), with each step’s price contributing to the running average. This increases the qubit count roughly proportionally to the number of time steps, but the quadratic speedup in query complexity is preserved.

Resource Analysis: What It Actually Takes

The Goldman Sachs analysis is notable for being rigorous about the full resource stack, not just the asymptotic speedup.

To achieve genuine quantum advantage (faster wall-clock time than classical Monte Carlo with optimized hardware), the analysis found:

• Logical qubits: approximately 7500 (after error correction overhead)
• Gate error rate: below 10^-4 per two-qubit gate
• Circuit depth: thousands of layers for practically useful precision
• Comparison target: classical Monte Carlo running on a GPU cluster

Under these requirements, practical advantage is contingent on fault-tolerant hardware that does not yet exist. The current best two-qubit gate error rates on superconducting hardware are around 10^-3.

Near-Term Hybrid Strategy

Goldman Sachs identified quantum-enhanced variance reduction as a nearer-term approach. Instead of replacing classical Monte Carlo entirely, a small quantum computation identifies a better control variate (a correlated quantity whose classical expectation is known). This reduces the variance of the classical Monte Carlo estimator, giving a speedup without requiring fault-tolerant hardware.

This hybrid approach requires far fewer qubits and shallower circuits, making it tractable on NISQ hardware with error mitigation.

Results and Publications

Goldman Sachs published detailed findings on arXiv through their quantum computing research group (in collaboration with QC Ware). Key contributions:

• End-to-end resource estimates including error correction overhead (not just logical qubit counts)
• Extension of QAE to path-dependent payoffs (Asian, barrier options)
• Analysis of near-term hybrid strategies as a bridge to fault-tolerant advantage
• Open-source Qiskit Finance implementations allowing reproduction of results

The work is widely cited as a model for how financial institutions should assess quantum computing timelines: starting from concrete problem instances, computing exact resource requirements, and distinguishing asymptotic speedup from practical wall-clock advantage.

Framework

Goldman Sachs used Qiskit Finance for option pricing circuit construction and Qiskit Aer for simulation. Their resource estimates also used Qiskit’s circuit transpilation tools to count gate depths on specific IBM hardware topologies.

Learn more: Qiskit Finance Reference | Amplitude Estimation Algorithm Guide