Make your paper interactiveCreate

Text from the interactive explanation

Fast, parallel, three-dimensional rearrangement of atom arrays using superpositions of elementary holograms

D. J. Hoare, P. Dunniece, J. Rodewald, K. K. Voges, M. R. Tarbutt

Original paper

How one sheet of laser light can tidy a hundred atoms in 18 milliseconds, and lift some of them over the others.

Every hologram is computed in your browser from the current trap list (a 128 × 128-pixel simplified model). Tap an atom to see its own stripe pattern inside the hologram.

Some quantum computers store information in single atoms , each pinned in place by its own tightly focused laser beam. Arrays of thousands of such atoms already exist. But filling the beams is a coin toss: each one catches an atom only about half the time. Before any computing can begin, the atoms must be packed into a gap-free grid, and later reconfigured, perhaps even in 3D. So: how do you move a hundred atoms at once without dropping any?

Half the seats are empty

An optical tweezer is a laser beam focused so tightly that a single rubidium atom, chilled to about 30 millionths of a degree above absolute zero, gets stuck in its brightest spot.

The experiment makes a 16 × 16 grid of these traps, 5 micrometres apart (a human hair is about 15 traps wide), and drops a cloud of cold atoms onto them. Often two atoms land in the same trap; when that happens, light makes them collide and both are kicked out. So every trap ends up holding either one atom or none, and in practice only about 55% of them catch one.

The loading lottery

What are the odds that the central 10 × 10 comes out completely full, just by luck?

In the experiment, the 256 sites hold 141 ± 8 atoms on average (measured filling 55.26%), always enough to fill a 10 × 10 target.

One at a time, or all at once?

The traditional tool is a single steerable laser beam, a "moving tweezer" driven by acousto-optic deflectors. It picks up one atom, carries it to a gap, sets it down, and goes back for the next. The more atoms, the longer it takes: the time grows in proportion to the number of atoms.

A spatial light modulator (SLM) works differently. It is a screen of about a million liquid-crystal pixels (1024 × 1024 here) that delays different parts of the laser beam by different amounts. The pattern on that screen, a hologram , shapes one beam into all the traps at once. Show a slightly different hologram, and every trap shifts a little, all together. Step through a sequence of holograms and all the atoms travel in parallel.

The race

Each step is drawn with the same duration so you can compare counts, not real speeds. Moves ≈ the number of empty target sites (45% of them); frames K = ⌈longest trip ÷ 0.5 µm⌉, which is about 21 for a 10 × 10 target and doubles when the width doubles (paper, Sec. V E). Sequential time grows with the number of atoms, N; the number of SLM frames grows only with the array's width, √N.

Moving everything at once means computing a brand-new hologram for every small step, faster than the screen can show them. So what is a hologram, and how do you compute one quickly?

Every trap is a stripe

A lens turns the direction a beam travels into a position where it comes to a focus. Tilt the beam's wavefront and the bright spot slides sideways.

The light modulator can tilt a wavefront by delaying one side of the beam more than the other, a steady ramp of delay. But it can only delay light by up to one wavelength (one full cycle of the wave, 2π), so the ramp wraps around and starts again, like the hands of a clock. On the screen that wrapped ramp looks like a set of stripes . The stripes point towards the trap, and the further the trap is from the centre, the more tightly packed they become.

Try it. Drag the trap in the focal-plane window, or focus that window and use the arrow keys, and watch its stripes turn and tighten.

Hologram lab

Hologram on the modulator (phase, 0 → 2π)

Light in the focal plane, simulated from that hologram

–

Or start from a pattern:

Methods built on the fast Fourier transform (FFT) can only place traps on a grid of points 0.847 µm apart in this setup, unless they pad the calculation and pay for it in computing time. In the sum-of-stripes method, a trap's position is just a number in the formula, so it can sit anywhere and move in steps much smaller than the trap itself.

Brightness of each trap (relative to the average)live model

The modulator can only delay light, not dim it, so stacking stripes leaves some traps brighter than others. Each tap measures every trap's light, turns down the bright ones and up the dim ones a little, and adopts each trap's actual phase. Repeat and the bars level out.

Many traps: add the waves, keep the angle

For several traps, the recipe is almost embarrassingly simple: write down each trap's stripe pattern as a wave, add all the waves together pixel by pixel, and display only the angle (the phase) of the sum. Each trap gets two extra knobs: a weight that sets how strongly it contributes, and a phase offset that sets the timing of its light. This is the superposition of elementary holograms , or SEH.

