Tutorial › background

• Trapping a single ion
• The qubit inside the ion
• Gates, and why they need cold ions
• Motion as the currency
• The QCCD idea
• Transport primitives, and what each one costs
• The control system
• Where the noise comes from
• Simulating noise, in general
• How this website simulates noise
• The formulas, collected

Physics background#

Everything on this website is a picture of a real machine: ions held in a trap, moved between traps by voltages on electrodes, entangled by laser pulses, and slowly warmed by the world around them. This page walks from the trap up to the noise model, in the order you need it to read the studio. Each section says which knob in the studio it explains and which of the rules it stands behind; the diagrams are drawn from the same machine data the verifier walks, and the running examples are the studio's own pages. The numbers quoted are the ones the default machine document carries.

Trapping a single ion#

An ion is a charged atom, so an electric field pushes on it. But a static field cannot hold a charge in place: Earnshaw's theorem says a potential with no charges inside it has no minimum, only saddles. The Paul trap escapes this with an oscillating field. A radio-frequency (RF) voltage at a frequency Ω of tens of megahertz is applied to one set of electrodes, and the ion, too heavy to follow the oscillation, feels only its time average. That average is a pseudopotential proportional to the square of the RF field amplitude, Ψ = q²·‖E_rf‖² / (4·m·Ω²), which is smallest where the RF field vanishes. The line along which the RF field is zero is the RF null, and the ion sits on it.

The RF null is a line, not a point, so a second set of electrodes carries static (DC) voltages that shape the potential along that line into wells. Each well is a trapping site: a place an ion, or a short chain of ions, can rest. Changing the DC voltages moves the wells, and an ion follows its well. This is the whole mechanism of transport, and it is why the control system in a later section is a story about voltages and wires.

In a surface-electrode trap all the electrodes lie in one plane on a chip and the ion floats above it, typically at a height of tens of micrometres. Above a planar electrode the potential has a closed form: each electrode contributes the solid angle it subtends at the ion, divided by 2π. The reference page on the electrodes a machine implies uses exactly that model to work out, from a layout drawn in the studio, where the ions would sit and how much metal it takes.

Inside the well the ion oscillates like a mass on a spring at a secular frequency ω of a few megahertz; for a trap of characteristic size r₀ the RF drive sets it through the Mathieu parameter q ≈ 2·Q·V_rf / (m·r₀²·Ω²), and in the usual regime ω ≈ q·Ω / (2√2). Quantum mechanically that oscillator has energy levels spaced by ħω, and its state is described by the mean number of quanta it holds, written n̄. An ion fresh from Doppler cooling has n̄ around ten; resolved-sideband cooling brings it below 0.1, close to the motional ground state. Almost every cost on this website is measured in these quanta, so n̄ is the number to keep in mind.

The qubit inside the ion#

The qubit is two internal electronic states of the ion. In a hyperfine qubit both states belong to the electronic ground level and differ only in the orientation of the nuclear spin, which makes them extraordinarily insensitive to noise: coherence times of minutes are measured. The default document names Ba⁺ as the qubit ion and carries a coherence time T_coh of 600 s; a second species, Sr⁺, is loaded alongside it as a coolant, for a reason explained under cooling.

Preparing and reading the qubit both use light. Optical pumping drives the ion into one of the two states, which is a reset (50 µs, with an error of 0.5% in the document). Reading it out shines a laser that makes one state fluoresce and the other stay dark, and a detector counts the photons; this is a measurement (120 µs, 99.84% correct). Together these are the state preparation and measurement (SPAM) errors, and they enter the fidelity estimate directly, once per measurement.

Gates, and why they need cold ions#

A single-qubit gate is a resonant pulse that rotates the qubit; in the document it takes 5 µs and fails once in forty thousand times. The two-qubit gate is the Mølmer–Sørensen (MS) gate. Two ions in the same well share a motional mode, a normal mode of the chain. A pair of laser beams, detuned close to a motional sideband, exerts a spin-dependent force on both ions; the shared mode is pushed out and back, and the phase it picks up along the way depends on the product of the two spins. When the pulse ends the motion has returned to where it started and only the entangling phase remains.

