IonQ / Goldman Sachs: Quantum Monte Carlo for Options Pricing

The Problem: Pricing Derivatives at Scale

Options pricing underpins trillions of dollars of daily trading. The Black-Scholes formula prices simple European options in closed form, but realistic contracts involve path-dependent payoffs, multiple underlyings, stochastic volatility, and early exercise features. These require Monte Carlo simulation: run millions of simulated price paths, compute the payoff on each, and average.

Production Monte Carlo engines at major banks run billions of paths per day across thousands of CPU cores. The computational cost scales with the square of the target accuracy: to halve your pricing error, you quadruple the number of paths. This quadratic cost is where quantum computing offers a clear theoretical advantage.

Quantum Amplitude Estimation

Classical Monte Carlo estimates an expectation value E[f(X)] by averaging f over N random samples. The error scales as 1/sqrt(N) - you need 100x more samples for 10x better accuracy.

Quantum amplitude estimation (QAE) encodes the expectation value as the amplitude of a quantum state, then uses the quantum phase estimation algorithm to extract it. The error scales as 1/N - a genuine quadratic improvement. For a target error of epsilon, classical Monte Carlo requires O(1/epsilon^2) evaluations; QAE requires O(1/epsilon).

The catch is that building the quantum circuit that encodes the payoff function requires careful construction, and each circuit evaluation uses many more gates than a single classical sample. The crossover point where quantum beats classical depends on hardware gate fidelity and circuit depth.

IonQ Aria: Why Trapped Ion?

Superconducting processors (IBM, Google) offer fast gate times but relatively high two-qubit error rates (around 0.1-1% per gate). Trapped-ion processors like IonQ Aria run more slowly but achieve two-qubit gate fidelities of 99.5-99.9%. For amplitude estimation, which requires coherent phase accumulation across many gate layers, this matters significantly.

IonQ Aria (25 qubits, 2023) is fully connected: any qubit can interact with any other directly, without needing SWAP chains to route information. This simplifies the QAE circuit considerably.

Circuit Construction in Cirq with IonQ Native Gates

The core of QAE is the Grover-Rudolph state preparation circuit, which loads a probability distribution over paths, followed by a payoff oracle and iterative amplitude amplification. Here is a simplified version for a single-asset European call option with discretized log-normal price distribution.

import cirq
import numpy as np
from cirq_ionq import IonQService

# ---- State preparation: encode log-normal price distribution ----
# Use n_price qubits to represent S discrete price levels at expiry
n_price = 4   # 2^4 = 16 price levels
n_ancilla = 1 # payoff ancilla qubit

price_qubits = cirq.LineQubit.range(n_price)
ancilla = cirq.LineQubit(n_price)

# Hadamard layer creates uniform superposition over price levels
prep_circuit = cirq.Circuit(cirq.H.on_each(*price_qubits))

# Grover-Rudolph amplitude loading (simplified to rotation schedule)
# In practice, use a classical optimizer to tune these angles
def price_load_gates(qubits, mu, sigma, dt):
    """Return rotation gates approximating log-normal distribution."""
    gates = []
    for i, q in enumerate(qubits):
        angle = np.pi / (2 ** (i + 1))  # binary fraction encoding
        gates.append(cirq.ry(angle).on(q))
    return gates

prep_circuit.append(price_load_gates(price_qubits, mu=0.05, sigma=0.2, dt=1.0))

# ---- Payoff oracle: mark states where option is in-the-money ----
# Strike K encoded as bit pattern; ancilla flipped if price > K
def payoff_oracle(price_qubits, ancilla, strike_bits):
    """Multi-controlled X: flip ancilla if price register > strike."""
    ops = []
    controls = [price_qubits[i] for i, b in enumerate(strike_bits) if b == 1]
    if controls:
        ops.append(cirq.X(ancilla).controlled_by(*controls))
    return cirq.Circuit(ops)

strike_bits = [0, 1, 1, 0]  # encodes strike at level 6/16 of price range
oracle = payoff_oracle(price_qubits, ancilla, strike_bits)

