⚛️ quantum physics

Large-scale portfolio optimization on a trapped-ion quantum computer

This paper presents and experimentally validates an end-to-end pipeline for large-scale portfolio optimization on a 64-qubit trapped-ion quantum computer, which combines RMT-based asset clustering with a hardware-aware greedy splitting scheme and bias-field digitized counterdiabatic quantum optimization to demonstrate that larger executable subproblems systematically improve solution quality and risk-return trade-offs.

Original authors: Alejandro Gomez Cadavid, Ananth Kaushik, Pranav Chandarana, Miguel Angel Lopez-Ruiz, Gaurav Dev, Willie Aboumrad, Qi Zhang, Claudio Girotto, Sebastián V. Romero, Martin Roetteler, Enrique Solano, Marc

Published 2026-03-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alejandro Gomez Cadavid, Ananth Kaushik, Pranav Chandarana, Miguel Angel Lopez-Ruiz, Gaurav Dev, Willie Aboumrad, Qi Zhang, Claudio Girotto, Sebastián V. Romero, Martin Roetteler, Enrique Solano, Marco Pistoia, Narendra N. Hegade

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a chef trying to create the perfect 125-dish tasting menu from a massive pantry of 250 ingredients. Your goal is to pick the best combination that balances flavor (return) and health risks (volatility), while strictly sticking to the rule: "You must pick exactly 125 items."

This is the real-world problem of Portfolio Optimization. It's a math nightmare because the number of possible combinations is so huge that even the world's fastest supercomputers struggle to find the perfect menu in a reasonable time.

This paper describes a clever new way to solve this problem using a Trapped-Ion Quantum Computer (a very advanced, futuristic type of computer). Here is how they did it, explained simply:

1. The Problem: The "Too Big to Cook" Pantry

Trying to cook a 250-ingredient menu on a tiny stove (current quantum computers) is impossible. The stove only has room for a few pots at a time. If you try to cook everything at once, the kitchen explodes (the computer crashes or gives garbage results).

2. The Solution: The "Smart Kitchen Team" Strategy

Instead of trying to cook the whole menu at once, the authors built an end-to-end pipeline (a step-by-step recipe) that breaks the big problem into smaller, manageable chunks.

Step A: Grouping Ingredients (The "Community Detective")

First, they looked at how the ingredients relate to each other.

The Analogy: Imagine you notice that "Tomatoes, Basil, and Mozzarella" always go together, while "Fish and Chocolate" never mix.
The Tech: They used a mathematical trick called Random Matrix Theory to filter out the "noise" (random market fluctuations) and find the real "communities" of assets that move together. They grouped the 250 assets into clusters based on these relationships.

Step B: The Size Limit (The "Pot Size" Rule)

The quantum computer (the stove) has a strict limit: it can only hold 36 or 64 pots (qubits) at once.

The Analogy: If a group of ingredients has 80 items, you can't put them all in one pot. You have to split them up.
The Tech: They used a "greedy splitting" method. If a cluster was too big, they chopped it up into smaller groups that fit perfectly into the quantum computer's "pot size," ensuring no ingredient was left behind.

Step C: The Quantum Chef (BF-DCQO)

Now, they sent these small groups to the quantum computer.

The Analogy: Instead of a human chef guessing which ingredients work best, they used a Quantum Chef named BF-DCQO.
How it works: This chef doesn't need to "learn" from mistakes over and over (like traditional AI). Instead, it uses a special "shortcut" technique (Counter-Diabatic) to slide down a hill of possibilities very quickly to find the lowest point (the best solution). It's like sliding down a slide instead of walking down a mountain.

Step D: The "Taste Test" and Fix (Post-Processing)

The quantum computer gave them a list of "low-energy" (good) candidates, but they weren't perfect.

