Skip to content

Chapter 20: QML in Finance and Optimization

Finance offers compelling QML application domains: portfolio optimization (combinatorial, NP-hard), derivative pricing (Monte Carlo acceleration), risk assessment (credit scoring, fraud detection), and market simulation. Quantum algorithms — QAOA for combinatorial problems, quantum Monte Carlo, and quantum amplitude estimation — promise quadratic speedups in sampling and portfolio optimization. This chapter covers the theory and implementation of quantum finance algorithms.

Learning Objectives

By the end of this chapter, you will be able to:

  • Formulate portfolio optimization as a QUBO and solve with QAOA

  • Apply quantum amplitude estimation for option pricing speedup

  • Implement quantum Monte Carlo for risk assessment

  • Train quantum classifiers for credit scoring and fraud detection

  • Evaluate the practical quantum advantage window for financial applications

20.1 Portfolio Optimization as QUBO

20.1.1 Markowitz Portfolio Optimization

The classical Markowitz model (Markowitz 1952) minimizes portfolio risk subject to return constraints:

\[\begin{align*} \min_{\mathbf{w}} &\quad \mathbf{w}^\top\Sigma\mathbf{w} \\ \text{s.t.} &\quad \mathbf{w}^\top\boldsymbol{\mu} \geq R_\text{target} \\ &\quad \sum_i w_i = 1,\quad w_i \geq 0 \end{align*}\]

For binary selection (\(w_i\in\{0,1\}\), select \(k\) of \(N\) assets):

\[\min_{\mathbf{x}\in\{0,1\}^N}\left[ q\sum_{i,j}x_i\sigma_{ij}x_j - \sum_i\mu_i x_i + \lambda\left(\sum_i x_i - k\right)^2 \right]\tag{20.4}\]

where \(q\) is risk aversion, \(\lambda\) is a penalty for violating the cardinality constraint. This is a Quadratic Unconstrained Binary Optimization (QUBO).

20.1.2 QUBO to Ising Mapping

Map \(x_i\in\{0,1\}\) to \(s_i\in\{-1,+1\}\) via \(x_i = (1-s_i)/2\). The QUBO becomes an Ising problem:

\[H_\text{Ising} = -\sum_i h_i s_i - \sum_{i<j} J_{ij}s_is_j\tag{20.5}\]

QAOA minimizes this Hamiltonian on a quantum computer.

20.2 QAOA for Portfolio Optimization

Algorithm: QAOA Portfolio Optimizer

Inputs: Returns \(\boldsymbol{\mu}\), covariance \(\Sigma\), risk aversion \(q\), target assets \(k\), circuit depth \(p\).

Steps:

  1. Encode portfolio as Ising Hamiltonian \(H_C\).

  2. Initialize \(|\psi_0\rangle = H^{\otimes N}|0\rangle^N\) (uniform superposition).

  3. Apply \(p\) alternating layers: \(U_B(\beta) = e^{-i\beta B}\) where \(B = \sum_i X_i\) (mixer), \(U_C(\gamma) = e^{-i\gamma H_C}\) (cost).

  4. Measure and compute portfolio expectation value.

  5. Optimize \(\{\gamma_l, \beta_l\}\) classically.

  6. Sample best portfolio from converged state.

Solved Example 20.1

Problem: Set up the QUBO matrix for a 3-asset portfolio selection problem with returns \(\boldsymbol{\mu} = [0.1, 0.2, 0.15]\), variance \(\boldsymbol{\sigma}^2 = [0.05, 0.08, 0.06]\) (uncorrelated, \(\Sigma = \text{diag}(\sigma^2)\)), risk aversion \(q=0.5\), and \(k=2\) assets to select.

Solution: Penalty for \(\sum x_i = 2\): \(\lambda(\sum x_i - 2)^2\).

QUBO objective: \(f(x) = 0.5(0.05x_1^2 + 0.08x_2^2 + 0.06x_3^2) - 0.1x_1 - 0.2x_2 - 0.15x_3 + \lambda(x_1+x_2+x_3-2)^2\)

Since \(x_i^2 = x_i\) (binary), the diagonal terms are \((q\sigma_i^2 + \lambda - \mu_i)\) and off-diagonal terms are \(2\lambda\) (from cross terms of \((x_i+x_j)^2\)).

With \(\lambda=1\): \(Q_{ii} = 0.5\sigma_i^2 + 1 - \mu_i\): \(Q_{11}=0.925\), \(Q_{22}=0.84\), \(Q_{33}=0.88\). \(Q_{ij} = 2\lambda = 2\) for all \(i\neq j\).

The QUBO matrix is \(Q = \begin{pmatrix}0.925&2&2\\2&0.84&2\\2&2&0.88\end{pmatrix}\).

20.3 Quantum Monte Carlo for Option Pricing

