Velocity-Enabled Quantum Computing with Neutral Atoms

A self-contained walkthrough of arXiv:2603.15561

Author

Based on Lib, Timme, Ammenwerth, Gyger, Tao, Sun, Bloch & Zeiher (2026)

Introduction

Imagine you have a thousand atoms pinned in a grid of optical tweezers, each one a qubit. You can flip any single qubit by shining a tightly focused laser on it — but that means a thousand individually steered beams, each aligned to micron precision. Alternatively, you can shuttle atoms into dedicated “gate zones” — but dragging an atom hundreds of microns across the array takes hundreds of microseconds, time your fragile quantum state cannot afford. Now consider a different idea: what if the atoms already carry an address, encoded not in where they sit but in how fast they move?

That is the core proposal — and experimental demonstration — of the paper we are unpacking here.

This paper (arXiv: 2603.15561) was published in March 2026 by the strontium quantum computing group at MPQ Garching.

The bottleneck in neutral-atom quantum computing

Neutral-atom platforms have emerged as one of the most promising architectures for scalable quantum computing. Arrays of optical tweezers can trap hundreds of individual atoms, and Rydberg interactions provide a natural mechanism for entangling gates. But there is a practical tension at the heart of current designs.

To perform different operations on different qubits, we need selective addressing. The two standard strategies each come with a cost:

Spatial zoning. Atoms are physically shuttled between separated regions — a storage zone, a gate zone, a readout zone. Shuttling over distances of $$100 $\mu$m at safe accelerations takes on the order of 100 $\mu$s per move. For circuits requiring many rounds of gates and measurements, this transport overhead dominates the total runtime.
Focused beams. Individual laser beams target specific sites. This works well at small scales, but the optical hardware (acousto-optic deflectors, spatial light modulators, high-NA objectives) becomes increasingly complex and error-prone as the array grows.

We would like a method that gives us local control using global beams — no steering, no shuttling across the full array.

Velocity as an address

The laser irradiates every atom in the array — but only the atoms moving at the right velocity actually respond to it. Stationary atoms get hit by the same beam and nothing happens to them. That is the entire trick.

The physics behind it is the Doppler effect. When an atom moves toward a laser source with velocity $v$, it perceives the light at a slightly higher frequency than a stationary atom would — shifted by $\Delta f = v/\lambda$. If the laser is tuned to exactly that shifted frequency, the moving atoms are on-resonance and get driven by the pulse. The stationary atoms see the same laser as being on the wrong frequency and are essentially transparent to it. Velocity becomes a spectroscopic address: instead of targeting an atom by its location, you target it by its speed.

In practice this is simple to implement: nudge selected atoms with their tweezer by a few microns, giving them a well-defined velocity during the laser pulse. Moving atoms get driven; stationary neighbors are untouched.

What makes this so effective for strontium-88 is how narrow its clock transition is. At 698 nm, an atom moving at just 0.03 m/s sees a Doppler shift of $\Delta f \approx 43\,\text{kHz}$. The clock transition’s natural linewidth is under 1 Hz — so even this tiny shift puts the moving and stationary atoms on completely different channels from the laser’s perspective. The ratio of Doppler shift to drive strength, $\Delta/\Omega \approx 10$, is enough to leave stationary atoms with only 0.4% spurious excitation.

Notice that the required displacements are tiny — just 1–2 $\mu$m, executed in $$10 $\mu$s. Compare that with the hundreds of microns and hundreds of microseconds needed for zone-based shuttling. The overhead shrinks by roughly two orders of magnitude in both distance and time.

Figure 1: Velocity-enabled architecture overview.

Figure 1 shows the basic architecture. All atoms sit in a single zone. Tweezers shift selected atoms by small displacements during global laser pulses, and the Doppler effect does the rest.

The MPQ strontium platform

The experiments in this paper were carried out at the Max-Planck-Institut fur Quantenoptik (MPQ) in Garching, near Munich. The group uses strontium-88, an alkaline-earth atom with a particularly clean level structure. Its ultra-narrow $^1S_0 \leftrightarrow\, ^3P_0$ clock transition (natural linewidth $$1 mHz, wavelength 698 nm) is the same transition that makes strontium the backbone of the world’s most precise optical clocks. For quantum computing, this narrow linewidth means that even modest atomic velocities produce Doppler shifts many orders of magnitude larger than the transition’s natural width — exactly the regime where velocity-selective addressing works best. The group has previously demonstrated high-fidelity Rydberg gates and erasure conversion in this platform; the velocity-enabled scheme builds directly on that foundation.

What the paper demonstrates

Let’s preview the main results. Using velocity-selective addressing on a strontium-88 tweezer array, the authors demonstrate: (i) state preparation and measurement that selectively targets moving atoms while leaving stationary neighbors untouched; (ii) local single-qubit rotations driven by global laser beams, with selectivity enabled by micron-scale tweezer displacements; (iii) a controlled-Z (CZ) entangling gate reaching 99.86% fidelity (corrected for state-preparation and measurement errors); (iv) an eight-qubit linear cluster state with a stabilizer witness value of 0.830, certifying genuine multipartite entanglement; (v) a [[4,2,2]] error-detecting code that encodes a logical Bell state at 99.0% fidelity after postselection on the code space; and (vi) a flying-ancilla protocol in which a mobile atom is shuttled between data qubits for sequential syndrome extraction — demonstrating a key primitive for scalable quantum error correction.

Roadmap

In this document, we will first cover the necessary background — the strontium level structure, the Doppler effect in optical transitions, and the basics of Rydberg entangling gates. Then we will walk through each of these achievements step by step, with interactive visualizations to build intuition for how velocity-selective addressing works in practice.

Prerequisites and Background

Before diving into the velocity-enabled architecture, let’s build up the concepts we will need. If you have a solid quantum-computing background, feel free to skim or skip ahead — but even experts may find the Doppler-shift and neutral-atom sections useful for context.

Qubits and Quantum Gates

A classical bit is either 0 or 1. A qubit can be in a superposition of both:

\[ \ket{\psi} = \alpha\ket{0} + \beta\ket{1}, \qquad |\alpha|^2 + |\beta|^2 = 1. \]

We can visualize any single-qubit state as a point on the Bloch sphere — a unit sphere where $\ket{0}$ sits at the north pole, $\ket{1}$ at the south pole, and superpositions like $\ket{+} = \tfrac{1}{\sqrt{2}}(\ket{0}+\ket{1})$ lie on the equator. Every single-qubit operation is then a rotation of this sphere.

The Bloch sphere: any single-qubit state $\ket{\psi}$ corresponds to a point on this unit sphere. The poles represent $\ket{0}$ and $\ket{1}$, the equator holds superposition states like $\ket{+}$ and $\ket{-}$, and single-qubit gates are rotations around the $X$, $Y$, $Z$ axes.

Single-qubit gates. The Pauli operators $X$, $Y$, $Z$ generate rotations around the corresponding Bloch-sphere axes. The Hadamard gate $H = \tfrac{1}{\sqrt{2}}\bigl(\begin{smallmatrix}1&1\\1&-1\end{smallmatrix}\bigr)$ maps $\ket{0}\mapsto\ket{+}$ and $\ket{1}\mapsto\ket{-}$, interchanging the $Z$ and $X$ bases.

Think of $X$ as a bit-flip (swapping $\ket{0}$ and $\ket{1}$), $Z$ as a phase-flip ($\ket{1}\mapsto -\ket{1}$), and $H$ as putting the qubit “halfway” between the computational and superposition bases.

Example 1. Start with a qubit in $\ket{0}$. Apply $X$: the state becomes $\ket{1}$ (bit-flip). Now apply $H$: we get $\ket{-} = \tfrac{1}{\sqrt{2}}(\ket{0} - \ket{1})$. If we measure in the computational basis, we see $\ket{0}$ or $\ket{1}$ each with 50% probability. But if we instead apply $Z$ to $\ket{+} = \tfrac{1}{\sqrt{2}}(\ket{0} + \ket{1})$, the relative sign flips: $Z\ket{+} = \tfrac{1}{\sqrt{2}}(\ket{0} - \ket{1}) = \ket{-}$. The amplitude of each component is unchanged, but the phase relationship between $\ket{0}$ and $\ket{1}$ is reversed — that is the essence of a phase-flip.

For computation, we also need gates that entangle two qubits. The key two-qubit gate in this paper is the controlled-Z (CZ) gate: it applies a phase of $-1$ if and only if both qubits are in $\ket{1}$.

\[ \text{CZ}\ket{ab} = (-1)^{ab}\ket{ab}. \]

The CZ gate is symmetric — it doesn’t matter which qubit is “control” and which is “target.”

The CZ gate acts on computational basis states: only $\ket{11}$ acquires a phase of $-1$. The circuit symbol shows two filled dots connected by a vertical line, reflecting the gate’s symmetry.

A CZ gate preceded and followed by Hadamard gates on the target qubit produces a CNOT, so CZ is a universal entangling gate. When we apply a Hadamard to each of two qubits in $\ket{00}$ and then a CZ gate, we produce a Bell state: $\ket{\Phi^+} = \tfrac{1}{\sqrt{2}}(\ket{00}+\ket{11})$. Bell states are maximally entangled — measuring one qubit instantly determines the other. They serve as the building blocks for teleportation, entanglement distillation, and error correction.

