Quantum Portfolio Optimization

6.1 — The Classical Portfolio Optimization Problem

Markowitz Mean-Variance Optimization

The central problem: select portfolio weights that maximize return while minimizing risk.

Where $\mathbf{w}$ = weights, $\boldsymbol{\Sigma}$ = covariance matrix, $\boldsymbol{\mu}$ = expected returns, $\lambda$ = risk-aversion parameter.

Why This Is Hard

For continuous weights, this is solvable classically. But real-world constraints make it NP-hard:

• Discrete asset selection: "Choose exactly 5 out of 50 stocks"
• Lot size constraints: "Buy in multiples of 100 shares"
• Sector limits: "No more than 30% in technology"
• Cardinality constraints: Limit on number of assets

Python: Efficient Frontier

Pythonimport numpy as np
import matplotlib.pyplot as plt

assets = ['RELIANCE', 'TCS', 'HDFCBANK', 'INFY', 'ITC']
expected_returns = np.array([0.12, 0.15, 0.10, 0.14, 0.08])
volatilities = np.array([0.25, 0.22, 0.18, 0.24, 0.15])

correlation_matrix = np.array([
    [1.00, 0.45, 0.50, 0.40, 0.30],
    [0.45, 1.00, 0.35, 0.70, 0.20],
    [0.50, 0.35, 1.00, 0.30, 0.40],
    [0.40, 0.70, 0.30, 1.00, 0.25],
    [0.30, 0.20, 0.40, 0.25, 1.00]
])

D = np.diag(volatilities)
cov_matrix = D @ correlation_matrix @ D

# Generate 10,000 random portfolios
n_portfolios = 10000
results = np.zeros((3, n_portfolios))
np.random.seed(42)

for i in range(n_portfolios):
    weights = np.random.random(len(assets))
    weights /= weights.sum()
    portfolio_return = np.dot(weights, expected_returns)
    portfolio_vol = np.sqrt(weights @ cov_matrix @ weights)
    sharpe = (portfolio_return - 0.06) / portfolio_vol
    results[0, i] = portfolio_vol
    results[1, i] = portfolio_return
    results[2, i] = sharpe

plt.figure(figsize=(12, 7))
scatter = plt.scatter(results[0], results[1], c=results[2],
                      cmap='viridis', alpha=0.5, s=10)
plt.colorbar(scatter, label='Sharpe Ratio')

max_sharpe_idx = results[2].argmax()
plt.scatter(results[0, max_sharpe_idx], results[1, max_sharpe_idx],
           marker='*', s=300, c='red', edgecolors='black',
           label=f'Max Sharpe: {results[2, max_sharpe_idx]:.2f}')

for i, asset in enumerate(assets):
    plt.scatter(volatilities[i], expected_returns[i], marker='D', s=100,
               c='white', edgecolors='black', linewidths=1.5)
    plt.annotate(asset, (volatilities[i], expected_returns[i]),
                fontsize=9, fontweight='bold', xytext=(10, 5),
                textcoords='offset points')

plt.title('Efficient Frontier: 10,000 Random Portfolios',
          fontsize=14, fontweight='bold')
plt.xlabel('Portfolio Volatility (σ)')
plt.ylabel('Expected Return (μ)')
plt.legend(fontsize=11)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

6.2 — QUBO: Making Problems Quantum-Compatible

What Is QUBO?

Quadratic Unconstrained Binary Optimization — the mathematical framework that maps optimization to quantum hardware:

Where $\mathbf{x}$ = binary vector ($x_i \in \{0, 1\}$ — include asset $i$ or not), $Q$ = QUBO matrix encoding objective and constraints.

Portfolio Optimization as QUBO

Where $q$ = risk-return tradeoff, $B$ = budget (number of assets to select), $A$ = penalty for violating budget.

6.3 — QAOA: The Quantum Optimization Algorithm

QAOA (Farhi et al., 2014) is a hybrid quantum-classical algorithm for combinatorial optimization:

