⚛️ quantum physics

Defect-Aware Parallel Atom Reloading Protocol for Neutral-Atom Quantum Computers

This paper proposes a defect-aware parallel atom reloading protocol for neutral-atom quantum computers that combines coherent reloading with an efficient planner to achieve a near-perfect 99.94% atom filling rate in under 0.1 ms, meeting real-time operational requirements.

Original authors: Koki Aoyama, Fumihiko Ino

Published 2026-10-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Koki Aoyama, Fumihiko Ino

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that would take today's machines thousands of years to crack, but they face a fundamental hurdle: they are incredibly fragile. In many designs, the basic units of information, called qubits, are individual atoms held in place by beams of light. These atoms are so sensitive that they can vanish from their spots due to tiny disturbances, leaving empty holes in the grid where calculations are supposed to happen. If too many atoms disappear, the computer loses its data and the calculation fails. For these machines to run long enough to be useful, they must be able to continuously replace lost atoms without stopping the work or corrupting the information held by the atoms that remain. This is the challenge of keeping a quantum computer "fed" while it is running.

Researchers at the University of Osaka have developed a new method to solve this problem, one that treats the missing atoms not as a random nuisance, but as a map to be read and acted upon. In their work, they propose a system that detects exactly where atoms have been lost and immediately calculates the most efficient way to refill those specific spots. Unlike previous approaches that followed a rigid, pre-set schedule to replace atoms regardless of whether they were actually missing, this new protocol adapts in real time. It uses a smart planning algorithm to decide which rows and columns of the atomic grid to target, ensuring that new atoms are delivered exactly where they are needed most. The result is a system that keeps the grid nearly full, maintaining the computer's ability to work even as atoms occasionally disappear.

The core of this innovation lies in how the replacement is performed. In a neutral-atom quantum computer, the atoms are arranged in a two-dimensional grid, much like a spreadsheet of tiny dots. When an atom is lost, it leaves a defect, or an empty cell. To fix this, the computer must move fresh atoms from a storage area into the empty spots. However, the hardware used to move these atoms, which relies on sound waves to steer light beams, can only address entire rows and columns at once. This creates a difficult puzzle: if the computer simply picks a row to refill, it might accidentally overwrite an atom that is still there and holding valuable data. Previous methods avoided this risk by following a fixed pattern, but that meant wasting time and resources on spots that didn't need filling.

The researchers solved this by inventing a way to swap the data out of an atom before it is physically replaced, and then put the data back into a fresh atom. This process, which they call a coherent operation, allows the computer to discard an old atom and insert a new one without ever losing the information it was holding. Because the data is preserved during the swap, the system is free to choose which rows and columns to target based entirely on where the defects are located. This flexibility is the key to the new method's success. It allows the computer to look at the current state of the grid, identify the empty spots, and select the specific combination of rows and columns that will cover the most defects in a single move.

To make these decisions quickly enough to keep up with the computer's speed, the team developed a planning tool that acts like a rapid-fire strategist. This tool does not try to find the single perfect solution, which would take too long to calculate, but instead finds a very good solution almost instantly. It starts by greedily picking the rows and columns that cover the most empty spots, and then makes small adjustments to see if it can do even better. In their tests, this approach was able to plan a refill operation in less than a millisecond, a timeframe that fits comfortably within the strict time limits of the hardware. This speed is crucial because if the planning takes too long, the computer might lose more atoms before the new ones can be delivered.

When the researchers simulated this system on a grid of 36 rows by 90 columns, the results were striking. Under conditions where atoms were lost at a low rate, the new method kept the grid filled to 99.94 percent, a significant improvement over the 98.61 percent achieved by the older, fixed-pattern method. Even in a harsher environment where atoms were lost five times more frequently, the new system maintained a 97.18 percent fill rate, compared to just 93.22 percent for the old way. These numbers matter because a higher fill rate means fewer errors in the calculation. The study also showed that the new planner performed nearly as well as a much slower, mathematically perfect solver, but did so thousands of times faster. This suggests that the method is not only effective but also practical for real-world machines.