Example 2. Let’s see the CZ gate act on each computational basis state: $\text{CZ}\ket{00} = \ket{00}$, $\text{CZ}\ket{01} = \ket{01}$, $\text{CZ}\ket{10} = \ket{10}$, $\text{CZ}\ket{11} = -\ket{11}$. Only $\ket{11}$ picks up a minus sign. Now start with $\ket{+}\ket{0} = \tfrac{1}{\sqrt{2}}(\ket{00} + \ket{10})$ and apply CZ: we get $\tfrac{1}{\sqrt{2}}(\ket{00} + \ket{10}) = \ket{+}\ket{0}$ — nothing changes. But $\ket{+}\ket{1} = \tfrac{1}{\sqrt{2}}(\ket{01} + \ket{11}) \xrightarrow{\text{CZ}} \tfrac{1}{\sqrt{2}}(\ket{01} - \ket{11}) = \ket{-}\ket{1}$. The first qubit “notices” the second qubit’s state: it flips from $\ket{+}$ to $\ket{-}$ only when the second qubit is in $\ket{1}$.

Fidelity. Given an ideal target state $\ket{\psi}$ and an experimentally prepared state described by density matrix $\rho$, the fidelity is $F = \bra{\psi}\rho\ket{\psi}$. A fidelity of 1 means perfect preparation; anything below indicates errors.

For instance, if we prepare a Bell state and measure a fidelity of $99.86\%$, it means that out of 10,000 repetitions, roughly 9,986 would produce the ideal outcome. The remaining 14 runs suffer from some combination of gate errors, decoherence, and measurement imperfections. The paper reports a CZ fidelity of $99.86(4)\%$ — comfortably above the $\sim 99\%$ threshold typically needed for quantum error correction to work.

In practice, fidelity is our report card for gate quality. For error correction to work, we need fidelities above certain thresholds, typically around $99\%$ or better.

Quantum Error Correction Basics

Real qubits are fragile. They interact with their environment (stray fields, laser noise, thermal fluctuations) and lose their quantum information — a process called decoherence. A qubit that started in $\alpha\ket{0}+\beta\ket{1}$ drifts unpredictably over time. Without intervention, no quantum computation can last long enough to be useful.

The key idea of quantum error correction (QEC) is to spread one logical qubit across several physical qubits, so that errors on individual physical qubits can be detected and corrected without destroying the encoded information.

Stabilizer codes. A stabilizer code is defined by a set of commuting operators $\{S_1, S_2, \ldots\}$ (products of Pauli matrices) whose simultaneous $+1$ eigenspace is the code space. Measuring each $S_i$ yields a syndrome telling us what (if any) error occurred.

Example 3. Consider a 3-qubit phase-flip code with stabilizers $S_1 = Z_1 Z_2$ and $S_2 = Z_2 Z_3$. The code space is spanned by $\ket{000}$ and $\ket{111}$. If a phase-flip $Z_1$ hits qubit 1, we measure $S_1 = -1$ and $S_2 = +1$. This syndrome pattern $(-, +)$ uniquely identifies qubit 1 as the error location. A phase-flip on qubit 2 gives $(-, -)$, and on qubit 3 gives $(+, -)$. Each single-qubit error produces a distinct syndrome, so we can correct it. The key point: measuring stabilizers never reveals whether the encoded state is $\ket{000}$ or $\ket{111}$ (or a superposition) — they only reveal error information.

The intuition here is beautifully simple: stabilizers are parity checks. Consider a classical repetition code that encodes $0 \to 000$ and $1 \to 111$. We can detect a single bit-flip by checking: “Do bits 1 and 2 agree? Do bits 2 and 3 agree?” These parity checks never reveal the encoded value, but they reveal where an error struck. Stabilizers are the quantum version of exactly this idea, extended to handle both bit-flips ($X$ errors) and phase-flips ($Z$ errors).

Remark. The $[[4,2,2]]$ code. This is the smallest quantum error-detecting code: it encodes $k=2$ logical qubits into $n=4$ physical qubits and can detect any single-qubit error (distance $d=2$). Its stabilizers are $X^{\otimes 4}$ and $Z^{\otimes 4}$ — essentially checking that the parity of all four qubits is even in both the $X$ and $Z$ bases. If any single qubit suffers an error, the parity flips, and we know something went wrong.

Example 4. The four logical basis states of the $[[4,2,2]]$ code are: $\ket{00}_L = (\ket{0000} + \ket{1111})/\sqrt{2}$, $\ket{01}_L = (\ket{0011} + \ket{1100})/\sqrt{2}$, $\ket{10}_L = (\ket{0101} + \ket{1010})/\sqrt{2}$, $\ket{11}_L = (\ket{0110} + \ket{1001})/\sqrt{2}$. Notice every state has even parity in both the $Z$ basis (equal numbers of 0s and 1s in each superposition branch) and the $X$ basis — that is how $X^{\otimes 4}$ and $Z^{\otimes 4}$ catch single-qubit errors. A bit-flip on any one qubit produces odd parity, flipping the $Z^{\otimes 4}$ eigenvalue from $+1$ to $-1$, and the error is flagged.

Notice that this code detects but cannot correct errors (for that, we would need $d \geq 3$). The strategy used in the paper is post-selection: whenever the parity check flags an error, we discard that run. This is not scalable on its own — you can’t throw away exponentially many runs — but it is an excellent benchmark for the quality of the underlying operations. The paper achieves $99.0(3)\%$ logical Bell-state fidelity after post-selection, exceeding the raw physical Bell-state fidelity.

Neutral Atoms as Qubits

Among the competing quantum-computing platforms (superconducting circuits, trapped ions, photonics, etc.), neutral atoms trapped in arrays of optical tweezers have emerged as a leading contender. An optical tweezer is a tightly focused laser beam that creates a potential well for a single atom — think of it as a tiny bowl of light holding an atom at its center.

Why neutral atoms?

Neutral-atom platforms offer three compelling advantages. First, scalability: atoms are identical by nature, and tweezer arrays with hundreds of sites can be generated using spatial light modulators. Second, long-range connectivity: unlike superconducting qubits on a fixed chip, atoms can be physically picked up and moved (shuttled) to interact with distant partners. Third, low crosstalk: neutral atoms don’t interact unless deliberately brought close together and excited to Rydberg states, so idle qubits are well isolated.

The experiments in this paper use strontium-88 ($^{88}\text{Sr}$), an alkaline-earth atom with a rich level structure. The qubit is encoded in the fine-structure (FS) qubit, defined by two long-lived metastable states:

$\ket{0} \equiv {^3\!P_0}$ — the “clock state,” with a natural lifetime exceeding 100 seconds
$\ket{1} \equiv {^3\!P_2},\, m_J = 0$ — another metastable state with similarly long coherence

The notation $^3\!P_0$ refers to spectroscopic term symbols: spin-triplet ($S=1$), orbital angular momentum $L=1$ ($P$-state), total angular momentum $J=0$.

Both states are “metastable” — they live far longer than any experiment takes. The energy splitting between them corresponds to a frequency of about $17\,\text{THz}$, giving an effective wavelength $\lambda_\text{FS} \approx 17.2\,\mu\text{m}$. This is a sweet spot: long enough that micron-scale atom displacements produce controlled phase shifts (enabling local single-qubit rotations), yet short enough that the Doppler effect from modest atom velocities is resolvable. The atoms are trapped under so-called “triple-magic” conditions where both qubit states experience the same trapping potential, preserving coherence. For a deeper introduction to alkaline-earth atom qubits, see Kaufman & Ni (2021).

The Doppler Effect

We all know the Doppler effect from everyday life: an ambulance siren sounds higher-pitched as it approaches and lower-pitched as it recedes. The same physics applies to light. When an atom moves toward a laser beam, it “sees” the light at a higher frequency than an atom sitting still.

Doppler shift for atoms. An atom moving with velocity $v$ toward a laser beam of wavenumber $k_0 = 2\pi/\lambda_0$ experiences a frequency shift \[ \Delta = k_0 \, v. \]

Doppler shift: an atom moving toward a laser beam sees the light at a higher frequency. The wavefronts are compressed in the atom’s reference frame, producing a frequency shift $\Delta = k_0 v$.

Let’s put numbers to this. For the $698\,\text{nm}$ clock transition in strontium, $k_0 = 2\pi/(698\,\text{nm}) \approx 9 \times 10^6\,\text{m}^{-1}$. An atom moving at just $v = 0.03\,\text{m/s}$ — barely a crawl — sees a Doppler shift of $\Delta \approx 2\pi \times 43\,\text{kHz}$. That might seem tiny, but the clock transition is extremely narrow (linewidth $< 1\,\text{Hz}$), so a few tens of kHz is a huge detuning relative to the linewidth.

Detuning ($\Delta$) is the difference between the laser frequency and the atomic transition frequency: $\Delta = \omega_\text{laser} - \omega_0$. When $\Delta = 0$ the laser is resonant and drives the atom efficiently. When $|\Delta| \gg \Omega$ (the Rabi frequency), the atom barely responds — it sees the laser as being on the wrong channel. Throughout this paper, $\Delta$ will always refer to the Doppler-induced detuning experienced by a stationary atom when the laser is tuned to resonate with a moving one.

