Exploiting Long-Distance Interactions and Tolerating Atom Loss in Neutral Atom Quantum Architectures

TL;DR

This paper evaluates neutral atom quantum architectures, highlighting their long-range interactions and atom loss resilience, and proposes compiler and hardware methods to optimize performance and scalability.

Contribution

It introduces new compiler and hardware strategies to exploit long-distance interactions and tolerate atom loss in neutral atom quantum systems.

Findings

Long-range interactions reduce communication overhead and gate count.

Proposed methods significantly improve resilience to atom loss.

Compiler optimizations maximize advantages of neutral atom architectures.

Abstract

Quantum technologies currently struggle to scale beyond moderate scale prototypes and are unable to execute even reasonably sized programs due to prohibitive gate error rates or coherence times. Many software approaches rely on heavy compiler optimization to squeeze extra value from noisy machines but are fundamentally limited by hardware. Alone, these software approaches help to maximize the use of available hardware but cannot overcome the inherent limitations posed by the underlying technology. An alternative approach is to explore the use of new, though potentially less developed, technology as a path towards scalability. In this work we evaluate the advantages and disadvantages of a Neutral Atom (NA) architecture. NA systems offer several promising advantages such as long range interactions and native multiqubit gates which reduce communication overhead, overall gate count, and depth for compiled programs. Long range interactions, however, impede parallelism with restriction zones surrounding interacting qubit pairs. We extend current compiler methods to maximize the benefit of these advantages and minimize the cost. Furthermore, atoms in an NA device have the possibility to randomly be lost over the course of program execution which is extremely detrimental to total program execution time as atom arrays are slow to load. When the compiled program is no longer compatible with the underlying topology, we need a fast and efficient coping mechanism. We propose hardware and compiler methods to increase system resilience to atom loss dramatically reducing total computation time by circumventing complete reloads or full recompilation every cycle.