How strongly the light couples spin to motion is the Lamb–Dicke parameter η = k·√(ħ / (2·m·ω)), the ratio of the ion's ground-state wavepacket to the laser wavelength, and the gate works cleanly only in the Lamb–Dicke regime η²·(2n̄ + 1) ≪ 1. That inequality is the physics behind the two consequences that shape the whole design. The ions must share a mode, so they must be in the same trap, and a trap where the beams can reach is a gate zone; rule R6b says a two-qubit gate acts only on ions co-located in one. And the motion must be cold: the gate's error grows with the number of quanta in the mode, because a hot mode blurs the spin-dependent displacement. Quantinuum's H2 processor measured a two-qubit infidelity of 1.84e-3 with cold ions, and the document carries that as the gate's error at n̄ = 0.

Motion as the currency#

Every operation on an ion trap is paid for in motional quanta, and the two ways of paying back are the two kinds of cooling. Doppler cooling scatters photons from a laser tuned just below an atomic resonance; the ion absorbs photons preferentially when moving towards the beam, and each scattering event removes a little momentum. It stops at the Doppler limit, where the recoil of the scattered photons balances the cooling, at roughly n̄ ≈ Γ / (2ω) quanta for a transition of linewidth Γ. It is fast and works on the whole trap at once from sheet beams, which is why the document's cool primitive is a single 300 µs operation that cools every ion in the machine and does not have to be scheduled per ion. Sideband cooling goes further, to the ground state, one quantum at a time, down to about (Γ / 2ω)².

Cooling the qubit ion directly would scatter photons off the qubit and destroy its state. This is the job of the second species: a laser tuned to the coolant ion cools it, and since the coolant and the qubit ion sit in the same well they share motional modes, so the qubit's motion is cooled sympathetically without its internal state being touched. This is why the species entry names a coolant and why the document keeps half the ions as coolants.

Cooling costs time, and time is not free: the qubit dephases against T_coh, and, as the noise section explains, the ion warms up just by waiting. So the compiler does not cool after everything. It cools when it must, and knowing when it must is what rule R7 decides.

The QCCD idea#

One trap, then, holds a short chain of cold ions and gates them. A computer needs thousands of qubits and any pair of them able to meet. The next section is the architecture that answers this, and the map the studio draws of it.

A single trap can hold a long chain of ions, but every ion added makes the chain's modes denser and the gates slower and less precise; rule R13 records that two-qubit gate time degrades sharply beyond roughly fifteen ions per trap. The quantum charge-coupled device (QCCD) keeps the chains short by using many small traps and moving ions between them, so that any two qubits can be brought together for a gate. It was first put forward by Wineland, Monroe, Itano, Leibfried, King and Meekhof at NIST in 1998: a "super-register" of few-ion accumulators, built from segmented traps, in and out of which ions are moved for each logic operation (Fig. 10 of J. Res. NIST 103, 259). It is usually cited from the 2002 paper that named it, by Kielpinski, Monroe and Wineland (Nature 417, 709). The name borrows from the charge-coupled device in a camera, which also shifts charges from cell to cell.

In the studio a machine is a map. A site is a trapping well; a segment is the stretch of RF null an ion is shuttled along between sites; a junction is a place where three or more trap axes meet; a transport loop is a closed path along which a whole ring of ions can be rotated in step; and a zone type is the label a site carries saying how many ions fit there and whether a gate, a measurement or cooling can happen. The diagrams below are drawn from the machine data itself, for the small machines the examples on this website run on: a straight register with no junctions, a racetrack whose bends cost nothing, a lattice with real T-junctions beside plain corners, two loops joined at one coupling, and a ring with dock spurs.

Reading the physics above back into the map: a gate needs ions co-located at a gate zone, a shuttle is a well walked along a segment, and everything that moves an ion heats it. The same drawing scales to the machines on the leaderboard.

Not every graph is a surface trap, and three rules say which are. A junction is a place where RF nulls meet, and on a planar chip at most four can meet without their RF electrodes running into each other, so rule R19 bounds the degree of every node by the number the machine's document declares (max_junction_degree: six when it says nothing, the most a trap built in more than one layer joins; a planar chip's document declares four). Two rails leaving one node need room between them for their electrodes, so rule R20 requires at least 60 degrees between any two rails at a node, measured from the node positions; a symmetric X-junction has 90. And rails live on one plane, so rule R21 requires that a rail meets only the nodes it ends at and that two rails cross only at a node they share. These three read the drawing alone, before any programme runs. They are why a Tanner graph of a code laid out as rails is not a machine, and why a torus drawn on a plane, with its wrap wires running back across the die, is not either; the cylinder on the leaderboard is the planar drawing of the same torus, and it passes.

