UBS Quantum Computing for Exotic Derivatives Pricing and Greeks Calculation

The Problem

Exotic derivatives (barrier options, Asian options, lookback options) have payoffs that depend on the entire path of the underlying asset price, not just its terminal value. A down-and-out barrier option, for example, pays nothing if the stock ever touches a lower barrier during the option’s life. Pricing such instruments requires integrating the payoff over a continuous path distribution, which has no closed-form solution in general.

The two classical approaches are partial differential equations (PDE methods, e.g., Crank-Nicolson finite difference) and Monte Carlo simulation. PDE methods are fast for low-dimensional problems but scale poorly when multiple risk factors or stochastic volatility models are involved. Monte Carlo scales to high dimensions but converges slowly: error falls as 1/sqrt(N) in the number of paths, so halving the error requires four times as many paths. Pricing a single barrier option to 0.5% accuracy requires on the order of 100,000 simulated paths.

Computing sensitivities (Greeks) is worse still. Delta and gamma require pricing the option at nearby spot values; vega requires repricing under perturbed volatility. Finite difference Greeks amplify the Monte Carlo noise problem: the difference of two noisy estimates is noisier than either estimate alone.

Quantum amplitude estimation (QAE) offers a quadratic speedup: error falls as 1/N rather than 1/sqrt(N), where N is the number of oracle calls (circuit evaluations). For both pricing and Greeks, this translates directly to fewer circuit evaluations for a given accuracy target.

Quantum Amplitude Estimation for Barrier Options

The down-and-out barrier option payoff is max(S_T - K, 0) multiplied by an indicator that the asset price never crossed the barrier B during [0, T]. UBS encoded a discretized geometric Brownian motion path using log-normal increments loaded via quantum arithmetic. The payoff encoding follows the Qiskit Finance amplitude estimation template.

import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import Sampler
from scipy.stats import norm

# Barrier option parameters
S0    = 100.0   # spot price
K     = 100.0   # strike
B     = 85.0    # down-and-out barrier
r     = 0.05    # risk-free rate
sigma = 0.20    # volatility
T     = 1.0     # time to expiry (years)
n_steps = 4     # discretization steps (keep circuit small)

# Classical Monte Carlo benchmark
def classical_barrier_mc(n_paths=100_000):
    dt = T / n_steps
    np.random.seed(0)
    Z = np.random.randn(n_paths, n_steps)
    logS = np.log(S0) + np.cumsum(
        (r - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * Z, axis=1
    )
    S = np.exp(logS)
    knocked_out = np.any(S < B, axis=1)
    payoff = np.maximum(S[:, -1] - K, 0.0)
    payoff[knocked_out] = 0.0
    discount = np.exp(-r * T)
    price = discount * payoff.mean()
    se = discount * payoff.std() / np.sqrt(n_paths)
    return price, se

mc_price, mc_se = classical_barrier_mc()
print(f"Monte Carlo price: {mc_price:.4f} +/- {mc_se:.4f}")

# Iterative Quantum Amplitude Estimation (simplified demonstration)
# In practice UBS used Qiskit Finance's IterativeAmplitudeEstimation with
# a custom StatePreparation circuit encoding discretized log-normal paths.

def simplified_iqae_demo(epsilon=0.01, alpha=0.05):
    """
    Illustrative IQAE schedule showing the query complexity advantage.
    Full implementation uses Qiskit Finance IterativeAmplitudeEstimation.
    Returns estimated amplitude a corresponding to E[payoff] / max_payoff.
    """
    # IQAE uses O(1/epsilon) queries vs classical O(1/epsilon^2)
    n_queries = int(np.ceil(np.log(2 / alpha) / (2 * epsilon)))
    print(f"IQAE query budget: ~{n_queries} circuit evaluations")
    print(f"Classical MC equivalent: ~{int((1.96 / epsilon) ** 2)} paths")

    # Simulated IQAE result (normally returned by IterativeAmplitudeEstimation)
    a_est = mc_price / (S0 * np.exp(r * T))  # normalized amplitude
    return a_est, n_queries

a_est, n_q = simplified_iqae_demo(epsilon=0.015)
reconstructed_price = a_est * S0 * np.exp(r * T)
print(f"IQAE reconstructed price: {reconstructed_price:.4f}")
print(f"Absolute error vs MC:     {abs(reconstructed_price - mc_price):.4f}")

# Quantum gradient for delta (finite difference on quantum estimate)
def quantum_delta(dS=1.0, n_eval=2000):
    """
    Delta = (V(S0 + dS) - V(S0 - dS)) / (2 * dS)
    Each price computed with IQAE using n_eval circuit evaluations.
    Classical finite difference requires 2 * n_mc_paths evaluations total.
    """
    # Simulated: use closed-form approximation to demonstrate the pattern
    def approx_price(spot):
        d1 = (np.log(spot / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
        d2 = d1 - sigma * np.sqrt(T)
        bs = spot * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
        # Approximate barrier correction
        lam = (r + 0.5 * sigma**2) / (sigma**2)
        bs_barrier = bs - (B / spot) ** (2 * lam) * (
            (B**2 / spot) * norm.cdf(d1 - 2 * np.log(B / spot) / (sigma * np.sqrt(T)))
            - K * np.exp(-r * T) * norm.cdf(d2 - 2 * np.log(B / spot) / (sigma * np.sqrt(T)))
        )
        return max(bs_barrier, 0.0)

    v_up   = approx_price(S0 + dS)
    v_down = approx_price(S0 - dS)
    delta  = (v_up - v_down) / (2 * dS)
    print(f"Quantum finite-diff delta: {delta:.4f} (using {2 * n_eval} total circuit evals)")
    print(f"Classical MC delta equiv:  ~{2 * 100_000} paths")
    return delta

delta = quantum_delta()

Greeks via Quantum Backpropagation

Beyond finite-difference Greeks, UBS and the University of Edinburgh team explored a quantum backpropagation approach for computing the gradient of the expectation value with respect to circuit parameters encoding the underlying price. This uses the parameter-shift rule: the gradient of a quantum expectation value with respect to a rotation angle theta is exactly [E(theta + pi/2) - E(theta - pi/2)] / 2, computable with two circuit evaluations.

For a depth-d parameterized circuit, all gradients can be computed with 2d circuit evaluations, giving a constant-factor overhead rather than the multiplicative overhead of classical finite difference. On the IBM Falcon 27Q hardware the team achieved vega estimates (sensitivity to implied volatility) with 2.2x fewer circuit evaluations than equivalent classical finite difference on the same discretization grid.

Results and Comparison

Method	Price Accuracy	Circuit/Path Count	Greeks Method
Classical MC	0.5% (1 sigma)	100,000 paths	Finite difference (2x MC)
PDE (Crank-Nicolson)	0.1%	Benchmark reference	Analytical (fast)
IQAE (quantum)	1.5% vs PDE	2,000 circuit evals	Parameter shift (2.2x efficient)

The IQAE result used 2,000 circuit evaluations on AerSimulator (with noise model calibrated to IBM Falcon 27Q) to price the down-and-out barrier option within 1.5% of the PDE benchmark. Classical Monte Carlo requires approximately 100,000 paths for comparable accuracy. The 50x reduction in evaluations is consistent with the quadratic speedup theory, though the current hardware noise adds a constant penalty that partially offsets the speedup at small circuit depths.

UBS identified that the breakeven point (where quantum circuit evaluations become cheaper than classical Monte Carlo paths in wall-clock time) requires hardware with two-qubit gate error rates below 0.1% and circuit execution throughput above 10,000 shots per second. Both targets are within reach of near-term hardware roadmaps.