⚛️ quantum physics

Learning-Optimized Qubit Mapping and Reuse to Minimize Inter-Core Communication in Modular Quantum Architectures

This paper introduces QARMA and its extension QARMA-R, novel deep reinforcement learning frameworks that leverage attention mechanisms, graph neural networks, and dynamic qubit reuse to significantly minimize costly inter-core communications in modular quantum architectures, thereby enabling the execution of larger algorithms on resource-constrained systems.

Original authors: Sokea Sang, Leanghok Hour, Youngsun Han

Published 2026-04-21

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sokea Sang, Leanghok Hour, Youngsun Han

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

Imagine you are trying to organize a massive, high-stakes cooking competition, but instead of one giant kitchen, you have 10 small, separate kitchens (these are the "modular quantum cores").

You have a complex recipe (the "quantum circuit") that requires 50 different ingredients (the "qubits") to be chopped, mixed, and heated in a very specific order.

The Problem: The "Inter-Core" Traffic Jam

In a perfect world, all 50 ingredients would sit on one giant counter, and the chefs could grab whatever they needed instantly. But in our modular setup, the ingredients are scattered across 10 different kitchens.

The Issue: If a chef in Kitchen A needs an ingredient that is currently in Kitchen B, they have to send a runner to fetch it.
The Cost: This runner trip is slow, expensive, and risky. The ingredient might get spoiled (quantum decoherence) or the runner might get lost (errors).
The Old Way: Traditional methods (like IBM's Qiskit) try to be smart about this, but they often treat the kitchens like a single room with a few walls. They don't fully realize that sending a runner between buildings is a disaster waiting to happen. They also don't realize that once an ingredient is used, it can be washed and reused immediately, saving space.

The Solution: QARMA and QARMA-R

The authors of this paper created a new "Head Chef" AI called QARMA (and its super-smart cousin, QARMA-R). Think of it as a genius logistics manager that uses Deep Reinforcement Learning (basically, an AI that learns by playing millions of games of "what-if").

Here is how they solve the problem using three clever tricks:

1. The "Attention" Mechanism (The Smart Eye)

Imagine the Head Chef has a magical pair of glasses. Instead of looking at the whole recipe at once and getting overwhelmed, the glasses highlight exactly which ingredients need to be together right now.

How it works: The AI uses a "Transformer" (the same tech behind chatbots) to look at the entire recipe and say, "Hey, Ingredient 3 and Ingredient 7 need to mix in 5 seconds. Let's put them in the same kitchen so no runner is needed."
The Result: It groups ingredients that work together into the same room, minimizing the need for runners.

2. The "Dynamic Reuse" Trick (The Magic Sponge)

This is the secret sauce of QARMA-R.

The Scenario: In a normal kitchen, if you use a bowl to mix eggs, that bowl is "busy" until the recipe is done. You need a new bowl for the next step.
The Innovation: In quantum computing, once an ingredient (qubit) is measured (the "eggs are mixed"), you can instantly "reset" it (wash the bowl) and use it for a completely different part of the recipe later.
The Analogy: Instead of needing 50 bowls for 50 steps, QARMA-R realizes you only need 10 bowls. It washes and reuses them as soon as they are free.
The Benefit: Because you need fewer physical bowls (qubits), you can fit the whole recipe into fewer kitchens. This means zero runners are needed because everything fits in one building!

3. The "Pointer" System (The GPS)

The AI doesn't just guess where to put things. It uses a "pointer" system that acts like a GPS for the ingredients. It calculates the exact probability of putting Ingredient X in Kitchen Y to ensure the total number of runner trips is as close to zero as possible.

The Results: A Miracle in the Kitchen

The paper tested this new AI against the old methods (Qiskit and QUBO) using real-world recipes. The results were staggering:

Compared to Qiskit: The old method sent runners back and forth constantly. QARMA-R reduced these trips by 86% on average. In many cases, it eliminated them 100% (zero trips!).
Compared to QUBO: The old mathematical approach was so slow it took hours to plan a simple meal. QARMA did it in seconds and cut the runner trips by 97-100%.
The "Fidelity" Factor: The paper also proved that by avoiding the "runner trips" (which are noisy and error-prone), the final dish (the calculation result) is much tastier (more accurate). Even though reusing the bowls adds a tiny bit of extra washing time, it's worth it to avoid the disaster of a spoiled ingredient.

The Big Picture

This paper is a breakthrough because it tells us how to build a super-computer out of many small, imperfect computers.

Instead of trying to build one giant, fragile quantum brain (which is incredibly hard to manufacture), we can build many small, sturdy ones and connect them. The challenge was making them talk to each other without losing their minds. QARMA is the traffic controller that keeps the conversation smooth, ensuring that the quantum computers of the future can solve problems we can't even imagine today.

In short: It's like turning a chaotic, noisy city with 100 traffic jams into a perfectly synchronized subway system where trains (qubits) never have to leave their tracks (cores) unless absolutely necessary.

1. Problem Statement

As quantum computing scales toward thousands or millions of qubits, Modular Quantum Architectures (connecting multiple smaller Quantum Processing Units or QPUs) have emerged as a viable solution to overcome physical and manufacturing constraints. However, this architecture introduces a critical bottleneck: inter-core communication.

The Challenge: Transferring quantum states between different chips (cores) is significantly more costly in terms of execution time, error rates, and decoherence compared to operations within a single core.
The Optimization Task: Efficiently mapping logical qubits to physical cores is an NP-hard problem. The goal is to minimize the number of inter-core state transfers (quantum state transfers) while respecting core capacity constraints and circuit dependencies.
The Gap: Existing approaches (heuristic, QUBO-based, or standard compiler tools like Qiskit) often fail to fully exploit the global structure of quantum circuits or adapt to specific modular topologies. Furthermore, they largely ignore the potential of dynamic qubit reuse (using mid-circuit measurement and reset to reuse physical qubits for different logical qubits), which could drastically reduce resource requirements and communication overhead.

2. Methodology: QARMA and QARMA-R

The authors propose QARMA (Qubit mapping using Attention-based deep Reinforcement learning for Modular quantum Architectures) and its extension QARMA-R (which includes dynamic qubit reuse).

A. Core Architecture

The system formulates qubit allocation as a sequential decision-making process using Deep Reinforcement Learning (DRL).

Input Representation: The quantum circuit is decomposed into time slices. The state is represented as a graph where nodes are qubits and edges represent gate interactions.
Model Architecture:
- Encoder: Combines Graph Neural Networks (GNNs) to capture local qubit interaction patterns and Transformer-based self-attention mechanisms to model long-range temporal dependencies across time slices.
- Decoder: Uses an attention-based pointer mechanism to output the probability distribution of assigning the current logical qubit to a specific physical core.
- Dynamic Embedding: Incorporates real-time constraints such as remaining core capacity and communication costs from the previous allocation.
Training: The model is trained using the REINFORCE algorithm with a rollout baseline to minimize the total inter-core communication cost (reward function).

B. Qubit Reuse Mechanism (QARMA-R)

A key innovation is the integration of mid-circuit measurement and reset.

Dependency Analysis: The system analyzes the "lifetime" of each logical qubit. Once a qubit's operations are complete and its state is measured, the physical qubit holding it is reset and can be reused for a subsequent logical qubit.
Cost Function: A weighted cost function balances three factors when selecting reuse pairs:
1. Increase in circuit depth ( $w_0$ ).
2. Earliness of the qubit's completion ( $w_1$ ).
3. Duration of the gap between operations ( $w_2$ ).
Impact: This allows wider logical circuits to be executed on fewer physical cores, often eliminating the need for inter-core transfers entirely.

C. Hierarchical Compilation Strategy

The authors position QARMA as Stage 1 of a hierarchical pipeline:

Global Mapping (QARMA): Allocates logical qubits to physical cores to minimize global inter-core transfers.
Local Mapping: A standard topology-aware algorithm (e.g., SABRE) handles intra-core routing and SWAP insertion.
This decoupling allows QARMA to focus exclusively on the high-cost inter-core problem.

3. Key Contributions

Novel DRL Framework: Introduction of a transformer-GNN hybrid architecture that learns global allocation policies, capturing both local circuit structure and long-term temporal dependencies.
Dynamic Qubit Reuse: The first integration of dynamic mid-circuit measurement and reset into a DRL-based modular qubit mapper, enabling significant resource compression.
Attention-Based Pointer Mechanism: A direct probability output for core assignment that efficiently handles the combinatorial action space.
Comprehensive Evaluation: Extensive benchmarking against state-of-the-art methods (QUBO, Qiskit-O3) across diverse circuit sizes and modular topologies.

4. Experimental Results

The methods were evaluated on standard benchmarks (QASMBench) and randomly generated circuits across modular architectures (2x5 grid of chips with varying capacities).

Comparison with QUBO-based Mapping:
- QARMA-R achieved a 98–100% reduction in inter-core connections compared to QUBO methods.
- For many standard benchmarks, QARMA-R reduced inter-core communications to zero, whereas QUBO required hundreds or thousands of transfers.
Comparison with Qiskit (Optimization Level 3):
- QARMA-R reduced inter-core communications by an average of 86% (up to 100% reduction) compared to highly optimized Qiskit.
- Even QARMA (without reuse) showed a 15–40% improvement over Qiskit for larger, more complex circuits, demonstrating the superiority of the learned global policy over local heuristics.
Fidelity Analysis:
- Using a hardware-calibrated fidelity model (based on IBM's ibm_brisbane parameters), the authors demonstrated that the fidelity cost of inter-core transfers is catastrophic compared to the minor overhead of measurement/reset gates.
- QARMA-R maintained near-perfect execution fidelity even under high non-local latency factors (up to 100x), while Qiskit and non-reuse methods suffered fidelity collapses (orders of magnitude lower).
Computational Efficiency:
- While QARMA is slower than Qiskit (seconds/minutes vs. milliseconds for compilation), it is vastly faster than QUBO solvers (which can take hours). The trade-off is justified by the massive reduction in execution errors on noisy hardware.

5. Significance

This work represents a significant advancement in the compilation of quantum circuits for scalable, modular quantum systems.

Paradigm Shift: It shifts the optimization focus from merely minimizing SWAP gates (intra-core) to minimizing inter-core state transfers, which are the primary source of error in modular architectures.
Resource Efficiency: By leveraging dynamic qubit reuse, the approach enables the execution of algorithms requiring more logical qubits than the total physical qubits available in a single module, effectively "compressing" circuits.
Practical Impact: The results suggest that for near-term NISQ-era modular systems, aggressive qubit reuse is not just a resource-saving technique but a critical strategy for maintaining high-fidelity execution. The proposed DRL approach provides a scalable, hardware-agnostic solution to a problem that is currently a major bottleneck in quantum system scaling.