No trial and error is needed to build a hologram, just one big sum, which a graphics chip can do for a million pixels in a fraction of a millisecond. And because every trap's position, weight and phase are explicit numbers in that sum, they can be changed smoothly from one hologram to the next. That turns out to be the key to moving atoms safely.

Trap n at position r n needs a phase ramp with wavevector k n = (2π𝓜 / λf) r n. The target field on the modulator and the displayed phase are (Eqs. 4 and 5):

Equalising (Eq. 10): evaluate the actual light at every trap, In and its phase φn, then update

This page computes the sum with a 128 × 128 hologram and simulates the focal plane with a fast Fourier transform of the phase-only hologram, the same physics as a lens, at lower resolution than the experiment's 1024 × 1024 modulator.

The blink between frames

A light modulator does not swap pictures instantly. For a brief moment while its liquid crystal settles, the old hologram and the new one are both on the screen, and their light interferes.

Each trap is made of light with a certain timing, its phase. If a trap's light arrives with the same timing in both holograms, the two contributions add up and nothing much happens. If the timing is different, they partly cancel, and for an instant the trap gets weaker. An atom in a weakened trap can slip out.

Predict first

A trap stays exactly where it is, but between two frames its light's phase flips by half a cycle (180°). Halfway through the switch, the trap gets…

One trap through a switch

Atoms surviving rearrangement vs step sizemeasured

–

Approximate values read from Fig. 2e of the paper (87Rb, trap waist 1.0 µm). Survival stays near 99% up to steps of about 1 µm, roughly the size of the trap, then falls.

The readout is the paper's Eq. 13, Imin/I0 = exp(−δ²/2w0²) · cos²(Δφ/2), with waist w0 = 1 µm: a step as big as the waist alone leaves 60.7% of the depth, and a 180° phase flip extinguishes the trap whatever the step.

Why the usual hologram recipes blink

The standard way to compute hologram arrays, iterative algorithms such as Gerchberg–Saxton, makes every trap uniform but leaves each trap's phase free: it wanders randomly from one hologram to the next. With random phase jumps, half of the traps dip below 50% depth during every switch, and one in five falls below 10%. Over the twenty-odd frames of a rearrangement, losing atoms becomes almost certain.

The fix in this paper follows directly from the sum-of-stripes recipe. Because each trap's phase is an explicit knob, it can be ramped : the total phase change between the first and last hologram is split evenly over all K frames, taking the shortest way round the circle. Positions and weights are slid linearly in the same way. Each step then changes the phase by only Δθ/K, and the worst possible dip is cos²(π/2K), just 2.4% for K = 10.

Twenty-four traps, many switches

Free phases: each trap's phase jumps by a random amount at every switch (the paper's Eq. 12 predicts ½ below 50% and ⅕ below 10%). Ramped: each trap's total phase change is random, but it is spread over K frames. illustration An atom is drawn escaping when its trap falls below 20% depth; real loss depends on temperature and how long the dip lasts.

simulated In the paper's numerical study (a half-filled 20 × 20 array rearranged into 14 × 14 over K = 85 frames), each trap's phase stayed within σε = 0.0432 rad of its planned ramp, against 0.2 rad reported for a neural-network method. Phase steps averaged 0.021 rad and never exceeded 0.079 rad, so they cost almost nothing. What remains is the overlap between successive trap positions, which is why the step size matters.

During a switch the focal field is a mix of the two holograms (Eq. 11), with a(t) + b(t) = 1:

The worst moment is a = b = ½. For a Gaussian trap of waist w0 moved by δ (Eq. 13):

With random Δφ (Eq. 12): P(Imin/I0 < x) = (2/π) · sin−1√x. The interpolation for frame p of K, with s = p/K (Eqs. 14–18):

The number of frames is K = ⌈dmax/δ⌉, set by the longest trip dmax and the chosen maximum step δ.

Spare time, well spent

Two clocks race during a rearrangement: how fast a graphics chip (GPU) can compute each hologram, and how fast the light modulator can show it.

On a single NVIDIA RTX 5090, each hologram for the 256-site array takes 0.284 ms to compute. The modulator needs 0.696 ms to refresh. Computing wins, so the speed of the whole rearrangement is set by the hardware, not by the maths. The team keeps the two apart with two threads: a generator fills a queue of up to five finished holograms while a writer copies each one off the GPU and onto the modulator, waiting at least 0.700 ms between writes so that no frame is skipped.