This is the central insight: narrow-line transitions make velocity selectivity easy. A laser tuned to resonate with a moving atom will be far off-resonance for a stationary one. The paper exploits this to perform selective state preparation and measurement on moving atoms while leaving nearby stationary atoms completely unaffected. The residual excitation of stationary qubits can be as low as $0.4\%$ even at $v = 0.03\,\text{m/s}$.

Remark. Why “narrow-line” matters. Broader transitions (like the $461\,\text{nm}$ line in strontium, with linewidth $\sim 30\,\text{MHz}$) would require atom velocities thousands of times larger to achieve the same selectivity. The ultra-narrow clock transition is what makes the velocity-enabled architecture practical at sub-$\mu\text{m}/\mu\text{s}$ speeds.

For those wanting a deeper treatment of light-atom interactions and Doppler effects, Foot, Atomic Physics (2005) is an excellent reference.

Measurement-Based Quantum Computing

Most discussions of quantum computing follow the circuit model: apply a sequence of gates, then measure at the end. But there is a fundamentally different paradigm called measurement-based quantum computing (MBQC).

The recipe is conceptually striking:

Prepare a large, highly entangled resource state called a cluster state.
Compute by measuring individual qubits one at a time, choosing the measurement basis adaptively based on previous outcomes.
Read out the answer from the remaining unmeasured qubits.

Cluster state. A cluster state on a graph $G$ is constructed by placing each qubit in $\ket{+}$ and applying CZ gates between every pair of qubits connected by an edge. Its stabilizers are $S_i = X_i \prod_{j \in \mathcal{N}(i)} Z_j$, where $\mathcal{N}(i)$ denotes the neighbors of qubit $i$ in the graph.

Construction of a 4-qubit linear cluster state and its stabilizer operators. Each qubit starts in $\ket{+}$, CZ gates create entanglement along edges, and each stabilizer applies $X$ on one qubit and $Z$ on its neighbors.

Let’s unpack this. Consider a simple chain of three qubits. We prepare each in $\ket{+}$, then apply CZ between qubits 1–2 and between qubits 2–3. The resulting state is stabilized by operators like $X_1 Z_2$ (an $X$ on qubit 1 times a $Z$ on its neighbor qubit 2) and $Z_1 X_2 Z_3$ (an $X$ on qubit 2 times $Z$ on both its neighbors). These stabilizers all commute and have eigenvalue $+1$ on the cluster state. Measuring a stabilizer is a way to verify that the entanglement structure is intact.

For instance, the three stabilizers of this 3-qubit linear chain are $S_1 = X_1 Z_2$, $S_2 = Z_1 X_2 Z_3$, and $S_3 = Z_2 X_3$. If we measure $S_2$ and get $+1$, it confirms that qubit 2 is properly entangled with its neighbors 1 and 3. If we get $-1$ instead, something has gone wrong — an error has disrupted the entanglement near qubit 2. In the paper’s 8-qubit cluster state, all eight such stabilizer measurements exceeded $+0.5$, confirming genuine 8-party entanglement.

The average stabilizer value of the 8-qubit cluster state in the paper is $0.830(4)$ — above the entanglement witness threshold of $0.5$.

Why does MBQC matter for this paper? The velocity-enabled architecture provides exactly the tools that MBQC demands: (1) selective state preparation to initialize fresh qubits from a reservoir, (2) entangling gates (CZ) to build or grow a cluster state, (3) local single-qubit rotations to choose measurement bases, and (4) selective measurement to read out individual qubits without disturbing the rest. Crucially, the cluster state does not need to be created all at once — it can be grown incrementally, with measured qubits recycled back into the reservoir. For a comprehensive introduction to MBQC, see Raussendorf & Briegel (2001) and Briegel et al. (2009).

Velocity-Selective Operations

The core idea: Doppler-based addressability

Neutral-atom quantum computers face a persistent engineering headache: how do you talk to one qubit without disturbing its neighbors? The standard answers — tightly focused laser beams, spatial separation, frequency-gradient fields — all impose constraints on architecture, speed, or scalability. This paper offers a refreshingly different answer: make the atom move.

The physics is freshman-level, but the application is not. When an atom travels toward a laser source with velocity $v$, it sees a Doppler-shifted frequency

\[ \omega_{\text{lab}} + k_0 \, v, \]

where $k_0 = 2\pi / \lambda_0$ is the laser wavevector. If the bare atomic transition sits at $\omega_0$, then a laser tuned to $\omega_0 + k_0 v$ is resonant with the moving atom but detuned by $\Delta = k_0 v$ from every stationary atom in the array. As long as $\Delta$ is large compared to the Rabi frequency $\Omega$, the stationary atoms simply do not respond.

Velocity-selective addressing: a global laser beam interacts differently with stationary and moving atoms. Stationary atoms are off-resonant and unaffected, while moving atoms see the Doppler-shifted laser as resonant and are driven by the pulse.

Velocity-selective addressing. A laser pulse of Rabi frequency $\Omega$ and detuning $\Delta = k_0 v$ from the bare transition drives coherent Rabi oscillations on atoms moving at velocity $v$, while leaving stationary atoms essentially unperturbed, provided $\Delta / \Omega \gg 1$.

Example 5. Let’s plug in the paper’s numbers. The clock laser has $\lambda_0 = 698\;\text{nm}$, so $k_0 = 2\pi / 698\;\text{nm} \approx 9.0 \times 10^6\;\text{m}^{-1}$. At $v = 0.03\;\text{m/s}$, the Doppler shift is $\Delta = k_0 v \approx 2\pi \times 43\;\text{kHz}$. The Rabi frequency is $\Omega \approx 2\pi \times 4\;\text{kHz}$, giving a selectivity ratio $\Delta/\Omega \approx 10$. A stationary atom sees this $43\;\text{kHz}$ detuning as enormous compared to the $4\;\text{kHz}$ drive — it picks up only $0.4\%$ spurious excitation. Meanwhile the moving atom, being on resonance, undergoes a full $\pi$-pulse and flips with $97\%$ fidelity.

Let’s build some intuition. Think of a crowded radio dial: every station has its own frequency, and your receiver picks up only the one it is tuned to. Here, the “frequency label” is not painted on the atom at manufacture — we create it dynamically by setting the atom’s velocity. A stationary atom and a moving atom are, from the laser’s perspective, two different radio stations. Tune in to the moving one and the stationary one stays silent.

This is the conceptual engine of the entire paper. Every operation we will discuss — state preparation, measurement, single-qubit gates, even entangling gates — reduces to the same trick: move the right atoms, fire a velocity-tuned pulse, stop the atoms.

Velocity-selective state preparation

Let’s trace through the experiment step by step, following Figure 2b.

Velocity-selective Rabi oscillations. Stationary atoms (orange) remain near the ground state while moving atoms (blue) undergo coherent oscillations driven by a Doppler-shifted clock laser.

Step 1 — Accelerate the target atoms. A subset of atoms, held in acousto-optic deflector (AOD) tweezers, are smoothly accelerated to a velocity $v = 0.03\;\text{m/s}$ directed toward the clock laser at $\lambda_0 = 698\;\text{nm}$. The remaining atoms, held in static tweezers (SLM traps), stay put. This acceleration is gentle enough to avoid heating or trap loss.

Step 2 — Compute the Doppler shift. At $v = 0.03\;\text{m/s}$ and $\lambda_0 = 698\;\text{nm}$, the Doppler shift is

\[ \Delta = k_0 v = \frac{2\pi}{\lambda_0}\,v \approx 2\pi \times 43\;\text{kHz}. \]

This is many times larger than the Rabi frequency on the ${}^1S_0 \leftrightarrow {}^3P_0$ clock transition (typically $\Omega \approx 2\pi \times 4\;\text{kHz}$), giving a selectivity ratio $\Delta/\Omega \approx 10$.

Step 3 — Fire the clock laser. The clock laser is tuned to $\omega_0 + \Delta$, resonant with the moving atoms. As we can see in Figure 2b, the stationary atoms (orange) remain flat while the moving atoms (blue) oscillate — textbook Rabi flopping with high contrast.

Step 4 — Read off the result. At the $\pi$-time, the moving atoms are transferred from $\ket{0} \equiv {}^1S_0$ to $\ket{1} \equiv {}^3P_0$ with 97% fidelity. Meanwhile, the stationary atoms pick up only 0.4% residual excitation — they barely notice the pulse happened.

Remark. Remark. The 97% fidelity is not a fundamental limit. It is set by technical factors: laser linewidth, atom temperature, and the finite duration of the acceleration ramp. The 0.4% cross-talk on stationary atoms, however, is close to the theoretical floor predicted by the infidelity formula we derive below.

Velocity-selective measurement

Measurement is the reverse film of preparation, and the protocol (Figure 2c) mirrors the steps above.

Suppose a subset of qubits — the ones we want to measure — are in some superposition of $\ket{0}$ and $\ket{1}$. We accelerate those atoms to $v$ and apply a velocity-selective $\pi$-pulse that maps $\ket{1} \to \ket{0}$ on the moving atoms only. Now any moving atom that was in $\ket{1}$ is back in the ground state, while one that was in $\ket{0}$ gets shelved to $\ket{1}$ (or vice versa, depending on the pulse phase convention). We then image all atoms using the standard ${}^1S_0 \leftrightarrow {}^1P_1$ fluorescence cycling transition: ground-state atoms scatter photons and appear bright; ${}^3P_0$ atoms are dark.

