ATLAS: Efficient Atom Rearrangement for Defect-Free Neutral-Atom Quantum Arrays Under Transport Loss

TL;DR

ATLAS addresses the challenge of assembling defect-free neutral-atom arrays under probabilistic loading and transport loss by separating planning from execution. It uses a lossless virtual planning phase to generate parallel move batches and then replay execution under stochastic loss, guided by a loss-aware target sizing that determines the final subarray size. The seven planning subroutines implement row/column centering, spread-and-squeeze cycles, and corner moves to guarantee a perfect LxL target, with a subsequent defect repair step if needed; a physics-informed execution phase applies realistic transfer times and loss. Monte Carlo simulations show fill rates consistently above 99% within six iterations and robust retention across sizes and loss rates, with sublinear move scaling and linear initial-size growth, and a parallel ATLAS variant achieving ~N^0.47 move-scaling, making large defect-free neutral-atom arrays more practical for scalable quantum computing.

Abstract

Neutral-atom quantum computers encode qubits in individually trapped atoms arranged in optical lattices. Achieving defect-free atom configurations is essential for high-fidelity quantum gates and scalable error correction, yet stochastic loading and atom loss during rearrangement hinder reliable large-scale assembly. This work presents ATLAS, an open-source atom transport algorithm that efficiently converts a randomly loaded $W \times W$ lattice into a defect-free $L \times L$ subarray while accounting for realistic physical constraints, including finite acceleration, transfer time, and per-move loss probability. In the planning phase, optimal batches of parallel moves are computed on a lossless virtual array; during execution, these moves are replayed under probabilistic atom loss to maximize the expected number of retained atoms. Monte Carlo simulations across lattice sizes $W=10$--$100$, loading probabilities $p_{\mathrm{occ}}=0.5$--$0.9$, and loss rates $p_{\mathrm{loss}}=0$--$0.05$ demonstrate fill rates above $99\%$ within six iterations and over $90\%$ atom retention at low loss. The algorithm achieves sublinear move scaling ($\propto M^{0.55}$) and linear growth of required initial size with target dimension, outperforming prior methods in robustness and scalability -- offering a practical path toward larger neutral-atom quantum arrays.

Figures (7)

• Figure 1: Rearrangement of $10 \times 10$ neutral atom array. Blue disks indicate occupied traps (atoms) and grey rings mark all SLM trap sites. (a) The initial, probabilistically loaded configuration ($p_{occ} \approx 0.7$), with randomly missing atoms. (b) The defect-free square lattice achieved after running the assembly algorithm.
• Figure 2: ATLAS without loss ($p_{loss}=0$). (a) The atoms are initially loaded into each site with a 0.6 probability. The red arrows represent parallel moves made in one move batch. (b) Row-wise centering is performed, where each row fills its defects using atoms from the same row and side. (c) Column-wise centering starts from the left side of the target zone and progresses towards the right edge. Four move batches remain after the one shown. (d) The "spread" phase moves atoms above and below the target zone. Atoms on the right side are shifted to the right edge of the target zone, and atoms on the left side are moved toward the left edge. (e) The "squeeze" phase inserts atoms into the target zone after spreading. (f) Atoms in the top-right corner block are moved in parallel. The bottom-left corner is moved the same way immediately after. (g) A final column-wise centering "squeezes" the remaining atoms into the target zone. If any defects remain, additional steps are executed.
• Figure 3: Monte Carlo simulation of fill rate improvement over iterations for: (a) a $100 \times 100$ lattice with an occupation probability of 0.7; (b) a $50 \times 50$ lattice with an occupation probability of 0.7. With $p_{loss} = 0$ (blue), the algorithm achieves a perfect fill rate immediately in the first iteration.
• Figure 4: Monte Carlo simulations of retention rate as a function of initial lattice size, shown for three different atom-loss probabilities; blue: $p_{loss}=0$, orange: $p_{loss}=0.01$, and green: $p_{loss}=0.05$. The retention rate decreases with increasing loss probability. The more significant drop for $p_{loss}=0.05$ as the lattice size increases is an artifact of capped iterations. Without the cap, retention would remain near 80 %.
• Figure 5: Log–Log Scaling of Rearrangement Time vs. Lattice Width: Monte Carlo–measured timings plotted on a log-log scale as a function of lattice side length W (for $p_{loss}=0$). The yellow line represents the computational time scaling with the initial lattice width. The magenta line represents the physical time it takes to complete the moves. The green line represents the total time (computational + physical). The yellow line shows nearly cubic scaling of computational time with lattice width. Above $W\approx50$, the computational time starts to dominate the total time.