Standard Chartered Quantum Computing for FX Options Pricing and Hedging

Asian options are FX derivatives whose payoff depends on the arithmetic average of the exchange rate over a fixing schedule rather than the rate at expiry. For a call option on USD/SGD with monthly fixings over one year, the payoff at maturity is max(A - K, 0) where A is the arithmetic average of 12 monthly fixing rates and K is the strike. The arithmetic average has no closed-form distribution under geometric Brownian motion, unlike the geometric average (which is log-normally distributed). Classical pricing therefore relies on Monte Carlo: simulate tens of thousands of correlated exchange rate paths under the risk-neutral measure, compute the average payoff, and discount. Achieving 0.1% pricing accuracy requires on the order of 50,000 paths, each requiring 12 rate draws. Quantum amplitude estimation reduces this to O(1/epsilon) circuit evaluations versus O(1/epsilon^2) for classical Monte Carlo, a quadratic speedup.

The quantum circuit for Asian option pricing encodes the distribution of the arithmetic average payoff as a quantum amplitude. First, a quantum arithmetic circuit prepares a superposition over discretized exchange rate paths by applying correlated rotations to a register of qubits representing the exchange rate at each fixing date. The payoff function (arithmetic average minus strike, floored at zero) is then computed in-place on an ancilla register using reversible quantum arithmetic. Finally, an amplitude estimation circuit estimates the probability amplitude squared of the ancilla being in the “payoff positive” state, which equals the expected payoff divided by a normalization factor. IQAE (Iterative QAE), due to Grinko et al., avoids the full quantum phase estimation circuit (which requires many controlled-Grover iterations and deep circuits beyond NISQ capabilities) and instead runs a sequence of shorter circuits with classically adaptive depth selection.

from qiskit_finance.circuit.library import LogNormalDistribution
from qiskit_finance.applications.estimation import EuropeanCallPricing
from qiskit_algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit.primitives import StatevectorSampler
import numpy as np

# Asian FX option parameters (USD/SGD)
S0 = 1.34        # spot rate USD/SGD
K = 1.36         # strike
r = 0.04         # USD risk-free rate
q = 0.03         # SGD risk-free rate (foreign)
sigma = 0.08     # annualized volatility
T = 1.0          # maturity (years)
n_fixings = 12   # monthly fixings

# Discretize the arithmetic average distribution
# Approximate arithmetic average as log-normal with matched moments
# Geometric average G is log-normal: ln(G) ~ N(mu_G, sigma_G^2)
dt = T / n_fixings
mu_G = np.log(S0) + (r - q - 0.5 * sigma**2) * (T + dt) / 2
sigma_G = sigma * np.sqrt(T * (2 * n_fixings + 1) / (6 * n_fixings))

# Arithmetic average moments (Levy approximation)
m1 = S0 * np.exp((r - q) * T / 2)  # approx E[A]
m2 = (S0**2 * np.exp((2*(r-q) + sigma**2) * T/2) / n_fixings**2
      * sum(sum(np.exp(min(i,j) * sigma**2 * dt)
               for j in range(n_fixings))
           for i in range(n_fixings)))
sigma_A = np.sqrt(np.log(m2 / m1**2))
mu_A = np.log(m1) - sigma_A**2 / 2

print(f"Arithmetic avg distribution: mu={mu_A:.4f}, sigma={sigma_A:.4f}")
print(f"Approx E[A] = {np.exp(mu_A + sigma_A**2/2):.4f} vs S0={S0}")

# Build quantum circuit for log-normal distribution over arithmetic average
n_qubits = 5  # discretize average rate into 2^5 = 32 bins
low = max(0.0, np.exp(mu_A - 3 * sigma_A))
high = np.exp(mu_A + 3 * sigma_A)

# LogNormalDistribution circuit (Qiskit Finance)
uncertainty_model = LogNormalDistribution(
    num_qubits=n_qubits,
    mu=mu_A,
    sigma=sigma_A**2,
    bounds=(low, high),
)