The clock-state ${}^3P_0$ is metastable with a natural lifetime exceeding 100 seconds in ${}^{87}\text{Sr}$. It is completely invisible to the imaging light.

Because the velocity-selective $\pi$-pulse only touches the moving atoms, the stationary atoms are not measured — their quantum state is preserved through the entire imaging process. This is mid-circuit measurement without any physical shuttling to a separate readout zone. The reported detection fidelity is 96%, limited mainly by photon collection efficiency and off-resonant scattering during imaging.

The infidelity formula

We now arrive at one of the cleanest results in the paper: a closed-form expression for the cross-talk on stationary atoms.

Velocity-selective infidelity. The probability that a stationary atom is spuriously excited by a velocity-selective $\pi$-pulse is

\[ \epsilon = \frac{\pi^2}{4}\,\operatorname{sinc}^2\!\left(\frac{\pi}{2}\sqrt{1 + \left(\frac{\Delta}{\Omega}\right)^2}\right), \]

where $\operatorname{sinc}(x) = \sin(x)/x$, $\Delta = k_0 v$ is the Doppler detuning, and $\Omega$ is the resonant Rabi frequency.

Example 6. Let’s plug in real numbers. At $v = 0.03\;\text{m/s}$ with $\lambda_0 = 698\;\text{nm}$ and $\Omega = 2\pi \times 4\;\text{kHz}$, we have $\Delta/\Omega \approx 10$. During the $\pi$-pulse (duration $t_\pi = \pi/\Omega \approx 125\;\mu\text{s}$), the atom travels $d = v \cdot t_\pi \approx 3.75\;\mu\text{m}$, which is $d/\lambda_0 \approx 5.4$ wavelengths. The sinc argument is $(\pi/2)\sqrt{1 + 100} \approx 15.8$, so $\operatorname{sinc}(15.8) \approx -0.020$ and $\epsilon \approx (\pi^2/4)(0.020)^2 \approx 10^{-3}$. That is about $0.1\%$ cross-talk — close to the measured $0.4\%$, with the difference attributed to laser linewidth and atom temperature. Doubling the velocity to $0.06\;\text{m/s}$ would push $\Delta/\Omega$ to $\sim 20$ and suppress cross-talk below $0.01\%$.

The key insight is that the ratio $\Delta / \Omega$ has a beautiful geometric meaning. During the $\pi$-pulse (duration $t_\pi = \pi / \Omega$), the atom travels a distance

\[ d = v \, t_\pi = v \cdot \frac{\pi}{\Omega} = \frac{\pi \Delta}{k_0 \Omega} = \frac{\Delta}{2\Omega}\,\lambda_0. \]

So $\Delta / (2\Omega) = d / \lambda_0$: the selectivity parameter is just the number of laser wavelengths the atom traverses during the pulse. More distance means more accumulated Doppler phase, which means the stationary and moving atoms are better “frequency-resolved.” The infidelity drops rapidly once $d \gtrsim \lambda_0$.

Let’s put in numbers. At $\Delta/\Omega = 10$, the atom travels about 5 wavelengths during the $\pi$-pulse. The sinc function is evaluated far from its central peak, giving $\epsilon \approx 2.5 \times 10^{-3}$, consistent with the measured 0.4% cross-talk.

Why sinc-squared?

The sinc-squared envelope is the same function that appears in single-slit diffraction. This is not a coincidence. A square $\pi$-pulse in time is a rectangular window in the frequency domain, and its Fourier transform is a sinc. The probability of exciting a detuned atom is the squared overlap of this spectral window with the off-resonant transition — exactly the diffraction pattern of a slit of width $1/t_\pi$ evaluated at offset $\Delta$.

Derivation of the infidelity formula

Consider a two-level atom driven on resonance at Rabi frequency $\Omega$, but with detuning $\Delta$ (the case of a stationary atom seeing the velocity-shifted laser). The generalized Rabi frequency is $\Omega' = \sqrt{\Omega^2 + \Delta^2}$. Starting in $\ket{0}$, the excited-state population after time $t$ is

\[ P_1(t) = \frac{\Omega^2}{\Omega'^2}\,\sin^2\!\left(\frac{\Omega' t}{2}\right). \]

For a resonant $\pi$-pulse on the moving atoms, we need $\Omega\, t_\pi = \pi$, so $t_\pi = \pi/\Omega$. Substituting into the expression for stationary-atom excitation:

\[ \epsilon = P_1(t_\pi) = \frac{\Omega^2}{\Omega^2 + \Delta^2}\,\sin^2\!\left(\frac{\pi}{2}\,\frac{\sqrt{\Omega^2 + \Delta^2}}{\Omega}\right). \]

Writing $\Omega^2/(\Omega^2 + \Delta^2) = 1/(1 + (\Delta/\Omega)^2)$ and using $\sin^2(x)/x^2 \cdot x^2 = \operatorname{sinc}^2(x/\pi)\cdot x^2$, we can massage this into

\[ \epsilon = \frac{\pi^2}{4}\,\operatorname{sinc}^2\!\left(\frac{\pi}{2}\sqrt{1 + \left(\frac{\Delta}{\Omega}\right)^2}\right), \]

where $\operatorname{sinc}(x) = \sin(x)/x$. The identification $d/\lambda_0 = \Delta/(2\Omega)$ follows directly from $d = v\,t_\pi$ and $\Delta = k_0 v = (2\pi/\lambda_0)\,v$.

Faster variants: three-photon and dissipative protocols

The clock transition ${}^1S_0 \leftrightarrow {}^3P_0$ in strontium is narrow (millihertz natural linewidth), which is wonderful for selectivity but limits the Rabi frequency to a few kHz — each $\pi$-pulse takes hundreds of microseconds. For a quantum computer that needs to interleave many operations, this is slow.

Three-photon Raman transition. The authors demonstrate an alternative pathway that drives the same $\ket{0} \to \ket{1}$ transition via three intermediate photons, achieving Rabi frequencies up to $\Omega \approx 2\pi \times 40\;\text{kHz}$ — roughly ten times faster than the direct clock drive. Because the effective wavevector $k_{\text{eff}}$ of the three-photon process is different, the required velocity changes, but the principle is identical: the Doppler shift on moving atoms puts them on resonance while stationary atoms remain detuned.

Dissipative depumping (Figures 2e, 2f). Sometimes we do not need a coherent rotation; we just need to reset a qubit to $\ket{0}$. The dissipative protocol velocity-selectively drives moving atoms from ${}^3P_0$ into a short-lived excited state that rapidly decays back to ${}^1S_0$. This is incoherent by design — it works regardless of the initial phase of the qubit and empties $\ket{1}$ in a few cycles. It is especially useful for mid-circuit reset, where we want to reinitialize a measured qubit without disturbing unmeasured neighbors.

Remark. Remark. The three-photon and dissipative schemes highlight a general design principle: the velocity-selective framework is agnostic to the internal mechanism of the state transfer. Any process whose resonance condition depends on the atom’s velocity can be made selective. What matters is the ratio $\Delta / \Omega$, however that ratio is engineered.

Generality across platforms

Nothing in the velocity-selective idea is specific to strontium or to the clock transition. The requirement is simply a transition narrow enough that a realistic Doppler shift ($\sim$ tens of kHz) produces a large detuning relative to $\Omega$. This is satisfied by:

Ytterbium (${}^{171}\text{Yb}$): Has an analogous ${}^1S_0 \leftrightarrow {}^3P_0$ clock transition at 578 nm. The shorter wavelength means a larger $k_0$ and hence more Doppler shift per unit velocity — even better selectivity at the same speed.
Rubidium (${}^{87}\text{Rb}$): Lacks a narrow clock transition, but one can engineer velocity sensitivity using counter-propagating Raman beams (Figure 2d). Two lasers driving a two-photon Raman transition between hyperfine ground states produce an effective wavevector $k_{\text{eff}} = k_1 + k_2 \approx 2k$, doubling the Doppler sensitivity. The individual Raman beams are far-detuned from any excited state, so the effective linewidth is set by the Rabi frequency, not by spontaneous emission.

Counter-propagating Raman beams are standard toolkit in atom interferometry, where they split atomic wavepackets by imparting momentum $\hbar k_{\text{eff}}$. Here the same geometry provides velocity selectivity instead.

The rubidium case is particularly significant because it shows the velocity-selective approach is not limited to alkaline-earth atoms with their special clock states. Any platform where atoms can be moved at controlled velocities and addressed by a transition with a sufficiently narrow effective linewidth can, in principle, implement the full velocity-selective gate set.

This generality is what elevates the proposal from a clever strontium trick to a potentially universal architectural primitive for neutral-atom quantum computing.

Local Rotations On-The-Fly

The problem: co-propagating beams kill velocity selectivity

In the previous sections we saw how velocity selectivity on a narrow-line transition lets us address individual atoms for state preparation and measurement — atoms at different velocities simply don’t see the same resonance frequency. That trick relies on a large Doppler shift, which requires counter-propagating laser beams so that the effective wavevector $k_{\text{eff}}$ is large.

Single-qubit rotations on the fine-structure qubit, however, use co-propagating Raman beams. The two beams travel in the same direction, so the atom absorbs a photon from one beam and emits into the other with almost the same momentum. The effective wavevector is tiny — just the difference between the two Raman frequencies divided by $c$ — and the resulting Doppler shift is negligible. Velocity selectivity simply does not work here.

