Scalable Memory Recycling for Large Quantum Programs

TL;DR

The paper addresses memory management in large quantum programs by focusing on qubit reuse after uncomputation, a necessity due to quantum reversibility constraints. It introduces a high-level compilation flow that models quantum code as a control-flow graph and applies a topological-sorting analysis to maximize qubit reuse, followed by a reuse-analysis pass with multiple heuristics. The work analyzes the theoretical complexity of sorting and reuse steps, proposes scalable strategies including partitioning and function-block composition, and explores handling auxiliary qubits and potential extensions for multi-device architectures. The approach, implemented within Classiq's platform, demonstrates scalable compilation for complex circuits by preserving high-level information and enabling modular, reuse-driven optimization. These contributions advance quantum compiler design by integrating scalability into memory management and offering practical heuristics tailored to qubit reuse trade-offs.

Abstract

As quantum computing technology advances, the complexity of quantum algorithms increases, necessitating a shift from low-level circuit descriptions to high-level programming paradigms. This paper addresses the challenges of developing a compilation algorithm that optimizes memory management and scales well for bigger, more complex circuits. Our approach models the high-level quantum code as a control flow graph and presents a workflow that searches for a topological sort that maximizes opportunities for qubit reuse. Various heuristics for qubit reuse strategies handle the trade-off between circuit width and depth. We also explore scalability issues in large circuits, suggesting methods to mitigate compilation bottlenecks. By analyzing the structure of the circuit, we are able to identify sub-problems that can be solved separately, without a significant effect on circuit quality, while reducing runtime significantly. This method lays the groundwork for future advancements in quantum programming and compiler optimization by incorporating scalability into quantum memory management.

Figures (8)

• Figure 1: A control flow DAG corresponding to some quantum program. The nodes A and G are allocation nodes and are marked in red. The nodes B, C, D, and E are neutral and are marked in blue. The node F is a deallocation node and is marked in green. The numbers correspond to the required or released qubit count.
• Figure 2: Two different quantum circuit implementations for the control flow DAG in Figure \ref{['fig:reuse-dag']}.
• Figure 3: A control flow DAG corresponding to a quantum program similar to \ref{['fig:reuse-dag']} up to differences in nodes F and G. The node A is an allocation node. The nodes B, C, D, and E are neutral. Nodes G and F are also neutral, but each has an additional auxiliary qubit.
• Figure 4: Three different quantum circuit implementations for the control flow DAG in Figure \ref{['fig:reuse-dag-auxiliaries']}.
• Figure 5: An example of a control flow DAG corresponding to an iteration in Algorithm \ref{['alg:smart-sort']}. Allocation, neutral, and deallocation nodes are marked in red, blue, and green, respectively. The nodes forming the qubit-releasing frontier are encircled by dashed lines. Each node has its corresponding ancestry. Each node and its ancestry are marked together with the letters a, b, and c.