Adiabatic Quantum Computing — A Comprehensive Study

From classical optimization to quantum adiabatic algorithms: theory, proofs, and code.

---

What Is Adiabatic Quantum Computing?

Adiabatic Quantum Computing (AQC) is a paradigm of quantum computing that solves hard optimization problems by encoding them into the energy landscape of a quantum system and letting physics find the answer.

1. Start with a quantum system in a known, easy-to-prepare ground state.
2. Slowly evolve the system's Hamiltonian toward one whose ground state encodes the solution.
3. The adiabatic theorem guarantees the system stays in the ground state — delivering the optimal answer.

Why It Matters

• Natural fit for optimization: Logistics, finance, drug discovery, manufacturing scheduling — most real-world problems are optimization problems. AQC maps them directly into physics.
• Intrinsic error resilience: The energy gap protects the computation from noise — no expensive error correction codes needed.
• Quantum tunneling: AQC can tunnel through energy barriers that trap classical algorithms in suboptimal solutions.
• Already deployed: D-Wave's 5,000+ qubit annealers are being used by Volkswagen (traffic routing), Mastercard (offer optimization), ExxonMobil (shipping logistics), Airbus (aircraft design), BBVA (portfolio optimization), and others.
• Proven universal: AQC is computationally equivalent to gate-based quantum computing (Aharonov et al., 2007).

Business Impact

Sector	Application	Potential Value
Finance	Portfolio optimization, credit risk	$2-5B annual savings (McKinsey est.)
Logistics	Vehicle routing, supply chain	10-30% cost reduction in pilots
Pharma	Molecular simulation, trial design	Faster drug discovery pipelines
Energy	Grid balancing, shipping schedules	Millions in fuel savings
Manufacturing	Scheduling, quality control	Reduced downtime and waste

Challenges

AQC is not a silver bullet. Key challenges include exponentially closing spectral gaps for worst-case problems, limited qubit connectivity on current hardware, thermal noise, and the need for honest benchmarking against state-of-the-art classical algorithms. Most enterprise deployments are still at the pilot stage.

📘 Start here: Notebook 00 — Introduction & Big Picture gives a full non-technical overview with company case studies and an ROI framework.

---

Overview

This repository provides a self-contained, rigorous introduction to Adiabatic Quantum Computing (AQC) through 11 interactive Jupyter Notebooks. Each notebook combines:

• Rigorous mathematical treatment with full derivations and proofs
• Python simulations (NumPy/SciPy for exact linear algebra, Qiskit for quantum circuit simulations)
• Q# implementations for quantum-native programming
• Visualizations to build geometric intuition
• Exercises for self-assessment

The material is based on the Master in Quantum Computing Technology course at UPM (2025–26) and seminal papers in the field.

Prerequisites

Topic	Level
Linear Algebra	Eigenvalues, matrix exponentiation, spectral decomposition
Quantum Mechanics	Dirac notation, Hamiltonians, Schrödinger equation (basics suffice — Notebook 02 covers the essentials)
Complexity Theory	P, NP, NP-complete (intuitive understanding)
Python	Comfortable with NumPy, matplotlib

Learning Path

00 Introduction & Big Picture        ← START HERE
│   ├── What is AQC? (no math required)
│   ├── Benefits, companies, use cases
│   └── Challenges, ROI, strategic outlook
│
01 The World of Hard Problems
│   ├── Everyday optimisation & exponential growth
│   ├── SAT, unstructured search, MaxCut, MIS
│   └── Complexity classes (P, NP, NP-hard)
│
02 From Bits to Qubits
│   ├── Qubits, superposition & Dirac notation
│   ├── Hamiltonians = cost functions → ground states
│   └── Schrödinger equation, Pauli matrices & mini AQC demo
│
03 The Adiabatic Theorem
│   ├── Statement and proof
│   ├── Spectral gap Δ(s)
│   └── Runtime bounds (Messiah, Teufel)
│
04 Adiabatic Optimization Framework
│   ├── The AQC recipe: H₀ → H₁
│   ├── Initial & problem Hamiltonians
│   └── Simulated vs. native dynamics
│
05 3-SAT with AQC                    ← Full worked example
│   ├── n=4, m=10 clauses
│   ├── 4 interpolation schedules
│   └── Trotterized evolution
│
06 Unstructured Search via AQC       ← Connection to Grover
│   ├── H₁ = I − |w⟩⟨w|
│   ├── Gap analysis: Δ ~ 1/√N
│   └── Roland–Cerf non-linear schedule
│
07 Maximum Independent Set via AQC
│   ├── Graph → Hamiltonian encoding
│   └── Penalty-based cost functions
│
08 Maximum Cut via AQC
│   ├── Ising model encoding
│   └── Connection to QAOA
│
09 Q# Implementations
│   ├── Adiabatic state preparation in Q#
│   └── 3-SAT and search examples
│
10 Advanced Topics & Open Problems
    ├── Robustness of AQC
    ├── Universality (AQC ↔ circuit model)
    └── Open questions in the field

Quick Start

# 1. Clone the repository
git clone https://github.com/<your-username>/adiabatic-quantum-computing.git
cd adiabatic-quantum-computing

# 2. Create a virtual environment
python -m venv .venv
source .venv/bin/activate        # Linux/macOS
.venv\Scripts\Activate.ps1       # Windows PowerShell

# 3. Install dependencies
pip install -r requirements.txt

# 4. Launch Jupyter
jupyter lab notebooks/

For Q# setup, see setup_guide.md.

Repository Structure

.
├── README.md
├── requirements.txt
├── setup_guide.md
├── LICENSE
├── notebooks/
│   ├── 00_introduction.ipynb
│   ├── 01_optimization_and_satisfiability.ipynb
│   ├── 02_quantum_mechanics_foundations.ipynb
│   ├── 03_adiabatic_theorem.ipynb
│   ├── 04_aqc_framework.ipynb
│   ├── 05_3sat_aqc.ipynb
│   ├── 06_unstructured_search.ipynb
│   ├── 07_mis_aqc.ipynb
│   ├── 08_maxcut_qaoa.ipynb
│   ├── 09_qsharp_implementations.ipynb
│   └── 10_advanced_topics.ipynb
└── src/
    ├── __init__.py
    └── aqc_utils.py

Key References

1. Farhi, E., Goldstone, J., Gutmann, S., & Sipser, M. (2000). Quantum Computation by Adiabatic Evolution. arXiv:quant-ph/0001106
2. Grover, L. K. (1996). A fast quantum mechanical algorithm for database search. STOC '96.
3. Roland, J., & Cerf, N. J. (2002). Quantum search by local adiabatic evolution. Phys. Rev. A 65, 042308
4. van Dam, W., Mosca, M., & Vazirani, U. (2001). How powerful is adiabatic quantum computation? FOCS '01.
5. Teufel, S. (2003). Adiabatic Perturbation Theory in Quantum Dynamics. Springer.
6. Jansen, S., Ruskai, M.-B., & Seiler, R. (2007). Bounds for the adiabatic approximation. J. Math. Phys. 48, 102111.

License

This project is licensed under the MIT License — see LICENSE for details.