Project Showcase: Quantum Advantage Lab

Most people are told that quantum computers are faster. Far fewer ever see why. Quantum Advantage Lab is built to close that gap: pick one of four famous algorithms, press go, and watch it run step by step beside the classical method solving the same problem.

The four races span the canon: Grover's search, a variational eigensolver for molecular ground states, a discrete-time quantum walk, and Hamiltonian simulation. Each one streams the quantum computation's intermediate state, the amplitudes climbing, the energy converging, the probability spreading, next to a classical baseline doing the same job. It is built and MIT-licensed by Hossein Sadeghi, a quantum-software veteran with a decade at D-Wave and Pasqal, and it runs on IonQ's trapped-ion hardware. What makes it unusual is not that it claims a win. It is how honest it is about what winning even means.

The whole idea started from the race: what algorithms can we show, and how do we visualize that competition? I had written the proposal, but it was not a case of "I know the answer, I just need to implement it." It was going to be challenging.

The four races

All four races share a shape. On one side, a quantum circuit; on the other, the best classical method for the same task. Both run, and the Lab streams what is happening inside each, not just the answer at the end.

Grover's search races amplitude amplification against a brute-force scan. You watch the amplitude of the target answer climb in a smooth arc while the classical search checks items one at a time. The picture makes Grover's true nature obvious: it is less a search than a rotation, one you can over-shoot if you run it too long.

VQE, the variational quantum eigensolver, hunts for a molecule's ground-state energy. You watch the energy descend toward the exact value, with a chemical-accuracy band drawn in, while a classical optimizer works the same landscape. It is the one race where the quantum side is genuinely hard, and the Lab shows you why: the optimization landscape is full of traps.

The quantum walk sets a coined walk loose against an ordinary random walk on the same graph. Interference makes the quantum distribution spread ballistically, with sharp peaks at its edges, while the classical walk just diffuses into a bell curve. The gap between spreading like the square root of time and spreading linearly with time is the whole story, drawn live.

Hamiltonian simulation evolves a spin chain with a Trotterized circuit and races it against direct matrix exponentiation. Finer time-slices mean a more faithful result and a deeper circuit, and you watch that depth-versus-accuracy tradeoff play out as the fidelity climbs. This is the race that ships ready to run in the code below.

It does not just show static circuits or final answers. It runs real Qiskit circuits, streams the intermediate solver state, pairs each quantum method with a meaningful classical baseline, and is shaped around IonQ-native execution.

An honest race

Here is the part that most "watch quantum win" demos quietly skip. At the sizes that run on today's hardware, the quantum side does not finish first on a stopwatch. Four qubits are trivial for a laptop, every gate carries noise, and real jobs wait in a queue behind everyone else's. Quantum Advantage Lab does not pretend otherwise.

Quantum advantage is usually explained with asymptotic notation. That is technically correct, but it is not persuasive for most people. I built this to make the speedup something you can watch unfold, not just read about, even though in practice no such speedup exists yet.

So the Lab races the right thing. Not wall-clock time, but the mechanism: how many steps each method needs, how the quantum state evolves, where interference or amplitude amplification does its work. That is where the asymptotic story actually lives, and it is visible long before any hardware is genuinely faster.

It is also honest about the hardware itself. Live runs on IonQ go through a real queue and come back with real noise, so the Lab captures genuine hardware results and replays them on demand, each one labeled for what it is, with a clean statevector simulator alongside as the "this is what perfect looks like" reference. And because it targets IonQ's trapped-ion processor, the entangling layers in Grover and VQE map onto all-to-all connectivity without the SWAP overhead a superconducting chip would pay. The Lab can show you that directly, by comparing the transpiled circuits side by side.

How it works

Every race is a real circuit, not an animation. The Hamiltonian-simulation race is the most self-contained, and it ships ready to run in the Qollab Playground. It builds a transverse-field Ising chain, evolves it with a first-order Trotter circuit, and measures how close the sampled result is to exact evolution as the number of Trotter steps climbs:

# Quantum Advantage Lab: the Hamiltonian Simulation race.
# Evolve a transverse-field Ising chain with a Trotter circuit, then sweep
# the step count and watch the quantum result close in on exact evolution.
import numpy as np
from scipy.linalg import expm
from qiskit import QuantumCircuit, transpile
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
from qiskit.synthesis import LieTrotter

N_QUBITS, TIME = 4, 0.5
N_STEPS_SWEEP  = [1, 2, 4, 8, 16]

def build_ising(n, J=1.0, h=1.0):              # H = -J sum ZZ - h sum X
    terms = []
    for i in range(n - 1):
        zz = ["I"] * n; zz[i] = zz[i + 1] = "Z"
        terms.append(("".join(zz), -J))
    for i in range(n):
        x = ["I"] * n; x[i] = "X"
        terms.append(("".join(x), -h))
    return SparsePauliOp.from_list(terms)?The model. A 1D transverse-field Ising chain: neighbouring spins coupled along Z, a field along X. A small, well-understood system to simulate.
def trotter_circuit(H, t, n_steps, n):         # first-order Lie-Trotter
    qc = QuantumCircuit(n, n)
    qc.append(PauliEvolutionGate(H, time=t, synthesis=LieTrotter(reps=n_steps)), range(n))?Trotterization. Approximates the time-evolution by chopping it into n_steps slices. More steps means a more faithful result and a deeper circuit, and watching that tradeoff is the race.    qc.measure(range(n), range(n))
    return qc

H     = build_ising(N_QUBITS)
exact = exact_distribution(H, TIME, N_QUBITS)   # classical baseline, via SciPy expm?The classical side. SciPy exponentiates the full 2ⁿ×2ⁿ matrix directly. Exact, but the cost explodes with every qubit you add.
for n_steps in N_STEPS_SWEEP:
    qc     = trotter_circuit(H, TIME, n_steps, N_QUBITS)
    tqc    = transpile(qc, backend, optimization_level=1)   # IonQ-native gates?IonQ-native. On trapped-ion hardware, all-to-all connectivity lets the entangling layers run with no SWAP gates, so the circuit stays shallow. Switch the backend to compare.    counts = backend.run(tqc, shots=shots).result().get_counts()
    probs  = counts_to_probs(counts, N_QUBITS)
    print(f"steps={n_steps:>2}  depth={tqc.depth():>3}  TV(quantum, exact)={tv_distance(probs, exact):.4f}")?The verdict. Total-variation distance between the sampled quantum distribution and the exact one. Watch it shrink as the Trotter steps climb.

The same pattern drives the other three races: a real circuit on one side, an exact or best-effort classical solver on the other, and a stream of intermediate state in between. Because the architecture is modular, each race is a self-contained plug-in, which is what lets the Lab grow a fifth or sixth race without a rewrite.

Make it yours

Quantum Advantage Lab is open and forkable on Qollab, MIT-licensed on GitHub, and live on the web right now. Pick a race, set the parameters, and step through it on a simulator or a real IonQ processor. The architecture is modular, so a new race is a plug-in, not a rewrite.