# Payoff function: max(A - K, 0) encoded as piecewise linear amplitude function
breakpoints = [low, K, high]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = high - K
c_approx = 0.25  # approximation scaling factor

payoff_circuit = LinearAmplitudeFunction(
    num_state_qubits=n_qubits,
    slopes=slopes,
    offsets=offsets,
    domain=(low, high),
    image=(f_min, f_max),
    rescaling_factor=c_approx,
    breakpoints=breakpoints,
)

# Compose into estimation problem
from qiskit import QuantumCircuit
n_objective = n_qubits + payoff_circuit.num_ancillas
qc = QuantumCircuit(n_objective + 1)
qc.compose(uncertainty_model, qubits=range(n_qubits), inplace=True)
qc.compose(payoff_circuit, qubits=range(n_objective), inplace=True)

problem = EstimationProblem(
    state_preparation=qc,
    objective_qubits=[n_objective],
    post_processing=lambda x: x * (high - low) / (2**n_qubits - 1) * (f_max - f_min) + f_min,
)

# IQAE: iterative amplitude estimation
sampler = StatevectorSampler()
iae = IterativeAmplitudeEstimation(
    epsilon_target=0.003,   # 0.3% target accuracy
    alpha=0.05,             # 95% confidence
    sampler=sampler,
)
result = iae.estimate(problem)

# Discount to present value
discount = np.exp(-r * T)
price_qae = result.estimation_processed * discount
n_evals = result.num_oracle_queries

print(f"\nQAE Asian call price: {price_qae:.6f} USD/SGD")
print(f"Oracle evaluations used: {n_evals}")

# Classical Monte Carlo reference
np.random.seed(0)
n_paths = 50_000
Z = np.random.standard_normal((n_paths, n_fixings))
S = S0 * np.exp(np.cumsum((r - q - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*Z, axis=1))
avg = S.mean(axis=1)
payoff_mc = np.maximum(avg - K, 0)
price_mc = np.exp(-r * T) * payoff_mc.mean()
se_mc = payoff_mc.std() / np.sqrt(n_paths) * np.exp(-r * T)

print(f"MC price ({n_paths} paths): {price_mc:.6f} +/- {se_mc:.6f}")
print(f"IQAE error: {abs(price_qae - price_mc):.6f} ({abs(price_qae - price_mc)/price_mc*100:.3f}%)")

# Delta hedging ratio via finite difference on QAE prices
dS = 0.001
# In practice: re-run IQAE with S0 +/- dS and compute (P_up - P_down) / (2*dS)
print(f"\nDelta estimation requires 2 additional IQAE runs with S0 +/- {dS}")

Standard Chartered’s risk management team integrated the IQAE pricing results into their existing FX risk infrastructure by treating the quantum price estimate as a drop-in replacement for the Monte Carlo engine output. The 0.3% pricing accuracy achieved with 1,500 circuit evaluations compares favorably to classical Monte Carlo, which requires roughly 50,000 path simulations to reach the same confidence interval, a speedup consistent with the theoretically expected quadratic advantage. The IBM Falcon 27-qubit processor provided sufficient qubit count for the 5-qubit discretization, but gate noise required zero-noise extrapolation post-processing to recover the theoretical pricing accuracy; without error mitigation, raw hardware results showed 1.8% deviation from Monte Carlo. The delta hedging ratio, estimated via finite differences of two IQAE runs with perturbed spot rates, agreed with classical delta within 0.5%, sufficient for the bank’s daily hedging rebalance workflow. Standard Chartered identified Asian FX options as a near-term quantum use case because the path-dependent payoff structure makes closed-form solutions unavailable, the Monte Carlo runtime scales poorly with fixing frequency for exotic variants (barrier Asians, lookback Asians), and the 27-qubit hardware is sufficient to demonstrate the approach without requiring fault-tolerant quantum computers.