We spend most of our time on three questions: how to compile a circuit for a machine it was never written for, how to simulate it honestly, and how to read a trustworthy number out of a noisy one. Below are the areas we work in, and the lab notes we write as we go.
Every backend has a fixed qubit topology and a small native gate set. Transpilation is the art of rewriting a logical circuit — gate decomposition, qubit mapping, SWAP routing, scheduling — into the shortest physical circuit that computes the same thing, with the same answer, on hardware that can actually run it.
Without fault tolerance, every expectation value is biased by gate and readout error. We study methods that trade classical sampling for less bias: zero-noise extrapolation, Pauli twirling, and readout correction — and, just as importantly, the regimes where each one quietly stops working.
A statevector simulator for the small circuits you can afford to store, a density-matrix simulator for the noisy ones, and tensor-network methods for the shallow, wide ones in between. The point is to model decoherence well enough to test a mitigation strategy before you spend device time.
The surface code is where most error correction is heading. We work on the software side — stabilizer measurement, decoding, and how a logical circuit maps onto a patch — and on explaining it well enough that a newcomer can follow the argument end to end.
Dated notes, written for ourselves and published for anyone else. Not every one resolves cleanly — several end in an open question.
When you simulate a Hamiltonian with a Trotter decomposition, the step size is usually chosen to control the state error. But most experiments measure a specific observable, and that observable's error can be far smaller — or far larger — than the state's. We're reworking the step-size heuristic to match the observable you actually read out, not the one you can compute.
simulation · observablesMost routers rank candidate SWAP insertions with a heuristic that assumes a uniform error model. On a sparse connectivity that assumption breaks first. We're looking at routing directly against a device's measured gate-error profile, and the surprising result that greedy depth-minimization is not always the best proxy for fidelity.
transpilation · routingZNE scales noise by boosting gate count and extrapolating back to zero. Each noise level costs real sampling budget. We're mapping how few levels you can get away with before the extrapolation error dominates the bias you set out to remove — and the answer is lower than the folklore suggests.
error mitigationPauli twirling converts coherent errors into stochastic ones, which are easier to model. But the twirl changes the noise you measure, and not always in a way that matches the noise your application will actually see. We're cataloguing the cases where the twirled model is the wrong thing to trust.
error mitigationEstimating the success probability of a compiled circuit usually needs a reference-state reconstruction, which is expensive. We're testing a shortcut that estimates fidelity from the same samples you'd take anyway — useful when you just want to know whether the compiler helped.
transpilation · benchmarkingAn n-controlled gate does not exist natively on any machine we target, so it must be decomposed into single-qubit rotations and CNOTs. The textbook construction is correct but wasteful; we're comparing the ancilla-free and ancilla-assisted decompositions head-to-head on depth and gate count.
gate decompositionReadout error — measuring a |1⟩ as |0⟩ or vice versa — can be corrected with a calibration matrix, but calibrating every qubit is costly and the matrix drifts between runs. We're looking at how much correction you keep if you calibrate a subset and interpolate the rest.
readout · mitigation"T₂" gets quoted as one number, but decoherence is a spectrum of processes — amplitude damping, dephasing, leakage — each with its own rate. We're working through what a simulator has to model to reproduce an observed decay curve, and what it can safely ignore.
simulation · noiseA statevector of n qubits is 2ⁿ complex amplitudes. The memory wall is real, but the practical limits are softer than the asymptotic ones. We're benchmarking how far a single machine gets — and where the density-matrix and tensor-network methods take over.
simulation · statevectorThe surface code is usually introduced through its stabilizers and syndromes, which is correct but opaque. We're writing an introduction that starts from the geometry — a grid of data and ancilla qubits — and builds the X and Z stabilizers up from there.
fault tolerance · surface code