Neutral Atom Quantum Computing, and Why It Is Not Gate-Based

Neutral atom quantum computing has the largest publicly accessible qubit count of any modality. QuEra's Aquila offers 256 qubits through Amazon Braket, against 108 for the largest superconducting device on the same service and 36 for the largest trapped-ion one. On a specification sheet that looks decisive.

It is also misleading, because Aquila does not accept quantum gates. Understanding why is the most useful thing to know about the modality, and it is rarely the first thing said about it.

The physics

A neutral atom quantum computer holds individual atoms, usually rubidium, in optical tweezers: tightly focused laser beams that trap a single atom at a fixed point in space. An array of such tweezers holds an array of atoms, and because the tweezers can be positioned arbitrarily, the qubit array can be arranged in almost any geometry. Two dimensional lattices, rings, arbitrary graphs, all are available by moving light rather than by fabricating a new chip.

The qubit is encoded in two electronic states of the atom. Interaction between qubits uses the Rydberg blockade: exciting an atom to a Rydberg state, one with a very high principal quantum number, inflates it enormously and shifts the energy levels of its neighbours. Within a blockade radius, a second atom cannot be excited simultaneously. That conditional behaviour is the two-qubit interaction.

Two consequences follow, and they are the modality's real advantages.

Every qubit is identical. Atoms of a given isotope are indistinguishable by physical law. Superconducting qubits are lithographically fabricated and vary from one another, which is why calibration is a permanent operational burden on those platforms. Neutral atom arrays have no fabrication variance to calibrate away.

The geometry is programmable. Connectivity is set by where the tweezers put the atoms, not by wiring laid down at manufacture. A problem whose natural structure is a triangular lattice can be given a triangular lattice.

The part the qubit count does not tell you

Aquila is an analog Hamiltonian simulator, not a gate-based quantum computer. Its interface reflects that directly. Querying the device registry returns a paradigm of `quera_ahs_paradigm_properties` and a single accepted program type, `braket.ir.ahs.program`. It does not accept OpenQASM. There is no gate set to compile to.

Device        QuEra Aquila
Qubits        256
Paradigm      analog Hamiltonian simulation (AHS)
Accepts       braket.ir.ahs.program
Does NOT      OpenQASM, gate-based circuits
Shots         1 to 1,000 per task
Price         $0.01 per shot

Programming it means something structurally different from writing a circuit. Instead of a sequence of gates, you supply the positions of the atoms and a set of time-dependent control functions: the Rabi frequency, the detuning, and the phase, each specified as a waveform over the duration of the run. The machine then evolves the whole system under the Hamiltonian those parameters define, and you measure the final configuration.

This is quantum simulation in the original sense that Feynman proposed: building a controllable quantum system whose dynamics mirror the system you want to study. It is not a universal computer executing an algorithm. Grover's algorithm has no meaning on Aquila, because Grover's algorithm is a sequence of gates and there are no gates.

What that makes it good for, and bad for

The natural applications are problems that map onto the physics directly.

• Condensed-matter physics. Quantum spin models, phase transitions and quench dynamics in Ising-type systems are what the Rydberg Hamiltonian naturally expresses. This is the strongest use, and it is genuine research rather than a demonstration.
• Combinatorial optimisation with a geometric structure. Maximum independent set maps onto the Rydberg blockade almost exactly: within a blockade radius, two atoms cannot both be excited, which is the independent set constraint expressed as physics rather than as a penalty term. Placing atoms according to a graph makes the ground state the answer.

The exclusions are equally sharp. Shor's algorithm, Grover search, quantum phase estimation, variational circuits with parameterised gates and error-corrected logical operations are all gate-based constructions, and none of them apply. A team whose work is written in Qiskit cannot submit it to Aquila by changing a device string.

How it compares in practice

Set against the other modalities available on the same cloud:

                        Superconducting     Trapped ion        Neutral atom
Qubits (public)         up to 108           up to 36           256
Gate-based              yes                 yes                not on Aquila
Connectivity            fixed by wiring     all-to-all         programmable
                                                               geometry
Gate speed              fast                slow               n/a (analog)
Qubit uniformity        fabrication         identical          identical
                        variation
Price per shot          $0.000425 to        $0.0235 to         $0.01
                        $0.0016             $0.08

The pricing is worth noting because it is quoted per shot and Aquila caps a task at 1,000 shots, so a single run costs at most ten dollars. That is inexpensive for hardware access. The constraint is not budget, it is applicability.

Where the modality is going

The gate-based limitation is a property of this generation rather than of neutral atoms. Gate-based neutral atom processors exist in the laboratory, and the modality is a serious contender for fault-tolerant quantum computing precisely because atoms can be physically moved during a computation, which allows logical qubits to be shuffled into position rather than requiring long-range couplers. QuEra has stated a fault-tolerant target of 2028, and specialised compilers for fault-tolerant neutral atom hardware are already being built commercially.

For now, the honest summary is that neutral atoms lead on qubit count and on physical elegance, and that the leading accessible machine solves a different class of problem from the gate-based devices it is listed beside. A qubit count comparison across modalities is therefore not a like-for-like comparison, and treating it as one leads to the wrong hardware.

Before any hardware run

This applies to every modality and it applies here with particular force, because the programming model is unfamiliar. Whatever the device, the question worth asking first is whether a classical simulation answers the same question for a fraction of a cent. Ising dynamics of the kind Aquila runs are frequently within reach of tensor-network methods on a laptop, as measured in How many qubits can a tensor network simulate, and a simulated run tells you what the hardware ought to produce, which is the only way to know whether the hardware run succeeded. The general argument is in CPU, GPU or QPU, and the comparison of the gate-based modalities is in Transmon or trapped ion.