The Problem: The quantum computer might have picked 124 items instead of 125, or 126.
The Fix: They used a two-step "repair crew":
1. The Fixer: If you have too many items, they swap out the "worst" ones. If you have too few, they add the "best" missing ones.
2. The Local Search: They did a quick "neighborhood check," swapping two items to see if the menu got even better. This is a classic computer trick to polish the quantum result.

3. The Results: Bigger Pots, Better Meals

They tested this on a real quantum computer made by IonQ (using trapped ions, which are like tiny atoms held in place by lasers).

The Experiment: They tried solving the problem with a 36-pot stove and a 64-pot stove.
The Discovery: The bigger stove (64 qubits) did a much better job.
- Why? When you have a bigger pot, you don't have to chop the ingredients up as much. You keep more of the "flavor connections" between ingredients intact.
- The Outcome: The 64-qubit version produced portfolios that were closer to the "perfect" theoretical menu and offered better risk-reward trade-offs than the smaller version or random guessing.

The Big Takeaway

This paper proves that we don't need a perfect, massive quantum computer to solve huge financial problems today.

Instead, we can use a hybrid approach:

Break the problem down smartly based on how the data is connected.
Fit the pieces into the quantum computer's current size limits.
Use the quantum computer to find the best local solutions.
Use classical computers to stitch the pieces back together and fix any small errors.

It's like building a massive skyscraper: you don't lift the whole building at once. You build it floor by floor, using the crane (quantum computer) to lift the heavy beams, and the workers (classical computers) to bolt them together. As the cranes get bigger (more qubits), the buildings we can construct get taller and more impressive.

1. Problem Statement

The paper addresses cardinality-constrained portfolio selection, a prototypical NP-hard combinatorial optimization problem in finance.

Objective: Select a fixed number ( $K$ ) of assets from a universe of $N$ assets to optimize the trade-off between expected return and risk (variance), based on the Markowitz mean-variance framework.
Constraints: The solution must satisfy a strict cardinality constraint ( $\sum x_i = K$ ), where $x_i \in \{0,1\}$ indicates asset inclusion.
Challenges:
- Scale: Real-world universes (e.g., S&P 500) are too large for current quantum processors (QPs) to solve directly.
- Hardware Limitations: Current QPs have limited qubit counts, connectivity constraints, and noise, making direct execution of dense Ising/QUBO formulations impossible for large $N$ .
- Noise: Near-term devices suffer from decoherence and gate errors, requiring algorithms that are robust to noise and avoid long, variational training loops.

2. Methodology: End-to-End Hardware-Aware Pipeline

The authors propose a complete workflow that bridges empirical market data to executable quantum subproblems and back to a global solution. The pipeline consists of four main stages:

A. Hardware-Aware Decomposition

To fit the problem onto a target quantum processor with a qubit limit $Q_{max}$ :

Denoising: The empirical correlation matrix $C$ is decomposed using Random Matrix Theory (RMT) (Marchenko-Pastur spectral separation) into noise ( $C_{noise}$ ), a global market mode ( $C_{global}$ ), and structured informative modes ( $C_{\star}$ ). Clustering is performed only on $C_{\star}$ to suppress noise-driven correlations.
Community Detection: A community detection algorithm (e.g., Louvain) identifies correlated asset groups on $C_{\star}$ .
Greedy Splitting: If a community exceeds $Q_{max}$ , it is recursively split using a correlation-guided greedy algorithm. This selects a high-degree node and groups it with its most strongly correlated neighbors until the cluster size hits $Q_{max}$ . This ensures no assets are discarded and every cluster fits the hardware budget.

B. Quantum Optimization (BF-DCQO)

Each cluster defines a smaller QUBO subproblem, mapped to an Ising Hamiltonian ( $H_f$ ). These are solved using Bias-Field Digitized Counterdiabatic Quantum Optimization (BF-DCQO):