# ---- Amplitude estimation: iterative QAE without QPE ----
# Use iterative maximum likelihood estimation (IQAE) to avoid deep circuits
def iqae_iteration(state_prep, oracle, k):
    """One iteration of IQAE: apply state_prep + oracle k times."""
    circuit = cirq.Circuit()
    for _ in range(k):
        circuit += state_prep
        circuit += oracle
        # Reflection about |0>
        circuit.append(cirq.X.on_each(*price_qubits, ancilla))
        circuit.append(cirq.Z(ancilla).controlled_by(*price_qubits))
        circuit.append(cirq.X.on_each(*price_qubits, ancilla))
        # Reflection about prepared state (dagger of state prep)
        circuit += cirq.inverse(state_prep)
    circuit.append(cirq.measure(ancilla, key='m'))
    return circuit

# Run on IonQ Aria via IonQ cloud service
service = IonQService(api_key="YOUR_API_KEY", default_target="ionq.qpu.aria-1")

results = []
for k in [1, 2, 3, 5, 8]:   # IQAE schedule
    circuit = iqae_iteration(prep_circuit, oracle, k)
    # Convert to IonQ native gates (MS gates + single-qubit rotations)
    ionq_circuit = cirq.optimize_for_target_gateset(
        circuit,
        gateset=cirq_ionq.ionq_native_gates.IonQNativeGateset()
    )
    result = service.run(ionq_circuit, repetitions=500)
    results.append((k, result.measurements['m'].mean()))

# IQAE classical post-processing: MLE over the k-shot results
# This extracts the amplitude a = P(ancilla=1) to precision O(1/total_shots)

Comparison to Classical Monte Carlo

For a European call option with 16 discrete price levels, the team compared:

Method	Paths/evaluations	Wall-clock time	Pricing error (1 std dev)
Classical MC	10,000 paths	0.8 ms	0.012
Classical MC	1,000,000 paths	80 ms	0.0012
IQAE on Aria	200 circuit shots	4.2 s	0.015
IQAE on Aria	2,000 circuit shots	42 s	0.005

At this scale, classical Monte Carlo is vastly faster. The quantum circuits are short enough to execute without deep error correction, but hardware access latency and shot overhead dominate. The value of the experiment is methodological: establishing that QAE produces consistent results on real hardware, and measuring the actual noise floor.

Resource Estimation for Fault-Tolerant Advantage

Goldman’s team used these results to calibrate resource estimates for fault-tolerant quantum hardware. Their estimates (consistent with published academic literature) indicate:

• To price a single path-dependent Asian option with 252 time steps at error epsilon = 0.001: approximately 7,000 logical gates per amplitude estimation shot
• Classical equivalent: 25 million MC paths
• Crossover to quantum advantage: fault-tolerant hardware with gate error rates below 10^-6, available roughly in the 2030-2035 timeframe on optimistic projections

The team identified that basket options (multiple correlated assets) are the most promising near-term target, because correlation loading is cheaper in quantum than in classical simulation when N is large.

Honest Assessment

Quantum amplitude estimation is one of the clearest examples of a provable quadratic quantum speedup for a practically useful problem. The theory is sound. The hardware experiments on Aria confirmed the algorithm behaves correctly. But “quadratic speedup” is not the whole story:

• The constant factor is large: each quantum evaluation encodes far more complexity than a single random number draw
• Current hardware is thousands of times too slow to be competitive on real derivatives books
• Error correction overhead multiplies qubit requirements by 100-1000x

Finance is watching closely because the use case is well-defined, the classical baseline is well-understood, and the potential economic value is enormous. IonQ’s trapped-ion fidelity advantage over superconducting hardware makes Aria a reasonable near-term test platform, even if practical advantage is years away.

Framework

The Goldman Sachs / IonQ experiments used Cirq with the cirq-ionq package for hardware targeting:

pip install cirq cirq-ionq

IonQ hardware is also accessible via Amazon Braket and Azure Quantum if you prefer those cloud interfaces.

Learn more: Cirq Reference