Classical Monte Carlo (MC) for pricing a European call option:

\[V = e^{-rT}\mathbb{E}[\max(S_T - K, 0)] \approx e^{-rT}\frac{1}{M}\sum_{m=1}^M\max(S_T^{(m)} - K, 0)\tag{20.6}\]

Convergence: \(O(1/\sqrt{M})\) error after \(M\) samples.

20.3.1 Quantum Amplitude Estimation

Quantum Amplitude Estimation (QAE) (Brassard et al. 2002) estimates \(a = \sin^2\theta\) from the output of a quantum operator \(\mathcal{A}\):

\[\mathcal{A}|0\rangle = \sqrt{1-a}|\text{bad}\rangle + \sqrt{a}|\text{good}\rangle\tag{20.7}\]

with error \(O(1/M)\) using \(M\) queries (quadratic speedup over classical MC which needs \(O(1/M^2)\) samples for \(O(1/M)\) error).

Option pricing via QAE:

  1. Load asset price distribution \(P(S)\) into quantum state using QRAM

  2. Compute payoff \(\max(S-K,0)\) as quantum arithmetic

  3. Apply amplitude estimation to extract \(\mathbb{E}[\text{payoff}]\)

Quantum speedup: \(O(1/\epsilon)\) vs. \(O(1/\epsilon^2)\) classically.

20.4 Quantum Classifiers for Financial ML

Left: Efficient frontier for a 6-asset portfolio universe; the star marks the QAOA optimal binary portfolio (highest Sharpe ratio). Right: QAOA approximation ratio vs circuit depth p, converging…
Figure 20.1. Left: Efficient frontier for a 6-asset portfolio universe; the star marks the QAOA optimal binary portfolio (highest Sharpe ratio). Right: QAOA approximation ratio vs circuit depth \(p\), converging toward the exact optimum. Figure drawn for this book

Financial classification tasks (credit scoring, fraud detection, bankruptcy prediction) naturally use:

  • QSVMs: Quantum kernel advantage for structured financial data

  • QNNs: Hybrid classifiers with quantum feature extraction

  • Quantum transfer learning: Pre-trained quantum features for small financial datasets

20.5 Implementation: QAOA Portfolio and Quantum Finance

import pennylane as qml
import numpy as np
from scipy.optimize import minimize

# -- Portfolio data --------------------------------------------
n_assets = 4
np.random.seed(42)
# Simulated returns and covariance
mu    = np.array([0.10, 0.18, 0.14, 0.08])  # expected returns
sigma = np.array([      # covariance matrix
    [0.05, 0.01, 0.02, 0.01],
    [0.01, 0.08, 0.03, 0.02],
    [0.02, 0.03, 0.06, 0.01],
    [0.01, 0.02, 0.01, 0.04]
])
q_risk = 0.5    # risk aversion
k = 2           # number of assets to select
lam = 3.0       # penalty strength

# -- Build Ising Hamiltonian ----------------------------------
def portfolio_ising(mu, sigma, q, k, lam):
    """
    Returns (h, J) for the Ising problem:
      H = sum_i h_i*Z_i + sum_ij J_ij*Z_i*Z_j
    """
    n = len(mu)
    # QUBO: Q_ij
    Q = np.zeros((n, n))
    for i in range(n):
        Q[i, i] = q * sigma[i, i] + lam - mu[i] - 2*lam*k
    for i in range(n):
        for j in range(i+1, n):
            Q[i, j] = q * sigma[i, j] + 2*lam
            Q[j, i] = Q[i, j]

    # Convert QUBO x_i in {0,1} to Ising s_i in {-1,+1}: x_i=(1-s_i)/2
    # H_Ising = (1/4) sum_ij Q_ij s_i s_j + offset
    h = np.zeros(n)
    J = np.zeros((n, n))
    for i in range(n):
        h[i] = -0.5 * (Q[i, i] + sum(Q[i, j] for j in range(n) if j != i))
    for i in range(n):
        for j in range(i+1, n):
            J[i, j] = 0.25 * Q[i, j]
    return h, J

h, J = portfolio_ising(mu, sigma, q_risk, k, lam)

# -- QAOA circuit ----------------------------------------------
dev = qml.device("default.qubit", wires=n_assets)
p_layers = 2  # QAOA depth

def cost_unitary(gamma, h, J, wires):
    """Apply cost Hamiltonian unitary exp(-i*gamma*H_C)."""
    for i in wires:
        qml.RZ(2 * gamma * h[i], wires=i)
    for i in range(len(wires)):
        for j in range(i+1, len(wires)):
            if abs(J[i, j]) > 1e-10:
                qml.CNOT(wires=[wires[i], wires[j]])
                qml.RZ(2 * gamma * J[i, j], wires=wires[j])
                qml.CNOT(wires=[wires[i], wires[j]])