QAOA vs VQE

6.4 — Python Demo: Brute Force vs QAOA

Pythonimport numpy as np
from itertools import combinations

n_assets = 4
assets = ['RELIANCE', 'TCS', 'HDFCBANK', 'INFY']
expected_returns = np.array([0.12, 0.15, 0.10, 0.14])
cov_matrix = np.array([
    [0.0625, 0.0248, 0.0225, 0.0240],
    [0.0248, 0.0484, 0.0139, 0.0370],
    [0.0225, 0.0139, 0.0324, 0.0130],
    [0.0240, 0.0370, 0.0130, 0.0576]
])

budget = 2        # Select exactly 2 assets
risk_factor = 0.5

print("=" * 60)
print(f"{'PORTFOLIO OPTIMIZATION: Select 2 from 4 assets':^60}")
print("=" * 60)
print(f"\n{'Portfolio':<25} {'Return':<10} {'Risk':<10} {'Objective':<12}")
print("-" * 60)

best_obj = float('inf')
best_portfolio = None

for combo in combinations(range(n_assets), budget):
    x = np.zeros(n_assets)
    for i in combo:
        x[i] = 1
    risk = x @ cov_matrix @ x
    ret = x @ expected_returns
    objective = risk_factor * risk - (1 - risk_factor) * ret
    portfolio_str = ' + '.join([assets[i] for i in combo])
    print(f"  {portfolio_str:<23} {ret:<10.4f} {risk:<10.4f} {objective:<12.6f}")
    if objective < best_obj:
        best_obj = objective
        best_portfolio = combo

print("-" * 60)
print(f"\n✅ Optimal: {' + '.join([assets[i] for i in best_portfolio])}")
print(f"   Objective value: {best_obj:.6f}")

Conceptual QAOA Workflow

Python# ─── Conceptual QAOA for Portfolio Optimization ───
print("\n" + "=" * 60)
print(f"{'QAOA CONCEPTUAL WORKFLOW':^60}")
print("=" * 60)
print("""
STEP 1: QUBO Formulation
   x_i ∈ {0, 1} for each asset | Q matrix encodes covariances

STEP 2: Map to Quantum Hamiltonian
   QUBO → Ising: H = Σ J_ij Z_i Z_j + Σ h_i Z_i
   4 assets → 4 qubits

STEP 3: QAOA Circuit (p=1)
   |0⟩ ─┤ H ├──┤ e^(-iγH_p) ├──┤ e^(-iβH_m) ├──┤M├
   (×4 qubits)

STEP 4: Classical Optimization Loop
   Measure → Compute cost → Update γ, β → Repeat

STEP 5: Read Optimal Portfolio
   Most frequent bitstring = optimal portfolio
   E.g., "0110" → Select TCS and HDFCBANK
""")

# Simulated QAOA convergence
print("Simulated QAOA Optimization Progress:")
print(f"{'Iter':<8} {'γ':<8} {'β':<8} {'Best Objective':<18} {'Portfolio'}")
print("-" * 65)

np.random.seed(42)
gamma, beta = np.random.uniform(0, np.pi, 2)
best_obj_qaoa = float('inf')

for iteration in range(1, 11):
    gamma += np.random.uniform(-0.1, 0.1)
    beta += np.random.uniform(-0.1, 0.1)
    current_obj = best_obj * (1 + 0.5 * np.exp(-0.5 * iteration)
                              * np.random.uniform(-1, 1))
    if current_obj < best_obj_qaoa:
        best_obj_qaoa = current_obj
    label = ' + '.join([assets[i] for i in best_portfolio])
    print(f"  {iteration:<6} {gamma:<8.3f} {beta:<8.3f} "
          f"{best_obj_qaoa:<18.6f} {label}")

print("-" * 65)
print(f"\n✅ QAOA Result: {' + '.join([assets[i] for i in best_portfolio])}")
print(f"   Matches classical optimal: YES ✓")