Transport primitives, and what each one costs#

Transport is done by walking the DC voltages. The elementary moves are the primitives, and each is a curve of measured points trading speed against motional excitation: run it faster and the ion picks up more quanta. The physics of that trade is the driven oscillator: a well moved with acceleration a(t) drives the ion at its secular frequency, and the quanta left behind are the Fourier component of the acceleration at ω, Δn̄ = (m / (2·ħ·ω)) · ‖∫ a(t)·e^{iωt} dt‖², so a slower, smoother waveform can leave almost nothing behind while a fast one leaves a lot. The table below is the default document's operating point, and each row says where its numbers come from. The transport rows are the qccdsim_jones table: the times of the QCCDSim simulator of Murali and colleagues, with the heating bound Jones and Murali attach to each in their cost table. The other rows come from other papers. The transport_excitation table from Munoz and colleagues offers a slower, colder point for several of them, and the studio lets you choose which point a design runs at.

Two of these deserve a word. Splitting a chain is sixty times as hot as a shuttle, because the well must be deformed through a point where the confinement along the axis nearly vanishes. And a junction is not simply a bend: where three or more RF nulls meet, the RF field cannot vanish smoothly, and residual RF barriers rise on the approaches; carrying an ion over them without excitation takes a carefully shaped waveform and still heats. A corner of the RF null, where two axes meet, has no such barrier, and rule R18 says a bend is ordinary transport. Measured on an X-junction trap, an ion survived about 65 uncooled round trips at over 98% and was lost from the trap beyond about 85, so excitation is not only a fidelity problem but, past a point, a loss of the qubit.

A docked site off a loop is reached by a split at the loop and a merge at the dock, so docking is charged for both; a rotation of the whole loop, in which every well moves together, entails neither.

Swap-or-stay: transport without routes#

A C2LR lattice (Delaney and colleagues, Quantinuum) has one leg, a short trap, on every wire between its X-junctions, and each leg holds one crystal: a qubit ion with its coolant ion, one ion in this model. Nothing is routed. One shared waveform plays at every junction at once, for one diagonal (W-S, W-N, E-S or E-N), and the only choice each crystal has is one bit: shifted toward its pair's junction, or away. Both crystals of a pair toward swap; both away stay; one toward into an occupied leg enters it, so that two crystals share a leg for a gate, and leaves again the same way. The rules of such a machine are C1 to C10, in the rule set c2lr, and the C2LR boards rank designs by them.

Every crystal on the machine plays every waveform, so a stay is not free (C9), and the step takes its full time however many crystals move. The control is 27 shared analog signals plus one digital input and one switch per leg, and two site-dependent shims per leg (C10; p4 of the paper), which the DAC count reads as a broadcast bank and two compensation DACs a leg. The paper demonstrates the four single diagonals; the two-pair checkerboard steps, in which two diagonals cross one junction at the same time at the junctions of one colour, were not demonstrated: they are allowed and marked assumed in every report, and the rule set c2lr-demonstrated refuses them.

The control system#

Under the chip, each DC electrode is driven by a digital-to-analogue converter (DAC), and a transport is a set of voltage waveforms played on the electrodes along the path. The default document's traps have 24 electrodes each and its junctions 48, so a machine with hundreds of sites has tens of thousands of electrodes, and one DAC per electrode is the first thing that does not scale; the fanned leads in the racetrack photograph above are this problem made visible. This is the control plane in the studio, and it is what the DAC count on the report measures, against the budget the document declares: at most so many DACs, junctions and square millimetres of trap.

The scalable answer is broadcast wiring: electrodes that play the same role on every trap are wired to the same DAC, so that one waveform moves every ion whose site is wired to it. In the WISE scheme this holds the number of dynamic DACs at about a hundred regardless of the size of the machine, at the price that only one kind of motion can happen in a cycle. Rule R4 is that price: at most one movement class is active per cycle, a class fixes a type and a direction, and any ion whose site is wired to the active waveform takes part unless a per-site switch opts it out. Two neighbouring ions cannot simply pass one another, because the waveform that moves one left moves the other left too; moving them past each other is a sequence of sorts, and a compiler for such a machine is scheduling a SIMD processor. Rule R4d checks that each cycle can actually be driven by the declared channels, and the wiring tab of the studio is where the channels and switches are declared.