Remark. Remark. This is not a minor inconvenience. Without some mechanism for local single-qubit rotations, we would still need focused laser beams to address individual atoms, defeating the entire purpose of the velocity-enabled architecture. We need a different trick.

Spatial phase: position replaces velocity

The key insight is that even though the Doppler shift is negligible, the spatial phase picked up by a displaced atom is not. Let’s see why.

When an atom sits at position $x$ along the propagation axis of the Raman beams, the two-photon Raman transition imprints a phase

\[ \phi(x) = k_{\text{eff}} \cdot x = \frac{2\pi}{\lambda_{FS}} \, x \]

where $\lambda_{FS}$ is the effective wavelength set by the fine-structure splitting. For the ${}^{3}P_0 \leftrightarrow {}^{3}P_2$ fine-structure qubit in ${}^{88}\text{Sr}$, this works out to

\[ \lambda_{FS} \approx 17.2\;\mu\text{m}. \]

Spatial phase addressability. A qubit displaced by $\Delta x$ along the Raman beam axis accumulates an additional phase $\Delta\phi = 2\pi\,\Delta x / \lambda_{FS}$ relative to a stationary qubit. A displacement of $\lambda_{FS}/2 \approx 8.6\;\mu\text{m}$ corresponds to a full $\pi$ phase shift.

Example 7. Let’s see this concretely with the paper’s parameters. With $\lambda_{FS} = 17.2\;\mu\text{m}$, a displacement of $\Delta x = 2.15\;\mu\text{m}$ (one-eighth of a wavelength) gives $\Delta\phi = 2\pi \times 2.15 / 17.2 = \pi/4$, i.e., a 45-degree rotation on the Bloch sphere. Double it to $4.3\;\mu\text{m}$ ($\lambda_{FS}/4$) and we get $\Delta\phi = \pi/2$ — exactly a Hadamard-like rotation that converts a $Z$-eigenstate into an $X$-eigenstate. This is how the paper implements measurement-basis changes for stabilizer readout: shift the target atom by $2.15\;\mu\text{m}$, apply a global Raman pulse, and that atom alone receives a different rotation than its neighbors.

Intuitively, think of the Raman field as a standing-wave pattern with period $\lambda_{FS}$. Sliding an atom along this pattern rotates the axis of the Raman drive in the equatorial plane of the Bloch sphere. At $8.6\;\mu\text{m}$ of displacement, the rotation axis has flipped completely — that’s a $\pi$ phase difference. The crucial point is that $17.2\;\mu\text{m}$ is a comfortable length scale for optical tweezers. Moving atoms by a few microns is routine. Compare this with optical-frequency qubits, where $\lambda_{\text{eff}}$ is on the order of hundreds of nanometers — there, sub-$100\;\text{nm}$ positioning precision would be required for phase control, which is far beyond what current tweezer systems can reliably achieve.

The fine-structure wavelength of $17.2\;\mu\text{m}$ sits in a sweet spot: long enough for easy tweezer control, short enough that useful phase differences accumulate over just a few microns.

Ramsey experiment: seeing the phase oscillation

The authors verify this spatial phase mechanism with a clean Ramsey interferometry experiment (Figure 3a).

Here is the protocol, step by step:

First $\pi/2$ pulse (global). All atoms, regardless of position, are rotated from $\ket{0}$ into an equal superposition $(\ket{0} + \ket{1})/\sqrt{2}$.
Displace the atom by a controlled distance $\Delta x$ along the Raman beam axis (the $x$-direction). This imprints the spatial phase $\Delta\phi = 2\pi\,\Delta x / \lambda_{FS}$ between the two qubit states.
Second $\pi/2$ pulse (global). This converts the accumulated phase into a population difference.
Measure the $\ket{0}$-state population.

The result is a Ramsey fringe: the population oscillates sinusoidally as a function of $\Delta x$ with period $\lambda_{FS} \approx 17.2\;\mu\text{m}$. Crucially, when the displacement is along $y$ (perpendicular to the Raman beams), the signal is flat — no phase is accumulated, exactly as expected.

Figure 3. (a) Ramsey fringes from spatial displacement. The $\ket{0}$-state population oscillates with displacement along $x$ (Raman beam direction) at the expected fine-structure wavelength, while displacement along $y$ produces no oscillation. (b) Echo experiment demonstrating local control. (c) On-the-fly rotations performed while atoms are in motion.

This is a textbook Ramsey experiment, but the “free evolution” phase comes not from a detuning or a time delay — it comes purely from a spatial displacement. That distinction is the entire mechanism for local control.

Echo sequence: different rotations on different atoms

Demonstrating the spatial phase is one thing. The real question is: can we use it to apply different rotations to different atoms using only global beams? The echo experiment in Figure 3b answers this decisively.

The protocol works as follows. Three groups of atoms are prepared, all starting in $\ket{0}$:

Static group — these atoms stay put. They serve as a reference.
Group A — displaced by $\lambda_{FS}/8 \approx 2.15\;\mu\text{m}$.
Group B — displaced by $\lambda_{FS}/4 \approx 4.3\;\mu\text{m}$.

All three groups receive the same global Ramsey pulse sequence ($\pi/2$ – displacement – $\pi/2$), but because they sit at different positions in the Raman phase landscape, they accumulate different phases. The result:

The static group shows the standard Ramsey fringe.
Group A shows a Ramsey fringe shifted by $\pi/4$ relative to the static reference.
Group B shows a Ramsey fringe shifted by $\pi/2$.

Remark. Remark. Notice what just happened: three atoms in the same trap array, illuminated by the same global laser pulses, ended up with three distinct rotation angles. The only difference was a micron-scale displacement applied by the optical tweezers. This is the core primitive for single-qubit addressability in the velocity-enabled architecture.

The echo sequence also serves a practical purpose. Any global phase drifts (from laser noise, ambient magnetic fields, etc.) affect all three groups identically and cancel out in the differential measurement. The clean sinusoidal shifts confirm that the spatial phase is the dominant, controllable effect.

On-the-fly rotations: gates during transport

So far the atoms were displaced and then held still during the Raman pulses. But in a velocity-enabled architecture, atoms are constantly in motion. Can we perform a rotation on a moving atom?

Why motion doesn’t spoil the gate

The concern is straightforward: if an atom moves during the Raman pulse, the spatial phase $\phi(x)$ changes continuously, potentially scrambling the rotation. Whether this matters depends on how much the phase changes during the gate time $\tau_{\text{gate}}$.

The phase accumulated during transit is

\[ \Delta\phi_{\text{transit}} = k_{\text{eff}} \cdot v \cdot \tau_{\text{gate}} = \frac{2\pi\,v\,\tau_{\text{gate}}}{\lambda_{FS}}. \]

For the fine-structure qubit, the Rabi frequency is $\Omega_R / 2\pi \approx 120\;\text{kHz}$, giving a $\pi$-pulse time of $\tau_{\pi} \approx 4.2\;\mu\text{s}$. At a velocity of $v = 0.1\;\text{m/s}$:

\[ \Delta\phi_{\text{transit}} = \frac{2\pi \times 0.1 \times 4.2 \times 10^{-6}}{17.2 \times 10^{-6}} \approx 0.15\;\text{rad} \approx 9°. \]

This is small enough that the rotation fidelity is barely affected. The combination of a long effective wavelength ($17.2\;\mu\text{m}$) and a fast gate ($4.2\;\mu\text{s}$) keeps the atom effectively “frozen” in the Raman phase landscape during the pulse.

The intuition is simple: the atom just doesn’t move very far during the gate. At $0.1\;\text{m/s}$, it traverses only $0.4\;\text{nm}$ during a $\pi$-pulse — a tiny fraction of $\lambda_{FS}$. The phase barely budges.

The experiment in Figure 3c confirms this. Atoms are launched at $v = 0.1\;\text{m/s}$ and a Ramsey sequence is performed while they are in flight. The measured contrast is 95.5%, compared to 96.2% for the stationary reference — statistically indistinguishable. The on-the-fly rotations work.

The $0.7\%$ contrast difference between stationary and moving atoms is well within experimental uncertainty. There is no measurable penalty for performing gates during transport at $0.1\;\text{m/s}$.

Putting it all together: a complete local toolbox from global beams

Let’s step back and appreciate what we now have. Between the velocity-selective operations (Sections 2–3) and the spatial-phase rotations (this section), the architecture provides:

Operation	Mechanism	Addressing method
State preparation	Narrow-line optical pumping	Velocity selectivity
Measurement	Narrow-line fluorescence	Velocity selectivity
Single-qubit $Z$-rotation	Raman spatial phase	Positional displacement
Single-qubit $X$/$Y$-rotation	Raman spatial phase	Positional displacement

Every entry in this table uses global beams only. Individual atom control comes entirely from the atoms’ velocities and positions — quantities that optical tweezers already control with high precision as part of their basic function.

This is a qualitative shift in architecture. Conventional neutral-atom quantum computers require tightly focused, individually steered laser beams for single-qubit gates — one of the most technically demanding aspects of scaling. The velocity-enabled approach replaces all of that hardware with the transport system that the tweezers were already providing for atom rearrangement and entangling-gate zones.

Remark. Remark. The spatial-phase technique is specific to qubits with long effective wavelengths, such as the fine-structure qubit. Hyperfine or optical qubits have $\lambda_{\text{eff}}$ in the hundreds of nanometers, requiring impractical positioning precision. The fine-structure qubit in ${}^{88}\text{Sr}$ is not just a convenient choice — it is architecturally essential.