def mixer_unitary(beta, wires):
    """Apply mixer Hamiltonian unitary exp(-i*beta*sum_X)."""
    for w in wires:
        qml.RX(2 * beta, wires=w)

@qml.qnode(dev, diff_method="parameter-shift")
def qaoa_circuit(params, h, J):
    """p-layer QAOA circuit for portfolio optimization."""
    gammas = params[:p_layers]
    betas  = params[p_layers:]
    wires  = list(range(n_assets))

    # Uniform superposition
    for w in wires:
        qml.Hadamard(wires=w)

    # Alternating layers
    for l in range(p_layers):
        cost_unitary(gammas[l], h, J, wires)
        mixer_unitary(betas[l], wires)

    # Measure cost Hamiltonian expectation
    cost_terms = []
    for i in wires:
        if abs(h[i]) > 1e-10:
            cost_terms.append(h[i] * qml.PauliZ(i))
    for i in range(len(wires)):
        for j in range(i+1, len(wires)):
            if abs(J[i, j]) > 1e-10:
                cost_terms.append(
                    J[i, j] * (qml.PauliZ(i) @ qml.PauliZ(j))
                )

    H_obs = qml.Hamiltonian(
        [t.coeffs[0] if hasattr(t, 'coeffs') else 1.0 for t in cost_terms],
        [t.ops[0] if hasattr(t, 'ops') else t for t in cost_terms]
    )
    return qml.expval(H_obs)

# -- Optimize QAOA parameters ---------------------------------
def objective(params):
    return qaoa_circuit(params, h, J)

np.random.seed(1)
init_params = np.random.uniform(0, np.pi, 2 * p_layers)
result = minimize(objective, init_params, method='COBYLA',
                  options={'maxiter': 500, 'rhobeg': 0.5})

print(f"Optimized QAOA cost: {result.fun:.4f}")
print(f"Parameters: {result.x}")

# -- Sample from optimized circuit to find best portfolio -----
@qml.qnode(dev)
def sample_portfolio(params):
    gammas = params[:p_layers]
    betas  = params[p_layers:]
    wires  = list(range(n_assets))
    for w in wires:
        qml.Hadamard(wires=w)
    for l in range(p_layers):
        cost_unitary(gammas[l], h, J, wires)
        mixer_unitary(betas[l], wires)
    return qml.sample(wires=wires)

samples = sample_portfolio(result.x).reshape(-1, n_assets)
# Find most frequent bitstring = best portfolio
from collections import Counter
portfolio_counts = Counter(map(tuple, samples.tolist()[:100]))
best_portfolio = max(portfolio_counts, key=portfolio_counts.get)
selected = [i for i, x in enumerate(best_portfolio) if x == 1]
print(f"\nBest portfolio (QAOA): assets {selected}")
print(f"Expected return: {sum(mu[i] for i in selected):.4f}")
print(f"Portfolio risk:  {np.array([sigma[i,j] for i in selected for j in selected]).sum():.4f}")

20.6 Chapter Summary

Chapter Summary

  • Portfolio optimization: Markowitz binary selection is a QUBO, solvable by QAOA or quantum annealers. Quadratic speedup over brute-force for combinatorial selection.

  • Quantum Monte Carlo: QAE gives \(O(1/\epsilon)\) complexity for option pricing vs. \(O(1/\epsilon^2)\) classical. Requires fault-tolerant QC.

  • Quantum classifiers: QSVM and QNN for credit scoring and fraud detection using quantum kernels on financial time series.

  • Quantum advantage: Amplitude estimation (fault-tolerant), QAOA (near-term heuristic), quantum ML on structured financial data.

  • Practical note: Near-term quantum advantage in finance requires circuit depths beyond NISQ; classical heuristics (genetic algorithms, simulated annealing) remain competitive for current qubit counts.

Exercises

Exercise . Formulate the binary knapsack problem (maximize value subject to weight constraint) as a QUBO. How does it differ from the portfolio optimization QUBO?

Exercise . Show that quantum amplitude estimation achieves a quadratic speedup over classical Monte Carlo: derive the \(O(1/M)\) error bound for QAE using \(M\) oracle calls, compared to \(O(1/\sqrt{M})\) for classical MC.

Exercise . Implement QAOA for portfolio optimization with 5 assets using real historical return data (obtain it from Yahoo Finance). Compare QAOA solution quality (expected return, risk) with the brute-force optimal solution.

Further Reading

  • Markowitz (1952) (Markowitz 1952) — modern portfolio theory

  • Brassard et al. (2002) (Brassard et al. 2002) — quantum amplitude estimation

  • Egger et al. (2020) — quantum computing for finance: state of the art

  • Woerner & Egger (2019) — quantum risk analysis using amplitude estimation

  • Orús et al. (2019) — quantum computing for finance survey