Rule R22 states the consequence exactly: one transport cycle is one waveform, so every ion that moves in a cycle performs the same motion, hop by hop, and a site may only opt out. A rigid rotation of a loop is one motion by construction, and so is a batch of docks that all dock the same way; a lattice router that sends one ion east while another goes north in the same cycle is asking for two waveforms, and the verifier now refuses it. The compiler now reserves one motion per cycle while it routes, which costs a lattice design between two and four times its transport time (the BB grids went from about 200 ms to about 400 ms a round) and costs a ring nothing, and that difference is much of why the rings lead the leaderboard.

The optical side is wired the same way: the document uses global beams with a switch per zone, so a gate pulse reaches every gate zone that is switched on. Cooling, being a sheet beam over the whole trap, needs no addressing at all, which is what makes the global cool cheap in control even though it is expensive in time.

Where the noise comes from#

Up to here the machine worked perfectly. It does not. The next three sections are the noise: where it comes from, how a noisy machine is simulated in general, and how this website does it.

Six things go wrong on a trapped-ion machine. The noise models on this website say, each in one clause of a text, which of them reaches a qubit, where, and with what probability; the Evaluation page prints both models whole.

Anomalous heating. An ion warms up even when nothing moves it. Electric-field noise from the electrode surfaces, of a magnitude far above what thermal Johnson noise predicts and hence called anomalous, drives the oscillator at its secular frequency. The heating rate is ṅ = S_E(ω)·e² / (4·m·ħ·ω) where S_E is the spectral density of the field noise; it scales roughly as the inverse fourth power of the ion's distance from the electrodes, S_E ∝ d⁻⁴, and drops by about two orders of magnitude when the trap is cooled to cryogenic temperature. The default document carries 0.05 quanta per millisecond and Goal 1's cited physics 0.029 (a Ba–Yb crystal, arXiv:2206.11888), and rule R17 accrues it against elapsed time for every ion, moving or not, the gate's own duration included.

Heating by transport. Every primitive deposits its quanta into the ions it moves, as in the table above. The replay keeps five heating channels separate: shuttling, junction crossings, split and merge, the gate's own duration, and the anomalous heating above. Rule R15 notes that consecutive transports interfere: two excitations with a phase θ between them compose as n̄ = n̄₁ + n̄₂ + 2·√(n̄₁·n̄₂)·cos θ, so a phase-aware schedule can cancel excitation, and the additive sum the replay uses is the cos θ = 1 upper bound.

Gate error growing with heat. The MS gate's error at gate time is linear in the quanta the ions bring to it, ε(n̄) = ε₀ + k·n̄: ε₀ = 1.84e-3 and k = 2e-3 per quantum in the default document, ε₀ = 7.9e-4 and k = 9.5e-4 in Goal 1's physics; this is rule R16. A second term, after Murali and colleagues, grows the error with the length N of the chain in the gate zone as N / ln N, because laser-intensity noise couples more strongly to a longer chain; the numbers are calibrated at a two-ion chain and the term switches on when a design gates in longer ones. Both noise models charge it on every two-ion gate as a two-qubit depolarizing channel; qccd-noise@2 adds the n̄ of 0.05 that ground-state cooling leaves behind.

Dephasing while waiting. A qubit that waits loses phase coherence. qccd-noise@1 charges every ion (1 − e^(−Δt/T₂)) / 2 of Z error for each step's duration Δt, against the species' coherence time (600 s in the default document). qccd-noise@2 charges what Quantinuum's Helios measures: a linear memory error r·Δt (r = 7.9e-3 per second) on every ion a step does not operate on -- idling, riding a rotation or being carried -- and a coherent part sin²(π·f·T) (f = 0.058 Hz) over each wait T before the ion is next operated on, which grows as T², so one long wait costs far more than many short ones. This is how time reaches the logical error rate: every microsecond a schedule spends is memory error on every ion that waits through it.

State preparation and measurement. Each reset leaves its ion in |1⟩, and each readout reports the wrong outcome, with the machine's own probabilities. Under qccd-noise@2 a measurement also disturbs the other ions of its trap (2.1e-4 each) and, less, every other ion (4.3e-5), and a reset the ions in the other traps (3.5e-6), as Helios measures.