The work demonstrates that by combining a clever physical trick to preserve data with a smart, adaptive planning system, it is possible to keep a quantum computer running smoothly despite the constant threat of atom loss. The researchers note that while their results are based on simulations, the underlying principles rely on hardware capabilities that already exist. They acknowledge that real-world conditions might introduce new complications, such as the noise generated by the extra steps needed to swap data, but their findings suggest that the benefit of keeping the grid full outweighs these costs. By turning a chaotic problem of random loss into a solvable optimization task, this research offers a clear path toward building quantum computers that can run for the long durations required to tackle the world's most difficult problems.

Technical Summary: Defect-Aware Parallel Atom Reloading Protocol for Neutral-Atom Quantum Computers

1. Problem Statement

Neutral-atom quantum computers offer scalability and versatile qubit topologies but face a critical challenge in continuous operation: atom loss. During long-running computations (e.g., utility-scale tasks requiring days of operation), atoms are lost due to idle noise, creating "defects" (empty sites) in the storage atom array. If the density of defects becomes too high, quantum error correction fails, and data is corrupted.

Existing reloading strategies suffer from two main limitations:

Predetermined Patterns: Methods like Chiu et al. [3] use fixed reloading patterns (e.g., cycling through rows/columns) that ignore current defect locations. This leads to inefficiency, as atoms are discarded and reloaded even in occupied sites, wasting time and resources.
Sequential/Row-by-Row Approaches: Defect-aware methods that reload based on specific defect locations [13, 14] typically operate atom-by-atom or row-by-row. Their execution time scales linearly with the array size, making them unsuitable for large-scale systems where real-time planning is required.

The core challenge is to design a parallel, defect-aware reloading protocol that can identify and replenish empty sites efficiently within a strict real-time planning budget (approx. 40 ms) while preserving the quantum information stored in the remaining atoms.

2. Methodology

The proposed solution integrates two primary components: a Coherent Parallel Atom-Reloading Operation and a Defect-Aware Planner.

2.1 Coherent Parallel Atom-Reloading Operation

To enable defect-aware selection without risking data loss, the authors propose a coherent operation that extends the SWAP-LDU (Leakage Detection Unit) concept [15] to parallel reloading.

Mechanism: The operation selects a set of rows $I$ and columns $J$ in the storage array. It uses optical tweezers (generated by crossed Acousto-Optic Deflectors, AODs) to transport atoms between the storage array and an entanglement array.
State Preservation: Unlike previous methods that discard all atoms in the selected $I \times J$ region, this protocol uses a sequence of parallel logical state-transfer gates (CZ-H-CZ) to transfer the quantum state of existing atoms in the storage array to the entanglement array.
Process:
1. Prepare: Fresh atoms in the $|+\rangle$ state are loaded into the entanglement array.
2. Transfer: Atoms in the selected storage sites ( $I \times J$ ) are moved to the entanglement array.
3. State-Transfer: The quantum data from the storage atoms is coherently transferred to the fresh atoms in the entanglement array using a parallel CZ-H-CZ sequence.
4. Reload: The fresh atoms (now holding the original data) are moved back to the storage array.
5. Discard: Remaining atoms in the entanglement array are discarded.
Result: Defects in the selected $I \times J$ region are filled with new atoms in the default state, while existing atoms are physically replaced by new atoms carrying the same quantum information. This coherence allows the selection of $I$ and $J$ to be based purely on current defect configurations without pre-planning data migration.

2.2 Defect-Aware Planner

The planner determines the optimal sets of rows $I$ and columns $J$ to maximize the number of replenished defects, subject to hardware constraints ( $|I| \le H_p$ , $|J| \le W_p$ ).