Non-Variational: Unlike QAOA, BF-DCQO does not require classical parameter tuning loops, making it more robust to noise and faster to execute.
Mechanism: It follows an adiabatic path from a biased initial Hamiltonian ( $H_i$ ) to the target ( $H_f$ ). To counteract non-adiabatic transitions caused by short evolution times, a Counterdiabatic (CD) term ( $A_\lambda$ ) is added.
Digitization: The evolution is digitized via Trotterization. A pruning technique is applied to discard gates with rotation angles below a threshold, reducing circuit depth and accumulated noise.
Bias Update: The algorithm iteratively updates bias fields based on the empirical spin orientations of low-energy samples, refining the search.

C. Post-Processing and Recombination

Since quantum sampling does not inherently preserve the global cardinality constraint ( $K$ ), a two-stage classical post-processing routine is applied:

Gradient-Based Repair: Projects near-feasible solutions onto the constraint manifold. If the Hamming weight $w(x) \neq K$ , assets are flipped based on the gradient of the objective function to minimize the cost of the change.
Swap Local Search: A "first-improvement" local search explores the neighborhood of fixed Hamming weight by swapping in/out assets. This refines the solution to a local optimum.
Recombination: Low-energy candidates from all clusters are recombined into global portfolios, which are then subjected to the global local search.

3. Experimental Setup

Dataset: A 250-asset universe derived from the S&P 500 (daily closing prices, 2020–2025). Target cardinality $K=125$ .
Hardware:
- IonQ Forte: 36-qubit system (Ytterbium ions).
- IonQ Barium Development System: 64-qubit system (Barium ions), similar to the upcoming IonQ Tempo line.
Configurations:
- 36-qubit limit: Decomposed into 14 clusters (max size 36).
- 64-qubit limit: Decomposed into 11 clusters (max size 60).
Baselines: Randomized selection, recombined optimal subproblem solutions (without global search), and classical solvers (Gurobi) for small subproblems.

4. Key Results

Scaling with Qubit Budget: Increasing the executable subproblem size from 36 to 60 qubits (by moving to the 64-qubit hardware) systematically improved the final objective values and risk-return trade-offs. Larger subproblems reduced the "decomposition error" caused by ignoring inter-cluster correlations.
Performance vs. Baselines: The BF-DCQO pipeline with post-processing consistently outperformed randomized baselines and the simple recombination of individual cluster optima.
Role of Post-Processing: The global local search was crucial. It demonstrated that suboptimal cluster candidates could be steered toward lower-energy global configurations once the global cardinality constraint was enforced and inter-cluster swaps were allowed.
Pruning Impact: Varying the pruning level (removing 40–70% of gates) showed that moderate approximations of the Hamiltonian could reduce circuit cost without significantly degrading solution quality on noisy hardware.
Risk-Return Profile: The pipeline generated a diverse set of portfolios spanning a continuous range of risk and return, rather than clustering only at extremes, indicating a rich solution space.

5. Key Contributions

End-to-End Pipeline: Demonstrated a full workflow from raw financial data to a feasible portfolio on real quantum hardware, explicitly accounting for hardware constraints during the decomposition phase.
Non-Variational Optimization: Successfully applied BF-DCQO, a non-variational, counterdiabatic approach, to a real-world financial problem, avoiding the barren plateau and training overhead associated with variational algorithms.
Hardware-Aware Decomposition: Introduced a specific splitting strategy that respects the qubit budget while preserving correlation structures via RMT-based denoising.
Empirical Validation: Provided experimental evidence that larger qubit counts directly translate to higher solution quality in decomposition-based workflows, establishing a clear path for scaling financial optimization as hardware improves.

6. Significance

This work establishes a hardware-tested route for scaling quantum optimization in finance. It proves that:

Decomposition strategies tailored to specific hardware limits are viable for large-scale problems.
Non-variational quantum algorithms (like BF-DCQO) are practical candidates for near-term devices.
The "trade space" between circuit cost (pruning) and solution quality can be navigated effectively.
As quantum hardware scales (e.g., to the IonQ Tempo line), the quality of solutions for dense, combinatorial financial problems will improve monotonically, offering a competitive advantage over purely classical heuristics in specific regimes.