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.

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.

[Advantage Lab] turns abstract ideas like amplitude amplification, ballistic spreading, variational convergence, and Trotter error into visual, replayable experiences. That makes it useful for newcomers, instructors, and technically curious product audiences.

An honest race

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 is usually explained with asymptotic notation, which is technically correct but not persuasive for most people. I built this to make the speedup something users can watch unfold, not just read about. Though currently no such speedup exists in practice.

The Lab focuses on measuring distance from the right answer. The Hamiltonian race sweeps 1, 2, 4, 8 and 16 Trotter steps and prints the circuit depth beside the total-variation distance from exact evolution, so the accuracy you buy with each extra step is a number on the screen. Hardware runs are stored and replayed rather than re-queued, with a statevector simulator alongside for the noiseless version of the same circuit. And since the backend is trapped-ion, the entangling layers in Grover and VQE need no SWAP gates, which you can check by transpiling against another backend and comparing depths.

How it works

The Hamiltonian-simulation race is the most self-contained, and the project ships ready to run in the Qollab Playground. The Lab 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: neighboring 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.

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

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.