Cluster State Generation

Measurement-based quantum computing in a nutshell

Most people’s first encounter with quantum computing is the circuit model: we initialize qubits, apply a sequence of gates, and measure at the end. Measurement-based quantum computing (MBQC) takes a radically different approach. The idea, due to Raussendorf and Briegel, is to split the computation into two phases:

Resource preparation. We create a large, highly entangled state called a cluster state – an entangled fabric of qubits arranged on a graph (typically a lattice). This step is the same regardless of what computation we want to run.
Adaptive measurement. We perform the actual computation by measuring individual qubits one at a time, choosing the measurement basis for each qubit based on the outcomes of previous measurements. The choice of basis is what encodes the algorithm.

Cluster state. A cluster state on a graph $G = (V, E)$ is the $n$-qubit state obtained by:

Initializing every qubit in $\ket{+} = \frac{1}{\sqrt{2}}(\ket{0} + \ket{1})$
Applying a controlled-Z (CZ) gate between every pair of qubits connected by an edge in $G$

The resulting state is the unique simultaneous $+1$ eigenstate of the stabilizer generators \[S_i = X_i \prod_{j \in \mathcal{N}(i)} Z_j, \qquad i \in V,\] where $\mathcal{N}(i)$ is the set of neighbors of qubit $i$ in $G$.

Let’s unpack this. Each qubit $i$ “owns” a stabilizer $S_i$: Pauli-$X$ on itself, tensored with Pauli-$Z$ on every neighbor. If we measure all stabilizers and get $+1$ for each, we know the cluster state is correct. If any gives $-1$, an error occurred. Stabilizers are a checklist the state must pass.

Example 8. For a 4-qubit linear chain ($1$–$2$–$3$–$4$), the stabilizer generators are: $S_1 = X_1 Z_2$, $S_2 = Z_1 X_2 Z_3$, $S_3 = Z_2 X_3 Z_4$, $S_4 = Z_3 X_4$. Suppose we measure $S_3$: we rotate qubit 3 from the $Z$ to the $X$ basis (via a $\pi/2$ displacement of $2.15\;\mu\text{m}$), then measure qubits 2, 3, and 4 in the computational basis, obtaining outcomes $m_2, m_3, m_4 \in \{+1, -1\}$. The stabilizer value is $s_3 = m_2 \cdot m_3 \cdot m_4$. If we get $(m_2, m_3, m_4) = (+1, -1, -1)$, then $s_3 = (+1)(-1)(-1) = +1$ — the cluster state passes this check. But $(+1, +1, -1)$ gives $s_3 = -1$, signaling an error near qubit 3.

Remark. Why MBQC? The appeal of measurement-based computing is that the entangling operations (the hard part, physically) are done in a uniform, pattern-independent way. All the algorithmic flexibility lives in the choice of single-qubit measurement bases, which are typically much easier to implement. For neutral-atom platforms, where global Rydberg interactions naturally produce CZ gates, this is an excellent match.

The velocity-enabled MBQC scheme

The paper proposes a concrete protocol for running MBQC using the velocity-enabled toolbox. Let’s walk through it step by step, following Figure 4a.

Step 1: Start with a reservoir. We begin with a pool of ground-state atoms held in optical tweezers – cold, unentangled, sitting in their motional ground state.

Step 2: Pick up selected atoms. Movable tweezers grab a subset of atoms from the reservoir to become the next batch of qubits.

Step 3: Velocity-selective excitation. While the tweezers move the atoms, a velocity-selective clock pulse excites them into the qubit manifold. The Doppler shift means only atoms at the target velocity are resonant with the laser. Stationary reservoir atoms are left untouched – we selectively promote atoms into qubits without disturbing anything else.

Step 4: Entangle via CZ gates. The freshly excited qubits are brought near existing cluster qubits. Global Rydberg pulses implement CZ gates, stitching new qubits onto the cluster boundary.

Step 5: Local rotations via displacement. To choose measurement bases, we displace individual atoms by a fraction of $\lambda_{FS}$, implementing qubit-specific phase gates as described in earlier sections.

Step 6: Velocity-selective measurement and recycling. We measure qubits selectively via a three-photon transition addressing only moving atoms, then take a fast camera image. Measured atoms are recooled and returned to the reservoir for reuse. Classical outcomes feed forward to determine subsequent measurement bases.

Step 7: Repeat. The cycle continues: pick up, excite, entangle, measure, recycle. The cluster grows and the computation proceeds through adaptive measurements.

Why recycling matters

In circuit-model quantum computing, once a qubit is measured, it’s typically done. In the velocity-enabled MBQC scheme, measured atoms don’t go to waste. They are recooled to the motional ground state and returned to the reservoir, ready to be picked up and re-excited for the next round. This atom recycling is crucial for scalability: we don’t need $N$ atoms for an $N$-step computation. A modest reservoir can support an arbitrarily long computation, as long as we recycle fast enough.

Experimental demonstration

To demonstrate this scheme, the authors build an 8-qubit linear cluster state using 12 atoms total. Let’s follow what they do, step by step, referring to Figure 4b and 4c.

Figure 4. (a) Schematic of the velocity-enabled MBQC protocol. (b,c) Experimental generation and verification of an 8-qubit linear cluster state. (d) Scanning the displacement to find the optimal single-qubit rotation point.

The setup. Twelve atoms are loaded into tweezers. Eight of them are picked up and will become cluster qubits. The remaining four stay in the ground state as a reservoir, demonstrating that ground-state atoms coexist harmlessly with active qubits.

Building the cluster. The 8-qubit linear cluster state is created using a circuit that maps neatly onto the platform’s capabilities:

All 8 qubits are initialized in $\ket{0}$ and then rotated to $\ket{+}$ by a global Hadamard-like operation (a $\pi/2$ rotation).
Two layers of CZ gates are applied. The first layer entangles qubits in odd-even pairs: $(1,2), (3,4), (5,6), (7,8)$. The second layer entangles even-odd pairs: $(2,3), (4,5), (6,7)$. Together, these two layers create all nearest-neighbor CZ connections needed for a linear chain.

Two layers of CZ gates suffice for a linear cluster because the graph has no edges between next-nearest neighbors. This is a general fact: a graph with maximum degree $d$ needs at most $d$ layers of parallel CZ gates.

Verifying the cluster state with stabilizers. We measure the stabilizer generators $S_i = X_i \prod_{j \in \mathcal{N}(i)} Z_j$. For a linear chain, interior qubits have $S_i = Z_{i-1} X_i Z_{i+1}$; boundary qubits have $S_1 = X_1 Z_2$ and $S_8 = Z_7 X_8$.

Measuring each stabilizer requires rotating the $X$-measured qubit before readout while leaving the $Z$-measured neighbors alone. The displacement-based local addressing handles this: individual atom displacements implement the necessary rotations, then all qubits are measured in the computational basis.

Stabilizer measurement details

For a linear cluster state on 8 qubits, the 8 stabilizer generators are:

\[S_1 = X_1 Z_2, \quad S_2 = Z_1 X_2 Z_3, \quad \ldots, \quad S_7 = Z_6 X_7 Z_8, \quad S_8 = Z_7 X_8.\]

Measuring $S_i$ requires a joint measurement of $X$ on qubit $i$ and $Z$ on its neighbors. In practice, this is done by rotating qubit $i$ with a displacement-based $R_y(\pi/2)$ gate (mapping $Z \to X$), then measuring all relevant qubits in the $Z$ basis. The stabilizer eigenvalue is the product of the outcomes: $s_i = m_i \cdot \prod_{j \in \mathcal{N}(i)} m_j$, where $m_k = \pm 1$ is the measurement result of qubit $k$. If the state is a perfect cluster state, every $\expect{S_i} = +1$.

Results. The average stabilizer expectation value across all 8 generators is $\expect{S_i} = 0.830(4)$, measured using state-resolved detection (which distinguishes the two qubit states $\ket{0}$ and $\ket{1}$ rather than just checking whether an atom is present). Every individual stabilizer value exceeds $0.5$.

Remark. Why 0.5 matters. A stabilizer expectation above $0.5$ is the threshold for certifying genuine multipartite entanglement (GME). If $\expect{S_i} > 0.5$ for all $i$, the state cannot be written as a mixture of biseparable states – it is genuinely 8-party entangled. This is a strong benchmark: random or poorly prepared states will not pass this test. The fact that all 8 stabilizers clear this bar confirms that the velocity-enabled protocol produces a high-quality cluster state.

Scanning the displacement

Figure 4d shows a beautiful diagnostic measurement. The authors take one of the stabilizers and vary the displacement applied to the target qubit, sweeping it continuously. The stabilizer expectation value traces out a sinusoidal oscillation as a function of displacement.

This makes perfect sense physically. The displacement-based phase gate rotates the qubit on the Bloch sphere. As we increase the displacement from zero, the qubit rotates away from the $Z$-axis toward the $X$-axis, reaches the equator (optimal for $X$ measurement), continues to $-Z$, and so on. The stabilizer expectation is maximized when the qubit is rotated into exactly the right basis – which occurs at a displacement of $\lambda_{FS}/8$, one-eighth of the fine-structure wavelength.