Optimization Problem: The goal is to maximize the expected number of atoms in the array after reloading. This is formulated as a dense bipartite subgraph selection problem (related to the maximum edge biclique problem), which is NP-hard.
Heuristic Solver: To meet real-time constraints, the authors propose a two-step heuristic:
1. Greedy Construction: An algorithm iteratively adds rows and columns to $I$ and $J$ based on the number of covered defects, balancing the ratio of selected rows to columns to match the entanglement array dimensions. It uses incremental updates to achieve a time complexity of $O((H_s + W_s)^2)$ .
2. Hill Climbing Refinement: A local search algorithm iteratively improves the greedy solution by swapping, adding, or removing rows/columns to reach a local optimum.
Performance: The planner is designed to run within the 40 ms budget, significantly faster than exact solvers like Mixed Integer Programming (MIP).

3. Key Contributions

Protocol Integration: The proposal of a unified protocol combining a coherent parallel reloading operation with a real-time defect-aware planner.
Coherent Operation: A novel atom-reloading operation that preserves quantum information during parallel replenishment, enabling adaptive selection of reloading targets based on real-time defect data.
Efficient Solver: A defect-aware planner utilizing a greedy algorithm with hill-climbing refinement that finds near-optimal solutions within strict real-time constraints.
Empirical Validation: Numerical experiments demonstrating significant improvements in atom filling rates compared to baseline methods, with planning times well within hardware limits.

4. Results

The authors evaluated the method on storage arrays ranging from $12 \times 30$ to $180 \times 450$ sites under low-noise ( $p=0.004$ ) and high-noise ( $p=0.020$ ) conditions.

Filling Rate Improvement:
- Low Noise: For a $36 \times 90$ array, the average filling rate improved from 98.61% (Baseline) to 99.94% (Proposed).
- High Noise: For the same array, the rate improved from 93.22% to 97.18%.
- The proposed method achieved filling rates within 0.0006 percentage points (low noise) and 0.109 percentage points (high noise) of the optimal solution found by the MIP solver (GLPK) at $n=3$ . Over all completed MIP settings, the maximum differences were 0.0163 percentage points (low noise) and 0.109 percentage points (high noise).
Planning Efficiency:
- The proposed planner completed each reload planning step in under 0.1 ms (average 0.014 ms for $36 \times 90$ ), well below the 40 ms budget.
- In contrast, the MIP solver showed erratic runtimes and failed to complete planning for larger arrays within the time limit. Specifically, under high-noise conditions, the SCIP solver exceeded the 40 ms budget for a $12 \times 30$ array, while the GLPK solver completed the task but with significantly higher latency (approx. 13 ms).
Convergence: The greedy solution alone was nearly optimal in most instances. The hill-climbing refinement provided a marginal but consistent gain, particularly in high-noise, large-array scenarios, with an average of fewer than 10 iterations to convergence.

5. Significance and Claims

The paper claims that the proposed protocol offers a viable path toward sustaining high qubit availability in continuously operated neutral-atom quantum computers. By leveraging defect awareness and parallelism, the method overcomes the inefficiencies of fixed-pattern reloading and the scalability limits of sequential reloading.

The authors emphasize that their approach:

Enables Adaptive Reloading: The coherence of the operation allows the system to react to the specific defect configuration of the moment, rather than relying on pre-determined schedules.
Meets Real-Time Constraints: The heuristic planner achieves near-optimal performance with execution times that scale efficiently, making it suitable for integration into the control loop of large-scale quantum systems.
Validates the Trade-off: While the coherent operation introduces additional gate noise (estimated ~1% error rate), the authors argue that the substantial reduction in defect density (and thus the reduction in errors caused by missing atoms) likely outweighs the operational noise, though this specific impact on logical error rates depends on the specific error correction code used.

The work concludes that defect-aware parallel reloading is essential for scaling neutral-atom systems, and the proposed method successfully balances high filling rates with the real-time performance required for practical quantum computing.