Ion loss. Past roughly 85 uncooled junction round trips the ion is gone, not merely warm. No noise model gives it a probability: no vendor publishes one, and a lost ion is not a Pauli error. It enters as a limit instead: the cooling pass can be asked to cap accumulated quanta between cools so that no ion approaches it, and it names the single instruction to blame when one move alone would exceed the cap.

Simulating noise, in general#

There are three levels at which a noisy quantum computer can be simulated, and it helps to know which one you are looking at.

The most faithful is to evolve the density matrix under a master equation that includes every decoherence channel. It is exact, and it is exponential in the number of qubits, so it serves for a gate or two, not a syndrome round of a code with 288 qubits.

The workhorse for error correction is stochastic Pauli simulation. Each operation is followed by a random Pauli error drawn with its physical probability; because the circuit is Clifford, the state is tracked as a stabilizer tableau in polynomial time, the syndromes are handed to a decoder, and the logical error rate is estimated by sampling many rounds. This is how a code's threshold is found. Below the threshold the logical error falls as a power of the ratio, p_L ∝ (p / p_th)^((d+1)/2) for a code of distance d, which is why a factor of two in the physical error rate is worth so much.

The third level is the error budget: add the error of every operation, each evaluated at the conditions it actually runs under. It is not a simulation of the quantum state at all, but of the machine: it says where the faults come from, not whether the code survives them.

This website works at the second level, and reports the third beside it: every logical error rate on the leaderboard is a stochastic Pauli simulation of the programme's own circuit, decoded, and every entry's error budget says which channel its faults come from.

How this website simulates noise#

The compiler turns a circuit into a hardware programme, a list of instructions each of which is one concurrent cycle of the machine. The verifier then replays that programme on the machine document, instruction by instruction, keeping for every ion its position, its accumulated n̄ split by heating channel, and the clock. A shuttle adds its quanta to the ion shuttled; a junction crossing is charged on entry to the node; a split is charged to the ion that leaves; every ion accrues anomalous heating for the cycle's duration; a cool sets the cooled ions' n̄ back to zero. When a two-qubit gate is reached the replay reads each ion's n̄ and checks it against the gate's budget for rule R7.

The replay fixes everything noise depends on: how long every step takes, how hot every ion is when each gate starts, how many ions share each trap, how long every ion has waited. A noise model is a text that reads those facts. Each of its clauses names a Pauli channel, where it goes and its probability, as a term over the replay -- after g in two_qubit_gates: DEPOLARIZE2(ms_error(gate_nbar(g) + 0.05, gate_chain(g))) on ions(g) says that every two-ion gate is followed by two-qubit depolarizing noise at the gate law's value for the heat and the chain it meets. The programme's gates, measurements and resets become their stabilizer operations, the clauses put their noise around them, and the result is a stim circuit with the experiment's detectors. stim samples it, a decoder corrects each shot (minimum-weight matching, or BP-OSD where a fault touches three or more detectors), and the fraction of shots left wrong is the logical error rate, reported with its 95 % interval. That is what the Goal 1 board ranks, and the Evaluation page recomputes one of its entries, line by line.

The replay is deterministic, and that buys two things. The error budget is exact: each channel's expected number of faults is its probabilities added over every place it writes, and since every probability is a term of the replay, scaling one heating channel moves the gate error along a straight line. And cooling insertion is a pass over the same replay: rule R7c makes cooling mandatory under broadcast wiring, so the pass walks the programme, and wherever a gate is about to run on an ion above the budget it inserts one global cool before it. A global cool zeroes every ion, so one pass provably converges. The trade the studio exposes as the operating point is real: a slower, colder split that stays under the gate budget can save the 300 µs cool that a faster one would force, and be faster overall.

What the models do not do is as important as what they do. They do not evolve a density matrix: every channel is a Pauli channel, and a coherent rotation enters as its Pauli twirl. Transport heating is additive, with no interference term. No error is charged per shuttle, junction, split or swap beyond the time and the heat they cost, because no QCCD experiment reports one; no crosstalk from a two-ion gate is charged (Helios detects none); and ion loss is a limit, not a probability. The anomalous heating rate is a constant in the document rather than derived from the electrode geometry, although the electrode layer already solves for the ion height that would set it.

The formulas, collected#