The $\lambda_{FS}/8$ displacement implements a $\pi/2$ rotation. Since the differential light shift completes a full $2\pi$ phase cycle over $\lambda_{FS}/2$ (due to the standing-wave structure of the trapping potential), a shift of $\lambda_{FS}/8$ gives a quarter-cycle, i.e., $\pi/2$.

The sinusoidal shape is direct experimental proof that the displacement-based rotation works as predicted: we can dial in any desired rotation angle by choosing the right displacement. The peak contrast also serves as a quality metric – a decoherent system would show a damped sinusoid with reduced amplitude.

Putting it together

This section demonstrated the full velocity-enabled MBQC workflow: velocity-selective excitation to create qubits on demand, CZ gates to build entanglement, displacement-based local rotations to choose measurement bases, and selective measurement with atom recycling. The 8-qubit cluster state, with its average stabilizer value of $0.830(4)$ and certified genuine multipartite entanglement, shows that all the individual velocity-enabled primitives compose into a working quantum computing protocol. In the next section, we will see these same tools applied to an even more demanding task: quantum error detection.

Quantum Error Detection with the [[4,2,2]] Code

The [[4,2,2]] code: two logical qubits in four physical ones

Real quantum hardware is noisy. Qubits decohere, gates have finite fidelity, and measurements sometimes give wrong answers. Quantum error correction (QEC) is the art of encoding quantum information redundantly so that errors can be detected or corrected. The simplest useful code the authors demonstrate is the [[4,2,2]] code.

The [[4,2,2]] code. This code encodes $k = 2$ logical qubits into $n = 4$ physical qubits, with distance $d = 2$. The stabilizer group is generated by two operators: \[g_1 = X^{\otimes 4} = X_1 X_2 X_3 X_4, \qquad g_2 = Z^{\otimes 4} = Z_1 Z_2 Z_3 Z_4.\] The code can detect any single-qubit error (distance 2 means it detects up to $d - 1 = 1$ errors), but it cannot correct errors.

Let’s build intuition for what this means. The two stabilizer generators $X^{\otimes 4}$ and $Z^{\otimes 4}$ define the code space: the valid logical states are exactly those 4-qubit states that are $+1$ eigenstates of both operators. This carves out a 4-dimensional subspace (encoding 2 logical qubits) from the 16-dimensional Hilbert space of 4 physical qubits.

Example 9. The four logical basis states are: $\ket{00}_L = (\ket{0000} + \ket{1111})/\sqrt{2}$, $\ket{01}_L = (\ket{0011} + \ket{1100})/\sqrt{2}$, $\ket{10}_L = (\ket{0101} + \ket{1010})/\sqrt{2}$, $\ket{11}_L = (\ket{0110} + \ket{1001})/\sqrt{2}$. Notice every state has even parity — each branch contains an even number of 1s. That is how $Z^{\otimes 4}$ catches single bit-flips: flipping any one physical qubit produces odd parity, changing the $Z^{\otimes 4}$ eigenvalue from $+1$ to $-1$. The logical Bell state prepared in the paper is $\ket{\Phi^+}_L = (\ket{00}_L + \ket{11}_L)/\sqrt{2}$, which expands to $(\ket{0000} + \ket{1111} + \ket{0110} + \ket{1001})/2$ — all even-parity terms, as required.

What happens when a single-qubit error strikes? A bit-flip $X_j$ anticommutes with $Z^{\otimes 4}$ (it changes the overall $Z$-parity), flipping $g_2$ from $+1$ to $-1$. A phase-flip $Z_j$ anticommutes with $X^{\otimes 4}$, flipping $g_1$. A combined $Y_j$ error flips both syndromes. In every case, at least one stabilizer flags the error. We know that an error occurred, though not which qubit was affected (correcting would require distance 3).

The notation $[[n,k,d]]$ is standard for quantum error-correcting codes: $n$ physical qubits, $k$ logical qubits, distance $d$. The [[4,2,2]] code is the smallest code that encodes more than one logical qubit.

Remark. Detection vs. correction. A distance-2 code detects single errors but cannot correct them. In practice, we post-select: keep only runs where both stabilizers give $+1$, discard the rest. This reduces data rate but dramatically improves the fidelity of surviving runs – a powerful tool for near-term demonstrations.

Preparing a logical Bell state

The first error-detection experiment prepares a logical Bell state – a maximally entangled state of the two logical qubits encoded in the [[4,2,2]] code. Let’s follow the protocol shown in Figure 5a and 5b.

Figure 5. (a,b) Fault-tolerant preparation and verification of a logical Bell state in the [[4,2,2]] code. (c) Flying ancilla syndrome measurement: an atom moves along the data qubit chain, performing fly-by CZ gates and enabling on-the-fly error detection.

The circuit. The authors use a fault-tolerant circuit consisting of single-qubit rotations and CZ gates across the 4 physical qubits. The local rotations are implemented via atom displacement – the same technique from the cluster-state experiment. Different qubits are displaced by different amounts to achieve qubit-specific rotations within an otherwise global gate sequence.

Measurement in two bases. To fully characterize the logical Bell state, the authors measure in both the logical $X$ and logical $Z$ bases. Since logical operators act on pairs of physical qubits, measuring them requires physical measurements in the appropriate bases followed by parity computation. Displacement-based rotations switch individual qubits between $X$ and $Z$ measurement bases.

Post-selection. After each run, the syndromes $X^{\otimes 4}$ and $Z^{\otimes 4}$ are computed from the outcomes. Runs where either syndrome gives $-1$ are discarded; only syndrome-passing runs contribute to the fidelity estimate.

Logical operators of the [[4,2,2]] code

With two logical qubits, we need two pairs of logical Pauli operators. A standard choice is:

\[X_{L1} = X_1 X_2, \quad Z_{L1} = Z_1 Z_3, \quad X_{L2} = X_1 X_3, \quad Z_{L2} = Z_1 Z_2.\]

These commute with both stabilizers, commute across logical qubits, and anticommute within each pair – exactly as bare Paulis should. The logical Bell state is: \[\ket{\Phi^+}_L = \frac{1}{\sqrt{2}}\bigl(\ket{00}_L + \ket{11}_L\bigr).\]

For instance, to measure logical $Z_{L1} = Z_1 Z_3$, we measure physical qubits 1 and 3 in the $Z$ basis and multiply the outcomes. If qubit 1 gives $+1$ and qubit 3 gives $-1$, then $Z_{L1} = -1$, meaning logical qubit 1 is in $\ket{1}_L$. The physical measurement never touches qubits 2 or 4 — logical information is spread across non-adjacent physical qubits, a hallmark of the code’s error-detection capability.

The result: 99.0(3)% logical fidelity. After post-selection on correct stabilizer parity, the logical Bell state is prepared with $99.0(3)\%$ fidelity. Let’s pause and appreciate what this number means.

In the same experimental sequence, the best physical Bell-state fidelity – two physical qubits entangled by a CZ gate without any encoding or error detection – is $88.5\%$. The logical Bell state, encoded in four physical qubits with error detection, achieves $99.0\%$.

The whole point of quantum error correction

This demonstrates the central promise of QEC: logical operations outperforming physical ones. The physical Bell pair has $\sim 11.5\%$ infidelity; the [[4,2,2]] code suppresses this to $\sim 1\%$ by detecting and discarding error events. We paid a cost – 4 physical qubits instead of 2, plus discarded runs – but the surviving data is dramatically cleaner. This is the QEC bargain: trade qubit count and data rate for fidelity. That this bargain already pays off on a first demonstration signals that the platform has the gate quality needed for fault-tolerant computing.

Flying ancilla syndrome measurement

The most striking demonstration in the paper is the flying ancilla experiment, shown in Figure 5c. This is where the velocity-enabled architecture reveals capabilities that have no analog in conventional neutral-atom or ion-trap platforms.

The concept. In any QEC code, we must periodically check for errors via syndrome extraction: an ancilla qubit interacts with data qubits to gather syndrome information, then gets measured. Conventionally, this requires shuttling atoms to dedicated interaction zones and stopping at each one.

The velocity-enabled approach is different. An ancilla atom physically moves along the data qubit chain at $v = 0.1$ m/s, performing CZ gates with each data qubit as it flies past. It never stops. Let’s walk through the sequence.

Step 1: Selective excitation. The ancilla is picked up by a movable tweezer and accelerated to $v = 0.1$ m/s. A velocity-selective clock pulse excites it into the qubit manifold while moving; stationary data qubits are unaffected.

Step 2: Fly-by CZ gates. As the ancilla passes each data qubit, a global Rydberg pulse implements a CZ gate – the ancilla is momentarily within blockade radius as it flies by. After interacting with all data qubits, the ancilla’s state encodes the parity of the data register.

The velocity $0.1$ m/s balances two demands: fast enough to finish before decoherence degrades the data, slow enough for high-fidelity fly-by CZ gates.

Step 3: Selective measurement. After flying past all data qubits, the ancilla is measured via a three-photon transition and fast camera image. Velocity selectivity ensures only the moving ancilla is addressed, leaving data qubits undisturbed.

Step 4: Result. The protocol prepares $\ket{01}_L$ with $96\%$ probability. The high success rate confirms that fly-by syndrome extraction works reliably.

How fly-by CZ gates extract a syndrome

An ancilla in $\ket{+}$ sequentially undergoes CZ gates with each data qubit:

\[\text{CZ}_{a,4}\;\text{CZ}_{a,3}\;\text{CZ}_{a,2}\;\text{CZ}_{a,1}\;\ket{+}_a \otimes \ket{\psi}_{\text{data}}.\]

Each CZ applies a $-1$ phase when both qubits are in $\ket{1}$, so the ancilla accumulates a phase reflecting the total $\ket{1}$-population of the data. Measuring the ancilla in the $X$ basis reveals $Z^{\otimes 4}$ – exactly one of the [[4,2,2]] stabilizers. The other stabilizer $X^{\otimes 4}$ is extracted analogously by first rotating data qubits into the $X$ basis.

Why the flying ancilla changes the game

Let’s consider why the flying ancilla is such a significant result. In conventional neutral-atom architectures, syndrome extraction typically follows a zone-based model:

Shuttle data qubits (or ancillas) to a dedicated gate zone
Stop and perform the entangling gate
Shuttle to a measurement zone
Stop and measure
Shuttle everything back

Each stop requires deceleration, settling time, interaction, and re-acceleration. These overheads accumulate and can dominate the QEC cycle time.

The flying ancilla eliminates all of this. The ancilla picks up speed, gets excited while moving, performs CZ gates on the fly, and gets measured without ever decelerating. Syndrome extraction becomes a continuous process rather than a sequence of discrete park-and-operate steps.

Remark. Speed advantage. In a zone-based architecture, each gate requires a deceleration-gate-acceleration sequence taking hundreds of microseconds per stop. With $n$ data qubits, that is $n$ stops. The flying ancilla replaces this with a single smooth pass at constant velocity. The time per syndrome extraction scales with the fly-by time rather than $n$ times the stop-start overhead – an advantage that compounds as codes grow larger.

Notice the conceptual shift. In the velocity-enabled picture, an atom’s motion is not a nuisance to be suppressed – it is a resource. The velocity enables selective excitation and measurement; the physical motion through space enables sequential interactions with data qubits. Every moment of motion is doing useful work.

Summary of error-detection results

Let’s collect the key numbers from this section:

Metric	Value
Logical Bell-state fidelity (post-selected)	99.0(3)%
Best physical Bell-state fidelity (same sequence)	88.5%
Logical $\ket{01}_L$ preparation via flying ancilla	96% probability
Ancilla velocity during syndrome extraction	0.1 m/s
Code parameters	[[4,2,2]]: 4 physical qubits, 2 logical qubits, distance 2

The logical fidelity exceeding the physical fidelity is the headline result: it demonstrates that error detection genuinely helps on this platform. The flying ancilla shows that syndrome extraction – the most repetitive operation in QEC – can be performed continuously, without stopping. Together, these results make a compelling case that velocity-enabled neutral-atom quantum computing is a serious architecture for scalable, fault-tolerant quantum computation.

Outlook and Perspective

We have walked through the core machinery of velocity-enabled quantum computing: using an atom’s motion — specifically its velocity — as a control knob for selectively addressing qubits with global laser beams. Let’s now step back and ask: how does this compare to existing approaches, where might it go, and what still needs work?

Velocity zones vs spatial zones: a quantitative snapshot

The conventional way to achieve selective control in a neutral-atom processor is spatial zoning: physically shuttle atoms to different regions of the trap array, each illuminated by its own laser. The paper’s supplementary information puts hard numbers on the comparison.

In a spatial-zone architecture, the distinct zones sit roughly 100 $\mu$m apart. Moving an atom between zones takes on the order of 200 $\mu$s of shuttling time — time during which the qubit is idle and accumulating decoherence.

In the velocity-zone architecture, the “zones” are not places but speeds. Two velocity classes differ by only about 0.05 m/s. Accelerating an atom into a new velocity class takes roughly 26 $\mu$s and displaces it by just 860 nm — less than one micron. That is an order of magnitude faster and two orders of magnitude shorter in distance.

The elevator pitch

Instead of moving atoms far away to talk to them privately, you just speed them up a little. A slightly faster atom sees a different laser frequency (Doppler shift), so a global beam can address it selectively. The atom barely moves, but its “frequency label” changes completely.

This matters for more than raw speed. Shorter transport distances mean tighter packing of qubits, higher connectivity, and less sensitivity to stray fields accumulated during long shuttles.

Generality beyond strontium

The experiments in the paper use strontium-88, but the underlying idea — velocity-selective resonance via the Doppler effect — is not specific to one atomic species.

Ytterbium. Another alkaline-earth-like atom with a narrow clock transition (${}^1S_0 \leftrightarrow {}^3P_0$). The same three-photon scheme could be adapted, with different wavelengths but the same logic.
Rubidium. The workhorse of many neutral-atom labs. Here one would use counter-propagating Raman beams rather than a clock transition. The effective wavevector $k_{\text{eff}}$ is the sum of the two beam wavevectors, giving a large Doppler sensitivity even at modest velocities.
Any platform with velocity-dependent resonance. The principle generalises to any system where you can engineer a transition whose frequency depends on the atom’s (or ion’s) velocity strongly enough to resolve distinct velocity classes within your available laser linewidth.

Remark. Notice that the key requirement is not a specific atomic structure but a narrow enough transition combined with a large enough effective wavevector. The three-photon scheme in strontium is one realisation; counter-propagating Raman beams in alkali atoms are another. The toolbox is broader than any single experiment.

Hardware simplification

One of the most practically significant points — easy to overlook amid the physics — is that the velocity-enabled architecture actually reduces hardware complexity.

In conventional selective addressing, you need focused beams targeting individual atoms or spatial zones: high-NA optics, acousto-optic deflectors or spatial light modulators, and careful calibration to avoid crosstalk. Every additional qubit demands more optical channels.

In the velocity-enabled scheme, all laser beams are global: they illuminate the entire array uniformly. Selectivity comes from frequency, not position. Different velocity classes respond to different detunings of the same global beam. You trade complex local optics for a set of RF frequency sources — and RF electronics is far cheaper and more scalable than free-space optics.

Fewer lasers, fewer alignment degrees of freedom, fewer things to break. This is the kind of engineering advantage that compounds as you scale from tens to thousands of qubits.

Open challenges

We should be honest about what is not yet solved.

Three-photon state preparation fidelity. The demonstrated fidelity for the three-photon ${}^1S_0 \leftrightarrow {}^3P_0$ transfer is around 97%. For fault-tolerant quantum computing, this needs to approach 99.9% or better. The dominant error sources — AC Stark shifts, laser phase noise, and residual motional excitation — are all improvable in principle, but doing so simultaneously is an engineering challenge.
Fly-by CZ gate infidelity at high velocities. The fly-by controlled-Z gate relies on atoms passing through each other’s Rydberg blockade radius. At high relative velocities, the finite interaction time introduces Doppler-induced phase errors. There is a fundamental trade-off: faster fly-bys mean shorter gate times but larger velocity-dependent infidelities.
Compilation algorithms. Existing quantum circuit compilers do not know about velocity zones. We need velocity-aware compilers that can schedule gate operations, velocity-class reassignments, and atom trajectories jointly. This is a non-trivial classical optimisation problem.
Coherence vs fidelity trade-off. The FS qubit (encoded in ${}^3P_0$ fine-structure states) has excellent coherence properties, but its state preparation relies on the same three-photon process whose fidelity is currently the bottleneck. At a given trap depth, improving one metric can come at the cost of the other. Breaking this trade-off likely requires deeper traps or alternative state-preparation pathways.

Future directions

Several extensions are already on the horizon:

Curved trajectories and SWAP operations. Atoms need not travel in straight lines. Curved paths enable ancilla recycling — a qubit performs a gate, loops around, gets reinitialised, and returns for the next round. This is essential for quantum error correction, which consumes ancilla qubits at high rates.
Fast spatial light modulators. Current SLMs update at kilohertz rates. Newer MEMS-based and acousto-optic devices reaching megahertz speeds would allow thousands of atoms to follow independent trajectories simultaneously.
Moving optical lattices. Rather than tweezers, one could use counter-propagating beams to create a lattice that moves atoms in bulk. This offers a path to massive parallelism — thousands of atoms accelerated in lockstep.
Velocity-aware quantum compilers. Given a target circuit and the physical constraints of velocity zones, find the optimal schedule of gate operations and velocity-class assignments — a rich problem at the intersection of quantum compilation and control theory.

Summary: zone-based vs velocity-enabled

Comparison of the two architectural paradigms for selective qubit control in neutral-atom processors.
	Zone-Based	Velocity-Enabled
Selective control	Focused beams or spatial zones	Global beams + velocity classes
Transfer time	~200 $\mu$s	~26 $\mu$s
Transfer distance	~100 $\mu$m	~860 nm
Hardware	Complex local optics	Simpler global optics
Status	Demonstrated at scale	Building blocks demonstrated

Closing thought

The velocity-enabled paradigm is not yet a complete quantum computer — it is a set of building blocks, each demonstrated individually, waiting to be assembled. But the building blocks are compelling. They offer faster control, simpler hardware, and a natural path to parallelism. The gap between “building blocks demonstrated” and “system demonstrated” is real, but it is an engineering gap, not a physics gap. The physical principles are sound; what remains is the hard, patient work of integration.

For researchers entering this field, that gap is an opportunity. The compiler problem is open, the optimal trajectories are unknown, and the best atomic species may not yet have been tried. Velocity-enabled quantum computing is a young idea with considerable room to grow — and, we think, a genuinely good one.