Travelers Quantum Algorithm Benchmarking - Bloch Heads

Inspiration

The Travelers/Quantinuum/ITM Quantum Challenge at YQuantum 2026 tasked participants with applying quantum algorithms to a real-world business problem in the insurance industry. Specifically, we needed to solve an insurance bundling optimization problem: given 10 insurance packages and 20 possible coverages with various constraints, how can we maximize profit while respecting all business rules?

This challenge deeply resonated with us because it bridged cutting-edge quantum computing with a practical, high-impact industry application. Insurance product optimization is a complex combinatorial problem that grows exponentially with the number of packages and coverages — a perfect candidate for exploring the potential advantages of quantum algorithms over classical methods.

What it does

Our project, Travelers Quantum Algorithm Benchmarking - Bloch Heads, benchmarks two quantum algorithms — QAOA (Quantum Approximate Optimization Algorithm) and DQI (Decoded Quantum Interferometry) — on the insurance bundling problem.

The goal is to find the optimal combination of coverages for each insurance package that maximizes total profit while satisfying all constraints (e.g., coverage compatibility, regulatory limits, and profitability thresholds).

We implemented both algorithms and compared their performance in terms of approximation quality, feasibility, and scaling behavior. Additionally, we introduced two novel goodness-of-fit measures: variance of solution quality and KL divergence (Kullback-Leibler divergence) between the obtained probability distributions and the ideal solution distribution.

How we built it

We built the entire solution in Python using Quantinuum’s Guppylang SDK.

The development process followed these steps:

Classical Baseline: We first implemented a classical optimization solver (using integer linear programming) to establish a performance benchmark and generate reference solutions.
QAOA Implementation: We formulated the insurance bundling problem as a Quadratic Unconstrained Binary Optimization (QUBO) and implemented a feasibility-sensitive version of QAOA. This hybrid quantum-classical approach involved repeated parameterized quantum circuits with classical optimization of the variational parameters.
DQI Implementation: We also implemented Decoded Quantum Interferometry, which transforms the optimization problem into a decoding problem using the Quantum Fourier Transform.
Benchmarking Framework: We developed a comprehensive evaluation pipeline that runs both algorithms across different problem sizes, measures solution quality, feasibility rates, runtime, and our custom metrics (variance and KL divergence).

All quantum circuits were executed (or emulated) on Quantinuum’s hardware and emulators, primarily using the Selene emulator.

Challenges we ran into

Runtime Constraints: Hackathon time limits made it difficult to run large-scale experiments. Even moderate problem instances required significant computation time.
Emulator Performance: Running on Quantinuum’s Selene emulator initially suffered from long queue times and slower performance. We resolved this by switching to a different remote cluster, which provided much better throughput.
Scaling Limitations: While QAOA performed reliably, we were unable to successfully run DQI on the largest problem instances due to circuit depth and resource requirements.
Metric Design: Creating meaningful and novel comparison metrics (variance and KL divergence) required careful mathematical formulation to ensure they were both informative and computationally tractable.

Accomplishments that we're proud of

Successfully implemented and benchmarked two advanced quantum algorithms (QAOA and DQI) on a real business use-case.
Achieved consistently high approximation ratios and feasibility rates with our QAOA implementation.
Introduced two novel evaluation metrics — variance of solution quality and KL divergence — that provide deeper insight into algorithm behavior beyond standard approximation ratios.
Built a complete, end-to-end benchmarking framework from classical baseline to quantum solutions.
Overcame emulator performance issues through creative resource management during the hackathon.

What we learned

This project was an incredible deep dive into quantum optimization algorithms. We gained hands-on experience with:

Translating real-world business constraints into quantum-friendly mathematical formulations (QUBO).
The practical challenges of variational quantum algorithms, especially parameter tuning and circuit depth limitations.
The strengths and current limitations of QAOA versus more specialized approaches like DQI.
The importance of hybrid quantum-classical workflows and the critical role of classical pre- and post-processing.
How emulator performance and queue times can significantly impact development in cloud-based quantum environments.

Most importantly, we learned that while quantum algorithms show promise for combinatorial optimization, significant engineering and algorithmic advances are still needed before they can outperform classical solvers on practical business problems of this scale.

What's next for Travelers Quantum Algorithm Benchmarking - Bloch Heads

Looking ahead, we plan to:

Refine and optimize our code implementations for better performance and scalability.
Further explore DQI methods to better understand its limitations and potential improvements in scaling.
Test the algorithms on larger, more realistic insurance datasets (with real-world constraints and stochastic elements).
Investigate noise mitigation techniques and error-aware formulations to prepare for execution on actual quantum hardware.
Expand the benchmarking framework to include additional quantum optimization algorithms.

This project was an exciting and valuable learning experience in applied quantum computing for the entire team. We’re grateful to Travelers, Quantinuum, and ITM for sponsoring such a meaningful challenge!

Team: Bloch Heads
Event: YQuantum 2026