The hologram pipeline

Equalising iterations per hologram (computing time at N = 256, Fig. 6):

Hardware-limited: the modulator sets the pace

–

Measured per-frame costs (Table I): compute 0.284 ms (in parallel with the previous write), GPU sync 0.003, copy to host memory 0.068, write to the modulator 0.587, pacing hold 0.037, other overhead 0.013, giving one hologram every 0.708 ms. Because computing runs ahead, holograms wait longer and longer in the queue until it is full (in the paper's Fig. 5 example, up to 4.18 ms from computation to display) while the delivery rate stays the same. Time here runs about 1,000× slower than in the lab.

What to do with the spare time

Sliding positions, weights and phases in straight lines keeps the phases continuous, but it does nothing for brightness: halfway through a move, the interpolated weights are no longer balanced, and some traps get noticeably weaker than others. The spare time between holograms is enough for one round of equalising per frame , the same "measure every trap, nudge its weight" step you tried in the lab, without slowing the rearrangement at all.

Equalising on the move

Spread of trap depths at each frame (min to max ÷ mean)

Paper's simulation, 20 × 20 → 14 × 14, K = 85simulated

Non-uniformity is the spread of trap intensities, σI/⟨I⟩. In the paper's simulation, one iteration per frame cuts it by an order of magnitude, and the dimmest trap rises from 35% to 91% of the mean, while phase control barely changes (σε from 0.0434 to about 0.045 rad). This page's smaller model (128 × 128 pixels, 16 × 16 → 10 × 10, correction carried from frame to frame) shows the same trend with different numbers.

How big can the array get?

The sum-of-stripes hologram costs more as you add traps (its work grows with pixels × traps). An FFT-based hologram costs the same however many traps there are, but needs extra padding to place traps finer than its 0.847 µm grid. Slide the array size to see which method stays under the modulator's refresh time.

Compute time per hologram vs number of traps

Approximate values read from Fig. 6 of the paper (single RTX 5090 GPU, 1024 × 1024 holograms, means over five repeats). Without equalising, computing stays under the 0.696 ms refresh up to about 2,100 traps; with one iteration, up to about 435; two iterations exceed it at every size. FFT with padding P = 1 or 2 is faster beyond about 800 traps, but its smallest diagonal step, 1.2 µm at P = 1, is bigger than the trap itself; at P = 4 (0.3 µm steps) it only wins beyond about 5,000 traps.

Up and over

So far every trap lived in one flat plane. Give one trap's ingredient a gentle curve, and its focus slides along the beam, out of the plane.

The extra ingredient is a lens: a phase that grows with the square of the distance from the screen's centre. Add it to a trap's stripes and they bend into rings, like the zones of a flat Fresnel lens. The more curve, the further the focus moves up or down the beam. The camera that images the atoms stays focused on the original plane, so a lifted atom looks blurred and dim, and by 10 µm it disappears from the picture completely, although it is still safely trapped.

One trap, moved along the beam

Hologram

Side view of the beamillustration

Camera viewillustration

–

The hologram is computed with the paper's lens term (Eq. 21). The side view uses an ideal Gaussian beam with a 1.0 µm waist and the 3.69 µm Rayleigh range quoted in the paper. The camera view illustrates what the paper's Fig. 3a–c shows: dim and blurred at 5 µm, gone from the image at 10 µm.

Leapfrog

Three-dimensional moves are most useful if one layer of atoms can travel without disturbing another. To test this, the team built an 80-site array arranged as five pairs of columns. In every pair, the left (red) column is lifted by a distance d, carried sideways behind its stationary (blue) partner 5 µm away, and set back down on the far side. Lifting steps were 1 µm, sideways steps 0.5 µm, with one equalising iteration per step.

The leapfrog sequence

–

Camera, focused on the original plane

–

Leapfrog survival vs lift height dmeasured

Approximate values read from Fig. 3h of the paper. Blue circles: stationary atoms; red squares: moving atoms. Without equalising, peak survival was 10–20% lower.

Round-trip survival vs axial step sizemeasured

Approximate values read from Fig. 3d: 10 steps of size δz out of the plane, a 10 ms hold, 10 steps back, no equalising. 98.7% survive at δz = 2 µm; losses begin near 3 µm, close to the beam's Rayleigh range of 3.69 µm.

A trap at height zn above the focal plane gets an extra quadratic phase (Eq. 21):

The quadratic term still splits into a product of an x-part and a y-part, so evaluating it costs no more than the flat case; the same matrix products handle 3D.

What they found

Starting from a randomly loaded 16 × 16 array of rubidium atoms, the team assembled a gap-free 10 × 10 array, over and over, using a stream of holograms computed on the fly.

of atoms survive the rearrangement itself (±0.12%), from 1,000 repetitions with 0.5 µm maximum steps.

average rearrangement time, from receiving the first image to uploading the last of on average 20.78 holograms.

filling of the target sites before and after (55.26% → 96.33%); the array was completely defect-free in half of the runs.

of heating (26.6 → 35.1 µK), tiny next to the 480 µK depth of the traps: the atoms stay cold and deeply held.

to compute each hologram on one GPU, against 0.696 ms for the modulator to refresh, so the hardware sets the pace.

survive a round trip 20 µm out of the plane in 2 µm steps; in the leapfrog, 99.4% of stationary and 95.1% of moving atoms survive.

trap non-uniformity during transport with one equalising iteration per frame, down from 19.85% without (0.48% with two).

spread of each trap's phase around its planned ramp, so phase jumps no longer cause dips; step overlap does.

What about thousands of atoms?

The number of holograms needed is set by the longest trip divided by the step size. Make the array twice as wide and the longest trip, and so the number of frames, roughly doubles. As long as each hologram is computed within the refresh time, the rearrangement time therefore grows with the array's width, the square root of the number of atoms, rather than with the number of atoms itself.

Scaling up

–

Estimate = 3.74 ms fixed cost + K × (time per hologram), with K ≈ 21 for a 10 × 10 target growing in proportion to the width, and the time per hologram the larger of the 0.697 ms refresh-limited cost and the measured compute time without equalising (Fig. 6, N = target size). Beyond about 2,100 traps the computation becomes the bottleneck. The dashed curve is only a reference for a cost that grows in proportion to the number of atoms, matched at 10 × 10; it is not a measurement.

Back to the big question

How do you move a hundred atoms at once without dropping any? Compute every hologram as a plain sum of stripes, slide each trap's position, brightness and phase smoothly between frames, and use the spare time to keep every trap equally deep. The result is parallel, hardware-limited rearrangement that can also lift atoms over one another. The authors point to where this could lead:

Source

D. J. Hoare, P. Dunniece, J. Rodewald, K. K. Voges and M. R. Tarbutt, “Fast, parallel, three-dimensional rearrangement of atom arrays using superpositions of elementary holograms”, arXiv preprint arXiv:2610.21609 [physics.atom-ph] (2026). Centre for Cold Matter, Imperial College London. arxiv.org/abs/2610.21609

Figures in this experience are original visualisations; plotted data points are approximate values read from the paper's figures. Tags mark what is measured in the experiment, simulated in the paper's numerical study, computed by this page's live model, or an illustration. The live hologram and light simulations on this page are simplified models: for example a 128 × 128-pixel hologram (96 × 96 on small screens) instead of the experiment's 1024 × 1024, an optimisation started from smooth lens-like phases rather than random ones, and an ideal lens with uniform illumination.

Topics in this iPaper

Physics
Starting from an array of 256 sites loaded stochastically with 87 Rb atoms, we assemble a 100-atom array in under 20 ms

Abstract, page 1

Computer science
Holograms are computed on a single NVIDIA RTX 5090

Section V, page 9

optical tweezers
Assembling defect-free arrays of neutral atoms requires real-time rearrangement of stochastically loaded optical tweezers.

Abstract, page 1

spatial light modulator
high-speed spatial light modulators (SLMs) can move all atoms in parallel

Abstract, page 1

computer generated holography
In this approach, a hologram is calculated by summing the complex field contributions of each tweezer and taking the argument of the result.

Section II A, page 2

neutral atom quantum computing
establishes neutral atom tweezer arrays as a promising architecture for scalable, fault-tolerant quantum computation

Section I, page 1

gpu computing
Using a single GPU, we compute each intermediate hologram in 0.284 ms, considerably faster than the SLM refresh time of 0.696 ms

Abstract, page 1

ultracold atoms
The temperatures before and after rearrangement are 26.6(15) µK and 35.1(22) µK

Section III A, page 6

Fast, parallel, three-dimensional rearrangement of atom arrays using superpositions of elementary holograms — Interactive explanation | iPaper.ai